Concept Index (Gforth Manual)

Previous: Word Index, Up: Gforth [Contents][Index]

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

-

`-`	Single precision
`--`	Locals definition words
`-->`	Blocks
–, tutorial	Stack-Effect Comments Tutorial
`-[do`	Counted Loops
`-\d`	Regular Expressions
`-\s`	Regular Expressions
-`	Regular Expressions
`->here`	Dictionary allocation
–appl-image, command-line option	Invoking Gforth
–application, `gforthmi` option	gforthmi
`-c?`	Regular Expressions
`-char`	Regular Expressions
`-class`	Regular Expressions
–clear-dictionary, command-line option	Invoking Gforth
–code-block-size, command-line option	Invoking Gforth
-d, command-line option	Invoking Gforth
-D, command-line option	Invoking Gforth
–data-stack-size, command-line option	Invoking Gforth
–debug-mcheck, command-line option	Invoking Gforth
–debug, command-line option	Invoking Gforth
-DFORCE_REG	Portability
–diag, command-line option	Invoking Gforth
–dictionary-size, command-line option	Invoking Gforth
–die-on-signal, command-line-option	Invoking Gforth
`-DO`	Counted Loops
-DUSE_FTOS	TOS Optimization
-DUSE_NO_FTOS	TOS Optimization
-DUSE_NO_TOS	TOS Optimization
-DUSE_TOS	TOS Optimization
–dynamic command-line option	Dynamic Superinstructions
–dynamic, command-line option	Invoking Gforth
–enable-force-reg, configuration flag	Portability
-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
–ignore-async-signals, command-line-option	Invoking Gforth
–image file, invoke image file	Running Image Files
–image-file, command-line option	Invoking Gforth
`-inf`	Floating Point
`-infinity`	Floating Point
-l, command-line option	Invoking Gforth
–locals-stack-size, command-line option	Invoking Gforth
`-LOOP`	Counted Loops
`-ltrace`	Debugging
-m, command-line option	Invoking Gforth
–map_32bit, command-line option	Invoking Gforth
–no-0rc, command-line option	Invoking Gforth
–no-dynamic command-line option	Dynamic Superinstructions
–no-dynamic-image, command-line option	Invoking Gforth
–no-dynamic, command-line option	Invoking Gforth
–no-offset-im, command-line option	Invoking Gforth
–no-super command-line option	Dynamic Superinstructions
–no-super, command-line option	Invoking Gforth
–offset-image, command-line option	Invoking Gforth
–opt-ip-updates, command-line option	Invoking Gforth
-p, command-line option	Invoking Gforth
–path, command-line option	Invoking Gforth
–print-metrics, command-line option	Invoking Gforth
–print-nonreloc, command-line option	Invoking Gforth
–print-prims, command-line option	Invoking Gforth
–print-sequences, command-line option	Invoking Gforth
-r, command-line option	Invoking Gforth
–return-stack-size, command-line option	Invoking Gforth
`-rot`	Data stack
–ss-greedy, command-line option	Invoking Gforth
–ss-min-..., command-line options	Invoking Gforth
–ss-number, command-line option	Invoking Gforth
`-stack`	User-defined Stacks
`-status`	Text interpreter status
–tpa-noautomaton, command-line option	Invoking Gforth
–tpa-noequiv, command-line option	Invoking Gforth
–tpa-trace, command-line option	Invoking Gforth
`-trailing`	String words
`-trailing-garbage`	Xchars and Unicode
-v, command-line option	Invoking Gforth
–version, command-line option	Invoking Gforth
–vm-commit, command-line option	Invoking Gforth
-W, command-line option	Invoking Gforth
-Wall, command-line option	Invoking Gforth
-Werror, command-line option	Invoking Gforth
-Won, command-line option	Invoking Gforth
-Wpedantic, command-line option	Invoking Gforth

,
`,`	Dictionary allocation

;
`;`	Colon Definitions
`;]`	Quotations
`;>`	How do I write outer locals?
`;abi-code`	Assembler Definitions
`;code`	Assembler Definitions
`;CODE` ending sequence	programming-idef
`;CODE`, name not defined via `CREATE`	programming-ambcond
`;CODE`, processing input	programming-idef
`;inline`	Inline Definitions
`;m`	Objects Glossary
`;m` usage	Method conveniences

:
`:`	Colon Definitions
`:`, passing data across	Literals
`::`	Basic Mini-OOF Usage
`:}`	Locals definition words
`:}d`	Closures
`:}h`	Closures
`:}h1`	Closures
`:}l`	Closures
`:}xt`	Closures
`:is`	Deferred Words
`:m`	Objects Glossary
`:method`	Mini-OOF2
`:noname`	Anonymous Definitions

!
`!`	Memory Access
`!!FIXME!!`	Debugging
`!@`	Memory Access
`!localn`	Locals implementation
`!resize`	widget methods
`!size`	widget methods

?
`?`	Examining data
`???`	Debugging
`?cov+`	Code Coverage
`?DO`	Counted Loops
`?dup`	Data stack
`?DUP-0=-IF`	Arbitrary control structures
`?dup-IF`	Arbitrary control structures
`?errno-throw`	Exception Handling
`?events`	Message queues
`?EXIT`	Calls and returns
`?inside`	actor methods
`?ior`	Exception Handling
`?LEAVE`	Counted Loops
`?of`	General control structures with CASE
`?rec-found`	Performing translation actions

.
`.`	Simple numeric output
`.-is-dcell?`	Default recognizers
`.?`	Regular Expressions
`...`	Examining data
`..char`	Regular Expressions
`."`	Miscellaneous output
`."`, how it works	How does that work?
`.(`	Miscellaneous output
`.\"`	Miscellaneous output
`.cover-raw`	Code Coverage
`.coverage`	Code Coverage
`.debugline`	Debugging
`.emacs`	Installing gforth.el
`.fi` files	Image Files
`.fpath`	Source Search Paths
`.gforth-history`	Command-line editing
`.hm`	Header methods
`.id`	Name token
`.included`	Forth source files
`.locale-csv`	Internationalization and localization
`.path`	General Search Paths
`.quoted-csv`	CSV reading and writing
`.r`	Simple numeric output
`.s`	Examining data
`.sections`	Sections
`.substitute`	Substitute
`.unresolved`	Calls and returns
`.voc`	Word Lists
`.widget`	widget methods

'
`'`	Execution token
’-prefix for characters/code points	Integer and character literals
`'`, stack item type	Notation
`'cold`	Modifying the Startup Sequence
`'s`	Task-local data

"
`"`, stack item type	Notation

(
`(`	Comments
`((`	Regular Expressions
`(local)`	Standard Forth locals

)
`)`	Assertions
`))`	Regular Expressions

[
`[`	Literals
`[:`	Quotations
`[?DO]`	Interpreter Directives
`[']`	Execution token
`[{:`	Closures
`[+LOOP]`	Interpreter Directives
`[AGAIN]`	Interpreter Directives
`[BEGIN]`	Interpreter Directives
`[bind]`	Objects Glossary
`[bind]` usage	Class Binding
`[char]`	String and character literals
`[COMP']`	Compilation token
`[compile]`	Macros
`[current]`	Objects Glossary
`[d:d`	Closures
`[d:h`	Closures
`[d:h1`	Closures
`[d:l`	Closures
`[defined]`	Interpreter Directives
`[DO]`	Interpreter Directives
`[ELSE]`	Interpreter Directives
`[ENDIF]`	Interpreter Directives
`[f:d`	Closures
`[f:h`	Closures
`[f:h1`	Closures
`[f:l`	Closures
`[FOR]`	Interpreter Directives
`[I]`	Interpreter Directives
`[IF]`	Interpreter Directives
`[IF]` and `POSTPONE`	programming-ambcond
`[IF]`, end of the input source before matching `[ELSE]` or `[THEN]`	programming-ambcond
`[IFDEF]`	Interpreter Directives
`[IFUNDEF]`	Interpreter Directives
`[LOOP]`	Interpreter Directives
`[n:d`	Closures
`[n:h`	Closures
`[n:h1`	Closures
`[n:l`	Closures
`[NEXT]`	Interpreter Directives
`[noop]`	Execution token
`[parent]`	Objects Glossary
`[parent]` usage	Class Binding
`[REPEAT]`	Interpreter Directives
`[THEN]`	Interpreter Directives
`[to-inst]`	Objects Glossary
`[undefined]`	Interpreter Directives
`[UNTIL]`	Interpreter Directives
`[WHILE]`	Interpreter Directives

]
`]`	Literals
`]]`	Macros
`]L`	Literals
`]nocov`	Code Coverage

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

}
`}`	Locals definition words
`}}`	Regular Expressions

@
`@`	Memory Access
`@localn`	Locals implementation

*
`*`	Single precision
`*}`	Regular Expressions
`**}`	Regular Expressions
`*/`	Integer division
`*/f`	Integer division
`*/mod`	Integer division
`*/modf`	Integer division
`*/mods`	Integer division
`*/s`	Integer division
`*align`	Address arithmetic
`*aligned`	Address arithmetic

/
`/`	Integer division
`//`	Regular Expressions
`//g`	Regular Expressions
`//o`	Regular Expressions
`//s`	Regular Expressions
`/COUNTED-STRING`	Environmental Queries
`/f`	Integer division
`/f-stage1m`	Two-stage integer division
`/f-stage2m`	Two-stage integer division
`/HOLD`	Environmental Queries
`/l`	Address arithmetic
`/mod`	Integer division
`/modf`	Integer division
`/modf-stage2m`	Two-stage integer division
`/mods`	Integer division
`/PAD`	Environmental Queries
`/s`	Integer division
`/string`	String words
`/w`	Address arithmetic
`/x`	Address arithmetic

\
`\`	Comments
`\`, editing with Emacs	Emacs and Gforth
`\`, line length in blocks	block-idef
`\(`	Regular Expressions
`\)`	Regular Expressions
`\\\`	Forth source files
`\^`	Regular Expressions
`\$`	Regular Expressions
`\0`	Regular Expressions
`\c`	Declaring C Functions
`\d`	Regular Expressions
`\G`	Comments
`\s`	Regular Expressions

&
&-prefix for decimal numbers	Integer and character literals

#
`#`	Integer to string conversion
#-prefix for decimal numbers	Integer and character literals
`#!`	Running Image Files
`#>`	Integer to string conversion
`#>>`	Integer to string conversion
`#bell`	String and character literals
`#bs`	String and character literals
`#cr`	String and character literals
`#del`	String and character literals
`#eof`	String and character literals
`#esc`	String and character literals
`#ff`	String and character literals
`#lf`	String and character literals
`#line`	Interpreter Directives
`#loc`	Debugging
`#locals`	Environmental Queries
`#s`	Integer to string conversion
`#tab`	String and character literals
`#tib`	The Text Interpreter

%
%-prefix for binary numbers	Integer and character literals
`%align`	Gforth structs
`%alignment`	Gforth structs
`%alloc`	Gforth structs
`%allocate`	Gforth structs
`%allot`	Gforth structs
`%size`	Gforth structs

