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

-
	Index Entry	Section

	`-`	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
	–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`	Colon Definitions
	`;m`	Objects Glossary
	`;m` usage	Method conveniences
	`;s`	Calls and returns

:
	`:`	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
	`!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
	`?found`	Dealing with existing Recognizers
	`?inside`	actor methods
	`?ior`	Exception Handling
	`?LEAVE`	Counted Loops
	`?of`	Arbitrary control structures

.
	`.`	Simple numeric output
	`.?`	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`	i18n and l10n
	`.path`	General Search Paths
	`.quoted-csv`	CSV reading and writing
	`.r`	Simple numeric output
	`.recognizers`	Default Recognizers
	`.s`	Examining data
	`.sections`	Sections
	`.substitute`	Substitute
	`.unresolved`	Forward
	`.voc`	Word Lists
	`.widget`	widget methods

'
	`'`	Execution token
	’-prefix for characters/code points	Literals in source code
	`'`, 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]`	Words with user-defined TO etc.
	`[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	Literals in source code

#
	`#`	Formatted numeric output
	#-prefix for decimal numbers	Literals in source code
	`#!`	Running Image Files
	`#>`	Formatted numeric output
	`#>>`	Formatted numeric output
	`#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`	Formatted numeric output
	`#tab`	String and character literals
	`#tib`	The Text Interpreter

%
	%-prefix for binary numbers	Literals in source code
	`%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 in source code
	`?	Regular Expressions
	`` prefix of word	Literals in source code

+
	`+`	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
	`+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?
	`<#`	Formatted numeric output
	`<<`	Regular Expressions
	`<<"`	Regular Expressions
	`<<#`	Formatted numeric output
	`<=`	Numeric comparison
	`<>`	Numeric comparison
	`<bind>`	Objects Glossary
	`<to-inst>`	Objects Glossary

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

>
	`>`	Numeric comparison
	`>=`	Numeric comparison
	`>>`	Regular Expressions
	`>addr`	Varues
	`>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`	Line input and conversion
	`>float1`	Line input and conversion
	`>in`	The Text Interpreter
	`>IN` greater than input buffer	core-ambcond
	`>l`	Locals implementation
	`>name`	Name token
	`>number`	Line input and 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
	`>to+addr-table:`	Words with user-defined TO etc.
	`>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	Literals in source code
	`$!`	$tring words
	`$!len`	$tring words
	`$?`	Passing Commands to the OS
	`$.`	$tring words
	`$[]`	$tring words
	`$[]!`	$tring words
	`$[].`	$tring words
	`$[]@`	$tring words
	`$[]#`	$tring words
	`$[]+!`	$tring words
	`$[]boot`	$tring words
	`$[]free`	$tring words
	`$[]map`	$tring words
	`$[]save`	$tring words
	`$[]saved`	$tring words
	`$[]slurp`	$tring words
	`$[]slurp-file`	$tring words
	`$[]Variable`	$tring words
	`$@`	$tring words
	`$@len`	$tring words
	`$+!`	$tring words
	`$+!len`	$tring words
	`$+[]!`	$tring words
	`$+slurp`	$tring words
	`$+slurp-file`	$tring words
	`$boot`	$tring words
	`$del`	$tring words
	`$exec`	$tring words
	`$free`	$tring words
	`$init`	$tring words
	`$ins`	$tring words
	`$iter`	$tring words
	`$over`	$tring words
	`$save`	$tring words
	`$saved`	$tring words
	`$slurp`	$tring words
	`$slurp-file`	$tring words
	`$split`	String words
	`$substitute`	Substitute
	`$tmp`	$tring words
	`$unescape`	Substitute
	`$value:`	Varue-Flavoured and Defer-Flavoured Fields
	`$value[]:`	Varue-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	Literals in source code

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
	`2compile,`	Macros
	`2Constant`	Constants
	`2drop`	Data stack
	`2dup`	Data stack
	`2field:`	Standard Structures
	`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:`	Varue-Flavoured and Defer-Flavoured Fields
	`2Variable`	Variables
	`2varue`	Varues

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`	Line input and conversion
	`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`	Varues
	`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
	`adjust-buffer`	Growable memory buffers
	`after-locate`	Locating source code definitions
	`AGAIN`	Arbitrary control structures
	`AHEAD`	Arbitrary control structures
	`Alias`	Aliases
	aliases	Aliases
	`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
	`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`	Number Conversion
	`base` is not decimal (`REPRESENT`, `F.`, `FE.`, `FS.`)	floating-ambcond
	`base-execute`	Number Conversion
	`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
	`block-position`	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 in source code
	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
	`CA:`	Locals definition 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`	Arbitrary control structures
	`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	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 vs. extended characters	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 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-cover`	Code Coverage
	`color:`	widget methods
	combined words	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 semantics	How does that work?
	compilation semantics	Interpretation and Compilation Semantics
	compilation semantics tutorial	Interpretation and Compilation Semantics and Immediacy Tutorial
	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`	Terminal output
	`compile-lp+!`	Locals implementation
	`compile-only`	Interpretation and Compilation Semantics
	compile-only warning, for `'` etc.	core-ambcond
	compile-only words	Interpretation and Compilation Semantics
	`compile-only?`	Header fields
	`compile,`	Macros
	compiled code examination	Examining compiled code
	`compiling`	Dealing with existing Recognizers
	compiling compilation semantics	Macros
	compiling words	Compiling words
	complex numbers, input format	Literals in source code
	`compsem:`	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 regions and heap allocation	Heap Allocation
	contiguous regions in dictionary allocation	Dictionary allocation
	contiguous regioons and sections	Sections
	`contof`	Arbitrary control structures
	contributors to Gforth	Origin
	control characters as delimiters	core-idef
	control structures	Control Structures
	control structures for selection	Selection
	control structures programming style	Arbitrary control structures
	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`	Line input and conversion
	convertin strings to numbers	Line input and 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
	`Country`	i18n and l10n
	`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:`	Varue-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
	`DA:`	Locals definition words
	`dabs`	Double precision
	`dark-mode`	Terminal output
	`darshift`	Bitwise operations
	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`	Number Conversion
	declaring C functions	Declaring C Functions
	decompilation tutorial	Decompilation Tutorial
	default type of locals	Gforth locals
	`default-color`	Terminal output
	`default-w:`	Gforth locals
	`default-wa:`	Gforth locals
	`Defer`	Deferred Words
	`defer`	Class Declaration
	`defer:`	Varue-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:`	Varue-Flavoured and Defer-Flavoured Fields
	`dglue`	widget methods
	`dglue@`	widget methods
	`dict-new`	Objects Glossary
	`dict-new` discussion	Creating objects
	dictionary	The Text Interpreter
	dictionary in persistent form	Image Files
	dictionary overflow	core-ambcond
	dictionary size default	Stack and Dictionary Sizes
	digits > 35	core-idef
	direct threaded inner interpreter	Threading
	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	Literals in source code
	double-ended queue	User-defined Stacks
	`double%`	Gforth structs
	doubly indirect threaded code	gforthmi
	`douser:`	Threading Words
	`dovalue:`	Threading Words
	`dovar:`	Threading Words
	`dpl`	Number Conversion
	`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`	Line input and conversion
	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-buffer`	Blocks
	`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`	Arbitrary control structures
	`ENDIF`	Arbitrary control structures
	endless loop	Simple Loops
	`endof`	Arbitrary control structures
	`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	Literals in source code
	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
	`erase`	Memory Blocks
	error messages	Error messages
	error output, finding the source location in Emacs	Emacs and Gforth
	`error-color`	Terminal output
	`error-hl-inv`	Terminal output
	`error-hl-ul`	Terminal 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	Interpretation and Compilation Semantics
	execution token	Introducing the Text Interpreter
	execution token	Execution token
	execution token input format	Literals in source code
	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`	Line input and conversion
	`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
	`f<=`	Floating Point
	`f<>`	Floating Point
	`f=`	Floating Point
	`f>`	Floating Point
	`f>=`	Floating Point
	`f>buf-rdp`	Floating-point output
	`f>d`	Floating Point
	`F>D`, integer part of float cannot be represented by d	floating-ambcond
	`f>l`	Locals implementation
	`f>s`	Floating Point
	`f>str-rdp`	Floating-point output
	`f~`	Floating Point
	`f~abs`	Floating Point
	`f~rel`	Floating Point
	`f0<`	Floating Point
	`f0<=`	Floating Point
	`f0<>`	Floating Point
	`f0=`	Floating Point
	`f0>`	Floating Point
	`f0>=`	Floating Point
	`f2*`	Floating Point
	`f2/`	Floating Point
	`FA:`	Locals definition words
	`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 closures	Closures
	flavours of locals	Gforth locals
	`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
	floating-point constants	Floating Point
	floating-point dividing by zero	floating-ambcond
	floating-point numbers, input format	Literals in source code
	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	Formatted numeric output
	`Forth`	Word Lists
	Forth - an introduction	Introduction
	Forth mode in Emacs	Emacs and Gforth
	Forth source files	Forth source files
	Forth Tutorial	Tutorial
	`forth-recognize`	Dealing with existing Recognizers
	`forth-recognizer`	Dealing with existing Recognizers
	Forth-related information	Forth-related information
	`forth-wordlist`	Word Lists
	`forth.el`	Emacs and Gforth
	`forward`	Forward
	`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
	`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:`	Varue-Flavoured and Defer-Flavoured Fields
	`fvariable`	Variables
	`fvarue`	Varues

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-recognizers`	Dealing with existing Recognizers
	`get-stack`	User-defined Stacks
	`get-state`	Dealing with existing Recognizers
	`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-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`	Number Conversion
	`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`	Formatted numeric output
	`holds`	Formatted numeric output
	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 - see input	Line input and conversion
	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`	Interpretation and Compilation Semantics
	immediate words	How does that work?
	immediate words	Interpretation and Compilation Semantics
	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-lining of constants	Constants
	`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-locale`	i18n and l10n
	`include`, placement in files	Emacs Tags
	`included`	Forth source files
	`included-locale`	i18n and l10n
	`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`	Terminal 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:`	Colon Definitions
	inner interpreter implementation	Threading
	inner interpreter optimization	Scheduling
	inner interpreter, direct threaded	Threading
	inner interpreter, indirect threaded	Threading
	input buffer	The Text Interpreter
	input format for body-relative addresses	Literals in source code
	input format for characters/code points	Literals in source code
	input format for double-cell numbers	Literals in source code
	input format for environment variables	Literals in source code
	input format for execution tokens	Literals in source code
	input format for floating-point numbers	Literals in source code
	input format for name tokens	Literals in source code
	input format for single-cell numbers	Literals in source code
	input format for strings	Literals in source code
	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`	Terminal output
	input, linewise from terminal	Line input and conversion
	input, single-key	Single-key input
	`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 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`	The Text Interpreter
	interpret state	The Text Interpreter
	Interpret/Compile states	Interpret/Compile states
	`interpret/compile:`	Combined words
	interpretation semantics	How does that work?
	interpretation semantics	Interpretation and Compilation Semantics
	interpretation semantics tutorial	Interpretation and Compilation Semantics and Immediacy Tutorial
	interpreter - outer	The Text Interpreter
	interpreter directives	Interpreter Directives
	`interpreting`	Dealing with existing Recognizers
	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:`	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
	`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"`	i18n and l10n
	`l@`	Special Memory Accesses
	`l>s`	Special Memory Accesses
	labels as values	Threading
	`lalign`	Address arithmetic
	`laligned`	Address arithmetic
	`LANG` – environment variable	Environment variables
	`Language`	i18n and l10n
	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`	Terminal output
	line input from terminal	Line input and conversion
	line terminator on input	core-idef
	`line-end-hook`	Text Interpreter Hooks
	`list`	Blocks
	`LIST` display format	block-idef
	`list-size`	Locals implementation
	`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`	i18n and l10n
	`locale-csv-out`	i18n and l10n
	`locale-file`	i18n and l10n
	`locale!`	i18n and l10n
	`locale@`	i18n and l10n
	locals	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 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
	`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	Simple Loops
	loops, counted	Counted Loops
	loops, counted, tutorial	Counted loops Tutorial
	loops, endless	Simple Loops
	loops, indefinite, tutorial	General Loops Tutorial
	`lp!`	Stack pointer manipulation
	`lp!`	Locals implementation
	`lp@`	Stack pointer manipulation
	`lp+!`	Locals implementation
	`lp0`	Stack pointer manipulation
	`lrol`	Bitwise operations
	`lror`	Bitwise operations
	`lshift`	Bitwise operations
	`LSHIFT`, large shift counts	core-ambcond
	`LU"`	i18n and l10n
	`lvalue:`	Varue-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`	Terminal output
	`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	Literals in source code
	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`	BEGIN 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 token	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@`	i18n and l10n
	`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`	Arbitrary control structures
	`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 in source code
	nt token input format	Literals in source code
	`nt`, stack item type	Notation
	`ntime`	Keeping track of Time
	number conversion	Number Conversion
	number conversion - traps for the unwary	Number Conversion
	number of bits in one address unit	core-idef
	number representation and arithmetic	core-idef
	numeric comparison words	Numeric comparison
	numeric output - formatted	Formatted numeric output
	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`	Arbitrary control structures
	`off`	Boolean Flags
	`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 area	The Text Interpreter
	`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?
	parsing words	The Text Interpreter
	`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	Formatted numeric output
	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,`	Compilation token
	`postponing`	Dealing with existing Recognizers
	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 data space available	core-other
	programming style, arbitrary control structures	Arbitrary control structures
	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	core-idef
	pronounciation 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`	Dealing with existing Recognizers
	`rec-complex`	Dealing with existing Recognizers
	`rec-dtick`	Dealing with existing Recognizers
	`rec-env`	Dealing with existing Recognizers
	`rec-float`	Dealing with existing Recognizers
	`rec-meta`	Dealing with existing Recognizers
	`rec-moof2`	Mini-OOF2
	`rec-nt`	Dealing with existing Recognizers
	`rec-num`	Dealing with existing Recognizers
	`rec-scope`	Dealing with existing Recognizers
	`rec-string`	Dealing with existing Recognizers
	`rec-tick`	Dealing with existing Recognizers
	`rec-to`	Dealing with existing Recognizers
	receiving object	Object-Oriented Terminology
	reciprocal of integer	Two-stage integer division
	`recognize`	Dealing with existing Recognizers
	`recognizer-sequence:`	Dealing with existing Recognizers
	Recognizers normal usage	Default Recognizers
	Recognizers, dealing with	Dealing with existing Recognizers
	recongizers	Recognizers
	records	Structures
	records tutorial	Arrays and Records Tutorial
	`recover` (old Gforth versions)	Exception Handling
	`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 output
	`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`	Interpretation and Compilation Semantics
	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
	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
	`s>number?`	Line input and conversion
	`s>unumber?`	Line input and conversion
	`safe/string`	String words
	`save-buffer`	Blocks
	`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
	`scope`	Where are locals visible by name?
	scope of locals	Where are locals visible by name?
	scoping and classes	Classes and Scoping
	`scr`	Blocks
	`scrolled`	actor methods
	`scvalue:`	Varue-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, changing the `to`/`+to`/`addr`/`action-of`/`is name` semantics	Words with user-defined TO etc.
	semantics, interpretation and compilation	Interpretation and Compilation Semantics
	`semaphore`	Semaphores
	`send-event`	Message queues
	`set`	actor methods
	`set->comp`	Header methods
	`set->int`	Header methods
	`set-compsem`	Combined words
	`set-current`	Word Lists
	`set-dir`	Directories
	`set-does>`	CREATE..DOES> details
	`set-execute`	Header methods
	`set-forth-recognize`	Dealing with existing Recognizers
	`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-recognizers`	Dealing with existing Recognizers
	`set-stack`	User-defined Stacks
	`set-state`	Dealing with existing Recognizers
	`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:`	Varue-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`	Formatted numeric output
	sign extension	Special Memory Accesses
	silent exiting from Gforth	Gforth in pipes
	simple defining words	CREATE
	simple loops	Simple 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	Literals in source code
	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
	`SLiteral`	Literals
	`slurp-fid`	General files
	`slurp-file`	General files
	`slvalue:`	Varue-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`	Line input and conversion
	`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` - effect on the text interpreter	How does that work?
	`STATE` values	core-idef
	state-smart words (are a bad idea)	Combined words
	`static`	Class Declaration
	`status-color`	Terminal 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	Literals in source code
	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 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`	Terminal output
	superclass binding	Class Binding
	Superinstructions	Dynamic Superinstructions
	`swap`	Data stack
	`swvalue:`	Varue-Flavoured and Defer-Flavoured Fields
	symmetric division	Integer division
	`Synonym`	Aliases
	synonyms	Aliases
	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 input buffer	The Text Interpreter
	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	The Text Interpreter
	text interpreter - input sources	Input Sources
	`text-color:`	widget methods
	`text-emoji-color:`	widget methods
	`text-emoji-fade-color:`	widget methods
	`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`	Characters
	`translate-dnum`	Dealing with existing Recognizers
	`translate-float`	Dealing with existing Recognizers
	`translate-method:`	Dealing with existing Recognizers
	`translate-nt`	Dealing with existing Recognizers
	`translate-num`	Dealing with existing Recognizers
	`translate:`	Dealing with existing Recognizers
	`traverse-wordlist`	Name token
	trigonometric operations	Floating Point
	`true`	Boolean Flags
	truncation of floating-point numbers	floating-idef
	`try`	Exception Handling
	`try-recognize`	Dealing with existing Recognizers
	`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`	Terminal output
	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	Simple 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
	`utime`	Keeping track of Time
	`UValue`	Task-local data

V
	`v*`	Floating Point
	`Value`	Values
	value-flavoured locals	Gforth locals
	`value:`	Varue-Flavoured and Defer-Flavoured Fields
	`value!`	Values
	`value[]:`	Varue-Flavoured and Defer-Flavoured Fields
	`value+!`	Values
	values	Values
	`var`	Class Declaration
	`var`	Basic Mini-OOF Usage
	`Variable`	Variables
	variable-flavoured locals	Gforth locals
	variables	Variables
	variadic C functions	Declaring C Functions
	`Varue`	Varues
	varue-flavoured locals	Gforth locals
	varues	Varues
	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, detailed explanation	Vocabularies
	`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
	`WA:`	Locals definition words
	`wake`	Basic multi-tasking
	`walign`	Address arithmetic
	`waligned`	Address arithmetic
	`warning-color`	Terminal 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	Simple 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 - example	Word list example
	word lists - why use them?	Why use word lists?
	word name too long	core-ambcond
	`WORD`, string overflow	core-ambcond
	`wordlist`	Word Lists
	`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:`	Varue-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`	Xchars and Unicode
	`xkey?`	Single-key input
	`xle`	Special Memory Accesses
	`xor`	Bitwise operations
	xt	Introducing the Text Interpreter
	xt	Execution token
	xt input format	Literals in source code
	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
	`XTA:`	Locals definition words
	`xywh`	widget methods
	`xywhd`	widget methods

Y
	`y`	widget methods

Z
	`z:`	Locals definition words
	`za:`	Locals definition words
	zero-length string as a name	core-ambcond
	Zsoter’s object-oriented model	Comparison with other object models
	`zvalue:`	Varue-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