                       *** Source-Level Commands ***

command (menu)              Description
--------------              ----------------------------------------------
<F1> or <PageUp>            Scrolls source up one page.

<F2> or <PageDown>          Scrolls source down one page.

<F3>                        Sets a temporary breakpoint at the current
(Run/Go to Cursor Line)     cursor line and continues execution of your
                            program.

<F4>                        Sets or removes a breakpoint at the source
(Breakpoints/Toggle at      line containing the cursor.
Cursor Line)

<F5> or <Up Arrow>          Moves the source cursor up one line.

<F6> or <Down Arrow>        Moves the source cursor down one line.

<F7>                        Causes the cursor line to be searched for
                            program variables.  If one is found, its name
                            and current contents are displayed.

<tab>                       Search the current line for selectable text.
                            If selectable text is found, select it.

@!                          Moves the current program location to the line
(Run/Skip to Cursor Line)   containing the cursor.

F                           Repeats the last Find command, starting at the
(Source/Repeat Find)        current cursor line.

FB pat                      Locates pat in the program's source code. The
(Source/Find Backwards)     debugger searches backwards from the current
                            cursor line.

FF pat                      Locates pat in the program's source code. The
(Source/Find Forward)       debugger searches forward from the current
                            cursor line.

FT pat                      Locates pat in the program's source code. The
(Source/Find from Top)      search starts at the top of the current
                            program source.

VP                          Lists all of the nested paragraphs leading up
(View/Perform Stack)        to the current statement, starting from the
                            beginning of the program.

W procedure                 Positions the cursor at the procedure you name.
(Source/Paragraph)          The procedure must be located in the current
                            program.

W@                          Positions the cursor at the current line in
(Source/Current Line)       your program.

WB                          Positions the cursor at the last line
(Source/Last Line)          (bottom) in your program.

WT                          Positions the cursor at the first line (top)
(Source/Line 1)             of your program.

                       *** Other Commands ***

!                           Invokes the operating system's command
(File/Shell)                processor, allowing you to enter commands.

<script-file                Causes the runtime to take all input (debugger
(File/Run Script)           and program) from script-file.

>                           Ends your recording.  If you don't end your
(File/Stop Recorder)        recording, nothing is saved in the file.

>script-file                Turns on a recorder that saves all of your
(File/Record Script)        keyboard input and menu selections to a file
                            of your choice.

A variable                  Lets you modify the contents of a variable.
(Data/Accept)

B                           Displays a dialog box with all existing
(View/Breakpoints)          breakpoints.  You can add and modify
(Breakpoints/View)          breakpoints from this dialog box.

B address, [skip#]          Set a breakpoint with a skip count.  The
(Breakpoints/Set)           breakpoint will not be activated until it
                            has been hit skip# times.

B address, [SKIP #] [WHEN cond] Set a breakpoint with a skip count and/or
(Breakpoints/Set)           condition.  The breakpoint will not be
                            activated unless cond is true # times.

C address                   Removes a breakpoint.  You can enter either
(Breakpoints/Clear)         the breakpoint's paragraph name or hexadecimal
                            address.

CA                          Removes all breakpoints.
(Breakpoints/Clear All)

CM number                   Clears variable monitor number.
(Data/Monitor/Clear)

CMA                         Clears all variable monitors.
(Data/Monitor/Clear All)

D variable [, X]            Shows the contents of a variable.  The value
(Data/Display)              is shown in the debugger command window.  If
                            X is appended to the display command, the
                            variable is displayed in hexadecimal.

E                           Turns off the debugger while continuing the
(File/Exit Debugger)        execution of your program.

G                           Resumes execution of your program from its
(Run/Continue)              current location.

G address                   Sets a temporary breakpoint at address, and
                            continues execution

GE                          Runs your program until the current program
(Run/Go until               exits to its calling program.
Program Exits)

GP                          Runs your program until the current paragraph
(Run/Go until               returns to the point from which it was
Paragraph Returns)          performed.

H                           Displays this screen.

L                           Displays the name of source paragraph or
                            section which is being executed.

M                           Shows all monitored variables and their values.
(View/Monitors)             This also displays a sequence number for each
(Data/Monitor/List)         monitor, which is used to clear the monitor.

M variable                  Causes the program to stop whenever the named
(Data/Monitor/Set)          variable changes its value.  The variable is
                            shown in the watch window.

P [#]                       Steps over the next statement.  With a count,
                            the program will step count times.

Q!                          Halts your application and exits the debugger.
(File/Quit)

R script                    Read debugging commands from script.

RA [#]                      Toggles or sets the "Run All Threads" setting.
(Run/Run all Threads)       If # is 0, only the current thread will run.
                            If # is non-0, all threads will run.

S [#]                       Execute one statement of your program and then
(Step Into)                 return control to the debugger. You may follow
                            the command with the number of steps to take.

SA                          Causes your program to execute "step" commands
(Run/Auto Step)             repeatedly until it reaches the end of the

                            program, or until you stop the auto-step by
                            pressing <SPACE> while the debugger is active.

ST [#]                      Switches to the thread identified by the given
(Run/thread)                number (or the next thread, if no number is
                            given).  Numbers correspond to the threads as
                            listed under the "Run" menu item.

T flush                     Causes the error file to be flushed to disk
                            after each write, if you are writing to an
                            error file.

TF [#]                      Turns on file tracing.  The # indicates the
(File/Trace Files)          level of tracing, from 1 to 9, where 1 is the
                            lowest and 9 is the highest.

TP                          Toggles paragraph tracing, which is a listing
(File/Trace Paragraphs)     of all paragraphs and sections entered at
                            runtime.

U                           Displays the amount of dynamically allocated
(View/Memory Usage)         memory currently used by the runtime system.

V                           Displays your application's current screen.
(View/Screen)               Press any key or click the left mouse button
                            to return to the debugger.

WA                          Place a variable in the watch window.  The
(Data/Monitor/Set)          difference between a watched variable and a
                            monitored variable is that watched variables
                            don't cause program execution to halt when
                            they change.

WS number                   Specify the number of lines to show in the
(Source/Window Size)        command window.

WW number                   Specify the number of lines to display in the
(Source/Watch Size)         Watch Window.

<F8>                        Edit Command causes the last command entered
                            to be recalled for editing.

<ctrl-n>                    Show the next line in the watch window.

<ctrl-p>                    Show the previous line in the watch window.
