                                   [Line]
                       This page is not finished yet

   About the SmartEiffel Debugger

   The SmartEiffel debugger is an embedded debugger. It means that to use
   it,  you must compile your application with the special command option
   -sedb.  The  generated  executable is then equipped with the debugger,
   you just have to start it as you would without it.

   The debugger offers many powerful commands, that let you look into the
   guts of your program:
     * commands that control [1]the execution,
     * commands that set or reset [2]breakpoints,
     * commands that allow to [3]display data,
     * and some [4]other commands.

   Execution commands

   Those  commands  are  meant  to make your program advance; either walk
   step  by  step,  or by greater strides, or run until its end. Whatever
   command  you  choose,  the  program  will  run  at  most  to  the next
   breakpoint ([5]see below) or till you press ^C. The available commands
   are:

     s Make a single step; if it involves entering into another routine
       (it's a feature call), then so be it.
     n Make a single step, without entering into any other routine (it
       means that a feature call is seen as a single step).
     f Stride to the end of the current routine.
     c Run till the next breakpoint, or till the end.

   Breakpoints

   Note   that   the   breakpoints   in   the   code   (marked   by   the
   pseudo-instruction   sedb_breakpoint)   are   heeded;   they  work  as
   manually-added   breakpoints.   Here   are   the  commands  to  manage
   manually-added breakpoints:

    b    Add a breakpoint. There are many possibilities, among which you can
         choose a subset to define. All the criteria you choose must be met for
         the breakpoint to be activated.

         The possible criteria are described below.
    B    Display all the manually-added breakpoints.
 - <num> Removes the breakpoint designed by its number (you can see
         that number by the 'B' command).

   When setting a breakpoint, the possible criteria are:
     * Name  indication:  The  name  information  of  the debugging stack
       contains  information about the name of the routine called as well
       as  the  base  class  where  this  routine  is  defined.  The name
       indication  of  the breakpoint can be any substring to be searched
       within the name information of the stack. For example, if the name
       indication  is "item", the execution would stop in feature item of
       STRING  but  also  in  feature  item  of ARRAY, in feature item of
       DICTIONARY,   etc.  If  the  name  indication  is  "item  STRING",
       execution would stop only in routine item defined in class STRING.
       Also  note  that  the  name  indication  can be any substring. For
       example, if the name indication is "is_", the execution would stop
       in  is_empty, is_integer, is_real, etc. As another example, if the
       name  indication  is "STRI", the execution would stop at any place
       in  classes  STRING,  ARRAY[STRING],  DICTIONARY[STRING,FOO], etc.
       Finally,  also  note  that the "invariant" string is used when the
       execution  is in the class invariant of some class, hence allowing
       you to spot all class invariant execution.
     * File  indication:  If  you  want  to  stop each time the execution
       reaches  the  string.e  file  class,  it can be achieved easily by
       setting  the  file indication to "string.e". Because the file name
       indication  is  applied  on  the  whole path of the file, the file
       indication  allows you to filter more than a simple file name. For
       example,  if  the  file  indication is "lib/kernel", the execution
       would  stop  each  time  execution reaches some code in the kernel
       cluster of the SmartEiffel library.
     * Line  range:  The  line range information allows you to select the
       line  range  to  be  considered.  For  example,  to stop each time
       execution  reaches  line 12 or 13 in some file, just enter [12,13]
       as a line range.
     * Stack  limit:  The  stack  limit condition allows you to watch the
       stack  size  during  execution.  (This  is  useful  to  debug  bad
       recursive  calls.) For example, a stack limit of 10 would stop the
       execution  as  soon  as  the stack size reaches this 10 limit. The
       automatic  incrementation  option  causes  the  stack-limit  to be
       incremented  each  time  the  corresponding  breakpoint matches. A
       breakpoint  composed  only  of a single stack limit condition is a
       perfect watch dog of stack memory consumption.

   Here is how sedb_breakpoint works:

   The  feature  sedb_breakpoint  defined in class GENERAL can be used to
   set  a  breakpoint  directly  in your Eiffel source file. Keep in mind
   that  you must recompile your system each time some Eiffel source file
   is  modified.  Thus  each  time you add a sedb_breakpoint call to some
   Eiffel  source file you must recompile your code first. Also note that
   a sedb_breakpoint is always enabled even when the corresponding source
   file is not traced (see ACE file mode).

   Data display

   The following commands allow you to look at the data of your program:

 e <exp> Evaluates and displays the result of an expression. Note that
         currently only object attributes can be displayed (general Eiffel
         expression are not supported).

         What you can do is:
           * display either Current or any local variable or parameter of the
             current routine;
           * display any attribute of the above objects, using the standard
             Eiffel dotted expression (e.g. e my_string.count);
           * display any element of a NATIVE_ARRAY, using a special notation: a
             dot followed by the offset of the object you want to display (e.g.
             e my_string.storage.4);
           * recursively string dotted expressions (like in the above example,
             or even more complex expressions).

         Note: the 'e' command is available since SmartEiffel 1.1 beta 3.
    .    Display the current frame.
    u    Up in the stack (go to the caller). Note that the 'e' expressions
         follow the "current frame" (you can display Current and so on of that
         frame).
    d    Down in the stack (go back to the callee). Note that the 'e'
         expressions follow the "current frame" (you can display Current and so
         on of that frame).
    S    Display the whole stack (compact mode or not).

   Other commands

       q   Quits the debugger (the program will be stopped). You can use 'Q' to
           bypass the confirmation.
       h   Display some help. You can follow that 'h' by a second letter to
           have help on the following topics:
             * a: all topics
             * e: "executing" topic
             * b: "breakpoints" topic
             * d: "data-display" topic
             * m: "miscellaneous" topic

           Note: you can use '?' instead of 'h'.
       H   Display some more help. Answer "yes" at each question if you want
           details.
       G   Run the Garbage Collector.
       T   Switch to the trace.se file mode.
     Enter Repeat the last command.

                                   [Line]
             Copyright © Dominique COLNET and Suzanne COLLIN -
                         [6]<SmartEiffel@loria.fr>
                Last modified: Thu May 1 17:58:51 CEST 2003

References

   1. file://localhost/users/miro/colnet/SmartEiffel/man/sedb.html#execution
   2. file://localhost/users/miro/colnet/SmartEiffel/man/sedb.html#breakpoints
   3. file://localhost/users/miro/colnet/SmartEiffel/man/sedb.html#data-display
   4. file://localhost/users/miro/colnet/SmartEiffel/man/sedb.html#other
   5. file://localhost/users/miro/colnet/SmartEiffel/man/sedb.html#breakpoints
   6. mailto:SmartEiffel@loria.fr
