qAW∞BáêC	/H&D╞≈0╛0[╫G%|⌠H
0ú
L5╗
EÅ)Mó⌡02oO;0RR
<╖0
Jô0NuS#Æ±0T?Tl-Wg0	[AAssembly Window~╝1disassembly location~C1address to disassemble~å1Statement Address~é
1Bpt Menu~â!2Set Breakpoint~▄(2Clear Breakpoint~N,2Kill all Breakpoints~Ñ/
1Others Menu~932Statement Address~[43disassembly address~è	:2Jump to Line~▓	;3execution location~gD1View Menu~hJ
2Assembly~▐N2Mixed~å
S
2with Source~<YBBreakpoint Window~ q2name of the module~Dr2name of the procedure~πu
2line number~Jw	2address~íy2limit~N|2count~ªé2conditional breakpoint~Å1Unconditional Breakpoints~╛Ö1Conditional Breakpoints~╪╛1Delayed Breakpoints~₧$▀1Show Menu~)%π2Source~╨%Φ	2Address~à&φ1Commands Menu~%'≥2Clear Breakpoint~m'⌡2Kill All Breakpoints~╦'∙
CCall Window~╤,1Show Menu~Θ-#2Source~~/,2Data~F012Both~[023double-click~┘05
1Others Menu~q1:2Statement Address~ô1;/3execution address of the selected procedure,~é2A
DData Window~▌4L1global and local data~∞8b1View Menu~ⁿ8c2Child/Contents~(:i3array~E;o3record~╬;r	3pointer~@<u3function or module~┌<y3nested block~^=|	3PROCESS~╫=3double-click~D>é2Parent~ª?ë3double-click~@î2Right (next element)~Aæ2Left (prev. element)~Bû2Specific Index~╜DÑ2Variable Level~F¼2Graphic Data Structure~┘G┤2Local/Global Data~I║1Watch Menu~»J├2Add Watch~qK╚2Kill Watch~L╠2Clear All Watches~iL╧
1Others Menu~(M╘2Modify Value~\Oα2Data Address~yOß3memory location~EPσ2Type Transfer~≡PΩ3predefined type~⌡R⌡
4Modula-2~.T2Examine String Pointer~/U0Global Commands~V0Go Menu (RTD Only)~zW1Assembly Next~⌠X 1Assembly Trace~▓Y%1Breakpoint~[-1Child~┴[2
1End Program~]:1Flat~^@
1Instruction~Σ^D2double-click~_F1Procedure~`M1Return~kaU
1Source Line~9bY2double-click~[c_1Statement~;ejGGraphic Window~£fq1boxes~ßfr1lines~hy1selecting a variable~╬jç1Simple Graphs~mÆ1Complex Graphs~St╢1Show Menu~u╗2select the object~ôu╛
2Information~v├
2Subgraph~gw╚2Parent~9x═1Zoom Menu~ƒx╤	2Zoom In~_y╓$3Double-click the left mouse button~╖y┘
2Zoom Out~?z▌%3Double-click the right mouse button~ÿzα2Zoom Reset~{{µHHelp~F|δ2double-click~⌡~√0Local Commands~╖üLLog Window~sà*1File Menu~å.2Open Log File~,ç52Close Log File~ê:2Pause Log File~║ê@EMemory Window~YìW1View Menu~≡ìZ2display format~Ä\3Char~&Åb3Text~FÉh3Byte~µÉl3Word~çæp
3Unsigned~KÆu	3Integer~ôz3Long Integer~Φô3Short Real~íöä3Long Real~Yòë	3Address~ûì1Watch Menu~αùû2Add Watch~÷ÿ£2Kill Watch~«Öí2Clear All Watches~Üñ1Convert Menu~≥Ü¬2Decimal => Hex~╒¢»2Hex => Decimal~╝£┤
1Others Menu~v¥╣2Modify~c₧╛	2Address~+á╟2Child~uí╧MModule Window~╞ó╓1status information~╓⌐1Show Menu~z¬2Source~╓¼2Data~Ω¡2Both~0«3double-click~ï«1Language Menu~g▒,1Language menu~}▒.
2Assembly~╙▒12C~▓4
2Modula-2~q▓72Pascal~├▓:1Trace Menu~d╢L2Enable~«╢O	2Disable~·╢R
2Disable All~╕Y
1Others Menu~⌐╕]
2Find Module~·║i	1Address~`╝q
0Others Menu~I╜x1Evaluate Expression~2╛~1Expr Language~⌠┐ë1Flip Screen On/Off (RTD Only)~[┴Æ1Set Output Time (RTD Only)~E┬ÿ1Center on Position~├¥1Redraw all Windows~╠├úOOutput Window~╒╚╗0Program Menu~ê╔┴1Restart/Load~╦╩1Quit and Save~╠╨1Exit - F3~Ü╠╘1About~3═┘RRegister Window~,╨Φ1View Menu~ⁿ╨φ
2Hex Mode~⌐╤±2Decimal Mode~T╥⌡2Vertical/Horizontal~ë╙√1Convert Menu~s╘2Decimal => Hex~?╒2Hex => Decimal~%╓
1Others Menu~ƒ╓2Modify~ì╫0Setting Window Colors~I┘1Presentation Manager~f┘2Mouse~▌22Quit and Save~╝▌62Quit and Discard~P▐92Quit, but Keep Colors~ΓI
2Keyboard~█ΓM1Text Mode~φΓO2Mouse~╦ΣW
2Keyboard~éµ_0Setup Menu~ëτf1Small Font~⌠τi
1Medium Font~aΦl1Large Font~═Φo
1Color Panel~└Θs2foreground~ëδÇ2Quit and Save~▌∞ê2Quit and Discard~Wφï2Quit, but Keep Colors~íεÆ1Next Window Color~d∩ù1Prev Window Color~R≡£1Next Menu Color~╤≡á1Prev Menu Color~±í1Next Border Color~7±ó1Prev Border Color~╟±ª1Save Setup~╚≥¡SSource Window~╬∙┘1Find Menu~z·▐2Find Procedure/Line~├√σ3wildcards~/²∞
3line number~Θ²≡
1Bpt Menu~δ■÷2Set Breakpoint~à■3statement number~{3conditional breakpoint~▓3unconditional breakpoint~b3double-click~Ä
2Clear Breakpoint~;
3statement number~*2Kill Breakpoint~}
1Others Menu~ë2Statement Address~½#3code address of the selected line~╙"3statement number~^%2Jump to Line~å&3execution location~W	/3statement number~82Exchange DEF/MOD~┌;3definition module~7?
0System Menu~╤
I	1Restore~°O1Move~&U1Size~a
1Minimize~£l
1Maximize~÷u1Close~@|1Task Manager~ü1Horizontal Expand~|ä1Vertical Expand~▀ç1Exchange Windows~qï
1Move Border~nôTThread Window~cº1control status~i▓1thread status~╔"╩1Show Menu~$╤2All~╪$╓3double-click~:%┘2Source~&▐2Data~π&π2Call Chain~ƒ'Φ
1Action Menu~Æ(φ2Freeze~^*÷2Thaw~┴+ WWatch Window~■/1name~·01address range~G1
1byte1...~ù11number sign (#)~;3*1Show Menu~─3.	2Address~c421Commands Menu~562Clear Watchpoint~O592Kill all Watchpoints~ª5<1Granularity Menu~Ü6@2frequency of the watchpoint~║7G2Trace~P9N2Statement~;V2Procedure~&>f0Windows Menu~
~~AAssembly Window~
  The Assembly window shows the disassembled instructions of
  your program at a selected memory location.  The Assembly
  window's local menus - Bpt, Options, and View - let you set
  and lear assembly level breakpoints (for the Run-Time Debugger
  only), set the disassembly address, and determine the amount
  of symbolic information to display.

  The information in the Assembly window is displayed starting
  at the ~1disassembly location~.  MultiScope automatically sets
  the disassembly location, but it can also be set by the user.
  By default in the Run-Time Debugger, the disassembly location
  is set to the address of the next statement to be executed.
  In the Post-Mortem Debugger, the disassembly location is set
  to the location of the error that caused the program to crash.

  You can also specify your own ~1address to disassemble~.  To do
  this, use the ~1Statement Address~ command in the Assembly
  window Others menu.

  The Assembly window has three menus in the Run-Time Debugger:
  View, Bpt, and Others.  In the Post-Mortem Debugger, there are
  two menus:  View and Others.

  ~1Bpt Menu~ (RTD-Only)

  The Bpt menu contains commands that let you set and clear
  breakpoints at the assembly level in your program.  Section
  6.2.2, The Breakpoint Window, contains a complete discussion
  of using breakpoints in MultiScope.

    ~2Set Breakpoint~ - Alt-S
    Sets a breakpoint at the selected assembly line.  When you
    execute the Set Breakpoint command, MultiScope prompts you
    for a breakpoint expression.  To set an unconditional
    breakpoint, press Enter.  To set a conditional breakpoint,
    type an expression into the dialog box and press Enter.

    ~2Clear Breakpoint~ - Alt-C
    Clears a breakpoint that has been set at the selected
    assembly line.

    ~2Kill all Breakpoints~ - Alt-K
    Clear all breakpoints set in your program.

  ~1Others Menu~
   The Others menu lets you set a particular disassembly location
   and change the execution location of the current thread.

    ~2Statement Address~ - Alt-A
    Sets the ~3disassembly address~.  When this command is executed,
    MultiScope prompts you for an address.  In the dialog box,
    enter a hexadecimal address of the form, xxxx:xxxx to specify
    a segment:offset pair or simply enter xxxx to specify another
    offset in the same segment.

    ~2Jump to Line~ - Alt-J (RTD-Only)
    Changes the ~3execution location~ (CS:IP registers) of the
    current thread to the selected assembly line.  To execute the
    Jump to Line command, select the assembly line where you want
    the execution to resume and press Alt-J.

    This command simulates a jump instruction and skips sections
    of code without executing it.  When you step through your
    program, it continues executing from the new location.

  ~1View Menu~
   This menu sets the display mode of the Assembly window.  The
   Assembly window can display assembly code in three ways Assembly,
   Mixed, and with Source.  A check mark appears in the menu to
   indicate the current display mode.

    ~2Assembly~
    Displays only disassembled instructions without any symbolic
    information or source code.

    ~2Mixed~
    Displays disassembled instructions mixed with symbolic
    information, such as variable names, procedure calls, and
    procedure entry points.

    ~2with Source~
    Displays disassembled instructions mixed with symbolic
    information and the corresponding source code (if available).
    This is the default mode.


~~BBreakpoint Window~ (RTD-Only)
  The Breakpoint window displays status information about the
  breakpoints that are set in your program.  All of the important
  information for a breakpoint is displayed in this window,
  including the module, procedure, location, condition, pass
  count, limit, and expression.

  With the Breakpoint window commands, you can view the source
  location of a breakpoint, and you can clear breakpoints.
  However, this window is not used to set breakpoints.  When
  a breakpoint in either the Source window or the Assembly
  window is set, cleared, or triggered, the status of the
  breakpoint is displayed here.

  If no breakpoints are set in the program, the Breakpoint
  window displays this message:

        No breakpoints defined

  When breakpoints are set in the program, information about
  each breakpoint is displayed in this format:

      <mod>.<proc> <line#> <addr> <limit> <count> <expr>

      mod    The ~2name of the module~ where the breakpoint is set.
      proc   The ~2name of the procedure~ where the breakpoint is
             set.  This field may not be displayed for assembly
             breakpoints.
      line#  The source-level ~2line number~ in the module where
             the breakpoint is set.
      addr   The assembly-level ~2address~ where the breakpoint is
             set.
      ~2limit~  The number of times the breakpoint must be reached
             to be triggered.  This field is only displayed if
             the breakpoint is delayed.
      ~2count~  The number of times the breakpoint has been reached.
             If a conditional expression has been specified, it
             is the number of times the breakpoint has been reached
             with the specified expression evaluating to true.  This
             field is only displayed if the breakpoint is delayed.

      expr   The expression entered for a ~2conditional breakpoint~.

  When the program stops on a breakpoint, a number sign (#) appears
  to the left of the line containing the breakpoint that was triggered.
  You may set a breakpoint on any program statement in the Source
  window or any assembly instruction in the Assembly window.  There
  is no limit to the number of breakpoints you can set.  Breakpoints
  may be set or cleared before you start the execution of your
  program, or whenever the program is stopped.

  MultiScope supports three types of breakpoints:  unconditional,
  conditional, and delayed.

  ~1Unconditional Breakpoints~
  Unconditional breakpoints are breakpoints that always cause
  MultiScope to stop the execution of the program when they are
  encountered.

  When setting a breakpoint, you are prompted with an expression
  dialog box.  Simply press Enter to set the unconditional breakpoint.
  If that breakpoint is reached, MultiScope stops the execution of
  the program at that point.

  ~1Conditional Breakpoints~
  Conditional breakpoints are breakpoints that can be set so that
  MultiScope will stop the execution of the program when a specified
  expression evaluates to true (which is any non-zero value).

  When setting a breakpoint, you are prompted with an expression
  dialog box.  You may enter any valid expression  to set a
  conditional breakpoint.  (Refer to Chapter 7, Expression
  Evaluation.)  This expression is evaluated each time the
  breakpoint is reached.  If it evaluates to true, MultiScope
  stops the program at that point.

  A typical expression used in a conditional breakpoint could look
  like this:

    i >= 5

  If the variable i (either local or global) were to become greater
  than or equal to five, execution would stop at the point the
  breakpoint was set.

  You can also use the assignment and function call capability of
  conditional breakpoints to implement temporary "patches" in your
  code.  For example, to have an assignment occur at a particular
  point in your program, you could set a breakpoint with this
  condition (this example is in C):

    (variable = newvalue) && 0

  The expression "variable = newvalue" sets variable to "newvalue"
  every time the line containing the breakpoint is reached.  The
  "&& 0" causes the expression to always return false, so that
  execution does not stop at the breakpoint.

  Note: MultiScope assumes that a breakpoint condition is false if
  it encounters an error while evaluating the breakpoint's expression.

  ~1Delayed Breakpoints~
  Delayed breakpoints are breakpoints that may occur after they have
  been encountered a specific number of times.  They are set by
  entering a pass count limit on either an unconditional or
  a conditional breakpoint.

  When the program reaches a delayed breakpoint, MultiScope
  evaluates the breakpoint's condition.  If the result of the
  condition is true, or the breakpoint is unconditional, the
  pass count of the breakpoint is incriminated.  When the pass
  count reaches the specified limit, MultiScope stops the program
  at that point.

  When setting a breakpoint, you are prompted with an expression
  dialog box.  To set a delayed breakpoint, enter

    //<limit>

  either alone (for setting an unconditional delayed breakpoint) or
  at the end of an expression (for a conditional delayed breakpoint).
  For example, to have an unconditional breakpoint trigger after it
  has been executed five times, enter

    //5

  To have a conditional breakpoint trigger if an expression has
  evaluated to true after ten times, you could enter

    i > 128 //10

  This triggers the breakpoint if the expression "i > 128" evaluates
  to true ten times.

  ~1Show Menu~
  This menu contains commands that let you view the source and
  assembly locations of breakpoints that have been set.

    ~2Source~ - Alt-S
    Positions the Source window at the point where the selected
    breakpoint has been set.  Double-click also executes this
    command.

    ~2Address~ - Alt-A
    Displays the assembly location of the selected breakpoint
    and positions the Assembly window at the point where the
    breakpoint has been set.

  ~1Commands Menu~
  This menu contains commands that allow you to selectively
  clear breakpoints, or clear all of the breakpoints set in
  the program.

    ~2Clear Breakpoint~ - Alt-C
    Clears the selected breakpoint.

    ~2Kill All Breakpoints~ - Alt-K
    Clears all the breakpoints set in your program.


~~CCall Window~
  The Call window displays the list of procedure or function
  calls that have been made in the current thread.  This list
  is known as the call chain.  The entries in the call chain
  are displayed in reverse order from the last (most recent)
  call to the first (initial) call.  Each entry lists the
  procedure or function name called, followed by the name of
  the module containing the procedure or function.

  You can use the Call window for the following:  to view the
  status of the calls in each thread, to show the source level
  execution location of any procedure, or to view the local data
  of any procedure or function in the call chain.

  If no procedure calls have been made or the thread has not
  started or has terminated but not been removed, the Call window
  displays one of these status messages:

    No call chain (loading)
              or
    No call chain (terminating)

  If the call chain is invalid, the Call window displays this
  message:

    No call chain (error)

  If no debugging information is available for a procedure in the
  call chain, the entry in the Call window is displayed as

    PROCEDURE AT <sel:off>

  <sel:off> is the address of the procedure or function that was
  called.

  ~1Show Menu~

  The Show menu contains commands to update the position and
  information displayed in the Source and Data windows. By using
  these commands, you can view the local data and source-level
  execution position of the selected procedure in the Call window.

    ~2Source~ - Alt-S
    Updates the Source window to show the source-level location
    where the selected procedure is executing.  Refer to Section
    6.2.11, The Source Window, for more information.

    Note: If you have source files in different directories and
    want MultiScope to automatically search those directories,
    include the directories in the DPATH environment variable.

    ~2Data~ - Alt-D
    Updates the Data window to show the local data and variable
    information of the selected procedure. Refer to Section 6.2.4,
    The Data Window, for more information.

    ~2Both~ - Alt-B
    Updates the Data and Source windows.  You can also ~3double-click~
    on a call chain entry to execute this command.

  ~1Others Menu~

  The Others menu contains a command that let you view the current
  execution address of the selected entry in the call chain.

    ~2Statement Address~ - Alt-A
    Displays the ~3execution address of the selected procedure,
    including the source-level line number, statement number, and
    code address.  It also positions the selection line in the
    Assembly window to that location.


~~DData Window~
  The Windows Data window displays the local and global variables
  in your program.  Each line in the Data window shows a different
  variable (or element of a variable) with the name, value, and
  type being displayed.  You can easily examine the elements of
  structures and arrays and the contents of pointers and sets.
  In the Presentation Manager Debuggers, you can view the graphical
  data representation of any data structure.  In the Run-Time
  Debuggers, you can modify and set watchpoints on data.

  The commands in the Module and Call window let you update the
  Data window so that it displays ~1global and local data~.  The
  variable and type information in the Data window is determined
  by the language of the module containing the data.  Refer to
  Section 6.2.8, The Module Window, for more information on the
  module languages and displaying global data in the Data window.
  Refer to Section 6.2.3, The Call Window, for more information
  on updating the Data window for displaying local data.  Once
  the variable information is displayed in the Data window, you
  may examine and modify it.

  If you try showing the local data of a procedure that does not
  have any local data, the Data window displays the global data
  of the module the procedure is in.  If there is no local or
  global data available to view, the Data window displays this
  message:

      No global or local data

  The Data window has three local menus in the Run-Time Debugger:
  View, Watch, and Others.  In the Post-Mortem Debugger, there are
  only two local menus:  View and Others.

  ~1View Menu~
    ~2Child/Contents~ - Alt-C
    Displays the next level of data structure beneath the selected
    data structure.  This command lets you navigate down through
    arrays, structures, and pointers so that you can see the
    elements of each.  This command operates in the following manner:

    * If the selected item is an ~3array~, the Data window displays
    the list of elements of the array with one element per line.
    The name of each element is its index value in the array.  You
    may examine and modify an array element just like any other
    variable.

    * If the selected item is a ~3record~ or structure, the Data
    window displays the names and values of the structure elements.

    * If the selected item is a ~3pointer~, the Data window displays
    the object that is being pointed to.

    * If the selected item is a ~3function or module~, the Data
    window displays the static variables declared inside the function
    or module.

    * If the selected item is a ~3nested block~, the Data window
    displays the variables declared in the nested local scope.

    * If the selected item is a ~3PROCESS~ type, the Data window
    displays the address of its process descriptor.

    Note: You can also ~3double-click~ on the data item to execute
          the Child/Contents command.

    ~2Parent~ - Alt-P
    Displays the parent data structure of the current data structure.
    This command lets you move up a level in a data structure that
    you moved down into with the Child/Contents command.  When the
    Parent command is executed, the Data window displays the
    structure one level up from the current data structure

    Note: You can also ~3double-click~ with the right mouse button
          to execute the Parent command.

    ~2Right (next element)~ - Alt-R
    Displays the next index of the current array.  If you have used
    the Child/Contents command to view the elements of an array, you
    can use this command to quickly select the next index in the array.

    ~2Left (prev. element)~ - Alt-L
    Displays the previous index of the current array.  If you have
    used the Child/Contents command to view the elements of an array,
    you can use this command to select the previous index in the array.

    ~2Specific Index~ - Alt-I
    Lets you  specify a particular index to view in the array.  If
    you have used the Child/Contents command to view the elements of
    an array, you can use this command to view the contents of a
    specific index in the array.

    When this command is executed, MultiScope prompts you for an
    expression.  The result of the expression becomes the new array
    index value.

    Note:  When you are viewing the fields of an array element and
           use one of these commands Right (next element), Left
           (prev. element), or Specific Index the Data window
           displays the fields of the array with the new index.

    ~2Variable Level~ - Alt-V
    Returns to the top nesting level (the variable level) of the
    data display.  You can use this command if you selected the
    Child/Contents command to descend into a data structure and
    want to jump back to the top variable level without repeatedly
    using the Parent command.

    ~2Graphic Data Structure~ Alt-G (Presentation Manager-Only)
    Draws a graphic data representation of the selected variable.
    The Graphic window displays the  drawing of the selected data
    structure.  This command provides a visual overview of your
    structure in addition to the data browsing capabilities provided
    by the Data window.  Refer to Section 6.2.5, The Graphic Window,
    for complete information about the Graphic data display.

    ~2Local/Global Data~ - Alt-X  Toggles the data view between
    the current procedure's local variables and the global
    variables of the current module.  This allows you to toggle
    between the local data of a procedure and the global data
    of the module that contains the procedure.

  ~1Watch Menu~ (RTD-Only)
  Commands in the Watch menu let you control data watchpoints
  in your program.  When a watchpoint is set on a variable, a
  change in the variable's value causes the program to stop
  near the point the value changed.  This feature allows you
  to catch data modifications that may be incorrect.  Refer
  to Section 6.2.13, The Watch Window, for more information
  about watchpoints.

    ~2Add Watch~ - Alt-W
    Sets a data watchpoint on the selected variable.  When
    the value of the variable being watched changes, MultiScope
    stops the execution of the program.

    ~2Kill Watch~ - Alt - K
    Clears a watchpoint that is set on the selected variable.
    This command reverses the effect of the Add Watch command.

    ~2Clear All Watches~ - (Menu-Only)
    Clears all watchpoints set in the program.

  ~1Others Menu~
  The Others menu contains commands that let you modify data
  variables, view the memory address of a data item, and display
  data information using different types.

    ~2Modify Value~ - Alt-M (RTD-Only)
    Modifies the contents of the selected variable.  Select the
    variable you want to modify in the Data window and execute
    this command.  Then press Alt-M.  MultiScope prompts you for
    an expression.  Enter the expression.  The variable is set
    to the result of the expression.

    The expression must evaluate to a value of the same size as
    the variable but not necessarily the same type.  Refer to
    Chapter 7, Expression Evaluation, for complete information
    on expression evaluation.

    ~2Data Address~ - Alt-A
    Displays the ~3memory location~ of the selected variable and
    positions the Memory window at the location of the variable.
    Refer to Section 6.2.7, The Memory Window, for more information.

    ~2Type Transfer~ - Alt-T
    Changes a variable from its original type to another named
    type.

    When you execute Type Transfer, MultiScope prompts you for
    the type name.  If the type you enter is not a ~3predefined type~
    for the Type Transfer command, MultiScope prompts you for the
    module where that type is defined.  The selected variable is
    then cast to that type, and a T is displayed to the left of the
    variable's name.  To reset the variable to its original type,
    select Type Transfer again and press Enter for the type name
    in the dialog box.

    The following types are predefined in Modula-2, Pascal, C, and
    Assembly.

      ~4Modula-2~ ~4Pascal~   ~4C~        ~4ASM~
      CHAR     CHAR     char     DB
      INTEGER  INTEGER  int      DW
      CARDINAL WORD     unsigned
      LONGINT  INTEGER4 long     DD
      ADDRESS  ADS      PTR
      BYTE
      WORD
               REAL     float
      REAL     REAL8    double

    ~2Examine String Pointer~ - Alt-S
    Displays the string that the selected character pointer points
    to.  To view the string, select the pointer and execute this
    command.  A message box displays the string that is being
    pointed to.


~0Global Commands~

  Global menu commands are available regardless of the window
  that is active.  The global menus - Go, Others, Program,
  Setup, and Windows - are found on the menu bar of MultiScope's
  parent window.


~0Go Menu (RTD Only)~

  The Go commands give you control over the execution of
  your program.  A variety of Go commands are provided.
  For example, you can step through your program by
  statement, procedure, or return from procedure.  In
  addition, you can execute at the source or assembly level
  or execute your program to breakpoints.

 ~1Assembly Next~ - N
  Executes the program to the next assembly instruction
  without tracing into calls.  If the current instruction
  is a call to a procedure, your program executes to the
  assembly instruction following the call.  This command
  allows you to step through procedures in your program at
  the assembly level without tracing into other procedures.

 ~1Assembly Trace~ - T
  Executes to the next assembly instruction.  This command
  allows you to trace through the program's code at the
  assembly level, instruction by instruction.

 ~1Breakpoint~ - B
  Executes the program until a breakpoint or watchpoint is
  triggered.  This command is used to execute the program
  after setting your breakpoints or watchpoints.  Refer to
  Section 6.2.2, The Breakpoint Window, for information about
  breakpoints and Section 6.2.13, The Watchpoint Window, for
  information about watchpoints.

 ~1Child~ - C
  Executes the program until it creates a child process or
  session.  This command is used to stop the program when
  it creates another process.

 ~1End Program~ - E
  Executes the program to the end while ignoring all
  breakpoints and watchpoints that are set.  This is useful
  if you want to execute your program without stopping it
  anymore in the current debugging session.  If a protection
  fault occurs, the program breaks at the point of that the
  violation occurred.

 ~1Flat~ - F
  Executes the program to the next statement (or until a
  breakpoint or watchpoint is triggered).  If the current
  statement is a call to a procedure of function, the program
  executes to the next statement following the call.

 ~1Instruction~ - I
  Executes the program until the selected line in the Assembly
  window is reached (or until a breakpoint or watchpoint is
  triggered).  To execute to a particular line in the Assembly
  window, ~2double-click~ on that line.

 ~1Procedure~ - P
  Executes the program until the entry point of the next
  procedure call is reached (or until a breakpoint or
  watchpoint is triggered).  This command is useful for
  executing from any point in a procedure to the next
  procedure call.

 ~1Return~ - R
  Executes the program to the current procedure's return
  address (or until a breakpoint or watchpoint is triggered).
  This command is useful for executing the rest of the
  current function or procedure, and then stopping the
  execution at the point immediately after the function
  or procedure call was made.

 ~1Source Line~ - L
  Executes the program until the selected line in the Source
  window is reached (or until a breakpoint or watchpoint is
  triggered).  To execute to a particular line in the Source
  window, ~2double-click~ on that line.  If there is more than
  one executable statement on the selected line, MultiScope
  prompts you for the statement number.  Enter the statement
  number, such as 1 or 2.  The program then executes until
  that statement in the specified line.

 ~1Statement~ - S
  Executes the program until the next source level statement.
  This command allows you to step through the program's code
  at the source level, statement by statement.  If you use
  this command on a procedure or function call, MultiScope
  steps into the first statement of the procedure only if
  tracing has been enabled for that module containing the
  procedure.  Refer to Section 6.2.8, The Module Window
  Trace Menu, for more information.


~~GGraphic Window~ (Presentation Manager-Only)
  The Graphic window is used to display a graph of a simple or
  complex data structure in your program.  The structure can be
  any variable defined in your program.  Several commands are
  provided in the Graphic window that let you view information
  and zoom in on specific parts of the graph.

  In the Graphic window, a graph is displayed as ~1boxes~ connected
  by ~1lines~.  Each box represents a particular data object, and
  each line represents a relationship between data objects.

  Data objects are the items in the structure that can have a value
  or meaning.  Variables that are pointers, arrays, records, or any
  simple type are data objects.

  A graph can be displayed by ~1selecting a variable~ in the Data
  window and executing the View Graphic Data Structure command.
  (Refer to Section 6.2.4, The Data Window, for more information
  about the Graphic Data Structure command.)  This variable becomes
  the starting (or root) data object of the graph.  The graph that
  is generated from the root data object can be one of two types:
  simple or complex.

  Simple graphs are created when the form of the structure is a
  linked list.  Complex graphs are created when the form of the
  structure is a tree (with multiple pointers).  If the graph
  cannot be displayed as a simple graph, it is displayed as a
  complex graph.

  ~1Simple Graphs~
  Simple graphs (and simple portions of a graph) can be displayed
  fully in the Graphic window.  An overview of the entire graph is
  visible after it is created.  You may zoom in and scroll through
  the graph to examine the information contained there in more detail.

  While MultiScope is creating a simple graph, the Presentation
  Manager clock icon is displayed, preventing you from executing
  any commands.  After the graph is created, the clock icon changes
  back to the normal pointer icon, and you can examine the graph.

  ~1Complex Graphs~
  Complex graphs are initially displayed in the Graphic window as
  a single box representing the root data object of a subgraph.
  An object represents a complex subgraph when the variable name
  in the box is surrounded by vertical bars.  To view the subgraph
  of the complex graph object, you execute the View Subgraph command.

  When you view the complex subgraph, each object in the complex
  structure is displayed.   You may zoom in and scroll through the
  graph to examine the information more closely.

  While MultiScope is creating a complex graph, the Presentation
  Manager clock icon is displayed in the Graphic window.  However,
  you can perform other operations in MultiScope while the graph
  is being created.  After the graph is created, the menu entries
  in the Graphic window will appear, and you can examine the graph.

  If you are viewing a complex subgraph and want to view the parent
  graph of the subgraph, select the Show Parent command.

  The creation of a graph may take a few seconds depending on the
  speed of your machine, the amount of memory available, and the
  complexity of the data structure.  The menu commands of the
  Graphic window are not available until a graph is displayed in
  the Graphic window.

  Each object in the graph displays information about itself, such
  as its name or value.  Each different type of object also has its
  own color, so that at a glance you can tell what an object is.
  To obtain more information about an object, you can use the Show
  Information command.  Note that if an object is too small to display
  its information, you must zoom in on it before the information
  appears.  To customize the colors in the graph, use the Color Panel.
  Refer to Section 6.1.5, The Setup Menu, for information on using
  the Color Panel.

  ~1Show Menu~
  The Show menu lets you display a complex subgraph, display additional
  information about an object, and display the parent graph of a
  complex subgraph.

  To use these commands on particular objects, first ~2select the object~
  by clicking on it.  Once it is selected, execute the command.

    ~2Information~ - Alt-N
    Displays information about the selected object.  When you select
    an object and execute this command, a message box is displayed
    showing the object name and its type information and/or value.

    ~2Subgraph~ - Alt-S
    Displays the subgraph of a complex graph object.  When a complex
    subgraph object is selected and this command is executed, the
    Graphic window displays the associated subgraph of the object.

    ~2Parent~ - Alt-P
    Displays the parent graph of the current subgraph.  If you are
    currently viewing a complex subgraph, this command allows you
    to return to the parent graph of this graph.

  ~1Zoom Menu~
  The Zoom menu commands control the view magnification of the
  selected object.

    ~2Zoom In~ - Alt-I
    Zooms in on the selected object.  Select the object by clicking
    on it and execute this command.  The window redraws and the
    selected object is larger.

    Note: ~3Double-click the left mouse button~ on an object to zoom
          out.

    ~2Zoom Out~ - Alt-O
    Zooms out from the selected object.  Select the object by
    clicking on it and execute this command.

    Note: ~3Double-click the right mouse button~ on an object to
          zoom out.

    ~2Zoom Reset~ - Alt-R
    Resets the display of the graph to its initial state.  Use
    this command if you have zoomed or scrolled the display of
    the graph and want to restore the graph to its original state.


~~HHelp~

  MultiScope's Help feature is context sensitive.  If you
  press F1, MultiScope displays an index for the active window.
  This index contains key items about the window.  To obtain help
  about an item, ~2double-click~ on the item or select the item with
  the arrow keys and press Alt-H.  Then you can view the Help
  information and any other commands or features provided in
  the Help screen.

  While viewing help for an item, double-click the right mouse
  button or press Alt-I to view the local index.

  To view the main index from the local index, double-click the
  right mouse button or press F11.  The main index displays the
  complete list of all of MultiScope's features.  You can view
  the help information for an item in the main index by
  double-clicking on the item or by selecting the item with
  the arrow keys and pressing Alt-H.


~0Local Commands~
  Each window (with the exception of the Output window) has
  its own local menus that contain commands specific to that
  window.  Since the local commands are designed for a specific
  window, they are only available when the window is active.

  You can open a local menu by using the mouse or the keyboard.
  To activate the local menu bar with the keyboard, press and
  release Alt or F10.  Press the arrow keys (right and left) to
  move among the menus.  Press the arrow keys (up and down) to
  open the pull-down menu and to move between the menu commands.

  The next 13 sections describe the MultiScope windows, the
  local menus, and the local menu commands.


~~LLog Window~
  The Log window displays the commands used and messages that
  occurred during the debugging session.  You can view this
  information in the Log window or save it to a log file.

  The Log window logs both commands and messages.  Commands
  are logged in this manner:

    windowName menuName : command, location

  For example, the Show Source command in the Module window
  were executed on the fifth entry in the window, it would be
  logged like this:

    Module Show : source, entry 5

  Messages are logged in the this way:

    -- message

  For example,

    -- note: No statement in this line

  The Log window displays just the last 500 entries in the log,
  but all of the log entries can be logged to a file.

  When the Log window is minimized in the Text Mode debuggers,
  the Log window icon is displayed on the right side of the icon
  line and shows the most recent entry in the log file.

  ~1File Menu~
  The File menu contains commands for opening a new log file,
  closing a log file, and writing the output to the log file.

    ~2Open Log File~ - Alt-O
    Opens a log file where the Log window's output is saved.
    When this command is executed, you are prompted for a
    filename.  The file is created, and all subsequent Log
    window output is written to this file until the file is
    closed or paused.

    ~2Close Log File~ - Alt-C
    Closes the log file so that log messages are no longer
    written to the log file.  To begin logging output again,
    you must open a log file with the Open Log File command.

    ~2Pause Log File~ - Alt-P
    Pauses the Log window output to the open log file.  To
    continue logging output to the log file, select the Pause
    Log File command.


~~EMemory Window~
  The Memory window displays the memory contents at a given
  address and lets you view the contents of memory in various
  formats.  The Memory window commands let you modify a memory
  location, set the memory watchpoints, set the memory address
  to view, and convert hexadecimal and decimal numbers.

  The Memory window is useful for showing the contents of a
  memory range.  Memory can be displayed in ten different formats,
  ranging from hexadecimal bytes to real numbers.  You can specify
  a particular address to view, or you can view the address of a
  variable by using the Data window Address command.  (Refer to
  Section 6.2.4, The Data Window, for more information.)  In addition
  to examining a particular address, you can scroll through the
  Memory window display to all of the memory in a selector.  In the
  Run-Time Debugger, you can modify memory and set memory watchpoints
  as well.  (Refer to Section 6.2.13, The Watch Window, for more
  information.)

  The Memory window in the Run-Time Debugger has four local menus:
  View, Watch, Convert, and Others.  In the Post-Mortem Debugger,
  there is no Watch menu.

  ~1View Menu~
  The View menu contains commands that set the display mode of the
  Memory window.  You can select one of the formats from the menu
  to set the ~2display format~.

      ~3Char~ (Menu-Only)
      Sets the display format to character.  The contents of memory
      are displayed as single-quoted ASCII characters.  If an address
      does not contain a standard ASCII character, the octal value
      of the character is displayed.

      ~3Text~ (Menu-Only)
      Sets the display format to complete text.  The contents of
      memory are displayed as extended-ASCII characters.  Each
      memory value is displayed as a single character.  The complete
      extended character set is used to display the text.

      ~3Byte~ (Menu-Only)
      Sets the display format to hexadecimal bytes.  The contents
      of memory are displayed as two digit hexadecimal values.

      ~3Word~ (Menu-Only)
      Sets the display format to hexadecimal words.  The contents
      of memory are displayed as four digit hexadecimal values.

      ~3Unsigned~ (Menu-Only)
      Sets the display format to unsigned integers.  The contents
      of memory are displayed as two-byte unsigned integers in the
      range of 0 to 65535.

      ~3Integer~ (Menu-Only)
      Sets the display format to signed integers.  The contents
      of memory are displayed as two-byte signed integers in the
      range of -32768 to 32767.

      ~3Long Integer~ (Menu-Only)
      Sets the display format to signed long integers.  The contents
      of memory are displayed as four byte signed integers in the
      range of -2147483648 to 2147483647.

      ~3Short Real~ (Menu-Only)
      Sets the display format to short real numbers.  The contents
      of memory are displayed as four byte single-precision real
      numbers.

      ~3Long Real~ (Menu-Only)
      Sets the display format to long real numbers.  The contents
      of memory are displayed as eight-byte double-precision real
      numbers.

      ~3Address~ (Menu-Only)
      Menu Only Sets the display format to addresses.  The contents
      of memory are displayed as addresses of the form selector:offset.

  ~1Watch Menu~ (RTD-Only)
  Commands in the Watch menu allow you to control memory watchpoints
  in your program.  When a watchpoint is set on a memory location, a
  change in the contents of that location will cause the program to
  stop near the point the value changed.  This feature allows you to
  catch memory modifications that may be incorrect.  Refer to Section
  6.2.13, The Watch Window, for more information about watchpoints
  and the Watch window.

    ~2Add Watch~ - Alt-W
    Sets a memory watchpoint on the selected memory location.  When
    the value of the location being watched changes, MultiScope will
    stop the execution of the program.  Refer to Section 6.2.13, The
    Watch Window, for more information.

    ~2Kill Watch~ - Alt-K
    Clears a watchpoint that is set on the selected memory location.
    This command reverses the effect of the Add Watch command on the
    location.

    ~2Clear All Watches~ (Menu-Only)
    Clears all watchpoints set in the program.

  ~1Convert Menu~
  The Convert menu contains commands for converting an input value
  from decimal to hexadecimal, and from hexadecimal to decimal.
  This comes in handy when you need to perform a quick conversion
  of a value.

    ~2Decimal => Hex~ - Alt-I
    Converts a decimal value to a hexadecimal value.  When this
    command is executed, you are prompted for a decimal value.
    The result of the conversion is displayed in a message box.

    ~2Hex => Decimal~ - Alt-H
    Converts a hexadecimal value to a decimal value.  When this
    command is executed, you are prompted for a hexadecimal value.
    The result of the conversion is displayed in a message box.

  ~1Others Menu~
  The Others menu contains commands for modifying data, specifying
  the memory address to display, and setting the memory address
  through an address in memory.

    ~2Modify~ - Alt-M (RTD only)
    Modifies the contents of the selected memory location. Select
    a location in the Memory window to modify, and execute this
    command.  MultiScope prompts you with an expression dialog box.

    ~2Address~ - Alt-A
    Displays the contents of memory at the specified address.
    MultiScope prompts you for an address.  In the dialog box,
    enter a hexadecimal address in the form xxxx:xxxx to specify
    a segment:offset pair.  If you wish to view another offset
    in the current selector being displayed, you may enter just
    the offset location.  The Memory window then displays the
    contents of memory at the new location.

    ~2Child~ - Alt-C
    Sets the Memory window display address to the location contained
    in the selected memory window location (the Memory window must
    be displaying memory in the Address format).  This command allows
    you to show the contents of memory that is being pointed to by an
    address in memory.


~~MModule Window~
  The Module window displays the names of the object modules that form
  your program.  The entries in the window are displayed in the order
  that the program was linked.  Several commands are provided in the
  Module window to allow you to view the source text or the global data
  of your program's modules.

  Each entry in the Module window contains ~1status information~ about the
  module.  This information occupies the left columns of each entry.

  For the Run-Time debugger, the first column contains the breakpoint
  indicator.  If a breakpoint has been set in the module, the first
  column will contain an asterisk (*).  If execution has stopped at
  a breakpoint in the module, the first column will contain a number
  sign (#).  See Section 6.2.2, The Breakpoint Window, for more
  information on breakpoints.

  The next column contains a letter indicating the default language
  of the module:

          A      Assembly
          C      C
          M      Modula-2
          P      Pascal

  The module language determines the manner in which the variables,
  values, and types in the Data window are displayed.

  Note: The default expression language is set to the language type
  of the first module in the list.  Refer to Chapter 7, Expression
  Evaluation, for more information.

  The next column contains the execution indicator.  If the program
  has executed into the module, the column contains a greater-than
  sign (>).

  For the Run-Time debugger, the next column contains the trace-enable
  indicator.  If tracing into the module is enabled, the column contains
  a plus sign (+).  The Trace Enable and Trace Disable commands are
  described in detail below.

  Module entries in the Module window are listed in the order that they
  were linked in the program.  If you are debugging dynamic-link libraries,
  the modules in the libraries are loaded at the top of the module list.

  The Module window in the Run-Time Debugger has four local menus:  Show,
  Language, Trace, and Others.  In the Post-Mortem Debugger, there is no
  Trace menu.

  ~1Show Menu~
  The Show menu contains commands for updating the Source and Data
  windows to show the source code and global data of the selected
  module.

    ~2Source~ - Alt-S
    Updates the Source window and shows the selected module's source
    code.  This command is used to view the source code of any module
    in the program.  See Section 6.2.11, The Source Window, for more
    information on the Source window.  If MultiScope cannot locate
    the source file, a dialog box prompts you for the filename.
    Enter the path of the source file.

    Note: If you have source files in different directories and want
    MultiScope to search those directories automatically, include the
    directories in the DPATH environment variable.

    ~2Data~ - Alt-D
    Updates the Data window and shows the global variables in the
    selected module.  This command is used to show the global data
    of any module in the program.  See Section 6.2.4, The Data Window,
    for more information on the Data Window.

    ~2Both~ - Alt-B
    Updates both the Source and Data windows.

    Note:  You can also ~3double-click~ on a module entry to execute
    this command.

  ~1Language Menu~
  The language of each module determines the manner in which the Data
  window displays data information for that module.  For example, if
  the language is C, the Data window displays data for the module with
  C type information.  For Pascal, the data is displayed with Pascal
  type information.

  MultiScope tries to determine each module's language from the debugging
  information in the program.  However, if MultiScope cannot find the
  information, it sets the language of the module to C.

  The commands in the Language menu allow you to override the language
  of the module.  This is useful, for example, if you wish to view the
  data of a Pascal module as if it were written in C.

  ~1Language menu~

    ~2Assembly~ - Alt-L
    Sets the language of the selected module to Assembly.

    ~2C~ - Alt-C
    Sets the language of the selected module to C.

    ~2Modula-2~ - Alt-M
    Sets the language of the selected module to Modula 2.

    ~2Pascal~ - Alt-P
    Sets the language of the selected module to Pascal.

  ~1Trace Menu~ - RTD Only
  Sometimes you may not want to trace into a particular module or set
  of modules.  The Trace menu contains commands that let you control
  whether or not you can step into, set breakpoints in, or watch data
  in a particular module.  By default, all of the modules in a program
  have tracing enabled.

  When you step through the program using the Go commands, MultiScope
  will not stop the program in modules that have tracing disabled.
  If you do not want to step into a particular module, you can disable
  tracing for that module.  Refer to Section 6.1.2, The Go Menu, for
  more information on the Go commands.

  Watchpoints are checked only in modules that have tracing enabled.
  If you know that a particular module does not affect your data, you
  can disable tracing for that module.  Refer to Section 6.2.13, The
  Watch Window, for more information on watchpoints.

    ~2Enable~ - Menu Only
    Enables tracing in the selected module.

    ~2Disable~ - Menu Only
    Disables tracing in the selected module.

    ~2Disable All~ - Menu Only
    Disables tracing in all program modules.

  Note: You can set the default tracing mode of a module by using the
  NOSTEP command in the MS.INI file.  Refer to Section 4.5, Initialization
  File Options, for more information.

  ~1Others Menu~
  The Others menu contains commands for finding a particular module in the
  Module window, and for displaying the code address of a module.

    ~2Find Module~ - Alt-F
    Searches for a module in the Module window.  When this command is
    executed, MultiScope prompts you for the name of the module to find.
    If the module is found, the module is selected.  Case is not important
    when specifying the module name.

    You can search for modules using the wildcards (* and ?).  These
    wildcards operate in the same manner as OS/2 file specification
    wildcards.  You can specify the search pattern once and execute
    the Find Module command with no input repeatedly until the desired
    module is found.

  ~1Address~ - Alt-A
  Displays the starting code address of the selected module.  When this
  command is executed, a message box is displayed containing the first
  executable address in the module.  The Assembly window display is
  updated to that location.  See Section 6.2.1, The Assembly Window,
  for more information on the assembly window.


~0Others Menu~

  The Others menu lets you control MultiScope's expression
  evaluation system, turn screen flipping on or off, set the
  output display time, and redraw a particular window or the
  entire MultiScope screen.

 ~1Evaluate Expression~ (Menu-Only)
  Prompts you to enter an expression and evaluates that
  expression when you press Enter.  After evaluating the
  expression, a message box displays the value returned by the
  expression.

 ~1Expr Language~ (Menu-Only)
  Lets you change the expression evaluation language
  to C, Modula-2, or Pascal.  MultiScope sets the default
  language to use for evaluating expressions automatically at
  startup.  A checkmark (4) appears next to the selected
  language.  You can override the selected language by choosing
  one of the language options on this menu.

  Refer to Chapter 7, Expression Evaluation, for more
  information.

  ~1Flip Screen On/Off (RTD Only)~
  Toggles screen flipping on and off when you execute your
  program.  If Flip Screen On/Off is off, MultiScope does
  not display your program's screen in the foreground as
  you step through your program.  This prevents the flashing
  of the screen.

  A checkmark appears next to the menu option when it is on.

  ~1Set Output Time (RTD Only)~ Menu-Only
  Sets the length of time the output window is visible
  when you execute the output window command.  Select this
  command and enter the new display output time length (in
  seconds).

  ~1Center on Position~ - Ctrl-P
  Resets the selected window to display the current line.
  Use this command if you have scrolled away from the
  selection and wish to return quickly.

  ~1Redraw all Windows~ - F5
  Redraws all the windows.  Some times unusual things can
  overwrite the window layout.  To return the screen to its
  original state, select Redraw all Windows.


~~OOutput Window~
  The Output window displays the output screen of the program you are
  debugging.  This is not a MultiScope window but rather an independent
  Text Mode screen or Presentation Manager window that contains the
  output of the program being debugged.  The Output screen exists in
  both the Run-Time and Post-Mortem debuggers.  In the Run-Time Debugger,
  the Output screen consists of your program's current output.  In the
  Post-Mortem Debugger, the Output screen consists of your program's
  output at the time of the crash.

  The Output screen may be viewed by executing the Output command in the
  global Windows menu.  You can set the length of time the Output screen
  is displayed by using the Set Output Time command in the global Others
  menu.  See Section 6.1.3, The Others Menu, for more information about
  this command.

  In the Run-Time debugger, the Flip Screen On/Off command also affects
  the output window.  When MultiScope executes your program, by default
  the output screen is brought to the foreground.  By using Flip Screen
  On/Off, you can control whether or not MultiScope displays the Output
  screen when it executes your program.  See Section 6.1.3, The Others
  Menu, for more information about this command.


~0Program Menu~

  The Program menu contains the commands for MultiScope's
  program-related operations, such as loading or restarting
  a program or exiting the debugger.

  ~1Restart/Load~ - F4
  Loads a program or restarts the current program.  If you
  started a debugging session without specifying a program
  to debug, the Restart/Load command prompts you for the
  name of the program.  If you have loaded and are debugging
  a program, executing the Restart/Load command restarts that
  program as if you exited MultiScope and started it from
  the beginning.

  ~1Quit and Save~ - Alt-Q
  Quits MultiScope after saving the window and options
  configuration.  You can set and change the various debugger
  options in the Setup menu described further in Section 6.1.5,
  The Setup Menu.

  ~1Exit - F3~
  Quits MultiScope and returns you to the OS/2 command line.
  This command provides the quickest way to exit from MultiScope.

  ~1About~ (Menu-Only)
  Displays important information about the MultiScope debuggers,
  including the version number and copyright information.


~~RRegister Window~
  The Register window displays the CPU register values of the current
  thread.  If a math coprocesssor is installed in the system, its register
  values are displayed as well.  Several commands are provided for changing
  the value of the registers, changing the display mode of the registers,
  and performing hexadecimal and decimal number conversions.

  The Register window displays the registers in either a horizontal or
  vertical orientation, in either hexadecimal or decimal.  You can select
  a specific register by clicking on it with the mouse, or using the
  keyboard arrow keys.

  The Register window has three local menus: Convert, Others, and View.
  The Post-Mortem Debugger does not have the Others menu.

  ~1View Menu~
  The View menu contains commands for changing the display mode of the
  registers between hexadecimal and decimal and changing the display
  orientation between horizontal and vertical.

    ~2Hex Mode~ - Alt-E
    Sets the register display mode to hexadecimal.  After this command
    is executed, the register values are displayed as hexadecimal words.

    ~2Decimal Mode~ Alt-D
    Sets the register display mode to decimal.  After this command is
    executed, the register values are displayed as unsigned integers.

    ~2Vertical/Horizontal~ - Alt-X
    Toggles the register orientation either vertically or horizontally.
    The orientation is saved in the configuration file when you execute
    the global Save Setup command.  See Section 6.1.5, The Setup Menu,
    for more information of the Save Setup command.

  ~1Convert Menu~

  The Convert menu contains commands for converting word value from
  decimal to hexadecimal and from hexadecimal to decimal.  This can
  come in handy when you need to perform a quick conversion of a value.

    ~2Decimal => Hex~ - Alt-I
    Converts a decimal value to a hexadecimal value.  Enter the decimal
    value in the dialog box.  The number's hexadecimal value is displayed
    in a message box.

    ~2Hex => Decimal~ - Alt-H
    Converts a hexadecimal value to decimal value.  When this command
    is executed, you are prompted for a hexadecimal value.  The result
    of the conversion is displayed in a message box.

  ~1Others Menu~ (RTD-Only)
  The Others menu contains a command for allowing you to modify the
  selected register.

    ~2Modify~ - Alt-M (RTD-Only)
    Modifies the contents of the selected register.  MultiScope prompts
    you with an expression dialog box.  Enter an expression.  The
    register is updated with the result of the expression.


~0Setting Window Colors~
  You can change a window's background or text colors with the Color
  Panel in the Presentation Manager or with the global Setup menu in
  the Text Mode.  This allows you to configure your screen with your
  own color settings.  Once the window and color settings are established,
  you can save them as the default settings, discard these settings
  completely, or save the settings for the current session.

  ~1Presentation Manager~

    ~2Mouse~      Select the Color Panel command in the global Setup menu.
               The Color Panel is displayed.

               The Color Panel list box displays all the places within
               MultiScope where you can set a color.  You can set these
               colors by selecting from the three color bars:  red, green,
               and blue.  For example, to set a window's foreground or
               background colors, you would

             * Select the item for the window's foreground or background
               color that you want to change the color of.

             * Use the color bars to set the window's colors.

               When you have finished setting the window colors, open the
               Exit menu at the top of the Color Panel.  The Exit menu has
               three choices:  Quit and Save, Quit and Discard, and Quit but
               Keep Colors.

               ~2Quit and Save~ closes the Color Panel and saves the
               changes you have made.  These color settings become
               MultiScope's default colors.

               ~2Quit and Discard~ closes the Color Panel and discards
               any changes you may have made to the color configuration.

               ~2Quit, but Keep Colors~ closes the Color Panel but retains
               the new color settings for the current MultiScope session.
               To save the color settings, select the Save Setup command
               from the Setup menu.  If you do not save the settings, the
               next time you start MultiScope the colors return to the
               default settings.

         Note: You can use the keyboard within the Color Panel to enter your
               settings.  Press the up-arrow or down-arrow key to select a
               window in the List Box.  Press the Tab key to cycle through
               the color bars, and then back to the List Box.  To select a
               color, press the left-arrow or right-arrow key to cycle
               through the shades until you come to the one you want.  Once
               the color is selected, press F3 to exit and save the
               configuration.

    ~2Keyboard~   Activate a window.  Press Ctrl-Keypad+ or Ctrl-Keypad- to
               cycle through the predefined color combinations to change a
               window's background color.

  ~1Text Mode~

    ~2Mouse~      Select the Next Color or the Previous Color command
               from the global Setup menu to change window, border, or
               menu colors.  With Next Color or Previous Color, the colors
               change, but the menu stays visible so that you can make
               another selection.  Press Esc or click outside the menu to
               exit.  To save the new color settings, select Save Setup
               from the Setup menu.

    ~2Keyboard~   Activate a window.  Press Ctrl-Keypad+ or Ctrl-Keypad-
               to cycle through the predefined color combinations for the
               window's background color.  To set the menu and border
               colors, press Shift-F10 to highlight the global menu bar.
               Then press S for Setup and use the arrow keys to select the
               appropriate command.  Press Enter to execute it.


~0Setup Menu~

  The Setup menu contains commands for configuring the different
  MultiScope windows and saving the new configuration.  For
  example, you can change the text and background colors, select
  a border color, or change the text's font size.

  ~1Small Font~ - Ctrl-1 (Presentation Manager-Only)
  Sets the active window's font size to 6 points.

  ~1Medium Font~ - Ctrl-2 (Presentation Manager-Only)
  Sets the active window's font size to 10 points.

  ~1Large Font~ - Ctrl-3 (Presentation Manager-Only)
  Sets the active window's font size to 12 points.

  ~1Color Panel~ - (Menu-Only, Presentation Manager-Only)
  Displays all the places within MultiScope where you can set
  a color.  You can set these colors by selecting from the
  three color bars:  red, green, and blue.  For example, to
  set a window's ~2foreground~ or ~2background~ colors, you
  would:

    Select the item for the window's foreground or background
    color that you want to change the color of.

    Use the color bars to set the window's colors.

    When you have finished setting the window colors, open the
    Exit menu at the top of the Color Panel.  The Exit menu has
    three choices:  Quit and Save, Quit and Discard, and Quit but
    Keep Colors.

  ~2Quit and Save~ closes the Color Panel and saves the changes
  you have made.  These color settings become MultiScope's
  default colors.

  The configuration file is saved in the current directory.  You
  can replace the configuration file in your MultiScope directory
  with the file you saved to make your changes permanent.

  ~2Quit and Discard~ closes the Color Panel and discards any
  changes you may have made to the color configuration.

  ~2Quit, but Keep Colors~ closes the Color Panel but retains
  the new color settings for the current MultiScope session.
  To save the color settings, select the Save Setup command
  from the Setup menu.  If you do not save the settings, the
  next time you start MultiScope the colors return to the
  default settings.

  ~1Next Window Color~ - Ctrl-Keypad +
  Cycles the active window through predefined color combinations.
  To change the color inside a window, select the window and
  press Ctrl-Keypad +.

  ~1Prev Window Color~ - Ctrl-Keypad -
  Cycles the active window through predefined color combinations
  in reverse direction of Next Window Color.  To change the color
  inside a window, select the window and press Ctrl-Keypad -.

  ~1Next Menu Color~ - Alt-L (Text Mode-Only)
  Cycles the active window's menus through predefined color
  combinations.

  ~1Prev Menu Color~ (Menu-Only, Text Mode-Only)
  ~1Next Border Color~ (Menu-Only, Text Mode-Only)
  ~1Prev Border Color~ (Menu-Only, Text Mode-Only)
  Cycles the active window's menus and borders through
  predefined color combinations.

  ~1Save Setup~ - Ctrl-V
  Saves the current screen configuration.  This command
  saves the changes you made to the window, menu, and
  border colors.  If you save the setup, MultiScope uses
  the same configuration in the next debugging session.


~~SSource Window~
  The Source window displays the source code of your program.  In this
  window you can view or change the current execution position, manipulate
  source-level breakpoints, and set the Assembly window view to a particular
  source line.

  If you want to view the source file of a particular module, use the Show
  Source command in the Module window.  Refer to Section 6.2.8, The Module
  Window, for more information about this command.

  The location of the selection line in the Source window also determines
  the current local scope for the evaluation of local variables in the
  expression evaluator.  Refer to Chapter 7, Expression Evaluation, for
  more information.

  Several different status messages can appear in the Source window.  If it
  cannot find the source file, it will display one of these messages:

      Text file not found

             or

      No text associated

  If you view the source position of the PROCESS entry in the Call window,
  the Source window will display this message:

      No text for a PROCESS

  In the Run-Time debugger, the first column contains the breakpoint
  indicator.  If a breakpoint has been set in the program, the first
  column will contain an asterisk (*).  If execution has stopped at
  a breakpoint in the program, the first column will contain a number
  sign (#).  See Section 6.2.2, The Breakpoint Window, for more
  information on breakpoints.

  The next column contains the execution indicator.  If the program
  has executed at a particular point in the source, this column
  contains a greater-than sign (>).

  The Source window has three local menus in the Run-Time Debugger:
  Find, Bpt, and Others.  In the Post-Mortem Debugger, there is no
  Bpt menu.

  ~1Find Menu~
  The Find menu contains a command for searching the current source
  file for a procedure, or setting the selection line to a specific
  line number.

    ~2Find Procedure/Line~ Alt-F
    Searches for a procedure or line number in the current source
    file.  To search for a procedure, enter its name in the dialog
    box.  If the procedure is found, the Source window selection is
    positioned at the beginning of the procedure.  This command is
    case sensitive.

    You can include ~3wildcards~ (* and ?) in the procedure name to
    search for more than one specific procedure.  These wildcards
    operate in the same manner as OS/2 file specification wildcards.
    Specify the search pattern once and execute the Find Procedure/Line
    command (with no input) repeatedly until the desired procedure is
    found.

    To search for a line, enter the ~3line number~ in the dialog box.
    The Source window display is updated and the selection bar is
    positioned at the specified line number.

  ~1Bpt Menu~ (RTD-Only)
  The Breakpoint Menu contains commands that allow you to set and
  clear breakpoints in the Source window.  Refer to Section 6.2.2,
  The Breakpoint Window, for complete details on the types of
  breakpoints that can be set.

    ~2Set Breakpoint~ Alt-S
    Sets a breakpoint at the selected line. To set a breakpoint, select
    line in the Source window to set the breakpoint on, and execute Set
    Breakpoint.

    If there is more than one source level statement on the line, you are
    first prompted to enter the number of the statement to set the
    breakpoint on.  Enter the statement number, such as 1 or 2.  If you
    do not enter a ~3statement number~, MultiScope will set the breakpoint
    on the first statement.

    You are then prompted with an expression dialog box.  When you enter
    the breakpoint expression, enter a boolean expression for a
    ~3conditional breakpoint~or press Enter to set an
    ~3unconditional breakpoint~.

    Note:  If you want to execute to a specific line in the Source window
           instead of using the Set Breakpoint command, you can
           ~3double-click~ on that line.

    ~2Clear Breakpoint~ - Alt-C
    Clears a breakpoint that has been set at the selected line.  If
    there is more than one statement on the line, you are prompted to
    enter the ~3statement number~ of the statement where the breakpoint
    is set.

    Enter the statement number, such as 1 or 2.  If you do not enter
    a statement number, MultiScope uses the first statement in the
    line.

    ~2Kill Breakpoint~ -  Alt-K
    Clears all breakpoints set in the program.

  ~1Others Menu~
  The Others menu contains commands for showing the assembly location
  of the selected line; for allowing you to change the execution location
  to another position; and for showing the definition module of a
  Modula-2 implementation module.

    ~2Statement Address~ - Alt-A
    Displays the ~3code address of the selected line~ and positions the
    selection line in the Assembly window to that location.  If there is
    more than one source level statement on the line, you are prompted to
    enter the number of the statement to view the address of.  Enter the
    ~3statement number~, such as 1 or 2.  If you do not enter a statement
    number, MultiScope uses the first statement on the line.

    ~2Jump to Line~ - Alt-J (RTD-Only)
    Changes the ~3execution location~ of the current thread to the address
    of the selected source line.  When you execute the program again, it
    resumes execution from the new location.

    To use this command, select the source line where you want execution to
    resume, and execute Jump To Line.

    If there is more than one source level statement on the line, you are
    prompted to enter the number of the statement you want the execution
    to resume at.  Enter the ~3statement number~, such as 1 or 2.  If you
    do not enter a statement number, MultiScope uses the first statement
    on the line.

    After this command is executed, the thread's code and instruction
    pointer registers are updated, and the Source window shows the new
    execution location.  This command simulates a jump instruction and
    allows you to skip portions of code you do not want to execute.

    ~2Exchange DEF/MOD~ - Alt-X
    Modula OS/2 Only Toggles the Source window display between corresponding
    definition and implementation modules.  This command allows you to view
    the source of the ~3definition module~ for a particular implementation
    module.


~0System Menu~

  The System menu contains commands that control MultiScope's
  window operations.  These commands let you restore icons to
  windows, move a window's border, exchange windows in Text
  Mode, maximize a window, or iconize a window.  With these
  commands you can organize the window layout of the debugger.
  Refer to Chapter 5 for more information on the user interface
  commands.

  ~1Restore~ - Alt-F5 (Presentation Manager-Only)
  Restores the active window to its previous state.  If the
  window has been iconized, Restore changes the icon back
  into the window.  If a window has been maximized, Restore
  returns the window to how it was before it was maximized.

  ~1Move~ - Alt-F7 (Presentation Manager-Only)
  Highlights the border of the active window and allows you
  to reposition the window.  After this command is executed,
  you may use the arrow keys or the mouse to move the window.
  Press Enter or click to anchor the window in its new position.

  ~1Size~ - Alt-F8 (Presentation Manager-Only)
  Highlights the border of the active window and lets you
  change the window's size.  After this command is executed,
  you may use the arrow keys or the mouse to stretch the
  borders of the active window.  Press Enter or click the
  left mouse button to anchor the window with its new size.

  This command is also executed by positioning the pointer
  over the window's border.  Then click and drag the border
  to its new location.


  ~1Minimize~ - Alt-F9
  Reduces the active window to an icon and places it at the
  bottom of the MultiScope screen.  This command lets you
  temporarily remove windows from the MultiScope screen while
  keeping the icon accessible.

  This command is also executed with the mouse by clicking
  on the Minimize icon in the upper left corner of the
  window to be minimized.


  ~1Maximize~ - Alt-F10
  Expands the active window to its maximum size on MultiScope's
  main screen.  This command lets you "zoom in" on a particular
  window without manually resizing the window.

  This command is also executed with the mouse by clicking on
  the Maximize icon in the upper left corner of the window
  to maximize.

  ~1Close~ - Alt-F4 (Presentation Manager-Only)
  Closes the MultiScope main window and exits the debugger,
  much like the Exit command in the Program menu (Refer to
  Section 6.1.4, The Program Menu.)  This command only exists
  for the MultiScope's main window; it has no effect in any
  of the other debugger windows.

  ~1Task Manager~ - Ctrl-Esc (Presentation Manager-Only)
  Selects the OS/2 Task Manager.  This command brings up
  the system task list, which allows you to choose another
  session or program to switch to.

  ~1Horizontal Expand~ - F7 (Text Mode-Only)
  Restores an icon horizontally into an open window.

  ~1Vertical Expand~ -  F8 (Text Mode-Only)
  Restores an icon vertically into an open window.

  ~1Exchange Windows~ - F6 (Text Mode-Only)
  Exchanges the contents of two Text Mode windows without
  affecting the size of either window.

  ~1Move Border~ - Alt-F8 (Text Mode-Only)
  Moves the border between two windows and reallocates the
  space shared by the windows.

  Refer to Chapter 5, Window, Menus, Dialog Boxes, for more
  information on the MultiScope user interfaces.


~~TThread Window~

  The Thread window displays the list of threads that have been created
  in your program.  Each thread entry displays the thread's id number,
  status, priority, stack location, and current execution location.
  Commands in the Thread window have been provided to update the context
  of the other windows to a particular thread and to control the execution
  of threads.

  You can use the Thread window to change the various MultiScope views
  to different threads, and to view or change the status of each thread.

  The information displayed in the Thread window is displayed in the
  following format:

    <thread #> <control & thread status> <prty> <SS:SP> <CS:IP>

    thread #       The thread's ID number


    ~1control status~
      This field displays the control status of the thread.  In the
      Run-Time debugger, you can control the threads execution by using
      the commands in the Action menu (described below).  They are
      displayed in the following manner:

      Frz    The thread has been "frozen", meaning that MultiScope has
             disabled the thread from executing.
      Thw    The thread has been "thawed", meaning that Multiscope has
             enabled the thread to execute.

    ~1thread status~
      This field displays the system status of the thread - its current
      state of execution.  Here is what this field displays:

      Blk    The thread's execution has been stopped by the system.  For
             example, it may be waiting on a semphore.
      Crs    The thread is executing in a critical section of code.  When
             a thread is executing in a critical section, no other threads
             can execute.
      Run    The thread is executable.
      Sus    The thread's execution has been suspended by MultiScope.
      prty   This field displays the thread's priority.
      SS:SP  This field displays the current stack location of the
             thread.
      CS:IP  This field displays the current execution location of the
             thread.

  The thread that was executing at the time the program stopped has a
  greater-than sign (>) in the left column of its entry in the Thread
  window.

  The Thread in the Run-Time Debugger window has two local menus:
  Show and Action.  In the Post-Mortem Debugger, there is no Action menu.

  ~1Show Menu~
  The Show menu contains commands to update the position and information
  displayed in the Source, Data, Call, and Register windows.  By using
  these commands, you can view the source-level execution position, the
  local data and call chain, and the current register values of the selected
  thread.

    ~2All~ - Alt-A
    Updates all of the related windows to the context of the selected
    thread.  When this command is executed, the Source, Data, Call, and
    Register windows are updated.

    Note:  You can also ~3double-click~ on a thread entry to execute this
           command.

    ~2Source~ - Alt-S
    Updates the Source, Call, and Register windows to the context of the
    selected thread.  This command is used primarily to display the source
    level location of the selected thread.

    ~2Data~ - Alt-D
    Updates the Data, Call, and Register windows to the context of the
    selected thread.  This command is used to view the data of the
    procedure the thread is executing in.

    ~2Call Chain~ - Alt-C
    Updates the Call and Register windows to the context of the selected
    thread.  This command lets you view the call chain of the selected
    thread.

  ~1Action Menu~ (RTD-Only)
  The Action menu contains commands for controlling the execution state of
  the threads in your program.  You freeze a thread to prevent it from
  executing, and you thaw a thread to let it resume execution.

    ~2Freeze~ - Alt-F
    Suspends the execution of the selected thread.  After this command is
    executed, the selected thread will not be scheduled for execution.

    Never suspend all of the threads in the program both MultiScope and
    your program stop when you try to execute a Go command.  Also,
    suspending the thread of a Presentation Manager application that
    contains the window message dispatch loop can hang the entire system.

    ~2Thaw~ - Alt-T
    Resumes the execution of the selected thread.  After this command
    is executed, the selected thread is scheduled for execution.

    Note:  All threads in a process are stopped when MultiScope has
           control, and all runnable threads are scheduled for execution
           the next time you run your program.


~~WWatch Window~ (RTD-Only)
  Watchpoints are used to determine the approximate point at which a
  value or a value in a range in memory changes.  A watchpoint defines
  a range in memory, and causes MultiScope to stop the program if any
  value in the memory range changes.  Watchpoints can be set on variables
  in the Data window, or on memory locations in the Memory window.  The
  Watchpoint window displays a list of all the watchpoints set in the
  program.  You can view the memory locations of watchpoints, selectively
  clear watchpoints, and change the granularity level of the watchpoint
  checks.  This window is not used to set watchpoints; when a watchpoint
  is set in either the Data window or Memory window, the status of the
  watchpoint is displayed here.

  If no watchpoints are set in the program, the Watchpoint window displays
  this message:

    No watchpoints defined

  When watchpoints have been set on data in the program, the Watchpoint
  window displays this information:

    <name> [address range] <byte1> <byte2> <byte3> ...

  ~1name~          If the watchpoint has been set on a variable in the Data
                  window, this field contains the name of the variable.
                  For Memory window watchpoints, it contains the string
                  (memory).
  ~1address range~   This is the range of memory that is being watched.


  ~1byte1...~        The successive bytes being watched in the memory range.

  When the program stops because of a watchpoint, a ~1number sign (#)~
  appears in the left column of the line containing the watchpoint that
  was triggered.

  Watchpoints are not checked in modules where Trace mode is disabled.
  Refer to Section 6.2.8, The Module Window, for information on the Module
  Trace commands.

  The Watchpoint window has three local menus: Commands, Granularity, and
  Show.

  ~1Show Menu~
  The Show menu contains a command for updating the memory window to the
  starting address of the watchpoint range.

    ~2Address~ - Alt-A
    Displays the starting address of the watchpoint range and updates
    the Memory window to display the memory at that address.

  ~1Commands Menu~
  The Commands menu contains commands that allow you to selectively clear
  watchpoints or clear all of the watchpoints set in the program.

    ~2Clear Watchpoint~ - Alt-C
    Clears the selected watchpoint.

    ~2Kill all Watchpoints~ - Alt-K
    Clears all watchpoints set in the program.

  ~1Granularity Menu~
  Watchpoints:granularity;Watchpoints can be checked at three different
  intervals:  every procedure call, source-level statement, or assembly
  instruction.  The commands in the Granularity menu allow you to set the
  ~2frequency of the watchpoint~ checks.

  The watchpoint checks can significantly slow down the execution of your
  program.  We recommend that you set the checking granularity to Procedure
  first, then, if necessary, refine your search with Statement and Trace
  granularity.

    ~2Trace~ (Menu-Only)
    With trace granularity, your program executes very slowly, but provides
    you with almost the exact assembly-level location where the value was
    changed.  After each assembly instruction, the value is checked.  If
    the value is changed, execution will stop at the beginning of the next
    assembly instruction following the instruction that changed the value.

    ~2Statement~ (Menu-Only)
    With statement granularity, your program executes fairly slowly, but
    will provide you with a much better idea of where the value changed.
    After each high-level statement, the value of all defined watchpoints
    are checked.  If any value has changed since the last check, execution
    will stop at the beginning of the next high-level statement following
    the statement that changed the value.

    ~2Procedure~ (Menu-Only)
    With procedure granularity (the default), your program executes
    quickly but only gives you a rough idea of where the value changed.
    In procedure granularity, the values of all defined watchpoints are
    checked at the entry and exit point of each procedure call.  If the
    value is changed, execution stops either at the return point of the
    procedure where it changed or at the entry point of the next procedure
    called after the value was changed.

    In most cases, procedure granularity is sufficient to give you an
    idea of where the variable or memory range was changed.

    Note:  When using procedure granularity, you can check the call
           chain in the Call window to see what the previous call was.


~0Windows Menu~
  The Windows menu contains commands for activating a specific
  window in the debugger.  Once a window has become active,
  you can execute the local commands of that window.

  You can also activate a window with by using a global
  accelerator key or by clicking the mouse inside the window.
  The global accelerator key table is shown below.  The Next
  command lets you cycle through all the windows.

