Symbols/Numbers

NAME            : !
PRONOUNCIATION  : "store"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 16b addr ---   )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Stores 16 at addr.
LONG DEFINITION : 16b is stored at addr.


NAME            : #
PRONOUNCIATION  : "sharp"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( +d1 --- +d2 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             : Bytes below  PAD  modified  as  temporary  area
                  where +d1 is converted to string.
INPUT           :
OUTPUT          :
GROUP           : Format
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: +d1  is  divided  by BASE and the quotient is
                  placed onto the stack.   The remainder is  con-
                  verted  to  an  ASCII character and appended to
                  the  output  string  toward  lower  memory  ad-
                  dresses.
LONG DEFINITION : The  remainder  of +d1 divided by the value of
                  BASE is converted to an ASCII character and ap-
                  pended to the output string toward lower memory
                  addresses.   +d2 is the quotient and  is  main-
                  tained for further processing.   Typically used
                  between  <# and #> .


NAME            : #>
PRONOUNCIATION  : "sharp-greater"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 32b --- addr +n )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 2
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Format
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Terminates  formatted  (or   pictured)   output
                  string (ready for TYPE  ).
LONG DEFINITION : Pictured  numeric  output  conversion is ended
                  dropping 32b.   addr  is  the  address  of  the
                  resulting  output string starting +n characters
                  below pad.   +n is the number of characters  in
                  the  output string.    addr and +n together are
                  suitable for TYPE .


NAME            : #S
PRONOUNCIATION  : "sharp-s"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( +d --- 0 0 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 2
RETURN STACK    :
DICTIONARY      :
PAD             : Bytes below  PAD  modified  as  temporary  area
                  where +n is converted to string.
INPUT           :
OUTPUT          :
GROUP           : Format
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Converts  all digits of an entire number into
                  string.
LONG DEFINITION : +d is converted apppending each resultant  into
                  the  pictured  numeric  output string until the
                  quotient (see:  #  ) is zero.  A single zero is
                  added to the output string if  the  number  was
                  initially  zero.    Typically  used between  <#
                  and  #> .


NAME            : #TIB
PRONOUNCIATION  : "number-t-i-b"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   --- addr )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : I/O
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Returns the address of the user  variable  that
                  holds the number of characters input.
LONG DEFINITION : The  address  of a user variable containing the
                  number of bytes in the text input buffer.  #TIB
                  is accessed by WORD when BLK is zero.


NAME            : '
PRONOUNCIATION  : "tick"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   --- addr )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : <name> is removed from input stream.
OUTPUT          :
GROUP           : Dictionary
ATTRIBUTE       : M 83
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Returns <name>'s PFAPTR, addr.
LONG DEFINITION : Used in the form:  ' <name>  .  addr is the
                  PFAPTR of <name>.  An error condition exists
                  if <name> is not found in the  currently
                  active search order.


NAME            : (
PRONOUNCIATION  : "paren"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : Characters  up  to  )  are  removed from input
                  stream.
OUTPUT          :
GROUP           : Compiler
ATTRIBUTE       : I
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Starts a comment input.
                  Comment is ended by a  )  .
