You can enter debugger commands interactively at the keyboard or
    store them within a command procedure to be executed later with
    the @ (Execute Procedure) command.

1  –  General Rules

    A command string is the complete specification of a debugger
    command. Although you can continue a command on more than one
    line, the term command string is used to define an entire command
    that is passed to the debugger.

    A debugger command string consists of a verb and, possibly,
    parameters and qualifiers.

    The verb specifies the command to be executed. Some debugger
    command strings might consist of only a verb or a verb pair. For
    example:

    DBG> GO
    DBG> SHOW IMAGE

    A parameter specifies what the verb acts on (for example, a file
    specification). A qualifier describes or modifies the action
    taken by the verb. Some command strings might include one or more
    parameters or qualifiers. In the following examples, COUNT, I,
    J, and K, OUT2, and PROG4.COM are parameters (@ is the "execute
    procedure" command); /SCROLL and /OUTPUT are qualifiers.

    DBG> SET WATCH COUNT
    DBG> EXAMINE I,J,K
    DBG> SELECT/SCROLL/OUTPUT OUT2
    DBG> @PROG4.COM

    Some commands accept optional WHEN or DO clauses. DO clauses are
    also used in some screen display definitions.

    A WHEN clause consists of the keyword WHEN followed by a
    conditional expression (within parentheses) that evaluates to
    true or false in the current language. A DO clause consists
    of the keyword DO followed by one or more command strings
    (within parentheses) that are to be executed in the order that
    they are listed. You must separate multiple command strings
    with semicolons (;).  These points are illustrated in the next
    example.

    The following command string sets a breakpoint on routine SWAP.
    The breakpoint is triggered whenever the value of J equals 4
    during execution. When the breakpoint is triggered, the debugger
    executes the two commands SHOW CALLS and EXAMINE I,K, in the
    order indicated.

    DBG> SET BREAK SWAP WHEN (J = 4) DO (SHOW CALLS; EXAMINE I,K)

    The debugger checks the syntax of the commands in a DO clause
    when it executes the DO clause. You can nest commands within DO
    clauses.

2  –  Interactive Input Rules

    When entering a debugger command interactively at the keyboard,
    you can abbreviate a keyword (verb, qualifier, parameter) to as
    few characters as are needed to make it unique within the set of
    all debugger keywords. However, some commonly used commands (for
    example, EXAMINE, DEPOSIT, GO, STEP) can be abbreviated to their
    first characters. Also, in some cases, the debugger interprets
    nonunique abbreviations correctly on the basis of context.

    Pressing the Return key terminates the current line, causing
    the debugger to process it. To continue a long command string
    on another line, type a hyphen (-)  before pressing Return. As
    a result, the debugger prompt is prefixed with an underscore
    character (_DBG>), indicating that the command string is still
    being accepted.

    You can enter more than one command string on one line by
    separating command strings with semicolons (;).

    To enter a comment (explanatory text recorded in a debugger log
    file but otherwise ignored by the debugger), precede the comment
    text with an exclamation point (!).  If the comment wraps to
    another line, start that line with an exclamation point.

    The command line editing functions that are available at the
    DCL prompt ($) are also available at the debugger prompt (DBG>),
    including command recall with the up arrow and down arrow keys.
    For example, pressing the left arrow and right arrow keys moves
    the cursor one character to the left and right, respectively;
    pressing Ctrl/H or Ctrl/E moves the cursor to the start or
    end of the line, respectively; pressing Ctrl/U deletes all the
    characters to the left of the cursor, and so on.

    To interrupt a command that is being processed by the debugger,
    press Ctrl/C. See the Ctrl/C command.

3  –  Command Procedure Rules

    To maximize legibility, it is best not to abbreviate command
    keywords in a command procedure. Do not abbreviate command
    keywords to less than four significant characters (not counting
    the negation /NO . . . ), to avoid potential conflicts in future
    releases.

    Start a debugger command line at the left margin. (Do not start a
    command line with a dollar sign ($)  as you do when writing a DCL
    command procedure).

    The beginning of a new line ends the previous command line (the
    end-of-file character also ends the previous command line). To
    continue a command string on another line, type a hyphen (-)
    before starting the new line.

    You can enter more than one command string on one line by
    separating command strings with semicolons (;).

    To enter a comment (explanatory text that does not affect the
    execution of the command procedure), precede the comment text
    with an exclamation point (!).  If the comment wraps to another
    line, start that line with an exclamation point.