<!DOCUMENTTYPE forthheaderxml SYSTEM "forth.dtd">
<forthheaderxml>
 <forthheaderlist filename="../../pfe/assembler-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>CODE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CODE ( "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  call <link>ALSO</link> and add ASSEMBLER wordlist if available. Add PROC ENTER
  assembler snippet as needed for the architecture into the PFA. The
  CFA is setup (a) with the PFA adress in traditional ITC or (b)
  with an infoblock as for sbr-coded colon words.
</para><para>
  Remember that not all architectures are support and that the
  ASSEMBLER wordset is not compiled into pfe by default. Use always
  the corresponding <link>END-CODE</link> for each <link>CODE</link> start. The new
  word name is not smudged.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>END-CODE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>END-CODE ( "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  call <link>PREVIOUS</link> and  add PROC LEAVE assembler snippet as needed
  for the architecture -  usually includes bits to "return from
  subroutine". Remember that not all architectures are support and
  PFE usually does only do variants of call-threading with a separate
  loop for the inner interpreter that does "call into subroutine".
  Some forth implementations do "jump into routine" and the PROC
  LEAVE part would do "jump to next routine" also known as 
  next-threading. The sbr-call-threading is usually similar to the
  native subroutine-coding of the host operating system. See <link>CODE</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/block-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>BLOCK</forthname>
    <forthstack>( block-u -- block-addr )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>BLOCK ( block-u -- block-addr ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  load the specified block into a block buffer
  and return the address of that block buffer
  - see also <link>BUFFER</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BUFFER</forthname>
    <forthstack>( block-u -- block-addr )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>BUFFER ( block-u -- block-addr ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  get the block buffer address for the specified 
  block - if it had not been loaded already it
  is <b>not</b> filled with data from the disk
  unlike <link>BLOCK</link> does.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SAVE-BUFFERS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SAVE-BUFFERS ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  write all modified buffer to
  the disk, see <link>UPDATE</link> and
  <link>FLUSH</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EMPTY-BUFFERS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>EMPTY-BUFFERS ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  unassign all block buffers, does not even <link>UPDATE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FLUSH</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FLUSH ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  call <link>SAVE-BUFFERS</link> and then unassign all
  block buffers with <link>EMPTY-BUFFERS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LIST</forthname>
    <forthstack>( block-u -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>LIST ( block-u -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  display the block
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOAD</forthname>
    <forthstack>( block-u -- ?? )</forthstack>
    <forthhints> [FORTH]</forthhints>
    <stackline>LOAD ( block-u -- ?? ) [FORTH]</stackline>
   </forthdefinition>
   <comment><para>  <link>INTERPRET</link> the specified <link>BLOCK</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>THRU</forthname>
    <forthstack>( block1-u block2-u -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>THRU ( block1-u block2-u -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  <link>LOAD</link> a number of block in sequence.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UPDATE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>UPDATE ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  mark the current block buffer as modified,
  see <link>FLUSH</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BLK</forthname>
    <forthstack>( -- block-u* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>BLK ( -- block-u* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  the direct use of <link>BLK</link> and <link>SCR</link> is depracated
  (very traditional variables for I/O system)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SCR</forthname>
    <forthstack>( -- scr-n* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SCR ( -- scr-n* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  the direct use of <link>BLK</link> and <link>SCR</link> is depracated
  (very traditional variables for I/O system)
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/block-mix.c">
  <forthheader>
   <forthdefinition>
    <forthname>CLOSE-BLOCKFILE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH] w32for</forthhints>
    <stackline>CLOSE-BLOCKFILE ( -- ) [FTH] w32for</stackline>
   </forthdefinition>
   <comment><para>  w32for-implementation:
</para><screen>  blockhandle -1 &lt;&gt; if flush close-file drop then
  -1 set-blockfile
</screen><para>  in pfe:
</para><screen>  : CLOSE-BLOCKFILE 
    BLOCK-FILE ?DUP IF FLUSH CLOSE-FILE DROP THEN 
    OFF&gt; BLOCK-FILE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OPEN-BLOCKFILE</forthname>
    <forthstack>( "filename" -- )</forthstack>
    <forthhints> [FTH] w32for</forthhints>
    <stackline>OPEN-BLOCKFILE ( "filename" -- ) [FTH] w32for</stackline>
   </forthdefinition>
   <comment><para>  w32for-implementation:
</para><screen>    close-blockfile
    parse-word r/w open-file abort" failed to open block-file"
    set-blockfile
    empty-buffers 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CREATE-BLOCKFILE</forthname>
    <forthstack>( blocks-count "filename" -- )</forthstack>
    <forthhints> [FTH] w32for</forthhints>
    <stackline>CREATE-BLOCKFILE ( blocks-count "filename" -- ) [FTH] w32for</stackline>
   </forthdefinition>
   <comment><para>  w32for-implementation:
</para><screen>    close-blockfile
    parse-word r/w create-file abort" failed to create block-file"
    set-blockfile
    dup b/buf m* blockhandle resize-file
    abort" unable to create a file of that size"
    empty-buffers
    0 do i wipe loop 
    flush
</screen><para>  pfe does not wipe the buffers
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>USING</forthname>
    <forthstack>( "filename" -- )</forthstack>
    <forthhints> [EXT] [obsolete]</forthhints>
    <stackline>USING ( "filename" -- ) [EXT] [obsolete]</stackline>
   </forthdefinition>
   <comment><para>  use filename as a block file 
  OBSOLETE word, use <link>OPEN-BLOCKFILE</link>
</para><screen>  : USING OPEN-BLOCKFILE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>USING-NEW</forthname>
    <forthstack>( "filename" -- )</forthstack>
    <forthhints> [EXT] [obsolete]</forthhints>
    <stackline>USING-NEW ( "filename" -- ) [EXT] [obsolete]</stackline>
   </forthdefinition>
   <comment><para>  like <link>USING</link> but can create the file
  OBSOLETE word, use <link>CREATE-BLOCKFILE</link>
</para><screen>  : USING-NEW 0 CREATE-BLOCKFILE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SET-BLOCKFILE</forthname>
    <forthstack>( block-file* -- )</forthstack>
    <forthhints> [EXT] win32for</forthhints>
    <stackline>SET-BLOCKFILE ( block-file* -- ) [EXT] win32for</stackline>
   </forthdefinition>
   <comment><para>  win32forth uses a system-filedescriptor where -1 means unused
  in the BLOCKHANDLE, but we use a "FILE*"-like structure, so NULL
  means NOT-IN-USE. Here we set it.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BLOCK-FILE</forthname>
    <forthstack>( -- block-file* )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>BLOCK-FILE ( -- block-file* ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  return blockhandle as last set by <link>SET-BLOCKFILE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>B/BUF</forthname>
    <forthstack>( -- bytesperbuffer-count )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>B/BUF ( -- bytesperbuffer-count ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/cdecl-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>#ELSE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#ELSE ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  The implementation of #ELSE is done in C for speed and
  being less error prone. Better use the ANSI-compatible
  <link>[IF]</link> <link>[ELSE]</link> <link>[THEN]</link> construct.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#ENDIF</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#ENDIF ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  end of <link>#IF</link> <link>#IFDEF</link> <link>#IFNOTDEF</link> and <link>#ELSE</link> contructs
</para><screen>    (a dummy word that does actually nothing, but #ELSE may look for it)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#IF</forthname>
    <forthstack>( -- C: state-save-flag mfth-if-magic S: )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#IF ( -- C: state-save-flag mfth-if-magic S: ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  prepares for a following <link>#IS_TRUE</link> or <link>#IS_FALSE</link>,
  does basically switch off compile-mode for the enclosed
  code. <br>
  better use the ANSI style <link>[IF]</link> <link>[ELSE]</link> <link>[THEN]</link> construct.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#IS_TRUE</forthname>
    <forthstack>( C: state-save-flag mfth-if-magic S: test-flag -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#IS_TRUE ( C: state-save-flag mfth-if-magic S: test-flag -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  checks the condition on the <code>CS-STACK</code>. <br>
  Pairs with <link>#IF</link> <br>
  better use the ANSI style <link>[IF]</link> <link>[ELSE]</link> <link>[THEN]</link> construct.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#IS_FALSE</forthname>
    <forthstack>( C: state-save-flag mfth-if-magic S: test-flag -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#IS_FALSE ( C: state-save-flag mfth-if-magic S: test-flag -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  checks the condition on the <code>CS-STACK</code>. <br>
  Pairs with <link>#IF</link> <br>
  better use the ANSI style <link>[IF]</link> <link>[ELSE]</link> <link>[THEN]</link> construct.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#IFDEF</forthname>
    <forthstack>( "word" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#IFDEF ( "word" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  better use <code>[DEFINED] word [IF]</code> - the word <link>[IF]</link>
  is ANSI-conform.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#IFNOTDEF</forthname>
    <forthstack>( "word" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#IFNOTDEF ( "word" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  better use <code>[DEFINED] word [NOT] [IF]</code> - the word <link>[IF]</link>
  and <link>[ELSE]</link> are ANSI-conform, while <link>#IFDEF</link> <link>#ELSE</link> are not.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>//</forthname>
    <forthstack>( [...&lt;cr&gt;] -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>// ( [...&lt;cr&gt;] -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  a line-comment
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#define</forthname>
    <forthstack>( "name" "value" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#define ( "name" "value" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  create an alias, will actually make a <link>DEFER</link>ed word,
  and it has the magic to handle number-arguments
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#pragma</forthname>
    <forthstack>( "word" "evaluate&lt;cr&gt;" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>#pragma ( "word" "evaluate&lt;cr&gt;" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  pass the word to <link>ENVIRONMENT</link>?
  If the word does *not* exist, the rest of the line is parsed
  away with <link>//</link> - therefore, if the executed word does not
  consume the line itself, the rest of the line is still executed.
  examples:
</para><screen>  #pragma warnings on // if warnings is a variable, ON can set it
  #pragma stack-cells 50 &lt; [if] .( not enough stackcells ) [then]
  #pragma simply anything else you like to have in environment or not
 
</screen><para>  implementation:
</para><screen>  : #pragma ?exec
    bl word count environment? if exit then ( interpret the rest of the line )
    [compile] \               ( parse away the rest of the line as a comment )
  ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/chain-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>link,</forthname>
    <forthstack>( some-list* -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>link, ( some-list* -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><screen> 
  : link,        here over @ a, swap ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>chain-link</forthname>
    <forthstack>( -- chain-link* )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>chain-link ( -- chain-link* ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  a system variable used at <link>new-chain</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>new-chain</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints> [EXT] [DOES: -- new-chain* ]</forthhints>
    <stackline>new-chain ( "name" -- ) [EXT] [DOES: -- new-chain* ]</stackline>
   </forthdefinition>
   <comment><para>   create a new chain and register in chain-link
</para><screen>  : new-chain create: 0 , ['] noop , chain-link link, ;
</screen><para>  layout of a chain:
  /cell field ->chain.link
  /cell field ->chain.exec
  /cell field ->chain.next
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.chain</forthname>
    <forthstack>( some-chain* -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>.chain ( some-chain* -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  show chain - compare with <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.chains</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>.chains ( -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  show all chains registered in the system - compare with <link>VLIST</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>do-chain</forthname>
    <forthstack>( some-chain* -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>do-chain ( some-chain* -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  execute chain
</para><screen>  : do-chain being @ ?dup while dup&gt;r cell+ @execute r&gt; repeat ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>chain-add-before</forthname>
    <forthstack>( some-chain* "word-to-add" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>chain-add-before ( some-chain* "word-to-add" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  add chain item, for reverse chain like BYE
</para><screen>  : chain-add-before ' &gt;r here over @ , r&gt; , swap ! ;
  ( chain-add-before link, ' , )
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>chain-add</forthname>
    <forthstack>( some-chain* "word-to-add" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>chain-add ( some-chain* "word-to-add" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  add chain item, for normal setup, at end of do-chain
</para><screen>  : chain-add ' &gt;r begin dup @ while @ repeat here swap ! 0 , r&gt; , ;
  ( chain-add begin dup @ while @ repeat  here swap ! 0, ' , )
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>semicolon-chain</forthname>
    <forthstack>( -- semicolon-chain* )</forthstack>
    <forthhints> [EXT] [OLD]</forthhints>
    <stackline>semicolon-chain ( -- semicolon-chain* ) [EXT] [OLD]</stackline>
   </forthdefinition>
   <comment><para>  do not use.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/chainlist-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>NEW-WORDLIST</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints> [EXT] [DOES: -- new-wordlist* ]</forthhints>
    <stackline>NEW-WORDLIST ( "name" -- ) [EXT] [DOES: -- new-wordlist* ]</stackline>
   </forthdefinition>
   <comment><para>
  create a new <link>WORDLIST</link> and a "name" with a runtime of ( -- wordlist* )
</para><para>
</para><screen>  : NEW-WORDLIST WORDLIST VALUE ;
  : NEW-WORDLIST CREATE: WORDLIST ;
</screen><para>                          usually used for <link>DO-ALL-WORDS</link> / <link>DO-SYNONYM</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.WORDS</forthname>
    <forthstack>( some-wordlist* -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>.WORDS ( some-wordlist* -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  print the <link>WORDLIST</link> interactivly to the user
</para><para>
</para><screen>  : .WORDS ALSO SET-CONTEXT WORDS PREVIOUS ;
</screen><para>
  <link>WORDS</link> / <link>ORDER</link> / <link>NEW-WORDLIST</link> / <link>DO-ALL-WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DO-ALL-WORDS</forthname>
    <forthstack>( some-wordlist* -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>DO-ALL-WORDS ( some-wordlist* -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  <link>EXECUTE</link> each entry in the wordlist in the reverse order defined
</para><para>
</para><screen>  : DO-ALL-WORDS
       0 FIRST-NAME
       BEGIN ?DUP WHILE 
          DUP NAME&gt; EXECUTE
          NAME-NEXT
       REPEAT
  ;
</screen><para>  to run the <link>NEW-WORDLIST</link> in original order, use <link>REDO-ALL-WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REDO-ALL-WORDS</forthname>
    <forthstack>( some-wordlist* -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>REDO-ALL-WORDS ( some-wordlist* -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  <link>EXECUTE</link> each entry in the wordlist in the original order defined
</para><para>
</para><screen>  : REDO-ALL-WORDS
       0 FIRST-NAME
       0 SWAP ( under )
       BEGIN ?DUP WHILE 
          DUP NAME&gt; SWAP ( under )
          NAME-NEXT
       REPEAT
       BEGIN ?DUP WHILE
          EXECUTE
       REPEAT
  ;
</screen><para>  to run the <link>NEW-WORDLIST</link> in last-run-first order, use <link>DO-ALL-WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DO-ALL-WORDS-WHILE-LOOP</forthname>
    <forthstack>( some-wordlist* test-xt* -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>DO-ALL-WORDS-WHILE-LOOP ( some-wordlist* test-xt* -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  <link>EXECUTE</link> each entry in the wordlist in the reverse order defined
     but only as long as after EXECUTE of "word" a TRUE flag is left
     on the stack. The wordlist execution is cut when a FALSE flag is seen.
     (the current wordlist entry is _not_ on the stack!)
</para><para>
</para><screen>  : DO-ALL-WORDS-WHILE-LOOP &gt;R
       0 FIRST-NAME
       BEGIN ?DUP WHILE 
          R@ EXECUTE 0= IF R&gt;DROP DROP EXIT THEN
          DUP NAME&gt; EXECUTE
          NAME-NEXT
       REPEAT R&gt;DROP
  ;
</screen><para>  compare with <link>DO-ALL-WORDS-WHILE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DO-ALL-WORDS-WHILE</forthname>
    <forthstack>( some-wordlist* "word" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>DO-ALL-WORDS-WHILE ( some-wordlist* "word" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  <link>EXECUTE</link> each entry in the wordlist in the reverse order defined
     but only as long as after EXECUTE of "word" a TRUE flag is left
     on the stack. The wordlist execution is cut when a FALSE flag is seen.
     (the current wordlist entry is _not_ on the stack!)
</para><para>
</para><screen>  : DO-ALL-WORDS-WHILE ' 
       STATE @ IF LITERAL, COMPILE DO-ALL-WORDS-WHILE-LOOP EXIT THEN
       &gt;R 0 FIRST-NAME
       BEGIN ?DUP WHILE 
          R@ EXECUTE 0= IF R&gt;DROP DROP EXIT THEN
          DUP NAME&gt; EXECUTE
          NAME-NEXT
       REPEAT R&gt;DROP
  ;
</screen><para>  to run the <link>NEW-WORDLIST</link> in original order, use <link>REDO-ALL-WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DO-SYNONYM</forthname>
    <forthstack>( some-wordlist* "do-name" "orig-name" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>DO-SYNONYM ( some-wordlist* "do-name" "orig-name" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  create a <link>SYNONYM</link> in the specified wordlist.
</para><para>
</para><screen>  : DO-SYNONYM GET-CURRENT SWAP SET-CURRENT SYNONYM SET-CURRENT ;
</screen><para>
  <link>DO-ALIAS</link> / <link>DO-ALL-WORDS</link> / <link>NEW-WORDLIST</link> / <link>WORDLIST</link> / <link>ORDER</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ALIAS-ATEXIT</forthname>
    <forthstack>( some-xt* "name" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>ALIAS-ATEXIT ( some-xt* "name" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  create a defer word that is initialized with the given x-token.
</para><para>
</para><screen>  : ALIAS-ATEXIT ATEXIT-WORDLIST DO-ALIAS ;
</screen><para>                                         <link>ATEXIT-WORDLIST</link> <link>DO-ALL-WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DO-ALIAS</forthname>
    <forthstack>( some-xt* definition-wordlist* "do-name" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>DO-ALIAS ( some-xt* definition-wordlist* "do-name" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  create an <link>ALIAS</link> with the exec-token in the specified wordlist
</para><para>
</para><screen>  : DO-ALIAS GET-CURRENT SWAP SET-CURRENT SWAP ALIAS SET-CURRENT ;
</screen><para>                                                            <link>DO-SYNONYM</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ATEXIT-WORDLIST</forthname>
    <forthstack>( -- atexit-do-wordlist* )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>ATEXIT-WORDLIST ( -- atexit-do-wordlist* ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  <link>BYE</link> will run this wordlist, last added being run first
</para><screen>  : BYE ... ATEXIT-WORDLIST DO-ALL-WORDS ... ;
  : FORGET ... ATEXIT-WORDLIST DO-ALL-WORDS-WHILE BIGGER-THAN-HERE ... ;
  WORDLIST VALUE ATEXIT-WORDLIST
</screen><para>                                         <link>DO-ALL-WORDS</link> / <link>LOADED</link>
  note: parts of these will be run by 
  <link>FORGET</link> when the HERE mark becomes
  lower than the definition you had
  added after that to this chainlist.
  (that is to run destroyer aliases).    <link>ALIAS-ATEXIT</link> / <link>FORGET</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PROMPT-WORDLIST</forthname>
    <forthstack>( -- prompt-do-wordlist* )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>PROMPT-WORDLIST ( -- prompt-do-wordlist* ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  <link>QUIT</link> inits will run this wordlist, last added being run first
</para><screen>  : QUIT ... PROMPT-WORDLIST DO-ALL-WORDS ... ;
  WORDLIST VALUE PROMPT-WORDLIST
</screen><para>                                         <link>DO-ALL-WORDS</link> / <link>ABORT-WORDLIST</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ABORT-WORDLIST</forthname>
    <forthstack>( -- abort-redo-wordlist* )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>ABORT-WORDLIST ( -- abort-redo-wordlist* ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>
  <link>ABORT</link> inits will run this wordlist, first added being run first
</para><screen>  : ABORT ... ABORT-WORDLIST REDO-ALL-WORDS ... ;
  WORDLIST VALUE ABORT-WORDLIST
</screen><para>                                        <link>REDO-ALL-WORDS</link> / <link>PROMPT-WORDLIST</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/complex-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>Z@</forthname>
    <forthstack>( addr --  f: z )</forthstack>
    <forthhints></forthhints>
    <stackline>Z@  ( addr --  f: z )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z!</forthname>
    <forthstack>( addr f: z -- )</forthstack>
    <forthhints></forthhints>
    <stackline>Z!  ( addr f: z -- )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>X@</forthname>
    <forthstack>( zaddr --  f: x )</forthstack>
    <forthhints></forthhints>
    <stackline>X@  ( zaddr --  f: x )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>X!</forthname>
    <forthstack>( zaddr f: x -- )</forthstack>
    <forthhints></forthhints>
    <stackline>X!  ( zaddr f: x -- )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Y@</forthname>
    <forthstack>( zaddr --  f: y )</forthstack>
    <forthhints></forthhints>
    <stackline>Y@  ( zaddr --  f: y )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Y!</forthname>
    <forthstack>( zaddr f: x -- )</forthstack>
    <forthhints></forthhints>
    <stackline>Y!  ( zaddr f: x -- )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z.</forthname>
    <forthstack>(f: z -- )</forthstack>
    <forthhints></forthhints>
    <stackline>Z.  (f: z -- )</stackline>
   </forthdefinition>
   <comment><para>  Emit the complex number, including the sign of zero when
  <link>signbit()</link> is available.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZS.</forthname>
    <forthstack>(f: z -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ZS.  (f: z -- )</stackline>
   </forthdefinition>
   <comment><para>  Emit the complex number in scientific notation, including the
  sign of zero when <link>signbit()</link> is available.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REAL</forthname>
    <forthstack>(f: x y -- x )</forthstack>
    <forthhints></forthhints>
    <stackline>REAL  (f: x y -- x )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IMAG</forthname>
    <forthstack>(f: x y -- y )</forthstack>
    <forthhints></forthhints>
    <stackline>IMAG  (f: x y -- y )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CONJG</forthname>
    <forthstack>(f: x y -- x -y )</forthstack>
    <forthhints></forthhints>
    <stackline>CONJG  (f: x y -- x -y )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZDROP</forthname>
    <forthstack>(f: z -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ZDROP  (f: z -- )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZDUP</forthname>
    <forthstack>(f: z -- z z )</forthstack>
    <forthhints></forthhints>
    <stackline>ZDUP  (f: z -- z z )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZSWAP</forthname>
    <forthstack>(f: z1 z2 -- z2 z1 )</forthstack>
    <forthhints></forthhints>
    <stackline>ZSWAP  (f: z1 z2 -- z2 z1 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZOVER</forthname>
    <forthstack>(f: z1 z2 -- z1 z2 z1 )</forthstack>
    <forthhints></forthhints>
    <stackline>ZOVER  (f: z1 z2 -- z1 z2 z1 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZNIP</forthname>
    <forthstack>(f: z1 z2 -- z2 )</forthstack>
    <forthhints></forthhints>
    <stackline>ZNIP  (f: z1 z2 -- z2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZTUCK</forthname>
    <forthstack>(f: z1 z2 -- z2 z1 z2 )</forthstack>
    <forthhints></forthhints>
    <stackline>ZTUCK  (f: z1 z2 -- z2 z1 z2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZROT</forthname>
    <forthstack>(f: z1 z2 z3 -- z2 z3 z1 )</forthstack>
    <forthhints></forthhints>
    <stackline>ZROT  (f: z1 z2 z3 -- z2 z3 z1 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-ZROT</forthname>
    <forthstack>(f: z1 z2 z3 -- z3 z1 z2 )</forthstack>
    <forthhints></forthhints>
    <stackline>-ZROT  (f: z1 z2 z3 -- z3 z1 z2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z+</forthname>
    <forthstack>(f: z1 z2 -- z1+z2 )</forthstack>
    <forthhints></forthhints>
    <stackline>Z+  (f: z1 z2 -- z1+z2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z-</forthname>
    <forthstack>(f: z1 z2 -- z1-z2 )</forthstack>
    <forthhints></forthhints>
    <stackline>Z-  (f: z1 z2 -- z1-z2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z*</forthname>
    <forthstack>(f: x y u v -- x*u-y*v  x*v+y*u )</forthstack>
    <forthhints></forthhints>
    <stackline>Z*  (f: x y u v -- x*u-y*v  x*v+y*u )</stackline>
   </forthdefinition>
   <comment><para>  Uses the algorithm followed by JVN:
      (x+iy)*(u+iv) = [(x+y)*u - y*(u+v)] + i[(x+y)*u + x*(v-u)]
  Requires 3 multiplications and 5 additions.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z/</forthname>
    <forthstack>(f: u+iv z -- u/z+iv/z )</forthstack>
    <forthhints></forthhints>
    <stackline>Z/  (f: u+iv z -- u/z+iv/z )</stackline>
   </forthdefinition>
   <comment><para>  Kahan-like algorithm *without* due attention to spurious
  over/underflows and zeros and infinities.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZNEGATE</forthname>
    <forthstack>(f: z -- -z )</forthstack>
    <forthhints></forthhints>
    <stackline>ZNEGATE  (f: z -- -z )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z2*</forthname>
    <forthstack>(f: z -- z*2 )</forthstack>
    <forthhints></forthhints>
    <stackline>Z2*  (f: z -- z*2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z2/</forthname>
    <forthstack>(f: z -- z/2 )</forthstack>
    <forthhints></forthhints>
    <stackline>Z2/  (f: z -- z/2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>I*</forthname>
    <forthstack>(f: x y -- -y x )</forthstack>
    <forthhints></forthhints>
    <stackline>I*  (f: x y -- -y x )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-I*</forthname>
    <forthstack>(f: x y -- y -x )</forthstack>
    <forthhints></forthhints>
    <stackline>-I*  (f: x y -- y -x )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>1/Z</forthname>
    <forthstack>(f: z -- 1/z )</forthstack>
    <forthhints></forthhints>
    <stackline>1/Z  (f: z -- 1/z )</stackline>
   </forthdefinition>
   <comment><para>  Kahan algorithm *without* due attention to spurious
  over/underflows and zeros and infinities.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z^2</forthname>
    <forthstack>(f: z -- z^2 )</forthstack>
    <forthhints></forthhints>
    <stackline>Z^2  (f: z -- z^2 )</stackline>
   </forthdefinition>
   <comment><para>  Kahan algorithm without removal of any spurious NaN created
  by overflow.  It deliberately uses (x-y)(x+y) instead of
  x^2-y^2 for the real part.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>|Z|^2</forthname>
    <forthstack>(f: x y -- |z|^2 )</forthstack>
    <forthhints></forthhints>
    <stackline>|Z|^2  (f: x y -- |z|^2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z^N</forthname>
    <forthstack>( n f: z -- z^n )</forthstack>
    <forthhints></forthhints>
    <stackline>Z^N  ( n f: z -- z^n )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>X+</forthname>
    <forthstack>(f: z a -- x+a y )</forthstack>
    <forthhints></forthhints>
    <stackline>X+  (f: z a -- x+a y )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>X-</forthname>
    <forthstack>(f: z a -- x-a y )</forthstack>
    <forthhints></forthhints>
    <stackline>X-  (f: z a -- x-a y )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Y+</forthname>
    <forthstack>(f: z a -- x y+a )</forthstack>
    <forthhints></forthhints>
    <stackline>Y+  (f: z a -- x y+a )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Y-</forthname>
    <forthstack>(f: z a -- x y-a )</forthstack>
    <forthhints></forthhints>
    <stackline>Y-  (f: z a -- x y-a )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z*F</forthname>
    <forthstack>(f: x y f -- x*f y*f )</forthstack>
    <forthhints></forthhints>
    <stackline>Z*F  (f: x y f -- x*f y*f )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z/F</forthname>
    <forthstack>(f: x y f -- x/f y/f )</forthstack>
    <forthhints></forthhints>
    <stackline>Z/F  (f: x y f -- x/f y/f )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F*Z</forthname>
    <forthstack>(f: f x y -- f*x f*y )</forthstack>
    <forthhints></forthhints>
    <stackline>F*Z  (f: f x y -- f*x f*y )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F/Z</forthname>
    <forthstack>(f: f z -- f/z )</forthstack>
    <forthhints></forthhints>
    <stackline>F/Z  (f: f z -- f/z )</stackline>
   </forthdefinition>
   <comment><para>  Kahan algorithm *without* due attention to spurious
  over/underflows and zeros and infinities.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z*I*F</forthname>
    <forthstack>(f: z f --  z*if )</forthstack>
    <forthhints></forthhints>
    <stackline>Z*I*F  (f: z f --  z*if )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-I*Z/F</forthname>
    <forthstack>(f: z f --  z/[if] )</forthstack>
    <forthhints></forthhints>
    <stackline>-I*Z/F  (f: z f --  z/[if] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>I*F*Z</forthname>
    <forthstack>(f: f z -- if*z )</forthstack>
    <forthhints></forthhints>
    <stackline>I*F*Z  (f: f z -- if*z )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>I*F/Z</forthname>
    <forthstack>(f: f z -- [0+if]/z )</forthstack>
    <forthhints></forthhints>
    <stackline>I*F/Z  (f: f z -- [0+if]/z )</stackline>
   </forthdefinition>
   <comment><para>  Kahan algorithm *without* due attention to spurious
  over/underflows and zeros and infinities.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z*&gt;REAL</forthname>
    <forthstack>(f: z1 z2 -- Re[z1*z2] )</forthstack>
    <forthhints></forthhints>
    <stackline>Z*&gt;REAL  (f: z1 z2 -- Re[z1*z2] )</stackline>
   </forthdefinition>
   <comment><para>  Compute the real part of the complex product without
  computing the imaginary part.  Recommended by Kahan to avoid
  gratuitous overflow or underflow signals from the unnecessary
  part.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z*&gt;IMAG</forthname>
    <forthstack>(f: z1 z2 -- Im[z1*z2] )</forthstack>
    <forthhints></forthhints>
    <stackline>Z*&gt;IMAG  (f: z1 z2 -- Im[z1*z2] )</stackline>
   </forthdefinition>
   <comment><para>  Compute the imaginary part of the complex product without
  computing the real part.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>|Z|</forthname>
    <forthstack>(f: x y -- |z| )</forthstack>
    <forthhints></forthhints>
    <stackline>|Z|  (f: x y -- |z| )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZBOX</forthname>
    <forthstack>(f: z -- box[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZBOX  (f: z -- box[z] )</stackline>
   </forthdefinition>
   <comment><para>  Defined *only* for zero and infinite arguments. This difffers
  from Kahan's <link>CBOX</link> [p. 198] by conserving signs when only
  one of x or y is infinite, consistent with the other cases, and
  with its use in his <link>ARG</link> [p. 199].
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ARG</forthname>
    <forthstack>(f: z -- principal.arg[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ARG  (f: z -- principal.arg[z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;POLAR</forthname>
    <forthstack>(f: x y -- r theta )</forthstack>
    <forthhints></forthhints>
    <stackline>&gt;POLAR  (f: x y -- r theta )</stackline>
   </forthdefinition>
   <comment><para>  Convert the complex number z to its polar representation,
  where theta is the principal argument.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>POLAR&gt;</forthname>
    <forthstack>(f: r theta -- x y )</forthstack>
    <forthhints></forthhints>
    <stackline>POLAR&gt;  (f: r theta -- x y )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZSSQS</forthname>
    <forthstack>(f: z -- rho s: k )</forthstack>
    <forthhints></forthhints>
    <stackline>ZSSQS  (f: z -- rho s: k )</stackline>
   </forthdefinition>
   <comment><para>  Compute rho = |(x+iy)/2^k|^2, scaled to avoid overflow or
  underflow, and leave the scaling integer k.  Kahan, p. 200.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZSQRT</forthname>
    <forthstack>(f: z -- sqrt[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZSQRT  (f: z -- sqrt[z] )</stackline>
   </forthdefinition>
   <comment><para>  Compute the principal branch of the square root, with
  Re sqrt[z] >= 0.  Kahan, p. 201.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZLN</forthname>
    <forthstack>(f: z -- ln|z|+i*theta )</forthstack>
    <forthhints></forthhints>
    <stackline>ZLN  (f: z -- ln|z|+i*theta )</stackline>
   </forthdefinition>
   <comment><para>  Compute the principal branch of the complex natural
  logarithm. The angle theta is the principal argument.  This
  code uses Kahan's algorithm for the scaled logarithm
  <link>CLOGS(z,J)</link> = ln(z*2^J), with J=0 and blind choices of the
  threshholds T0, T1, and T2.  Namely, T0 = 1/sqrt(2), T1 =
  5/4, and T2 = 3;
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZEXP</forthname>
    <forthstack>(f: z -- exp[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZEXP  (f: z -- exp[z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z^</forthname>
    <forthstack>(f: x y u v -- [x+iy]^[u+iv] )</forthstack>
    <forthhints></forthhints>
    <stackline>Z^  (f: x y u v -- [x+iy]^[u+iv] )</stackline>
   </forthdefinition>
   <comment><para>  Compute in terms of the principal argument of x+iy.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZCOSH</forthname>
    <forthstack>(f: z -- cosh[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZCOSH  (f: z -- cosh[z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZSINH</forthname>
    <forthstack>(f: z -- sinh[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZSINH  (f: z -- sinh[z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZTANH</forthname>
    <forthstack>(f: z -- tanh[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZTANH  (f: z -- tanh[z] )</stackline>
   </forthdefinition>
   <comment><para>  Kahan, p. 204, including his divide by zero signal
  suppression for infinite values of <link>tan()</link>.  To quote the very
  informative "=>'man math'" on our Darwin system about IEEE 754:
  "Divide-by-Zero is signaled only when a function takes
  exactly infinite values at finite operands."
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZCOTH</forthname>
    <forthstack>(f: z -- 1/tanh[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZCOTH  (f: z -- 1/tanh[z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZCOS</forthname>
    <forthstack>(f: z -- cosh[i*z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZCOS  (f: z -- cosh[i*z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZSIN</forthname>
    <forthstack>(f: z -- -i*sinh[i*z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZSIN  (f: z -- -i*sinh[i*z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZTAN</forthname>
    <forthstack>(f: z -- -i*tanh[i*z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZTAN  (f: z -- -i*tanh[i*z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZCOT</forthname>
    <forthstack>(f: z -- -i*coth[-i*z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZCOT  (f: z -- -i*coth[-i*z] )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZACOS</forthname>
    <forthstack>(f: z -- u+iv=acos[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZACOS  (f: z -- u+iv=acos[z] )</stackline>
   </forthdefinition>
   <comment><para>  Kahan, p.202.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZACOSH</forthname>
    <forthstack>(f: z -- u+iv=acosh[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZACOSH  (f: z -- u+iv=acosh[z] )</stackline>
   </forthdefinition>
   <comment><para>  Kahan, p.203.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZASIN</forthname>
    <forthstack>(f: z -- u+iv=asin[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZASIN  (f: z -- u+iv=asin[z] )</stackline>
   </forthdefinition>
   <comment><para>  Kahan, p.203.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZASINH</forthname>
    <forthstack>(f: z -- -i*asin[i*z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZASINH  (f: z -- -i*asin[i*z] )</stackline>
   </forthdefinition>
   <comment><para>  Kahan, p. 203, couth.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZATANH</forthname>
    <forthstack>(f: z -- u+iv=atanh[z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZATANH  (f: z -- u+iv=atanh[z] )</stackline>
   </forthdefinition>
   <comment><para>  Kahan, p. 203.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZATAN</forthname>
    <forthstack>(f: z -- -i*atanh[i*z] )</forthstack>
    <forthhints></forthhints>
    <stackline>ZATAN  (f: z -- -i*atanh[i*z] )</stackline>
   </forthdefinition>
   <comment><para>  Kahan, p. 204, couth.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZCONSTANT</forthname>
    <forthstack>( "name" f: z -- )</forthstack>
    <forthhints>  "name" execution: (f: -- z )</forthhints>
    <stackline>ZCONSTANT ( "name" f: z -- )  "name" execution: (f: -- z )</stackline>
   </forthdefinition>
   <comment><para>  Define a word that leaves x+iy on the fp stack upon execution.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>ZLITERAL    Compilation: (f: z -- )  Run: (f: -- z )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZVARIABLE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints>  "name" exection: ( -- zaddr )</forthhints>
    <stackline>ZVARIABLE  ( "name" -- )  "name" exection: ( -- zaddr )</stackline>
   </forthdefinition>
   <comment><para>  Allocate aligned memory for an fp complex number, with the
  real part first in memory, and define a word that leaves
  the address on the data stack.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/core-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>!</forthname>
    <forthstack>( value some-cell* -- | value addr* -- [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>! ( value some-cell* -- | value addr* -- [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  store value at addr (sizeof <link>CELL</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#</forthname>
    <forthstack>( n,n -- n,n' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline># ( n,n -- n,n' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  see also <link>HOLD</link> for old-style forth-formatting words
  and <link>PRINTF</link> of the C-style formatting - this word
  divides the argument by <link>BASE</link> and add it to the
  picture space - it should be used inside of <link><#</link>
  and <link>#></link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#&gt;</forthname>
    <forthstack>( n,n -- hold-str-ptr hold-str-len )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>#&gt; ( n,n -- hold-str-ptr hold-str-len ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  see also <link>HOLD</link> for old-style forth-formatting words
  and <link>PRINTF</link> of the C-style formatting - this word
  drops the argument and returns the picture space
  buffer
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#S</forthname>
    <forthstack>( n,n -- 0,0 )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>#S ( n,n -- 0,0 ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  see also <link>HOLD</link> for old-style forth-formatting words
  and <link>PRINTF</link> of the C-style formatting - this word
  does repeat the word <link>#</link> for a number of times, until
  the argument becomes zero. Hence the result is always
  null - it should be used inside of <link><#</link> and <link>#></link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CFA'</forthname>
    <forthstack>( 'name' -- name-xt* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>"CFA'" ( 'name' -- name-xt* ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  return the execution token of the following name. This word
  is _not_ immediate and may not do what you expect in
  compile-mode. See <link>[']</link> and <link>'></link> - note that in FIG-forth
  the word <link>'</link> had returned the PFA (not the CFA) and therefore
  this word was introduced being the <link>SYNONYM</link> of the ans-like
  word <link>'</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>'</forthname>
    <forthstack>( 'name' -- name-xt* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"'" ( 'name' -- name-xt* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the execution token of the following name. This word
  is _not_ immediate and may not do what you expect in
  compile-mode. See <link>[']</link> and <link>'></link> - note that in FIG-forth
  the word of the same name had returned the PFA (not the CFA)
  and was immediate/smart, so beware when porting forth-code
  from FIG-forth to ANSI-forth.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(</forthname>
    <forthstack>( 'comment&lt;closeparen&gt;' -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"("  ( 'comment&lt;closeparen&gt;' -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  eat everything up to the next closing paren - treat it
  as a comment.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>*</forthname>
    <forthstack>( a# b# -- mul-a#' | a b -- mul-a' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"*" ( a# b# -- mul-a#' | a b -- mul-a' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the multiply of the two args
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>*/</forthname>
    <forthstack>( a# b# c# -- scale-a#' | a b c -- scale-a' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"*\/" ( a# b# c# -- scale-a#' | a b c -- scale-a' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  regard the b/c as element Q - this word
  has an advantage over the sequence of <link>*</link>
  and <link>/</link> by using an intermediate double-cell
  value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>*/MOD</forthname>
    <forthstack>( a# b# c# -- div-a# mod-a# | a b c -- div-a mod-a [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"*\/MOD" ( a# b# c# -- div-a# mod-a# | a b c -- div-a mod-a [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  has an adavantage over the sequence of <link>*</link>
  and <link>/MOD</link> by using an intermediate double-cell
  value.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+</forthname>
    <forthstack>( a* b# -- a*' | a# b* -- b*' | a# b# -- a#' | a b -- a' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>+ ( a* b# -- a*' | a# b* -- b*' | a# b# -- a#' | a b -- a' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the sum of the two args
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+!</forthname>
    <forthstack>( value# some-cell* -- | value some* -- [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>+! ( value# some-cell* -- | value some* -- [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  add val to the value found in addr
</para><screen>  simulate:
    : +! TUCK @ + SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((+LOOP))</forthname>
    <forthstack>( increment# -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((+LOOP))" ( increment# -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>+LOOP</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+LOOP</forthname>
    <forthstack>( increment# R: some,loop -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>+LOOP ( increment# R: some,loop -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  compile <link>((+LOOP))</link> which will use the increment
  as the loop-offset instead of just 1. See the
  <link>DO</link> and <link>LOOP</link> construct.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>,</forthname>
    <forthstack>( value* -- | value# -- | value -- [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"," ( value* -- | value# -- | value -- [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  store the value in the dictionary
</para><screen>  simulate:
    : , DP  1 CELLS DP +!  ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-</forthname>
    <forthstack>( a* b# -- a*' | a# b* -- b*' | a# b# -- a#' | a* b* -- diff-b#' | a b -- a' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"-" ( a* b# -- a*' | a# b* -- b*' | a# b# -- a#' | a* b* -- diff-b#' | a b -- a' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the difference of the two arguments
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.</forthname>
    <forthstack>( value# -- | value* -- [?] | value -- [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"." ( value# -- | value* -- [?] | value -- [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print the numerical value to stdout - uses <link>BASE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((."))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN] skipstring</forthhints>
    <stackline>'((.\"))' ( -- ) [HIDDEN] skipstring</stackline>
   </forthdefinition>
   <comment><para>  compiled by => ." string"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>."</forthname>
    <forthstack>( [string&lt;"&gt;] -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>'.\"' ( [string&lt;"&gt;] -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print the string to stdout
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/</forthname>
    <forthstack>( a# b#  -- a#' | a b -- a' [???] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"/" ( a# b#  -- a#' | a b -- a' [???] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the quotient of the two arguments
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/MOD</forthname>
    <forthstack>( a# b# -- div-a#' mod-a#' | a b -- div-a' mod-a' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"/MOD" ( a# b# -- div-a#' mod-a#' | a b -- div-a' mod-a' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  divide a and b and return both
  quotient n and remainder m
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>0&lt;</forthname>
    <forthstack>( value -- test-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>0&lt; ( value -- test-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return a flag that is true if val is lower than zero
</para><screen>  simulate:
   : 0&lt; 0 &lt; ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>0=</forthname>
    <forthstack>( 0 -- test-flag! | value! -- 0 | value -- test-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>0= ( 0 -- test-flag! | value! -- 0 | value -- test-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return a flag that is true if val is just zero
</para><screen>  simulate:
   : 0= 0 = ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>1+</forthname>
    <forthstack>( value -- value' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>1+ ( value -- value' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the value incremented by one
</para><screen>  simulate:
   : 1+ 1 + ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>1-</forthname>
    <forthstack>( value -- value' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>1- ( value -- value' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the value decremented by one
</para><screen>  simulate:
    : 1- 1 - ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2!</forthname>
    <forthstack>( x,x variable* -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2! ( x,x variable* -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  double-cell store
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2*</forthname>
    <forthstack>( a# -- a#' | a -- a' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2* ( a# -- a#' | a -- a' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  multiplies the value with two - but it
  does actually use a shift1 to be faster
</para><screen>  simulate:
   : 2* 2 * ; ( canonic) : 2* 1 LSHIFT ; ( usual)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2/</forthname>
    <forthstack>( a# -- a#' | a -- a' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2/ ( a# -- a#' | a -- a' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  divides the value by two - but it
  does actually use a shift1 to be faster
</para><screen>  simulate:
   : 2/ 2 / ; ( canonic) : 2/ 1 RSHIFT ; ( usual)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2@</forthname>
    <forthstack>( variable* -- x,x )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2@ ( variable* -- x,x ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  double-cell fetch
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2DROP</forthname>
    <forthstack>( a b -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2DROP ( a b -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  double-cell drop, also used to drop two items
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2DUP</forthname>
    <forthstack>( a,a -- a,a a,a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2DUP ( a,a -- a,a a,a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  double-cell duplication, also used to duplicate
  two items
</para><screen>  simulate:
    : 2DUP OVER OVER ; ( wrong would be : 2DUP DUP DUP ; !!)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2OVER</forthname>
    <forthstack>( a,a b,b -- a,a b,b a,a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2OVER ( a,a b,b -- a,a b,b a,a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  double-cell over, see <link>OVER</link> and <link>2DUP</link>
</para><screen>  simulate:
    : 2OVER SP@ 2 CELLS + 2@ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2SWAP</forthname>
    <forthstack>( a,a b,b -- b,b a,a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2SWAP ( a,a b,b -- b,b a,a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  double-cell swap, see <link>SWAP</link> and <link>2DUP</link>
</para><screen>  simulate:
    : 2SWAP LOCALS| B1 B2 A1 A2 | B2 B1 A2 A1 ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(NEST)</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"(NEST)" ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>:</link>
  (see also <link>(NONAME)</link> compiled by <link>:NONAME</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>:</forthname>
    <forthstack>( 'name' -- )</forthstack>
    <forthhints> [ANS] [NEW]</forthhints>
    <stackline>":" ( 'name' -- ) [ANS] [NEW]</stackline>
   </forthdefinition>
   <comment><para>  create a header for a nesting word and go to compiling
  mode then. This word is usually ended with <link>;</link> but
  the execution of the resulting colon-word can also
  return with <link>EXIT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((;))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN] [EXIT]</forthhints>
    <stackline>"((;))" ( -- ) [HIDDEN] [EXIT]</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>;</link> and maybe <link>;AND</link> --
  it will perform an <link>EXIT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>;</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS] [EXIT] [END]</forthhints>
    <stackline>";" ( -- ) [ANS] [EXIT] [END]</stackline>
   </forthdefinition>
   <comment><para>  compiles <link>((;))</link> which does <link>EXIT</link> the current
  colon-definition. It does then end compile-mode
  and returns to execute-mode. See <link>:</link> and <link>:NONAME</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&lt;</forthname>
    <forthstack>( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>&lt; ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return a flag telling if a is lower than b
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&lt;#</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>&lt;# ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  see also <link>HOLD</link> for old-style forth-formatting words
  and <link>PRINTF</link> of the C-style formatting - this word
  does initialize the pictured numeric output space.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>=</forthname>
    <forthstack>( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>= ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return a flag telling if a is equal to b
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;</forthname>
    <forthstack>( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>&gt; ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return a flag telling if a is greater than b
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;BODY</forthname>
    <forthstack>( some-xt* -- some-body* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>&gt;BODY ( some-xt* -- some-body* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  adjust the execution-token (ie. the CFA) to point
  to the parameter field (ie. the PFA) of a word.
  this is not a constant operation - most words have their
  parameters at "1 CELLS +" but CREATE/DOES-words have the
  parameters at "2 CELLS +" and ROM/USER words go indirect
  with a rom'ed offset i.e. "CELL + @ UP +"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;NUMBER</forthname>
    <forthstack>( a,a str-ptr str-len -- a,a' str-ptr' str-len)</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>&gt;NUMBER ( a,a str-ptr str-len -- a,a' str-ptr' str-len) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  try to convert a string into a number, and place
  that number at a,a respeciting <link>BASE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;R</forthname>
    <forthstack>( value -- R: value )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>&gt;R ( value -- R: value ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  save the value onto the return stack. The return
  stack must be returned back to clean state before
  an exit and you should note that the return-stack
  is also touched by the <link>DO</link> ... <link>WHILE</link> loop.
  Use <link>R></link> to clean the stack and <link>R@</link> to get the
  last value put by <link>>R</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?DUP</forthname>
    <forthstack>( 0 -- 0 | value! -- value! value! | value -- 0 | value! value! )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>?DUP ( 0 -- 0 | value! -- value! value! | value -- 0 | value! value! ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  one of the rare words whose stack-change is
  condition-dependet. This word will duplicate
  the value only if it is not zero. The usual
  place to use it is directly before a control-word
  that can go to different places where we can
  spare an extra <link>DROP</link> on the is-null-part.
  This makes the code faster and often a little
  easier to read.
</para><screen>  example:
    : XX BEGIN ?DUP WHILE DUP . 2/ REPEAT ; instead of
    : XX BEGIN DUP WHILE DUP . 2/ REPEAT DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>@</forthname>
    <forthstack>( value* -- value )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>@ ( value* -- value ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fetch the value from the variables address
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ABS</forthname>
    <forthstack>( value# -- value#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ABS ( value# -- value#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the absolute value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ACCEPT</forthname>
    <forthstack>( buffer-ptr buffer-max -- buffer-len )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ACCEPT ( buffer-ptr buffer-max -- buffer-len ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  get a string from terminal into the named input
  buffer, returns the number of bytes being stored
  in the buffer. May provide line-editing functions.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ALIGN</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ALIGN ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  will make the dictionary aligned, usually to a
  cell-boundary, see <link>ALIGNED</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ALIGNED</forthname>
    <forthstack>( addr -- addr' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ALIGNED ( addr -- addr' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  uses the value (being usually a dictionary-address)
  and increment it to the required alignment for the
  dictionary which is usually in <link>CELLS</link> - see also
  <link>ALIGN</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ALLOT</forthname>
    <forthstack>( allot-count -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ALLOT ( allot-count -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  make room in the dictionary - usually called after
  a <link>CREATE</link> word like <link>VARIABLE</link> or <link>VALUE</link>
  to make for an array of variables. Does not
  initialize the space allocated from the dictionary-heap.
  The count is in bytes - use <link>CELLS</link> ALLOT to allocate
  a field of cells.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>AND</forthname>
    <forthstack>( value mask -- value' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>AND ( value mask -- value' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  mask with a bitwise and - be careful when applying
  it to logical values.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BEGIN</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS] [LOOP]</forthhints>
    <stackline>BEGIN ( -- ) [ANS] [LOOP]</stackline>
   </forthdefinition>
   <comment><para>  start a control-loop, see <link>WHILE</link> and <link>REPEAT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>C!</forthname>
    <forthstack>( value# variable#* -- | value# variable* [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>C! ( value# variable#* -- | value# variable* [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  store the byte-value at address, see => !
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>C,</forthname>
    <forthstack>( value# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>C, ( value# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  store a new byte-value in the dictionary, implicit 1 ALLOT,
  see => ,
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>C@</forthname>
    <forthstack>( value#* -- value# | value* -- value# [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>C@ ( value#* -- value# | value* -- value# [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fetch a byte-value from the address, see <link>@</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CELL+</forthname>
    <forthstack>( value -- value' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CELL+ ( value -- value' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  adjust the value by adding a single Cell's width
  - the value is often an address or offset, see <link>CELLS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CELLS</forthname>
    <forthstack>( value# -- value#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CELLS ( value# -- value#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  scale the value by the sizeof a Cell
  the value is then often applied to an address or
  fed into <link>ALLOT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CHAR</forthname>
    <forthstack>( 'word' -- char# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CHAR ( 'word' -- char# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the (ascii-)value of the following word's
  first character.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CHAR+</forthname>
    <forthstack>( value -- value' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CHAR+ ( value -- value' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  increment the value by the sizeof one char
  - the value is often a pointer or an offset,
  see <link>CHARS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CHARS</forthname>
    <forthstack>( value# -- value#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CHARS ( value# -- value#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  scale the value by the sizeof a char
  - the value is then often applied to an address or
  fed into <link>ALLOT</link> (did you expect that sizeof(p4char)
  may actually yield 2 bytes?)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((CONSTANT))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((CONSTANT))" ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  runtime compiled by <link>CONSTANT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CONSTANT</forthname>
    <forthstack>( value 'name' -- )</forthstack>
    <forthhints> [ANS] [DOES: -- value ]</forthhints>
    <stackline>CONSTANT ( value 'name' -- ) [ANS] [DOES: -- value ]</stackline>
   </forthdefinition>
   <comment><para>  <link>CREATE</link> a new word with runtime <link>((CONSTANT))</link>
  so that the value placed here is returned everytime
  the constant's name is used in code. See <link>VALUE</link>
  for constant-like names that are expected to change
  during execution of the program. In a ROM-able
  forth the CONSTANT-value may get into a shared
  ROM-area and is never copied to a RAM-address.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>COUNT</forthname>
    <forthstack>( string-bstr* -- string-ptr' string-len | some* -- some*' some-len [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>COUNT ( string-bstr* -- string-ptr' string-len | some* -- some*' some-len [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  usually before calling <link>TYPE</link>
</para><para>
  (as an unwarranted extension, this word does try to be idempotent).
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CR</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CR ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print a carriage-return/new-line on stdout
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DECIMAL</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>DECIMAL ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  set the <link>BASE</link> to 10
</para><screen>  simulate:
    : DECIMAL 10 BASE ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DEPTH</forthname>
    <forthstack>( -- depth# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>DEPTH ( -- depth# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the depth of the parameter stack before
  the call, see <link>SP@</link> - the return-value is in <link>CELLS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((DO))</forthname>
    <forthstack>( end# start# -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((DO))" ( end# start# -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>DO</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DO</forthname>
    <forthstack>( end# start# | end* start* -- R: some,loop )</forthstack>
    <forthhints> [ANS] [LOOP]</forthhints>
    <stackline>DO ( end# start# | end* start* -- R: some,loop ) [ANS] [LOOP]</stackline>
   </forthdefinition>
   <comment><para>   pushes $end and $start onto the return-stack ( <link>>R</link> )
   and starts a control-loop that ends with <link>LOOP</link> or
   <link>+LOOP</link> and may get a break-out with <link>LEAVE</link> . The
   loop-variable can be accessed with <link>I</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((VAR))</forthname>
    <forthstack>( -- pfa )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((VAR))" ( -- pfa ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  the runtime compiled by <link>VARIABLE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((BUILDS))</forthname>
    <forthstack>( -- pfa )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((BUILDS))" ( -- pfa ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  the runtime compiled by <link>CREATE</link> which
  is not much unlike a <link>VARIABLE</link>
  (in ANS Forth Mode we reserve an additional DOES-field)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((DOES&gt;))</forthname>
    <forthstack>( -- pfa )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((DOES&gt;))" ( -- pfa ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  runtime compiled by DOES>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(DOES&gt;)</forthname>
    <forthstack>( -- pfa )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"(DOES&gt;)" ( -- pfa ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>DOES></link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DOES&gt;</forthname>
    <forthstack>( -- does* )</forthstack>
    <forthhints> [ANS] [END] [NEW]</forthhints>
    <stackline>"DOES&gt;" ( -- does* ) [ANS] [END] [NEW]</stackline>
   </forthdefinition>
   <comment><para>  does twist the last <link>CREATE</link> word to carry
  the <link>(DOES>)</link> runtime. That way, using the
  word will execute the code-piece following <link>DOES></link>
  where the pfa of the word is already on stack.
  (note: FIG option will leave pfa+cell since does-rt is stored in pfa)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CREATE</forthname>
    <forthstack>( 'name' -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CREATE ( 'name' -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  create a name with runtime <link>((VAR))</link> so that everywhere the name is used
  the pfa of the name's body is returned. This word is not immediate and
  according to the ANS Forth documents it may get directly used in the
  first part of a <link>DOES></link> defining word - in traditional forth systems
  the word <link><BUILDS</link> was used for that and <link>CREATE</link> was defined to be
  the first part of a <link>VARIABLE</link> word (compare with <link>CREATE:</link> and the
  portable expression <link>0</link> <link>BUFFER:</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&lt;BUILDS</forthname>
    <forthstack>( 'name' -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>&lt;BUILDS ( 'name' -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>   make a <link>HEADER</link> whose runtime will be changed later
   using <link>DOES></link>  <br />
   note that ans'forth does not define <link><BUILDS</link> and
   it suggests to use <link>CREATE</link> directly. <br />
   ... if you want to write FIG-programs in pure pfe then you have
   to use <link>CREATE:</link> to get the FIG-like meaning of <link>CREATE</link> whereas
   the ans-forth <link>CREATE</link> is the same as <link><BUILDS</link>
</para><screen>  : &lt;BUILDS BL WORD HEADER DOCREATE A, 0 A, ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DROP</forthname>
    <forthstack>( a -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>DROP ( a -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  just drop the word on the top of stack, see <link>DUP</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DUP</forthname>
    <forthstack>( a -- a a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>DUP ( a -- a a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  duplicate the cell on top of the stack - so the
  two topmost cells have the same value (they are
  equal w.r.t <link>=</link> ) , see <link>DROP</link> for the inverse
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(BRANCH)</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"(BRANCH)" ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>ELSE</link> - just a simple <link>BRANCH</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((ELSE))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> OBSOLETE (FIXME: to be removed in pfe-34)</forthhints>
    <stackline>"((ELSE))" ( -- ) OBSOLETE (FIXME: to be removed in pfe-34)</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ELSE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>ELSE ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  will compile an <link>((ELSE))</link> <link>BRANCH</link> that performs an
  unconditional jump to the next <link>THEN</link> - and it resolves
  an <link>IF</link> for the non-true case
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EMIT</forthname>
    <forthstack>( char# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>EMIT ( char# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print the char-value on stack to stdout
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT?</forthname>
    <forthstack>( name-ptr name-len -- 0 | ?? name-flag! )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ENVIRONMENT? ( name-ptr name-len -- 0 | ?? name-flag! ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  check the environment for a property, usually
  a condition like questioning the existance of
  specified wordset, but it can also return some
  implementation properties like "WORDLISTS"
  (the length of the search-order) or "#LOCALS"
  (the maximum number of locals)
</para><para>  Here it implements the environment queries as a <link>SEARCH-WORDLIST</link>
  in a user-visible vocabulary called <link>ENVIRONMENT</link>
</para><screen>  : ENVIRONMENT?
    ['] ENVIRONMENT &gt;WORDLIST SEARCH-WORDLIST
    IF  EXECUTE TRUE ELSE  FALSE THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EVALUATE</forthname>
    <forthstack>( str-ptr str-len -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>EVALUATE ( str-ptr str-len -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  <link>INTERPRET</link> the given string, <link>SOURCE</link> id
  is -1 during that time.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXECUTE</forthname>
    <forthstack>( some-xt* -- ??? )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>EXECUTE ( some-xt* -- ??? ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  run the execution-token on stack - this will usually
  trap if it was null for some reason, see <link>>EXECUTE</link>
</para><screen>  simulate:
   : EXECUTE &gt;R EXIT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXIT</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS] [EXIT]</forthhints>
    <stackline>EXIT ( -- ) [ANS] [EXIT]</stackline>
   </forthdefinition>
   <comment><para>  will unnest the current colon-word so it will actually
  return the word calling it. This can be found in the
  middle of a colon-sequence between <link>:</link> and <link>;</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILL</forthname>
    <forthstack>( mem-ptr mem-len char# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FILL ( mem-ptr mem-len char# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fill a memory area with the given char, does now
  simply call p4_memset()
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FIND</forthname>
    <forthstack>( name-bstr* -- name-bstr* 0 | name-xt* -1|1 )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FIND ( name-bstr* -- name-bstr* 0 | name-xt* -1|1 ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  looks into the current search-order and tries to find
  the name string as the name of a word. Returns its
  execution-token or the original-bstring if not found,
  along with a flag-like value that is zero if nothing
  could be found. Otherwise it will be 1 (a positive value)
  if the word had been immediate, -1 otherwise (a negative
  value).
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FM/MOD</forthname>
    <forthstack>( n1,n1# n2# -- div-n1# mod-n1# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"FM/MOD" ( n1,n1# n2# -- div-n1# mod-n1# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  divide the double-cell value n1 by n2 and return
  both (floored) quotient n and remainder m
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>HERE</forthname>
    <forthstack>( -- here* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>HERE ( -- here* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  used with <link>WORD</link> and many compiling words
</para><screen>  simulate:   : HERE DP @ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>HOLD</forthname>
    <forthstack>( char# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>HOLD ( char# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  the old-style forth-formatting system -- this
  word adds a char to the picutred output string.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>I</forthname>
    <forthstack>( R: some,loop -- S: i# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>I ( R: some,loop -- S: i# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  returns the index-value of the innermost <link>DO</link> .. <link>LOOP</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(?BRANCH)</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"(?BRANCH)" ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution word compiled by <link>IF</link> - just some simple => ?BRANCH
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((IF))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> OBSOLETE (FIXME: to be removed in pfe-34)</forthhints>
    <stackline>"((IF))" ( -- ) OBSOLETE (FIXME: to be removed in pfe-34)</stackline>
   </forthdefinition>
   <comment><para>  use <link>(?BRANCH)</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IF</forthname>
    <forthstack>( value -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>IF ( value -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  checks the value on the stack (at run-time, not compile-time)
  and if true executes the code-piece between <link>IF</link> and the next
  <link>ELSE</link> or <link>THEN</link> . Otherwise it has compiled a branch over
  to be executed if the value on stack had been null at run-time.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IMMEDIATE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>IMMEDIATE ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  make the <link>LATEST</link> word immediate, see also <link>CREATE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>INVERT</forthname>
    <forthstack>( value# -- value#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>INVERT ( value# -- value#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  make a bitwise negation of the value on stack.
  see also <link>NEGATE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>J</forthname>
    <forthstack>( R: some,loop -- S: j# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>J ( R: some,loop -- S: j# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  get the current <link>DO</link> ... <link>LOOP</link> index-value being
  the not-innnermost. (the second-innermost...)
  see also for the other loop-index-values at
  <link>I</link> and <link>K</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>KEY</forthname>
    <forthstack>( -- char# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>KEY ( -- char# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return a single character from the keyboard - the
  key is not echoed.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LEAVE</forthname>
    <forthstack>( R: some,loop -- R: some,loop )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>LEAVE ( R: some,loop -- R: some,loop ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  quit the innermost <link>DO</link> .. <link>LOOP</link>  - it does even
  clean the return-stack and branches to the place directly
  after the next <link>LOOP</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((LIT))</forthname>
    <forthstack>( -- value )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((LIT))" ( -- value ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>LITERAL</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LITERAL</forthname>
    <forthstack>( C: value -- S: value )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>LITERAL ( C: value -- S: value ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  if compiling this will take the value from the compiling-stack
  and puts in dictionary so that it will pop up again at the
  run-time of the word currently in creation. This word is used
  in compiling words but may also be useful in making a hard-constant
  value in some code-piece like this:
</para><screen>  : DCELLS [ 2 CELLS ] LITERAL * ; ( will save a multiplication at runtime)
</screen><para>  (in most configurations this word is statesmart and it will do nothing
   in interpret-mode. See <link>LITERAL,</link> for a non-immediate variant)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((LOOP))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((LOOP))" ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>LOOP</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOOP</forthname>
    <forthstack>( R: some,loop -- )</forthstack>
    <forthhints> [ANS] [REPEAT]</forthhints>
    <stackline>LOOP ( R: some,loop -- ) [ANS] [REPEAT]</stackline>
   </forthdefinition>
   <comment><para>  resolves a previous <link>DO</link> thereby compiling <link>((LOOP))</link> which
  does increment/decrement the index-value and branch back if
  the end-value of the loop has not been reached.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LSHIFT</forthname>
    <forthstack>( value# shift-count -- value#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>LSHIFT ( value# shift-count -- value#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  does a bitwise left-shift on value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>M*</forthname>
    <forthstack>( a# b# -- a,a#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>M* ( a# b# -- a,a#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  multiply and return a double-cell result
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MAX</forthname>
    <forthstack>( a# b# -- a#|b# | a* b* -- a*|b* | a b -- a|b [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>MAX ( a# b# -- a#|b# | a* b* -- a*|b* | a b -- a|b [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the maximum of a and b
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MIN</forthname>
    <forthstack>( a# b# -- a#|b# | a* b* -- a*|b* | a b -- a|b [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>MIN ( a# b# -- a#|b# | a* b* -- a*|b* | a b -- a|b [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the minimum of a and b
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MOD</forthname>
    <forthstack>( a# b# -- mod-a# | a b# -- mod-a# [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>MOD ( a# b# -- mod-a# | a b# -- mod-a# [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the module of "a mod b"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MOVE</forthname>
    <forthstack>( from-ptr to-ptr move-len -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>MOVE ( from-ptr to-ptr move-len -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  p4_memcpy an area
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NEGATE</forthname>
    <forthstack>( value# -- value#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>NEGATE ( value# -- value#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the arithmetic negative of the (signed) cell
</para><screen>  simulate:   : NEGATE -1 * ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OR</forthname>
    <forthstack>( a b# -- a' | a# b -- b' | a b -- a' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>OR ( a b# -- a' | a# b -- b' | a b -- a' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the bitwise OR of a and b - unlike <link>AND</link> this
  is usually safe to use on logical values
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OVER</forthname>
    <forthstack>( a b -- a b a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>OVER ( a b -- a b a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  get the value from under the top of stack. The inverse
  operation would be <link>TUCK</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((POSTPONE))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((POSTPONE))" ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>POSTPONE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>POSTPONE</forthname>
    <forthstack>( [word] -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>POSTPONE ( [word] -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  will compile the following word at the run-time of the
  current-word which is a compiling-word. The point is that
  <link>POSTPONE</link> takes care of the fact that word may be
  an IMMEDIATE-word that flags for a compiling word, so it
  must be executed (and not pushed directly) to compile
  sth. later. Choose this word in favour of <link>COMPILE</link>
  (for non-immediate words) and <link>[COMPILE]</link> (for immediate
  words)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>QUIT</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [EXIT]</forthhints>
    <stackline>QUIT ( -- ) [EXIT]</stackline>
   </forthdefinition>
   <comment><para>  this will throw and lead back to the outer-interpreter.
  traditionally, the outer-interpreter is called QUIT
  in forth itself where the first part of the QUIT-word
  had been to clean the stacks (and some other variables)
  and then turn to an endless loop containing <link>QUERY</link>
  and <link>EVALUATE</link> (otherwise known as <link>INTERPRET</link> )
  - in pfe it is defined as a <link>THROW</link> ,
</para><screen>  : QUIT -56 THROW ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R&gt;</forthname>
    <forthstack>( R: a -- a R: )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>R&gt; ( R: a -- a R: ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  get back a value from the return-stack that had been saved
  there using <link>>R</link> . This is the traditional form of a local
  var space that could be accessed with <link>R@</link> later. If you
  need more local variables you should have a look at <link>LOCALS|</link>
  which does grab some space from the return-stack too, but names
  them the way you like.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R@</forthname>
    <forthstack>( R: a -- a R: a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>R@ ( R: a -- a R: a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fetch the (upper-most) value from the return-stack that had
  been saved there using <link>>R</link> - This is the traditional form of a local
  var space. If you need more local variables you should have a
  look at <link>LOCALS|</link> , see also <link>>R</link> and <link>R></link> . Without LOCALS-EXT
  there are useful words like <link>2R@</link> <link>R'@</link> <link>R"@</link> <link>R!</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RECURSE</forthname>
    <forthstack>( ? -- ? )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>RECURSE ( ? -- ? ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  when creating a colon word the name of the currently-created
  word is smudged, so that you can redefine a previous word
  of the same name simply by using its name. Sometimes however
  one wants to recurse into the current definition instead of
  calling the older defintion. The <link>RECURSE</link> word does it
  exactly this.
</para><screen>    traditionally the following code had been in use:
    : GREAT-WORD [ UNSMUDGE ] DUP . 1- ?DUP IF GREAT-WORD THEN ;
    now use
    : GREAT-WORD DUP . 1- ?DUP IF RECURSE THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REPEAT</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS] [REPEAT]</forthhints>
    <stackline>REPEAT ( -- ) [ANS] [REPEAT]</stackline>
   </forthdefinition>
   <comment><para>  ends an unconditional loop, see <link>BEGIN</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ROT</forthname>
    <forthstack>( a b c -- b c a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ROT ( a b c -- b c a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  rotates the three uppermost values on the stack,
  the other direction would be with <link>-ROT</link> - please
  have a look at <link>LOCALS|</link> and <link>VAR</link> that can avoid
  its use.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RSHIFT</forthname>
    <forthstack>( value# shift-count# -- value#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>RSHIFT ( value# shift-count# -- value#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  does a bitwise logical right-shift on value
  (ie. the value is considered to be unsigned)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((S"))</forthname>
    <forthstack>( -- string-ptr string-len )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>'((S"))' ( -- string-ptr string-len ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>S"</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>S"</forthname>
    <forthstack>( [string&lt;"&gt;] -- string-ptr string-len)</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>'S"' ( [string&lt;"&gt;] -- string-ptr string-len) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  if compiling then place the string into the currently
  compiled word and on execution the string pops up
  again as a double-cell value yielding the string's address
  and length. To be most portable this is the word to be
  best being used. Compare with <link>C"</link> and non-portable <link>"</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>S&gt;D</forthname>
    <forthstack>( a# -- a,a#' | a -- a,a#' [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>S&gt;D ( a# -- a,a#' | a -- a,a#' [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  signed extension of a single-cell value to a double-cell value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SIGN</forthname>
    <forthstack>( a# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SIGN ( a# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  put the sign of the value into the hold-space, this is
  the forth-style output formatting, see <link>HOLD</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SM/REM</forthname>
    <forthstack>( a,a# b# -- div-a# rem-a# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SM/REM ( a,a# b# -- div-a# rem-a# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  see <link>/MOD</link> or <link>FM/MOD</link> or <link>UM/MOD</link> or <link>SM/REM</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SOURCE</forthname>
    <forthstack>( -- buffer* IN-offset# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SOURCE ( -- buffer* IN-offset# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>   the current point of interpret can be gotten through SOURCE.
   The buffer may flag out TIB or BLK or a FILE and IN gives
   you the offset therein. Traditionally, if the current SOURCE
   buffer is used up, <link>REFILL</link> is called that asks for another
   input-line or input-block. This scheme would have made it
   impossible to stretch an [IF] ... [THEN] over different blocks,
   unless [IF] does call <link>REFILL</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPACE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SPACE ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print a single space to stdout, see <link>SPACES</link>
</para><screen>  simulate:    : SPACE  BL EMIT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPACES</forthname>
    <forthstack>( space-count -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SPACES ( space-count -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print n space to stdout, actually a loop over n calling <link>SPACE</link> ,
  but the implemenation may take advantage of printing chunks of
  spaces to speed up the operation.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SWAP</forthname>
    <forthstack>( a b -- b a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SWAP ( a b -- b a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  exchanges the value on top of the stack with the value beneath it
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>THEN</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>THEN ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  does resolve a branch coming from either <link>IF</link> or <link>ELSE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TYPE</forthname>
    <forthstack>( string-ptr string-len -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>TYPE ( string-ptr string-len -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  prints the string-buffer to stdout, see <link>COUNT</link> and <link>EMIT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>U.</forthname>
    <forthstack>( value# -- | value -- [?] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>U. ( value# -- | value -- [?] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print unsigned number to stdout
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>U&lt;</forthname>
    <forthstack>( a b -- test-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>U&lt; ( a b -- test-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  unsigned comparison, see <link><</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UM*</forthname>
    <forthstack>( a# b# -- a,a#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>UM* ( a# b# -- a,a#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  unsigned multiply returning double-cell value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UM/MOD</forthname>
    <forthstack>( a,a# b# -- div-a#' mod-a#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"UM/MOD" ( a,a# b# -- div-a#' mod-a#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  see <link>/MOD</link> and <link>SM/REM</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UNLOOP</forthname>
    <forthstack>( R: some,loop -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>UNLOOP ( R: some,loop -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  drop the <link>DO</link> .. <link>LOOP</link> runtime variables from the return-stack,
  usually used just in before an <link>EXIT</link> call. Using this multiple
  times can unnest multiple nested loops.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UNTIL</forthname>
    <forthstack>( test-flag -- )</forthstack>
    <forthhints> [ANS] [REPEAT]</forthhints>
    <stackline>UNTIL ( test-flag -- ) [ANS] [REPEAT]</stackline>
   </forthdefinition>
   <comment><para>  ends an control-loop, see <link>BEGIN</link> and compare with <link>WHILE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>VARIABLE</forthname>
    <forthstack>( 'name' -- )</forthstack>
    <forthhints> [ANS] [DOES: -- name* ]</forthhints>
    <stackline>VARIABLE ( 'name' -- ) [ANS] [DOES: -- name* ]</stackline>
   </forthdefinition>
   <comment><para>  <link>CREATE</link> a new variable, so that everytime the variable is
  name, the address is returned for using with <link>@</link> and => !
  - be aware that in FIG-forth VARIABLE did take an argument
  being the initial value. ANSI-forth does different here.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WHILE</forthname>
    <forthstack>( test-flag -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>WHILE ( test-flag -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  middle part of a <link>BEGIN</link> .. <link>WHILE</link> .. <link>REPEAT</link>
  control-loop - if cond is true the code-piece up to <link>REPEAT</link>
  is executed which will then jump back to <link>BEGIN</link> - and if
  the cond is null then <link>WHILE</link> will branch to right after
  the <link>REPEAT</link>
  (compare with <link>UNTIL</link> that forms a <link>BEGIN</link> .. <link>UNTIL</link> loop)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WORD</forthname>
    <forthstack>( delimiter-char# -- here* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>WORD ( delimiter-char# -- here* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  read the next <link>SOURCE</link> section (thereby moving <link>>IN</link> ) up
  to the point reaching $delimiter-char - the text is placed
  at <link>HERE</link> - where you will find a counted string. You may
  want to use <link>PARSE</link> instead.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>XOR</forthname>
    <forthstack>( a# b# -- a#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>XOR ( a# b# -- a#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the bitwise-or of the two arguments - it may be unsafe
  use it on logical values. beware.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>[ ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  leave compiling mode - often used inside of a colon-definition
  to make fetch some very constant value and place it into the
  currently compiled colon-defintion with => , or <link>LITERAL</link>
  - the corresponding unleave word is <link>]</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[']</forthname>
    <forthstack>( [name] -- name-xt* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>['] ( [name] -- name-xt* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  will place the execution token of the following word into
  the dictionary. See <link>'</link> for non-compiling variant.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[CHAR]</forthname>
    <forthstack>( [word] -- char# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>[CHAR] ( [word] -- char# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  in compile-mode, get the (ascii-)value of the first charachter
  in the following word and compile it as a literal so that it
  will pop up on execution again. See <link>CHAR</link> and forth-83 <link>ASCII</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>]</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>] ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  enter compiling mode - often used inside of a colon-definition
  to end a previous <link>[</link> - you may find a  => , or <link>LITERAL</link>
  nearby in example texts.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.(</forthname>
    <forthstack>( [message&lt;closeparen&gt;] -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>".(" ( [message&lt;closeparen&gt;] -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print the message to the screen while reading a file. This works
  too while compiling, so you can whatch the interpretation/compilation
  to go on. Some Forth-implementations won't even accept a => ." message"
  outside compile-mode while the (current) pfe does.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.R</forthname>
    <forthstack>( value# precision# -- | value precision# -- [??] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>.R ( value# precision# -- | value precision# -- [??] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print with precision - that is to fill
  a field of the give prec-with with
  right-aligned number from the converted value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>0&lt;&gt;</forthname>
    <forthstack>( 0 -- 0 | value! -- value-flag! | value -- value-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"0&lt;&gt;" ( 0 -- 0 | value! -- value-flag! | value -- value-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  returns a logical-value saying if the value was not-zero.
  This is most useful in turning a numerical value into a
  boolean value that can be fed into bitwise words like
  <link>AND</link> and <link>XOR</link> - a simple <link>IF</link> or <link>WHILE</link> doesn't
  need it actually.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>0&gt;</forthname>
    <forthstack>( 0 -- 0 | value! -- value-flag! | value -- value-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>0&gt; ( 0 -- 0 | value! -- value-flag! | value -- value-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return value greater than zero
</para><screen>  simulate:    : 0&gt; 0 &gt; ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2&gt;R</forthname>
    <forthstack>( a,a -- R: a,a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2&gt;R ( a,a -- R: a,a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  save a double-cell value onto the return-stack, see <link>>R</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2R&gt;</forthname>
    <forthstack>( R: a,a -- a,a R: )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2R&gt; ( R: a,a -- a,a R: ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  pop back a double-cell value from the return-stack, see <link>R></link>
  and the earlier used <link>2>R</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2R@</forthname>
    <forthstack>( R: a,a -- a,a R: a,a )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>2R@ ( R: a,a -- a,a R: a,a ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fetch a double-cell value from the return-stack, that had been
  previously been put there with <link>2>R</link> - see <link>R@</link> for single value.
  This can partly be a two-cell <link>LOCALS|</link> value,  without LOCALS-EXT
  there are alos other useful words like <link>2R!</link> <link>R'@</link> <link>R"@</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(NONAME)</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"(NONAME)" ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>:NONAME</link>
  (see also <link>(NEST)</link> compiled by <link>:</link> (execution is identical))
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>:NONAME</forthname>
    <forthstack>( -- C: noname,word )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>:NONAME ( -- C: noname,word ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  start a colon nested-word but do not use <link>CREATE</link> - so no name
  is given to the colon-definition that follows. When the definition
  is finished at the corresponding <link>;</link> the start-address (ie.
  the execution token) can be found on the outer cs.stack that may
  be stored used elsewhere then.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&lt;&gt;</forthname>
    <forthstack>( a b -- a-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"&lt;&gt;" ( a b -- a-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return true if a and b are not equal, see <link>=</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((?DO))</forthname>
    <forthstack>( a b -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((?DO))" ( a b -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by => ?DO
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?DO</forthname>
    <forthstack>( end# start# | end* start* -- R: some,loop )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>?DO ( end# start# | end* start* -- R: some,loop ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  start a control-loop just like <link>DO</link> - but don't execute
  atleast once. Instead jump over the code-piece if the loop's
  variables are not in a range to allow any loop.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>AGAIN</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS] [REPEAT]</forthhints>
    <stackline>AGAIN ( -- ) [ANS] [REPEAT]</stackline>
   </forthdefinition>
   <comment><para>  ends an infinite loop, see <link>BEGIN</link> and compare with
  <link>WHILE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((C"))</forthname>
    <forthstack>( -- string-bstr* )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>'((C"))' ( -- string-bstr* ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>C"</link> string"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>C"</forthname>
    <forthstack>( [string&lt;"&gt;] -- string-bstr* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>'C"' ( [string&lt;"&gt;] -- string-bstr* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  in compiling mode place the following string in the current
  word and return the address of the counted string on execution.
  (in exec-mode use a <link>POCKET</link> and leave the bstring-address of it),
  see <link>S"</link> string" and the non-portable <link>"</link> string"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CASE</forthname>
    <forthstack>( value -- value )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CASE ( value -- value ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  start a CASE construct that ends at <link>ENDCASE</link>
  and compares the value on stack at each <link>OF</link> place
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>COMPILE,</forthname>
    <forthstack>( some-xt* -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"COMPILE," ( some-xt* -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  place the execution-token on stack into the dictionary - in
  traditional forth this is not even the least different than
  a simple => , but in call-threaded code there's a big
  difference - so COMPILE, is the portable one. Unlike
  <link>COMPILE</link> , <link>[COMPILE]</link> and <link>POSTPONE</link> this word does
  not need the xt to have actually a name, see <link>:NONAME</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CONVERT</forthname>
    <forthstack>( a,a# string-bstr* -- a,a# a-len# )</forthstack>
    <forthhints> [ANS] [OLD]</forthhints>
    <stackline>CONVERT ( a,a# string-bstr* -- a,a# a-len# ) [ANS] [OLD]</stackline>
   </forthdefinition>
   <comment><para>  digit conversion, obsolete, superseded by <link>>NUMBER</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENDCASE</forthname>
    <forthstack>( value -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ENDCASE ( value -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  ends a <link>CASE</link> construct that may surround multiple sections of
  <link>OF</link> ... <link>ENDOF</link> code-portions. The <link>ENDCASE</link> has to resolve the
  branches that are necessary at each <link>ENDOF</link> to point to right after
  <link>ENDCASE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENDOF</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ENDOF ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  resolve the branch need at the previous <link>OF</link> to mark
  a code-piece and leave with an unconditional branch
  at the next <link>ENDCASE</link> (opened by <link>CASE</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ERASE</forthname>
    <forthstack>( buffer-ptr buffer-len -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ERASE ( buffer-ptr buffer-len -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fill an area will zeros.
</para><screen>  2000 CREATE DUP ALLOT ERASE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXPECT</forthname>
    <forthstack>( str-ptr str-len -- )</forthstack>
    <forthhints> [ANS] [OLD]</forthhints>
    <stackline>EXPECT ( str-ptr str-len -- ) [ANS] [OLD]</stackline>
   </forthdefinition>
   <comment><para>  input handling, see <link>WORD</link> and <link>PARSE</link> and <link>QUERY</link>
  the input string is placed at str-adr and its length
</para><screen>  in =&gt; SPAN - this word is superceded by =&gt; ACCEPT
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>HEX</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>HEX ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  set the input/output <link>BASE</link> to hexadecimal
</para><screen>  simulate:        : HEX 16 BASE ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MARKER</forthname>
    <forthstack>( 'name' -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>MARKER ( 'name' -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  create a named marker that you can use to <link>FORGET</link> ,
  running the created word will reset the dict/order variables
  to the state at the creation of this name.
</para><screen>  : MARKER PARSE-WORD (MARKER) ;
</screen><para>  see also <link>ANEW</link> which is not defined in ans-forth but which uses
  the <link>MARKER</link> functionality in the way it should have been defined.
</para><screen>  : MARKER PARSE-WORD (MARKER) ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NIP</forthname>
    <forthstack>( a b -- b )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>NIP ( a b -- b ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  drop the value under the top of stack, inverse of <link>TUCK</link>
</para><screen>  simulate:        : NIP SWAP DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((OF))</forthname>
    <forthstack>( check val -- check )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((OF))" ( check val -- check ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>OF</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OF</forthname>
    <forthstack>( value test -- value )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>OF ( value test -- value ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  compare the case-value placed lately with the comp-value
  being available since <link>CASE</link> - if they are equal run the
  following code-portion up to <link>ENDOF</link> after which the
  case-construct ends at the next <link>ENDCASE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PAD</forthname>
    <forthstack>( -- pad* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>PAD ( -- pad* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  transient buffer region
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PARSE</forthname>
    <forthstack>( delim-char# -- buffer-ptr buffer-len )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>PARSE ( delim-char# -- buffer-ptr buffer-len ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  parse a piece of input (not much unlike WORD) and place
  it into the given buffer. The difference with word is
  also that <link>WORD</link> would first skip any delim-char while
  <link>PARSE</link> does not and thus may yield that one. In a newer
  version, <link>PARSE</link> will not copy but just return the word-span
  being seen in the input-buffer - therefore a transient space.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PARSE-NAME</forthname>
    <forthstack>( "chars" -- buffer-ptr buffer-len )</forthstack>
    <forthhints> [Forth200x]</forthhints>
    <stackline>PARSE-NAME  ( "chars" -- buffer-ptr buffer-len ) [Forth200x]</stackline>
   </forthdefinition>
   <comment><para>  This word is identical with the PFE implementation <link>PARSE-WORD</link>
</para><para>
  The only difference between the 1994 ANS-Forth PARSE-WORD
  and the 2005 Forth200x PARSE-NAME is in the explicit condition
  of whitespace-only - while 1994 reads "If the parse area is empty,
  the resulting string has a zero length." you will find that the
  2005 version says "If the parse area is empty or contains only
  white space, the resulting string has length zero."
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PARSE-WORD</forthname>
    <forthstack>( "chars" -- buffer-ptr buffer-len )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>PARSE-WORD ( "chars" -- buffer-ptr buffer-len ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  the ANS'94 standard describes this word in a comment
  under <link>PARSE</link>, section A.6.2.2008 - quote:
</para><para>
  Skip leading spaces and parse name delimited by a space. c-addr
  is the address within the input buffer and u is the length of the
  selected string. If the parse area is empty, the resulting string
  has a zero length.
</para><para>
  If both <link>PARSE</link> and <link>PARSE-WORD</link> are present, the need for <link>WORD</link>
  is largely eliminated. Note that Forth200x calls it <link>PARSE-NAME</link>
  and clarifies that non-empty whitespace-only input is returned as
  a zero length string as well.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PICK</forthname>
    <forthstack>( value ...[n-1] n -- value ...[n-1] value )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>PICK ( value ...[n-1] n -- value ...[n-1] value ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  pick the nth value from under the top of stack and push it
  note that
</para><screen>    0 PICK -&gt; DUP         1 PICK -&gt; OVER
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REFILL</forthname>
    <forthstack>( -- refill-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>REFILL ( -- refill-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  try to get a new input line from the <link>SOURCE</link> and set
  <link>>IN</link> accordingly. Return a flag if sucessful, which is
  always true if the current input comes from a
  terminal and which is always false if the current input
  comes from <link>EVALUATE</link> - and may be either if the
  input comes from a file
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RESTORE-INPUT</forthname>
    <forthstack>( input...[input-len] input-len -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>RESTORE-INPUT ( input...[input-len] input-len -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  inverse of <link>SAVE-INPUT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ROLL</forthname>
    <forthstack>( value ...[n-1] n -- ...[n-1] value )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ROLL ( value ...[n-1] n -- ...[n-1] value ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  the extended form of <link>ROT</link>
</para><screen>     2 ROLL -&gt; ROT
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SAVE-INPUT</forthname>
    <forthstack>( -- input...[input-len] input-len )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SAVE-INPUT ( -- input...[input-len] input-len ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fetch the current state of the input-channel which
  may be restored with <link>RESTORE-INPUT</link> later
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((TO))</forthname>
    <forthstack>( value -- )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((TO))" ( value -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>TO</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TO</forthname>
    <forthstack>( value [name] -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>TO ( value [name] -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  set the parameter field of name to the value, this is used
  to change the value of a <link>VALUE</link> and it can be also used
  to change the value of <link>LOCALS|</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TUCK</forthname>
    <forthstack>( a b -- b a b )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>TUCK ( a b -- b a b ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  shove the top-value under the value beneath. See <link>OVER</link>
  and <link>NIP</link>
</para><screen>  simulate:    : TUCK  SWAP OVER ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>U.R</forthname>
    <forthstack>( value# precision# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>U.R ( value# precision# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  print right-aligned in a prec-field, treat value to
  be unsigned as opposed to => .R
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>U&gt;</forthname>
    <forthstack>( a b -- a-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>U&gt; ( a b -- a-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  unsigned comparison of a and b, see <link>></link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UNUSED</forthname>
    <forthstack>( -- unused-len )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>UNUSED ( -- unused-len ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the number of cells that are left to be used
  above <link>HERE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((VALUE))</forthname>
    <forthstack>( -- value )</forthstack>
    <forthhints> [HIDDEN]</forthhints>
    <stackline>"((VALUE))" ( -- value ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  runtime compiled by <link>VALUE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>VALUE</forthname>
    <forthstack>( value 'name' -- )</forthstack>
    <forthhints> [HIDDEN] [DOES: -- value ]</forthhints>
    <stackline>VALUE ( value 'name' -- ) [HIDDEN] [DOES: -- value ]</stackline>
   </forthdefinition>
   <comment><para>  <link>CREATE</link> a word and initialize it with value. Using it
  later will push the value back onto the stack. Compare with
  <link>VARIABLE</link> and <link>CONSTANT</link> - look also for <link>LOCALS|</link> and
  <link>VAR</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WITHIN</forthname>
    <forthstack>( a# b# c# -- a-flag | a* b* c* -- a-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>WITHIN ( a# b# c# -- a-flag | a* b* c* -- a-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  a widely used word, returns ( b <= a && a < c ) so
  that is very useful to check an index a of an array
  to be within range b to c
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[COMPILE]</forthname>
    <forthstack>( [word] -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>[COMPILE] ( [word] -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  while compiling the next word will be place in the currently
  defined word no matter if that word is immediate (like <link>IF</link> )
  - compare with <link>COMPILE</link> and <link>POSTPONE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>\</forthname>
    <forthstack>( [comment&lt;eol&gt;] -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>"\\" ( [comment&lt;eol&gt;] -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  eat everything up to the next end-of-line so that it is
  getting ignored by the interpreter.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>"</forthname>
    <forthstack>( [string&lt;"&gt;] -- string-bstr* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>'"' ( [string&lt;"&gt;] -- string-bstr* ) [FTH]</stackline>
   </forthdefinition>
   <comment><screen> 
     or perhaps ( [string&lt;"&gt;] -- string-ptr string-len )
</screen><para>   This is the non-portable word which is why the ANSI-committee
   on forth has created the two other words, namely <link>S"</link> and <link>C"</link> ,
   since each implementation (and in pfe configurable) uses another
   runtime behaviour. FIG-forth did return bstring which is the configure
   default for pfe.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BL</forthname>
    <forthstack>( -- bl-char# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>BL ( -- bl-char# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  a quick constant returning the blank character in host encoding,
  in ascii that is 0x20
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TIB</forthname>
    <forthstack>( -- tib-char* )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>TIB ( -- tib-char* ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  traditional variable for forth terminal I/O system.
  (Terminal Input Buffer)    ( <link>TIB</link> <link>SPAN</link> <link>SOURCE</link> <link>BLK</link> <link>REFILL</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SOURCE</forthname>
    <forthstack>( -- source# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SOURCE ( -- source# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  traditional variable for forth terminal I/O system.
                             ( <link>TIB</link> <link>SPAN</link> <link>SOURCE</link> <link>BLK</link> <link>REFILL</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;IN</forthname>
    <forthstack>( -- inputpoint# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>&gt;IN ( -- inputpoint# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  traditional variable for forth terminal I/O system.
                             ( <link>TIB</link> <link>SPAN</link> <link>SOURCE</link> <link>BLK</link> <link>REFILL</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPAN</forthname>
    <forthstack>( -- span-count )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SPAN ( -- span-count ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  traditional variable for forth terminal I/O system.
                             ( <link>TIB</link> <link>SOURCE</link> <link>SOURCE-ID</link> <link>BLK</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SOURCE-ID</forthname>
    <forthstack>( -- source# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>SOURCE-ID ( -- source# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  modern variable for forth terminal I/O system.
                             ( <link>TIB</link> <link>SPAN</link> <link>>IN</link> <link>SOURCE</link> <link>BLK</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STATE</forthname>
    <forthstack>( -- state-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>STATE ( -- state-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  traditional variable for forth outer interpreter.
   ( <link>:</link> <link>[</link> <link>]</link> <link>LITERAL</link> <link>COMPILE</link> <link>POSTPONE</link> <link>BASE</link> <link>NUMBER</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FALSE</forthname>
    <forthstack>( -- 0 )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FALSE ( -- 0 ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  places zero on the stack to express the code want to do a boolean
  evaluation with this value. (<link>IF</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TRUE</forthname>
    <forthstack>( -- true! )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>TRUE ( -- true! ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  places <link>FALSE</link> <link>INVERT</link> on the stack to express the code want to
  do a boolean evaluation with this value. (<link>IF</link>) - we chose the
  FIG79/FTH83 value of allbitsset to make it easier to do logical
  computations using bitwise operands like <link>AND</link> <link>OR</link> <link>NOT</link> ,
  however ANS-Forth programs shall not assume a specific representation
  of the truth value and handle just the cases <link>=0</link> and <link><>0</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT STACK-CELLS</forthname>
    <forthstack>( -- stackdepth# )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT STACK-CELLS" ( -- stackdepth# ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  the number of cells allocated for the parameter stack of forth.
  it can be set with a startup option to match different needs
  of applications. (like <link>ENVIRONMENT RETURN-STACK-CELLS</link>) unless
  the parameter-stack is made in hardware (like on some special
  forth CPUs)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT RETURN-STACK-CELLS</forthname>
    <forthstack>( -- stackdepth# )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT RETURN-STACK-CELLS" ( -- stackdepth# ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  the number of cells allocated for the return stack of forth.
  it can be set with a startup option to match different needs
  of applications. (like <link>ENVIRONMENT STACK-CELLS</link>) unless
  the return-stack is made in hardware (like on some special
  forth CPUs) or aliased with the return-stack provided by
  the hosting operating system for the forth process thread.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT /COUNTED-STRING</forthname>
    <forthstack>( -- string-max )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT /COUNTED-STRING" ( -- string-max ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  the maximum number of chars in a counted string created with
  words like <link>C\</link>" or <link>PLACE</link> - in general, the counted string
  can use all bits from the first <link>CHAR</link> of the string, so it
  expands to <link>1</link> <link>/CHAR</link> <link>LSHIFT</link> <link>1-</link> being 255 for octet systems.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT /HOLD</forthname>
    <forthstack>( -- hold-max )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT /HOLD" ( -- hold-max ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  traditional constant for the forth I/O system, moved into
  the environment in ans-forth systems.
  ( <link>HLD</link> <link>HOLD</link> <link>ENVIRONMENT /PAD</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT /PAD</forthname>
    <forthstack>( -- pad-max )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT /PAD" ( -- pad-max ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  traditional constant for the forth I/O system, moved into
  the environment in ans-forth systems.
  ( <link>HLD</link> <link>HOLD</link> <link>ENVIRONMENT /HOLD</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT ADDRESS-UNIT-BITS</forthname>
    <forthstack>( -- unit-len )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT ADDRESS-UNIT-BITS" ( -- unit-len ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  a constant useful to retarget forth applications to unusual
  hardware that has not 8 bits per address unit (i.e. not an
  octet-addressable system). This includes some desktop calculators
  and wristwatch calculators with a 4 bit address system, and
  some special DSP cpus with 24 bit or 32 bit address units.
  All these are deeply embedded for special purpose applications.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT FLOORED</forthname>
    <forthstack>( -- true! )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT FLOORED" ( -- true! ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  a flag whether division/modulo is floored or not. since pfe
  builds on top of C, it takes its style of computations in
  all respects, please refer to the ISO C standard for further
  interpretations.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT MAX-CHAR</forthname>
    <forthstack>( -- char-max )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT MAX-CHAR" ( -- char-max ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  a constant to check representation limits, expands to 255 in
  octet-char systems like PFE.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT MAX-N</forthname>
    <forthstack>( -- int-max )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT MAX-N" ( -- int-max ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  a constant to check representation limits, here it is the
  the largest usable signed integer. In a 16-bit two's-complement
  system this is 32767, and likewise higher in 32-bit and 64-bit
  versions of PFE. (like <link>ENVIRONMENT MAX-U</link>)
</para><screen>    TRUE 1 RSHIFT CONSTANT MAX-N
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT MAX-U</forthname>
    <forthstack>( -- uint-max )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT MAX-U" ( -- uint-max ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  a constant to check representation limits, here it is the
  the largest usable unsigned integer. In a 16-bit two's-complement
  system this is 65535, and likewise higher in 32-bit and 64-bit
  versions of PFE. (like <link>ENVIRONMENT MAX-N</link>)
</para><screen>    TRUE CONSTANT MAX-U
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/core-mix.c">
  <forthheader>
   <forthdefinition>
    <forthname>0&lt;=</forthname>
    <forthstack>( a -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>0&lt;= ( a -- flag )</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate    : 0&lt;= 0&gt; 0= ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>0&gt;=</forthname>
    <forthstack>( a -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>0&gt;= ( a -- flag )</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate    : 0&gt;= 0&lt; 0= ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&lt;=</forthname>
    <forthstack>( a b -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>&lt;= ( a b -- flag )</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate    : &lt;= &gt; 0= ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;=</forthname>
    <forthstack>( a b -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>&gt;= ( a b -- flag )</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate    : &gt;= &lt; 0= ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>U&lt;=</forthname>
    <forthstack>( a b -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>U&lt;= ( a b -- flag )</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate    : U&lt;= U&gt; 0= ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>U&gt;=</forthname>
    <forthstack>( a b -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>U&gt;= ( a b -- flag )</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate    : U&gt;= U&lt; 0= ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UMAX</forthname>
    <forthstack>( a b -- max )</forthstack>
    <forthhints></forthhints>
    <stackline>UMAX ( a b -- max )</stackline>
   </forthdefinition>
   <comment><para>  see <link>MAX</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UMIN</forthname>
    <forthstack>( a b -- min )</forthstack>
    <forthhints></forthhints>
    <stackline>UMIN ( a b -- min )</stackline>
   </forthdefinition>
   <comment><para>  see <link>MIN</link> , <link>MAX</link> and <link>UMAX</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LICENSE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>LICENSE ( -- )</stackline>
   </forthdefinition>
   <comment><para>  show a lisence info - the basic PFE system is licensed under the terms
  of the LGPL (Lesser GNU Public License) - binary modules loaded into
  the system and hooking into the system may carry another <link>LICENSE</link>
</para><screen>  : LICENSE [ ENVIRONMENT ] FORTH-LICENSE TYPE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WARRANTY</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>WARRANTY ( -- )</stackline>
   </forthdefinition>
   <comment><para>  show a warranty info - the basic PFE system is licensed under the terms
  of the LGPL (Lesser GNU Public License) - which exludes almost any 
  liabilities whatsoever - however loadable binary modules may hook into
  the system and their functionality may have different WARRANTY infos.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.VERSION</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>.VERSION ( -- )</stackline>
   </forthdefinition>
   <comment><para>  show the version of the current PFE system
</para><screen>  : .VERSION [ ENVIRONMENT ] FORTH-NAME TYPE FORTH-VERSION TYPE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.CVERSION</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>.CVERSION ( -- )</stackline>
   </forthdefinition>
   <comment><para>  show the compile date of the current PFE system
</para><screen>  : .CVERSION [ ENVIRONMENT ] FORTH-NAME TYPE FORTH-DATE TYPE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STRING,</forthname>
    <forthstack>( str len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>STRING,               ( str len -- )</stackline>
   </forthdefinition>
   <comment><para>   Store a string in data space as a counted string.
</para><screen>  : STRING, HERE  OVER 1+  ALLOT  PLACE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PARSE,</forthname>
    <forthstack>( "chars&lt;"&gt;" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>PARSE,                    ( "chars&lt;"&gt;" -- )</stackline>
   </forthdefinition>
   <comment><para>   Store a char-delimited string in data space as a counted
   string. As seen in Bawd's
</para><screen>  : ," [CHAR] " PARSE  STRING, ; IMMEDIATE
</screen><para>
  this implementation is much different from Bawd's
</para><screen>  : PARSE, PARSE STRING, ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>"PARSE,\""</forthname>
    <forthstack>( "chars&lt;"&gt;" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"PARSE,\""  ( "chars&lt;"&gt;" -- )</stackline>
   </forthdefinition>
   <comment><para>   Store a quote-delimited string in data space as a counted
   string.
</para><screen>  : ," [CHAR] " PARSE  STRING, ; IMMEDIATE
</screen><para>
  implemented here as
</para><screen>  : PARSE," [CHAR] " PARSE, ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(MARKER)</forthname>
    <forthstack>( str-ptr str-len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"(MARKER)" ( str-ptr str-len -- )</stackline>
   </forthdefinition>
   <comment><para>  create a named marker that you can use to <link>FORGET</link> ,
  running the created word will reset the dict/order variables
  to the state at the creation of this name.
</para><screen>  : (MARKER) (CREATE) HERE , 
          GET-ORDER DUP , 0 DO ?DUP IF , THEN LOOP 0 , 
          ...
    DOES&gt; DUP @ (FORGET) 
          ...
  ; 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ANEW</forthname>
    <forthstack>( 'name' -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ANEW ( 'name' -- )</stackline>
   </forthdefinition>
   <comment><para>  creates a <link>MARKER</link> if it doesn't exist,
  or forgets everything after it if it does. (it just gets executed).
</para><para>
  Note: in PFE the <link>ANEW</link> will always work on the <link>ENVIRONMENT-WORDLIST</link>
  which has a reason: it is never quite sure whether the same
  <link>DEFINITIONS</link> wordlist is in the search <link>ORDER</link> that the original
  <link>ANEW</link> <link>MARKER</link> was defined in. Therefore, <link>ANEW</link> would be only safe
  on systems that do always stick to <link>FORTH</link> <link>DEFINITIONS</link>. Instead
  we will <link>CREATE</link> the <link>ANEW</link> <link>MARKER</link> in the <link>ENVIRONMENT</link> and use a 
  simple <link>SEARCH-WORDLIST</link> on the <link>ENVIRONMENT-WORDLIST</link> upon re-run.
</para><screen>  \ old
  : ANEW BL WORD   DUP FIND NIP IF EXECUTE THEN   (MARKER) ;
  \ new
  : ANEW 
    PARSE-WORD  2DUP ENVIRONMENT-WORDLIST SEARCH-WORDLIST IF  EXECUTE  THEN 
    GET-CURRENT &gt;R ENVIRONMENT-WORDLIST SET-CURRENT  (MARKER)  R&gt; SET-CURRENT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((MARKER))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"((MARKER))" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  runtime compiled by <link>MARKER</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/core-sub.c">
  <forthheader>
   <forthdefinition>
    <forthname>_strpush_</forthname>
    <forthstack>( zstr* -- S: str* str# )</forthstack>
    <forthhints></forthhints>
    <stackline>_strpush_ ( zstr* -- S: str* str# )</stackline>
   </forthdefinition>
   <comment><para>  push a C-string onto the SP runtime-stack, as if <link>S"</link> string" was used
</para><screen>  : _strpush_ s! _strlen_ s! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_pocket_</forthname>
    <forthstack>( -- str* )</forthstack>
    <forthhints></forthhints>
    <stackline>_pocket_ ( -- str* )</stackline>
   </forthdefinition>
   <comment><para>  return the next pocket for interactive string input.
</para><screen>  : _pocket_ _pockets@_ _pocket@_ th  _pocket@_ 1+ _pockets#_ mod to _pocket@_ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_-trailing_</forthname>
    <forthstack>( str* str# -- str#' )</forthstack>
    <forthhints></forthhints>
    <stackline>_-trailing_ ( str* str# -- str#' )</stackline>
   </forthdefinition>
   <comment><para>  chop off trailing spaces for the stringbuffer. returns the new length,
  so for an internal counted string, use
</para><screen>    &lt;x&gt; dup count _-trailing_ c!
    : _-trailing_ begin dup while
       2dup + c@ bl &lt;&gt; if nip exit then
       1- repeat nip ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_lower_</forthname>
    <forthstack>( str* str# -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_lower_ ( str* str# -- )</stackline>
   </forthdefinition>
   <comment><para>  _tolower_ applied to a stringbuffer
</para><screen>  : _lower_ 0 do dup c@ _tolower_ over c! 1+ loop drop ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_upper_</forthname>
    <forthstack>( str* str# -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_upper_ ( str* str# -- )</stackline>
   </forthdefinition>
   <comment><para>  _toupper_ applied to a stringbuffer
</para><screen>  : _upper_ 0 do dup c@ _toupper_ over c! 1+ loop drop ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_zplaced_</forthname>
    <forthstack>( str* str# dst* max# -- dst* )</forthstack>
    <forthhints> [alias] _store_c_string_</forthhints>
    <stackline>_zplaced_ ( str* str# dst* max# -- dst* ) [alias] _store_c_string_</stackline>
   </forthdefinition>
   <comment><para>  copy stringbuffer into a field as a zero-terminated string.
</para><screen>  : _zsplaced_ rot 2dup &gt; if drop 1- else nip then _zplace_ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_pocket_zplaced</forthname>
    <forthstack>( str* str# -- pocket* )</forthstack>
    <forthhints> [alias] _pocket_c_string_</forthhints>
    <stackline>_pocket_zplaced ( str* str# -- pocket* ) [alias] _pocket_c_string_</stackline>
   </forthdefinition>
   <comment><para>  store a string-span as a zero-terminated string into another pocket-pad
</para><screen>  : _pocket_zplaced _pocket_ _/pocket_ _zplaced_ ;
 
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_zplaced_filename_</forthname>
    <forthstack>( str* str# dst* max# -- dst* )</forthstack>
    <forthhints> [alias] _store_filename_</forthhints>
    <stackline>_zplaced_filename_ ( str* str# dst* max# -- dst* ) [alias] _store_filename_</stackline>
   </forthdefinition>
   <comment><para>  copy stringbuffer into a field as a zero-terminated filename-string,
  a shell-homedir like "~username" will be expanded, and the
  platform-specific dir-delimiter is converted in on the fly ('/' vs. '\\')
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_pocket_fileame_</forthname>
    <forthstack>( str* str# -- dst* )</forthstack>
    <forthhints></forthhints>
    <stackline>_pocket_fileame_ ( str* str# -- dst* )</stackline>
   </forthdefinition>
   <comment><para>  a new pocket with the given filename as asciiz
</para><screen>  : _pocket_filename_ _pocket_ /pocket _zplaced_filename_
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_search_</forthname>
    <forthstack>( str* str# key* key# -- 0 | key-in-str* )</forthstack>
    <forthhints></forthhints>
    <stackline>_search_ ( str* str# key* key# -- 0 | key-in-str* )</stackline>
   </forthdefinition>
   <comment><para>  search for substring p2/u2 in string p1/u1, returns null if not found
  or a pointer into str*,str# that has lenght of key#
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_match_</forthname>
    <forthstack>( zpattern* zstring* ignorecase? -- yes? )</forthstack>
    <forthhints></forthhints>
    <stackline>_match_ ( zpattern* zstring* ignorecase? -- yes? )</stackline>
   </forthdefinition>
   <comment><para>  Match string against pattern.
  Pattern knows wildcards `*' and `?' and `\' to escape a wildcard.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_dig&gt;num_</forthname>
    <forthstack>( c n* base -- ?ok )</forthstack>
    <forthhints></forthhints>
    <stackline>_dig&gt;num_ ( c n* base -- ?ok )</stackline>
   </forthdefinition>
   <comment><para>  Get value of digit c into *n, return flag: valid digit.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_num2dig_</forthname>
    <forthstack>( val -- c )</forthstack>
    <forthhints></forthhints>
    <stackline>_num2dig_ ( val -- c )</stackline>
   </forthdefinition>
   <comment><para>  make digit
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_hold_</forthname>
    <forthstack>( c -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_hold_ ( c -- )</stackline>
   </forthdefinition>
   <comment><para>  insert into pictured numeric output string
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_?number_</forthname>
    <forthstack>( str* str# dcell* -- ?ok )</forthstack>
    <forthhints></forthhints>
    <stackline>_?number_ ( str* str# dcell* -- ?ok )</stackline>
   </forthdefinition>
   <comment><para>  try to convert into number, see => ?NUMBER
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_ud.r_</forthname>
    <forthstack>( d,d str* str# base -- str* )</forthstack>
    <forthhints></forthhints>
    <stackline>_ud.r_ ( d,d str* str# base -- str* )</stackline>
   </forthdefinition>
   <comment><para>  This is for internal use only (SEE and debugger),
  The real <link>UD</link>.R etc. words uses <link>HOLD</link> and the memory area below <link>PAD</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_d.r_</forthname>
    <forthstack>( d,d str* str# base -- str* )</forthstack>
    <forthhints></forthhints>
    <stackline>_d.r_ ( d,d str* str# base -- str* )</stackline>
   </forthdefinition>
   <comment><para>  This is for internal use only (SEE and debugger),
  The real <link>UD</link>.R etc. words use <link>HOLD</link> and the memory area below <link>PAD</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_._</forthname>
    <forthstack>( i str* str# base -- str* )</forthstack>
    <forthhints></forthhints>
    <stackline>_._ ( i str* str# base -- str* )</stackline>
   </forthdefinition>
   <comment><para>  This is for internal use only (SEE and debugger),
  The real => . etc. words use <link>HOLD</link> and the memory area below <link>PAD</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_outc_</forthname>
    <forthstack>( char -- )</forthstack>
    <forthhints> [alias] _outc</forthhints>
    <stackline>_outc_ ( char -- ) [alias] _outc</stackline>
   </forthdefinition>
   <comment><para>  emit single character,
  (output adjusting the <link>OUT</link> variable, see <link>_putc_</link> to do without)
</para><screen>  : _emit_ _putc_ _?xy_ drop out ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_ztype_</forthname>
    <forthstack>( zstr* -- )</forthstack>
    <forthhints> [alias] _outs</forthhints>
    <stackline>_ztype_ ( zstr* -- ) [alias] _outs</stackline>
   </forthdefinition>
   <comment><para>  type a string
  (output adjusting the <link>OUT</link> variable, see <link>_puts_</link> to do without)
</para><screen>  : _ztype_ _puts_ _?xy_ drop out ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_outf_</forthname>
    <forthstack>( ... zstr* -- n# )</forthstack>
    <forthhints></forthhints>
    <stackline>_outf_ ( ... zstr* -- n# )</stackline>
   </forthdefinition>
   <comment><para>  type a string with formatting
  (output adjusting the <link>OUT</link> variable, see <link>_puts_</link> and <link>_outs_</link> )
</para><screen>  : _outf_ 0x200 lbuffer: buf[]  buf[] _vsprintf_  buf[] _outs_ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_type_</forthname>
    <forthstack>( str* str# -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_type_ ( str* str# -- )</stackline>
   </forthdefinition>
   <comment><para>  type counted string to terminal
  (output adjusting the <link>OUT</link> variable, see <link>_puts_</link> and <link>_outs_</link> )
</para><screen>  : _type_ 0 do c@++ _putc_ loop drop _flush_ _?xy drop out ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_typeline_</forthname>
    <forthstack>( str* str# -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_typeline_ ( str* str# -- )</stackline>
   </forthdefinition>
   <comment><para>  type counted string to terminal, if it does not fit in full on
  the current line, emit a <link>CR</link> before
  (output adjusting the OUT variable, see <link>_type_</link> and <link>_outs_</link> )
</para><screen>  : _typeline_ out @ over + cols @ &gt; if cr then _type_ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_emits_</forthname>
    <forthstack>( n# ch -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_emits_ ( n# ch -- )</stackline>
   </forthdefinition>
   <comment><para>  type a string of chars by repeating a single character which
  is usually a space, see <link>SPACES</link>
  (output adjusting the OUT variable, see <link>_type_</link> and <link>_outs_</link> )
</para><screen>  : _emits_ swap 0 do dup _putc_ loop drop _flush_ _?xy_ drop out ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_tab_</forthname>
    <forthstack>( n# -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_tab_ ( n# -- )</stackline>
   </forthdefinition>
   <comment><para>  type a string of space up to the next tabulator column
  (output adjusting the OUT variable, see <link>_emits</link> and <link>_typeonline</link> )
</para><screen>  : _tab_ dup out @ - swap mod bl _emits_ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_.line_</forthname>
    <forthstack>( file* block# line# -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_.line_ ( file* block# line# -- )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_expect_noecho_</forthname>
    <forthstack>( str* str# -- span# )</forthstack>
    <forthhints></forthhints>
    <stackline>_expect_noecho_ ( str* str# -- span# )</stackline>
   </forthdefinition>
   <comment><para>  EXPECT counted string from terminal, without echo, so no real editing
  it will however convert backspace and tabulators, break on newline/escape
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_expect_</forthname>
    <forthstack>( str* str# -- span# )</forthstack>
    <forthhints></forthhints>
    <stackline>_expect_ ( str* str# -- span# )</stackline>
   </forthdefinition>
   <comment><para>  EXPECT counted string from terminal, with echo, so one can use
  simple editing facility with backspace, but nothing more.
  it's very traditional, you want to use a lined-like function instead!
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_accept_</forthname>
    <forthstack>( str* str# -- span# )</forthstack>
    <forthhints></forthhints>
    <stackline>_accept_ ( str* str# -- span# )</stackline>
   </forthdefinition>
   <comment><para>  better input facility using lined if possible, otherwise
  call _expect_noecho when running in a pipe or just _expect_ if no
  real terminal attached.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>QUERY</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>QUERY ( -- )</stackline>
   </forthdefinition>
   <comment><para>  source input:  read from terminal using <link>_accept_</link> with the
  returned string to show up in <link>TIB</link> of <link>/TIB</link> size.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_source_</forthname>
    <forthstack>( str*&amp; str#&amp; -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_source_ ( str*&amp; str#&amp; -- )</stackline>
   </forthdefinition>
   <comment><para>  see <link>SOURCE</link> - dispatch input source
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_size_saved_input_</forthname>
    <forthstack>( -- iframe-size )</forthstack>
    <forthhints></forthhints>
    <stackline>_size_saved_input_ ( -- iframe-size )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_link_saved_input_</forthname>
    <forthstack>( iframe* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_link_saved_input_ ( iframe* -- )</stackline>
   </forthdefinition>
   <comment><para>  see <link>SAVE-INPUT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_save_input_</forthname>
    <forthstack>( iframe-stack* -- iframe-stack*' )</forthstack>
    <forthhints></forthhints>
    <stackline>_save_input_ ( iframe-stack* -- iframe-stack*' )</stackline>
   </forthdefinition>
   <comment><para>  see <link>SAVE-INPUT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_unlink_saved_input_</forthname>
    <forthstack>( iframe* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_unlink_saved_input_ ( iframe* -- )</stackline>
   </forthdefinition>
   <comment><para>  see <link>RESTORE-INPUT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_restore_input_</forthname>
    <forthstack>( iframe-stack* -- iframe-stack*' )</forthstack>
    <forthhints></forthhints>
    <stackline>_restore_input_ ( iframe-stack* -- iframe-stack*' )</stackline>
   </forthdefinition>
   <comment><para>  see <link>RESTORE-INPUT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_refill_</forthname>
    <forthstack>( -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>_refill_ ( -- flag )</stackline>
   </forthdefinition>
   <comment><para>  see <link>REFILL</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_skip_delimiter_</forthname>
    <forthstack>( del -- )</forthstack>
    <forthhints></forthhints>
    <stackline>_skip_delimiter_ ( del -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>SKIP-DELIMITER</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_word:parse_</forthname>
    <forthstack>( delim -- &lt;end?&gt; )</forthstack>
    <forthhints></forthhints>
    <stackline>_word:parse_ ( delim -- &lt;end?&gt; )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_parse_</forthname>
    <forthstack>( delim -- ptr len )</forthstack>
    <forthhints></forthhints>
    <stackline>_parse_ ( delim -- ptr len )</stackline>
   </forthdefinition>
   <comment><screen> 
  : _parse_ _word:parse_ _word*_ s! _word#_ s! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_word&gt;here_</forthname>
    <forthstack>( -- here* )</forthstack>
    <forthhints></forthhints>
    <stackline>_word&gt;here_ ( -- here* )</stackline>
   </forthdefinition>
   <comment><para>  complement <link>_word:parse_</link> to  arrive at the normal <link>WORD</link> implementation
  will also ensure the string is zero-terminated - this makes a lot of
  operations easier since most forth function can receive a string-span
  directly but some need a string-copy and that is usually because it has
  to be passed down into a C-defined function with zerotermined string. Just
  use p4_HERE+1 (which is also the returnvalue of this function!) to have
  the start of the zero-terminated string. Note that this function may throw
  with P4_ON_PARSE_OVER if the string is too long (it has set *DP=0 to
  ensure again that <link>THROW</link> will report PFE.word. as the offending string)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_word_</forthname>
    <forthstack>( del -- here* )</forthstack>
    <forthhints></forthhints>
    <stackline>_word_ ( del -- here* )</stackline>
   </forthdefinition>
   <comment><screen> 
  : _word_ dup _skip_delimiter_ _word:parse_ _word&gt;here_ ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/debug-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>DEBUG</forthname>
    <forthstack>( "word" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>DEBUG ( "word" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  this word will place an debug-runtime into
  the <link>CFA</link> of the following word. If the
  word gets executed later, the user will
  be prompted and can decide to single-step
  the given word. The debug-stepper is
  interactive and should be self-explanatory.
  (use <link>NO-DEBUG</link> to turn it off again)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NO-DEBUG</forthname>
    <forthstack>( "word" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>NO-DEBUG ( "word" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  the inverse of " <link>DEBUG</link> word "
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(SEE) ( some-xt* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  decompile the token-sequence - used
  by <link>SEE</link> name
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ADDR&gt;NAME</forthname>
    <forthstack>( word-addr* -- word-nfa*!' | 0 )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>ADDR&gt;NAME ( word-addr* -- word-nfa*!' | 0 ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  search the next corresponding namefield that address
  is next too. If it is not in the base-dictionary, then
  just return 0 as not-found.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ADDR&gt;NAME</forthname>
    <forthstack>( word-addr* -- word-nfa!*' | 0 )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>ADDR&gt;NAME ( word-addr* -- word-nfa!*' | 0 ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  search the next corresponding namefield that address
  is next too. If it is not in the base-dictionary, then
  just return 0 as not-found.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>COME_BACK</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>COME_BACK ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  show the return stack before last exception
  along with the best names as given by <link>ADDR>NAME</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/dict-sub.c">
  <forthheader>
   <forthdefinition>
    <forthname>ONLY</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ONLY ( -- )</stackline>
   </forthdefinition>
   <comment><para>  the only-vocabulary is special. Calling it will erase
  the search <link>ORDER</link> of vocabularies and only allows
  to name some very basic vocabularies. Even <link>ALSO</link>
  is not available.
</para><screen>  example:
    ONLY FORTH ALSO EXTENSIONS ALSO DEFINITIONS
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FORTH</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>FORTH ( -- )</stackline>
   </forthdefinition>
   <comment><screen> 
  : FORTH FORTH-WORDLIST CONTEXT ! ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/dl-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(LOADM) ( module-bstr* -- module-sucess# ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOADM</forthname>
    <forthstack>( "filename" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LOADM ( "filename" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>   dlmap the shared object (or share an already mapped object)
   and run the per-thread initialization code. This is the
   user-convenient function, otherwise use <link>(LOADM)</link>
</para><screen>  simulate:
    : LOADM  BL WORD   
      ((IS_MODULE_LOADED)) IF EXIT THEN 
      HERE (LOADM)  0= IF ." -- load failed: " HERE COUNT TYPE CR THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOCAL-DLSYM</forthname>
    <forthstack>( [symbol] -- symbol-addr )</forthstack>
    <forthhints> [FTH] [EXEC]</forthhints>
    <stackline>LOCAL-DLSYM ( [symbol] -- symbol-addr ) [FTH] [EXEC]</stackline>
   </forthdefinition>
   <comment><para>   lookup the symbol that follows and leave the address (or null)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOCAL_DLCALL</forthname>
    <forthstack>( x...[8] [symbol] -- x...[8] )</forthstack>
    <forthhints> [FTH] [EXEC]</forthhints>
    <stackline>LOCAL_DLCALL ( x...[8] [symbol] -- x...[8] ) [FTH] [EXEC]</stackline>
   </forthdefinition>
   <comment><para>   does not do any stack changes, the caller
   must clean up the stack himself. You don't even
   get the return value (sigh)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>lt_dlinit</forthname>
    <forthstack>( -- dlinit-ior# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>lt_dlinit ( -- dlinit-ior# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  initialiize library, usually open the program itself so that its
  handles can be found under "0"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>lt_dlopenext</forthname>
    <forthstack>( module-ptr module-len -- module-dl-handle*! | 0 )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>lt_dlopenext ( module-ptr module-len -- module-dl-handle*! | 0 ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  walk the searchpath for dlopen and try to open a binary module
  under the given name with the usual file extension for the 
  current system.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>lt_dlsym</forthname>
    <forthstack>( symbol-ptr symbol-len module-dl-handle* -- symbol*! | 0 )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>lt_dlsym ( symbol-ptr symbol-len module-dl-handle* -- symbol*! | 0 ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  try to find the name in the binary module denoted by its handle
  .. if handle is null, use the main body of the program
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>lt_dlclose</forthname>
    <forthstack>( module-dl-handle* -- module-ior# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>lt_dlclose ( module-dl-handle* -- module-ior# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  close handle that was returned by <link>lt_dlopenext</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>lt_dlerror</forthname>
    <forthstack>( -- dlerror-zstr* )</forthstack>
    <forthhints></forthhints>
    <stackline>lt_dlerror ( -- dlerror-zstr* )</stackline>
   </forthdefinition>
   <comment><para>  returns string describing the last dlerror as for <link>lt_dlopenext</link>
  and <link>lt_dlsym</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/double-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(2CONSTANT) ( -- x1 x2 )</stackline>
   </forthdefinition>
   <comment><para>  runtime portion of <link>2CONSTANT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2CONSTANT</forthname>
    <forthstack>( x1 x2 "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>2CONSTANT ( x1 x2 "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  create a word that contains the specified twocell number in its body.
  when the name is executed, these numbers are left on the stack
</para><screen>    12. 2CONSTANT X .s 
    &lt;emtpy stack&gt; ok
    X .s
    0 12 ok
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(2LITERAL) ( -- x1 x2 )</stackline>
   </forthdefinition>
   <comment><para>  runtime portion of <link>2LITERAL</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2LITERAL</forthname>
    <forthstack>( x1 x2 -- )</forthstack>
    <forthhints> immediate</forthhints>
    <stackline>2LITERAL ( x1 x2 -- ) immediate</stackline>
   </forthdefinition>
   <comment><para>  compile a double-cell number to the current definition. When
  run, the doubele-cell is left on the stack for execution.
</para><screen>    ( -- x1 x2 )
</screen><para>  (in most configurations this word is statesmart and it will do nothing
   in interpret-mode. See <link>2LITERAL,</link> for a non-immediate variant)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2VARIABLE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>2VARIABLE ( -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>CREATE</link> a new variable definition. When executed leave
  the <link>>BODY</link> address on stack. In pfe, the data area
  of a <link>2VARIABLE</link> is <link>ERASE</link>d initially.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D+</forthname>
    <forthstack>( d1.ud1 d2.ud2 -- d3.ud3 )</forthstack>
    <forthhints></forthhints>
    <stackline>D+ ( d1.ud1 d2.ud2 -- d3.ud3 )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell sum operation ( <link>+</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>D-( d1.ud1 d2.ud2 -- d3.ud3 )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell diff operation ( <link>-</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D.R</forthname>
    <forthstack>( d1.d1 n -- )</forthstack>
    <forthhints></forthhints>
    <stackline>D.R ( d1.d1 n -- )</stackline>
   </forthdefinition>
   <comment><para>  aligned output for a double-cell number ( => .R )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D.</forthname>
    <forthstack>( d1.d1 -- )</forthstack>
    <forthhints></forthhints>
    <stackline>D. ( d1.d1 -- )</stackline>
   </forthdefinition>
   <comment><para>  freefield output for a double-cell number ( => . )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D0&lt;</forthname>
    <forthstack>( d1.d1 -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>D0&lt; ( d1.d1 -- flag )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell less-than-zero operation ( <link>0<</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D0=</forthname>
    <forthstack>( d1.d1 -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>D0= ( d1.d1 -- flag )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell equal-to-zero operation ( <link>0=</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D2*</forthname>
    <forthstack>( d1.d1 -- d1.d1' )</forthstack>
    <forthhints></forthhints>
    <stackline>D2* ( d1.d1 -- d1.d1' )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell arithmetic shiftleft-by-1 operation ( <link>2*</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D2/</forthname>
    <forthstack>( d1.d1 -- d1.d1' )</forthstack>
    <forthhints></forthhints>
    <stackline>D2/ ( d1.d1 -- d1.d1' )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell arithmetic shiftright-by-1 operation ( <link>2/</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D&lt;</forthname>
    <forthstack>( d1.d1 d2.d2 -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>D&lt; ( d1.d1 d2.d2 -- flag )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell is-less operation ( <link><</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D&gt;S</forthname>
    <forthstack>( d.d -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>D&gt;S ( d.d -- n )</stackline>
   </forthdefinition>
   <comment><para>  result is the numeric equivalent of d. If the double number was
  greater than what could fit into a single cell number, the 
  modulo cellsize will be left since the higher-significant bits
  are just <link>DROP</link>ed
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>D=</forthname>
    <forthstack>( d1.d1 d2.d2 -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>D= ( d1.d1 d2.d2 -- flag )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell is-equal operation ( <link>=</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DABS</forthname>
    <forthstack>( d1.d1 -- d1.d1'  )</forthstack>
    <forthhints></forthhints>
    <stackline>DABS ( d1.d1 -- d1.d1'  )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell abs operation ( <link>ABS</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DMAX</forthname>
    <forthstack>( d1.d1 d2.d2 -- d1.d1|d2.d2  )</forthstack>
    <forthhints></forthhints>
    <stackline>DMAX ( d1.d1 d2.d2 -- d1.d1|d2.d2  )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell max operation ( <link>MAX</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DMIN</forthname>
    <forthstack>( d1.d1 d2.d2 -- d1.d1|d2.d2  )</forthstack>
    <forthhints></forthhints>
    <stackline>DMIN ( d1.d1 d2.d2 -- d1.d1|d2.d2  )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell max operation ( <link>MIN</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DNEGATE</forthname>
    <forthstack>( d1.d1 -- d1.d1' )</forthstack>
    <forthhints></forthhints>
    <stackline>DNEGATE ( d1.d1 -- d1.d1' )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell arithmetic negate operation ( <link>NEGATE</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>M*/</forthname>
    <forthstack>( d1.d1 n1 +n2 -- d2.d2 )</forthstack>
    <forthhints></forthhints>
    <stackline>"M*\/" ( d1.d1 n1 +n2 -- d2.d2 )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell multiply-divide operation 
  using a triple-cell intermediate result for <link>*</link>
  ( <link>*\/</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>M+</forthname>
    <forthstack>( d1.d1 n1 -- d2.d2 )</forthstack>
    <forthhints></forthhints>
    <stackline>"M+" ( d1.d1 n1 -- d2.d2 )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell mixed-operand sum operation ( <link>+</link> / <link>D+</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT MAX-D</forthname>
    <forthstack>( -- d.d )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT MAX-D" ( -- d.d )</stackline>
   </forthdefinition>
   <comment><para>  <link>ENVIRONMENT</link> definition to check with <link>ENVIRONMENT?</link>
  if the double-cell wordset is present, the signed-max
  number is left.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT MAX-UD ( -- d.d )</stackline>
   </forthdefinition>
   <comment><para>  <link>ENVIRONMENT</link> definition to check with <link>ENVIRONMENT?</link>
  if the double-cell wordset is present, the unsigned-max
  number is left.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/double-mix.c">
  <forthheader>
   <forthdefinition>
    <forthname>2ROT</forthname>
    <forthstack>( d1,d1 d2,d2 d3,d3 -- d2,d2 d3,d3 d1,d1 )</forthstack>
    <forthhints></forthhints>
    <stackline>2ROT ( d1,d1 d2,d2 d3,d3 -- d2,d2 d3,d3 d1,d1 )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell <link>ROT</link> operation.
  actively moves six cells, i.e.
</para><screen>    ( x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2 )
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DU&lt;</forthname>
    <forthstack>( d1,d1 d2,d2 -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>DU&lt; ( d1,d1 d2,d2 -- flag )</stackline>
   </forthdefinition>
   <comment><para>  the double-cell unsigned-is-less operation ( <link>U<</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LITERAL,</forthname>
    <forthstack>( value -- )</forthstack>
    <forthhints></forthhints>
    <stackline>LITERAL, ( value -- )</stackline>
   </forthdefinition>
   <comment><para>  take the value from stack (or cs-stack) and compile a runtime-code and
  the value as for <link>LITERAL</link> ... this word is never state-smart, it
  is not immediate, and has therefore no complications with <link>POSTPONE</link>
  (compare also with <link>COMPILE,</link> to make a call-stub with an exectoken)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2LITERAL,</forthname>
    <forthstack>( x1,x2 -- )</forthstack>
    <forthhints></forthhints>
    <stackline>2LITERAL, ( x1,x2 -- )</stackline>
   </forthdefinition>
   <comment><para>  take the double-value from stack (or cs-stack) and compile a runtime-code 
  and the value as for <link>2LITERAL</link> ... this word is never state-smart, it
  is not immediate, and has therefore no complications with <link>POSTPONE</link>
  (compare also with <link>COMPILE,</link> to make a call-stub with an exectoken)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DCELLS</forthname>
    <forthstack>( x -- x' )</forthstack>
    <forthhints></forthhints>
    <stackline>DCELLS ( x -- x' )</stackline>
   </forthdefinition>
   <comment><para>  computes the number of address units for the specified number 
  of double-cells
</para><screen>  : DCELLS CELLS 2* ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DLSHIFT</forthname>
    <forthstack>( x1,x2 y -- z1,z2 )</forthstack>
    <forthhints></forthhints>
    <stackline>DLSHIFT ( x1,x2 y -- z1,z2 )</stackline>
   </forthdefinition>
   <comment><para>  shift-left a double-cell value.
  The shift-count is given as a single-cell.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DRSHIFT</forthname>
    <forthstack>( x1,x2 y -- z1,z2 )</forthstack>
    <forthhints></forthhints>
    <stackline>DRSHIFT ( x1,x2 y -- z1,z2 )</stackline>
   </forthdefinition>
   <comment><para>  shift-right a double-cell value.
  The shift-count is given as a single-cell.
  This is an arithmetic shift as for a signed double-cell value.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/dstrings-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>MAX-MCOUNT</forthname>
    <forthstack>( -- u )</forthstack>
    <forthhints></forthhints>
    <stackline>MAX-MCOUNT	( -- u )</stackline>
   </forthdefinition>
   <comment><para>  Leave the largest mstring count provided by the
  implementation.  Canonical values are 255 and 2^32-1.
  <ansref>"max-m-count"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/MCOUNT</forthname>
    <forthstack>( -- u )</forthstack>
    <forthhints></forthhints>
    <stackline>/MCOUNT	( -- u )</stackline>
   </forthdefinition>
   <comment><para>  Leave the size of the mstring count field provided by the
  implementation in ANS Forth character units, nominally bytes.
  Canonical sizes are one character and one cell.
  <ansref>"slash-m-count"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EMPTY$</forthname>
    <forthstack>( $: -- empty$ )</forthstack>
    <forthhints></forthhints>
    <stackline>EMPTY$	( $: -- empty$ )</stackline>
   </forthdefinition>
   <comment><para>  Push the MSA of a fixed, external representation of the empty
  string onto the string stack.  <ansref>"empty-string"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>\n$</forthname>
    <forthstack>( $: -- newline$ )</forthstack>
    <forthhints></forthhints>
    <stackline>\n$		( $: -- newline$ )</stackline>
   </forthdefinition>
   <comment><para>  Push the MSA of a fixed, external string whose body is the
  Unix newline character onto the string stack.
  <ansref>"newline-string"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DSTRINGS</forthname>
    <forthstack>( -- dfa )</forthstack>
    <forthhints></forthhints>
    <stackline>DSTRINGS	( -- dfa )</stackline>
   </forthdefinition>
   <comment><para>  A Forth variable that holds the address of the current string
  space, where all dynamic string operations take place. 
  <ansref>"d-strings"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(M!)	( a.s msa -- )</stackline>
   </forthdefinition>
   <comment><para>  (M!) is the same as Wil Baden's PLACE, except it assumes
  the buffer address msa to be aligned, and stores the ANS
  Forth string a.s as a measured string, zero-filled to
  trailing alignment.  As with PLACE, it is assumed that the
  mstring copy does not clobber the old string, and there is no
  check for room starting at msa.  <ansref>"parens-m-store"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PARSE&gt;S</forthname>
    <forthstack>( [ccc&lt;char&gt;] char -- addr len )</forthstack>
    <forthhints></forthhints>
    <stackline>PARSE&gt;S	( [ccc&lt;char&gt;] char -- addr len )</stackline>
   </forthdefinition>
   <comment><para>  Parse the input stream up to the first occurrence of char,
  which is parsed away.  If executing in compilation mode,
  append run-time semantics to the current definition that
  leaves the ANS Forth string representation on the stack.  In
  interpretation mode, leave the ANS Forth string
  representation for a stored copy, which may be transient in
  the style of <link>S</link>".  In either mode, the format of the
  stored string is implementation dependent.
  <ansref>"parse-to-s"</ansref>
</para><para>  NOTE: The interpreted copy is a nontransient in this
  implementation, and both copies are mstrings.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>S`</forthname>
    <forthstack>( [ccc&lt;`&gt;] -- addr len )</forthstack>
    <forthhints></forthhints>
    <stackline>S`		( [ccc&lt;`&gt;] -- addr len )</stackline>
   </forthdefinition>
   <comment><para>  An immediate version of parse>s where the delimiter is `.  In
  particular, the stored string in interpret mode is not
  transient. <ansref>"s-back-tick"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>M,S</forthname>
    <forthstack>( addr len -- addr' len )</forthstack>
    <forthhints></forthhints>
    <stackline>M,S		( addr len -- addr' len )</stackline>
   </forthdefinition>
   <comment><para>  ALLOT room and store the ANS Forth string into aligned data
  space as an mstring, leaving data space zero-filled to
  alignment; and leave the length and new body address.  It is
  assumed that len is unsigned.  An error is thrown if len is
  larger than the system parameter <link>MAX_DATA_STR</link>.
  <ansref>"m-comma-s"</ansref>
</para><para>  NOTE: <link>MAX_DATA_STR</link> is returned by
</para><screen>    S" /SCOPY" ENVIRONMENT?
 
</screen><para>  NOTE: <link>M,S</link> differs from <link>STRING,</link> in Wil Baden's Tool
  Belt in that it stores an aligned, measured string with
  zero-filled alignment instead of a counted string, and it
  leaves the ANS Forth string representation of the stored
  string.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MCOUNT@</forthname>
    <forthstack>( msa -- count )</forthstack>
    <forthhints></forthhints>
    <stackline>MCOUNT@	( msa -- count )</stackline>
   </forthdefinition>
   <comment><para>  Fetch the count of the mstring at msa.
  <ansref>"m-count-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MCOUNT!</forthname>
    <forthstack>( count msa -- )</forthstack>
    <forthhints></forthhints>
    <stackline>MCOUNT!	( count msa -- )</stackline>
   </forthdefinition>
   <comment><para>  Store the count in the measured string count field at msa,
  without checking that it fits. 
  <ansref>"m-count-store"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MCOUNT</forthname>
    <forthstack>( msa -- body.addr count )</forthstack>
    <forthhints></forthhints>
    <stackline>MCOUNT	( msa -- body.addr count )</stackline>
   </forthdefinition>
   <comment><para>  Convert the mstring MSA to its ANS Forth string
  representation.  <ansref>"m-count"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-MCOUNT</forthname>
    <forthstack>( addr len -- msa )</forthstack>
    <forthhints></forthhints>
    <stackline>-MCOUNT	( addr len -- msa )</stackline>
   </forthdefinition>
   <comment><para>  Convert the ANS Forth representation of an mstring to its
  MSA.  <ansref>"minus-m-count"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>0STRINGS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>0STRINGS	( -- )</stackline>
   </forthdefinition>
   <comment><para>  Set all string variables holding bound string values in string
  space to the empty string, and clear string space, including
  the string buffer, string stack, and string stack frames. 
  <ansref>"zero-strings"</ansref>
</para><para>  NOTE:  If used for under the hood development, this word must
  be executed only when string space is in a valid state.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$GARBAGE?</forthname>
    <forthstack>( -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>$GARBAGE?	( -- flag )</stackline>
   </forthdefinition>
   <comment><para>  Leave true if there is garbage in the current string space. 
  Not normally used, since garbage collection is transparent.
  <ansref>"string-garbage-question"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$GC-OFF</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$GC-OFF	( -- )</stackline>
   </forthdefinition>
   <comment><para>  Disable garbage collection in the current string space.  An
  error will be thrown if garbage collection is attempted.
  <ansref>"string-g-c-off"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$GC-ON</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$GC-ON	( -- )</stackline>
   </forthdefinition>
   <comment><para>  Enable garbage collection in the current string space.  This
  is the default.  <ansref>"string-g-c-on"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$GC-LOCK@</forthname>
    <forthstack>( -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>$GC-LOCK@     ( -- flag )</stackline>
   </forthdefinition>
   <comment><para>  Fetch the dstring garbage collection "off" state.  Intended
  for saving the off state for later restoration after a usage
  of <link>$GC-ON</link> or <link>$GC-OFF</link>.
  <ansref>"string-g-c-lock-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$GC-LOCK!</forthname>
    <forthstack>( flag -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$GC-LOCK!    ( flag -- )</stackline>
   </forthdefinition>
   <comment><para>  Set the dstring garbage collection "off" state according to
  flag.  Intended for restoring the off state previously
  fetched by <link>$GC-LOCK@</link>.
  <ansref>"string-g-c-lock-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$UNUSED</forthname>
    <forthstack>( -- u )</forthstack>
    <forthhints></forthhints>
    <stackline>$UNUSED	( -- u )</stackline>
   </forthdefinition>
   <comment><para>  Leave the number of bytes available for dynamic strings and
  string stack entries in the string buffer. 
  <ansref>"string-unused"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>COLLECT-$GARBAGE</forthname>
    <forthstack>( -- collected-flag )</forthstack>
    <forthhints></forthhints>
    <stackline>COLLECT-$GARBAGE	( -- collected-flag )</stackline>
   </forthdefinition>
   <comment><para>  If string space is not marked as containing garbage, return
  false.  If there is garbage, throw an error when garbage
  collection is disabled.  Otherwise remove the garbage and
  return true.  Garbage collection is "transparent", so the
  user would not normally use this word.
  <ansref>"collect-string-garbage"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MAKE-$SPACE</forthname>
    <forthstack>( size #frames -- addr )</forthstack>
    <forthhints></forthhints>
    <stackline>MAKE-$SPACE		( size #frames -- addr )</stackline>
   </forthdefinition>
   <comment><para>  Allocate and initialize a string space with size bytes
  available for the string buffer including the string stack,
  and with a string frame stack for frame description entries
  holding up to #frames.  The size is rounded up to cell
  alignment, and the buffer begins and ends with cell alignment.
  Return addr, the address of the string space.  The standard
  word <link>FREE</link> with addr as input can be used to release the space.
  <ansref>"make-string-space"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/$BUF</forthname>
    <forthstack>( -- u )</forthstack>
    <forthhints></forthhints>
    <stackline>/$BUF	( -- u )</stackline>
   </forthdefinition>
   <comment><para>  Leave the size in address units allocated for the current
  string buffer. <ansref>"slash-string-buf"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MAX-#$FRAMES</forthname>
    <forthstack>( -- u )</forthstack>
    <forthhints></forthhints>
    <stackline>MAX-#$FRAMES	( -- u )</stackline>
   </forthdefinition>
   <comment><para>  Leave the number of string frames allowed on the string frame
  stack for the current string space.
  <ansref>"max-number-string-frames"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$!</forthname>
    <forthstack>( $var.dfa $: a$ -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$!		( $var.dfa $: a$ -- )</stackline>
   </forthdefinition>
   <comment><para>  Store the string MSA on the string stack in the variable
  whose DFA is on the parameter stack. 
  <ansref>"string-store"</ansref>
</para><para>  NOTES: The only situation in which <link>$!</link> copies the string
  value is when it is a bound string already stored in another
  variable.  In that case, the new copy is the one that is
  stored in the variable.  In particular, external strings are
  not copied.
</para><para>  If the string value held by the string variable on entry is a
  bound string that is also referenced deeper on the string
  stack, its back link is reset to point to the deepest string
  stack reference.  If it is a bound string not deeper on the
  string stack and not identical to the input string, its back
  link is set to zero, making it garbage.  If it is an external
  string, its MSA in the variable is simply written over by
  that popped from the string stack.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$@</forthname>
    <forthstack>( $var.pfa -- $: a$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$@		( $var.pfa -- $: a$ )</stackline>
   </forthdefinition>
   <comment><para>  Leave the MSA of the string held by the string variable.
  <ansref>"string-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$"</forthname>
    <forthstack>( [ccc&lt;"&gt;] -- $: str )</forthstack>
    <forthhints></forthhints>
    <stackline>$"		( [ccc&lt;"&gt;] -- $: str )</stackline>
   </forthdefinition>
   <comment><para>  Parse ccc delimited by " (double quote) and store it in data
  space as an mstring.  If interpreting, leave the MSA on the
  string stack.  If compiling, append run-time semantics to the
  current definition that leaves the MSA on the string stack. 
  A program should not alter the stored string.  An error is
  thrown if the quoted string length is larger than the system
  parameter <link>MAX_DATA_STR</link> (see <link>SM,</link>).
  <ansref>"string-quote"</ansref>
</para><para>  NOTE:  In contrast to <link>S"</link>, the string stored by <link>$"</link> when
  interpreting is not transient.
</para><para>  The implementation is based on PFE code for <link>S"</link>.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$`</forthname>
    <forthstack>( [ccc&lt;`&gt;] -- $: str )</forthstack>
    <forthhints></forthhints>
    <stackline>$`		( [ccc&lt;`&gt;] -- $: str )</stackline>
   </forthdefinition>
   <comment><para>  Parse ccc delimited by ` (back-tick).  This is <link>"$""</link> with
  back tick instead of double quote as the delimiter.
  <ansref>"string-back-tick"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$CONSTANT</forthname>
    <forthstack>( "name" $: a$ -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$CONSTANT		( "name" $: a$ -- )</stackline>
   </forthdefinition>
   <comment><para>  Create a definition for "name" with the execution semantics
  "name" execution:	($: -- a$ )
</para><para>  It is assumed that the input string resides as a measured,
  unchanging string outside of string space.
  <ansref>"string-constant"</ansref>
</para><para>  For example:
</para><screen>    $" This is a sample string." $constant sample$
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$VARIABLE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$VARIABLE		( "name" -- )</stackline>
   </forthdefinition>
   <comment><screen> 
    "name" execution:	( -- dfa )
 
</screen><para>  Create an ordinary Forth variable and initialize it to the
  address of a fixed, external, measured representation of the
  empty string, such as that pushed onto the string stack by
  <link>EMPTY$</link>.  <ansref>"string-variable"</ansref>"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PARSE&gt;$</forthname>
    <forthstack>( [ccc&lt;char&gt;] char -- $: ccc$ )</forthstack>
    <forthhints></forthhints>
    <stackline>PARSE&gt;$	( [ccc&lt;char&gt;] char -- $: ccc$ )</stackline>
   </forthdefinition>
   <comment><para>  Parse the input stream up to the first occurrence of char,
  which is parsed away, and store the string as an external
  measured string.  If executing in compilation mode, append
  run-time semantics to the current definition that leaves the
  MSA on the string stack.  In interpretation mode, leave the
  MSA on the string stack, where the stored copy, unlike
  <link>PARSE>S</link>, is required to be nontransient.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>($:		( "ccc&lt;paren&gt;" -- )</stackline>
   </forthdefinition>
   <comment><para>  A synonym for <link>(</link>.  Immediate. 
  <ansref>"paren-string-colon"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$.</forthname>
    <forthstack>( $: a$ -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$.		( $: a$ -- )</stackline>
   </forthdefinition>
   <comment><para>  Display the string on the terminal.  If the system
  implementation of TYPE has its output vectored, $. uses the
  same vector. <ansref>"string-dot"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$2DROP</forthname>
    <forthstack>( $: a$ b$ --  )</forthstack>
    <forthhints></forthhints>
    <stackline>$2DROP	( $: a$ b$ --  )</stackline>
   </forthdefinition>
   <comment><para>  Drop the two topmost string stack entries, marking them as
  garbage if appropriate.  <ansref>"string-two-drop"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$2DUP</forthname>
    <forthstack>( $: a$ b$ -- a$ b$ a$ b$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$2DUP	( $: a$ b$ -- a$ b$ a$ b$ )</stackline>
   </forthdefinition>
   <comment><para>  Leave copies of the two topmost string stack entries.  The string
  values are not copied.  <ansref>"string-two-dupe"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$DEPTH</forthname>
    <forthstack>( -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>$DEPTH	( -- n )</stackline>
   </forthdefinition>
   <comment><para>  Leave the number of items on the string stack.
  <ansref>"string-depth"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$DROP</forthname>
    <forthstack>( $:  a$ -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$DROP	( $:  a$ -- )</stackline>
   </forthdefinition>
   <comment><para>  Drop the topmost string stack entry, marking it as garbage if
  it is initially bound to the top of the string stack.
  <ansref>"string-drop"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$DUP</forthname>
    <forthstack>( $: a$ -- a$ a$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$DUP	( $: a$ -- a$ a$ )</stackline>
   </forthdefinition>
   <comment><para>  Leave a copy of the topmost string stack entry.  The string
  value is not copied.  <ansref>"string-dupe"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$NIP</forthname>
    <forthstack>($: a$ b$ -- b$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$NIP	($: a$ b$ -- b$ )</stackline>
   </forthdefinition>
   <comment><para>  Drop the next to top item from the string stack.
  <ansref>"string-nip"</ansref>
</para><para>  NOTE:  Because of essential string  space bookkeeping, the
  system level implementation can be little more efficient than
  the high-level definition:
</para><screen>    : $NIP  $SWAP $DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$OVER</forthname>
    <forthstack>( $: a$ b$ -- a$ b$ a$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$OVER	( $: a$ b$ -- a$ b$ a$ )</stackline>
   </forthdefinition>
   <comment><para>  Leave a copy of the next most accessible string stack entry
  on top of the string stack.  The string value is not copied.
  <ansref>"string-over"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$PICK</forthname>
    <forthstack>( u $: au$ ... a0$ -- au$ ... a0$ au$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$PICK	( u $: au$ ... a0$ -- au$ ... a0$ au$ )</stackline>
   </forthdefinition>
   <comment><para>  Copy the u-th string stack entry to the top of the string
  stack.  The string value is not copied.  Throw an error if
  the input string stack does not have at least u+1 items. 
  <ansref>"string-pick"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$SWAP</forthname>
    <forthstack>( $: a$ b$ -- b$ a$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$SWAP	( $: a$ b$ -- b$ a$ )</stackline>
   </forthdefinition>
   <comment><para>  Exchange the two most accessible strings on the string stack.
  Throw an error if there are less than two strings on the
  stack.  Neither string value is copied.
  <ansref>"string-swap"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$EXCHANGE</forthname>
    <forthstack>( i j -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$EXCHANGE	( i j -- )</stackline>
   </forthdefinition>
   <comment><para> 		($: maxth$ ... minth$ ... -- minth$ ... maxth$ ... )
  Exchange the ith and jth strings on the string stack, where
  the top is the 0th.  Throw an error if there are not at least
  max[i,j] + 1 strings on the stack.  Neither string value is
  copied.
  <ansref>"string-exchange"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$S&gt;</forthname>
    <forthstack>( $: a$ -- S: a.s )</forthstack>
    <forthhints></forthhints>
    <stackline>$S&gt;		( $: a$ -- S: a.s )</stackline>
   </forthdefinition>
   <comment><para>  Drop a$ from the string stack and leave it as a ANS Forth
  string a.s, without copying.
  <ansref>"string-s-from"</ansref>
</para><para>  WARNING:  If a$ is a bound string, it may move or disappear
  at the next garbage collection, making a.s invalid.  This can
  be avoided by sandwiching sections of code where this could
  occur between $GC-OFF and $GC-ON.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$,S</forthname>
    <forthstack>( $: a$ -- S: a.s )</forthstack>
    <forthhints></forthhints>
    <stackline>$,S	( $: a$ -- S: a.s )</stackline>
   </forthdefinition>
   <comment><para>  Drop a$ from the string stack, copy it into data space as a
  measured string, and leave it as an ANS Forth string a.s.
  An error is thrown if the string length is larger than the
  system parameter <link>MAX_DATA_STR</link> (see <link>M,S</link>).
  <ansref>"string-comma-s"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$S@</forthname>
    <forthstack>( $: a$ -- a$ S: a.s )</forthstack>
    <forthhints></forthhints>
    <stackline>$S@ 	( $: a$ -- a$ S: a.s )</stackline>
   </forthdefinition>
   <comment><para>  Leave the string stack unchanged, and leave the string body
  address and length on the data stack. 
  <ansref>"string-s-fetch"</ansref>
</para><para>  WARNING:  If a$ is a bound string, it may move at the next
  garbage collection, making a.s invalid.  This can be avoided
  by sandwiching sections of code where this could occur
  between $GC-OFF and $GC-ON.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$TUCK</forthname>
    <forthstack>($: a$ b$ -- b$ a$ b$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$TUCK	($: a$ b$ -- b$ a$ b$ )</stackline>
   </forthdefinition>
   <comment><para>  Copy the top string stack item just below the second item.  The
  string value is not copied.  <ansref>"string-tuck"</ansref>
</para><para>  NOTE:  Because of essential string  space bookkeeping, the
  system level implementation can be little more efficient than
  the high-level definition:
</para><screen>    : $TUCK  $SWAP $OVER ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$TYPE</forthname>
    <forthstack>($: a$ -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$TYPE	($: a$ -- )</stackline>
   </forthdefinition>
   <comment><para>  Display the string on the terminal.  A deprecated <link>$.</link>
  synonym.  <ansref>"string-type"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;$S</forthname>
    <forthstack>( a.s -- $: a$ )</forthstack>
    <forthhints></forthhints>
    <stackline>&gt;$S		( a.s -- $: a$ )</stackline>
   </forthdefinition>
   <comment><para>  Push the external ANS Forth string a.s onto the string
  stack, without copying the string value into the string
  buffer.  It is an unchecked error if the Forth string a.s
  is not stored as an external measured string.
  <ansref>"to-string-s"</ansref>
</para><para>  WARNING: If the string value of a.s is actually in the
  string buffer and not external, the push operation may
  generate a garbage collection that invalidates its MSA.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;$S-COPY</forthname>
    <forthstack>( a.s -- $: a$ )</forthstack>
    <forthhints></forthhints>
    <stackline>&gt;$S-COPY	( a.s -- $: a$ )</stackline>
   </forthdefinition>
   <comment><para>  Copy the external string value whose body address and count
  are on the parameter stack into the string buffer and push it
  onto the string stack.  Errors are thrown if the count is
  larger than <link>MAX_MCOUNT</link>, if there is not enough room in string
  space, even after garbage collection, or if there is an
  unterminated string concatenation.  The input external string
  need not exist as a measured string. 
  <ansref>"to-string-s-copy"</ansref>
</para><para>  NOTE:  <link>MAX_MCOUNT</link> is the largest size the count field of a
  measured string can hold, e.g., 255, 64K-1, or 4,096M-1.  It
  is returned by:
</para><screen>    S" /DYNAMIC-STRING" ENVIRONMENT?
 
</screen><para>  WARNING: This word should not be used when the input string
  is a bound string because the copy operation may generate a
  garbage collection which invalidates its MSA.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$+</forthname>
    <forthstack>($: a$ -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$+		($: a$ -- )</stackline>
   </forthdefinition>
   <comment><para>  If a$ is the empty string, drop it and do nothing else.
</para><para>  In particular, do not start a new concatenation, which would
  lock string space against new nonconcatenating copies.
</para><para>  Otherwise append the string body to the end of the string
  currently being concatenated as the last string in the string
  buffer, and update its count field.  If there is no
  concatenating string, start one.  An error is thrown if the
  size of the combined string would be larger than
  <link>MAX_MCOUNT</link> or if there is not enough room in string space
  even after a garbage collection.
</para><para>  If garbage collection occurs, a$ remains valid even when
  it is in the string buffer.
</para><para>  When there is a concatenating string, concatenation is the
  only basic string operation that can copy a string into the
  string buffer.  <ansref>"string-plus"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>S+</forthname>
    <forthstack>( a.s -- )</forthstack>
    <forthhints></forthhints>
    <stackline>S+	( a.s -- )</stackline>
   </forthdefinition>
   <comment><para>  If a.s is the empty string, drop it and do nothing else.
</para><para>  Append the ANS Forth string body to the end of the string
  currently being concatenated as the last string in the string
  buffer, and update its count field.  If there is no
  concatenating string, start one.  An error is thrown if the
  size of the combined string would be larger than <link>MAX_MCOUNT</link>
  or if there is not enough room in string space even after a
  garbage collection.
</para><para>  <link>S+</link> is most commonly used on external strings, not
  assumed to exist as mstrings.  In contrast to <link>$+</link>,
  garbage collection could invalidate a.s if it is a dynamic
  string in the string buffer.  <link>S+</link> can be used in that
  situation if garbage collection is turned off with
  <link>$GC-OFF</link>.
</para><para>  When there is a concatenating string, concatenation is the
  only basic string operation that can copy a string into the
  string buffer.  <ansref>"s-plus"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PARSE-S+</forthname>
    <forthstack>( [ccc&lt;char&gt;] char -- )</forthstack>
    <forthhints></forthhints>
    <stackline>PARSE-S+	( [ccc&lt;char&gt;] char -- )</stackline>
   </forthdefinition>
   <comment><para>  Parse the input stream up to the first occurrence of char,
  which is parsed away.  If executing in compilation mode,
  append run-time semantics to the current definition that
  concatenates the characters parsed from the string. 
  Otherwise concatenate the characters. 
  <ansref>"parse-s-plus"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENDCAT</forthname>
    <forthstack>( -- $: cat$ | empty$ )</forthstack>
    <forthhints></forthhints>
    <stackline>ENDCAT	( -- $: cat$ | empty$ )</stackline>
   </forthdefinition>
   <comment><para>  If there is no concatenating string, do nothing but leave the
  empty string.  If there is, leave it as a string bound to the
  top of the string stack, and terminate concatenation,
  permitting normal copies into the string buffer. 
  <ansref>"end-cat"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$+"</forthname>
    <forthstack>( [ccc&lt;quote&gt;] -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$+"	( [ccc&lt;quote&gt;] -- )</stackline>
   </forthdefinition>
   <comment><para>  This word is immediate.  In compilation mode it appends
  run-time semantics to the current definition that
  concatenates the quoted string according to the specification
  for <link>$+</link>.  In interpretation mode it concatenates the
  string.  An error is thrown if the length of the quoted
  string is longer than the system parameter <link>MAX_DATA_STR</link>
  (see <link>M,S</link>).  <ansref>"string-plus-quote"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$+`</forthname>
    <forthstack>( [ccc&lt;backtick&gt;] -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$+`	( [ccc&lt;backtick&gt;] -- )</stackline>
   </forthdefinition>
   <comment><para>  The same as <link>$+"</link> but with back tick instead of double
  quote as delimiter.  <ansref>"string-plus-back-tick"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#$ARGS</forthname>
    <forthstack>( -- u )</forthstack>
    <forthhints></forthhints>
    <stackline>#$ARGS	( -- u )</stackline>
   </forthdefinition>
   <comment><para>  Leave the number of entries in the topmost string frame.
  Throw an error if the frame stack is empty.
  <ansref>"number-string-args"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$ARGS{</forthname>
    <forthstack>( arg1'$ ... argN'$ "arg1 ... argN &lt;}&gt;" --  )</forthstack>
    <forthhints></forthhints>
    <stackline>$ARGS{	 ( arg1'$ ... argN'$ "arg1 ... argN &lt;}&gt;" --  )</stackline>
   </forthdefinition>
   <comment><screen> 
     compilation: ( -- $: arg1$ ... argN$ )
</screen><para>  Immediate and compilation-only.
</para><para>  Copy the argument strings across lines to the string buffer,
  push them onto the string stack with "argN" the most
  accessible, and make them into the top compile-time string
  stack frame.  Compile the run-time code to make an argument
  frame out of the N most accessible run-time string stack
  entries.  Inform the system text interpreter that it should
  compile run-time code for any white-space delimited argument
  encountered in the text of the definition, that concatenates
  the corresponding string in the run-time frame.  At the
  semicolon terminating the definition, drop the compile-time
  argument frame and compile code to drop the run-time argument
  frame.
</para><para>  The code between <link>$ARGS{</link> ... <link>}</link> and the terminating
  semicolon is not allowed to make a net change in the string
  stack depth, because that would interfere with the automatic
  dropping of the string argument frame at the semicolon.
  <ansref>"string-args-brace"</ansref>
</para><para>  Syntax for defining a string macro GEORGE:
</para><screen> 
      : george  ($: a$ b$ c$ -- cat$ )
        $ARGS{ arg1 arg2 arg3 }
        cat" This is arg1:  " arg1 cat" ." ENDCAT $. ;
 
</screen><para>  The blank following the last argument is required.  For a
  macro with no arguments, <link>$ARGS{ }</link> does nothing but add
  useless overhead and should be omitted.  Two of the
  arguments in this example are ignored and could have been
  left out.  Note that <link>ENDCAT</link> would not be legal in this
  word without something like <link>$.</link> to remove the concatenated
  string from the string stack before the terminating
  semicolon.  It is normal to use an <link>$ARGS{ }</link> word as a step
  in a concatenation that is terminated elsewhere.
</para><para>  Sample syntax using the string macro <link>george</link>:
</para><screen> 
      $" bill"  $" sue"  $" marie"  george $.
 
</screen><para>  The resulting display is:
</para><screen> 
      This is arg1:  bill.
 
</screen><para>  NOTE: Macro argument labels must be distinct from each other
  and from any local labels that appear in the same definition,
  and there is no check for that.
</para><para>  NOTE: At the moment the semantics of <link>$ARGS{</link> is undefined
  before <link>DOES></link>.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$FRAME</forthname>
    <forthstack>( u -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$FRAME	( u -- )</stackline>
   </forthdefinition>
   <comment><para>  Push the description of a string stack frame starting at the
  top of the string stack and containing u entries onto the
  string frame stack.  Errors are thrown if the frame stack
  would overflow or if the depth of the string stack above the
  top frame, if there is one, is less than u.  The value u = 0
  is allowed.  <ansref>"string-frame"</ansref>
</para><para>  NOTE: This implementation pushes u and the string stack
  pointer onto the frame stack.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$FRAME-DEPTH</forthname>
    <forthstack>( -- u )</forthstack>
    <forthhints></forthhints>
    <stackline>$FRAME-DEPTH	( -- u )</stackline>
   </forthdefinition>
   <comment><para>  Leave the number of string frames currently on the string
  frame stack.  <ansref>"string-frame-depth"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DROP-$FRAME</forthname>
    <forthstack>($: frame*$ i*$ -- i*s )</forthstack>
    <forthhints></forthhints>
    <stackline>DROP-$FRAME	 ($: frame*$ i*$ -- i*s )</stackline>
   </forthdefinition>
   <comment><para>  Drop the topmost string frame from the string frame stack,
  and the corresponding strings, frame*$, from the string
  stack.  An error is thrown if either stack would underflow. 
  The cases where the frame has zero entries on the string
  stack and/or there are zero or more items on the string stack
  above the top frame item are handled properly.
  <ansref>"drop-string-frame"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FIND-$ARG</forthname>
    <forthstack>( s -- u true | false )</forthstack>
    <forthhints></forthhints>
    <stackline>FIND-$ARG	( s -- u true | false )</stackline>
   </forthdefinition>
   <comment><para>  Leave true and its index u in the top string frame if the
  ANS Forth string matches an element of the frame, else leave
  false.  The index of the top frame element is zero.
  <ansref>"find-string-arg"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TH-$ARG</forthname>
    <forthstack>( u -- $: arg$ )</forthstack>
    <forthhints></forthhints>
    <stackline>TH-$ARG	( u -- $: arg$ )</stackline>
   </forthdefinition>
   <comment><para>  Leave the u-th string in the topmost string frame, where the
  index u of the top element is zero. Throw an error if the
  frame stack is empty or if the top frame contains less than
  u+1 strings. <ansref>"th-string-arg"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(DROP-$FRAME)	( -- )</stackline>
   </forthdefinition>
   <comment><para>  Cleanup code for the end of a definition that uses
  <link>$ARGS{</link>.  <link>;</link>-semicolon should be overloaded to compile
  it automatically if dynamic string arguments were in use.
  <ansref>"paren-drop-string-frame-paren"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$POP</forthname>
    <forthstack>( $:  a$ -- s: a$)</forthstack>
    <forthhints></forthhints>
    <stackline>$POP	( $:  a$ -- s: a$)</stackline>
   </forthdefinition>
   <comment><para>  Abort if the string stack would underflow when popped.
</para><para>  Otherwise pop the top of the string stack and push it onto
  the data stack.
</para><para>  If the string is in the current string space and initially
  bound to the top of the string stack, mark it as garbage by
  setting its back link to <link>NULL</link> and set the garbage flag.
</para><para>  This word violates the rule that only ANS Forth strings
  should appear on the data stack, and so is under the hood.
  <ansref>"string-pop"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$PUSH-EXT</forthname>
    <forthstack>( a$ -- $: a$ )</forthstack>
    <forthhints></forthhints>
    <stackline>$PUSH-EXT  	( a$ -- $: a$ )</stackline>
   </forthdefinition>
   <comment><para>  Pop an external mstring address from the data stack and push
  it onto the string stack after checking for room, invoking
  garbage collection if necessary.  Not to be used with a
  dynamic string because a garbage collection can invalidate
  its address.
</para><para>  This word violates the normal rule that only ANS Forth
  strings should appear on the data stack, and so is under the
  hood.
  <ansref>"string-push-ext"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$BREAKP@</forthname>
    <forthstack>( -- $stack.break.addr )</forthstack>
    <forthhints></forthhints>
    <stackline>$BREAKP@	( -- $stack.break.addr )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"string-break-p-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$BUFP@</forthname>
    <forthstack>( -- $buffer.addr )</forthstack>
    <forthhints></forthhints>
    <stackline>$BUFP@	( -- $buffer.addr )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"string-buf-p-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$FBREAKP@</forthname>
    <forthstack>( -- frame.stack.break.addr )</forthstack>
    <forthhints></forthhints>
    <stackline>$FBREAKP@	( -- frame.stack.break.addr )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"string-f-break-p-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$FSP0@</forthname>
    <forthstack>( -- initial.frame.stack.top.addr )</forthstack>
    <forthhints></forthhints>
    <stackline>$FSP0@	( -- initial.frame.stack.top.addr )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"string-f-s-p-zero-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$FSP@</forthname>
    <forthstack>( -- frame.stack.top.addr )</forthstack>
    <forthhints></forthhints>
    <stackline>$FSP@	( -- frame.stack.top.addr )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"string-f-s-p-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$SP0@</forthname>
    <forthstack>( -- initial.string.stack.top.addr )</forthstack>
    <forthhints></forthhints>
    <stackline>$SP0@	( -- initial.string.stack.top.addr )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"string-s-p-zero-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$SP@</forthname>
    <forthstack>( -- string.stack.top.addr )</forthstack>
    <forthhints></forthhints>
    <stackline>$SP@	( -- string.stack.top.addr )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"string-s-p-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/$SFRAME-ITEM</forthname>
    <forthstack>( -- frame.stack.item.size )</forthstack>
    <forthhints></forthhints>
    <stackline>/$SFRAME-ITEM	( -- frame.stack.item.size )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"slash-string-frame-item"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/$SFRAME-STACK</forthname>
    <forthstack>( -- max.frame.stack.size )</forthstack>
    <forthhints></forthhints>
    <stackline>/$SFRAME-STACK	( -- max.frame.stack.size )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"slash-string-frame-stack"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/$SPACE-HEADER</forthname>
    <forthstack>( -- $space.header.size )</forthstack>
    <forthhints></forthhints>
    <stackline>/$SPACE-HEADER	( -- $space.header.size )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"slash-string-space-header"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>0$SPACE</forthname>
    <forthstack>( $space.addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>0$SPACE	( $space.addr -- )</stackline>
   </forthdefinition>
   <comment><para>  Clear the string buffer, string stack, and string frame stack
  in the string space starting at space.addr.  Any string
  variables holding strings in the string buffer are left
  pointing into limbo.  This may be executed with the string
  space in an invalid state, as long as the <link>/$BUF</link> and
  <link>MAX-#$FRAMES</link> fields of its string space structure are
  intact. <ansref>"zero-string-space"</ansref>
</para><para>  NOTE: This word does not zero fill the string buffer.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CAT$P@</forthname>
    <forthstack>( -- cat$.msa | 0 )</forthstack>
    <forthhints></forthhints>
    <stackline>CAT$P@	( -- cat$.msa | 0 )</stackline>
   </forthdefinition>
   <comment><para>  <ansref>"cat-string-fetch"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IN-$BUFFER?</forthname>
    <forthstack>( msa -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>IN-$BUFFER?	( msa -- flag )</stackline>
   </forthdefinition>
   <comment><para>  Leave true if the mstring is in the string buffer.
  <ansref>"in-string-buffer-question"</ansref>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT DSTRINGS-EXT</forthname>
    <forthstack>( -- datecoded-version )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT DSTRINGS-EXT" ( -- datecoded-version )</stackline>
   </forthdefinition>
   <comment><para>  an <link>ENVIRONMENT</link> constant to be checked with <link>ENVIRONMENT?</link>
  the value is currently encoded as a datecode with a decimal
  printout of format like <link>YYMMDD</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT /SCOPY</forthname>
    <forthstack>( -- MAX_DATA_STR )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT /SCOPY" ( -- MAX_DATA_STR )</stackline>
   </forthdefinition>
   <comment><para>  an <link>ENVIRONMENT</link> constant to be checked with <link>ENVIRONMENT?</link>
  returns the configuration value of <link>MAX_DATA_STR</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT /DYNAMIC-STRING</forthname>
    <forthstack>( -- MAX_MCOUNT )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT /DYNAMIC-STRING" ( -- MAX_MCOUNT )</stackline>
   </forthdefinition>
   <comment><para>  an <link>ENVIRONMENT</link> constant to be checked with <link>ENVIRONMENT?</link>
  returns the configuration value of <link>MAX_MCOUNT</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/edit-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>EDIT-BLOCK</forthname>
    <forthstack>( blk -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EDIT-BLOCK ( blk -- )</stackline>
   </forthdefinition>
   <comment><para>  start the internal block-editor on the assigned block
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>EDIT-TEXT name ( -- )</stackline>
   </forthdefinition>
   <comment><para>  start an external <link>EDITOR</link> with the specified filename
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EDIT-ERROR</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EDIT-ERROR ( -- )</stackline>
   </forthdefinition>
   <comment><para>  if an error occured, this routine can be called to invoke
  an appropriate <link>EDITOR</link> (see also <link>EDIT-BLOCK</link>)
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/engine-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>[ANS]</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> immediate</forthhints>
    <stackline>[ANS] ( -- ) immediate</stackline>
   </forthdefinition>
   <comment><para>  the <link>VOCABULARY</link> that holds only the standardwords.
  see <link>FORTH</link> for a definition that will search-also point to <link>ANS'</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FORTH</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>FORTH ( -- )</stackline>
   </forthdefinition>
   <comment><para>  in pfe it is not actually a <link>VOCABULARY</link> anymore but
  behaves likewise. it will fetch the <link>VALUE</link> from <link>FORTH-WORDLIST</link>
  and execute it as if it were a <link>VOCABULARY</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXTENSIONS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EXTENSIONS ( -- )</stackline>
   </forthdefinition>
   <comment><para>  in pfe it is not actually a <link>VOCABULARY</link> anymore but
  behaves likewise. it will fetch the <link>VALUE</link> from <link>EXTRA-WORDLIST</link>
  and execute it as if it were a <link>VOCABULARY</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/engine-sub.c">
  <forthheader>
   <forthdefinition>
    <forthname>INTERPRET-FIND</forthname>
    <forthstack>( CS: dest* -- dest* )</forthstack>
    <forthhints> executes ( -- ) experimental</forthhints>
    <stackline>INTERPRET-FIND ( CS: dest* -- dest* ) executes ( -- ) experimental</stackline>
   </forthdefinition>
   <comment><para>   check the next word from <link>QUERY</link> and try to look it up
   with <link>FIND</link> - if found then execute the token right away
   and branch out of the loop body (usually do it <link>AGAIN</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>INTERPRET-NUMBER</forthname>
    <forthstack>( CS: dest* -- dest* )</forthstack>
    <forthhints> executes ( -- ) experimental</forthhints>
    <stackline>INTERPRET-NUMBER ( CS: dest* -- dest* ) executes ( -- ) experimental</stackline>
   </forthdefinition>
   <comment><para>   check the next word from <link>QUERY</link> and try to parse it up
   with => ?NUMBER - if parseable then postpone the number for execution
   and branch out of the loop body (usually do it <link>AGAIN</link> )
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/environ-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>REQUIRED</forthname>
    <forthstack>( ... str-ptr str-len -- ??? )</forthstack>
    <forthhints></forthhints>
    <stackline>REQUIRED ( ... str-ptr str-len -- ??? )</stackline>
   </forthdefinition>
   <comment><para>  the filename argument is loaded via <link>INCLUDED</link> as
  an extension package to the current system. The filename
  is registered in the current <link>ENVIRONMENT</link> so that it is
  only <link>INCLUDED</link> once (!!) if called multiple times via
  <link>REQUIRED</link> or <link>REQUIRES</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REQUIRES</forthname>
    <forthstack>( ... "file-name" -- ... )</forthstack>
    <forthhints></forthhints>
    <stackline>REQUIRES ( ... "file-name" -- ... )</stackline>
   </forthdefinition>
   <comment><para>  old variant of Forth200x <link>REQUIRE</link> name
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REQUIRE</forthname>
    <forthstack>( ... "file-name" -- ... )</forthstack>
    <forthhints></forthhints>
    <stackline>REQUIRE ( ... "file-name" -- ... )</stackline>
   </forthdefinition>
   <comment><para>  parses the next <link>WORD</link> and passes it to <link>REQUIRED</link>
  this is the self-parsing version of <link>REQUIRED</link> and
  it does parrallel <link>INCLUDE</link> w.r.t. <link>INCLUDED</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ENVIRONMENT ( -- )</stackline>
   </forthdefinition>
   <comment><para>  execute the <link>VOCABULARY</link> runtime for the <link>ENVIRONMENT-WORDLIST</link>
</para><screen>  : ENVIRONMENT  ENVIRONMENT-WORDLIST CONTEXT ! ;
  ' ENVIRONMENT  ALIAS [ENV] IMMEDIATE
</screen><para>  see newstyle <link>ENVIRONMENT?</link> 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT-WORDLIST</forthname>
    <forthstack>( -- wid )</forthstack>
    <forthhints></forthhints>
    <stackline>ENVIRONMENT-WORDLIST ( -- wid )</stackline>
   </forthdefinition>
   <comment><para>  return the <link>WORDLIST</link> id of the <link>ENVIRONMENT</link> so
  it could be passed to <link>CURRENT</link> (via <link>SET-CURRENT</link>)
</para><screen>  WORDLIST VALUE ENVIRONMENT-WORDLIST ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT?</forthname>
    <forthstack>( a1 n1 -- false | ?? true )</forthstack>
    <forthhints></forthhints>
    <stackline>ENVIRONMENT? ( a1 n1 -- false | ?? true )</stackline>
   </forthdefinition>
   <comment><para>  check the environment for a property, usually
  a condition like questioning the existance of 
  specified wordset, but it can also return some
  implementation properties like "WORDLISTS"
  (the length of the search-order) or "#LOCALS"
  (the maximum number of locals) 
</para><para>  Here it implements the environment queries as a <link>SEARCH-WORDLIST</link> 
  in a user-visible vocabulary called <link>ENVIRONMENT</link>
</para><screen>  : ENVIRONMENT?
    ['] ENVIRONMENT &gt;WORDLIST SEARCH-WORDLIST
    IF  EXECUTE TRUE ELSE  FALSE THEN ;
 
</screen><para>  special extension: a search for CORE will also find a definition
  of CORE-EXT or CORE-EXT-EXT or CORE-EXT-EXT-EXT - it just has to
  be below the ansi-standard maximum length of 31 chars.
</para><para>  if a name like "dstrings-ext" is given, and no such entry
  can be found, then envQ will try to trigger a <link>(LOADM)</link> of
  that module, in the hope that this implicit-load does in fact
  define the answer. Use with care, it's a very new feature.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NEEDS</forthname>
    <forthstack>( name -- )</forthstack>
    <forthhints></forthhints>
    <stackline>NEEDS ( name -- )</stackline>
   </forthdefinition>
   <comment><para>
  A self-parsing variant of an environment-query check. It is similar
  to a simulation like
</para><screen> 
  : NEEDS PARSE-WORD 2DUP ENVIRONMENT? 
    IF DROP ( extra value ) 2DROP ( success - be silent )
    ELSE TYPE ." not available " CR THEN ;
 
</screen><para>  however that would only match those worset-envqueries which return a
  single extra item under the uppermost TRUE flag in the success case.
  Instead it works more like
</para><screen> 
  : NEEDS PARSE-WORD 2DUP ENVIRONMENT-WORDLIST SEARCH-WORDLIST
    IF 2DROP ( success - be silent and just drop the parsed word )
    ELSE TYPE ." not available " CR THEN ;
 
</screen><para>  however we add the same extension as in <link>ENVIRONMENT</link>? as that
  it can automatically load a wordset module to fullfil a query
  that looks like "[wordsetname]-ext". Therefore, the following
  two lines are pretty much identical:
</para><screen> 
  LOADM floating
  NEEDS floating-ext
 
</screen><para>  the difference between the two: if somebody did provide a forth
  level implementation of floating-ext then that implementation might
  have registered a hint "floating-ext" in the environment-wordlist.
  This extra-hint will inhibit loading of the binary module even if
  it exists and not been loaded so far. The <link>LOADM</link> however will
  not check the <link>ENVIRONMENT-WORDLIST</link> and only check its loadlist
  of binary wordset modules in the system.
</para><para>
  It is therefore recommended to use <link>NEEDS</link> instead of <link>LOADM</link>
  unless you know you want the binary module, quickly and uncondtionally.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT HOST-SYSTEM</forthname>
    <forthstack>( -- str len )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT HOST-SYSTEM" ( -- str len )</stackline>
   </forthdefinition>
   <comment><para>  returns the HOST-SYTEM type, can be used to distinguish
  different runtime environments. (see <link>.STATUS</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT CASE-SENSITIVE?</forthname>
    <forthstack>( -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT CASE-SENSITIVE?" ( -- flag )</stackline>
   </forthdefinition>
   <comment><para>  Classifying Forth systems 7
  by J Thomas on comp.lang.forth, 06.Feb.2001
  -------------------------------------------
  Thomas' spec did not reveal whether to return the
  system-wide LOWER_CASE or the wordlist-local NOCASE-state.
  For now, it returns the wordlist-local state.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT FORTH-NAME</forthname>
    <forthstack>( -- caddr len )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT FORTH-NAME" ( -- caddr len )</stackline>
   </forthdefinition>
   <comment><para>  Classifying Forth systems 6
  by J Thomas on comp.lang.forth, 03.Feb.2001
  -------------------------------------------
</para><para>
  The string should be a name, like ProForth or SwiftForth
</para><para>
  -------------------------------------------
  Thomas' spec did not reveal whether to return a
  longname or shortname.
  For now, it returns the short name.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT FORTH-VERSION</forthname>
    <forthstack>( -- caddr len )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT FORTH-VERSION" ( -- caddr len )</stackline>
   </forthdefinition>
   <comment><para>  Classifying Forth systems 6
  by J Thomas on comp.lang.forth, 03.Feb.2001
  -------------------------------------------
</para><para>
  The string will give a version number, whatever the
  implementor chooses.
</para><para>
  -------------------------------------------
  Thomas' spec did not reveal whether to return a
  compact or talkative version spec.
  For now, it returns the long version-string.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT FORTH-CONTACT</forthname>
    <forthstack>( -- caddr len )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT FORTH-CONTACT" ( -- caddr len )</stackline>
   </forthdefinition>
   <comment><para>  Classifying Forth systems 6
  by J Thomas on comp.lang.forth, 03.Feb.2001
  -------------------------------------------
</para><para>
  The string will give a name-and-address or website etc.
</para><para>
  -------------------------------------------
  Thomas' spec did not reveal whether to return a
  URL-form and a readable free-form. 
  For now, it returns the URL-form of the sourceforge project.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/exception-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>CATCH</forthname>
    <forthstack>( catch-xt* -- 0 | throw#! )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CATCH ( catch-xt* -- 0 | throw#! ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  execute the given execution-token and catch
  any exception that can be caught therein.
  software can arbitrarily raise an exception
  using <link>THROW</link> - the value 0 means there
  was no exception, other denote implementation
  dependent exception-codes.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>THROW</forthname>
    <forthstack>( throw#! -- [THROW] | throw# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>THROW ( throw#! -- [THROW] | throw# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  raise an exception - it will adjust the depth
  of all stacks and start interpreting at the point 
  of the latest <link>CATCH</link> <br>
  if n is null nothing happens, the -1 (ie. <link>FALSE</link> )
  is the raise-code of <link>ABORT</link> - the other codes
  are implementation dependent and will result in
  something quite like <link>ABORT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ABORT</forthname>
    <forthstack>( -- [THROW] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ABORT ( -- [THROW] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  throw - cleanup some things and go back to the QUIT routine
</para><screen>  : ABORT -1 THROW ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((ABORT")) ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>ABORT"</link> what"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ABORT"</forthname>
    <forthstack>( [string&lt;"&gt;] -- [THROW] )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>'ABORT"' ( [string&lt;"&gt;] -- [THROW] ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  throw like <link>ABORT</link> but print an additional error-message
  to stdout telling what has happened.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NEXT-EXCEPTION</forthname>
    <forthstack>( -- throw#!* )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>NEXT-EXCEPTION ( -- throw#!* ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>   used for runtime allocation of a new throw id.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(EXCEPTION-STRING: ( exception# [description&lt;closeparen&gt;] -- )</stackline>
   </forthdefinition>
   <comment><para>  append a node with the given id and a pointer to an 
  extern zstring to the <link>NEXT-EXCEPTION</link> chain-list.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/facility-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>AT-XY</forthname>
    <forthstack>( col# row# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>AT-XY ( col# row# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  move the cursor position to the given row and column
  of the screen. If the output device is not a terminal
  this will have no effect but can still send an
  escape sequence.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>KEY?</forthname>
    <forthstack>( -- key-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>KEY? ( -- key-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  if a character is available from the keyboard, return true.
  The <link>KEY</link> word will retrieve the actual character.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EKEY</forthname>
    <forthstack>( -- key-code# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>EKEY ( -- key-code# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return a keyboard event, the encoding may differ, esp.
  that it can contain special keys.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EKEY&gt;CHAR</forthname>
    <forthstack>( key-code# -- key-code# 0 | char# true! )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>EKEY&gt;CHAR ( key-code# -- key-code# 0 | char# true! ) [ANS]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EKEY?</forthname>
    <forthstack>( -- ekey-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>EKEY? ( -- ekey-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  check if a character is available from the keyboard
  to be received - unlike <link>KEY</link>? it will not discard
  non-visible codes.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EMIT?</forthname>
    <forthstack>( -- emit-flag )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>EMIT? ( -- emit-flag ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  if <link>EMIT</link> can safely output characters without
  blocking the forth by waiting for an indefinite time.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MS</forthname>
    <forthstack>( milliseconds# -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>MS ( milliseconds# -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  wait at least the specified milliseconds
  (suspend the forth tasklet)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TIME&amp;amp;DATE</forthname>
    <forthstack>( -- sec# min# hrs# day# month# year# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>TIME&amp;amp;DATE ( -- sec# min# hrs# day# month# year# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the broken down current time
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PAGE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>PAGE ( -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  <link>CLRSCR</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/facility-mix.c">
  <forthheader>
   <forthdefinition>
    <forthname>#!</forthname>
    <forthstack>( "...&lt;eol&gt;" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>#! ( "...&lt;eol&gt;" -- )</stackline>
   </forthdefinition>
   <comment><para>  ignores the rest of the line,
  defining `#!' is used to support forth scripts
  executed by the unix kernel
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CLOCK@</forthname>
    <forthstack>( --- clock-ticks# )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>CLOCK@ ( --- clock-ticks# ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  return clock(2) - the number of clocks of this process.
  To get the number of seconds, divide by <link>CLOCKS_PER_SEC</link>
  as represented in the <link>ENVIROMENT</link> for a hosted forth system.
  A similar scheme is used by <link>MS@</link> to compute the clock time
  rounded to milliseconds (named in similarity with <link>MS</link> sleep).
</para><para>
  Remember that the process clock will wrap around at some point,
  therefore only use difference values between two clock reads.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>GETTIMEOFDAY</forthname>
    <forthstack>( -- milliseconds# epochseconds# )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>GETTIMEOFDAY ( -- milliseconds# epochseconds# ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  returns SVR/BSD gettimeofday(2).
  Incompatible with 16-bit systems as the numbers can not be properly
  represented, hence <link>TIME&DATE</link> is more portable.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT CLOCKS_PER_SEC</forthname>
    <forthstack>( -- tick-count# )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT CLOCKS_PER_SEC" ( -- tick-count# ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  the system's scheduler heartbeat clock
  (also known as jiffies or simply HZ)
  for every function that expects time-values in ticks.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MS@</forthname>
    <forthstack>( -- milliseconds# )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>MS@ ( -- milliseconds# ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  elapsed time since start of process (or system) - in millseconds.
  The granularity is per clock ticks as per <link>ENVIRONMENT CLOCKS_PER_SEC</link>
  For the current wall clock in milliseconds, ask <link>GETTIMEOFDAY</link>.
</para><para>
  Remember that the process clock will wrap around at some point,
  therefore only use difference values between two clock reads.
  Also note that on many desktop systems the process scheduler ticks
  per 1/100s or 1/60s so that the difference of two continuous reads
  of the process clock will show steps of 10 to 16 milliseconds.
</para><para>
  see also <link>CLOCK@</link> and <link>MS</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/file-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>BIN</forthname>
    <forthstack>( access-mode# -- access-mode#' )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>BIN ( access-mode# -- access-mode#' ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  modify the give file access-mode to be a binary-mode
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CLOSE-FILE</forthname>
    <forthstack>( some-file* -- some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CLOSE-FILE ( some-file* -- some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  close the file and return the status-code
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CREATE-FILE</forthname>
    <forthstack>( name-ptr name-len open-mode# -- name-file* name-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>CREATE-FILE ( name-ptr name-len open-mode# -- name-file* name-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  create the file with the given name and open
  it - returns the file id and a status code.
  A code of zero means success. An existing file
  of the same name is truncated upon open.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DELETE-FILE</forthname>
    <forthstack>( name-ptr name-len -- name-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>DELETE-FILE ( name-ptr name-len -- name-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  delete the named file and return a status code
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-POSITION</forthname>
    <forthstack>( some-file* -- p,pos# some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FILE-POSITION ( some-file* -- p,pos# some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the current position in the file and
  return a status code. A code of zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-SIZE</forthname>
    <forthstack>( some-file* -- s,size# some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FILE-SIZE ( some-file* -- s,size# some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  return the current size of the file and
  return a status code. A code of zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>INCLUDE-FILE</forthname>
    <forthstack>( some-file* -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>INCLUDE-FILE ( some-file* -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  <link>INTERPRET</link> the given file
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>INCLUDED</forthname>
    <forthstack>( name-ptr name-len -- )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>INCLUDED ( name-ptr name-len -- ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  open the named file and then <link>INCLUDE-FILE</link>
  see also the interactive <link>INCLUDE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OPEN-FILE</forthname>
    <forthstack>( name-ptr name-len open-mode# -- name-file* name-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>OPEN-FILE ( name-ptr name-len open-mode# -- name-file* name-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  open the named file with mode. returns the
  file id and a status code. A code of zero
  means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>READ-FILE</forthname>
    <forthstack>( buf-ptr buf-len some-file* -- buf-count some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>READ-FILE ( buf-ptr buf-len some-file* -- buf-count some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fill the given string buffer with characters
  from the buffer. A status code of zero means
  success and the returned count gives the
  number of bytes actually read. If an error
  occurs the number of already transferred bytes 
  is returned.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>READ-LINE</forthname>
    <forthstack>( buf-ptr buf-len some-file* -- buf-count buf-flag some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>READ-LINE ( buf-ptr buf-len some-file* -- buf-count buf-flag some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  fill the given string buffer with one line
  from the file. A line termination character
  (or character sequence under WIN/DOS) may
  also be placed in the buffer but is not
  included in the final count. In other respects
  this function performs a <link>READ-FILE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REPOSITION-FILE</forthname>
    <forthstack>( o,offset# some-file* -- some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>REPOSITION-FILE ( o,offset# some-file* -- some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  reposition the file offset - the next <link>FILE-POSITION</link>
  would return o.offset then. returns a status code where zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RESIZE-FILE</forthname>
    <forthstack>( s,size# some-file* -- some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>RESIZE-FILE ( s,size# some-file* -- some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  resize the give file, returns a status code where zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WRITE-FILE</forthname>
    <forthstack>( buf-ptr buf-len some-file* -- some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>WRITE-FILE ( buf-ptr buf-len some-file* -- some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  write characters from the string buffer to a file,
  returns a status code where zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WRITE-LINE</forthname>
    <forthstack>( buf-ptr buf-len some-file* -- some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>WRITE-LINE ( buf-ptr buf-len some-file* -- some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  write characters from the string buffer to a file,
  and add the line-terminator to the end of it.
  returns a status code.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-STATUS</forthname>
    <forthstack>( file-ptr file-len -- file-subcode# file-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FILE-STATUS ( file-ptr file-len -- file-subcode# file-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  check the named file - if it exists
  the status errno code is zero. The status subcode
  is implementation-specific and usually matches the
  file access permission bits of the filesystem.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FLUSH-FILE</forthname>
    <forthstack>( some-file* -- some-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FLUSH-FILE ( some-file* -- some-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  flush all unsaved buffers of the file to disk.
  A status code of zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RENAME-FILE</forthname>
    <forthstack>( oldname-ptr oldname-len newname-ptr newname-len -- newname-errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>RENAME-FILE ( oldname-ptr oldname-len newname-ptr newname-len -- newname-errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  rename the file named by "oldname" to the name of "newname"
  returns a status-code where zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R/O</forthname>
    <forthstack>( -- readonly-mode# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>R/O ( -- readonly-mode# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  a bitmask for <link>OPEN-FILE</link> ( <link>R/O</link> <link>R/W</link> <link>W/O</link> <link>BIN</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>W/O</forthname>
    <forthstack>( -- writeonly-mode# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>W/O ( -- writeonly-mode# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  a bitmask for <link>OPEN-FILE</link> or <link>CREATE-FILE</link> ( <link>R/O</link> <link>R/W</link> <link>W/O</link> <link>BIN</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R/W</forthname>
    <forthstack>( -- readwrite-mode# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>R/W ( -- readwrite-mode# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  a bitmask for <link>OPEN-FILE</link> or <link>CREATE-FILE</link> ( <link>R/O</link> <link>R/W</link> <link>W/O</link> <link>BIN</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT MAX-FILES</forthname>
    <forthstack>( -- files-max )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>"ENVIRONMENT MAX-FILES" ( -- files-max ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  the number of opened file-ids allowed during compilation.
  portable programs can check this with <link>ENVIRONMENT</link>?
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/file-mix.c">
  <forthheader>
   <forthdefinition>
    <forthname>INCLUDE</forthname>
    <forthstack>( "filename" -- ??? )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>INCLUDE ( "filename" -- ??? ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  load the specified file, see also <link>LOAD"</link> filename"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>COPY-FILE</forthname>
    <forthstack>( src-ptr src-len dst-ptr dst-len -- copy-errno# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>COPY-FILE ( src-ptr src-len dst-ptr dst-len -- copy-errno# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  like <link>RENAME-FILE</link>, copies the file from src-name to dst-name
  and returns an error-code or null
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MOVE-FILE</forthname>
    <forthstack>( src-ptr src-len dst-ptr dst-len -- move-errno# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>MOVE-FILE ( src-ptr src-len dst-ptr dst-len -- move-errno# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  like <link>RENAME-FILE</link>, but also across-volumes <br>
  moves the file from src-name to dst-name and returns an
  error-code or null
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-R/W</forthname>
    <forthstack>( buffer* use-block# flag? some-file* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-R/W ( buffer* use-block# flag? some-file* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  like FIG-Forth <code> R/W </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-BLOCK</forthname>
    <forthstack>( use-block# some-file* -- buffer* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-BLOCK ( use-block# some-file* -- buffer* ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-BUFFER</forthname>
    <forthstack>( use-block# some-file* -- buffer* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-BUFFER ( use-block# some-file* -- buffer* ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-EMPTY-BUFFERS</forthname>
    <forthstack>( some-file* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-EMPTY-BUFFERS ( some-file* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-FLUSH</forthname>
    <forthstack>( some-file* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-FLUSH ( some-file* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate      : FILE-FLUSH DUP FILE-SAVE-BUFFERS FILE-EMTPY-BUFFERS ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-LIST</forthname>
    <forthstack>( use-block# some-file* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-LIST ( use-block# some-file* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-LOAD</forthname>
    <forthstack>( use-block# some-file* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-LOAD ( use-block# some-file* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-SAVE-BUFFERS</forthname>
    <forthstack>( some-file* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-SAVE-BUFFERS ( some-file* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-THRU</forthname>
    <forthstack>( lo-block# hi-block# some-file* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-THRU ( lo-block# hi-block# some-file* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>THRU</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-UPDATE</forthname>
    <forthstack>( some-file* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FILE-UPDATE ( some-file* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/floating-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>( f: a -- n,n )</stackline>
   </forthdefinition>
   <comment><para>  b is the integer representation of a
</para><para>
  we use truncation towards zero.
  compare with <link>F>S</link> and its <link>"FROUND>S"</link> / <link>"FTRUNC>S"</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>INTERPRET-FLOAT</forthname>
    <forthstack>( CS: dest* -- dest* )</forthstack>
    <forthhints> executes ( -- F: f# ) experimental</forthhints>
    <stackline>INTERPRET-FLOAT ( CS: dest* -- dest* ) executes ( -- F: f# ) experimental</stackline>
   </forthdefinition>
   <comment><para>   check the next word from <link>QUERY</link> and try to parse it as a
   floating number - if parseable then postpone the value on the
   floating stack and branch out of the loop body (usually do it <link>AGAIN</link> )
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/floating-mix.c">
  <forthheader>
   <forthdefinition>
    <forthname>FP@</forthname>
    <forthstack>( -- addr )</forthstack>
    <forthhints></forthhints>
    <stackline>FP@ ( -- addr )</stackline>
   </forthdefinition>
   <comment><para>  returns the floating point stack pointer 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FP!</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>FP! ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>  sets the floating point stack pointer -
  this is the inverse of <link>FP@</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F?</forthname>
    <forthstack>( f: a b -- s: a==b )</forthstack>
    <forthhints></forthhints>
    <stackline>F? ( f: a b -- s: a==b )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F&lt;&gt;</forthname>
    <forthstack>( f: a b -- s: a!=b )</forthstack>
    <forthhints></forthhints>
    <stackline>F&lt;&gt; ( f: a b -- s: a!=b )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>S&gt;F</forthname>
    <forthstack>( n -- f: x )</forthstack>
    <forthhints></forthhints>
    <stackline>S&gt;F  ( n -- f: x )</stackline>
   </forthdefinition>
   <comment><para>  it's inverse is <link>F>S</link> - convert a cell parameter to floating-point.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FTRUNC&gt;S</forthname>
    <forthstack>(f: x -- s: n )</forthstack>
    <forthhints></forthhints>
    <stackline>FTRUNC&gt;S  (f: x -- s: n )</stackline>
   </forthdefinition>
   <comment><para>
  The word <link>F>S</link> was sometimes defined with a different behavior 
  than <link>FTRUNC>S</link> which is the type-cast behaviour of C according 
  to C99 section 6.3.1.4 - truncation would also match the ANS-Forth
  specification for <link>F>D</link>.
</para><para>
  Some systems used <link>F>S</link> defined to <link>FROUND>S</link> instead. The pfe
  provides explicit words for both conversions, the word <link>FROUND>S</link>
  and <link>FTRUNC>S</link> which return single-cell parameters for a floating
  point number with the conversion method of <link>FTRUNC</link> or <link>FROUND</link>.
</para><para>
  In PFE, <link>F>S</link> is a synonym pointing to <link>FTRUNC>S</link> in analogy 
  of the behavior of <link>F>D</link> where no explicit word exists. The
  inverse of <link>F>S</link> is the cast conversion of <link>S>F</link>.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FROUND&gt;S</forthname>
    <forthstack>(f: x -- s: n)</forthstack>
    <forthhints></forthhints>
    <stackline>FROUND&gt;S (f: x -- s: n)</stackline>
   </forthdefinition>
   <comment><para>  complements <link>FTRUNC>S</link> for applications that expect <link>F>S</link> to
  be defined with a rounding behavior like 
</para><screen>  : FROUND&gt;S FROUND FTRUNC&gt;S ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FTRUNC</forthname>
    <forthstack>(f: x -- x' )</forthstack>
    <forthhints></forthhints>
    <stackline>FTRUNC (f: x -- x' )</stackline>
   </forthdefinition>
   <comment><para>  truncate towards zero, discard a fractional part. See also <link>FTRUNC>S</link>
  conversion and the <link>FROUND</link> and <link>FLOOR</link> adaptors.
</para><screen>  : FTRUNC FDUP F0&lt; IF FCEIL ELSE FLOOR THEN ;
</screen><para>  (When available, uses a single call to C99 trunc() internally)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-FROT</forthname>
    <forthstack>(f: x1 x2 x3 -- x3 x1 x2 )</forthstack>
    <forthhints></forthhints>
    <stackline>-FROT  (f: x1 x2 x3 -- x3 x1 x2 )</stackline>
   </forthdefinition>
   <comment><para>
  F-stack equivalent of <link>-ROT</link>
</para><para>
  note, some systems call this work F-ROT,
  here it is the inverse of <link>FROT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FNIP</forthname>
    <forthstack>(f: x1 x2 -- x2 )</forthstack>
    <forthhints></forthhints>
    <stackline>FNIP  (f: x1 x2 -- x2 )</stackline>
   </forthdefinition>
   <comment><para>
  F-stack equivalent of <link>NIP</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FTUCK</forthname>
    <forthstack>(f: x1 x2 -- x2 x1 x2 )</forthstack>
    <forthhints></forthhints>
    <stackline>FTUCK  (f: x1 x2 -- x2 x1 x2 )</stackline>
   </forthdefinition>
   <comment><para>
  F-stack equivalent of <link>TUCK</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>1/F</forthname>
    <forthstack>(f: x -- 1/x )</forthstack>
    <forthhints></forthhints>
    <stackline>1/F  (f: x -- 1/x )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F^2</forthname>
    <forthstack>(f: x -- x^2 )</forthstack>
    <forthhints></forthhints>
    <stackline>F^2  (f: x -- x^2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F^N</forthname>
    <forthstack>( u f: x -- x^u )</forthstack>
    <forthhints></forthhints>
    <stackline>F^N  ( u f: x -- x^u )</stackline>
   </forthdefinition>
   <comment><para>  For large exponents, use F** instead.  Of course u=-1 is large. 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F2/</forthname>
    <forthstack>(f: x -- x/2 )</forthstack>
    <forthhints></forthhints>
    <stackline>F2/  (f: x -- x/2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F2*</forthname>
    <forthstack>(f: x -- x*2 )</forthstack>
    <forthhints></forthhints>
    <stackline>F2*  (f: x -- x*2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F0&gt;</forthname>
    <forthstack>(f: x -- s: flag )</forthstack>
    <forthhints></forthhints>
    <stackline>F0&gt;  (f: x -- s: flag )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F0&lt;&gt;</forthname>
    <forthstack>(f: x -- s: flag )</forthstack>
    <forthhints></forthhints>
    <stackline>F0&lt;&gt;  (f: x -- s: flag )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/forth-83-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>2+</forthname>
    <forthstack>( a# -- a#' | a* -- a*' | a -- a' [??] )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>2+ ( a# -- a#' | a* -- a*' | a -- a' [??] ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>   add 2 to the value on stack (and leave the result there)
</para><screen>  simulate:
    : 2+ 2 + ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2-</forthname>
    <forthstack>( a# -- a#' | a* -- a*' | a -- a' [??] )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>2- ( a# -- a#' | a* -- a*' | a -- a' [??] ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>   substract 2 from the value on stack (and leave the result there)
</para><screen>  simulate:
    : 2- 2 - ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>COMPILE</forthname>
    <forthstack>( "word" -- )</forthstack>
    <forthhints>  [FTH]</forthhints>
    <stackline>COMPILE ( "word" -- )  [FTH]</stackline>
   </forthdefinition>
   <comment><para>  compile the next word. The next word should not be immediate,
  in which case you would have to use <link>[COMPILE]</link>. For this
  reason, you should use the word <link>POSTPONE</link>, which takes care
  it.
</para><screen>  simulate:
    : COMPILE  R&gt; DUP @ , CELL+ &gt;R ;  ( not immediate !!! )
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((VOCABULARY)) ( -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  runtime of a <link>VOCABULARY</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>VOCABULARY</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>VOCABULARY ( "name" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  create a vocabulary of that name. If the named vocabulary
  is called later, it will run <link>((VOCABULARY))</link> , thereby
  putting it into the current search order.
  Special pfe-extensions are accessible via 
  <link>CASE-SENSITIVE-VOC</link> and <link>SEARCH-ALSO-VOC</link>
</para><screen>  simulate:
    : VOCABULARY  CREATE ALLOT-WORDLIST
         DOES&gt; ( the ((VOCABULARY)) runtime )
           CONTEXT ! 
    ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>--&gt;</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>--&gt; ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  does increase <link>BLK</link> and refills the input-buffer
  from there. Does hence break interpretation of the
  current BLK and starts with the next. Old-style
  forth mechanism. You should use <link>INCLUDE</link>
</para><screen>  : --&gt; ?LOADING REFILL ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>K</forthname>
    <forthstack>( -- k# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>K ( -- k# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  the 3rd loop index just like <link>I</link> and <link>J</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OCTAL</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>OCTAL ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  sets <link>BASE</link> to 8. Compare with <link>HEX</link> and <link>DECIMAL</link>
</para><screen>  simulate:
    : OCTAL  8 BASE ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SP@</forthname>
    <forthstack>( -- sp-cell* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>SP@ ( -- sp-cell* ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  the address of the top of stack. Does save it onto
  the stack. You could do 
</para><screen>    : DUP  SP@ @ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>!BITS</forthname>
    <forthstack>( x-bits# x-addr mask# -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>!BITS ( x-bits# x-addr mask# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  at the cell pointed to by addr, change only the bits that
  are enabled in mask
</para><screen>  simulate:
    : !BITS  &gt;R 2DUP @ R NOT AND SWAP R&gt; AND OR SWAP ! DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>**</forthname>
    <forthstack>( a# b# -- power-a# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>** ( a# b# -- power-a# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  raise second to top power
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;&lt;</forthname>
    <forthstack>( a -- a' )</forthstack>
    <forthhints> [FTH] [OLD]</forthhints>
    <stackline>&gt;&lt; ( a -- a' ) [FTH] [OLD]</stackline>
   </forthdefinition>
   <comment><para>  byte-swap a word
</para><para>
  depracated: use <link>NTOHS</link> which does the same as this word when
  the local byte-order seems to have no match, and be otherwise
  a no-op. Note that only the two lower bytes of the top-of-cell
  are swapped.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;MOVE&lt;</forthname>
    <forthstack>( from-addr* to-addr* count# -- )</forthstack>
    <forthhints> [FTH] [OLD]</forthhints>
    <stackline>&gt;MOVE&lt; ( from-addr* to-addr* count# -- ) [FTH] [OLD]</stackline>
   </forthdefinition>
   <comment><para>  see <link>MOVE</link> , does byte-swap for each word underway. 
</para><para>
  depracated: this word has not been very useful lately. It does
  still stem from times of 16bit forth systems that wanted to
  interchange data blocks. It is better to use functionality
  based on <link>NTOHS</link> or <link>NTOHL</link>. Note that this word <link>>MOVE<</link>
  does swap each 2byte. It is not useful for byte-swapping
  <link>WCHAR</link> strings as the count is given in bytes, not wchar items.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>@BITS</forthname>
    <forthstack>( x-addr mask# -- x-value# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>@BITS ( x-addr mask# -- x-value# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see the companion word => !BITS
</para><screen>  simulate:
    : @BITS  SWAP @ AND ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SEAL</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>SEAL ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  looks through the search-order and kills the ONLY wordset -
  hence you can't access the primary vocabularies from there.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/forth-usual-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>C+!</forthname>
    <forthstack>( n addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>C+!  ( n addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Add the low-order byte of _n_ to the byte at _addr_,
   removing both from the stack.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;WORDLIST</forthname>
    <forthstack>( xt -- wordl* )</forthstack>
    <forthhints></forthhints>
    <stackline>"&gt;WORDLIST" ( xt -- wordl* )</stackline>
   </forthdefinition>
   <comment><para>  convert a <link>VOCABULARY</link>-xt into its wordlist reference
  (as in win32forth)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BOUNDS</forthname>
    <forthstack>( str len -- str+len str )</forthstack>
    <forthhints></forthhints>
    <stackline>BOUNDS                ( str len -- str+len str )</stackline>
   </forthdefinition>
   <comment><para>   Convert _str len_ to range for DO-loop.
</para><screen>  : BOUNDS  ( str len -- str+len str )  OVER + SWAP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OFF</forthname>
    <forthstack>( addr  -- )</forthstack>
    <forthhints></forthhints>
    <stackline>OFF                   ( addr  -- )</stackline>
   </forthdefinition>
   <comment><para>   Store 0 at _addr_. Defined in f84 as <link>OFF</link>. See antonym <link>ON!</link>.
</para><screen>   : OFF  ( addr -- )  0 SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ON!</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ON!                    ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Store -1 at _addr_. Defined in f83 as <link>ON</link>. See antonym <link>OFF!</link>.
</para><screen>   : ON!  ( addr -- )  -1 SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>APPEND</forthname>
    <forthstack>( str len add2 -- )</forthstack>
    <forthhints></forthhints>
    <stackline>APPEND                ( str len add2 -- )</stackline>
   </forthdefinition>
   <comment><para>   Append string _str len_ to the counted string at _addr_.
   a.k.a. <link>+PLACE</link> of the <link>PLACE</link> family
</para><screen>  : APPEND   2DUP 2&gt;R  COUNT +  SWAP MOVE ( ) 2R&gt; C+! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+PLACE</forthname>
    <forthstack>( str len add2 -- )</forthstack>
    <forthhints></forthhints>
    <stackline>+PLACE                ( str len add2 -- )</stackline>
   </forthdefinition>
   <comment><para>   Append string _str len_ to the counted string at _addr_.
   a.k.a. <link>APPEND</link> (being a <link>SYNONYM</link> now)
</para><screen>  : +PLACE   2DUP 2&gt;R  COUNT +  SWAP MOVE ( ) 2R&gt; C+! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>APPEND-CHAR</forthname>
    <forthstack>( char addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>APPEND-CHAR           ( char addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Append _char_ to the counted string at _addr_.
   a.k.a. <link>C+PLACE</link> of the <link>PLACE</link> family
</para><screen>  : APPEND-CHAR   DUP &gt;R  COUNT  DUP 1+ R&gt; C!  +  C! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>C+PLACE</forthname>
    <forthstack>( char addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>C+PLACE           ( char addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Append _char_ to the counted string at _addr_.
   a.k.a. <link>APPEND-CHAR</link> (being a <link>SYNONYM</link> now)
</para><screen>  : C+PLACE   DUP &gt;R  COUNT  DUP 1+ R&gt; C!  +  C! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PLACE</forthname>
    <forthstack>( str len addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>PLACE                 ( str len addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Place the string _str len_ at _addr_, formatting it as a
   counted string.
</para><screen>  : PLACE  2DUP 2&gt;R  1+ SWAP  MOVE  2R&gt; C! ;
  : PLACE  2DUP C!   1+ SWAP CMOVE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PERFORM</forthname>
    <forthstack>( addr -- ? )</forthstack>
    <forthhints></forthhints>
    <stackline>PERFORM ( addr -- ? )</stackline>
   </forthdefinition>
   <comment><para>  see <link>@EXECUTE</link> which reads better
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?LEAVE</forthname>
    <forthstack>( cond -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?LEAVE ( cond -- )</stackline>
   </forthdefinition>
   <comment><para>  leave a (innermost) loop if condition is true
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NOOP</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>NOOP ( -- )</stackline>
   </forthdefinition>
   <comment><para>  do nothing, used as a place-holder where 
  an execution word is needed
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RP@</forthname>
    <forthstack>( -- addr )</forthstack>
    <forthhints></forthhints>
    <stackline>RP@ ( -- addr )</stackline>
   </forthdefinition>
   <comment><para>  returns the return stack pointer 
</para><screen>  example:
    : R@ RP@ @ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RP!</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>RP! ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>  sets the return stack pointer, reverse of <link>RP@</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SP!</forthname>
    <forthstack>( ... addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SP! ( ... addr -- )</stackline>
   </forthdefinition>
   <comment><para>  sets the stack pointer, reverse of <link>SP@</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-ROT</forthname>
    <forthstack>( a b c -- c a b )</forthstack>
    <forthhints></forthhints>
    <stackline>-ROT ( a b c -- c a b )</stackline>
   </forthdefinition>
   <comment><para>  inverse of <link>ROT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CSET</forthname>
    <forthstack>( n addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CSET ( n addr -- )</stackline>
   </forthdefinition>
   <comment><para>  set bits in byte at given address 
</para><screen>  simulate:
    : CSET  TUCK @ SWAP OR SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CRESET</forthname>
    <forthstack>( n addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CRESET ( n addr -- )</stackline>
   </forthdefinition>
   <comment><para>   reset bits in byte at given address 
</para><screen>  simulate:
    : CRESET  TUCK @ SWAP NOT AND SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CTOGGLE</forthname>
    <forthstack>( n addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CTOGGLE ( n addr -- )</stackline>
   </forthdefinition>
   <comment><para>  toggle bits in byte at given address 
</para><screen>  simulate:
    : CTOGGLE  TUCK @ SWAP XOR SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TOGGLE</forthname>
    <forthstack>( c-addr charmask -- )</forthstack>
    <forthhints></forthhints>
    <stackline>TOGGLE ( c-addr charmask -- )</stackline>
   </forthdefinition>
   <comment><para>  toggle the bits given in charmask, see also <link>SMUDGE</link> and = UNSMUDGE
</para><screen>  example: the fig-style SMUDGE had been defined such
    : FIG-SMUDGE LATEST &gt;FFA (SMUDGE#) TOGGLE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>3DUP</forthname>
    <forthstack>( x y z -- x y z x y z )</forthstack>
    <forthhints></forthhints>
    <stackline>3DUP                ( x y z -- x y z x y z )</stackline>
   </forthdefinition>
   <comment><para>   Copy top three elements on the stack onto top of stack.
</para><screen>  : 3DUP   THIRD THIRD THIRD ;
</screen><para>
  or
</para><screen>  : 3DUP  3 PICK 3 PICK 3 PICK ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>3DROP</forthname>
    <forthstack>( x y z -- )</forthstack>
    <forthhints></forthhints>
    <stackline>3DROP               ( x y z -- )</stackline>
   </forthdefinition>
   <comment><para>   Drop the top three elements from the stack.
</para><screen>  : 3DROP   DROP 2DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>4DUP</forthname>
    <forthstack>( a b c d -- a b c d a b c d )</forthstack>
    <forthhints></forthhints>
    <stackline>4DUP ( a b c d -- a b c d a b c d )</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate:
   : 4DUP  4 PICK 4 PICK 4 PICK 4 PICK ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>4DROP</forthname>
    <forthstack>( x y z -- )</forthstack>
    <forthhints></forthhints>
    <stackline>4DROP               ( x y z -- )</stackline>
   </forthdefinition>
   <comment><para>   Drop the top three elements from the stack.
</para><screen>  : 4DROP   2DROP 2DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TOUPPER</forthname>
    <forthstack>( c1 -- c2 )</forthstack>
    <forthhints></forthhints>
    <stackline>TOUPPER ( c1 -- c2 )</stackline>
   </forthdefinition>
   <comment><para>  convert a single character to upper case 
</para><screen>    : TOUPPER  &gt;R _toupper ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UPPER</forthname>
    <forthstack>( addr cnt -- )</forthstack>
    <forthhints></forthhints>
    <stackline>UPPER ( addr cnt -- )</stackline>
   </forthdefinition>
   <comment><para>  convert string to upper case 
</para><screen>  simulate:
    : UPPER  0 DO  DUP I +  DUP C@ UPC SWAP C!  LOOP  DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOWER</forthname>
    <forthstack>( addr cnt -- )</forthstack>
    <forthhints></forthhints>
    <stackline>LOWER ( addr cnt -- )</stackline>
   </forthdefinition>
   <comment><para>  convert string to lower case
  This is not in L&P's F83 but provided for symmetry 
</para><screen>  simulate:
    : LOWER  0 DO  DUP I +  DUP C@ &gt;R _tolower SWAP C!  LOOP  DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ASCII</forthname>
    <forthstack>( [word] -- val )</forthstack>
    <forthhints></forthhints>
    <stackline>ASCII ( [word] -- val )</stackline>
   </forthdefinition>
   <comment><para>  state smart version of <link>CHAR</link> or <link>[CHAR]</link> resp.
</para><screen>  simulate:
    : ASCII  [COMPILE] [CHAR] 
             STATE @ IF [COMPILE] LITERAL THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CONTROL</forthname>
    <forthstack>( [word] -- val )</forthstack>
    <forthhints></forthhints>
    <stackline>CONTROL ( [word] -- val )</stackline>
   </forthdefinition>
   <comment><para>  see <link>ASCII</link>, but returns char - '@' 
</para><screen>  simulate:
    : CONTROL  [COMPILE] [CHAR]  [CHAR] @ -  
               STATE @ IF [COMPILE] LITERAL THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NUMBER?</forthname>
    <forthstack>( addr -- d flag )</forthstack>
    <forthhints></forthhints>
    <stackline>NUMBER? ( addr -- d flag )</stackline>
   </forthdefinition>
   <comment><para>  convert counted string to number - used in inner interpreter 
  ( <link>INTERPRET</link> ), flags if conversion was successful
</para><screen>  example:
    BL WORD  HERE NUMBER? 0= IF ." not a number " THEN . 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>VOCS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>VOCS ( -- )</stackline>
   </forthdefinition>
   <comment><para>  list all vocabularies in the system
</para><screen>  simulate:
    : VOCS VOC-LINK @ BEGIN DUP WHILE
                            DUP -&gt;WORDLIST.NAME @ ID.
                            -&gt;WORDLIST.LINK @
                      REPEAT DROP ; 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>@EXECUTE</forthname>
    <forthstack>( xt -- ? )</forthstack>
    <forthhints></forthhints>
    <stackline>@EXECUTE ( xt -- ? )</stackline>
   </forthdefinition>
   <comment><para>  same as <link>@</link> <link>EXECUTE</link> , but checks for null as xt and
  silently ignores it. Same as in most forths where defined.
</para><screen>  simulate:
    : @EXECUTE  @ ?DUP IF EXECUTE THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EMITS</forthname>
    <forthstack>( n char -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EMITS           ( n char -- )</stackline>
   </forthdefinition>
   <comment><para>   Emit _char_ _n_ times.
</para><screen>  : EMITS             ( n char -- )
     SWAP 0 ?DO  DUP EMIT  LOOP DROP ;
</screen><para>  also compare
</para><screen>  : SPACES BL EMITS ;
  : SPACE BL EMIT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-CHECK</forthname>
    <forthstack>( n -- )</forthstack>
    <forthhints></forthhints>
    <stackline>FILE-CHECK        ( n -- )</stackline>
   </forthdefinition>
   <comment><para>   Check for file access error.
</para><screen>  \ : FILE-CHECK    ( n -- )  THROW ;
  : FILE-CHECK      ( n -- )  ABORT" File Access Error " ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MEMORY-CHECK</forthname>
    <forthstack>( n -- )</forthstack>
    <forthhints></forthhints>
    <stackline>MEMORY-CHECK      ( n -- )</stackline>
   </forthdefinition>
   <comment><para>   Check for memory allocation error.
</para><screen>  \ : MEMORY-CHECK  ( n -- )  THROW ;
  : MEMORY-CHECK    ( n -- )  ABORT" Memory Allocation Error " ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>++</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>++                  ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Increment the value at _addr_.
</para><screen>  : ++  ( addr -- )  1 SWAP +! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>@++</forthname>
    <forthstack>( addr -- addr' x )</forthstack>
    <forthhints></forthhints>
    <stackline>@++                  ( addr -- addr' x )</stackline>
   </forthdefinition>
   <comment><para>   Fetch the value _x_ from _addr_, and increment the address
   by one cell.
</para><screen>  : @++  ( addr -- addr' x )  DUP CELL+ SWAP  @ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>!++</forthname>
    <forthstack>( addr x -- addr' )</forthstack>
    <forthhints></forthhints>
    <stackline>!++                  ( addr x -- addr' )</stackline>
   </forthdefinition>
   <comment><para>   Store the value _x_ into _addr_, and increment the address
   by one cell.
</para><screen>  : !++  ( addr x -- addr' )  OVER !  CELL+ ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/fpnostack-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>S&gt;F</forthname>
    <forthstack>( n -- x )</forthstack>
    <forthhints></forthhints>
    <stackline>S&gt;F  ( n -- x )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FTRUNC&gt;S</forthname>
    <forthstack>( x -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>FTRUNC&gt;S  ( x -- n )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FROUND&gt;S</forthname>
    <forthstack>( x -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>FROUND&gt;S ( x -- n )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FTRUNC</forthname>
    <forthstack>( x -- x' )</forthstack>
    <forthhints></forthhints>
    <stackline>FTRUNC ( x -- x' )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-FROT</forthname>
    <forthstack>( x1 x2 x3 -- x3 x1 x2 )</forthstack>
    <forthhints></forthhints>
    <stackline>-FROT  ( x1 x2 x3 -- x3 x1 x2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FNIP</forthname>
    <forthstack>( x1 x2 -- x2 )</forthstack>
    <forthhints></forthhints>
    <stackline>FNIP  ( x1 x2 -- x2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FTUCK</forthname>
    <forthstack>( x1 x2 -- x2 x1 x2 )</forthstack>
    <forthhints></forthhints>
    <stackline>FTUCK  ( x1 x2 -- x2 x1 x2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>1/F</forthname>
    <forthstack>( x -- 1/x )</forthstack>
    <forthhints></forthhints>
    <stackline>1/F  ( x -- 1/x )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F^2</forthname>
    <forthstack>( x -- x^2 )</forthstack>
    <forthhints></forthhints>
    <stackline>F^2  ( x -- x^2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F^N</forthname>
    <forthstack>( x u -- x^u )</forthstack>
    <forthhints></forthhints>
    <stackline>F^N  ( x u -- x^u )</stackline>
   </forthdefinition>
   <comment><para>  For large exponents, use F** instead.  Of course u=-1 is large. 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F2/</forthname>
    <forthstack>( x -- x/2 )</forthstack>
    <forthhints></forthhints>
    <stackline>F2/  ( x -- x/2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F2*</forthname>
    <forthstack>( x -- x*2 )</forthstack>
    <forthhints></forthhints>
    <stackline>F2*  ( x -- x*2 )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F0&gt;</forthname>
    <forthstack>( x -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>F0&gt;  ( x -- flag )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>F0&lt;&gt;</forthname>
    <forthstack>( x -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>F0&lt;&gt;  ( x -- flag )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/gforth-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>open-dir</forthname>
    <forthstack>( c_addr u -- wdirid wior )</forthstack>
    <forthhints>  gforth  open_dir</forthhints>
    <stackline>open-dir   ( c_addr u -- wdirid wior )  gforth  open_dir</stackline>
   </forthdefinition>
   <comment><para>  will vanish without warning. see gforth documentation.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>read-dir</forthname>
    <forthstack>( c_addr u1 wdirid -- u2 flag wior )</forthstack>
    <forthhints>  gforth  read_dir</forthhints>
    <stackline>read-dir   ( c_addr u1 wdirid -- u2 flag wior )  gforth  read_dir</stackline>
   </forthdefinition>
   <comment><para>  will vanish without warning. see gforth documentation.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>close-dir</forthname>
    <forthstack>( wdirid -- wior )</forthstack>
    <forthhints>      gforth  close_dir</forthhints>
    <stackline>close-dir       ( wdirid -- wior )      gforth  close_dir</stackline>
   </forthdefinition>
   <comment><para>  will vanish without warning. see gforth documentation.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>linked</forthname>
    <forthstack>( list -- )</forthstack>
    <forthhints> \ gforth</forthhints>
    <stackline>linked ( list -- ) \ gforth</stackline>
   </forthdefinition>
   <comment><screen> 
  : linked        here over @ a, swap ! ;
</screen><para>  (note: win32forth calls it "link," )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>chained</forthname>
    <forthstack>( xt list -- )</forthstack>
    <forthhints> \ gforth</forthhints>
    <stackline>chained       ( xt list -- ) \ gforth</stackline>
   </forthdefinition>
   <comment><para>  generic chains
</para><screen>  : chained  linked , ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>chainperform</forthname>
    <forthstack>( list -- )</forthstack>
    <forthhints> \ gforth</forthhints>
    <stackline>chainperform  ( list -- ) \ gforth</stackline>
   </forthdefinition>
   <comment><para>
</para><screen>  : chainperform  BEGIN @ dup WHILE dup cell+ perform REPEAT drop ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/header-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>&gt;NAME</forthname>
    <forthstack>( cfa -- nfa )</forthstack>
    <forthhints></forthhints>
    <stackline>&gt;NAME ( cfa -- nfa )</stackline>
   </forthdefinition>
   <comment><para>  converts a pointer to the code-field (CFA) to point
  then to the corresponding name-field (NFA)
</para><screen>  implementation-specific simulation:
    : &gt;NAME  &gt;LINK L&gt;NAME ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;LINK</forthname>
    <forthstack>( cfa -- lfa )</forthstack>
    <forthhints></forthhints>
    <stackline>&gt;LINK ( cfa -- lfa )</stackline>
   </forthdefinition>
   <comment><para>  converts a pointer to the code-field (CFA) to point
  then to the corresponding link-field (LFA) - in some configurations
  this can be a very slow operation since the system might need to walk
  through all header-words in the system, looking for a <link>>NAME</link> that
  has the cfa and *then* returning the "N>LINK" result here - which might
  be none at all if the word is a <link>:NONAME</link>. Use always <link>>NAME</link> and
  treat this word as non-portable just like any assumption about the
  contents of the <link>>LINK</link>-field.
  Only in fig-mode and for traditional fig-mode programs, this word may
  possibly have enough extra assertions to be somewhat reliable.
  (and fig-mode did not know about <link>SYNONYM</link>s - see note at <link>LINK></link>).
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BODY&gt;</forthname>
    <forthstack>( pfa -- cfa )</forthstack>
    <forthhints></forthhints>
    <stackline>BODY&gt; ( pfa -- cfa )</stackline>
   </forthdefinition>
   <comment><para>  trying to convert a pointer to the parameter-field (PFA) to point
  then to the corresponding code-field (CFA) - note that this is not
  necessarily the inverse of <link>>BODY</link> instead it is a fast implementation
  assuming a <link>VARIABLE</link> thing had been used. Every use of "BODY>" is
  warned in the logfile.
</para><screen>  implementation-specific simulation:
    : BODY&gt; CELL - ;
</screen><para>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NAME&gt;</forthname>
    <forthstack>( nfa -- cfa )</forthstack>
    <forthhints></forthhints>
    <stackline>NAME&gt; ( nfa -- cfa )</stackline>
   </forthdefinition>
   <comment><para>  converts a pointer to the name-field (NFA) to point
  then to the corresponding code-field (CFA)
</para><para>
  In all cases but a <link>SYNONYM</link> the pfe will behave not unlike the
  original fig-forth did - being identical to <link>N>LINK</link> <link>LINK></link> .
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LINK&gt;</forthname>
    <forthstack>( lfa -- cfa )</forthstack>
    <forthhints></forthhints>
    <stackline>LINK&gt; ( lfa -- cfa )</stackline>
   </forthdefinition>
   <comment><para>  converts a pointer to the link-field (LFA) to point
  then to the corresponding code-field (CFA)
</para><para>
  BEWARE: this one does not care about <link>SYNONYM</link>s and it is the
  only way to get at the data of a <link>SYNONYM</link>. Therefore, if you have
  a synonym called A for an old word B then there is a different
  result using "NAME>" on an A-nfa or using "N>LINK LINK>" since the
  first "NAME>" will return the xt of B while the latter will return
  the xt of A - but executing an xt of A is an error and it will <link>THROW</link>
</para><para>
  this difference is intentional to allow knowledgable persons to
  do weird things looking around in the dictionary. The forth standard
  words will not give you much of a chance to get hold of the nfa of
  a <link>SYNONYM</link> word anyway - asking <link>FIND</link> for a word A will return
  the execution token of B immediatly and "NAME>" on that one lead to
  the nfa of B and not that of A.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>L&gt;NAME</forthname>
    <forthstack>( lfa -- nfa )</forthstack>
    <forthhints></forthhints>
    <stackline>L&gt;NAME ( lfa -- nfa )</stackline>
   </forthdefinition>
   <comment><para>  converts a pointer to the link-field (LFA) to point
  then to the corresponding name-field (CFA) - this one is one of
  the slowest operation available. One should always use the inverse
  operation <link>N>LINK</link> and cache an older value if that is needed.
  Some words might be linked but they do not have a name-field (just
  the other fields) but this word can not detect that and will try to look
  into the bits of the dictionary anway in the assumption that there is 
  something - and if done in the wrong place it might even segfault.
  Only in fig-mode and for traditional fig-mode programs, this word may
  possibly have enough extra assertions to be somewhat reliable.
  (and fig-mode did not know about <link>SYNONYM</link>s - see note at <link>LINK></link>).
</para><screen> 
  implementation-specific configure-dependent fig-only simulation:
  : L&gt;NAME BEGIN DUP C@ 128 AND 0= WHILE 1- REPEAT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>N&gt;LINK</forthname>
    <forthstack>( nfa -- lfa )</forthstack>
    <forthhints></forthhints>
    <stackline>N&gt;LINK ( nfa -- lfa )</stackline>
   </forthdefinition>
   <comment><para>  converts a pointer to the name-field (NFA) to point
  then to the corresponding link-field (LFA) - this operation
  is quicker than the inverse <link>L>NAME</link>. This word is a specific
  implementation detail and should not be used by normal users - instead
  use always <link>NAME></link> which is much more portable. Many systems may
  possibly not even have a <link>>LINK</link>-field in the sense that a <link>@</link> on
  this adress will lead to another <link>>NAME</link>. Any operation on the 
  resulting <link>>LINK</link>-adress is even dependent on the current configuration
  of PFE - only in fig-mode you are asserted to have the classic detail.
  (and fig-mode did not know about <link>SYNONYM</link>s - see note at <link>LINK></link>).
</para><screen> 
  implementation-specific configure-dependent fig-only simulation:
    : N&gt;LINK  C@ + ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&gt;FFA</forthname>
    <forthstack>( nfa -- ffa )</forthstack>
    <forthhints> obsolete</forthhints>
    <stackline>&gt;FFA ( nfa -- ffa ) obsolete</stackline>
   </forthdefinition>
   <comment><para>  converts a pointer to the name-field (NFA) to point
  then to the corresponding flag-field (FFA) - in traditinal
  Forth this is the same address. pfe _can_ do different.
</para><screen>  implementation-specific configure-dependent simulation:
    : FFA  1- ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FFA&gt;</forthname>
    <forthstack>( ffa -- nfa )</forthstack>
    <forthhints> obsolete</forthhints>
    <stackline>FFA&gt; ( ffa -- nfa ) obsolete</stackline>
   </forthdefinition>
   <comment><para>  converts a pointer to the flag-field (FFA) to point
  then to the corresponding name-field (NFA) - in traditinal
  Forth this is the same address. pfe _can_ do different.
</para><screen>  implementation-specific configure-dependent simulation:
    : FFA  1+ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NAME&gt;STRING</forthname>
    <forthstack>( name-token -- str-ptr str-len )</forthstack>
    <forthhints></forthhints>
    <stackline>NAME&gt;STRING        ( name-token -- str-ptr str-len )</stackline>
   </forthdefinition>
   <comment><para>  convert a name-token into a string-span, used to detect the
  name for a word and print it. The word <link>ID.</link> can be defined as
</para><screen>  : ID. NAME&gt;STRING TYPE ;
</screen><para>  the implementation of <link>NAME>STRING</link> depends on the header layout
  that is defined during the configuration of the forth system.
</para><screen>  : NAME&gt;STRING COUNT 31 AND ; ( for fig-like names )
  : NAME&gt;STRING COUNT ;        ( default, name is a simple counted string )
  : NAME&gt;STRING @ ZCOUNT ;     ( name-token is a pointer to a C-level string )
  : NAME&gt;STRING COUNT 31 AND   ( hybrid of fig-like and zero-terminated )
       DUP 31 = IF DROP 1+ ZCOUNT THEN
  ;
  : NAME&gt;STRING HEAD:: COUNT CODE:: PAD PLACE PAD ; ( different i86 segments )
 
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>HEADER,</forthname>
    <forthstack>( str-ptr str-len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>HEADER, ( str-ptr str-len -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>CREATE</link> a new header in the dictionary from the given string, without CFA
</para><screen>  usage: : VARIABLE  BL WORD COUNT HEADER, DOVAR , ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$HEADER</forthname>
    <forthstack>( bstring -- )</forthstack>
    <forthhints></forthhints>
    <stackline>$HEADER ( bstring -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>CREATE</link> a new header in the dictionary from the given string
  with the variable runtime (see <link>HEADER,</link> and <link>CREATE:</link>)
</para><screen>  usage: : VARIABLE  BL WORD $HEADER ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LATEST</forthname>
    <forthstack>( -- nfa )</forthstack>
    <forthhints></forthhints>
    <stackline>LATEST ( -- nfa )</stackline>
   </forthdefinition>
   <comment><para>  return the NFA of the lateset definition in the
  <link>CURRENT</link> vocabulary
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SMUGDE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SMUGDE ( -- )</stackline>
   </forthdefinition>
   <comment><para>  the FIG definition toggles the <link>SMUDGE</link> bit, and not all systems have
  a smudge bit - instead one should use <link>REVEAL</link> or <link>HIDE</link>
</para><screen>  : SMUDGE LAST @ &gt;FFA SMUDGE-MASK TOGGLE ;
  : SMUDGE LAST @ NAME-FLAGS@ SMUDGE-MASK XOR LAST @ NAME-FLAGS! ;
  : HIDE   LAST @ NAME-FLAGS@ SMUDGE-MASK  OR LAST @ NAME-FLAGS! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>HIDE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>HIDE ( -- )</stackline>
   </forthdefinition>
   <comment><para>  the FIG definition toggles the <link>SMUDGE</link> bit, and not all systems have
  a smudge bit - instead one should use <link>REVEAL</link> or <link>HIDE</link>
</para><screen>  : HIDE LAST @ FLAGS@ SMUDGE-MASK XOR LAST @ FLAGS! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RECURSIVE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>RECURSIVE ( -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>REVEAL</link> the current definition making it <link>RECURSIVE</link> by its
  own name instead of using the ans-forth word to <link>RECURSE</link>.
</para><screen>  ' REVEAL ALIAS RECURSIVE IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REVEAL</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>REVEAL ( -- )</stackline>
   </forthdefinition>
   <comment><para>  the FIG definition toggles the <link>SMUDGE</link> bit, and not all systems have
  a smudge bit - instead one should use <link>REVEAL</link> or <link>HIDE</link>
</para><screen>  : REVEAL LAST @ FLAGS@ SMUDGE-MASK INVERT AND LAST @ FLAGS! ;
  : REVEAL LAST @ CHAIN-INTO-CURRENT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IMMEDIATE-MASK</forthname>
    <forthstack>( -- bit-mask )</forthstack>
    <forthhints></forthhints>
    <stackline>IMMEDIATE-MASK ( -- bit-mask )</stackline>
   </forthdefinition>
   <comment><para>   returns the bit-mask to check if a found word is immediate
   (use in conjunction with <link>NAME-FLAGS@</link> and NAME-FLAGS! )
</para><screen>     " my-word" FIND-NAME IF NAME-FLAGS@ IMMEDIATE-MASK AND 
                        IF ." immediate" THEN ELSE DROP THEN
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SMUDGE-MASK</forthname>
    <forthstack>( -- bit-mask )</forthstack>
    <forthhints></forthhints>
    <stackline>SMUDGE-MASK ( -- bit-mask )</stackline>
   </forthdefinition>
   <comment><para>   returns the bit-mask to check if a found word is smudge
   (use in conjunction with <link>NAME-FLAGS@</link> and NAME-FLAGS! )
</para><screen>     " my-word" FIND-NAME IF NAME-FLAGS@ SMUDGE-MASK AND 
                        IF ." smudge" THEN ELSE DROP THEN
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NAME-FLAGS@</forthname>
    <forthstack>( nfa -- nfa-flags )</forthstack>
    <forthhints></forthhints>
    <stackline>NAME-FLAGS@ ( nfa -- nfa-flags )</stackline>
   </forthdefinition>
   <comment><para>  get the nfa-flags that corresponds to the nfa given. Note that
  in the fig-style would include the nfa-count in the lower bits.
  (see <link>NAME-FLAGS!</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NAME-FLAGS!</forthname>
    <forthstack>( nfa-flags nfa -- )</forthstack>
    <forthhints></forthhints>
    <stackline>NAME-FLAGS! ( nfa-flags nfa -- )</stackline>
   </forthdefinition>
   <comment><para>  set the nfa-flags of nfa given. Note that in the fig-style the nfa-flags
  would include the nfa-count in the lower bits - therefore this should only
  set bits that had been previously retrieved with <link>NAME-FLAGS@</link>
</para><screen>  : IMMEDIATE LAST @ NAME-FLAGS@ IMMEDIATE-MASK OR LAST @ NAME-FLAGS! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((DEFER)) ( -- )</stackline>
   </forthdefinition>
   <comment><para>  runtime of <link>DEFER</link> words
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DEFER</forthname>
    <forthstack>( 'word' -- )</forthstack>
    <forthhints></forthhints>
    <stackline>DEFER ( 'word' -- )</stackline>
   </forthdefinition>
   <comment><para>  create a new word with ((DEFER))-semantics
</para><screen>  simulate:
    : DEFER  CREATE 0, DOES&gt; ( the ((DEFER)) runtime ) 
       @ ?DUP IF EXECUTE THEN ;
    : DEFER  DEFER-RT HEADER 0 , ;
</screen><para>
  declare as <code>"DEFER deferword"</code>  <br>
  and set as <code>"['] executionword IS deferword"</code>
  (in pfe, you can also use <code>TO deferword</code> to set the execution)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IS</forthname>
    <forthstack>( xt-value [word] -- )</forthstack>
    <forthhints></forthhints>
    <stackline>IS ( xt-value [word] -- )</stackline>
   </forthdefinition>
   <comment><para>  set a <link>DEFER</link> word
  (in pfe: set the DOES-field - which is the BODY-field in ans-mode
   and therefore the same as <link>TO</link> /  in fig-mode the DOES-field is
   one cell higher up than for a <link>CREATE:</link> <link>VARIABLE</link> 
   Use <link>IS</link> freely on each DOES-words in both modes).
</para><screen>  : IS ' 
    STATE @ IF LITERAL, POSTPONE &gt;DOES-BODY POSTPONE ! 
    ELSE &gt;DOES-BODY ! THEN 
  ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ACTION-OF</forthname>
    <forthstack>( [word] -- xt-value )</forthstack>
    <forthhints></forthhints>
    <stackline>ACTION-OF ( [word] -- xt-value )</stackline>
   </forthdefinition>
   <comment><para>  get the <link>BEHAVIOR</link> of a <link>DEFER</link> word when executed. If being
  compiled then the ACTION-OF will be the value of [word] at the
  time of execution and not that of compilation time (non-constant). 
</para><para>
  In PFE it does actually pick whatever is stored in the DOES-field
  of a word and therefore ACTION-OF may applied to all DOES-words.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DEFER!</forthname>
    <forthstack>( xt-value xt-defer -- )</forthstack>
    <forthhints></forthhints>
    <stackline>DEFER! ( xt-value xt-defer -- )</stackline>
   </forthdefinition>
   <comment><para>  A Forth200x definition that is not very useful.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BEHAVIOR</forthname>
    <forthstack>( xt1 -- x2 )</forthstack>
    <forthhints></forthhints>
    <stackline>BEHAVIOR ( xt1 -- x2 )</stackline>
   </forthdefinition>
   <comment><para>  A defintion from OpenBoot that is identical Forth200x <link>DEFER@</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DEFER@</forthname>
    <forthstack>( xt1 -- xt2 )</forthstack>
    <forthhints></forthhints>
    <stackline>DEFER@ ( xt1 -- xt2 )</stackline>
   </forthdefinition>
   <comment><para>  get the execution token xt2 that would be executed by the <link>DEFER</link>
  identified by xt1.
</para><para>
  This command is used to obtain the execution contents of a deferred
  word. A typical use would be to retrieve and save the execution
  behavior of the deferred word, set the deferred word to a new behavior,
  and then later restore the old behavior.
</para><para>
  If the deferred word identified by _xt1_ is associated with some
  other deferred word, _xt2_ is the execution token of that other
  deferred word. To retrieve the execution token of the word currently
  associated with that other deferred word, use the phrase DEFER@ DEFER@ .
</para><para>
  Experience:
       BEHAVIOR was used many years in OpenBoot and OpenFirmware systems.
</para><para>
  In PFE it is the inverse of an <link>IS</link> operation and it will never fail
  if applied to a word with atleast a body. That's just like <link>IS</link> can
  be applied to almost every <link>DOES></link> word where <link>DEFER@</link> will get
  the value back.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ALIAS</forthname>
    <forthstack>( some-xt* "name" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>ALIAS ( some-xt* "name" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  create a defer word that is initialized with the given x-token.
                                                            <link>DO-ALIAS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SYNONYM</forthname>
    <forthstack>( "newname" "oldname" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SYNONYM ( "newname" "oldname" -- )</stackline>
   </forthdefinition>
   <comment><para>  make an name-alias for a word - this is very different from a <link>DEFER</link>
  since a <link>DEFER</link> will resolve at runtime. Changing the target of a
  <link>DEFER</link> via <link>IS</link> will result in changing the <link>BEHAVIOR</link> of all
  words defined earlier and containing the name of the <link>DEFER</link>.
</para><para>
  A <link>SYNONYM</link> however does not have any data field (theoretically not
  even an execution token), instead it gets resolved at compile time.
  In theory, you can try to <link>FIND</link> the name of the <link>SYNONYM</link> but as
  soon as you apply <link>NAME></link> the execution token of the end-point is
  returned. This has also the effect that using the inverse <link>>NAME</link>
  operation will result in the name-token of the other name. 
</para><screen> 
    SYNONYM CREATE &lt;BUILDS ( like it is in ANS Forth )
    : FOO CREATE DOES&gt; @ ;
    SEE FOO
    : foo &lt;builds
      does&gt; @ ;
    SYNONYM CREATE CREATE:
    : BAR CREATE 10 ALLOT ;
    SEE BAR
    : bar create: 10 allot ;
</screen><para>                       (only <link>LINK></link> does not care about <link>SYNONYM</link>s)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>"SYNONYM-OBSOLETED</forthname>
    <forthstack>( "newname" "oldname" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"SYNONYM-OBSOLETED ( "newname" "oldname" -- )</stackline>
   </forthdefinition>
   <comment><para>  same as <link>SYNONYM</link> but on the first use an error message will be
  displayed on both the screen and the sys-log.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(DEPRECATED: ( "newname" [message&lt;closeparen&gt;] -- )</stackline>
   </forthdefinition>
   <comment><para>  add a message for the following word "newname" that should
  be shown once upon using the following word. Use it like
</para><screen>    (DEPRECATED: myword is obsoleted in Forth200X)
    : myword ." hello world" ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(CHECK-DEPRECATED) ( nfa* -- nfa* )</stackline>
   </forthdefinition>
   <comment><para>  an internal function that will check a word name
  to have any deprecation attribution - some words have
  a (one time) message to be shown to the user, while
  <link>OBSOLETED-SYNONYM</link> will show a message and rebuild
  itself as a normal SYNONYM. - Note that most deprecations
  are only shown once and that they are not emitted when
  having REDEFINED-MSG OFF.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXTERN,-DEPRECATED:</forthname>
    <forthstack>( "newname" zstring* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EXTERN,-DEPRECATED: ( "newname" zstring* -- )</stackline>
   </forthdefinition>
   <comment><para>  compile a pointer to an extern (loader) z-string
  to the dictionary and on execution show a deprecation
  message once. Note: the new name is smudged+immediate,
  so it you can not <link>FIND</link> it right after compilation.
</para><para>
  see also <link>(DEPRECATED:</link> name message) for the real thing
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXTERN,-LOGMESSAGE:</forthname>
    <forthstack>( "newname" zstring* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EXTERN,-LOGMESSAGE: ( "newname" zstring* -- )</stackline>
   </forthdefinition>
   <comment><para>  compile a pointer to an extern (loader) z-string
  to the dictionary and on execution show a logging
  message once. Note: this name is NOT smudged+immediate.
</para><para>
  see also <link>(DEPRECATED:</link> name message) for 
  deprecation messages
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/help-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(HELP) ( str-ptr str-len -- )</stackline>
   </forthdefinition>
   <comment><para>  display help for the specified word
  (not functional yet)
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/host-k12.c">
  <forthheader>
   <forthdefinition>
    <forthname>OPEN-TERMINAL-LOGFILE</forthname>
    <forthstack>( s-buf s-len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>OPEN-TERMINAL-LOGFILE ( s-buf s-len -- )</stackline>
   </forthdefinition>
   <comment><para>  open terminal logfile named by the string-buffer
  all further output to the terminal window is also logged into
  this file. This is especially useful in embedded environments
  where the terminal connection is often not used or it is
  directed to a different location that does not easily allow to
  redirect the forth output to a file for further examination.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CLOSE-TERMINAL-LOGFILE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CLOSE-TERMINAL-LOGFILE ( -- )</stackline>
   </forthdefinition>
   <comment><para>  close terminal logfile opened with <link>OPEN-TERMINAL-LOGFILE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TERMINAL-ANSWER-LINK</forthname>
    <forthstack>( -- sap#* )</forthstack>
    <forthhints></forthhints>
    <stackline>TERMINAL-ANSWER-LINK ( -- sap#* )</stackline>
   </forthdefinition>
   <comment><para>  send terminal-output as a data-message to the specified link sap.
  Unlike <link>TERMINAL-OUTPUT-LINK</link> the data-messages are in line-mode.
  The flushed characters are buffered until a non-printable character
  is seen. This is somewhat more useful when treating pfe as a print
  service and testing machine, but can not provide for interactivity.
</para><screen>  60 TERMINAL-ANSWER-LINK !
  ...
  TERMINAL-ANSWER-LINK OFF
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TERMINAL-OUTPUT-LINK</forthname>
    <forthstack>( -- sap#* )</forthstack>
    <forthhints></forthhints>
    <stackline>TERMINAL-OUTPUT-LINK ( -- sap#* )</stackline>
   </forthdefinition>
   <comment><para>  send terminal-output as a data-message to the specified link sap.
  This can be used in an embedded systems for a terminal session simulation.
  setting zero-sap will disable sending message-frames (the zero sap is
  therefore not usable for output-to-link). The startup default is zero.
</para><screen>  60 TERMINAL-OUTPUT-LINK !
  ...
  TERMINAL-OUTPUT-LINK OFF
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TERMINAL-INPUT-LINK</forthname>
    <forthstack>( -- sap#* )</forthstack>
    <forthhints></forthhints>
    <stackline>TERMINAL-INPUT-LINK ( -- sap#* )</stackline>
   </forthdefinition>
   <comment><para>  let the forth stdin-handling look for data-messages on this link too.
  These will be interpreted like messages that come from the interactive
  forth terminal. This can be used in an embedded systems for a terminal 
  session simulation. setting zero-sap will disable interpreting these
  incoming data-frames as keyboard-strings (so that the zero sap is
  therefore not usable for an input-link!). The startup default is zero.
</para><screen>  60 TERMINAL-INPUT-LINK !
  ...
  TERMINAL-INPUT-LINK OFF
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TERMINAL-EMULATION-STATE</forthname>
    <forthstack>( -- state* )</forthstack>
    <forthhints></forthhints>
    <stackline>TERMINAL-EMULATION-STATE ( -- state* )</stackline>
   </forthdefinition>
   <comment><para>  returns the address of the emulations state variable so it can be
  read and explicitly changed to another value from forth text. This is
  a very questionable thing to do as the emulation-state is actually
  an enumerated value, the ESE will just show question-marks setting 
  this variable to something not understood.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/lib-sdl.c">
  <forthheader>
   <forthdefinition>
    <forthname>SDL_init</forthname>
    <forthstack>( flags -- int )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_init ( flags -- int )</stackline>
   </forthdefinition>
   <comment><para>  This function loads the SDL dynamically linked library and initializes 
  the subsystems specified by 'flags' (and those satisfying dependencies)
  Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
  signal handlers for some commonly ignored fatal signals (like SIGSEGV)
</para><para>
</para><screen>  int SDL_Init(Uint32 flags);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_InitSubSystem</forthname>
    <forthstack>( flags -- int )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_InitSubSystem ( flags -- int )</stackline>
   </forthdefinition>
   <comment><para>  This function initializes specific SDL subsystems 
</para><screen>  int SDL_InitSubSystem(Uint32 flags);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_QuitSubSystem</forthname>
    <forthstack>( flags -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_QuitSubSystem ( flags -- )</stackline>
   </forthdefinition>
   <comment><para>  This function cleans up specific SDL subsystems 
</para><screen>  void SDL_QuitSubSystem(Uint32 flags);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_WasInit</forthname>
    <forthstack>( flags -- mask )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_WasInit ( flags -- mask )</stackline>
   </forthdefinition>
   <comment><para>  This function returns mask of the specified subsystems which have
  been initialized.
  If 'flags' is 0, it returns a mask of all initialized subsystems.
</para><screen>  Uint32 SDL_WasInit(Uint32 flags);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_Quit</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_Quit ( -- )</stackline>
   </forthdefinition>
   <comment><para>  This function cleans up all initialized subsystems and unloads the
  dynamically linked library.  You should call it upon all exit conditions.
</para><screen>  void SDL_Quit(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_SetError</forthname>
    <forthstack>( str-ptr str-len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_SetError ( str-ptr str-len -- )</stackline>
   </forthdefinition>
   <comment><para>  set it, based on
</para><screen>  void SDL_SetError(const char *fmt, ...);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_GetError</forthname>
    <forthstack>( -- str-ptr str-len )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_GetError ( -- str-ptr str-len )</stackline>
   </forthdefinition>
   <comment><para>  get it, based on
</para><screen>  char * SDL_GetError(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_ClearError</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_ClearError ( -- )</stackline>
   </forthdefinition>
   <comment><para>  clear it.
</para><screen>  void SDL_ClearError(void);
 
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_RWFromFile</forthname>
    <forthstack>( Z-modestr* Z-filename* -- SDL_RWops* )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_RWFromFile ( Z-modestr* Z-filename* -- SDL_RWops* )</stackline>
   </forthdefinition>
   <comment><para>  A Functions to create SDL_RWops structures from various data sources 
</para><screen>  SDL_RWops * SDL_RWFromFile(const char *file, const char *mode);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_RWFromFP</forthname>
    <forthstack>( autoclose STDIO-FILE* -- SDL_RWops* )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_RWFromFP ( autoclose STDIO-FILE* -- SDL_RWops* )</stackline>
   </forthdefinition>
   <comment><para>  A Functions to create SDL_RWops structures from various data sources 
</para><screen>  SDL_RWops * SDL_RWFromFP(FILE *fp, int autoclose);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_RWFromMem</forthname>
    <forthstack>( size mem* -- SDL_RWops* )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_RWFromMem ( size mem* -- SDL_RWops* )</stackline>
   </forthdefinition>
   <comment><para>  A Functions to create SDL_RWops structures from various data sources 
</para><screen>  SDL_RWops * SDL_RWFromMem(void *mem, int size);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_AllocRW</forthname>
    <forthstack>( -- SDL_RWops* )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_AllocRW ( -- SDL_RWops* )</stackline>
   </forthdefinition>
   <comment><para>  A Functions to create SDL_RWops structures from various data sources 
</para><screen>  SDL_RWops * SDL_AllocRW(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_FreeRW</forthname>
    <forthstack>( SDL_RWops* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_FreeRW ( SDL_RWops* -- )</stackline>
   </forthdefinition>
   <comment><para>  A Functions to create SDL_RWops structures from various data sources 
</para><screen>  void SDL_FreeRW(SDL_RWops *area);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_RWseek</forthname>
    <forthstack>( whence offset rwops-context -- status )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_RWseek ( whence offset rwops-context -- status )</stackline>
   </forthdefinition>
   <comment><para>  Macro-based call to easily read and write from an SDL_RWops structure 
</para><screen>  define SDL_RWseek(ctx, offset, whence) (ctx)-&gt;seek(ctx, offset, whence)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_RWtell</forthname>
    <forthstack>( rwops-context -- status )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_RWtell ( rwops-context -- status )</stackline>
   </forthdefinition>
   <comment><para>  Macro-based call to easily read and write from an SDL_RWops structure 
</para><screen>  define SDL_RWtell(ctx)                 (ctx)-&gt;seek(ctx, 0, SEEK_CUR)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_RWread</forthname>
    <forthstack>( n size ptr rwops-context -- status )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_RWread ( n size ptr rwops-context -- status )</stackline>
   </forthdefinition>
   <comment><para>  Macro-based call to easily read and write from an SDL_RWops structure 
</para><screen>  define SDL_RWread(ctx, ptr, size, n)   (ctx)-&gt;read(ctx, ptr, size, n)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_RWwrite</forthname>
    <forthstack>( n size ptr rwops-context -- status )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_RWwrite ( n size ptr rwops-context -- status )</stackline>
   </forthdefinition>
   <comment><para>  Macro-based call to easily read and write from an SDL_RWops structure 
</para><screen>  define SDL_RWwrite(ctx, ptr, size, n)   (ctx)-&gt;read(ctx, ptr, size, n)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_RWclose</forthname>
    <forthstack>( rwops-context -- status )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_RWclose ( rwops-context -- status )</stackline>
   </forthdefinition>
   <comment><para>  Macro-based call to easily read and write from an SDL_RWops structure 
</para><screen>  define SDL_RWtell(ctx)                 (ctx)-&gt;seek(ctx, 0, SEEK_CUR)
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_GetTicks</forthname>
    <forthstack>( -- value )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_GetTicks ( -- value )</stackline>
   </forthdefinition>
   <comment><para>  Get the number of milliseconds since the SDL library initialization.
  Note that this value wraps if the program runs for more than ~49 days.
</para><screen>  Uint32 SDL_GetTicks(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_Delay</forthname>
    <forthstack>( value -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_Delay ( value -- )</stackline>
   </forthdefinition>
   <comment><para>  Wait a specified number of milliseconds before returning 
</para><screen>  void SDL_Delay(Uint32 ms);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_AudioInit</forthname>
    <forthstack>( Z-str -- status )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_AudioInit ( Z-str -- status )</stackline>
   </forthdefinition>
   <comment><para>  One of the functions that are used internally, 
  and should not be used unless you
  have a specific need to specify the audio driver you want to use.
</para><screen>  int SDL_AudioInit(const char *driver_name);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_AudioQuit</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_AudioQuit ( -- )</stackline>
   </forthdefinition>
   <comment><para>  One of the functions that are used internally, 
  and should not be used unless you
  have a specific need to specify the audio driver you want to use.
</para><screen>  void SDL_AudioQuit(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_AudioDriverName</forthname>
    <forthstack>( maxlen namebuf -- namebuf | 0 )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_AudioDriverName ( maxlen namebuf -- namebuf | 0 )</stackline>
   </forthdefinition>
   <comment><para>  This function fills the given character buffer with the name of the
  audio driver, and returns a pointer to it if the audio driver has
  been initialized.  It returns NULL if no driver has been initialized.
</para><screen>  char *SDL_AudioDriverName(char *namebuf, int maxlen);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_OpenAudio</forthname>
    <forthstack>( SDL_AudioSpec-obtained SDL_AudioSpec-desired -- status )</forthstack>
    <forthhints>;</forthhints>
    <stackline>SDL_OpenAudio ( SDL_AudioSpec-obtained SDL_AudioSpec-desired -- status );</stackline>
   </forthdefinition>
   <comment><para>  This function opens the audio device with the desired parameters, and
  returns 0 if successful, placing the actual hardware parameters in the
  structure pointed to by 'obtained'.  If 'obtained' is NULL, the audio
  data passed to the callback function will be guaranteed to be in the
  requested format, and will be automatically converted to the hardware
  audio format if necessary.  This function returns -1 if it failed 
  to open the audio device, or couldn't set up the audio thread.
</para><para>
  When filling in the desired audio spec structure,
   'desired->freq' should be the desired audio frequency in samples-per-second.
   'desired->format' should be the desired audio format.
   'desired->samples' is the desired size of the audio buffer, in samples.
      This number should be a power of two, and may be adjusted by the audio
      driver to a value more suitable for the hardware.  Good values seem to
      range between 512 and 8096 inclusive, depending on the application and
      CPU speed.  Smaller values yield faster response time, but can lead
      to underflow if the application is doing heavy processing and cannot
      fill the audio buffer in time.  A stereo sample consists of both right
      and left channels in LR ordering.
      Note that the number of samples is directly related to time by the
      following formula:  ms = (samples*1000)/freq
   'desired->size' is the size in bytes of the audio buffer, and is
      calculated by SDL_OpenAudio().
   'desired->silence' is the value used to set the buffer to silence,
      and is calculated by SDL_OpenAudio().
   'desired->callback' should be set to a function that will be called
      when the audio device is ready for more data.  It is passed a pointer
      to the audio buffer, and the length in bytes of the audio buffer.
      This function usually runs in a separate thread, and so you should
      protect data structures that it accesses by calling SDL_LockAudio()
      and SDL_UnlockAudio() in your code.
   'desired->userdata' is passed as the first parameter to your callback
      function.
</para><para>
  The audio device starts out playing silence when it's opened, and should
  be enabled for playing by calling SDL_PauseAudio(0) when you are ready
  for your audio callback function to be called.  Since the audio driver
  may modify the requested size of the audio buffer, you should allocate
  any local mixing buffers after you open the audio device.
</para><para>
</para><screen>  int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_GetAudioStatus</forthname>
    <forthstack>( -- status )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_GetAudioStatus ( -- status )</stackline>
   </forthdefinition>
   <comment><para>  Get the current audio state:
</para><screen>   typedef enum {
         SDL_AUDIO_STOPPED = 0,
         SDL_AUDIO_PLAYING,
         SDL_AUDIO_PAUSED
   } SDL_audiostatus;
  int SDL_audiostatus SDL_GetAudioStatus(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_LoadWAV_RW</forthname>
    <forthstack>( audio_len audio_buf spec* freesrc rwops* -- spec* )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_LoadWAV_RW ( audio_len audio_buf spec* freesrc rwops* -- spec* )</stackline>
   </forthdefinition>
   <comment><para>  This function loads a WAVE from the data source, automatically freeing
  that source if 'freesrc' is non-zero.  For example, to load a WAVE file,
  you could do:
       SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
</para><para>
  If this function succeeds, it returns the given SDL_AudioSpec,
  filled with the audio data format of the wave data, and sets
  'audio_buf' to a malloc()'d buffer containing the audio data,
  and sets 'audio_len' to the length of that audio buffer, in bytes.
  You need to free the audio buffer with SDL_FreeWAV() when you are 
  done with it.
</para><para>
  This function returns NULL and sets the SDL error message if the 
  wave file cannot be opened, uses an unknown data format, or is 
  corrupt.  Currently raw and MS-ADPCM WAVE files are supported.
</para><screen>  SDL_AudioSpec *SDL_LoadWAV_RW (
 		SDL_RWops *src, int freesrc,
                 SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_LoadWAV</forthname>
    <forthstack>( audio_len audio_buf spec* rwops* -- spec* )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_LoadWAV ( audio_len audio_buf spec* rwops* -- spec* )</stackline>
   </forthdefinition>
   <comment><para>  Compatibility convenience function -- loads a WAV from a file 
  see <link>SDL_LoadWAV_RW</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_FreeWAV</forthname>
    <forthstack>( audiobuf* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_FreeWAV ( audiobuf* -- )</stackline>
   </forthdefinition>
   <comment><para>  This function frees data previously allocated with SDL_LoadWAV_RW()
</para><screen>  void SDL_FreeWAV(Uint8 *audio_buf);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_ConvertAudio</forthname>
    <forthstack>( cvt* -- standard-inst )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_ConvertAudio ( cvt* -- standard-inst )</stackline>
   </forthdefinition>
   <comment><para>  Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(),
  created an audio buffer cvt->buf, and filled it with cvt->len bytes of
  audio data in the source format, this function will convert it in-place
  to the desired format.
  The data conversion may expand the size of the audio data, so the buffer
  cvt->buf should be allocated after the cvt structure is initialized by
  SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long.
</para><screen>  int SDL_ConvertAudio(SDL_AudioCVT *cvt);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_MixAudio</forthname>
    <forthstack>( volume len src dst -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_MixAudio ( volume len src dst -- )</stackline>
   </forthdefinition>
   <comment><para>  This takes two audio buffers of the playing audio format and mixes
  them, performing addition, volume adjustment, and overflow clipping.
  The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
  for full audio volume.  Note this does not change hardware volume.
  This is provided for convenience -- you can mix your own audio data.
</para><screen>  define SDL_MIX_MAXVOLUME 128
  void SDL_MixAudio(Uint8 *dst, Uint8 *src, Uint32 len, int volume);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_LockAudio</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_LockAudio ( -- )</stackline>
   </forthdefinition>
   <comment><para>  The lock manipulated by these functions protects the callback function.
  During a LockAudio/UnlockAudio pair, you can be guaranteed that the
  callback function is not running.  Do not call these from the callback
  function or you will cause deadlock.
</para><screen>  void SDL_LockAudio(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_UnlockAudio</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_UnlockAudio ( -- )</stackline>
   </forthdefinition>
   <comment><para>  The lock manipulated by these functions protects the callback function.
  During a LockAudio/UnlockAudio pair, you can be guaranteed that the
  callback function is not running.  Do not call these from the callback
  function or you will cause deadlock.
</para><screen>  void SDL_UnlockAudio(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_Linked_Version</forthname>
    <forthstack>( -- SDL_version* )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_Linked_Version ( -- SDL_version* )</stackline>
   </forthdefinition>
   <comment><para>   This function gets the version of the dynamically linked SDL library.
   it should NOT be used to fill a version structure, instead you should
   use the SDL_Version() macro. see <link>SDL_LinkedVersion</link>
</para><screen>  extern DECLSPEC const SDL_version * SDL_Linked_Version(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_LinkedVersion</forthname>
    <forthstack>( -- SDL_versionnum )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_LinkedVersion ( -- SDL_versionnum )</stackline>
   </forthdefinition>
   <comment><para>   This function gets the version of the dynamically linked SDL library.
   it should NOT be used to fill a version structure, instead you should
   use the SDL_Version() macro. see <link>SDL_LinkedVersion</link>
</para><screen>  implementation applies the SDL_VERSIONNUM macro to
  extern DECLSPEC const SDL_version * SDL_Linked_Version(void);
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SDL_CompiledVersion</forthname>
    <forthstack>( -- SDL_versionnum )</forthstack>
    <forthhints></forthhints>
    <stackline>SDL_CompiledVersion ( -- SDL_versionnum )</stackline>
   </forthdefinition>
   <comment><para>   This function gets the version of the SDL library headers the PFE 
   has been linked with. It returns the compact code from SDL_VERSIONNUM
   macro
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/locals-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(LOCAL)          ( strptr strcnt -- )</stackline>
   </forthdefinition>
   <comment><para>  this word is used to create compiling words that can
  declare <link>LOCALS|</link> - it shall not be used directly
  to declare a local, the pfe provides <link>LVALUE</link> for
  that a purpose beyond <link>LOCALS|</link> 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOCALS|</forthname>
    <forthstack>( xN ... x2 x1 [name1 .. nameN &lt;|&gt;] -- )</forthstack>
    <forthhints></forthhints>
    <stackline>LOCALS|   ( xN ... x2 x1 [name1 .. nameN &lt;|&gt;] -- )</stackline>
   </forthdefinition>
   <comment><para>  create local identifiers to be used in the current definition.
  At runtime, each identifier will be assigned a value from
  the parameter stack. <br>
  The identifiers may be treated as if being a <link>VALUE</link> , it does
  also implement the ansi <link>TO</link> extensions for locals. Note that
  the identifiers are only valid inside the currently compiled
  word, the <link>SEE</link> decompiled word will show them as 
  <link><A></link> <link><B></link> ... <link><N></link> a.s.o.   <br>
  see also <link>LVALUE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LVALUE</forthname>
    <forthstack>( value [name] -- )</forthstack>
    <forthhints></forthhints>
    <stackline>LVALUE ( value [name] -- )</stackline>
   </forthdefinition>
   <comment><para>  declares a single local <link>VALUE</link> using <link>(LOCAL)</link> - a 
  sequence of <link>LVALUE</link> declarations can replace a 
  <link>LOCALS|</link> argument, ie. <code> LOCALS| a b c | </code> 
  is the same as <code> LVALUE a  LVALUE b  LVALUE c </code>.
  This should also clarify the runtime stack behaviour of
  <link>LOCALS|</link> where the stack parameters seem to be
  assigned in reverse order as opposed to their textual
  identifier declarations. <br>
  compare with <link>VALUE</link> and the pfe's convenience word
  <link>VAR</link>.
</para><para>
</para><screen>  : LVALUE 
    STATE @ IF 
      VALUE 
    ELSE 
      BL WORD COUNT DUP (LOCAL) (TO)
    THEN
  ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LBUFFER:</forthname>
    <forthstack>( size [name] -- )</forthstack>
    <forthhints></forthhints>
    <stackline>LBUFFER: ( size [name] -- )</stackline>
   </forthdefinition>
   <comment><para>  declares a single local <link>VALUE</link> using <link>(LOCAL)</link> - which
  will hold the address of an area like <link>BUFFER:</link> but carved
  from the return-stack (as in C with alloca). This local buffer
  will be automatically given up at the end of the word. The
  return-stack-pointer will be increased only at the time of
  this function (and the address assigned to the <link>LVALUE</link>)
  so that the provided size gets determined at runtime. Note
  that in some configurations the forth-return-stack area is
  quite small - for large string operations you should consider
  to use a <link>POCKET-PAD</link> in pfe.
</para><screen>  : LBUFFER:
    STATE @ IF 
      BUFFER:
    ELSE 
      :NONAME ( size -- rp* ) R&gt; RP@ - DUP RP! SWAP &gt;R ;NONAME
      COMPILE, POSTPONE LVALUE
    THEN
  ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT #LOCALS</forthname>
    <forthstack>( -- number )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT #LOCALS" ( -- number )</stackline>
   </forthdefinition>
   <comment><para>  the number of local names allowed during compilation.
  portable programs can check this with <link>ENVIRONMENT</link>?
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/memory-alloc-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>ALLOCATE</forthname>
    <forthstack>( size# -- alloc*! 0 | 0 errno#! )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>ALLOCATE ( size# -- alloc*! 0 | 0 errno#! ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  Allocate a chunk of memory from the system heap.
  use <link>FREE</link> to release the memory area back to the system. <br>
  A code of zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FREE</forthname>
    <forthstack>( alloc* -- errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>FREE ( alloc* -- errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  Free the memory from <link>ALLOCATE</link>
  A code of zero means success.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RESIZE</forthname>
    <forthstack>( alloc* newsize# -- alloc*' errno# )</forthstack>
    <forthhints> [ANS]</forthhints>
    <stackline>RESIZE ( alloc* newsize# -- alloc*' errno# ) [ANS]</stackline>
   </forthdefinition>
   <comment><para>  Resize the system memory chunk. A code of zero means success.
  Our implementation returns the old pointer on failure.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/misc-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>COLD</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>COLD ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  cold abort - reinitialize everything and go to <link>QUIT</link> routine
  ... this routine is implemented as a warm-boot in pfe.
</para><screen>  : COLD [ ALSO ENVIRONMENT ] EMPTY SCRIPT-FILE INCLUDED QUIT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.LINE</forthname>
    <forthstack>( line# block# -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>.LINE ( line# block# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UD.R</forthname>
    <forthstack>( x,x# r# -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>UD.R ( x,x# r# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UD.</forthname>
    <forthstack>( x,x# -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>UD. ( x,x# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see also <link>UD</link>.R
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.NAME</forthname>
    <forthstack>( some-nfa* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>.NAME ( some-nfa* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  use <link>ID</link>. or better <link>NAME>STRING</link> <link>TYPE</link>
  (the => .NAME word is not very portable across forth systems)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ID.</forthname>
    <forthstack>( some-nfa* -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>ID. ( some-nfa* -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  print the name-field pointed to by the nfa-argument.
  a synonym for .NAME - but this word is more portable due its
  heritage from fig-forth.
</para><para>
  in fig-forth the name-field is effectivly a bstring with some flags,
  so the nfa's count has to be masked out, e.g.
</para><screen>  : .NAME COUNT 32 AND TYPE ;
</screen><para>
  in other pfe configurations, the name might not contain the flags it
  it just a counted string - and there may be even more possibilities.
</para><screen>  : .NAME COUNT TYPE ;
</screen><para>
  you should more and more convert your code to use the sequence
  <link>NAME>STRING</link> <link>TYPE</link> which is widely regarded as the better
  variant.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-ROLL</forthname>
    <forthstack>( x...[n-1] y n# -- y x...[n-1] |  num# -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>-ROLL ( x...[n-1] y n# -- y x...[n-1] |  num# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  the inverse of <link>ROLL</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RANDOM</forthname>
    <forthstack>( n# -- random# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>RANDOM ( n# -- random# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  returns random number with 0 <= n2 < n1)
</para><screen>  : RANDOM ?DUP IF _random SWAP MOD ELSE _random THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SRAND</forthname>
    <forthstack>( seed# -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>SRAND ( seed# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UNDER+</forthname>
    <forthstack>( n1 x n2 -- n1+n2 x [??] | n1 n2 -- n1+n2 n2 [??] )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>UNDER+ ( n1 x n2 -- n1+n2 x [??] | n1 n2 -- n1+n2 n2 [??] ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>      quicker than
</para><screen>  : UNDER+  ROT + SWAP ;
</screen><para>  Note: the old pfe version of UNDER+ is obsolete as it is in conflict
  with a comus word of the same name. The behavior of this word will
  continue to exist under the name of <link>(UNDER+)</link>. Users are encouraged
  to use the comus behavior of UNDER+ which does already exist under
  the name of <link>+UNDER</link>. In the future pfe will be changed to pick up
  the comus behavior making UNDER+ and +UNDER to be synonyms. In the
  current version there will be load-time warning on usages of "UNDER+".
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+UNDER</forthname>
    <forthstack>( n1 x n2 -- n1+n2 x )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>+UNDER ( n1 x n2 -- n1+n2 x ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>      quicker than
</para><screen>  : UNDER+  ROT + SWAP ;
</screen><para>  Note: the old pfe version of UNDER+ is obsolete as it is in conflict
  with a comus word of the same name. The behavior of this word will
  continue to exist under the name of <link>(UNDER+)</link>. Users are encouraged
  to use the comus behavior of UNDER+ which does already exist under
  the name of <link>+UNDER</link>. In the future pfe will be changed to pick up
  the comus behavior making UNDER+ and +UNDER to be synonyms. In the
  current version there will be load-time warning on usages of "UNDER+".
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(UNDER+)</forthname>
    <forthstack>( n1 n2 -- n1+n2 n2 )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>"(UNDER+)" ( n1 n2 -- n1+n2 n2 ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  quicker than
</para><screen>  : (UNDER+) TUCK + SWAP ; or : (UNDER+) DUP UNDER+ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((+TO)) ( val -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>+TO</link>
  adds the stack-val to the lvalue compiled
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((+TO.local)) ( val -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  same as <link>((+TO))</link> when the lvalue is a <link>LOCALS|</link> value
  <br> compiled by <link>+TO</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+TO</forthname>
    <forthstack>( val [name] -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>+TO ( val [name] -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  add the val to the named <link>VALUE</link> or <link>LOCALS|</link> value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BUILD-ARRAY</forthname>
    <forthstack>( x#...[dim] dim# -- memsize# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>BUILD-ARRAY ( x#...[dim] dim# -- memsize# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  writes X, n1, ... nX into the dictionary -
  returns product n1 * n2 * ... * nX
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ACCESS-ARRAY</forthname>
    <forthstack>( x#...[dim#] array* --- array* value# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>ACCESS-ARRAY ( x#...[dim#] array* --- array* value# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>BUILD-ARRAY</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SOURCE-LINE</forthname>
    <forthstack>( -- source-line# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>SOURCE-LINE ( -- source-line# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  if <link>SOURCE</link> is from <link>EVALUATE</link> (or <link>QUERY</link> ) then
  the result is 0 else the line-numbers start from 1
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SOURCE-NAME</forthname>
    <forthstack>( -- source-name-ptr source-name-len )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>SOURCE-NAME ( -- source-name-ptr source-name-len ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  if <link>SOURCE</link> is from <link>INCLUDE</link> then the result is the filename,
  otherwise a generic name for the SOURCE-ID is given.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TH'POCKET</forthname>
    <forthstack>( pocket# -- pocket-ptr pocket-len )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>TH'POCKET ( pocket# -- pocket-ptr pocket-len ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  returns the specified pocket as a <link>S"</link> string reference
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>POCKET-PAD</forthname>
    <forthstack>( -- pocket-ptr )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>POCKET-PAD ( -- pocket-ptr ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>This function  Returns the next pocket.
  A pocket has usually the size of a maxstring, see <link>ENVIRONMENT /STRING</link>
  (but can be configured to be different, mostly when MAXPATH > /STRING )
  Note that a pocket is a temporary and forth internal functions do
  sometimes call <link>POCKET-PAD</link> too, especially when building filenames
  and getting a literal (but temporary) string from the keyboard.
  Functions are not expected to hold references to this transient
  area any longer than building a name and calling another word with it.
</para><para>  Usage of a pocket pad is a good way to make local temporary buffers
  superfluous that are only used to construct a temporary string that
  usually gets swallowed by another function.
</para><screen>  depracated code:
    create temp-buffer 255 allot
    : make-temp ( str buf )
           temp-buffer place  " .tmp" count temp-buffer append
           temp-buffer count make-file ;
  replace with this:
    : make-temp ( str buf )
         pocket-pad &gt;r
         r place  " .tmp" count r append
         r&gt; count make-file
    ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WL-HASH</forthname>
    <forthstack>( buf-ptr buf-len -- buf-hash# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>WL-HASH ( buf-ptr buf-len -- buf-hash# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  calc hash-code for selection of thread
  in a threaded-vocabulary
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TOPMOST</forthname>
    <forthstack>( some-wordlist* -- some-topmost-nfa* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>TOPMOST ( some-wordlist* -- some-topmost-nfa* ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  that last valid word in the specified vocabulary
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LS.WORDS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LS.WORDS ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LS.PRIMITIVES</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LS.PRIMITIVES ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LS.COLON-DEFS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LS.COLON-DEFS ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LS.DOES-DEFS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LS.DOES-DEFS ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LS.CONSTANTS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LS.CONSTANTS ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LS.VARIABLES</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LS.VARIABLES ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LS.VOCABULARIES</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LS.VOCABULARIES ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LS.MARKERS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>LS.MARKERS ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  see <link>WORDS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>W@</forthname>
    <forthstack>( some-wchar* -- some-wchar# | some* -- some# [?] )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>W@ ( some-wchar* -- some-wchar# | some* -- some# [?] ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  fetch a 2byte-val from address
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>W!</forthname>
    <forthstack>( value#  some-wchar* -- | value# wchar* -- [?] )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>W! ( value#  some-wchar* -- | value# wchar* -- [?] ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  store a 2byte-val at addressed 2byte-value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>W+!</forthname>
    <forthstack>( value# some-wchar* -- | value# wchar* -- [?] )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>W+! ( value# some-wchar* -- | value# wchar* -- [?] ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  add a 2byte-val to addressed 2byte-value
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TAB</forthname>
    <forthstack>( tab-n# -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>TAB ( tab-n# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  jump to next column divisible by n
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BACKSPACE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>BACKSPACE ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  reverse of <link>SPACE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?STOP</forthname>
    <forthstack>( -- stop-flag )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>?STOP ( -- stop-flag ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  check for 'q' pressed
  - see => ?CR
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>START?CR</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>START?CR ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  initialized for more-like effect
  - see => ?CR
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?CR</forthname>
    <forthstack>( -- cr-flag )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>?CR ( -- cr-flag ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  like <link>CR</link> , stop 25 lines past <link>START</link>?CR
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CLOSE-ALL-FILES</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>CLOSE-ALL-FILES ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.MEMORY</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>.MEMORY ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.STATUS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>.STATUS ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  display internal variables
</para><screen>  : .STATUS .VERSION .CVERSION .MEMORY .SEARCHPATHS .DICTVARS .REGSUSED ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>*EMIT*</forthname>
    <forthstack>( -- handler-xt* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>*EMIT* ( -- handler-xt* ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  initialized to <link>(EMIT)</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(EMIT) ( char# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  like <link>EMIT</link> and always to screen
  - the routine to be put into <link>*EMIT*</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>*EXPECT*</forthname>
    <forthstack>( -- handler-xt* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>*EXPECT* ( -- handler-xt* ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  initialized to <link>(EXPECT)</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(EXPECT) ( a b -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  like <link>EXPECT</link> and always from screen
  - the routine to be put into <link>*EXPECT*</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>*KEY*</forthname>
    <forthstack>( -- handler-xt* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>*KEY* ( -- handler-xt* ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  initialized to <link>(KEY)</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(KEY) ( -- key# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  like <link>KEY</link> and always from screen
  - the routine to be put into <link>*KEY*</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(TYPE) ( str* len# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  like <link>TYPE</link> and always to screen
  - the routine to be put into <link>*TYPE*</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STANDARD-I/O</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>STANDARD-I/O ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  initialize <link>*TYPE*</link> , <link>*EMIT*</link> , <link>*EXPECT*</link> and <link>*KEY*</link>
  to point directly to the screen I/O routines, <br>
  namely <link>(TYPE)</link> , <link>(EMIT)</link> , <link>(EXPECT)</link> , <link>(KEY)</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((EXECUTES)) ( fkey# -- ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>EXECUTES</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXECUTES</forthname>
    <forthstack>( fkey# [word] -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>EXECUTES ( fkey# [word] -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  stores the execution token of following word into
  the callback pointer for the specified function-key
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>HELP</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints> [FTH] [EXEC]</forthhints>
    <stackline>HELP ( "name" -- ) [FTH] [EXEC]</stackline>
   </forthdefinition>
   <comment><para>  will load the help module in the background and hand over the
  parsed name to <link>(HELP)</link> to be resolved. If no <link>(HELP)</link> word
  can be loaded, nothing will happen.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EDIT-BLOCKFILE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints> [FTH] [EXEC]</forthhints>
    <stackline>EDIT-BLOCKFILE ( "name" -- ) [FTH] [EXEC]</stackline>
   </forthdefinition>
   <comment><para>  will load the edit module in the background and look for a word
  called <link>EDIT-BLOCK</link> that could be used to edit the blockfile.
  If no <link>EDIT-BLOCKFILE</link> word can be loaded, nothing will happen.
  Otherwise, <link>OPEN-BLOCKFILE</link> is called followed by <link>0</link> <link>EDIT-BLOCK</link>
  to start editing the file at the first block.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ARGC</forthname>
    <forthstack>( -- arg-count )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>ARGC ( -- arg-count ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ARGV</forthname>
    <forthstack>( arg-n# -- arg-ptr arg-len )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>ARGV ( arg-n# -- arg-ptr arg-len ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXPAND-FN</forthname>
    <forthstack>( name-ptr name-len buf-ptr -- buf-ptr buf-len )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>EXPAND-FN ( name-ptr name-len buf-ptr -- buf-ptr buf-len ) [FTH]</stackline>
   </forthdefinition>
   <comment><screen> 
  : e.g. s" includefile" POCKET-PAD EXPAND-FN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((LOAD")) ( -- ? ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOAD"</forthname>
    <forthstack>( [filename&lt;"&gt;] -- ??? )</forthstack>
    <forthhints> [FTH] [OLD]</forthhints>
    <stackline>LOAD"  ( [filename&lt;"&gt;] -- ??? ) [FTH] [OLD]</stackline>
   </forthdefinition>
   <comment><para>  load the specified file - this word can be compiled into a word-definition
  obsolete! use <link>OPEN-BLOCKFILE</link> name <link>LOAD</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SYSTEM</forthname>
    <forthstack>( command-ptr command-len -- command-exitcode# )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>SYSTEM ( command-ptr command-len -- command-exitcode# ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  run a shell command  (note: embedded systems have no shell)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((SYSTEM")) ( ... -- exitcode# ) [HIDDEN]</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>SYSTEM"</link> commandline"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SYSTEM"</forthname>
    <forthstack>( [command-line&lt;"&gt;] -- command-exitcode# )</forthstack>
    <forthhints> [FTH] [OLD]</forthhints>
    <stackline>SYSTEM" ( [command-line&lt;"&gt;] -- command-exitcode# ) [FTH] [OLD]</stackline>
   </forthdefinition>
   <comment><para>  run a shell command (note:embedded systems have no shell)
  obsolete! use <link>S"</link> string" <link>SYSTEM</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OK</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>OK ( -- )</stackline>
   </forthdefinition>
   <comment><para>  it usually prints "ok"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CREATE:</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>CREATE: ( "name" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  this creates a name with the <link>VARIABLE</link> runtime.
  Note that this is the FIG-implemenation of <link>CREATE</link> whereas in
  ANS-Forth mode we have a <link>CREATE</link> identical to FIG-style <link><BUILDS</link>
</para><screen>  : CREATE: BL WORD $HEADER DOVAR A, ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BUFFER:</forthname>
    <forthstack>( size# "name" -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>BUFFER: ( size# "name" -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  this creates a name with the <link>VARIABLE</link> runtime and <link>ALLOT</link>s memory
</para><screen>  : BUFFER: BL WORD $HEADER DOVAR A, ALLOT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R'@</forthname>
    <forthstack>( R: a b -- a R: a b )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>R'@ ( R: a b -- a R: a b ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  fetch the next-under value from the returnstack.
  used to interpret the returnstack to hold two <link>LOCALS|</link> values.
  ( <link>R@</link> / <link>2R@</link> / <link>R>DROP</link> / <link>R"@</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R'!</forthname>
    <forthstack>( x R: a b -- R: x b )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>R'! ( x R: a b -- R: x b ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  store the value into the next-under value in the returnstack.
  used to interpret the returnstack to hold two <link>LOCALS|</link> values.
  see <link>R'@</link> for inverse operation
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R"@</forthname>
    <forthstack>( R: a b c -- a R: a b c )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>R"@ ( R: a b c -- a R: a b c ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  fetch the second-under value from the returnstack.
  used to interpret the returnstack to hold three <link>LOCALS|</link> values.
  see <link>R"!</link> for inverse operation ( <link>R'@</link> <link>R@</link> / <link>2R@</link> / <link>R>DROP</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R"!</forthname>
    <forthstack>( x R: a b c -- R: x b c )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>R"! ( x R: a b c -- R: x b c ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  store the value into the second-under value in the returnstack.
  used to interpret the returnstack to hold three <link>LOCALS|</link> values.
  see <link>R"@</link> for inverse operation
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R!</forthname>
    <forthstack>( x R: a -- R: x )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>R! ( x R: a -- R: x ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  store the value as the topmost value in the returnstack.
  see <link>R@</link> for inverse operation ( <link>R'@</link> / <link>R"@</link> / <link>2R@</link> / <link>2R!</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2R!</forthname>
    <forthstack>( x y R: a b -- R: x y )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>2R! ( x y R: a b -- R: x y ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  store the value as the topmost value in the returnstack.
  see <link>2R@</link> for inverse operation ( <link>R'@</link> / <link>R"@</link> / <link>2R@</link> / <link>2R!</link>)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DUP&gt;R</forthname>
    <forthstack>( val -- val R: val )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>DUP&gt;R ( val -- val R: val ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  shortcut, see <link>R>DROP</link>
  <br> note again that the following will fail:
</para><screen>  : DUP&gt;R DUP &gt;R ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R&gt;DROP</forthname>
    <forthstack>( R: val -- R: )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>R&gt;DROP ( R: val -- R: ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  shortcut (e.g. in CSI-Forth)
  <br> note that the access to R is configuration dependent - only in
  a traditional fig-forth each NEST will be one cell wide - in case that
  there are no <link>LOCALS|</link> of course. And remember, the word above reads
  like the sequence <link>R></link> and <link>DROP</link> but that is not quite true.
</para><screen>  : R&gt;DROP R&gt; DROP ; ( is bad - correct might be )  : R&gt;DROP R&gt; R&gt; DROP &gt;R ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2R&gt;2DROP</forthname>
    <forthstack>( R: a b -- R: )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>2R&gt;2DROP ( R: a b -- R: ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  this is two times <link>R>DROP</link> but a bit quicker.
  it is however really quick compared to the sequence <link>2R></link> and <link>2DROP</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CLEARSTACK</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>CLEARSTACK ( -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  reset the parameter stack to be empty
</para><screen>  : CLEARSTACK  S0 SP! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOWER-CASE</forthname>
    <forthstack>( -- uppercase-var* )</forthstack>
    <forthhints> [OLD]</forthhints>
    <stackline>LOWER-CASE ( -- uppercase-var* ) [OLD]</stackline>
   </forthdefinition>
   <comment><para>  Call to enable lower-case symbols as input
  Replace code of "LOWER-CASE OFF" with "NO TO UPPER-CASE?"
  see <link>UPPER-CASE</link>?
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UPPER-CASE?</forthname>
    <forthstack>( -- uppercase-flag )</forthstack>
    <forthhints></forthhints>
    <stackline>UPPER-CASE? ( -- uppercase-flag )</stackline>
   </forthdefinition>
   <comment><para>  Call to check whether lower-case symbols in input can match
  words defined in uppercase. Actually it sets the internal
  wordl-flag which has some bit-defs used when creating new
  vocabularies.
</para><para>
  This flag <link>VALUE</link> is modifiable with <link>TO</link>
</para><screen>    YES TO UPPER-CASE?
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REDEFINED-MSG</forthname>
    <forthstack>( -- redefined-var* )</forthstack>
    <forthhints> [OLD]</forthhints>
    <stackline>REDEFINED-MSG ( -- redefined-var* ) [OLD]</stackline>
   </forthdefinition>
   <comment><para>  Call to enable warnings if creating symbols being in the <link>ORDER</link>
  Replace code of "REDEFINED-MSG OFF" with "NO TO REDEFINED-MSG?"
  see <link>REDEFINED-MSG</link>?
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REDEFINED-MSG?</forthname>
    <forthstack>( -- redefined-flag )</forthstack>
    <forthhints></forthhints>
    <stackline>REDEFINED-MSG? ( -- redefined-flag )</stackline>
   </forthdefinition>
   <comment><para>  Call to check whether the system will emit warnings if creating
  symbols being already defined in the <link>CURRENT</link> vocabulary.
</para><para>
  This flag <link>VALUE</link> is modifiable with <link>TO</link>
</para><screen>    YES TO REDEFINED-MSG?
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>QUOTED-PARSE</forthname>
    <forthstack>( -- quotedparse-var* )</forthstack>
    <forthhints> [OLD]</forthhints>
    <stackline>QUOTED-PARSE ( -- quotedparse-var* ) [OLD]</stackline>
   </forthdefinition>
   <comment><para>  Call to enable quoted-parse extension in <link>PARSE</link> <link>WORD</link>s
  Replace code of "QUOTED-PARSE OFF" with "NO TO QUOTED-PARSE?"
  see <link>QUOTED-PARSE</link>?
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>QUOTED-PARSE?</forthname>
    <forthstack>( -- quotedparse-flag )</forthstack>
    <forthhints></forthhints>
    <stackline>QUOTED-PARSE? ( -- quotedparse-flag )</stackline>
   </forthdefinition>
   <comment><para>  Call to check for quoted-parse extension in <link>PARSE</link> <link>WORD</link>s
</para><para>
  This flag <link>VALUE</link> is modifiable with <link>TO</link>
</para><screen>    YES TO QUOTED-PARSE?
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RAND_MAX</forthname>
    <forthstack>( -- rand-max )</forthstack>
    <forthhints> [ENVIRONMENT]</forthhints>
    <stackline>RAND_MAX ( -- rand-max ) [ENVIRONMENT]</stackline>
   </forthdefinition>
   <comment><para>  maximum value for <link>RANDOM</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline> ( -- fid ) - the standard file-handles of the task </stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/module-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>MODULE</forthname>
    <forthstack>( "name" -- old-current )</forthstack>
    <forthhints></forthhints>
    <stackline>MODULE ( "name" -- old-current )</stackline>
   </forthdefinition>
   <comment><para>  create a new <link>WORDLIST</link> with the given name. It
  will also have an implicit hidden vocabulary just as
  well and all <link>DEFINITIONS</link> will go into that
  hidden wordlist. Therefore the old <link>CURRENT</link> is
  memorized on the cs-stack.
</para><para>
  effectivly, CONTEXT[1] will have the wordlist-id
  of the public wordlist "name" and CONTEXT[0] will
  have the hidden wordlist contained in "name" - the
  hidden wordlist will always be known as HIDDEN' so
  that it can be re-referenced without need to use
  <link>ALSO</link> just to access a single definition from 
  just another vocabulary. Note that HIDDEN' is 
  defined immediate (a <link>VOCABULARY'</link> ) to modify
  the <link>ORDER</link> inside a colon definition.
</para><screen>  : MODULE
    CURRENT @ ( -- old-current )
    VOCABULARY
    ALSO LATEST NAME&gt; EXECUTE ALSO DEFINITIONS
    C" HIDDEN'" $CREATE WORDLIST CONTEXT !
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>END-MODULE</forthname>
    <forthstack>( old-current -- )</forthstack>
    <forthhints></forthhints>
    <stackline>END-MODULE ( old-current -- )</stackline>
   </forthdefinition>
   <comment><para>  clean up the cs-stack from the last <link>MODULE</link> 
  definition. Effectivly, MODULE definitions can
  be nested.
</para><screen>  : END-MODULE ( old-current )
    PREVIOUS PREVIOUS CURRENT ! 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXPORT</forthname>
    <forthstack>( old-current "name" -- old-current )</forthstack>
    <forthhints></forthhints>
    <stackline>EXPORT ( old-current "name" -- old-current )</stackline>
   </forthdefinition>
   <comment><para>  the named word in the hidden dictionary (i.e. 
  the wordlist referenced in <link>CURRENT</link>) is exported
  into the public wordlist of it (i.e. which is in
  this implementation <link>CONTEXT</link>[1]). The actual
  implemenation will create a <link>DEFER</link>-word in the
  public wordlist withits parameter area pointing
  to the cfa of the hidden implementation.
</para><screen>  : EXPORT
    CURRENT @ CONTEXT CELL+ @ CURRENT !
    DEFER CURRENT !
    LATEST COUNT CURRENT @ SEARCH-WORDLIST
    IF LATEST NAME&gt; &gt;BODY ! ELSE ABORT" can't find word to export" THEN
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EXPOSE-MODULE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EXPOSE-MODULE ( "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  affects the search order, ALSO module-wid CONTEXT ! hidden'
</para><screen>  : EXPOSE-MODULE 
     ALSO S" HIDDEN'" 
     ' DUP VOC? ABORT?" is no vocabulary" &gt;VOC 
     SEARCH-WORDLIST 0= IF " no hidden vocabulary found" THEN
     DUP VOC? ABORT?" hidden is no vocabulary" EXECUTE
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ALSO-MODULE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ALSO-MODULE ( "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  affects the search-order, ALSO module-wid CONTEXT ! 
</para><screen>  : ALSO-MODULE
    ' DUP VOC? ABORT?" is no vocabulary" 
    ALSO EXECUTE
  ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/option-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>NVRAM,WORDS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>NVRAM,WORDS ( -- )</stackline>
   </forthdefinition>
   <comment><para>
  Print a list of <link>WORDS</link> in the NVRAM buffer. Try to show also the
  current value, atleast for NVRAM numbers and strings. Words can be
  added or changed with the help of <link>NVRAM</link>,SET or <link>NVRAM</link>,USE
</para><para>
  Values in the NVRAM buffer will survive a <link>COLD</link> reboot, in many
  hosted environments however the NVRAM will be lost on program exit.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NVRAM,AS</forthname>
    <forthstack>( str-ptr str-len "varname" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>NVRAM,AS ( str-ptr str-len "varname" -- )</stackline>
   </forthdefinition>
   <comment><para>  set the NVRAM variable to the specified string.
</para><para>
  Some NVRAM strings do not take effect until next <link>COLD</link> reboot.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NVRAM,TO</forthname>
    <forthstack>( number "varname" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>NVRAM,TO ( number "varname" -- )</stackline>
   </forthdefinition>
   <comment><para>  set the NVRAM variable to the specified number.
</para><para>
  Most NVRAM numbers do not take effect until next <link>COLD</link> reboot.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NVRAM,Z@</forthname>
    <forthstack>( "varname" -- z-str )</forthstack>
    <forthhints></forthhints>
    <stackline>NVRAM,Z@ ( "varname" -- z-str )</stackline>
   </forthdefinition>
   <comment><para>
  Return the string pointer of the NVRAM string item, or null if no
  such item exists.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NVRAM,S@</forthname>
    <forthstack>( "varname" -- str-ptr str-len )</forthstack>
    <forthhints></forthhints>
    <stackline>NVRAM,S@ ( "varname" -- str-ptr str-len )</stackline>
   </forthdefinition>
   <comment><para>
  Return the string span of the NVRAM string item, or double null if no
  such item exists.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NVRAM,?@</forthname>
    <forthstack>( number "varname" -- number' )</forthstack>
    <forthhints></forthhints>
    <stackline>NVRAM,?@ ( number "varname" -- number' )</stackline>
   </forthdefinition>
   <comment><para>
  Return the value of the NVRAM value item, or leave the original
  number untouched (i.e. the default value for your option).
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/posix-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>NTOHS</forthname>
    <forthstack>( w -- w' )</forthstack>
    <forthhints></forthhints>
    <stackline>NTOHS ( w -- w' )</stackline>
   </forthdefinition>
   <comment><para>  if current host-encoding is bigendian, this is a NOOP
  otherwise byteswap the lower 16-bit bits of the topofstack.
  see <link>W@</link> and <link>W!</link>
  (on some platforms, the upper bits are erased, on others not)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NTOHL</forthname>
    <forthstack>( l -- l' )</forthstack>
    <forthhints></forthhints>
    <stackline>NTOHL ( l -- l' )</stackline>
   </forthdefinition>
   <comment><para>  if current host-encoding is bigendian, this is a NOOP
  otherwise byteswap the lower 32-bit bits of the topofstack.
  see <link>L@</link> and <link>L!</link> (being usually just <link>@</link> and <link>!</link> )
  (on some platforms, the upper bits are erased, on others not)
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/search-order-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>DEFINITIONS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>DEFINITIONS ( -- )</stackline>
   </forthdefinition>
   <comment><para>  make the current context-vocabulary the definition-vocabulary,
  that is where new names are declared in. see <link>ORDER</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>GET-CURRENT</forthname>
    <forthstack>( -- voc )</forthstack>
    <forthhints></forthhints>
    <stackline>GET-CURRENT ( -- voc )</stackline>
   </forthdefinition>
   <comment><para>  return the current definition vocabulary, see <link>DEFINITIONS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>GET-ORDER</forthname>
    <forthstack>( -- vocn ... voc1 n )</forthstack>
    <forthhints></forthhints>
    <stackline>GET-ORDER ( -- vocn ... voc1 n )</stackline>
   </forthdefinition>
   <comment><para>  get the current search order onto the stack, see <link>SET-ORDER</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SEARCH-WORDLIST</forthname>
    <forthstack>( str-ptr str-len voc -- 0 | xt 1 | xt -1 )</forthstack>
    <forthhints></forthhints>
    <stackline>SEARCH-WORDLIST ( str-ptr str-len voc -- 0 | xt 1 | xt -1 )</stackline>
   </forthdefinition>
   <comment><para>  almost like <link>FIND</link> or <link>(FIND)</link> -- but searches only the
  specified vocabulary.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SET-CURRENT</forthname>
    <forthstack>( voc -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SET-CURRENT ( voc -- )</stackline>
   </forthdefinition>
   <comment><para>  set the definition-vocabulary. see <link>DEFINITIONS</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SET-ORDER</forthname>
    <forthstack>( vocn ... voc1 n -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SET-ORDER ( vocn ... voc1 n -- )</stackline>
   </forthdefinition>
   <comment><para>  set the search-order -- probably saved beforehand using
  <link>GET-ORDER</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WORDLIST</forthname>
    <forthstack>( -- voc )</forthstack>
    <forthhints></forthhints>
    <stackline>WORDLIST ( -- voc )</stackline>
   </forthdefinition>
   <comment><para>  return a new vocabulary-body for private definitions.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ALSO</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ALSO ( -- )</stackline>
   </forthdefinition>
   <comment><para>  a <link>DUP</link> on the search <link>ORDER</link> - each named vocabulary
  replaces the topmost <link>ORDER</link> vocabulary. Using <link>ALSO</link>
  will make it fixed to the search-order. (but it is 
  not nailed in trap-conditions as if using <link>DEFAULT-ORDER</link> )
</para><screen>  order:   vocn ... voc2 voc1 -- vocn ... voc2 voc1 voc1
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ORDER</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ORDER ( -- )</stackline>
   </forthdefinition>
   <comment><para>  show the current search-order, followed by 
  the <link>CURRENT</link> <link>DEFINITIONS</link> vocabulary 
  and the <link>ONLY</link> base vocabulary
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PREVIOUS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>PREVIOUS ( -- )</stackline>
   </forthdefinition>
   <comment><para>  the invers of <link>ALSO</link> , does a <link>DROP</link> on the search <link>ORDER</link>
  of vocabularies.
</para><screen>  order: vocn ... voc2 voc1 -- vocn ... voc2 
  example: ALSO PRIVATE-VOC DEFINTIONS (...do some...) PREVIOUS DEFINITIONS
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DEFAULT-ORDER</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>DEFAULT-ORDER ( -- )</stackline>
   </forthdefinition>
   <comment><para>  nail the current search <link>ORDER</link> so that it will even
  survive a trap-condition. This default-order can be
  explicitly loaded with <link>RESET-ORDER</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RESET-ORDER</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>RESET-ORDER ( -- )</stackline>
   </forthdefinition>
   <comment><para>  load the <link>DEFAULT-ORDER</link> into the current search <link>ORDER</link>
  - this is implicitly done when a trap is encountered.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENVIRONMENT WORDLISTS</forthname>
    <forthstack>( -- value )</forthstack>
    <forthhints></forthhints>
    <stackline>"ENVIRONMENT WORDLISTS" ( -- value )</stackline>
   </forthdefinition>
   <comment><para>  the maximum number of wordlists in the search order
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FORTH-WORDLIST</forthname>
    <forthstack>( -- voc )</forthstack>
    <forthhints></forthhints>
    <stackline>FORTH-WORDLIST ( -- voc )</stackline>
   </forthdefinition>
   <comment><para>  return the voc-address of the base FORTH-vocabulary
  (quite often the actual name is not <link>FORTH</link> )
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/shell-os-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>$PID</forthname>
    <forthstack>( -- pid )</forthstack>
    <forthhints></forthhints>
    <stackline>$PID ( -- pid )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> getpid </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$UID</forthname>
    <forthstack>( -- val )</forthstack>
    <forthhints></forthhints>
    <stackline>$UID ( -- val )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> getuid </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$EUID</forthname>
    <forthstack>( -- val )</forthstack>
    <forthhints></forthhints>
    <stackline>$EUID ( -- val )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> geteuid </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$GID</forthname>
    <forthstack>( -- val )</forthstack>
    <forthhints></forthhints>
    <stackline>$GID ( -- val )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> getgid </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>UMASK</forthname>
    <forthstack>( val -- ret )</forthstack>
    <forthhints></forthhints>
    <stackline>UMASK ( val -- ret )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> umask </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$HOME</forthname>
    <forthstack>( -- str-ptr str-len )</forthstack>
    <forthhints></forthhints>
    <stackline>$HOME ( -- str-ptr str-len )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> getenv(HOME) </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$USER</forthname>
    <forthstack>( -- str-ptr str-len )</forthstack>
    <forthhints></forthhints>
    <stackline>$USER ( -- str-ptr str-len )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> getenv(USER) </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>$CWD</forthname>
    <forthstack>( -- str-ptr str-len )</forthstack>
    <forthhints></forthhints>
    <stackline>$CWD ( -- str-ptr str-len )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> getcwd </code>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PWD</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>PWD ( -- )</stackline>
   </forthdefinition>
   <comment><para>  calls system's <code> getcwd </code> and prints it to the screen
</para><screen>  : PWD  $CWD TYPE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CHDIR</forthname>
    <forthstack>( bstring -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CHDIR ( bstring -- )</stackline>
   </forthdefinition>
   <comment><para>  change the current directory. <br>
  <small> (under VxWorks it is global! do not use in scripts!!) </small>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/signals-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(RAISE) ( signal# -- ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  send a <link>SIGNAL</link> to self
  OLD: use RAISE-SIGNAL
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RAISE-SIGNAL</forthname>
    <forthstack>( signal# -- ior )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>RAISE-SIGNAL ( signal# -- ior ) [FTH]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FORTH-SIGNAL</forthname>
    <forthstack>( handler-xt* signal# -- old-signal-xt* )</forthstack>
    <forthhints> [FTH]</forthhints>
    <stackline>FORTH-SIGNAL ( handler-xt* signal# -- old-signal-xt* ) [FTH]</stackline>
   </forthdefinition>
   <comment><para>  install signal handler
  - return old signal handler
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/smart-go-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>SMART-INTERPRET-INIT</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SMART-INTERPRET-INIT ( -- )</stackline>
   </forthdefinition>
   <comment><para>  creates a set of interpret-words that are used in the inner
  interpreter, so if a word is unknown to the interpreter-loop
  it will use the first char of that word, attach it to an 
  "interpret-" prefix, and tries to use that <link>IMMEDIATE</link>-=>'DEFER'-word 
  on the rest of the word. This <link>SMART-INTERPRET-INIT</link> will set up
  words like interpret-" so you can write 
  <code>"hello"</code>  instead of   <code>" hello"</code>
  and it creates interpret-\ so that words like <code>\if-unix</code> are
  ignoring the line if the word <code>\if-unknown</code> is unknown in itself.
  This is usually <i>not</i> activated on startup.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SMART-INTERPRET!</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SMART-INTERPRET! ( -- )</stackline>
   </forthdefinition>
   <comment><para>  enables/disables the SMART-INTERPRET extension in <link>INTERPRET</link> ,
  (actually stores an XT in <link>DEFER</link> inside the mainloop interpreter)
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/socket-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>gethostbyname</forthname>
    <forthstack>( name -- hostent )</forthstack>
    <forthhints></forthhints>
    <stackline>gethostbyname ( name -- hostent )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>socket</forthname>
    <forthstack>( class type proto -- fd )</forthstack>
    <forthhints></forthhints>
    <stackline>socket ( class type proto -- fd )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>connect</forthname>
    <forthstack>( fd sock size -- err )</forthstack>
    <forthhints></forthhints>
    <stackline>connect ( fd sock size -- err )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>fdopen</forthname>
    <forthstack>( fd fileattr -- file )</forthstack>
    <forthhints></forthhints>
    <stackline>fdopen ( fd fileattr -- file )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>htonl</forthname>
    <forthstack>( x -- x' )</forthstack>
    <forthhints></forthhints>
    <stackline>htonl ( x -- x' )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>host&gt;addr</forthname>
    <forthstack>( addr u -- x )</forthstack>
    <forthhints></forthhints>
    <stackline>"host&gt;addr" ( addr u -- x )</stackline>
   </forthdefinition>
   <comment><para>  coverts an internet path into a IPv$ adress
  the resulting address in network by order
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>open-socket</forthname>
    <forthstack>( addr u port -- fid )</forthstack>
    <forthhints></forthhints>
    <stackline>open-socket ( addr u port -- fid )</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/stackhelp-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-CHANGER(</forthname>
    <forthstack>( changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-CHANGER(" ( changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-INPUTLIST(</forthname>
    <forthstack>( changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-INPUTLIST(" ( changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-OUTPUTLIST(</forthname>
    <forthstack>( changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-OUTPUTLIST(" ( changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-INPUT-VARIANT(</forthname>
    <forthstack>( variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-INPUT-VARIANT(" ( variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-OUTPUT-VARIANT(</forthname>
    <forthstack>( variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-OUTPUT-VARIANT(" ( variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-INPUT-STACK(</forthname>
    <forthstack>( stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-INPUT-STACK(" ( stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-OUTPUT-STACK(</forthname>
    <forthstack>( stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-OUTPUT-STACK(" ( stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-INPUT-ARGUMENT(</forthname>
    <forthstack>( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-INPUT-ARGUMENT(" ( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' 
  arg# is [0] = TOS and [1] = UNDER, same as the pick values where
  3 2 1 0 2 pick . =:= 2
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-OUTPUT-ARGUMENT(</forthname>
    <forthstack>( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-OUTPUT-ARGUMENT(" ( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  arg# is [0] = TOS and [1] = UNDER, same as the pick values where
  3 2 1 0 2 pick . =:= 2
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-INPUT-ARGUMENT-NAME(</forthname>
    <forthstack>( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-INPUT-ARGUMENT-NAME(" ( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' 
  arg# is [0] = TOS and [1] = UNDER, same as the pick values where
  3 2 1 0 2 pick . =:= 2
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-OUTPUT-ARGUMENT-NAME(</forthname>
    <forthstack>( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-OUTPUT-ARGUMENT-NAME(" ( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  arg# is [0] = TOS and [1] = UNDER, same as the pick values where
  3 2 1 0 2 pick . =:= 2
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-INPUT-ARGUMENT-TYPE(</forthname>
    <forthstack>( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-INPUT-ARGUMENT-TYPE(" ( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' 
  arg# is [0] = TOS and [1] = UNDER, same as the pick values where
  3 2 1 0 2 pick . =:= 2
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-OUTPUT-ARGUMENT-TYPE(</forthname>
    <forthstack>( arg# stk-char which# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-OUTPUT-ARGUMENT-TYPE(" ( arg# stk-char which# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  arg# is [0] = TOS and [1] = UNDER, same as the pick values where
  3 2 1 0 2 pick . =:= 2
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CANONIC-INPUT-TYPE(</forthname>
    <forthstack>( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"CANONIC-INPUT-TYPE(" ( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' 
  arg# is [0] = TOS and [1] = UNDER, same as the pick values where
  3 2 1 0 2 pick . =:= 2
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CANONIC-OUTPUT-TYPE(</forthname>
    <forthstack>( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"CANONIC-OUTPUT-TYPE(" ( arg# stk-char variant# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  arg# is [0] = TOS and [1] = UNDER, same as the pick values where
  3 2 1 0 2 pick . =:= 2
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITER-TEST(</forthname>
    <forthstack>( "tracked-stack -- input-stack&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"REWRITER-TEST(" ( "tracked-stack -- input-stack&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  suppose that the left side is a tracked stack line during compiling
  and the right side is a candidate changer input stack. Test whethr
  the candidate does match and the complete changer would be allowed
  to run a rewrite in the track stack buffer.
</para><para>
  Possible conditions include:
    the left side has not enough arguments or...
       any argument on the right side has a type specialization
       that does not match as a valid suffix to their counterpart
       on the left side.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITER-INPUT-ARG(</forthname>
    <forthstack>( arg# "tracked-stack -- changer&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"REWRITER-INPUT-ARG(" ( arg# "tracked-stack -- changer&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  suppose that the left side is a tracked stack line during compiling
  and the right side is a candidate changer input stack. Assume the
  righthand candidate does match - look at the given argument on the
  left side and show the prefix being copied to the output trackstack
  when the rewrite-rule is gettin applied later.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITE-LINE(</forthname>
    <forthstack>( "stack-layout&lt;rp&gt;" -- )</forthstack>
    <forthhints>  [EXT]</forthhints>
    <stackline>"REWRITE-LINE(" ( "stack-layout&lt;rp&gt;" -- )  [EXT]</stackline>
   </forthdefinition>
   <comment><para>  fill rewrite-buffer with a stack-layout to be processed.
  see <link>REWRITE-SHOW.</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITE-SHOW.</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"REWRITE-SHOW." ( -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  show current rewrite-buffer.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITE-STACK-TEST(</forthname>
    <forthstack>( "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"REWRITE-STACK-TEST(" ( "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>   check whether this stackhelp does match on current rewrite-buffer
   and say oK/No respectivly.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITE-INPUT-ARG(</forthname>
    <forthstack>( arg# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"REWRITE-INPUT-ARG(" ( arg# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>   check whether this stackhelp does match on current rewrite-buffer
   and in the given input match show us the argument but only the
   good prefix i.e. the type constraint being cut off already.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITE-STACK-RESULT(</forthname>
    <forthstack>( "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"REWRITE-STACK-RESULT(" ( "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  rewrite the current rewrite-buffer and show the result that
  would occur with this stackhelp being applied.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-INPUT-NOTATION(</forthname>
    <forthstack>( notation# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-INPUT-NOTATION(" ( notation# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NARROW-OUTPUT-NOTATION(</forthname>
    <forthstack>( notation# changer# "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"NARROW-OUTPUT-NOTATION(" ( notation# changer# "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITE-STACKDEF-RESULT(</forthname>
    <forthstack>( "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"REWRITE-STACKDEF-RESULT(" ( "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>   assume:
        only one changer (if more are provided then only the first is used)
        only one stackdef variant in inputlist
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWRITE-TEST(</forthname>
    <forthstack>( "stackhelp&lt;rp&gt;" -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"REWRITE-TEST(" ( "stackhelp&lt;rp&gt;" -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>  Test whether the given changer would match the current line.
  assume:
       only one changer (if more are provided then only the first is used)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>|(</forthname>
    <forthstack>( [string&lt;rp&gt;] -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>"|(" ( [string&lt;rp&gt;] -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>   add a checkstack notation for the LAST word or just try to
   match the given notation with the stacklayout traced so
   far - possibly casting a few types as needed.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STACKHELPS</forthname>
    <forthstack>( [name] -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>STACKHELPS ( [name] -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>   show all possible stackhelps for this name.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STACKHELP</forthname>
    <forthstack>( [name] -- )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>STACKHELP ( [name] -- ) [EXT]</stackline>
   </forthdefinition>
   <comment><para>   show the stackhelp info registered for this name.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STACKHELP-WORDLIST</forthname>
    <forthstack>( -- stackhelp-wordlist* )</forthstack>
    <forthhints> [EXT]</forthhints>
    <stackline>STACKHELP-WORDLIST ( -- stackhelp-wordlist* ) [EXT]</stackline>
   </forthdefinition>
   <comment>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/string-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>-TRAILING</forthname>
    <forthstack>( str-ptr str-len -- str-ptr str-len' )</forthstack>
    <forthhints></forthhints>
    <stackline>-TRAILING ( str-ptr str-len -- str-ptr str-len' )</stackline>
   </forthdefinition>
   <comment><para>  check the given buffer if it contains whitespace at its end.
  If so, shorten str-len to meet the last non-whitespace
  character in the buffer.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/STRING</forthname>
    <forthstack>( str-ptr str-len n -- str-ptr' str-len' )</forthstack>
    <forthhints></forthhints>
    <stackline>/STRING ( str-ptr str-len n -- str-ptr' str-len' )</stackline>
   </forthdefinition>
   <comment><para>  shorten the buffer from the beginning by n characters, i.e.
</para><screen>   str-ptr += n ;
   str-len -= n; 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BLANK</forthname>
    <forthstack>( str-ptr str-len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>BLANK ( str-ptr str-len -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>FILL</link> a given buffer with <link>BL</link> blanks
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CMOVE</forthname>
    <forthstack>( from-ptr to-ptr len# -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CMOVE ( from-ptr to-ptr len# -- )</stackline>
   </forthdefinition>
   <comment><para>   memcpy an area from->to for len bytes, starting at
   the lower addresses, see <link>CMOVE></link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CMOVE&gt;</forthname>
    <forthstack>( from-ptr to-ptr len# -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CMOVE&gt; ( from-ptr to-ptr len# -- )</stackline>
   </forthdefinition>
   <comment><para>   memcpy an area from->to for len bytes, starting 
   with the higher addresses, see <link>CMOVE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>COMPARE</forthname>
    <forthstack>( str1-ptr str1-len str2-ptr str2-len -- diff# )</forthstack>
    <forthhints></forthhints>
    <stackline>COMPARE ( str1-ptr str1-len str2-ptr str2-len -- diff# )</stackline>
   </forthdefinition>
   <comment><para>  compare both str-buffers, return 0 if they are equal,
  -1 if lower or shorter, and 1 if greater or longer
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SEARCH</forthname>
    <forthstack>( str1-ptr str1-len str2-ptr str2-len -- str1-ptr' str1-len' flag )</forthstack>
    <forthhints></forthhints>
    <stackline>SEARCH ( str1-ptr str1-len str2-ptr str2-len -- str1-ptr' str1-len' flag )</stackline>
   </forthdefinition>
   <comment><para>  search the str-buffer1 for the text of str-buffer2,
  if it is contained return TRUE and return buffer-values that
  point to the contained string, otherwise return FALSE and
  leave the original str-buffer1.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SLITERAL</forthname>
    <forthstack>( C: str-ptr str-len -- S: str-ptr str-len )</forthstack>
    <forthhints></forthhints>
    <stackline>SLITERAL ( C: str-ptr str-len -- S: str-ptr str-len )</stackline>
   </forthdefinition>
   <comment><para>  this word does almost the same as <link>LITERAL</link> - it takes
  an <link>S"</link> string as specified in the CS-STACK at compile
  time and compiles into the current definition where it is
  returned as if there were a direct string-literal. This
  can be used to compute a string-literal at compile-time
  and hardwire it.
</para><screen>  example:
    : ORIGINAL-HOME  [ $HOME COUNT ] SLITERAL ; ( -- str-ptr str-len )
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/struct-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>FIELD</forthname>
    <forthstack>( offset size "name" -- offset+size )</forthstack>
    <forthhints></forthhints>
    <stackline>FIELD ( offset size "name" -- offset+size )</stackline>
   </forthdefinition>
   <comment><para>  create a field - the workhorse for both <link>STRUCT</link> and <link>STRUCTURE</link>
  implementations. The created fieldname is an <link>OFFSET:</link>-word 
  that memorizes the current offset in its PFA and will add
  that offset on runtime. This forth-word does *not* align.
</para><screen>  : FIELD CREATE
    OVER ,
    +
  DOES&gt;
     @ +
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SIZEOF</forthname>
    <forthstack>( "name" -- size )</forthstack>
    <forthhints></forthhints>
    <stackline>SIZEOF ( "name" -- size )</stackline>
   </forthdefinition>
   <comment><para>  get the size-value from a previous structure definition
</para><screen>  : SIZEOF   ' &gt;BODY @  STATE @ IF [COMPILE] LITERAL THEN ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STRUCTURE</forthname>
    <forthstack>( "name" -- here zero-offset )</forthstack>
    <forthhints> exec</forthhints>
    <stackline>STRUCTURE ( "name" -- here zero-offset ) exec</stackline>
   </forthdefinition>
   <comment><para>  start a structure definition 
</para><screen>  : STRUCTURE: CREATE !CSP
    HERE
    0 DUP ,
  DOES&gt;
    CREATE @ ALLOT
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENDSTRUCTURE</forthname>
    <forthstack>( here some-offset -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ENDSTRUCTURE ( here some-offset -- )</stackline>
   </forthdefinition>
   <comment><para>  finalize a previously started <link>STRUCTURE</link> definition
</para><screen>  : ENDSTRUCTURE  SWAP !  ?CSP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STRUCT</forthname>
    <forthstack>( "name" -- here zero-offset )</forthstack>
    <forthhints></forthhints>
    <stackline>STRUCT ( "name" -- here zero-offset )</stackline>
   </forthdefinition>
   <comment><para>  begin definition of a new structure (mpe.000)
</para><screen>  : STRUCT CREATE  !CSP
    HERE
    0 DUP ,
  DOES&gt;
    @
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>END-STRUCT</forthname>
    <forthstack>( here some-offset -- )</forthstack>
    <forthhints></forthhints>
    <stackline>END-STRUCT ( here some-offset -- )</stackline>
   </forthdefinition>
   <comment><para>  terminate definition of a new structure (mpe.000)
</para><screen>  : END-STRUCT  SWAP !  ?CSP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SUBRECORD</forthname>
    <forthstack>( outer-offset "name" -- outer-offset here zero-offset )</forthstack>
    <forthhints></forthhints>
    <stackline>SUBRECORD ( outer-offset "name" -- outer-offset here zero-offset )</stackline>
   </forthdefinition>
   <comment><para>  begin definition of a subrecord (mpe.000)
</para><screen>  : STRUCT CREATE  
    HERE
    0 DUP ,
  DOES&gt;
    @
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>END-SUBRECORD</forthname>
    <forthstack>( outer-offset here some-offset -- outer-offset+some )</forthstack>
    <forthhints></forthhints>
    <stackline>END-SUBRECORD ( outer-offset here some-offset -- outer-offset+some )</stackline>
   </forthdefinition>
   <comment><para>  end definition of a subrecord (mpe.000)
</para><screen>  : END-SUBRECORD  TUCK SWAP !  + ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ARRAY-OF</forthname>
    <forthstack>( some-offset n len "name" -- some-offset )</forthstack>
    <forthhints></forthhints>
    <stackline>ARRAY-OF ( some-offset n len "name" -- some-offset )</stackline>
   </forthdefinition>
   <comment><para>  a <link>FIELD</link>-array
</para><screen>  : ARRAY-OF * FIELD ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>VARIANT</forthname>
    <forthstack>( outer-offset "name" -- outer-offset here zero-offset )</forthstack>
    <forthhints></forthhints>
    <stackline>VARIANT ( outer-offset "name" -- outer-offset here zero-offset )</stackline>
   </forthdefinition>
   <comment><para>  Variant records describe an alternative view of the 
  current record or subrecord from the start to the current point. 
  The variant need not be of the same length, but the larger is taken 
</para><screen>  : VARIANT SUBRECORD ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>END-VARIANT</forthname>
    <forthstack>( outer-offset here some-offset -- outer-offset )</forthstack>
    <forthhints></forthhints>
    <stackline>END-VARIANT ( outer-offset here some-offset -- outer-offset )</stackline>
   </forthdefinition>
   <comment><para>  terminate definition of a new variant (mpe.000)
</para><screen>  : END-STRUCT  TUCK SWAP !  2DUP &lt; IF NIP ELSE DROP THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>INSTANCE</forthname>
    <forthstack>( len "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>INSTANCE ( len "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  Create a named instance of a named structure. 
</para><screen>  : INSTANCE  CREATE ALLOT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>INSTANCE-ADDR</forthname>
    <forthstack>( len -- addr )</forthstack>
    <forthhints></forthhints>
    <stackline>INSTANCE-ADDR ( len -- addr )</stackline>
   </forthdefinition>
   <comment><para>  Create nameless instance of a structure and return base address. 
</para><screen>  : INSTANCE-ADDR  HERE SWAP ALLOT ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/system-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>&lt;MARK</forthname>
    <forthstack>( -- DP-mark )</forthstack>
    <forthhints> compile-only</forthhints>
    <stackline>&lt;MARK ( -- DP-mark ) compile-only</stackline>
   </forthdefinition>
   <comment><para>  memorizes the current <link>DP</link> on the CS-STACK
  used for <link><RESOLVE</link> later. Useful for creation of 
  compiling words, eg. <link>BEGIN</link> , see <link>AHEAD</link>
</para><screen>  simulate:
    : &lt;MARK ?COMP  HERE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>&lt;RESOLVE</forthname>
    <forthstack>( DP-mark -- )</forthstack>
    <forthhints> compile-only</forthhints>
    <stackline>&lt;RESOLVE ( DP-mark -- ) compile-only</stackline>
   </forthdefinition>
   <comment><para>  resolves a previous <link><MARK</link> , actually pushes
  the DP-address memorized at <MARK into the dictionary.
  Mostly used after <link>BRANCH</link> or => ?BRANCH in compiling
  words like <link>UNTIL</link>
</para><screen>  simulate:
    : &lt;RESOLVE ?COMP  , ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MARK&gt;</forthname>
    <forthstack>( -- DP-mark )</forthstack>
    <forthhints> compile-only</forthhints>
    <stackline>MARK&gt; ( -- DP-mark ) compile-only</stackline>
   </forthdefinition>
   <comment><para>  makes room for a pointer in the dictionary to
  be resolved through <link>RESOLVE></link> and does therefore
  memorize that cell's address on the CS-STACK
  Mostly used after <link>BRANCH</link> or => ?BRANCH in compiling
  words like <link>IF</link> or <link>ELSE</link>
</para><screen>  simulate:
    : MARK&gt; ?COMP  HERE 0 , ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>RESOLVE&gt;</forthname>
    <forthstack>( DP-mark -- )</forthstack>
    <forthhints> compile-only</forthhints>
    <stackline>RESOLVE&gt; ( DP-mark -- ) compile-only</stackline>
   </forthdefinition>
   <comment><para>  resolves a pointer created by <link>MARK></link>
  Mostly used in compiling words like <link>THEN</link>
</para><screen>  simulate:
    : RESOLVE&gt; ?COMP  HERE SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BRANCH</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>BRANCH ( -- )</stackline>
   </forthdefinition>
   <comment><para>  compiles a branch-runtime into the dictionary that
  can be resolved with <link>MARK&lt;</link>d or <link>&lt;RESOLVE</link>.
  Usage:
</para><screen>      BRANCH MARK&amp;lt;     or
      BRANCH &amp;gt;RESOLVE  or ...
</screen><para>  this is the runtime-portion of <link>ELSE</link> - the use of
  <link>ELSE</link> should be preferred. See also => ?BRANCH
</para><screen>  : BRANCH COMPILE (BRANCH) ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?BRANCH</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?BRANCH ( -- )</stackline>
   </forthdefinition>
   <comment><para>  compiles a cond-branch-runtime into the dictionary that
  can be resolved with <link>&gt;MARK&</link>d or <link>RESOLVE&gt;</link>.
  Usage:
</para><screen>      ?BRANCH MARK&amp;lt;     or
      ?BRANCH &amp;gt;RESOLVE  or ...
</screen><para>  this is the runtime-portion of <link>IF</link> - the use of
  <link>IF</link> should be preferred. See also <link>BRANCH</link>
</para><screen>  : ?BRANCH COMPILE (?BRANCH) ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CONTEXT</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CONTEXT ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>  The variable that holds the or the topmost search-order
  wordlist. The new ansforth standard suggests the use 
  of <link>SET-CONTEXT</link> and <link>GET-CONTEXT</link> instead of
  using <link>CONTEXT</link> => ! and <link>CONTEXT</link> <link>@</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CURRENT</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CURRENT ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>  The variable that holds the or the topmost compile-order
  wordlist. The new ansforth standard suggests the use 
  of <link>SET-CURRENT</link> and <link>GET-CURRENT</link> instead of
  using <link>CURRENT</link> => ! and <link>CURRENT</link> <link>@</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/term-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>SHOW-TERM-CONTROLS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> for debugging</forthhints>
    <stackline>SHOW-TERM-CONTROLS ( -- ) for debugging</stackline>
   </forthdefinition>
   <comment><para>  show the current mappings for the terminal output 
  may give hints about what is wrong if the output
  seems to miss some functionality
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SHOW-TERM-ESC-KEYS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> for debugging</forthhints>
    <stackline>SHOW-TERM-ESC-KEYS ( -- ) for debugging</stackline>
   </forthdefinition>
   <comment><para>  show the current mappings for the terminal input
  may give hints about what is wrong if the input
  seems to miss some functionality
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SHOW-TERMCAP</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> for debugging</forthhints>
    <stackline>SHOW-TERMCAP ( -- ) for debugging</stackline>
   </forthdefinition>
   <comment><para>  print the termcap strings used for input and output
  may give hints about what is wrong if the terminal
  seems to miss some functionality
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ASSUME_VT100</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ASSUME_VT100 ( -- )</stackline>
   </forthdefinition>
   <comment><para>  load hardwired VT100-termcap into the terminal-driver
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ASSUME_DUMBTERM</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ASSUME_DUMBTERM ( -- )</stackline>
   </forthdefinition>
   <comment><para>  load hardwired DUMBTERM-termcap into the terminal-driver
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>GOTOXY</forthname>
    <forthstack>( x y -- )</forthstack>
    <forthhints></forthhints>
    <stackline>GOTOXY ( x y -- )</stackline>
   </forthdefinition>
   <comment><para>  move the cursor to the specified position on the screen -
  this is usually done by sending a corresponding esc-sequence
  to the terminal. 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?XY</forthname>
    <forthstack>( -- x y )</forthstack>
    <forthhints></forthhints>
    <stackline>?XY ( -- x y )</stackline>
   </forthdefinition>
   <comment><para>  returns the cursor position on screen, on a real unix system
  this includes a special call to the screen driver, in remote
  systems this can be the expected position as seen on the
  client side's terminal driver.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>K-SHIFT-MASK</forthname>
    <forthstack>( -- mask# )</forthstack>
    <forthhints></forthhints>
    <stackline>K-SHIFT-MASK ( -- mask# )</stackline>
   </forthdefinition>
   <comment><para>  this value is only usable on the result value of <link>KEY>FKEY</link>
</para><para>
  Note that { K-F1-SHIFT <unequal> K-F1 K-SHIFT-MASK OR }
  because the first one is a plain ekey-value while the 
  second refers to a decoded fkey-value. 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EKEY&gt;FKEY</forthname>
    <forthstack>( key-code# -- key-code# 0 | fkey-code# true! )</forthstack>
    <forthhints></forthhints>
    <stackline>EKEY&gt;FKEY ( key-code# -- key-code# 0 | fkey-code# true! )</stackline>
   </forthdefinition>
   <comment><para>  If the input ekey value was not an extended key
  then flag is set to FALSE and the value is left
  unchanged. Compare to EKEY>CHAR for the inverse.
</para><para>
  If the input eky was an extended key then the value 
  will be modified such that shifted values are transposed
  to their base EKEY plus <link>K-SHIFT-MASK</link> - therefore the
  K-SHIFT-MASK is only apropriate for the result fkey-code
  values of this function.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/termcatch-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>TERM-CAPTURE-CONTROLS</forthname>
    <forthstack>( -- var-ptr )</forthstack>
    <forthhints></forthhints>
    <stackline>TERM-CAPTURE-CONTROLS ( -- var-ptr )</stackline>
   </forthdefinition>
   <comment><para>   enable/disable common visualization of terminal control sequences.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(TERM-CAPTURE-ON) ( -- )</stackline>
   </forthdefinition>
   <comment><para>   start capturing any terminal output. Whether the captured output
   does include any control commands depends on the setting of
   <link>(TERM-CAPTURE-CONTROLS)</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(TERM-CAPTURE-OFF) ( -- )</stackline>
   </forthdefinition>
   <comment><para>   reset terminal driver to the one being effective on the
   last <link>TERM-CAPTURE-TEXT</link> or <link>TERM-CAPTURE-KEYS</link> call.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(TERM-CAPTURE-BUFFER) ( capturebuffer-ptr capturebuffer-len -- )</stackline>
   </forthdefinition>
   <comment><para>   start with new capture buffer.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(TERM-CAPTURE-RESULT) ( -- capturebuffer-ptr capturebuffer-len )</stackline>
   </forthdefinition>
   <comment><para>   get fill state of current capture buffer.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TERM-CAPTURE-ON</forthname>
    <forthstack>( capturebuffer-ptr capturebuffer-len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>TERM-CAPTURE-ON ( capturebuffer-ptr capturebuffer-len -- )</stackline>
   </forthdefinition>
   <comment><para>   init/start capturing terminal output
</para><screen>  :  TERM-CAPTURE-ON (TERM-CAPTURE-BUFFER) (TERM-CAPTURE-ON) ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TERM-CAPTURE-OFF</forthname>
    <forthstack>( -- capturebuffer-ptr capturebuffer-len )</forthstack>
    <forthhints></forthhints>
    <stackline>TERM-CAPTURE-OFF ( -- capturebuffer-ptr capturebuffer-len )</stackline>
   </forthdefinition>
   <comment><para>   shutdown capturing terminal output
</para><screen>  :  TERM-CAPTURE-OFF (TERM-CAPTURE-OFF) (TERM-CAPTURE-RESULT) ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TERMCATCH</forthname>
    <forthstack>( str-ptr str-len some-xt* -- str-ptr str-len' catch-code# )</forthstack>
    <forthhints></forthhints>
    <stackline>TERMCATCH ( str-ptr str-len some-xt* -- str-ptr str-len' catch-code# )</stackline>
   </forthdefinition>
   <comment><para>   create a catch-domain around the token to be executed. This works
   the same as <link>CATCH</link>. Additionally all terminal output of that word
   is being captured to the buffer being provided as an argument. The
   maximum length input argument is modified flagging the actual length
   of captured output stream as the output argument. Note that in most
   cases a <link>POCKET-PAD</link> is just not big enough, atleast many error
   condition notifications tend to be quite lengthy for byte counted
   forth strings.
</para><screen>  : TERMCATCH TERM-CAPTURE-ON CATCH &gt;R TERM-CAPTURE-OFF R&gt; ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/toolbelt-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>[VOID]</forthname>
    <forthstack>( -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>[VOID]          ( -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Immediate FALSE. Used to comment out sections of code.
   IMMEDIATE so it can be inside definitions.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NOT</forthname>
    <forthstack>( x -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>NOT                 ( x -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Identical to `0=`, used for program clarity to reverse the
   result of a previous test.
</para><para>
   WARNING: PFE's NOT uses bitwise complement <link>INVERT</link>
            instead of the logical complement <link>0=</link>, so
            that loading TOOLBELT will change semantics.
   ... this difference in semantics has caused dpans94 to
   depracate the word. Only if TRUE is -1 it would be identical
   but not all words return -1 for true.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[DEFINED]</forthname>
    <forthstack>( "name" -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>[DEFINED]           ( "name" -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Search the dictionary for _name_. If _name_ is found,
   return TRUE; otherwise return FALSE. Immediate for use in
   definitions.
</para><para>  [DEFINED] word       ( -- nfa|0 ) immediate
  does check for the word using find (so it does not throw like <link>'</link> )
  and puts it on stack. As it is immediate it does work in compile-mode
  too, so it places its argument in the cs-stack then. This is most
  useful with a directly following <link>[IF]</link> clause, so that sth. like
  an <code>[IFDEF] word</code> can be simulated through <code>[DEFINED] word [IF]</code>
</para><screen> 
  : [DEFINED] BL WORD FIND NIP ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[UNDEFINED]</forthname>
    <forthstack>( "name" -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>[UNDEFINED]         ( "name" -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Search the dictionary for _name_. If _name_ is found,
   return FALSE; otherwise return TRUE. Immediate for use in
   definitions.
</para><para>
   see <link>[DEFINED]</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>C+!</forthname>
    <forthstack>( n addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>C+!                 ( n addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Add the low-order byte of _n_ to the byte at _addr_,
   removing both from the stack.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EMPTY</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EMPTY               ( -- )</stackline>
   </forthdefinition>
   <comment><para>   Reset the dictionary to a predefined golden state,
   discarding all definitions and releasing all allocated
   data space beyond that state.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BOUNDS</forthname>
    <forthstack>( str len -- str+len str )</forthstack>
    <forthhints></forthhints>
    <stackline>BOUNDS                ( str len -- str+len str )</stackline>
   </forthdefinition>
   <comment><para>   Convert _str len_ to range for DO-loop.
</para><screen>  : BOUNDS  ( str len -- str+len str )  OVER + SWAP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OFF</forthname>
    <forthstack>( addr  -- )</forthstack>
    <forthhints></forthhints>
    <stackline>OFF                   ( addr  -- )</stackline>
   </forthdefinition>
   <comment><para>   Store 0 at _addr_. See `ON`.
</para><screen>   : OFF  ( addr -- )  0 SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ON</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ON                    ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Store -1 at _addr_. See `OFF`.
</para><screen>   : ON  ( addr -- )  -1 SWAP ! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>APPEND</forthname>
    <forthstack>( str len add2 -- )</forthstack>
    <forthhints></forthhints>
    <stackline>APPEND                ( str len add2 -- )</stackline>
   </forthdefinition>
   <comment><para>   Append string _str len_ to the counted string at _addr_.
   AKA `+PLACE`.
</para><screen>  : APPEND   2DUP 2&gt;R  COUNT +  SWAP MOVE ( ) 2R&gt; C+! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>APPEND-CHAR</forthname>
    <forthstack>( char addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>APPEND-CHAR           ( char addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Append _char_ to the counted string at _addr_.
</para><screen>  : APPEND-CHAR   DUP &gt;R  COUNT  DUP 1+ R&gt; C!  +  C! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PLACE</forthname>
    <forthstack>( str len addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>PLACE                 ( str len addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Place the string _str len_ at _addr_, formatting it as a
   counted string.
</para><screen>  : PLACE  2DUP 2&gt;R  1+ SWAP  MOVE  2R&gt; C! ;
  : PLACE  2DUP C!   1+ SWAP CMOVE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STRING,</forthname>
    <forthstack>( str len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>STRING,               ( str len -- )</stackline>
   </forthdefinition>
   <comment><para>   Store a string in data space as a counted string.
</para><screen>  : STRING, HERE  OVER 1+  ALLOT  PLACE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>,"</forthname>
    <forthstack>( "&lt;ccc&gt;&lt;quote&gt;" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>,"                    ( "&lt;ccc&gt;&lt;quote&gt;" -- )</stackline>
   </forthdefinition>
   <comment><para>   Store a quote-delimited string in data space as a counted
   string.
</para><screen>  : ," [CHAR] " PARSE  STRING, ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>THIRD</forthname>
    <forthstack>( x y z -- x y z x )</forthstack>
    <forthhints></forthhints>
    <stackline>THIRD               ( x y z -- x y z x )</stackline>
   </forthdefinition>
   <comment><para>   Copy third element on the stack onto top of stack.
</para><screen>  : THIRD   2 PICK ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FOURTH</forthname>
    <forthstack>( w x y z -- w x y z w )</forthstack>
    <forthhints></forthhints>
    <stackline>FOURTH              ( w x y z -- w x y z w )</stackline>
   </forthdefinition>
   <comment><para>   Copy fourth element on the stack onto top of stack.
</para><screen>  : FOURTH  3 PICK ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>3DUP</forthname>
    <forthstack>( x y z -- x y z x y z )</forthstack>
    <forthhints></forthhints>
    <stackline>3DUP                ( x y z -- x y z x y z )</stackline>
   </forthdefinition>
   <comment><para>   Copy top three elements on the stack onto top of stack.
</para><screen>  : 3DUP   THIRD THIRD THIRD ;
</screen><para>
  or
</para><screen>  : 3DUP  3 PICK 3 PICK 3 PICK ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>3DROP</forthname>
    <forthstack>( x y z -- )</forthstack>
    <forthhints></forthhints>
    <stackline>3DROP               ( x y z -- )</stackline>
   </forthdefinition>
   <comment><para>   Drop the top three elements from the stack.
</para><screen>  : 3DROP   DROP 2DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>2NIP</forthname>
    <forthstack>( w x y z -- y z )</forthstack>
    <forthhints></forthhints>
    <stackline>2NIP                ( w x y z -- y z )</stackline>
   </forthdefinition>
   <comment><para>   Drop the third and fourth elements from the stack.
</para><screen>  : 2NIP   2SWAP 2DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>R'@</forthname>
    <forthstack>( -- x )</forthstack>
    <forthhints>( R: x y -- x y )</forthhints>
    <stackline>R'@                 ( -- x )( R: x y -- x y )</stackline>
   </forthdefinition>
   <comment><para>   The second element on the return stack.
</para><screen>  : R'@   S" 2R@ DROP " EVALUATE ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ANDIF</forthname>
    <forthstack>( p ... -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>ANDIF               ( p ... -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Given `p ANDIF q THEN`,  _q_ will not be performed if
   _p_ is false.
</para><screen>  : ANDIF  S" DUP IF DROP " EVALUATE ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ORIF</forthname>
    <forthstack>( p ... -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>ORIF                ( p ... -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Given `p ORIF q THEN`,  _q_ will not be performed if
   _p_ is true.
</para><screen>  : ORIF   S" DUP 0= IF DROP " EVALUATE ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SCAN</forthname>
    <forthstack>( str len char -- str+i len-i )</forthstack>
    <forthhints></forthhints>
    <stackline>SCAN            ( str len char -- str+i len-i )</stackline>
   </forthdefinition>
   <comment><para>   Look for a particular character in the specified string.
</para><screen>  : SCAN     
     &gt;R  BEGIN  DUP WHILE  OVER C@ R@ -
         WHILE  1 /STRING  REPEAT THEN
     R&gt; DROP ;
</screen><para>
  ie.
  scan for first occurence of c in string 
</para><screen>    : SCAN &gt;R BEGIN DUP OVER C@ R@ = 0= OR WHILE 
                     1- SWAP 1- SWAP REPEAT R&gt; DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SKIP</forthname>
    <forthstack>( str len char -- str+i len-i )</forthstack>
    <forthhints></forthhints>
    <stackline>SKIP            ( str len char -- str+i len-i )</stackline>
   </forthdefinition>
   <comment><para>   Advance past leading characters in the specified string.
</para><screen>  : SKIP     
    &gt;R  BEGIN  DUP WHILE  OVER C@ R@ =
         WHILE  1 /STRING  REPEAT THEN
     R&gt; DROP ;
</screen><para>
  ie.
  skip leading characters c 
</para><screen>    : SKIP  &gt;R BEGIN DUP OVER C@ R@ = OR WHILE 
                     1- SWAP 1- SWAP REPEAT R&gt; DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BACK</forthname>
    <forthstack>( str len char -- str len-i )</forthstack>
    <forthhints></forthhints>
    <stackline>BACK            ( str len char -- str len-i )</stackline>
   </forthdefinition>
   <comment><para>   Look for a particular character in the string from the
   back toward the front.
</para><screen>  : BACK     
     &gt;R  BEGIN  DUP WHILE
         1-  2DUP + C@  R@ =
     UNTIL 1+ THEN
     R&gt; DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/SPLIT</forthname>
    <forthstack>( a m a+i m-i -- a+i m-i a i )</forthstack>
    <forthhints></forthhints>
    <stackline>/SPLIT          ( a m a+i m-i -- a+i m-i a i )</stackline>
   </forthdefinition>
   <comment><para>   Split a character string _a m_ at place given by _a+i m-i_.
   Called "cut-split" because "slash-split" is a tongue
   twister.
</para><screen>  : /SPLIT  DUP &gt;R  2SWAP  R&gt; - ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IS-WHITE</forthname>
    <forthstack>( char -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>IS-WHITE        ( char -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Test char for white space.
</para><screen>  : IS-WHITE   33 - 0&lt; ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TRIM</forthname>
    <forthstack>( str len -- str len-i )</forthstack>
    <forthhints></forthhints>
    <stackline>TRIM            ( str len -- str len-i )</stackline>
   </forthdefinition>
   <comment><para>   Trim white space from end of string.
</para><screen>  : TRIM    
     BEGIN  DUP WHILE
         1-  2DUP + C@ IS-WHITE NOT
     UNTIL 1+ THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BL-SCAN</forthname>
    <forthstack>( str len -- str+i len-i )</forthstack>
    <forthhints></forthhints>
    <stackline>BL-SCAN         ( str len -- str+i len-i )</stackline>
   </forthdefinition>
   <comment><para>   Look for white space from start of string
</para><screen>  : BL-SCAN 
     BEGIN  DUP WHILE  OVER C@ IS-WHITE NOT
     WHILE  1 /STRING  REPEAT THEN ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BL-SKIP</forthname>
    <forthstack>( str len -- str+i len-i )</forthstack>
    <forthhints></forthhints>
    <stackline>BL-SKIP         ( str len -- str+i len-i )</stackline>
   </forthdefinition>
   <comment><para>   Skip over white space at start of string.
</para><screen>  : BL-SKIP 
     BEGIN  DUP WHILE  OVER C@ IS-WHITE
     WHILE  1 /STRING  REPEAT THEN ;
 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>STARTS?</forthname>
    <forthstack>( str len pattern len2 -- str len flag )</forthstack>
    <forthhints></forthhints>
    <stackline>STARTS?         ( str len pattern len2 -- str len flag )</stackline>
   </forthdefinition>
   <comment><para>   Check start of string.
</para><screen>  : STARTS?   DUP &gt;R  2OVER  R&gt; MIN  COMPARE 0= ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ENDS?</forthname>
    <forthstack>( str len pattern len2 -- str len flag )</forthstack>
    <forthhints></forthhints>
    <stackline>ENDS?           ( str len pattern len2 -- str len flag )</stackline>
   </forthdefinition>
   <comment><para>   Check end of string.
</para><screen>  : ENDS?   DUP &gt;R  2OVER  DUP R&gt; - /STRING  COMPARE 0= ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IS-DIGIT</forthname>
    <forthstack>( char -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>IS-DIGIT        ( char -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Test _char_ for digit [0-9].
</para><screen>  : IS-DIGIT   [CHAR] 0 -  10 U&lt; ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IS-ALPHA</forthname>
    <forthstack>( char -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>IS-ALPHA        ( char -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Test _char_ for alphabetic [A-Za-z].
</para><screen>  : IS-ALPHA  32 OR  [CHAR] a -  26 U&lt; ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>IS-ALNUM</forthname>
    <forthstack>( char -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>IS-ALNUM        ( char -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Test _char_ for alphanumeric [A-Za-z0-9].
</para><screen>  : IS-ALNUM  
     DUP IS-ALPHA  ORIF  DUP IS-DIGIT  THEN  NIP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#BACKSPACE-CHAR</forthname>
    <forthstack>( -- char )</forthstack>
    <forthhints></forthhints>
    <stackline>#BACKSPACE-CHAR     ( -- char )</stackline>
   </forthdefinition>
   <comment><para>   Backspace character.
</para><screen>  8 CONSTANT #BACKSPACE-CHAR
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#CHARS/LINE</forthname>
    <forthstack>( -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>#CHARS/LINE         ( -- n )</stackline>
   </forthdefinition>
   <comment><para>   Preferred width of line in source files.  Suit yourself.
</para><screen>  62 VALUE    #CHARS/LINE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#EOL-CHAR</forthname>
    <forthstack>( -- char )</forthstack>
    <forthhints></forthhints>
    <stackline>#EOL-CHAR           ( -- char )</stackline>
   </forthdefinition>
   <comment><para>   End-of-line character.  13 for Mac and DOS, 10 for Unix.
</para><screen>  13 CONSTANT #EOL-CHAR
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>#TAB-CHAR</forthname>
    <forthstack>( -- char )</forthstack>
    <forthhints></forthhints>
    <stackline>#TAB-CHAR           ( -- char )</stackline>
   </forthdefinition>
   <comment><para>   Tab character.
</para><screen>  9 CONSTANT #TAB-CHAR
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MAX-N</forthname>
    <forthstack>( -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>MAX-N               ( -- n )</stackline>
   </forthdefinition>
   <comment><para>   Largest usable signed integer.
</para><screen>  TRUE 1 RSHIFT        CONSTANT MAX-N
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SIGN-BIT</forthname>
    <forthstack>( -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>SIGN-BIT            ( -- n )</stackline>
   </forthdefinition>
   <comment><para>   1-bit mask for the sign bit.
</para><screen>  TRUE 1 RSHIFT INVERT CONSTANT SIGN-BIT
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CELL</forthname>
    <forthstack>( -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>CELL                ( -- n )</stackline>
   </forthdefinition>
   <comment><para>   Address units (i.e. bytes) in a cell.
</para><screen>  1 CELLS CONSTANT CELL
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>-CELL</forthname>
    <forthstack>( -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>-CELL               ( -- n )</stackline>
   </forthdefinition>
   <comment><para>   Negative of address units in a cell.
</para><screen>  -1 CELLS CONSTANT -CELL
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPLIT-NEXT-LINE</forthname>
    <forthstack>( src . -- src' . str len )</forthstack>
    <forthhints></forthhints>
    <stackline>SPLIT-NEXT-LINE     ( src . -- src' . str len )</stackline>
   </forthdefinition>
   <comment><para>   Split the next line from the string.
</para><screen>  : SPLIT-NEXT-LINE 
     2DUP #EOL-CHAR SCAN  
     DUP &gt;R  1 /STRING  2SWAP R&gt; - ;
</screen><para>  FIXME: inform Neil Bawd that this is probably
  not what he wanted. replace /STRING with /SPLIT here. 
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>VIEW-NEXT-LINE</forthname>
    <forthstack>( src . str len -- src . str len str2 len2 )</forthstack>
    <forthhints></forthhints>
    <stackline>VIEW-NEXT-LINE    ( src . str len -- src . str len str2 len2 )</stackline>
   </forthdefinition>
   <comment><para>   Copy next line above current line.
</para><screen>  : VIEW-NEXT-LINE 
     2OVER 2DUP #EOL-CHAR SCAN NIP - ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OUT</forthname>
    <forthstack>( -- addr )</forthstack>
    <forthhints></forthhints>
    <stackline>OUT                 ( -- addr )</stackline>
   </forthdefinition>
   <comment><para>    Promiscuous variable.
</para><screen>  VARIABLE OUT
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>TEMP</forthname>
    <forthstack>( -- addr )</forthstack>
    <forthhints></forthhints>
    <stackline>TEMP                ( -- addr )</stackline>
   </forthdefinition>
   <comment><para>   Promiscuous variable.
</para><screen>  VARIABLE TEMP
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>NEXT-WORD</forthname>
    <forthstack>( -- str len )</forthstack>
    <forthhints></forthhints>
    <stackline>NEXT-WORD             ( -- str len )</stackline>
   </forthdefinition>
   <comment><para>   Get the next word across line breaks as a character
   string. _len_ will be 0 at end of file.
</para><screen>  : NEXT-WORD         
     BEGIN   BL WORD COUNT      ( str len )
         DUP IF EXIT THEN
         REFILL
     WHILE  2DROP ( ) REPEAT ;  
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LEXEME</forthname>
    <forthstack>( "name" -- str len )</forthstack>
    <forthhints></forthhints>
    <stackline>LEXEME                ( "name" -- str len )</stackline>
   </forthdefinition>
   <comment><para>   Get the next word on the line as a character string.
   If it's a single character, use it as the delimiter to
   get a phrase.
</para><screen>  : LEXEME             
     BL WORD ( addr) DUP C@ 1 =
         IF  CHAR+ C@ WORD  THEN
     COUNT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>H#</forthname>
    <forthstack>( "hexnumber" -- n )</forthstack>
    <forthhints></forthhints>
    <stackline>H#                    ( "hexnumber" -- n )</stackline>
   </forthdefinition>
   <comment><para>   Get the next word in the input stream as a hex
   single-number literal.  (Adopted from Open Firmware.)
</para><screen>  : H#  ( "hexnumber" -- n )  \  Simplified for easy porting.
     0 0 BL WORD COUNT                  
     BASE @ &gt;R  HEX  &gt;NUMBER  R&gt; BASE !
         ABORT" Not Hex " 2DROP          ( n)
     STATE @ IF  POSTPONE LITERAL  THEN
     ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>\\</forthname>
    <forthstack>( "...&lt;eof&gt;" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>\\                    ( "...&lt;eof&gt;" -- )</stackline>
   </forthdefinition>
   <comment><para>   Ignore the rest of the input stream.
</para><screen>  : \\   BEGIN  -1 PARSE  2DROP  REFILL 0= UNTIL ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FILE-CHECK</forthname>
    <forthstack>( n -- )</forthstack>
    <forthhints></forthhints>
    <stackline>FILE-CHECK        ( n -- )</stackline>
   </forthdefinition>
   <comment><para>   Check for file access error.
</para><screen>  \ : FILE-CHECK    ( n -- )  THROW ;
  : FILE-CHECK      ( n -- )  ABORT" File Access Error " ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MEMORY-CHECK</forthname>
    <forthstack>( n -- )</forthstack>
    <forthhints></forthhints>
    <stackline>MEMORY-CHECK      ( n -- )</stackline>
   </forthdefinition>
   <comment><para>   Check for memory allocation error.
</para><screen>  \ : MEMORY-CHECK  ( n -- )  THROW ;
  : MEMORY-CHECK    ( n -- )  ABORT" Memory Allocation Error " ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>++</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>++                  ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>   Increment the value at _addr_.
</para><screen>  : ++  ( addr -- )  1 SWAP +! ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>@+</forthname>
    <forthstack>( addr -- addr' x )</forthstack>
    <forthhints></forthhints>
    <stackline>@+                  ( addr -- addr' x )</stackline>
   </forthdefinition>
   <comment><para>   Fetch the value _x_ from _addr_, and increment the address
   by one cell.
</para><screen>  : @+  ( addr -- addr' x )  DUP CELL+ SWAP  @ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>!+</forthname>
    <forthstack>( addr x -- addr' )</forthstack>
    <forthhints></forthhints>
    <stackline>!+                  ( addr x -- addr' )</stackline>
   </forthdefinition>
   <comment><para>   Store the value _x_ into _addr_, and increment the address
   by one cell.
</para><screen>  : !+  ( addr x -- addr' )  OVER !  CELL+ ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>'th</forthname>
    <forthstack>( n "addr" -- &amp;addr[n] )</forthstack>
    <forthhints></forthhints>
    <stackline>'th             ( n "addr" -- &amp;addr[n] )</stackline>
   </forthdefinition>
   <comment><para>   Address `n CELLS addr +`.
</para><screen>  : 'th     ( n "addr" -- &amp;addr[n] )
     S" 2 LSHIFT " EVALUATE
     BL WORD COUNT EVALUATE
     S" + " EVALUATE
     ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(.)             ( n -- addr u )</stackline>
   </forthdefinition>
   <comment><para>   Convert _n_ to characters, without punctuation, as for `.`
   (dot), returning the address and length of the resulting
   string.
</para><screen>  : (.)  ( n -- addr u )  DUP ABS 0 &lt;# #S ROT SIGN #&gt; ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CELL-</forthname>
    <forthstack>( addr -- addr' )</forthstack>
    <forthhints></forthhints>
    <stackline>CELL-               ( addr -- addr' )</stackline>
   </forthdefinition>
   <comment><para>   Decrement address by one cell
</para><screen>  : CELL-  ( addr -- addr' )  CELL - ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EMITS</forthname>
    <forthstack>( n char -- )</forthstack>
    <forthhints></forthhints>
    <stackline>EMITS           ( n char -- )</stackline>
   </forthdefinition>
   <comment><para>   Emit _char_ _n_ times.
</para><screen>  : EMITS             ( n char -- )
     SWAP 0 ?DO  DUP EMIT  LOOP DROP ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>HIWORD</forthname>
    <forthstack>( xxyy -- xx )</forthstack>
    <forthhints></forthhints>
    <stackline>HIWORD          ( xxyy -- xx )</stackline>
   </forthdefinition>
   <comment><para>   The high half of the value.
</para><screen>  : HIWORD  ( xxyy -- xx )  16 RSHIFT ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOWORD</forthname>
    <forthstack>( xxyy -- yy )</forthstack>
    <forthhints></forthhints>
    <stackline>LOWORD          ( xxyy -- yy )</stackline>
   </forthdefinition>
   <comment><para>   The low half of the value.
</para><screen>  : LOWORD  ( xxyy -- yy )  65535 AND ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REWIND-FILE</forthname>
    <forthstack>( file-id -- ior )</forthstack>
    <forthhints></forthhints>
    <stackline>REWIND-FILE     ( file-id -- ior )</stackline>
   </forthdefinition>
   <comment><para>   Rewind the file.
</para><screen>  : REWIND-FILE       ( file-id -- ior )
     0 0 ROT REPOSITION-FILE ;
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/tools-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>.S</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>.S ( -- )</stackline>
   </forthdefinition>
   <comment><para>      print the stack content in vertical nice format.
      tries to show cell-stack and float-stack side-by-side,
</para><para>
 	 Depending on configuration,
 	there are two parameter stacks: for integers and for
 	floating point operations. If both stacks are empty, <link>.S</link>
 	will display the message <code>&lt;stacks empty&gt;</code>.
</para><para>
 	If only the floating point stack is empty, <link>.S</link> displays
 	the integer stack items  in one column, one item per line,
 	both in hex and in decimal like this (the first item is topmost):
</para><screen>  12345 HEX 67890 .S
     	424080 [00067890]
          12345 [00003039] ok
</screen><para>
       If both stacks ar not empty, => .S displays both stacks, in two
 	columns, one item per line
</para><screen>  HEX 123456.78E90 ok
  DECIMAL 123456.78E90 .S
     	   291 [00000123]          1.234568E+95
     1164414608 [45678E90] ok
</screen><para>  	Confusing example? Remember that floating point input only works
  	when the <link>BASE</link> number is <link>DECIMAL</link>. The first number looks like
  	a floating point but it is a goodhex double integer too - the number
  	base is <link>HEX</link>. Thus it is accepted as a hex number. Second try 
       with a decimal base will input the floating point number.
</para><para>
       If only the integer stack is empty, => .S shows two columns, but
       he first columns is called <tt>&lt;stack empty&gt;</tt>, and the
       second column is the floating point stack, topmost item first.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?</forthname>
    <forthstack>( addr -- )</forthstack>
    <forthhints></forthhints>
    <stackline>? ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>  Display the (integer) content of at address <tt>addr</tt>.
  This word is sensitive to <link>BASE</link>
</para><screen>  simulate:
    : ?  @ . ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DUMP</forthname>
    <forthstack>( addr len -- )</forthstack>
    <forthhints></forthhints>
    <stackline>DUMP ( addr len -- )</stackline>
   </forthdefinition>
   <comment><para>  show a hex-dump of the given area, if it's more than a screenful
  it will ask using => ?CR
</para><para>
  You can easily cause a segmentation fault of something like that
  by accessing memory that does not belong to the pfe-process.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SEE</forthname>
    <forthstack>( "word" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SEE ( "word" -- )</stackline>
   </forthdefinition>
   <comment><para>   decompile word - tries to show it in re-compilable form.
</para><para>
   <link>(SEE)</link> tries to display the word as a reasonable indented
   source text. If you defined your own control structures or
   use extended control-flow patterns, the indentation may be
   suboptimal.
</para><screen>  simulate:
    : SEE  [COMPILE] ' (SEE) ; 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>WORDS</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>WORDS ( -- )</stackline>
   </forthdefinition>
   <comment><para>  uses CONTEXT and lists the words defined in that vocabulary.
  usually the vocabulary to list is named directly in before.
</para><screen>  example:
     FORTH WORDS  or  LOADED WORDS
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>AHEAD</forthname>
    <forthstack>( -- DP-mark ORIG-magic )</forthstack>
    <forthhints> compile-only</forthhints>
    <stackline>AHEAD ( -- DP-mark ORIG-magic ) compile-only</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate:
    : AHEAD  BRANCH MARK&gt; (ORIG#) ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>BYE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints> no-return</forthhints>
    <stackline>BYE ( -- ) no-return</stackline>
   </forthdefinition>
   <comment><para>  should quit the forth environment completly
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CS-PICK</forthname>
    <forthstack>( 2a 2b 2c ... n -- 2a 2b 2c ... 2a )</forthstack>
    <forthhints></forthhints>
    <stackline>CS-PICK ( 2a 2b 2c ... n -- 2a 2b 2c ... 2a )</stackline>
   </forthdefinition>
   <comment><para>  pick a value in the compilation-stack - note that the compilation
  stack _can_ be seperate in some forth-implemenations. In PFE
  the parameter-stack is used in a double-cell fashion, so CS-PICK
  would 2PICK a DP-mark and a COMP-magic, see <link>PICK</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CS-ROLL</forthname>
    <forthstack>( 2a 2b 2c ... n -- 2b 2c ... 2a )</forthstack>
    <forthhints></forthhints>
    <stackline>CS-ROLL ( 2a 2b 2c ... n -- 2b 2c ... 2a )</stackline>
   </forthdefinition>
   <comment><para>  roll a value in the compilation-stack - note that the compilation
  stack _can_ be seperate in some forth-implemenations. In PFE
  the parameter-stack is used in a double-cell fashion, so CS-ROLL
  would 2ROLL a DP-mark and a COMP-magic, see <link>ROLL</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FORGET</forthname>
    <forthstack>( "word" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>FORGET ( "word" -- )</stackline>
   </forthdefinition>
   <comment><screen> 
  simulate:
    : FORGET  [COMPILE] '  &gt;NAME (FORGET) ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[ELSE]</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>[ELSE] ( -- )</stackline>
   </forthdefinition>
   <comment><para>  eat up everything upto and including the next [THEN]. count
  nested [IF] ... [THEN] constructs. see <link>[IF]</link>
</para><screen>  this word provides a simple pre-compiler mechanism
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[IF]</forthname>
    <forthstack>( flag -- )</forthstack>
    <forthhints></forthhints>
    <stackline>[IF] ( flag -- )</stackline>
   </forthdefinition>
   <comment><para>  check the condition in the CS-STACK. If true let the following
  text flow into <link>INTERPRET</link> , otherwise eat up everything upto
  and including the next <link>[ELSE]</link> or <link>[THEN]</link> . In case of 
  skipping, count nested [IF] ... [THEN] constructs.
</para><screen>  this word provides a simple pre-compiler mechanism
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ASSEMBLER</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ASSEMBLER ( -- )</stackline>
   </forthdefinition>
   <comment><para>  set the <link>ASSEMBLER-WORDLIST</link> as current <link>CONTEXT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CODE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CODE ( "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>CREATE</link> a new name and put PFA adress into the CFA place. 
</para><para>
  NOTE: this description (PFA into CFA) is only correct for traditional
  indirect threaded code (ITC). The other variants use a block info
  in the CFA - there we will start a normal colon word which is cut
  off immediately by a <link>;CODE</link> directive to enter the machine-level.
</para><para>
  BE AWARE:
  The TOOLS-EXT will not provide an <link>END-CODE</link> or any other word in the
  <link>ASSEMBLER</link> wordlist which is required to start any useful assembler 
  programming. After requiring ASSEMBLER-EXT you will see a second "CODE"
  in the <link>EXTENSIONS</link> wordlist that will also provide an optimized execution
  than the result of this standard-forth implemenation.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>;CODE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>;CODE ( -- )</stackline>
   </forthdefinition>
   <comment><para>  Does end the latest word (being usually some DOES> part) and enters
  machine-level (in EXEC-mode). 
</para><para>
  BE AWARE:
  The TOOLS-EXT will not provide an <link>END-CODE</link> or any other word in the
  <link>ASSEMBLER</link> wordlist which is required to start any useful assembler 
  programming. After requiring ASSEMBLER-EXT you will see a second ";CODE"
  in the <link>EXTENSIONS</link> wordlist that will also provide an optimized execution
  than the result of this standard-forth implemenation.
</para><para>
  The Standard-Forth implementation will actually compile a derivate of
  <link>BRANCH</link> into the dictionary followed by <link>;</link>. The compiled word
  will not jump to the target adress (following the execution token)
  but it will call the target adress via the host C stack. The target
  machine level word (C domain) will just return here for being
  returned (Forth domain). Hence <link>END-CODE</link> may be a simple RET, comma!
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>END-CODE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>END-CODE ( "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  call <link>PREVIOUS</link> and  add PROC LEAVE assembler snippet as needed
  for the architecture -  usually includes bits to "return from
  subroutine". Remember that not all architectures are support and
  PFE usually does only do variants of call-threading with a separate
  loop for the inner interpreter that does "call into subroutine".
</para><para>
  Some forth implementations do "jump into routine" and the PROC
  LEAVE part would do "jump to next routine" also known as 
  next-threading. The sbr-call-threading is usually similar to the
  native subroutine-coding of the host operating system. See <link>CODE</link>
</para><para>
  On some machine types, this word is NOT DEFINED!
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/tools-mix.c">
  <forthheader>
   <forthdefinition>
    <forthname>VLIST</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>VLIST ( -- )</stackline>
   </forthdefinition>
   <comment><para>   The VLIST command had been present in FIG and other forth
   implementations. It has to list all accessible words. In PFE
   it list all words in the search order. Well, the point is,
   that we do really just look into the search order and are
   then calling <link>WORDS</link> on that Wordl. That way you can see
   all accessible words in the order they might be found.
   Uses => ?CR
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>!CSP</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>!CSP ( -- )</stackline>
   </forthdefinition>
   <comment><para>  put <link>SP</link> into <link>CSP</link>
  <br> used in control-words
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?CSP</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?CSP ( -- )</stackline>
   </forthdefinition>
   <comment><para>  check that <link>SP</link> == <link>CSP</link> otherwise <link>THROW</link>
  <br> used in control-words
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?COMP</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?COMP ( -- )</stackline>
   </forthdefinition>
   <comment><para>  check that the current <link>STATE</link> is compiling
  otherwise <link>THROW</link>
  <br> often used in control-words
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?EXEC</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?EXEC ( -- )</stackline>
   </forthdefinition>
   <comment><para>  check that the current <link>STATE</link> is executing
  otherwise <link>THROW</link>
  <br> often used in control-words
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?FILE</forthname>
    <forthstack>( file-id -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?FILE ( file-id -- )</stackline>
   </forthdefinition>
   <comment><para>  check the file-id otherwise (fixme)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?LOADING</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?LOADING ( -- )</stackline>
   </forthdefinition>
   <comment><para>  check that the currently interpreted text is 
  from a file/block, otherwise <link>THROW</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?PAIRS</forthname>
    <forthstack>( a b -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?PAIRS ( a b -- )</stackline>
   </forthdefinition>
   <comment><para>  if compiling, check that the two magics on
  the <link>CS-STACK</link> are identical, otherwise throw
  <br> used in control-words
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>?STACK</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>?STACK ( -- )</stackline>
   </forthdefinition>
   <comment><para>  check all stacks for underflow and overflow conditions,
  and if such an error condition is detected <link>THROW</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[VOID]</forthname>
    <forthstack>( -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>[VOID]                ( -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Immediate FALSE. Used to comment out sections of code.
   IMMEDIATE so it can be inside definitions.
</para><screen>  : [VOID] 0 ; immediate
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DEFINED</forthname>
    <forthstack>( "name" -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>DEFINED             ( "name" -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Search the dictionary for _name_. If _name_ is found,
   return TRUE; otherwise return FALSE. Immediate for use in
   definitions.
</para><para>  This word will actually return what <link>FIND</link> returns (the NFA). 
  does check for the word using find (so it does not throw like <link>'</link> )
  and puts it on stack. As it is immediate it does work in compile-mode
  too, so it places its argument in the cs-stack then. This is most
  useful with a directly following <link>[IF]</link> clause, so that sth. like
  an <code>[IFDEF] word</code> can be simulated through <code>[DEFINED] word [IF]</code>
</para><screen> 
  : DEFINED BL WORD COUNT (FIND-NFA) ; 
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[DEFINED]</forthname>
    <forthstack>( [name] -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>[DEFINED]             ( [name] -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Search the dictionary for _name_. If _name_ is found,
   return TRUE; otherwise return FALSE. Immediate for use in
   definitions.
</para><para>  This word will actually return what <link>FIND</link> returns (the NFA). 
  does check for the word using find (so it does not throw like <link>'</link> )
  and puts it on stack. As it is immediate it does work in compile-mode
  too, so it places its argument in the cs-stack then. This is most
  useful with a directly following <link>[IF]</link> clause, so that sth. like
  an <code>[IFDEF] word</code> can be simulated through <code>[DEFINED] word [IF]</code>
</para><screen> 
  : [DEFINED] DEFINED ; IMMEDIATE
  : [DEFINED] BL WORD COUNT (FIND-NFA) ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[UNDEFINED]</forthname>
    <forthstack>( [name] -- flag )</forthstack>
    <forthhints></forthhints>
    <stackline>[UNDEFINED]          ( [name] -- flag )</stackline>
   </forthdefinition>
   <comment><para>   Search the dictionary for _name_. If _name_ is found,
   return FALSE; otherwise return TRUE. Immediate for use in
   definitions.
</para><para>
   see <link>[DEFINED]</link>
</para><screen>  : [UNDEFINED] DEFINED 0= ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(FORGET) ( addr -- )</stackline>
   </forthdefinition>
   <comment><para>  forget everything above addr
  - used by <link>FORGET</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(DICTLIMIT)   ( -- constvalue )</stackline>
   </forthdefinition>
   <comment><para>  the upper limit of the forth writeable memory space,
  the variable <link>DICTLIMIT</link> must be below this line.
  stack-space and other space-areas are often allocated
  above <link>DICTLIMIT</link> upto this constant.
</para><para>
  <link>DICTFENCE</link> is the lower end of the writeable dictionary
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>(DICTFENCE)   ( -- constvalue )</stackline>
   </forthdefinition>
   <comment><para>  the lower limit of the forth writeable memory space,
  the variable <link>DICTFENCE</link> must be above this line.
  Some code-areas are often moved in between <link>DICTFENCE</link> and
  this constant. To guard normal Forth code from deletion
  the usual practice goes with the <link>FENCE</link> variable
</para><para>
  <link>DICTLIMIT</link> is the upper end of the writeable dictionary
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>FENCE</forthname>
    <forthstack>( -- var* )</forthstack>
    <forthhints></forthhints>
    <stackline>FENCE        ( -- var* )</stackline>
   </forthdefinition>
   <comment><para>  a forth system variable - <link>(FORGET)</link> will not work below
  this address and any <link>FORGET</link> on a header below this mark
  will <link>THROW</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DICTFENCE</forthname>
    <forthstack>( -- var* )</forthstack>
    <forthhints></forthhints>
    <stackline>DICTFENCE   ( -- var* )</stackline>
   </forthdefinition>
   <comment><para>  the lower end of usable area - the forth memory block minus the 
  forth-VM backstore. Note that this is a variable by tradition but
  you should not move it.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DICTLIMIT</forthname>
    <forthstack>( -- var* )</forthstack>
    <forthhints></forthhints>
    <stackline>DICTLIMIT   ( -- var* )</stackline>
   </forthdefinition>
   <comment><para>  the lower end of usable area - the forth memory block minus the 
  forth-related DICTALLOCS at the upper end (e.g. <link>POCKET-PAD</link> )
  Note that this is a variable by tradition but you should not move it.
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/tools-sub.c">
  <forthheader>
   <forthdefinition>
    <forthname>_?stop_</forthname>
    <forthstack>( -- ?key )</forthstack>
    <forthhints></forthhints>
    <stackline>_?stop_ ( -- ?key )</stackline>
   </forthdefinition>
   <comment><para>  check for a keypress, and if it was 'q' being pressed
</para><screen>  : _?stop_ _key?_ _key_ [char] q = ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>_?cr_</forthname>
    <forthstack>( -- ?stopped )</forthstack>
    <forthhints></forthhints>
    <stackline>_?cr_ ( -- ?stopped )</stackline>
   </forthdefinition>
   <comment><para>  Like CR but stop after one screenful and return flag if 'q' pressed.
  Improved by aph@oclc.org (Andrew Houghton)
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/useful-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>_for:COMPILE,</forthname>
    <forthstack>( xt -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"_for:COMPILE," ( xt -- )</stackline>
   </forthdefinition>
   <comment><para>   does the work of <link>POSTPONE</link> on the execution token that 
   you got from somewhere else - so it checks if the name
   (that correspond to the execution-token argument) is
   actually immediate, so it has to be executed to compile
   something, e.g. <link>IF</link> or <link>THEN</link> - see also <link>POSTPONE</link> ,
   <link>COMPILE</link> , <link>[COMPILE]</link> , <link>INTERPRET</link>
</para><para>
   warning: do not use this word anymore, it is an error to
   compile a token where the immediate-bit must be checked.
   The immediate-bit is a pure header information not present
   with headerless words as such. Furthermore, this function
   is subject to POSTPONE problems as well.
</para><para>
   Newer code should use <link>COMPILE,</link> when trying to simulate
   a behavior similar to <link>POSTPONE</link>.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>($</forthname>
    <forthstack>( [word] -- cs-token )</forthstack>
    <forthhints> compile-only</forthhints>
    <stackline>"($" ( [word] -- cs-token ) compile-only</stackline>
   </forthdefinition>
   <comment><para>   takes the execution token of the following word and
   saves it on the compile-stack. The correspondig closing
   <link>)</link> will then feed it into <link>>COMPILE</link> - so this pair
   of word provides you with a prefix-operation syntax
   that you may have been seen in lisp-like languages.
</para><screen>    ($ IF ($ 0= A1 @ )) ($ THEN ." hello " )
</screen><para>  Note that an opening simple <link>(</link> paren is a comment.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>)</forthname>
    <forthstack>( cs-token -- )</forthstack>
    <forthhints></forthhints>
    <stackline>")" ( cs-token -- )</stackline>
   </forthdefinition>
   <comment><para>  takes the execution-token from <link>($</link> and compiles
  it using <link>>COMPILE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>))</forthname>
    <forthstack>( cs-token cs-token -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"))" ( cs-token cs-token -- )</stackline>
   </forthdefinition>
   <comment><para>  takes two execution-tokens from two of <link>($</link> and compiles
  them on after another using <link>>COMPILE</link>
</para><screen>  simulate:
     : )) [COMPILE] ) [COMPILE] ) ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PFE-SPRINTF</forthname>
    <forthstack>( args ... format$ dest$ -- len-dest )</forthstack>
    <forthhints></forthhints>
    <stackline>PFE-SPRINTF ( args ... format$ dest$ -- len-dest )</stackline>
   </forthdefinition>
   <comment><para>  just like the standard sprintf() function in C, but
  the format is a counted string and accepts %#s to
  be the format-symbol for a forth-counted string.
  The result is a zeroterminated string at dest$ having
  a length being returned. To create a forth-counted
  string, you could use:
</para><screen>    variable A 256 ALLOT
    15 " example" " the %#s value is %i" A 1+ SPRINTF A C!
    A COUNT TYPE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>PFE-PRINTF</forthname>
    <forthstack>( args ... format$ -- )</forthstack>
    <forthhints></forthhints>
    <stackline>PFE-PRINTF ( args ... format$ -- )</stackline>
   </forthdefinition>
   <comment><para>  uses <link>SPRINTF</link> to print to a temporary 256-char buffer
  and prints it to stdout afterwards. See the example
  at <link>SPRINTF</link> of what it does internally.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOADF</forthname>
    <forthstack>( "filename" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>LOADF ( "filename" -- )</stackline>
   </forthdefinition>
   <comment><para>   loads a file just like <link>INCLUDE</link> but does also put
   a <link>MARKER</link> in the <link>LOADED</link> dictionary that you can
   do a <link>FORGET</link> on to kill everything being loaded
   from that file.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(LOADF-LOCATE)</forthname>
    <forthstack>( xt -- nfa )</forthstack>
    <forthhints></forthhints>
    <stackline>"(LOADF-LOCATE)" ( xt -- nfa )</stackline>
   </forthdefinition>
   <comment><para>  the implementation of <link>LOADF-LOCATE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>LOADF-LOCATE</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>LOADF-LOCATE ( "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  look for the filename created by <link>LOADF</link> that had been
  defining the given name. <link>LOADF</link> has created a marker
  that is <em>above</em> the <link>INCLUDED</link> file and that
  marker has a body-value just <em>below</em> the 
  <link>INCLUDED</link> file. Hence the symbol was defined during
  <link>LOADF</link> execution of that file.
</para><screen>  : LOADF-LOCATE ?EXEC POSTPONE ' (LOADF-LOCATE) .NAME ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>(;AND)</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"(;AND)" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>;AND</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>;AND</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>";AND" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  For the code piece between <link>MAKE</link> and <link>;AND</link> , this word
  will do just an <link>EXIT</link> . For the code outside of
  the <link>MAKE</link> construct a branch-around must be resolved then.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((MAKE-))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"((MAKE-))" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>MAKE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>((MAKE))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"((MAKE))" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>MAKE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DOER</forthname>
    <forthstack>( word -- )</forthstack>
    <forthhints></forthhints>
    <stackline>DOER ( word -- )</stackline>
   </forthdefinition>
   <comment><para>  In PFE it is a synonym to <link>DEFER</link> which a semistandard word.
  Unlike <link>DEFER</link>, the <link>DOER</link>-vector was set with an a small
  piece of code between <link>MAKE</link> and <link>;AND</link>. The "DOER"-word
  should be replaced with <link>DEFER</link> <link>IS</link>, which is easy since
  the <link>DEFER</link> and <link>DOER</link> point to the same internal runtime.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>MAKE</forthname>
    <forthstack>( [word] -- )</forthstack>
    <forthhints> ... ;AND</forthhints>
    <stackline>MAKE ( [word] -- ) ... ;AND</stackline>
   </forthdefinition>
   <comment><para>  make a seperated piece of code between <link>MAKE</link> and <link>;AND</link> 
  and on execution of the <link>MAKE</link> the named word is twisted
  to point to this piece of code. The word is usually 
  a <link>DOER</link> but the current implementation works 
  on <link>DEFER</link> just as well, just as it does on other words who
  expect to find an execution-token in its PFA. You could even
  create a colon-word that starts with <link>NOOP</link> and can then make
  that colon-word be prefixed with the execution of the code piece. 
  This <link>MAKE</link>
  does even work on <link>LOCALS|</link> and <link>VAR</link> but it is uncertain
  what that is good for.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>OFFSET-RT</forthname>
    <forthstack>( value -- value+offset )</forthstack>
    <forthhints></forthhints>
    <stackline>OFFSET-RT ( value -- value+offset )</stackline>
   </forthdefinition>
   <comment><para>   this runtime will add the body-value to the value at top-of-stack.
   used heavily in structure access words, compiled by <link>/FIELD</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+CONSTANT</forthname>
    <forthstack>( offset "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>+CONSTANT ( offset "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  create a new offsetword. The word is created and upon execution
  it adds the offset, ie. compiling the <link>OFFSET-RT</link> runtime:
</para><screen>        ( address -- address+offset )
</screen><para>  This word is just a convenience word, just use the word <link>+FIELD</link> 
  directly and choose a <link>DROP</link> to flag the end of a current
  offset-field declaration series. See also <link>/FIELD</link> series to
  declare simple structures which end with a final <link>CONSTANT</link> to
  memorize the complete size. The <link>/FIELD</link> style is more traditional.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+FIELD</forthname>
    <forthstack>( offset "name" -- offset )</forthstack>
    <forthhints> [deprecated]</forthhints>
    <stackline>+FIELD ( offset "name" -- offset ) [deprecated]</stackline>
   </forthdefinition>
   <comment><para>  The word +FIELD is reserved by http://www.forth200x.org/structures.html
  so the old PFE usage of <link>+FIELD</link> has been renamed to <link>+FIELD:</link> to avoid 
  a conflict. A deprecation warning will be shown when code uses this word
  that is already a <link>SYNONYM</link> of <link>+FIELD:</link> . As earlier PFE implementations
  have not been using +FIELD: one can use an ifdef to run modified
  PFE applications on old PFE implementations.
</para><screen>  [DEFINED] +FIELD: [NOT] [IF] SYNONYM +FIELD: +FIELD [THEN]
</screen><para>
  The Forth200x interpretation of <link>+FIELD</link> is already present in PFE under
  the name of <link>/FIELD</link> so you can already use it in your code. Any
  application that likes be forth200x conformant may use an ifdef of
  the format
</para><screen>  [DEFINED] /FIELD [IF] SYNONYM +FIELD /FIELD [THEN]
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+FIELD:</forthname>
    <forthstack>( offset "name" -- offset )</forthstack>
    <forthhints></forthhints>
    <stackline>+FIELD: ( offset "name" -- offset )</stackline>
   </forthdefinition>
   <comment><para>  created a new name with an <link>OFFSET-RT</link> runtime using the given offset. 
  Leave the offset-value untouched, so it can be modified with words
  like <link>CHAR+</link> and <link>CELL+</link> and <link>SFLOAT+</link> ; This word is the simplest way 
  to declared structure access words in forth - the two <link>STRUCT</link> modules 
  contain a more elaborate series of words. Use this one like:
</para><screen>  0                        ( a fresh definition is started )
  +FIELD: zapp.a+ CHAR+     ( zero offset from the base of the struct )
  +FIELD: zapp.b+ CELL+     ( no alignment, starts off at 1 from base )
  +FIELD: zapp+   DROP      ( store size of complete zap structure )
 
  0 zapp+                  ( extend the zap structure )
  +FIELD: zappx.c+ CELL+    ( a new field )
  +FIELD: zappx+   DROP     ( and save it again )
 
  CREATE zapp1  0 zapp+ ALLOT ( a way to allocate a strucutre )
 
  zapp2 zapp.b+ @         ( read a value from the field )
  16 zapp2 zapp.b+ !      ( store a value in there )
 
</screen><para>  this form is not the traditional form used in forth, it is however
  quite simple. Use the simplefield declaration with <link>/FIELD</link> to
  be compatible with traditional styles that build on top of sizeof
  constants in forth (which are not part of the ANS Forth standard).
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>/FIELD</forthname>
    <forthstack>( offset size "name" -- offset+size )</forthstack>
    <forthhints></forthhints>
    <stackline>/FIELD ( offset size "name" -- offset+size )</stackline>
   </forthdefinition>
   <comment><para>  created a new <link>+FIELD</link> name with an <link>OFFSET-RT</link>
  of offset. Then add the size value to the offset so that
  the next <link>/FIELD</link> declaration will start at the end of the
  field currently declared. This word is the simplest way to
  declared structure access words in forth - the two <link>STRUCT</link> modules 
  contain a more elaborate series of words. This one is used like:
</para><screen>  0                        ( a fresh definition is started )
  /CHAR /FIELD -&gt;zapp.a    ( zero offset from the base of the struct )
  /CELL /FIELD -&gt;zapp.b    ( no alignment, starts off at 1 from base )
  CONSTANT /zapp           ( store size of complete zap structure )
 
  /zapp                    ( extend the zap structure )
  /CELL /FIELD -&gt;zappx.c   ( a new field )
  CONSTANT /zappx          ( and save it again )
 
  CREATE zapp1 /zapp ALLOT ( a way to allocate a strucutre )
  /zapp BUFFER: zapp2      ( another way to do it, semi-standard )
 
  zapp2 -&gt;zapp.b @         ( read a value from the field )
  16 zapp2 -&gt;zapp.b !      ( store a value in there )
 
</screen><para>  compare also with <link>/CHAR</link> <link>/WCHAR</link> <link>/CELL</link> <link>/DCELL</link>
  and use <link>+FIELD</link> as the lowlevel word, can simulate as
</para><screen>  : /FIELD SWAP +FIELD + ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[NOT]</forthname>
    <forthstack>( a -- a' )</forthstack>
    <forthhints></forthhints>
    <stackline>[NOT] ( a -- a' )</stackline>
   </forthdefinition>
   <comment><para>  executes <link>0=</link> but this word is immediate so that it does 
  affect the cs-stack while compiling rather than compiling
  anything. This is useful just before words like <link>[IF]</link> to
  provide semantics of an <code>[IFNOT]</code>. It is most useful in
  conjunction with "=> [DEFINED] word" as it the sequence
  "<code>[DEFINED] word [NOT] [IF]</code>" can simulate "<code>[IFNOTDEF] word</code>"
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>REPLACE-IN</forthname>
    <forthstack>( to-xt from-xt n "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>REPLACE-IN ( to-xt from-xt n "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  will handle the body of the named word as a sequence of cells (or tokens) 
  and replaces the n'th occurences of from-xt into to-xt. A negative value
  will change all occurences. A zero value will not change any.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>X"</forthname>
    <forthstack>( "hex-q" -- bstring )</forthstack>
    <forthhints></forthhints>
    <stackline>'X"' ( "hex-q" -- bstring )</stackline>
   </forthdefinition>
   <comment><para>  places a counted string on stack
  containing bytes specified by hex-string
  - the hex string may contain spaces which will delimit the bytes
</para><screen>  example: 
     X" 41 42 4344" COUNT TYPE ( shows ABCD )
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>EVALUATE-WITH</forthname>
    <forthstack>( i*x addr len xt[i*x--j*x] -- j*x )</forthstack>
    <forthhints></forthhints>
    <stackline>EVALUATE-WITH ( i*x addr len xt[i*x--j*x] -- j*x )</stackline>
   </forthdefinition>
   <comment><para>  added to be visible on the forth command line on request by MLG,
  he has explained the usage before a lot, you can get an idea from:
</para><screen>     : EVALUATE ['] INTERPRET EVALUATE-WITH ;
</screen><para>  The word is used internally in PFE for the loadlist evaluation of
  the binary modules: where previously each loadercode had its own
  CREATE-execution we do now call the original forthish CREATE-word
  like, so bootstrapping a <link>VARIABLE</link> will now call VARIABLE itself
  and of course we need to set up the TIB-area to point to the name
  of the variable that shall be created in the forth dictionary:
</para><screen>  : LOAD-WORD ( arg-value str-ptr str-len loader-code -- )
       CASE
         #LOAD-VARIABLE OF ['] VARIABLE EVALUATE-WITH ENDOF
         ....
       ENDCASE
       CLEARSTACK
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[VOCABULARY]</forthname>
    <forthstack>( "name" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>[VOCABULARY] ( "name" -- )</stackline>
   </forthdefinition>
   <comment><para>  create an immediate vocabulary. Provides for basic 
  modularization.
</para><screen>  : [VOCABULARY] VOCABULARY IMMEDIATE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[POSSIBLY]</forthname>
    <forthstack>( [name] -- ?? )</forthstack>
    <forthhints></forthhints>
    <stackline>[POSSIBLY] ( [name] -- ?? )</stackline>
   </forthdefinition>
   <comment><para>  check if the name exists, and execute it immediatly
  if found. Derived from POSSIBLY as seen in other forth systems.
</para><screen>  : [POSSIBLY] (') ?DUP IF EXECUTE THEN ; IMMEDIATE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[DEF]</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>[DEF] ( -- )</stackline>
   </forthdefinition>
   <comment><para>  immediatly set topmost <link>CONTEXT</link> voc to <link>CURRENT</link> compilation voc.
</para><screen>  : DEF' CURRENT @ CONTEXT ! ; IMMEDIATE
</screen><para>  note that in PFE most basic vocabularies are immediate, so that
  you can use a sequence of
</para><screen>  FORTH ALSO  DEFINITIONS
  [DEF] : GET-FIND-3  [ANS] ['] FIND  [FIG] ['] FIND  [DEF] ['] FIND ;
</screen><para>  where the first wordlist to be searched via the search order are
  [ANS] and [FIG] and FORTH (in this order) and which may or may not 
  yield different flavours of the FIND routine (i.e. different XTs)
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CONTEXT?</forthname>
    <forthstack>( -- number )</forthstack>
    <forthhints></forthhints>
    <stackline>CONTEXT? ( -- number )</stackline>
   </forthdefinition>
   <comment><para>  GET-CONTEXT and count how many times it is in the order but
  the CONTEXT variable itself. The returned number is therefore
  minus one the occurences in the complete search-order.
  usage:
</para><screen>    ALSO EXTENSIONS CONTEXT? [IF] PREVIOUS [THEN]
    ALSO DEF' DEFAULT-ORDER
  : CONTEXT? 
    0 LVALUE _count
    GET-ORDER 1- SWAP  LVALUE _context
    0 ?DO _context = IF 1 +TO _count THEN LOOP
    _count
  ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DEFS-ARE-CASE-SENSITIVE</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>DEFS-ARE-CASE-SENSITIVE ( -- )</stackline>
   </forthdefinition>
   <comment><para>  accesses <link>CURRENT</link> which is generally the last wordlist that the
  <link>DEFINITIONS</link> shall go in. sets there a flag in the vocabulary-definition
  so that words are matched case-sensitive. 
</para><screen>  example: 
     VOCABULARY MY-VOC  MY-VOC DEFINITIONS DEFS-ARE-CASE-SENSITIVE
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>CASE-SENSITIVE-VOC</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>CASE-SENSITIVE-VOC ( -- )</stackline>
   </forthdefinition>
   <comment><para>  accesses <link>CONTEXT</link> which is generally the last named <link>VOCABULARY</link> .
  sets a flag in the vocabulary-definition so that words are matched
  case-sensitive. 
</para><screen>  example: 
     VOCABULARY MY-VOC  MY-VOC CASE-SENSITIVE-VOC
</screen><para>  OBSOLETE! use <link>DEFS-ARE-CASE-SENSITIVE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>DEFS-ARE-SEARCHED-ALSO</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>DEFS-ARE-SEARCHED-ALSO ( -- )</stackline>
   </forthdefinition>
   <comment><para>  binds <link>CONTEXT</link> with <link>CURRENT</link>. If the <link>CURRENT</link> <link>VOCABULARY</link> is in
  the search-order (later), then the <link>CONTEXT</link> vocabulary will 
  be searched also. If the result of this word could lead into 
  a recursive lookup with <link>FIND</link> it will throw <code>CURRENT_DELETED</code>
  and leave the <link>CURRENT</link> <link>VOCABULARY</link> unaltered.
</para><screen>  example:
</screen><para>  MY-VOC DEFINITIONS  MY-VOC-PRIVATE DEFS-ARE-SEARCHED-ALSO
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SEARCH-ALSO-VOC</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SEARCH-ALSO-VOC ( -- )</stackline>
   </forthdefinition>
   <comment><para>  OBSOLETE!! use DEFS-ARE-SEARCHED-ALSO
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>[EXECUTE]</forthname>
    <forthstack>( [word] -- )</forthstack>
    <forthhints></forthhints>
    <stackline>[EXECUTE] ( [word] -- )</stackline>
   </forthdefinition>
   <comment><para>  ticks the following word, and executes it - even in compiling mode.
</para><screen>  : [EXECUTE] ' EXECUTE ;
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>!NO</forthname>
    <forthstack>( -- false )</forthstack>
    <forthhints></forthhints>
    <stackline>!NO ( -- false )</stackline>
   </forthdefinition>
   <comment><para>  a synonym for <link>FALSE</link>
</para><screen>  !NO SMART-WORDS!
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>!USE</forthname>
    <forthstack>( -- true )</forthstack>
    <forthhints></forthhints>
    <stackline>!USE ( -- true )</stackline>
   </forthdefinition>
   <comment><para>  a synonym for <link>TRUE</link>
</para><screen>  !USE SMART-WORDS!
  
</screen>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/with-spy.c">
  <forthheader>
   <forthdefinition>
    <forthname>SPY_ON</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SPY_ON ( -- )</stackline>
   </forthdefinition>
   <comment><para>  change the runtime-code of <link>(NEST)</link> 
  to call a special word that prints info
  to the screen whenever a colon word is 
  entered. It will print the name and
  the current stack, and results in a kind
  of execution trace over <link>SPY' :</link>-colon nested
  words.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPY_OFF</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>SPY_OFF ( -- )</stackline>
   </forthdefinition>
   <comment><para>  disable <link>SPY_ON</link> nest-trace.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPY' (NEST)</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"SPY' (NEST)" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>:</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPY' :</forthname>
    <forthstack>( name -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"SPY' :" ( name -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>SPY:</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPY:</forthname>
    <forthstack>( name -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"SPY:" ( name -- )</stackline>
   </forthdefinition>
   <comment><para>  create a header for a nesting word and go to compiling
  mode then. This word is usually ended with <link>;</link> but
  the execution of the resulting colon-word can also 
  return with <link>EXIT</link>
  this is the spy-version <link>SPY_ON</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPY' ((SPY;))</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"SPY' ((SPY;))" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  compiled by <link>;</link> and maybe <link>;AND</link> --
  it will perform an <link>EXIT</link>
  this is the SPY-version
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPY' ;</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"SPY' ;" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>;SPY</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>;SPY</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>";SPY" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  compiles <link>((;))</link> which does <link>EXIT</link> the current
  colon-definition. It does then end compile-mode
  and returns to execute-mode. See <link>:</link> and <link>:NONAME</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPY' EXIT</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"SPY' EXIT" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  <link>SPY-EXIT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>SPY-EXIT</forthname>
    <forthstack>( -- )</forthstack>
    <forthhints></forthhints>
    <stackline>"SPY-EXIT" ( -- )</stackline>
   </forthdefinition>
   <comment><para>  will unnest the current colon-word so it will actually
  return the word calling it. This can be found in the
  middle of a colon-sequence between <link>:</link> and <link>;</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/your-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>'&gt;</forthname>
    <forthstack>( [name] -- xt )</forthstack>
    <forthhints></forthhints>
    <stackline>"'&gt;" ( [name] -- xt )</stackline>
   </forthdefinition>
   <comment><para>  get the execution-token, ie the CFA, of the word following.
  This word is fully state-smart while the ANSI standard words
  namely <link>'</link> and <link>[']</link> are not.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((@&gt;)) ( -- value )</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>@></link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>@&gt;</forthname>
    <forthstack>( [name] -- value )</forthstack>
    <forthhints></forthhints>
    <stackline>@&gt; ( [name] -- value )</stackline>
   </forthdefinition>
   <comment><para>  does fetch the value from the PFA of the named item, which
  may be about everything, including a <link>VARIABLE</link> , <link>VALUE</link>
  <link>LVALUE</link> , <link>LOCALS|</link> , <link>VAR</link> , <link>DEFER</link> , <link>DOER</link> , <link>DOES></link>
  and more.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>!&gt;</forthname>
    <forthstack>( value [name] -- )</forthstack>
    <forthhints></forthhints>
    <stackline>!&gt; ( value [name] -- )</stackline>
   </forthdefinition>
   <comment><para>  actually a synonym for <link>TO</link> but very common amongst
  forth interpreters
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname></forthname>
    <forthstack></forthstack>
    <forthhints></forthhints>
    <stackline>((INTO-)) ( -- value )</stackline>
   </forthdefinition>
   <comment><para>  execution compiled by <link>INTO</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>INTO</forthname>
    <forthstack>( [name] -- pfa )</forthstack>
    <forthhints></forthhints>
    <stackline>INTO ( [name] -- pfa )</stackline>
   </forthdefinition>
   <comment><para>  will return the parameter-field address of the following word.
  Unlike others, this word will also return the address of
  <link>LOCALS|</link> and local <link>LVALUE</link> - so in fact a <code>TO A</code> and 
  <code>INTO A !</code> are the same. This word is most useful when calling
  C-exported function with a temporary local-VAR as a return-place
  argument - so the address of a local has to be given as an arg.
  Beware that you should not try to save the address anywhere else,
  since a local's address does always depend of the RP-depth -
  EXIT from a colon-word and the value may soon get overwritten.
  (see also <link>TO</link> )
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>.H2</forthname>
    <forthstack>( value -- )</forthstack>
    <forthhints></forthhints>
    <stackline>.H2 ( value -- )</stackline>
   </forthdefinition>
   <comment><para>  print hexadecimal, but with per-byte 0-padding
</para><screen>    0x0     -&gt; 00
    0xf     -&gt; 0f
    0x12    -&gt; 12
    0x123   -&gt; 0123
    0x1234  -&gt; 1234
    0x12345 -&gt; 012345
  
</screen>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>HERE-WORD</forthname>
    <forthstack>( char "name&lt;char&gt;" -- )</forthstack>
    <forthhints></forthhints>
    <stackline>HERE-WORD ( char "name&lt;char&gt;" -- )</stackline>
   </forthdefinition>
   <comment><para>  a FIG-compatible WORD. Where ANSI says "skip leading delimiters"
  this one acts as "skip leading whitespace". And it will not return
  anything and have the string parsed to <link>HERE</link>
</para>
</comment>
  </forthheader>
 </forthheaderlist>
 <forthheaderlist filename="../../pfe/zchar-ext.c">
  <forthheader>
   <forthdefinition>
    <forthname>Z"</forthname>
    <forthstack>( [chars&lt;"&gt;] -- z* )</forthstack>
    <forthhints></forthhints>
    <stackline>'Z"'           ( [chars&lt;"&gt;] -- z* )</stackline>
   </forthdefinition>
   <comment><para>  scan the input to the next doublequote and create a buffer
  that holds the chars - return the address of that zero-terminated
  string-buffer, either <link>POCKET-PAD</link> or <link>ALLOT</link>ed into the dictionary.
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZCOUNT</forthname>
    <forthstack>( z* -- z* len )</forthstack>
    <forthhints></forthhints>
    <stackline>ZCOUNT    ( z* -- z* len )</stackline>
   </forthdefinition>
   <comment><para>  push length of z-string, additionally to the string addr itself.
</para><screen>  : ZSTRLEN ZCOUNT NIP ;
</screen><para>  (see libc strlen(3)) / compare with <link>COUNT</link> / <link>ZSTRLEN</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZSTRLEN</forthname>
    <forthstack>( z* -- len )</forthstack>
    <forthhints></forthhints>
    <stackline>ZSTRLEN    ( z* -- len )</stackline>
   </forthdefinition>
   <comment><para>  push length of z-string.
</para><screen>  : ZSTRLEN ZCOUNT NIP ;
</screen><para>  (see libc strlen(3)) / compare with <link>ZMOVE</link> / <link>CMOVE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZMOVE</forthname>
    <forthstack>( zsrc* zdest* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ZMOVE      ( zsrc* zdest* -- )</stackline>
   </forthdefinition>
   <comment><para>  copy a zero terminated string
  (see libc strcpy(3)) / compare with <link>ZSTRLEN</link> / <link>COUNT</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>APPENDZ</forthname>
    <forthstack>( caddr* u zdest* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>APPENDZ    ( caddr* u zdest* -- )</stackline>
   </forthdefinition>
   <comment><para>  Add the string defined by CADDR LEN to the zero terminated string 
  at ZDEST - actually a <link>SYNONYM</link> of <link>+ZPLACE</link> of the <link>ZPLACE</link> family
  (see strncat(3)) / compare with <link>ZPLACE</link> / <link>+PLACE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>+ZPLACE</forthname>
    <forthstack>( caddr* u zdest* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>+ZPLACE    ( caddr* u zdest* -- )</stackline>
   </forthdefinition>
   <comment><para>  Add the string defined by CADDR LEN to the zero terminated string 
  at ZDEST - (for older scripts the <link>SYNONYM</link> named <link>APPENDZ</link> exists)
  (see libc strncat(3)) / compare with <link>ZPLACE</link> / <link>+PLACE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>ZPLACE</forthname>
    <forthstack>( addr* len zaddr* -- )</forthstack>
    <forthhints></forthhints>
    <stackline>ZPLACE  ( addr* len zaddr* -- )</stackline>
   </forthdefinition>
   <comment><para>  copy string and place as 0 terminated
  (see libc strncpy(3)) / see also <link>+ZPLACE</link> / <link>Z+PLACE</link>
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>C\"</forthname>
    <forthstack>( [backslashed-strings_&lt;"&gt;] -- bstr* )</forthstack>
    <forthhints></forthhints>
    <stackline>'C\\\"' ( [backslashed-strings_&lt;"&gt;] -- bstr* )</stackline>
   </forthdefinition>
   <comment><para>  scan the following text to create a literal just
  like <link>C"</link> does, but backslashes can be used to
  escape special chars. The rules for the backslashes
  follow C literals, implemented techniques are
  \n \r \b \a \f \v \e \777
  and all non-alnum chars represent themselves, esp.
  \" \' \ \? \! \% \( \) \[ \] \{ \} etcetera.
  most importantly the doublequote itself can be escaped.
  but be also informed that the usage of \' and \" is not
  portable as some systems preferred to map [\'] into ["].
  Here I use the experimental addition to map [\q] to ["] and [\i] to [']
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>S\"</forthname>
    <forthstack>( [backslashed-strings_&lt;"&gt;] -- str cnt )</forthstack>
    <forthhints></forthhints>
    <stackline>'S\\\"' ( [backslashed-strings_&lt;"&gt;] -- str cnt )</stackline>
   </forthdefinition>
   <comment><para>  scan the following text to create a literal just
  like <link>S"</link> does, but backslashes can be used to
  escape special chars. The rules for the backslashes
  follow C literals, implemented techniques are
  \n \r \b \a \f \v \e \777
  and all non-alnum chars represent themselves, esp.
  \" \' \ \? \! \% \( \) \[ \] \{ \} etcetera.
  most importantly the doublequote itself can be escaped.
  but be also informed that the usage of \' and \" is not
  portable as some systems preferred to map [\'] into ["].
  Here I use the experimental addition to map [\q] to ["] and [\i] to [']
</para>
</comment>
  </forthheader>
  <forthheader>
   <forthdefinition>
    <forthname>Z\"</forthname>
    <forthstack>( [backslashed-strings_&lt;"&gt;] -- zstr* )</forthstack>
    <forthhints></forthhints>
    <stackline>'Z\\\"' ( [backslashed-strings_&lt;"&gt;] -- zstr* )</stackline>
   </forthdefinition>
   <comment><para>  scan the following text to create a literal just
  like <link>Z"</link> does, but backslashes can be used to
  escape special chars. The rules for the backslashes
  follow C literals, implemented techniques are
  \n \r \b \a \f \v \e \777
  and all non-alnum chars represent themselves, esp.
  \" \' \ \? \! \% \( \) \[ \] \{ \} etcetera.
  most importantly the doublequote itself can be escaped
  but be also informed that the usage of \' and \" is not
  portable as some systems preferred to map [\'] into ["].
  Here I use the experimental addition to map [\q] to ["] and [\i] to [']
</para>
</comment>
  </forthheader>
 </forthheaderlist>
</forthheaderxml>