LONG DEFINITION : Used in the form:  ( ccc)  .    The  characters
                  ccc,  delimited  by ) (close parenthesis),  are
                  considered comments.   Comments  are  otherwise
                  not  processed.   The blank following (  is not
                  part of ccc.  ( may be freely used while inter-
                  preting or compiling.  The number of characters
                  in ccc may be from zero to the number of charac-
                  ters remaining in the input stream  up  to  the
                  closing parenthesis.


NAME            : (E.)
PRONOUNCIATION  : "paren-E-dot-paren"
VERSION         : NMI ANSI
STACK NOTATION  : (F:r -- )( -- addr +n)
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 2
RETURN STACK    :
DICTIONARY      :
PAD             : string stored below PAD
INPUT           :
OUTPUT          :
GROUP           : floating-point
ATTRIBUTE       :
STANDARD        : ANSI basis 13
SHORT DEFINITION: Convert  the top number on the floating-point
                  stack to its character string representation using the scientific
                  notation. Addr is the address of the location where the character
                  string representation of r is stored,  and +n is  the  number  of
                  bytes.
LONG DEFINITION : Convert  the  top number on the floating-point
                  stack to its character string representation using the scientific
                  notation.  The character string produced will be exactly the same
                  as that generated by the floating-point operator E..   Scientific
                  notation  has the format [-]mantissa e[-] exponent where the man-
                  tissa contains a radix point with the most  sigificant  digit  to
                  the  left  the point,  zero or more trailing digits,  and the ex-
                  ponent with one or more trailing digits.   The  exact  number  of
                  digits  to the right of the radix place in the mantissa is deter-
                  mined by PLACES.  The exponent consists of an optional  sign  and
                  enough  decimal  digits to represent the exponent.   An exception
                  exists if the system basis is not DECIMAL.


NAME            : (F.)
PRONOUNCIATION  : "paren-F-dot-paren"
VERSION         : NMI ANSI
STACK NOTATION  : (F:r -- )( -- addr +n)
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 2
RETURN STACK    :
DICTIONARY      :
PAD             : string stored below PAD
INPUT           :
OUTPUT          :
GROUP           : floating-point
ATTRIBUTE       :
STANDARD        : ANSI basis 13
SHORT DEFINITION: Convert the top number  on  the  floating-point
                  stack  to  its  character  string representation using the fixed-
                  point notation.  Addr is the address of the  location  where  the
                  character string representation of r is stored, and +n is the num-
                  ber of bytes.
LONG DEFINITION : Convert  the  top number on the floating-point
                  stack to its character string  representation  using  the  fixed-
                  point notation. The character string produced will be exactly the
                  same  as  that generated by the floating-point operator F..   The
                  exact number of digits to the right of the radix place in the man-
                  tissa is determined by PLACES.  An exception exists if the system
                  basis  is not DECIMAL.   Very large numbers are represented using
                  scientific notation.


NAME            : (LINE)
PRONOUNCIATION  : "paren-line"
VERSION         : RSC NMIDR
STACK NOTATION  : ( n1 n2 --- addr count )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 2
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : May cause block read if not RAM resident.
OUTPUT          : May cause block write to facilitate block read
GROUP           : Mass
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Virtual storage line primitive.
LONG DEFINITION : Converts the line number n1 and the screen num-
                  ber  n2  to  the disk buffer address containing
                  the data.   A count of 64 indicates a full line
                  length.


NAME            : *
PRONOUNCIATION  : "times"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 w2 --- w3 )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Multiplies  w2  by w1 and leaves the product w3
                  onto the stack.
LONG DEFINITION : w3 is the least  significant  16  bits  of  the
                  arithmetic product of w1 times w2.


NAME            : */
PRONOUNCIATION  : "times-divide"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n1 n2 n3 --- n4 )
# ARGUMENTS IN  : 3
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Multiplies  n2 by n1 and divides the product by
                  n3.  The quotient, n4  is placed on the stack.
LONG DEFINITION : n1 is first multiplied by n2 producing an inter-
                  mediate 32-bit result.   n4 is the floor of the
                  quotient  of  the  intermediate  32-bit  result
                  divided by the divisor n3.   The product of  n1
                  times  n2  is maintained as an intermediate 32-
                  bit result for greater precision than the other-
                  wise equivalent  sequence:  n1 n2 * n3 / .   An
                  error  condition results if the divisor is zero
                  or if the  quotient  falls  outside  the  range
                  {-32,768...32,767}.


NAME            : */MOD
PRONOUNCIATION  : "times-divide-mod"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n1 n2 n3 --- n4 n5 )
# ARGUMENTS IN  : 3
# ARGUMENTS OUT : 2
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: n1  is  multiplied  by  n2  producing a product
                  which is divided by n3.  The remainder,  n4 and
                  the quotient, n5 are then placed on the stack.
LONG DEFINITION : n1 is first multiplied by n2 producing an inter-
                  mediate 32 bit result.  n4 is the remainder and
                  n5  is  the floor of the quotient of the inter-
                  mediate 32-bit result divided  by  the  divisor
                  n3.   A 32-bit intermediate product is used for
                  */ .   n4 has the same sign as n3 or  is  zero.
                  An  error  condition  results if the divisor is
                  zero or if the quotient falls  outside  of  the
                  range {-32,768...32,767}.


NAME            : +
PRONOUNCIATION  : "plus"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (w1 w2 --- w3 )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Adds  w2 and w1 then leaves the sum,  w3 on the
                  stack.
LONG DEFINITION : w3 is the arithmetic sum of w1 plus w2.


NAME            : +!
PRONOUNCIATION  : "plus-store"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 addr ---   )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Adds w1 to the value at addr  then  stores  the
                  sum at addr replacing its previous value.
LONG DEFINITION : w1 is added to the w value at addr using the
                  convention for +  .    This  sum  replaces  the
                  original value at addr.


NAME            : +LOOP
PRONOUNCIATION  : "plus-loop"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n ---   ), ( sys ---   ) (compiling)
# ARGUMENTS IN  : 1 , 1
# ARGUMENTS OUT : 0 , 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Control
ATTRIBUTE       : I C
STANDARD        : F83-RWS-CL
SHORT DEFINITION: Increments the DO LOOP index by n.
LONG DEFINITION : n is added to the loop index.  If the new index
                  was  incremented  across  the  boundary between
                  limit-1 and limit then the loop  is  terminated
                  and  loop  control  parameters  are  discarded.
                  When the loop is not terminated, execution con-
                  tinues to just after  the  corresponding  DO  .
                  sys  is  balanced  with its corresponding  DO .
                  See: DO


