Sedb - Revision history

Dkearns: s/LibertyEiffel/Liberty Eiffel/

2016-06-26T19:48:15Z

s/LibertyEiffel/Liberty Eiffel/

← Older revision		Revision as of 21:48, 26 June 2016
Line 1:		Line 1:
	[[Category: Tool]]		[[Category: Tool]]
−	The ~~LibertyEiffel~~ debugger is an ''Embedded debugger''. This means that in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.	+	The Liberty Eiffel debugger is an ''Embedded debugger''. This means that in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.

	Note: <TT>sedb</TT> is only available with [[compile_to_c]] (or [[compile]]).		Note: <TT>sedb</TT> is only available with [[compile_to_c]] (or [[compile]]).

Ramack: removed /* sedbov: GUI Front end for sedb */

2016-03-19T22:15:44Z

removed sedbov: GUI Front end for sedb

← Older revision		Revision as of 00:15, 20 March 2016
Line 154:		Line 154:
	\| Re-executes the last command.		\| Re-executes the last command.
	\|}		\|}
−
−	== sedbov: GUI Front end for sedb ==
−
−	There is a [https://opensvn.csie.org/traccgi/sedbov/wiki/WikiStart GUI front end] for sedb. It uses the TCL/TK language.

Ramack: /* Various commands */

2016-02-16T20:40:23Z

Various commands

← Older revision		Revision as of 22:40, 16 February 2016
Line 146:		Line 146:
	\|-		\|-
	\|valign="top"\| <TT>G</TT>		\|valign="top"\| <TT>G</TT>
−	\| Runs the [[~~GarbageCollector~~\|garbage collector]], if it is present.	+	\| Runs the [[Garbage_collector\|garbage collector]], if it is present.
	\|-		\|-
	\|valign="top"\| <TT>T</TT>		\|valign="top"\| <TT>T</TT>

Hzwakenberg at 18:31, 10 September 2014

2014-09-10T18:31:40Z

← Older revision		Revision as of 20:31, 10 September 2014
Line 1:		Line 1:
		+	[[Category: Tool]]
	The LibertyEiffel debugger is an ''Embedded debugger''. This means that in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.		The LibertyEiffel debugger is an ''Embedded debugger''. This means that in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.

Hzwakenberg at 10:21, 7 September 2014

2014-09-07T10:21:24Z

← Older revision		Revision as of 12:21, 7 September 2014
Line 1:		Line 1:
−	The LibertyEiffel debugger is an ''Embedded debugger''. This means that, in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.	+	The LibertyEiffel debugger is an ''Embedded debugger''. This means that in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.

	Note: <TT>sedb</TT> is only available with [[compile_to_c]] (or [[compile]]).		Note: <TT>sedb</TT> is only available with [[compile_to_c]] (or [[compile]]).

Hzwakenberg at 18:58, 5 September 2014

2014-09-05T18:58:43Z

← Older revision		Revision as of 20:58, 5 September 2014
Line 1:		Line 1:
−	[[Category:Smarteiffel]]
−
−
	The LibertyEiffel debugger is an ''Embedded debugger''. This means that, in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.		The LibertyEiffel debugger is an ''Embedded debugger''. This means that, in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.

Hzwakenberg at 18:58, 5 September 2014

2014-09-05T18:58:09Z

← Older revision		Revision as of 20:58, 5 September 2014
Line 2:		Line 2:


−	The ~~SmartEiffel~~ debugger is an ''Embedded debugger''. This means that, in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.	+	The LibertyEiffel debugger is an ''Embedded debugger''. This means that, in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.

	Note: <TT>sedb</TT> is only available with [[compile_to_c]] (or [[compile]]).		Note: <TT>sedb</TT> is only available with [[compile_to_c]] (or [[compile]]).

Ramack at 21:12, 4 March 2013

2013-03-04T21:12:09Z

← Older revision		Revision as of 23:12, 4 March 2013
Line 1:		Line 1:
−	[[Category:~~Book~~]]	+	[[Category:Smarteiffel]]

Ramack: 32 revisions: initial import from SamrtEiffel Wiki - The Grand SmartEiffel Book

2013-03-03T21:46:30Z

32 revisions: initial import from SamrtEiffel Wiki - The Grand SmartEiffel Book

← Older revision	Revision as of 23:46, 3 March 2013
(No difference)

Cadrian: sedbov URL

2007-05-28T08:09:46Z

sedbov URL

New page

[[Category:Book]]

The SmartEiffel debugger is an ''Embedded debugger''. This means that, in order to use it, you need to compile your application with a special flag <TT>-sedb</TT>. The executable will then have the debugger inside, you can launch your application the usual way.

Note: <TT>sedb</TT> is only available with [[compile_to_c]] (or [[compile]]).

The debugger offers powerful commands which allows you to examine the bowels of your program:
* commands to control execution,
* commands to set or unset breakpoints,
* commands to print your data,
* other various commands.

== Execution control ==

These commands allow your program to execute. You can either run step by step or make bigger strides, or even force execution until the end.

Whatever your choice is, the program will run until the next breakpoint (see below), or until the next <TT>^C</TT>.

The available commands are (in increasing order of step size):

{|
|-
|valign="top"| <TT>s</TT> 
| Move only one ''step'' forward. This means entering a routine if the step is a [[Glossary#Feature|feature]] call.
|-
|valign="top"| <TT>n</TT> 
| Move only one step forward (next), but without entering a routine (this means that a [[Glossary#Feature|feature]] call is considered as one step).
|-
|valign="top"| <TT>f</TT> 
| Move to the next routine return (finish).
|-
|valign="top"| <TT>c</TT> 
| Move as far as possible (continue), perhaps even to the end of the program.
|-
|valign="top"| <TT>C</TT> 
| Continue until the end of the program, ignoring all breakpoints (whether static or dynamic).
|}

== Breakpoints ==

There are two kinds of breakpoints:
* those explicitly placed in the code, with the instruction <TT>sedb_breakpoint</TT>,
* those dynamically placed in the debugger. To modify dynamic breakpoints, you can use the following commands:

{|
|-
|valign="top"| <TT>b</TT> 
| Add a dynamic breakpoint. There are many possible criteria, described below. All chosen criteria must be valid to activate the breakpoint.
|-
|valign="top"| <TT>B</TT> 
| Print all dynamic breakpoints.
|-
|valign="top"| <TT>-<num></TT> 
| Remove a dynamic breakpoint designated by its number. The numbers are printed by the <TT>B</TT> command.
|}

=== The <TT>sedb_breakpoint</TT> instruction===

The <TT>sedb_breakpoint</TT> instruction is defined in [[library_class:ANY|<TT>ANY</TT>]]. It places a static breakpoint directly in the Eiffel source. This command does nothing if the program is not compiled with the <TT>-sedb</TT> flag.

These breakpoints cannot be removed by the <TT>-<num></TT> command. The only way to ignore them is to use the <TT>C</TT> command (continue until the end of the program).

=== Specifications of a dynamic breakpoint ===

To set up a dynamic breakpoint, you can specify one or more criteria.
* '''Name''': the name of the method and the class name in which the method is defined, separated by a space, for example <TT>"item STRING"</TT>. You can specify a substring of this name. Thus, if you specify <TT>item</TT>, the program will stop at the beginning of the <TT>item</TT> method of [[library_class:STRING|<TT>STRING</TT>]], but also at the beginning of the one in [[library_class:ARRAY|<TT>ARRAY</TT>]], etc. Similarly, if you specify <TT>STRING</TT>, the program will stop when encountering any method of [[library_class:STRING|<TT>STRING</TT>]], but also of [[library_class:HASHED_DICTIONARY|<TT>HASHED_DICTIONARY</TT>]]<TT>[</TT>[[library_class:STRING|<TT>STRING</TT>]]<TT>, </TT>[[library_class:INTEGER|<TT>INTEGER</TT>]]<TT>]</TT>. You can even be original: I will let you guess the behaviour of the <TT>is_</TT> specification :-)
* '''File''': for example, <TT>string.e</TT>. As the file name is applied to the complete path, you can specify <TT>lib/kernel</TT> which will stop at all the methods in the classes of that cluster.
* '''Line numbers''': you can specify a range of lines, for example <TT>[12,13]</TT>.
* '''Execution stack''': this condition lets you track the size of the execution stack (useful for debugging a recursive function, for example). For instance, you can specify a stack size limit of <TT>10</TT>, which will stop the execution when the stack size reaches 10. An optional automatic increment permits the limit to be incremented each time the breakpoint is reached. If you don't use this option, this breakpoint can be a good way to track the stack's memory consumption.

Of course, all these specifications are cumulative: they must all be true at the same time to activate the breakpoint.

== Data printing ==

The following commands allow to print the data of your program:

{|
|-
|valign="top"| <TT>e <exp></TT> 
| Evaluates and prints the result of an expression. '''Note that''' the general Eiffel expressions are not supported.
|-
|
| Only the following can be printed:
* ''Current''
* local variables
* a parameter of the current routine
* the content of an instance of a [[library_class:NATIVE_ARRAY|<TT>NATIVE_ARRAY</TT>]]; suffixing the attribute name with a dot and an index beginning at zero prints the contents of the specified array element. For example <TT>storage.2</TT> prints the ''third'' element of <TT>storage</TT>.
* the attributes of these objects, by using the classical notation with dots (for example <TT>my_string.count</TT> or <TT>my_string.storage.4</TT>), recursively
* the result of [[Syntax_diagrams#RoutineBody|<TT>once</TT> functions]], provided that they have already been evaluated (i.e. the debugger does not execute the function call; it only checks the result)
|-
|valign="top"| <TT>p</TT>

<TT>p <exp></TT> 
| Re-evaluates the last expression by suffixing a dot and the expression <TT><exp></TT> (if present). This is very useful for chain printing. Instead of a single dot you can also use the notation <TT>..</TT> which goes one level up, <TT>....</TT> which goes two levels up, etc.
|-
|
| Example of the use of <TT>e</TT> and <TT>p</TT> :
sedb> e Current
STD_OUTPUT#0x807ab00
[ filter = Void
buffer_position = 0
buffer = NATIVE_ARRAY[CHARACTER]#0x806c030
capacity = 4096
]
sedb> e buffer
NATIVE_ARRAY[CHARACTER]#0x806c030
sedb> p.0
(sedb) e buffer.0
'H'
sedb> p..1
(sedb) e buffer.1
'e'
sedb> p....buffer_position
(sedb) e buffer_position
0
sedb>
|-
|valign="top"| <TT>.</TT> 
| Print the current frame; that is the content of the local variables of the current routine.
|-
|valign="top"| <TT>u</TT> 
| Goes up in the stack (i.e. goes to the caller). This means that the calling routine becomes the ''current routine''. Note that the <TT>e</TT>, <TT>p</TT> and <TT>.</TT> commands follow the current routine.
|-
|valign="top"| <TT>d</TT> 
| Goes down in the stack (opposite of <TT>u</TT>).
|-
|valign="top"| <TT>S</TT> 
| Prints the execution stack. There are two printing modes:
* compact mode which only prints the name of the file and executed routine; an asterisk indicates the current routine
* complete mode which prints the entire stack, with all frames (as the printed stack when a program crashes outside sedb).
|}

== Various commands ==

{|
|-
|valign="top"| <TT>q</TT> 
| Quits the debugger; the program will be stopped. You can also use <TT>Q</TT> which doesn't ask for confirmation.
|-
|valign="top"| <TT>h</TT>

<TT>?</TT> 
| Prints help.
|-
|valign="top"| <TT>H</TT> 
| Prints detailed help.
|-
|valign="top"| <TT>G</TT> 
| Runs the [[GarbageCollector|garbage collector]], if it is present.
|-
|valign="top"| <TT>T</TT> 
| Changes the trace mode, if it is present (flag <TT>-trace</TT> when compiling). If the mode is active, the file <TT>trace.se</TT> fills up (very quickly!)
|-
|valign="top"| ''Return'' 
| Re-executes the last command.
|}

== sedbov: GUI Front end for sedb ==

There is a [https://opensvn.csie.org/traccgi/sedbov/wiki/WikiStart GUI front end] for sedb. It uses the TCL/TK language.