Concept and Word Index

Not all entries listed in this index are present verbatim in the text. This index also duplicates, in abbreviated form, all of the words listed in the Word Index (only the names are listed for the words here).

Jump to:   -   ,   ;   :   !   ?   .   '   "   (   )   [   ]   {   }   @   *   /   \   &   #   %   `   +   <   =   >   |   ~   $   0   1   2  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z  
Index EntrySection

-Single precision
--Locals definition words
–, tutorialStack-Effect Comments Tutorial
-[doCounted Loops
-\dRegular Expressions
-\sRegular Expressions
-`Regular Expressions
->hereDictionary allocation
–appl-image, command-line optionInvoking Gforth
–application, gforthmi optiongforthmi
-c?Regular Expressions
-charRegular Expressions
-classRegular Expressions
–clear-dictionary, command-line optionInvoking Gforth
-d, command-line optionInvoking Gforth
–data-stack-size, command-line optionInvoking Gforth
–debug, command-line optionInvoking Gforth
–dictionary-size, command-line optionInvoking Gforth
–die-on-signal, command-line-optionInvoking Gforth
-DOCounted Loops
-DUSE_FTOSTOS Optimization
-DUSE_NO_FTOSTOS Optimization
-DUSE_NO_TOSTOS Optimization
-DUSE_TOSTOS Optimization
–dynamic command-line optionDynamic Superinstructions
–dynamic, command-line optionInvoking Gforth
–enable-force-reg, configuration flagPortability
-f, command-line optionInvoking Gforth
–fp-stack-size, command-line optionInvoking Gforth
-h, command-line optionInvoking Gforth
–help, command-line optionInvoking Gforth
-i, command-line optionInvoking Gforth
-i, invoke image fileRunning Image Files
–image file, invoke image fileRunning Image Files
–image-file, command-line optionInvoking Gforth
-infinityFloating Point
-l, command-line optionInvoking Gforth
–locals-stack-size, command-line optionInvoking Gforth
-LOOPCounted Loops
-m, command-line optionInvoking Gforth
–no-dynamic command-line optionDynamic Superinstructions
–no-dynamic, command-line optionInvoking Gforth
–no-offset-im, command-line optionInvoking Gforth
–no-super command-line optionDynamic Superinstructions
–no-super, command-line optionInvoking Gforth
–offset-image, command-line optionInvoking Gforth
-p, command-line optionInvoking Gforth
–path, command-line optionInvoking Gforth
–print-metrics, command-line optionInvoking Gforth
-r, command-line optionInvoking Gforth
–return-stack-size, command-line optionInvoking Gforth
-rotData stack
–ss-greedy, command-line optionInvoking Gforth
–ss-min-..., command-line optionsInvoking Gforth
–ss-number, command-line optionInvoking Gforth
-trailingString words
-trailing-garbageXchars and Unicode
-v, command-line optionInvoking Gforth
–version, command-line optionInvoking Gforth
–vm-commit, command-line optionInvoking Gforth
-W, command-line optionInvoking Gforth
-Wall, command-line optionInvoking Gforth
-Werror, command-line optionInvoking Gforth
-Won, command-line optionInvoking Gforth
-Wpedantic, command-line optionInvoking Gforth

,Dictionary allocation

;Colon Definitions
;abi-codeAssembler Definitions
;codeAssembler Definitions
;CODE ending sequenceprogramming-idef
;CODE, name not defined via CREATEprogramming-ambcond
;CODE, processing inputprogramming-idef
;inlineColon Definitions
;mObjects Glossary
;m usageMethod conveniences
;sCalls and returns

:Colon Definitions
:, passing data acrossLiterals
::Basic Mini-OOF Usage
:}Locals definition words
:mObjects Glossary
:nonameAnonymous Definitions

!Memory Access
!@Hardware operations for multi-tasking
!resizewidget methods
!sizewidget methods

?Examining data
?!@Hardware operations for multi-tasking
?cov+Code Coverage
?DOCounted Loops
?dupData stack
?DUP-0=-IFArbitrary control structures
?dup-IFArbitrary control structures
?eventsMessage queues
?EXITCalls and returns
?insideactor methods
?LEAVECounted Loops
?ofArbitrary control structures

.Simple numeric output
.?Regular Expressions
...Examining data
..charRegular Expressions
."Miscellaneous output
.", how it worksHow does that work?
.(Miscellaneous output
.\"Miscellaneous output
.cover-rawCode Coverage
.coverageCode Coverage
.emacsInstalling gforth.el
.fi filesImage Files
.fpathSource Search Paths
.gforth-historyCommand-line editing
.hmHeader methods
.idName token
.includedForth source files
.locale-csvi18n and l10n
.pathGeneral Search Paths
.rSimple numeric output
.recognizersDefault Recognizers
.sExamining data
.vocWord Lists
.widgetwidget methods

'Execution token
’-prefix for characters/code pointsLiterals in source code
'coldModifying the Startup Sequence
'sTask-local data

", stack item typeNotation

((Regular Expressions
(local)Standard Forth locals
(to)User-defined TO and DEFER@

))Regular Expressions

[?DO]Interpreter Directives
[']Execution token
[+LOOP]Interpreter Directives
[AGAIN]Interpreter Directives
[BEGIN]Interpreter Directives
[bind]Objects Glossary
[bind] usageClass Binding
[char]String and character literals
[COMP']Compilation token
[current]Objects Glossary
[defined]Interpreter Directives
[DO]Interpreter Directives
[ELSE]Interpreter Directives
[ENDIF]Interpreter Directives
[FOR]Interpreter Directives
[I]Interpreter Directives
[IF]Interpreter Directives
[IF] and POSTPONEprogramming-ambcond
[IF], end of the input source before matching [ELSE] or [THEN]programming-ambcond
[IFDEF]Interpreter Directives
[IFUNDEF]Interpreter Directives
[LOOP]Interpreter Directives
[NEXT]Interpreter Directives
[parent]Objects Glossary
[parent] usageClass Binding
[REPEAT]Interpreter Directives
[THEN]Interpreter Directives
[to-inst]Objects Glossary
[undefined]Interpreter Directives
[UNTIL]Interpreter Directives
[WHILE]Interpreter Directives

]nocovCode Coverage

{Locals definition words
{:Locals definition words
{{Regular Expressions
{*Regular Expressions
{**Regular Expressions
{+Regular Expressions
{++Regular Expressions

}Locals definition words
}}Regular Expressions

@Memory Access
@localnLocals implementation

*Single precision
*}Regular Expressions
**}Regular Expressions
*/Integer division
*/fInteger division
*/modInteger division
*/modfInteger division
*/modsInteger division
*/sInteger division
*alignAddress arithmetic
*alignedAddress arithmetic

/Integer division
//Regular Expressions
//gRegular Expressions
//oRegular Expressions
//sRegular Expressions
/COUNTED-STRINGEnvironmental Queries
/fInteger division
/f-stage1mTwo-stage integer division
/f-stage2mTwo-stage integer division
/HOLDEnvironmental Queries
/lAddress arithmetic
/modInteger division
/modfInteger division
/modf-stage2mTwo-stage integer division
/modsInteger division
/PADEnvironmental Queries
/sInteger division
/stringString words
/wAddress arithmetic
/xAddress arithmetic

\, editing with EmacsEmacs and Gforth
\, line length in blocksblock-idef
\(Regular Expressions
\)Regular Expressions
\\\Forth source files
\^Regular Expressions
\$Regular Expressions
\0Regular Expressions
\cDeclaring C Functions
\dRegular Expressions
\sRegular Expressions

&-prefix for decimal numbersLiterals in source code

#Formatted numeric output
#-prefix for decimal numbersLiterals in source code
#!Running Image Files
#>Formatted numeric output
#>>Formatted numeric output
#bellString and character literals
#bsString and character literals
#crString and character literals
#delString and character literals
#eofString and character literals
#escString and character literals
#ffString and character literals
#lfString and character literals
#lineInterpreter Directives
#localsEnvironmental Queries
#sFormatted numeric output
#tabString and character literals
#tibThe Text Interpreter

%-prefix for binary numbersLiterals in source code
%alignStructure Glossary
%alignmentStructure Glossary
%allocStructure Glossary
%allocateStructure Glossary
%allotStructure Glossary
%sizeStructure Glossary

`Regular Expressions
` prefixExecution token
` prefix of wordLiterals in source code
`?Regular Expressions
`` prefix of wordLiterals in source code

+Single precision
+!Memory Access
+!@Hardware operations for multi-tasking
+}Regular Expressions
++}Regular Expressions
+charRegular Expressions
+charsRegular Expressions
+classRegular Expressions
+DOCounted Loops
+fieldForth200x Structures
+fmodeGeneral files
+LOOPCounted Loops
+x/stringXchars and Unicode

<Numeric comparison
<#Formatted numeric output
<<Regular Expressions
<<"Regular Expressions
<<#Formatted numeric output
<=Numeric comparison
<>Numeric comparison
<bind>Objects Glossary
<to-inst>Objects Glossary

=Numeric comparison

>Numeric comparison
>=Numeric comparison
>>Regular Expressions
>animatewidget methods
>bodyCREATE..DOES> details
>BODY of non-CREATEd wordscore-ambcond
>code-addressThreading Words
>compileDealing with existing Recognizers
>definerThreading Words
>does-codeThreading Words
>floatLine input and conversion
>float1Line input and conversion
>inThe Text Interpreter
>IN greater than input buffercore-ambcond
>interpretDealing with existing Recognizers
>lLocals implementation
>nameName token
>numberLine input and conversion
>orderWord Lists
>postponeDealing with existing Recognizers
>pow2Bitwise operations
>rReturn stack
>string-executeString words
>time&date&tzKeeping track of Time

|Locals definition words
||Regular Expressions

~~, removal with EmacsEmacs and Gforth

$-prefix for hexadecimal numbersLiterals in source code
$!$tring words
$!len$tring words
$?Passing Commands to the OS
$.$tring words
$[]$tring words
$[]!$tring words
$[].$tring words
$[]@$tring words
$[]#$tring words
$[]+!$tring words
$[]boot$tring words
$[]free$tring words
$[]map$tring words
$[]save$tring words
$[]saved$tring words
$[]slurp$tring words
$[]slurp-file$tring words
$[]Variable$tring words
$@$tring words
$@len$tring words
$+!$tring words
$+!len$tring words
$+[]!$tring words
$+slurp$tring words
$+slurp-file$tring words
$boot$tring words
$del$tring words
$exec$tring words
$free$tring words
$init$tring words
$ins$tring words
$iter$tring words
$over$tring words
$save$tring words
$saved$tring words
$slurp$tring words
$slurp-file$tring words
$split$tring words
$tmp$tring words
$Variable$tring words

0<Numeric comparison
0<=Numeric comparison
0<>Numeric comparison
0=Numeric comparison
0>Numeric comparison
0>=Numeric comparison
0x-prefix for hexadecimal numbersLiterals in source code

1-Single precision
1/fFloating Point
1+Single precision

2,Dictionary allocation
2!Memory Access
2@Memory Access
2*Bitwise operations
2/Bitwise operations
2>rReturn stack
2dropData stack
2dupData stack
2field:Forth200x Structures
2nipData stack
2overData stack
2r@Return stack
2r>Return stack
2rdropReturn stack
2rotData stack
2swapData stack
2tuckData stack

a_, stack item typeNotation
A,Dictionary allocation
abi-codeAssembler Definitions
abortException Handling
ABORT"Exception Handling
ABORT", exception abort sequencecore-idef
absSingle precision
absolute-file?Search Paths
abstract classBasic Objects Usage
abstract classBasic OOF Usage
acceptLine input and conversion
ACCEPT, display after end of inputcore-idef
ACCEPT, editingcore-idef
actwidget methods
act-name$actor methods
action-ofDeferred Words
activateBasic multi-tasking
active-wactor methods
actorMINOS2 object framework
add-cflagsDeclaring OS-level libraries
add-frameworkDeclaring OS-level libraries
add-incdirDeclaring OS-level libraries
add-ldflagsDeclaring OS-level libraries
add-libDeclaring OS-level libraries
add-libpathDeclaring OS-level libraries
address alignment exceptioncore-ambcond
address alignment exception, stack overflowcore-ambcond
address arithmetic for structuresWhy explicit structure support?
address arithmetic wordsAddress arithmetic
address unitAddress arithmetic
address unit, size in bitscore-idef
ADDRESS-UNIT-BITSEnvironmental Queries
adjust-bufferHeap Allocation
after-locateLocating source code definitions
AGAINArbitrary control structures
AHEADArbitrary control structures
alignDictionary allocation
alignedAddress arithmetic
aligned addressescore-idef
alignment faultscore-ambcond
alignment of addresses for typesAddress arithmetic
alignment tutorialAlignment Tutorial
allocateHeap Allocation
allotDictionary allocation
alsoWord Lists
also-pathGeneral Search Paths
also, too many word lists in search ordersearch-ambcond
ambiguous conditions, block wordsblock-ambcond
ambiguous conditions, core wordscore-ambcond
ambiguous conditions, double wordsdouble-ambcond
ambiguous conditions, facility wordsfacility-ambcond
ambiguous conditions, file wordsfile-ambcond
ambiguous conditions, floating-point wordsfloating-ambcond
ambiguous conditions, locals wordslocals-ambcond
ambiguous conditions, programming-tools wordsprogramming-ambcond
ambiguous conditions, search-order wordssearch-ambcond
andBitwise operations
angles in trigonometric operationsFloating Point
annotate-covCode Coverage
ans-report.fsStandard Report
appendString words
argOS command line arguments
argcOS command line arguments
argument input source different than current input source for RESTORE-INPUTcore-ambcond
argument type mismatchcore-ambcond
argument type mismatch, RESTORE-INPUTcore-ambcond
arguments, OS command lineOS command line arguments
argvOS command line arguments
arithmetic wordsArithmetic
arithmetics tutorialArithmetics Tutorial
array, iterating overCounted Loops
arrays tutorialArrays and Records Tutorial
arshiftBitwise operations
asptrClass Declaration
assemblerAssembler and Code Words
assemblerAssembler Definitions
ASSEMBLER, search order capabilityprogramming-idef
ASSUME-LIVEWhere are locals visible by name?
at-deltaxyTerminal output
at-xyTerminal output
AT-XY can’t be performed on user output devicefacility-ambcond
Attempt to use zero-length string as a namecore-ambcond
au (address unit)Address arithmetic
AUserTask-local data
authorsHelp on Gforth
authors of GforthOrigin
auto-indentation of Forth code in EmacsAuto-Indentation

bLocating source code definitions
backtraceError messages
backtrace examinationLocating exception source
backtraces with gforth-fastError messages
barrierHardware operations for multi-tasking
baseNumber Conversion
base is not decimal (REPRESENT, F., FE., FS.)floating-ambcond
base-executeNumber Conversion
baselinewidget methods
basic objects usageBasic Objects Usage
batch processing with GforthInvoking Gforth
before-lineText Interpreter Hooks
before-locateLocating source code definitions
before-wordText Interpreter Hooks
BEGINArbitrary control structures
begin-structureForth200x Structures
benchmarking Forth systemsPerformance
big-endianSpecial Memory Accesses
binGeneral files
bindObjects Glossary
bind usageClass Binding
bind'Objects Glossary
bitwise operation wordsBitwise operations
blString and character literals
blankMemory Blocks
blkInput Sources
BLK, altering BLKblock-ambcond
block buffersBlocks
block number invalidblock-ambcond
block read not possibleblock-ambcond
block transfer, I/O exceptionblock-ambcond
block words, ambiguous conditionsblock-ambcond
block words, implementation-defined optionsblock-idef
block words, other system documentationblock-other
block words, system documentationThe optional Block word set
blocks fileBlocks
blocks files, use with EmacsBlocks Files
blocks in filesfile-idef
body-relative address input formatLiterals in source code
Boolean flagsBoolean Flags
bootmessageModifying the Startup Sequence
borderwidget methods
borderlwidget methods
bordertwidget methods
bordervwidget methods
boundsCounted Loops
break:Singlestep Debugger
break"Singlestep Debugger
browseLocating source code definitions
btLocating exception source
buffer%Heap Allocation
bug reportingBugs
bwLocating uses of a word
bw-coverCode Coverage
bye during gforthmigforthmi
byte orderSpecial Memory Accesses

C function pointers to Forth wordsCallbacks
C function pointers, calling from ForthCalling C function pointers
C functions, calls toCalling C Functions
C functions, declarationsDeclaring C Functions
C interfaceC Interface
c_, stack item typeNotation
c-functionDeclaring C Functions
c-funptrCalling C function pointers
c-libraryDefining library interfaces
c-library-nameDefining library interfaces
c-valueDeclaring C Functions
c-variableDeclaring C Functions
c,Dictionary allocation
c, stack item typeNotation
C, using C for the enginePortability
C:Locals definition words
c!Memory Access
c?Regular Expressions
C"Counted string words
c@Memory Access
C^Locals definition words
c>sSpecial Memory Accesses
c$+!$tring words
CA:Locals definition words
call-cLow-Level C Interface Words
Callback functions written in ForthCallbacks
caller-wactor methods
calling a definitionCalls and returns
calling C functionsCalling C Functions
capscompareString words
capssearchString words
capsstring-prefix?String words
caseArbitrary control structures
case as generalized control structureGeneral control structures with CASE
CASE control structureSelection
case sensitivityCase insensitivity
case-sensitivity characteristicscore-idef
case-sensitivity for name lookupcore-idef
catchException Handling
catch and backtracesError messages
catch and thisObjects Implementation
catch in m: ... ;mMethod conveniences
cellAddress arithmetic
cell sizecore-idef
cell-Address arithmetic
cell-aligned addressescore-idef
cell/Address arithmetic
cell%Structure Glossary
cell+Address arithmetic
cellsAddress arithmetic
CFAThreading Words
cfalignDictionary allocation
cfalignedAddress arithmetic
cfield:Forth200x Structures
changing the compilation word list (during compilation)search-ambcond
charString and character literals
char sizecore-idef
char-Address arithmetic
char%Structure Glossary
char+Address arithmetic
character editing of ACCEPT and EXPECTcore-idef
character encodingCharacters
character literalsString and character literals
character setcore-idef
character strings - displayingDisplaying characters and strings
character strings - moving and copyingMemory Blocks
character strings - representationsString representations
character-aligned address requirementscore-idef
character-set extensions and matching of namescore-idef
Characters - chars/bytes vs. extended charactersCharacters
characters - displayingDisplaying characters and strings
characters tutorialCharacters and Strings Tutorial
charclassRegular Expressions
charsAddress arithmetic
child classObject-Oriented Terminology
child wordsUser-defined defining words using CREATE
classObject-Oriented Terminology
classObjects Glossary
classBasic Mini-OOF Usage
class bindingClass Binding
class binding as optimizationClass Binding
class binding, alternative toClass Binding
class binding, implementationObjects Implementation
class declarationClass Declaration
class definition, restrictionsBasic Objects Usage
class definition, restrictionsBasic OOF Usage
class implementationClass Implementation
class implementation and representationObjects Implementation
class scoping implementationObjects Implementation
class usageBasic Objects Usage
class usageBasic OOF Usage
class->mapObjects Glossary
class-inst-sizeObjects Glossary
class-inst-size discussionCreating objects
class-override!Objects Glossary
class-previousObjects Glossary
class;Class Declaration
class; usageBasic OOF Usage
class>orderObjects Glossary
classes and scopingClasses and Scoping
clear screenTerminal output
clear-libsDeclaring OS-level libraries
clear-pathGeneral Search Paths
clearstackExamining data
clearstacksExamining data
clickedactor methods
clock tick durationfacility-idef
close-fileGeneral files
cmoveMemory Blocks
cmove>Memory Blocks
codeAssembler Definitions
code addressThreading Words
code coverageCode Coverage
CODE ending sequenceprogramming-idef
code fieldThreading Words
code wordsAssembler and Code Words
code-address!Threading Words
CODE, processing inputprogramming-idef
colon definitionsColon Definitions
colon definitionsAnonymous Definitions
colon definitions, nestingQuotations
colon definitions, tutorialColon Definitions Tutorial
colon-sys, passing data across :Literals
color-coverCode Coverage
color:widget methods
combined wordsCombined words
command line arguments, OSOS command line arguments
command-line editingCommand-line editing
command-line optionsInvoking Gforth
comment editing commandsEmacs and Gforth
comments tutorialComments Tutorial
common-listLocals implementation
comp.lang.forthForth-related information
COMP'Compilation token
compareMemory Blocks
comparison of object modelsComparison with other object models
comparison tutorialFlags and Comparisons Tutorial
compilation semanticsHow does that work?
compilation semanticsInterpretation and Compilation Semantics
compilation semantics tutorialInterpretation and Compilation Semantics and Immediacy Tutorial
compilation tokenCompilation token
compilation tokens, tutorialCompilation Tokens Tutorial
compilation word listWord Lists
compilation word list, change before definition endssearch-ambcond
compile stateThe Text Interpreter
compile-lp+!Locals implementation
compile-onlyInterpretation and Compilation Semantics
compile-only warning, for ' etc.core-ambcond
compile-only wordsInterpretation and Compilation Semantics
compile-only?Header fields
compiled code examinationExamining compiled code
compiling compilation semanticsMacros
compiling wordsCompiling words
conditional compilationInterpreter Directives
conditionals, tutorialConditional execution Tutorial
constructObjects Glossary
construct discussionCreating objects
contextWord Lists
context-sensitive helpEmacs and Gforth
contiguous regions and heap allocationHeap Allocation
contiguous regions in dictionary allocationDictionary allocation
contofArbitrary control structures
contributors to GforthOrigin
control characters as delimiterscore-idef
control structuresControl Structures
control structures for selectionSelection
control structures programming styleArbitrary control structures
control structures, user-definedArbitrary control structures
control-flow stackArbitrary control structures
control-flow stack items, locals informationLocals implementation
control-flow stack underflowprogramming-ambcond
control-flow stack, formatcore-idef
convertLine input and conversion
convertin strings to numbersLine input and conversion
COREEnvironmental Queries
core words, ambiguous conditionscore-ambcond
core words, implementation-defined optionscore-idef
core words, other system documentationcore-other
core words, system documentationThe Core Words
CORE-EXTEnvironmental Queries
countCounted string words
counted loopsCounted Loops
counted loops with negative incrementCounted Loops
counted string, maximum sizecore-idef
counted stringsString representations
Countryi18n and l10n
cov%Code Coverage
cov+Code Coverage
coverage?Code Coverage
cputimeKeeping track of Time
crMiscellaneous output
CREATE ... DOES>User-defined defining words using CREATE
CREATE ... DOES>, applicationsCREATE..DOES> applications
CREATE ... DOES>, detailsCREATE..DOES> details
CREATE ... SET-DOES>User-defined defining words using CREATE
CREATE and alignmentAddress arithmetic
create-fileGeneral files
create-fromCreating from a prototype
create...does> tutorialDefining Words Tutorial
creating objectsCreating objects
cross-compilerCross Compiler
cross.fsCross Compiler
CS-DROPArbitrary control structures
CS-PICKArbitrary control structures
CS-PICK, fewer than u+1 items on the control flow-stackprogramming-ambcond
CS-ROLLArbitrary control structures
CS-ROLL, fewer than u+1 items on the control flow-stackprogramming-ambcond
cs-vocabularyWord Lists
cs-wordlistWord Lists
cstring>sstringString words
ct (compilation token)Compilation token
CT, tutorialCompilation Tokens Tutorial
ctzBitwise operations
currentWord Lists
current-interfaceObjects Glossary
current-interface discussionObjects Implementation
current'Objects Glossary
curryingCREATE..DOES> applications
cursor positioningTerminal output

dwidget methods
d-Double precision
d, stack item typeNotation
D:Locals definition words
d.Simple numeric output
d.rSimple numeric output
D^Locals definition words
d+Double precision
d<Numeric comparison
d<=Numeric comparison
d<>Numeric comparison
d=Numeric comparison
d>Numeric comparison
d>=Numeric comparison
d>fFloating Point
D>F, d cannot be presented precisely as a floatfloating-ambcond
d>sDouble precision
D>S, d out of range of ndouble-ambcond
d0<Numeric comparison
d0<=Numeric comparison
d0<>Numeric comparison
d0=Numeric comparison
d0>Numeric comparison
d0>=Numeric comparison
d2*Bitwise operations
d2/Bitwise operations
DA:Locals definition words
dabsDouble precision
dark-modeTerminal output
darshiftBitwise operations
data space - reserving someDictionary allocation
data space availablecore-other
data space containing definitions gets de-allocatedcore-ambcond
data space pointer not properly aligned, ,, C,core-ambcond
data space read/write with incorrect alignmentcore-ambcond
data stackStack Manipulation
data stack manipulation wordsData stack
data structure localsGforth locals
data-relocatable image filesData-Relocatable Image Files
data-space, read-only regionscore-idef
dbgSinglestep Debugger
debug tracer editing commandsEmacs and Gforth
debugging output, finding the source location in EmacsEmacs and Gforth
debugging SinglestepSinglestep Debugger
dec.Simple numeric output
dec.rSimple numeric output
decimalNumber Conversion
declaring C functionsDeclaring C Functions
decompilation tutorialDecompilation Tutorial
default type of localsGforth locals
default-colorTerminal output
default-w:Gforth locals
default-wa:Gforth locals
DeferDeferred Words
deferClass Declaration
defer!Deferred Words
defer@Deferred Words
deferred wordsDeferred Words
defersDeferred Words
definerThreading Words
definer!Threading Words
definesBasic Mini-OOF Usage
defining defining wordsUser-defined Defining Words
defining wordsDefining Words
defining words tutorialDefining Words Tutorial
defining words without nameAnonymous Definitions
defining words, name given in a stringSupplying names
defining words, simpleCREATE
defining words, user-definedUser-defined Defining Words
definitionIntroducing the Text Interpreter
definitionsWord Lists
definitions, tutorialColon Definitions Tutorial
defocusactor methods
deleteMemory Blocks
delete-fileGeneral files
delta-iCounted Loops
depthExamining data
depth changes during interpretationStack depth changes
depth-changes.fsStack depth changes
design of stack effects, tutorialDesigning the stack effect Tutorial
dest, control-flow stack itemArbitrary control structures
df_, stack item typeNotation
df!Memory Access
df@Memory Access
df@ or df! used with an address that is not double-float alignedfloating-ambcond
dfalignDictionary allocation
dfalignedAddress arithmetic
dffield:Forth200x Structures
dfloat/Address arithmetic
dfloat%Structure Glossary
dfloat+Address arithmetic
dfloatsAddress arithmetic
dgluewidget methods
dglue@widget methods
dict-newObjects Glossary
dict-new discussionCreating objects
dictionaryThe Text Interpreter
dictionary in persistent formImage Files
dictionary overflowcore-ambcond
dictionary size defaultStack and Dictionary Sizes
digits > 35core-idef
direct threaded inner interpreterThreading
disassembler, generalCommon Disassembler
discodeCommon Disassembler
dispose-widgetwidget methods
dividing by zerocore-ambcond
dividing by zero, floating-pointfloating-ambcond
Dividing classesDividing classes
dividing integersInteger division
dividing many integers with the same divisorTwo-stage integer division
Division by zeroInteger division
Division by zeroInteger division
division roundingcore-idef
division with potentially negative operandsArithmetic
dlshiftBitwise operations
dmaxDouble precision
dminDouble precision
dnegateDouble precision
DOCounted Loops
DO loopsCounted Loops
doabicode,Threading Words
doabicode:Threading Words
docol,Threading Words
docol:Threading Words
docon,Threading Words
docon:Threading Words
dodefer,Threading Words
dodefer:Threading Words
dodoes routineDOES>
dodoes:Threading Words
does-code!Threading Words
DOES> implementationDOES>
DOES> in a separate definitionCREATE..DOES> details
DOES> in interpretation stateCREATE..DOES> details
DOES> of non-CREATEd wordscore-ambcond
does> tutorialDefining Words Tutorial
does>-codeThreading Words
DOES>-parts, stack effectUser-defined defining words using CREATE
DOES>, visibility of current definitioncore-idef
dofield,Threading Words
dofield:Threading Words
DONECounted Loops
double precision arithmetic wordsDouble precision
double words, ambiguous conditionsdouble-ambcond
double words, system documentationThe optional Double Number word set
double-cell numbers, input formatLiterals in source code
double%Structure Glossary
doubly indirect threaded codegforthmi
douser,Threading Words
douser:Threading Words
dovalue,Threading Words
dovalue:Threading Words
dovar,Threading Words
dovar:Threading Words
dplNumber Conversion
drawwidget methods
draw-initwidget methods
drolBitwise operations
dropData stack
drorBitwise operations
drshiftBitwise operations
du/modInteger division
du<Numeric comparison
du<=Numeric comparison
du>Numeric comparison
du>=Numeric comparison
dumpExamining data
dupData stack
duration of a system clock tickfacility-idef
dynamic allocation of memoryHeap Allocation
Dynamic superinstructions with replicationDynamic Superinstructions
Dynamically linked libraries in C interfaceDeclaring OS-level libraries

earlyClass Declaration
early bindingClass Binding
editLocating source code definitions
edit-lineLine input and conversion
editing in ACCEPT and EXPECTcore-idef
eforth performancePerformance
ekeySingle-key input
EKEY, encoding of keyboard eventsfacility-idef
ekey?Single-key input
ekey>charSingle-key input
ekey>fkeySingle-key input
ekey>xcharSingle-key input
ekeyedactor methods
elements of a Forth systemReview - elements of a Forth system
ELSEArbitrary control structures
Emacs and GforthEmacs and Gforth
emitDisplaying characters and strings
EMIT and non-graphic characterscore-idef
emit-fileGeneral files
end-c-libraryDefining library interfaces
end-classObjects Glossary
end-classBasic Mini-OOF Usage
end-class usageBasic Objects Usage
end-class-nonameObjects Glossary
end-codeAssembler Definitions
end-interfaceObjects Glossary
end-interface usageObject Interfaces
end-interface-nonameObjects Glossary
end-methodsObjects Glossary
end-structStructure Glossary
end-struct usageStructure Usage
end-structureForth200x Structures
endcaseArbitrary control structures
ENDIFArbitrary control structures
endless loopSimple Loops
endofArbitrary control structures
endscopeWhere are locals visible by name?
endtryException Handling
endtry-iferrorException Handling
engine performancePerformance
engine portabilityPortability
engine.sProduced code
engines, gforth vs. gforth-fast vs. gforth-itcDirect or Indirect Threaded?
enteredactor methods
environmentEnvironmental Queries
environment variable input formatLiterals in source code
environment variablesEnvironment variables
environment variablesgforthmi
environment wordsetNotation
environment-wordlistEnvironmental Queries
environment?Environmental Queries
ENVIRONMENT? string length, maximumcore-idef
environmental queriesEnvironmental Queries
environmental restrictionsStandard conformance
equality of floatsFloating Point
eraseMemory Blocks
error messagesError messages
error output, finding the source location in EmacsEmacs and Gforth
error-colorTerminal output
error-hl-invTerminal output
error-hl-ulTerminal output
etags.fsEmacs Tags
evaluateInput Sources
event-loopMessage queues
examining data and codeExamining data
exceptionException Handling
exception abort sequence of ABORT"core-idef
exception source codeLocating exception source
exception when including sourcefile-idef
exception words, implementation-defined optionsexception-idef
exception words, system documentationThe optional Exception word set
exceptionsException Handling
exceptionsException Handling
exceptions tutorialExceptions Tutorial
executable image fileRunning Image Files
executeExecution token
execute-exitExecution token
execute-parsingThe Input Stream
execute-parsing-fileThe Input Stream
execute-taskBasic multi-tasking
executing code on startupInvoking Gforth
execution frequencyCode Coverage
execution semanticsInterpretation and Compilation Semantics
execution tokenIntroducing the Text Interpreter
execution tokenExecution token
execution token input formatLiterals in source code
execution token of last defined wordAnonymous Definitions
execution token of words with undefined execution semanticscore-ambcond
execution tokens tutorialExecution Tokens Tutorial
EXITCalls and returns
exit in m: ... ;mMethod conveniences
exitmObjects Glossary
exitm discussionMethod conveniences
expand-whereLocating uses of a word
expectLine input and conversion
EXPECT, display after end of inputcore-idef
EXPECT, editingcore-idef
explicit register declarationsPortability
exponent too big for conversion (DF!, DF@, SF!, SF@)floating-ambcond
extend-memHeap Allocation
extend-structureForth200x Structures
extended recordsStructure Usage

f_, stack item typeNotation
f-Floating Point
f-rotFloating point stack
f,Dictionary allocation
f, stack item typeNotation
F:Locals definition words
f!Memory Access
f! used with an address that is not float alignedfloating-ambcond
f.Floating-point output
f.rdpFloating-point output
f.sExamining data
f.s-precisionExamining data
f@Memory Access
f@ used with an address that is not float alignedfloating-ambcond
f@localnLocals implementation
f*Floating Point
f**Floating Point
f/Floating Point
F^Locals definition words
f+Floating Point
f<Floating Point
f<=Floating Point
f<>Floating Point
f=Floating Point
f>Floating Point
f>=Floating Point
f>buf-rdpFloating-point output
f>dFloating Point
F>D, integer part of float cannot be represented by dfloating-ambcond
f>lLocals implementation
f>sFloating Point
f>str-rdpFloating-point output
f~Floating Point
f~absFloating Point
f~relFloating Point
f0<Floating Point
f0<=Floating Point
f0<>Floating Point
f0=Floating Point
f0>Floating Point
f0>=Floating Point
f2*Floating Point
f2/Floating Point
f83name, stack item typeNotation
FA:Locals definition words
fabsFloating Point
facility words, ambiguous conditionsfacility-ambcond
facility words, implementation-defined optionsfacility-idef
facility words, system documentationThe optional Facility word set
facosFloating Point
FACOS, |float|>1floating-ambcond
facoshFloating Point
FACOSH, float<1floating-ambcond
factoring similar colon definitionsCREATE..DOES> applications
factoring tutorialFactoring Tutorial
fade-color:widget methods
falignDictionary allocation
falignedAddress arithmetic
falogFloating Point
falseBoolean Flags
fam (file access method)General files
fasinFloating Point
FASIN, |float|>1floating-ambcond
fasinhFloating Point
FASINH, float<0floating-ambcond
fast-throwException Handling
fatanFloating Point
fatan2Floating Point
FATAN2, both arguments are equal to zerofloating-ambcond
fatanhFloating Point
FATANH, |float|>1floating-ambcond
faxpyFloating Point
fclearstackExamining data
fcopysignFloating Point
fcosFloating Point
fcoshFloating Point
fdepthExamining data
FDL, GNU Free Documentation LicenseGNU Free Documentation License
fdropFloating point stack
fdupFloating point stack
fe.Floating-point output
fexpFloating Point
fexpm1Floating Point
ffield:Forth200x Structures
ffourthFloating point stack
fieldStructure Glossary
field naming conventionStructure Naming Convention
field usageStructure Usage
field usage in class definitionBasic Objects Usage
field:Forth200x Structures
file access methods usedfile-idef
file exceptionsfile-idef
file input nesting, maximum depthfile-idef
file line terminatorfile-idef
file name formatfile-idef
file search pathSearch Paths
file words, ambiguous conditionsfile-ambcond
file words, implementation-defined optionsfile-idef
file words, system documentationThe optional File-Access word set
file-eof?General files
file-handlingGeneral files
file-positionGeneral files
file-sizeGeneral files
file-statusGeneral files
FILE-STATUS, returned informationfile-idef
file>fpathSource Search Paths
file>pathGeneral Search Paths
filenames in ~~ outputDebugging
filenames in assertion outputAssertions
files containing blocksfile-idef
files containing Forth code, tutorialUsing files for Forth code Tutorial
files tutorialFiles Tutorial
fillMemory Blocks
findWord Lists
find-nameName token
find-name-inName token
first definitionYour first definition
first field optimizationStructure Usage
first field optimization, implementationStructure Implementation
fkey.Single-key input
flags on the command lineInvoking Gforth
flags tutorialFlags and Comparisons Tutorial
flavours of localsGforth locals
flnFloating Point
FLN, float<=0floating-ambcond
flnp1Floating Point
FLNP1, float<=-1floating-ambcond
floatAddress arithmetic
float/Address arithmetic
float%Structure Glossary
float+Address arithmetic
floating point arithmetic wordsFloating Point
floating point numbers, format and rangefloating-idef
floating point tutorialFloating Point Tutorial
floating point unidentified fault, integer divisioncore-ambcond
floating-point arithmetic, pitfallsFloating Point
floating-point comparisonsFloating Point
floating-point constantsFloating Point
floating-point dividing by zerofloating-ambcond
floating-point numbers, input formatLiterals in source code
floating-point numbers, rounding or truncationfloating-idef
floating-point outputFloating-point output
floating-point result out of rangefloating-ambcond
floating-point stackStack Manipulation
floating-point stack in the standardStack Manipulation
floating-point stack manipulation wordsFloating point stack
floating-point stack sizefloating-idef
floating-point stack widthfloating-idef
Floating-point unidentified faultInteger division
Floating-point unidentified fault (on integer division)Integer division
floating-point unidentified fault, F>Dfloating-ambcond
floating-point unidentified fault, FACOS, FASIN or FATANHfloating-ambcond
floating-point unidentified fault, FACOSHfloating-ambcond
floating-point unidentified fault, FASINH or FSQRTfloating-ambcond
floating-point unidentified fault, FLN or FLOGfloating-ambcond
floating-point unidentified fault, FLNP1floating-ambcond
floating-point unidentified fault, FP divide-by-zerofloating-ambcond
floating-point words, ambiguous conditionsfloating-ambcond
floating-point words, implementation-defined optionsfloating-idef
floating-point words, system documentationThe optional Floating-Point word set
floating-stackEnvironmental Queries
floatsAddress arithmetic
flogFloating Point
FLOG, float<=0floating-ambcond
floorFloating Point
FLOOREDEnvironmental Queries
floored divisionInteger division
flush-fileGeneral files
flush-icacheAssembler Definitions
fm/modInteger division
fmaxFloating Point
fminFloating Point
fnegateFloating Point
fnipFloating point stack
focusactor methods
FORCounted Loops
FOR loopsCounted Loops
foreign language interfaceC Interface
FORGET, deleting the compilation word listprogramming-ambcond
FORGET, name can’t be foundprogramming-ambcond
FORGET, removing a needed definitionprogramming-ambcond
forgeting wordsForgetting words
FORKRegular Expressions
formTerminal output
format and range of floating point numbersfloating-idef
format of glossary entriesNotation
formatted numeric outputFormatted numeric output
ForthWord Lists
Forth - an introductionIntroduction
Forth mode in EmacsEmacs and Gforth
Forth source filesForth source files
Forth TutorialTutorial
forth-recognizeDealing with existing Recognizers
forth-recognizerDealing with existing Recognizers
Forth-related informationForth-related information
forth-wordlistWord Lists
forth.elEmacs and Gforth
fourthData stack
foverFloating point stack
FP outputFloating-point output
FP tutorialFloating Point Tutorial
fp!Stack pointer manipulation
fp.Floating-point output
fp@Stack pointer manipulation
fp0Stack pointer manipulation
fpathSource Search Paths
fpickFloating point stack
freeHeap Allocation
free-mem-varHeap Allocation
frequently asked questionsForth-related information
frotFloating point stack
froundFloating Point
fs.Floating-point output
fsinFloating Point
fsincosFloating Point
fsinhFloating Point
fsqrtFloating Point
FSQRT, float<0floating-ambcond
fswapFloating point stack
ftanFloating Point
FTAN on an argument r1 where cos(r1) is zerofloating-ambcond
ftanhFloating Point
fthirdFloating point stack
ftruncFloating Point
ftuckFloating point stack
fully relocatable image filesFully Relocatable Image Files
functions, tutorialColon Definitions Tutorial

gLocating source code definitions
gapwidget methods
gdb disassemblerCommon Disassembler
general control structures (case)General control structures with CASE
general filesGeneral files
getactor methods
get-currentWord Lists
get-orderWord Lists
get-recognizersDealing with existing Recognizers
getenvPassing Commands to the OS
gforthEnvironmental Queries
GFORTH – environment variableEnvironment variables
GFORTH – environment variablegforthmi
Gforth - leavingLeaving Gforth
gforth engineDirect or Indirect Threaded?
Gforth environmentGforth Environment
Gforth extensionsStandard vs Extensions
Gforth filesGforth Files
Gforth localsGforth locals
Gforth performancePerformance
Gforth stabilityStability Goals
gforth-fast and backtracesError messages
gforth-fast engineDirect or Indirect Threaded?
gforth-fast, difference from gforthError messages
gforth-itc engineDirect or Indirect Threaded?
gforth.elEmacs and Gforth
gforth.el, installationInstalling gforth.el, relocatabilityFully Relocatable Image Files
GFORTHD – environment variableEnvironment variables
GFORTHD – environment variablegforthmi
GFORTHHIST – environment variableEnvironment variables
GFORTHPATH – environment variableEnvironment variables
GFORTHSYSTEMPREFIX – environment variableEnvironment variables
ggLocating uses of a word
giving a name to a library interfaceDefining library interfaces
glossary notation formatNotation
GNU C for the enginePortability
goals of the Gforth projectGoals

hwidget methods
h.Simple numeric output
haltBasic multi-tasking
header fieldsHeader fields
header methodsHeader methods
header spaceWord Lists
heap allocationHeap Allocation
heap-newObjects Glossary
heap-new discussionCreating objects
heap-new usageBasic Objects Usage
helpHelp on Gforth
helpHelp on Gforth
hereDictionary allocation
hexNumber Conversion
hex.Simple numeric output
hgluewidget methods
hglue@widget methods
hideactor methods
highlighting Forth code in EmacsHilighting
hilighting Forth code in EmacsHilighting
history fileCommand-line editing
hmcopy,Threading Words
holdFormatted numeric output
holdsFormatted numeric output
hooks in the text interpreterText Interpreter Hooks
how:Class Declaration
hybrid direct/indirect threaded codeDirect or Indirect Threaded?

iCounted Loops
i'Counted Loops
I/O - blocksBlocks
I/O - file-handlingFiles
I/O - keyboard and displayOther I/O
I/O - see inputLine input and conversion
I/O exception in block transferblock-ambcond
id.Name token
IDE (integrated development environment)Locating source code definitions
IFArbitrary control structures
IF control structureSelection
if, tutorialConditional execution Tutorial
iferrorException Handling
image fileImage Files
image file backgroundImage File Background
image file initialization sequenceModifying the Startup Sequence
image file invocationRunning Image Files
image file loaderImage File Background
image file, data-relocatableData-Relocatable Image Files
image file, executableRunning Image Files
image file, fully relocatableFully Relocatable Image Files
image file, non-relocatableNon-Relocatable Image Files
image file, stack and dictionary sizesStack and Dictionary Sizes
image file, turnkey applicationsModifying the Startup Sequence
image licenseImage Licensing Issues
immediateInterpretation and Compilation Semantics
immediate wordsHow does that work?
immediate wordsInterpretation and Compilation Semantics
immediate, tutorialInterpretation and Compilation Semantics and Immediacy Tutorial
immediate?Header methods
implementationObjects Glossary
implementation of localsLocals implementation
implementation of structuresStructure Implementation
implementation usageObject Interfaces
implementation-defined options, block wordsblock-idef
implementation-defined options, core wordscore-idef
implementation-defined options, exception wordsexception-idef
implementation-defined options, facility wordsfacility-idef
implementation-defined options, file wordsfile-idef
implementation-defined options, floating-point wordsfloating-idef
implementation-defined options, locals wordslocals-idef
implementation-defined options, memory-allocation wordsmemory-idef
implementation-defined options, programming-tools wordsprogramming-idef
implementation-defined options, search-order wordssearch-idef
in-lining of constantsConstants
includeForth source files
include search pathSearch Paths
include-fileForth source files
INCLUDE-FILE, file-id is invalidfile-ambcond
INCLUDE-FILE, I/O exception reading or closing file-idfile-ambcond
include-localei18n and l10n
include, placement in filesEmacs Tags
includedForth source files
included-localei18n and l10n
INCLUDED, I/O exception reading or closing file-idfile-ambcond
INCLUDED, named file cannot be openedfile-ambcond
included?Forth source files
including filesForth source files
including files, stack effectForth source files
indentation of Forth code in EmacsAuto-Indentation
indirect threaded inner interpreterThreading
infinityFloating Point
info-colorTerminal output
inheritanceObject-Oriented Terminology
init-asmAssembler Definitions
init-bufferHeap Allocation
init-objectObjects Glossary
init-object discussionCreating objects
initialization of localsGforth locals
initialization sequence of image fileModifying the Startup Sequence
initiateBasic multi-tasking
inline:Colon Definitions
inner interpreter implementationThreading
inner interpreter optimizationScheduling
inner interpreter, direct threadedThreading
inner interpreter, indirect threadedThreading
input bufferThe Text Interpreter
input format for body-relative addressesLiterals in source code
input format for characters/code pointsLiterals in source code
input format for double-cell numbersLiterals in source code
input format for environment variablesLiterals in source code
input format for execution tokensLiterals in source code
input format for floating-point numbersLiterals in source code
input format for name tokensLiterals in source code
input format for single-cell numbersLiterals in source code
input format for stringsLiterals in source code
input from pipesGforth in pipes
input line size, maximumfile-idef
input line terminatorcore-idef
Input RedirectionRedirection
input sourcesInput Sources
input streamThe Input Stream
input-colorTerminal output
input, linewise from terminalLine input and conversion
input, single-keySingle-key input
insertMemory Blocks
inst-valueObjects Glossary
inst-value usageMethod conveniences
inst-value visibilityClasses and Scoping
inst-varObjects Glossary
inst-var implementationObjects Implementation
inst-var usageMethod conveniences
inst-var visibilityClasses and Scoping
instance variablesObject-Oriented Terminology
instruction pointerThreading
insufficient data stack or return stack spacecore-ambcond
insufficient space for loop control parameterscore-ambcond
insufficient space in the dictionarycore-ambcond
INT-[I]Interpreter Directives
integer types, rangescore-idef
integrated development environmentLocating source code definitions
interfaceObjects Glossary
interface implementationObjects Implementation
interface to C functionsC Interface
interface usageObject Interfaces
interfaces for objectsObject Interfaces
interpretThe Text Interpreter
interpret stateThe Text Interpreter
Interpret/Compile statesInterpret/Compile states
interpret/compile:Combined words
interpretation semanticsHow does that work?
interpretation semanticsInterpretation and Compilation Semantics
interpretation semantics tutorialInterpretation and Compilation Semantics and Immediacy Tutorial
interpreter - outerThe Text Interpreter
interpreter directivesInterpreter Directives
Interpreting a compile-only wordcore-ambcond
Interpreting a compile-only word, for a locallocals-ambcond
interpreting a word with undefined interpretation semanticscore-ambcond
invalid block numberblock-ambcond
Invalid memory addresscore-ambcond
Invalid memory address, stack overflowcore-ambcond
Invalid name argument, TOcore-ambcond
Invalid name argument, TOlocals-ambcond
invertBitwise operations
invoking a selectorObject-Oriented Terminology
invoking GforthInvoking Gforth
invoking image filesRunning Image Files
ior type descriptionNotation
ior values and meaningfile-idef
ior values and meaningmemory-idef
ISDeferred Words
items on the stack after interpretationStack depth changes
iterate over arrayCounted Loops

jCounted Loops
JOINRegular Expressions

kCounted Loops
k-alt-maskSingle-key input
k-backspaceSingle-key input
k-ctrl-maskSingle-key input
k-deleteSingle-key input
k-downSingle-key input
k-endSingle-key input
k-enterSingle-key input
k-eofSingle-key input
k-f1Single-key input
k-f10Single-key input
k-f11Single-key input
k-f12Single-key input
k-f2Single-key input
k-f3Single-key input
k-f4Single-key input
k-f5Single-key input
k-f6Single-key input
k-f7Single-key input
k-f8Single-key input
k-f9Single-key input
k-homeSingle-key input
k-insertSingle-key input
k-leftSingle-key input
k-muteSingle-key input
k-nextSingle-key input
k-pauseSingle-key input
k-priorSingle-key input
k-rightSingle-key input
k-selSingle-key input
k-shift-maskSingle-key input
k-tabSingle-key input
k-upSingle-key input
k-voldownSingle-key input
k-volupSingle-key input
k-winchSingle-key input
kern*.fi, relocatabilityFully Relocatable Image Files
kerningwidget methods
keySingle-key input
key-fileGeneral files
key-iorSingle-key input
key?Single-key input
key?-fileGeneral files
keyboard events, encoding in EKEYfacility-idef
killBasic multi-tasking
kill-taskBasic multi-tasking
Kuehling, DavidEmacs and Gforth

lLocating source code definitions
l,Dictionary allocation
l!Special Memory Accesses
L"i18n and l10n
l@Special Memory Accesses
l>sSpecial Memory Accesses
labels as valuesThreading
lalignAddress arithmetic
lalignedAddress arithmetic
LANG – environment variableEnvironment variables
Languagei18n and l10n
last word was headerlesscore-ambcond
lastfitwidget methods
late bindingClass Binding
latestName token
latestntName token
latestxtAnonymous Definitions
lbeSpecial Memory Accesses
LC_ALL – environment variableEnvironment variables
LC_CTYPE – environment variableEnvironment variables
LEAVECounted Loops
leaving definitions, tutorialLeaving definitions or loops Tutorial
leaving GforthLeaving Gforth
leaving loops, tutorialLeaving definitions or loops Tutorial
leftactor methods
length of a line affected by \block-idef
lfield:Forth200x Structures
lib-errorLow-Level C Interface Words
lib-symLow-Level C Interface Words
Libraries in C interfaceDeclaring OS-level libraries
library interface namesDefining library interfaces
licenseHelp on Gforth
license for imagesImage Licensing Issues
lifetime of localsHow long do locals live?
light-modeTerminal output
line input from terminalLine input and conversion
line terminator on inputcore-idef
line-end-hookText Interpreter Hooks
LIST display formatblock-idef
list-sizeLocals implementation
literal tutorialLiteral Tutorial
Literals (in source code)Literals in source code
literals for characters and stringsString and character literals
little-endianSpecial Memory Accesses
llLocating uses of a word
lleSpecial Memory Accesses
load-covCode Coverage
loader for image filesImage File Background
loading files at startupInvoking Gforth
loading Forth code, tutorialUsing files for Forth code Tutorial
local in interpretation statelocals-ambcond
local variables, tutorialLocal Variables Tutorial
locale and case-sensitivitycore-idef
locale-csvi18n and l10n
locale-csv-outi18n and l10n
locale-filei18n and l10n
locale!i18n and l10n
locale@i18n and l10n
locals and return stackReturn stack
locals flavoursGforth locals
locals implementationLocals implementation
locals information on the control-flow stackLocals implementation
locals initializationGforth locals
locals lifetimeHow long do locals live?
locals programming styleLocals programming style
locals stackStack Manipulation
locals stackLocals implementation
locals typesGforth locals
locals visibilityWhere are locals visible by name?
locals words, ambiguous conditionslocals-ambcond
locals words, implementation-defined optionslocals-idef
locals words, system documentationThe optional Locals word set
locals, default typeGforth locals
locals, Gforth styleGforth locals
locals, maximum number in a definitionlocals-idef
locals, Standard Forth styleStandard Forth locals
locateLocating source code definitions
log2Bitwise operations
long longPortability
LOOPCounted Loops
loop control parameters not availablecore-ambcond
loops without countSimple Loops
loops, countedCounted Loops
loops, counted, tutorialCounted loops Tutorial
loops, endlessSimple Loops
loops, indefinite, tutorialGeneral Loops Tutorial
lp!Stack pointer manipulation
lp!Locals implementation
lp@Stack pointer manipulation
lp@Locals implementation
lp0Stack pointer manipulation
lrolBitwise operations
lrorBitwise operations
lshiftBitwise operations
LSHIFT, large shift countscore-ambcond
LU"i18n and l10n

m:Objects Glossary
m: usageMethod conveniences
m*Mixed precision
m*/Integer division
m+Mixed precision
macrosCompiling words
macros, advanced tutorialAdvanced macros Tutorial
magenta-inputTerminal output
make-latestMaking a word current
map-vocsWord Lists
mapping block ranges to filesfile-idef
markerForgetting words
maxSingle precision
MAX-CHAREnvironmental Queries
MAX-DEnvironmental Queries
max-floatEnvironmental Queries
MAX-NEnvironmental Queries
MAX-UEnvironmental Queries
MAX-UDEnvironmental Queries
MAX-XCHAREnvironmental Queries
maxalignDictionary allocation
maxalignedAddress arithmetic
maxdepth-.sExamining data
maximum depth of file input nestingfile-idef
maximum number of locals in a definitionlocals-idef
maximum number of word lists in search ordersearch-idef
maximum size of a counted stringcore-idef
maximum size of a definition name, in characterscore-idef
maximum size of a parsed stringcore-idef
maximum size of input linefile-idef
maximum string length for ENVIRONMENT?, in characterscore-idef
mem-doCounted Loops
mem,Dictionary allocation
mem+doCounted Loops
memory access wordsMemory Access
memory access/allocation tutorialMemory Tutorial
memory alignment tutorialAlignment Tutorial
memory block wordsMemory Blocks
memory overcommit for dictionary and stacksInvoking Gforth
memory wordsMemory
memory-allocation word setHeap Allocation
memory-allocation words, implementation-defined optionsmemory-idef
memory-allocation words, system documentationThe optional Memory-Allocation word set
message sendObject-Oriented Terminology
metacompilerCross Compiler
methodObject-Oriented Terminology
methodObjects Glossary
methodClass Declaration
methodBasic Mini-OOF Usage
method conveniencesMethod conveniences
method mapObjects Implementation
method selectorObject-Oriented Terminology
method usageBasic OOF Usage
methodsObjects Glossary
methods...end-methodsDividing classes
minSingle precision
mini-oof exampleMini-OOF Example
mini-oof usageBasic Mini-OOF Usage
mini-oof.fs, differences to other modelsComparison with other object models
minimum search ordersearch-idef
miscellaneous wordsMiscellaneous Words
mixed precision arithmetic wordsMixed precision
modInteger division
modfInteger division
modf-stage2mTwo-stage integer division
modifying >INHow does that work?
Modifying a word defined earlierMaking a word current
modifying the contents of the input buffer or a string literalcore-ambcond
modsInteger division
modulusInteger division
most recent definition does not have a name (IMMEDIATE)core-ambcond
motivation for object-oriented programmingWhy object-oriented programming?
moveMemory Blocks
msKeeping track of Time
MS, repeatability to be expectedfacility-idef
Multiple exits from beginBEGIN loops with multiple exits
Must now be used inside C-LIBRARY, see C interface docMigrating the C interface from earlier Gforth
muxBitwise operations
mwordsWord Lists

nLocating source code definitions
n, stack item typeNotation
n/aUser-defined TO and DEFER@
n>rReturn stack
nameThe Input Stream
name dictionaryIntroducing the Text Interpreter
name field addressName token
name lookup, case-sensitivitycore-idef
name not defined by VALUE or (LOCAL) used by TOlocals-ambcond
name not defined by VALUE used by TOcore-ambcond
name not foundcore-ambcond
name not found (', POSTPONE, ['], [COMPILE])core-ambcond
name tokenName token
name, maximum lengthcore-idef
name>compileName token
name>interpretName token
name>linkName token
name>stringName token
name$widget methods
names for defined wordsSupplying names
NaNFloating Point
native@i18n and l10n
needsForth source files
negateSingle precision
negative increment for counted loopsCounted Loops
Neon modelComparison with other object models
nested colon definitionsQuotations
newBasic Mini-OOF Usage
new-color:widget methods
newlineString and character literals
newline character on inputcore-idef
newtaskBasic multi-tasking
newtask4Basic multi-tasking
NEXTCounted Loops
next-argOS command line arguments
next-caseArbitrary control structures
NEXT, direct threadedThreading
NEXT, indirect threadedThreading
nextnameSupplying names
NFAName token
nipData stack
nocov[Code Coverage
non-graphic characters and EMITcore-idef
non-relocatable image filesNon-Relocatable Image Files
nonameAnonymous Definitions
noname-fromCreating from a prototype
noopExecution token
notation of glossary entriesNotation
notfoundDealing with existing Recognizers
nothrowException Handling
nr>Return stack
nsKeeping track of Time
ntLocating exception source
nt (name token)Name token
NT Forth performancePerformance
nt input formatLiterals in source code
nt token input formatLiterals in source code
ntimeKeeping track of Time
number conversionNumber Conversion
number conversion - traps for the unwaryNumber Conversion
number of bits in one address unitcore-idef
number representation and arithmeticcore-idef
numeric comparison wordsNumeric comparison
numeric output - formattedFormatted numeric output
numeric output - simple/free-formatSimple numeric output
numeric output, FPFloating-point output
nwLocating uses of a word

objectObject-Oriented Terminology
objectObjects Glossary
objectBasic Mini-OOF Usage
object allocation optionsCreating objects
object classThe Objects base class
object creationCreating objects
object interfacesObject Interfaces
object models, comparisonComparison with other object models
object-:The OOF base class
object-::The OOF base class
object-'The OOF base class
object-[]The OOF base class
object-asptrThe OOF base class
object-bindThe OOF base class
object-boundThe OOF base class
object-classThe OOF base class
object-class?The OOF base class
object-definitionsThe OOF base class
object-disposeThe OOF base class
object-endwithThe OOF base class
object-initThe OOF base class
object-isThe OOF base class
object-linkThe OOF base class
object-map discussionObjects Implementation
object-newThe OOF base class
object-new[]The OOF base class
object-oriented programmingObjects
object-oriented programmingOOF
object-oriented programming motivationWhy object-oriented programming?
object-oriented programming styleObject-Oriented Programming Style
object-oriented terminologyObject-Oriented Terminology
object-postponeThe OOF base class
object-ptrThe OOF base class
object-selfThe OOF base class
object-superThe OOF base class
object-withThe OOF base class
objects, basic usageBasic Objects Usage
objects.fs GlossaryObjects Glossary
objects.fs implementationObjects Implementation
objects.fs propertiesProperties of the Objects model
ofArbitrary control structures
offBoolean Flags
onBoolean Flags
OnlyWord Lists
oof.fs base classThe OOF base class
oof.fs propertiesProperties of the OOF model
oof.fs usageBasic OOF Usage
oof.fs, differences to other modelsComparison with other object models
open-fileGeneral files
open-libLow-Level C Interface Words
open-path-fileGeneral Search Paths
operating system - passing commandsPassing Commands to the OS
operator’s terminal facilities availablecore-other
opt:User-defined compile-comma
options on the command lineInvoking Gforth
orBitwise operations
orderWord Lists
orig, control-flow stack itemArbitrary control structures
OS command line argumentsOS command line arguments
os-classEnvironmental Queries
os-typeEnvironmental Queries
other system documentation, block wordsblock-other
other system documentation, core wordscore-other
outMiscellaneous output
outer interpreterIntroducing the Text Interpreter
outer interpreterStacks and Postfix notation
outer interpreterThe Text Interpreter
output in pipesGforth in pipes
Output RedirectionRedirection
output to terminalTerminal output
overData stack
overcommit memory for dictionary and stacksInvoking Gforth
overflow of the pictured numeric output stringcore-ambcond
overridesObjects Glossary
overrides usageBasic Objects Usage

padMemory Blocks
PAD sizecore-idef
PAD use by nonstandard wordscore-other
pageTerminal output
par-splitwidget methods
parameter stackStack Manipulation
parameters are not of the same type (DO, ?DO, WITHIN)core-ambcond
parent classObject-Oriented Terminology
parent class bindingClass Binding
parent-wwidget methods
parseThe Input Stream
parse areaThe Text Interpreter
parse-nameThe Input Stream
parse-wordThe Input Stream
parsed string overflowcore-ambcond
parsed string, maximum sizecore-idef
parsing wordsHow does that work?
parsing wordsHow does that work?
parsing wordsThe Text Interpreter
passBasic multi-tasking
patching threaded codeDynamic Superinstructions
path for includedSearch Paths
path+General Search Paths
path=General Search Paths
pauseBasic multi-tasking
pedigree of GforthOrigin
performExecution token
performance of some Forth interpretersPerformance
persistent form of dictionaryImage Files
PFE performancePerformance
piFloating Point
pickData stack
pictured numeric outputFormatted numeric output
pictured numeric output buffer, sizecore-idef
pictured numeric output string, overflowcore-ambcond
pipes, creating your ownPipes
pipes, Gforth as part ofGforth in pipes
POSTPONE applied to [IF]programming-ambcond
POSTPONE or [COMPILE] applied to TOcore-ambcond
postpone tutorialPOSTPONE Tutorial
postpone,Compilation token
Pountain’s object-oriented modelComparison with other object models
pow2?Bitwise operations
precisionFloating-point output
precompiled Forth codeImage Files
prefix `Execution token
prepend-whereLocating uses of a word
preserveDeferred Words
previousWord Lists
previous, search order emptysearch-ambcond
primitive source formatAutomatic Generation
primitive-centric threaded codeDirect or Indirect Threaded?
primitives, assembly code listingProduced code
primitives, automatic generationAutomatic Generation
primitives, implementationPrimitives
primitives, keeping the TOS in a registerTOS Optimization
prims2x.fsAutomatic Generation
printObjects Glossary
private discussionClasses and Scoping
procedures, tutorialColon Definitions Tutorial
process-optionModifying the Startup Sequence
program data space availablecore-other
programming style, arbitrary control structuresArbitrary control structures
programming style, localsLocals programming style
programming style, object-orientedObject-Oriented Programming Style
programming toolsProgramming Tools
programming-tools words, ambiguous conditionsprogramming-ambcond
programming-tools words, implementation-defined optionsprogramming-idef
programming-tools words, system documentationThe optional Programming-Tools word set
pronounciation of wordsNotation
protectedObjects Glossary
protected discussionClasses and Scoping
ptrClass Declaration
publicObjects Glossary

queryInput Sources
quitMiscellaneous Words

r, stack item typeNotation
r@Return stack
r/oGeneral files
r/wGeneral files
r>Return stack
raisewidget methods
ranges for integer typescore-idef
rdropReturn stack
re-colorwidget methods
re-emoji-colorwidget methods
re-fade-colorwidget methods
re-text-colorwidget methods
re-text-emoji-fade-colorwidget methods
read-csvCSV Reader
read-fileGeneral files
read-lineGeneral files
read-only data space regionscore-idef
reading from file positions not yet writtenfile-ambcond
rec-bodyDealing with existing Recognizers
rec-dtickDealing with existing Recognizers
rec-floatDealing with existing Recognizers
rec-ntDealing with existing Recognizers
rec-numDealing with existing Recognizers
rec-stringDealing with existing Recognizers
rec-tickDealing with existing Recognizers
rec-toDealing with existing Recognizers
receiving objectObject-Oriented Terminology
reciprocal of integerTwo-stage integer division
recognizeDealing with existing Recognizers
recognizer-sequence:Dealing with existing Recognizers
Recognizers normal usageDefault Recognizers
Recognizers, dealing withDealing with existing Recognizers
records tutorialArrays and Records Tutorial
recover (old Gforth versions)Exception Handling
recurseCalls and returns
RECURSE appears after DOES>core-ambcond
recursion tutorialRecursion Tutorial
recursiveCalls and returns
recursive definitionsCalls and returns
refillThe Input Stream
regexpsRegular Expressions
relocating loaderImage File Background
relocation at load-timeImage File Background
relocation at run-timeImage File Background
remainderInteger division
rename-fileGeneral files
REPEATArbitrary control structures
repeatability to be expected from the execution of MSfacility-idef
ReplicationDynamic Superinstructions
report the words used in your programStandard Report
reposition-fileGeneral files
REPOSITION-FILE, outside the file’s boundariesfile-ambcond
representFloating-point output
REPRESENT, results when float is out of rangefloating-idef
requireForth source files
require, placement in filesEmacs Tags
requiredForth source files
reserving data spaceDictionary allocation
resizeHeap Allocation
resize-fileGeneral files
resizedwidget methods
restartBasic multi-tasking
restoreException Handling
restore-inputInput Sources
RESTORE-INPUT, Argument type mismatchcore-ambcond
restrictInterpretation and Compilation Semantics
Result out of rangeInteger division
result out of rangecore-ambcond
Result out of range (on integer division)Integer division
return stackStack Manipulation
return stack and localsReturn stack
return stack dump with gforth-fastError messages
return stack manipulation wordsReturn stack
return stack space availablecore-other
return stack tutorialReturn Stack Tutorial
return stack underflowcore-ambcond
return-stack-cellsEnvironmental Queries
returning from a definitionCalls and returns
revealCreating from a prototype
rolBitwise operations
rollData stack
RootWord Lists
rorBitwise operations
rotData stack
rounding of floating-point numbersfloating-idef
rp!Stack pointer manipulation
rp@Stack pointer manipulation
rp0Stack pointer manipulation
rshiftBitwise operations
RSHIFT, large shift countscore-ambcond
run-time code generation, tutorialAdvanced macros Tutorial
running GforthInvoking Gforth
running image filesRunning Image Files
Rydqvist, GoranEmacs and Gforth

S"String and character literals
S", number of string buffersfile-idef
S", size of string bufferfile-idef
s//Regular Expressions
s\"String and character literals
s+String words
s>>Regular Expressions
s>dDouble precision
s>fFloating Point
s>number?Line input and conversion
s>unumber?Line input and conversion
safe/stringString words
save-covCode Coverage
save-inputInput Sources
save-memHeap Allocation
savesystemNon-Relocatable Image Files
savesystem during gforthmigforthmi
scanString words
scan-backString words
scopeWhere are locals visible by name?
scope of localsWhere are locals visible by name?
scoping and classesClasses and Scoping
scrolledactor methods
sealWord Lists
searchString words
search order stackWord Lists
search order, maximum depthsearch-idef
search order, minimumsearch-idef
search order, tutorialWordlists and Search Order Tutorial
search path control, source filesSource Search Paths
search path control, source filesGeneral Search Paths
search path for filesSearch Paths
search-order words, ambiguous conditionssearch-ambcond
search-order words, implementation-defined optionssearch-idef
search-order words, system documentationThe optional Search-Order word set
search-wordlistWord Lists
seeExamining compiled code
see tutorialDecompilation Tutorial
see-codeExamining compiled code
see-code-rangeExamining compiled code
SEE, source and format of outputprogramming-idef
selectBoolean Flags
selection control structuresSelection
selectorObject-Oriented Terminology
selectorObjects Glossary
selector implementation, classObjects Implementation
selector invocationObject-Oriented Terminology
selector invocation, restrictionsBasic Objects Usage
selector invocation, restrictionsBasic OOF Usage
selector usageBasic Objects Usage
selectors and stack effectsObject-Oriented Programming Style
selectors common to hardly-related classesObject Interfaces
semantics tutorialInterpretation and Compilation Semantics and Immediacy Tutorial
semantics, interpretation and compilationInterpretation and Compilation Semantics
send-eventMessage queues
setactor methods
set->compHeader methods
set->intHeader methods
set-currentWord Lists
set-does>CREATE..DOES> details
set-executeHeader methods
set-forth-recognizeDealing with existing Recognizers
set-name>linkHeader methods
set-name>stringHeader methods
set-optimizerUser-defined compile-comma
set-orderWord Lists
set-precisionFloating-point output
set-recognizersDealing with existing Recognizers
set-toUser-defined TO and DEFER@
sf_, stack item typeNotation
sf!Memory Access
sf@Memory Access
sf@ or sf! used with an address that is not single-float alignedfloating-ambcond
sfalignDictionary allocation
sfalignedAddress arithmetic
sffield:Forth200x Structures
sfloat/Address arithmetic
sfloat%Structure Glossary
sfloat+Address arithmetic
sfloatsAddress arithmetic
shPassing Commands to the OS
sh-getPassing Commands to the OS
Shared libraries in C interfaceDeclaring OS-level libraries
shell commandsPassing Commands to the OS
shift-argsOS command line arguments
short-whereLocating uses of a word
showactor methods
show-youactor methods
signFormatted numeric output
sign extensionSpecial Memory Accesses
silent exiting from GforthGforth in pipes
simple defining wordsCREATE
simple loopsSimple Loops
simple-fkey-stringSingle-key input
simple-seeExamining compiled code
simple-see-rangeExamining compiled code
single precision arithmetic wordsSingle precision
single-assignment style for localsLocals programming style
single-cell numbers, input formatLiterals in source code
single-key inputSingle-key input
singlestep DebuggerSinglestep Debugger
size of buffer at WORDcore-idef
size of the dictionary and the stacksInvoking Gforth
size of the keyboard terminal buffercore-idef
size of the pictured numeric output buffercore-idef
size of the scratch area returned by PADcore-idef
size parameters for command-line optionsInvoking Gforth
skipString words
slurp-fidGeneral files
slurp-fileGeneral files
sm/remInteger division
sourceThe Text Interpreter
source code for exceptionLocating exception source
source code of a wordLocating source code definitions
source location of error or debugging output in EmacsEmacs and Gforth
source-idInput Sources
SOURCE-ID, behaviour when BLK is non-zerofile-ambcond
sourcefilenameForth source files
sourceline#Forth source files
sp!Stack pointer manipulation
sp@Stack pointer manipulation
sp0Stack pointer manipulation
spaceMiscellaneous output
space delimiterscore-idef
spacesMiscellaneous output
spanLine input and conversion
speed, startupStartup speed
splitwidget methods
stability of GforthStability Goals
stack depth changes during interpretationStack depth changes
stack effectNotation
Stack effect design, tutorialDesigning the stack effect Tutorial
stack effect of DOES>-partsUser-defined defining words using CREATE
stack effect of included filesForth source files
stack effects of selectorsObject-Oriented Programming Style
stack emptycore-ambcond
stack item typesNotation
stack manipulation tutorialStack Manipulation Tutorial
stack manipulation wordsStack Manipulation
stack manipulation words, floating-point stackFloating point stack
stack manipulation words, return stackReturn stack
stack manipulations words, data stackData stack
stack overflowcore-ambcond
stack pointer manipulation wordsStack pointer manipulation
stack size defaultStack and Dictionary Sizes
stack size, cache-friendlyStack and Dictionary Sizes
stack space availablecore-other
stack tutorialStack Tutorial
stack underflowcore-ambcond
stack-cellsEnvironmental Queries
stack-effect comments, tutorialStack-Effect Comments Tutorial
stacksizeBasic multi-tasking
stacksize4Basic multi-tasking
staged/-divisorTwo-stage integer division
staged/-sizeTwo-stage integer division
Standard conformance of GforthStandard conformance
starting Gforth tutorialStarting Gforth Tutorial
startup sequence for image fileModifying the Startup Sequence
Startup speedStartup speed
state - effect on the text interpreterHow does that work?
STATE valuescore-idef
state-smart words (are a bad idea)Combined words
staticClass Declaration
status-colorTerminal output
stderrGeneral files
stderr and pipesGforth in pipes
stdinGeneral files
stdoutGeneral files
stopBasic multi-tasking
stop-nsBasic multi-tasking
str<String words
str=String words
str=?Regular Expressions
String input formatLiterals in source code
string larger than pictured numeric output area (f., fe., fs.)floating-ambcond
string literalsString and character literals
string longer than a counted string returned by WORDcore-ambcond
string words with $$tring words
string-parseThe Input Stream
string-prefix?String words
string-suffix?String words
string,Counted string words
strings - see character stringsString representations
strings tutorialCharacters and Strings Tutorial
structStructure Glossary
struct usageStructure Usage
structs tutorialArrays and Records Tutorial
structure extensionStructure Usage
structure glossaryStructure Glossary
structure implementationStructure Implementation
structure naming conventionStructure Naming Convention
structure naming conventionStructure Naming Convention
structure of Forth programsForth is written in Forth
structure usageStructure Usage
structures containing arraysStructure Usage
structures containing structuresStructure Usage
Structures in Forth200xForth200x Structures
structures using address arithmeticWhy explicit structure support?
sub-list?Locals implementation
success-colorTerminal output
superclass bindingClass Binding
SuperinstructionsDynamic Superinstructions
swapData stack
symmetric divisionInteger division
syntax tutorialSyntax Tutorial
systemPassing Commands to the OS
system dictionary space required, in address unitscore-other
system documentationStandard conformance
system documentation, block wordsThe optional Block word set
system documentation, core wordsThe Core Words
system documentation, double wordsThe optional Double Number word set
system documentation, exception wordsThe optional Exception word set
system documentation, facility wordsThe optional Facility word set
system documentation, file wordsThe optional File-Access word set
system documentation, floating-point wordsThe optional Floating-Point word set
system documentation, locals wordsThe optional Locals word set
system documentation, memory-allocation wordsThe optional Memory-Allocation word set
system documentation, programming-tools wordsThe optional Programming-Tools word set
system documentation, search-order wordsThe optional Search-Order word set
system promptcore-idef

tableWord Lists
TAGS fileEmacs Tags
target compilercross.fs
target compilerCross Compiler
taskBasic multi-tasking
task-local dataTask-local data
terminal buffer, sizecore-idef
terminal input bufferThe Text Interpreter
terminal outputTerminal output
terminal sizeTerminal output
terminology for object-oriented programmingObject-Oriented Terminology
text interpreterIntroducing the Text Interpreter
text interpreterStacks and Postfix notation
text interpreterThe Text Interpreter
text interpreter - effect of stateHow does that work?
text interpreter - input sourcesThe Text Interpreter
text interpreter - input sourcesInput Sources
text-color:widget methods
text-emoji-color:widget methods
text-emoji-fade-color:widget methods
THENArbitrary control structures
thirdData stack
thisObjects Glossary
this and catchObjects Implementation
this implementationObjects Implementation
this usageMethod conveniences
ThisForth performancePerformance
threaded code implementationThreading
threading wordsThreading Words
threading-methodThreading Words
threading, direct or indirect?Direct or Indirect Threaded?
throwException Handling
THROW-codes used in the systemexception-idef
tibThe Text Interpreter
tick (’)Execution token
TILE performancePerformance
time-related wordsKeeping track of Time
time&dateKeeping track of Time
TMP, TEMP - environment variableEnvironment variables
TO on non-VALUEscore-ambcond
TO on non-VALUEs and non-localslocals-ambcond
to-method:User-defined TO and DEFER@
to-table:User-defined TO and DEFER@
to-thisObjects Glossary
tokens for wordsTokens for Words
TOS definitionStacks and Postfix notation
TOS optimization for primitivesTOS Optimization
touchdownactor methods
touchupactor methods
translate-dnumDealing with existing Recognizers
translate-method:Dealing with existing Recognizers
translate-ntDealing with existing Recognizers
translate-numDealing with existing Recognizers
translate-stateDealing with existing Recognizers
translate:Dealing with existing Recognizers
traverse-wordlistName token
trigonometric operationsFloating Point
trueBoolean Flags
truncation of floating-point numbersfloating-idef
tryException Handling
try-recognizeDealing with existing Recognizers
ttLocating exception source
tuckData stack
turnkey image filesModifying the Startup Sequence
typeDisplaying characters and strings
types of localsGforth locals
types of stack itemsNotation
types tutorialTypes Tutorial
typewhiteDisplaying characters and strings

u-[doCounted Loops
U-DOCounted Loops
u, stack item typeNotation
u.Simple numeric output
u.rSimple numeric output
u*/Integer division
u*/modInteger division
u/Integer division
u/-stage1mTwo-stage integer division
u/-stage2mTwo-stage integer division
u/modInteger division
u/mod-stage2mTwo-stage integer division
U+DOCounted Loops
u<Numeric comparison
u<=Numeric comparison
u>Numeric comparison
u>=Numeric comparison
uallotTask-local data
ud, stack item typeNotation
ud.Simple numeric output
ud.rSimple numeric output
ud/modInteger division
UDeferTask-local data
ukeyedactor methods
um*Mixed precision
um/modInteger division
umaxSingle precision
uminSingle precision
umodInteger division
umod-stage2mTwo-stage integer division
unaligned memory accessSpecial Memory Accesses
uncolored-modeTerminal output
undefined wordcore-ambcond
undefined word, ', POSTPONE, ['], [COMPILE]core-ambcond
under+Single precision
unexpected end of the input buffercore-ambcond
unloopCounted Loops
unmapped block numbersfile-ambcond
UNREACHABLEWhere are locals visible by name?
UNTILArbitrary control structures
UNTIL loopSimple Loops
unusedDictionary allocation
unused-wordsLocating uses of a word
unwind-protectException Handling
up@Task-local data
UPDATE, no current block bufferblock-ambcond
upper and lower caseCase insensitivity
UserTask-local data
user input device, method of selectingcore-idef
user output device, method of selectingcore-idef
user spaceTask-local data
user variablesTask-local data
user-defined defining wordsUser-defined Defining Words
user'Task-local data
Uses of a wordLocating uses of a word
utimeKeeping track of Time
UValueTask-local data

v*Floating Point
value-flavoured localsGforth locals
varClass Declaration
varBasic Mini-OOF Usage
variable-flavoured localsGforth locals
variadic C functionsDeclaring C Functions
varue-flavoured localsGforth locals
versions, invoking other versions of GforthInvoking Gforth
vgluewidget methods
vglue@widget methods
view (called locate in Gforth)Locating source code definitions
viewing the documentation of a word in EmacsEmacs and Gforth
viewing the source of a word in EmacsEmacs Tags
virtual functionObject-Oriented Terminology
virtual function tableObjects Implementation
virtual machineEngine
virtual machine instructions, implementationPrimitives
visibility of localsWhere are locals visible by name?
vlistWord Lists
Vocabularies, detailed explanationVocabularies
VocabularyWord Lists
vocsWord Lists
vocstack empty, previoussearch-ambcond
vocstack full, alsosearch-ambcond
vp-bottomwidget methods
vp-leftwidget methods
vp-neededwidget methods
vp-reslidewidget methods
vp-rightwidget methods
vp-topwidget methods

wwidget methods
w-colorwidget methods
w,Dictionary allocation
w, stack item typeNotation
W:Locals definition words
w!Special Memory Accesses
w@Special Memory Accesses
w/oGeneral files
W^Locals definition words
w>sSpecial Memory Accesses
WA:Locals definition words
walignAddress arithmetic
walignedAddress arithmetic
warning-colorTerminal output
WARNING"Exception Handling
warningsException Handling
wbeSpecial Memory Accesses
wfield:Forth200x Structures
whereLocating uses of a word
where to go nextWhere to go next
wheregLocating uses of a word
WHILEArbitrary control structures
WHILE loopSimple Loops
widWord Lists
wid, stack item typeNotation
widgetMINOS2 object framework
Win32Forth performancePerformance
wior type descriptionNotation
wior values and meaningfile-idef
withinNumeric comparison
wleSpecial Memory Accesses
wordIntroducing the Text Interpreter
wordThe Input Stream
WORD buffer sizecore-idef
word glossary entry formatNotation
word list for defining localsLocals implementation
word listsWord Lists
word lists - exampleWord list example
word lists - why use them?Why use word lists?
word name too longcore-ambcond
WORD, string overflowcore-ambcond
wordlistWord Lists
wordlist-wordsWord Lists
wordlistsEnvironmental Queries
wordlists tutorialWordlists and Search Order Tutorial
wordsWord Lists
words used in your programStandard Report
words, forgettingForgetting words
wrap-xtDeferred Words
write-fileGeneral files
write-lineGeneral files
wrolBitwise operations
wrorBitwise operations
wwLocating uses of a word

xwidget methods
x-sizeXchars and Unicode
x-widthXchars and Unicode
x,Dictionary allocation
x!Special Memory Accesses
x@Special Memory Accesses
x\string-Xchars and Unicode
x>sSpecial Memory Accesses
xalignAddress arithmetic
xalignedAddress arithmetic
xbeSpecial Memory Accesses
xc-sizeXchars and Unicode
xc-widthXchars and Unicode
xc,Xchars and Unicode
xc!+Xchars and Unicode
xc!+?Xchars and Unicode
xc@Xchars and Unicode
xc@+Xchars and Unicode
xc@+?Xchars and Unicode
xchar-Xchars and Unicode
XCHAR-ENCODINGEnvironmental Queries
XCHAR-MAXMEMEnvironmental Queries
xchar+Xchars and Unicode
xd,Dictionary allocation
xd!Special Memory Accesses
xd@Special Memory Accesses
xd>sSpecial Memory Accesses
xdbeSpecial Memory Accesses
xdleSpecial Memory Accesses
xemitDisplaying characters and strings
xfield:Forth200x Structures
xholdXchars and Unicode
xkeyXchars and Unicode
xkey?Single-key input
xleSpecial Memory Accesses
xorBitwise operations
xtIntroducing the Text Interpreter
xtExecution token
xt input formatLiterals in source code
XT tutorialExecution Tokens Tutorial
xt-newObjects Glossary
xt-seeExamining compiled code
xt-see-codeExamining compiled code
xt-simple-seeExamining compiled code
xt, stack item typeNotation
XT:Locals definition words
xt>nameName token
XTA:Locals definition words
xywhwidget methods
xywhdwidget methods

ywidget methods

zero-length string as a namecore-ambcond
Zsoter’s object-oriented modelComparison with other object models