NAME            : ,
PRONOUNCIATION  : "comma"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 16b ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      : Word pointed to by  DP  prior to  execution  is
                  modified.
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Dictionary
ATTRIBUTE       :
STANDARD        : F83-RWS-CL
SHORT DEFINITION: Reserves 16b of space in the dictionary.
LONG DEFINITION : ALLOT space for 16b then store 16b at HERE 2- .


NAME            : -
PRONOUNCIATION  : "minus"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 w2 --- w3 )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Subtracts w2 from w1 and leaves the result,  w3
                  on the stack.
LONG DEFINITION : w3 is the result of subtracting w2 from w1.


NAME            : -->
PRONOUNCIATION  : "next block"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : Causes read of next block if not RAM resident.
OUTPUT          : May cause  write  of  updated  screen  to  make
                  buffer space.
GROUP           : Mass
ATTRIBUTE       : I
STANDARD        : F83-CRW
SHORT DEFINITION: Immediately  transfers  interpretation to the
                  start of the next sequential block.
LONG DEFINITION : Continue interpretation on the next  sequential
                  block.    May be used within a colon definition
                  that crosses a block boundary.


NAME            : -ROLL
PRONOUNCIATION  : "dash-roll"
VERSION         : NMI NMIDR
STACK NOTATION  : ( n  ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Removes the value on the top of stack  and  in-
                  serts  it  to  the  nth  place  from the top of
                  stack.
LONG DEFINITION : The item on  the  top  of  the  data  stack  is
                  removed  and  inserted down to the nth location
                  from (but not including) the top of the  stack.
                  The  rest  of  the  contents  of  the  stack is
                  shifted up to make room to insert the item.   1
                  -ROLL is equivalent to SWAP .


NAME            : -TRAILING
PRONOUNCIATION  : "dash-trailing"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( addr +n1 --- addr +n2 )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 2
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Format
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Counts +n1 characters starting at addr and sub-
                  tracts 1 from the count when a blank is encoun-
                  tered.    Leaves  on the stack the final string
                  count, n2 and addr.
LONG DEFINITION : The character count +n1 of a text string begin-
                  ning at addr is adjusted  to  exclude  trailing
                  spaces.  If +n1 is zero, then +n2 is also zero.
                  If  the entire string consists of spaces,  then
                  +n2 is zero.


NAME            : .
PRONOUNCIATION  : "dot"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : I/O
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Removes n from the top of  stack  and  displays
                  it.
LONG DEFINITION : The value of n is displayed in a free field for-
                  mat with a leading minus sign if n is negative.


NAME            : ."
PRONOUNCIATION  : "dot-quote"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : I/O
ATTRIBUTE       : I M
STANDARD        : F83-RWS-CL
SHORT DEFINITION: Displays  the characters following it up to the
                  delimiter  " .
LONG DEFINITION : Used in the form:  ." ccc"  .   Later execution
                  will  display  the characters ccc up to but not
                  including the delimiting  " (close-quote).  The
                  blank following  ." is not part of ccc.    Used
                  inside a colon definition only.


NAME            : .(
PRONOUNCIATION  : "dot-paren"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          : Displays character string
GROUP           : I/O
ATTRIBUTE       : I M 83
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Displays string following .( delimited by ) .
LONG DEFINITION : Used  in  the form:  .( ccc)  .  The characters
                  ccc up to but not including the delimiting    )
                  (close  parenthesis) are displayed.   The blank
                  following  .(  is not part of ccc.   Used  out-
                  side of a colon definition only.


NAME            : .LINE
PRONOUNCIATION  : "dot-line"
VERSION         : RSC NMI NMIDR
STACK NOTATION  : ( n1 n2 ---   )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : May cause block read if not RAM resident.
OUTPUT          : Lists line to terminal.
GROUP           : Mass
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Display line of text from mass storage.
LONG DEFINITION : Displays  a  line  of text from mass storage by
                  its line number n2.   Trailing blanks are  sup-
                  pressed.


NAME            : .R
PRONOUNCIATION  : "dot-r"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n +n ---   )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             : Bytes   below    PAD    modified  as  temporary
                  area where +n is converted to string.
INPUT           :
OUTPUT          :
GROUP           : I/O
ATTRIBUTE       :
STANDARD        : F83-CRW
SHORT DEFINITION: Displays the value n right justified in a field
                  +n characters wide according to  the  value  of
                  BASE.
LONG DEFINITION : n  is  converted using BASE  and then displayed
                  right alligned in a field +n  characters  wide.
                  A leading minus sign is displayed if n is nega-
                  tive.   If the number of characters required to
                  display n is greater than +n,  an error  condi-
                  tion exists.


NAME            : .S
PRONOUNCIATION  : "dot-s"
VERSION         : RSC NMI NMIDR
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : I/O
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Display  stack  contents  without modifying the
                  stack.
LONG DEFINITION : Displays the contents of the stack without  al-
                  tering the stack.   This word is very useful in
                  determining the stack contents during debugging
                  programs and learning FORTH.


NAME            : /
PRONOUNCIATION  : "divide"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n1 n2 --- n3 )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Divides n1 by n2 and leaves the quotient n3  on
                  the stack.
