Author:halw

Date:2009-01-25T23:31:24.000000Z


git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@168 abb3cda0-5349-4a8f-a601-0c33ac3a8c38

documentation/current/eiffelstudio/eiffelstudio-how-tos/running-and-debugging/exploring-application-dynamic-state.wiki

@@ -13,7 +13,7 @@ You can also query features dynamically by using the evaluation tool, which can
 [[Interrupting an application|Pausing an application]]  <br/>
 [[Call stack tool]]  <br/>
 [[Object tool]]  <br/>
-[[Expression evaluation: Introduction|Evaluation tool]]  }}
+[[Expression evaluation|Evaluation tool]]  }}
 
 
 

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/execution-record-and-replay/record-execution.wiki

@@ -6,9 +6,19 @@ For performance reason, the recording mechanism has a few parameters. For now th
 ** Type: <code>INTEGER</code>
 ** Default value: 1_000_000
 ** Effect: The recording keeps only the last <code>maximum_record_count</code> object's records.
-* boolean parameter: <code>{RT_DBG_EXECUTION_PARAMETERS}.flatten_when_closing</code> (default: True): 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 recommended).
-* boolean parameter: <code>{RT_DBG_EXECUTION_PARAMETERS}.keep_calls_records</code>(default: True): 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): 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.)
+* <code>{RT_DBG_EXECUTION_PARAMETERS}.flatten_when_closing</code>
+** Type: <code>BOOLEAN</code>
+** Default value: <code>True</code> 
+** Effect: When leaving a feature, the recorder flattens the associated record. This saves memory space, and optimizes the underlying mechanism. The default value of <code>True</code> is recommended.
+* <code>{RT_DBG_EXECUTION_PARAMETERS}.keep_calls_records</code>
+** Type: <code>BOOLEAN</code>
+** Default value: <code>True</code>
+** Effect: When flattening call records' values, keep the sub-call records (i.e: the execution calls history)
+* <code>{RT_DBG_EXECUTION_PARAMETERS}.recording_values</code>
+** Type: <code>BOOLEAN</code>
+** Default value: <code>True</code>
+** Effect: During execution, record attribute and locals assignment. Set to <code>False</code> if you just want to review the calls history. Values will not be recorded, but recording will be faster.
+
 
 {{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.}}
 
@@ -17,6 +27,7 @@ The recording functionality is graphically available on the Call stack tool, or
 
 After you start debugging, if at some point you decide to start recording, click on the "record" button:
 
+
 [[Image:exec-replay-00]]
 
 
@@ -36,4 +47,3 @@ The execution is now recorded. Whenever the application is stopped, you can deci
 
 
 
-

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/execution-record-and-replay/replay-recorded-execution.wiki

@@ -1,43 +1,60 @@
 [[Property:title|Replay (recorded) execution]]
 [[Property:weight|2]]
 [[Property:uuid|13932252-4eca-7c71-d047-b0b011e50d60]]
-The replay functionality is graphically available on the Call stack tool, or though the "Execution" menu.
+The replay functionality is available from a button on the Call stack tool, or though EiffelStudio's "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:
 
+
 [[Image:exec-replay-01]] 
 
-Now we are in "execution replay" mode, as you can see by the fact that the "Replay" button is enabled. Also, another command bar is visible with replay "Back", "Forth", "Previous", "Next", and "Go to". 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/>
+
+After clicking the "Replay" button, the Call stack tool enters "execution replay" mode, as shown below: 
+
 
 [[Image:exec-replay-02]]
 
