SUMMARY - summary of BOFF commands.

Syntax:

[ARGUMENT][,COUNT] [COMMAND]

:b  (Set Breakpoint)
    :bf    (Function Breakpoint)
    :br    (Return Breakpoint)
    :bt    (Temporary Breakpoint)
    :bq    (Quiet Breakpoint)
    :bd    (Delete Breakpoint)
    :bda   (Delete All Breakpoints)
    :b {COMMANDS}
:c  (Co-routine)
:d  (Move Down Stack)
:f WORD,MASK    (Find WORD in memory)
    :fa WORD,MASK    (Find all WORDS in memory)
:k VALUE    (Checksum)
:n NAME     (Assign NAME to Memory Location)
:o  (Set default Offset)
:p  (Proceed with execution)
    :p EXPRESSION    (Conditional :p)
:q  (Quit Normally)
:qq (Quit Immediately)
:r FILE    (Restore memory image)
:s FILE    (Save memory image)
:t  (Traceback)
:u  (Move Up Stack)
:va (View Autos)
:vb (View Breakpoints)
:vc (View Co-routine)
:ve (View Externals)
:vm (View Modes)
:vu (View User variables)
:x  (EXamine registers)
=EXPRESSION    (Patch)
\[DESIGNATOR][FORMAT]    (Display memory)
    a   (ASCII)
    b   (BCD)
    c   (ASCII character constant)
    d   (Decimal)
    e   (Double Precision)
    f   (Single Precision)
    h   (Hexadecimal Bytes)
    i   (Instruction)
    l   (Address mode)
    o   (Octal)
    s   (String)
    u   (Unsigned integer)
    x   (HeXadecimal Words)
    +   (Increment effective address)
    -   (Decrement effective address)
    m   (Take address from top 18 bits)
    p   (Take address from bottom 18 bits)
    r   (Reset)
    .   (Line Break)
"[DESIGNATOR][FORMAT]    (Display memory)
<cr>    (Carriage Return)
^       (Caret)
A!B     (Display offset B from A)

Where:

ARGUMENT and COUNT are expressions. Assignment operators (= += &= etc.) and logical operators (&& || etc.) are not allowed in these expressions. COMMAND is one of the following commands.

:b (Set Breakpoint)

sets a breakpoint at the location given by ARGUMENT. If COUNT is non-zero, the break will not be triggered until COUNT executions of the breakpoint have been made. Breakpoints may also be set with:

:bf (Function Breakpoint)

when break occurs, BOFF will print the current function name and its arguments

:br (Return Breakpoint)

sets a breakpoint at the point where the current function returns to its caller

:bt (Temporary Breakpoint)

the breakpoint is deleted the first time it is encountered

:bq (Quiet Breakpoint)

the break occurs, but the standard breakpoint header is not printed

:bd (Delete Breakpoint)

deletes the breakpoint at location ARGUMENT

:bda (Delete All Breakpoints)

deletes all breakpoints currently set in the program

:b {COMMANDS}

can be used with any command which sets a breakpoint. The COMMANDS argument is a list of one or more BOFF commands which will be executed whenever the breakpoint is encountered. The brace brackets may be omitted.

The breakpoint options described above can be combined, as in ":btr" or ":brt".

:c (Co-routine)

sets current co-routine to ARGUMENT.

:d (Move Down Stack)

moves down the stack (to a parent of the current function); ARGUMENT specifies how many levels to move. The default is one level.

:f WORD,MASK (Find WORD in memory)

finds the next location in memory whose contents are equal to WORD in the bit positions where MASK is zero. ARGUMENT specifies the memory location where the search should begin. Display formats may be specified with the command if desired. ":f" sets the current word to the word that is found in the search.

:fa WORD,MASK (Find all WORDS in memory)

is the same as ":f", except that it finds ALL memory locations that match WORD under the given MASK.

:k VALUE (Checksum)

calculates a checksum beginning at the location given by ARGUMENT and going COUNT words. If VALUE is 0, the checksum will not add in the last carry. If VALUE is 1, the checksum will include the last carry. If VALUE is 2, the checksum will add in the carry after adding the last carry.

:n NAME (Assign NAME to Memory Location)

associates the given NAME with the memory location given by ARGUMENT. NAME may then be used like an external variable. This is useful in situations where symbol tables are not available in the program being examined. A maximum of 20 such names may be defined. Old names may be redefined with a new ":n" command.

:o (Set default Offset)

sets the default offset to the value of ARGUMENT. ALL future addresses will be calculated relative to this offset. This command is only available in Patch mode. If no ARGUMENT is specified, ":o" will give the current offset value in words and llinks.

:p (Proceed with execution)

continues execution after a breakpoint. This is helpful when setting a breakpoint with ":b {COMMANDS}". If ":p" is the last command in {COMMANDS}, BOFF will continue program execution after the {COMMANDS} have been executed. You may not specify an ARGUMENT for a ":p" command.

:p EXPRESSION (Conditional :p)

is similar to ":p", but only resumes execution if the given EXPRESSION is non-zero.

:q (Quit Normally)

quits a BOFF session normally. "exit" is called and output buffers are flushed.

:qq (Quit Immediately)

quits immediately. "exit" is not called and buffers are not flushed.

:r FILE (Restore memory image)

restores a BOFF memory image that was saved in FILE.

