<!DOCUMENTTYPE forthmodulexml SYSTEM "forth.dtd">
<forthmodulexml>
 <forthmodulelist>
  <forthmodule filename="../../pfe/_missing.c">
   <forthmoduleinfo>
    <title>definitions that may be missing in your system</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2000.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               put here any definitions missing in your system -
 		most of this file contributed by Marko Teiste
</para><para>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/assembler-ext.c">
   <forthmoduleinfo>
    <title>Assembler Words for the Optional Programming-Tools Word Set</title>
    <text>

Copyright (C) 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-05-11 12:48:04 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       The ANS Forth defines some "Programming Tools" containing
       also an ASSEMBLER wordlist plus CODE and ;CODE to create
       callable words with a machine-level text inbetween. This
       wordset.
</para><para>
       Unlike most systems, the PFE is a portable system - therefore
       it is asserted that the machine-level words for CODE / END-CODE
       are known for the specific machine that this Forth is being
       compiled for. Hence you must explicitly require the assembler
       to make it working.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/block-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>      Historically Forth was implemented on small computers as an
      operating system in its own right. Mass storage was not
      organized in files but as a sequence of 1 KB blocks. A block
      was addressed with a block number. This way a diskette drive
      provided a few hundred blocks and if you had a fixed disk
      you simply had thousands of those blocks.
</para><para>
      Both program text and arbitrary data can be stored in blocks.
      In order to hold source text the 1K block is treated as
      having 16 lines with 64 charactes each. This is often 
      referred to as a 'screen'.
</para><para>
      When loading (i.e. interpreting) a block with source text it
      is simply taking to be a single line of 1024 characters. The
      only exception to this is the word <link>\</link> (begin comment to
      end of line) which skips text up to the end of a 64-char line
      in a block.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/block-mix.c">
   <forthmoduleinfo>
    <title>miscellaneous useful extra words for BLOCK-EXT</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-05-10 16:34:51 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Compatiblity with former standards, miscellaneous useful words.
       ... for BLOCK-EXT
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/block-stk.c">
   <forthmoduleinfo>
    <title>StackHelp for Block-Ext</title>
    <text>

