[Scilab-Dev] debug: remanent breakpoints

[Samuel Gougeon]

Hello the Scilab Team,

I would like to point a special behavior of the new debugger.
It looks a bit strange (and may be unhandy) to me, but after all it 
could be on purpose:

When

  * we define some breakpoints in a function,
  * then we quit the debugger,
  * then we modify the function -- adding or removing lines, etc --
  * then we exec() the function file to update it
  * then we reenter the debugger

The former breakpoints are then still defined at unchanged line numbers, 
but, obviously, the contents pointed by these references are no longer 
the same, since the function content has changed.

So, my questions are :

  * When we quit and reenter the debugger, former breakpoints are still
    defined. They are remanent from the previous debug session. Is this
    behavior on purpose? I think it could be so, but then imo it would
    be worthwhile to document it. Moreover, an debug() launching option
    or/and a debug() environment variable tuning its behavior could be
    useful.

  * When some breakpoints have been defined for a function, *and* the
    function is then updated (exec(), redefined with deff() or with
    lib(), etc), its former breakpoints are not removed. Is this
    behavior implemented on purpose?

    IMO, it could be useful as is, when the modification of the function
    did not change the number and order of its lines.
    But quite often it won't be the case: we will wish to cancel former
    breakpoints and redefine new ones for this function. Unfortunately,
    there is no way to easily remove all breakpoints of a function in a
    once: We have to remove them one by one. This is very unhandy.

Knowing what are the expected behaviors will help in reporting wishes or 
bugs.
Thanks
Samuel

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.scilab.org/pipermail/dev/attachments/20160817/d9bdb87a/attachment.htm>