Diff for /gforth/Attic/gforth.ds between versions 1.17 and 1.29

version 1.17, 1995/09/15 14:52:51 version 1.29, 1996/01/07 17:22:09
Line 9 Line 9
 @ifinfo  @ifinfo
 This file documents Gforth 0.1  This file documents Gforth 0.1
   
 Copyright @copyright{} 1994 Gforth Development Group  Copyright @copyright{} 1995 Free Software Foundation, Inc.
   
      Permission is granted to make and distribute verbatim copies of       Permission is granted to make and distribute verbatim copies of
      this manual provided the copyright notice and this permission notice       this manual provided the copyright notice and this permission notice
Line 36  Copyright @copyright{} 1994 Gforth Devel Line 36  Copyright @copyright{} 1994 Gforth Devel
      of in the original English.       of in the original English.
 @end ifinfo  @end ifinfo
   
   @finalout
 @titlepage  @titlepage
 @sp 10  @sp 10
 @center @titlefont{Gforth Manual}  @center @titlefont{Gforth Manual}
Line 43  Copyright @copyright{} 1994 Gforth Devel Line 44  Copyright @copyright{} 1994 Gforth Devel
 @center for version 0.1  @center for version 0.1
 @sp 2  @sp 2
 @center Anton Ertl  @center Anton Ertl
   @center Bernd Paysan
 @sp 3  @sp 3
 @center This manual is under construction  @center This manual is under construction
   
 @comment  The following two commands start the copyright page.  @comment  The following two commands start the copyright page.
 @page  @page
 @vskip 0pt plus 1filll  @vskip 0pt plus 1filll
 Copyright @copyright{} 1994 Gforth Development Group  Copyright @copyright{} 1995 Free Software Foundation, Inc.
   
 @comment !! Published by ... or You can get a copy of this manual ...  @comment !! Published by ... or You can get a copy of this manual ...
   
Line 75  Copyright @copyright{} 1994 Gforth Devel Line 77  Copyright @copyright{} 1994 Gforth Devel
 @node Top, License, (dir), (dir)  @node Top, License, (dir), (dir)
 @ifinfo  @ifinfo
 Gforth is a free implementation of ANS Forth available on many  Gforth is a free implementation of ANS Forth available on many
 personal machines. This manual corresponds to version 0.0.  personal machines. This manual corresponds to version 0.1.
 @end ifinfo  @end ifinfo
   
 @menu  @menu
