Alternate stack results shown with space, e.g. ( input -- addr len false | result true )

Alternate stack items shown without space, e.g. ( input -- addr len | 0 result ).

Unknown stack item(s).

Unknown stack item(s). If used on both sides of a stack comment, means the same stack items are present on both sides.

Space delimiter. Leading spaces are ignored.

Variable-aligned address.

Memory address (generally a virtual address).

Address and length for memory region

8-bit value (low order byte in a 32-bit word).

7-bit value (low order byte), high bit unspecified.

cnt len size

Count or length.

dxxx

Double (extended-precision) numbers. 2 stack items, most significant cell on top of stack.

<eol>

End-of-line delimiter.

false

0 (false flag).

ihandle

Pointer for an instance of a package.

n n1 n2 n3

Normal signed values (32-bit).

nu nu1

Signed or unsigned values (32-bit).

<nothing>

Zero stack items.

phandle

Pointer for a package.

phys

Physical address (actual hardware address).

phys.lo phys.hi

Lower/upper cell of physical address

pstr

Packed string.

quad qxxx

Quadlet (32-bit value).

qaddr

Quadlet (32-bit) aligned address

{text}

Optional text. Causes default behavior if omitted.

"text<delim>"

Input buffer text, parsed when command is executed. Text delimiter is enclosed in <>.

[text<delim>]

Text immediately following on the same line as the command, parsed immediately. Text delimiter is enclosed in <>.

true

-1 (true flag).

uxxx

Unsigned value, positive values (32-bit).

virt

Virtual address (address used by software).

waddr

Doublet (16-bit) aligned address

word wxxx

Doublet (16-bit value, low order two bytes in a 32-bit word).

x x1

Arbitrary stack item.

x.lo x.hi

Low/high significant bits of a data item

xt

Execution token.

xxx?

Flag. Name indicates usage (e.g. done? ok? error? ).

xyz-str xyz-len

Address and length for unpacked string.

xyz-sys

Control-flow stack items, implementation-dependent.

( C: -- )

Compilation stack diagram.

( -- ) ( E: -- )

Execution stack diagram.

( R: -- )

Return stack diagram.

Display the names and values of the current node's properties.

Choose the specified device node, making it the current node.

Search for a node with the specified name in the subtree below the current node, and choose the first such node found.

Choose the device node that is the parent of the current node.

Choose the root machine node.

Leave the device tree.

Choose the specified device node, similar to dev .

Display the names of the current node's children.

Display the device path name that names the current node.

Decompile the specified word.

Display all the devices known to the system directly beneath a given device in the device hierarchy. show-devs used by itself shows the entire device tree.

Display the names of the current node's methods.

Select the specified device and make it the active node.

The name (full path name or alias) of the boot device. Typical values include:

cdrom (CD-PROM drive)

disk (hard disk)

