{\huge Glossary of Forth words }

{\it 0} (null) \\
( $\longrightarrow$ ) (immediate) \\
The name string of this word is the single byte zero, or ascii null.
This word is executed at the end of a terminal input line when the
zero value left by {\tt EXPECT} is discovered. It completes the reading of the
text line, finishes the {\tt INTERPRET} word to return to {\tt QUIT}.

{\tt !} (Store) \\ (n, addr $\longrightarrow$ ) (primitive) \\
Store word value "n" at absolute "addr" in memory.

{\tt !CSP} \\ ($\longrightarrow$ ) \\
Copy the current value of the parameter stack pointer into {\tt USER} variable
{\tt CSP}. Used as part of the compiler security.

{\tt \#}  (Sharp) \\ (dlo, dhi $\longrightarrow$ d2lo, d2hi) \\
Generate, from the double word value on the stack, the next ascii character
which is placed in an output string at {\tt PAD}.
Result d2 is the quotient after
division by {\tt BASE} which is used for further ascii string manufacture.
Used between {\tt <\#} and {\tt \#>}. See {\tt \#S} and {\tt SIGN}.

{\tt \#>} \\ (dlo, dhi $\longrightarrow$ addr, count) \\
Terminates numeric output conversion by dropping the double word
value on the stack leaving the address of an ascii text string and its
length. Suitable for immediate use by {\tt TYPE}. See {\tt $<$\#},
{\tt \#S} and {\tt SIGN}.

{\tt \#S} \\ (dlo, dhi $\longrightarrow$ 0, 0) \\
Generates ascii text in the text output buffer at {\tt PAD} to represent the
double word value on the stack. {\tt \#} is used repeatedly until the stack
values result in zeros.

{\tt '}  (Tick) \\ ($\longrightarrow$ pfa) (immediate) \\
Used in the form: {\tt ' word} \\
Obtains the parameter field address of word in the dictionary. As a compiler
directive executes in a colon definition to compile the address as a literal.
If not found in {\tt CONTEXT} and {\tt CURRENT} an error message is generated.

{\tt (} (Comment) \\ ( $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt ( text)} \\
Ignore a comment that will be delimeted by a right parenthesis on the same
line. A comment may occur during execution or in a colon definition during
compilation. The blank after the left parenthesis is required for the
interpreter to recognise the parenthesis as a separate word.

{\tt (.")} \\ ( $\longrightarrow$ ) \\
The run time procedure compiled by {\tt ."} which transmits the text that
follows this word in the dictionary to the selected output device. See {\tt
."} .

{\tt (/)} \\ ( n1, n2 $\longrightarrow$ n3, boolean) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
The procedure used by {\tt /} to generate "n3=n1/n2". The "boolean" is 1
when "n2" is zero in which case "n3" is invalid.

{\tt (;CODE)} \\ ( $\longrightarrow$ ) \\
The run time procedure compiled by {\tt ;CODE} , that rewrites the code field
address of the most recently defined word in the dictionary. The code field
is changed to point to the following machine code sequence. Used at the
end of a {\tt <BUILDS} immediately before a {\tt DOES>}.

{\tt (+LOOP)} \\ ( n $\longrightarrow$ ) (primitive) \\
The run time procedure compiled by {\tt +LOOP} which increments the loop
index by "n" and tests for loop completion. The loop index is the first value
on the return stack, the loop limit the second. For "n" $>$ 0,
when the loop index is
equal to or greater than the limit the loop will finish. For "n" $<$ 0, the
loop finishes when the loop index is less than or equal to the loop limit.
 The value stored in
the dictionary after this word is the jump to be taken, to repeat the loop,
with respect to the current Forth interpretive pointer. See {\tt DO}.

{\tt (ABORT)} \\ (  $\longrightarrow$ ) \\
Executes after an error when {\tt WARNING} has the value -1. This word normally
executes {\tt ABORT}, but may be cautiously altered to an alternative procedure
selected by the user.

{\tt (DO)} \\ ( n1, n2 $\longrightarrow$) (primitive) \\
The run time procedure compiled by {\tt DO} which moves the loop control
parameters to the return stack. "n1", the loop limiting value, is pushed
first, followed by "n2", the loop index start value. See {\tt LEAVE}.

{\tt (EMIT)} \\ ( addr, n $\longrightarrow$ ) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
The primitive used by {\tt EMIT} and
{\tt TYPE} to print a string on the current output device. The string
to be printed starts at "addr" and is "n" bytes in length. The variable
{\tt OUT} is unaffected. Output is raw with no spaces or returns added.

{\tt (FIND)} \\ ( addr, nfa $\longrightarrow$  0 OR
pfa, length.byte, 1 ) (primitive)\\
Searches the dictionary list starting at the name field address "nfa",
matching with the text with prefixing length byte stored at "addr".
The string at "addr" must be packed with spaces to a word boundary
as the match is done a machine word
at a time. The sign bit is ignored for all characters in the match.
The top two bits (sign and immediate) are ignored on the length
byte. It is assumed that the dictionary ends with {\tt NULL}
 not zero. See {\tt -FIND}.

{\tt (LINE)} \\ ( n1, n2 $\longrightarrow$ addr, count ) \\
Convert the line number "n1" and the screen number "n2" to the disk buffer
address containing the data. A count of 64 bytes indicates the full
line text length. Each disk screen is made up of 16 lines of 64 bytes.

{\tt (LOOP)} \\ ( $\longrightarrow$ ) (primitive) \\
The run time procedure compiled by {\tt LOOP} which increments the loop
index by 1 and tests for loop completion. The loop index is the first value
on the return stack, the loop limit the second. When the loop index is
equal to the limit the loop will finish. The value stored in
the dictionary after this word is the jump to be taken, to repeat the loop,
with respect to the current Forth interpretive pointer. See {\tt DO}.

{\tt (NUMBER)} \\ ( dlo, dhi, addr $\longrightarrow$ d2lo, d2hi, addr2) \\
Convert the ascii text starting at "addr" with regard  to {\tt BASE}. The new
double word value is accumulated into d to become d2. "addr2" is the
address of the first unconverted digit. Used by {\tt NUMBER}.

{\tt (U/)} \\ ( dlo, dhi, n $\longrightarrow$
n1, n2, bool1, bool2 ) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
The procedure called by {\tt U/}. The double number on the stack is divided
by "n" to produce the remainder "n1" and quotient "n2". "bool1" has value
1 when overflow occurs, "bool2" is 1 on divide by zero, in either case
the values of "n1" and "n2" will be invalid.

{\tt (USING)} \\ ( $\longrightarrow$ ) \\
{\it Not included in FIG Forth standard model.} \\
The run procedure compiled by {\tt USING} to request a change of disk screen
file from the system. The string is assumed to start in the next word in the
dictionary. The interpretive pointer is moved over it and {\tt NEWFILE}
called.

{\tt *}  (Times) \\ ( n1, n2 $\longrightarrow$ n3) (primitive) \\
Generate the signed product, "n3", of two signed numbers "n1" and "n2".

{\tt */} (Times-divide) \\ ( n1, n2, n3 $\longrightarrow$ n4) \\
Generate the ratio "n4=(n1*n2)/n3" where all values are signed numbers.
The intermediate product is stored as a double word value permitting
greater accuracy than a sequence of {\tt *} and then {\tt /}. See {\tt */MOD}.

{\tt */MOD} \\ ( n1, n2, n3 $\longrightarrow$ n4, n5) \\
Generate the quotient "n5" and remainder "n4" of the operation "(n1*n2)/n3".
A double word intermediate product is used for improved accuracy.

{\tt +} (Plus) \\ ( n1, n2 $\longrightarrow$ n3) (primitive) \\
Generate the signed sum, "n3", of two signed numbers "n1" and "n2".

{\tt +!} (Plus-store) \\ ( n, addr  $\longrightarrow$ )(primitive) \\
Add the value "n" to the value at "addr" returning the sum to "addr".

{\tt +-} \\ ( n1, n2 $\longrightarrow$ n3) \\
Apply the sign of "n2" to "n1" resulting in value "n3".

{\tt +BUF} \\ ( addr1 $\longrightarrow$ addr2, boolean) \\
Advance the disk buffer address  "addr1", to the address of the next buffer
"addr2". "boolean" is zero when "addr2" is the buffer currently pointed to
by {\tt USER} variable {\tt PREV}.

{\tt +LOOP} \\ ( n $\longrightarrow$ ) (immediate) \\
  ( addr, n2 $\longrightarrow$ ) (During compilation) \\
At run time {\tt (+LOOP)}
selectively controls branching back to a corresponding
{\tt DO}. The value "n" is added to the loop index on the return stack then
compared with the value next on the return stack, the loop limit.
The branch back to {\tt DO} occurs until the new index is equal to or greater
than the limit ("n" $>$ 0) or until the new index is equal to or less than the
limit ("n" $<$ 0). Upon exiting the loop the two loop control words on
the return stack are discarded.

At compile time {\tt +LOOP} compiles the run time word {\tt (+LOOP)}
and the branch
offset computed from {\tt HERE} to the address left on the stack by {\tt DO}.
"n2" is
used for compile time error checking, when used correctly it has value 3.

{\tt +ORIGIN} \\ ( n $\longrightarrow$ addr) (primitive) \\
Leave the memory address relative to the origin.pointer on the stack. The
origin.pointer is the address of an area containing boot constants such
as where the disk buffers, stacks etc live in memory on a {\tt COLD} start.
The value "n" is taken as a word offset not a byte offset. This is to make
code easily portable between transputers of different wordlengths.

{\tt ,} (Comma) \\ ( n $\longrightarrow$ ) \\
Store "n" into the next available dictionary memory cell as denoted by
{\tt HERE}.
The dictionary pointer is advanced by one word. See {\tt DP}.

{\tt -} (Minus) \\ ( n1, n2 $\longrightarrow$ n3) (primitive) \\
Generate the signed difference, "n3=n1-n2", of two signed numbers "n1"
and "n2".

{\tt -->}  (Next-screen) \\ ( $\longrightarrow$ ) (immediate) \\
Continue interpretation with the numerically next disk screen.

{\tt -DUP} \\ ( n $\longrightarrow$ n OR n, n) (primitive) \\
Duplicate top of stack unless value is zero. This is useful prior to an
{\tt IF} to avoid having an {\tt ELSE DROP} part.

{\tt -FIND} \\ ( $\longrightarrow$ 0 OR pfa, length.byte, 1 ) \\
Takes the next text word, delimeted with spaces, from the input stream and
places it at {\tt HERE}.
The {\tt CONTEXT} and {\tt CURRENT} vocabularies are searched for a
matching entry. If found, the word's parameter field address and
"length.byte"
 value are returned. The name length byte will have the sign bit (bit 7)
set and possibly bit 6 if it is an "immediate" word.

{\tt -TRAILING} \\ ( addr, n1 $\longrightarrow$ addr, n2) \\
Adjust the the character count "n1" of a text string beginning address to
suppress the output of trailing blanks, ie. the characters at "addr+n1" to
"addr+n2" are spaces.

{\tt .} (Dot) \\ ( n $\longrightarrow$ ) \\
Print a number from a signed word length value according to the {\tt USER}
variable {\tt BASE}. A trailing space is appended.

{\tt ."} \\ ( $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt ." ascii text"}\\
Compiles an in-line string of user defined ascii text delimited by the
trailing '"' character. The string is prefixed by the compiled word {\tt (.")}
which at run time prints the string to the output device. This can be
executed in interpret mode where it directly prints the following string.

{\tt .LINE} \\ ( n1, n2 $\longrightarrow$) \\
Print on the terminal device, a line of text from the current file,
from disk screen "n2" at offset of "n1" multiplied by
the disk screen line length.
Trailing blanks are suppressed.

{\tt .R} \\ ( n1, n2 $\longrightarrow$ ) \\
Print the signed number "n1" right aligned in a field whose width is "n2".
No following spaces are added, just prefixing spaces to make up the width.

{\tt /} (Divide) \\ ( n1, n2 $\longrightarrow$ n3) \\
Generate the signed quotient, "n3=n1/n2", of two signed numbers "n1" and "n2".
An error is generated on divide by zero. See {\tt (/)}.

{\tt /MOD} \\ ( n1, n2 $\longrightarrow$ n3, n4) \\
Generate the signed quotient "n4" and remainder "n3" from the operation
"n1/n2" using the two signed numbers "n1" and "n2". The remainder has the sign
of the dividend ie. "n3" has the sign of "n1".

{\tt 0}  (Zero) \\ ( $\longrightarrow$ 0) (CONSTANT) \\
Push the constant value of zero onto the stack.

{\tt 0<} \\ ( n $\longrightarrow$ boolean) (primitive) \\
Replace the number on the stack with 1 if "n" $<$ 0, otherwise 0.

{\tt 0=} \\ ( n $\longrightarrow$ boolean) (primitive) \\
Replace the number on the stack with 1 if "n" = 0, otherwise 0.

{\tt 0BRANCH} \\ ( n $\longrightarrow$ ) (primitive) \\
The run time procedure to conditionally branch. If "n" is zero the
in-line parameter value following the {\tt 0BRANCH} is
added as a byte offset to the interpretive pointer.
This addition has the effect of jumping backwards or forwards in the
current word according to the next parameters value. When "n" is non-zero
no branch will be taken. Compiled by {\tt IF}, {\tt UNTIL} and {\tt WHILE}.

{\tt 1} (One) \\ ( $\longrightarrow$ 1) (CONSTANT) \\
Push the constant value one onto the stack.

{\tt 1+} (One-plus) \\ ( n $\longrightarrow$ n+1) (primitive) \\
Increment the value on the stack by one.

{\tt 2}  (Two) \\ ( $\longrightarrow$ 2) (CONSTANT) \\
Push the constant value two onto the stack.

{\tt 2+} (Two-plus) \\ ( n $\longrightarrow$ n+2) (primitive) \\
Increment the value on the stack by two.

{\tt 3}  (Three) \\ ( $\longrightarrow$ 3) (CONSTANT) \\
Push the constant value three onto the stack.

{\tt :}  (Colon) \\ ( $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name } \\
Creates a dictionary entry defining "name" to be equivalent to whatever
sequence of forth words follows until either {\tt ;},
{\tt ;CODE} or an error is detected.
The compiling process is done by the text interpreter as long as {\tt USER}
variable {\tt STATE} is non-zero.
The {\tt CONTEXT} vocabulary is set to the {\tt CURRENT}
vocabulary and all words with the sign bit (bit 7) set on their
name length bytes will be executed
immediately rather than compiled.

{\tt ;} (Semicolon) \\ ( $\longrightarrow$ ) (immediate) \\
Terminate a colon defined word definition. Compilation stops and
interpretation continues. This compiles the run time procedure {\tt ;S}.

{\tt ;CODE} \\ ( $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name .... ;CODE assembly mnemonics} \\
Stop compilation and terminate a new defining word called "name" by compiling
{\tt (;CODE)}. Set the {\tt CONTEXT} vocabulary to {\tt ASSEMBLER}
and continue to read the following assembler words.
When "name" executes it will jump direct to the code following {\tt (;CODE)}.
This word patches the {\tt LATEST} word's code field  address.

{\tt ;S} \\ ( $\longrightarrow$ ) (primitive) \\
Stop interpretation of a disk screen. This is also the run time procedure
compiled by {\tt ;} to complete execution of a colon defined word and
return control to the caller. The caller's interpretive pointer is stored
on the return stack.

{\tt <}  (Less than) \\ ( n1, n2 $\longrightarrow$ boolean) (primitive) \\
Test if "n1" is less than "n2" returning 1 for success and 0 if false.

{\tt <\#} \\ ( $\longrightarrow$) \\
Set up for numeric output. Selects {\tt PAD} as the site for text generation.

{\tt <BUILDS} \\ ( $\longrightarrow$ ) \\
Used in the form: {\tt : name1 <BUILDS ... DOES> ... ;} \\
Each time name1 is executed {\tt <BUILDS} defines a new word with a high level
execution procedure. \\
Used in the form: {\tt name1 name2} \\
uses {\tt <BUILDS} to create a dictionary entry for "name2" with its
code field address pointing to the word following {\tt DOES>} in "name1".
{\tt <BUILDS} and {\tt DOES>} allow run time procedures to be written
generically in terms of words rather than assembler as required by
{\tt ;CODE}.

{\tt =}  (Equal) \\ ( n1, n2 $\longrightarrow$ boolean) (primitive) \\
Test if "n1" is equal to "n2" returning 1 for success and 0 if false.

{\tt >} (Greater than) \\ ( n1, n2 $\longrightarrow$ boolean) (primitive) \\
Test if "n1" is greater than "n2" returning 1 for success and 0 if false.

{\tt >R} \\ ( n $\longrightarrow$ ) (primitive) \\
Remove a number from the parameter stack and push it onto the return
stack. This should be balanced with {\tt R>} in the same definition or
the control of what runs next will be changed. Sometimes this is the
intention!

{\tt ?} \\ ( addr $\longrightarrow$ ) \\
Print the value at addr in free format according to {\tt BASE}.

{\tt ?COMP} \\ ( $\longrightarrow$ ) \\
Issue error message if not compiling.

{\tt ?CSP} \\ ( $\longrightarrow$ ) \\
Issue error message if the current stack pointer is dissimilar to what
is held in {\tt CSP}.

{\tt ?ERROR} \\ (boolean, n $\longrightarrow$ ) \\
Issue  error message number n if the boolean is 1.

{\tt ?EXEC} \\ ( $\longrightarrow$ )  \\
Issue an error message if not executing.

{\tt ?LOADING} \\ ( $\longrightarrow$ ) \\
Issue an error message if not interpreting from a disk screen.

{\tt ?PAIRS} \\ (n1, n2  $\longrightarrow$ ) \\
Issue an error message if "n1" and "n2" differ. This message indicates that
compiled conditionals do not match.

{\tt ?STACK} \\ ( $\longrightarrow$ ) \\
Issue an error message if the stack is out of bounds. This is when the stack
pointer is either greater than it's starting point {\tt S0} or within
512 bytes of {\tt HERE}.

{\tt ?TERMINAL} \\ ( $\longrightarrow$ char OR 0) (primitive) \\
Test the keyboard to see if a key has been pressed. If a key has been pressed
the value "char" will be returned on the stack, otherwise zero. The effect on
any buffered data in the terminal input stream is host-specific.

{\tt @}  (At) \\ ( addr $\longrightarrow$ n) (primitive) \\
Replace the value on the stack with the value at that address.

{\tt ABORT}  \\ ( $\longrightarrow$ ) \\
Clear the stacks and enter the execution state. Return control to the
terminal with an appropriate restart message. Uses {\tt QUIT}.

{\tt ABS}  \\ (n1 $\longrightarrow$ n2) \\
Leave the absolute value of "n1" as "n2".

{\tt AGAIN}  \\ (addr, n $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name ... BEGIN ... AGAIN ... ;} \\
At compile time {\tt AGAIN} compiles the run time procedure {\tt BRANCH}
with an offset from {\tt HERE} to "addr". "n" is used for compile time error
checking and should have the value 1.

At run time the {\tt BRANCH} word forces execution back to {\tt AGAIN}
to form an infinite loop. This is only broken by direct manipulation
of the interpretive pointer or return stack eg. {\tt R> DROP} one calling
level below the above loop.

{\tt ALLOT}  \\ (n $\longrightarrow$ ) \\
Add the signed number n to the current value in {\tt DP}, the dictionary
pointer, and return the result to {\tt DP}. This has the effect of allocating
space in the dictionary, for example, for table storage. All dictionary words
require nfa, lfa, cfa and pfa to fall on word boundaries so be careful
not to {\tt ALLOT} a non word quantity. The word size will depend on the
transputer type of the host processor. See {\tt ALIGN}.

{\tt AND} \\ ( n1, n2 $\longrightarrow$ n3) (primitive) \\
Perform the bitwise logical and of values "n1" and "n2" to obtain value "n3".

{\tt ASSEMBLER} \\ ( $\longrightarrow$ ) (VOCABULARY) \\
The home of the assembly code words for creating user defined primitives.
This word is not resident on bootstrap but can be found on disk.

{\tt B/BUF} \\ ( $\longrightarrow$ n) (CONSTANT) \\
Push the constant value of the number of bytes per disk block onto the stack.

{\tt B/SCR} \\ ( $\longrightarrow$ n) (CONSTANT) \\
Push the constant value of disk blocks per forth screen onto the stack.

{\tt BACK} \\ ( addr $\longrightarrow$ ) \\
Calculate the backwards branch offset from {\tt HERE} to "addr" and compile it
into the next available dictionary memory address.

{\tt BANNER} \\ ( $\longrightarrow$ ) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
Print the text that appears when the system bootstraps.

{\tt BASE} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the current number base at addr for input and output conversion.

{\tt BEGIN} \\ ( $\longrightarrow$ addr, 1) (immediate) \\
Used in the form: {\tt : name ... BEGIN ... UNTIL ... ;} \\
or in the form: {\tt : name ... BEGIN ... AGAIN... ;}      \\
or in the form: {\tt : name ... BEGIN ... WHILE ... REPEAT ... ;} \\
At run time {\tt BEGIN} is merely a label for jump sizes to be computed to
in the above three constructs.

At compile time {\tt BEGIN} leaves its return address, which is the current
value of the dictionary pointer {\tt DP}, and the value 1 for
compile time error checking.

{\tt BL}  (Blank) \\ ( $\longrightarrow$ 32) (CONSTANT) \\
Push the constant value of 32, the ascii space, onto the stack.

{\tt BLANKS} \\ ( addr, n $\longrightarrow$ ) \\
Fill memory at "addr" with "n" ascii space characters.

{\tt BLK} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the number of the current disk block being used for interpretation.
If the terminal is the input device the value of {\tt BLK} will be zero.

{\tt BLOCK} \\ ( n $\longrightarrow$ addr ) \\
Leave the memory address of the disk buffer area containing {\tt BLOCK} "n".
If the {\tt BLOCK} is not already in memory it will be transferred from disk to
whichever {\tt BUFFER} was least recently written. If the data occupying
the selected
buffer has been marked for {\tt UPDATE}, it will be written to disk
before "n" is read. See {\tt R/W} and {\tt FLUSH}.

{\tt BLOCK-READ} \\ ( addr, n $\longrightarrow$ ) (primitive) \\
Request the system to read a new block of 1024 bytes from the disk. The data
is taken from the current file at an offset of "n" * 1024 bytes. The data is
placed at "addr". No file error information is returned. See {\tt DISK?} and
{\tt R/W}.

{\tt BLOCK-WRITE} \\ ( addr, n $\longrightarrow$ ) (primitive) \\
Request the system to write a block of 1024 bytes to the disk. The data
is written to the current file at an offset of "n" * 1024 bytes. The data is
read from "addr" in
memory. No file error information is returned. See {\tt DISK?} and
{\tt R/W}.

{\tt BPW}  (Bytes-per-word) \\ ( $\longrightarrow$ 2 OR 4) (CONSTANT) \\
{\it Not included in FIG Forth standard model.} \\
Push the number of bytes in a word onto the stack. Transputer type dependent.

{\tt BRANCH} \\ ( $\longrightarrow$ ) (primitive) \\
The run time procedure to unconditionally branch. An in-line offset, stored
in the next dictionary word, is added to the interpretive pointer causing
a branch forward or backwards depending on its sign.
Used by {\tt ELSE}, {\tt AGAIN} and
{\tt REPEAT}.

{\tt BUFFER} \\ ( n $\longrightarrow$ addr ) \\
Obtain the next memory {\tt BUFFER}, assigning it to {\tt BLOCK} "n".
If the {\tt BUFFER} contents are marked as updated then it is first written to
disk. The new {\tt BLOCK} is not read from the disk. The value of "addr"
is the first address within the {\tt BUFFER} available for data storage.
See {\tt UPDATE}.

{\tt BYE} \\ ( $\longrightarrow$) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
Terminate this session by terminating the system interface and the host
specific server. Control is returned to the host operating system.

{\tt C!} \\ ( char, addr $\longrightarrow$) (primitive) \\
Store byte char at absolute address addr. See {\tt !}and {\tt ALIGN}.

{\tt C,} \\ ( char $\longrightarrow$ )  \\
Store byte "char" into the next available dictionary byte.
The dictionary pointer {\tt DP} is incremented by one.  Use with extreme
caution on transputers as any words following the byte must be word aligned.
Note that {\tt HERE} and {\tt CREATE} are word aligned, so for example,
{\tt HERE} and {\tt DP @} may not give the same result. See
{\tt ,} and {\tt ALIGN}.

{\tt C/L} \\ ( $\longrightarrow$ n) (CONSTANT) \\
Push the constant value of the number of characters per text output line
onto the stack.

{\tt C@} \\  ( addr $\longrightarrow$ char) (primitive) \\
Replace the value on the stack with the byte value from that address.

{\tt CFA} \\ (pfa $\longrightarrow$ cfa) \\
Convert the parameter field address of a word into its code field address.

{\tt CMOVE} \\ ( addr1, addr2, n $\longrightarrow$)
(primitive) \\
Move "n" bytes from "addr1" to "addr2".
Neither source or dest need be word aligned and it is expected
that the copy is byte by byte starting with the first byte at "addr1".
Source and destination may
overlap preventing the direct inclusion of the transputer block
move instruction. A separate word called {\tt MOVE} has this function.

{\tt COLD} \\ ( $\longrightarrow$ ) (primitive) \\
Restarts the system from cold. Values are copied from the origin to reset
the stacks, disk buffer space and dictionary to the cold boot values.
A call is made to {\tt QUIT} to accept new input from the terminal.
See {\tt WARM} and {\tt ABORT}.

{\tt COMPILE} \\ ( $\longrightarrow$ ) \\
When {\tt COMPILE} executes the value already in the next interpreted location
is copied (compiled) into the next dictionary location. This allows the user
to control unusual compilation situations.

{\tt CONSTANT} \\ ( n $\longrightarrow$ ) (Defining word) \\
Used in the form: {\tt n CONSTANT name} \\
Creates word "name" with parameter field containing "n". When "name" is
executed the value of "n" will be pushed onto the stack.

{\tt CONTEXT} \\ ( $\longrightarrow$ addr) (USER) \\ Contains a pointer to the
vocaubulary in which dictionary searches begin.  See {\tt -FIND}.

{\tt COUNT} \\ (addr $\longrightarrow$ addr+1, n) \\
Set up the address of a string "addr+1", and the string length "n" in a manner
suitable for {\tt TYPE}. The length "n" is obtained from the first byte
value stored at "addr". The text is assumed to start immediately after this.

{\tt CR}  (Carriage-return) \\ ( $\longrightarrow$ ) (primitive) \\
Transmit carriage-return line-feed to the output device. This procedure
does not use {\tt EMIT} and thus has no effect on {\tt OUT}.

{\tt CREATE} \\ ( $\longrightarrow$ ) \\
Used in the form: {\tt CREATE name} \\
Used by such as {\tt VARIABLE} and {\tt CONSTANT} to create a dictionary header
for a Forth definition. The code field contains the address of the word's
parameter field. The new definition is created in the {\tt CURRENT}
vocabulary.

{\tt CSP} \\ ( $\longrightarrow$ addr) (USER) \\
Contains a temporary store of the stack pointer position. Used for
compiler security.

{\tt CURRENT} \\ ( $\longrightarrow$ addr) (USER) \\
Contains a pointer to the second vocabulary to search should a search
through the {\tt CONTEXT} vocabulary fail. This is also the vocabulary
in which new word definitions will be placed. See {\tt :} and {\tt -FIND}.

{\tt D+} (Double-plus) \\ ( dlo1, dhi1, dlo2, dhi2,
$\longrightarrow$ dlo3, dhi3 ) (primitive) \\
Generate the signed double word sum d3, of two double word signed
numbers on the stack.

{\tt D+-} \\ ( dlo, dhi, n $\longrightarrow$ d2lo, d2hi) \\
Apply the sign of "n" to the double number on the stack.

{\tt D.} (D-dot) \\ ( dlo, dhi $\longrightarrow$ ) \\
Print a signed double word number according to the value of {\tt BASE}.
A space is printed after the number.

{\tt D.R} \\ ( dlo, dhi, n  $\longrightarrow$ ) \\
Print a signed double word number, according to the value of {\tt BASE},
right aligned in a field "n" characters wide.

{\tt DABS} \\ ( dlo, dhi $\longrightarrow$ d2lo, d2hi ) \\
Generate the absolute value from a signed double word number.

{\tt DECIMAL} \\ ( $\longrightarrow$ )  \\
Set the contents of {\tt BASE} to the value
ten to control numeric input and output
formatting. This is the default after {\tt ABORT}.

{\tt DEFINITIONS} \\ ( $\longrightarrow$ ) \\
Set the {\tt CURRENT} vocabulary to the {\tt CONTEXT} vocabulary.
See {\tt VOCABULARY}.

{\tt DEPTH} \\ ( $\longrightarrow$ n ) \\
{\it Not included in FIG Forth standard model.} \\
Return "n", the number of word values on the parameter stack.

{\tt DIGIT} \\ ( char, n  $\longrightarrow$ 0 OR n2, 1 ) (primitive) \\
Convert the ascii numeric character "char" into its binary equivalent
in base "n"
(ie. 49 $\longrightarrow$ 1 as '0'=48) accompanied
by a boolean. If conversion is invalid the character value
is removed and just the zero returned.

{\tt DISK?} \\ ( $\longrightarrow$ n) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
Request the system for the disk error status of the current file. A value
of zero denotes no errors. All other numbers will be host specific.

{\tt DLIST} \\ ( $\longrightarrow$ ) \\
An alias for {\tt VLIST}. Lists the words in the {\tt CONTEXT} vocabulary.

{\tt DLITERAL} \\ ( dlo dhi $\longrightarrow$ ) (immediate) \\
Compile the double word stack
value as two word length literals. This allows a constant
in a procedure to be calculated at run time eg. \\
{\tt : name ... [ calculate dnumber ] DLITERAL ... ;} \\
The calculation puts two words on the stack, {\tt DLITERAL} compiles them
into the dictionary so they will be put on the stack at run time.
See {\tt LIT} and {\tt LITERAL}.

{\tt DMINUS} \\ ( d1lo, d1hi $\longrightarrow$ d2lo, d2hi) (primitive) \\
Negate the double
word value d1 in a signed sense by subtracting it from zero to generate
the double value d2.

{\tt DO} \\ (  $\longrightarrow$ addr, 3) (immediate) \\
Used in the form: {\tt : name ... DO ... LOOP ...  ;} \\
or in the form: {\tt : name ... DO ... +LOOP ...  ;} \\
When compiled within a colon definition the word {\tt (DO)} is compiled.
At run time this will control the start of an iterative loop.
The values "addr" and "3" are left for jump sizing and error checking.

{\tt DOES>} \\ ( $\longrightarrow$ ) \\
Used in the form: {\tt : name1 <BUILDS ... DOES> ... ;} \\
and then in the form: {\tt name1 name2} \\
{\tt DOES>} defines the run time action within a high level defining word.
It alters the code field and first parameter of the new word to execute the
sequence of compiled word address that follow {\tt DOES>}.

{\tt DP} \\ ( $\longrightarrow$ addr) (USER) \\
The variable containing the current value of the dictionary pointer.
See {\tt ALLOT} and {\tt HERE}.

{\tt DPL} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the number of digits to the right of the decimal point on double
word integer input. The default value on single word input is -1.

{\tt DR0 and DR1} \\ (NOT IMPLEMENTED) \\
See {\tt USING}.

{\tt DROP} \\ ( n $\longrightarrow$ ) (primitive) \\
Drop the current value at top of stack.

{\tt DUMP} \\ (NOT IMPLEMENTED) \\ Better for user to declare his own, for
example unsigned hex dump is useful on transputers.  An example of a hex
dump is supplied on disk.

{\tt DUP} \\ ( n $\longrightarrow$ n, n) (primitive) \\
Duplicate the current top of stack value.

{\tt EDITOR} \\ ( $\longrightarrow$ ) (VOCABULARY) \\
{\it Not included in FIG Forth standard model.} \\
The home of the screen editing definitions.
This word is not resident on bootstrap but can be found on disk.

{\tt ELSE} \\ (addr1, n1 $\longrightarrow$ addr2, n2) (immediate) \\
Used in the form: {\tt : name ... IF ... ELSE ... ENDIF ... ; } \\
At run time {\tt ELSE} executes after the true part following an {\tt IF}
and causes the skip over the false part with no effect on the stack.
At compile time {\tt ELSE} compiles {\tt BRANCH}, resolves the jump
size after {\tt IF} at "addr1" and leaves a reference to "addr2" which
will be resolved on the execution of {\tt ENDIF}. "n1" and "n2" are used
for error testing.

{\tt EMIT} \\ (char $\longrightarrow$ ) \\
Print the ascii value on the stack to the current output device. The
{\tt USER} variable {\tt OUT} is incremented by one. See {\tt (EMIT)}.

{\tt EMPTY-BUFFERS} \\ ( $\longrightarrow$ ) \\
Marks all disk {\tt BUFFER}s as empty. The {\tt BUFFER}s are not cleared.
Updated blocks are not written to disk.

{\tt ENCLOSE} \\ ( addr, char $\longrightarrow$
addr2, n1, n2, n2+1) (primitive) \\
The text scanning primitive used by {\tt WORD}. From the text address addr,
using delimeter "char", the following are determined. "n1" is the byte offset
from "addr" to the first non-delimeter character in the string. "n2" is the
offset to the first delimiting character after the text. The lowest value
on the stack is used to denote the offset to the next string after this one.
This procedure will assume all zero valued bytes are unconditional
delimeters.

{\tt END} \\ ( addr, n $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name ... BEGIN ... END ... ;} \\
An alias for {\tt UNTIL}.

{\tt ENDIF} \\ ( addr, n $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name ... IF ... ENDIF ... ;} \\
or in the form: {\tt : name ... IF ... ELSE ... ENDIF ... ;} \\
Computes the forward branch offset from "addr" to {\tt HERE} and stores it
at "addr". "n" is used for compiler security and should have value 2.
Same as {\tt THEN}.

{\tt ERASE} \\ ( addr, n $\longrightarrow$ ) \\
Fill memory at addr with "n" byte values of zero.

{\tt ERROR} \\ ( n $\longrightarrow$ n2, n3) \\
Execute an error message and restart system. {\tt WARNING} is examined
to determine whether to just print the error number ({\tt WARNING} = 0),
to print a message relative to disk screen 4 ({\tt WARNING} = 1) or
execute the {\tt (ABORT)} word. The user may change the {\tt (ABORT)} word
to include a user defined procedure. {\tt ERROR} finishes by returning "n2",
the value of {\tt IN} and "n3" the value of {\tt BLK}. {\tt QUIT} is executed
next which returns control to the terminal.

{\tt EXECUTE} \\ ( cfa $\longrightarrow$ ) (primitive) \\
Excecute the definition whose code field address is on the stack. Code
field addresses are also compilation addresses inside a colon definition.

{\tt EXPECT} \\ ( addr, count $\longrightarrow$ ) \\
Transfer characters from the terminal to addr, until a return or count
characters have been received. One or more zeros are added to the end
of the text.

{\tt FENCE} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the address below which {\tt FORGET} is unable to delete.

{\tt FILL} \\ ( addr, n, char $\longrightarrow$ ) \\
Fill the memory at addr with "n" bytes of value char.  See {\tt CMOVE}.

{\tt FIRST} \\ ( $\longrightarrow$ addr) \\
Returns the constant address of the start of the disk buffer area.

{\tt FLD} \\ ( $\longrightarrow$ addr) (USER) \\
A {\tt USER} variable recommended for
controlling number output field width.
This variable is not referenced by any other system word.

{\tt FLUSH} \\ ( $\longrightarrow$ ) \\
Ensure that all disk {\tt BUFFER}s marked for {\tt UPDATE} are copied to
disk. The {\tt UPDATE} bits on all {\tt BUFFER}s are cleared but
the {\tt BUFFER} contents remain unaffected.

{\tt FORGET} \\ ( $\longrightarrow$ ) \\
Used in the form: {\tt FORGET word} \\
Deletes definition "name" from the dictionary with all words that followed
it. An error occurs if {\tt CURRENT} and {\tt CONTEXT} are different.
It is illegal to do a {\tt FORGET} which includes the current vocabulary
definition itself. A {\tt VOCABULARY} can be forgotten by being in another
vocabulary which contains it.
See {\tt FENCE}.

{\tt FORTH} \\ ( $\longrightarrow$ ) (VOCABULARY, immediate) \\
The system root vocabulary. All other vocabularies chain to {\tt FORTH}.
See {\tt CONTEXT} and {\tt CURRENT}.

{\tt HERE} \\ ( $\longrightarrow$ addr) \\
Obtain the address of the next available dictionary word
location. This is the value of {\tt DP} aligned to the next word boundary.

{\tt HEX} \\ ( $\longrightarrow$ )  \\
Set the contents of {\tt BASE} to the value sixteen to
control numeric input and output
formatting. Hexadecimal output is not prefixed with a \#.

{\tt HLD} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the address of the latest character of text during numeric
output conversion. See {\tt HOLD} and {\tt PAD}.

{\tt HOLD} \\ ( char $\longrightarrow$ ) \\
Used between {\tt $<$\#} and {\tt \#$>$} to insert an ascii character
into a numeric output string. eg. {\tt 46 HOLD} will place a decimal point.
See {\tt PAD}.

{\tt I} \\ ( $\longrightarrow$ n) (primitive) \\
Used within a {\tt DO} loop construct to copy the loop index to the stack.
In effect it copies the current top of return stack to the parameter stack.
See {\tt R}.

{\tt ID.} \\ ( nfa $\longrightarrow$ ) \\
Print a definitions name from its name field address.

{\tt IF} \\ (  $\longrightarrow$ addr, 2 ) (immediate) \\
Used in the form: {\tt : name ... IF ... ENDIF ... ; } \\
or in the form: {\tt : name ... IF ... ELSE ... ENDIF ... ; } \\
At run time {\tt IF} selects, according to the value on the stack, to
jump on zero to the {\tt ELSE} or to continue execution and jump to
{\tt ENDIF} on reaching the {\tt ELSE}.
At compile time {\tt IF} compiles {\tt 0BRANCH} and reserves space for
an offset at "addr". "addr" and "n" are required to resolve the jump
offsets and test for errors respectively.

{\tt IMMEDIATE} \\ ( $\longrightarrow$ ) \\
Mark the most recent definition, as defined by {\tt LATEST}, by toggling
the immediate bit (bit 6) in it's name length byte. This will allow
the word to always execute, even when compiling. {\tt IMMEDIATE} words
can be forced to compile using {\tt [COMPILE]}.

{\tt IN} \\ ( $\longrightarrow$ addr) (USER) \\
The byte offset into the text input buffer from which the next text
will be accepted. Used by {\tt WORD}.

{\tt INDEX} \\ ( n1, n2 $\longrightarrow$ ) \\
Print the first line of each screen starting with "n1" up to screen "n2".
This is used to view the top line of the screen as a comment line defining
what is on the rest of the screen.

{\tt INTERPRET} \\ ( $\longrightarrow$ ) \\
The outer text interpreter which sequentially executes or compiles text
from the input stream according to the value of {\tt STATE}. If a word
cannot be found in the {\tt CONTEXT} or {\tt CURRENT} vocabularies then
the attempt will be made to convert it into a number according to {\tt BASE}.
If this fails an error message will be given. Text input is done using {\tt
WORD}. If a decimal point is found a double number will be created and
{\tt DPL} set. See {\tt NUMBER}.

{\tt J} \\ ( $\longrightarrow$ n) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
Used within nested {\tt DO} loops to obtain the index of a {\tt DO} loop
outside the
{\tt DO} loop that is currently being executed. In effect it copies the third
value from the return stack onto the parameter stack.

{\tt K} \\ ( $\longrightarrow$ n) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
Used within nested {\tt DO} loops to obtain the index of a {\tt DO} loop
which is two loops outside the
DO loop currently being executed. In effect it copies the fifth
value from the return stack onto the parameter stack.

{\tt KEY} \\ ( $\longrightarrow$ char) (primitive) \\
Leave the ascii value of the next terminal key to be pressed. The value
received will be a word on the stack and if char $>$ 256 it will be
a special terminal key. See {\tt UP}, {\tt DOWN}, {\tt LEFT} and {\tt RIGHT}.

{\tt LATEST} \\ ( $\longrightarrow$ addr) \\
Obtain the name field address of the topmost word in the {\tt CURRENT}
vocabulary.

{\tt LEAVE} \\ ( $\longrightarrow$ ) (primitive) \\
Force termination of a {\tt DO} loop by setting the loop limit equal to the
current value, both stored on the return stack. The index remains unchanged
and execution proceeds until the next {\tt (LOOP)} or {\tt (+LOOP)}.

{\tt LFA} \\ ( pfa $\longrightarrow$ lfa) \\
Obtain the link field address of a word from its parameter field address on
the stack.

{\tt LIMIT} \\ ( $\longrightarrow$ addr) \\
This is used to generate "addr",
the end of the disk buffer storage area. It is
set to the address one beyond the end of memory
as used by the system. This may not actually be the
end of memory depending on the host hardware in use.

{\tt LIST} \\ ( n $\longrightarrow$ ) \\
Display the ascii text of screen "n" on the selected output device. {\tt SCR}
contains the screen number used during and after this printing.

{\tt LIT} \\ ( $\longrightarrow$ n) (primitive) \\
Within a colon definition {\tt LIT} is
automatically compiled before each literal
value found in the input text. Execution of {\tt LIT}
causes the contents of the
next dictionary location to be pushed onto the stack.

{\tt LITERAL} \\ ( n $\longrightarrow$ ) (immediate) \\
Compile the stack value as a word length literal. This allows a constant
in a procedure to be calculated at run time eg. \\
{\tt : name ... [ calculate ] LITERAL ... ;} \\
The calculation puts a number on the stack, {\tt LITERAL} compiles it.
See {\tt LIT} and {\tt DLITERAL}.

{\tt LOAD} \\ ( n $\longrightarrow$ ) \\
Begin interpretation of screen "n". Loading will terminate at the end
of the screen or at {\tt ;S}. See {\tt -->}.

{\tt LOOP} \\ ( addr, n $\longrightarrow$ ) (immediate) \\
Compiles the run time procedure {\tt (LOOP)} which increments the loop
index by 1 and tests for loop completion. The loop index is the first value
on the return stack, the loop limit the second. When the loop index is
equal to the limit the loop will finish. The value stored in
the dictionary after {\tt (LOOP)} is the jump to be taken, to repeat the loop,
with respect to the current Forth interpretive pointer.
At compile time {\tt LOOP} uses "addr" to calculate an offset to the most
recent {\tt (DO)}. "n" is used for error checking and should have value 3. See
{\tt DO}.

{\tt M*} \\ ( n1, n2 $\longrightarrow$ dlo, dhi ) \\
A mixed magnitude operator which creates the double word signed product
of two single word values.

{\tt M/} \\ ( dlo, dhi, n $\longrightarrow$ n1, n2 ) \\
A mixed magnitude operator which creates the remainder "n1" and quotient "n2"
from dividing the double number on the stack by "n". The remainder takes
its sign from the dividend.

{\tt M/MOD} \\ ( dlo, dhi, n $\longrightarrow$ n1, d2lo, d2hi ) \\
A unsigned mixed
magnitude operator which creates the remainder "n1" and double quotient
from dividing the double number on the stack by "n" in an unsigned sense.
Both "n" and "n1" are treated as unsigned.

{\tt MAX} \\ ( n1, n2 $\longrightarrow$ n1 OR n2 ) \\
Leave the unsigned maximum of two signed numbers on the stack.

{\tt MESSAGE} \\ ( n $\longrightarrow$ ) \\
Print on the output device the text on line "n" relative to screen 4 of
the current screen file. "n" may be negative. If {\tt WARNING} = 0
the message will be simply printed as a number.

{\tt MIN} \\ ( n1, n2 $\longrightarrow$ n1 OR n2 ) \\
Leave the unsigned minimum of two signed numbers on the stack.

{\tt MINUS} \\ ( n1 $\longrightarrow$ n2) (primitive) \\
Negate "n1" in a signed sense by subtracting it from zero to generate "n2".

{\tt MOD} \\ ( n1, n2 $\longrightarrow$ n3 ) \\
Leave the remainder "n3" of "n1/n2" with the same sign as "n1".

{\tt MON} \\ (NOT IMPLEMENTED)

{\tt MOVE} \\ ( add1, addr2, n $\longrightarrow$ ) (primitive) \\
Move "n" words from "addr1" to "addr2". This word uses the transputer block
move hence source and
destination areas should not overlap. See {\tt CMOVE}

{\tt NEWFILE} \\ ( addr $\longrightarrow$ boolean ) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
The primitive required by {\tt USING} to request a change of disk screen
file from the system. "addr" is the address of the length byte prefixed text
string representing the name of the new file to be used. The previous
disk screen file will be closed. The procedure returns 0 if successful.
See {\tt USING} and {\tt (USING)}.

{\tt NEXT} \\ (NOT IMPLEMENTED) \\
The inner interpreter is not one location as it is handled
by in-line code after each primitive definition.

{\tt NFA} \\ (pfa $\longrightarrow$ nfa) \\
Convert the parameter field address of a word into its name field address.
See {\tt TRAVERSE}.

{\tt NOT} \\ ( n1 $\longrightarrow$ n2 )  (primitive) \\
{\it Not included in FIG Forth standard model.} \\
Perform the bitwise not, or ones complement, of the number on the stack.

{\tt NULL} \\ ( $\longrightarrow$ n) (CONSTANT) \\
{\it Not included in FIG Forth standard model.} \\
Push the constant value of the most negative integer that fits into a
word onto the stack. This value of $2^{31}$ or $2^{15}$ depends on the
wordlength of the designated transputer host.  This value is used to denote
the address of the base of memory. In addition, with a
signed address space it is
inappropriate for a list to end with zero, hence the dictionary chain is
terminated with a {\tt NULL}.

{\tt NUMBER} \\ ( addr $\longrightarrow$ dlo, dhi) \\
Convert a character string left at "addr",
with included byte count, to a double
word signed number, using the current value of {\tt BASE}. A trailing space or
zero is expected after the string. If
a decimal point is
encountered in the text, its position will be stored in {\tt DPL}, but
no other effect occurs. If numeric conversion fails an error message is
given.

{\tt OFFSET} \\ ( $\longrightarrow$ addr) (USER) \\
May contain a block offset to a set of disk screens. Used by {\tt BLOCK}.
Messages using {\tt MESSAGE} are independent of {\tt OFFSET}.

{\tt OR} \\ ( n1, n2 $\longrightarrow$ n3) (primitive) \\
Perform the bitwise logical or of values "n1" and "n2" to obtain value "n3".

{\tt OUT} \\ ( $\longrightarrow$ addr) (USER) \\
Contains a number incremented by {\tt EMIT} for every character printed.
This can be used to control the format of the output.

{\tt OVER} \\ ( n1, n2 $\longrightarrow$ n1, n2, n1) (primitive) \\
Copy the second value on the stack and push it onto the stack.

{\tt PAD} \\ ( $\longrightarrow$ addr ) \\
Returns the address to be used for numeric output formatting. This address
is 34 machine words above the dictionary.

{\tt PFA} \\ (nfa $\longrightarrow$ pfa) \\
Convert the name field address of a word into its parameter field address.
See {\tt NFA} and {\tt TRAVERSE}.

{\tt PREV} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the address of the disk screen most recently referenced. The
word {\tt UPDATE} marks this buffer to be later written to disk.

{\tt QUERY} \\ ( $\longrightarrow$ ) \\
Input 80 characters of text, or that given up to a return, from the terminal.
The text is position at the address contained in {\tt TIB} with {\tt IN} set
to zero. See {\tt EXPECT}.

{\tt QUIT} \\ ( $\longrightarrow$ ) \\
Clear the return stack, stop compilation and return control to the terminal.
No message is given. See {\tt STATE} and {\tt ABORT}.

{\tt R} \\ (  $\longrightarrow$ n) (primitive) \\
Copy a value from the return stack onto the parameter stack. This can be used
to determine the word that follows the current one in execution. The action
is identical to {\tt I}. See {\tt R>} and {\tt >R}.

{\tt R\#} \\ ( $\longrightarrow$ addr) (USER) \\
The recommended variable to
contain the location of an editing cursor or other file related function.

{\tt R/W} \\ ( addr, n, boolean $\longrightarrow$ )  \\
The standard disk read/write word. "addr" specifies the source or destination
{\tt BLOCK} number to be used as an absolute address.
"n" is the sequential number
 of the referenced {\tt BLOCK}. To write a {\tt BLOCK} "boolean"=0, to read
 "boolean"=1. {\tt R/W} determines the location on mass storage and then
performs the read or write with associated error testing. See {\tt USING}.

{\tt R>} \\ (  $\longrightarrow$ n) (primitive) \\
Remove a number from the return stack and push it onto the parameter
stack. This should be balanced with {\tt >R} in the same definition or
the control of what runs next will be changed. Sometimes this is the
intention!

{\tt R0} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the starting address of the return stack pointer.

{\tt REPEAT} \\ ( addr, n $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name ... BEGIN ... WHILE ... REPEAT ... ;} \\
At run time {\tt REPEAT} executes a {\tt BRANCH} back to the corresponding
{\tt BEGIN}. At compile time {\tt REPEAT} compiles {\tt BRANCH} and the
offset from {\tt HERE} to "addr". "n" is used for error testing.

{\tt ROT} \\ (n1, n2, n3 $\longrightarrow$ n2, n3, n1) (primitive) \\
Rotate the top three values on the stack bringing the third value to the top.

{\tt RP!} \\ ( $\longrightarrow$ ) (primitive) \\
Initialise the return stack pointer from the value stored in the origin table.
This boot-up literal value is normally only referenced on a {\tt COLD} start.

{\tt S->D} \\ (n $\longrightarrow$ dlo, dhi ) (primitive) \\
Sign extend a single word number to form a double word value.

{\tt S0} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the starting address for the stack pointer.

{\tt SCR} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the disk screen number most recently referenced by {\tt LIST}.

{\tt SIGN} \\ ( n, dlo, dhi $\longrightarrow$ dlo, dhi) \\
Stores an ascii '-' character before a numeric output string at {\tt HOLD}
when the value of "n" is negative. "n" is discarded. Should be used
between {\tt <\#} and {\tt \#>}.

{\tt SMUDGE} \\ ( $\longrightarrow$ ) \\
Toggle the smudge bit (bit 5) in the {\tt LATEST} definitions name field.
This prevents incomplete definitions from being included in dictionary
searches.

{\tt SP!} \\ ($\longrightarrow$) (primitive) \\
Initialise the stack pointer from the value stored in the origin table.
This boot-up literal value is normally only referenced on a {\tt COLD} start.

{\tt SP@} \\ ( $\longrightarrow$ addr) (primitive) \\
Push the current stack pointer value onto the stack.

{\tt SPACE} \\ ( $\longrightarrow$ ) \\
Print an ascii space character on the current output device. This uses
the {\tt EMIT} word so that {\tt OUT} will be incremented. {\tt See SPACES}.

{\tt SPACES} \\ ( n $\longrightarrow$ ) \\
Print "n" ascii space characters on the current output device. This uses
the {\tt EMIT} word so that {\tt OUT} will be incremented. See {\tt SPACE}.

{\tt STATE} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the compilation state. A non-zero value indicates that compilation
is currently underway. See {\tt [}, {\tt ]} and {\tt INTERPRET}.

{\tt SWAP} \\ ( n1, n2 $\longrightarrow$ n2, n1) (primitive) \\
Exchange the two values which are currently on top of the stack.

{\tt TASK} \\ ( $\longrightarrow$ ) \\
A no-operation word that marks the application boundary areas. {\tt TASK}
is the last word in the precompiled system.

{\tt THEN} \\ ( addr, n $\longrightarrow$ ) (immediate)  \\
Used in the form: {\tt : name ... IF ... THEN ... ;} \\
or in the form: {\tt : name ... IF ... ELSE ... THEN ... ;} \\
An alias for {\tt ENDIF}.

{\tt TIB} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the address of the terminal input buffer.

{\tt TOGGLE} \\ (  addr, n  $\longrightarrow$ ) (primitive) \\
Complement the contents of "addr" with the bit values in "n".

{\tt TRAVERSE} \\ ( addr1, n $\longrightarrow$ addr2) \\
Move across the name field of a variable length name field. "addr1" is the
address of either the address byte or the last letter. If "n" = 1 the motion is
towards high memory, for "n" = -1 the motion is towards low memory. The value
of "addr2" is the address at the other end of the name string. Note that
both ends of a name string are marked with the sign bit set by {\tt CREATE}.

{\tt TRIAD} \\ ( n $\longrightarrow$ ) \\
Display on the selected output device the three screens which include
screen "n" and start with the value of "n" divisible by three. Output is
a convenient format for source text records. A reference line is included
from screen 4 line 15. The listing is prefixed with the form feed character
to assist with aligning printouts.

{\tt TYPE} \\ (addr, n $\longrightarrow$ ) \\
Transmit "n" characters from "addr" to the output device.
{\tt EMIT} is used so that {\tt OUT}  will be increased by n.

{\tt U*} \\ ( n1, n2 $\longrightarrow$ d) (primitive) \\
Leave the unsigned double number product of two single unsigned
numbers.

{\tt U.} \\ ( n $\longrightarrow$ ) \\
{\it Not included in FIG Forth standard model.} \\
Print "n" on the terminal output as an unsigned value according to {\tt BASE}.

{\tt U/} \\ ( dlo, dhi, n $\longrightarrow$ n1, n2)  \\
Leave the unsigned remainder "n1" and unsigned quotient "n2"
from the unsigned operation of dividing the double value d by "n".
Errors will be generated for divide by zero and when the result of the
division will not fit into "n2", ie overflow. See {\tt (U/)}.

{\tt UNTIL} \\ ( addr, n $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name ... BEGIN ... UNTIL ... ;} \\
At run time {\tt UNTIL} becomes the execution of {\tt 0BRANCH} to a matching
{\tt BEGIN}. The value in the next word is the jump to take when the top of
stack value is zero. At compile time {\tt UNTIL}
compiles {\tt 0BRANCH} and an offset from {\tt HERE} to
"addr". "n" is used for error checking and should have value 1. Same as {\tt
END}.

{\tt UPDATE} \\ ( $\longrightarrow$ ) \\
Marks the most recently referenced {\tt BLOCK}, pointed to by {\tt PREV},
as altered and therefore requiring updating to the disk. The {\tt BLOCK}
will subsequently be transfered to disk should its buffer be required by
a different {\tt BLOCK}.

{\tt USE} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the address of the {\tt BLOCK} buffer to use next. This is the {\tt
BLOCK} determined to be the least recently written.

{\tt USER} \\ ( n $\longrightarrow$ ) (Defining word) \\
Used in the form: {\tt n USER name} \\
Creates {\tt USER} variable called
"name" with parameter field containing "n". {\tt USER}
variables refer to an area in memory
containing system variables such as {\tt DP}, {\tt BASE}
and {\tt STATE}. The system retains a pointer to the {\tt USER} area. The
value of "n" becomes a word offset from the {\tt USER} area pointer.
When "name" is executed the address of "n" words above the {\tt USER}
pointer will be pushed onto the stack.
Note that space has been allocated for only 31 {\tt USER} variables of
which 26 are used by the system. Free locations are 0, 1, 2, 13 and 14.
See {\tt VARIABLE}.

{\tt USING} \\ ( $\longrightarrow$ boolean ) (immediate) \\
{\it Not included in FIG Forth standard model.} \\
Used in the form: {\tt USING filename.scr} \\
Requests a change of disk screen file from the system.
The previous disk screen file will be closed.
If the new file cannot be opened the old file will be reopened. The
procedure returns 0 if the new file is successfully opened.
See {\tt (USING)} and {\tt NEWFILE}.

{\tt VARIABLE} \\ ( n $\longrightarrow$ ) (Defining word) \\
Used in the form: {\tt n VARIABLE name} \\
Creates word "name" with parameter field containing "n". When "name" is
executed the address of "n" will be pushed onto the stack thus enabling
the value of the variable to be modified.

{\tt VLIST} (Verb-list) \\ ( $\longrightarrow$ ) \\
List the names of the words in the {\tt CONTEXT} vocabulary. Pressing any
key will terminate the listing. Forth words are sometimes referred to as
verbs, hence the name. Same as {\tt DLIST}.

{\tt VOC-LINK} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the address of a field in the most recently declared vocabulary
word. All {\tt VOCABULARY}
words are linked by these fields to allow {\tt FORGET}
to work through multiple vocabularies. See {\tt FORTH} and {\tt ASSEMBLER}.

{\tt VOCABULARY} \\ ( $\longrightarrow$ ) (Defining word) \\
Used in the form: {\tt VOCABULARY name} \\
A defining word used to create new vocabularies as words in the dictionary.
Subsequent uses of "name" will make it the {\tt CONTEXT} vocabulary
which is searched first by {\tt INTERPRET}.  All vocabularies are chained
to include all definitions of the vocabulary in which "name" is itself
declared. All vocabularies ultimately chain to {\tt FORTH}. By convention
vocabularies are immediates. See {\tt VOC-LINK} and {\tt DEFINITIONS}.

{\tt WARM} \\ ( $\longrightarrow$) (primitive) \\
{\it Not included in FIG Forth standard model.} \\
Restart the system by resetting the stacks and accepting new text from
the terminal. This has no effect on the disk buffer space or dictionary.
Called by {\tt COLD}.

{\tt WARNING} \\ ( $\longrightarrow$ addr) (USER) \\
Contains a value that controls the production of error messages.
When {\tt WARNING} contains the value 1 the disk is assumed to be present and
all messages are printed using disk screen 4 as the base for the text.
When {\tt WARNING} contains zero just the error number is printed.
If {\tt WARNING} contains -1 then the system executes {\tt (ABORT)} for
a user specified procedure. See {\tt MESSAGE} and {\tt ERROR}.

{\tt WHILE} \\ ( addr, n $\longrightarrow$ addr, n, addr1, n1) (immediate) \\
Used in the form: {\tt : name ... BEGIN ... WHILE ... REPEAT ... ; } \\
At run time {\tt WHILE} uses the top of stack value to decide to jump
beyond {\tt REPEAT} when zero or to do nothing. The top of stack value is
removed. At compile time , {\tt WHILE} compiles {\tt 0BRANCH} and leaves
"addr1" to be resolved by {\tt REPEAT}. "n" and "n1" are used for error
testing.

{\tt WIDTH} \\ ( $\longrightarrow$ addr) (USER) \\
Contains the maximum name field length allowed in the system.

{\tt WORD} \\ ( char $\longrightarrow$ ) \\
Read the next word from the input stream until the delimeter "char" is found
or the end of input is reached. The byte value zero is considered an
unconditional delimeter. The packed string is transfered to {\tt HERE}
with a prefixing length byte. Two or more ascii spaces always follow the
copied text. Leading occurances of "char" will be ignored. If {\tt BLK} is zero
then text is taken from the terminal input, otherwise the text is read from
the disk screen numbered by the value of {\tt BLK}. See {\tt IN}.

{\tt XOR} \\ ( n1, n2 $\longrightarrow$ n3) (primitive) \\
Perform the bitwise logical exclusive or
of values "n1" and "n2" to obtain value "n3".

{\tt [} \\ ( $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name ... [ ... words ... ] ... ;} \\
Suspend compilation. The words between the square brackets are executed
instead of compiled.

{\tt [COMPILE]} \\ ( $\longrightarrow$ ) (immediate) \\
Used in the form: {\tt : name ... [COMPILE] word ... ;} \\
Forces compilation of an immediate "word" so that when "name" executes word
will execute then and not at compile time.

{\tt ]} \\ ( $\longrightarrow$ ) \\
Used in the form: {\tt : name ... [ ... words ... ] ... ;} \\
Resume compilation after it was suspended by {\tt [}.
