
                         FORTH-79 STANDARD


                         A PUBLICATION OF
                     THE FORTH STANDARDS TEAM


                           OCTOBER 1980


                             CONTENTS
                                                               Page
 0.       FOREWORD                                              1
 1.       PURPOSE                                               1
 2.       SCOPE                                                 1
 3.       ORGANIZATION                                          1
 4.       DEFINITION OF TERMS                                   2
 5.       REFERENCES                                            9
 6.       REQUIREMENTS                                         10
 7.       COMPLIANCE AND LABELING                              11
 8.       USE                                                  12
 9.       GLOSSARY NOTATION                                    13
10.       REQUIRED WORD SET                                    15
11.       EXTENSION WORD SETS                                  32

          11.1  Double Number Word Set                         32
          11.2  Assembler Word Set                             34

12.       EXPERIMENTAL PROPOSALS                               34

          REFERENCE WORD SET
          FORTH-79 HANDY REFERENCE CARD



                         FORTH-79 STANDARD


                         A PUBLICATION OF
                     THE FORTH STANDARDS TEAM


                           OCTOBER 1980


The  existence of a FORTH Standard does not in any respect preclude
anyone,  whether the individual has approved this Standard or  not,
from  implementing,   marketing,   purchasing  or  using  products,
processes,  or  procedures not conforming to the  Standard.   FORTH
Standards are subject to periodic review and users are cautioned to
obtain the latest editions.


                         0.  FOREWORD


The computer language FORTH was created by Mr.  Charles Moore as an
extensible,    multi-level   environment  containing elements of an
operating  system,  a machine monitor,  and facilities for  program
development and testing.

This  Standard  is a direct descendant of FORTH-77,  a work of  the
FORTH Users Group (Europe).


                         1.  PURPOSE


The purpose of this FORTH Standard is to allow transportability  of
standard  FORTH  programs  in  source  form  among  standard  FORTH
systems.   A  standard  program shall execute equivalently  on  all
standard FORTH systems.


                         2.  SCOPE


This  standard shall apply to any Standard FORTH program  executing
on  any  Standard  FORTH  system,   providing  sufficient  computer
resources (memory, mass storage) are available.


                         3.  ORGANIZATION


This standard consists of:
     1)   General Text
     2)   Definitions of Terms
     3)   Required Word Set
     4)   Extension Ward Sets

Word sets may be subdivided for conceptual purposes by functions
          Nucleus
          Interpreter
          Compiler
          Devices

Tradeoffs

When conflicting choices  must be made,  the following order  shall
guide the Standards Team.

     1)   Functional correctness
               - known bounds, non-ambiguous.
     2)   Portability
               - repeatable results when transported among  Standard
                 systems.
     3)   Simplicity.
     4)   Naming clarity
               - uniformity  of expression.  Descriptive  names  are
                 preferred over procedural, (i.e., [COMPILE]  rather
                 than 'C, and ALLOT rather than DP+! .)
     5)   Generality.
     6)   Execution speed.
     7)   Memory compactness.
     8)   Compilation speed.
     9)   Historical continuity.
    10)   Pronounceability.
    11)   Teachability.


                         4.  DEFINITIONS OF TERMS


These definitions, when in lower  case, are terms used within  this
Standard.  They present terms as specifically used within FORTH.

address, byte

     An unsigned  number that locates an  8-bit byte in a  standard
     FORTH  address space over {0..65,535}.  It  may   be a  native
     machine address  or a representation  on  a  virtual  machine,
     locating the  'addr-th' byte  within  the virtual byte address
     space.  Address arithmetic is modulo 65,536 without overflow.

address, compilation

     The numerical  value  equivalent to a  FORTH word  definition,
     which   is  compiled   for  that   definition.   The   address
     interpreter  uses  this  value  to  locate  the  machine  code
     corresponding to  each definition.   (May also  be called  the
     code field address.)

address, native machine

     The natural address representation of the host computer.

address, parameter field

     The address of the first byte of memory associated with a word
     definition  for the  storage of  compilation addresses  (in a
     colon-definition), numeric data and text characters.

arithmetic

     All integer arithmetic is performed  with signed 16 or 32  bit
     two's complement results, unless noted.

block

     The  unit  of  data from  mass  storage,  referenced by  block
     number.  A  block must  contain 1024  bytes regardless  of the
     minimum  data  unit  read/written  from  mass  storage.    The
     translation from block number to device and physical record is
     a function of the implementation.

block buffer

     A memory area where a mass storage block is maintained.

byte

     An assembly  of 8  bits.  In  reference to  memory, it  is the
     storage capacity for 8 bits.

cell

     A 16-bit memory  location.  The n-th  cell contains the  2n-th
     and (2n+1)-th byte of the FORTH address space.  The byte order
     is presently unspecified.

character

     A 7-bit  number which  represents a  terminal character.   The
     ASCII character set is considered standard.  When contained in
     a larger field, the higher order bits are zero.

compilation

     The action of accepting text  words from the input stream  and
     placing   corresponding   compilation  addresses   in   a  new
     dictionary entry.

defining word

     A word that,  when executed, creates  a new dictionary  entry.
     The new  word name  is taken  from the  input stream.   If the
     input stream is exhausted before the new name is available, an
     error condition exists.  Common defining words are:
          :  CONSTANT  CREATE

definition

     See 'word definition'.

dictionary

     A structure of  word definitions  in  a computer memory.    In
     systems with  a text  interpreter, the  dictionary entries are
     organized in  vocabularies to  enable location  by name.   The
     dictionary is extensible, growing toward high memory.

equivalent execution

     For the  execution of  a standard  program, a  set of non-tine
     dependent  inputs  will produce  the  same non-time  dependent
     outputs on any FORTH Standard System with sufficient resources
     to execute  the program.   Only standard  source code  will be
     transportable.

error condition

     An exceptional condition which  requires action by the  system
     other than the expected function.  Actions may be:

          1.   ignore, and continue
          2.   display a message
          3.   execute a particular word
          4.   interpret a block
          5.   return control  to the text interpreter

     A Standard System shall be  provided with a tabulation of  the
     action  taken  for all  specified  error conditions.   General
     error conditions:

          1.   input stream exhausted before a required <name>.
          2.   empty stack and full stack for the text interpreter.
          3.   an unknown word, not a valid number for the text
               interpreter.
          4.   compilation of incorrectly nested conditionals.
          5.   interpretation of words restricted to compilation.
          6.   FORGETing within the system to a point that removes
               a word required for correct execution.
          7.   insufficient space remaining in the dictionary.

false

     A zero number represents the false condition flag.

flag

     A number  that may have two logical states, zero and non-zero.
     These  are  named  'true'  =  non-zero,  and  'false'  = zero.
     Standard word definitions leave 1 for true, 0 for false.

glossary

     A  set  of  word  definitions  given  in  a  natural  language
     describing the corresponding computer execution action.

immediate word

     A  word  defined  to  automatically  execute  when encountered
     during compilation, which handles exception cases to the usual
     compilation.   See  IF LITERAL  ."  etc.

input stream

     A  sequence  of  characters  available  to  the  system,   for
     processing  by  the   text  interpreter.   The   input  stream
     conventionally may be taken from a terminal (via the  terminal
     input buffer) and mass storage (via a block buffer).  >IN  and
     BLK specify the input stream.  Words using or altering >IN and
     BLK are responsible for  maintaining and restoring control  of
     the input stream.

interpreter, address

     The (set of) word definitions which interprets (sequences  of)
     FORTH compilation addresses  by executing the  word definition
     specified for each one.

interpreter, text

     The (set of) word  definitions that repeatedly accepts  a word
     name  from  the   input  stream,  locates   the  corresponding
     dictionary  entry,  and  starts  the  address  interpreter  to
     execute it.  Text in the input stream interpreted  as a number
     leaves the corresponding  value on the   data stack.  When  in
     the compile mode,  the addresses of  FORTH words are  compiled
     into the  dictionary for  later interpretation  by the address
     interpreter.  In this case, numbers are compiled, to be placed
     on the data  stack when later  interpreted.  Numbers shall  be
     accepted unsigned or negatively signed, according to BASE.

