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: Concept Index,  Prev: Word Index,  Up: Top

Concept and Word Index
**********************

   This index is as incomplete as the manual. Not all entries listed are
present verbatim in the text. Only the names are listed for the words
here.

* Menu:

* !:                                     Memory Access.
* ", stack item type:                    Notation.
* #!:                                    Running Image Files.
* %align:                                Structure Glossary.
* %alignment:                            Structure Glossary.
* %alloc:                                Structure Glossary.
* %allocate:                             Structure Glossary.
* %allot:                                Structure Glossary.
* %size:                                 Structure Glossary.
* ' <1>:                                 Tokens for Words.
* ':                                     The base class object.
* 'cold:                                 Modifying the Startup Sequence.
* (local):                               ANS Forth locals.
* ):                                     Assertions.
* *:                                     Single precision.
* */:                                    Mixed precision.
* */mod:                                 Mixed precision.
* +:                                     Single precision.
* +!:                                    Memory Access.
* +DO:                                   Arbitrary control structures.
* +load:                                 Blocks.
* +LOOP:                                 Arbitrary control structures.
* +thru:                                 Blocks.
* -:                                     Single precision.
* -->:                                   Blocks.
* -clear-dictionary, command-line option: Invoking Gforth.
* -d, command-line option:               Invoking Gforth.
* -data-stack-size, command-line option: Invoking Gforth.
* -DDIRECT_THREADED:                     Direct or Indirect Threaded?.
* -debug, command-line option:           Invoking Gforth.
* -DFORCE_REG:                           Portability.
* -dictionary-size, command-line option: Invoking Gforth.
* -die-on-signal, command-line-option:   Invoking Gforth.
* -DO:                                   Arbitrary control structures.
* -DUSE_FTOS:                            TOS Optimization.
* -DUSE_NO_FTOS:                         TOS Optimization.
* -DUSE_NO_TOS:                          TOS Optimization.
* -DUSE_TOS:                             TOS Optimization.
* -enable-direct-threaded, configuration flag: Direct or Indirect Threaded?.
* -enable-force-reg, configuration flag: Portability.
* -enable-indirect-threaded, configuration flag: Direct or Indirect Threaded?.
* -f, command-line option:               Invoking Gforth.
* -fp-stack-size, command-line option:   Invoking Gforth.
* -h, command-line option:               Invoking Gforth.
* -help, command-line option:            Invoking Gforth.
* -i, command-line option:               Invoking Gforth.
* -i, invoke image file:                 Running Image Files.
* -image file, invoke image file:        Running Image Files.
* -image-file, command-line option:      Invoking Gforth.
* -l, command-line option:               Invoking Gforth.
* -locals-stack-size, command-line option: Invoking Gforth.
* -LOOP:                                 Arbitrary control structures.
* -m, command-line option:               Invoking Gforth.
* -no-offset-im, command-line option:    Invoking Gforth.
* -offset-image, command-line option:    Invoking Gforth.
* -p, command-line option:               Invoking Gforth.
* -path, command-line option:            Invoking Gforth.
* -r, command-line option:               Invoking Gforth.
* -return-stack-size, command-line option: Invoking Gforth.
* -rot:                                  Data stack.
* -v, command-line option:               Invoking Gforth.
* -version, command-line option:         Invoking Gforth.
* .emacs:                                Emacs and Gforth.
* .fi files:                             Image Files.
* .fpath:                                Changing the Search Path.
* .path:                                 General Search Paths.
* /:                                     Single precision.
* /does-handler:                         Threading Words.
* /mod:                                  Single precision.
* 2!:                                    Memory Access.
* 2*:                                    Bitwise operations.
* 2/:                                    Bitwise operations.
* 2>r:                                   Return stack.
* 2@:                                    Memory Access.
* 2Constant:                             Simple Defining Words.
* 2drop:                                 Data stack.
* 2dup:                                  Data stack.
* 2nip:                                  Data stack.
* 2over:                                 Data stack.
* 2r>:                                   Return stack.
* 2r@:                                   Return stack.
* 2rdrop:                                Return stack.
* 2rot:                                  Data stack.
* 2swap:                                 Data stack.
* 2tuck:                                 Data stack.
* 2Variable:                             Simple Defining Words.
* : <1>:                                 The base class object.
* ::                                     Colon Definitions.
* :: <1>:                                Mini-OOF Usage.
* :::                                    The base class object.
* :noname:                               Supplying names.
* ;:                                     Colon Definitions.
* ;code:                                 Assembler and Code Words.
* ;CODE ending sequence:                 programming-idef.
* ;CODE, NAME not defined via CREATE:    programming-ambcond.
* ;CODE, processing input:               programming-idef.
* ;m:                                    Objects Glossary.
* ;m usage:                              Method conveniences.
* ;s:                                    Calls and returns.
* <bind>:                                Objects Glossary.
* <compilation:                          Interpretation and Compilation Semantics.
* <interpretation:                       Interpretation and Compilation Semantics.
* <to-inst>:                             Objects Glossary.
* >body:                                 User-defined Defining Words.
* >BODY of non-CREATEd words:            core-ambcond.
* >code-address:                         Threading Words.
* >does-code:                            Threading Words.
* >IN greater than input buffer:         core-ambcond.
* >l:                                    Implementation.
* >r:                                    Return stack.
* ?DO:                                   Arbitrary control structures.
* ?dup:                                  Data stack.
* ?DUP-0=-IF:                            Arbitrary control structures.
* ?DUP-IF:                               Arbitrary control structures.
* ?LEAVE:                                Arbitrary control structures.
* @:                                     Memory Access.
* @local#:                               Implementation.
* [']:                                   Tokens for Words.
* []:                                    The base class object.
* [bind]:                                Objects Glossary.
* [bind] usage:                          Class Binding.
* [COMP']:                               Tokens for Words.
* [current]:                             Objects Glossary.
* [IF] and POSTPONE:                     programming-ambcond.
* [IF], end of the input source before matching [ELSE] or [THEN]: programming-ambcond.
* [parent]:                              Objects Glossary.
* [parent] usage:                        Class Binding.
* [to-inst]:                             Objects Glossary.
* \, editing with Emacs:                 Emacs and Gforth.
* \, line length in blocks:              block-idef.
* `Forth Programmer's Handbook' (book):  Other Books.
* `Forth: The new model' (book):         Other Books.
* a_, stack item type:                   Notation.
* ABORT", exception abort sequence:      core-idef.
* abs:                                   Single precision.
* abstract class <1>:                    Basic OOF Usage.
* abstract class:                        Basic Objects Usage.
* ACCEPT, display after end of input:    core-idef.
* ACCEPT, editing:                       core-idef.
* Address alignment exception:           core-ambcond.
* Address alignment exception, stack overflow: core-ambcond.
* address arithmetic for structures:     Why explicit structure support?.
* address arithmetic words:              Address arithmetic.
* address unit, size in bits:            core-idef.
* ADDRESS-UNIT-BITS:                     Address arithmetic.
* AGAIN:                                 Arbitrary control structures.
* AHEAD:                                 Arbitrary control structures.
* align:                                 Address arithmetic.
* aligned:                               Address arithmetic.
* aligned addresses:                     core-idef.
* alignment faults:                      core-ambcond.
* alignment of addresses for types:      Address arithmetic.
* also, too many word lists in search order: search-ambcond.
* ambiguous conditions, block words:     block-ambcond.
* ambiguous conditions, core words:      core-ambcond.
* ambiguous conditions, double words:    double-ambcond.
* ambiguous conditions, facility words:  facility-ambcond.
* ambiguous conditions, file words:      file-ambcond.
* ambiguous conditions, floating-point words: floating-ambcond.
* ambiguous conditions, locals words:    locals-ambcond.
* ambiguous conditions, programming-tools words: programming-ambcond.
* ambiguous conditions, search-order words: search-ambcond.
* and:                                   Bitwise operations.
* angles in trigonometric operations:    Floating Point.
* ANS conformance of Gforth:             ANS conformance.
* ANS Forth document:                    Other Books.
* ans-report.fs:                         ANS Report.
* arg:                                   Modifying the Startup Sequence.
* argc:                                  Modifying the Startup Sequence.
* argument input source different than current input source for RESTORE-INPUT: core-ambcond.
* Argument type mismatch:                core-ambcond.
* Argument type mismatch, RESTORE-INPUT: core-ambcond.
* arguments on the command line, access: Modifying the Startup Sequence.
* argv:                                  Modifying the Startup Sequence.
* arithmetic words:                      Arithmetic.
* asptr <1>:                             Class Declaration.
* asptr:                                 The base class object.
* assembler:                             Assembler and Code Words.
* ASSEMBLER, search order capability:    programming-idef.
* assert(:                               Assertions.
* assert-level:                          Assertions.
* assert0(:                              Assertions.
* assert1(:                              Assertions.
* assert2(:                              Assertions.
* assert3(:                              Assertions.
* assertions:                            Assertions.
* ASSUME-LIVE:                           Where are locals visible by name?.
* AT-XY can't be performed on user output device: facility-ambcond.
* Attempt to use zero-length string as a name: core-ambcond.
* authors of Gforth:                     Origin.
* BASE is not decimal (REPRESENT, F., FE., FS.): floating-ambcond.
* basic objects usage:                   Basic Objects Usage.
* batch processing with Gforth:          Invoking Gforth.
* BEGIN:                                 Arbitrary control structures.
* benchmarking Forth systems:            Performance.
* Benchres:                              Performance.
* bin:                                   Files.
* bind <1>:                              The base class object.
* bind:                                  Objects Glossary.
* bind usage:                            Class Binding.
* bind':                                 Objects Glossary.
* bitwise operation words:               Bitwise operations.
* blank:                                 Memory Blocks.
* BLK, altering BLK:                     block-ambcond.
* block:                                 Blocks.
* block number invalid:                  block-ambcond.
* block read not possible:               block-ambcond.
* block transfer, I/O exception:         block-ambcond.
* block words, ambiguous conditions:     block-ambcond.
* block words, implementation-defined options: block-idef.
* block words, other system documentation: block-other.
* block words, system documentation:     The optional Block word set.
* block-included:                        Blocks.
* block-position:                        Blocks.
* blocks in files:                       file-idef.
* book, introductory:                    Other Books.
* books on Forth:                        Other Books.
* bound:                                 The base class object.
* BREAK":                                Singlestep Debugger.
* BREAK::                                Singlestep Debugger.
* buffer:                                Blocks.
* bug reporting:                         Bugs.
* bye during gforthmi:                   gforthmi.
* c!:                                    Memory Access.
* c, stack item type:                    Notation.
* C, using C for the engine:             Portability.
* c@:                                    Memory Access.
* c_, stack item type:                   Notation.
* calling a definition:                  Calls and returns.
* case:                                  Arbitrary control structures.
* CASE control structure:                Selection.
* case insensitivity:                    Notation.
* case sensitivity for name lookup:      core-idef.
* case-sensitivity characteristics:      core-idef.
* catch:                                 Exception Handling.
* catch and this:                        Objects Implementation.
* catch in m: ... ;m:                    Method conveniences.
* cell:                                  Address arithmetic.
* cell size:                             core-idef.
* cell%:                                 Structure Glossary.
* cell+:                                 Address arithmetic.
* cell-aligned addresses:                core-idef.
* cells:                                 Address arithmetic.
* CFA:                                   Tokens for Words.
* cfalign:                               Address arithmetic.
* cfaligned:                             Address arithmetic.
* changing the compilation wordlist (during compilation): search-ambcond.
* char size:                             core-idef.
* char%:                                 Structure Glossary.
* char+:                                 Address arithmetic.
* character editing of ACCEPT and EXPECT: core-idef.
* character set:                         core-idef.
* character-aligned address requirements: core-idef.
* character-set extensions and matching of names: core-idef.
* chars:                                 Address arithmetic.
* child class:                           Object-Oriented Terminology.
* class <1>:                             Mini-OOF Usage.
* class <2>:                             The base class object.
* class <3>:                             Objects Glossary.
* class:                                 Object-Oriented Terminology.
* class binding:                         Class Binding.
* class binding as optimization:         Class Binding.
* class binding, alternative to:         Class Binding.
* class binding, implementation:         Objects Implementation.
* class declaration:                     Class Declaration.
* class definition, restrictions <1>:    Basic OOF Usage.
* class definition, restrictions:        Basic Objects Usage.
* class implementation:                  Class Implementation.
* class implementation and representation: Objects Implementation.
* class scoping implementation:          Objects Implementation.
* class usage <1>:                       Basic OOF Usage.
* class usage:                           Basic Objects Usage.
* class->map:                            Objects Glossary.
* class-inst-size:                       Objects Glossary.
* class-inst-size discussion:            Creating objects.
* class-override!:                       Objects Glossary.
* class;:                                Class Declaration.
* class; usage:                          Basic OOF Usage.
* class?:                                The base class object.
* classes and scoping:                   Classes and Scoping.
* clock tick duration:                   facility-idef.
* close-file:                            Files.
* cmove:                                 Memory Blocks.
* cmove>:                                Memory Blocks.
* code:                                  Assembler and Code Words.
* code address:                          Threading Words.
* CODE ending sequence:                  programming-idef.
* code field address:                    Tokens for Words.
* code words:                            Assembler and Code Words.
* code words, portable:                  Assembler and Code Words.
* CODE, processing input:                programming-idef.
* code-address!:                         Threading Words.
* colon definitions:                     Colon Definitions.
* command-line arguments, access:        Modifying the Startup Sequence.
* command-line options:                  Invoking Gforth.
* comment editing commands:              Emacs and Gforth.
* common-list:                           Implementation.
* COMP':                                 Tokens for Words.
* comp-i.fs:                             gforthmi.
* comparison of object models:           Comparison with other object models.
* compilation semantics:                 Interpretation and Compilation Semantics.
* compilation token:                     Tokens for Words.
* compilation wordlist, change before definition ends: search-ambcond.
* compilation>:                          Interpretation and Compilation Semantics.
* compile,:                              Tokens for Words.
* compile-@local:                        Implementation.
* compile-f@local:                       Implementation.
* compile-lp+!:                          Implementation.
* compile-only:                          Interpretation and Compilation Semantics.
* compile-only words:                    Interpretation and Compilation Semantics.
* Conklin, Edward K., and Elizabeth Rather: `Forth Programmer's Handbook': Other Books.
* Constant:                              Simple Defining Words.
* construct:                             Objects Glossary.
* construct discussion:                  Creating objects.
* contributors to Gforth:                Origin.
* control characters as delimiters:      core-idef.
* control flow stack, format:            core-idef.
* control structures:                    Control Structures.
* control structures for selection:      Selection.
* control structures, user-defined:      Arbitrary control structures.
* control-flow stack:                    Arbitrary control structures.
* control-flow stack items, locals information: Implementation.
* control-flow stack underflow:          programming-ambcond.
* core words, ambiguous conditions:      core-ambcond.
* core words, implementation-defined options: core-idef.
* core words, other system documentation: core-other.
* core words, system documentation:      The Core Words.
* counted loops:                         Counted Loops.
* counted loops with negative increment: Counted Loops.
* counted string, maximum size:          core-idef.
* Create:                                Simple Defining Words.
* CREATE ... DOES>:                      User-defined Defining Words.
* CREATE ... DOES>, applications:        User-defined Defining Words.
* CREATE ... DOES>, details:             User-defined Defining Words.
* CREATE and alignment:                  Address arithmetic.
* create-file:                           Files.
* create-interpret/compile:              Interpretation and Compilation Semantics.
* creating objects:                      Creating objects.
* cross-compiler:                        cross.fs.
* cross.fs:                              cross.fs.
* CS-PICK:                               Arbitrary control structures.
* CS-PICK, fewer than U+1 items on the control flow stack: programming-ambcond.
* CS-ROLL:                               Arbitrary control structures.
* CS-ROLL, fewer than U+1 items on the control flow stack: programming-ambcond.
* current':                              Objects Glossary.
* current-interface:                     Objects Glossary.
* current-interface discussion:          Objects Implementation.
* currying:                              User-defined Defining Words.
* d+:                                    Double precision.
* d, stack item type:                    Notation.
* d-:                                    Double precision.
* D>F, D cannot be presented precisely as a float: floating-ambcond.
* D>S, D out of range of N:              double-ambcond.
* dabs:                                  Double precision.
* data space available:                  core-other.
* data space containing definitions gets de-allocated: core-ambcond.
* data space pointer not properly aligned, ,, C,: core-ambcond.
* data space read/write with incorrect alignment: core-ambcond.
* data stack manipulation words:         Data stack.
* data-relocatable image files:          Data-Relocatable Image Files.
* data-space, read-only regions:         core-idef.
* dbg:                                   Singlestep Debugger.
* debug tracer editing commands:         Emacs and Gforth.
* debugging:                             Debugging.
* debugging output, finding the source location in Emacs: Emacs and Gforth.
* debugging Singlestep:                  Singlestep Debugger.
* default type of locals:                Gforth locals.
* defer:                                 Class Declaration.
* Defer:                                 Simple Defining Words.
* defines:                               Mini-OOF Usage.
* defining words:                        Defining Words.
* defining words with arbitrary semantics combinations: Interpretation and Compilation Semantics.
* defining words without name:           Supplying names.
* defining words, name given in a string: Supplying names.
* defining words, name parameter:        Supplying names.
* defining words, simple:                Simple Defining Words.
* defining words, user-defined:          User-defined Defining Words.
* definitions:                           The base class object.
* delete-file:                           Files.
* dest, control-flow stack item:         Arbitrary control structures.
* df!:                                   Memory Access.
* df@:                                   Memory Access.
* df@ or df! used with an address that is not double-float  aligned: floating-ambcond.
* df_, stack item type:                  Notation.
* dfalign:                               Address arithmetic.
* dfaligned:                             Address arithmetic.
* dfloat%:                               Structure Glossary.
* dfloat+:                               Address arithmetic.
* dfloats:                               Address arithmetic.
* dict-new:                              Objects Glossary.
* dict-new discussion:                   Creating objects.
* dictionary in persistent form:         Image Files.
* dictionary overflow:                   core-ambcond.
* dictionary size default:               Stack and Dictionary Sizes.
* digits > 35:                           core-idef.
* direct threaded inner interpreter:     Threading.
* dispose:                               The base class object.
* divide by zero:                        core-ambcond.
* dividing by zero:                      core-ambcond.
* dividing by zero, floating-point:      floating-ambcond.
* division rounding:                     core-idef.
* division with potentially negative operands: Arithmetic.
* dmax:                                  Double precision.
* dmin:                                  Double precision.
* dnegate:                               Double precision.
* DO:                                    Arbitrary control structures.
* DO loops:                              Counted Loops.
* docol::                                Threading Words.
* docon::                                Threading Words.
* dodefer::                              Threading Words.
* dodoes routine:                        DOES>.
* DOES-code:                             DOES>.
* does-code!:                            Threading Words.
* DOES-handler:                          DOES>.
* does-handler!:                         Threading Words.
* DOES>:                                 User-defined Defining Words.
* DOES> implementation:                  DOES>.
* DOES> in a separate definition:        User-defined Defining Words.
* DOES> in interpretation state:         User-defined Defining Words.
* DOES> of non-CREATEd words:            core-ambcond.
* DOES>, visibility of current definition: core-idef.
* DOES>-parts, stack effect:             User-defined Defining Words.
* dofield::                              Threading Words.
* DONE:                                  Arbitrary control structures.
* double precision arithmetic words:     Double precision.
* double words, ambiguous conditions:    double-ambcond.
* double words, system documentation:    The optional Double Number word set.
* double%:                               Structure Glossary.
* double-cell numbers, input format:     Double precision.
* doubly indirect threaded code:         gforthmi.
* douser::                               Threading Words.
* dovar::                                Threading Words.
* drop:                                  Data stack.
* drop-order:                            Objects Glossary.
* dup:                                   Data stack.
* duration of a system clock tick:       facility-idef.
* early:                                 Class Declaration.
* early binding:                         Class Binding.
* editing in ACCEPT and EXPECT:          core-idef.
* eforth performance:                    Performance.
* EKEY, encoding of keyboard events:     facility-idef.
* ELSE:                                  Arbitrary control structures.
* Emacs and Gforth:                      Emacs and Gforth.
* EMIT and non-graphic characters:       core-idef.
* emit-file:                             Files.
* empty-buffer:                          Blocks.
* end-class <1>:                         Mini-OOF Usage.
* end-class:                             Objects Glossary.
* end-class usage:                       Basic Objects Usage.
* end-class-noname:                      Objects Glossary.
* end-code:                              Assembler and Code Words.
* end-interface:                         Objects Glossary.
* end-interface usage:                   Object Interfaces.
* end-interface-noname:                  Objects Glossary.
* end-struct:                            Structure Glossary.
* end-struct usage:                      Structure Usage.
* endcase:                               Arbitrary control structures.
* ENDIF:                                 Arbitrary control structures.
* endless loop:                          Simple Loops.
* endof:                                 Arbitrary control structures.
* endscope:                              Where are locals visible by name?.
* endwith:                               The base class object.
* engine:                                Engine.
* engine performance:                    Performance.
* engine portability:                    Portability.
* engine.s:                              Produced code.
* environment variable GFORTHD:          gforthmi.
* ENVIRONMENT? string length, maximum:   core-idef.
* erase:                                 Memory Blocks.
* error output, finding the source location in Emacs: Emacs and Gforth.
* etags.fs:                              Emacs and Gforth.
* exception abort sequence of ABORT":    core-idef.
* exception when including source:       file-idef.
* exception words, implementation-defined options: exception-idef.
* exception words, system documentation: The optional Exception word set.
* Exceptions:                            Exception Handling.
* executable image file:                 Running Image Files.
* execute:                               Tokens for Words.
* executing code on startup:             Invoking Gforth.
* execution semantics:                   Interpretation and Compilation Semantics.
* execution token:                       Tokens for Words.
* execution token of last defined word:  Supplying names.
* execution token of words with undefined execution semantics: core-ambcond.
* EXIT:                                  Calls and returns.
* exit in m: ... ;m:                     Method conveniences.
* exitm:                                 Objects Glossary.
* exitm discussion:                      Method conveniences.
* EXPECT, display after end of input:    core-idef.
* EXPECT, editing:                       core-idef.
* explicit register declarations:        Portability.
* exponent too big for conversion (DF!, DF@, SF!, SF@): floating-ambcond.
* extended records:                      Structure Usage.
* f!:                                    Memory Access.
* f! used with an address that is not float aligned: floating-ambcond.
* f*:                                    Floating Point.
* f**:                                   Floating Point.
* f+:                                    Floating Point.
* f, stack item type:                    Notation.
* f-:                                    Floating Point.
* f/:                                    Floating Point.
* f83name, stack item type:              Notation.
* F>D, integer part of float cannot be represented by D: floating-ambcond.
* f>l:                                   Implementation.
* f@:                                    Memory Access.
* f@ used with an address that is not float aligned: floating-ambcond.
* f@local#:                              Implementation.
* f_, stack item type:                   Notation.
* fabs:                                  Floating Point.
* facility words, ambiguous conditions:  facility-ambcond.
* facility words, implementation-defined options: facility-idef.
* facility words, system documentation:  The optional Facility word set.
* facos:                                 Floating Point.
* FACOS, |FLOAT|>1:                      floating-ambcond.
* facosh:                                Floating Point.
* FACOSH, FLOAT<1:                       floating-ambcond.
* factoring similar colon definitions:   User-defined Defining Words.
* falign:                                Address arithmetic.
* faligned:                              Address arithmetic.
* falog:                                 Floating Point.
* fasin:                                 Floating Point.
* FASIN, |FLOAT|>1:                      floating-ambcond.
* fasinh:                                Floating Point.
* FASINH, FLOAT<0:                       floating-ambcond.
* fatan:                                 Floating Point.
* fatan2:                                Floating Point.
* FATAN2, both arguments are equal to zero: floating-ambcond.
* fatanh:                                Floating Point.
* FATANH, |FLOAT|>1:                     floating-ambcond.
* fconstant:                             Simple Defining Words.
* fcos:                                  Floating Point.
* fcosh:                                 Floating Point.
* fdrop:                                 Floating point stack.
* fdup:                                  Floating point stack.
* fexp:                                  Floating Point.
* fexpm1:                                Floating Point.
* field:                                 Structure Glossary.
* field naming convention:               Structure Naming Convention.
* field usage:                           Structure Usage.
* field usage in class definition:       Basic Objects Usage.
* file access methods used:              file-idef.
* file exceptions:                       file-idef.
* file input nesting, maximum depth:     file-idef.
* file line terminator:                  file-idef.
* file name format:                      file-idef.
* file search path:                      Search Path.
* file words, ambiguous conditions:      file-ambcond.
* file words, implementation-defined options: file-idef.
* file words, system documentation:      The optional File-Access word set.
* file-position:                         Files.
* file-size:                             Files.
* file-status:                           Files.
* FILE-STATUS, returned information:     file-idef.
* files containing blocks:               file-idef.
* fill:                                  Memory Blocks.
* find-name:                             Tokens for Words.
* first field optimization:              Structure Usage.
* first field optimization, implementation: Structure Implementation.
* flags on the command line:             Invoking Gforth.
* flavours of locals:                    Gforth locals.
* fln:                                   Floating Point.
* FLN, FLOAT=<0:                         floating-ambcond.
* flnp1:                                 Floating Point.
* FLNP1, FLOAT=<-1:                      floating-ambcond.
* float:                                 Address arithmetic.
* float%:                                Structure Glossary.
* float+:                                Address arithmetic.
* floating point arithmetic words:       Floating Point.
* floating point numbers, format and range: floating-idef.
* floating point unidentified fault, integer division: core-ambcond.
* floating-point arithmetic, pitfalls:   Floating Point.
* floating-point dividing by zero:       floating-ambcond.
* floating-point numbers, input format:  Floating Point.
* floating-point numbers, rounding or truncation: floating-idef.
* floating-point result out of range:    floating-ambcond.
* floating-point stack in the standard:  Stack Manipulation.
* floating-point stack manipulation words: Floating point stack.
* floating-point stack size:             floating-idef.
* floating-point stack width:            floating-idef.
* floating-point unidentified fault, F>D: floating-ambcond.
* floating-point unidentified fault, FACOS, FASIN or FATANH: floating-ambcond.
* floating-point unidentified fault, FACOSH: floating-ambcond.
* floating-point unidentified fault, FASINH or FSQRT: floating-ambcond.
* floating-point unidentified fault, FLN or FLOG: floating-ambcond.
* floating-point unidentified fault, FLNP1: floating-ambcond.
* floating-point unidentified fault, FP divide-by-zero: floating-ambcond.
* floating-point words, ambiguous conditions: floating-ambcond.
* floating-point words, implementation-defined options: floating-idef.
* floating-point words, system documentation: The optional Floating-Point word set.
* floats:                                Address arithmetic.
* flog:                                  Floating Point.
* FLOG, FLOAT=<0:                        floating-ambcond.
* floor:                                 Floating Point.
* flush:                                 Blocks.
* flush-file:                            Files.
* flush-icache:                          Assembler and Code Words.
* fm/mod:                                Mixed precision.
* fmax:                                  Floating Point.
* fmin:                                  Floating Point.
* fnegate:                               Floating Point.
* fnip:                                  Floating point stack.
* FOR:                                   Arbitrary control structures.
* FOR loops:                             Counted Loops.
* FORGET, deleting the compilation wordlist: programming-ambcond.
* FORGET, NAME can't be found:           programming-ambcond.
* FORGET, removing a needed definition:  programming-ambcond.
* format and range of floating point numbers: floating-idef.
* format of glossary entries:            Notation.
* Forth mode in Emacs:                   Emacs and Gforth.
* forth.el:                              Emacs and Gforth.
* fover:                                 Floating point stack.
* fp!:                                   Stack pointer manipulation.
* fp@:                                   Stack pointer manipulation.
* fpath+:                                Changing the Search Path.
* fpath=:                                Changing the Search Path.
* frot:                                  Floating point stack.
* fround:                                Floating Point.
* fsin:                                  Floating Point.
* fsincos:                               Floating Point.
* fsinh:                                 Floating Point.
* fsqrt:                                 Floating Point.
* FSQRT, FLOAT<0:                        floating-ambcond.
* fswap:                                 Floating point stack.
* ftan:                                  Floating Point.
* FTAN on an argument R1 where cos(R1) is zero: floating-ambcond.
* ftanh:                                 Floating Point.
* ftuck:                                 Floating point stack.
* fully relocatable image files:         Fully Relocatable Image Files.
* fvariable:                             Simple Defining Words.
* get-block-fid:                         Blocks.
* get-buffer:                            Blocks.
* Gforth locals:                         Gforth locals.
* Gforth performance:                    Performance.
* gforth-ditc:                           gforthmi.
* gforth.el:                             Emacs and Gforth.
* gforth.fi, relocatability:             Fully Relocatable Image Files.
* GFORTHD environment variable:          gforthmi.
* gforthmi:                              gforthmi.
* glossary notation format:              Notation.
* GNU C for the engine:                  Portability.
* Goals:                                 Goals.
* heap-new:                              Objects Glossary.
* heap-new discussion:                   Creating objects.
* heap-new usage:                        Basic Objects Usage.
* how::                                  Class Declaration.
* i:                                     Counted Loops.
* I/O exception in block transfer:       block-ambcond.
* IF:                                    Arbitrary control structures.
* IF control structure:                  Selection.
* image file background:                 Image File Background.
* image file initialization sequence:    Modifying the Startup Sequence.
* image file invocation:                 Running Image Files.
* image file loader:                     Image File Background.
* image file, stack and dictionary sizes: Stack and Dictionary Sizes.
* image files:                           Image Files.
* image files, data-relocatable:         Data-Relocatable Image Files.
* image files, executable:               Running Image Files.
* image files, fully relocatable:        Fully Relocatable Image Files.
* image files, non-relocatable:          Non-Relocatable Image Files.
* image files, turnkey applications:     Modifying the Startup Sequence.
* image license:                         Image Licensing Issues.
* immediate:                             Interpretation and Compilation Semantics.
* immediate words:                       Interpretation and Compilation Semantics.
* implementation:                        Objects Glossary.
* implementation of locals:              Implementation.
* implementation of structures:          Structure Implementation.
* implementation usage:                  Object Interfaces.
* implementation-defined options, block words: block-idef.
* implementation-defined options, core words: core-idef.
* implementation-defined options, exception words: exception-idef.
* implementation-defined options, facility words: facility-idef.
* implementation-defined options, file words: file-idef.
* implementation-defined options, floating-point words: floating-idef.
* implementation-defined options, locals words: locals-idef.
* implementation-defined options, memory-allocation words: memory-idef.
* implementation-defined options, programming-tools words: programming-idef.
* implementation-defined options, search-order words: search-idef.
* include:                               Words for Including.
* include search path:                   Search Path.
* include-file:                          Words for Including.
* INCLUDE-FILE, FILE-ID is invalid:      file-ambcond.
* INCLUDE-FILE, I/O exception reading or closing FILE-ID: file-ambcond.
* included:                              Words for Including.
* INCLUDED, I/O exception reading or closing FILE-ID: file-ambcond.
* INCLUDED, named file cannot be opened: file-ambcond.
* including files:                       Including Files.
* including files, stack effect:         Words for Including.
* indirect threaded inner interpreter:   Threading.
* inheritance:                           Object-Oriented Terminology.
* init:                                  The base class object.
* init-object:                           Objects Glossary.
* init-object discussion:                Creating objects.
* initialization sequence of image file: Modifying the Startup Sequence.
* inner interpreter implementation:      Threading.
* inner interpreter optimization:        Scheduling.
* inner interpreter, direct threaded:    Threading.
* inner interpreter, indirect threaded:  Threading.
* input format for double-cell numbers:  Double precision.
* input format for floating-point numbers: Floating Point.
* input line size, maximum:              file-idef.
* input line terminator:                 core-idef.
* inst-value:                            Objects Glossary.
* inst-value usage:                      Method conveniences.
* inst-value visibility:                 Classes and Scoping.
* inst-var:                              Objects Glossary.
* inst-var implementation:               Objects Implementation.
* inst-var usage:                        Method conveniences.
* inst-var visibility:                   Classes and Scoping.
* instance variables:                    Object-Oriented Terminology.
* instruction pointer:                   Threading.
* insufficient data stack or return stack space: core-ambcond.
* insufficient space for loop control parameters: core-ambcond.
* insufficient space in the dictionary:  core-ambcond.
* integer types, ranges:                 core-idef.
* interface:                             Objects Glossary.
* interface implementation:              Objects Implementation.
* interface usage:                       Object Interfaces.
* interfaces for objects:                Object Interfaces.
* interpret/compile::                    Interpretation and Compilation Semantics.
* interpretation semantics:              Interpretation and Compilation Semantics.
* interpretation>:                       Interpretation and Compilation Semantics.
* Interpreting a compile-only word:      core-ambcond.
* Interpreting a compile-only word, for ' etc.: core-ambcond.
* Interpreting a compile-only word, for a local: locals-ambcond.
* interpreting a word with undefined interpretation semantics: core-ambcond.
* introductory book:                     Other Books.
* invalid block number:                  block-ambcond.
* Invalid memory address:                core-ambcond.
* Invalid memory address, stack overflow: core-ambcond.
* Invalid name argument, TO <1>:         locals-ambcond.
* Invalid name argument, TO:             core-ambcond.
* invert:                                Bitwise operations.
* invoking a selector:                   Object-Oriented Terminology.
* invoking Gforth:                       Invoking Gforth.
* invoking image files:                  Running Image Files.
* IOR values and meaning <1>:            memory-idef.
* IOR values and meaning:                file-idef.
* is:                                    The base class object.
* IS:                                    Simple Defining Words.
* j:                                     Counted Loops.
* k:                                     Counted Loops.
* kern*.fi, relocatability:              Fully Relocatable Image Files.
* keyboard events, encoding in EKEY:     facility-idef.
* labels as values:                      Threading.
* laddr#:                                Implementation.
* last word was headerless:              core-ambcond.
* lastxt <1>:                            Tokens for Words.
* lastxt:                                Supplying names.
* late binding:                          Class Binding.
* LEAVE:                                 Arbitrary control structures.
* length of a line affected by \:        block-idef.
* license for images:                    Image Licensing Issues.
* lifetime of locals:                    How long do locals live?.
* line terminator on input:              core-idef.
* link:                                  The base class object.
* list:                                  Blocks.
* LIST display format:                   block-idef.
* list-size:                             Implementation.
* load:                                  Blocks.
* loader for image files:                Image File Background.
* loading files at startup:              Invoking Gforth.
* local in interpretation state:         locals-ambcond.
* locale and case sensitivity:           core-idef.
* locals:                                Locals.
* locals and return stack:               Stack Manipulation.
* locals flavours:                       Gforth locals.
* locals implementation:                 Implementation.
* locals information on the control-flow stack: Implementation.
* locals lifetime:                       How long do locals live?.
* locals programming style:              Programming Style.
* locals stack:                          Implementation.
* locals types:                          Gforth locals.
* locals visibility:                     Where are locals visible by name?.
* locals words, ambiguous conditions:    locals-ambcond.
* locals words, implementation-defined options: locals-idef.
* locals words, system documentation:    The optional Locals word set.
* locals, ANS Forth style:               ANS Forth locals.
* locals, default type:                  Gforth locals.
* locals, Gforth style:                  Gforth locals.
* locals, maximum number in a definition: locals-idef.
* long long:                             Portability.
* LOOP:                                  Arbitrary control structures.
* loop control parameters not available: core-ambcond.
* loops without count:                   Simple Loops.
* loops, counted:                        Counted Loops.
* loops, endless:                        Simple Loops.
* lp! <1>:                               Implementation.
* lp!:                                   Stack pointer manipulation.
* lp+!#:                                 Implementation.
* lp@:                                   Stack pointer manipulation.
* LSHIFT, large shift counts:            core-ambcond.
* m*:                                    Mixed precision.
* m*/:                                   Mixed precision.
* m+:                                    Mixed precision.
* m::                                    Objects Glossary.
* m: usage:                              Method conveniences.
* mapping block ranges to files:         file-idef.
* max:                                   Single precision.
* maxalign:                              Address arithmetic.
* maxaligned:                            Address arithmetic.
* maximum depth of file input nesting:   file-idef.
* maximum number of locals in a definition: locals-idef.
* maximum number of word lists in search order: search-idef.
* maximum size of a counted string:      core-idef.
* maximum size of a definition name, in characters: core-idef.
* maximum size of a parsed string:       core-idef.
* maximum size of input line:            file-idef.
* maximum string length for ENVIRONMENT?, in characters: core-idef.
* memory access words:                   Memory Access.
* memory block words:                    Memory Blocks.
* Memory words:                          Memory.
* memory-allocation words, implementation-defined options: memory-idef.
* memory-allocation words, system documentation: The optional Memory-Allocation word set.
* message send:                          Object-Oriented Terminology.
* metacompiler:                          cross.fs.
* method <1>:                            Mini-OOF Usage.
* method <2>:                            Class Declaration.
* method <3>:                            Objects Glossary.
* method:                                Object-Oriented Terminology.
* method conveniences:                   Method conveniences.
* method map:                            Objects Implementation.
* method selector:                       Object-Oriented Terminology.
* method usage:                          Basic OOF Usage.
* min:                                   Single precision.
* mini-oof:                              Mini-OOF.
* mini-oof example:                      Mini-OOF Example.
* mini-oof usage:                        Mini-OOF Usage.
* mini-oof.fs, differences to other models: Comparison with other object models.
* minimum search order:                  search-idef.
* mixed precision arithmetic words:      Mixed precision.
* mod:                                   Single precision.
* modifying the contents of the input buffer or a string literal: core-ambcond.
* most recent definition does not have a name (IMMEDIATE): core-ambcond.
* motivation for object-oriented programming: Why object-oriented programming?.
* move:                                  Memory Blocks.
* MS, repeatability to be expected:      facility-idef.
* n, stack item type:                    Notation.
* nalign:                                Structure Glossary.
* name field address:                    Tokens for Words.
* name lookup, case sensitivity:         core-idef.
* name not defined by VALUE or (LOCAL) used by TO: locals-ambcond.
* name not defined by VALUE used by TO:  core-ambcond.
* name not found:                        core-ambcond.
* name not found (', POSTPONE, ['], [COMPILE]): core-ambcond.
* name token:                            Tokens for Words.
* name, maximum length:                  core-idef.
* name>comp:                             Tokens for Words.
* name>int:                              Tokens for Words.
* name>string:                           Tokens for Words.
* name?int:                              Tokens for Words.
* names for defined words:               Supplying names.
* needs:                                 Words for Including.
* negate:                                Single precision.
* negative increment for counted loops:  Counted Loops.
* Neon model:                            Comparison with other object models.
* new <1>:                               Mini-OOF Usage.
* new:                                   The base class object.
* new[]:                                 The base class object.
* newline charcter on input:             core-idef.
* NEXT:                                  Arbitrary control structures.
* NEXT, direct threaded:                 Threading.
* NEXT, indirect threaded:               Threading.
* nextname:                              Supplying names.
* NFA:                                   Tokens for Words.
* nip:                                   Data stack.
* non-graphic characters and EMIT:       core-idef.
* non-relocatable image files:           Non-Relocatable Image Files.
* noname:                                Supplying names.
* notation of glossary entries:          Notation.
* NT Forth performance:                  Performance.
* number of bits in one address unit:    core-idef.
* number representation and arithmetic:  core-idef.
* object <1>:                            Mini-OOF Usage.
* object <2>:                            Objects Glossary.
* object:                                Object-Oriented Terminology.
* object allocation options:             Creating objects.
* object class:                          The class Object.
* object creation:                       Creating objects.
* object interfaces:                     Object Interfaces.
* object models, comparison:             Comparison with other object models.
* object-map discussion:                 Objects Implementation.
* object-oriented programming <1>:       OOF.
* object-oriented programming:           Objects.
* object-oriented programming motivation: Why object-oriented programming?.
* object-oriented programming style:     Object-Oriented Programming Style.
* object-oriented terminology:           Object-Oriented Terminology.
* objects:                               Objects.
* objects, basic usage:                  Basic Objects Usage.
* objects.fs <1>:                        OOF.
* objects.fs:                            Objects.
* objects.fs Glossary:                   Objects Glossary.
* objects.fs implementation:             Objects Implementation.
* objects.fs properties:                 Properties of the Objects model.
* of:                                    Arbitrary control structures.
* oof:                                   OOF.
* oof.fs <1>:                            OOF.
* oof.fs:                                Objects.
* oof.fs base class:                     The base class object.
* oof.fs properties:                     Properties of the OOF model.
* oof.fs usage:                          Basic OOF Usage.
* oof.fs, differences to other models:   Comparison with other object models.
* open-blocks:                           Blocks.
* open-file:                             Files.
* open-fpath-file:                       Changing the Search Path.
* open-path-file:                        General Search Paths.
* operator's terminal facilities available: core-other.
* options on the command line:           Invoking Gforth.
* or:                                    Bitwise operations.
* orig, control-flow stack item:         Arbitrary control structures.
* other system documentation, block words: block-other.
* other system documentation, core words: core-other.
* over:                                  Data stack.
* overflow of the pictured numeric output string: core-ambcond.
* overrides:                             Objects Glossary.
* overrides usage:                       Basic Objects Usage.
* PAD size:                              core-idef.
* PAD use by nonstandard words:          core-other.
* parameters are not of the same type (DO, ?DO, WITHIN): core-ambcond.
* parent class:                          Object-Oriented Terminology.
* parent class binding:                  Class Binding.
* parsed string overflow:                core-ambcond.
* parsed string, maximum size:           core-idef.
* path for included:                     Search Path.
* path+:                                 General Search Paths.
* path=:                                 General Search Paths.
* Pedigree of Gforth:                    Origin.
* performance of some Forth interpreters: Performance.
* persistent form of dictionary:         Image Files.
* PFE performance:                       Performance.
* pick:                                  Data stack.
* pictured numeric output buffer, size:  core-idef.
* pictured numeric output string, overflow: core-ambcond.
* postpone:                              The base class object.
* POSTPONE applied to [IF]:              programming-ambcond.
* POSTPONE or [COMPILE] applied to TO:   core-ambcond.
* postpone,:                             Tokens for Words.
* Pountain's object-oriented model:      Comparison with other object models.
* precompiled Forth code:                Image Files.
* previous, search order empty:          search-ambcond.
* primitive source format:               Automatic Generation.
* primitives, assembly code listing:     Produced code.
* primitives, automatic generation:      Automatic Generation.
* primitives, implementation:            Primitives.
* primitives, keeping the TOS in a register: TOS Optimization.
* prims2x.fs:                            Automatic Generation.
* print:                                 Objects Glossary.
* printdebugdata:                        Debugging.
* printdebugline:                        Debugging.
* private discussion:                    Classes and Scoping.
* program data space available:          core-other.
* programming style, locals:             Programming Style.
* programming tools:                     Programming Tools.
* programming-tools words, ambiguous conditions: programming-ambcond.
* programming-tools words, implementation-defined options: programming-idef.
* programming-tools words, system documentation: The optional Programming-Tools word set.
* prompt:                                core-idef.
* pronounciation of words:               Notation.
* protected:                             Objects Glossary.
* protected discussion:                  Classes and Scoping.
* ptr <1>:                               Class Declaration.
* ptr:                                   The base class object.
* public:                                Objects Glossary.
* push-order:                            Objects Glossary.
* r, stack item type:                    Notation.
* r/o:                                   Files.
* r/w:                                   Files.
* r>:                                    Return stack.
* r@:                                    Return stack.
* ranges for integer types:              core-idef.
* Rather, Elizabeth and Edward K. Conklin: `Forth Programmer's Handbook': Other Books.
* rdrop:                                 Return stack.
* read-file:                             Files.
* read-line:                             Files.
* read-only data space regions:          core-idef.
* reading from file positions not yet written: file-ambcond.
* receiving object:                      Object-Oriented Terminology.
* records:                               Structures.
* recurse:                               Calls and returns.
* RECURSE appears after DOES>:           core-ambcond.
* recursive:                             Calls and returns.
* recursive definitions:                 Calls and returns.
* registers of the inner interpreter:    Assembler and Code Words.
* relocating loader:                     Image File Background.
* relocation at load-time:               Image File Background.
* relocation at run-time:                Image File Background.
* rename-file:                           Files.
* REPEAT:                                Arbitrary control structures.
* repeatability to be expected from the execution of MS: facility-idef.
* report the words used in your program: ANS Report.
* reposition-file:                       Files.
* REPOSITION-FILE, outside the file's boundaries: file-ambcond.
* REPRESENT, results when FLOAT is out of range: floating-idef.
* require:                               Words for Including.
* required:                              Words for Including.
* resize-file:                           Files.
* RESTORE-INPUT, Argument type mismatch: core-ambcond.
* restrict:                              Interpretation and Compilation Semantics.
* result out of range:                   core-ambcond.
* return stack and locals:               Stack Manipulation.
* return stack manipulation words:       Return stack.
* return stack space available:          core-other.
* returning from a definition:           Calls and returns.
* roll:                                  Data stack.
* rot:                                   Data stack.
* rounding of floating-point numbers:    floating-idef.
* rp!:                                   Stack pointer manipulation.
* rp@:                                   Stack pointer manipulation.
* RSHIFT, large shift counts:            core-ambcond.
* running Gforth:                        Invoking Gforth.
* running image files:                   Running Image Files.
* Rydqvist, Goran:                       Emacs and Gforth.
* S", number of string buffers:          file-idef.
* S", size of string buffer:             file-idef.
* save-buffer:                           Blocks.
* savesystem:                            Non-Relocatable Image Files.
* savesystem during gforthmi:            gforthmi.
* scope:                                 Where are locals visible by name?.
* scope of locals:                       Where are locals visible by name?.
* scoping and classes:                   Classes and Scoping.
* search order, maximum depth:           search-idef.
* search order, minimum:                 search-idef.
* search path for files:                 Search Path.
* search path, changes:                  Changing the Search Path.
* search paths for user applications:    General Search Paths.
* search-order words, ambiguous conditions: search-ambcond.
* search-order words, implementation-defined options: search-idef.
* search-order words, system documentation: The optional Search-Order word set.
* SEE, source and format of output:      programming-idef.
* selection control structures:          Selection.
* selector <1>:                          Objects Glossary.
* selector:                              Object-Oriented Terminology.
* selector implementation, class:        Objects Implementation.
* selector invocation:                   Object-Oriented Terminology.
* selector invocation, restrictions <1>: Basic OOF Usage.
* selector invocation, restrictions:     Basic Objects Usage.
* selector usage:                        Basic Objects Usage.
* selectors and stack effects:           Object-Oriented Programming Style.
* selectors common to hardly-related classes: Object Interfaces.
* self:                                  The base class object.
* semantics, interpretation and compilation: Interpretation and Compilation Semantics.
* sf!:                                   Memory Access.
* sf@:                                   Memory Access.
* sf@ or sf! used with an address that is not single-float  aligned: floating-ambcond.
* sf_, stack item type:                  Notation.
* sfalign:                               Address arithmetic.
* sfaligned:                             Address arithmetic.
* sfloat%:                               Structure Glossary.
* sfloat+:                               Address arithmetic.
* sfloats:                               Address arithmetic.
* simple defining words:                 Simple Defining Words.
* simple loops:                          Simple Loops.
* single precision arithmetic words:     Single precision.
* single-assignment style for locals:    Programming Style.
* singlestep Debugger:                   Singlestep Debugger.
* size of buffer at WORD:                core-idef.
* size of the dictionary and the stacks: Invoking Gforth.
* size of the keyboard terminal buffer:  core-idef.
* size of the pictured numeric output buffer: core-idef.
* size of the scratch area returned by PAD: core-idef.
* SIZE parameters for command-line options: Invoking Gforth.
* sm/rem:                                Mixed precision.
* source location of error or debugging output in Emacs: Emacs and Gforth.
* SOURCE-ID, behaviour when BLK is non-zero: file-ambcond.
* sp!:                                   Stack pointer manipulation.
* sp@:                                   Stack pointer manipulation.
* space delimiters:                      core-idef.
* stack effect:                          Notation.
* stack effect of DOES>-parts:           User-defined Defining Words.
* stack effect of included files:        Words for Including.
* stack effects of selectors:            Object-Oriented Programming Style.
* stack empty:                           core-ambcond.
* stack item types:                      Notation.
* stack manipulation words:              Stack Manipulation.
* stack manipulation words, floating-point stack: Floating point stack.
* stack manipulation words, return stack: Return stack.
* stack manipulations words, data stack: Data stack.
* stack overflow:                        core-ambcond.
* stack pointer manipulation words:      Stack pointer manipulation.
* stack size default:                    Stack and Dictionary Sizes.
* stack size, cache-friendly:            Stack and Dictionary Sizes.
* stack space available:                 core-other.
* stack underflow:                       core-ambcond.
* standard document for ANS Forth:       Other Books.
* startup sequence for image file:       Modifying the Startup Sequence.
* STATE values:                          core-idef.
* state-smart words are a bad idea:      Interpretation and Compilation Semantics.
* static:                                Class Declaration.
* strcutures containing structures:      Structure Usage.
* string larger than pictured numeric output area (f., fe., fs.): floating-ambcond.
* String longer than a counted string returned by WORD: core-ambcond.
* struct:                                Structure Glossary.
* struct usage:                          Structure Usage.
* structure extension:                   Structure Usage.
* structure glossary:                    Structure Glossary.
* structure implementation:              Structure Implementation.
* structure naming convention:           Structure Naming Convention.
* structure naming conventions:          Structure Naming Convention.
* structure usage:                       Structure Usage.
* structures:                            Structures.
* structures containing arrays:          Structure Usage.
* structures using address arithmetic:   Why explicit structure support?.
* sub-list?:                             Implementation.
* super:                                 The base class object.
* superclass binding:                    Class Binding.
* swap:                                  Data stack.
* system dictionary space required, in address units: core-other.
* system documentation:                  ANS conformance.
* system documentation, block words:     The optional Block word set.
* system documentation, core words:      The Core Words.
* system documentation, double words:    The optional Double Number word set.
* system documentation, exception words: The optional Exception word set.
* system documentation, facility words:  The optional Facility word set.
* system documentation, file words:      The optional File-Access word set.
* system documentation, floating-point words: The optional Floating-Point word set.
* system documentation, locals words:    The optional Locals word set.
* system documentation, memory-allocation words: The optional Memory-Allocation word set.
* system documentation, programming-tools words: The optional Programming-Tools word set.
* system documentation, search-order words: The optional Search-Order word set.
* system prompt:                         core-idef.
* TAGS file:                             Emacs and Gforth.
* target compiler:                       cross.fs.
* terminal buffer, size:                 core-idef.
* terminology for object-oriented programming: Object-Oriented Terminology.
* THEN:                                  Arbitrary control structures.
* this:                                  Objects Glossary.
* this and catch:                        Objects Implementation.
* this implementation:                   Objects Implementation.
* this usage:                            Method conveniences.
* ThisForth performance:                 Performance.
* threaded code implementation:          Threading.
* threading words:                       Threading Words.
* threading, direct or indirect?:        Direct or Indirect Threaded?.
* throw:                                 Exception Handling.
* THROW-codes used in the system:        exception-idef.
* thru:                                  Blocks.
* TILE performance:                      Performance.
* TO:                                    Simple Defining Words.
* TO on non-VALUEs:                      core-ambcond.
* TO on non-VALUEs and non-locals:       locals-ambcond.
* to-this:                               Objects Glossary.
* tokens for words:                      Tokens for Words.
* TOS optimization for primitives:       TOS Optimization.
* trigonometric operations:              Floating Point.
* truncation of floating-point numbers:  floating-idef.
* tuck:                                  Data stack.
* turnkey image files:                   Modifying the Startup Sequence.
* types of locals:                       Gforth locals.
* types of stack items:                  Notation.
* U+DO:                                  Arbitrary control structures.
* u, stack item type:                    Notation.
* U-DO:                                  Arbitrary control structures.
* ud, stack item type:                   Notation.
* um*:                                   Mixed precision.
* um/mod:                                Mixed precision.
* Undefined word:                        core-ambcond.
* Undefined word, ', POSTPONE, ['], [COMPILE]: core-ambcond.
* unexpected end of the input buffer:    core-ambcond.
* unloop:                                Arbitrary control structures.
* unmapped block numbers:                file-ambcond.
* UNREACHABLE:                           Where are locals visible by name?.
* UNTIL:                                 Arbitrary control structures.
* UNTIL loop:                            Simple Loops.
* update:                                Blocks.
* UPDATE, no current block buffer:       block-ambcond.
* updated?:                              Blocks.
* use:                                   Blocks.
* User:                                  Simple Defining Words.
* user input device, method of selecting: core-idef.
* user output device, method of selecting: core-idef.
* user-defined defining words:           User-defined Defining Words.
* Value:                                 Simple Defining Words.
* value-flavoured locals:                Gforth locals.
* var <1>:                               Mini-OOF Usage.
* var:                                   Class Declaration.
* Variable:                              Simple Defining Words.
* variable-flavoured locals:             Gforth locals.
* versions, invoking other versions of Gforth: Invoking Gforth.
* viewing the source of a word in Emacs: Emacs and Gforth.
* virtual function:                      Object-Oriented Terminology.
* virtual function table:                Objects Implementation.
* virtual machine:                       Engine.
* virtual machine instructions, implementation: Primitives.
* visibility of locals:                  Where are locals visible by name?.
* Vocstack empty, previous:              search-ambcond.
* Vocstack full, also:                   search-ambcond.
* w, stack item type:                    Notation.
* w/o:                                   Files.
* WHILE:                                 Arbitrary control structures.
* WHILE loop:                            Simple Loops.
* wid, stack item type:                  Notation.
* Win32Forth performance:                Performance.
* with:                                  The base class object.
* Woehr, Jack: `Forth: The New Model':   Other Books.
* WORD buffer size:                      core-idef.
* word glossary entry format:            Notation.
* Word name too long:                    core-ambcond.
* WORD, string overflow:                 core-ambcond.
* wordlist for defining locals:          Implementation.
* Words:                                 Words.
* words used in your program:            ANS Report.
* wordset:                               Notation.
* write-file:                            Files.
* xor:                                   Bitwise operations.
* xt, stack item type:                   Notation.
* xt-new:                                Objects Glossary.
* zero-length string as a name:          core-ambcond.
* Zsoter's object-oriented model:        Comparison with other object models.
* ~~:                                    Debugging.
* ~~, removal with Emacs:                Emacs and Gforth.