LONG DEFINITION : n3  is  the floor of the quotient of n1 divided
                  by the divisor n2.   An error condition results
                  if the divisor is zero or if the quotient falls
                  outside the range {-32,768 ... 32,767}.


NAME            : /MOD
PRONOUNCIATION  : "divide-mod"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n1 n2 --- n3 n4 )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 2
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Divides  n1  by n2 then leaves on the stack the
                  remainder n3 and the quotient n4.
LONG DEFINITION : n3 is the remainder and n4  the  floor  of  the
                  quotient  of n1 divided by the divisor n2.   n3
                  has the same sign as n2 or is zero.   An  error
                  condition  results if the divisor is zero or if
                  the quotient falls outside the  range  {-32,768
                  ... 32,676}.


NAME            : 0<
PRONOUNCIATION  : "zero-less"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n --- flag )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Comparison
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Leaves a true flag if n is less than zero.
LONG DEFINITION : Flag is true if n is less than zero (negative).


NAME            : 0=
PRONOUNCIATION  : "zero-equals"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w --- flag )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Comparison
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Leaves a true flag if w is equal to zero.
LONG DEFINITION : flag is true if w is zero.


NAME            : 0>
PRONOUNCIATION  : "zero-greater"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n --- flag )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Comparison
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Leaves a true flag if n is greater than zero.
LONG DEFINITION : flag is true if n is greater than zero.


NAME            : 1+
PRONOUNCIATION  : "one-plus"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 --- w2 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Adds  1  to  w1 then leaves the sum,  w2 on the
                  stack.
LONG DEFINITION : w2 is the result of adding 1 to w1 according to
                  the operation of + .


NAME            : 1+!
PRONOUNCIATION  : "one-plus-store"
VERSION         : NMI NMIDR
STACK NOTATION  : ( addr ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        : F83-URW
SHORT DEFINITION: Adds one to the value at addr  and  stores  the
                  result at addr.
LONG DEFINITION : Adds  one  to  the value at addr and stores the
                  result at addr.


NAME            : 1-
PRONOUNCIATION  : "one-minus"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 --- w2 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Subtract 1 from w1 then leaves the  difference,
                  w2 on the stack.
LONG DEFINITION : w2 is the result of subtracting one from w1 ac-
                  cording to the operation of  - .


NAME            : 1-!
PRONOUNCIATION  : "one-minus-store"
VERSION         : NMI NMIDR
STACK NOTATION  : ( addr ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        : F83-URW
SHORT DEFINITION: Subtracts one from the value at addr and stores
                  the result at addr.
LONG DEFINITION : Subtracts one from the value at addr and stores
                  the result at addr.


NAME            : 2!
PRONOUNCIATION  : "two-store"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 32b addr ---   )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        : F83-DNEWS-NL
SHORT DEFINITION: Stores 32b at addr.
LONG DEFINITION : 32b is stored at addr.


NAME            : 2*
PRONOUNCIATION  : "two-times"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 --- w2 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-CRW
SHORT DEFINITION: Multiplies w1 by 2 to give w2.
LONG DEFINITION : w2  is  the result of shifting w1 left one bit.
                  A zero is shifted into vacated bit position.


NAME            : 2**X
PRONOUNCIATION  : "2-double-star-x"
VERSION         :
STACK NOTATION  : (F: r1 -- r2)
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : floating-point
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Raise 2 to the r1 power giving r2.
LONG DEFINITION : Raise 2 to the r1 power giving r2.


NAME            : 2+
PRONOUNCIATION  : "two-plus"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 --- w2 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Adds two to w1 and leaves the sum,  w2  on  the
                  stack.
LONG DEFINITION : w2  is the result of adding two to w1 according
                  to the operation of  + .


NAME            : 2-
PRONOUNCIATION  : "two-minus"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 --- w2 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Subtracts two from w1 and leaves the result, w2
                  on the stack.
LONG DEFINITION : w2 is the result of subtracting two from w1 ac-
                  cording to the operation of  - .


NAME            : 2/
PRONOUNCIATION  : "two-divide"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n1 --- n2 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Arithmetic
ATTRIBUTE       : 83
STANDARD        : F83-RWS-NL
SHORT DEFINITION: divides n1 by 2, giving n2 as the result.
LONG DEFINITION : n2 is the result of the arithmetically shifting
                  n1 right one bit.   The sign is included in the
                  shift and remains unchanged.


NAME            : 2@
PRONOUNCIATION  : "two-fetch"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( addr --- 32b )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT :
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        : F83-DNEWS-NL
SHORT DEFINITION: Returns 32b from addr.
LONG DEFINITION : 32b is the value at addr.


NAME            : 2CONSTANT
PRONOUNCIATION  : "two-constant"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 32b ---   )
# ARGUMENTS IN  : 1 (2 words)
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : <name> is removed from input stream.
OUTPUT          :
GROUP           : Definition
ATTRIBUTE       :
STANDARD        : F83-DNEWS-CL
SHORT DEFINITION: Creates  a double length constant for a <name>.
                  When <name> is executed,  32b is  left  on  the
                  stack.