load

     The  acceptance  of  text  from  a  mass  storage  device  and
     execution   of  the   dictionary  definition   of  the   words
     encountered.  This  is the  general method  for compilation of
     new definitions into the dictionary.

mass storage

     Data  is read  from mass  storage in  the form  of 1024  byte
     blocks.  This data is  held in block buffers.   When indicated
     as UPDATEd (modified) data will be ultimately written to  mass
     storage.

number

     When  values exist within a larger field, the high order  bits
     are zero.  When stored in memory the byte order of a number is
     unspecified.

          type                     range              minimum field

          bit                      0..1                      1
          character                0..127                    7
          byte                     0..255                    8
          number                   -32,768..32,767          16
          positive number          0..32,767                16
          unsigned number          O..65,535                16
          double number            -2,147,483,648..
                                      2,147,483,647         32
          positive double number   0..2,147,483,647         32
          unsigned double number   0..4,294,967,295         32

     When represented on the stack, the higher 16-bits (with  sign)
     of a double  number are most  accessible.  When in  memory the
     higher 16-bits are at the lower address.  Storage extends over
     four bytes toward high memory.  The byte order within each  16
     -bit field is unspecified.

output, pictured

     The use of numeric output primitives, which convert  numerical
     values  into  text  strings.   The operators  are  used  in  a
     sequence  which resembles a symbolic 'picture' of the  desired
     text  format.    Conversion proceeds from low digit  to  high,
     from high memory to low.

program

     A  complete specification of execution to achieve  a  specific
     function  (application  task) expressed in FORTH  source  code
     form.

return

     The   means  of  terminating  text  from  the  input   stream.
     (Conventionally a null (ASCII 0) indicates end of text in  the
     input  stream.   This character is left by  the  'return'  key
     actuation  of the operator's terminal, as an absolute  stopper
     to text interpretation.)

screen

     Textual data  arranged for  editing.  By  convention, a screen
     consists of  16 lines  (numbered 0  thru 15)  of 64 characters
     each.  Screens usually contain program source text, but may be
     used to view mass storage data.   The first  byte of  a screen
     occupies the first byte of a mass storage block,  which is the
     beginning point for text interpretation during a load.

source definition

     Text consisting of  word names suitable  for execution by  the
     text interpreter.   Such text  is usually  arranged in screens
     and maintained on a mass storage device.

stack, data

     A last in, first out list consisting of 16-bit binary  values.
     This  stack  is  primarily used to  hold  intermediate  values
     during  execution  of  word  definitions.   Stack  values  may
     represent numbers, characters, addresses, boolean values, etc.

     When the name 'stack' is used, it implies the data stack.

stack, return

     A last in, first out list which contains the machine addresses
     of word definitions whose execution has not been completed  by
     the address interpreter.  As a word definition passes  control
     to  another  definition,  the return point is  placed  on  the
     return stack.

     The return stack may cautiously be used for other values, such
     as   loop   control   parameters,   and   for   pointers   for
     interpretation of text.

string

     A sequence of 8-bit bytes containing ASCII characters, located
     in memory by an initial byte address and byte count.

transportability

     This  term indicates that equivalent execution results when  a
     program  is executed on other than the system on which it  was
     created.  See 'equivalent execution'.

true

     A non-zero value represents the true condition flag.  Any non-
     zero value will be accepted by a standard word as 'true';  all
     standard words return one when leaving a ' true' flag.

user area

     An  area  in  memory  which  contains  the  storage  for  user
     variables.

variables, user

     So  that the words of the FORTH vocabulary may  be  re-entrant
     (to  different  users),  a copy of  each  system  variable  is
     maintained in the user area.

vocabulary

     An ordered list of word definitions.  Vocabulary lists are  an
     advantage in reducing dictionary search time and in separating
     different word definitions that may carry the sane name.

word

     A sequence of characters terminated by at least one blank  (or
     'return').   Words are usually obtained via the input  stream,
     from a terminal or mass storage device.

word definition

     A   named   FORTH  execution  procedure  compiled   into   the
     dictionary.  Its execution may be defined in terms of  machine
     code, as a sequence of compilation addresses or other compiled
     words.   If named, it nay be located by specifying  this  name
     and the vocabulary in which it is located.

word name

     The  name  of  a  word definition.   Standard  names  must  be
     distinguished by their length and first thirty-one characters,
     and may not contain an ASCII null, blank, or 'return'.

word set

     A   group   of  FORTH  word  definitions  listed   by   common
     characteristics.  The standard word sets consist of:

          Required Word Set
               Nucleus Words
               Interpreter Words
               Compiler Words
               Device Words

          Extension Word Sets
               32-bit Word Set
               Assembler Ward Set

     Included as reference material only:
          Reference Word Set

word set, compiler

     Words  which  add  new procedures to  the  dictionary  or  aid
     compilation by adding compilation addresses or data structures
     to the dictionary.

word set, devices

     Words  which  allow  access  to  mass  storage  and   computer
     peripheral devices.

word set, interpreter

     Words  which  support  interpretation of text  input  from   a
     terminal  or  mass  storage  by  execution  of   corresponding
     dictionary entries, vocabularies, and terminal output.

word set, nucleus

     The FORTH words generally defined in machine  code that create
     the  stacks  and fundamental stack  operators  (virtual  FORTH
     machine).

word set, reference

     This set of words is provided as a reference document only, as
     a  set of formerly standardized words and candidate words  for
     standardization.

word set, required

     The  minimum words needed to compile and execute all  Standard
     Programs.

word, standard

     A  named  FORTH procedure definition, formally   reviewed  and
     accepted  by the Standards Team.  A serial  number  identifier
     {100..999} indicates a Standard Word.  A functional alteration
     of  a  Standard Word will require assignment of a  new  serial
     number identifier.

     The  serial number identifier has no required use, other  than
     to  correlate  the definition name with  its  unique  Standard
     definition.


                         5.  REFERENCES


The  following  documents are considered to be a  portion  of  this
Standard:

     American Standard Code for Information Interchange,
     American National Standards  Institute, X3.4-1968

     Webster's  Collegiate  Dictionary  shall  be  used  to resolve
     conflicts in spelling and  English word usage.

The  following  documents are noted as pertinent  to  the  FORTH-79
Standard, but are not part of this Standard.

     FORTH-77, FORTH Users Group, FST-780314
     FORTH-78, FORTH International Standards Team
     FORTH-79, Reference Word Set
     FORTH-79, Experimental Proposals


                         6.  REQUIREMENTS


6.1  Documentation Requirements

Each Standard System and Standard Program shall be accompanied by a
statement of the minimum (byte) requirements for:

     1.   System dictionary space
     2.   Application dictionary space
     3.   Data stack
     4.   Return stack
     5.   Mass storage contiguous block quantity required
     6.   An operator's terminal.

Each  Standard  System shall be provided with a  statement  of  the
system  action upon each of the error conditions as  identified  in
this Standard.

6.2  Testing Requirements

The following host computer configuration is specified as a minimum
environment  for testing against this Standard.   Applications  may
require different capacities.

     1.   2000 bytes of memory for application dictionary
     2.   Data stack of 64 bytes
     3.   Return stack of 48 bytes
     4.   Mass storage capacity of 32 blocks, numbered 0 through 31
     5.   One ASCII input/output device acting as an operator's
          terminal.


                         7.  COMPLIANCE AND LABELING


The  FORTH  Standards Team hereby specifies  the  requirements  for
labeling  of  systems and applications so that the  conditions  for
program portability may be established.

A  system  may use the specified labeling if it complies  with  the
terms  of  this  Standard,  and  meets  the  particular  Word   Set
definitions.

A Standard Program (application) may use the specified labeling  if
it  utilizes  the  specified  standard  system  according  to  this
Standard, and executes equivalently on any such system.

FORTH Standard

A  system may be labeled 'FORTH-79 Standard' if it includes all  of
the Required Word Set in either source or object form, and complies
with the text of this Standard.  After executing "79-STANDARD"  the
dictionary  must  contain  all  of the Required  Word  Set  in  the
vocabulary FORTH, as specified in this Standard.

Standard Sub-set