Line 89  personal machines. This manual correspon Line 91  personal machines. This manual correspon
 * Emacs and Gforth::            The Gforth Mode  * Emacs and Gforth::            The Gforth Mode
 * Internals::                   Implementation details  * Internals::                   Implementation details
 * Bugs::                        How to report them  * Bugs::                        How to report them
 * Pedigree::                    Ancestors of Gforth  * Origin::                      Authors and ancestors of Gforth
 * Word Index::                  An item for each Forth word  * Word Index::                  An item for each Forth word
 * Node Index::                  An item for each node  * Node Index::                  An item for each node
 @end menu  @end menu
   
 @node License, Goals, Top, Top  @node License, Goals, Top, Top
 @unnumbered License  @unnumbered GNU GENERAL PUBLIC LICENSE
 !! Insert GPL here  @center Version 2, June 1991
   
   @display
   Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
   675 Mass Ave, Cambridge, MA 02139, USA
   
   Everyone is permitted to copy and distribute verbatim copies
   of this license document, but changing it is not allowed.
   @end display
   
   @unnumberedsec Preamble
   
     The licenses for most software are designed to take away your
   freedom to share and change it.  By contrast, the GNU General Public
   License is intended to guarantee your freedom to share and change free
   software---to make sure the software is free for all its users.  This
   General Public License applies to most of the Free Software
   Foundation's software and to any other program whose authors commit to
   using it.  (Some other Free Software Foundation software is covered by
   the GNU Library General Public License instead.)  You can apply it to
   your programs, too.
   
     When we speak of free software, we are referring to freedom, not
   price.  Our General Public Licenses are designed to make sure that you
   have the freedom to distribute copies of free software (and charge for
   this service if you wish), that you receive source code or can get it
   if you want it, that you can change the software or use pieces of it
   in new free programs; and that you know you can do these things.
   
     To protect your rights, we need to make restrictions that forbid
   anyone to deny you these rights or to ask you to surrender the rights.
   These restrictions translate to certain responsibilities for you if you
   distribute copies of the software, or if you modify it.
   
     For example, if you distribute copies of such a program, whether
   gratis or for a fee, you must give the recipients all the rights that
   you have.  You must make sure that they, too, receive or can get the
   source code.  And you must show them these terms so they know their
   rights.
   
     We protect your rights with two steps: (1) copyright the software, and
   (2) offer you this license which gives you legal permission to copy,
   distribute and/or modify the software.
   
     Also, for each author's protection and ours, we want to make certain
   that everyone understands that there is no warranty for this free
   software.  If the software is modified by someone else and passed on, we
   want its recipients to know that what they have is not the original, so
   that any problems introduced by others will not reflect on the original
   authors' reputations.
   
     Finally, any free program is threatened constantly by software
   patents.  We wish to avoid the danger that redistributors of a free
   program will individually obtain patent licenses, in effect making the
   program proprietary.  To prevent this, we have made it clear that any
   patent must be licensed for everyone's free use or not licensed at all.
   
     The precise terms and conditions for copying, distribution and
   modification follow.
   
   @iftex
   @unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
   @end iftex
   @ifinfo
   @center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
   @end ifinfo
   
   @enumerate 0
   @item
   This License applies to any program or other work which contains
   a notice placed by the copyright holder saying it may be distributed
   under the terms of this General Public License.  The ``Program'', below,
   refers to any such program or work, and a ``work based on the Program''
   means either the Program or any derivative work under copyright law:
   that is to say, a work containing the Program or a portion of it,
   either verbatim or with modifications and/or translated into another
   language.  (Hereinafter, translation is included without limitation in
   the term ``modification''.)  Each licensee is addressed as ``you''.
   
   Activities other than copying, distribution and modification are not
   covered by this License; they are outside its scope.  The act of
   running the Program is not restricted, and the output from the Program
   is covered only if its contents constitute a work based on the
   Program (independent of having been made by running the Program).
   Whether that is true depends on what the Program does.
   
   @item
   You may copy and distribute verbatim copies of the Program's
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the
   notices that refer to this License and to the absence of any warranty;
   and give any other recipients of the Program a copy of this License
   along with the Program.
   
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
   
   @item
   You may modify your copy or copies of the Program or any portion
   of it, thus forming a work based on the Program, and copy and
   distribute such modifications or work under the terms of Section 1
   above, provided that you also meet all of these conditions:
   
   @enumerate a
   @item
   You must cause the modified files to carry prominent notices
   stating that you changed the files and the date of any change.
   
   @item
   You must cause any work that you distribute or publish, that in
   whole or in part contains or is derived from the Program or any
   part thereof, to be licensed as a whole at no charge to all third
   parties under the terms of this License.
   
   @item
   If the modified program normally reads commands interactively
   when run, you must cause it, when started running for such
   interactive use in the most ordinary way, to print or display an
   announcement including an appropriate copyright notice and a
   notice that there is no warranty (or else, saying that you provide
   a warranty) and that users may redistribute the program under
   these conditions, and telling the user how to view a copy of this
   License.  (Exception: if the Program itself is interactive but
   does not normally print such an announcement, your work based on
   the Program is not required to print an announcement.)
   @end enumerate
   
   These requirements apply to the modified work as a whole.  If
   identifiable sections of that work are not derived from the Program,
   and can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works.  But when you
   distribute the same sections as part of a whole which is a work based
   on the Program, the distribution of the whole must be on the terms of
   this License, whose permissions for other licensees extend to the
   entire whole, and thus to each and every part regardless of who wrote it.
   
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Program.
   
   In addition, mere aggregation of another work not based on the Program
   with the Program (or with a work based on the Program) on a volume of
   a storage or distribution medium does not bring the other work under
   the scope of this License.
   
   @item
   You may copy and distribute the Program (or a work based on it,
   under Section 2) in object code or executable form under the terms of
   Sections 1 and 2 above provided that you also do one of the following:
   
   @enumerate a
   @item
   Accompany it with the complete corresponding machine-readable
   source code, which must be distributed under the terms of Sections
   1 and 2 above on a medium customarily used for software interchange; or,
   
   @item
   Accompany it with a written offer, valid for at least three
   years, to give any third party, for a charge no more than your
   cost of physically performing source distribution, a complete
   machine-readable copy of the corresponding source code, to be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange; or,
   
   @item
   Accompany it with the information you received as to the offer
   to distribute corresponding source code.  (This alternative is
   allowed only for noncommercial distribution and only if you
   received the program in object code or executable form with such
   an offer, in accord with Subsection b above.)
   @end enumerate
   
   The source code for a work means the preferred form of the work for
   making modifications to it.  For an executable work, complete source
   code means all the source code for all modules it contains, plus any
   associated interface definition files, plus the scripts used to
   control compilation and installation of the executable.  However, as a
   special exception, the source code distributed need not include
   anything that is normally distributed (in either source or binary
   form) with the major components (compiler, kernel, and so on) of the
   operating system on which the executable runs, unless that component
   itself accompanies the executable.
   
   If distribution of executable or object code is made by offering
   access to copy from a designated place, then offering equivalent
   access to copy the source code from the same place counts as
   distribution of the source code, even though third parties are not
   compelled to copy the source along with the object code.
   
   @item
   You may not copy, modify, sublicense, or distribute the Program
   except as expressly provided under this License.  Any attempt
   otherwise to copy, modify, sublicense or distribute the Program is
   void, and will automatically terminate your rights under this License.
   However, parties who have received copies, or rights, from you under
   this License will not have their licenses terminated so long as such
   parties remain in full compliance.
   
   @item
   You are not required to accept this License, since you have not
   signed it.  However, nothing else grants you permission to modify or
   distribute the Program or its derivative works.  These actions are
   prohibited by law if you do not accept this License.  Therefore, by
   modifying or distributing the Program (or any work based on the
   Program), you indicate your acceptance of this License to do so, and
   all its terms and conditions for copying, distributing or modifying
   the Program or works based on it.
   
   @item
   Each time you redistribute the Program (or any work based on the
   Program), the recipient automatically receives a license from the
   original licensor to copy, distribute or modify the Program subject to
   these terms and conditions.  You may not impose any further
   restrictions on the recipients' exercise of the rights granted herein.
   You are not responsible for enforcing compliance by third parties to
   this License.
   
   @item
   If, as a consequence of a court judgment or allegation of patent
   infringement or for any other reason (not limited to patent issues),
   conditions are imposed on you (whether by court order, agreement or
   otherwise) that contradict the conditions of this License, they do not
   excuse you from the conditions of this License.  If you cannot
   distribute so as to satisfy simultaneously your obligations under this
   License and any other pertinent obligations, then as a consequence you
   may not distribute the Program at all.  For example, if a patent
   license would not permit royalty-free redistribution of the Program by
   all those who receive copies directly or indirectly through you, then
   the only way you could satisfy both it and this License would be to
   refrain entirely from distribution of the Program.
   
   If any portion of this section is held invalid or unenforceable under
   any particular circumstance, the balance of the section is intended to
   apply and the section as a whole is intended to apply in other
   circumstances.
   
   It is not the purpose of this section to induce you to infringe any
   patents or other property right claims or to contest validity of any
   such claims; this section has the sole purpose of protecting the
   integrity of the free software distribution system, which is
   implemented by public license practices.  Many people have made
   generous contributions to the wide range of software distributed
   through that system in reliance on consistent application of that
   system; it is up to the author/donor to decide if he or she is willing
   to distribute software through any other system and a licensee cannot
   impose that choice.
   
   This section is intended to make thoroughly clear what is believed to
   be a consequence of the rest of this License.
   
   @item
   If the distribution and/or use of the Program is restricted in
   certain countries either by patents or by copyrighted interfaces, the
   original copyright holder who places the Program under this License
   may add an explicit geographical distribution limitation excluding
   those countries, so that distribution is permitted only in or among
   countries not thus excluded.  In such case, this License incorporates
   the limitation as if written in the body of this License.
   
   @item
   The Free Software Foundation may publish revised and/or new versions
   of the General Public License from time to time.  Such new versions will
   be similar in spirit to the present version, but may differ in detail to
   address new problems or concerns.
   
   Each version is given a distinguishing version number.  If the Program
   specifies a version number of this License which applies to it and ``any
   later version'', you have the option of following the terms and conditions
   either of that version or of any later version published by the Free
   Software Foundation.  If the Program does not specify a version number of
   this License, you may choose any version ever published by the Free Software
   Foundation.
   
   @item
   If you wish to incorporate parts of the Program into other free
   programs whose distribution conditions are different, write to the author
   to ask for permission.  For software which is copyrighted by the Free
   Software Foundation, write to the Free Software Foundation; we sometimes
   make exceptions for this.  Our decision will be guided by the two goals
   of preserving the free status of all derivatives of our free software and
   of promoting the sharing and reuse of software generally.
   
   @iftex
   @heading NO WARRANTY
   @end iftex
   @ifinfo
   @center NO WARRANTY
   @end ifinfo
   
   @item
   BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
   FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
   OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
   PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
   OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
   TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
   PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
   REPAIR OR CORRECTION.
   
   @item
   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
   WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
   REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
   INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
   OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
   TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
   YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
   PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
   POSSIBILITY OF SUCH DAMAGES.
   @end enumerate
   
 @iftex  @iftex
   @heading END OF TERMS AND CONDITIONS
   @end iftex
   @ifinfo
   @center END OF TERMS AND CONDITIONS
   @end ifinfo
   
   @page
   @unnumberedsec How to Apply These Terms to Your New Programs
   
     If you develop a new program, and you want it to be of the greatest
   possible use to the public, the best way to achieve this is to make it
   free software which everyone can redistribute and change under these terms.
   
     To do so, attach the following notices to the program.  It is safest
   to attach them to the start of each source file to most effectively
   convey the exclusion of warranty; and each file should have at least
   the ``copyright'' line and a pointer to where the full notice is found.
   
   @smallexample
   @var{one line to give the program's name and a brief idea of what it does.}
   Copyright (C) 19@var{yy}  @var{name of author}
   
   This program is free software; you can redistribute it and/or modify 
   it under the terms of the GNU General Public License as published by 
   the Free Software Foundation; either version 2 of the License, or 
   (at your option) any later version.
   
   This program 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 General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   @end smallexample
   
   Also add information on how to contact you by electronic and paper mail.
   
   If the program is interactive, make it output a short notice like this
   when it starts in an interactive mode:
   
   @smallexample
   Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
   Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
   type `show w'.  
   This is free software, and you are welcome to redistribute it 
   under certain conditions; type `show c' for details.
   @end smallexample
   
   The hypothetical commands @samp{show w} and @samp{show c} should show
   the appropriate parts of the General Public License.  Of course, the
   commands you use may be called something other than @samp{show w} and
   @samp{show c}; they could even be mouse-clicks or menu items---whatever
   suits your program.
   
   You should also get your employer (if you work as a programmer) or your
   school, if any, to sign a ``copyright disclaimer'' for the program, if
   necessary.  Here is a sample; alter the names:
   
   @smallexample
   Yoyodyne, Inc., hereby disclaims all copyright interest in the program
   `Gnomovision' (which makes passes at compilers) written by James Hacker.
   
   @var{signature of Ty Coon}, 1 April 1989
   Ty Coon, President of Vice
   @end smallexample
   
   This General Public License does not permit incorporating your program into
   proprietary programs.  If your program is a subroutine library, you may
   consider it more useful to permit linking proprietary applications with the
   library.  If this is what you want to do, use the GNU Library General
   Public License instead of this License.
   
   @iftex
   @node    Preface
   @comment node-name,     next,           previous, up
 @unnumbered Preface  @unnumbered Preface
   @cindex Preface
 This manual documents Gforth. The reader is expected to know  This manual documents Gforth. The reader is expected to know
 Forth. This manual is primarily a reference manual. @xref{Other Books}  Forth. This manual is primarily a reference manual. @xref{Other Books}
 for introductory material.  for introductory material.
Line 157  not written for ANS Forth, as you will n Line 550  not written for ANS Forth, as you will n
 deviations of the book.  deviations of the book.
   
 There is, of course, the standard, the definite reference if you want to  There is, of course, the standard, the definite reference if you want to
 write ANS Forth programs. It will be available in printed form from  write ANS Forth programs. It is available in printed form from the
 Global Engineering Documents !! somtime in spring or summer 1994. If you  National Standards Institute Sales Department (Tel.: USA (212) 642-4900;
 are lucky, you can still get dpANS6 (the draft that was approved as  Fax.: USA (212) 302-1286) as document @cite{X3.215-1994} for about $200. You
 standard) by aftp from ftp.uu.net:/vendor/minerva/x3j14.  can also get it from Global Engineering Documents (Tel.: USA (800)
   854-7179; Fax.: (303) 843-9880) for about $300.
   
   @cite{dpANS6}, the last draft of the standard, which was then submitted to ANSI
   for publication is available electronically and for free in some MS Word
   format, and it has been converted to HTML. Some pointers to these
   versions can be found through
   @*@file{http://www.complang.tuwien.ac.at/projects/forth.html}.
   
 @cite{Forth: The new model} by Jack Woehr (!! Publisher) is an  @cite{Forth: The new model} by Jack Woehr (Prentice-Hall, 1993) is an
 introductory book based on a draft version of the standard. It does not  introductory book based on a draft version of the standard. It does not
 cover the whole standard. It also contains interesting background  cover the whole standard. It also contains interesting background
 information (Jack Woehr was in the ANS Forth Technical Committe). It is  information (Jack Woehr was in the ANS Forth Technical Committe). It is
Line 193  line. They are: Line 593  line. They are:
   
 @table @code  @table @code
 @item --image-file @var{file}  @item --image-file @var{file}
   @item -i @var{file}
 Loads the Forth image @var{file} instead of the default  Loads the Forth image @var{file} instead of the default
 @file{gforth.fi}.  @file{gforth.fi}.
   
 @item --path @var{path}  @item --path @var{path}
   @item -p @var{path}
 Uses @var{path} for searching the image file and Forth source code  Uses @var{path} for searching the image file and Forth source code
 files instead of the default in the environment variable  files instead of the default in the environment variable
 @code{GFORTHPATH} or the path specified at installation time (typically  @code{GFORTHPATH} or the path specified at installation time (typically
Line 245  Forth words, you have to quote them or u Line 647  Forth words, you have to quote them or u
 after processing the command line (instead of entering interactive mode)  after processing the command line (instead of entering interactive mode)
 append @code{-e bye} to the command line.  append @code{-e bye} to the command line.
   
   If you have several versions of Gforth installed, @code{gforth} will
   invoke the version that was installed last. @code{gforth-@var{version}}
   invokes a specific version. You may want to use the option
   @code{--path}, if your environment contains the variable
   @code{GFORTHPATH}.
   
 Not yet implemented:  Not yet implemented:
 On startup the system first executes the system initialization file  On startup the system first executes the system initialization file
 (unless the option @code{--no-init-file} is given; note that the system  (unless the option @code{--no-init-file} is given; note that the system
Line 269  then in @file{~}, then in the normal pat Line 677  then in @file{~}, then in the normal pat
 * Blocks::                        * Blocks::                      
 * Other I/O::                     * Other I/O::                   
 * Programming Tools::             * Programming Tools::           
   * Assembler and Code words::    
 * Threading Words::               * Threading Words::             
 @end menu  @end menu
   
Line 300  effect}, but in @var{Description}. The n Line 709  effect}, but in @var{Description}. The n
 the type and/or the function of the item. See below for a discussion of  the type and/or the function of the item. See below for a discussion of
 the types.  the types.
   
   All words have two stack effects: A compile-time stack effect and a
   run-time stack effect. The compile-time stack-effect of most words is
   @var{ -- }. If the compile-time stack-effect of a word deviates from
   this standard behaviour, or the word does other unusual things at
   compile time, both stack effects are shown; otherwise only the run-time
   stack effect is shown.
   
 @item pronunciation  @item pronunciation
 How the word is pronounced  How the word is pronounced
   
Line 309  system need not support all of them. So, Line 725  system need not support all of them. So,
 uses the more portable it will be in theory. However, we suspect that  uses the more portable it will be in theory. However, we suspect that
 most ANS Forth systems on personal machines will feature all  most ANS Forth systems on personal machines will feature all
 wordsets. Words that are not defined in the ANS standard have  wordsets. Words that are not defined in the ANS standard have
 @code{gforth} as wordset.  @code{gforth} or @code{gforth-internal} as wordset. @code{gforth}
   describes words that will work in future releases of Gforth;
   @code{gforth-internal} words are more volatile. Environmental query
   strings are also displayed like words; you can recognize them by the
   @code{environment} in the wordset field.
   
 @item Description  @item Description
 A description of the behaviour of the word.  A description of the behaviour of the word.
Line 808  There are several variations on the coun Line 1228  There are several variations on the coun
   
 @code{LEAVE} leaves the innermost counted loop immediately.  @code{LEAVE} leaves the innermost counted loop immediately.
   
   If @var{start} is greater than @var{limit}, a @code{?DO} loop is entered
   (and @code{LOOP} iterates until they become equal by wrap-around
   arithmetic). This behaviour is usually not what you want. Therefore,
   Gforth offers @code{+DO} and @code{U+DO} (as replacements for
   @code{?DO}), which do not enter the loop if @var{start} is greater than
   @var{limit}; @code{+DO} is for signed loop parameters, @code{U+DO} for
   unsigned loop parameters. These words can be implemented easily on
   standard systems, so using them does not make your programs hard to
   port; e.g.:
   @example
   : +DO ( compile-time: -- do-sys; run-time: n1 n2 -- )
       POSTPONE over POSTPONE min POSTPONE ?DO ; immediate
   @end example
   
 @code{LOOP} can be replaced with @code{@var{n} +LOOP}; this updates the  @code{LOOP} can be replaced with @code{@var{n} +LOOP}; this updates the
 index by @var{n} instead of by 1. The loop is terminated when the border  index by @var{n} instead of by 1. The loop is terminated when the border
 between @var{limit-1} and @var{limit} is crossed. E.g.:  between @var{limit-1} and @var{limit} is crossed. E.g.:
   
 @code{4 0 ?DO  i .  2 +LOOP}   prints @code{0 2}  @code{4 0 +DO  i .  2 +LOOP}   prints @code{0 2}
   
 @code{4 1 ?DO  i .  2 +LOOP}   prints @code{1 3}  @code{4 1 +DO  i .  2 +LOOP}   prints @code{1 3}
   
 The behaviour of @code{@var{n} +LOOP} is peculiar when @var{n} is negative:  The behaviour of @code{@var{n} +LOOP} is peculiar when @var{n} is negative:
   
Line 822  The behaviour of @code{@var{n} +LOOP} is Line 1256  The behaviour of @code{@var{n} +LOOP} is
   
 @code{ 0 0 ?DO  i .  -1 +LOOP}  prints nothing  @code{ 0 0 ?DO  i .  -1 +LOOP}  prints nothing
   
 Therefore we recommend avoiding using @code{@var{n} +LOOP} with negative  Therefore we recommend avoiding @code{@var{n} +LOOP} with negative
 @var{n}. One alternative is @code{@var{n} S+LOOP}, where the negative  @var{n}. One alternative is @code{@var{u} -LOOP}, which reduces the
 case behaves symmetrical to the positive case:  index by @var{u} each iteration. The loop is terminated when the border
   between @var{limit+1} and @var{limit} is crossed. Gforth also provides
   @code{-DO} and @code{U-DO} for down-counting loops. E.g.:
   
 @code{-2 0 ?DO  i .  -1 S+LOOP}  prints @code{0 -1}  @code{-2 0 -DO  i .  1 -LOOP}  prints @code{0 -1}
   
 @code{-1 0 ?DO  i .  -1 S+LOOP}  prints @code{0}  @code{-1 0 -DO  i .  1 -LOOP}  prints @code{0}
   
 @code{ 0 0 ?DO  i .  -1 S+LOOP}  prints nothing  @code{ 0 0 -DO  i .  1 -LOOP}  prints nothing
   
 The loop is terminated when the border between @var{limit@minus{}sgn(n)} and  Another alternative is @code{@var{n} S+LOOP}, where the negative
 @var{limit} is crossed. However, @code{S+LOOP} is not part of the ANS  case behaves symmetrical to the positive case:
 Forth standard.  
   @code{-2 0 -DO  i .  -1 S+LOOP}  prints @code{0 -1}
   
 @code{?DO} can be replaced by @code{DO}. @code{DO} enters the loop even  The loop is terminated when the border between @var{limit@minus{}sgn(n)}
 when the start and the limit value are equal. We do not recommend using  and @var{limit} is crossed. Unfortunately, neither @code{-LOOP} nor
 @code{DO}. It will just give you maintenance troubles.  @code{S+LOOP} are part of the ANS Forth standard, and they are not easy
   to implement using standard words. If you want to write standard
   programs, just avoid counting down.
   
   @code{?DO} can also be replaced by @code{DO}. @code{DO} always enters
   the loop, independent of the loop parameters. Do not use @code{DO}, even
   if you know that the loop is entered in any case. Such knowledge tends
   to become invalid during maintenance of a program, and then the
   @code{DO} will make trouble.
   
 @code{UNLOOP} is used to prepare for an abnormal loop exit, e.g., via  @code{UNLOOP} is used to prepare for an abnormal loop exit, e.g., via
 @code{EXIT}. @code{UNLOOP} removes the loop control parameters from the  @code{EXIT}. @code{UNLOOP} removes the loop control parameters from the
Line 894  doc-repeat Line 1339  doc-repeat
 Counted loop words constitute a separate group of words:  Counted loop words constitute a separate group of words:
   
 doc-?do  doc-?do
   doc-+do
   doc-u+do
   doc--do
   doc-u-do
 doc-do  doc-do
 doc-for  doc-for
 doc-loop  doc-loop
 doc-s+loop  doc-s+loop
 doc-+loop  doc-+loop
   doc--loop
 doc-next  doc-next
 doc-leave  doc-leave
 doc-?leave  doc-?leave
Line 995  laden with restrictions. Therefore, we p Line 1445  laden with restrictions. Therefore, we p
 locals wordset, but also our own, more powerful locals wordset (we  locals wordset, but also our own, more powerful locals wordset (we
 implemented the ANS Forth locals wordset through our locals wordset).  implemented the ANS Forth locals wordset through our locals wordset).
   
   The ideas in this section have also been published in the paper
   @cite{Automatic Scoping of Local Variables} by M. Anton Ertl, presented
   at EuroForth '94; it is available at
   @*@file{http://www.complang.tuwien.ac.at/papers/ertl94l.ps.gz}.
   
 @menu  @menu
 * Gforth locals::                 * Gforth locals::               
 * ANS Forth locals::              * ANS Forth locals::            
Line 1526  locals wordset. Line 1981  locals wordset.
 @node Other I/O, Programming Tools, Blocks, Words  @node Other I/O, Programming Tools, Blocks, Words
 @section Other I/O  @section Other I/O
   
 @node Programming Tools, Threading Words, Other I/O, Words  @node Programming Tools, Assembler and Code words, Other I/O, Words
 @section Programming Tools  @section Programming Tools
   
 @menu  @menu
Line 1625  If there is interest, we will introduce Line 2080  If there is interest, we will introduce
 intend to @code{catch} a specific condition, using @code{throw} is  intend to @code{catch} a specific condition, using @code{throw} is
 probably more appropriate than an assertion).  probably more appropriate than an assertion).
   
 @node Threading Words,  , Programming Tools, Words  @node Assembler and Code words, Threading Words, Programming Tools, Words
   @section Assembler and Code words
   
   Gforth provides some words for defining primitives (words written in
   machine code), and for defining the the machine-code equivalent of
   @code{DOES>}-based defining words. However, the machine-independent
   nature of Gforth poses a few problems: First of all. Gforth runs on
   several architectures, so it can provide no standard assembler. What's
   worse is that the register allocation not only depends on the processor,
   but also on the @code{gcc} version and options used.
   
   The words that Gforth offers encapsulate some system dependences (e.g., the
   header structure), so a system-independent assembler may be used in
   Gforth. If you do not have an assembler, you can compile machine code
   directly with @code{,} and @code{c,}.
   
   doc-assembler
   doc-code
   doc-end-code
   doc-;code
   doc-flush-icache
   
   If @code{flush-icache} does not work correctly, @code{code} words
   etc. will not work (reliably), either.
   
   These words are rarely used. Therefore they reside in @code{code.fs},
   which is usually not loaded (except @code{flush-icache}, which is always
   present). You can load them with @code{require code.fs}.
   
   In the assembly code you will want to refer to the inner interpreter's
   registers (e.g., the data stack pointer) and you may want to use other
   registers for temporary storage. Unfortunately, the register allocation
   is installation-dependent.
   
   The easiest solution is to use explicit register declarations
   (@pxref{Explicit Reg Vars, , Variables in Specified Registers, gcc.info,
   GNU C Manual}) for all of the inner interpreter's registers: You have to
   compile Gforth with @code{-DFORCE_REG} (configure option
   @code{--enable-force-reg}) and the appropriate declarations must be
   present in the @code{machine.h} file (see @code{mips.h} for an example;
   you can find a full list of all declarable register symbols with
   @code{grep register engine.c}). If you give explicit registers to all
   variables that are declared at the beginning of @code{engine()}, you
   should be able to use the other caller-saved registers for temporary
   storage. Alternatively, you can use the @code{gcc} option
   @code{-ffixed-REG} (@pxref{Code Gen Options, , Options for Code
   Generation Conventions, gcc.info, GNU C Manual}) to reserve a register
   (however, this restriction on register allocation may slow Gforth
   significantly).
   
   If this solution is not viable (e.g., because @code{gcc} does not allow
   you to explicitly declare all the registers you need), you have to find
   out by looking at the code where the inner interpreter's registers
   reside and which registers can be used for temporary storage. You can
   get an assembly listing of the engine's code with @code{make engine.s}.
   
   In any case, it is good practice to abstract your assembly code from the
   actual register allocation. E.g., if the data stack pointer resides in
   register @code{$17}, create an alias for this register called @code{sp},
   and use that in your assembly code.
   
   Another option for implementing normal and defining words efficiently
   is: adding the wanted functionality to the source of Gforth. For normal
   words you just have to edit @file{primitives}, defining words (for fast
   defined words) may require changes in @file{engine.c},
   @file{kernal.fs}, @file{prims2x.fs}, and possibly @file{cross.fs}.
   
   
   @node Threading Words,  , Assembler and Code words, Words
 @section Threading Words  @section Threading Words
   
 These words provide access to code addresses and other threading stuff  These words provide access to code addresses and other threading stuff
Line 1643  doc-does-code! Line 2166  doc-does-code!
 doc-does-handler!  doc-does-handler!
 doc-/does-handler  doc-/does-handler
   
   The code addresses produced by various defining words are produced by
   the following words:
   
   doc-docol:
   doc-docon:
   doc-dovar:
   doc-douser:
   doc-dodefer:
   doc-dofield:
   
   Currently there is no installation-independent way for recogizing words
   defined by a @code{CREATE}...@code{DOES>} word; however, once you know
   that a word is defined by a @code{CREATE}...@code{DOES>} word, you can
   use @code{>DOES-CODE}.
   
 @node ANS conformance, Model, Words, Top  @node ANS conformance, Model, Words, Top
 @chapter ANS conformance  @chapter ANS conformance
Line 1670  ANS Forth System Line 2206  ANS Forth System
 @item providing the Memory-Allocation word set  @item providing the Memory-Allocation word set
 @item providing the Memory-Allocation Extensions word set (that one's easy)  @item providing the Memory-Allocation Extensions word set (that one's easy)
 @item providing the Programming-Tools word set  @item providing the Programming-Tools word set
 @item providing @code{AHEAD}, @code{BYE}, @code{CS-PICK}, @code{CS-ROLL}, @code{STATE}, @code{[ELSE]}, @code{[IF]}, @code{[THEN]} from the Programming-Tools Extensions word set  @item providing @code{;code}, @code{AHEAD}, @code{ASSEMBLER}, @code{BYE}, @code{CODE}, @code{CS-PICK}, @code{CS-ROLL}, @code{STATE}, @code{[ELSE]}, @code{[IF]}, @code{[THEN]} from the Programming-Tools Extensions word set
 @item providing the Search-Order word set  @item providing the Search-Order word set
 @item providing the Search-Order Extensions word set  @item providing the Search-Order Extensions word set
 @item providing the String word set  @item providing the String word set
Line 1881  characters is determined by the locale y Line 2417  characters is determined by the locale y
   
 @item division rounding:  @item division rounding:
 installation dependent. @code{s" floored" environment? drop .}. We leave  installation dependent. @code{s" floored" environment? drop .}. We leave
 the choice to gcc (what to use for @code{/}) and to you (whether to use  the choice to @code{gcc} (what to use for @code{/}) and to you (whether to use
 @code{fm/mod}, @code{sm/rem} or simply @code{/}).  @code{fm/mod}, @code{sm/rem} or simply @code{/}).
   
 @item values of @code{STATE} when true:  @item values of @code{STATE} when true:
Line 1992  The next invocation of a parsing word re Line 2528  The next invocation of a parsing word re
 Compiles a recursive call to the defining word not to the defined word.  Compiles a recursive call to the defining word not to the defined word.
   
 @item argument input source different than current input source for @code{RESTORE-INPUT}:  @item argument input source different than current input source for @code{RESTORE-INPUT}:
 !!???If the argument input source is a valid input source then it gets  @code{-12 THROW}. Note that, once an input file is closed (e.g., because
 restored. Otherwise causes @code{-12 THROW} which unless caught issues  the end of the file was reached), its source-id may be
 the message "argument type mismatch" and aborts.  reused. Therefore, restoring an input source specification referencing a
   closed file may lead to unpredictable results instead of a @code{-12
   THROW}.
   
   In the future, Gforth may be able to retore input source specifications
   from other than the current input soruce.
   
 @item data space containing definitions gets de-allocated:  @item data space containing definitions gets de-allocated:
 Deallocation with @code{allot} is not checked. This typically resuls in  Deallocation with @code{allot} is not checked. This typically resuls in
Line 2066  Not checked. As usual, you can expect me Line 2607  Not checked. As usual, you can expect me
 None.  None.
   
 @item operator's terminal facilities available:  @item operator's terminal facilities available:
 !!??  After processing the command line, Gforth goes into interactive mode,
   and you can give commands to Gforth interactively. The actual facilities
   available depend on how you invoke Gforth.
   
 @item program data space available:  @item program data space available:
 @code{sp@ here - .} gives the space remaining for dictionary and data  @code{sp@ here - .} gives the space remaining for dictionary and data
 stack together.  stack together.
   
 @item return stack space available:  @item return stack space available:
 !!??  By default 16 KBytes. The default can be overridden with the @code{-r}
   switch (@pxref{Invocation}) when Gforth starts up.
   
 @item stack space available:  @item stack space available:
 @code{sp@ here - .} gives the space remaining for dictionary and data  @code{sp@ here - .} gives the space remaining for dictionary and data
Line 2394  System dependent; @code{REPRESENT} is im Line 2938  System dependent; @code{REPRESENT} is im
 function @code{ecvt()} and inherits its behaviour in this respect.  function @code{ecvt()} and inherits its behaviour in this respect.
   
 @item rounding or truncation of floating-point numbers:  @item rounding or truncation of floating-point numbers:
 What's the question?!!  System dependent; the rounding behaviour is inherited from the hosting C
   compiler. IEEE-FP-based (i.e., most) systems by default round to
   nearest, and break ties by rounding to even (i.e., such that the last
   bit of the mantissa is 0).
   
 @item size of floating-point stack:  @item size of floating-point stack:
 @code{s" FLOATING-STACK" environment? drop .}. Can be changed at startup  @code{s" FLOATING-STACK" environment? drop .}. Can be changed at startup
Line 2696  Also, if you @code{include} @file{etags. Line 3243  Also, if you @code{include} @file{etags.
 contains the definitions of all words defined afterwards. You can then  contains the definitions of all words defined afterwards. You can then
 find the source for a word using @kbd{M-.}. Note that emacs can use  find the source for a word using @kbd{M-.}. Note that emacs can use
 several tags files at the same time (e.g., one for the Gforth sources  several tags files at the same time (e.g., one for the Gforth sources
 and one for your program).  and one for your program, @pxref{Select Tags Table,,Selecting a Tags
   Table,emacs, Emacs Manual}). The TAGS file for the preloaded words is
   @file{$(datadir)/gforth/$(VERSION)/TAGS} (e.g.,
   @file{/usr/local/share/gforth/0.2/TAGS}).
   
 To get all these benefits, add the following lines to your @file{.emacs}  To get all these benefits, add the following lines to your @file{.emacs}
 file:  file:
Line 2712  file: Line 3262  file:
 Reading this section is not necessary for programming with Gforth. It  Reading this section is not necessary for programming with Gforth. It
 should be helpful for finding your way in the Gforth sources.  should be helpful for finding your way in the Gforth sources.
   
   The ideas in this section have also been published in the papers
   @cite{ANS fig/GNU/??? Forth} (in German) by Bernd Paysan, presented at
   the Forth-Tagung '93 and @cite{A Portable Forth Engine} by M. Anton
   Ertl, presented at EuroForth '93; the latter is available at
   @*@file{http://www.complang.tuwien.ac.at/papers/ertl93.ps.Z}.
   
 @menu  @menu
 * Portability::                   * Portability::                 
 * Threading::                     * Threading::                   
Line 3099  Sieve benchmark on a 486DX2/66 than Gfor Line 3655  Sieve benchmark on a 486DX2/66 than Gfor
   
 However, this potential advantage of assembly language implementations  However, this potential advantage of assembly language implementations
 is not necessarily realized in complete Forth systems: We compared  is not necessarily realized in complete Forth systems: We compared
 Gforth (compiled with @code{gcc-2.6.3} and @code{-DFORCE_REG}) with  Gforth (direct threaded, compiled with @code{gcc-2.6.3} and
 Win32Forth and LMI's NT Forth, two systems written in assembly, and with  @code{-DFORCE_REG}) with Win32Forth 1.2093, LMI's NT Forth (Beta, May
 two systems written in C: PFE-0.9.11 (compiled with @code{gcc-2.6.3}  1994) and Eforth (with and without peephole (aka pinhole) optimization
 with the default configuration for Linux: @code{-O2 -fomit-frame-pointer  of the threaded code); all these systems were written in assembly
 -DUSE_REGS}) and ThisForth Beta (compiled with gcc-2.6.3 -O3  language. We also compared Gforth with two systems written in C:
 -fomit-frame-pointer). We benchmarked Gforth, PFE and ThisForth on a  PFE-0.9.11 (compiled with @code{gcc-2.6.3} with the default
 486DX2/66 under Linux. Kenneth O'Heskin kindly provided the results for  configuration for Linux: @code{-O2 -fomit-frame-pointer -DUSE_REGS}) and
 Win32Forth and NT Forth on a 486DX2/66 with similar memory performance  ThisForth Beta (compiled with gcc-2.6.3 -O3 -fomit-frame-pointer;
 under Windows NT.  ThisForth employs peephole optimization of the threaded code). We
   benchmarked Gforth, PFE and ThisForth on a 486DX2/66 under
   Linux. Kenneth O'Heskin kindly provided the results for Win32Forth and
   NT Forth on a 486DX2/66 with similar memory performance under Windows
   NT. Marcel Hendrix ported Eforth to Linux, then extended it to run the
   benchmarks, added the peephole optimizer, ran the benchmarks and
   reported the results.
     
 We used four small benchmarks: the ubiquitous Sieve; bubble-sorting and  We used four small benchmarks: the ubiquitous Sieve; bubble-sorting and
 matrix multiplication come from the Stanford integer benchmarks and have  matrix multiplication come from the Stanford integer benchmarks and have
 been translated into Forth by Martin Fraeman; we used the versions  been translated into Forth by Martin Fraeman; we used the versions
 included in the TILE Forth package; and a recursive Fibonacci number  included in the TILE Forth package; and a recursive Fibonacci number
 computation for benchmark calling performance. The following table shows  computation for benchmarking calling performance. The following table shows
 the time taken for the benchmarks scaled by the time taken by Gforth (in  the time taken for the benchmarks scaled by the time taken by Gforth (in
 other words, it shows the speedup factor that Gforth achieved over the  other words, it shows the speedup factor that Gforth achieved over the
 other systems).  other systems).
   
 @example  @example
 relative             Win32-        NT               This-  relative        Win32-    NT       eforth       This-
   time     Gforth     Forth     Forth       PFE     Forth  time      Gforth Forth Forth eforth  +opt   PFE Forth
 sieve        1.00      1.30      1.07      1.67      2.98  sieve       1.00  1.39  1.14   1.39  0.85  1.78  3.18
 bubble       1.00      1.30      1.40      1.66  bubble      1.00  1.33  1.43   1.51  0.89  1.70
 matmul       1.00      1.40      1.29      2.24  matmul      1.00  1.43  1.31   1.42  1.12  2.28
 fib          1.00      1.44      1.26      1.82      2.82  fib         1.00  1.55  1.36   1.24  1.15  1.97  3.04
 @end example  @end example
   
 You may find the good performance of Gforth compared with the systems  You may find the good performance of Gforth compared with the systems
Line 3136  method for relocating the Forth image: l Line 3698  method for relocating the Forth image: l
 the actual addresses at run time, resulting in two address computations  the actual addresses at run time, resulting in two address computations
 per NEXT (@pxref{System Architecture}).  per NEXT (@pxref{System Architecture}).
   
   Only Eforth with the peephole optimizer performs comparable to
   Gforth. The speedups achieved with peephole optimization of threaded
   code are quite remarkable. Adding a peephole optimizer to Gforth should
   cause similar speedups.
   
 The speedup of Gforth over PFE and ThisForth can be easily explained  The speedup of Gforth over PFE and ThisForth can be easily explained
 with the self-imposed restriction to standard C (although the measured  with the self-imposed restriction to standard C (although the measured
 implementation of PFE uses a GNU C extension: global register  implementation of PFE uses a GNU C extension: global register
Line 3150  machine registers by itself and would no Line 3717  machine registers by itself and would no
 register declarations, giving a 1.3 times slower engine (on a 486DX2/66  register declarations, giving a 1.3 times slower engine (on a 486DX2/66
 running the Sieve) than the one measured above.  running the Sieve) than the one measured above.
   
 @node Bugs, Pedigree, Internals, Top  In @cite{Translating Forth to Efficient C} by M. Anton Ertl and Martin
   Maierhofer (presented at EuroForth '95), an indirect threaded version of
   Gforth is compared with Win32Forth, NT Forth, PFE, and ThisForth; that
   version of Gforth is 2\%@minus{}8\% slower on a 486 than the version
   used here. The paper available at
   @*@file{http://www.complang.tuwien.ac.at/papers/ertl&maierhofer95.ps.gz};
   it also contains numbers for some native code systems. You can find
   numbers for Gforth on various machines in @file{Benchres}.
   
   @node Bugs, Origin, Internals, Top
 @chapter Bugs  @chapter Bugs
   
 Known bugs are described in the file BUGS in the Gforth distribution.  Known bugs are described in the file BUGS in the Gforth distribution.
   
 If you find a bug, please send a bug report to !!. A bug report should  If you find a bug, please send a bug report to
   @code{gforth-bugs@@mips.complang.tuwien.ac.at}. A bug report should
 describe the Gforth version used (it is announced at the start of an  describe the Gforth version used (it is announced at the start of an
 interactive Gforth session), the machine and operating system (on Unix  interactive Gforth session), the machine and operating system (on Unix
 systems you can use @code{uname -a} to produce this information), the  systems you can use @code{uname -a} to produce this information), the
 installation options (!! a way to find them out), and a complete list of  installation options (send the @code{config.status} file), and a
 changes you (or your installer) have made to the Gforth sources (if  complete list of changes you (or your installer) have made to the Gforth
 any); it should contain a program (or a sequence of keyboard commands)  sources (if any); it should contain a program (or a sequence of keyboard
 that reproduces the bug and a description of what you think constitutes  commands) that reproduces the bug and a description of what you think
 the buggy behaviour.  constitutes the buggy behaviour.
   
 For a thorough guide on reporting bugs read @ref{Bug Reporting, , How  For a thorough guide on reporting bugs read @ref{Bug Reporting, , How
 to Report Bugs, gcc.info, GNU C Manual}.  to Report Bugs, gcc.info, GNU C Manual}.
   
   
 @node Pedigree, Word Index, Bugs, Top  @node Origin, Word Index, Bugs, Top
 @chapter Pedigree  @chapter Authors and Ancestors of Gforth
   
 Gforth descends from BigForth (1993) and fig-Forth. Gforth and PFE (by  @section Authors and Contributors
 Dirk Zoller) will cross-fertilize each other. Of course, a significant part of the design of Gforth was prescribed by ANS Forth.  
   The Gforth project was started in mid-1992 by Bernd Paysan and Anton
   Ertl. The third major author was Jens Wilke. Lennart Benschop (who also
   was one of Gforth's first users, in mid-1993) and Stuart Ramsden
   inspired us with their continuous feedback. Lennart Benshop contributed
   @file{glosgen.fs}, while Stuart Ramsden has been working on automatic
   support for calling C libraries. Helpful comments also came from Paul
   Kleinrubatscher, Christian Pirker, Dirk Zoller and Marcel Hendrix.
   
 Bernd Paysan wrote BigForth, a child of VolksForth.  @section Pedigree
   
 VolksForth descends from F83. !! Authors? When?  Gforth descends from BigForth (1993) and fig-Forth. Gforth and PFE (by
   Dirk Zoller) will cross-fertilize each other. Of course, a significant
   part of the design of Gforth was prescribed by ANS Forth.
   
 Laxen and Perry wrote F83 as a model implementation of the  Bernd Paysan wrote BigForth, a descendent from TurboForth, an unreleased
   32 bit native code version of VolksForth for the Atari ST, written
   mostly by Dietrich Weineck.
   
   VolksForth descends from F83. It was written by Klaus Schleisiek, Bernd
   Pennemann, Georg Rehfeld and Dietrich Weineck for the C64 (called
   UltraForth there) in the mid-80s and ported to the Atari ST in 1986.
   
   Hennry Laxen and Mike Perry wrote F83 as a model implementation of the
 Forth-83 standard. !! Pedigree? When?  Forth-83 standard. !! Pedigree? When?
   
 A team led by Bill Ragsdale implemented fig-Forth on many processors in  A team led by Bill Ragsdale implemented fig-Forth on many processors in
 1979. Dean Sanderson and Bill Ragsdale developed the original  1979. Robert Selzer and Bill Ragsdale developed the original
 implementation of fig-Forth based on microForth.  implementation of fig-Forth for the 6502 based on microForth.
   
   The principal architect of microForth was Dean Sanderson. microForth was
   FORTH, Inc.'s first off-the-shelf product. It was developped in 1976 for
   the 1802, and subsequently implemented on the 8080, the 6800 and the
   Z80.
   
 !! microForth pedigree  All earlier Forth systems were custom-made, usually by Charles Moore,
   who discovered (as he puts it) Forth in the late 60s.
   
 A part of the information in this section comes from @cite{The Evolution  A part of the information in this section comes from @cite{The Evolution
 of Forth} by Elizabeth D. Rather, Donald R. Colburn and Charles  of Forth} by Elizabeth D. Rather, Donald R. Colburn and Charles
Line 3194  H. Moore, presented at the HOPL-II confe Line 3794  H. Moore, presented at the HOPL-II confe
 Notices 28(3), 1993.  You can find more historical and genealogical  Notices 28(3), 1993.  You can find more historical and genealogical
 information about Forth there.  information about Forth there.
   
 @node Word Index, Node Index, Pedigree, Top  @node Word Index, Node Index, Origin, Top
 @chapter Word Index  @chapter Word Index
   
 This index is as incomplete as the manual.  This index is as incomplete as the manual. Each word is listed with
   stack effect and wordset.
   
 @printindex fn  @printindex fn
   

Removed from v.1.17  
changed lines
  Added in v.1.29


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>