mirror of
https://github.com/EiffelSoftware/eiffel-org.git
synced 2026-02-10 04:24:18 +01:00
Author:admin
Date:2008-09-17T13:53:28.000000Z git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@3 abb3cda0-5349-4a8f-a601-0c33ac3a8c38
This commit is contained in:
jfiat
@@ -0,0 +1,11 @@
|
||||
[[Property:title|Breakpoint commands]]
|
||||
[[Property:weight|2]]
|
||||
Located in the '''debug''' menu and the '''project''' toolbar, these three commands allow to change the state of set [[Breakpoints: Introduction|breakpoints]] in the system.
|
||||
|
||||
Enable breakpoints ( [[Image:16x16--breakpoints-enable-icon]] ), disable breakpoints ( [[Image:16x16--breakpoints-disable-icon]] ) and remove breakpoints ( [[Image:breakpoints-delete-icon]] ) have all global and local actions. Left-clicking on them has a global action: all set breakpoints of the system will be respectively enabled, disabled, or discarded. However, it is also possible to [[Pick-and-drop mechanism|drop]] a feature or a class onto them, in which case only set breakpoints of the feature/class will be affected.
|
||||
|
||||
Note that these commands work only on set breakpoints (that is, enabled or disabled breakpoints). Therefore, discarded breakpoints cannot be set again thanks to these commands.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
[[Property:title|Breakpoint editing]]
|
||||
[[Property:weight|1]]
|
||||
In all flat views ( [[Feature formatters: Flat view|feature flat view]] and [[Class formatters: Flat view|class flat view]] ), a margin is displayed on the left of the editor. [[Breakpoints: Introduction|Breakpoints]] are there symbolized as circles, of a different appearance depending on their state: enabled ( [[Image:bp-enabled-icon]] ), disabled ( [[Image:bp-disabled-icon]] ) or not set ( [[Image:bp-slot-icon]] ). A small question mark in the circle ( [[Image:bp-enabled-conditional-icon]] , [[Image:bp-disabled-conditional-icon]] )indicates [[Breakpoint menu|conditional breakpoints]] .
|
||||
|
||||
Right-clicking on any breakpoint pops up a context menu:
|
||||
|
||||
<center> [[Image:breakpoint-context-menu]] </center>
|
||||
|
||||
The first line provides the breakpoint slot index of the selected breakpoint(i.e: the one used in call stack or exception trace output). <br/>
|
||||
Clicking one of the three first entries of the context menu changes the state of the breakpoint that was right-clicked. The last entry ( '''Run to breakpoint''') launches the debugged application so that it will stop as soon as the selected breakpoint is encountered, as if the breakpoint had been enabled. <br/>
|
||||
|
||||
|
||||
"Edit This Breakpoint" allows the user to edit the parameters of the breakpoint (condition, hit count, when hits actions...) thanks to the breakpoint dialog. This dialog provides on hte first tab "Context": access to the associated tags, condition, and hit count control. And on the second tab, it allows to associate "When hits..." action(s) to the breakpoint.
|
||||
<center>
|
||||
{|
|
||||
|-
|
||||
|
|
||||
Context's tab
|
||||
[[Image:breakpoint-dialog-context|Context's tab]]
|
||||
|
|
||||
When hits action 's tab
|
||||
[[Image:breakpoint-dialog-when-hits-action|When hits... 's tab]]
|
||||
|}
|
||||
</center>
|
||||
|
||||
* The tags allow to identified a collection of breakpoints, either from the [[Breakpoint information command|breakpoints tool]] , or even in the parameters of "When hits .." actions. <br/>
|
||||
Note that any existing breakpoint can be referenced by an implicit tag with ''"'''bp:'''cluster.{CLASS}.feature@index"'' (cluster is not mandatory).<br/>
|
||||
|
||||
{{sample|For instance "'''bp:'''elks.{LINKED_LIST}.extend@2"}}
|
||||
|
||||
* the "Condition" allows the user to set a condition for stopping.
|
||||
* the "Hit count" allows the user to set a condition on hitcount for stopping.
|
||||
* And the "When Hits..." allows to associate specific actions to the breakpoint:
|
||||
** Print message: display the expanded message to the output (there are predefined variables, and you can also evaluate expressions).
|
||||
** Disable/Restore Assertion Checking: this might be useful to desactivate assertion checking on a specific part of the execution.
|
||||
** Record Execution: start or stop the execution recording (cf: [[Execution record and replay|Execution recording and replay]] )
|
||||
** Enable/Disable Breakpoints: either use tags or implicit tags (ex: ''"bp:elks.{LINKED_LIST}.extend@2"''), to reference a set of existing breakpoints. This can be pretty useful to enable a breakpoint only if the execution takes a specific execution path.
|
||||
** Reset Hits count
|
||||
|
||||
|
||||
|
||||
|
||||
"Edit Condition" allows the user to set a condition for stopping, it opens the same dialog as "EditThis Breakpoint", but focus on the "condition" field.
|
||||
|
||||
<center> [[Image:breakpoint-dialog-condition]] </center>
|
||||
|
||||
"Hit count" allows the user to set a condition on hitcount for stopping
|
||||
|
||||
<center> [[Image:breakpoint-dialog-hit-count]] </center>
|
||||
|
||||
"When hits ..." allows the user to do an action when we actually stopped on this breakpoint. This can be for instance `print message'.
|
||||
|
||||
<center> [[Image:breakpoint-dialog-when-hits]] </center>
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Breakpoint commands|Breakpoint commands]] <br/>
|
||||
[[Breakpoint information command|Breakpoint information command]] <br/>
|
||||
}}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
[[Property:title|Breakpoint information command]]
|
||||
[[Property:weight|3]]
|
||||
The breakpoint information command, located in the '''debug''' menu and in the '''project''' toolbar ( [[Image:tool-breakpoints-icon]] ), displays the list of all set breakpoints in the system (enabled or disabled).
|
||||
|
||||
<center>Display all breakpoints in a grid<br/>
|
||||
[[Image:breakpoints-list]] </center>
|
||||
|
||||
Note: the * shows that the breakpoint has a [[Breakpoint menu|condition]] .<br/>
|
||||
Note: you can edit the selected breakpoint by double clicking on it, or pressing [enter] which show the menu.<br/>
|
||||
Note: you can disable/enable the selected breakpoint(s) by pressing [space].<br/>
|
||||
Note: you can sort by clicking the column, especially the first column which provide tree, flat or sorted view.
|
||||
|
||||
<center>Display all breakpoints in a list<br/>
|
||||
[[Image:breakpoints-list-flat]] </center>
|
||||
|
||||
<center>Display all breakpoints in a list filtered by a tag using button [[Image:breakpoints-list-filter-button]] <br/>
|
||||
[[Image:breakpoints-list-filter]] </center>
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Breakpoint commands|Breakpoints commands]] <br/>
|
||||
[[Breakpoint information command|Breakpoint information command]] <br/>
|
||||
}}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
[[Property:title|Breakpoint menu]]
|
||||
[[Property:weight|4]]
|
||||
A condition breakpoint is a breakpoint in which debugger will stop if a certain condition is met. To set a conditional breakpoint use the [[Breakpoint editing|breakpoint menu]] and choose `Set conditional breakpoint':
|
||||
|
||||
[[Image:breakpoint-context-menu]]
|
||||
|
||||
Once done a dialog pops up where you can enter a condition:
|
||||
|
||||
[[Image:breakpoint-dialog-condition]]
|
||||
|
||||
The condition is a Boolean expression that follows the same rule as the expression you can enter in the [[Expression evaluation|expression evaluation tool]] . <br/>
|
||||
|
||||
|
||||
{{warning|'''Caution''': if you enter an expression that is not supported or which raises an error during evaluation, by default the condition is considered as True (then the debugger will stop) }}
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Breakpoint editing|Breakpoint menu]] <br/>
|
||||
[[Breakpoint commands|Breakpoints commands]] <br/>
|
||||
[[Breakpoint information command|Breakpoint information command]] <br/>
|
||||
[[Expression evaluation|Expression evaluation tool]] <br/>
|
||||
}}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
[[Property:title|Breakpoints]]
|
||||
[[Property:weight|-14]]
|
||||
* [[Breakpoints: Introduction|Introduction]]
|
||||
* [[Breakpoint editing|Breakpoint menu]]
|
||||
* [[Image:16x16--breakpoints-enable-icon]] [[Image:16x16--breakpoints-disable-icon]] [[Image:breakpoints-delete-icon]] [[Breakpoint commands|Breakpoint commands]]
|
||||
* [[Image:tool-breakpoints-icon]] [[Breakpoint information command|Breakpoint information command]]
|
||||
* [[Breakpoint menu|Conditional breakpoints]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
[[Property:title|Call stack tool: Interface]]
|
||||
[[Property:weight|1]]
|
||||
[[Image:call-stack-tool]]
|
||||
|
||||
The call stack tool gives information about the current call stack of a debugged application.
|
||||
|
||||
It is mainly composed of a list representing the call stack elements, where the entry feature of the program is at the bottom and the top of the call stack is at the top. <br/>
|
||||
- The current call stack element, to which the [[Information relative to a stack element|other debug tools]] refer, is represented by a green arrow [[Image:callstack-active-arrow-icon]] . <br/>
|
||||
- Clicking on a call stack element represented by an empty arrow [[Image:callstack-empty-arrow-icon]] , or picking it and dropping it onto either the call stack list or the locals view defines it as being the current call stack element. <br/>
|
||||
- The call stack elements with no pixmap are called external call stack elements, they represent a call stack out of Eiffel, for instance a true dotnet call stack. <br/>
|
||||
- For each feature in the call stack, its name, its dynamic class and its static class are displayed. An asterisk next to the name of a feature means the feature is melted, as opposed to frozen. The dynamic class is the type of the object upon which the feature is called, whereas the static class is the class in which the feature was written.
|
||||
|
||||
On top of this list, a line gives the state of the debugged application, and another one describes the exception that caused the application to stop, if any. For more information concerning exceptions, see the [[Supported exceptions|supported exceptions]] .
|
||||
The button [[Image:debug-exception-dialog-icon]] is used to open the Exception dialog which show the exception details. For instance a call on Void target in a dotnet system would popup :
|
||||
|
||||
<center> [[Image:exception-dialog]] </center>
|
||||
|
||||
When more than one thread is available to the debugger, you can switch from one to the other, for that you have to click on the thread's id "0x000..." and select from the popup list of available threads. Or (recommended) you can use the [[Threads tool|threads tool]] (clicking on '''Show threads panel''' will show the threads tool).
|
||||
<center> [[Image:call-stack-tool-with-threads]] </center>
|
||||
|
||||
|
||||
In the toolbar, the button [[Image:general-save-icon]] gives the possibility to [[Save call stack|save the call stack]] to a text file, and the button [[Image:general-copy-icon]] copy to the clipboard. The [[Image:debugger-callstack-depth-icon]] button makes it possible to choose which call stack depth should be displayed in the list (the default is to display the 100 top stack elements, but it is configurable with the same button).
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
[[Property:title|Call stack tool]]
|
||||
[[Property:weight|-13]]
|
||||
* [[Callstack tool: Introduction|Introduction]]
|
||||
* [[Call stack tool: Interface|Call stack tool]]
|
||||
* [[Information relative to a stack element|Information about the current stack level]]
|
||||
* [[Supported exceptions|Supported exceptions]]
|
||||
* [[Save call stack|Save call stack command]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
[[Property:title|Information relative to a stack element]]
|
||||
[[Property:weight|2]]
|
||||
In addition to the [[Call stack tool: Interface|call stack tool]] that provides information concerning the call stack in its globality, some other debug tools give information concerning the [[Call stack tool: Interface|current call stack element]] .
|
||||
|
||||
In debug mode, the context tool is automatically switched to the feature tab in flat view, and displays the feature which corresponds to the current call stack element. In the left margin, a yellow arrow ( [[Image:bp-current-line-icon]] ) marks the execution line where the program is currently stopped, whereas a green arrow ( [[Image:bp-slot-other-frame-icon]] ) indicates the execution line that was attained in the feature in the current call stack element. Therefore, if a feature is recursive, and appears several times in the call stack, changing the current call stack element may cause green arrows to be displayed at different places in the same feature (if the different calls did not reach the same execution point). On the other hand, the yellow arrow can only appear at one place as long as the application is not started again.
|
||||
|
||||
The left part of the [[Objects tool: Introduction|object tool]] gives valuable information concerning parameters that were passed to the feature corresponding to the current call stack, the current value of the local variables, and, if it is a function, the current value of its result.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
[[Property:title|Save call stack]]
|
||||
[[Property:weight|4]]
|
||||
It is possible to copy the current call stack to the clipboard ( [[Image:general-copy-icon]] ) or to a text file ( [[Image:general-save-icon]] ). This may be useful to indicate to other people of a team where an error occurred. After the button is clicked, a dialog is popped up that prompts for a place where to save the [[Call stack tool: Interface|call stack]] (if the selected file already exists, it is overwritten).
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
[[Property:title|Supported exceptions]]
|
||||
[[Property:weight|3]]
|
||||
Here is a list of exceptions that may appear in the [[Call stack tool: Interface|call stack tool]] . When they are raised, a tag may be there to give more information, if necessary. All these exceptions are declared in <eiffel>EXCEPT_CONST</eiffel>.
|
||||
|
||||
'''Feature call on Void target''': An attempt was made to calla feature on an object that is Void. The tag indicates the name of the feature of the feature that could not be called. For instance if the code line is <eiffel>a.b.c</eiffel> and the tag is "c" then <eiffel>a.b</eiffel> was Void.
|
||||
|
||||
'''No more memory''': A memory allocation failed.
|
||||
|
||||
'''Precondition violated''': One of the conditions necessary prior to entering a feature is not verified. This may indicate either that the precondition is too strong, or that the call is invalid. The tag should give the name of the violated precondition, if any.
|
||||
|
||||
'''Postcondition violated''': One of the conditions checked when a feature exits is not verified. This may indicate either that the postcondition is too strong, or that the feature did not behave correctly. The tag should give the name of the violated postcondition, if any.
|
||||
|
||||
'''Class invariant violated''': One of the conditions that checks the validity of objects is not verified. This may indicate that an object was left in an invalid state after a method call. The tag should give the name of the violated invariant, if any.
|
||||
|
||||
'''Assertion violated''': An assertion was not verified. The tag should give the name of the violated assertion, if any.
|
||||
|
||||
'''Non-decreasing loop variant''': A loop variant does not vary. This may lead to stack overflows or erroneous results.
|
||||
|
||||
'''Loop invariant violated''': A condition that should be checked when executing a loop is not verified. The tag should give the name of the violated invariant.
|
||||
|
||||
'''Floating point exception''' (signal SIGFPE): An error occurred while processing floating point numbers. This may be for example a FPU overflow, a division by zero, or an invalid operation.
|
||||
|
||||
'''Unmatched inspect value''': An inspect clause couldn't find the value it was passed among the `when' clauses. If any value maybe passed to the `when' clause, adding an `else' clause will solve this problem.
|
||||
|
||||
'''I/O error''': An error occurred while accessing a stream. Examples of this are a missing file, or insufficient rights.
|
||||
|
||||
'''Retrieval error''': A file could not be retrieved. This maybe caused by an invalid header, or more generally by a corrupted data file.
|
||||
|
||||
'''Developer exception''': Developer exceptions can be raised by calling {<eiffel>EXCEPTIONS</eiffel>}.<eiffel>raise</eiffel>. They can indicate any kind of internal error.
|
||||
|
||||
'''Operating system signal''': The program received a signal from the operating system.
|
||||
|
||||
'''Exception in rescue clause''': An exception occurred within a rescue clause.
|
||||
|
||||
'''Void assigned to expanded''': An attempt was made to assign a Void value to an expanded object.
|
||||
|
||||
'''Run-time I/O error''': Exception raised by the run-time when encountering a I/O error internally.
|
||||
|
||||
'''External event''': On Unix, this happens when an operating system error occurs and does not set the `errno' variable.
|
||||
|
||||
'''Operating system error''': On Unix, this happens when an operating system error occurs and sets the `errno' variable.
|
||||
|
||||
'''COM error''': Raised when EiffelCOM encounters an error.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
[[Property:title|Debuggee's Object Storage]]
|
||||
[[Property:weight|-9]]
|
||||
This command can be accessed through the context menu, and from the objects tool, and watches tools thanks to the tool bar's button [ [[Image:execution-object-storage-icon]] ].
|
||||
|
||||
By Pick-and-Dropping a debuggee object onto the button [ [[Image:execution-object-storage-icon]] ], you raise the "save" dialog. Then you need to choose the target filename where we'll store the debuggee object.
|
||||
|
||||
<center> [[Image:debuggee-object-storage-save]] </center>
|
||||
|
||||
By clicking on a watch tool's button [ [[Image:execution-object-storage-icon]] ], you raise the "load" dialog. Then you need to select the filename which contain the debuggee object's storage. If the loading is successful, the retrieved object will be added in the related watch tool. <br/>
|
||||
|
||||
|
||||
<center> [[Image:debuggee-object-storage-load]] </center>
|
||||
|
||||
{{tip|By Pick-and-Dropping an object onto the button, you can load the retrieved values into the dropped object (make sure it has same type).}}
|
||||
|
||||
{{warning|For now this command is pretty basic, and provided as it is. The underlying implementation is using <code>{FILE}.independent_store and {FILE}.retrieved</code> for save and load operation, to load the value into an existing object, it is using <code>{ANY}.standard_copy (..)</code>. For details, you can have a look at the RT_EXTENSION_GENERAL code }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
[[Property:title|Debugging limitations]]
|
||||
[[Property:weight|-2]]
|
||||
General limitations:
|
||||
* Watch expression: Agents are not supported (for instance "agent my_function" is not supported").
|
||||
* The debugger is still not very helpful when the execution is stopped inside an invariant.
|
||||
|
||||
Limitations or known bugs for the Classic debugger:
|
||||
* Evaluating <code>Precursor</code> will produce the current feature's <code>Result</code> (not the precursor)
|
||||
* If you use any of the previous non supported expressions in a breakpoint condition, since the evaluation is failing the condition will always return True. In such case the debugger will stop.
|
||||
|
||||
Limitations or known bugs for the .Net debugger:
|
||||
* It happens the debugger does not show the correct executed line, especially when dealing with disabled assertions or disabled debug clauses.
|
||||
* The same trouble occurs when stepping through an unordered inspect code.
|
||||
|
||||
Various known issues for classic system :
|
||||
* If a precondition is violated inside a rescue, the debugger reports the assertion violation will the exception's tag.
|
||||
* If you use the "Disable Assertion Handling" functionality when the execution is stopped in a rescue, the effect might be cancelled as soon as the execution exits the rescue's associated feature.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
[[Property:title|Debugging preferences]]
|
||||
[[Property:weight|-4]]
|
||||
Two main preferences are available for the debugger, in order to speed up the objects display :
|
||||
* Enable/disable the debug_output display (see [[Debug output|debug output]] )
|
||||
* Enable/disable the full generic type display (for instance see <eiffel>ARRAY [INTEGER] </eiffel>instead of only <eiffel>ARRAY</eiffel>
|
||||
* To avoid infinite evalution processing, the debugger abort evaluation after "max evaluation duration" timeout. So you can change this value to fit your needs.
|
||||
[[Image:debugging-tools-preferences]]
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
[[Property:title|Debugging tips with the objects grid view]]
|
||||
[[Property:weight|-5]]
|
||||
General behavior
|
||||
* Double clicking on the grid's header separator will resize the corresponding column. If you hold the [SHIFT] key at the same time, it will resize according to the displayed cells.
|
||||
* Right clicking on the header's cell will popup a menu that enable or disable the auto resizing on the selected column. This can be useful to resize automatically the "name" column when inspecting an object value.
|
||||
* Pressing [CONTROL] + [E] when the selected line represents a value with potential text representation (STRING, DEBUG_OUPUT ...) will open the [[Object Viewer (also known as Expanded display)|expanded view dialog]]
|
||||
|
||||
Watch tools (alias evaluation tool)
|
||||
* Dropping an object value on a [[Evaluation tool or Watch tool|watch tool ]] will open the [[New expression dialog|expression definition dialog]] with the object's address filled. This way you can evalute expression directly on this object. If you press [Ctrl] during the dropping, the dropped object will be added as expression in the watch tool as itself.
|
||||
* You can also drop the object on the notebook tab of the wanted watch tool.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
[[Property:title|Exceptions handling tool]]
|
||||
[[Property:weight|-7]]
|
||||
This tool is used to precise whether the debugger stops or continues on specific exceptions.<br/>
|
||||
To show this tool, go to menu : '''Debug > Exception handling''' .<br/>
|
||||
Note: now that exception are object in Eiffel too, the mechanism is unified for classic and dotnet system using the Eiffel exception class names.
|
||||
|
||||
==Exception handling dialog==
|
||||
|
||||
If the "filter exceptions" is enabled, for each exception you can leave the exception action as '''Disabled''' (default behavior: catch), '''Catch''' (stop on such exception), '''Ignore''' (do not stop on such exception). By double clicking on the exception name you toggle Ignore/Catch.
|
||||
|
||||
In the following picture, we stop on every exception except the "External Exception".
|
||||
|
||||
<center> [[Image:exceptions-handling-tool|Exception handling tool]] </center>
|
||||
|
||||
{{tip|Using the "Pattern" field, you can add you own filter using regular expression.}}
|
||||
|
||||
|
||||
==Cat call detection during the execution==
|
||||
|
||||
This dialog also provides a way to disable/enable the cat call warning on the console or in the debugger with the first two checkbox fields.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
[[Property:title|Execute one line at a time]]
|
||||
[[Property:weight|-9]]
|
||||
If no application was already running, this command launches an application compiled in Work Bench mode and stops at its first line.
|
||||
|
||||
If an application was stopped, it attempts to execute the instruction located on the execution line where the application is stopped. If this execution line does not contain an instruction, the execution stops at the next execution line.
|
||||
|
||||
It is accessible through the '''project''' toolbar ( [[Image:debug-step-over-icon]] ) or through the '''debug''' menu.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Eiffel Debugger Execution: Introduction|Execution commands]] <br/>
|
||||
[[Generating executables|Compiling in Workbench mode]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
[[Property:title|Execution commands]]
|
||||
[[Property:weight|-15]]
|
||||
* [[Eiffel Debugger Execution: Introduction|Introduction]]
|
||||
* [[Image:debug-run-icon]] [[Run and stop at breakpoints|Run and debug]]
|
||||
* [[Image:debug-run-icon]] [[Run with arguments|Run with arguments]]
|
||||
* [[Image:debug-run-without-breakpoint-icon]] [[Run without breakpoints|Run regardless of breakpoints]]
|
||||
* [[Image:debug-run-finalized-icon]] [[Run a finalized executable|Run a finalized executable]]
|
||||
* [[Image:debug-step-into-icon]] [[Step into a feature|Step into a feature]]
|
||||
* [[Image:debug-step-over-icon]] [[Execute one line at a time|Execute an instruction line]]
|
||||
* [[Image:debug-step-out-icon]] [[Step out of a feature|Step out of a feature]]
|
||||
* [[Image:debug-pause-icon]] [[Pause an application|Pause the execution]]
|
||||
* [[Image:debug-stop-icon]] [[Stop a debugged application|Stop the debugged application]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
[[Property:title|Pause an application]]
|
||||
[[Property:weight|-7]]
|
||||
This command stops the execution of a running debugged application.
|
||||
|
||||
This gives access to dynamic information concerning the application, such as the current [[Callstack tool: Introduction|call stack]] and the [[Objects tool: Introduction|state of objects]] in the system.
|
||||
|
||||
It is accessible through the '''project''' toolbar ( [[Image:debug-pause-icon]] ) or through the '''debug''' menu.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Eiffel Debugger Execution: Introduction|Execution commands]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
[[Property:title|Run and stop at breakpoints]]
|
||||
[[Property:weight|-15]]
|
||||
This command launches an application compiled in Work Bench mode. The application will stop as soon as a [[Breakpoints: Introduction|breakpoint]] is encountered, or when an exception occurs.
|
||||
|
||||
It is accessible through the '''project''' toolbar ( [[Image:debug-run-icon]] ) or through the '''debug''' menu.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Eiffel Debugger Execution: Introduction|Execution commands]] <br/>
|
||||
[[Generating executables|Compiling in Workbench mode]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
[[Property:title|Run with arguments]]
|
||||
[[Property:weight|-14]]
|
||||
While working on a project, you may want to launch it with one or more arguments.
|
||||
|
||||
There are two ways to specify arguments for a program from EiffelStudio:
|
||||
* From the '''Debug, Debugging Options''' menu.
|
||||
* By right-clicking any of the buttons on the debugging toolbar.
|
||||
|
||||
==Using the Argument Dialog==
|
||||
|
||||
[[Image:argument-dialog]]
|
||||
|
||||
|
||||
|
||||
The dialog allows you to manage different execution profiles to specify parameters to be passed to the system at execution time.
|
||||
|
||||
Each profile allows to set a title, the '''arguments''', the '''working directory''', and you can also set your own '''environment variables'''.
|
||||
|
||||
To use a profile, just select it by clicking the corresponding line in the grid..
|
||||
|
||||
Once the appropriate execution profile is selected then the system can be run with those parameters using the Run button (If "Keep Dialog Open" is selected the dialog remains opened).<br/>
|
||||
To run without any particular parameter select '''default''' 's profile.
|
||||
|
||||
If you click on "Run Workbench" or "Run Finalized", the system will be executed outside EiffelStudio (thus no debugging)..
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
[[Property:title|Run a finalized executable]]
|
||||
[[Property:weight|-11]]
|
||||
As opposed to other execution commands, this command launches an application compiled in finalized mode. This has the same effect as running the application in the EIFGENs/target_name/F_code directory from a console prompt.
|
||||
|
||||
No debugging is possible with this command, but it lets you test the real speed of your program without any overhead.
|
||||
|
||||
It is accessible through the '''project''' toolbar ( [[Image:debug-run-finalized-icon]] ) or through the '''project''' menu.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Eiffel Debugger Execution: Introduction|Execution commands]] <br/>
|
||||
[[Generating executables|Compiling in finalized mode]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
[[Property:title|Run without breakpoints]]
|
||||
[[Property:weight|-12]]
|
||||
This command launches an application compiled in Workbench mode. The application will not stop when a [[Breakpoints: Introduction|breakpoint]] is encountered. However, it stops when an exception occurs.
|
||||
|
||||
It is accessible through the '''project''' toolbar ( [[Image:debug-run-without-breakpoint-icon]] ) or through the '''debug''' menu.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Eiffel Debugger Execution: Introduction|Execution commands]] <br/>
|
||||
[[Generating executables|Compiling in Workbench mode]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
[[Property:title|Step into a feature]]
|
||||
[[Property:weight|-10]]
|
||||
If no application was already running, this command launches an application compiled in Work Bench mode and stops at its first line.
|
||||
|
||||
If an application was stopped, it attempts to enter the feature located on the execution line where the application is stopped. If this feature is an attribute, or another non debuggable feature, it simply executes the current execution line and stops at the next one.
|
||||
|
||||
It is accessible through the '''project''' toolbar ( [[Image:debug-step-into-icon]] ) or through the '''debug''' menu.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Eiffel Debugger Execution: Introduction|Execution commands]] <br/>
|
||||
[[Generating executables|Compiling in Workbench mode]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
[[Property:title|Step out of a feature]]
|
||||
[[Property:weight|-8]]
|
||||
If no application was already running, this command launches an application compiled in Work Bench mode and stops at its first line.
|
||||
|
||||
If an application was stopped, it attempts to exit the feature where the application is stopped.
|
||||
|
||||
It is accessible through the '''project''' toolbar ( [[Image:debug-step-out-icon]] ) or through the '''debug''' menu.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Eiffel Debugger Execution: Introduction|Execution commands]] <br/>
|
||||
[[Generating executables|Compiling in Workbench mode]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
[[Property:title|Stop a debugged application]]
|
||||
[[Property:weight|-6]]
|
||||
This command kills the debugged application, if any. This stops the debugging session.
|
||||
|
||||
It is accessible through the '''project''' toolbar ( [[Image:debug-stop-icon]] ) or through the '''debug''' menu.
|
||||
|
||||
{{seealso| '''See Also''' <br/>
|
||||
[[Eiffel Debugger Execution: Introduction|Execution commands]] }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
[[Property:title|Execution record and replay]]
|
||||
[[Property:weight|-12]]
|
||||
* [[Introduction to execution record and replay|Introduction]]
|
||||
* [[Record execution|Execution recording]]
|
||||
* [[Replay (recorded) execution|Execution replaying]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
[[Property:title|Record execution]]
|
||||
[[Property:weight|1]]
|
||||
For performance reason, the recording mechanism has a few parameters. For now there is no way to change them easily with the graphical debugger, however you can change those parameters by editing (and recompiling) <code>{RT_DBG_EXECUTION_PARAMETERS}.make</code>.
|
||||
* integer parameter: <code>{RT_DBG_EXECUTION_PARAMETERS}.'''maximum_record_count'''</code> (default: 1_000_000): <br/>
|
||||
the recording keeps only the last '''maximum_record_count''' object's records.
|
||||
* boolean parameter: <code>{RT_DBG_EXECUTION_PARAMETERS}.'''flatten_when_closing'''</code> (default: True): <br/>
|
||||
when leaving a feature, the recorder can flatten the associated record. This will save memory space, and optimize underlying mechanism. By default it is enabled (and recommanded).
|
||||
* boolean parameter: <code>{RT_DBG_EXECUTION_PARAMETERS}.'''keep_calls_records'''</code>(default: True): <br/>
|
||||
when flattening call records' values, keep the sub-call records (i.e: the execution calls history)?
|
||||
* boolean parameter: <code>{RT_DBG_EXECUTION_PARAMETERS}.'''recording_values'''</code>(default: True): <br/>
|
||||
during execution, record attribute and locals assignment?(if you just want to review the calls history, you can discard value recording to speed up the recording.)
|
||||
|
||||
{{warning|Since there is no way to restore local values when the execution left the related call stack frame, the recording discards the recorded local values.}}
|
||||
|
||||
|
||||
The recording functionality is graphically available on the Call stack tool, or though the "Execution" menu (former "Debug" menu).
|
||||
|
||||
When you start debugging, at some point you decide to start recording, click on the "record" button:
|
||||
|
||||
<center> [[Image:exec-replay-00]] </center>
|
||||
|
||||
{{note|If you want to record from the beginning, just enable the recording before starting the debug session (the recording button is a toggle button)}}
|
||||
|
||||
{{tip|You can also use the "When hits.." actions of [[Breakpoint editing|breakpoints]] to start and stop the execution recording. This can be useful to record only the part you are interested in.}}
|
||||
|
||||
<center> [[Image:exec-replay-00-1]] </center>
|
||||
|
||||
The execution is now recorded, whenever the application is stopped, you can decide to [[Replay (recorded) execution|replay]] the previously recorded execution. [[Replay (recorded) execution|Read how to replay execution]] .
|
||||
|
||||
{{warning|For now, EiffelStudio supports only "Replay back" and "Replay forth" (finner replay might be added for 6.2).}}
|
||||
|
||||
{{warning|EiffelStudio 6.1 provides this feature only on classic system, this is not yet supported on dotnet (planned for 6.2).}}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
[[Property:title|Replay (recorded) execution]]
|
||||
[[Property:weight|2]]
|
||||
The replay functionality is graphically available on the Call stack tool, or though the "Execution" menu.
|
||||
|
||||
{{note|First, you must be sure execution recording is activated ([[Record execution|read how to record execution]] ).}}
|
||||
|
||||
Now, whenever the application is stopped in the debugger, you can replay the recorded execution by clicking on the "Replay" button:
|
||||
|
||||
<center> [[Image:exec-replay-01]] </center>
|
||||
|
||||
Now we are in "execution replay" mode, as you can notice the "Replay" button is enabled, and there is a new commands bar with replay "Back", "Forth", "Previous", "Next", and "Go to". And on the right the number indicates the call stack depth, the breakable index, and the nested breakable index . <br/>
|
||||
* '''Back''': means replay back to caller, i.e: down in the call stack.
|
||||
* '''Forth''': means replay to callee, i.e: up in the call stack.
|
||||
* '''Previous''': means replay to previous instruction (previous call in the same stack; i.e: similar to step previous) if possible.
|
||||
* '''Previous''': means replay to next instruction (next call in the same stack; i.e: similar to step next) if possible.
|
||||
* '''Go to''': replay to the selected call when possible.
|
||||
In the first column, you will find a tree structure, which show on the root level, the effective call stacks, and for each root node, you can inspect the sub element to browse the calls history.<br/>
|
||||
The '''bold entries''' show the active call stacks (i,e: the current call stack when we stopped the debugger).<br/>
|
||||
The '''red arrow''' shows the replayed call stack level, and the call stack levels which can be replayed have a light blue background. <br/>
|
||||
|
||||
<center> [[Image:exec-replay-02]] </center>
|
||||
|
||||
If you expand a node, you will be able to browse the whole recorded execution history from this stack (if you expand the bottom node, the whole recorded execution history will be available).<br/>
|
||||
You can still select other call stack level as you do in normal debugging mode to inspect them, in this case the red arrow stick to the replayed call, and the green arrow show you the selected call stack level.
|
||||
|
||||
<center> [[Image:exec-replay-02-1]] </center>
|
||||
|
||||
Here we clicked on "Back" 3 times, you can now also replay "Forth" 3 times. When you execute a "Replay" operation, the debugger restores the related recorded values, and the various debugger tools are updated with tools values (including the watch tools)
|
||||
|
||||
<center> [[Image:exec-replay-03]] </center>
|
||||
|
||||
And then if you replay "previous" twice, you rewind the execution in the same call stack frame, you will notice the "blue" dot to show the replayed execution cursor.
|
||||
|
||||
|
||||
<center> [[Image:exec-replay-04]] </center>
|
||||
|
||||
{{note|When replaying, you will notice the debugging tools are synchronized and refresh. <br/>
|
||||
This means the objects tool, the watch tools, and the feature tool will display the replayed context (values, and replayed execution cursor). <br/>
|
||||
If you evaluate an expression in a watch tool, it will use the recorded values, then be careful about side effects, since you can modify those values... }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
[[Property:title|Evaluation tool or Watch tool]]
|
||||
[[Property:weight|1]]
|
||||
The expression evaluation tool's main part is the list of expressions that should be evaluated.
|
||||
|
||||
[[Image:expression-evaluation-tool]]
|
||||
|
||||
Its first column gives the expression's text, the context's column gives the context in which the [[New expression dialog|expression]] is evaluated. The value's column gives the result of the expression, and the type's column the result's type of the expression..
|
||||
|
||||
In the screenshot, you can see various expressions, the 4th one, is a dropped object, and the debugger displayed it as itself, this is shown by the context's value "As object", and also by the italic style. The user can name the dropped object by editing the "expression" cell. This is useful to remember the origin of the value.
|
||||
|
||||
The 5th expression has an error, the icon is different, and the 'value' shows there is an error, double click on it for more details
|
||||
|
||||
{{tip| '''Tip''': If the expression returns a non-Void (and non basic type) object, then the corresponding row in the list is pickable, and can be dropped for example in the Watch tool to evaluate expression on it, or even to keep the object over the steppings. }}
|
||||
|
||||
{{tip| '''Tip''': holding the mouse pointer over the expression's cell will popup a tooltip with details on the pointed expression }}
|
||||
|
||||
On top of the list, four buttons can be found.
|
||||
* the button [[Image:toolbar-dropdown-icon]] is used to create/close watch tools via a menu popup
|
||||
* [[Image:debugger-auto-values]] Enable or disable auto expressions.
|
||||
* [[Image:new-expression-icon]] pops up the [[New expression dialog|expression definition dialog]] , and can be used to define new expressions. If you have selected text in the editor, this text will be used to create the expression.
|
||||
* [[Image:general-edit-icon]] edits a currently selected expression (it is not possible to change the context of an expression, only the expression itself). <br/>
|
||||
The associated key shortcut is F2.
|
||||
* [[Image:general-toogle-icon]] disable/enable the evaluation of the selected expressions from the list. <br/>
|
||||
|
||||
* [[Image:debugger-set-sizes-icon]] set the slice limits of dropped <eiffel>SPECIAL</eiffel> or <eiffel>NATIVE_ARRAY</eiffel> objects. <br/>
|
||||
|
||||
* [[Image:debugger-show-hex-value-icon]] Toggle format display of numeric between decimal and hexadecimal format. <br/>
|
||||
|
||||
* [[Image:debugger-expand-info-icon]] This command can give an [[Object Viewer (also known as Expanded display)|expanded display]] of the string relative to an object, by dropping the object onto the button (or pressing Ctrl+E on the selected value). Use it if an object has a very long string representation or a string representation that contains carriage returns, for example. <br/>
|
||||
|
||||
* [[Image:execution-object-storage-icon]] This button is used to remotely store or load a "stored" object (check [[Debuggee's Object Storage|remote object storage]] ). <br/>
|
||||
|
||||
* [[Image:general-delete-icon]] removes the selected expressions from the list. <br/>
|
||||
The associated key shortcut is Del.
|
||||
* And the last two buttons are used to move up and down the expressions. You can also move the expressions up and down using [CONTROL] + [-] or [CONTROL] + [+].
|
||||
|
||||
{{tip| '''Tip''': Dropping an object onto this list lets you define quickly an expression whose context is the dropped object. This avoids having to type object addresses manually. <br/>
|
||||
If you press the [Control] key during the dropping, you will add the dropped object as itself. }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
[[Property:title|Expression evaluation]]
|
||||
[[Property:weight|-10]]
|
||||
* [[Expression evaluation: Introduction|Introduction]]
|
||||
* [[Evaluation tool or Watch tool|Evaluation tool (alias Watch tool)]]
|
||||
* [[New expression dialog|New expression dialog]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
[[Property:title|New expression dialog]]
|
||||
[[Property:weight|2]]
|
||||
Adding new expressions to the [[Evaluation tool or Watch tool|list of expressions]] that should be dynamically evaluated is performed via a dialog.
|
||||
|
||||
<center>
|
||||
{|
|
||||
|-
|
||||
| [[Image:new-expression-definition-dlg]] <br/>
|
||||
context: Current feature
|
||||
| [[Image:new-expression-as-object-definition-dlg]] <br/>
|
||||
context: As object
|
||||
|}
|
||||
</center>
|
||||
|
||||
The first part in the dialog makes it possible to select the context of the expression.
|
||||
* The default context is the context of the [[Information relative to a stack element|currently selected call stack element]] . This context gives access to the locals, the arguments, the result and the enclosing object features. <br/>
|
||||
|
||||
* The object context, that requires a valid object address, gives access to the features of the selected object. But if the "As object" is selected, the result of the expression, is the pointed object it self; and you can name the object (see the second screenshot).
|
||||
* The last context, the class-related context, gives access to the once and constants features of that class. It requires a valid class name.
|
||||
|
||||
|
||||
The second part prompts for the expression itself. This field supports arguments, dot calls and operators (to a certain extent), but does not support creation expressions, agents or static calls (as in "feature {<eiffel>MY_CLASS</eiffel>}.<eiffel>my_feature</eiffel>"). Genericity is partially supported. Despite these limitations, we believe the expression evaluation tool should provide you with a lot of useful functionality.
|
||||
|
||||
And the "Keep Assertion Checking" checkbox is used to enable assertion checking during expression evaluation if wanted (by default assertions won't be checked).
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
[[Property:title|EiffelStudio Debugger]]
|
||||
[[Property:link_title|Debugger]]
|
||||
[[Property:weight|-8]]
|
||||
* [[Eiffel Debugger: Introduction|Introduction]]
|
||||
* [[Execution commands|Execution commands]]
|
||||
* [[Breakpoints|Breakpoint management]]
|
||||
* [[Call stack tool|Call stack information]]
|
||||
* [[Execution record and replay|Execution replay mechanism]]
|
||||
* [[Object tool|Objects tool (stack information)]]
|
||||
* [[Object Viewer (also known as Expanded display)|Object viewer tool (also known as expanded display)]]
|
||||
* [[Expression evaluation|Dynamic evaluation of expressions]]
|
||||
* [[Debuggee's Object Storage|Debuggee object storage]]
|
||||
* [[Threads tool|Threads information]]
|
||||
* [[Exceptions handling tool|Exception caching handler tool]]
|
||||
* [[Stack overflow prevention|Stack overflow prevention]]
|
||||
* [[Debugging tips with the objects grid view|Debugging tips with the objects grid view]]
|
||||
* [[Debugging preferences|Debugging preferences]]
|
||||
* [[Debugging limitations|Debugging limitations]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
[[Property:title|Attribute symbols]]
|
||||
[[Property:weight|1]]
|
||||
In both trees of the [[Objects tool: Introduction|object tool]] , objects are displayed. Two categories are made for each objects: its attributes (grouped under the `attributes' folder [[Image:feature-attribute-icon]] ) and its once routines (grouped under the `once routines' folder [[Image:feature-once-icon]] ).
|
||||
|
||||
All follow the following symbol scheme to describe the kind of each item:
|
||||
* [[Image:debugger-object-immediate-icon]] An attribute of a basic type, such as <eiffel>[/libraries/base/reference/kernel/integer_chart.xml| INTEGER ]</eiffel>, <eiffel>[/libraries/base/reference/kernel/classic/double_chart.xml| DOUBLE ]</eiffel>,...
|
||||
* [[Image:debugger-object-eiffel-icon]] An attribute that is a reference to an object
|
||||
* [[Image:debugger-object-void-icon]] A Void reference
|
||||
* [[Image:debugger-object-expanded-icon]] An object that is expanded
|
||||
|
||||
For .NET system, special symbols are used to describe :
|
||||
* [[Image:debugger-object-dotnet-icon]] An object that is external (i.e not known as an Eiffel type)
|
||||
* [[Image:debugger-object-dotnet-static-icon]] A static value object that is external (i.e not known as an Eiffel type)
|
||||
* [[Image:debugger-object-static-icon]] A static value object that is known as an Eiffel type
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
[[Property:title|Debug output]]
|
||||
[[Property:weight|2]]
|
||||
In both grids of the [[Objects tool: Introduction|object tool]] , objects are displayed. For virtually all objects, it is possible to display a user-definable string value next to the object address.
|
||||
|
||||
To do so, inherit from the class <eiffel>DEBUG_OUTPUT</eiffel> in the classes that should let their objects display a string value, and implement the `debug_output' feature. At run-time, the debugger will automatically query the result of this feature on all objects that define it and display it in the object tool and the [[Expression evaluation|evaluation tool]] .
|
||||
|
||||
{{sample| '''Sample''': The <eiffel>NUMERIC</eiffel> class inherits from the <eiffel>DEBUG_OUTPUT</eiffel> one so that it is possible to see the value of *_REF objects without expanding them. }}
|
||||
|
||||
{{tip| '''Tip''': If an object has a long string output or an output with carriage returns, for instance, pick-and-drop it to the expanded display command [[Image:debugger-expand-info-icon]] in the object tool. }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
[[Property:title|Object tool]]
|
||||
[[Property:weight|-11]]
|
||||
* [[Objects tool: Introduction|Introduction]]
|
||||
* [[Attribute symbols|Attribute symbols]]
|
||||
* [[Debug output|Debug output]]
|
||||
* [[Image:debugger-set-sizes-icon]] [[Set slice size command|Set slice size command]]
|
||||
* [[Image:general-delete-icon]] [[Remove object command|Remove object command]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
[[Property:title|Object Viewer (also known as Expanded display)]]
|
||||
[[Property:weight|4]]
|
||||
You can either show the "Object Viewer" tool (Menu Execution>Tools>Object Viewer, or popup the object viewer dialog thanks to the button located in the tool bar of the [[Object tool|objects tool]] and [[Expression evaluation|watch tool]] . <br/>
|
||||
This command [[Image:debugger-expand-info-icon]] opens an object viewer dialog when an object is dropped onto the button.
|
||||
|
||||
Depending the nature of the dropped object, you can view it with several viewers:
|
||||
* '''Object dump''': dump a text representation of the value
|
||||
* '''String display''': string representation
|
||||
* '''XML display''': xml viewer
|
||||
* '''Object browse''': browse the object, as you would do in objects or watch tools
|
||||
* '''Object internal''': display a few internal data such as <code>class_name</code>, <code>type_name</code>, <code>dynamic_type</code>, <code>field_count</code>, <code>deep_physicial_size</code>, and <code>physical_size</code>
|
||||
|
||||
{{note|Note that the "string display" viewer is available for object with a string representation, for instance object conformed to [[ref:/libraries/base/reference/string_8_chart]] or conform to [[ref:/libraries/base/reference/debug_output_chart]] (see [[Debug output|Debug Output]] )}}
|
||||
|
||||
{{note|And the "XML display" is available for object eligible to "String display", and whose string representation has XML content. The viewer is display XML in a basic tree enabled grid.}}
|
||||
|
||||
|
||||
'''String display viewer:''':<br/>
|
||||
|
||||
<center> [[Image:expanded-display-default]] </center>
|
||||
|
||||
Displays the object as a string, by default the displayed length is 50:<br/>
|
||||
If the limits are over the current slice limits, the displayed string will end by "..." to show there is more.<br/>
|
||||
If you click on the auto expand button [[Image:debugger-object-expand-icon]] , the slice limits will be set to the lower and upper limits of the string value.
|
||||
|
||||
You can enable or disable the line wrapping by clicking onto [[Image:general-word-wrap-icon]] .
|
||||
|
||||
|
||||
'''Object dump viewer:'''
|
||||
<center> [[Image:object-viewer-dump]] </center>
|
||||
|
||||
|
||||
'''Object browse viewer:'''
|
||||
<center> [[Image:object-viewer-browse]] </center>
|
||||
|
||||
|
||||
'''Object internal viewer:'''
|
||||
<center> [[Image:object-viewer-internal]] </center>
|
||||
|
||||
|
||||
'''XML viewer:'''
|
||||
<center> [[Image:object-viewer-xml]] </center>
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
[[Property:title|Remove object command]]
|
||||
[[Property:weight|5]]
|
||||
Located in the [[Objects tool: Introduction|object tool]] toolbar, this command [[Image:general-delete-icon]] discards an object from the [[Objects tool: Introduction|object tools]] . All top-level objects can be removed, except the first one, which is the object relative to the [[Callstack tool: Introduction|current call stack element]] .
|
||||
|
||||
Left-clicking on this button removes the selected object from the [[Objects tool: Introduction|object tools]] , if possible. It is also possible to [[Pick-and-drop mechanism|drop]] an object onto the button to remove the object.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
[[Property:title|Set slice size command]]
|
||||
[[Property:weight|3]]
|
||||
Located in the object tool toolbar, this command [[Image:debugger-set-sizes-icon]] changes the display size of special objects (i.e. objects whose class is [[ref:/libraries/base/reference/special_chart]] ).Since special objects may contain thousands of attributes, only the first fifty are displayed by default. If left-clicked, a dialog is popped up that sets the exploration indices of special objects that will be loaded in the future. <br/>
|
||||
This popup also shows the "Maximum displayed string size" in the grid ([[Objects tool: Introduction|objects tool]] , or the [[Expression evaluation|watch tools]] ).
|
||||
|
||||
This dialog changes the settings for future special objects:
|
||||
|
||||
[[Image:set-default-slice-size-dlg]]
|
||||
|
||||
If a special object is [[Pick-and-drop mechanism|dropped]] onto this command, the special object that is dropped is shrunk or extended in the tree according to the new exploration indices it is given in the dialog box. The dropped object may be any object, top-level or not.
|
||||
|
||||
This dialog changes the settings for a single special object (the dropped object) :
|
||||
|
||||
[[Image:set-slice-size-dlg]]
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
[[Property:title|Stack overflow prevention]]
|
||||
[[Property:weight|-6]]
|
||||
Accessible via the '''Debug/Overflow prevention...''' menu, this command makes it possible to detect stack overflows before they occur. Selecting it pops up a dialog that lets you decide at which call stack depth a warning should be issued.
|
||||
|
||||
[[Image:stack-overflow-dlg]]
|
||||
|
||||
By default a warning is issued when the debugged program reaches a stack depth of 1,000 elements.
|
||||
|
||||
{{note| '''Note''': Once an application has stopped at the selected level, it will not stop again until its stack depth goes below the critical stack depth again. }}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
[[Property:title|Threads tool]]
|
||||
[[Property:weight|-8]]
|
||||
This tool displays the list of current Eiffel '''threads'''. <br/>
|
||||
To show this tool, go to menu : '''Debug > Tools > Threads''' .
|
||||
[[Image:threads-tool|Threads tool]]
|
||||
By double clicking on a row, you change the current thread for the debuggee (application). If you double click on "Note" cell, you can edit a note, this can be useful to identify a thread during the debugging session.<br/>
|
||||
The highlighted line shows the current thread.
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user