Copyright (C) Tektronix, Inc. 2003 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       see stackhelp-ext for details
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/cdecl-ext.c">
   <forthmoduleinfo>
    <title>C-like declaration primitives</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.6 $
   (modified $Date: 2008-05-11 12:29:19 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        some words that mimic partial behaviour of a C compiler
        especially it's preprocessor.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/cdecl-stk.c">
   <forthmoduleinfo>
    <title>Stackhelp for C-like declaration primitives</title>
    <text>

Copyright (C) Tektronix, Inc. 2001
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        some words that mimic partial behaviour of a C compiler
        especially it's preprocessor.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/chain-ext.c">
   <forthmoduleinfo>
    <title>CHAIN words - compare with win32forth</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-01 00:42:01 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               This wordset implements CHAINs of words as seen in
               win32forth - unlike LINK-chains these chains will
               be watched by the system and referenced globabally
               via the chain-link variable. During FORGET we can
               prune these chains and keep them in the state they
               deserve to be at that point. In general, CHAINs
               are used as defer-chains which hold a series of
               of executions tokens in each chain item, and a call
               to `do-chain` will execute each one in that chain.
</para><para>
   new-chain semicolon-chain : items are usually called resolve-*
   new-chain forget-chain    : items are usually called trim-*
   new-chain unload-chain    : items are usually called release-*
</para><para>
   a chain-item is either a PRIMITIVE or a COLONWORD
   we simulate that it is part of a colonword - setting the IP
   to the address of the CHAIN-ITEM's body should make it callable.
       ITC:
            with XT:      the XT
            at PRIM:      HERE+1 | CODE* (simulating a prim XT)
       CTC:
            with XT:      flatten XT being: CODE* | BODY*
            at PRIM       CODE*
       STC variants:
            COLONWORDS are PRIMITIVES too, so just CODE*
</para><para>
  WARNING: this wordset is not complete - it should hang on to
   the forget-routine to be able to prune chains given that their
   chain-heads are registered in a system-wide chainlist too.
   This has not been implemented. 
</para><para>
  The win32forth model has shown to be not directly usable within
  the pfe core parts - in win32forth each routine is itself just
  a forth routine while in pfe there is usually a difference
  between a colon-routine and a (C-made) primitive-routine so
  that they can not easily be universally referenced as XTs. It
  would be a rather complex endavour requiring quite some system
  runtime resources according to time and speed. Instead, the
  chain-wordlist system has been modelled at greater extents
  giving you largely the same functionality on different grounds.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/chain-stk.c">
   <forthmoduleinfo>
    <title>Stackhelp for CHAIN words</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>     Allow for chained words in the interpreter core.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/chainlist-ext.c">
   <forthmoduleinfo>
    <title>CHAINLIST words - executable WORDLISTs</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-10-07 02:35:39 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               This wordset implements CHAINLISTs.
               Unlike standard search-order WORDLISTs, these are
               never hashed lists, instead they are always in order
               and they do not take the VOCABULARY runtime even that
               they are allowed to live in the search-order itself.
               Instead, these singular wordlists may be subject to
               a DO-ALL-WORDS that executes the words contained in
               this wordlist, not much unlike that win32for DO-CHAIN.
               There are words to create these wordlists and list
               them to the user.
</para><para>
               There is already a wordlist known in pfe for quite a
               time being the ATEXIT-WORDLIST which has been not
               exported however to the forth-level directly so far
               and executions have been stored there using the older
               ALIAS-ATEXIT word.
</para><para>
               for an example, try the PROMPT-WORDLIST as included
               with the outer interpreter - for immediate stack visuals
               use:
                      PROMPT-WORDLIST DO-SYNONYM .S .S
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/chainlist-stk.c">
   <forthmoduleinfo>
    <title>Stackhelp for CHAINLIST words - executable WORDLISTs</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>          Allow executables list embedded in the pfe interpreter
          based on pure wordlists instead of defer link chains.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/complex-ext.c">
   <forthmoduleinfo>
    <title>Complex Arithmetic Word Set</title>
    <text>
   Version 0.8.9

   Code derived from the original source:
   Copyright (C) 1998 Julian V. Noble.
   This copyright notice must be preserved.

   Code derived from pfe:
   Copyright (C) 1998-2004 Tektronix, Inc.

   Code not derived from the above:
   Copyright (C) 2002-2006 David N. Williams
</text>
    <version>$Revision: 1.8 $
   (modified $Date: 2008-05-25 11:42:39 $)

</version>
    <author>Julian V. Noble         (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>          This is a port of Julian Noble's complex arithmetic
          lexicon to pfe.  There are a few differences, but his
          word set is pretty much intact.
</para><para>
          This implementation uses the pfe default type for
          floats (double), and requires the pfe floating
          module.
</para><para>
          In particular, it assumes a separate stack for
          floats.
</para><para>
          It does not construct a separate complex number
          stack.
</para><para>
          Complex numbers x+iy are stored on the fp stack as
          (f: -- x y).
</para><para>
          Angles are in radians.
</para><para>
          Our code uses higher-accuracy algorithms by William
          Kahan [1]. It uses the principal argument, with -pi <
          arg <= pi, for ARG, ZSQRT, ZLN, and Z^.  The Kahan
          alorithms implement an OpenMath compliant treatment
          of principal expressions, branch cuts, and branches
          for the elementary functions [2], which is based on
          Abramowitz and Stegun [3].
</para><para>
          Kahan pays attention to signed zero, where available
          in IEEE 754/854 implementations.  We address that in
          this file as follows.
</para><para>
          1. ZSINH, ZASINH, ZTANH, ZATANH, ZSIN, ZASIN, ZTAN,
             and ZATAN conserve the sign of zero, and 1/Z and
             the minimal compuation words ZF*, ZF/, FZ*, FZ/,
             ZIF*, ZIF/, IFZ*, IFZ/ do the right thing.
</para><para>
          2. We would like the analytic functions that are real
             and analytic on the real axis to do the right
             thing for the sign of the zero imaginary part. 
             This is not completely tested yet, and we're not
             sure it's always practical to implement.
</para><para>
          3. For functions having branch cuts, signed zero in
             the appropriate x or y input produces correct
             values on the cuts.  This is probably the most
             important concern.
</para><para>
          Kahan also uses IEEE-prescribed exception handling to
          avoid spurious overflow, underflow, and divide by
          zero signals.  We usually include that.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/core-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.18 $
   (modified $Date: 2008-12-21 11:01:54 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       The Core Wordset contains the most of the essential words
       for ANS Forth.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/core-mix.c">
   <forthmoduleinfo>
    <title>miscellaneous useful extra words for CORE-EXT</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-10-07 02:35:39 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Compatiblity with former standards, miscellaneous useful words.
       ... for CORE-EXT
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/core-stk.c">
   <forthmoduleinfo>
    <title>Stackhelp for standard CORE and CORE-EXT wordset</title>
    <text>

Copyright (C) Tektronix, Inc. 2003 - 2004.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       The Core Wordset contains the most of the essential words
       for ANS Forth. Here we add their stackdepth checks.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/core-sub.c">
   <forthmoduleinfo>
    <title> Subroutines for the Core Forth-System</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.11 $
   (modified $Date: 2008-05-11 21:10:21 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>          Subroutines for the Forth Core System - especially the
          general input/output routines like ACCEPT/QUERY/WORD/PARSE
          and converters like UD.DR and >NUMBER
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/debug-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.15 $
   (modified $Date: 2008-05-11 12:48:04 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 	The Portable Forth Environment provides a decompiler for
       colon words and a single stepper for debugging. After 
       setting a breakpoint at a word saying <link>DEBUG</link> <tt>word</tt>.
   	The next time the <tt>word</tt> gets executed the single
  	stepper takes control.
</para><para>
  	When this happens you see the top stack items displayed in one
 	line. The topmost stack item is the first in line, the second and
 	following stack items are displayed throughout the end of line.
 	This line is empty if the stack is empty when the word in question
 	executes.
</para><para>
 	On the next line you see the first word to become executed inside
 	the debugged <tt>word</tt>. There is a prompt <tt>&gt;</tt> to
 	the right of the displayed word. At this prompt you have several
 	options. Choose one by typing a key (<tt>[h]</tt> shows helpscreen):
</para><para>
 	<dl>
 	<dt> <tt>[enter], [x], [k], [down]</tt> </dt>  <dd>
 	The displayed word will be executed without single stepping.
 	Note that the execution of the word is slowed down a little
 	compared to execution outside the single stepper. This is
 	because the single stepper has to keep control to detect when
 	the word has finished.
</para><para>
 	After the actual word finished execution the resulting stack
 	is printed on the current line. The next line shows the next
 	word to become executed.
</para><para>
 	Having repeated this step several times, you can see to the
 	the right of every decompiled word what changes to the stack
 	this word caused by comparing with the stack display just
 	one line above.
       </dd>
 	<dt> <tt>[d], [l], [right]</tt> </dt><dd>
 	Begin single step the execution of the actual word. The first
 	word to become executed inside the definition is displayed on
 	the next line. The word's display is intended by two spaces
 	for each nesting level.
</para><para>
    	You can single step through colon-definitions and the children
 	of defining words. Note that most of the words in PFE are
 	rewritten in C for speed, and you can not step those kernel
 	words.
       </dd>
       <dt> <tt>[s], [j], [left]</tt> </dt><dd>
 	Leaves the nesting level. The rest of the definition currently
 	being executed is run with further prompt. If you leave the
 	outmost level, the single stepper won't get control again.
 	Otherwise the debugger stops after the current word is
 	finished and offers the next word in the previous nesting level.
 	</dd>
 	<dt> <tt>[space]</tt> </dt><dd>
 	The next word to be executed is decompiled. This should help 
 	to decide as if to single step that word.
 	</dd>
 	<dt> <tt>[q]</tt> </dt><dd>
 	Quits from the debugger. The execution of the debugged word is
 	not continued. The stacks are not cleared or changed.
 	</dd>
 	<dt> <tt>[c]</tt> </dt><dd>
 	Displays the profiling instruction counter.
 	<dt> <tt>[r]</tt> </dt><dd>
 	Reset the instruction counter, to profile some code. The
 	debugger counts how often the inner interpreter i.e. how
 	many Forth-primitives are executed. Use this option to 
       reset the counter to 0 to measure an arbitrary part of code.
 	</dd>
 	</dl>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dl-def.c">
   <forthmoduleinfo>
    <title>Words to open a shared code object</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		This file exports a set of system words for 
               any OS that can dynamically bind object code to
 		the interpreter. This part will then try to look
               up a symbol that can return a loadlist-table to
               be fed to the loadlist-loader routine.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dl-dlfcn.c">
   <forthmoduleinfo>
    <title>Words to open a shared code object</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-11 21:10:21 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		This file exports a set of system words for 
               any OS that can dynamically bind object code to
 		the interpreter. This part will then try to look
               up a symbol that can return a loadlist-table to
               be fed to the loadlist-loader routine.
</para><para>
     linux/solaris, win, bsd, hpux, win16, win32, beos, libdld, 
     autoconf-dlpreopen - libltdl and libdl are very close in its 
     api functionality, hence prefer ifdef-noise in this file.
</para><para>
     note that the dlopen() functionality is not only quite simple,
     it can also be implemented as a layer on top of most other
     foreign function interfaces of a system - and since this one
     is also in the unix98 specs we can expect dlfcn to become
     very very common. The only thing we have to watch out for:
     whether C symbols must be found with a leading underscore
     since that varies from platform to platform.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dl-ext.c">
   <forthmoduleinfo>
    <title>Words for dynamic loading of code modules</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		This file exports a set of system words for 
               dynamic loading of code modules.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dl-hpux.c">
   <forthmoduleinfo>
    <title>Words to open a shared code object</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		This file exports a set of system words for 
               any OS that can dynamically bind object code to
 		the interpreter. This part will then try to look
               up a symbol that can return a loadlist-table to
               be fed to the loadlist-loader routine.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dl-internal.c">
   <forthmoduleinfo>
    <title>Words to open a shared prim-module pre-linked to the executable</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		This file exports a set of words referencing
               loader-wordsets of shared-lib prim-modules that
               have been pre-linked to the executable. It is
               formed to be a list of internal modules that are
               used by the dl-loader facilities.
               This internal-module-llist is commonly used if 
               the target system does not support a nice way
               of creating shared-libs and binding them at runtime.
               It is a kind of libtool dlpreopen facility that is
               implemented here, in that it also works on some
               of the more peculiar embedded hostsystems around.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dl-none.c">
   <forthmoduleinfo>
    <title>Words to open a shared code object</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		This file exports a set of system words for 
               any OS that can dynamically bind object code to
 		the interpreter. This part will then try to look
               up a symbol that can return a loadlist-table to
               be fed to the loadlist-loader routine.
</para><para>
               this file is loaded when no dl-functionality
               could be detected. Therefore, nothing useful
               is done, and we define some dummy routines
               that will always fail.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dl-vxworks.c">
   <forthmoduleinfo>
    <title>Words to open a shared code object</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		This file exports a set of system words for 
               any OS that can dynamically bind object code to
 		the interpreter. This part will then try to look
               up a symbol that can return a loadlist-table to
               be fed to the loadlist-loader routine.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dl-win32.c">
   <forthmoduleinfo>
    <title>Words to open a shared code object</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		This file exports a set of system words for 
               any OS that can dynamically bind object code to
 		the interpreter. This part will then try to look
               up a symbol that can return a loadlist-table to
               be fed to the loadlist-loader routine.
</para><para>
               implementation for win32 using
               LoadLibrary GetProcAddress FreeLibrary
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/double-mix.c">
   <forthmoduleinfo>
    <title>miscellaneous useful extra words for DOUBLE-EXT</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Compatiblity with former standards, miscellaneous useful words.
       ... for DOUBLE-EXT  (which is almost complete... just almost)
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/dstrings-ext.c">
   <forthmoduleinfo>
    <title>Dynamic-Strings words</title>
    <text>
  Version 0.7.6

Copyright (C) 2001-2004, 2006, 2008 David N. Williams
</text>
    <version>$Revision: 1.6 $
   (modified $Date: 2008-09-11 23:05:06 $)
    starting date:  Sat Dec 16 14:00:00 2000

</version>
    <author>David N.Williams           (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later
  version.
</para><para>
  This library is distributed in the hope that it will be
  useful, but WITHOUT ANY WARRANTY; without even the implied
  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE. See the GNU Library General Public License for more
  details.
</para><para>
  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, 59 Temple Place, Suite 330, Boston,
  MA 02111-1307 USA.
</para><para>
  If you take advantage of the option in the LGPL to put a
  particular version of this library under the GPL, the author
  would regard it as polite if you would put any direct
  modifications under the LGPL as well, and include a copy of
  this request near the beginning of the modified library
  source.  A "direct modification" is one that enhances or
  extends the library in line with its original concept, as
  opposed to developing a distinct application or library which
  might use it.
</para><para>
  This code is based on the ^Forth Motorola 680x0 strings
  package as of June, 1999.
</para><para>
  There is an ANS Forth implementation of this glossary in
  a file called dstrings.fs.
</para><para>
  Please direct any comments to david.n.williams at umich.edu.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/edit-ext.c">
   <forthmoduleinfo>
    <title>simple FORTH-screenfile editor</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2000.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-01 21:49:01 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        This is a simple fullscreen FORTH block editor.
</para><para>
        will be missing in most builds
</para><para>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/engine-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.6 $
   (modified $Date: 2009-05-31 21:32:47 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>                Initial wordsets loaded at boottime.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/engine-set.c">
   <forthmoduleinfo>
    <title>setup forth memory and start up.</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-05-03 14:20:20 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   Process options via options block (set in option-set), get memory
   and init variables, and finally start up the interpret loop of PFE
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/environ-ext.c">
   <forthmoduleinfo>
    <title>Extended Environment related definitions</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.8 $
   (modified $Date: 2008-09-11 23:05:06 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        gforth and win32for are also using an extra <link>ENVIRONMENT</link>
        wordlist to register hints on the system environment. It
        is just a normal <link>VOCABULARY</link> that can be searched&executed
        with <link>ENVIRONMENT</link>? . In pfe, the environment wordlist does
        also register the extension status of the system including
        allocated slots, loaded binaries and <link>REQUIRED</link> source files.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/exception-ext.c">
   <forthmoduleinfo>
    <title>   The Optional Exception Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.8 $
   (modified $Date: 2008-09-11 01:27:20 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       These words implement an exception system in the
       widely known <link>THROW</link> &amp; <link>CATCH</link> concept.
</para><para>
       see the PFE-SIG wordset for catching OS traps.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/exception-stk.c">
   <forthmoduleinfo>
    <title>Stackhelp for The Optional Exception Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       These words implement an exception system in the
       widely known <link>THROW</link> &amp; <link>CATCH</link> concept.
</para><para>
       see the PFE-SIG wordset for catching OS traps.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/facility-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       There are the following primitive words for input and output:
</para><para>
       <link>KEY</link> waits for a character typed on the keyboard and returns
       that character, but <link>KEY</link> does not return non-character
       input events like function keys pressed - use <link>EKEY</link> for 
       a more complete keyboard query.
       Furthermore, <link>KEY</link>? returns true if a key is available for
       reading using <link>KEY</link> (function key presses are not detected
       but discarded).
</para><para>
       <link>EMIT</link> will display the character at the current cursor
       position, control characters take effect depending on the
       system. <link>TYPE</link> displays all the chars in the given string 
       buffer.
</para><para>
       To get the current cursor position, use <link>AT-XY</link>.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/facility-mix.c">
   <forthmoduleinfo>
    <title>Words making sense in POSIX-like systems only.</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               This file exports a set of system words for
               a posixish OS environment. So should do
               any alternative wordset you might create for your OS.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/file-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        The Optional File-Access Word Set and
        File-Access Extension Words.
        These words imply some kind of file-system unlike
        the BLOCK wordset.
</para><para>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/file-mix.c">
   <forthmoduleinfo>
    <title>miscellaneous useful extra words for FILE-EXT</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Compatiblity with former standards, miscellaneous useful words.
       ... for FILE-EXT
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/file-stk.c">
   <forthmoduleinfo>
    <title>Stackhelp for Optional File-Access Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        The Optional File-Access Word Set and
        File-Access Extension Words.
        These words imply some kind of file-system unlike
        the BLOCK wordset.
</para><para>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/floating-ext.c">
   <forthmoduleinfo>
    <title>The Optional Floating-Point Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.13 $
   (modified $Date: 2008-09-11 01:27:20 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>          The Optional Floating-Point Wordset is not usually
          used on embedded platforms. The PFE can be configured
          to even not allocate the separate floating-point stack
          that most of the floating-point words refer to.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/floating-mix.c">
   <forthmoduleinfo>
    <title>miscellaneous useful extra words for FLOATING-EXT</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Compatiblity with former standards, miscellaneous useful words.
       ... for FLOATING-EXT
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/forth-83-ext.c">
   <forthmoduleinfo>
    <title> Compatiblity with the FORTH-83 standard.</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-05-10 16:34:51 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>      All FORTH-83-Standard words are included here that are not 
      in the dpANS already.
      Though most of the "uncontrolled reference words" are omitted.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/forth-83-stk.c">
   <forthmoduleinfo>
    <title> Stackhelp for Compatiblity with the FORTH-83 standard.</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>      All FORTH-83-Standard words are included here that are not 
      in the dpANS already.
      Though most of the "uncontrolled reference words" are omitted.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/forth-usual-ext.c">
   <forthmoduleinfo>
    <title>usually implemented words.</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               There are lots of useful words that do not appear
               in any standard. This wordset defines some of them.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/fpnostack-ext.c">
   <forthmoduleinfo>
    <title>The No-FP-Stack Floating-Point Word Set</title>
    <text>

Copyright (C) Krishna Myneni and Guido Draheim, 2002
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.6 $
   (modified $Date: 2008-09-10 19:18:13 $)

</version>
    <author>Krishna Myneni              (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>          The No-FP-Stack Floating-Point Wordset is not usually
          used on embedded platforms. This Module implements
          the floating-point words but expects and puts the
          floating-point values on the forth parameter-stack.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/gforth-ext.c">
   <forthmoduleinfo>
    <title>Words designed to mimic gforth behaviour.</title>
    <text>

Copyright (C) Guido U. Draheim 2001 - 2004. 
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 		Usually the following words are defined to mimic
 		a certain gforth extension that some application
 		writers need. They are only added on request, and
 		they may be removed without warning requesting to
               use the functionality provided by pfe itself.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/header-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.16 $
   (modified $Date: 2008-10-07 02:35:39 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>     Implements header creation and navigation words including the
     ones from the forth-83 "experimental annex" targetting definition
     field access. Also it has the defer and synonym words that are
     almost standard - It is said that the missing DEFER in the ANS Forth
     standard of 1994 was just a mistake. 
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/help-ext.c">
   <forthmoduleinfo>
    <title>extra words for external HELP system</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       we grep the installed header files for comments ;-)
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/host-k12.c">
   <forthmoduleinfo>
    <title>useful additional primitives for K12xx platforms</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               This wordset adds some additional primitives that
 		are useful in K12xx environments.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/lined.c">
   <forthmoduleinfo>
    <title>small general purpose line editor</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       implements a history buffer. The buffer is a straight
       ring buffer or chars - the entries are seperated by '\0'.
       The last entry is given at the write-pointer that the next
       string gets appended to.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/locals-ext.c">
   <forthmoduleinfo>
    <title>The Optional Locals Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.7 $
   (modified $Date: 2008-08-31 03:07:54 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       The Portable Forth Environment does implement locals
       in such an extended form as that additional variable
       names can be declared anywhere in the compiled word.
</para><para>
       Locals are names for values that live in a locals-frame
       on the return-stack - on entry to the procedure that
       locals-frame is carved from the return-stack and a 
       frame-pointer is setup. Locals are in two forms, one
       is inialized by a chunk from the parameter-stack as
       it is with <link>LOCALS|</link> while the others are local variables
       declared later. The latter are left unitialized on
       setup of the locals-frame. 
</para><para>
       For unnamed returnstack locals, see words like 
       <link>R@</link> <link>R!</link> <link>R'@</link> <link>R'!</link> <link>R"@</link> <link>R"!</link> <link>2R@</link> <link>2R!</link>
       but here the setup and cleanup of the return-stack frame
       is left to the user, possibly using some words like
       <link>>R</link> <link>R></link> <link>2>R</link> <link>2R></link> <link>R>DROP</link> while the locals-ext
       will take care to provide a frame-creation token and
       some cleanup-code for each <link>EXIT</link> or <link>;</link>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/main-alloc.c">
   <forthmoduleinfo>
    <title>Process command line, get memory and start up.</title>
    <text>

Copyright (C) Tektronix, Inc. 1999 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   Process command line, get memory and start up the interpret loop of PFE
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/main-def.c">
   <forthmoduleinfo>
    <title>Process command line, get memory and start up.</title>
    <text>

Copyright (C) Tektronix, Inc. 1999 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   Process command line, get memory and start up the interpret loop of PFE
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/main-mmap.c">
   <forthmoduleinfo>
    <title>Process command line, get memory and start up.</title>
    <text>

Copyright (C) Tektronix, Inc. 1999 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   Process command line, get memory and start up the interpret loop of PFE
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/main-static.c">
   <forthmoduleinfo>
    <title>Process command line, get memory and start up.</title>
    <text>

Copyright (C) Tektronix, Inc. 1999 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   Process command line, get memory and start up the interpret loop of PFE
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/main-stdc.c">
   <forthmoduleinfo>
    <title>Process command line, get memory and start up.</title>
    <text>

Copyright (C) Tektronix, Inc. 1999 - 2001. 
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   Process command line, get memory and start up the interpret loop of PFE
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/main-sub.c">
   <forthmoduleinfo>
    <title>Process command line, get memory and start up.</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   Process command line, get memory and start up the interpret loop of PFE
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/memory-alloc-ext.c">
   <forthmoduleinfo>
    <title>The Optional Memory Allocation Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>      The optional memory allocation wordset interfaces to
      the surrounding OS heap memory management.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/memory-alloc-stk.c">
   <forthmoduleinfo>
    <title>StackHelp for Memory-Alloc-Ext</title>
    <text>

Copyright (C) Tektronix, Inc. 2003 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       see stackhelp-ext for details
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/memory-sub.c">
   <forthmoduleinfo>
    <title>Memory Allocation Words</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>      memory allocation interfaces to the surrounding OS.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/misc-ext.c">
   <forthmoduleinfo>
    <title>miscellaneous useful words, mostly stemming from fig-forth</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.9 $
   (modified $Date: 2008-11-21 20:53:37 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Compatiblity with former standards, miscellaneous useful words.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/misc-stk.c">
   <forthmoduleinfo>
    <title>Stackhelp for miscellaneous useful words (fig-forth)</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Compatiblity with former standards, miscellaneous useful words.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/module-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-01 00:42:01 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para> 	this wordset implements a simple module-system.
       the basic module-system is based on the three
       words MODULE/END-MODULE/EXPORT - these three were
       present TEK' mforth, here the MPE' forth is used
       as an example for the naming scheme. This 
       implementation has also mpe's EXPOSE-MODULE,
       and it has a serious form of mpe's REQUIRES
       under the name ALSO-MODULE which clarifies that
       the search-order is modified. Note also that
       pfe defines a REQUIRES in require-ext that works
       like INCLUDE-ONCE
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/option-ext.c">
   <forthmoduleinfo>
    <title>Almost-Non-Volatile Environment Options</title>
    <text>

Copyright (C) Tektronix, Inc. 2001 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-05-01 18:26:24 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        the openfirmware standard specifies some means to add
        options to a non-volatile ram-area (nvram) that are used
        in the bootup sequence of the forth-based bootsystem.
        Here we add an internal API for looking for bootup options,
        an internal API to add bootup options through commandline
        processing, and an external API to change the bootup options
        for a <link>COLD</link> reboot or an <link>APPLICATION</link> specific sequence.
        The external API will try to follow openfirmware as closely
        as possible without having a real non-volatile ram-area.
        Instead there is a session-struct that can be changed and
        from which multiple forth-threads can be instantiated
        later using those options. The forth-instantion processing
        is not supposed to scan for commandline options, which is
        a mere necessity in embedded enviroments where option
        transferal is done in a completly different way and where
        the forth thread is never killed but just stopped or
        restarted for various reasons. Even that there is no real
        nvram we add a cold-options reboot-area in this wordset.
        The option-ram is organized just along a normal dictionary
        just need to add a wordlist-handlestruct to find the
        definitions in this dictlike ram-portion.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/option-set.c">
   <forthmoduleinfo>
    <title>Process command line, init option block, prepare for start.</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-11 12:59:08 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   Process command line, init option block, prepare for start.
   The init of ofe memory and start up the interpret loop in PFE
   is done in the engine-set part.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/posix-ext.c">
   <forthmoduleinfo>
    <title>Words making sense in POSIX-like systems only.</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               This file exports a set of system words for 
               a posixish OS environment. So should do
               any alternative wordset you might create for your OS.
</para><para>
               NOTE: this wordset is going to be removed soon.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/search-order-ext.c">
   <forthmoduleinfo>
    <title> The Optional Search Order Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>     	The Search Order Word Set as defined by the Standard.
</para><para>
       Note that there a some extensions in the Portable 
       Forth Environment. Wordlists can be made case-sensitive
       always or only at request. Wordlists can be linear
       or hashed vocabularies. There are other words to 
       recursivly search an implicit vocabulary along with another.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/shell-os-ext.c">
   <forthmoduleinfo>
    <title>os-like / shell-like commands for pfe</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001. 
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-02 03:03:35 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>         These builtin words are modelled after common shell commands,
         so that the Portable Forth Environment can often 
         be put in the place of a normal OS shell.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/signals-ext.c">
   <forthmoduleinfo>
    <title>Handle signals in forth</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-05-11 12:29:19 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>   The signal-callback system divides signals internally
   into the following classes:
</para><para>
   <dl>
   <dt>P4_ON_XXXXX:</dt><dd>
       a signal which will be assigned a corresponding THROW
       on forth level, e.g. for SIGFPE
   </dd>
   <dt>Abort:</dt><dd>		
       a signal that will not kill the current forth process
       but which has not forth-level THROW either, e.g. SIGILL.
       It will result in an ABORT" Signal-Description"
    </dd>
   <dt>Fatal:</dt><dd>
 	the current forth process will die gracefully.
   </dd>
   <dt>Default:</dt><dd>
       A signal with some unknown meaning, exported to allow
       a forth-programmer to hook it anyway, e.g. to let
       a programmer on AIX to intercept SIGGRANT and run
       a forth word, otherwise the signal will be left untouched.
   </dd>
   <dt>Chandled:</dt><dd>
       A signal used internally be PFE and initially hooked
       by the runtime system, in general this would be the
       Job-Control signals and SIGWINCH that will get send 
       when an xterm changes its size.
   </dd>
   </dl>
</para><para>
  The first three classes will go to the default Forth Signal-Handler.
  Its execution will look for user-routine being registered (in 
  which cases that forth-routine will be executed) and otherwise
  do its default action (to throw, abort" or exit).
</para><para>
  The fourth class is not hooked until some user-code requests that
  signal in which case the user-defiend forth-routine is executed
  as its action, otherwise the system-defined default-action will
  be left untouched.
</para><para>
  The signal of the fourth type are not handled by the default
  signal handler defined herein, so can not just call a
  forth word, if I still get this right ;-)
                              <p align=right> Dirk-Uwe Zoller </p>
</para><para>
  note: forth-level callbacks might not work as expected on
        all systems that the rest of PFE runs on. Be careful.
                              <p align=right> Guido U. Draheim </p>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/smart-go-ext.c">
   <forthmoduleinfo>
    <title>smart outer interpreter</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Smart Outer Interpreter allows to register executions tokens
       that get tied to a single char - if the outer interpreter 
       Compatiblity with former standards, miscellaneous useful words.
       ... for TOOLS-EXT
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/stackhelp-ext.c">
   <forthmoduleinfo>
    <title>The Additional StackHelp TypeCheck Word Set</title>
    <text>

Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-05-01 00:42:01 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>     These are routines to add stackchecking capabilities. The
     loader routine will hook into the outer interpreter and
     _before_ any word is compiled/interpreted it is being 
     sent through an stackcheck interpreter. The stackcheck
     interpreter code is fully independent from the rest of
     the code. It will only work on the stackcheck hints given
     with each word. In most cases the stackcheck hints are
     simple strings which get parsed for information - these
     strings may be taken from the usual stack notation of a
     a colon word. The parser is detecting the syntax given
     in the OpenFirmware recommendations for specifying a compact
     stack and parsing behavior of a word. They are expanded for
     extra type hints and tracing through splitstack parts.
</para><para>
     Other than pure strings, the stackchecking can be done
     through code words that work on the checkstack - they are
     similar to immediate words in the normal forth interpreter
     whereas the stacknotation strings are checkstacked by the 
     checkstack parser directly instead of blackboxing it 
     through a call to a routine somewhere. It does however
     bring in a lot of flexibility and allows for complex
     stackcheck code in extension modules. The core-stk module
     is an integral part of the stackcheck behavior for forth
     and encompasses stackchecking for IF-ELSE branches and
     the various LOOPs and EXIT-points of a ':'-colon word.
</para><para>
    implementation notes:
      The parsing of a single stack notation ( .... ) follows
      these rules:
      (a) recognize "changer"s with embedded "--" and seperated
             by " |" twochar sequence 
      (b) cut into input / output effect notation without "--"
             with a resulting "notation"
      (c) each stack effect may have "variant" notations seperated
          by "| " twochar sequence
      (d) cut into stack effect parts with the "stack" notation broken
           at each "X:" up to the following "Y:" marker. The
           resulting notation applies to the specified stack only.
      (e) each argument is seperated by whitespace, but an argument
          may be broken down further.
      (f) an argument may have ellipsis expansion with "..."
          for multi-cell notations
      (g) an argument may have  a singular "alternative" notation with
          a "|" that has no whitespace on either side.
      (h) an argument may have  a singular expansion with ","
          used for double-cell notations
      (i) after seperation as above, each part is broken down
          into name-prefix and type-suffix-list where types may be
          non-ascii singlechar or ascii-named strings introduced
          by a "-", i.e. "a-ptr" is the same as "a*".
      (j) a literal may occur ("0"), or self-parsing hint as seen
          in traditional forth stack notations ("[text<eol>]")
      (x) note the ambiguity of " | ", the changer recognition
          is supposed to be greedy, i.e.
          0 NARROW-CHANGER( a b -- c d | x y | u v -- m n )
                          ..^^^^^^^^^^^^^^^^^..
          1 NARROW-CHANGER( a b -- c d | x y | u v -- m n )
                          ....................^^^^^^^^^^^^..
          1 NARROW-CHANGER( a b -- c d | x y| u v -- m n )
                          ..............^^^^^^^^^^^^^^^^^..
          1 NARROW-CHANGER( a b -- c d |x y |u v -- m n )
                          ..............^^^^^^^^^^^^^^^^..
          1 NARROW-CHANGER( a b -- c d| x y| u v -- m n )
                 [invalid -- no separator for second changer]
</para><para>
      (y) a "notation" is a single stack layout definition per changer
          which includes the syntaxhint at the start. This scheme allows
          to step through user-provided "notation"s in order and "rewrite" 
          each stack layout without changing the original order. Therefore
          we have
          0 0 NARROW-INPUT-NOTATION( a b R: x y | u v -- m n )
                                     ^^^^
          1 0 NARROW-INPUT-NOTATION( a b R: x y | u v -- m n )
                                         ^^^^^^^
          2 0 NARROW--INPUT-NOTATION( a b R: x y | u v -- m n )
                                                 ^^^^^^
</para><para>
  preliminary usage:
          start compiling a colon word and add a stack notation with
          the help of "|( ..... )". The stackhelp checker will show
          which words it did recognize and at the final semicolon (or
          any other exitpoint) it will check the resulting stack
          layout with the layout given first as the intended stack
          notation. Try ": |( a -- a a ) dup dup ;" for a start. And
          remember that stackhelp is an external module which you must
          load before as "needs stackhelp-ext".
</para><para>
          Additionally there are a few helper words, most prominently
          you can fetch the stackhelp notation for any registered word
          by saying "stackhelp 'wordname'". Note that forth is really
          a nontyped language and you are able to add "hint narrowing"
          on each portion of a stack item in a postfix notation of 
          each item. Therefore ": dup |( a -- a a)" will work simply
          on anything while ": @ |( a* -- a)" will issue a warning if
          you give it "depth @" since the depth word is defined with
          a numeric postfix hint by ": depth |( -- value#)". 
</para><para>
          Furthermore, there are a number of debugging words that can
          be used also to interactivly test whether some type narrowing
          will work later in practice. Start off with giving a current
          stack notation as the input line notation 
                  REWRITE-LINE( a b 0 | c 1! )
          which is a split notation example with differing depths in
          each of the possible inputs. You can get back the current
          stack notation by saying REWRITE-SHOW. Next one can test a
          few changer notations, where changer means anything that
          does contain a "--" seperator. One can first test which part
          of a multivariant changer would be used by asking with
          REWRITE-SELECT( a 0 -- | a 1! -- a ). The same with a
          REWRITE-TEST( a 0 -- | a 1! -- a) would say "Ok!" since we
          do can apply the changer to the current stack line. Then
          we can try with REWRITE-EXPAND( a 0 -- | a 1! -- a) and
          REWRITE-RESULT( a 0 -- | a 1! -- a) where the second one
          will also try to collapse a splitstack result to a simple
          one. 
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/string-ext.c">
   <forthmoduleinfo>
    <title>The Optional String Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       The basic words for handling string buffers. There are
       much more buffer words used in most Forth implementations around
       but they can usually implemented as colon-word quite effectivly
       on the basis of the STRING wordset.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/string-stk.c">
   <forthmoduleinfo>
    <title>StackHelp for String-Ext</title>
    <text>

Copyright (C) Tektronix, Inc. 2003 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       see stackhelp-ext for details
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/struct-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       "struct" implements neon/mops/mpe-like structures.
       "structs" implements fsl/mforth-like structures.
</para><para>
       the two wordsets are designed to let the sub-words 
       to be used interchangably both inside STRUCT and
       STRUCTURE definitions. They will also work inside
       pfe's class-definitions btw.
</para><para>
       The provided words try to be compatible
       with the simple implementation guidelines as 
       provided in the survey at the comp.lang.forth.repository
       (http://forth.sourceforge.net/word/structure)
       and the documentation on MPE' forth's implementation 
       (/vol/c/Programme/PfwVfx/Doc/VfxMan.Htm/struct.html)
       and the structs-source of the Forth Scientific Library
       (lib/fsl/structs.fth) 
       plus some compatibility sugar for the gforth' struct
       (gforth/struct.fs)
</para><para>
    field-layout
       PFA[0] has the offset (elsewhere for the method-table)
       PFA[1] has the sizeof (may serve as minimalistic type-id)
</para><para>
    struct-layout
       PFA[0] unused (elswehere method-table or type-id)
       PFA[1] has the sizeof (that is instantiated)
</para><para>
    therefore SIZEOF is designed to give a nice result in
    both places.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/structs-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       "struct" implements neon/mops/mpe-like structures.
       "structs" implements fsl/mforth-like structures.
</para><para>
       the two wordsets are designed to let the sub-words 
       to be used interchangably both inside STRUCT and
       STRUCTURE definitions. They will also work inside
       pfe's class-definitions btw.
</para><para>
       The provided words try to be compatible
       with the simple implementation guidelines as 
       provided in the survey at the comp.lang.forth.repository
       (http://forth.sourceforge.net/word/structure)
       and the documentation on MPE' forth's implementation 
       (/vol/c/Programme/PfwVfx/Doc/VfxMan.Htm/struct.html)
       and the structs-source of the Forth Scientific Library
       (lib/fsl/structs.fth)
</para><para>
    field-layout
       PFA[0] has the offset (elsewhere for the method-table)
       PFA[1] has the sizeof (may serve as minimalistic type-id)
</para><para>
    struct-layout
       PFA[0] unused (elswehere method-table or type-id)
       PFA[1] has the sizeof (that is instantiated)
</para><para>
    therefore SIZEOF is designed to give a nice result in
    both places.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/system-ext.c">
   <forthmoduleinfo>
    <title> FORTH-83 System Extensions</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001. 
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>      forth-83 did define a system extension word set which
      was deleted in dpans94 due to some problems with the
      native-compiling variants of forth. pfe is traditional
      enough to use the words as they were originally intended.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-curses.c">
   <forthmoduleinfo>
    <title>TERM-CURSES --- curses-terminal low-level routines for term-sub</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               Experimental terminal driver for UNIX-like systems
 		using the curses library.
</para><para>
               new version uses a getch -> getvkey mapping.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-dj.c">
   <forthmoduleinfo>
    <title>terminal driver fo djgpp</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>                       Terminal driver for DOS and OS/2 with DJGPP,
 			there is almost nothing to do.
</para><para>
  Adapted from term-emx.c by Antonio Costa (acc@asterix.inescn.pt)
  Works in 25 and 50 lines text modes (at least).
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-emx.c">
   <forthmoduleinfo>
    <title>terminal driver for emx     </title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>                       Terminal driver for DOS and OS/2 with EMX,
                       there is almost nothing to do.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-ext.c">
   <forthmoduleinfo>
    <title>  terminal i/o, system independent parts</title>
    <text>

Copyright (C) Tektronix, Inc, 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.8 $
   (modified $Date: 2008-10-07 02:35:39 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        this wordset exports words to talk to the terminal driver
        of forth. Depending on the active terminal driver, not
        all of these words are fully functional.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-k12.c">
   <forthmoduleinfo>
    <title>Terminal Driver for K12xx-2 Emulation System</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               The Terminal Driver for K12xx-2 Emulation System,
               interface via the global input queue of the task
               and write back via an assigned reply queue. The
               output is run on a seperated ring-buffer and
               send-task so that the normal execution of an
               embedded PFE is not blocked by the output system.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-lib.c">
   <forthmoduleinfo>
    <title>terminal driver for unix-like systems</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.6 $
   (modified $Date: 2008-12-21 11:01:54 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>                       Terminal driver for UNIX-like systems using
 			termcap or the termcap emulation in curses.
</para><para>
  Refer to this file as an example of how to write such a driver, though
  other drivers for non-portable operating systems should be much simpler.
  E.g. on an IBM-PC you could do everything here with a few INT-10h calls.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-sub.c">
   <forthmoduleinfo>
    <title>  terminal i/o, system independent parts</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>        functions to talk to the terminal driver of forth.
        Depending on the active terminal driver, not
        all of these words are fully functional.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-wat.c">
   <forthmoduleinfo>
    <title>terminal driver for Watcom C</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>                       Terminal driver for Watcom C, uses functions from
                       conio.h and ANSI escape sequences for attributes.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-wincon.c">
   <forthmoduleinfo>
    <title>terminal driver for win32 wincon.h API </title>
    <text>

Copyright (C) Guido U. Draheim, 2001 - 2003
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               	Terminal driver for win32 wincon.h API as
 			provided with the mingw32 compilers.
</para><para>
   http://msdn.microsoft.com/library/psdk/winbase/conchar_8wfi.htm
   this microsoft doc says that wincon.h API is supported since
   NT-3.1 and WIN-95 (and later versions).
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/term-x11.c">
   <forthmoduleinfo>
    <title>terminal driver that opens an xterm</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001. 
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-04-20 04:46:30 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>                    NOT FINISHED YET !!!!        *guidod*
</para><para>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/termcatch-ext.c">
   <forthmoduleinfo>
    <title>extra words for external TERMCATCH support</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       We hook into the terminal driver capturing all the
       output into a forth level buffer string. The implementation
       creates another terminal driver that overlays with the one
       being effective when initiating the capturing. 
</para><para>
       Capturing the forth output is most useful when implementing
       regression tests which currently uses shell utilities from
       the host operating system environment. That purpose is also
       the reason that this module is generally not active in any
       default system configuration - you have to load/activate the
       module explicitly (i.e. NEEDS termcatch-ext)
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/toolbelt-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-04-20 04:46:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><screen> :
</screen><para>        Words as defined by Neil Bawd's toolbelt, quite a few of these 
        have been around for a while, invented and implemented independently.
        Some of these were also present as PFE's extensions words, and they
        are referenced here due to the fact that Neil Bawd's website 
        had been given quite some attention, hence these words should be 
        assembled in a wordset to clarify their behaviour is compatible. 
        Comments taken from toolbelt.txt
</para><para>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/tools-ext.c">
   <forthmoduleinfo>
    <title>The Optional Programming-Tools Word Set</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.15 $
   (modified $Date: 2008-09-11 01:27:20 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       The ANS Forth defines some "Programming Tools", words to
       inspect the stack (<link>.S</link>), memory (<link>DUMP</link>), 
       compiled code (<link>SEE</link>) and what words
       are defined (<link>WORDS</link>).
</para><para>
       There are also word that provide some precompiler support 
       and explicit acces to the <link>CS-STACK</link>.
</para><para>
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/tools-mix.c">
   <forthmoduleinfo>
    <title>miscellaneous useful extra words for TOOLS-EXT</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-01 21:49:01 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       Compatiblity with former standards, miscellaneous useful words.
       ... for TOOLS-EXT
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/tools-sub.c">
   <forthmoduleinfo>
    <title>implementation words for TOOLS-EXT / TOOLS-MIX</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.3 $
   (modified $Date: 2008-04-20 04:46:31 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       These are tool words used throughout the system implemenation.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/useful-ext.c">
   <forthmoduleinfo>
    <title>useful additional primitives</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.10 $
   (modified $Date: 2008-05-10 16:34:51 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               This wordset adds some additional primitives that
 		are useful. The structure of this file follows the
               the example in your-ext.c, yet some of the words here
               must be bound statically into the main pfe-object to
               work out smart and nicely.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/version-sub.c">
   <forthmoduleinfo>
    <title>Version File</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2003.
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.5 $
   (modified $Date: 2008-04-20 04:51:55 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>       there are some internal functions in the version-file 
       that are used to print out compile-time, -date, -version 
       and the license of course.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/with-spy.c">
   <forthmoduleinfo>
    <title>SPY nest threading extension</title>
    <text>

Copyright (C) Tektronix, Inc. 2000 - 2001. 
Copyright (C) 2005 - 2008 Guido U. Draheim &lt;guidod@gmx.de&gt;
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-01 00:42:01 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               These words are of old Tek CTE/MPT usage - it is
               quite useful for debugging, but in a portable
               environment it just means a minor speed penalty
               even if <link>SPY_OFF</link> and a great speed penalty
               if SPY_ON. The default should be to not include
               it but some special Tek builds.
</para><para>
               To use it: enable the SPY' vocabulary when compiling
               colon words with spy-support. Later on, enable the
               spy-routine with SPY_ON and disable with SPY_OFF.
               The default spy-routine will print each word on enter
               and leave along with the stack contents at that point.
               You can attach customized entries into VALUEs named
               SPY-ENTER and SPY-LEAVE. Within a token-threaded
               environment, the CFA of the current entry can be gotten
               with 
                                   R> DUP >R CELL - @
               and most entries will give you a good >NAME for it.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/your-ext.c">
   <forthmoduleinfo>
    <title>user-supplied additional primitives</title>
    <text>

Copyright (C) Tektronix, Inc. 1998 - 2001.
Copyright (C) Guido U. Draheim, 2005 - 2008
</text>
    <version>$Revision: 1.4 $
   (modified $Date: 2008-05-02 20:31:29 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><para>               This wordset is the place to add any additional primitives
 		you might wish. A set of words do already live here that
               must be bound statically into the main pfe-object to
               work out smart and nicely.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
 <forthmodulelist>
  <forthmodule filename="../../pfe/zchar-ext.c">
   <forthmoduleinfo>
    <title></title>
    <text></text>
    <version>$Revision: 1.7 $
   (modified $Date: 2008-09-11 01:27:20 $)

</version>
    <author>Guido U. Draheim            (modified by $Author: guidod $)</author>
    <see>GNU LGPL</see>
    <comment></comment>
   </forthmodulinfo>
   <comment><screen> :
</screen><para>        ZCHAR-EXT wordset - defines words for zero-terminated strings,
        the datatype prefix is called "Z" which is usually a simple CHAR.
        And CHAR can be either BCHAR or WCHAR depending on your platform.
        Anyway, the words in this wordset should be largely modelled 
        after the examples found in other forth implementations - most 
        prominently MPE's forths.
</para>
</comment>
  </forthmodule>
 </forthmodulelist>
<forthmodulexml>