LONG DEFINITION : A defining word executed in the form:
                  32b  2CONSTANT  <name> .   Creates a dictionary
                  entry for <name> so that when <name>  is  later
                  executed, 32b will be left on the stack.


NAME            : 2DROP
PRONOUNCIATION  : "two-drop"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 32b ---   )
# ARGUMENTS IN  : 1 (2 words)
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        : F83-DNEWS-NL
SHORT DEFINITION: Removes 32b from the stack.
LONG DEFINITION : 32b is removed from the data stack.


NAME            : 2DUP
PRONOUNCIATION  : "two-dup"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 32b --- 32b 32b )
# ARGUMENTS IN  : 1 (2 words)
# ARGUMENTS OUT : 2 (4 words)
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        : F83-DNEWS-NL
SHORT DEFINITION: Duplicates 32b.
LONG DEFINITION : Duplicates 32b onto the top of the data stack.


NAME            : 2OVER
PRONOUNCIATION  : "two-over"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 32b1 32b2 ---   32b1 32b2 32b3 )
# ARGUMENTS IN  : 2 (4 words)
# ARGUMENTS OUT : 3 (6 words)
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        : F83-DNEWS-NL
SHORT DEFINITION: 32b3 is a copy of 32b1
LONG DEFINITION : Duplicates  the 2nd item 32b1 of the stack onto
                  the top of the data stack, leaving 32b.


NAME            : 2ROT
PRONOUNCIATION  : "two-rote"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 32b1 32b2 32b3 --- 32b2 32b3 32b1 )
# ARGUMENTS IN  : 3 (6 words)
# ARGUMENTS OUT : 3 (6 words)
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        : F83-DNEWS-NL
SHORT DEFINITION: Rotates 32b1 to the top of the stack.
LONG DEFINITION : The top three double numbers on the data  stack
                  are  rotated,  bringing the third double number
                  to the top of the stack.


NAME            : 2SWAP
PRONOUNCIATION  : "two-swap"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 32b1 32b2 --- 32b2 32b1 )
# ARGUMENTS IN  : 2 (4 words)
# ARGUMENTS OUT : 2 (4 words)
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        : F83-DNEWS-NL
SHORT DEFINITION: Swaps 32b1 and 32b2 on the stack.
LONG DEFINITION : The top two double  numbers  are  exchanged  in
                  position on the data stack.


NAME            : 2VARIABLE
PRONOUNCIATION  : "two-variable"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : <name> is removed from input stream.
OUTPUT          :
GROUP           : Definition
ATTRIBUTE       :
STANDARD        : F83-DNEWS-CL
SHORT DEFINITION: Creates   double-length  variable  for  <name>.
                  when <name> is executed,  its  parameter  field
                  address is placed on the stack.
LONG DEFINITION : A   defining   word  executed  in  the  form:
                  2VARIABLE <name> .    A  dictionary  entry  for
                  <name> is created and four bytes are ALLOTed in
                  its  parameter field.   This parameter field is
                  to be used for contents of the variable.    The
                  application is responsible for initializing the
                  contents  of  the    variable which it creates.
                  When <name> is later executed,  the address  of
                  its parameter field is placed on the stack.


NAME            : :
PRONOUNCIATION  : "colon"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   --- sys )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : <name> is removed from input stream.
OUTPUT          :
GROUP           : Definition
ATTRIBUTE       : E (I)
STANDARD        : F83-RWS-CL
SHORT DEFINITION: Starts the definition of a word.  Definition is
                  terminated by a  ; .
LONG DEFINITION : A defining word executed in the form:
                  : <name> ...  ;  Create a definition for <name>
                  in the compilation vocabulary and set  compila-
                  tion  state.    The  search order is changed so
                  that the first vocabulary in the  search  order
                  is replaced by the compilation vocabulary.  The
                  compilation  vocabulary is unchanged.  The text
                  from the input stream is subsequently compiled.
                  <name> is called a  "colon  definition".    The
                  newly created word definition for <name> cannot
                  be found in the dictionary until the correspond-
                  ing   ;   or  ;CODE  is successfully processed.
                  An error condition exists  if  a  word  is  not
                  found  and  cannot  be converted to a number or
                  if,  during compilation from mass storage,  the
                  input  stream  is exhausted before encountering
                  ;   or  ;CODE .   sys is balanced with its cor-
                  responding  ; .


