This is Info file gforth.info, produced by Makeinfo version 1.68 from
the input file gforth.texi.

INFO-DIR-SECTION GNU programming tools
START-INFO-DIR-ENTRY
* Gforth: (gforth).             A fast interpreter for the Forth language.
END-INFO-DIR-ENTRY

   This file documents Gforth 0.4.0

   Copyright (C) 1995-1998 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
 are preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this      manual under the conditions for verbatim copying, provided
also that the      sections entitled "Distribution" and "General Public
License" are      included exactly as in the original, and provided
that the entire      resulting derived work is distributed under the
terms of a permission      notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual      into another language, under the above conditions for
modified versions,      except that the sections entitled
"Distribution" and "General Public      License" may be included in a
translation approved by the author instead      of in the original
English.


File: gforth.info,  Node: Word Index,  Next: Concept Index,  Prev: Origin,  Up: Top

Word Index
**********

   This index is as incomplete as the manual. Each word is listed with
stack effect and wordset.

* Menu:

* !  W A-ADDR -   core:                  Memory Access.
* #!  -     gforth:                      Running Image Files.
* %align  ALIGN SIZE -     gforth:       Structure Glossary.
* %alignment  ALIGN SIZE - ALIGN     gforth: Structure Glossary.
* %alloc  SIZE ALIGN - ADDR     gforth:  Structure Glossary.
* %allocate  ALIGN SIZE - ADDR IOR     gforth: Structure Glossary.
* %allot  ALIGN SIZE - ADDR     gforth:  Structure Glossary.
* %size  ALIGN SIZE - SIZE     gforth:   Structure Glossary.
* '  "NAME" - XT     core:               Tokens for Words.
* '  "NAME" - XT     oof:                The base class object.
* 'cold  -     gforth:                   Modifying the Startup Sequence.
* (local)  ADDR U -     local:           ANS Forth locals.
* )  -     gforth:                       Assertions.
* *  N1 N2 - N   core:                   Single precision.
* */  N1 N2 N3 - N4     core:            Mixed precision.
* */mod  N1 N2 N3 - N4 N5     core:      Mixed precision.
* +  N1 N2 - N   core:                   Single precision.
* +!  N A-ADDR -   core:                 Memory Access.
* +DO  COMPILATION - DO-SYS ; RUN-TIME N1 N2 - | LOOP-SYS     gforth: Arbitrary control structures.
* +load  I*X N - J*X     block:          Blocks.
* +LOOP  COMPILATION DO-SYS - ; RUN-TIME LOOP-SYS1 N - | LOOP-SYS2     core: Arbitrary control structures.
* +thru  I*X N1 N2 - J*X     block:      Blocks.
* -  N1 N2 - N   core:                   Single precision.
* -->  -     block:                      Blocks.
* -DO  COMPILATION - DO-SYS ; RUN-TIME N1 N2 - | LOOP-SYS     gforth: Arbitrary control structures.
* -LOOP  COMPILATION DO-SYS - ; RUN-TIME LOOP-SYS1 U - | LOOP-SYS2     gforth: Arbitrary control structures.
* -rot  W1 W2 W3 - W3 W1 W2   gforth:    Data stack.
* .fpath  -     gforth:                  Changing the Search Path.
* .path  PATH-ADDR -     gforth:         General Search Paths.
* /  N1 N2 - N   core:                   Single precision.
* /does-handler  - N   gforth:           Threading Words.
* /mod  N1 N2 - N3 N4   core:            Single precision.
* 2!  W1 W2 A-ADDR -   core:             Memory Access.
* 2*  N1 - N2   core:                    Bitwise operations.
* 2/  N1 - N2   core:                    Bitwise operations.
* 2>r  W1 W2 -   core-ext:               Return stack.
* 2@  A-ADDR - W1 W2   core:             Memory Access.
* 2Constant  W1 W2 "NAME" -     double:  Simple Defining Words.
* 2drop  W1 W2 -   core:                 Data stack.
* 2dup  W1 W2 - W1 W2 W1 W2   core:      Data stack.
* 2nip  W1 W2 W3 W4 - W3 W4   gforth:    Data stack.
* 2over  W1 W2 W3 W4 - W1 W2 W3 W4 W1 W2   core: Data stack.
* 2r>  - W1 W2   core-ext:               Return stack.
* 2r@  - W1 W2   core-ext:               Return stack.
* 2rdrop  -   gforth:                    Return stack.
* 2rot  W1 W2 W3 W4 W5 W6 - W3 W4 W5 W6 W1 W2   double-ext: Data stack.
* 2swap  W1 W2 W3 W4 - W3 W4 W1 W2   core: Data stack.
* 2tuck  W1 W2 W3 W4 - W3 W4 W1 W2 W3 W4   gforth: Data stack.
* 2Variable  "NAME" -     double:        Simple Defining Words.
* :  "NAME" -     oof:                   The base class object.
* :  "NAME" - COLON-SYS     core:        Colon Definitions.
* ::  "NAME" -     oof:                  The base class object.
* ::  CLASS "NAME" -     unknown:        Mini-OOF Usage.
* :noname  - XT COLON-SYS     core-ext:  Supplying names.
* ;  COMPILATION COLON-SYS - ; RUN-TIME NEST-SYS     core: Colon Definitions.
* ;code  COMPILATION. COLON-SYS1 - COLON-SYS2     tools-ext: Assembler and Code Words.
* ;m  COLON-SYS -; RUN-TIME: -     objects: Objects Glossary.
* ;s  -   gforth:                        Calls and returns.
* <bind>  CLASS SELECTOR-XT - XT     objects: Objects Glossary.
* <compilation  COMPILATION. ORIG COLON-SYS -     gforth: Interpretation and Compilation Semantics.
* <interpretation  COMPILATION. ORIG COLON-SYS -     gforth: Interpretation and Compilation Semantics.
* <to-inst>  W XT -     objects:         Objects Glossary.
* >body  XT - A-ADDR   core:             User-defined Defining Words.
* >code-address  XT - C-ADDR   gforth:   Threading Words.
* >does-code  XT - A-ADDR   gforth:      Threading Words.
* >l  W -   gforth:                      Implementation.
* >r  W -   core:                        Return stack.
* ?DO  COMPILATION - DO-SYS ; RUN-TIME W1 W2 - | LOOP-SYS     core-ext: Arbitrary control structures.
* ?dup  W - W   core:                    Data stack.
* ?DUP-0=-IF  COMPILATION - ORIG ; RUN-TIME N - N|     gforth: Arbitrary control structures.
* ?DUP-IF  COMPILATION - ORIG ; RUN-TIME N - N|     gforth: Arbitrary control structures.
* ?LEAVE  COMPILATION - ; RUN-TIME F | F LOOP-SYS -     gforth: Arbitrary control structures.
* @  A-ADDR - W   core:                  Memory Access.
* @local#  - W   gforth:                 Implementation.
* [']  COMPILATION. "NAME" - ; RUN-TIME. - XT     core: Tokens for Words.
* []  N "NAME" -     oof:                The base class object.
* [bind]  COMPILE-TIME: "CLASS" "SELECTOR" - ; RUN-TIME: ... OBJECT - ...     objects: Objects Glossary.
* [COMP']  COMPILATION "NAME" - ; RUN-TIME - W XT     gforth: Tokens for Words.
* [current]  COMPILE-TIME: "SELECTOR" - ; RUN-TIME: ... OBJECT - ...     objects: Objects Glossary.
* [parent]  COMPILE-TIME: "SELECTOR" - ; RUN-TIME: ... OBJECT - ...     objects: Objects Glossary.
* [to-inst]  COMPILE-TIME: "NAME" - ; RUN-TIME: W -     objects: Objects Glossary.
* abs  N1 - N2   core:                   Single precision.
* ADDRESS-UNIT-BITS  - N     environment: Address arithmetic.
* AGAIN  COMPILATION DEST - ; RUN-TIME -     core-ext: Arbitrary control structures.
* AHEAD  COMPILATION - ORIG ; RUN-TIME -     tools-ext: Arbitrary control structures.
* align  -     core:                     Address arithmetic.
* aligned  C-ADDR - A-ADDR   core:       Address arithmetic.
* and  W1 W2 - W   core:                 Bitwise operations.
* arg  N - ADDR COUNT     gforth:        Modifying the Startup Sequence.
* argc  - ADDR     gforth:               Modifying the Startup Sequence.
* argv  - ADDR     gforth:               Modifying the Startup Sequence.
* asptr  CLASS -     oof:                Class Declaration.
* asptr  O "NAME" -     oof:             The base class object.
* assembler  -     tools-ext:            Assembler and Code Words.
* assert(  -     gforth:                 Assertions.
* assert-level  - A-ADDR     gforth:     Assertions.
* assert0(  -     gforth:                Assertions.
* assert1(  -     gforth:                Assertions.
* assert2(  -     gforth:                Assertions.
* assert3(  -     gforth:                Assertions.
* ASSUME-LIVE  ORIG - ORIG     gforth:   Where are locals visible by name?.
* BEGIN  COMPILATION - DEST ; RUN-TIME -     core: Arbitrary control structures.
* bin  FAM1 - FAM2     file:             Files.
* bind  ... "CLASS" "SELECTOR" - ...     objects: Objects Glossary.
* bind  O "NAME" -     oof:              The base class object.
* bind'  "CLASS" "SELECTOR" - XT     objects: Objects Glossary.
* blank  ADDR LEN -     string:          Memory Blocks.
* block     unknown:                     Blocks.
* block-included  ADDR U -     gforth:   Blocks.
* block-position  U -     block:         Blocks.
* bound  CLASS ADDR "NAME" -     oof:    The base class object.
* buffer  U - A-ADDR     block:          Blocks.
* c!  C C-ADDR -   core:                 Memory Access.
* c@  C-ADDR - C   core:                 Memory Access.
* case  COMPILATION  - CASE-SYS ; RUN-TIME  -     core-ext: Arbitrary control structures.
* catch  ... XT - ... N     exception:   Exception Handling.
* cell  - U     gforth:                  Address arithmetic.
* cell%  - ALIGN SIZE     gforth:        Structure Glossary.
* cell+  A-ADDR1 - A-ADDR2   core:       Address arithmetic.
* cells  N1 - N2   core:                 Address arithmetic.
* cfalign  -     gforth:                 Address arithmetic.
* cfaligned  ADDR1 - ADDR2     gforth:   Address arithmetic.
* char%  - ALIGN SIZE     gforth:        Structure Glossary.
* char+  C-ADDR1 - C-ADDR2   core:       Address arithmetic.
* chars  N1 - N2     core:               Address arithmetic.
* class  "NAME" -     oof:               The base class object.
* class  CLASS - CLASS METHODS VARS     unknown: Mini-OOF Usage.
* class  PARENT-CLASS - ALIGN OFFSET     objects: Objects Glossary.
* class->map  CLASS - MAP     objects:   Objects Glossary.
* class-inst-size  CLASS - ADDR     objects: Objects Glossary.
* class-override!  XT SEL-XT CLASS-MAP -     objects: Objects Glossary.
* class;  -     oof:                     Class Declaration.
* class?  O - FLAG     oof:              The base class object.
* close-file  WFILEID - WIOR   file:     Files.
* cmove  C-FROM C-TO U -   string:       Memory Blocks.
* cmove>  C-FROM C-TO U -   string:      Memory Blocks.
* code  "NAME" - COLON-SYS     tools-ext: Assembler and Code Words.
* code-address!  C-ADDR XT -   gforth:   Threading Words.
* common-list  LIST1 LIST2 - LIST3     gforth-internal: Implementation.
* COMP'  "NAME" - W XT     gforth:       Tokens for Words.
* compilation>  COMPILATION. - ORIG COLON-SYS     gforth: Interpretation and Compilation Semantics.
* compile,  XT -     core-ext:           Tokens for Words.
* compile-@local  N -     gforth:        Implementation.
* compile-f@local  N -     gforth:       Implementation.
* compile-lp+!  N -     gforth:          Implementation.
* compile-only  -     gforth:            Interpretation and Compilation Semantics.
* Constant  W "NAME" -     core:         Simple Defining Words.
* construct  ... OBJECT -     objects:   Objects Glossary.
* Create  "NAME" -     core:             Simple Defining Words.
* create-file  C-ADDR U NTYPE - W2 WIOR   file: Files.
* create-interpret/compile  "NAME" -     gforth: Interpretation and Compilation Semantics.
* CS-PICK  ... U - ... DESTU     tools-ext: Arbitrary control structures.
* CS-ROLL  DESTU/ORIGU .. DEST0/ORIG0 U - .. DEST0/ORIG0 DESTU/ORIGU     tools-ext: Arbitrary control structures.
* current'  "SELECTOR" - XT     objects: Objects Glossary.
* current-interface  - ADDR     objects: Objects Glossary.
* d+  D1 D2 - D   double:                Double precision.
* d-  D1 D2 - D   double:                Double precision.
* dabs  D1 - D2     double:              Double precision.
* Defer  "NAME" -     gforth:            Simple Defining Words.
* defer  -     oof:                      Class Declaration.
* defines  XT CLASS "NAME" -     unknown: Mini-OOF Usage.
* definitions  -     oof:                The base class object.
* delete-file  C-ADDR U - WIOR   file:   Files.
* df!  R DF-ADDR -   float-ext:          Memory Access.
* df@  DF-ADDR - R   float-ext:          Memory Access.
* dfalign  -     float-ext:              Address arithmetic.
* dfaligned  C-ADDR - DF-ADDR   float-ext: Address arithmetic.
* dfloat%  - ALIGN SIZE     gforth:      Structure Glossary.
* dfloat+  DF-ADDR1 - DF-ADDR2     float-ext: Address arithmetic.
* dfloats  N1 - N2   float-ext:          Address arithmetic.
* dict-new  ... CLASS - OBJECT     objects: Objects Glossary.
* dispose  -     oof:                    The base class object.
* dmax  D1 D2 - D     double:            Double precision.
* dmin  D1 D2 - D     double:            Double precision.
* dnegate  D1 - D2   double:             Double precision.
* DO  COMPILATION - DO-SYS ; RUN-TIME W1 W2 - LOOP-SYS     core: Arbitrary control structures.
* docol:  - ADDR     gforth:             Threading Words.
* docon:  - ADDR     gforth:             Threading Words.
* dodefer:  - ADDR     gforth:           Threading Words.
* does-code!  A-ADDR XT -   gforth:      Threading Words.
* does-handler!  A-ADDR -   gforth:      Threading Words.
* DOES>  COMPILATION COLON-SYS1 - COLON-SYS2 ; RUN-TIME NEST-SYS -     core: User-defined Defining Words.
* dofield:  - ADDR     gforth:           Threading Words.
* DONE  COMPILATION ORIG - ; RUN-TIME -     gforth: Arbitrary control structures.
* double%  - ALIGN SIZE     gforth:      Structure Glossary.
* douser:  - ADDR     gforth:            Threading Words.
* dovar:  - ADDR     gforth:             Threading Words.
* drop  W -   core:                      Data stack.
* drop-order  CLASS -     objects:       Objects Glossary.
* dup  W - W W   core:                   Data stack.
* early  -     oof:                      Class Declaration.
* ELSE  COMPILATION ORIG1 - ORIG2 ; RUN-TIME F -     core: Arbitrary control structures.
* emit-file  C WFILEID - WIOR   gforth:  Files.
* empty-buffer  BUFFER -     gforth:     Blocks.
* end-class  ALIGN OFFSET "NAME" -     objects: Objects Glossary.
* end-class  CLASS METHODS VARS -     unknown: Mini-OOF Usage.
* end-class-noname  ALIGN OFFSET - CLASS     objects: Objects Glossary.
* end-code  COLON-SYS -     gforth:      Assembler and Code Words.
* end-interface  "NAME" -     objects:   Objects Glossary.
* end-interface-noname  - INTERFACE     objects: Objects Glossary.
* end-struct  ALIGN SIZE "NAME" -     gforth: Structure Glossary.
* endcase  COMPILATION CASE-SYS - ; RUN-TIME X -     core-ext: Arbitrary control structures.
* ENDIF  COMPILATION ORIG - ; RUN-TIME -     gforth: Arbitrary control structures.
* endof  COMPILATION CASE-SYS1 OF-SYS - CASE-SYS2 ; RUN-TIME  -     core-ext: Arbitrary control structures.
* endscope  COMPILATION SCOPE - ; RUN-TIME  -     gforth: Where are locals visible by name?.
* endwith  -     oof:                    The base class object.
* erase  ADDR LEN -     core-ext:        Memory Blocks.
* execute  XT -   core:                  Tokens for Words.
* EXIT  COMPILATION - ; RUN-TIME NEST-SYS -     core: Calls and returns.
* exitm  -     objects:                  Objects Glossary.
* f!  R F-ADDR -   float:                Memory Access.
* f*  R1 R2 - R3   float:                Floating Point.
* f**  R1 R2 - R3   float-ext:           Floating Point.
* f+  R1 R2 - R3   float:                Floating Point.
* f-  R1 R2 - R3   float:                Floating Point.
* f/  R1 R2 - R3   float:                Floating Point.
* f>l  R -   gforth:                     Implementation.
* f@  F-ADDR - R   float:                Memory Access.
* f@local#  - R   gforth:                Implementation.
* fabs  R1 - R2   float-ext:             Floating Point.
* facos  R1 - R2   float-ext:            Floating Point.
* facosh  R1 - R2   float-ext:           Floating Point.
* falign  -     float:                   Address arithmetic.
* faligned  C-ADDR - F-ADDR   float:     Address arithmetic.
* falog  R1 - R2   float-ext:            Floating Point.
* fasin  R1 - R2   float-ext:            Floating Point.
* fasinh  R1 - R2   float-ext:           Floating Point.
* fatan  R1 - R2   float-ext:            Floating Point.
* fatan2  R1 R2 - R3   float-ext:        Floating Point.
* fatanh  R1 - R2   float-ext:           Floating Point.
* fconstant  R "NAME" -     float:       Simple Defining Words.
* fcos  R1 - R2   float-ext:             Floating Point.
* fcosh  R1 - R2   float-ext:            Floating Point.
* fdrop  R -   float:                    Floating point stack.
* fdup  R - R R   float:                 Floating point stack.
* fexp  R1 - R2   float-ext:             Floating Point.
* fexpm1  R1 - R2   float-ext:           Floating Point.
* field  ALIGN1 OFFSET1 ALIGN SIZE "NAME" -  ALIGN2 OFFSET2     gforth: Structure Glossary.
* file-position  WFILEID - UD WIOR   file: Files.
* file-size  WFILEID - UD WIOR   file:   Files.
* file-status  C-ADDR U - NTYPE WIOR   file-ext: Files.
* fill  C-ADDR U C -   core:             Memory Blocks.
* find-name  C-ADDR U - NT/0     gforth: Tokens for Words.
* fln  R1 - R2   float-ext:              Floating Point.
* flnp1  R1 - R2   float-ext:            Floating Point.
* float  - U     gforth:                 Address arithmetic.
* float%  - ALIGN SIZE     gforth:       Structure Glossary.
* float+  F-ADDR1 - F-ADDR2   float:     Address arithmetic.
* floats  N1 - N2   float:               Address arithmetic.
* flog  R1 - R2   float-ext:             Floating Point.
* floor  R1 - R2   float:                Floating Point.
* flush  -     block:                    Blocks.
* flush-file  WFILEID - WIOR   file-ext: Files.
* flush-icache  C-ADDR U -   gforth:     Assembler and Code Words.
* fm/mod  D1 N1 - N2 N3   core:          Mixed precision.
* fmax  R1 R2 - R3   float:              Floating Point.
* fmin  R1 R2 - R3   float:              Floating Point.
* fnegate  R1 - R2   float:              Floating Point.
* fnip  R1 R2 - R2   gforth:             Floating point stack.
* FOR  COMPILATION - DO-SYS ; RUN-TIME U - LOOP-SYS     gforth: Arbitrary control structures.
* fover  R1 R2 - R1 R2 R1   float:       Floating point stack.
* fp!  F-ADDR -   gforth:                Stack pointer manipulation.
* fp@  - F-ADDR   gforth:                Stack pointer manipulation.
* fpath+  "DIR"     gforth:              Changing the Search Path.
* fpath=  "DIR1|DIR2|DIR3"     gforth:   Changing the Search Path.
* frot  R1 R2 R3 - R2 R3 R1   float:     Floating point stack.
* fround  R1 - R2   float:               Floating Point.
* fsin  R1 - R2   float-ext:             Floating Point.
* fsincos  R1 - R2 R3   float-ext:       Floating Point.
* fsinh  R1 - R2   float-ext:            Floating Point.
* fsqrt  R1 - R2   float-ext:            Floating Point.
* fswap  R1 R2 - R2 R1   float:          Floating point stack.
* ftan  R1 - R2   float-ext:             Floating Point.
* ftanh  R1 - R2   float-ext:            Floating Point.
* ftuck  R1 R2 - R2 R1 R2   gforth:      Floating point stack.
* fvariable  "NAME" -     float:         Simple Defining Words.
* get-block-fid  - FID     gforth:       Blocks.
* get-buffer  N - A-ADDR     gforth:     Blocks.
* heap-new  ... CLASS - OBJECT     objects: Objects Glossary.
* how:  -     oof:                       Class Declaration.
* i  - N   core:                         Counted Loops.
* IF  COMPILATION - ORIG ; RUN-TIME F -     core: Arbitrary control structures.
* immediate  -     core:                 Interpretation and Compilation Semantics.
* implementation  INTERFACE -     objects: Objects Glossary.
* include  ... "FILE" - ...     gforth:  Words for Including.
* include-file  I*X FID - J*X     file:  Words for Including.
* included  I*X ADDR U - J*X     file:   Words for Including.
* init  ... -     oof:                   The base class object.
* init-object  ... CLASS OBJECT -     objects: Objects Glossary.
* inst-value  ALIGN1 OFFSET1 "NAME" - ALIGN2 OFFSET2     objects: Objects Glossary.
* inst-var  ALIGN1 OFFSET1 ALIGN SIZE "NAME" - ALIGN2 OFFSET2     objects: Objects Glossary.
* interface  -     objects:              Objects Glossary.
* interpret/compile:  INTERP-XT COMP-XT "NAME" -     gforth: Interpretation and Compilation Semantics.
* interpretation>  COMPILATION. - ORIG COLON-SYS     gforth: Interpretation and Compilation Semantics.
* invert  W1 - W2   core:                Bitwise operations.
* IS  ADDR "NAME" -     gforth:          Simple Defining Words.
* is  XT "NAME" -     oof:               The base class object.
* j  - N   core:                         Counted Loops.
* k  - N   gforth:                       Counted Loops.
* laddr#  - C-ADDR   gforth:             Implementation.
* lastxt  - XT     gforth <1>:           Tokens for Words.
* lastxt  - XT     gforth:               Supplying names.
* LEAVE  COMPILATION - ; RUN-TIME LOOP-SYS -     core: Arbitrary control structures.
* link  "NAME" - CLASS ADDR     oof:     The base class object.
* list  U -     block:                   Blocks.
* list-size  LIST - U     gforth-internal: Implementation.
* load  I*X N - J*X     block:           Blocks.
* LOOP  COMPILATION DO-SYS - ; RUN-TIME LOOP-SYS1 - | LOOP-SYS2     core: Arbitrary control structures.
* lp!  C-ADDR -   gforth <1>:            Implementation.
* lp!  C-ADDR -   gforth:                Stack pointer manipulation.
* lp+!#  -   gforth:                     Implementation.
* lp@  - ADDR     gforth:                Stack pointer manipulation.
* m*  N1 N2 - D   core:                  Mixed precision.
* m*/  D1 N2 U3 - DQOUT     double:      Mixed precision.
* m+  D1 N - D2   double:                Mixed precision.
* m:  - XT COLON-SYS; RUN-TIME: OBJECT -     objects: Objects Glossary.
* max  N1 N2 - N   core:                 Single precision.
* maxalign  -     float:                 Address arithmetic.
* maxaligned  ADDR - F-ADDR     float:   Address arithmetic.
* method  -     oof:                     Class Declaration.
* method  M V - M' V     unknown:        Mini-OOF Usage.
* method  XT "NAME" -     objects:       Objects Glossary.
* min  N1 N2 - N   core:                 Single precision.
* mod  N1 N2 - N   core:                 Single precision.
* move  C-FROM C-TO UCOUNT -   core:     Memory Blocks.
* nalign  ADDR1 N - ADDR2     gforth:    Structure Glossary.
* name>comp  NT - W XT     gforth:       Tokens for Words.
* name>int  NT - XT     gforth:          Tokens for Words.
* name>string  NT - ADDR COUNT     gforth: Tokens for Words.
* name?int  NT - XT     gforth:          Tokens for Words.
* needs  ... "NAME" - ...     gforth:    Words for Including.
* negate  N1 - N2   core:                Single precision.
* new  - O     oof:                      The base class object.
* new  CLASS - O     unknown:            Mini-OOF Usage.
* new[]  N - O     oof:                  The base class object.
* NEXT  COMPILATION DO-SYS - ; RUN-TIME LOOP-SYS1 - | LOOP-SYS2     gforth: Arbitrary control structures.
* nextname  C-ADDR U -     gforth:       Supplying names.
* nip  W1 W2 - W2   core-ext:            Data stack.
* noname  -     gforth:                  Supplying names.
* object     unknown:                    Mini-OOF Usage.
* object  - CLASS     objects:           Objects Glossary.
* of  COMPILATION  - OF-SYS ; RUN-TIME X1 X2 - |X1     core-ext: Arbitrary control structures.
* open-blocks  ADDR U -     gforth:      Blocks.
* open-file  C-ADDR U NTYPE - W2 WIOR   file: Files.
* open-fpath-file  ADR LEN - FD ADR1 LEN2 0 | IOR     gforth: Changing the Search Path.
* open-path-file  ADR LEN PATH-ADDR - FD ADR1 LEN2 0 | IOR     gforth: General Search Paths.
* or  W1 W2 - W   core:                  Bitwise operations.
* over  W1 W2 - W1 W2 W1   core:         Data stack.
* overrides  XT "SELECTOR" -     objects: Objects Glossary.
* path+  PATH-ADDR  "DIR" -     gforth:  General Search Paths.
* path=  PATH-ADDR "DIR1|DIR2|DIR3"     gforth: General Search Paths.
* pick  U - W   core-ext:                Data stack.
* postpone  "NAME" -     oof:            The base class object.
* postpone,  W XT -     gforth:          Tokens for Words.
* print  OBJECT -     objects:           Objects Glossary.
* printdebugdata  -     gforth:          Debugging.
* printdebugline  ADDR -     gforth:     Debugging.
* protected  -     objects:              Objects Glossary.
* ptr  "NAME" -     oof:                 The base class object.
* ptr  -     oof:                        Class Declaration.
* public  -     objects:                 Objects Glossary.
* push-order  CLASS -     objects:       Objects Glossary.
* r/o  - FAM     file:                   Files.
* r/w  - FAM     file:                   Files.
* r>  - W   core:                        Return stack.
* r@  - W ; R: W - W     core:           Return stack.
* rdrop  -   gforth:                     Return stack.
* read-file  C-ADDR U1 WFILEID - U2 WIOR   file: Files.
* read-line  C-ADDR U1 WFILEID - U2 FLAG WIOR   file: Files.
* recurse  COMPILATION - ; RUN-TIME ?? - ??     core: Calls and returns.
* recursive  COMPILATION - ; RUN-TIME -     gforth: Calls and returns.
* rename-file  C-ADDR1 U1 C-ADDR2 U2 - WIOR   file-ext: Files.
* REPEAT  COMPILATION ORIG DEST - ; RUN-TIME -     core: Arbitrary control structures.
* reposition-file  UD WFILEID - WIOR   file: Files.
* require  ... "FILE" - ...     gforth:  Words for Including.
* required  I*X ADDR U - J*X     gforth: Words for Including.
* resize-file  UD WFILEID - WIOR   file: Files.
* restrict  -     gforth:                Interpretation and Compilation Semantics.
* roll  X0 X1 .. XN N - X1 .. XN X0     core-ext: Data stack.
* rot  W1 W2 W3 - W2 W3 W1   core:       Data stack.
* rp!  A-ADDR -   gforth:                Stack pointer manipulation.
* rp@  - A-ADDR   gforth:                Stack pointer manipulation.
* save-buffer  BUFFER -     gforth:      Blocks.
* savesystem  "NAME" -     gforth:       Non-Relocatable Image Files.
* scope  COMPILATION  - SCOPE ; RUN-TIME  -     gforth: Where are locals visible by name?.
* selector  "NAME" -     objects:        Objects Glossary.
* self  - O     oof:                     The base class object.
* sf!  R SF-ADDR -   float-ext:          Memory Access.
* sf@  SF-ADDR - R   float-ext:          Memory Access.
* sfalign  -     float-ext:              Address arithmetic.
* sfaligned  C-ADDR - SF-ADDR   float-ext: Address arithmetic.
* sfloat%  - ALIGN SIZE     gforth:      Structure Glossary.
* sfloat+  SF-ADDR1 - SF-ADDR2     float-ext: Address arithmetic.
* sfloats  N1 - N2   float-ext:          Address arithmetic.
* sm/rem  D1 N1 - N2 N3   core:          Mixed precision.
* sp!  A-ADDR -   gforth:                Stack pointer manipulation.
* sp@  - A-ADDR   gforth:                Stack pointer manipulation.
* static  -     oof:                     Class Declaration.
* struct  - ALIGN SIZE     gforth:       Structure Glossary.
* sub-list?  LIST1 LIST2 - F     gforth-internal: Implementation.
* super  "NAME" -     oof:               The base class object.
* swap  W1 W2 - W2 W1   core:            Data stack.
* THEN  COMPILATION ORIG - ; RUN-TIME -     core: Arbitrary control structures.
* this  - OBJECT     objects:            Objects Glossary.
* throw  Y1 .. YM ERROR/0 - Y1 .. YM / Z1 .. ZN ERROR     exception: Exception Handling.
* thru  I*X N1 N2 - J*X     block:       Blocks.
* TO  ADDR "NAME" -     core-ext:        Simple Defining Words.
* to-this  OBJECT -     objects:         Objects Glossary.
* tuck  W1 W2 - W2 W1 W2   core-ext:     Data stack.
* U+DO  COMPILATION - DO-SYS ; RUN-TIME U1 U2 - | LOOP-SYS     gforth: Arbitrary control structures.
* U-DO  COMPILATION - DO-SYS ; RUN-TIME U1 U2 - | LOOP-SYS     gforth: Arbitrary control structures.
* um*  U1 U2 - UD   core:                Mixed precision.
* um/mod  UD U1 - U2 U3   core:          Mixed precision.
* unloop  -   core:                      Arbitrary control structures.
* UNREACHABLE  -     gforth:             Where are locals visible by name?.
* UNTIL  COMPILATION DEST - ; RUN-TIME F -     core: Arbitrary control structures.
* update  -     block:                   Blocks.
* updated?  N - F     gforth:            Blocks.
* use  "FILE" -     gforth:              Blocks.
* User  "NAME" -     gforth:             Simple Defining Words.
* Value  W "NAME" -     core-ext:        Simple Defining Words.
* var  M V SIZE - M V'     unknown:      Mini-OOF Usage.
* var  SIZE -     oof:                   Class Declaration.
* Variable  "NAME" -     core:           Simple Defining Words.
* w/o  - FAM     file:                   Files.
* WHILE  COMPILATION DEST - ORIG DEST ; RUN-TIME F -     core: Arbitrary control structures.
* with  O -     oof:                     The base class object.
* write-file  C-ADDR U1 WFILEID - WIOR   file: Files.
* xor  W1 W2 - W   core:                 Bitwise operations.
* xt-new  ... CLASS XT - OBJECT     objects: Objects Glossary.
* ~~  COMPILATION  - ; RUN-TIME  -     gforth: Debugging.

