home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / BEEHIVE / CPMFORTH / FORTHDOC.ARC / FORTH-79.TXT < prev    next >
Text File  |  1980-01-01  |  52KB  |  1,230 lines

  1.  
  2.       +-----------------------------------------------------+
  3.       | The  following glossary has been extracted from the |
  4.       | Forth-79  Standard.  It gives the  description  and |
  5.       | operation  of words required in a Forth-79 Standard |
  6.       | System.  Though  all  care has been  taken,  it  is |
  7.       | possible  that  errors  may  have  resulted  during |
  8.       | transcription. Full copies of the Forth-79 Standard |
  9.       | may be obtained from the Forth Interest Group, P.O. |
  10.       | Box 8231, San Jose, CA 95155 USA.                   |
  11.       +-----------------------------------------------------+
  12.  
  13.  
  14.  
  15.                          FORTH-79 STANDARD
  16.  
  17.  
  18.                          A PUBLICATION OF
  19.                      THE FORTH STANDARDS TEAM
  20.  
  21.  
  22.                            OCTOBER 1980
  23.  
  24.  
  25. The  existence of a FORTH Standard does not in any respect preclude
  26. anyone,  whether the individual has approved this Standard or  not,
  27. from  implementing,   marketing,   purchasing  or  using  products,
  28. processes,  or  procedures not conforming to the  Standard.   FORTH
  29. Standards are subject to periodic review and users are cautioned to
  30. obtain the latest editions.
  31.  
  32.  
  33.                          0.  FOREWORD
  34.  
  35. The computer language FORTH was created by Mr.  Charles Moore as an
  36. extensible,    multi-level   environment  containing elements of an
  37. operating  system,  a machine monitor,  and facilities for  program
  38. development and testing.
  39.  
  40. This  Standard  is a direct descendant of FORTH-77,  a work of  the
  41. FORTH Users Group (Europe).
  42.  
  43.                          1.  PURPOSE
  44.  
  45. The purpose of this FORTH Standard is to allow transportability  of
  46. standard  FORTH  programs  in  source  form  among  standard  FORTH
  47. systems.   A  standard  program shall execute equivalently  on  all
  48. standard FORTH systems.
  49.  
  50.                          2.  SCOPE
  51.  
  52. This  standard shall apply to any Standard FORTH program  executing
  53. on  any  Standard  FORTH  system,   providing  sufficient  computer
  54. resources (memory, mass storage) are available.
  55.  
  56.  
  57.                          9.  GLOSSARY NOTATION
  58.  
  59. Order
  60.  
  61.      The  Glossary  definitions are listed  in  ASCII  alphabetical
  62.      order.
  63.  
  64. Stack Notation
  65.  
  66.      The  first  line of each entry describes the execution of  the
  67.      definition:
  68.  
  69.           i.e., before -- after
  70.  
  71.      In  this  notation,   the top of the stack is  to  the  right.
  72.      Words may also be shown in context when appropriate.
  73.  
  74. Attributes
  75.  
  76.      Capitalized symbols indicate attributes of the defined words:
  77.  
  78.      C    The  word may only be used during compilation of a  colon
  79.           definition.
  80.  
  81.      I    Indicates  that  the word is IMMEDIATE and  will  execute
  82.           during compilation, unless special action is taken.
  83.  
  84.      U    A user variable.
  85.  
  86. Capitalization
  87.  
  88.      Word  names  as  used within the dictionary  are  conveniently
  89.      written in upper case characters.   Within this Standard lower
  90.      case  will  be  used when reference is made  to  the  run-time
  91.      machine code, not directly accessible.
  92.  
  93. Pronunciation
  94.  
  95.      The  natural language pronunciation of word names is given  in
  96.      double quotes (").
  97.  
  98. Stack Parameters
  99.  
  100.      Unless otherwise stated, all reference to numbers apply to 16-
  101.      bit signed integers.   The implied range of values is shown as
  102.      {from..to}.   The  content  of an address is shown  by  double
  103.      curly  brackets,  particularly for the contents of  variables,
  104.      i.e.,  BASE {{2..70}}.
  105.  
  106. addr                                                   {0..65,535}
  107.  
  108.      A value representing the address of a byte,  within the  FORTH
  109.      standard memory space.   This addressed byte may represent the
  110.      first byte of a larger data field in memory.
  111.  
  112. byte                                                   {0..255}
  113.  
  114.      A  value representing an 8 bit byte.   When in a larger field,
  115.      the higher bits are zero.
  116.  
  117. char                                                   {0..127}
  118.  
  119.      A value representing a 7 bit ASCII character code.   When in a
  120.      larger field, the higher bits are zero.
  121.  
  122. d                                  {-2,147,483,648..2,147,483,647}
  123.  
  124.      32 bit signed 'double' number.   The most significant 16-bits,
  125.      with sign, is most accessible on the stack.
  126.  
  127. flag
  128.  
  129.      A numerical value with two logical states;   0 = false,   non-
  130.      zero = true.
  131.  
  132. n                                                 {-32,768..32,767}
  133.  
  134.      16 bit signed integer number.
  135.  
  136.      Any other symbol refers to an arbitrary signed 16-bit  integer
  137.      in the range {-32,768..32,767}, unless otherwise noted.
  138.  
  139. Input Text
  140.  
  141.      <name>
  142.  
  143.      An arbitrary FORTH word accepted from the input stream.   This
  144.      notation refers to text from the input stream,  not to  values
  145.      on  the data stack.   If the input stream is exhausted  before
  146.      encountering <name>, an error condition exists.
  147.  
  148.  
  149.                          10.  REQUIRED WORD SET
  150.  
  151.  
  152. The  words  of  the  Required Word Set are  grouped  to  show  like
  153. characteristics.  No implementation requirements should be inferred
  154. from this grouping.
  155.  
  156. Nucleus Words
  157.  
  158. !   *   */   */MOD   +   +!   +loop   -   /
  159. /MOD   0<   0=   0>   1+   1-   2+   2-   <
  160. =   >   >R   ?DUP   @   ABS   AND   begin   C!
  161. C@   colon   CMOVE   constant   create   D+
  162. D<   DEPTH   DNEGATE   do   does>
  163. DROP   DUP   else   EXECUTE   EXIT   FILL   I
  164. if   J   LEAVE   literal   loop   MAX   MIN
  165. MOD   MOVE   NEGATE   NOT   OR   OVER   PICK
  166. R>   R@   repeat   ROLL   ROT   semicolon
  167. SWAP   then   U*   U/   until   variable
  168. while   XOR
  169.  
  170. (note  that  lower  case entries refer to just  the  run-time  code
  171. corresponding to a compiling word.)
  172.  
  173. Interpreter Words
  174.  
  175. #   #>   #S   '   (   -TRAILING   .
  176. 79-STANDARD   <#   >IN   ?   ABORT   BASE   BLK
  177. CONTEXT   CONVERT   COUNT   CR   CURRENT
  178. DECIMAL   EMIT   EXPECT   FIND   FORTH   HERE
  179. HOLD   KEY   PAD   QUERY   QUIT   SIGN   SPACE
  180. SPACES   TYPE   U.   WORD
  181.  
  182. Compiler Words
  183.  
  184. +LOOP   ,   ."   :   ;   ALLOT   BEGIN
  185. COMPILE   CONSTANT   CREATE   DEFINITIONS   DO
  186. DOES>   ELSE   FORGET   IF   IMMEDIATE
  187. LITERAL   LOOP   REPEAT   STATE   THEN   UNTIL
  188. VARIABLE   VOCABULARY   WHILE   [   [COMPILE]   ]
  189.  
  190. Device Words
  191.  
  192. BLOCK   BUFFER   EMPTY-BUFFERS   LIST
  193. LOAD   SAVE-BUFFERS   SCR   UPDATE
  194.  
  195.  
  196.  
  197. !              n addr --                     112            "store"
  198.      Store n at addr.
  199.  
  200. #              ud1 -- ud2                    158            "sharp"
  201.      Generate  from  an unsigned double number d1,  the next  ASCII
  202.      character which is placed in an output string.   Result d2  is
  203.      the  quotient after division by BASE is maintained for further
  204.      processing.  Used between <# and #> .
  205.  
  206. #>             d -- addr n                   190    "sharp-greater"
  207.      End pictured numeric output conversion.   Drop d,  leaving the
  208.      text address, and character count, suitable for TYPE.
  209.  
  210. #S             ud -- 0 0                     209          "sharp-s"
  211.      Convert  all digits of an unsigned 32-bit  number  ud,  adding
  212.      each  to the pictured numeric output text,  until remainder is
  213.      zero.   A  single  zero is added to the output string  if  the
  214.      number was initially zero.  Use only between <# and #>.
  215.  
  216. '              -- addr                       I,171           "tick"
  217.      Used in the form:
  218.           '  <name>
  219.      If  executing,  leave the parameter field address of the  next
  220.      word accepted from the input stream.   If  compiling,  compile
  221.      this  address  as a literal;  later execution will place  this
  222.      value  on the stack.   An error condition exists if not  found
  223.      after a search of the CONTEXT and FORTH vocabularies.   Within
  224.      a  colon-definition  '  <name> is identical to [  '  <name>  ]
  225.      LITERAL.
  226.  
  227. (              --                            I,122          "paren"
  228.      Used in the form:
  229.           ( ccc)
  230.      Accept  and ignore comment characters from the  input  stream,
  231.      until  the  next  right parenthesis.   As  a  word,  the  left
  232.      parenthesis  must be followed by one blank.   It may freely be
  233.      used while executing or compiling.   An error condition exists
  234.      if the input stream is exhausted before the right parenthesis.
  235.  
  236. *              n1 n2 -- n3                   138            "times"
  237.      Leave the arithmetic product of n1 times n2.
  238.  
  239. */             n1 n2 n3 -- n4                220     "times-divide"
  240.      Multiply  n1  by  n2,  divide the result by n3 and  leave  the
  241.      quotient n4.   n4 is rounded toward zero.   The product of  n1
  242.      times  n2  is maintained as an intermediate 32-bit  value  for
  243.      greater precision than the otherwise equivalent  sequence:  n1
  244.      n2 * n3 /
  245.  
  246. */MOD          n1 n2 n3 -- n4 n5             192 "times-divide-mod"
  247.      Multiply  n1  by  n2,  divide the result by n3 and  leave  the
  248.      remainder n4 and quotient n5.   A 32-bit intermediate  product
  249.      is used as for */ .  The remainder has the same sign as n1.
  250.  
  251. +              n1 n2 -- n3                   121             "plus"
  252.      Leave the arithmetic sum of n1 plus n2.
  253.  
  254. +!             n addr --                     157       "plus-store"
  255.      Add  n to the 16-bit value at the address,  by the  convention
  256.      given for + .
  257.  
  258. +LOOP          n --                          I,C,141    "plus-loop"
  259.      Add  the  signed  increment  n to the  loop  index  using  the
  260.      convention for +,  and compare the total to the limit.  Return
  261.      execution to the corresponding DO until the new index is equal
  262.      to or greater than the limit (n>0),  or until the new index is
  263.      less  than the limit (n<0).   Upon the exiting from the  loop,
  264.      discard  the  loop control  parameters,  continuing  execution
  265.      ahead.   Index and  limit are  signed  integers in  the  range
  266.      {-32,768..32,767}.
  267.  
  268.      (Comment:  It is a historical precedent that the limit for n<0
  269.      is irregular.   Further consideration of the characteristic is
  270.      unlikely.)
  271.  
  272. ,              n --                          143            "comma"
  273.      Allot two bytes in the dictionary, storing n there.
  274.  
  275. -              n1 n2 -- n3                   134            "minus"
  276.      Subtract n2 from n1 and leave the difference n3.
  277.  
  278. -TRAILING      addr n1 -- addr n2            148    "dash-trailing"
  279.      Adjust  the character count n1 of a text string  beginning  at
  280.      addr  to  exclude trailing blanks,  i.e.,  the  characters  at
  281.      addr+n2 to addr+n1-1 are blanks.  An error condition exists if
  282.      n1 is negative.
  283.  
  284. .              n --                          193              "dot"
  285.      Display  n converted according to BASE in a free field  format
  286.      with one trailing blank.  Display only a negative sign.
  287.  
  288. ."                                           I,133      "dot-quote"
  289.      Interpreted or used in a colon definition in the form:
  290.           ." ccc"
  291.      Accept the following text from the input stream, terminated by
  292.      "  (double-quote).   If executing,  transmit this text to  the
  293.      selected output device.   If compiling,  compile so that later
  294.      execution  will  transmit  the  text to  the  selected  output
  295.      device.   At least 127 characters are allowed in the text.  If
  296.      the  input stream is exhausted before the terminating  double-
  297.      quote, an error condition exists.
  298.  
  299. /              n1 n2 -- n3                   178           "divide"
  300.      Divide  n1  by n2 and leave the quotient n3.   n3  is  rounded
  301.      toward zero.
  302.  
  303. /MOD           n1 n2 -- n3 n4                198       "divide-mod"
  304.      Divide  n1 by n2 and leave the remainder n3 and  quotient  n4.
  305.      n3 has the same sign as n1.
  306.  
  307. 0<             n -- flag                     144        "zero-less"
  308.      True if n is less than zero (negative)
  309.  
  310. 0=             n -- flag                     180      "zero-equals"
  311.      True if n is zero.
  312.  
  313. 0>             n -- flag                     118     "zero-greater"
  314.      True if n is greater than zero.
  315.  
  316. 1+             n -- n+1                      107         "one-plus"
  317.      Increment n by one, according to the operation of + .
  318.  
  319. 1-             n -- n-1                      105        "one-minus"
  320.      Decrement n by one, according to the operation of - .
  321.  
  322. 2+             n -- n+2                      135         "two-plus"
  323.      Increment n by two, according to the operation of + .
  324.  
  325. 2-             n -- n-1                      129        "two-minus"
  326.      Decrement n by two, according to the operation of - .
  327.  
  328. 79-STANDARD                                  119
  329.      Execute assuring that a FORTH-79 Standard system is available,
  330.      otherwise an error condition exists.
  331.  
  332. :                                            116            "colon"
  333.      A defining word executed in the form:
  334.           :  <name>  ...  ;
  335.      Select  the  CONTEXT  vocabulary to be identical  to  CURRENT.
  336.      Create  a  dictionary entry for <name>  in  CURRENT,  and  set
  337.      compile   mode.    Words  thus  defined  are  called   'colon-
  338.      definitions'.   The  compilation addresses of subsequent words
  339.      from the input stream which are not immediate words are stored
  340.      in  the  dictionary  to  be  executed  when  <name>  is  later
  341.      executed.  IMMEDIATE words are executed as encountered.
  342.  
  343.      If a word is not found after a search of the CONTEXT and FORTH
  344.      vocabularies,  conversion and compilation of a literal  number
  345.      is attempted,  with regard to the current BASE;  that failing,
  346.      an error condition exists .
  347.  
  348. ;                                            I,C,196   "semi-colon"
  349.      Terminate  a  colon  definition  and  stop  compilation.    If
  350.      compiling  from mass storage and the input stream is exhausted
  351.      before encountering ; an error condition exists.
  352.  
  353. <              n1 n2 -- flag                 139        "less-than"
  354.      True if n1 is less than n2.
  355.  
  356.      -32768 32767 <  must return true.
  357.      -32768 0 <  must be distinguished.
  358.  
  359. <#                                           169       "less-sharp"
  360.      Initialize pictured numeric output.  The words:
  361.           #  #>  #S  <#  HOLD  SIGN
  362.      can   be used to specify the conversion of a  double-precision
  363.      number into an ASCII character string stored in  right-to-left
  364.      order.
  365.  
  366. =              n1 n2 -- flag                 173           "equals"
  367.      True if n1 is equal to n2.
  368.  
  369. >              n1 n2 -- flag                 102     "greater-than"
  370.      True if n1 is greater than n2.
  371.  
  372. >IN            -- addr                       U,201          "to-in"
  373.      Leave  the  address of a variable which contains  the  present
  374.      character offset within the input stream {{0..1023}}
  375.      See:  WORD  (  ."  FIND
  376.  
  377. >R             n --                          C,200           "to-r"
  378.      Transfer n to the return stack.   Every >R must be balanced by
  379.      a  R> in the same control structure nesting level of a  colon-
  380.      definition.
  381.  
  382. ?              addr --                       194    "question-mark"
  383.      Display the number at address, using the format of "." .
  384.  
  385. ?DUP           n -- n ( n )                  184       "query-dupe"
  386.      Duplicate n if it is non-zero.
  387.  
  388. @              addr -- n                     199            "fetch"
  389.      Leave on the stack the number contained at addr.
  390.  
  391. ABORT                                        101
  392.      Clear  the  data and return stacks,  setting  execution  mode.
  393.      Return control to the terminal.
  394.  
  395. ABS            n1 -- n1                      108         "absolute"
  396.      Leave the absolute value of a number.
  397.  
  398. ALLOT          n --                          154
  399.      Add  n  bytes  to the parameter field  of  the  most  recently
  400.      defined word.
  401.  
  402. AND            n1 n2 -- n3                   183
  403.      Leave the bitwise logical 'and' of n1 and n2.
  404.  
  405. BASE           -- addr                       U,115
  406.      Leave  the address of a variable containing the current input-
  407.      output numeric conversion base.  {{2..70}}
  408.  
  409. BEGIN                                        I,C,147
  410.      Used in a colon-definition in the form:
  411.           BEGIN ... flag UNTIL   or
  412.           BEGIN ... flag WHILE ... REPEAT
  413.      BEGIN  marks  the  start of a  word  sequence  for  repetitive
  414.      execution.   A BEGIN-UNTIL loop will be repeated until flag is
  415.      true.   A  BEGIN-WHILE-REPEAT loop will be repeated until flag
  416.      is  false.   The words after UNTIL or REPEAT will be  executed
  417.      when  either loop is finished.   flag is always dropped  after
  418.      being tested.
  419.  
  420. BLK            -- addr                       U,132          "b-l-k"
  421.      Leave  the address of a variable containing the number of  the
  422.      mass storage block being interpreted as the input stream.   If
  423.      the  content  is  zero,  the input stream is  taken  from  the
  424.      terminal.
  425.  
  426. BLOCK          n -- addr                     191
  427.      Leave the address of the first byte in block n.   If the block
  428.      is not already in memory,  it is transferred from mass storage
  429.      into whichever memory buffer has been least recently accessed.
  430.      If  the  block occupying that buffer has  been  UPDATEd  (i.e.
  431.      modified), it is rewritten onto mass storage before block n is
  432.      read  into the buffer.   n is an unsigned number.   If correct
  433.      mass storage read or write is not possible, an error condition
  434.      exists.  Only data within the latest block referenced by BLOCK
  435.      is valid by byte address, due to sharing of the block buffers.
  436.  
  437. BUFFER         n -- addr                     130
  438.      Obtain the next block buffer,  assigning it to block  n.   The
  439.      block  is  not  read  from  mass  storage.   If  the  previous
  440.      contents  of  the  buffer has been marked as  UPDATEd,  it  is
  441.      written to mass storage.   If correct writing to mass  storage
  442.      is not possible,  an error condition exists.  The address left
  443.      is the first byte within the buffer for data storage.  n is an
  444.      unsigned number.
  445.  
  446. C!             n addr --                     219          "c-store"
  447.      Store the least significant 8-bits of n at addr.
  448.  
  449. C@             addr -- byte                  156          "c-fetch"
  450.      Leave  on  the stack the contents of the byte  at  addr  (with
  451.      higher bits zero, in a 16-bit field).
  452.  
  453. CMOVE          addr1 addr2 n --              153           "c-move"
  454.      Move  n  bytes  beginning  at address  addr1  to  addr2.   The
  455.      contents  of  addr1  is moved  first  proceeding  toward  high
  456.      memory.  If n is zero nothing is moved.
  457.  
  458. COMPILE                                      C,146
  459.      When  a  word containing COMPILE executes,  the  16-bit  value
  460.      following   the  compilation  address  of  COMPILE  is  copied
  461.      (compiled) into the dictionary.   i.e.,  COMPILE DUP will copy
  462.      the compilation address of DUP.
  463.           COMPILE  [ 0 , ]   will copy zero.
  464.  
  465. CONSTANT       n --                          185
  466.      A defining word used in the form:
  467.           n CONSTANT <name>
  468.      to  create  a dictionary entry for <name>,  leaving n  in  its
  469.      parameter  field.   When <name> is later executed,  n will  be
  470.      left on the stack.
  471.  
  472. CONTEXT        -- addr                       U,151
  473.      Leave  the address of a variable specifying the vocabulary  in
  474.      which   dictionary   searches   are   to   be   made,   during
  475.      interpretation of the input stream.
  476.  
  477. CONVERT        d1 addr1 -- d2 addr2          195
  478.      Convert  to the equivalent stack number the text beginning  at
  479.      addr1+1  with regard to BASE.   The new value  is  accumulated
  480.      into double number d1, being left as d2.  addr2 is the address
  481.      of the first non-convertible character.
  482.  
  483. COUNT          addr -- addr+1 n              159
  484.      Leave  the  address  addr+1 and the character  count  of  text
  485.      beginning  at addr.   The first byte at addr must contain  the
  486.      character count n.  Range of n is {0..255}.
  487.  
  488. CR                                           160              "c-r"
  489.      Cause  a carriage-return and line-feed to occur at the current
  490.      output device.
  491.  
  492. CREATE                                       239
  493.      A defining word used in the form:
  494.           CREATE  <name>
  495.      to  create a dictionary entry for <name>,  without  allocating
  496.      any  parameter  field memory.   When  <name>  is  subsequently
  497.      executed,  the address of the first byte of <name>'s parameter
  498.      field is left on the stack.
  499.  
  500. CURRENT        -- addr                       U,137
  501.      Leave the address of a variable specifying the vocabulary into
  502.      which new word definitions are to be entered.
  503.  
  504. D+             d1 d2 --- d3                  241           "d-plus"
  505.      Leave the arithmetic sum of d1 plus d2.
  506.  
  507. D<             d1 d2 -- flag                 244      "d-less-than"
  508.      True if d1 is less than d2.
  509.  
  510. DECIMAL                                      197
  511.      Set the input-output numeric conversion base to ten.
  512.  
  513. DEFINITIONS                                  155
  514.      Set  CURRENT  to  the CONTEXT vocabulary  so  that  subsequent
  515.      definitions  will  be  created in  the  vocabulary  previously
  516.      selected as CONTEXT.
  517.  
  518. DEPTH          -- n                          238
  519.      Leave the number of the quantity of 16-bit values contained in
  520.      the data stack, before n added.
  521.  
  522. DNEGATE        d -- -d                       245         "d-negate"
  523.      Leave the two's complement of a double number.
  524.  
  525. DO             n1 n2 --                      I,C,142
  526.      Used in a colon-definition:
  527.           DO ... LOOP   or
  528.           DO ... +LOOP
  529.      Begin a loop which will terminate based on control parameters.
  530.      The loop index begins at n2, and terminates based on the limit
  531.      n1.   At LOOP or +LOOP, the index is modified by a positive or
  532.      negative  value.   The range of a DO-LOOP is determined by the
  533.      terminating word.   DO-LOOP may be nested.  Capacity for three
  534.      levels  of  nesting  is specified as a  minimum  for  standard
  535.      systems.
  536.  
  537. DOES>                                        I,C,168         "does"
  538.      Define  the run-time action of a word created by a  high-level
  539.      defining word.  Used in the form:
  540.           :  <name> ... CREATE ... DOES> ... ;
  541.           and then   <namex>  <name>
  542.      Marks  the  termination of the defining part of  the  defining
  543.      word <name> and begins the defining of the run-time action for
  544.      words  that will later be defined by <name>.   On execution of
  545.      <namex>  the  sequence  of  words  between  DOES>  and  ;  are
  546.      executed, with the address of <namex>'s parameter field on the
  547.      stack.
  548.  
  549. DROP           n --                          233
  550.      Drop the top number from the stack.
  551.  
  552. DUP            n -- n n                      205             "dupe"
  553.      Leave a copy of the top stack number.
  554.  
  555. ELSE           --                            I,C,167
  556.      Used in a colon-definition in the form:
  557.           IF ... ELSE ... THEN
  558.      ELSE executes after the true part following IF.   ELSE  forces
  559.      execution  to skip till just after THEN.   It has no effect on
  560.      the stack.  (see IF)
  561.  
  562. EMIT           char --                       207
  563.      Transmit character to the current output device.
  564.  
  565. EMPTY-BUFFERS                                145
  566.      Mark all block buffers as empty, without necessarily affecting
  567.      their actual contents.  UPDATEd blocks are not written to mass
  568.      storage.
  569.  
  570. EXIT                                         C,117
  571.      When compiled within a colon-definition,  terminate  execution
  572.      of that definition,  at that point.   May not be used within a
  573.      DO...LOOP.
  574.  
  575. EXPECT         addr n --                     189
  576.      Transfer  characters  from  the terminal  beginning  at  addr,
  577.      upward,  until a "return" or the count of n has been received.
  578.      Take  no action for n less than or equal to zero.   One or two
  579.      nulls are added at the end of text.
  580.  
  581. FILL           addr n byte --                234
  582.      Fill  memory beginning at address with a sequence of n  copies
  583.      of  byte.   If the quantity n is less than or equal  to  zero,
  584.      take no action.
  585.  
  586. FIND           -- addr                       203
  587.      Leave the compilation address of the next word name,  which is
  588.      accepted from the input stream.   If that word cannot be found
  589.      in  the  dictionary after a search of CONTEXT and FORTH  leave
  590.      zero.
  591.  
  592. FORGET                                       186
  593.      Execute in the form:
  594.           FORGET  <name>
  595.      Delete  from  the dictionary <name> (which is in  the  CURRENT
  596.      vocabulary)  and  all  words added  to  the  dictionary  after
  597.      <name>,  regardless  of  their vocabulary.   Failure  to  find
  598.      <name> in CURRENT or FORTH is an error condition.
  599.  
  600. FORTH                                        I,187
  601.      The name of the primary vocabulary.  Execution makes FORTH the
  602.      CONTEXT  vocabulary.   New  definitions become a part  of  the
  603.      FORTH  until  a differing CURRENT vocabulary  is  established.
  604.      User  vocabularies  conclude by 'chaining'  to  FORTH,  so  it
  605.      should  be  considered that FORTH is 'contained'  within  each
  606.      user's vocabulary.
  607.  
  608. HERE           -- addr                       188
  609.      Return the address of the next available dictionary location.
  610.  
  611. HOLD           char --                       175
  612.      Insert char into a pictured numeric output string.   May  only
  613.      be used between <# and #> .
  614.  
  615. I              -- n                          C,136
  616.      Copy the loop index onto the data stack.   May only be used in
  617.      the form:
  618.           DO ... I ... LOOP   or
  619.           DO ... I ... +LOOP
  620.  
  621. IF             flag --                       I,C,210
  622.      Used in a colon-definition in the form:
  623.           flag  IF ... ELSE ... THEN   or
  624.           flag  IF ... THEN
  625.      If  flag is true,  the words following IF are executed and the
  626.      words following ELSE are skipped.   The ELSE part is optional.
  627.      If flag is false, words between IF and ELSE, or between IF and
  628.      THEN  (when  no  ELSE is  used),  are  skipped.   IF-ELSE-THEN
  629.      conditionals may be nested.
  630.  
  631. IMMEDIATE                                    103
  632.      Marks the most recently made dictionary entry as a word  which
  633.      will  be  executed when encountered during compilation  rather
  634.      than compiled.
  635.  
  636. J              -- n                          C,225
  637.      Return  the index of the next outer loop.   May only  be  used
  638.      within a nested DO-LOOP in the form:
  639.           DO ... DO ... J ... LOOP ... LOOP
  640.  
  641. KEY            -- char                       100
  642.      Leave the ASCII value of the next available character from the
  643.      current input device.
  644.  
  645. LEAVE                                        C,213
  646.      Force  termination  of a DO-LOOP at the next LOOP or +LOOP  by
  647.      setting  the  loop  limit equal to the current  value  of  the
  648.      index.   The  index itself remains  unchanged,  and  execution
  649.      proceeds   normally   until  the  loop  terminating  word   is
  650.      encountered.
  651.  
  652. LIST           n --                          109
  653.      List  the ASCII symbolic contents of screen n on  the  current
  654.      output device, setting SCR to contain n.  n is unsigned.
  655.  
  656. LITERAL        n --                          I,215
  657.      If  compiling,  then  compile  the stack value n as  a  16-bit
  658.      literal, which when later executed, will leave n on the stack.
  659.  
  660. LOAD           n --                          202
  661.      Begin  interpretation  of  screen n by  making  it  the  input
  662.      stream;  preserve  the  locators of the present  input  stream
  663.      (from  >IN  and  BLK).   If interpretation is  not  terminated
  664.      explicitly  it  will be terminated when the  input  stream  is
  665.      exhausted.    Control   then  returns  to  the  input   stream
  666.      containing  LOAD,  determined by the input stream locators >IN
  667.      and BLK.
  668.  
  669. LOOP                                         I,C,124
  670.      Increment  the DO-LOOP index by one,  terminating the loop  if
  671.      the  new  index is equal to or greater than  the  limit.   The
  672.      limit  and  index  are signed numbers in  the  range  {-32,768
  673.      ..32,767}.
  674.  
  675. MAX            n1 n2 -- n3                   218              "max"
  676.      Leave the greater of two numbers.
  677.  
  678. MIN            n1 n2 -- n3                   127              "min"
  679.      Leave the lesser of two numbers.
  680.  
  681. MOD            n1 n2 -- n3                   104
  682.      Divide n1 by n2,  leaving the remainder n3, with the same sign
  683.      as n1.
  684.  
  685. MOVE           addr1 addr2 n --              113
  686.      Move the specified quantity n of 16-bit memory cells beginning
  687.      at addr1 into memory at addr2.  The contents of addr1 is moved
  688.      first.  If n is negative or zero, nothing is moved.
  689.  
  690. NEGATE         n -- -n                       177
  691.      Leave the two's complement of a number,  i.e.,  the difference
  692.      of zero less n.
  693.  
  694. NOT            flag1 -- flag2                165
  695.      Reverse the boolean value of flag1.  This is identical to 0=.
  696.  
  697. OR             n1 n2 -- n3                   223
  698.      Leave the bitwise inclusive-or of two numbers.
  699.  
  700. OVER           n1 n2 -- n1 n2 n1             170
  701.      Leave a copy of the second number on the stack.
  702.  
  703. PAD            -- addr                       226
  704.      The  address of a scratch area used to hold character  strings
  705.      for  intermediate processing.   The minimum capacity of PAD is
  706.      64 characters (addr through addr+63).
  707.  
  708. PICK           n1 -- n2                      240
  709.      Return the contents of the n1-th stack value,  not counting n1
  710.      itself.  An error condition results for n less than one.
  711.           2 PICK  is equivalent to OVER.  {1..n}
  712.  
  713. QUERY                                        235
  714.      Accept input of up to 80 characters (or until a 'return') from
  715.      the operator's terminal, into the terminal input buffer.  WORD
  716.      may  be  used  to accept text from this buffer  as  the  input
  717.      stream, by setting >IN and BLK to zero.
  718.  
  719. QUIT                                         211
  720.      Clear  the return stack,  setting execution mode,  and  return
  721.      control to the terminal.  No message is given.
  722.  
  723. R>             -- n                          C,110         "r-from"
  724.      Transfer n from the return stack to the data stack.
  725.  
  726. R@             -- n                          C,228        "r-fetch"
  727.      Copy the number on top of the return stack to the data stack.
  728.  
  729. REPEAT         --                            I,C,120
  730.      Used in a colon-definition in the form:
  731.           BEGIN ... WHILE ... REPEAT
  732.      At  run-time,  REPEAT returns to just after the  corresponding
  733.      BEGIN.
  734.  
  735. ROLL           n --                          236
  736.      Extract  the  n-th stack value to the top of  the  stack,  not
  737.      counting  n  itself,  moving  the remaining  values  into  the
  738.      vacated position.   An error condition results for n less than
  739.      one.  {1..n}
  740.           3  ROLL  =  ROT
  741.           1  ROLL  =  null operation
  742.  
  743. ROT            n1 n2 n3 -- n2 n3 n1          212             "rote"
  744.      Rotate the top three values, bringing the deepest to the top.
  745.  
  746. SAVE-BUFFERS                                 221
  747.      Write  all  blocks to mass-storage that have been  flagged  as
  748.      UPDATEd.   An  error condition results if mass-storage writing
  749.      is not completed.
  750.  
  751. SCR            -- addr                       U,217
  752.      Leave  the address of a variable containing the number of  the
  753.      screen most recently listed.
  754.  
  755. SIGN           n --                          C,140
  756.      Insert  the ASCII "-" (minus sign) into the  pictured  numeric
  757.      output string, if n is negative.
  758.  
  759. SPACE                                        232
  760.      Transmit an ASCII blank to the current output device.
  761.  
  762. SPACES         n --                          231
  763.      Transmit  n  spaces  to the current output  device.   Take  no
  764.      action for n of zero or less.
  765.  
  766. STATE          -- addr                       U,164
  767.      Leave  the address of the variable containing the  compilation
  768.      state.  A non-zero content indicates compilation is occurring,
  769.      but the value itself may be installation dependent.
  770.  
  771. SWAP           n1 n2 -- n2 n1                230
  772.      Exchange the top two stack values.
  773.  
  774. THEN                                         I,C,161
  775.      Used in a colon-definition in the form:
  776.           IF ... ELSE ... THEN   or
  777.           IF ... THEN
  778.      THEN  is  the point where execution resumes after ELSE  or  IF
  779.      (when no ELSE is present).
  780.  
  781. TYPE           addr n --                     222
  782.      Transmit  n  characters beginning at address  to  the  current
  783.      output device.  No action takes place for n less than or equal
  784.      to zero.
  785.  
  786. U*             un1 un2 -- ud3                242          "u-times"
  787.      Perform an unsigned multiplication of un1 by un2,  leaving the
  788.      double number product ud3.  All values are unsigned.
  789.  
  790. U.             un --                         106            "u-dot"
  791.      Display  un converted according to BASE as an unsigned number,
  792.      in a free-field format, with one trailing blank.
  793.  
  794. U/MOD          ud1 un2 -- un3 un4            243     "u-divide-mod"
  795.      Perform  the  unsigned division of double number ud1  by  un2,
  796.      leaving the remainder un3,  and the quotient un4.   All values
  797.      are unsigned.
  798.  
  799. U<             un1 un2 -- flag               150      "u-less-than"
  800.      Leave the flag representing the magnitude comparison of un1  <
  801.      un2 where un1 and un2 are treated as 16-bit unsigned integers.
  802.  
  803. UNTIL          flag --                       I,C,,237
  804.      Within a colon-definition, mark the end of a BEGIN-UNTIL loop,
  805.      which will terminate based on flag.  If flag is true, the loop
  806.      is  terminated.   If flag is false,  execution returns to  the
  807.      first word after BEGIN.  BEGIN-UNTIL structures may be nested.
  808.  
  809. UPDATE                                       229
  810.      Mark  the  most recently referenced block  as  modified.   The
  811.      block  will subsequently be automatically transferred to  mass
  812.      storage  should  its memory buffer be needed for storage of  a
  813.      different block, or upon execution of SAVE-BUFFERS.
  814.  
  815. VARIABLE                                     227
  816.      A defining word executed in the form:
  817.           VARIABLE  <name>
  818.      to  create a dictionary entry for <name> and allot  two  bytes
  819.      for  storage  in the parameter field.   The  application  must
  820.      initialize  the stored value.   When <name> is later executed,
  821.      it will place the storage address on the stack.
  822.  
  823. VOCABULARY                                   208
  824.      A defining word executed in the form:
  825.           VOCABULARY  <name>
  826.      to  create (in the CURRENT vocabulary) a dictionary entry  for
  827.      <name>,   which   specifies  a  new  ordered  list   of   word
  828.      definitions.   Subsequent execution of <name> will make it the
  829.      CONTEXT   vocabulary.    When   <name>  becomes  the   CURRENT
  830.      vocabulary (see DEFINITIONS), new definitions will be  created
  831.      in that list.
  832.  
  833.      In lieu of any further specification, new vocabularies 'chain'
  834.      to  FORTH.   That  is,  when  a dictionary  search  through  a
  835.      vocabulary is exhausted, FORTH will be searched.
  836.  
  837. WHILE          flag --                       I,C,149
  838.      Used in the form:
  839.           BEGIN ... flag WHILE ... REPEAT
  840.      Select conditional execution based on flag.   On a true  flag,
  841.      continue execution through to REPEAT,  which then returns back
  842.      to just after BEGIN.   On a false flag, skip execution to just
  843.      after REPEAT, exiting the structure.
  844.  
  845. WORD           char -- addr                  181
  846.      Receive  characters  from the input stream until the  non-zero
  847.      delimiting  character  is encountered or the input  stream  is
  848.      exhausted,  ignoring leading delimiters.   The characters  are
  849.      stored  as  a  packed string with the character count  in  the
  850.      first  character position.   The actual delimiter  encountered
  851.      (char  or  null)  is stored at the end of  the  text  but  not
  852.      included  in the count.   If the input stream was exhausted as
  853.      WORD is called,  then a zero length will result.   The address
  854.      of the beginning of this packed string is left on the stack.
  855.  
  856. XOR            n1 n2 -- n3                   174             "x-or"
  857.      Leave the bitwise exclusive-or of two numbers.
  858.  
  859. [                                            I,125   "left-bracket"
  860.      End the compilation mode.   The text from the input stream  is
  861.      subsequently executed.  See ]
  862.  
  863. [COMPILE]                                I,C,179  "bracket-compile"
  864.      Used in a colon-definition in the form:
  865.           [COMPILE] <name>
  866.      Forces  compilation  of  the  following  word.    This  allows
  867.      compilation  of  an IMMEDIATE word when it would otherwise  be
  868.      executed.
  869.  
  870. ]                                            126    "right-bracket"
  871.      Sets the compilation mode.   The text from the input stream is
  872.      subsequently compiled.  See [
  873.  
  874.  
  875.                11. EXTENSION WORD SETS
  876.  
  877.  
  878. 11.1  DOUBLE NUMBER WORD SET
  879.  
  880.  
  881. 2!             d addr --                                "two-store"
  882.      Store  d  in 4 consecutive bytes beginning at addr,  as for  a
  883.      double number.
  884.  
  885. 2@             addr -- d                                "two-fetch"
  886.      Leave on the stack the contents of the four consecutive  bytes
  887.      beginning at addr, as for a double number.
  888.  
  889. 2CONSTANT      d --                                  "two-constant"
  890.      A defining word used in the form:
  891.           d  2CONSTANT  <name>
  892.      to  create  a dictionary entry for <name>,  leaving d  in  its
  893.      parameter  field.   When <name> is later executed,  d will  be
  894.      left on the stack.
  895.  
  896. 2DROP          d --                                      "two-drop"
  897.      Drop the top double number on the stack.
  898.  
  899. 2DUP           d -- d d                                  "two-dupe"
  900.      Duplicate the top double number on the stack.
  901.  
  902. 2OVER          d1 d2 -- d1 d2 d1                         "two-over"
  903.      Leave a copy of the second double number on the stack.
  904.  
  905. 2ROT           d1 d2 d3 -- d2 d3 d1                      "two-rote"
  906.      Rotate the third double number to the top of the stack.
  907.  
  908. 2SWAP          d1 d2 -- d2 d1                            "two-swap"
  909.      Exchange the top two double numbers on the stack.
  910.  
  911. 2VARIABLE                                            "two-variable"
  912.      A defining word used in the form:
  913.                2VARIABLE  <name>
  914.      to  create a dictionary entry of <name> and assign four  bytes
  915.      for  storage  in the parameter field.   When <name>  is  later
  916.      executed,  it  will leave the address of the first byte of its
  917.      parameter field is placed on the stack.
  918.  
  919. D+             d1 d2 -- d3                   241           "d-plus"
  920.      Leave the arithmetic sum of d1 and d2.
  921.  
  922. D-             d1 d2 -- d3                   129          "d-minus"
  923.      Subtract d2 from d1 and leave the difference d3.
  924.  
  925. D.             d --                          129            "d-dot"
  926.      Display d converted according to BASE in a free field  format,
  927.      with one trailing blank.  Display the sign only if negative.
  928.  
  929. D.R            d n --                                     "d-dot-r"
  930.      Display  d converted according to BASE,  right aligned in an c
  931.      character field. Display the sign only if negative.
  932.  
  933. D0=            d -- flag                            "d-zero-equals"
  934.      Leave true if d is zero.
  935.  
  936. D<             d1 d2 -- flag                 244           "d-less"
  937.      True if d1 is less than d2.
  938.  
  939. D=             d1 d2 -- flag                              "d-equal"
  940.      True if d1 equals d2.
  941.  
  942. DABS           d1 -- d2                                "d-absolute"
  943.      Leave as a positive double number d2,  the absolute value of a
  944.      double number, d1.  {0..2,147,483,647}
  945.  
  946. DMAX           d1 d2 -- d3                                  "d-max"
  947.      Leave the larger of two double numbers.
  948.  
  949. DMIN           d1 d2 -- d3                                  "d-min"
  950.      Leave the smaller of two double numbers.
  951.  
  952. DNEGATE        d -- -d                       245
  953.      Leave  the double number two's complement of a double  number,
  954.      i.e., the difference 0 less d.
  955.  
  956. DU<            ud1 ud2 -- flag                           "d-u-less"
  957.      True if ud1 is less than ud2.  Both numbers are unsigned.
  958.  
  959.  
  960. 11.2  ASSEMBLER WORD SET
  961.  
  962. ;CODE                                    C,I,206  "semi-colon-code"
  963.      Used in the form:
  964.           : <name> ...  ;CODE
  965.      Stop  compilation  and  terminate  a  defining  word   <name>.
  966.      ASSEMBLER  becomes  the CONTEXT vocabulary.   When  <name>  is
  967.      executed in the form:
  968.           <name>  <namex>
  969.      to  define the new <namex>,  the execution address of  <namex>
  970.      will  contain  the address of the code sequence following  the
  971.      ;CODE  in <name>.   Execution of any <namex> will  cause  this
  972.      machine code sequence to be executed.
  973.  
  974. ASSEMBLER                                    I,166
  975.      Select assembler as the CONTEXT vocabulary.
  976.  
  977. CODE                                         111
  978.      A defining word used in the form:
  979.           CODE  <name> ... END-CODE
  980.      to  create  a dictionary entry for <name> to be defined  by  a
  981.      following  sequence  of assembly  language  words.   ASSEMBLER
  982.      becomes the context vocabulary.
  983.  
  984. END-CODE
  985.      Terminate a code definition,  resetting the CONTEXT vocabulary
  986.      to the CURRENT vocabulary.   If no errors have  occurred,  the
  987.      code definition is made available for use.
  988.  
  989.  
  990.                         REFERENCE WORD SET
  991.  
  992. This word set is furnished as a reference document.  It is a set of
  993. formerly    standardized    words   and   candidate    words    for
  994. standardization.
  995.  
  996.       +-----------------------------------------------------+
  997.       | The  following words represent only the more common |
  998.       | of the definitions actually listed in the  FORTH-79 |
  999.       | Standard.                                           |
  1000.       +-----------------------------------------------------+
  1001.  
  1002.                         REFERENCE WORD SET
  1003.                              FORTH-79
  1004.  
  1005. The Reference Word Set contain both Standard Word Definitions (with
  1006. serial  number  identifiers  in the range  100  through  999),  and
  1007. uncontrolled word definitions.
  1008.  
  1009. Uncontrolled definitions are included for public reference of words
  1010. that   have   present  usage  and/or  are  candidates  for   future
  1011. standardization.
  1012.  
  1013. No   restrictions  are  placed  on  the  definition  or  usage   of
  1014. uncontrolled  words.   However,  use of these names for  procedures
  1015. differing from the given definitions is discouraged.
  1016.  
  1017.  
  1018. -->                                          I,131     "next-block"
  1019.      Continue interpretation on the next sequential block.   May be
  1020.      used within a colon definition that crosses a block boundary.
  1021.  
  1022. -MATCH         addr1 n1 addr2 n2 -- addr3 f            "dash-match"
  1023.      Attempt  to  find the n2-character string beginning  at  addr2
  1024.      somewhere  in  the  n1-character string  beginning  at  addr1.
  1025.      Return  the last+1 character address addr3 of the match  point
  1026.      and a flag which is zero if a match exists.
  1027.  
  1028. -TEXT          addr1 n1 addr2 -- n2                     "dash-text"
  1029.      Compare two strings over the length n1 beginning at addr1  and
  1030.      addr2.   Return  zero if the strings are equal.   If  unequal,
  1031.      return   n2,   the  difference  between  the  last  characters
  1032.      compared:  addr1(i) - addr2(i)
  1033.  
  1034. .R             n1 n2 --                                     "dot-r"
  1035.      Print n1 right aligned in a field of n2 characters,  according
  1036.      to  BASE.   If  n2  is less than  1,  no  leading  blanks  are
  1037.      supplied.
  1038.  
  1039. /LOOP          n --                                       "up-loop"
  1040.      A DO-LOOP terminating word.   The loop index is incremented by
  1041.      the  unsigned  magnitude  of n.   Until  the  resultant  index
  1042.      exceeds  the  limit,  execution  returns  to  just  after  the
  1043.      corresponding   DO:   otherwise,   the  index  and  limit  are
  1044.      discarded.  Magnitude logic is used.
  1045.  
  1046. 2*             n1 -- n2                                 "two-times"
  1047.      Leave 2*(n1).
  1048.  
  1049. ;S                                                         "semi-s"
  1050.      Stop interpretation of a block.  For execution only.
  1051.  
  1052. <>             n1 n2 -- flag                            "not-equal"
  1053.      Leave true if n1 is not equal to n2.
  1054.  
  1055. <CMOVE         addr1 addr2 n --                    "reverse-c-move"
  1056.      Copy  n bytes beginning at addr1 to addr2.   The move proceeds
  1057.      within the bytes from high memory toward low memory.
  1058.  
  1059. ABORT"         flag --                       I,C      "abort-quote"
  1060.      Used in a colon-definition in the form:
  1061.                ABORT" stack empty"
  1062.      If the flag is true,  print the following text,  till ".  Then
  1063.      execute ABORT.
  1064.  
  1065. AGAIN                                        I,C,114
  1066.      Effect  an  unconditional jump back to the start of  a  BEGIN-
  1067.      AGAIN loop.
  1068.  
  1069. ASCII          -- char (executing)
  1070.                --      (compiling)           I,C
  1071.      Leave  the  ASCII  character  value  of  the  next   non-blank
  1072.      character in the input stream.   If compiling, compile it as a
  1073.      literal, which will be later left when executed.
  1074.  
  1075. B/BUF          -- 1024                           "bytes-per-buffer"
  1076.      A constant leaving 1024, the number of bytes per block buffer.
  1077.  
  1078. BELL
  1079.      Activate  a terminal bell or noise-maker as appropriate to the
  1080.      device in use.
  1081.  
  1082. BL             -- n                          176              "b-l"
  1083.      Leave the ASCII character value for space (decimal 32).
  1084.  
  1085. BLANKS         addr n --                     152
  1086.      Fill  an area of memory over n bytes with the value for  ASCII
  1087.      blank,  starting at addr.  If n is less than or equal to zero,
  1088.      take no action.
  1089.  
  1090. C,             n --                                       "c-comma"
  1091.      Store  the  low-order  8 bits of n at the  next  byte  in  the
  1092.      dictionary, advancing the dictionary pointer.
  1093.  
  1094. COM            n1 -- n2
  1095.      Leave the one's complement of n1.
  1096.  
  1097. DPL            -- addr                                      "d-p-l"
  1098.      A   variable  containing  the  number  of  places  after   the
  1099.      fractional point for output conversion.  If DPL contains zero,
  1100.      the  last character output will be a decimal point.   No point
  1101.      is  output if DPL contains a negative value.   DPL may be  set
  1102.      explicitly,  or by certain output words,  but is unaffected by
  1103.      number input.
  1104.  
  1105. DUMP           addr n --                     123
  1106.      List the contents of n addresses at addr.  Each line of values
  1107.      may be preceded by the address of the first value.
  1108.  
  1109. EDITOR                                       I,172
  1110.      The  name  of  the  editor  vocabulary.   When  this  name  is
  1111.      executed, EDITOR is established as the CONTEXT vocabulary.
  1112.  
  1113. END                                          I,C,224
  1114.      A synonym for UNTIL.
  1115.  
  1116. ERASE          addr n --                     182
  1117.      Fill  an area of memory over n bytes with zeros,  starting  at
  1118.      addr.  If n is zero or less, take no action.
  1119.  
  1120. FLD            -- addr                                      "f-l-d"
  1121.      A variable pointing to the field length reserved for a  number
  1122.      during output conversion.
  1123.  
  1124. FLUSH
  1125.      A synonym for SAVE-BUFFERS.
  1126.  
  1127. H.             n --
  1128.      Output  n  as a hexadecimal integer with one  trailing  blank.
  1129.      The current base is unchanged.
  1130.  
  1131. HEX            --                            162
  1132.      Set the numeric input-output conversion base to sixteen.
  1133.  
  1134. I'             -- n                          C            "i-prime"
  1135.      Used within a colon-definition executed only from within a DO-
  1136.      LOOP to return the corresponding loop index.
  1137.  
  1138. INDEX          n1 n2 --
  1139.      Print  the first line of each screen over the range  {n1..n2}.
  1140.      This  displays  the first line of each screen of source  text,
  1141.      which conventionally contains a title.
  1142.  
  1143. INTERPRET
  1144.      Begin interpretation at the character indexed by the  contents
  1145.      of  >IN  relative  to  the  block  number  contained  in  BLK,
  1146.      continuing  until  the  input stream  is  exhausted.   If  BLK
  1147.      contains  zero,  interpret characters from the terminal  input
  1148.      buffer.
  1149.  
  1150. K              -- n                          C
  1151.      Within a nested DO-LOOP,  return the index of the second outer
  1152.      loop.
  1153.  
  1154. LAST           -- addr
  1155.      A variable containing the address of the beginning of the last
  1156.      dictionary  entry  made,  which may not yet be a  complete  or
  1157.      valid entry.
  1158.  
  1159. LINE           n -- addr
  1160.      Leave  the  address of the beginning of line n for the  screen
  1161.      whose number is contained in SCR.  The range of n is {0..15}.
  1162.  
  1163. MS             n --
  1164.      Delay for approximately n milliseconds.
  1165.  
  1166. NUMBER         addr -- n
  1167.      Convert  the count and character string at addr,  to a  signed
  1168.      32-bit integer, using the current base.  If numeric conversion
  1169.      is not possible,  an error condition exists.   The string  may
  1170.      contain a preceding negative sign.
  1171.  
  1172. O.             n --
  1173.      Print n in octal format with one trailing blank.  The value in
  1174.      base is unaffected.
  1175.  
  1176. OCTAL
  1177.      Set the number base to 8.
  1178.  
  1179. OFFSET         -- addr                       128
  1180.      A  variable that contains the offset added to the block number
  1181.      on  the stack by BLOCK to determine the actual physical  block
  1182.      number.   The user must add any desired offset when  utilizing
  1183.      BUFFER.
  1184.  
  1185. PAGE
  1186.      Clear the terminal screen or perform an action suitable to the
  1187.      output device currently active.
  1188.  
  1189. S0             -- addr                                     "s-zero"
  1190.      Returns the address of the bottom of the stack, when empty.
  1191.  
  1192. SP@            -- addr                       214        "s-p-fetch"
  1193.      Return  the address of the top of the stack,  just before  SP@
  1194.      was executed.
  1195.  
  1196. TEXT           c --
  1197.      Accept  characters from the input stream,  as for  WORD,  into
  1198.      PAD, blank-filling the remainder of PAD to 64 characters.
  1199.  
  1200. THRU           n1 n2 --
  1201.      Load consecutively the blocks from n1 through n2.
  1202.  
  1203. U.R            un1 n2 --                     216          "u-dot-r"
  1204.      Output un1 as an unsigned number right justified in a field n2
  1205.      characters  wide.   If  n2  is  smaller  than  the  characters
  1206.      required for n1, no leading spaces are given.
  1207.  
  1208. USER           n --
  1209.      A defining word used in the form:
  1210.           n  USER  <name>
  1211.      which  creates a user variable <name>.   n is the cell  offset
  1212.      within  the  user area where the value for <name>  is  stored.
  1213.      Execution  of  <name> leaves its absolute  user  area  storage
  1214.      address.
  1215.  
  1216. VLIST
  1217.      List  the  word names of the CONTEXT vocabulary starting  with
  1218.      the most recent definition.
  1219.  
  1220. WHERE
  1221.      Output information about the status of FORTH,  (e.g., after an
  1222.      error  abort).   Indicate at least the last word compiled  and
  1223.      the last block accessed.
  1224.  
  1225. \LOOP          n --                          I,C        "down-loop"
  1226.      A DO-LOOP terminating word.   The loop index is decremented by
  1227.      n  and  the loop terminated when the resultant  index  becomes
  1228.      equal to or less than the limit.  Magnitude logic is used, and
  1229.      n must be positive.
  1230.