NAME            : :CASE
PRONOUNCIATION  : "colon-case"
VERSION         : NMI NMIDR
STACK NOTATION  : ( n ---    ), (   --- sys ) (compiling)
# ARGUMENTS IN  : 1 , 0
# ARGUMENTS OUT : 0 , 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : <name> is removed from input stream.
OUTPUT          :
GROUP           : Definition
ATTRIBUTE       : (I)
STANDARD        :
SHORT DEFINITION: Creates  a  dictionary entry for <name> in cur-
                  rent and sets the compile mode.
LONG DEFINITION : A defining word used in the form:
                  :CASE <name> ... ; . Creates a dictionary entry
                  for <name> in  CURRENT ,  and sets the  compile
                  mode.    Words  thus  defined  are called "case
                  statements".  The compilation addresses of sub-
                  sequent words from the input stream are  stored
                  into the dictionary.  At runtime a word defined
                  by  :CASE  will execute only the nth definition
                  compiled  into the definition.  sys is balanced
                  with its corresponding  ; .


NAME            : ;
PRONOUNCIATION  : "semi-colon"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( sys ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Definition
ATTRIBUTE       : C I 79
STANDARD        : F83-RWS-CL
SHORT DEFINITION: Terminates a colon-definiton.
LONG DEFINITION : Stops compilation of a colon definition, allows
                  the <name> of   this  colon  definition  to  be
                  found in the dictionary,   sets interpret state
                  and  compiles  ;S .  sys is balanced with  cor-
                  responding : .


NAME            : ;CODE
PRONOUNCIATION  : "semi-colon-code"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   ---   ), ( sys1 --- sys2 ) (compiling)
# ARGUMENTS IN  : 0 , 1
# ARGUMENTS OUT : 0 , 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Definition
ATTRIBUTE       : (I)
STANDARD        : F83-AEWS-CL
SHORT DEFINITION: Terminates  a defining-word.   May only be used
                  in compilation mode.
LONG DEFINITION : Used in the form:
                  : <name> ... <create> ... ;CODE ...END-CODE
                  Stops compilation, terminates the defining word
                  <name> and executes ASSEMBLER .  When
                  <name> is executed in the form: <name> <namex>
                  to define the new <namex>,  the  execution  ad-
                  dress  of  <namex>  will contain the address of
                  the  code  sequence  following  the  ;CODE   in
                  <name>.    Execution  of any <namex> will cause
                  this machine  code  sequence  to  be  executed.
                  sys1  is  balanced  with  its corresponding : .
                  sys2 is balanced with  its  corresponding  END-
                  CODE .  See: CODE DOES>


NAME            : ;S
PRONOUNCIATION  : "semi-colon-s"
VERSION         : RSC NMI NMIDR
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Interpreter
ATTRIBUTE       :
STANDARD        : F83-URW
SHORT DEFINITION: Stop interpretation.
LONG DEFINITION : Stops interpretation of a screen.   ;S is also
                  the run-time word compiled  at  the  end  of  a
                  colon-definition which returns execution to the
                  calling procedure.


NAME            : <
PRONOUNCIATION  : "less-than"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n1 n2 --- flag )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Comparison
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Leaves a true flag on stack if n1 is less than
                  n2.
LONG DEFINITION : flag is true if n1 is less than n2.      -32768
                  32767  <  must  return true.    -32768 0 < must
                  return true.


NAME            : <#
PRONOUNCIATION  : "less-sharp"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Format
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Starts a formatted (pictured)  numeric  output.
                  Terminated by #> .
LONG DEFINITION : Initialize  pictured  numeric ouput conversion.
                  The words:  # #>  #S  <#  HOLD  SIGN    can  be
                  used to specify the conversion of a double num-
                  ber  into an ASCII text string stored in right-
                  to-left order.


NAME            : <BUILDS
PRONOUNCIATION  : "builds"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   ---   )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Definition
ATTRIBUTE       : C
STANDARD        : F83-URW
SHORT DEFINITION: Creates a new dictionary entry for <name>
LONG DEFINITION : Used in  conjunction  with  DOES>  in  defining
                  words, in the form:
                  : <name> ... <BUILDS ... DOES> ... ;
                  and  then    <name> <namex> .   When <name> ex-
                  ecutes,  <BUILDS creates a dictionary entry for
                  the new <namex>.  The sequence of words between
                  <BUILDS and DOES> established a parameter field
                  for  <namex>.   When <namex> is later executed,
                  the sequence of words following DOES>  will  be
                  executed,  with  the parameter field address of
                  <namex> on the data stack.