`
`	Regular Expressions
` prefix	Execution token
` prefix of word	Literals for tokens and addresses
`?	Regular Expressions
`` prefix of word	Literals for tokens and addresses

+
`+`	Single precision
`+!`	Memory Access
`+!@`	Memory Access
`+}`	Regular Expressions
`++}`	Regular Expressions
`+after`	User-defined Stacks
`+char`	Regular Expressions
`+chars`	Regular Expressions
`+class`	Regular Expressions
`+DO`	Counted Loops
`+field`	Standard Structures
`+fmode`	General files
`+load`	Blocks
`+LOOP`	Counted Loops
`+ltrace`	Debugging
`+status`	Text interpreter status
`+thru`	Blocks
`+TO`	Values
`+to name` semantics, changing them	Words with user-defined TO etc.
`+x/string`	Xchars and Unicode

<
`<`	Numeric comparison
`<{:`	How do I write outer locals?
`<#`	Integer to string conversion
`<<`	Regular Expressions
`<<"`	Regular Expressions
`<<#`	Integer to string conversion
`<=`	Numeric comparison
`<>`	Numeric comparison
`<bind>`	Objects Glossary
`<to-inst>`	Objects Glossary

=
`=`	Numeric comparison
`="`	Regular Expressions
`=mkdir`	Directories

>
`>`	Numeric comparison
`>=`	Numeric comparison
`>>`	Regular Expressions
`>addr`	Closures
`>animate`	widget methods
`>back`	User-defined Stacks
`>body`	CREATE..DOES> details
`>BODY` of non-`CREATE`d words	core-ambcond
`>code-address`	Threading Words
`>definer`	Threading Words
`>does-code`	Threading Words
`>float`	String to number conversion
`>float1`	String to number conversion
`>in`	The Text Interpreter
`>IN` greater than input buffer	core-ambcond
`>l`	Locals implementation
`>name`	Name token
`>number`	String to number conversion
`>o`	Mini-OOF2
`>order`	Word Lists
`>pow2`	Bitwise operations
`>r`	Return stack
`>stack`	User-defined Stacks
`>string-execute`	String words
`>time&date&tz`	Keeping track of Time
`>uvalue`	Words with user-defined TO etc.

\|
`\|`	Locals definition words
`\|\|`	Regular Expressions

~
`~~`	Debugging
`~~`, removal with Emacs	Emacs and Gforth
`~~1bt`	Debugging
`~~bt`	Debugging
`~~Value`	Debugging
`~~Variable`	Debugging

$
$-prefix for hexadecimal numbers	Integer and character literals
`$!`	$tring words
`$!len`	$tring words
`$?`	Passing Commands to the OS
`$.`	$tring words
`$[]`	$tring words
`$[]!`	$tring words
`$[].`	$tring words
`$[]@`	$tring words
`$[]#`	$tring words
`$[]+!`	$tring words
`$[]free`	$tring words
`$[]map`	$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
`$del`	$tring words
`$exec`	$tring words
`$free`	$tring words
`$init`	$tring words
`$ins`	$tring words
`$iter`	$tring words
`$over`	$tring words
`$slurp`	$tring words
`$slurp-file`	$tring words
`$split`	String words
`$substitute`	Substitute
`$tmp`	String words
`$unescape`	Substitute
`$value:`	Value-Flavoured and Defer-Flavoured Fields
`$value[]:`	Value-Flavoured and Defer-Flavoured Fields
`$Variable`	$tring words

0
`0<`	Numeric comparison
`0<=`	Numeric comparison
`0<>`	Numeric comparison
`0=`	Numeric comparison
`0>`	Numeric comparison
`0>=`	Numeric comparison
0x-prefix for hexadecimal numbers	Integer and character literals

1
`1-`	Single precision
`1/f`	Floating Point
`1+`	Single precision

2
`2,`	Dictionary allocation
`2!`	Memory Access
`2@`	Memory Access
`2*`	Bitwise operations
`2/`	Bitwise operations
`2>r`	Return stack
`2Constant`	Constants
`2drop`	Data stack
`2dup`	Data stack
`2field:`	Standard Structures
`2lit,`	Literals
`2Literal`	Literals
`2nip`	Data stack
`2over`	Data stack
`2r@`	Return stack
`2r>`	Return stack
`2rdrop`	Return stack
`2rot`	Data stack
`2swap`	Data stack
`2tuck`	Data stack
`2Value`	Values
`2value:`	Value-Flavoured and Defer-Flavoured Fields
`2Variable`	Variables

A
`a_`, stack item type	Notation
`A,`	Dictionary allocation
`abi-code`	Assembler Definitions
`abort`	Exception Handling
`ABORT"`	Exception Handling
`ABORT"`, exception abort sequence	core-idef
`abs`	Single precision
`absolute-file?`	Search Paths
abstract class	Basic Objects Usage
abstract class	Basic OOF Usage
`accept`	String input from the terminal
`ACCEPT`, display after end of input	core-idef
`ACCEPT`, editing	core-idef
`AConstant`	Constants
`act`	widget methods
`act-name$`	actor methods
`action-of`	Deferred Words
`action-of name` semantics, changing them	Words with user-defined TO etc.
`activate`	Basic multi-tasking
`active-w`	actor methods
`actor`	MINOS2 object framework
`add-cflags`	Declaring OS-level libraries
`add-framework`	Declaring OS-level libraries
`add-incdir`	Declaring OS-level libraries
`add-ldflags`	Declaring OS-level libraries
`add-lib`	Declaring OS-level libraries
`add-libpath`	Declaring OS-level libraries
`addr`	Values
`addr name` semantics, changing them	Words with user-defined TO etc.
address alignment exception	core-ambcond
address alignment exception, stack overflow	core-ambcond
address arithmetic words	Address arithmetic
address unit	Address arithmetic
address unit, size in bits	core-idef
`ADDRESS-UNIT-BITS`	Environmental Queries
`addressable:`	Values
`adjust-buffer`	Growable memory buffers
`after-locate`	Locating source code definitions
`AGAIN`	Arbitrary control structures
`AHEAD`	Arbitrary control structures
`Alias`	Synonyms
aliases	Synonyms
`align`	Dictionary allocation
`aligned`	Address arithmetic
aligned addresses	core-idef
alignment faults	core-ambcond
alignment of addresses for types	Address arithmetic
alignment tutorial	Alignment Tutorial
`ALiteral`	Literals
`allocate`	Heap Allocation
`allot`	Dictionary allocation
`also`	Word Lists
`also-path`	General Search Paths
`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
`annotate-cov`	Code Coverage
`ans-report.fs`	Standard Report
`append`	String words
`arg`	OS command line arguments
`argc`	OS command line arguments
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, OS command line	OS command line arguments
`argv`	OS command line arguments
arithmetic words	Arithmetic
arithmetics tutorial	Arithmetics Tutorial
array, iterating over	Counted Loops
`array>mem`	Counted Loops
arrays	CREATE
arrays tutorial	Arrays and Records Tutorial
`arshift`	Bitwise operations
ASCII and UTF-8	Strings and Characters
`asptr`	Class Declaration
assembler	Assembler and Code Words
`assembler`	Assembler Definitions
`ASSEMBLER`, search order capability	programming-idef
`assert-level`	Assertions
`assert(`	Assertions
`assert0(`	Assertions
`assert1(`	Assertions
`assert2(`	Assertions
`assert3(`	Assertions
assertions	Assertions
assignment conversion	How do I write outer locals?
`ASSUME-LIVE`	Where are locals visible by name?
`at-deltaxy`	Terminal output
`at-xy`	Terminal output
`AT-XY` can’t be performed on user output device	facility-ambcond
atomic operations	Hardware operations for multi-tasking
`atomic!@`	Hardware operations for multi-tasking
`atomic?!@`	Hardware operations for multi-tasking
`atomic+!@`	Hardware operations for multi-tasking
Attempt to use zero-length string as a name	core-ambcond
au (address unit)	Address arithmetic
`AUser`	Task-local data
`authors`	Help on Gforth
authors of Gforth	Origin
auto-indentation of Forth code in Emacs	Auto-Indentation
`AValue`	Values
`AVariable`	Variables

B
`b`	Locating source code definitions
`back>`	User-defined Stacks
backtrace	Error messages
backtrace examination	Locating exception source
backtraces with `gforth-fast`	Error messages
`barrier`	Hardware operations for multi-tasking
`base`	Base and integer decimal point
`base` is not decimal (`REPRESENT`, `F.`, `FE.`, `FS.`)	floating-ambcond
`base-execute`	Base and integer decimal point
`baseline`	widget methods
`basename`	Directories
basic objects usage	Basic Objects Usage
batch processing with Gforth	Invoking Gforth
`before-line`	Text Interpreter Hooks
`before-locate`	Locating source code definitions
`before-word`	Text Interpreter Hooks
`BEGIN`	Arbitrary control structures
`begin-structure`	Standard Structures
benchmarking Forth systems	Performance
`Benchres`	Performance
big-endian	Special Memory Accesses
`bin`	General files
`bind`	Objects Glossary
`bind` usage	Class Binding
`bind'`	Objects Glossary
bitwise operation words	Bitwise operations
`bl`	String and character literals
`blank`	Memory Blocks
`blk`	Input Sources
`BLK`, altering `BLK`	block-ambcond
`block`	Blocks
block buffers	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-offset`	Blocks
blocks	Blocks
blocks file	Blocks
blocks files, use with Emacs	Blocks Files
blocks in files	file-idef
`blocks.fb`	Blocks
body-relative address input format	Literals for tokens and addresses
Boolean flags	Boolean Flags
`bootmessage`	Modifying the Startup Sequence
`border`	widget methods
`borderl`	widget methods
`bordert`	widget methods
`borderv`	widget methods
`bounds`	Counted Loops
`break:`	Singlestep Debugger
`break"`	Singlestep Debugger
`broken-pipe-error`	Pipes
`browse`	Locating source code definitions
`bt`	Locating exception source
`buffer`	Blocks
`buffer:`	Variables
`buffer%`	Growable memory buffers
bug reporting	Bugs
`bw`	Locating uses of a word
`bw-cover`	Code Coverage
`bye`	Leaving Gforth
`bye` during `gforthmi`	gforthmi
byte order	Special Memory Accesses

C
C function pointers to Forth words	Callbacks
C function pointers, calling from Forth	Calling C function pointers
C functions, calls to	Calling C Functions
C functions, declarations	Declaring C Functions
C interface	C Interface
`c_`, stack item type	Notation
`c-callback`	Callbacks
`c-callback-thread`	Callbacks
`c-function`	Declaring C Functions
`c-funptr`	Calling C function pointers
`c-library`	Defining library interfaces
`c-library-name`	Defining library interfaces
`c-value`	Declaring C Functions
`c-variable`	Declaring C Functions
`c,`	Dictionary allocation
`c`, stack item type	Notation
C, using C for the engine	Portability
`C:`	Locals definition words
`c!`	Memory Access
`c?`	Regular Expressions
`C"`	Counted string words
`c@`	Memory Access
`C^`	Locals definition words
`c++-library`	Defining library interfaces
`c++-library-name`	Defining library interfaces
`c>s`	Special Memory Accesses
`c$+!`	$tring words
`call-c`	Low-Level C Interface Words
Callback functions written in Forth	Callbacks
`caller-w`	actor methods
calling a definition	Calls and returns
calling C functions	Calling C Functions
`capscompare`	String words
`capssearch`	String words
`capsstring-prefix?`	String words
`case`	General control structures with CASE
`case` as generalized control structure	General control structures with CASE
`CASE` control structure	Selection
case sensitivity	Case insensitivity
case-sensitivity characteristics	core-idef
case-sensitivity for name lookup	core-idef
`catch`	Exception Handling
`catch` and backtraces	Error messages
`catch` and `this`	Objects Implementation
`catch` in `m: ... ;m`	Method conveniences
`catch-nobt`	Exception Handling
`cell`	Address arithmetic
cell size	core-idef
`cell-`	Address arithmetic
cell-aligned addresses	core-idef
`cell/`	Address arithmetic
`cell%`	Gforth structs
`cell+`	Address arithmetic
`cells`	Address arithmetic
CFA	Threading Words
`cfield:`	Standard Structures
changing the compilation word list (during compilation)	search-ambcond
`char`	String and character literals
char size	core-idef
`char-`	Address arithmetic
`char%`	Gforth structs
`char+`	Address arithmetic
character editing of `ACCEPT` and `EXPECT`	core-idef
character encoding	Strings and Characters
character literals	String and character literals
character set	core-idef
character strings - displaying	Displaying characters and strings
character strings - moving and copying	Memory Blocks
character strings - representations	String representations
character-aligned address requirements	core-idef
character-set extensions and matching of names	core-idef
Characters - chars=bytes, extended characters, user-perceived characters	Strings and Characters
characters - displaying	Displaying characters and strings
characters tutorial	Characters and Strings Tutorial
`charclass`	Regular Expressions
`chars`	Address arithmetic
child class	Object-Oriented Terminology
child words	User-defined defining words using CREATE
`cilk-bye`	Cilk
`cilk-init`	Cilk
`cilk-sync`	Cilk
class	Object-Oriented Terminology
`class`	Objects Glossary
`class`	Basic Mini-OOF Usage
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	Basic Objects Usage
class definition, restrictions	Basic OOF Usage
class implementation and representation	Objects Implementation
class scoping implementation	Objects Implementation
`class` usage	Basic Objects Usage
`class` usage	Basic OOF Usage
`class->map`	Objects Glossary
`class-inst-size`	Objects Glossary
`class-inst-size` discussion	Creating objects
`class-override!`	Objects Glossary
`class-previous`	Objects Glossary
`class;`	Class Declaration
`class;` usage	Basic OOF Usage
`class>order`	Objects Glossary
classes and scoping	Classes and Scoping
clear screen	Terminal output
`clear-libs`	Declaring OS-level libraries
`clear-path`	General Search Paths
`clearstack`	Examining data
`clearstacks`	Examining data
`clicked`	actor methods
clock tick duration	facility-idef
`close-dir`	Directories
`close-file`	General files
`close-pipe`	Pipes
closure conversion	How do I read outer locals?
closures	Closures
`cmove`	Memory Blocks
`cmove>`	Memory Blocks
`code`	Assembler Definitions
code address	Threading Words
code coverage	Code Coverage
`CODE` ending sequence	programming-idef
code field	Threading Words
code space	Memory model
code words	Assembler and Code Words
`code-address!`	Threading Words
`CODE`, processing input	programming-idef
colon definitions	Colon Definitions
colon definitions	Anonymous Definitions
colon definitions, nesting	Quotations
colon definitions, tutorial	Colon Definitions Tutorial
colon-sys, passing data across `:`	Literals
color output to the terminal	Color output
color themes	Color themes
`color-cover`	Code Coverage
`color:`	widget methods
combined word	How to define combined words
command line arguments, OS	OS command line arguments
command-line editing	Command-line editing
command-line options	Invoking Gforth
comment editing commands	Emacs and Gforth
comments	Comments
comments tutorial	Comments Tutorial
`common-list`	Locals implementation
`comp-i.fs`	gforthmi
comp.lang.forth	Forth-related information
`COMP'`	Compilation token
`compare`	String words
compare and swap	Hardware operations for multi-tasking
comparison of object models	Comparison with other object models
comparison tutorial	Flags and Comparisons Tutorial
compilation and interpretation semantics, arbitrary combination	How to define combined words
compilation semantics	How does that work?
compilation semantics tutorial	Interpretation and Compilation Semantics and Immediacy Tutorial
compilation semantics, default	What semantics do normal definitions have?
compilation semantics, usage	Where are compilation semantics used?
compilation token	Compilation token
compilation tokens, tutorial	Compilation Tokens Tutorial
compilation word list	Word Lists
compilation word list, change before definition ends	search-ambcond
compile state	The Text Interpreter
`compile-color`	Color output
`compile-only`	How to define immediate words
compile-only warning, for `'` etc.	core-ambcond
compile-only words	How to define immediate words
`compile-only?`	Name token
`compile,`	Macros
compiled code examination	Examining compiled code
`compiling`	Performing translation actions
compiling compilation semantics	Macros
`compiling` prompt	Text interpreter status
compiling words	Compiling words
complex numbers, input format	Floating-point number and complex literals
`compsem:`	How to define combined words
conditional compilation	Interpreter Directives
conditionals, tutorial	Conditional execution Tutorial
`const-does>`	Const-does>
`Constant`	Constants
constants	Constants
`construct`	Objects Glossary
`construct` discussion	Creating objects
`context`	Word Lists
context-sensitive help	Emacs and Gforth
contiguous region	Memory model
contiguous regions and heap allocation	Heap Allocation
contiguous regions in dictionary allocation	Dictionary allocation
contiguous regioons and sections	Sections
`contof`	General control structures with CASE
contributors to Gforth	Origin
control characters as delimiters	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	Locals implementation
control-flow stack underflow	programming-ambcond
control-flow stack, format	core-idef
`convert`	String to number conversion
`CORE`	Environmental Queries
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
`CORE-EXT`	Environmental Queries
`cores`	Cilk
`count`	Counted string words
counted loops	Counted Loops
counted loops with negative increment	Counted Loops
counted string, maximum size	core-idef
counted strings	String representations
`cov%`	Code Coverage
`cov+`	Code Coverage
`cover-filename`	Code Coverage
`coverage?`	Code Coverage
`cputime`	Keeping track of Time
`cr`	Miscellaneous output
`Create`	CREATE
`CREATE` ... `DOES>`	User-defined defining words using CREATE
`CREATE` ... `DOES>`, applications	CREATE..DOES> applications
`CREATE` ... `DOES>`, details	CREATE..DOES> details
`CREATE` ... `SET-DOES>`	User-defined defining words using CREATE
`CREATE` and alignment	Address arithmetic
`create-file`	General files
`create-from`	Creating from a prototype
create...does> tutorial	Defining Words Tutorial
creating objects	Creating objects
`critical-section`	Semaphores
cross-compiler	cross.fs
cross-compiler	Cross Compiler
`cross.fs`	cross.fs
`cross.fs`	Cross Compiler
`CS-DROP`	Arbitrary control structures
`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
`cs-vocabulary`	Word Lists
`cs-wordlist`	Word Lists
`cstring>sstring`	String words
`csv-quote`	CSV reading and writing
`csv-separator`	CSV reading and writing
ct (compilation token)	Compilation token
CT, tutorial	Compilation Tokens Tutorial
`ctz`	Bitwise operations
`current`	Word Lists
`current-interface`	Objects Glossary
`current-interface` discussion	Objects Implementation
`current'`	Objects Glossary
currying	CREATE..DOES> applications
cursor positioning	Terminal output
`cvalue:`	Value-Flavoured and Defer-Flavoured Fields

D
`d`	widget methods
`d-`	Double precision
`d`, stack item type	Notation
`D:`	Locals definition words
`d.`	Simple numeric output
`d.r`	Simple 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>f`	Floating Point
`D>F`, d cannot be presented precisely as a float	floating-ambcond
`d>s`	Double precision
`D>S`, d out of range of n	double-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
`dabs`	Double precision
`dark-mode`	Color themes
`darshift`	Bitwise operations
data space	Memory model
data space - reserving some	Dictionary allocation
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	Stack Manipulation
data stack manipulation words	Data stack
data structure locals	Gforth locals
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
`debug-fid`	Debugging
debugging	Debugging
debugging output, finding the source location in Emacs	Emacs and Gforth
debugging Singlestep	Singlestep Debugger
`dec.`	Simple numeric output
`dec.r`	Simple numeric output
`decimal`	Base and integer decimal point
declaring C functions	Declaring C Functions
decompilation tutorial	Decompilation Tutorial
`default`	Internationalization and localization
default type of locals	Gforth locals
`default-color`	Color output
`default-input`	Color themes
`Defer`	Deferred Words
`defer`	Class Declaration
`defer:`	Value-Flavoured and Defer-Flavoured Fields
`defer!`	Deferred Words
`defer@`	Deferred Words
deferred words	Deferred Words
`defers`	Deferred Words
definer	Threading Words
`definer!`	Threading Words
`defines`	Basic Mini-OOF Usage
defining defining words	User-defined Defining Words
defining words	Defining Words
defining words tutorial	Defining Words Tutorial
defining words without name	Anonymous Definitions
defining words, name given in a string	Supplying names
defining words, simple	CREATE
defining words, user-defined	User-defined Defining Words
definition	Introducing the Text Interpreter
`definitions`	Word Lists
definitions, tutorial	Colon Definitions Tutorial
`defocus`	actor methods
`delete`	String words
`delete-file`	General files
`delta-i`	Counted Loops
`depth`	Examining data
depth changes during interpretation	Stack depth changes
`depth-changes.fs`	Stack depth changes
deque	User-defined Stacks
design of stack effects, tutorial	Designing the stack effect Tutorial
`dest`, control-flow stack item	Arbitrary control structures
`df_`, stack item type	Notation
`df!`	Memory Access
`df@`	Memory Access
`df@` or `df!` used with an address that is not double-float aligned	floating-ambcond
`dfalign`	Dictionary allocation
`dfaligned`	Address arithmetic
`dffield:`	Standard Structures
`dfloat/`	Address arithmetic
`dfloat%`	Gforth structs
`dfloat+`	Address arithmetic
`dfloats`	Address arithmetic
`dfvalue:`	Value-Flavoured and Defer-Flavoured Fields
`dglue`	widget methods
`dglue@`	widget methods
`dict-new`	Objects Glossary
`dict-new` discussion	Creating objects
dictionary allocation direction	Memory model
dictionary in persistent form	Image Files
dictionary memory	Memory model
dictionary overflow	core-ambcond
dictionary size default	Stack and Dictionary Sizes
digits > 35	core-idef
direct threaded inner interpreter	Threading
Directories	Directories
`dirname`	Directories
disassembler, general	Common Disassembler
`discode`	Common Disassembler
`dispose-widget`	widget methods
dividing by zero	core-ambcond
dividing by zero, floating-point	floating-ambcond
Dividing classes	Dividing classes
dividing integers	Integer division
dividing many integers with the same divisor	Two-stage integer division
Division by zero	Integer division
Division by zero	Integer division
division rounding	core-idef
division with potentially negative operands	Arithmetic
`dlshift`	Bitwise operations
`dmax`	Double precision
`dmin`	Double precision
`dnegate`	Double precision
`DO`	Counted Loops
`DO` loops	Counted Loops
`doabicode:`	Threading Words
`docol:`	Threading Words
`docon:`	Threading Words
`dodefer:`	Threading Words
`dodoes` routine	DOES>
`dodoes:`	Threading Words
`does-code!`	Threading Words
`DOES>`	CREATE..DOES> details
`DOES>` implementation	DOES>
`DOES>` in a separate definition	CREATE..DOES> details
`DOES>` in interpretation state	CREATE..DOES> details
`DOES>` of non-`CREATE`d words	core-ambcond
does> tutorial	Defining Words Tutorial
`does>`-code	Threading Words
`DOES>`-code	DOES>
`DOES>`-parts, stack effect	User-defined defining words using CREATE
`DOES>`, visibility of current definition	core-idef
`dofield:`	Threading Words
`DONE`	Counted Loops
double precision arithmetic words	Double precision
double words, ambiguous conditions	double-ambcond
double words, system documentation	The optional Double Number word set
double-cell numbers, input format	Integer and character literals
double-ended queue	User-defined Stacks
`double%`	Gforth structs
doubly indirect threaded code	gforthmi
`douser:`	Threading Words
`dovalue:`	Threading Words
`dovar:`	Threading Words
`dpl`	Base and integer decimal point
`draw`	widget methods
`draw-init`	widget methods
`drol`	Bitwise operations
`drop`	Data stack
`dror`	Bitwise operations
`drshift`	Bitwise operations
`du/mod`	Integer division
`du<`	Numeric comparison
`du<=`	Numeric comparison
`du>`	Numeric comparison
`du>=`	Numeric comparison
`dump`	Examining data
`dup`	Data stack
duration of a system clock tick	facility-idef
dynamic allocation of memory	Heap Allocation
Dynamic superinstructions with replication	Dynamic Superinstructions
Dynamically linked libraries in C interface	Declaring OS-level libraries

E
`early`	Class Declaration
early binding	Class Binding
`edit`	Locating source code definitions
`edit-line`	String input from the terminal
editing in `ACCEPT` and `EXPECT`	core-idef
eforth performance	Performance
`ekey`	Single-key input
`EKEY`, encoding of keyboard events	facility-idef
`ekey?`	Single-key input
`ekey>char`	Single-key input
`ekey>fkey`	Single-key input
`ekey>xchar`	Single-key input
`ekeyed`	actor methods
elements of a Forth system	Review - elements of a Forth system
`ELSE`	Arbitrary control structures
Emacs and Gforth	Emacs and Gforth
`emit`	Displaying characters and strings
`EMIT` and non-graphic characters	core-idef
`emit-file`	General files
`empty-buffers`	Blocks
`end-c-library`	Defining library interfaces
`end-class`	Objects Glossary
`end-class`	Basic Mini-OOF Usage
`end-class` usage	Basic Objects Usage
`end-class-noname`	Objects Glossary
`end-code`	Assembler Definitions
`end-interface`	Objects Glossary
`end-interface` usage	Object Interfaces
`end-interface-noname`	Objects Glossary
`end-methods`	Objects Glossary
`end-struct`	Gforth structs
`end-struct` usage	Gforth structs
`end-structure`	Standard Structures
`endcase`	General control structures with CASE
`ENDIF`	Arbitrary control structures
endless loop	General Loops
`endof`	General control structures with CASE
`endscope`	Where are locals visible by name?
`endtry`	Exception Handling
`endtry-iferror`	Exception Handling
engine	Engine
engine performance	Performance
engine portability	Portability
`engine.s`	Produced code
engines, gforth vs. gforth-fast vs. gforth-itc	Direct or Indirect Threaded?
`entered`	actor methods
`environment`	Environmental Queries
environment variable input format	String and environment variable literals
environment variables	Environment variables
environment variables	gforthmi
environment wordset	Notation
`environment-wordlist`	Environmental Queries
`environment?`	Environmental Queries
`ENVIRONMENT?` string length, maximum	core-idef
environmental queries	Environmental Queries
environmental restrictions	Standard conformance
equality of floats	Floating-point comparisons
`erase`	Memory Blocks
error messages	Error messages
error output, finding the source location in Emacs	Emacs and Gforth
`error-color`	Color output
`error-hl-inv`	Color output
`error-hl-ul`	Color output
`etags.fs`	Emacs Tags
`evaluate`	Input Sources
`event-loop`	Message queues
examining data	Examining data
`exception`	Exception Handling
exception abort sequence of `ABORT"`	core-idef
exception source code	Locating exception source
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
`exceptions`	Exception Handling
exceptions tutorial	Exceptions Tutorial
executable image file	Running Image Files
`execute`	Execution token
`execute-exit`	Execution token
`execute-parsing`	The Input Stream
`execute-parsing-file`	The Input Stream
`execute-task`	Basic multi-tasking
executing code on startup	Invoking Gforth
execution frequency	Code Coverage
execution semantics (aka interpretation semantics)	Interpretation and Compilation Semantics
execution token	Introducing the Text Interpreter
execution token	Execution token
execution token input format	Literals for tokens and addresses
execution token of last defined word	Anonymous Definitions
execution token of words with undefined execution semantics	core-ambcond
execution tokens tutorial	Execution Tokens Tutorial
exercises	Exercises
`EXIT`	Calls and returns
`exit` in `m: ... ;m`	Method conveniences
`exitm`	Objects Glossary
`exitm` discussion	Method conveniences
`expand-where`	Locating uses of a word
`expect`	String input from the terminal
`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
`extend-mem`	Memory blocks and heap allocation
`extend-structure`	Structure Extension
extended records	Structure Extension
`extra-section`	Sections

F
`f_`, stack item type	Notation
`f-`	Floating Point
`f-rot`	Floating point stack
`f,`	Dictionary allocation
`f`, stack item type	Notation
`F:`	Locals definition words
`f!`	Memory Access
`f!` used with an address that is not float aligned	floating-ambcond
`f.`	Floating-point output
`f.rdp`	Floating-point output
`f.s`	Examining data
`f.s-precision`	Examining data
`f@`	Memory Access
`f@` used with an address that is not float aligned	floating-ambcond
`f@localn`	Locals implementation
`f*`	Floating Point
`f**`	Floating Point
`f/`	Floating Point
`F^`	Locals definition words
`f+`	Floating Point
`f<`	Floating-point comparisons
`f<=`	Floating-point comparisons
`f<>`	Floating-point comparisons
`f=`	Floating-point comparisons
`f>`	Floating-point comparisons
`f>=`	Floating-point comparisons
`f>buf-rdp`	Floating-point to string conversion
`f>d`	Floating Point
`F>D`, integer part of float cannot be represented by d	floating-ambcond
`f>l`	Locals implementation
`f>r`	Return stack
`f>s`	Floating Point
`f>str-rdp`	Floating-point to string conversion
`f~`	Floating-point comparisons
`f~abs`	Floating-point comparisons
`f~rel`	Floating-point comparisons
`f0<`	Floating-point comparisons
`f0<=`	Floating-point comparisons
`f0<>`	Floating-point comparisons
`f0=`	Floating-point comparisons
`f0>`	Floating-point comparisons
`f0>=`	Floating-point comparisons
`f2*`	Floating Point
`f2/`	Floating Point
`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	Introduction
factoring similar colon definitions	CREATE..DOES> applications
factoring tutorial	Factoring Tutorial
`fade-color:`	widget methods
`falign`	Dictionary allocation
`faligned`	Address arithmetic
`falog`	Floating Point
`false`	Boolean Flags
fam (file access method)	General files
`fasin`	Floating Point
`FASIN`, \|float\|>1	floating-ambcond
`fasinh`	Floating Point
`FASINH`, float<0	floating-ambcond
`fast-throw`	Exception Handling
`fatan`	Floating Point
`fatan2`	Floating Point
`FATAN2`, both arguments are equal to zero	floating-ambcond
`fatanh`	Floating Point
`FATANH`, \|float\|>1	floating-ambcond
`faxpy`	Floating Point
`fclearstack`	Examining data
`fconstant`	Constants
`fcopysign`	Floating Point
`fcos`	Floating Point
`fcosh`	Floating Point
`fdepth`	Examining data
FDL, GNU Free Documentation License	GNU Free Documentation License
`fdrop`	Floating point stack
`fdup`	Floating point stack
`fe.`	Floating-point output
fetch and add	Hardware operations for multi-tasking
`fexp`	Floating Point
`fexpm1`	Floating Point
`ffield:`	Standard Structures
`ffourth`	Floating point stack
`field`	Gforth structs
`field` usage	Gforth structs
`field` usage in class definition	Basic Objects Usage
`field:`	Standard Structures
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 Paths
file words, ambiguous conditions	file-ambcond
file words, implementation-defined options	file-idef
file words, system documentation	The optional File-Access word set
`file-eof?`	General files
file-handling	General files
`file-position`	General files
`file-size`	General files
`file-status`	General files
`FILE-STATUS`, returned information	file-idef
`file>fpath`	Source Search Paths
`file>path`	General Search Paths
`filename-match`	Directories
filenames in `~~` output	Debugging
filenames in assertion output	Assertions
files	Files
files containing blocks	file-idef
files containing Forth code, tutorial	Using files for Forth code Tutorial
files tutorial	Files Tutorial
`fill`	Memory Blocks
`find`	Word Lists
`find-name`	Name token
`find-name-in`	Name token
first definition	Your first definition
first field optimization	Standard Structures
`fkey.`	Single-key input
flags on the command line	Invoking Gforth
flags tutorial	Flags and Comparisons Tutorial
flat address space	Memory model
flat closures	Closures
flavours of locals	Gforth locals
`flit,`	Literals
`FLiteral`	Literals
`fln`	Floating Point
`FLN`, float<=0	floating-ambcond
`flnp1`	Floating Point
`FLNP1`, float<=-1	floating-ambcond
`float`	Address arithmetic
`float/`	Address arithmetic
`float%`	Gforth structs
`float+`	Address arithmetic
floating point arithmetic words	Floating Point
floating point numbers, format and range	floating-idef
floating point tutorial	Floating Point Tutorial
floating point unidentified fault, integer division	core-ambcond
floating-point arithmetic, pitfalls	Floating Point
floating-point comparisons	Floating-point comparisons
floating-point constants	Floating Point
floating-point dividing by zero	floating-ambcond
floating-point numbers, input format	Floating-point number and complex literals
floating-point numbers, rounding or truncation	floating-idef
floating-point output	Floating-point output
floating-point result out of range	floating-ambcond
floating-point stack	Stack Manipulation
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	Integer division
Floating-point unidentified fault (on integer division)	Integer division
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
`floating-stack`	Environmental Queries
`floats`	Address arithmetic
`flog`	Floating Point
`FLOG`, float<=0	floating-ambcond
`floor`	Floating Point
`FLOORED`	Environmental Queries
floored division	Integer division
`flush`	Blocks
`flush-file`	General files
`flush-icache`	Assembler Definitions
`fm/mod`	Integer division
`fmax`	Floating Point
`fmin`	Floating Point
`fnegate`	Floating Point
`fnip`	Floating point stack
`focus`	actor methods
`FOR`	Counted Loops
`FOR` loops	Counted Loops
foreign language interface	C Interface
`FORGET`, deleting the compilation word list	programming-ambcond
`FORGET`, name can’t be found	programming-ambcond
`FORGET`, removing a needed definition	programming-ambcond
forgeting words	Forgetting words
`FORK`	Regular Expressions
`form`	Terminal output
format and range of floating point numbers	floating-idef
format of glossary entries	Notation
formatted numeric output	Integer to string conversion
`Forth`	Word Lists
Forth - an introduction	Introduction
Forth mode in Emacs	Emacs and Gforth
Forth source files	Forth source files
Forth Tutorial	Tutorial
Forth-related information	Forth-related information
`forth-wordlist`	Word Lists
`forth.el`	Emacs and Gforth
`forward`	Calls and returns
`fourth`	Data stack
`fover`	Floating point stack
FP output	Floating-point output
FP tutorial	Floating Point Tutorial
`fp!`	Stack pointer manipulation
`fp.`	Floating-point output
`fp@`	Stack pointer manipulation
`fp0`	Stack pointer manipulation
`fpath`	Source Search Paths
`fpick`	Floating point stack
`fr@`	Return stack
`fr>`	Return stack
`free`	Heap Allocation
`free-closure`	Closures
`free-mem-var`	Memory blocks and heap allocation
frequently asked questions	Forth-related information
`frot`	Floating point stack
`fround`	Floating Point
`fs.`	Floating-point output
`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
`fthird`	Floating point stack
`ftrunc`	Floating Point
`ftuck`	Floating point stack
fully relocatable image files	Fully Relocatable Image Files
functions, tutorial	Colon Definitions Tutorial
`fvalue`	Values
`fvalue:`	Value-Flavoured and Defer-Flavoured Fields
`fvariable`	Variables

G
`g`	Locating source code definitions
`gap`	widget methods
gdb disassembler	Common Disassembler
general control structures (`case`)	General control structures with CASE
general files	General files
`get`	actor methods
`get-block-fid`	Blocks
`get-current`	Word Lists
`get-dir`	Directories
`get-order`	Word Lists
`get-recs`	Recognizer order
`get-stack`	User-defined Stacks
`getenv`	Passing Commands to the OS
`gforth`	Environmental Queries
`GFORTH` – environment variable	Environment variables
`GFORTH` – environment variable	gforthmi
Gforth - leaving	Leaving Gforth
gforth engine	Direct or Indirect Threaded?
Gforth environment	Gforth Environment
Gforth extensions	Standard vs Extensions
Gforth files	Gforth Files
Gforth locals	Gforth locals
Gforth performance	Performance
Gforth stability	Stability Goals
`gforth-ditc`	gforthmi
`gforth-fast` and backtraces	Error messages
gforth-fast engine	Direct or Indirect Threaded?
`gforth-fast`, difference from `gforth`	Error messages
gforth-itc engine	Direct or Indirect Threaded?
`gforth.el`	Emacs and Gforth
`gforth.el`, installation	Installing gforth.el
`gforth.fi`, relocatability	Fully Relocatable Image Files
`GFORTHD` – environment variable	Environment variables
`GFORTHD` – environment variable	gforthmi
`GFORTHHIST` – environment variable	Environment variables
`gforthmi`	gforthmi
`GFORTHPATH` – environment variable	Environment variables
`GFORTHSYSTEMPREFIX` – environment variable	Environment variables
`gg`	Locating uses of a word
giving a name to a library interface	Defining library interfaces
glossary notation format	Notation
GNU C for the engine	Portability
goals of the Gforth project	Goals

H
`h`	widget methods
`h.`	Simple numeric output
`halt`	Basic multi-tasking
header fields	Header fields
header methods	Header methods
header space	Word Lists
heap allocation	Heap Allocation
heap memory	Memory model
`heap-new`	Objects Glossary
`heap-new` discussion	Creating objects
`heap-new` usage	Basic Objects Usage
help	Help on Gforth
`help`	Help on Gforth
`here`	Dictionary allocation
`hex`	Base and integer decimal point
`hex.`	Simple numeric output
`hglue`	widget methods
`hglue@`	widget methods
`hide`	actor methods
highlighting Forth code in Emacs	Hilighting
hilighting Forth code in Emacs	Hilighting
history file	Command-line editing
`hold`	Integer to string conversion
`holds`	Integer to string conversion
hooks in the text interpreter	Text Interpreter Hooks
`how:`	Class Declaration
hybrid direct/indirect threaded code	Direct or Indirect Threaded?

I
`i`	Counted Loops
`i'`	Counted Loops
I/O - blocks	Blocks
I/O - file-handling	Files
I/O - keyboard and display	Other I/O
I/O exception in block transfer	block-ambcond
`id.`	Name token
IDE (integrated development environment)	Locating source code definitions
`IF`	Arbitrary control structures
`IF` control structure	Selection
if, tutorial	Conditional execution Tutorial
`iferror`	Exception Handling
image file	Image Files
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, data-relocatable	Data-Relocatable Image Files
image file, executable	Running Image Files
image file, fully relocatable	Fully Relocatable Image Files
image file, non-relocatable	Non-Relocatable Image Files
image file, stack and dictionary sizes	Stack and Dictionary Sizes
image file, turnkey applications	Modifying the Startup Sequence
image license	Image Licensing Issues
`immediate`	How to define immediate words
immediate words	How does that work?
immediate words	How to define immediate words
immediate, tutorial	Interpretation and Compilation Semantics and Immediacy Tutorial
`immediate?`	Header methods
`implementation`	Objects Glossary
implementation of locals	Locals 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
`in`	Word Lists
`in-colon-def?`	Macros
`in-wordlist`	Word Lists
`include`	Forth source files
`include` search path	Search Paths
`include-file`	Forth source files
`INCLUDE-FILE`, file-id is invalid	file-ambcond
`INCLUDE-FILE`, I/O exception reading or closing file-id	file-ambcond
`include`, placement in files	Emacs Tags
`included`	Forth source files
`INCLUDED`, I/O exception reading or closing file-id	file-ambcond
`INCLUDED`, named file cannot be opened	file-ambcond
`included?`	Forth source files
including files	Forth source files
including files, stack effect	Forth source files
indentation of Forth code in Emacs	Auto-Indentation
indirect threaded inner interpreter	Threading
`inf`	Floating Point
`infile-execute`	Redirection
`infile-id`	Redirection
`infinity`	Floating Point
`info-color`	Color output
inheritance	Object-Oriented Terminology
`init-asm`	Assembler Definitions
`init-buffer`	Growable memory buffers
`init-object`	Objects Glossary
`init-object` discussion	Creating objects
initialization of locals	Gforth locals
initialization sequence of image file	Modifying the Startup Sequence
`initiate`	Basic multi-tasking
`inline:`	Inline Definitions
inner interpreter and text interpreter	The Text Interpreter
inner interpreter implementation	Threading
inner interpreter optimization	Scheduling
inner interpreter, direct threaded	Threading
inner interpreter, indirect threaded	Threading
input format for body-relative addresses	Literals for tokens and addresses
input format for characters/code points	Integer and character literals
input format for double-cell numbers	Integer and character literals
input format for environment variables	String and environment variable literals
input format for execution tokens	Literals for tokens and addresses
input format for floating-point numbers	Floating-point number and complex literals
input format for name tokens	Literals for tokens and addresses
input format for single-cell numbers	Integer and character literals
input format for strings	String and environment variable literals
input from pipes	Gforth in pipes
input line size, maximum	file-idef
input line terminator	core-idef
Input Redirection	Redirection
input sources	Input Sources
input stream	The Input Stream
`input-color`	Color output
input, single-key	Single-key input
input, string from terminal	String input from the terminal
`insert`	String words
`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
`INT-[I]`	Interpreter Directives
integer conversion, `base`	Base and integer decimal point
integer to string conversion	Integer to string conversion
integer types, ranges	core-idef
integrated development environment	Locating source code definitions
`interface`	Objects Glossary
interface implementation	Objects Implementation
interface to C functions	C Interface
`interface` usage	Object Interfaces
interfaces for objects	Object Interfaces
interpret state	The Text Interpreter
Interpret/Compile states	Interpret/Compile states
`interpret/compile:`	How to define combined words
interpretation and compilation semantics, arbitrary combination	How to define combined words
interpretation semantics	How does that work?
interpretation semantics (aka execution semantics)	Interpretation and Compilation Semantics
interpretation semantics tutorial	Interpretation and Compilation Semantics and Immediacy Tutorial
interpretation semantics, default	What semantics do normal definitions have?
interpretation semantics, usage	Where are interpretation semantics used?
interpreter - outer	The Text Interpreter
interpreter directives	Interpreter Directives
`interpreting`	Performing translation actions
Interpreting a compile-only word	core-ambcond
Interpreting a compile-only word, for a local	locals-ambcond
interpreting a word with undefined interpretation semantics	core-ambcond
`intsem:`	How to define combined words
invalid block number	block-ambcond
Invalid memory address	core-ambcond
Invalid memory address, stack overflow	core-ambcond
Invalid name argument, `TO`	core-ambcond
Invalid name argument, `TO`	locals-ambcond
`invalid-char`	Xchars and Unicode
`invert`	Bitwise operations
invoking a selector	Object-Oriented Terminology
invoking Gforth	Invoking Gforth
invoking image files	Running Image Files
ior type description	Notation
ior values and meaning	file-idef
ior values and meaning	memory-idef
`IS`	Deferred Words
`is name` semantics, changing them	Words with user-defined TO etc.
items on the stack after interpretation	Stack depth changes
iterate over array	Counted Loops

J
`j`	Counted Loops
`JOIN`	Regular Expressions

K
`k`	Counted Loops
`k-alt-mask`	Single-key input
`k-backspace`	Single-key input
`k-ctrl-mask`	Single-key input
`k-delete`	Single-key input
`k-down`	Single-key input
`k-end`	Single-key input
`k-enter`	Single-key input
`k-eof`	Single-key input
`k-f1`	Single-key input
`k-f10`	Single-key input
`k-f11`	Single-key input
`k-f12`	Single-key input
`k-f2`	Single-key input
`k-f3`	Single-key input
`k-f4`	Single-key input
`k-f5`	Single-key input
`k-f6`	Single-key input
`k-f7`	Single-key input
`k-f8`	Single-key input
`k-f9`	Single-key input
`k-home`	Single-key input
`k-insert`	Single-key input
`k-left`	Single-key input
`k-mute`	Single-key input
`k-next`	Single-key input
`k-pause`	Single-key input
`k-prior`	Single-key input
`k-right`	Single-key input
`k-sel`	Single-key input
`k-shift-mask`	Single-key input
`k-tab`	Single-key input
`k-up`	Single-key input
`k-voldown`	Single-key input
`k-volup`	Single-key input
`k-winch`	Single-key input
`kern*.fi`, relocatability	Fully Relocatable Image Files
`kerning`	widget methods
`key`	Single-key input
`key-file`	General files
`key-ior`	Single-key input
`key?`	Single-key input
`key?-file`	General files
keyboard events, encoding in `EKEY`	facility-idef
`kill`	Basic multi-tasking
`kill-task`	Basic multi-tasking
Kuehling, David	Emacs and Gforth

L
`l`	Locating source code definitions
`l,`	Dictionary allocation
`l!`	Special Memory Accesses
`L"`	Internationalization and localization
`l@`	Special Memory Accesses
`l>s`	Special Memory Accesses
labels as values	Threading
`lalign`	Address arithmetic
`laligned`	Address arithmetic
`LANG` – environment variable	Environment variables
last word was headerless	core-ambcond
`lastfit`	widget methods
late binding	Class Binding
`latest`	Name token
`latestnt`	Name token
`latestxt`	Anonymous Definitions
`lbe`	Special Memory Accesses
`LC_ALL` – environment variable	Environment variables
`LC_CTYPE` – environment variable	Environment variables
`LEAVE`	Counted Loops
leaving definitions, tutorial	Leaving definitions or loops Tutorial
leaving Gforth	Leaving Gforth
leaving loops, tutorial	Leaving definitions or loops Tutorial
`left`	actor methods
length of a line affected by `\`	block-idef
`lfield:`	Standard Structures
`lib-error`	Low-Level C Interface Words
`lib-sym`	Low-Level C Interface Words
Libraries in C interface	Declaring OS-level libraries
library interface names	Defining library interfaces
`license`	Help on Gforth
license for images	Image Licensing Issues
lifetime of locals	How long do locals live?
`light-mode`	Color themes
line terminator on input	core-idef
`line-end-hook`	Text Interpreter Hooks
lines and the text interpreter	The Text Interpreter
`list`	Blocks
`LIST` display format	block-idef
`list-size`	Locals implementation
`lit,`	Literals
`Literal`	Literals
literal tutorial	Literal Tutorial
Literals	Literals
Literals (in source code)	Literals in source code
literals for characters and strings	String and character literals
little-endian	Special Memory Accesses
`ll`	Locating uses of a word
`lle`	Special Memory Accesses
`load`	Blocks
`load-cov`	Code Coverage
loader for image files	Image File Background
loading files at startup	Invoking Gforth
loading Forth code, tutorial	Using files for Forth code Tutorial
local in interpretation state	locals-ambcond
local variables, tutorial	Local Variables Tutorial
locale and case-sensitivity	core-idef
`locale-csv`	Internationalization and localization
`locale-csv-out`	Internationalization and localization
`Locale:`	Internationalization and localization
`locale!`	Internationalization and localization
`locale@`	Internationalization and localization
`locales`	Internationalization and localization
locals	Locals
locals and POSTPONE or ]]	POSTPONEing locals
locals and return stack	Return stack
locals flavours	Gforth locals
locals implementation	Locals implementation
locals information on the control-flow stack	Locals implementation
locals initialization	Gforth locals
locals lifetime	How long do locals live?
locals programming style	Locals programming style
locals stack	Stack Manipulation
locals stack	Locals implementation
locals types	Gforth locals
locals use without TO etc.	Locals programming style
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, default type	Gforth locals
locals, Gforth style	Gforth locals
locals, maximum number in a definition	locals-idef
locals, Standard Forth style	Standard Forth locals
`locals\|`	Locals definition words
`locate`	Locating source code definitions
`lock`	Semaphores
`log2`	Bitwise operations
long long	Portability
`LOOP`	Counted Loops
loop control parameters not available	core-ambcond
loops without count	General Loops
loops, counted	Counted Loops
loops, counted, tutorial	Counted loops Tutorial
loops, endless	General Loops
loops, indefinite, tutorial	General Loops Tutorial
`lp!`	Stack pointer manipulation
`lp@`	Stack pointer manipulation
`lp+!`	Locals implementation
`lp+n`	Locals implementation
`lp0`	Stack pointer manipulation
`lrol`	Bitwise operations
`lror`	Bitwise operations
`lshift`	Bitwise operations
`LSHIFT`, large shift counts	core-ambcond
`lvalue:`	Value-Flavoured and Defer-Flavoured Fields

M
`m:`	Objects Glossary
`m:` usage	Method conveniences
`m*`	Mixed precision
`m*/`	Integer division
`m+`	Mixed precision
macros	Compiling words
Macros	Macros
`macros-wordlist`	Substitute
macros, advanced tutorial	Advanced macros Tutorial
`magenta-input`	Color themes
`make-latest`	Making a word current
`map-vocs`	Word Lists
mapping block ranges to files	file-idef
`marker`	Forgetting words
`max`	Single precision
`MAX-CHAR`	Environmental Queries
`MAX-D`	Environmental Queries
`max-float`	Environmental Queries
`MAX-N`	Environmental Queries
`MAX-U`	Environmental Queries
`MAX-UD`	Environmental Queries
`MAX-XCHAR`	Environmental Queries
`maxalign`	Dictionary allocation
`maxaligned`	Address arithmetic
`maxdepth-.s`	Examining data
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
`mem-do`	Counted Loops
`mem,`	Dictionary allocation
`mem+do`	Counted Loops
memory access words	Memory Access
memory access/allocation tutorial	Memory Tutorial
memory alignment tutorial	Alignment Tutorial
memory barrier	Hardware operations for multi-tasking
memory block words	Memory Blocks
memory overcommit for dictionary and stacks	Invoking Gforth
memory words	Memory
memory-allocation word set	Heap Allocation
memory-allocation words, implementation-defined options	memory-idef
memory-allocation words, system documentation	The optional Memory-Allocation word set
message send	Object-Oriented Terminology
meta recognizer	Disambiguating recognizers
metacompiler	cross.fs
metacompiler	Cross Compiler
method	Object-Oriented Terminology
`method`	Objects Glossary
`method`	Class Declaration
`method`	Basic Mini-OOF Usage
method conveniences	Method conveniences
method map	Objects Implementation
method selector	Object-Oriented Terminology
`method` usage	Basic OOF Usage
`methods`	Objects Glossary
`methods`...`end-methods`	Dividing classes
`min`	Single precision
mini-oof	Mini-OOF
mini-oof example	Mini-OOF Example
mini-oof usage	Basic Mini-OOF Usage
`mini-oof.fs`, differences to other models	Comparison with other object models
minimum search order	search-idef
miscellaneous words	Miscellaneous Words
mixed precision arithmetic words	Mixed precision
`mkdir-parents`	Directories
`mod`	Integer division
`modf`	Integer division
`modf-stage2m`	Two-stage integer division
modifying >IN	How does that work?
Modifying a word defined earlier	Making a word current
modifying the contents of the input buffer or a string literal	core-ambcond
`mods`	Integer division
modulus	Integer division
most recent definition does not have a name (`IMMEDIATE`)	core-ambcond
motivation for object-oriented programming	Why object-oriented programming?
`move`	Memory Blocks
`ms`	Keeping track of Time
`MS`, repeatability to be expected	facility-idef
Multiple exits from `begin`	General loops with multiple exits
multitasker	Multitasker
Must now be used inside C-LIBRARY, see C interface doc	Migrating the C interface from earlier Gforth
`mux`	Bitwise operations
`mwords`	Word Lists

N
`n`	Locating source code definitions
`n`, stack item type	Notation
`n/a`	Words with user-defined TO etc.
`n>r`	Return stack
`name`	The Input Stream
name dictionary	Introducing the Text Interpreter
name field address	Name token
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 space	Memory model
name token (nt)	Name token
name, maximum length	core-idef
`name>compile`	Name token
`name>interpret`	Name token
`name>link`	Name token
`name>string`	Name token
`name$`	widget methods
names for defined words	Supplying names
`NaN`	Floating Point
`native@`	Internationalization and localization
NDCS word	How to define combined words
`needs`	Forth source files
`negate`	Single precision
negative increment for counted loops	Counted Loops
Neon model	Comparison with other object models
nested colon definitions	Quotations
`new`	Basic Mini-OOF Usage
`new-color:`	widget methods
`newline`	String and character literals
newline character on input	core-idef
`newtask`	Basic multi-tasking
`newtask4`	Basic multi-tasking
`NEXT`	Counted Loops
`next-arg`	OS command line arguments
`next-case`	General control structures with CASE
`next-section`	Sections
`NEXT`, direct threaded	Threading
`NEXT`, indirect threaded	Threading
`nextname`	Supplying names
NFA	Name token
`nip`	Data stack
`nocov[`	Code Coverage
non-graphic characters and `EMIT`	core-idef
non-relocatable image files	Non-Relocatable Image Files
`noname`	Anonymous Definitions
`noname-from`	Creating from a prototype
`noop`	Execution token
`nosplit?`	String words
notation of glossary entries	Notation
`nothrow`	Exception Handling
`nr>`	Return stack
`ns`	Keeping track of Time
`nt`	Locating exception source
nt (name token)	Name token
NT Forth performance	Performance
nt input format	Literals for tokens and addresses
nt token input format	Literals for tokens and addresses
`nt`, stack item type	Notation
`ntime`	Keeping track of Time
number conversion - traps for the unwary	Base and integer decimal point
number conversion, `base`	Base and integer decimal point
number of bits in one address unit	core-idef
number representation and arithmetic	core-idef
numeric comparison words	Numeric comparison
numeric output - formatted	Integer to string conversion
numeric output - simple/free-format	Simple numeric output
numeric output, FP	Floating-point output
`nw`	Locating uses of a word

O
`o>`	Mini-OOF2
object	Object-Oriented Terminology
`object`	Objects Glossary
`object`	Basic Mini-OOF Usage
object allocation options	Creating objects
`object` class	The Objects base class
object creation	Creating objects
object interfaces	Object Interfaces
object models, comparison	Comparison 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-asptr`	The OOF base class
`object-bind`	The OOF base class
`object-bound`	The OOF base class
`object-class`	The OOF base class
`object-class?`	The OOF base class
`object-definitions`	The OOF base class
`object-dispose`	The OOF base class
`object-endwith`	The OOF base class
`object-init`	The OOF base class
`object-is`	The OOF base class
`object-link`	The OOF base class
`object-map` discussion	Objects Implementation
`object-new`	The OOF base class
`object-new[]`	The OOF base class
object-oriented programming	Objects
object-oriented programming	OOF
object-oriented programming motivation	Why object-oriented programming?
object-oriented programming style	Object-Oriented Programming Style
object-oriented terminology	Object-Oriented Terminology
`object-postpone`	The OOF base class
`object-ptr`	The OOF base class
`object-self`	The OOF base class
`object-super`	The OOF base class
`object-with`	The OOF base class
objects	Objects
objects, basic usage	Basic Objects Usage
`objects.fs`	Objects
`objects.fs`	OOF
`objects.fs` Glossary	Objects Glossary
`objects.fs` implementation	Objects Implementation
`objects.fs` properties	Properties of the Objects model
`obsolete?`	Name token
`of`	General control structures with CASE
`off`	Boolean Flags
`ok` prompt	Text interpreter status
`on`	Boolean Flags
`once`	Debugging
`Only`	Word Lists
oof	OOF
`oof.fs`	Objects
`oof.fs`	OOF
`oof.fs` base class	The OOF base class
`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-dir`	Directories
`open-file`	General files
`open-lib`	Low-Level C Interface Words
`open-path-file`	General Search Paths
`open-pipe`	Pipes
operating system - passing commands	Passing Commands to the OS
operator’s terminal facilities available	core-other
`opt:`	User-defined compile-comma
options on the command line	Invoking Gforth
`or`	Bitwise operations
`order`	Word Lists
`orig`, control-flow stack item	Arbitrary control structures
OS command line arguments	OS command line arguments
`os-class`	Environmental Queries
`os-type`	Environmental Queries
other system documentation, block words	block-other
other system documentation, core words	core-other
`out`	Miscellaneous output
outer interpreter	Introducing the Text Interpreter
outer interpreter	Stacks and Postfix notation
outer interpreter	The Text Interpreter
`outfile-execute`	Redirection
`outfile-id`	Redirection
output in pipes	Gforth in pipes
Output Redirection	Redirection
output to terminal	Terminal output
`over`	Data stack
overcommit memory for dictionary and stacks	Invoking Gforth
overflow of the pictured numeric output string	core-ambcond
`overrides`	Objects Glossary
`overrides` usage	Basic Objects Usage

P
`pad`	Memory Blocks
`PAD` size	core-idef
`PAD` use by nonstandard words	core-other
`page`	Terminal output
`par-split`	widget methods
parameter stack	Stack Manipulation
parameters are not of the same type (`DO`, `?DO`, `WITHIN`)	core-ambcond
parent class	Object-Oriented Terminology
parent class binding	Class Binding
`parent-w`	widget methods
`parse`	The Input Stream
`parse-name`	The Input Stream
`parse-word`	The Input Stream
parsed string overflow	core-ambcond
parsed string, maximum size	core-idef
parsing words	How does that work?
parsing words	How does that work?
`pass`	Basic multi-tasking
patching threaded code	Dynamic Superinstructions
path for `included`	Search Paths
`path+`	General Search Paths
`path=`	General Search Paths
`pause`	Basic multi-tasking
pedigree of Gforth	Origin
`perform`	Execution token
performance of some Forth interpreters	Performance
persistent form of dictionary	Image Files
PFE performance	Performance
`pi`	Floating Point
`pick`	Data stack
pictured numeric output	Integer to string conversion
pictured numeric output buffer, size	core-idef
pictured numeric output string, overflow	core-ambcond
pipes, creating your own	Pipes
pipes, Gforth as part of	Gforth in pipes
`place`	Counted string words
`postpone`	Macros
`POSTPONE` applied to `[IF]`	programming-ambcond
`POSTPONE` or `[COMPILE]` applied to `TO`	core-ambcond
postpone tutorial	POSTPONE Tutorial
`postpone-color`	Color output
`postpone,`	Compilation token
`postponing`	Performing translation actions
`postponing` prompt	Text interpreter status
Pountain’s object-oriented model	Comparison with other object models
`pow2?`	Bitwise operations
`precision`	Floating-point output
precompiled Forth code	Image Files
prefix `	Execution token
`prepend-where`	Locating uses of a word
`preserve`	Deferred Words
`previous`	Word Lists
`previous-section`	Sections
`previous`, search order empty	search-ambcond
primitive source format	Automatic Generation
primitive-centric threaded code	Direct or Indirect Threaded?
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
`private` discussion	Classes and Scoping
procedures, tutorial	Colon Definitions Tutorial
`process-option`	Modifying the Startup Sequence
`program`	Internationalization and localization
program data space available	core-other
programming style, locals	Locals programming style
programming style, object-oriented	Object-Oriented 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	Text interpreter status
prompt	core-idef
pronunciation of words	Notation
`protected`	Objects Glossary
`protected` discussion	Classes and Scoping
pthread	Pthreads
`ptr`	Class Declaration
`public`	Objects Glossary

Q
`query`	Input Sources
`quit`	Miscellaneous Words
quotations	Quotations

R
`r`, stack item type	Notation
`r'@`	Return stack
`r@`	Return stack
`r/o`	General files
`r/w`	General files
`r>`	Return stack
`raise`	widget methods
ranges for integer types	core-idef
`rdrop`	Return stack
`re-color`	widget methods
`re-emoji-color`	widget methods
`re-fade-color`	widget methods
`re-text-color`	widget methods
`re-text-emoji-fade-color`	widget methods
`read-csv`	CSV reading and writing
`read-dir`	Directories
`read-file`	General files
`read-line`	General files
read-only data space regions	core-idef
reading from file positions not yet written	file-ambcond
`rec-body`	Default recognizers
`rec-complex`	Default recognizers
`rec-dtick`	Default recognizers
`rec-env`	Default recognizers
`rec-filter`	Defining recognizers
`rec-float`	Default recognizers
`rec-forth`	Recognizer order
`rec-forth-nt?`	Defining recognizers
`rec-local`	Default recognizers
`rec-meta`	Default recognizers
`rec-moof2`	Mini-OOF2
`rec-name`	Default recognizers
`rec-none`	Recognizer order
`rec-number`	Default recognizers
`rec-scope`	Default recognizers
`rec-sequence:`	Recognizer order
`rec-string`	Default recognizers
`rec-tick`	Default recognizers
`rec-to`	Default recognizers
receiving object	Object-Oriented Terminology
reciprocal of integer	Two-stage integer division
recognizer, stack effect	Defining recognizers
Recognizers normal usage	Default recognizers
recongizers	Recognizers
records	Structures
records tutorial	Arrays and Records Tutorial
`recover` (old Gforth versions)	Exception Handling
`recs`	Default recognizers
`recurse`	Calls and returns
`RECURSE` appears after `DOES>`	core-ambcond
recursion tutorial	Recursion Tutorial
`recursive`	Calls and returns
recursive definitions	Calls and returns
Redirection	Redirection
`refill`	The Input Stream
regexps	Regular Expressions
relocating loader	Image File Background
relocation at load-time	Image File Background
relocation at run-time	Image File Background
remainder	Integer division
`rename-file`	General files
`REPEAT`	Arbitrary control structures
repeatability to be expected from the execution of `MS`	facility-idef
`replace-word`	Debugging
`replacer:`	Substitute
`replaces`	Substitute
Replication	Dynamic Superinstructions
report the words used in your program	Standard Report
`reposition-file`	General files
`REPOSITION-FILE`, outside the file’s boundaries	file-ambcond
`represent`	Floating-point to string conversion
`REPRESENT`, results when float is out of range	floating-idef
`require`	Forth source files
`require`, placement in files	Emacs Tags
`required`	Forth source files
reserving data space	Dictionary allocation
`resize`	Heap Allocation
`resize-file`	General files
`resized`	widget methods
`restart`	Basic multi-tasking
`restore`	Exception Handling
`restore-input`	Input Sources
`RESTORE-INPUT`, Argument type mismatch	core-ambcond
`restrict`	How to define immediate words
Result out of range	Integer division
result out of range	core-ambcond
Result out of range (on integer division)	Integer division
return stack	Stack Manipulation
return stack and locals	Return stack
return stack dump with `gforth-fast`	Error messages
return stack manipulation words	Return stack
return stack space available	core-other
return stack tutorial	Return Stack Tutorial
return stack underflow	core-ambcond
`return-stack-cells`	Environmental Queries
returning from a definition	Calls and returns
`reveal`	Creating from a prototype
`reveal!`	Creating from a prototype
`rol`	Bitwise operations
`roll`	Data stack
`Root`	Word Lists
`ror`	Bitwise operations
`rot`	Data stack
rounding of floating-point numbers	floating-idef
`rp!`	Stack pointer manipulation
`rp@`	Stack pointer manipulation
`rp0`	Stack pointer manipulation
`rpick`	Return stack
`rshift`	Bitwise operations
`RSHIFT`, large shift counts	core-ambcond
run-time code generation, tutorial	Advanced macros Tutorial
run-time semantics	Which semantics do existing words have?
running Gforth	Invoking Gforth
running image files	Running Image Files
Rydqvist, Goran	Emacs and Gforth

S
`S"`	String and character literals
`S"`, number of string buffers	file-idef
`S"`, size of string buffer	file-idef
`s//`	Regular Expressions
`s\"`	String and character literals
`s+`	String words
`s>>`	Regular Expressions
`s>d`	Double precision
`s>f`	Floating Point
`safe/string`	String words
`save-buffers`	Blocks
`save-cov`	Code Coverage
`save-input`	Input Sources
`save-mem`	Memory blocks and heap allocation
`save-mem-dict`	Dictionary allocation
`savesystem`	Non-Relocatable Image Files
`savesystem` during `gforthmi`	gforthmi
`scan`	String words
`scan-back`	String words
`scan-translate-string`	Defining recognizers
`scope`	Where are locals visible by name?
scope of locals	Where are locals visible by name?
scoping and classes	Classes and Scoping
`scr`	Blocks
scripting with Gforth	Invoking Gforth
`scrolled`	actor methods
`scvalue:`	Value-Flavoured and Defer-Flavoured Fields
`seal`	Word Lists
`search`	String words
search order stack	Word Lists
search order, maximum depth	search-idef
search order, minimum	search-idef
search order, tutorial	Wordlists and Search Order Tutorial
search path control, source files	Source Search Paths
search path control, source files	General Search Paths
search path for files	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
`search-wordlist`	Word Lists
sections and contiguous regions	Sections
`see`	Examining compiled code
see tutorial	Decompilation Tutorial
`see-code`	Examining compiled code
`see-code-range`	Examining compiled code
`SEE`, source and format of output	programming-idef
`select`	Boolean Flags
selection control structures	Selection
selector	Object-Oriented Terminology
`selector`	Objects Glossary
`selector` implementation, class	Objects Implementation
selector invocation	Object-Oriented Terminology
selector invocation, restrictions	Basic Objects Usage
selector invocation, restrictions	Basic OOF Usage
`selector` usage	Basic Objects Usage
selectors and stack effects	Object-Oriented Programming Style
selectors common to hardly-related classes	Object Interfaces
semantics tutorial	Interpretation and Compilation Semantics and Immediacy Tutorial
semantics, arbitrary combination of interpretation and compilation	How to define combined words
semantics, changing the `to`/`+to`/`action-of`/`is`/`addr name` semantics	Words with user-defined TO etc.
semantics, interpretation and compilation	Interpretation and Compilation Semantics
semantics, interpretation/execution	Interpretation and Compilation Semantics
semantics, run-time	Which semantics do existing words have?
`semaphore`	Semaphores
`send-event`	Message queues
`set`	actor methods
`set->comp`	Header methods
`set->int`	Header methods
`set-compsem`	How to define combined words
`set-current`	Word Lists
`set-dir`	Directories
`set-does>`	CREATE..DOES> details
`set-execute`	Header methods
`set-name>link`	Header methods
`set-name>string`	Header methods
`set-optimizer`	User-defined compile-comma
`set-order`	Word Lists
`set-precision`	Floating-point output
`set-recs`	Recognizer order
`set-stack`	User-defined Stacks
`set-to`	Words with user-defined TO etc.
`sf_`, stack item type	Notation
`sf!`	Memory Access
`sf@`	Memory Access
`sf@` or `sf!` used with an address that is not single-float aligned	floating-ambcond
`sfalign`	Dictionary allocation
`sfaligned`	Address arithmetic
`sffield:`	Standard Structures
`sfloat/`	Address arithmetic
`sfloat%`	Gforth structs
`sfloat+`	Address arithmetic
`sfloats`	Address arithmetic
`sfvalue:`	Value-Flavoured and Defer-Flavoured Fields
`sh`	Passing Commands to the OS
`sh-get`	Passing Commands to the OS
Shared libraries in C interface	Declaring OS-level libraries
shell commands	Passing Commands to the OS
`shift-args`	OS command line arguments
`short-where`	Locating uses of a word
`show`	actor methods
`show-you`	actor methods
`sign`	Integer to string conversion
sign extension	Special Memory Accesses
silent exiting from Gforth	Gforth in pipes
simple defining words	CREATE
simple loops	General Loops
`simple-fkey-string`	Single-key input
`simple-see`	Examining compiled code
`simple-see-range`	Examining compiled code
single precision arithmetic words	Single precision
single-assignment style for locals	Locals programming style
single-cell numbers, input format	Integer and character literals
single-key input	Single-key input
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
`skip`	String words
`sleep`	Basic multi-tasking
`slit,`	Literals
`SLiteral`	Literals
`slurp-fid`	General files
`slurp-file`	General files
`slvalue:`	Value-Flavoured and Defer-Flavoured Fields
`sm/rem`	Integer division
`source`	The Text Interpreter
source code for exception	Locating exception source
source code of a word	Locating source code definitions
source location of error or debugging output in Emacs	Emacs and Gforth
`source-id`	Input Sources
`SOURCE-ID`, behaviour when `BLK` is non-zero	file-ambcond
`sourcefilename`	Forth source files
`sourceline#`	Forth source files
`sp!`	Stack pointer manipulation
`sp@`	Stack pointer manipulation
`sp0`	Stack pointer manipulation
`space`	Miscellaneous output
space delimiters	core-idef
`spaces`	Miscellaneous output
`span`	String input from the terminal
`spawn`	Cilk
`spawn1`	Cilk
`spawn2`	Cilk
speed, startup	Startup speed
`split`	widget methods
stability of Gforth	Stability Goals
`stack`	User-defined Stacks
stack depth changes during interpretation	Stack depth changes
stack effect	Notation
Stack effect design, tutorial	Designing the stack effect Tutorial
stack effect of `DOES>`-parts	User-defined defining words using CREATE
stack effect of included files	Forth source files
stack effects of selectors	Object-Oriented Programming Style
stack empty	core-ambcond
stack item types	Notation
stack manipulation tutorial	Stack Manipulation Tutorial
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 tutorial	Stack Tutorial
stack underflow	core-ambcond
`stack-cells`	Environmental Queries
stack-effect comments, tutorial	Stack-Effect Comments Tutorial
stack, user-defined	User-defined Stacks
`stack:`	User-defined Stacks
`stack>`	User-defined Stacks
`stacksize`	Basic multi-tasking
`stacksize4`	Basic multi-tasking
`staged/-divisor`	Two-stage integer division
`staged/-size`	Two-stage integer division
Standard conformance of Gforth	Standard conformance
starting Gforth tutorial	Starting Gforth Tutorial
startup sequence for image file	Modifying the Startup Sequence
Startup speed	Startup speed
`state`	Interpret/Compile states
`state` - effect on the text interpreter	How does that work?
`STATE` values	core-idef
state-smart words (are a bad idea)	How to define combined words
`static`	Class Declaration
status bar	Text interpreter status
`status-color`	Color output
`stderr`	General files
stderr and pipes	Gforth in pipes
`stdin`	General files
`stdout`	General files
`stop`	Basic multi-tasking
`stop-dns`	Basic multi-tasking
`stop-ns`	Basic multi-tasking
`str<`	String words
`str=`	String words
`str=?`	Regular Expressions
String input format	String and environment variable literals
string input from terminal	String input from the terminal
string larger than pictured numeric output area (`f.`, `fe.`, `fs.`)	floating-ambcond
string literals	String and character literals
string longer than a counted string returned by `WORD`	core-ambcond
String to number conversion	String to number conversion
string words with $	$tring words
`string-parse`	The Input Stream
`string-prefix?`	String words
`string-suffix?`	String words
`string,`	Counted string words
strings - see character strings	String representations
strings tutorial	Characters and Strings Tutorial
`struct`	Gforth structs
`struct` usage	Gforth structs
structs tutorial	Arrays and Records Tutorial
structure extension	Structure Extension
structure of Forth programs	Forth is written in Forth
structures	Structures
Structures in Forth200x	Standard Structures
`sub-list?`	Locals implementation
`substitute`	Substitute
`success-color`	Color output
superclass binding	Class Binding
Superinstructions	Dynamic Superinstructions
`swap`	Data stack
`swvalue:`	Value-Flavoured and Defer-Flavoured Fields
symmetric division	Integer division
`Synonym`	Synonyms
synonyms	Synonyms
syntax tutorial	Syntax Tutorial
`system`	Passing Commands to the OS
system dictionary space required, in address units	core-other
system documentation	Standard 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

T
`table`	Word Lists
`TAGS` file	Emacs Tags
target compiler	cross.fs
target compiler	Cross Compiler
`task`	Basic multi-tasking
task-local data	Task-local data
terminal buffer, size	core-idef
terminal output	Terminal output
terminal size	Terminal output
terminology for object-oriented programming	Object-Oriented Terminology
text interpreter	Introducing the Text Interpreter
text interpreter	Stacks and Postfix notation
text interpreter	The Text Interpreter
text interpreter - effect of state	How does that work?
text interpreter - input sources	Input Sources
`text-color:`	widget methods
`text-emoji-color:`	widget methods
`text-emoji-fade-color:`	widget methods
`th`	Address arithmetic
`th!`	Address arithmetic
`th@`	Address arithmetic
`THEN`	Arbitrary control structures
`third`	Data stack
`this`	Objects Glossary
`this` and `catch`	Objects Implementation
`this` implementation	Objects Implementation
`this` usage	Method conveniences
ThisForth performance	Performance
`thread-deadline`	Basic multi-tasking
threaded code implementation	Threading
threading words	Threading Words
`threading-method`	Threading Words
threading, direct or indirect?	Direct or Indirect Threaded?
`throw`	Exception Handling
`THROW`-codes used in the system	exception-idef
`thru`	Blocks
`tib`	The Text Interpreter
tick (’)	Execution token
TILE performance	Performance
time-related words	Keeping track of Time
`time&date`	Keeping track of Time
`TMP`, `TEMP` - environment variable	Environment variables
`TO`	Values
`to name` semantics, changing them	Words with user-defined TO etc.
`TO` on non-`VALUE`s	core-ambcond
`TO` on non-`VALUE`s and non-locals	locals-ambcond
`to-class:`	Words with user-defined TO etc.
`to-table:`	Words with user-defined TO etc.
`to-this`	Objects Glossary
tokens for words	Tokens for Words
TOS definition	Stacks and Postfix notation
TOS optimization for primitives	TOS Optimization
`touchdown`	actor methods
`touchup`	actor methods
`toupper`	Xchars and Unicode
`translate-cell`	Defining recognizers
`translate-complex`	Defining recognizers
`translate-dcell`	Defining recognizers
`translate-env`	Defining recognizers
`translate-float`	Defining recognizers
`translate-name`	Defining recognizers
`translate-string`	Defining recognizers
`translate-to`	Defining recognizers
`translate:`	Defining translation tokens
translation	Defining recognizers
translation token	Defining recognizers
translation-token words, stack effect	Defining recognizers
`traverse-wordlist`	Name token
trigonometric operations	Floating Point
`true`	Boolean Flags
truncation of floating-point numbers	floating-idef
`try`	Exception Handling
`tt`	Locating exception source
`tuck`	Data stack
turnkey image files	Modifying the Startup Sequence
Tutorial	Tutorial
`type`	Displaying characters and strings
types of locals	Gforth locals
types of stack items	Notation
types tutorial	Types Tutorial
`typewhite`	Displaying characters and strings

U
`u-[do`	Counted Loops
`U-DO`	Counted Loops
`u`, stack item type	Notation
`u.`	Simple numeric output
`u.r`	Simple numeric output
`u*/`	Integer division
`u*/mod`	Integer division
`u/`	Integer division
`u/-stage1m`	Two-stage integer division
`u/-stage2m`	Two-stage integer division
`u/mod`	Integer division
`u/mod-stage2m`	Two-stage integer division
`U+DO`	Counted Loops
`u<`	Numeric comparison
`u<=`	Numeric comparison
`u>`	Numeric comparison
`u>=`	Numeric comparison
`uallot`	Task-local data
`ud`, stack item type	Notation
`ud.`	Simple numeric output
`ud.r`	Simple numeric output
`ud/mod`	Integer division
`UDefer`	Task-local data
`ukeyed`	actor methods
`um*`	Mixed precision
`um/mod`	Integer division
`umax`	Single precision
`umin`	Single precision
`umod`	Integer division
`umod-stage2m`	Two-stage integer division
unaligned memory access	Special Memory Accesses
`uncolored-mode`	Color themes
undefined word	core-ambcond
undefined word, `'`, `POSTPONE`, `[']`, `[COMPILE]`	core-ambcond
`under+`	Single precision
`unescape`	Substitute
unexpected end of the input buffer	core-ambcond
`unlock`	Semaphores
`unloop`	Counted Loops
unmapped block numbers	file-ambcond
`UNREACHABLE`	Where are locals visible by name?
`UNTIL`	Arbitrary control structures
`UNTIL` loop	General Loops
`unused`	Dictionary allocation
`unused-words`	Locating uses of a word
unwind-protect	Exception Handling
`up@`	Task-local data
`update`	Blocks
`UPDATE`, no current block buffer	block-ambcond
`updated?`	Blocks
upper and lower case	Case insensitivity
`use`	Blocks
`User`	Task-local data
user input device, method of selecting	core-idef
user output device, method of selecting	core-idef
user space	Task-local data
user variables	Task-local data
user-defined defining words	User-defined Defining Words
`user'`	Task-local data
Uses of a word	Locating uses of a word
UTF-8 and ASCII	Strings and Characters
`utime`	Keeping track of Time
`UValue`	Task-local data

V
`v*`	Floating Point
`Value`	Values
value-flavoured locals	Gforth locals
value-flavoured words	Values
`value:`	Value-Flavoured and Defer-Flavoured Fields
`value[]:`	Value-Flavoured and Defer-Flavoured Fields
values	Values
`var`	Class Declaration
`var`	Basic Mini-OOF Usage
`Variable`	Variables
variable-flavoured locals	Gforth locals
variable-flavoured words	Values
variables	Variables
variadic C functions	Declaring C Functions
versions, invoking other versions of Gforth	Invoking Gforth
`vglue`	widget methods
`vglue@`	widget methods
`view` (called `locate` in Gforth)	Locating source code definitions
viewing the documentation of a word in Emacs	Emacs and Gforth
viewing the source of a word in Emacs	Emacs Tags
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?
`vlist`	Word Lists
vocabularies vs. wordlists	Wordlist and vocabulary usage
Vocabularies, usage	Wordlist and vocabulary usage
`Vocabulary`	Word Lists
`vocs`	Word Lists
vocstack empty, `previous`	search-ambcond
vocstack full, `also`	search-ambcond
`vp-bottom`	widget methods
`vp-left`	widget methods
`vp-needed`	widget methods
`vp-reslide`	widget methods
`vp-right`	widget methods
`vp-top`	widget methods

W
`w`	widget methods
`w-color`	widget methods
`w,`	Dictionary allocation
`w`, stack item type	Notation
`W:`	Locals definition words
`w!`	Special Memory Accesses
`w@`	Special Memory Accesses
`w/o`	General files
`W^`	Locals definition words
`w>s`	Special Memory Accesses
`wake`	Basic multi-tasking
`walign`	Address arithmetic
`waligned`	Address arithmetic
`warning-color`	Color output
`WARNING"`	Exception Handling
`warnings`	Exception Handling
`wbe`	Special Memory Accesses
`wfield:`	Standard Structures
`where`	Locating uses of a word
where to go next	Where to go next
`whereg`	Locating uses of a word
`WHILE`	Arbitrary control structures
`WHILE` loop	General Loops
wid	Word Lists
`wid`, stack item type	Notation
`widget`	MINOS2 object framework
Win32Forth performance	Performance
wior type description	Notation
wior values and meaning	file-idef
`within`	Numeric comparison
`wle`	Special Memory Accesses
word	Introducing the Text Interpreter
`word`	The Input Stream
`WORD` buffer size	core-idef
word glossary entry format	Notation
word list for defining locals	Locals implementation
word lists	Word Lists
word lists - why use them?	Why use word lists?
word name too long	core-ambcond
`WORD`, string overflow	core-ambcond
`wordlist`	Word Lists
wordlist usage	Wordlist and vocabulary usage
`wordlist-words`	Word Lists
`wordlists`	Environmental Queries
wordlists tutorial	Wordlists and Search Order Tutorial
words	Words
`words`	Word Lists
words used in your program	Standard Report
words, forgetting	Forgetting words
wordset	Notation
`wrap-xt`	Deferred Words
`write-file`	General files
`write-line`	General files
`wrol`	Bitwise operations
`wror`	Bitwise operations
`WTF??`	Debugging
`wvalue:`	Value-Flavoured and Defer-Flavoured Fields
`ww`	Locating uses of a word

X
`x`	widget methods
`x-size`	Xchars and Unicode
`x-width`	Xchars and Unicode
`x,`	Dictionary allocation
`x`, stack item type	Notation
`x!`	Special Memory Accesses
`x@`	Special Memory Accesses
`x\string-`	Xchars and Unicode
`x>s`	Special Memory Accesses
`xalign`	Address arithmetic
`xaligned`	Address arithmetic
`xbe`	Special Memory Accesses
`xc-size`	Xchars and Unicode
`xc-width`	Xchars 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-ENCODING`	Environmental Queries
`XCHAR-MAXMEM`	Environmental Queries
`xchar+`	Xchars and Unicode
`xd,`	Dictionary allocation
`xd!`	Special Memory Accesses
`xd@`	Special Memory Accesses
`xd>s`	Special Memory Accesses
`xdbe`	Special Memory Accesses
`xdle`	Special Memory Accesses
`xemit`	Displaying characters and strings
`xfield:`	Standard Structures
`xhold`	Xchars and Unicode
`xkey`	Single-key input
`xkey?`	Single-key input
`xle`	Special Memory Accesses
`xor`	Bitwise operations
xt	Introducing the Text Interpreter
xt	Execution token
xt input format	Literals for tokens and addresses
XT tutorial	Execution Tokens Tutorial
`xt-locate`	Locating source code definitions
`xt-new`	Objects Glossary
`xt-see`	Examining compiled code
`xt-see-code`	Examining compiled code
`xt-simple-see`	Examining compiled code
`xt`, stack item type	Notation
`XT:`	Locals definition words
`xt>name`	Name token
`xywh`	widget methods
`xywhd`	widget methods

Y
`y`	widget methods

Z
`Z:`	Locals definition words
`Z^`	Locals definition words
zero-length string as a name	core-ambcond
Zsoter’s object-oriented model	Comparison with other object models
`zvalue:`	Value-Flavoured and Defer-Flavoured Fields

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