home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / forth / compiler / fpc / help / kernel2.hlp < prev    next >
Encoding:
Text File  |  1989-07-06  |  21.6 KB  |  663 lines
  1. \ KERNEL2.HLP   Help file for the KERNEL2.SEQ file
  2.  
  3. TOS             ( -- a1 )
  4.         Top OF Stack, Saved during Task switching.
  5.  
  6. ENTRY           ( -- a1 )
  7.         Jumped to during multitasking.
  8.  
  9. LINK            ( -- a1 )
  10.         Points to next task in the circular queue
  11.  
  12. ES0             ( -- a1 )
  13.         ES register initial segment.
  14.  
  15. SP0             ( -- a1 )
  16.         Empty parameter stack for this task.
  17.  
  18. RP0             ( -- a1 )
  19.         Empty return stack for this task.
  20.  
  21. DP              ( -- a1 )
  22.         Size of dictionary.  Next available location.
  23.  
  24. OFFSET          ( -- a1 )
  25.         Added to all block references.
  26.  
  27. BASE            ( -- a1 )
  28.         The current numeric base for number input output.
  29.  
  30. HLD             ( -- a1 )
  31.         Points to a converted character during numeric output.
  32.  
  33. PRINTING        ( -- a1 )
  34.         A variable which holds a flag that Indicates whether printing is
  35.         enabled.
  36.  
  37. EMIT            ( c1 -- )
  38.         A defered word which sends a character to the output device.
  39.  
  40. KEY?            ( -- f1 )
  41.         A defered word that returns a true flag if a key waiting.
  42.  
  43. KEY             ( -- c1 )
  44.         A defered word to get a key from user.
  45.  
  46. TYPE            ( a1 n1 -- )
  47.         A defered word used to Print a string to the current output device
  48.         from the segment specified in the variable TYPESEG.
  49.  
  50. EXTYPE          ( seg a1 n1 -- )
  51.         A defered word used to print a string to the current output device
  52.         from external memory specified in segment SEG.
  53.  
  54. PRIOR           ( -- a1 )
  55.         Points to the last vocabulary that was searched.
  56.  
  57. STATE           ( -- addr )
  58.         A variable that holds the compilation state.  If the contents of
  59.         STATE are 0 , then the Forth system is in interpret mode.  Otherwise
  60.         the system is in compilation mode.
  61.  
  62. WARNING         ( -- a1 )
  63.         Checked by WARN for duplicate warnings.
  64.  
  65. DPL             ( -- a1 )
  66.         The decimal point location for number input.
  67.  
  68. R#              ( -- a1 )
  69.         The cursor position during editing.
  70.  
  71. LAST            ( -- a1 )
  72.         Points to the name of the most recently CREATEd word.
  73.  
  74. CSP             ( -- a1 )
  75.         Used for compile time error checking.
  76.  
  77. CURRENT         ( -- a1 )
  78.         New words are added to the CURRENT vocabulary.
  79.  
  80. #VOCS           ( -- a1 )
  81.         The number of elements in the search order array.
  82.  
  83. CONTEXT         ( -- a1 )
  84.         The array specifying the search order.
  85.  
  86. 'TIB            ( -- a1 )
  87.         Points to characters entered by user.
  88.  
  89. WIDTH           ( -- a1 )
  90.         Number of characters to keep in name field.
  91.  
  92. VOC-LINK         ( -- a1 )
  93.          Points to the most recently defined vocabulary.
  94.  
  95. >IN             ( -- a1 )
  96.         Number of characters interpreted so far.
  97.  
  98. SPAN            ( -- a1 )
  99.         Number of characters input by EXPECT.
  100.  
  101. #TIB            ( -- a1 )
  102.         Used by WORD, when interpreting from the terminal.
  103.  
  104. END?            ( -- a1 )
  105.         True if input stream exhausted, else false.
  106.  
  107. #OUT            ( -- a1 )
  108.         A variable that holds the column number of the most recent type or
  109.         emit to the display.
  110.  
  111. #LINE           ( -- a1 )
  112.         A variable that holds the line number of the current line on which
  113.         text is being typed.
  114.  
  115. XDP             ( -- a1 )
  116.         A variable that holds the address in dictionary list space of
  117.         the top of the top of the dictionary.
  118.  
  119. XDPSEG          ( -- a1 )
  120.         A variable that holds the segment of the top of the list dictionary.
  121.  
  122. YDP             ( -- a1 )
  123.         A variable that holds the address in HEAD space of the next
  124.         available byte.
  125.  
  126. YSTART          ( -- a1 )
  127.         A variable that holds the offset to the starting head in head space.
  128.  
  129. DPSTART         ( -- a1 )
  130.         Beginning of list space in .COM or .EXE file.
  131.  
  132. XSEGLEN         ( -- n )
  133.         Length of list space, in segments.
  134.  
  135. XMOVED          ( -- n )
  136.         A flag to tell if Lists have been moved.
  137.  
  138. SSEG            ( -- n )
  139.         The Search and Scan Segment.
  140.  
  141. SEQHANDLE       ( -- n )
  142.         The sequential handle file.
  143.  
  144. LOADLINE        ( -- n )
  145.         The line number last returned by LINEREAD .
  146.  
  147. BL              ( -- c1 )
  148.         Return hex 20, decimal 32 the value of an Ascii space.
  149.  
  150. BS              ( -- c1 )
  151.         Return the value 8, an Ascii Back Space.
  152.  
  153. BELL            ( -- c1 )
  154.         Return the value 7, an Ascii BELL char.
  155.  
  156. CAPS            ( -- a1 )
  157.         If true, then convert names to upper case
  158.  
  159. FILL            ( a1 n1 c1 -- )
  160.         FILL the string starting at a1 for count n1 bytes
  161.         with the character c1. Both BLANK and ERASE are
  162.         special cases of FILL.
  163.  
  164. LFILL           ( seg a1 n1 c1 -- )
  165.         FILL for a segment.
  166.  
  167. ERASE           ( a1 n1 -- )
  168.         Fill the string with zeros
  169.  
  170. BLANK           ( a1 n1 -- )
  171.         Fill the string with blanks
  172.  
  173. COUNT           ( a1 -- a2 n1 )
  174.         Given the address on the stack, returns the address
  175.         plus one and the byte at that address.  Useful for strings.
  176.  
  177. LENGTH          ( a1 -- a2 n1 )
  178.         Given the address on the stack, returns the address
  179.         plus two and the two byte contents of the address.
  180.  
  181. COUNTL          ( seg addr -- seg addr+1 len )
  182.         Like COUNT, but works with a LONG (seg/offset) address.
  183.  
  184. MOVE            ( a1 a2 n1 -- )
  185.         Move the specified bytes n1 from address a1 ro address a2. No
  186.         overlapping of data will occur.
  187.  
  188. ATBL            ( -- a1 )
  189.         Address of a table for Upper Case conversion.
  190.  
  191. UPC             ( c1 -- c2 )
  192.         Convert a Char to upper Case
  193.  
  194. UPPER           ( addr cnt -- )
  195.         Take the string at the specified address and convert it to
  196.         upper case.  It converts the string in place, so be sure to
  197.         make a copy of the original if you need to use it later.
  198.  
  199. ?UPPERCASE      ( a1 -- a1 )
  200.         Test the contents of the variable CAPS .  If the contents are
  201.         non-zero, convert the characters in the counted string to
  202.         upper case.
  203.  
  204. HERE            ( -- a1 )
  205.         Return the address of the top of the dictionary
  206.  
  207. PAD             ( -- a1 )
  208.         Floating Temporary Storage area.
  209.  
  210. -TRAILING       ( a1 n1 -- a1 n2 )
  211.         Return the address and length of the given string ignoring
  212.         trailing blanks.
  213.  
  214. COMP            ( a1 a2 n1 -- f1 )
  215.         This performs a string compare.  If the two strings are
  216.         equal, then COMPARE returns 0.  If the two strings differ,
  217.         then COMPARE returns -1 or +1.  -1 is returned if string 1
  218.         is less than string 2.  +1 is returned if string 1 is
  219.         greater than string 2.  All comparisons are relative to
  220.         ASCII order.
  221.  
  222. CAPS-COMP       ( a1 a2 n1 -- f1 )
  223.         The code on this screen handles the case where case is not
  224.         significant.  Each character is converted to upper case
  225.         before the comparison is made.  Thus, lower case a and upper
  226.         case A are considered identical.  The strings are not changed
  227.         in memory.
  228.  
  229. COMPARE         ( a1 a2 n1 -- f1 )
  230.         Performs a string compare. If CAPS is true, characters from
  231.         both strings are converted to upper case before comparing.
  232.         The strings are not changed in memory.
  233.  
  234. ?CS:            ( -- seg )
  235.         leave FORTH code segment CS on stack
  236.  
  237. ?ES:            ( -- seg )
  238.         Return the extra segment ES on the stack.
  239.  
  240. @L              ( seg adr - n )
  241.         load word long from seg and adr.
  242.  
  243. C@L             ( seg adr - byt)
  244.         char load long from seg and adr.
  245.  
  246. C!L             ( byt seg adr -)
  247.         char store long in seg and adr.
  248.  
  249. !L              ( n seg adr -- )
  250.         word store long
  251.  
  252. <BDOS>          ( n1 func# -- areg )
  253.         The default DOS system call.
  254.  
  255. BDOS            ( n1 func# -- areg )
  256.         Load up the registers and do a DOS system call. Return the
  257.         result placed in the A register on the stack.  BDOS is a
  258.         defered word.
  259.  
  260. BDOS2           ( cx dx func# -- cx' dx' ax' )
  261.         Similiar to BDOS, except that an additional register, CX , 
  262.         is used.
  263.  
  264. OS2             ( cx dx func# -- cx' dx' ax' )
  265.         Similiar to BDOS, except that an additional register, CX , 
  266.         is used.  Also, the high order part of ax' is set to 0.
  267.  
  268. BIOSCHAR        ( -- addr )
  269.         Holds the char from BIOS on scan by BIOSKEY?
  270.  
  271. BIOSKEYVAL      ( -- addr )
  272.         Holds the key value from BIOSKEY
  273.  
  274. BIOSKEY?        ( -- f1 )
  275.         Return a true flag if a key, other than control break, 
  276.         has been pressed.
  277.  
  278. BIOSKEY         ( -- c1 )
  279.         Return the value of the next key to be depressed, ignoring
  280.         control break.
  281.  
  282. KEYFILTER       ( n1 -- n2 )
  283.         A defered word to filter the action or code of a key.
  284.  
  285. BGSTUFF         ( -- )
  286.         A defered word for background task operation.
  287.  
  288. (KEY?)          ( -- f1 )
  289.         Returns true if the user pressed a key, otherwise false.
  290.  
  291. (KEY)           ( -- c1 )
  292.         Pauses until a key is ready, and returns it on the stack.
  293.  
  294. OUTPAUSE        ( -- )
  295.         A defered word to perform a background task while sending
  296.         characters to the screen.  Normally NOOP . 
  297.  
  298. CONSOLE         ( char -- )
  299.         A defered word for sending characters to the screen.
  300.  
  301. CMOVEL          ( sseg sptr dseg dptr cnt -- )
  302.         Move cnt bytes long from source seg sseg and sptr, to
  303.         destination seg dseg and dptr.  The sequence goes from 
  304.         low addresses to high addresses.
  305.  
  306. CMOVEL>         ( sseg sptr dseg dptr cnt -- )
  307.         Move cnt bytes from the source segment and offset to the
  308.         destination segment and offset.  The sequence goes from
  309.         high addresses to low addresses.
  310.  
  311. #CODESEGS       ( -- n1 )
  312.         Number of segments needed for CODE.  64k
  313.  
  314. #LISTSEGS       ( -- n1 )  
  315.         Number of segments needed for : definitions. 64k
  316.  
  317. #HEADSEGS       ( -- n1 )
  318.         Number of segments needed for HEADS. 64K
  319.  
  320. MEMCHK          ( f1 -- )
  321.         If the flag is true, print an error message "Insufficient
  322.         Memory", and terminate execution by returning to DOS.
  323.  
  324. DEALLOC         ( seg -- f1 )
  325.         Release a block of memory back to DOS.  Flag = 0 means ok.
  326.         Flag = 9 means segment is not valid.
  327.  
  328. ALLOC           ( size -- seg2 seg flag )
  329.         Allocate "size" segments from DOS.   If no error, flag is
  330.         set to 0.  If not enough segments are available, flag = 8.
  331.         "seg" is the base of the allocated memory.  "seg2" is the
  332.         maximum number of segments available.
  333.  
  334. SETBLOCK        ( seg siz -- f1 )
  335.         Re-adjust the memory block specified by "seg" to the new size "siz"
  336.         in segments.
  337.  
  338. DOSVER          ( -- n1 )
  339.         get DOS version number
  340.  
  341. CURSORSET       ( -- )
  342.         A defered word for setting the cursor?
  343.  
  344. +XSEG           ( n1 -- n2 )
  345.         Add the contents of the variable XSEG to n1, returning n2.
  346.         Used to convert a relative segment address to a physical
  347.         segment address.
  348.  
  349. SETYSEG         ( -- )
  350.         Set the segment variables as needed.
  351.  
  352. YHERE           ( -- addr )
  353.         The next available location in "Head" space.
  354.  
  355. YS:             ( n -- seg n )
  356.         Tuck the base of the head segement under the offset at the
  357.         top of the stack.
  358.  
  359. Y@              ( offset -- n )
  360.         Fetch the word at the specified offset in the head segment.
  361.  
  362. Y!              ( n offset -- )
  363.         Store word n at the offset in the head segment.
  364.  
  365. YC@             ( offset -- c1 )
  366.         Fetch the byte at the offset in the head segment.
  367.  
  368. YC!             ( c1 offset -- )
  369.         Store the byte at the specified offset in the head segment.
  370.  
  371. Y,              ( n -- )
  372.         Add the 16 bit value  n  to the end of the working head space.
  373.  
  374. YCSET           ( b offset -- )
  375.         Set the bits at offset in the head segment according to "b".
  376.  
  377. YHASH           ( ystr vocaddr -- thread )
  378.         Find the vocabulary thread corresponding to a counted string in 
  379.         head space.
  380.  
  381. XHERE           ( -- seg adr )
  382.         Returns segment an offset of next available byte in list space.
  383.  
  384. X,              ( n -- )
  385.         Adds a 16 bit value to the end of list space.
  386.  
  387. XC,             ( n -- )
  388.         Adds an 8 bit value to the end of list space.
  389.  
  390. PR-STATUS       ( n1 -- b1 )
  391.         n1 is the printer number.  Return the printer status byte.
  392.  
  393. <?PTR.READY>    ( -- f1 )
  394.         Return the status of the printer port.  $090 is printer 
  395.         not busy & printer selected.
  396.  
  397. ?PRINTER.READY  ( -- f1 )
  398.         A defered word.  Returns  TRUE  if the printer is ready.
  399.  
  400. CR              ( -- )
  401.         Typically set to CRLF, above. PR-STAT Return printer status,
  402.         if implemented, else TRUE (PRINT) The value of the DEFERRED
  403.         word EMIT when you want to send a character to the printer.
  404.  
  405. PEMIT           ( c1 -- )
  406.         A version of  EMIT  that sends a character to the printer.
  407.  
  408. (EMIT)          ( c1 -- )
  409.         Send a character to the console, and optionally to the printer.
  410.  
  411. CRLF            ( -- )
  412.         Sends a carriage return line feed sequence.
  413.  
  414. FEMIT           ( c1 -- )
  415.         A fast version of EMIT.  Control characters show graphic equivalence.
  416.  
  417. SPACE           ( -- )
  418.         Send a space to the terminal
  419.  
  420. SPCS            ( -- a1 )
  421.         The address of an array of 132 spaces.
  422.  
  423. SPACES          ( n1 -- )
  424.         Send a set of spaces to the terminal
  425.  
  426. BACKSPACES      ( n1 -- )
  427.         Send a set of Backspaces to the terminal.
  428.  
  429. BEEP            ( -- )
  430.         Ring the bell on the terminal
  431.  
  432. BS-IN           ( n c -- 0 | n-1 )
  433.         If at beginning of line, beep, otherwise back up 1.
  434.  
  435. (DEL-IN)        ( n c -- 0 | n-1 )
  436.         If at beginning of line, beep, otherwise back up and erase 1.
  437.  
  438. DEL-IN          ( n c -- 0 | n-1 )
  439.         If at beginning of line, beep, otherwise back up and erase 1.
  440.  
  441. BACK-UP         ( n c -- 0 c )
  442.         Wipe out the current line by overwriting it with spaces.
  443.  
  444. RESET-IN        ( -- )
  445.         Reset the system to a relatively clean state.
  446.  
  447. RES-IN          ( -- )
  448.         Reset the system to a relatively clean state.
  449.  
  450. P-IN            ( -- )
  451.         Toggle the printer on or off
  452.  
  453. (ESC-IN)        ( a n char -- a n+1 char )
  454.         Default handler of ESC character
  455.  
  456. ESC-IN          ( a n char -- a n+1 char )
  457.         A defered word to handle ESC character
  458.  
  459. CR-IN           ( m a n c -- m a m c )
  460.         Finish input and remember the number of chars in SPAN
  461.  
  462. (CHAR)          ( a n char -- a n+1 char )
  463.         Process an ordinary character by appending it to the buffer.
  464.  
  465. CHAR            ( a n char -- a n+1 char )
  466.         is usually (CHAR). Executed for most characters.
  467.         DEL-IN is usually (DEL-IN). Executed for delete characters.
  468.  
  469. ^CHAR           ( a n char -- a n+1 char )
  470.         Similiar to  CHAR  for control characters.
  471.  
  472. NORM-KEYTABLE   ( a n1 char n2 -- a n1+1 char )
  473.         Execute the control character corresponding to n2
  474.  
  475. KEYTABLE        ( a n1 char n2 -- a n1+1 char )
  476.         A defered word to execute the control character corresponding to n2 .
  477.  
  478. NEXPECT         ( adr len start -- )
  479.         Type the first "start" characters from the buffer at "adr" and
  480.         wait for additional characters (in-line editing allowed) to be
  481.         entered by the user.  The "start" characters may also be modified.
  482.         The entry stops when the user types the "Enter" key, or when the
  483.         buffer is filled, whatever happens first.
  484.  
  485. (EXPECT)        ( adr len -- )
  486.         Text entered by the user is entered into the buffer at "adr".
  487.         Entry is terminated by a carraige return or after "len" bytes
  488.         have been entered, whichever occurs first.  A limited amount of
  489.         in-line corrections is allowed.
  490.  
  491. EXPECT          ( a1 n1 -- )
  492.         Get a string from the terminal and place it in the buffer
  493.         provided.  Performs a certain amount of line editing.
  494.         Saves the number of characters input in the Variable SPAN.
  495.         Processes control characters per the array pointed to by CC.
  496.  
  497. TIB             ( -- a1 )
  498.         Leaves address of text input buffer.
  499.  
  500. MORE?           ( -- f1 )
  501.         Return a flag f1 true if there are words left in input stream,
  502.         else return false.
  503.  
  504. QUERY           ( -- )
  505.         Get more input from the user and place it at TIB.
  506.  
  507. DISK-ERROR      ( -- addr )
  508.         Returns the address of a variable which contains error 
  509.         information on the most recent attempt to access the disk.
  510.  
  511. LIMIT           ( -- n )
  512.         The highest address in the Code Segment used by Forth.
  513.  
  514. FIRST           ( -- n )
  515.         This is a simple constant having the value 10 less than  LIMIT .
  516.  
  517. INIT-R0         ( -- addr )
  518.         Address of the base of the Return Stack.
  519.  
  520. HEX             ( -- )
  521.         All subsequent numeric IO will be in Hexadecimal.
  522.  
  523. DECIMAL         ( -- )
  524.         All subsequent numeric IO will be in Decimal.
  525.  
  526. OCTAL           ( -- )
  527.         All subsequent numeric IO will be in Octal.
  528.  
  529.  
  530. DEFAULT         ( -- )
  531.         Opens the default file per the execute line.
  532.         This does nothing if no file was given.
  533.  
  534. DIGIT           ( char base -- n f )
  535.        Returns a flag indicating whether or not the character is a
  536.        valid digit in the given base.  If so, returns converted
  537.        value and true,  otherwise returns char and false.
  538.  
  539. DOUBLE?         ( -- f )
  540.         Returns non-zero if a period was encountered during last numeric 
  541.         scan. 
  542.  
  543. CONVERT         ( +d1 adr1 -- +d2 adr2 )
  544.         Starting with the unsigned double number ud1 and the string
  545.         at adr1, convert the string to a number in the current base.
  546.         Leave result and address of unconvertable digit on stack.
  547.  
  548. (NUMBER?)       ( adr -- d flag )
  549.         Given a string containing at least one digit, convert it
  550.         to a number.
  551.  
  552. NUMBER?         ( adr -- d flag )
  553.         Convert the count delimited string at addr to a double
  554.         number.  NUMBER? takes into account a leading minus sign,
  555.         and stores a pointer to the last delimiter in DPL.
  556.         The string must end with a blank.
  557.         Leaves a true flag if successful.
  558.  
  559. +1=$?           ( a1 -- a1 f1 )        
  560.         If second char in a1 is a "$", return a  TRUE  flag.
  561.  
  562. +1='?           ( a1 -- a1 f1 )        
  563.         If second char in a1 is a "'", return a  TRUE  flag.
  564.  
  565. +1=^?           ( a1 -- a1 f1 )        
  566.         If second char in a1 is a "^", return a  TRUE  flag.
  567.  
  568. %NUMBER         ( a1 -- d1 f1 ) 
  569.         Convert the string at  a1  into a double number.  A leading "-"
  570.         sign is allowed, and special prefixes like  $ , ^ , and ' are
  571.         allowed.
  572.  
  573. (NUMBER)        ( a1 -- d1 )
  574.         Convert the count delimited string at addr to a double
  575.         number.  (NUMBER) takes into account a leading minus sign,
  576.         and stores a pointer to the last period in DPL.  Note the
  577.         string must end with a blank or an error message is issued.
  578.  
  579. NUMBER          ( a1 -- d1 )
  580.         Convert a string to a number.  Normally (NUMBER)
  581.  
  582. HOLD            ( char -- )
  583.         Save the char for numeric output later.
  584.  
  585. <#              ( -- )
  586.         Start numeric conversion.
  587.  
  588. #>              ( d# -- addr len )
  589.         Terminate numeric conversion.
  590.  
  591. SIGN            ( n1 -- )
  592.         If n1 is negative insert a minus sign into the string.
  593.  
  594. #               ( d1 -- d2 )
  595.         Convert a single digit in the current base.
  596.  
  597. #S              ( d -- 0 0 )
  598.         Convert a number until it is finished.
  599.  
  600. (U.)            ( u1 -- a1 n2 )
  601.         Convert an unsigned 16 bit number to a string.
  602.  
  603. U.              ( u1 -- )
  604.         Output as an unsigned single number with trailing space.
  605.  
  606. U.R             ( u1 n2 -- )
  607.         Output as an unsigned single number right justified.
  608.  
  609. (.)             ( n1 -- a1 n2 )
  610.         Convert a signed 16 bit number to a string.
  611.  
  612. .               ( n1 -- )
  613.         Output as a signed single number with a trailing space.
  614.  
  615. .R              ( n1 n2 -- )
  616.         Output as a signed single number right justified.
  617.  
  618. (UD.)           ( d1 -- a1 n1 )
  619.         Convert an unsigned double number to a string.
  620.  
  621. UD.             ( d1 -- )
  622.         Output as an unsigned double number with a trailing space
  623.  
  624. UD.R            ( d1 n1 -- )
  625.         Output as an unsigned double number right justified.
  626.  
  627. (D.)            ( d1 -- a1 n1 )
  628.         Convert a signed double number to a string.
  629.  
  630. D.              ( d1 -- )
  631.         Output as a signed double number with a trailing space.
  632.  
  633. D.R             ( d1 n1 -- )
  634.         Output as a signed double number right justified.
  635.  
  636. SKIP            ( a1 n1 c1 -- a2 n2 )
  637.         Given the address and length of a string, and a character to
  638.         look for, run through the string while we continue to find
  639.         the character.  Leave the address of the mismatch and the
  640.         length of the remaining string.
  641.  
  642. SCAN            ( a1 n1 c1 -- a2 n2 )
  643.         Given the address and length of a string, and a character to
  644.         look for, run through the string until we find
  645.         the character.  Leave the address of the match and the
  646.         length of the remaining string.
  647.  
  648. /STRING         ( addr len n -- addr' len' )
  649.         Index into the string by n.  Returns addr+n and len-n.
  650.  
  651. SOURCE          ( -- a1 n1 )
  652.         Return a string from the current input stream.
  653.  
  654. PARSE           ( a1 -- a2 n1 )
  655.         Scan the input stream until char is encountered.  Update >IN
  656.         pointer. Leaves the address and length of the enclosed
  657.         string.
  658.  
  659. WORD            ( c1 -- a1 )
  660.         Parse the input stream for char and return a count delimited
  661.         string at here.  Note there is always a blank following it.
  662.  
  663.