NAME            : <MARK
PRONOUNCIATION  : "backward-mark"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   --- addr )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Control
ATTRIBUTE       : (I)
STANDARD        : F83-SEWS-CL
SHORT DEFINITION: Leaves  current  dictionary  location   to   be
                  resolved by <RESOLVE .
LONG DEFINITION : Used  at the destination of a backward branch.
                  addr is typicallyonly used by resolve  <RESOLVE
                  to compile a branch address.


NAME            : <RESOLVE
PRONOUNCIATION  : "backward-resolve"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( addr ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Control
ATTRIBUTE       : (I)
STANDARD        : F83-SEWS-CL
SHORT DEFINITION: Compiles  branch  offset to location previously
                  left by <MARK .
LONG DEFINITION : Used at the source of a backward  branch  after
                  either  BRANCH or ?BRANCH .   Compiles a branch
                  address using addr as the destination address.


NAME            : =
PRONOUNCIATION  : "equals"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( w1 w2 --- flag )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Comparison
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Returns a true flag if w1 is equal to w2.
LONG DEFINITION : flag is true if w1 is equal to w2.


NAME            : >
PRONOUNCIATION  : "greater-than"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( n1 n2 --- flag )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Comparison
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Returns a true flag if n1 is greater than n2.
LONG DEFINITION : flag is true if n1 is greater than n2.
                  -32768 32767 > must return false.
                  -32768 0 > must return false.


NAME            : ><
PRONOUNCIATION  : "byte-swap"
VERSION         : NMI NMIDR
STACK NOTATION  : ( 8b1/8b2 --- 8b2/8b1 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        : F83-URW
SHORT DEFINITION: Swaps the upper and lower bytes of the value on
                  the stack.
LONG DEFINITION : Swaps the upper and lower bytes of the value on
                  the top of the data stack.


NAME            : >BODY
PRONOUNCIATION  : "to-body"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( addr1 --- addr2 )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Compiler
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Leaves on the stack  the  parameter  field  ad-
                  dress, addr2 of a given field address, addr1.
LONG DEFINITION : addr2 is the parameter field address correspond-
                  ing to the compilation address addr1.


NAME            : >IN
PRONOUNCIATION  : "to-in"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   --- addr )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Interpreter
ATTRIBUTE       :
STANDARD        : F83-RWS-IL
SHORT DEFINITION: Leaves  the  address of the user variable >IN
                  which contains the number  of  bytes  from  the
                  beginning of the input stream at any particular
                  moment during interpretation.
LONG DEFINITION : The  address of a user variable which contains
                  the present character offset within  the  input
                  stream.  See: WORD


NAME            : >L
PRONOUNCIATION  : "to-line"
VERSION         : NMI NMIDR
STACK NOTATION  : ( n --- <text> )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           : <text> following >L is removed from input
                  stream.
OUTPUT          :
GROUP           : MASS
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Place  the  <text>  on  line  n  of the current
                  screen as designated by SCR.
LONG DEFINITION : Place the following text on line n of the  cur-
                  rent screen as designated by SCR .


NAME            : >MARK
PRONOUNCIATION  : "forward-mark"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : (   --- addr )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Control
ATTRIBUTE       : (I)
STANDARD        : F83-SEWS-CL
SHORT DEFINITION: Compiles zero in place of forward branch offset
                  and marks it for future resolve.
LONG DEFINITION : Used at the source of a forward branch.   Typi-
                  cally used after  either BRANCH  or  ?BRANCH  .
                  Compiles  space in the dictionary  for a branch
                  address  which  will  later  be  resolved    by
                  >RESOLVE .


NAME            : >R
PRONOUNCIATION  : "to-r"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 16b ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    : Takes 16b from stack
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Removes  16b  from user stack and place it onto
                  return stack.
LONG DEFINITION : Transfers 16b from the top of the data stack to
                  the top of the return stack.


NAME            : >RESOLVE
PRONOUNCIATION  : "forward-resolve"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( addr ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Control
ATTRIBUTE       : (I)
STANDARD        : F83-SEWS-CL
SHORT DEFINITION: Corrects branch offset previously  compiled  by
                  >mark to current dictionary location.
LONG DEFINITION : Used  at  the  destination of a forward branch.
                  Calculates the branch address (to  the  current
                  location  in  the  dictionary)   using addr and
                  places this branch address into the space  left
                  by >MARK .


NAME            : ?
PRONOUNCIATION  : "question-mark"
VERSION         : RSC NMI NMIDR
STACK NOTATION  : ( addr ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : I/O
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Displays the contents of addr.
LONG DEFINITION : Displays the value contained at the address on
                  the top of the stack in free  format  according
                  to the current BASE .  Uses the format of .  .


NAME            : ?BRANCH
PRONOUNCIATION  : "question-branch"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( flag ---   )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Primitive
ATTRIBUTE       : C
STANDARD        : F83-SEWS-NL
SHORT DEFINITION: Compiles a conditional branch operation.
LONG DEFINITION : When used in the form:  COMPILE ?BRANCH
                  a  conditional  branch  operation  is compiled.
                  See BRANCH for further details.  When executed,
                  if flag is false the  branch  is  performed  as
                  with BRANCH .  When flag is true execution con-
                  tinues  at  the compilation address immediately
                  following the branch address.


NAME            : ?COMP
PRONOUNCIATION  : "question-compile"
VERSION         :
STACK NOTATION  : ( -- )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : interpreter
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Checks for compilation  mode,  gives  error  if
                  not.
LONG DEFINITION : Checks for compilation mode,  gives error if
                  not.


NAME            : ?CSP
PRONOUNCIATION  : "question-c-s-p"
VERSION         :
STACK NOTATION  : ( -- )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : interpreter
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Checks for  stack  integrity  through  defining
                  process, gives error if not.
LONG DEFINITION : Checks  for  stack  integrity through defining
                  process, gives error if not.


NAME            : ?DUP
PRONOUNCIATION  : "question-dup"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( 16b --- 16b 16b ), ( 0 --- 0 )
# ARGUMENTS IN  : 1 , 1
# ARGUMENTS OUT : 2 , 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Stack
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Duplicates 16b if it is a non-zero.
LONG DEFINITION : Duplicate 16b if it is non-zero value, If it is
                  zero, 16b is not duplicated.


NAME            : ?ERROR
PRONOUNCIATION  : "question-error"
VERSION         :
STACK NOTATION  : (flag n -- )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : operating system
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: If flag is true, error n is initiated.
LONG DEFINITION : If flag is true, error n is initiated.


NAME            : ?EXEC
PRONOUNCIATION  : "question-execute"
VERSION         :
STACK NOTATION  : ( -- )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : interpreter
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Checks for interpretation mode,  gives error if
                  not.
LONG DEFINITION : Checks for interpretation mode,  gives error if
                  not.


NAME            : ?PAIRS
PRONOUNCIATION  : "question-pairs"
VERSION         :
STACK NOTATION  : (n1 n2 -- )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : interpreter
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Checks for matched structure pairs, gives error
                  if not.
LONG DEFINITION : Checks for matched structure pairs,  gives error
                  if not.


NAME            : ?STACK
PRONOUNCIATION  : "question-stack"
VERSION         :
STACK NOTATION  : ( --- )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Interpreter
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Checks to see if stack is within limits, gives 
                  error if not
LONG DEFINITION : Checks to see if stack is within limits.  Error 
                  1, STACK EMPTY, is given if stack has 
                  underflowed.


NAME            : ?TERMINAL
PRONOUNCIATION  : "question-terminal"
VERSION         : RSC NMI NMIDR
STACK NOTATION  : (   --- flag )
# ARGUMENTS IN  : 0
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : I/O
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: True if any key is depressed.
LONG DEFINITION : Tests the terminal input for actuation  of  any
                  key.   Generates a Boolean value.   A true flag
                  indicates actuation, whereas a  false flag indi-
                  cates non-actuation.


NAME            : @
PRONOUNCIATION  : "fetch"
VERSION         : NMI NMIDR FORTH-83
STACK NOTATION  : ( addr --- 16b )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        : F83-RWS-NL
SHORT DEFINITION: Replaces addr with its 16b contents on  top  of
                  the stack.
LONG DEFINITION : 16b is the value at addr.


NAME            : @!
PRONOUNCIATION  : "fetch-store"
VERSION         : V3.5
STACK NOTATION  : ( addr1 addr2 --- )
# ARGUMENTS IN  : 2
# ARGUMENTS OUT : 0
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Move cell contents from addr1 to addr2.
LONG DEFINITION : The contents of addr1 are copied to the
                  location pointed to by addr2.  This would
                  be the same as  >R @ R> !.


NAME            : @@
PRONOUNCIATION  : "fetch-fetch"
VERSION         :
STACK NOTATION  : ( addr --- 16b )
# ARGUMENTS IN  : 1
# ARGUMENTS OUT : 1
RETURN STACK    :
DICTIONARY      :
PAD             :
INPUT           :
OUTPUT          :
GROUP           : Memory
ATTRIBUTE       :
STANDARD        :
SHORT DEFINITION: Replaces addr with 16b, 16b is contents of 
                  address pointed to by addr.
LONG DEFINITION : 16b is the value pointed to by addr. addr is a 
                  pointer location. addr is fetched and used as 
                  source address from which the 16b value is 
                  fetched.  Like using @ @ but faster exectuion 
                  and smaller compilation using a single word.