A system may be labeled 'FORTH-79  Standard Sub-set' if it includes
a portion of the Required Word Set, and complies with the remaining
text  of this standard.  However, no Required Word may  be  present
with a non-standard definition.

Standard with Extensions

A  system  may be labeled 'FORTH-79 Standard with  <name>  Standard
Extensions)' if it comprises a FORTH-79 Standard System and one  or
more  Standard Extension Word Set(s).  The designation would be  in
the form:
          'FORTH-79 Standard with Double-Number-Standard Extensions'


                         8.  USE


A FORTH Standard, program may reference only the definitions of the
Required  Word Set, and definitions which are subsequently  defined
in  terms  of these words.  Furthermore, a FORTH  Standard  program
must use the standard words as required by any conventions of  this
Standard.  Equivalent execution must result from Standard programs.

The  FORTH  system may share the dictionary space with  the  user's
application,  and  the  native  addressing  protocol  of  the  host
computer is beyond the scope of this Standard.

Therefore, in a Standard program, the user may only operate on data
which was stored by the application.  No exceptions!

A Standard Program may address:

     1.   parameter fields of variables, constants and DOES> words.
          A DOES> word's parameter field may only be addressed with
          respect to the address left by DOES> , itself.

     2.   dictionary space ALLOTed.

     3.   data in mass storage block buffers.  (Note restriction in
          BLOCK on latest buffer addressing.)

     4.   the user area and PAD.

A Standard Program may NOT address:

     1.   directly into the data or return  stacks.

     2.   into  a  definition's  name field, link  field,  or  code
          field.

     3.   into a definition's parameter field if not stored by  the
          application.

Further   usage   requirements  are  expected  to  be   added   for
transporting progran between standard systems.

FORTH  Standard definitions have a serial number assigned,  in  the
range 100 thru 999.  Neither a Standard System nor Standard Program
may redefine these word names, within the FORTH vocabulary.


                         9.  GLOSSARY NOTATION


Order

     The  Glossary  definitions are listed  in  ASCII  alphabetical
     order.

Stack Notation

     The  first  line of each entry describes the execution of  the
     definition:

          i.e., before -- after

     In  this  notation,   the top of the stack is  to  the  right.
     Words may also be shown in context when appropriate.

Attributes

     Capitalized symbols indicate attributes of the defined words:

     C    The  word may only be used during compilation of a  colon
          definition.

     I    Indicates  that  the word is IMMEDIATE and  will  execute
          during compilation, unless special action is taken.

     U    A user variable.

Capitalization

     Word  names  as  used within the dictionary  are  conveniently
     written in upper case characters.   Within this Standard lower
     case  will  be  used when reference is made  to  the  run-time
     machine code, not directly accessible.

Pronunciation

     The  natural language pronunciation of word names is given  in
     double quotes (").

Stack Parameters

     Unless otherwise stated, all reference to numbers apply to 16-
     bit signed integers.   The implied range of values is shown as
     {from..to}.   The  content  of an address is shown  by  double
     curly  brackets,  particularly for the contents of  variables,
     i.e.,  BASE {{2..70}}.

addr                                                   {0..65,535}

     A value representing the address of a byte,  within the  FORTH
     standard memory space.   This addressed byte may represent the
     first byte of a larger data field in memory.

byte                                                   {0..255}

     A  value representing an 8 bit byte.   When in a larger field,
     the higher bits are zero.

char                                                   {0..127}

     A value representing a 7 bit ASCII character code.   When in a
     larger field, the higher bits are zero.

d                                  {-2,147,483,648..2,147,483,647}

     32 bit signed 'double' number.   The most significant 16-bits,
     with sign, is most accessible on the stack.

flag

     A numerical value with two logical states;   0 = false,   non-
     zero = true.

n                                                 {-32,768..32,767}

     16 bit signed integer number.

     Any other symbol refers to an arbitrary signed 16-bit  integer
     in the range {-32,768..32,767}, unless otherwise noted.

Input Text

     <name>

     An arbitrary FORTH word accepted from the input stream.   This
     notation refers to text from the input stream,  not to  values
     on  the data stack.   If the input stream is exhausted  before
     encountering <name>, an error condition exists.


                         10.  REQUIRED WORD SET


The  words  of  the  Required Word Set are  grouped  to  show  like
characteristics.  No implementation requirements should be inferred
from this grouping.

Nucleus Words

!   *   */   */MOD   +   +!   +loop   -   /
/MOD   0<   0=   0>   1+   1-   2+   2-   <
=   >   >R   ?DUP   @   ABS   AND   begin   C!
C@   colon   CMOVE   constant   create   D+
D<   DEPTH   DNEGATE   do   does>
DROP   DUP   else   EXECUTE   EXIT   FILL   I
if   J   LEAVE   literal   loop   MAX   MIN
MOD   MOVE   NEGATE   NOT   OR   OVER   PICK
R>   R@   repeat   ROLL   ROT   semicolon
SWAP   then   U*   U/   until   variable
while   XOR

(note  that  lower  case entries refer to just  the  run-time  code
corresponding to a compiling word.)

Interpreter Words

#   #>   #S   '   (   -TRAILING   .
79-STANDARD   <#   >IN   ?   ABORT   BASE   BLK
CONTEXT   CONVERT   COUNT   CR   CURRENT
DECIMAL   EMIT   EXPECT   FIND   FORTH   HERE
HOLD   KEY   PAD   QUERY   QUIT   SIGN   SPACE
SPACES   TYPE   U.   WORD

Compiler Words

+LOOP   ,   ."   :   ;   ALLOT   BEGIN
COMPILE   CONSTANT   CREATE   DEFINITIONS   DO
DOES>   ELSE   FORGET   IF   IMMEDIATE
LITERAL   LOOP   REPEAT   STATE   THEN   UNTIL
VARIABLE   VOCABULARY   WHILE   [   [COMPILE]   ]

Device Words

BLOCK   BUFFER   EMPTY-BUFFERS   LIST
LOAD   SAVE-BUFFERS   SCR   UPDATE



!              n addr --                     112            "store"
     Store n at addr.

#              ud1 -- ud2                    158            "sharp"
     Generate  from  an unsigned double number d1,  the next  ASCII
     character which is placed in an output string.   Result d2  is
     the  quotient after division by BASE is maintained for further
     processing.  Used between <# and #> .

#>             d -- addr n                   190    "sharp-greater"
     End pictured numeric output conversion.   Drop d,  leaving the
     text address, and character count, suitable for TYPE.

#S             ud -- 0 0                     209          "sharp-s"
     Convert  all digits of an unsigned 32-bit  number  ud,  adding
     each  to the pictured numeric output text,  until remainder is
     zero.   A  single  zero is added to the output string  if  the
     number was initially zero.  Use only between <# and #>.

'              -- addr                       I,171           "tick"
     Used in the form:
          '  <name>
     If  executing,  leave the parameter field address of the  next
     word accepted from the input stream.   If  compiling,  compile
     this  address  as a literal;  later execution will place  this
     value  on the stack.   An error condition exists if not  found
     after a search of the CONTEXT and FORTH vocabularies.   Within
     a  colon-definition  '  <name> is identical to [  '  <name>  ]
     LITERAL.

