wdbgexam.gml

开放源码的编译器open watcom 1.6.0版的源代码

"Protected" functions.
.menuitem Class/Show Inherited
Display inherited members of this object.
To see inherited functions, you must also select
.mi Class/Show Functions.
.menuitem Class/Show Generated
Display compiled-generated members of this object.
To see generated functions, you must also select
.mi Class/Show Functions.
.menuitem Class/Show Private
Display private members of this object.
To see private functions, you must also select
.mi Class/Show Functions.
.menuitem Class/Show Protected
Display protected members of this object.
To see protected functions, you must also select
.mi Class/Show Functions.
.menuitem Class/Show Static
Display static members of this object.
.menuitem Type/Hex
Change the value to be displayed in hexadecimal.
.menuitem Type/Decimal
Change the value to be displayed in decimal.
.menuitem Type/Character
Change the value to be displayed as a single character constant.  This
useful when you have a one byte variable that really contains a character.
The debugger will often display it as an integer by default.
.menuitem Type/String
.ix 'pointer' 'display as string'
.ix 'string' 'display pointer as'
The debugger automatically detects pointers to strings in the variable windows
and displays the string rather than the raw pointer value.  In the string is
not null terminated, contains non-printable characters, or is not typed as
a pointer to 'char', this mechanism will not work.
.mi Type/String
overrides the automatic string detecting and displays the pointer as a
string regardless of its type.
.menuitem Type/Pointer
.ix 'pointer' 'display value'
.ix 'string' 'display pointer'
This will undo the effects of
.mi Type/String
or
.mi Type/Array
.dot
It will also let you see the raw pointer value when the debugger has
automatically displayed a pointer to char as a string.
.menuitem Type/Array...
.ix 'pointer' 'display as array'
Use this menu item to display a pointer as if it were an array, or to
display ranges of an array's elements.  You will be prompted for the
first and last element to display.
.menuitem Options/Whole Expression
Select this option to show the whole expression used to access fields
and array elements instead of just the element number or field name
itself.
.menuitem Options/Expand 'this'
Do not display members of the 'this' pointer as if they were local
variables declared within the member function.
.endmenu
.*
.section *refid=wndmem The Memory and Stack Windows
.*
.figure *depth='2.50' *scale=58 *file='dbgmem' The Memory Window
.np
Use the
.wnddef Memory
window or the
.wnddef Stack
window to examine memory in raw form.
.ix 'memory' 'display'
To open a Memory window, choose
.menuref 'Memory At' 'Data'
.dot
The
.us Enter Memory Address
dialog appears. Enter the memory address and press Return to see the
Memory window.
You can also use one of the Show/Pointer Memory or Show/Raw Memory
items in a variable window to display the memory associated with a
variable.
.np
The Stack Window always shows the memory at the stack pointer.  It is moved
as your program executes to track the top of the stack.  The stack
pointer location will be at the top of the window.  The location
of the BP or EBP register will also be indicated.
.ix 'stack' 'display'
Choose
.menuref 'Stack' 'Data'
to open the Stack window.
.np
.ix 'memory' 'modify'
You can modify memory by double-clicking on a value in the Memory or
Stack window, or by cursoring to it and pressing enter. You will be
prompted for a new value.
.np
Memory windows allow you to follow data structures in the absence of
debugging information.  The
.mi Follow
menu items will reposition the memory window to the address that is
found under the cursor.  The
.mi Repeat
and
.mi Previous
items will let you repeat a follow action.  This makes it simple
to follow linked lists.
Press the right mouse button to access the following pop-up menu items:
.begmenu Memory Pop-up
.menuitem Modify
.ix 'memory' 'modify'
Modify the value at the selected address.  You will be prompted for
a new value.  You should enter the value in the same radix as the window is
currently displaying.  You are not limited to typing constants values.
You can enter an arbitrary expression to be used for the new value.
.menuitem Break on Write
.ix 'memory' 'break on write'
.ix 'breakpoint' 'on write'
Set a breakpoint to stop execution when the selected value changes.
.refalso vidbrk
.note --------
.menuitem Near Follow
.ix 'memory' 'follow pointers'
.ix 'pointer' 'follow in memory'
Displays the memory that the selected memory points to,
treating it as a near pointer.  The new offset to be displayed will
be xxxx where xxxx is the word under the cursor.
DGROUP will be used as the segment if it can be located.
The program's initial stack segment will be used otherwise.
When you are debugging a
16-bit or 32-bit application, the appropriate word size is used.
.menuitem Far Follow
Displays the memory that the selected memory points to,
treating it as a far pointer.  The new address to be displayed will
be the the segment and offset found at the cursor location.  Note
that pointers are stored in memory with the offset value first and the
segment value second.
.menuitem Segment Follow
Display the segment that the selected memory points to,
treating it as a segment selector.  The new address to be displayed will
be xxxx:0 where xxxx is the two byte word under the cursor.
.menuitem Cursor Follow
.ix 'memory' 'examine array'
Make the selected position the new starting address in
the window. This means that the first byte in the memory
window will become the byte that the cursor was pointing
to.  This is useful for navigating through an array when no debugging
information is available.
.menuitem Repeat
Repeat the previous Follow operation.  The new address that will
be used is at the same offset relative to the beginning of the window
as it was in the original Follow operation.   Repeating a pointer or
segment follow is a linked list traversal.  Repeating a Cursor Follow
operation advances to the next element in an array.
.menuitem Previous
Back out of a Follow or Repeat operation.  This
will display the memory window you were previously viewing.
Essentially, this undoes a Follow operation.  You can back
all the way out to the first memory location you were examining.
.menuitem Home
Undo all Follow and Repeat operations.  This will take you back
to the very first location window you were examining.  It is equivalent
to using Previous repeatedly.
.note --------
.menuitem Left
Scroll the window backward through memory by the size of
the displayed memory items.
.menuitem Right
Scroll the window forward through memory by the size of
the displayed memory items.
.note --------
.menuitem Address
.ix 'memory' 'examine new address'
Position the window at a new address.  You will be prompted to type in
a new address.  You can type an arbitrary expression.
.refalso videxpr
If you type the
name of a variable, the
.us address
of that variable is used.  If the expression you type does not contain
a segment value DGROUP will be used as the segment if it can be located.
The program's initial stack segment will be used otherwise.
.menuitem Assembly
Position the assembly window to the address of the memory under the cursor.
This is useful if you have incorrectly displayed a pointer as data and wish
to look at the code instead.
.menuitem Type/Byte
.ix 'memory' 'set display type'
Display as hexadecimal bytes.
.menuitem Type/Word
Display as hexadecimal 16-bit words.
.menuitem Type/Dword
Display as hexadecimal 32-bit words.
.menuitem Type/Qword
Display as hexadecimal 64-bit words.
.menuitem Type/Char
Display as signed 8-bit integers.
.menuitem Type/Short
Display as signed 16-bit integers.
.menuitem Type/Long
Display as signed 32-bit integers.
.menuitem Type/__int64
Display as signed 64-bit integers.
.menuitem Type/Unsigned Char
Display as unsigned 8-bit integers.
.menuitem Type/Unsigned Short
Display as unsigned 16-bit integers.
.menuitem Type/Unsigned Long
Display as unsigned 32-bit integers.
.menuitem Type/Unsigned __int64
Display as unsigned 64-bit integers.
.menuitem Type/0:16 Pointer
Display as 16-bit near pointers (16-bit offset).
.menuitem Type/16:16 Pointer
Display as 32-bit far pointers (16-bit segment, 16-bit offset).
.menuitem Type/0:32 Pointer
Display as 32-bit near pointers (32-bit offset).
.menuitem Type/16:32 Pointer
Display as 48-bit far pointers (16-bit segment, 32-bit offset).
.menuitem Type/Float
Display as 32-bit floating-point values.
.menuitem Type/Double
Display as 64-bit floating-point values.
.menuitem Type/Extended Float
Display as 80-bit floating-point values.
.endmenu
.*
.beglevel
.*
.section Following Linked Lists
.*
.np
.ix 'linked lists' 'following in memory'
Use the memory window to display the memory address of the
first node of your linked list. Move to the "next" field of your
structure and use the Near (or Far)
Follow command. The next node of your linked list will be
displayed. Now by using the Repeat
command you can traverse the linked list.
.*
.section Traversing Arrays
.*
.np
.ix 'array' 'traversing in memory'
Display the memory address of
your array. Select the first byte of the second element
of your array then use the Cursor Follow command to move
the second element of your array to the beginning of
the memory window. By using the Repeat
command you can traverse your array.
.*
.endlevel