floppy (3-1/2" diskette drive)

net (Ethernet)

tape (SCSI tape)

The name of the program to be booted (for example, stand/diag ). filename is relative to the root of the selected device and partition (if specified). If filename is not specified, the boot program uses the value of the boot-file NVRAM parameter (see Chapter 3).

(These options are specific to the operating system, and may differ from system to system.)

Display power-on banner.

Display list of installed and probed SBus devices.

Display current Ethernet address.

Display ID PROM contents, formatted.

Display a list of SPARC trap types.

Display version and date of the boot PROM.

Display CPU and bus speeds.

Display all installed and probed devices.

Display all current parameters and current default values.

(Numbers are usually shown as decimal values.)

printenv parameter shows the current value of the named parameter.

Set parameter to the specified decimal or text value.

(Changes are permanent, but usually only take effect after a reset.)

Reset the value of the named parameter to the factory default.

Reset parameter values to the factory defaults.

Set security-password.

Store the command " devalias alias device-path " in NVRAMRC. The alias persists until the nvunalias or set-defaults commands are executed.

Enter the NVRAMRC editor. If data remains in the temporary buffer from a previous nvedit session, resume editing those previous contents. If not, read the contents of NVRAMRC into the temporary buffer and begin editing it.

Discard the contents of the temporary buffer, without writing it to NVRAMRC. Prompt for confirmation.

Recover the contents of NVRAMRC if they have been lost as a result of the execution of set-defaults ; then enter the editor as with nvedit . nvrecover fails if nvedit is executed between the time that the NVRAMRC contents were lost and the time that nvrecover is executed.

Execute the contents of the temporary buffer.

Copy the contents of the temporary buffer to NVRAMRC; discard the contents of the temporary buffer.

Delete the corresponding alias from NVRAMRC.

Control-B

Moves backward one character.

Escape B

Moves backward one word.

Control-F

Moves forward one character.

Escape F

Moves forward one word.

Control-A

Moves backward to beginning of the line.

Control-E

Moves forward to end of the line.

Control-N

Moves to the next line of the script editing buffer.

Control-P

Moves to the previous line of the script editing buffer.

Return (Enter)

Inserts a newline at the cursor position and advances to the next line.

Control-O

Inserts a newline at the cursor position and stays on the current line.

Control-K

Erases from the cursor position to the end of the line, storing the erased characters in a save buffer. If at the end of a line, joins the next line to the current line (i.e. deletes the newline).

Delete

Erases the previous character.

Backspace

Erases the previous character.

Control-H

Erases the previous character.

Escape H

Erases from beginning of word to just before the cursor, storing erased characters in a save buffer.

Control-W

Erases from beginning of word to just before the cursor, storing erased characters in a save buffer.

Control-D

Erases the next character.

Escape D

Erases from the cursor to the end of the word, storing the erased characters in a save buffer.

Control-U

Erases the entire line, storing the erased characters in a save buffer.

Control-Y

Inserts the contents of the save buffer before the cursor.

Control-Q

Quotes the next character (i.e. allows you to insert control characters).

Control-R

Retypes the line.

Control-L

Displays the entire contents of the editing buffer.

Control-C

Exits the script editor, returning to the OpenBoot command interpreter. The temporary buffer is preserved, but is not written back to the script. (Use nvstore afterwards to write it back.)

clear

( ??? -- )

Empty the stack.

depth

( -- u )

Return the number of items on the stack.

drop

( x -- )

Remove top item from the stack.

2drop

( x1 x2 -- )

Remove 2 items from the stack.

3drop

( x1 x2 x3 -- )

Remove 3 items from the stack.

dup

( x -- x x )

Duplicate the top stack item.

2dup

( x1 x2 -- x1 x2 x1 x2 )

Duplicate 2 stack items.

3dup

( x1 x2 x3 -- x1 x2 x3 x1 x2 x3 )

Duplicate 3 stack items.

?dup

( x -- x x | 0 )

Duplicate the top stack item if it is non-zero.

nip

( x1 x2 -- x2 )

Discard the second stack item.

over

( x1 x2 -- x1 x2 x1 )

Copy second stack item to top of stack.

2over

( x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2 )

Copy second 2 stack items.

pick

( xu ... x1 x0 u -- xu ... x1 x0 xu )

Copy u -th stack item ( 1 pick = over ).

>r

( x -- ) (R: -- x )

Move a stack item to the return stack.

r>

( -- x ) ( R: x -- )

Move a return stack item to the stack.

r@

( -- x ) ( R: x -- x )

Copy the top of the return stack to the stack.

roll

( xu ... x1 x0 u -- xu-1 ... x1 x0 xu )

Rotate u stack items ( 2 roll = rot ).

rot

( x1 x2 x3 -- x2 x3 x1 )

Rotate 3 stack items.

-rot

( x1 x2 x3 -- x3 x1 x2 )

Inversely rotate 3 stack items.

2rot

( x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2 )

Rotate 3 pairs of stack items.

swap

( x1 x2 -- x2 x1 )

Exchange the top 2 stack items.

2swap

( x1 x2 x3 x4 -- x3 x4 x1 x2 )

Exchange 2 pairs of stack items.

tuck

( x1 x2 -- x2 x1 x2 )

Copy top stack item below second item.

( nu1 nu2 -- sum )

Add nu1 + nu2 .

( nu1 nu2 -- diff )

Subtract nu1 - nu2 .

( nu1 nu2 -- prod )

Multiply nu1 * nu2 .

( nu1 nu2 nu3 -- quot )

Calculates nu1 * nu2 / n3 .

( n1 n2 -- quot )

Divide n1 by n2 ; remainder is discarded.

( nu1 -- nu2 )

Add 1.

( nu1 -- nu2 )

Subtract 1.

( nu1 -- nu2 )

Add 2.

( nu1 -- nu2 )

Subtract 2.

( n -- u )

Absolute value.

( n count -- n+count n )

Prepare arguments for do or ?do loop.

( n -- n | n+1 )

Round to nearest even integer >= n .

( n1 n2 -- n1|n2 )

Return the maximum of n1 and n2 .

( n1 n2 -- n1|n2 )

Return the minimum of n1 and n2 .

( n1 n2 -- rem )

Remainder of n1 / n2 .

( n1 n2 n3 -- rem quot )

Remainder, quotient of n1 * n2 / n3 .

( n1 n2 -- rem quot )

Remainder, quotient of n1 / n2 .

( n1 -- n2 )

Change the sign of n1 .

( u1 u2 -- uprod )

Multiply 2 unsigned numbers yielding an unsigned product.

( u1 u2 -- urem uquot )

Divide unsigned number by an unsigned number; yield remainder and quotient.

( x1 -- x2 )

Multiply by 2.

( x1 -- x2 )

Divide by 2.

( x1 u -- x2 )

Arithmetic right-shift x1 by u bits.

( x1 x2 -- x3 )

Bitwise logical AND.

( x1 -- x2 )

Invert all bits of x1 .

( x1 u -- x2 )

Left-shift x1 by u bits. Zero-fill low bits.

( x1 x2 -- x3 )

Bitwise logical OR.

( x1 u -- x2 )

Right-shift x1 by u bits. Zero-fill high bits.

( x1 -- x2 )

Logical right shift 1 bit; zero shifted into high bit.

( x1 x2 -- x3 )

Bitwise exclusive OR.

(d1 d2 -- d.sum )

Add d1 to d2 yielding double number d.sum.

(d1 d2 -- d.diff )

Subtract d2 from d1 yielding double number d.diff.

( d n -- rem quot )

Divide d by n.

( n1 n2 -- d )

Signed multiply with double-number product.

( n1 -- d1 )

Convert a number to a double number.

( d n -- rem quot )

Divide d by n , symmetric division.

( u1 u2 -- ud )

Unsigned multiply yielding unsigned double number product.

( ud u -- urem uprod )

Divide ud by u .

( b.low b2 b3 b.hi -- quad )

Join four bytes to form a quadlet

( b.low b.hi -- word )

Join two bytes to form a doublet.

( quad1 -- quad2 )

Reverse the bytes within a quadlet

( quad -- b.low b2 b3 b.hi )

Split a quadlet into four bytes.

( quad1 -- quad2 )

Swap the doublets within a quadlet.

( quad -- w.low w.hi )

Split a quadlet into two doublets.

( word1 -- word2 )

Swap the bytes within a doublet.

( word -- b.low b.hi )

Split a doublet into two bytes.

( w.low w.hi -- quad )

Join two doublets to form a quadlet.

bxjoin

( b.lo b.2 b.3 b.4 b.5 b.6 b.7 b.hi -- o )

Join 8 bytes to form an octlet.

lxjoin

( quad.lo quad.hi -- o )

Join 2 quadlets to form an octlet.

wxjoin

( w.lo w.2 w.3 w.hi -- o )

Join four doublets to form an octlet.

xbflip

( oct1 -- oct2 )

Reverse the bytes within an octlet.

xbflips

( oaddr len -- )

Reverse the bytes within each octlet in the given region.The behavior is undefined if len is not a multiple of /x .

xbsplit

( o -- b.lo b.2 b.3 b.4 b.5 b.6 b.7 b.hi )

Split an octlet into 8 bytes.

xlflip

( oct1 -- oct2 )

Reverse the quadlets within an octlet. The bytes within each quadlet are not reversed.

xlflips

( oaddr len -- )

Reverse the quadlets within each octlet in the given region. The bytes within each quadlet are not reversed. The behavior is undefined if len is not a multiple of /x .

xlsplit

( o -- quad.lo quad.hi )

Split on octlet into 2 quadlets.

xwflip

( oct1 -- oct2 )

Reverse the doublets within an octlet. The bytes within each doublet are not reversed.

xwflips

( oaddr len -- )

Reverse the doublets within each octlet in the given region. The bytes within each doublet are not reversed. The behavior is undefined if len is not a multiple of /x .

xwsplit

( o -- w.lo w.2 w.3 w.hi )

Split an octlet into 4 doublets.

( n1 -- n1 | a-addr)

Increase n1 if necessary to yield a variable aligned address.

( -- n )

The number of address units to a byte: 1.

( nu1 -- nu2 )

Synonym for chars .

( addr1 index -- addr2 )

Increment addr1 by index times the value of /c .

( addr1 -- addr2 )

Synonym for char+ .

( addr1 -- addr2 )

Increment addr1 by the value of /c .

( addr1 -- addr2 )

Increment addr1 by the value of /n .

( nu1 -- nu2 )

Multiply nu1 by the value of /c .

( nu1 -- nu2 )

Multiply nu1 by the value of /n .

( -- n )

Number of address units to a quadlet; typically 4.

( nu1 -- nu2 )

Multiply nu1 by the value of /l .

( addr1 index -- addr2 )

Increment addr1 by index times the value of /l .

( addr1 -- addr2 )

Increment addr1 by the value of /l .

( -- n )

Number of address units in a cell.

( nu1 -- nu2 )

Synonym for cells .

( addr1 index -- addr2 )

Increment addr1 by index times the value of /n .

( addr1 -- addr2 )

Synonym for cell+ .

( -- n )

Number of address units to a doublet; typically 2.

( nu1 -- nu2 )

Multiply nu1 by the value of /w .

( addr1 index -- addr2 )

Increment addr1 by index times the value of /w .

( addr1 -- addr2 )

Increment addr1 by the value of /w .

( -- n )

Number of address units in an octlet, typically 8.

( nu1 -- nu2 )

Multiply nu1 by the value of /x .

( addr1 index -- addr2 )

Increment addr1 by index times the value of /x .

( addr1 -- addr2 )

Increment addr1 by the value of /x .

( x a-addr -- )

Store a number at a-addr .

( nu a-addr -- )

Add nu to the number stored at a-addr .

( a-addr -- x )

Fetch a number from a-addr .

( x1 x2 a-addr -- )

Store 2 numbers at a-addr , x2 at lower address.

( a-addr -- x1 x2 )

Fetch 2 numbers from a-addr , x2 from lower address.

( addr len -- )

Set len bytes of memory beginning at addr to the space character (decimal 32).

( byte addr -- )

Store byte at addr .

( addr -- byte )

Fetch a byte from addr .

( addr -- false | byte true )

Attempt to fetch the byte at addr . Return the data and true if the access was successful. Return false if a read access error occurred.

( byte addr -- okay? )

Attempt to store the byte to addr . Return true if the access was successful. Return false if a write access error occurred.

( addr1 addr2 len -- diff? )

Compare two byte arrays. diff? is 0 if the arrays are identical,
diff? is -1 if the first byte that is different is lesser in the string at addr1 , diff? is 1 otherwise.

( addr len -- )

Display len bytes of memory starting at addr .

( addr len -- )

Set len bytes of memory beginning at addr to 0 .

( addr len byte -- )

Set len bytes of memory beginning at addr to the value byte .

( quad qaddr -- )

Store a quadlet q at qaddr .

( qaddr -- quad )

Fetch a quadlet q from qaddr .

( qaddr len -- )

Reverse the bytes within each quadlet in the specified region.

( qaddr len -- )

Swap the doublets within each quadlet in specified region.

( qaddr -- false | quad true )

Attempt to fetch the 32-bit quantity at qaddr . Return the data and true if the access was successful. Return false if a read access error occurred.

( quad qaddr -- okay? )

Attempt to store the 32-bit quantity at qaddr . Return true if the access was successful. Return false if a a write access error occurred.

( src-addr dest-addr len -- )

Copy len bytes from src-addr to dest-addr .

( a-addr -- )

Store false at a-addr .

( a-addr -- )

Store true at a-addr .

( quad addr -- )

Store a quadlet q , any alignment

( addr -- quad )

Fetch a quadlet q , any alignment.

( w addr -- )

Store a doublet w , any alignment.

( addr -- w )

Fetch a doublet w , any alignment.

( w waddr -- )

Store a doublet w at waddr .

( waddr -- w)

Fetch a doublet w from waddr .

( waddr -- n )

Fetch doublet w from waddr , sign-extended.

( waddr len -- )

Swap the bytes within each doublet in the specified region.

( waddr -- false | w true )

Attempt to fetch the 16-bit quantity at waddr . Return the data and true if the access was successful. Return false if a read access error occurred.

( w waddr -- okay? )

Attempt to store the 16-bit quantity to waddr . Return true if the access was successful. Return false if a write access error occurred.

( qaddr -- n )

Fetch quadlet from qaddr, sign-extended.

( o -- )

Compile an octlet, o, into the dictionary (doublet-aligned).

( oaddr -- o )

Fetch octlet from an octlet aligned address.

( o oaddr -- )

Store octlet to an octlet aligned address.

xbflips

( oaddr len -- )

Reverse the bytes within each octlet in the given region.The behavior is undefined if len is not a multiple of /x .

xlflips

( oaddr len -- )

Reverse the quadlets within each octlet in the given region. The bytes within each quadlet are not reversed. The behavior is undefined if len is not a multiple of /x .

xwflips

( oaddr len -- )

Reverse the doublets within each octlet in the given region. The bytes within each doublet are not reversed. The behavior is undefined if len is not a multiple of /x .

( size -- virt )

Allocate and map size bytes of available memory; return the virtual address. Unmap with free-mem .

( virt size -- )

Free memory allocated by alloc-mem .

( virt -- )

Display memory map information for the virtual address.

( -- )
(E: ... -- ??? )

Start a new colon definition of the word new-name .

( -- )

End a colon definition.

( -- )
(E: ... -- ??? )

Create new-name with the same behavior as old-name .

( size -- )
(E: -- a-addr )

Create a named array in temporary storage.

( n -- )
(E: -- n )

Define a constant (for example, 3 constant bar ).

( n1 n2 -- )
(E: -- n1 n2 )

Define a 2-number constant.

( -- )
(E: -- a-addr )

Generic defining word.

( -- )
(E: ... -- ??? )

Define a word for forward references or execution vectors using execution token.

( ... -- ... a-addr )

(E: ... -- ??? )

Start the run-time clause for defining words.

( offset size -- offset+size )
(E: addr -- addr+offset )

Create a named offset pointer.

( -- 0 )

Initialize for field creation.

( n -- )
(E: -- n )

Create a changeable, named quantity.

( -- )
(E: -- a-addr )

Define a variable.

( -- xt )

Find the named word in the dictionary.
Returns the execution token. Use outside definitions.

( -- xt )

Similar to ' but is used either inside or outside definitions.

( xt -- )

Display a list of all words that call the word whose execution token is xt .

( str len -- str len false | xt true )

Search for word named by str,len. If found, leave xt and true on stack. If not found, leave name string and false on stack.

( pstr -- pstr false | xt n )

Search for word named by pstr. If found, leave xt and true on stack. If not found, leave name string and false on stack.

(Recommend using $find to avoid use of packed string.)

( -- )

Decompile the named command.

( xt -- )

Decompile the word indicated by the execution token.

( pstr -- )

Display names of all dictionary entries containing the string pointed to by pstr .

( -- )

Display names of all dictionary entries containing the sequence of characters. ccc contains no spaces.

( -- )

Display all visible words in the dictionary.

( n -- )

Place a number in the dictionary.

( byte -- )

Place a byte in the dictionary.

( word -- )

Place a 16-bit number in the dictionary.

( quad -- )

Place a 32-bit number in the dictionary.

( -- )

Enter interpretation state.

( -- )

End interpreting, enter compilation state.

( n -- )

Allocate n bytes in the dictionary.

( xt -- a-addr )

Find the data field address from the execution token.

( a-addr -- xt )

Find the execution token from the data field address.

( -- )

Compile the next word at run time. (Recommend using postpone instead.)

( -- )

Compile the next (immediate) word. (Recommend using postpone instead.)

( -- )

Remove word from dictionary and all subsequent words.

( -- addr )

Address of top of dictionary.

( -- )

Mark the last definition as immediate.

( n -- )

Install a new action in a defer word or value .

( n -- )

Compile a number.

( -- addr )

Return the address of the start of the Forth system.

( -- )

Replace old-word with new-word in word-to-patch .

( new-n old-n xt -- )

Replace old-n with new-n in word indicated
by xt .

( -- )

Delay the execution of the word name.

( -- )

Make the name of the colon definition being compiled visible in the dictionary, and thus allow the name of the word to be used recursively in its own definition.

( -- addr )

Variable that is non-zero in compile state.

( -- code-sys )

(E: ... -- ??? )

Begin the creation of an assembly language routine called name . Commands that follow are interpreted as assembler mnemonics. Note that if the assembler is not installed, code is still present, except that machine code must be entered numerically (for example, in hex) with ",".

( code-sys -- )

End the creation of an assembly language routine. Automatically assemble the Forth interpreter "next" function so that the created assembly-code word, when executed, returns control to the calling routine as usual.

( -- code-sys )

(E: -- a-addr )

Begin the creation of an assembly language routine called name . Words created with label leave the address of the code on the stack when executed. The commands that follow are interpreted as assembler mnemonics. As with code , label is present even if the assembler is not installed.

( code-sys -- )

End the assembly language patch started with label .

( n -- )

Display a number in the current base.

( n size -- )

Display a number in a fixed width field.

( -- )

Display contents of data stack.

( -- )

Execute .s automatically before each ok prompt.

( -- )

Turn off automatic display of the stack before each ok prompt.

( u -- )

Display an unsigned number.

( u size -- )

Display an unsigned number in a fixed width field.

( n -- )

Display n in decimal without changing base.

( n -- )

Display n in hex without changing base.

( -- addr )

Variable containing number base.

( -- )

Set the number base to 10.

( -- n )

Interpret number in decimal; base is unchanged.

( -- )

Set the number base to 16.

( -- n )

Interpret number in hex; base is unchanged.

( +l1 -- +l2 )

Convert a digit in pictured numeric output.

( l-- addr +n )

End pictured numeric output.

( -- )

Initialize pictured numeric output.

( n -- )

Convert a number to a string.

( -- addr len )

Convert unsigned to string.

( char base -- digit true | char false )

Convert a character to a digit.

( char -- )

Insert the char in the pictured numeric output string.

( addr len -- true | n false )

Convert a string to a number.

( l -- 0 )

Convert the rest of the digits in pictured numeric output.

( n -- )

Set sign of pictured output.

( -- )

Begin a comment.

( -- )

Skip the rest of the line.

( -- char )

Get numerical value of first ASCII character of next word.

( addr len1 -- len2 )

Get a line of edited input from the console input device; store at addr .len1 is the maximum allowed length. len2 is the actual length received.

( addr len -- )

Get and display a line of input from the console; store at addr . (Recommend using accept instead.)

( -- char )

Read a character from the console input device.

( -- flag )

True if a key has been typed on the console input device.

( char -- str len )

Parse text from the input buffer delimited by char.

( -- str len )

Skip leading spaces and parse text from the input buffer delimited by white space.

( -- str len )

Similar to parse-word but intended for use in cases where the null string as input is indicative of an error.

( char -- pstr )

Collect a string delimited by char from the input buffer and place it as a packed string in memory at pstr . (Recommend using parse instead.)

( -- )

Compile a string for later display.

( -- )

Move the output cursor back to the beginning of the current line.

( -- )

Terminate a line on the display and go to the next line.

( char -- )

Display the character.

( -- flag )

Enable the scrolling control prompt: More [<space>,<cr>,q] ?

The return flag is true if the user wants the output to be terminated.

( -- )

Display a space character.

( +n -- )

Display +n spaces.

( addr +n -- )

Display n characters.

( -- rows )

Value holding the number of lines on the output device.

( -- a-addr )

Variable holding the column number on the output device.

( addr len -- )

Compile an array of bytes from addr of length len , at the top of the dictionary as a packed string.

( -- addr len )

Collect an input stream string, either interpreted or compiled. Within the string, "(00,ff...) can be used to include arbitrary byte values.

( -- )

Display a string immediately.

( addr +n1 -- addr +n2 )

Remove trailing spaces.

( -- char )

ASCII code for the space character; decimal 32.

( pstr -- addr +n )

Unpack a packed string.

( char -- lowercase-char )

Convert a character to lowercase.

( addr len char -- addrR lenR addrL lenL )

Split a string at char (which is discarded).

( addr len pstr -- pstr )

Make a packed string from addr len ; place it at pstr .

( -- pstr )

Collect a string from the input stream; store as a packed string.

( char -- uppercase-char )

Convert a character to uppercase.

( device -- )

Select device ( keyboard , or device-specifier ) for subsequent input.

( device -- )

Select device for subsequent input and output.

( device -- )

Select device ( screen , or device-specifier ) for subsequent output.

( -- n )

ASCII code for the bell character; decimal 7.

( -- n )

ASCII code for the backspace character; decimal 8.

Moves backward one character.

Moves backward one word.

Moves forward one character.

Moves forward one word.

Moves backward to beginning of line.

Moves forward to end of line.

Erases previous character.

Erases previous character.

Erases previous character.

Erases from beginning of word to just before the cursor, storing erased characters in a save buffer.

Erases from beginning of word to just before the cursor, storing erased characters in a save buffer.

Erases next character.

Erases from cursor to end of the word, storing erased characters in a save buffer.

Erases from cursor to end of line, storing erased characters in a save buffer.

Erases entire line, storing erased characters in a save buffer.

Retypes the line.

Quotes next character (allows you to insert control characters).

Inserts the contents of the save buffer before the cursor.

Selects and displays the previous line for subsequent editing.

Selects and displays the next line for subsequent editing.

Displays the entire contents of the editing buffer.

Complete the name of the current word.

Display all possible matches for the current word.

( n1 n2 -- flag )

True if n1 < n2 .

( n1 n2 -- flag )

True if n1 <= n2 .

( n1 n2 -- flag )

True if n1 is not equal to n2 .

( n1 n2 -- flag )

True if n1 = n2 .

( n1 n2 -- flag )

True if n1 > n2 .

( n1 n2 -- flag )

True if n1 >= n2 .

( n -- flag )

True if n < 0.

( n -- flag )

True if n <= 0.

( n -- flag )

True if n <> 0.

( n -- flag )

True if n = 0 (also inverts any flag).

( n -- flag )

True if n > 0.

( n -- flag )

True if n >= 0.

( n min max -- flag )

True if min <= n <= max .

( -- 0 )

The value FALSE , which is 0.

( -- -1 )

The value TRUE , which is -1.

( u1 u2 -- flag )

True if u1 < u2 , unsigned.

( u1 u2 -- flag )

True if u1 <= u2 , unsigned.

( u1 u2 -- flag )

True if u1 > u2 , unsigned.

( u1 u2 -- flag )

True if u1 >= u2 , unsigned.

( n min max -- flag )

True if min <= n < max .

( flag -- )

Execute the following code when flag is true .

( -- )

Execute the following code when flag is false .

( -- )

Terminate if...then...else .

( selector -- selector )

Begin a case...endcase conditional.

( selector | {empty} -- )

Terminate a case...endcase conditional.

( -- )

Terminate an of...endof clause within a case...endcase

( selector test-value -- selector | {empty} )

Begin an of...endof clause within a case conditional.

( -- )

End a begin...again infinite loop.

( -- )

Begin a begin...while...repeat , begin...until, or begin...again loop.

( -- )

End a begin...while...repeat loop.

( flag -- )

Continue executing a begin...until loop until flag is true.

( flag -- )

Continue executing a begin...while...repeat loop while flag is true.

( n -- )

End a do...+loop construct; add n to loop index and return to do (if n < 0, index goes from start to end , inclusive).

( end start -- )

Begin ?do...loop to be executed 0 or more times. Index goes from start to end -1, inclusive. If end = start , loop is not executed.

( flag -- )

Exit from a do...loop if flag is non-zero.

( end start -- )

Begin a do...loop . Index goes from start to end -1, inclusive.

Example: 10 0 do i . loop (prints 0 1 2...d e f).

( -- n )

Leaves the loop index on the stack.

( -- n )

Leaves the loop index for next outer enclosing loop.

( -- )

Exit from do...loop .

( -- )

End of do...loop .

( -- )

Abort current execution and interpret keyboard commands.

( abort? -- )

If abort? is true, abort and display message.

( ... str len -- ??? )

Synonym for evaluate .

( ... str len -- ??? )

Interpret Forth source text from the specified string.

( xt -- )

Execute the word whose execution token is on the stack.

( -- )

Return from the current word. (Cannot be used in counted loops.)

( -- )

Same as abort , but leave stack intact.

( -- )

Execute Forth, FCode, or binary programs.

( -- )

Load file from specified source.

( addr span -- )

Interpret loaded FCode binary file. span is usually 1.

( -- )

Load a Forth file over a serial line with tip and interpret. Type:
~C cat filename
^-D

( -- )

Load a binary file over a serial line with tip .

Type: ~C cat filename

( addr -- )

Load the specified file over Ethernet at the given address.

( addr len -- )

Interpret loaded Forth text file.

( -- )

Begin executing a previously-loaded binary program, or resume executing an interrupted program.

( -- )

Initialize to execute a binary file.

( -- )

Load data from specified device into memory at the address given by load-base .

( -- addr )

Address at which load places the data it reads from a device.

( -- )

Continue disassembling where the last disassembly left off.

( addr -- )

Begin disassembling at the specified address.

( addr -- )

Add a breakpoint at the given address.

( addr -- )

Remove the breakpoint at the given address.

( -- )

Remove the most-recently-set breakpoint.

( -- )

Display all currently set breakpoints.

( -- )

Perform a specified action when a breakpoint occurs. This word can be altered to perform any desired action. For example, to display registers at every breakpoint, type: ['] .registers is .breakpoint . The default behavior is .instruction . To perform multiple behaviors, create a single definition which calls all desired behaviors, then load that word into .breakpoint .

( -- )

Display the address, opcode for the last-encountered breakpoint.

( -- )

Perform a specified action when a single step occurs. (See .breakpoint ).

( -- )

Remove all breakpoints.

( -- )

Execute until the end of this loop.

( -- )

Continue from a breakpoint. This can be used to go to an arbitrary address by setting up the processor's program counter before issuing go .

( n -- )

Execute go n times.

( -- )

(Like the step command.) Treat a subroutine call as a single instruction.

( n -- )

Execute hop n times.

( -- )

Execute until the end of this subroutine.

( -- )

Execute until the end of this leaf subroutine.

( -- )

Skip (do not execute) the current instruction.

( -- )

Single-step one instruction.

( n -- )

Execute step n times.

( addr -- )

Execute until the given address is encountered. Equivalent to +bp go .

"Continue". Switch from stepping to tracing, thus tracing the remainder of the execution of the word being debugged.

"Down a level". Mark for debugging the word whose name was just displayed, then execute it.

"Up a level". Un-mark the word being debugged, mark its caller for debugging, and finish executing the word that was previously being debugged.

Start a subordinate Forth interpreter. When that interpreter exits (with resume ), control returns to the debugger at the place where the f command was executed.

"Go." Turn off the debugger and continue execution.

"Quit". Abort the execution of the word being debugged and all its callers and return to the command interpreter.

"see". Decompile the word being debugged.

Display the address,len on top of the stack as a text string.

"Help". Display symbolic debugger documentation.

"Short Help". Display brief symbolic debugger documentation.

Mark the specified Forth word for debugging. Enter the Forth Source-level Debugger on all subsequent attempts to execute name. After executing debug , the execution speed of the system may decrease until debugging is turned off with debug-off . (Do not debug basic Forth words such as " dup " .)

Like debug except that (debug takes an execution token from the stack instead of a name from the input stream.

Turn off the Forth Source-level Debugger so that no word is being debugged.

Exit from a subordinate interpreter, and go back to the stepper (See the f command in this table.)

Set step mode for the Forth Source-level Debugger, allowing the interactive, step-by-step execution of the word being debugged. Step mode is the default.

Set trace mode for the Forth Source-level Debugger. Tracing enables the execution of the word being debugged, while showing the name and stack contents for each word called by that word.

Execute the word just displayed and proceed to the next word.

( -- ms )

Return the approximate current time in milliseconds.

( n -- )

Delay for n milliseconds. Resolution is 1 millisecond.

( value -- )

Call Solaris with the given value and string.

( ... xt -- ??? error-code | ??? false )

Execute xt ; return throw error code or 0 if throw is not called.

( -- )

Eject the diskette from the floppy drive.

(-- n )

Return major/minor CPU firmware version
(that is, 0x00030001 = firmware version 3.1).

( -- )

Restore main Forth vocabulary to top of search order.

( -- )

Show calling sequence when exception occurred.

( -- )

Do nothing.

( -- )

Reset the entire system (similar to a power-cycle).

( -- )

Call the operating system to write any pending information to the hard disk. Also boot after sync-ing file systems.

( error-code -- )

Return given error code to catch.

( cpu# -- )

Switch to indicated CPU.

map?

( virt -- )

Display memory map information for the virtual address.

memmap

( phys space size -- virt )

Map a region of physical addresses; return the allocated virtual address. Unmap with free-virtual .

obio

( -- space )

Specify the device address space for mapping.

obmem

( -- space )

Specify the onboard memory address space for mapping.

sbus

( -- space )

Specify the SBus address space for mapping.

iomap?

( virt -- )

Display IOMMU page map entry for the virtual address.

iomap-page

( phys space virt -- )

Map physical page given by phys and space to the virtual address.

iomap-pages

( phys space virt size -- )

Perform consecutive iomap-page s to map a region of memory given by size .

iopgmap@

( virt -- pte | 0 )

Return IOMMU page map entry for the virtual address.

iopgmap!

( pte virt -- )

Store a new page map entry for the virtual address.

map-page

( phys space virt -- )

Map one page of memory starting at address phys on to virtual address virt in the specified address space . All addresses are truncated to lie on a page boundary.

map-pages

( phys space virt size -- )

Perform consecutive map-page s to map a region of memory to the specified size .

map-region

( region# virt -- )

Map a region.

map-segments

( smentry virt len -- )

Perform consecutive smap! operations to map a region of memory.

pgmap!

( pmentry virt -- )

Store a new page map entry for the virtual address.

pgmap?

( virt -- )

Display the page map entry (decoded and in English) corresponding to the virtual address.

pgmap@

( virt -- pmentry )

Return the page map entry for the virtual address.

pagesize

( -- size )

Return the size of a page.

rmap!

( rmentry virt -- )

Store a new region map entry for the virtual address.

rmap@

( virt -- rmentry )

Return the region map entry for the virtual address.

segmentsize

( -- size )

Return the size of a segment.

smap!

( smentry virt -- )

Store a new segment map entry for the virtual address.

smap?

( virt -- )

Formatted display of the segment map entry for the virtual address.

smap@

( virt -- smentry )

Return the segment map entry for the virtual address.

clear-cache

( -- )

Invalidate all cache entries.

cache-off

( -- )

Disable the cache.

cache-on

( -- )

Enable the cache.

ecdata!

( data offset -- )

Store the data at the cache offset .

ecdata@

( offset -- data )

Fetch (return) data from the cache offset .

ectag!

( value offset -- )

Store the tag value at the cache offset .

ectag@

( offset -- value )

Return the tag value at the cache offset .

flush-cache

( -- )

Write back any pending data from the cache.

aux!

( data -- )

Write auxiliary register.

aux@

( -- data )

Read auxiliary register.

spacec!

( byte addr asi -- )

Store the byte in asi at addr .

spacec?

( addr asi -- )

Display the byte in asi at addr .

spacec@

( addr asi -- byte )

Fetch the byte from asi at addr .

spaced!

( quad1 quad2 addr asi -- )

Store the two quadlets in asi at addr . Order is implementation-dependent.

spaced?

( addr asi -- )

Display the two quadlets in asi at addr . Order is implementation-dependent.

spaced@

( addr asi -- quad1 quad2 )

Fetch the two quadlets from asi at addr . Order is implementation-dependent.

spacel!

( quad addr asi -- )

Store the quadlet in asi at addr .

spacel?

( addr asi -- )

Display the quadlet in asi at addr .

spacel@

( addr asi -- quad )

Fetch the quadlet from asi at addr .

spacew!

( w addr asi -- )

Store the doublet in asi at addr .

spacew?

( addr asi -- )

Display the doublet in asi at addr .

spacew@

( addr asi -- w )

Fetch the doublet from asi at addr .

spacex!

( x addr asi -- )

Store the number in asi at addr .

spacex?

( addr asi -- )

Display the word in asi at addr .

spacex@

( addr asi -- x )

Fetch the word from asi at addr.

( -- value )

Return the value in the specified global register.

( -- value )

Return the value in the specified input register.

( -- value )

Return the value in the specified local register.

( -- value )

Return the value in the specified output register.

( -- value )

Return the value in the specified register.

( -- value )

Return the value in the specified floating point register.

( -- )

Display the values in %f0 through %f31 .

( -- )

Display the values in the i , l and o registers.

( -- )

Display values in processor registers.

( window# -- )

Same as w .locals ; display the desired window.

( -- )

Display the return stack showing C subroutines.

( new-value -- )

Set %pc to new-value, and set %npc to (new-value+4).

( new-value -- )

Change the value stored in any of the above registers.
Use in the form: new-value to regname.

( window# -- )

Set the current window for displaying %i x, %l x, or %o x.

( -- value )

Return the value in the specified register.

( -- )

Formatted display of the processor state register.

( -- )

Formatted display of the version register.

( -- )

Formatted display of the ccr register.

( -- )

Display trap-related registers.

Bypass POST. This command does not depend on security-mode. (Note: some systems bypass POST as a default; in such cases, use Stop-D to start POST.)

Abort.

Enter diagnostic mode (set diag-switch? to true ).

Enter Forth on TTYA instead of probing. Use fexit to continue with the initialization sequence. Useful if hardware is broken.

Reset NVRAM contents to default values.