(              --                            I,122          "paren"
     Used in the form:
          ( ccc)
     Accept  and ignore comment characters from the  input  stream,
     until  the  next  right parenthesis.   As  a  word,  the  left
     parenthesis  must be followed by one blank.   It may freely be
     used while executing or compiling.   An error condition exists
     if the input stream is exhausted before the right parenthesis.

*              n1 n2 -- n3                   138            "times"
     Leave the arithmetic product of n1 times n2.

*/             n1 n2 n3 -- n4                220     "times-divide"
     Multiply  n1  by  n2,  divide the result by n3 and  leave  the
     quotient n4.   n4 is rounded toward zero.   The product of  n1
     times  n2  is maintained as an intermediate 32-bit  value  for
     greater precision than the otherwise equivalent  sequence:  n1
     n2 * n3 /

*/MOD          n1 n2 n3 -- n4 n5             192 "times-divide-mod"
     Multiply  n1  by  n2,  divide the result by n3 and  leave  the
     remainder n4 and quotient n5.   A 32-bit intermediate  product
     is used as for */ .  The remainder has the same sign as n1.

+              n1 n2 -- n3                   121             "plus"
     Leave the arithmetic sum of n1 plus n2.

+!             n addr --                     157       "plus-store"
     Add  n to the 16-bit value at the address,  by the  convention
     given for + .

+LOOP          n --                          I,C,141    "plus-loop"
     Add  the  signed  increment  n to the  loop  index  using  the
     convention for +,  and compare the total to the limit.  Return
     execution to the corresponding DO until the new index is equal
     to or greater than the limit (n>0),  or until the new index is
     less  than the limit (n<0).   Upon the exiting from the  loop,
     discard  the  loop control  parameters,  continuing  execution
     ahead.   Index and  limit are  signed  integers in  the  range
     {-32,768..32,767}.

     (Comment:  It is a historical precedent that the limit for n<0
     is irregular.   Further consideration of the characteristic is
     unlikely.)

,              n --                          143            "comma"
     Allot two bytes in the dictionary, storing n there.

-              n1 n2 -- n3                   134            "minus"
     Subtract n2 from n1 and leave the difference n3.

-TRAILING      addr n1 -- addr n2            148    "dash-trailing"
     Adjust  the character count n1 of a text string  beginning  at
     addr  to  exclude trailing blanks,  i.e.,  the  characters  at
     addr+n2 to addr+n1-1 are blanks.  An error condition exists if
     n1 is negative.

.              n --                          193              "dot"
     Display  n converted according to BASE in a free field  format
     with one trailing blank.  Display only a negative sign.

."                                           I,133      "dot-quote"
     Interpreted or used in a colon definition in the form:
          ." ccc"
     Accept the following text from the input stream, terminated by
     "  (double-quote).   If executing,  transmit this text to  the
     selected output device.   If compiling,  compile so that later
     execution  will  transmit  the  text to  the  selected  output
     device.   At least 127 characters are allowed in the text.  If
     the  input stream is exhausted before the terminating  double-
     quote, an error condition exists.

/              n1 n2 -- n3                   178           "divide"
     Divide  n1  by n2 and leave the quotient n3.   n3  is  rounded
     toward zero.

/MOD           n1 n2 -- n3 n4                198       "divide-mod"
     Divide  n1 by n2 and leave the remainder n3 and  quotient  n4.
     n3 has the same sign as n1.

0<             n -- flag                     144        "zero-less"
     True if n is less than zero (negative)

0=             n -- flag                     180      "zero-equals"
     True if n is zero.

0>             n -- flag                     118     "zero-greater"
     True if n is greater than zero.

1+             n -- n+1                      107         "one-plus"
     Increment n by one, according to the operation of + .

1-             n -- n-1                      105        "one-minus"
     Decrement n by one, according to the operation of - .

2+             n -- n+2                      135         "two-plus"
     Increment n by two, according to the operation of + .

2-             n -- n-1                      129        "two-minus"
     Decrement n by two, according to the operation of - .

79-STANDARD                                  119
     Execute assuring that a FORTH-79 Standard system is available,
     otherwise an error condition exists.

:                                            116            "colon"
     A defining word executed in the form:
          :  <name>  ...  ;
     Select  the  CONTEXT  vocabulary to be identical  to  CURRENT.
     Create  a  dictionary entry for <name>  in  CURRENT,  and  set
     compile   mode.    Words  thus  defined  are  called   'colon-
     definitions'.   The  compilation addresses of subsequent words
     from the input stream which are not immediate words are stored
     in  the  dictionary  to  be  executed  when  <name>  is  later
     executed.  IMMEDIATE words are executed as encountered.

     If a word is not found after a search of the CONTEXT and FORTH
     vocabularies,  conversion and compilation of a literal  number
     is attempted,  with regard to the current BASE;  that failing,
     an error condition exists .

;                                            I,C,196   "semi-colon"
     Terminate  a  colon  definition  and  stop  compilation.    If
     compiling  from mass storage and the input stream is exhausted
     before encountering ; an error condition exists.

<              n1 n2 -- flag                 139        "less-than"
     True if n1 is less than n2.

     -32768 32767 <  must return true.
     -32768 0 <  must be distinguished.

<#                                           169       "less-sharp"
     Initialize pictured numeric output.  The words:
          #  #>  #S  <#  HOLD  SIGN
     can   be used to specify the conversion of a  double-precision
     number into an ASCII character string stored in  right-to-left
     order.

=              n1 n2 -- flag                 173           "equals"
     True if n1 is equal to n2.

>              n1 n2 -- flag                 102     "greater-than"
     True if n1 is greater than n2.

>IN            -- addr                       U,201          "to-in"
     Leave  the  address of a variable which contains  the  present
     character offset within the input stream {{0..1023}}
     See:  WORD  (  ."  FIND

>R             n --                          C,200           "to-r"
     Transfer n to the return stack.   Every >R must be balanced by
     a  R> in the same control structure nesting level of a  colon-
     definition.

?              addr --                       194    "question-mark"
     Display the number at address, using the format of "." .

?DUP           n -- n ( n )                  184       "query-dupe"
     Duplicate n if it is non-zero.

@              addr -- n                     199            "fetch"
     Leave on the stack the number contained at addr.

ABORT                                        101
     Clear  the  data and return stacks,  setting  execution  mode.
     Return control to the terminal.

ABS            n1 -- n1                      108         "absolute"
     Leave the absolute value of a number.

ALLOT          n --                          154
     Add  n  bytes  to the parameter field  of  the  most  recently
     defined word.

AND            n1 n2 -- n3                   183
     Leave the bitwise logical 'and' of n1 and n2.

BASE           -- addr                       U,115
     Leave  the address of a variable containing the current input-
     output numeric conversion base.  {{2..70}}

BEGIN                                        I,C,147
     Used in a colon-definition in the form:
          BEGIN ... flag UNTIL   or
          BEGIN ... flag WHILE ... REPEAT
     BEGIN  marks  the  start of a  word  sequence  for  repetitive
     execution.   A BEGIN-UNTIL loop will be repeated until flag is
     true.   A  BEGIN-WHILE-REPEAT loop will be repeated until flag
     is  false.   The words after UNTIL or REPEAT will be  executed
     when  either loop is finished.   flag is always dropped  after
     being tested.

BLK            -- addr                       U,132          "b-l-k"
     Leave  the address of a variable containing the number of  the
     mass storage block being interpreted as the input stream.   If
     the  content  is  zero,  the input stream is  taken  from  the
     terminal.

BLOCK          n -- addr                     191
     Leave the address of the first byte in block n.   If the block
     is not already in memory,  it is transferred from mass storage
     into whichever memory buffer has been least recently accessed.
     If  the  block occupying that buffer has  been  UPDATEd  (i.e.
     modified), it is rewritten onto mass storage before block n is
     read  into the buffer.   n is an unsigned number.   If correct
     mass storage read or write is not possible, an error condition
     exists.  Only data within the latest block referenced by BLOCK
     is valid by byte address, due to sharing of the block buffers.

BUFFER         n -- addr                     130
     Obtain the next block buffer,  assigning it to block  n.   The
     block  is  not  read  from  mass  storage.   If  the  previous
     contents  of  the  buffer has been marked as  UPDATEd,  it  is
     written to mass storage.   If correct writing to mass  storage
     is not possible,  an error condition exists.  The address left
     is the first byte within the buffer for data storage.  n is an
     unsigned number.

C!             n addr --                     219          "c-store"
     Store the least significant 8-bits of n at addr.

C@             addr -- byte                  156          "c-fetch"
     Leave  on  the stack the contents of the byte  at  addr  (with
     higher bits zero, in a 16-bit field).

CMOVE          addr1 addr2 n --              153           "c-move"
     Move  n  bytes  beginning  at address  addr1  to  addr2.   The
     contents  of  addr1  is moved  first  proceeding  toward  high
     memory.  If n is zero nothing is moved.

COMPILE                                      C,146
     When  a  word containing COMPILE executes,  the  16-bit  value
     following   the  compilation  address  of  COMPILE  is  copied
     (compiled) into the dictionary.   i.e.,  COMPILE DUP will copy
     the compilation address of DUP.
          COMPILE  [ 0 , ]   will copy zero.

CONSTANT       n --                          185
     A defining word used in the form:
          n CONSTANT <name>
     to  create  a dictionary entry for <name>,  leaving n  in  its
     parameter  field.   When <name> is later executed,  n will  be
     left on the stack.

CONTEXT        -- addr                       U,151
     Leave  the address of a variable specifying the vocabulary  in
     which   dictionary   searches   are   to   be   made,   during
     interpretation of the input stream.

CONVERT        d1 addr1 -- d2 addr2          195
     Convert  to the equivalent stack number the text beginning  at
     addr1+1  with regard to BASE.   The new value  is  accumulated
     into double number d1, being left as d2.  addr2 is the address
     of the first non-convertible character.

COUNT          addr -- addr+1 n              159
     Leave  the  address  addr+1 and the character  count  of  text
     beginning  at addr.   The first byte at addr must contain  the
     character count n.  Range of n is {0..255}.

CR                                           160              "c-r"
     Cause  a carriage-return and line-feed to occur at the current
     output device.

CREATE                                       239
     A defining word used in the form:
          CREATE  <name>
     to  create a dictionary entry for <name>,  without  allocating
     any  parameter  field memory.   When  <name>  is  subsequently
     executed,  the address of the first byte of <name>'s parameter
     field is left on the stack.

CURRENT        -- addr                       U,137
     Leave the address of a variable specifying the vocabulary into
     which new word definitions are to be entered.

D+             d1 d2 --- d3                  241           "d-plus"
     Leave the arithmetic sum of d1 plus d2.

D<             d1 d2 -- flag                 244      "d-less-than"
     True if d1 is less than d2.

DECIMAL                                      197
     Set the input-output numeric conversion base to ten.

DEFINITIONS                                  155
     Set  CURRENT  to  the CONTEXT vocabulary  so  that  subsequent
     definitions  will  be  created in  the  vocabulary  previously
     selected as CONTEXT.

DEPTH          -- n                          238
     Leave the number of the quantity of 16-bit values contained in
     the data stack, before n added.

DNEGATE        d -- -d                       245         "d-negate"
     Leave the two's complement of a double number.

DO             n1 n2 --                      I,C,142
     Used in a colon-definition:
          DO ... LOOP   or
          DO ... +LOOP
     Begin a loop which will terminate based on control parameters.
     The loop index begins at n2, and terminates based on the limit
     n1.   At LOOP or +LOOP, the index is modified by a positive or
     negative  value.   The range of a DO-LOOP is determined by the
     terminating word.   DO-LOOP may be nested.  Capacity for three
     levels  of  nesting  is specified as a  minimum  for  standard
     systems.

DOES>                                        I,C,168         "does"
     Define  the run-time action of a word created by a  high-level
     defining word.  Used in the form:
          :  <name> ... CREATE ... DOES> ... ;
          and then   <namex>  <name>
     Marks  the  termination of the defining part of  the  defining
     word <name> and begins the defining of the run-time action for
     words  that will later be defined by <name>.   On execution of
     <namex>  the  sequence  of  words  between  DOES>  and  ;  are
     executed, with the address of <namex>'s parameter field on the
     stack.

DROP           n --                          233
     Drop the top number from the stack.

DUP            n -- n n                      205             "dupe"
     Leave a copy of the top stack number.

ELSE           --                            I,C,167
     Used in a colon-definition in the form:
          IF ... ELSE ... THEN
     ELSE executes after the true part following IF.   ELSE  forces
     execution  to skip till just after THEN.   It has no effect on
     the stack.  (see IF)

EMIT           char --                       207
     Transmit character to the current output device.

EMPTY-BUFFERS                                145
     Mark all block buffers as empty, without necessarily affecting
     their actual contents.  UPDATEd blocks are not written to mass
     storage.

EXECUTE        addr --                       163

     Execute the dictionary entry whose compilation address is on
     the stack.

EXIT                                         C,117
     When compiled within a colon-definition,  terminate  execution
     of that definition,  at that point.   May not be used within a
     DO...LOOP.

EXPECT         addr n --                     189
     Transfer  characters  from  the terminal  beginning  at  addr,
     upward,  until a "return" or the count of n has been received.
     Take  no action for n less than or equal to zero.   One or two
     nulls are added at the end of text.

FILL           addr n byte --                234
     Fill  memory beginning at address with a sequence of n  copies
     of  byte.   If the quantity n is less than or equal  to  zero,
     take no action.

FIND           -- addr                       203
     Leave the compilation address of the next word name,  which is
     accepted from the input stream.   If that word cannot be found
     in  the  dictionary after a search of CONTEXT and FORTH  leave
     zero.

FORGET                                       186
     Execute in the form:
          FORGET  <name>
     Delete  from  the dictionary <name> (which is in  the  CURRENT
     vocabulary)  and  all  words added  to  the  dictionary  after
     <name>,  regardless  of  their vocabulary.   Failure  to  find
     <name> in CURRENT or FORTH is an error condition.

FORTH                                        I,187
     The name of the primary vocabulary.  Execution makes FORTH the
     CONTEXT  vocabulary.   New  definitions become a part  of  the
     FORTH  until  a differing CURRENT vocabulary  is  established.
     User  vocabularies  conclude by 'chaining'  to  FORTH,  so  it
     should  be  considered that FORTH is 'contained'  within  each
     user's vocabulary.

HERE           -- addr                       188
     Return the address of the next available dictionary location.

HOLD           char --                       175
     Insert char into a pictured numeric output string.   May  only
     be used between <# and #> .

I              -- n                          C,136
     Copy the loop index onto the data stack.   May only be used in
     the form:
          DO ... I ... LOOP   or
          DO ... I ... +LOOP

IF             flag --                       I,C,210
     Used in a colon-definition in the form:
          flag  IF ... ELSE ... THEN   or
          flag  IF ... THEN
     If  flag is true,  the words following IF are executed and the
     words following ELSE are skipped.   The ELSE part is optional.
     If flag is false, words between IF and ELSE, or between IF and
     THEN  (when  no  ELSE is  used),  are  skipped.   IF-ELSE-THEN
     conditionals may be nested.

IMMEDIATE                                    103
     Marks the most recently made dictionary entry as a word  which
     will  be  executed when encountered during compilation  rather
     than compiled.

J              -- n                          C,225
     Return  the index of the next outer loop.   May only  be  used
     within a nested DO-LOOP in the form:
          DO ... DO ... J ... LOOP ... LOOP

KEY            -- char                       100
     Leave the ASCII value of the next available character from the
     current input device.

LEAVE                                        C,213
     Force  termination  of a DO-LOOP at the next LOOP or +LOOP  by
     setting  the  loop  limit equal to the current  value  of  the
     index.   The  index itself remains  unchanged,  and  execution
     proceeds   normally   until  the  loop  terminating  word   is
     encountered.

LIST           n --                          109
     List  the ASCII symbolic contents of screen n on  the  current
     output device, setting SCR to contain n.  n is unsigned.

LITERAL        n --                          I,215
     If  compiling,  then  compile  the stack value n as  a  16-bit
     literal, which when later executed, will leave n on the stack.

LOAD           n --                          202
     Begin  interpretation  of  screen n by  making  it  the  input
     stream;  preserve  the  locators of the present  input  stream
     (from  >IN  and  BLK).   If interpretation is  not  terminated
     explicitly  it  will be terminated when the  input  stream  is
     exhausted.    Control   then  returns  to  the  input   stream
     containing  LOAD,  determined by the input stream locators >IN
     and BLK.

LOOP                                         I,C,124
     Increment  the DO-LOOP index by one,  terminating the loop  if
     the  new  index is equal to or greater than  the  limit.   The
     limit  and  index  are signed numbers in  the  range  {-32,768
     ..32,767}.

MAX            n1 n2 -- n3                   218              "max"
     Leave the greater of two numbers.

MIN            n1 n2 -- n3                   127              "min"
     Leave the lesser of two numbers.

MOD            n1 n2 -- n3                   104
     Divide n1 by n2,  leaving the remainder n3, with the same sign
     as n1.

MOVE           addr1 addr2 n --              113
     Move the specified quantity n of 16-bit memory cells beginning
     at addr1 into memory at addr2.  The contents of addr1 is moved
     first.  If n is negative or zero, nothing is moved.

NEGATE         n -- -n                       177
     Leave the two's complement of a number,  i.e.,  the difference
     of zero less n.

NOT            flag1 -- flag2                165
     Reverse the boolean value of flag1.  This is identical to 0=.

OR             n1 n2 -- n3                   223
     Leave the bitwise inclusive-or of two numbers.

OVER           n1 n2 -- n1 n2 n1             170
     Leave a copy of the second number on the stack.

PAD            -- addr                       226
     The  address of a scratch area used to hold character  strings
     for  intermediate processing.   The minimum capacity of PAD is
     64 characters (addr through addr+63).

PICK           n1 -- n2                      240
     Return the contents of the n1-th stack value,  not counting n1
     itself.  An error condition results for n less than one.
          2 PICK  is equivalent to OVER.  {1..n}

QUERY                                        235
     Accept input of up to 80 characters (or until a 'return') from
     the operator's terminal, into the terminal input buffer.  WORD
     may  be  used  to accept text from this buffer  as  the  input
     stream, by setting >IN and BLK to zero.

QUIT                                         211
     Clear  the return stack,  setting execution mode,  and  return
     control to the terminal.  No message is given.

R>             -- n                          C,110         "r-from"
     Transfer n from the return stack to the data stack.

R@             -- n                          C,228        "r-fetch"
     Copy the number on top of the return stack to the data stack.

REPEAT         --                            I,C,120
     Used in a colon-definition in the form:
          BEGIN ... WHILE ... REPEAT
     At  run-time,  REPEAT returns to just after the  corresponding
     BEGIN.

ROLL           n --                          236
     Extract  the  n-th stack value to the top of  the  stack,  not
     counting  n  itself,  moving  the remaining  values  into  the
     vacated position.   An error condition results for n less than
     one.  {1..n}
          3  ROLL  =  ROT
          1  ROLL  =  null operation

ROT            n1 n2 n3 -- n2 n3 n1          212             "rote"
     Rotate the top three values, bringing the deepest to the top.

SAVE-BUFFERS                                 221
     Write  all  blocks to mass-storage that have been  flagged  as
     UPDATEd.   An  error condition results if mass-storage writing
     is not completed.

SCR            -- addr                       U,217
     Leave  the address of a variable containing the number of  the
     screen most recently listed.

SIGN           n --                          C,140
     Insert  the ASCII "-" (minus sign) into the  pictured  numeric
     output string, if n is negative.

SPACE                                        232
     Transmit an ASCII blank to the current output device.

SPACES         n --                          231
     Transmit  n  spaces  to the current output  device.   Take  no
     action for n of zero or less.

STATE          -- addr                       U,164
     Leave  the address of the variable containing the  compilation
     state.  A non-zero content indicates compilation is occurring,
     but the value itself may be installation dependent.

SWAP           n1 n2 -- n2 n1                230
     Exchange the top two stack values.

THEN                                         I,C,161
     Used in a colon-definition in the form:
          IF ... ELSE ... THEN   or
          IF ... THEN
     THEN  is  the point where execution resumes after ELSE  or  IF
     (when no ELSE is present).

TYPE           addr n --                     222
     Transmit  n  characters beginning at address  to  the  current
     output device.  No action takes place for n less than or equal
     to zero.

U*             un1 un2 -- ud3                242          "u-times"
     Perform an unsigned multiplication of un1 by un2,  leaving the
     double number product ud3.  All values are unsigned.

U.             un --                         106            "u-dot"
     Display  un converted according to BASE as an unsigned number,
     in a free-field format, with one trailing blank.

U/MOD          ud1 un2 -- un3 un4            243     "u-divide-mod"
     Perform  the  unsigned division of double number ud1  by  un2,
     leaving the remainder un3,  and the quotient un4.   All values
     are unsigned.

U<             un1 un2 -- flag               150      "u-less-than"
     Leave the flag representing the magnitude comparison of un1  <
     un2 where un1 and un2 are treated as 16-bit unsigned integers.

UNTIL          flag --                       I,C,,237
     Within a colon-definition, mark the end of a BEGIN-UNTIL loop,
     which will terminate based on flag.  If flag is true, the loop
     is  terminated.   If flag is false,  execution returns to  the
     first word after BEGIN.  BEGIN-UNTIL structures may be nested.

UPDATE                                       229
     Mark  the  most recently referenced block  as  modified.   The
     block  will subsequently be automatically transferred to  mass
     storage  should  its memory buffer be needed for storage of  a
     different block, or upon execution of SAVE-BUFFERS.

VARIABLE                                     227
     A defining word executed in the form:
          VARIABLE  <name>
     to  create a dictionary entry for <name> and allot  two  bytes
     for  storage  in the parameter field.   The  application  must
     initialize  the stored value.   When <name> is later executed,
     it will place the storage address on the stack.

VOCABULARY                                   208
     A defining word executed in the form:
          VOCABULARY  <name>
     to  create (in the CURRENT vocabulary) a dictionary entry  for
     <name>,   which   specifies  a  new  ordered  list   of   word
     definitions.   Subsequent execution of <name> will make it the
     CONTEXT   vocabulary.    When   <name>  becomes  the   CURRENT
     vocabulary (see DEFINITIONS), new definitions will be  created
     in that list.

     In lieu of any further specification, new vocabularies 'chain'
     to  FORTH.   That  is,  when  a dictionary  search  through  a
     vocabulary is exhausted, FORTH will be searched.

WHILE          flag --                       I,C,149
     Used in the form:
          BEGIN ... flag WHILE ... REPEAT
     Select conditional execution based on flag.   On a true  flag,
     continue execution through to REPEAT,  which then returns back
     to just after BEGIN.   On a false flag, skip execution to just
     after REPEAT, exiting the structure.

WORD           char -- addr                  181
     Receive  characters  from the input stream until the  non-zero
     delimiting  character  is encountered or the input  stream  is
     exhausted,  ignoring leading delimiters.   The characters  are
     stored  as  a  packed string with the character count  in  the
     first  character position.   The actual delimiter  encountered
     (char  or  null)  is stored at the end of  the  text  but  not
     included  in the count.   If the input stream was exhausted as
     WORD is called,  then a zero length will result.   The address
     of the beginning of this packed string is left on the stack.

XOR            n1 n2 -- n3                   174             "x-or"
     Leave the bitwise exclusive-or of two numbers.

[                                            I,125   "left-bracket"
     End the compilation mode.   The text from the input stream  is
     subsequently executed.  See ]

[COMPILE]                                I,C,179  "bracket-compile"
     Used in a colon-definition in the form:
          [COMPILE] <name>
     Forces  compilation  of  the  following  word.    This  allows
     compilation  of  an IMMEDIATE word when it would otherwise  be
     executed.

]                                            126    "right-bracket"
     Sets the compilation mode.   The text from the input stream is
     subsequently compiled.  See [


                         11. EXTENSION WORD SETS


11.1  DOUBLE NUMBER WORD SET


2!             d addr --                                "two-store"
     Store  d  in 4 consecutive bytes beginning at addr,  as for  a
     double number.

2@             addr -- d                                "two-fetch"
     Leave on the stack the contents of the four consecutive  bytes
     beginning at addr, as for a double number.

2CONSTANT      d --                                  "two-constant"
     A defining word used in the form:
          d  2CONSTANT  <name>
     to  create  a dictionary entry for <name>,  leaving d  in  its
     parameter  field.   When <name> is later executed,  d will  be
     left on the stack.

2DROP          d --                                      "two-drop"
     Drop the top double number on the stack.

2DUP           d -- d d                                  "two-dupe"
     Duplicate the top double number on the stack.

2OVER          d1 d2 -- d1 d2 d1                         "two-over"
     Leave a copy of the second double number on the stack.

2ROT           d1 d2 d3 -- d2 d3 d1                      "two-rote"
     Rotate the third double number to the top of the stack.

2SWAP          d1 d2 -- d2 d1                            "two-swap"
     Exchange the top two double numbers on the stack.

2VARIABLE                                            "two-variable"
     A defining word used in the form:
               2VARIABLE  <name>
     to  create a dictionary entry of <name> and assign four  bytes
     for  storage  in the parameter field.   When <name>  is  later
     executed,  it  will leave the address of the first byte of its
     parameter field is placed on the stack.

D+             d1 d2 -- d3                   241           "d-plus"
     Leave the arithmetic sum of d1 and d2.

D-             d1 d2 -- d3                   129          "d-minus"
     Subtract d2 from d1 and leave the difference d3.

D.             d --                          129            "d-dot"
     Display d converted according to BASE in a free field  format,
     with one trailing blank.  Display the sign only if negative.

D.R            d n --                                     "d-dot-r"
     Display  d converted according to BASE,  right aligned in an c
     character field. Display the sign only if negative.

D0=            d -- flag                            "d-zero-equals"
     Leave true if d is zero.

D<             d1 d2 -- flag                 244           "d-less"
     True if d1 is less than d2.

D=             d1 d2 -- flag                              "d-equal"
     True if d1 equals d2.

DABS           d1 -- d2                                "d-absolute"
     Leave as a positive double number d2,  the absolute value of a
     double number, d1.  {0..2,147,483,647}

DMAX           d1 d2 -- d3                                  "d-max"
     Leave the larger of two double numbers.

DMIN           d1 d2 -- d3                                  "d-min"
     Leave the smaller of two double numbers.

DNEGATE        d -- -d                       245
     Leave  the double number two's complement of a double  number,
     i.e., the difference 0 less d.

DU<            ud1 ud2 -- flag                           "d-u-less"
     True if ud1 is less than ud2.  Both numbers are unsigned.


11.2  ASSEMBLER WORD SET

;CODE                                    C,I,206  "semi-colon-code"
     Used in the form:
          : <name> ...  ;CODE
     Stop  compilation  and  terminate  a  defining  word   <name>.
     ASSEMBLER  becomes  the CONTEXT vocabulary.   When  <name>  is
     executed in the form:
          <name>  <namex>
     to  define the new <namex>,  the execution address 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.

ASSEMBLER                                    I,166
     Select assembler as the CONTEXT vocabulary.

CODE                                         111
     A defining word used in the form:
          CODE  <name> ... END-CODE
     to  create  a dictionary entry for <name> to be defined  by  a
     following  sequence  of assembly  language  words.   ASSEMBLER
     becomes the context vocabulary.

END-CODE
     Terminate a code definition,  resetting the CONTEXT vocabulary
     to the CURRENT vocabulary.   If no errors have  occurred,  the
     code definition is made available for use.


                         12.  EXPERIMENTAL PROPOSALS


No Experimental Proposals were submitted for publication.


                        REFERENCE WORD SET


This word set is furnished as a reference document.  It is a set of
formerly    standardized    words   and   candidate    words    for
standardization.

                        REFERENCE WORD SET
                             FORTH-79

The Reference Word Set contain both Standard Word Definitions (with
serial  number  identifiers  in the range  100  through  999),  and
uncontrolled word definitions.

Uncontrolled definitions are included for public reference of words
that   have   present  usage  and/or  are  candidates  for   future
standardization.

No   restrictions  are  placed  on  the  definition  or  usage   of
uncontrolled  words.   However,  use of these names for  procedures
differing from the given definitions is discouraged.


!BITS          n1 addr n2 --                           "store-bits"
     Store the value of n1  masked by n2 into the equivalent masked
     part  of the contents of addr,  without affecting bits outside
     the mask.

**             n1 n2 -- n3                                  "power"
     Leave the value of n1 to the power n2.

+BLOCK         n1 -- n2                                "plus-block"
     Leave the sum  of  n1  plus  the number  of  the  block  being
     interpreted, n1 and n2 are unsigned.

-'             -- ( addr )  flag                        "dash-tick"
     Used in the form:
          -' <name>
     Leave the parameter field of  <name>  beneath zero  (false) if
     the name can be found in the  CONTEXT  vocabulary;  leave only
     true if not found.

-->                                          I,131     "next-block"
     Continue interpretation on the next sequential block.   May be
     used within a colon definition that crosses a block boundary.

-MATCH         addr1 n1 addr2 n2 -- addr3 f            "dash-match"
     Attempt  to  find the n2-character string beginning  at  addr2
     somewhere  in  the  n1-character string  beginning  at  addr1.
     Return  the last+1 character address addr3 of the match  point
     and a flag which is zero if a match exists.

-TEXT          addr1 n1 addr2 -- n2                     "dash-text"
     Compare two strings over the length n1 beginning at addr1  and
     addr2.   Return  zero if the strings are equal.   If  unequal,
     return   n2,   the  difference  between  the  last  characters
     compared:  addr1(i) - addr2(i)

.R             n1 n2 --                                     "dot-r"
     Print n1 right aligned in a field of n2 characters,  according
     to  BASE.   If  n2  is less than  1,  no  leading  blanks  are
     supplied.

/LOOP          n --                                       "up-loop"
     A DO-LOOP terminating word.   The loop index is incremented by
     the  unsigned  magnitude  of n.   Until  the  resultant  index
     exceeds  the  limit,  execution  returns  to  just  after  the
     corresponding   DO:   otherwise,   the  index  and  limit  are
     discarded.  Magnitude logic is used.

1+!            addr --                             "one-plus-store"
     Add one to the 16-bit contents at addr.

1-!            addr --                            "one-minus-store"
     Subtract 1 from the 16-bit contents at addr.

2*             n1 -- n2                                 "two-times"
     Leave 2*(n1).

2/             n1 -- n2                                "two-divide"
     Leave (n1)/2.

;:                                           C   "semi-colon-oolon"
     Used to specify a new defining word:
          : <name>  ...
               ;:   ...  ;
          <name>  <namex>
     When <name> is executed, it creates an entry for the new  word
     <namex>.  Later execution of <namex> will execute the sequence
     of  words between  ;:  and  ; , with the address of the  first
     (if any) parameters associated with <namex> on the stack.

;S                                                         "semi-s"
     Stop interpretation of a block.  For execution only.

<>             n1 n2 -- flag                            "not-equal"
     Leave true if n1 is not equal to n2.

<BUILDS                                        C           "builds"
     Used in conjunction with DOES> in defining words, in the form:
          : <name>  . . .  <BUILDS  . . .
               DOES>  ...    ;
     and then  <name>  <namex>
     When  <name> executes, <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.

<CMOVE         addr1 addr2 n --                    "reverse-c-move"
     Copy  n bytes beginning at addr1 to addr2.   The move proceeds
     within the bytes from high memory toward low memory.

><             n1 -- n2                                 "byte-swap"
     Swap the high and low bytes within n1.

>MOVE<         addr1 addr2 n --                    "byte-swap-move"
     Move  n  bytes beginning at addr1 to the memory  beginning  at
     addr2.   During  this  move, the order of each  byte  pair  is
     reversed.

@BITS          addr n1 -- n2                          "fetch-bits"
     Return the 16-bits at addr masked by n1.

ABORT"         flag --                       I,C      "abort-quote"
     Used in a colon-definition in the form:
               ABORT" stack empty"
     If the flag is true,  print the following text,  till ".  Then
     execute ABORT.

AGAIN                                        I,C,114
     Effect  an  unconditional jump back to the start of  a  BEGIN-
     AGAIN loop.

ASCII          -- char (executing)
               --      (compiling)           I,C
     Leave  the  ASCII  character  value  of  the  next   non-blank
     character in the input stream.   If compiling, compile it as a
     literal, which will be later left when executed.

ASHIFT         n1 n2 -- n3
     Shift  the  value  n1 arithemetically n2 bits left  if  n2  is
     positive,  shifting  zeros  into  the  least-significant   bit
     positions.   If  n2 is negative, n1 is  shifted  right.   Sign
     extension is to be consistent with the processor's  arithmetic
     shift.

B/BUF          -- 1024                           "bytes-per-buffer"
     A constant leaving 1024, the number of bytes per block buffer.

BELL
     Activate  a terminal bell or noise-maker as appropriate to the
     device in use.

BL             -- n                          176              "b-l"
     Leave the ASCII character value for space (decimal 32).

BLANKS         addr n --                     152
     Fill  an area of memory over n bytes with the value for  ASCII
     blank,  starting at addr.  If n is less than or equal to zero,
     take no action.

C,             n --                                       "c-comma"
     Store  the  low-order  8 bits of n at the  next  byte  in  the
     dictionary, advancing the dictionary pointer.

CHAIN
     Used in the form:
          CHAIN  <name>
     Connect  the CURRENT vocabulary to all definitions that  might
     be  entered  into the vocabulary <name> in  the  future.   The
     CURRENT  vocabulary may not be FORTH or ASSEMBLER.  Any  given
     vocabulary may only be chained  once, but may be the object of
     any  number  of chainings.  For  example,  every  user-defined
     vocabulary may include the sequence:
          CHAIN  FORTH

COM            n1 -- n2
     Leave the one's complement of n1.

CONTINUED      n --
     Continue  interpretation at block n.

CUR            -- addr
     A variable pointing to the physical record number before which
     the tape is currently positioned.  REWIND sets CUR=1.

DBLOCK         d -- addr                                  "D-block"
     Identical to  BLOCK  but with a 32-bit block unsigned number.

DPL            -- addr                                      "d-p-l"
     A   variable  containing  the  number  of  places  after   the
     fractional point for output conversion.  If DPL contains zero,
     the  last character output will be a decimal point.   No point
     is  output if DPL contains a negative value.   DPL may be  set
     explicitly,  or by certain output words,  but is unaffected by
     number input.

DUMP           addr n --                     123
     List the contents of n addresses at addr.  Each line of values
     may be preceded by the address of the first value.

EDITOR                                       I,172
     The  name  of  the  editor  vocabulary.   When  this  name  is
     executed, EDITOR is established as the CONTEXT vocabulary.

END                                          I,C,224
     A synonym for UNTIL.

ERASE          addr n --                     182
     Fill  an area of memory over n bytes with zeros,  starting  at
     addr.  If n is zero or less, take no action.

FLD            -- addr                                      "f-l-d"
     A variable pointing to the field length reserved for a  number
     during output conversion.

FLUSH
     A synonym for SAVE-BUFFERS.

H.             n --
     Output  n  as a hexadecimal integer with one  trailing  blank.
     The current base is unchanged.

HEX            --                            162
     Set the numeric input-output conversion base to sixteen.

I'             -- n                          C            "i-prime"
     Used within a colon-definition executed only from within a DO-
     LOOP to return the corresponding loop index.

IFEND
     Terminate  a  conditional  interpretation  sequence  begun  by
     IFTRUE.

IFTRUE         flag --
     Begin an
               IFTRUE  ...  OTHERWISE  ...  IFEND
     conditional sequence.  These conditional words operate like
          IF  ...  ELSE  ...  THEN
     except  that  they cannot be nested, and are to be  used  only
     during interpretation.  In conjunction with the words [ and  ]
     they  may  be  used  within  a  colon-definition  to   control
     compilation, although they are not to be compiled.

INDEX          n1 n2 --
     Print  the first line of each screen over the range  {n1..n2}.
     This  displays  the first line of each screen of source  text,
     which conventionally contains a title.

INTERPRET
     Begin interpretation at the character indexed by the  contents
     of  >IN  relative  to  the  block  number  contained  in  BLK,
     continuing  until  the  input stream  is  exhausted.   If  BLK
     contains  zero,  interpret characters from the terminal  input
     buffer.

K              -- n                          C
     Within a nested DO-LOOP,  return the index of the second outer
     loop.

LAST           -- addr
     A variable containing the address of the beginning of the last
     dictionary  entry  made,  which may not yet be a  complete  or
     valid entry.

LINE           n -- addr
     Leave  the  address of the beginning of line n for the  screen
     whose number is contained in SCR.  The range of n is {0..15}.

LINELOAD       n1 n2 --
     Begin interpretation at line n1 of screen n2.

LOADS          n --
     A defining word used in the form:
          n  LOADS   <name>
     When <name> is subsequently executed, block n will be loaded.

MAP0           -- addr
     A variable pointing to the first location in the tape map.

MASK           n1 -- n2
     Leave a mask of n1 most significant bits if n1 is positive, or
     n least significant bits if n1 is negative.

MS             n --
     Delay for approximately n milliseconds.

NAND           n1 n2 -- n3
     Hie one's complement of the logical and of n1 and n2.

NOR            n1 n2 -- n3
     The one's complement of the logical or of n1 and n2.

NUMBER         addr -- n
     Convert  the count and character string at addr,  to a  signed
     32-bit integer, using the current base.  If numeric conversion
     is not possible,  an error condition exists.   The string  may
     contain a preceding negative sign.

O.             n --
     Print n in octal format with one trailing blank.  The value in
     base is unaffected.

OCTAL
     Set the number base to 8.

OFFSET         -- addr                       128
     A  variable that contains the offset added to the block number
     on  the stack by BLOCK to determine the actual physical  block
     number.   The user must add any desired offset when  utilizing
     BUFFER.

OTHERWISE
     An interpreter-level conditional word.  See IFTRUE.

PAGE
     Clear the terminal screen or perform an action suitable to the
     output device currently active.

READ-MAP
     Read   to   the  next  file  mark  on  tape   constructing   a
     correspondence  table  in memory (the map)  relating  physical
     block  position  to  logical block number.   The  tape  should
     normally  be rewound to its load point before executing  READ-
     MAP.

REMEMBER
     A defining word used in the form:
          REMEMBER <name>
     Defines a word which, when executed, will cause <name> and all
     subsequently defined words to be deleted from the  dictionary.
     <name>  may  be  compiled  into  and  executed  from  a  colon
     definition.  The sequence
          DISCARD  REMEMBER  DISCARD
     provides a standardized preface to any group of transient word
     definitions.

REWIND
     Rewind the tape to its load point, setting CUR=1.

ROTATE         n1 n2 -- n3
     Rotate  the value n1 left n2 bits if n2 is positive, right  n2
     bits  if n2 is negative.  Bits shifted out of one end  of  the
     cell are shifted back in at the opposite end.

S0             -- addr                                     "s-zero"
     Returns the address of the bottom of the stack, when empty.

SET            n addr --
     A defining word used  in the form:
          n  addr  SET  <name>

     Defines  a  word <name> which, when executed, will  cause  the
     value  n  to be stored at address.

SHIFT          n1 n2 -- n3
     Logical  shift  n1  left  n2  bits if  n2  in positive,  right
     if  n2  is  negative.   Zeros are  shifted  into  vacated  bit
     positions.

SP@            -- addr                       214        "s-p-fetch"
     Return  the address of the top of the stack,  just before  SP@
     was executed.

TEXT           c --
     Accept  characters from the input stream,  as for  WORD,  into
     PAD, blank-filling the remainder of PAD to 64 characters.

THRU           n1 n2 --
     Load consecutively the blocks from n1 through n2.

U.R            un1 n2 --                     216          "u-dot-r"
     Output un1 as an unsigned number right justified in a field n2
     characters  wide.   If  n2  is  smaller  than  the  characters
     required for n1, no leading spaces are given.

USER           n --
     A defining word used in the form:
          n  USER  <name>
     which  creates a user variable <name>.   n is the cell  offset
     within  the  user area where the value for <name>  is  stored.
     Execution  of  <name> leaves its absolute  user  area  storage
     address.

VLIST
     List  the  word names of the CONTEXT vocabulary starting  with
     the most recent definition.

WHERE
     Output information about the status of FORTH,  (e.g., after an
     error  abort).   Indicate at least the last word compiled  and
     the last block accessed.

\LOOP          n --                          I,C        "down-loop"
     A DO-LOOP terminating word.   The loop index is decremented by
     n  and  the loop terminated when the resultant  index  becomes
     equal to or less than the limit.  Magnitude logic is used, and
     n must be positive.