-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. 
+
+In "execution replay" mode, the "Replay" button is enabled, and an additional command bar becomes visible with replay control buttons "Back", "Forth", "Previous", "Next", and "Go to". The numbers on the right end of this command bar indicate the call stack depth, the breakable index, and the nested breakable index. The buttons have following meanings:
+
+* '''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.
+
+Below the command bar, in the first column, you will find a tree structure, which shows, on the root level, the effective call stacks, and for each root node, you can inspect the sub element to browse the call history.<br/>
+The '''bold entries''' show the active call stacks (i,e., the current call stack when the debugger was stopped).<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/>
+
+
+If you expand a node, you will be able to browse the whole recorded execution history from this stack, as shown below (if you expand the bottom node, the whole recorded execution history will be available).
+
+You can still select other call stack levels as you do in normal debugging mode to inspect them. When you do, the red arrow stick to the replayed call, and the green arrow indicates the call stack level you selected. 
+
 
 [[Image:exec-replay-02-1]]
 
-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)
+
+In the image below, we have 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)
+
 
 [[Image:exec-replay-03]]
 
-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.
+
+And then if you replay "previous" twice, you rewind the execution in the same call stack frame. Notice the "blue" dot that shows the replayed execution cursor.
 
 
 [[Image:exec-replay-04]]
 
+
 {{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... }}
+If you evaluate an expression in a watch tool, it will use the recorded values. So, be careful about side effects, because you can modify those values... }}
 
 
 

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/expression-evaluation/evaluation-tool-or-watch-tool.wiki

@@ -1,42 +1,43 @@
 [[Property:title|Evaluation tool or Watch tool]]
 [[Property:weight|1]]
 [[Property:uuid|e70d5827-a00d-47ee-9e7a-b7b4bfb34ccf]]
-The expression evaluation tool's main part is the list of expressions that should be evaluated.
+The Evaluation (or Watch) tool displays a list of expressions and their values (provided that those values can be obtained).
 
 [[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 display, the ''Expression'' column gives the expression's text. The ''Context'' column gives the context in which the [[New expression dialog|expression]] is evaluated. The ''Value'' column gives the result of the expression, and the ''Type'' column the type of the expression's value. 
 
-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. 
+In the image above, you can see various expressions. Look at the one on the fourth line. This is an object that has been dropped on to the Evaluation tool, and the tool displayed it as itself, as shown by "As object" in the ''Context'' column, and by the italic style. The user can name the dropped object by editing the value in the ''Expression'' column for the expression. This can be useful to help you 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 
+The expression in the fifth row has an error, the icon is different, and the ''Value'' shows there is an error, double click on it for more details.
 
-{{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|holding the mouse pointer over the expression's cell will popup a tooltip with details on the pointed expression }}
+{{tip|If the expression returns a non-Void (and non-basic type) object, then the corresponding row in the list is pickable. The object can be dropped, for example, on the Evaluation tool to inspect it or to keep the object visible while stepping through system execution. }}
+
+
+{{tip|holding the mouse pointer over the expression's cell will pop up 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: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). 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: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 <code>CTRL</code>+<code>E</code> 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: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] + [+]. 
+*   [[Image:general-delete-icon]]  removes the selected expressions from the list. 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 <code>CTRL</code>+<code>-</code> or <code>CTRL</code>+<code>+</code> respectively (that is, the Control key with the ''minus'' key or the Control key with the ''plus'' key). 
 
 {{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. }}
+If you hold the <code>CTRL</code> key while dropping, you will add the dropped object as itself. }}
 
 
 

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/expression-evaluation/index.wiki

@@ -1,9 +1,25 @@
 [[Property:title|Expression evaluation]]
 [[Property:weight|-10]]
 [[Property:uuid|e55442ac-7861-1995-d315-baeed6c49223]]
-*  [[Expression evaluation: Introduction|Introduction]]  
-*  [[Evaluation tool or Watch tool|Evaluation tool (alias Watch tool)]]  
-*  [[New expression dialog|New expression dialog]]  
+[[Image:expression-evaluation-tool]]  
+
+The Expression evaluation tool (sometimes called the Watch tool) makes it possible to evaluate expressions while the application is stopped in the debugger. A typical use for it is the case in which you would like to know the result that an external feature would return. Since you do not have access to the C memory of the application, doing this would be impossible without the Expression evaluation tool. You might also want to know the result of an Eiffel feature whose body is too complex for you to evaluate.
+
+In these cases (and any other that suits you), you should use the dynamic expression evaluation. Simply [[New expression dialog|define the expression]] and its result will be immediately available in the [[Evaluation tool or Watch tool|list of expressions]] . 
+
+If you keep the mouse cursor over the expression cell of line, you get a tooltip describing the expression result. 
+
+You can disable the evaluation of the selected expression by clicking on  [[Image:general-toogle-icon]]  . After you do, the context value will display 'disabled'. 
+
+If the expression has an error, or if the evaluation raised an exception, you can obtain a more detailed description by double-clicking on the expression row. 
+
+
+{{caution|During the evaluation of an expression, all features that are necessary to obtain the result are called. Therefore, you should avoid calling queries that have side-effects, since doing so may alter the program execution. The Eiffel methodology recommends against creating queries with side-effects for other important reasons, as well. }}
+
+{{caution|Eiffel ''agents'' (for example: <code>agent my_function</code>) are not supported is not supported. }}
+
+
+{{caution|Currently, for classic Eiffel systems, evaluating <code>Precursor</code> will result the current feature's result (not the precursor). }}
 
 
 

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/expression-evaluation/new-expression-dialog.wiki

@@ -3,7 +3,7 @@
 [[Property:uuid|95a78497-434d-759f-fdce-f9025c891495]]
 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/>
@@ -11,18 +11,17 @@ 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 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. 
+*  The object context, that requires a valid object address, gives access to the features of the selected object. If you select "As object", the result of the expression is the referenced object itself; and you can supply a name for the object (see the second screenshot). 
+*  The last context, the class-related context, gives access to the <code>once</code> and constant 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.
+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 non-object calls. Genericity is partially supported. 
 
-And the "Keep Assertion Checking" checkbox is used to enable assertion checking during expression evaluation if wanted (by default assertions won't be checked).
+The "Keep Assertion Checking" checkbox is used to enable assertion checking during expression evaluation if desired (by default assertions won't be checked).
 
 
 

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/object-tool/attribute-symbols.wiki

@@ -4,14 +4,14 @@
 In both trees of the [[Object tool|object tool]], objects are displayed. The values displayed for each object fall into two categories: the object's attributes (grouped under the '''attributes''' folder  [[Image:feature-attribute-icon]]  ) and its once routines (grouped under the '''once routines''' folder  [[Image:feature-once-icon]]  ). 
 
 The following symbol scheme is used to categorize each item:
-*   [[Image:debugger-object-immediate-icon]]  An attribute of a basic type, such as [[ref:/libraries/base/reference/kernel/integer_chart.xml|INTEGER]] or [[ref:/libraries/base/reference/kernel/classic/double_chart.xml|DOUBLE]] 
+*   [[Image:debugger-object-immediate-icon]]  An attribute of a basic Eiffel type, such as [[ref:/libraries/base/reference/kernel/integer_chart.xml|INTEGER]] or [[ref:/libraries/base/reference/kernel/classic/double_chart.xml|DOUBLE]] 
 *   [[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-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 
 
 

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/object-tool/debug-output.wiki

@@ -1,12 +1,12 @@
 [[Property:title|Debug output]]
 [[Property:weight|2]]
 [[Property:uuid|41544c3b-e1f1-53a5-ff63-e63224c32fa3]]
-In both grids of the [[Object tool|object tool]], objects are displayed. For virtually all objects, it is possible to display a user-definable string value next to the object address. 
+For virtually any object displayed in the Object tool, it is possible for the developer to cause the Object tool to display a user-definable string value next to the object address. 
 
-In order to have the instances of a class display such a string in the object tool, let the class inherit from the class <eiffel>DEBUG_OUTPUT</eiffel>. Then implement the feature <eiffel>debug_output</eiffel> to craft the string for display. At run-time, the debugger will automatically query this feature on all objects that define it, and then will display the results in the object tool and the [[Expression evaluation|evaluation tool]]. 
+In order to have the instances of a class display such a string in the object tool, make the class an heir to class <eiffel>DEBUG_OUTPUT</eiffel>. Then implement the feature <eiffel>debug_output</eiffel> to return the string to be displayed. At run-time, the debugger will automatically query this feature on all objects that define it, and then will display the results in the object tool and the [[Expression evaluation|evaluation tool]]. 
 
 
-{{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. }}
+{{sample|The numeric *<code>_REF</code> classes inherit (through class <eiffel>NUMERIC</eiffel>) from the class <eiffel>DEBUG_OUTPUT</eiffel> so that it is possible to see immediately the value of *<code>_REF</code> objects in the Object tool. The *<code>_REF</code> classes are reference versions of the basic Eiffel classes such as [[ref:/libraries/base/reference/kernel/integer_chart.xml|INTEGER]] and [[ref:/libraries/base/reference/kernel/classic/double_chart.xml|DOUBLE]]. So, without <eiffel>DEBUG_OUTPUT</eiffel>, if you wanted to see, for example, the value of the [[ref:/libraries/base/reference/kernel/integer_chart.xml|INTEGER]] associated with an instance of [[ref:/libraries/base/reference/kernel/integer_ref_chart.xml|INTEGER_REF]] displayed in the Object tool, you would have expand the reference first.}}
 
 
 {{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. }}

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/object-tool/index.wiki

@@ -3,21 +3,21 @@
 [[Property:uuid|6b736424-1729-0b6f-6ddd-8240f9f8ffd6]]
 [[Image:object-tool]]  
 
-The object tool is a debugging tool that displays extended dynamic information concerning one or several objects while debugging an application. This information includes the value of all their attributes, as well as the values of the once functions that have already been called.
+The object tool is a debugging tool that displays extended dynamic information about runtime objects while debugging an application. This information includes the values of attributes, as well as the values of <code>once</code> functions that have already been called.
 
-By default it is composed of one grid, which gives information about the [[Call stack tool|current stack element]]. Namely, it provides the Current object value, the arguments' values of the current stack element's feature call, the values of the local variables, as well as the value of the Result (if this feature is a function). 
+By default the Object tool display is composed of one grid, which gives information about the [[Call stack tool|current stack element]]. Specifically, it provides the Current object value, the arguments' values of the current stack element's feature call, the values of the local variables, as well as the value of the <code>Result</code> (if this feature is a function). 
 
-When an exception occurs (for instance, an assertion violation), the objects tool will also display the exception information: 
+When an exception occurs (for instance, an assertion violation), the object tool will also display the exception information: 
 
 
 [[Image:objects-tool-exception]]
 
 
-{{note|Specific case for .NET system: When the system is stopped, the first item of the local view displays the module name for the feature at which execution stopped. }} 
+{{note|A specific case for .NET systems: When the system is stopped, the first item of the local view displays the module name for the feature at which execution stopped. }} 
 
-All objects can be expanded to see the value of their attributes. They are also pickable, so that it is possible to drop them onto the '''objects tool''', an [[Expression evaluation|expression evaluator tool]]  (alias Watch tools), or an editor.
+All objects can be expanded to see the values of their attributes. They are also pickable, so that it is possible to drop them onto the Object tool, an [[Expression evaluation|expression evaluator tool]] (also know as Watch tool), or an editor.
 
-It is also possible to use the [[Set slice size command|set slice size command]]  with [[ref:/libraries/base/reference/special_chart|SPECIAL]]  objects or [[ref:/libraries/base/reference/native_array_chart|NATIVE_ARRAY]]  (.NET) objects. 
+It is also possible to use the [[Set slice size command|set slice size command]] with [[ref:/libraries/base/reference/special_chart|SPECIAL]] objects or [[ref:/libraries/base/reference/native_array_chart|NATIVE_ARRAY]] (.NET) objects. 
 
 
 
@@ -35,11 +35,11 @@ It is also possible to use the [[Set slice size command|set slice size command]]
 [[Image:object-tool-layout-editor]]
 
 
-{{note| By default, the object tool displays the full generating type for object, but this can be changed for speed concern in the [[Debugging preferences|preferences]] . The same way, through the [[Debugging preferences|preferences]] , the user can enable or disable the evaluation of the [[Debug output|Debug Output]]  feature .}}
+{{note| By default, the object tool displays the full generating type for object, but this can be changed for speed concern in the [[Debugging preferences|preferences]] . The same way, through the [[Debugging preferences|preferences]] , the user can enable or disable the evaluation of the [[Debug output|Debug Output]]  feature. }}
 
-{{note|When a row has a pink background, this indicates the value is different from previous step }}
+{{note|When a row displays a pink background, this indicates the value has changed as a result of the previous step. }}
 
-{{tip|The [[Expression evaluation|expression evaluator tools]] (alias "watch" tools) provides many of the same features as the object tool along with even more functionality. }}
+{{tip|The [[Expression evaluation|expression evaluator tools]] (also known as Watch tools) provide many of the same features as the object tool along with even more functionality. }}
 
 
 

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/object-tool/object-viewer-also-known-expanded-display.wiki

@@ -1,24 +1,36 @@
 [[Property:title|Object Viewer (also known as Expanded display)]]
 [[Property:weight|4]]
 [[Property:uuid|62002ce3-37f9-22de-39f0-0930468a67be]]
-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/>
+You can either show the "Object Viewer" tool through the menu path
+<code lang=text>
+Execution --> Tools --> Object Viewer</code>
+
+or pop-up the object viewer dialog by clicking the button ( [[Image:debugger-expand-info-icon]] ) located in the tool bar of the [[Object tool|objects tool]] and [[Expression evaluation|watch tool]].
+
 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: 
+Depending the nature of the dropped object, you can view it with one or more of 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>
+* '''Object browse''': browse the object, as you would do in the Object or watch tools
+* '''Object internal''': display some internal data elements such as: 
+** <code>class_name</code> 
+** <code>type_name</code>
+** <code>dynamic_type</code>
+** <code>field_count</code>
+** <code>deep_physicial_size</code>
+** <code>physical_size</code>
 
-{{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|The "string display" viewer is available for objects with a string representation, for instance objects whose types conform to [[ref:/libraries/base/reference/string_8_chart|STRING_8]] or conform to [[ref:/libraries/base/reference/debug_output_chart|DEBUG_OUTPUT]]  (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.}}
+{{note|The "XML display" is available for objects eligible for "String display", and whose string representation has XML content. The viewer displays XML in a tree-enabled grid.}}
 
 
-'''String display viewer:''':<br/>
+'''String display viewer:''':
 
-<center> [[Image:expanded-display-default]]  </center>
+
+[[Image:expanded-display-default]] 
 
 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/>
@@ -27,21 +39,29 @@ If you click on the auto expand button  [[Image:debugger-object-expand-icon]]  ,
 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>
+
+
+[[Image:object-viewer-dump]]  
 
 
 '''Object browse viewer:''' 
-<center> [[Image:object-viewer-browse]]  </center>
+
+
+[[Image:object-viewer-browse]]
 
 
 '''Object internal viewer:''' 
-<center> [[Image:object-viewer-internal]]  </center>
+
+
+[[Image:object-viewer-internal]] 
 
 
 '''XML viewer:''' 
-<center> [[Image:object-viewer-xml]]  </center>
-
+
+
+[[Image:object-viewer-xml]] 
 
 
 

documentation/current/eiffelstudio/eiffelstudio-reference/debugger/object-tool/set-slice-size-command.wiki

@@ -11,7 +11,7 @@ This dialog changes the settings for future special objects:
 [[Image:set-slice-size-dlg]]  
 
 
-You can affect the display of a single special object only by [[Pick-and-drop mechanism|dropping]] the object onto this ( [[Image:debugger-set-sizes-icon]] ) command. A dialog box appears, and the special object that is dropped is shrunk or extended in the tree according to the new exploration indices you set in the dialog box. The dropped object may be any special object, top-level or not. 
+You can affect the display of a single special object only by [[Pick-and-drop mechanism|dropping]] the object onto this ( [[Image:debugger-set-sizes-icon]] ) command. A dialog box appears, and the special object that is dropped is shrunk or expanded in the tree according to the new exploration indices you set in the dialog box. The dropped object may be any special object, top-level or not. 
 
 This dialog changes the settings for a single special object (the dropped object) :