:s FILE (Save memory image)

saves a BOFF memory image in FILE.

:t (Traceback)

prints out a traceback. If ARGUMENT is present, BOFF only prints ARGUMENT levels.

:u (Move Up Stack)

moves up the stack (to a child of the current function); ARGUMENT specifies how many levels to move. The default is one level.

:va (View Autos)

displays names of auto variables in current function

:vb (View Breakpoints)

displays locations and types of breakpoints currently set

:vc (View Co-routine)

displays the current co-routine header

:vd (View Externals)

displays all external names

:vf (View formats)

displays print formats; '*' marks current format

:vu (View User variables)

displays all user-defined BOFF variables

:x (EXamine registers)

display the values of all hardware registers in a program

=EXPRESSION (Patch)

assigns the value of EXPRESSION to the memory location given by ARGUMENT

\[DESIGNATOR][FORMAT] (Display memory)

displays memory locations in one or more display formats.

DESIGNATOR is an optional argument whose value can be 0, 1, 2, 3, or 4. It indicates a display format register whose value indicates that format(s) that should be used in displaying the memory. The default is register 0.

FORMAT is an optional string of characters indicating how the memory should be displayed. Possible formats are:

a (ASCII)

machine words are displayed as four ASCII characters. Unprintable characters are shown as a tilde (~).

b (BCD)

machine words are interpreted as strings of BCD characters.

c (ASCII character constant)

a machine word is displayed as an ASCII character constant. This differs from "a" above in two ways: first, the "c" format encloses the characters in single quotes, while the "a" format does not; second, the "c" format skips leading zero bytes. Therefore "*0*0*0a" is printed as 'a' in "c" format, but as ~~~a in "a" format.

d (Decimal)

machine words are printed as decimal integers

e (Double Precision)

a pair of machine words is interpreted as a double precision floating point number

f (Single Precision)

a single machine word is interpreted as a single precision floating point number

h (Hexadecimal Bytes)

machine words are printed byte by byte in hexadecimal

i (Instruction)

machine words are printed as the corresponding GMAP instructions

l (Address mode)

machine word is interpreted as the address of a memory location, and displayed in terms of offset from nearest external symbol. Line number of location is also printed.

o (Octal)

machine words are printed as octal integers

s (String)

bottom 18 bits of location are interpreted as pointer to a string. The string is printed, up to the first NUL ('*0' in B, '\0' in C).

u (Unsigned Integer)

machine words are printed as unsigned decimal integers

x (HeXadecimal Words)

machine words are printed as hexadecimal integers (whole word, not byte by byte)

. (Line Break)

breaks output to new line

FORMAT can also contain characters which dictate which memory location is to be displayed next:

+ (Increment effective address)

increments effective address by 1.

- (Decrement effective address)

decrements effective address by 1.

m (Take address from top 18 bits)

new effective address will be taken from top 18 bits of current address.

p (Take address from bottom 18 bits)

new effective address will be taken from bottom 18 bits of current address.

r (Reset)

resets the effective address to the current word

If a FORMAT is not given, the default is to use the FORMAT from the most recent display command. If a FORMAT is given, it is stored in the format register indicated by DESIGNATOR before the memory locations are displayed.

ARGUMENT indicates a memory location to be displayed. If ARGUMENT is an Lvalue, the contents of ARGUMENT are displayed. If ARGUMENT is an Rvalue, ARGUMENT itself is displayed.

If a COUNT is specified, the display command is repeated COUNT times; in this case, ARGUMENT must be an Lvalue.

At the end of a display command, the "future word" is set to the last effective address. If this location is the same as the current word, the future word is incremented by one to point to the word after the current word.

If a display command is repeated by using a COUNT, the current word is set to the future word before the next display takes place. In this way, a new word is displayed on each repetition. If COUNT is negative, the display command will begin the displaying process that many words before ARGUMENT.

"[DESIGNATOR][FORMAT] (Display memory)

is the same as \[DESIGNATOR][FORMAT]. The double quote (") form is intended for terminals that do not have a backslash (\) key.

<cr> (Carriage Return)

this command consists of an optional ARGUMENT and COUNT followed immediately by a carriage return. The current word is set to the future word, then the new current word is displayed in whatever display formats were used most recently.

^ (Caret)

displays the word immediately preceding the current word, in whatever display formats were used most recently.

A!B (Display offset B from A)

is equivalent to (&A)[B]. For example, "main!20" refers to the 20th word after "main".

Predefined BOFF Variables:

/ic: instruction counter
/i: indicator register
/a: A register
/q: Q register
/e: exponent register
/x0 - /x7: index registers
/ar0 - /ar7: address registers
/sp: working stack pointer
/cp: working co-routine pointer
/wr: B write unit
/rd: B read unit
/: the address of the future word
/.: the address of the current word
/..: the address of the past word (old value of /.)
/...: the address of the past-past word (old value of /..)
/_: the value of the most recently evaluated expression
/__: the value of the second most recently evaluated expression
ic: the value of the word to which the instruction pointer points
.: the value of the current word
..: the value of the past word
...: the value of the past-past word

Notes:

If BOFF intends to use the bottom 18 bits of a word as a pointer but those bits are all zero, BOFF will use the top 18 bits instead. This applies to display formats like "\p", "\s", and so on.