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 Z

-
	Index Entry	Section

	`-`	Single precision
	`-->`	Blocks
	–, tutorial	Stack-Effect Comments Tutorial
	–appl-image, command-line option	Invoking Gforth
	–application, `gforthmi` option	gforthmi
	–clear-dictionary, command-line option	Invoking Gforth
	-d, command-line option	Invoking Gforth
	–data-stack-size, command-line option	Invoking Gforth
	–debug, command-line option	Invoking Gforth
	-DFORCE_REG	Portability
	–dictionary-size, command-line option	Invoking Gforth
	–die-on-signal, command-line-option	Invoking Gforth
	`-DO`	Arbitrary control structures
	-DUSE_FTOS	TOS Optimization
	-DUSE_NO_FTOS	TOS Optimization
	-DUSE_NO_TOS	TOS Optimization
	-DUSE_TOS	TOS Optimization
	–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
	–image file, invoke image file	Running Image Files
	–image-file, command-line option	Invoking Gforth
	-l, command-line option	Invoking Gforth
	–locals-stack-size, command-line option	Invoking Gforth
	`-LOOP`	Arbitrary control structures
	-m, command-line option	Invoking Gforth
	–no-dynamic command-line option	Dynamic Superinstructions
	–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
	-p, command-line option	Invoking Gforth
	–path, command-line option	Invoking Gforth
	–print-metrics, 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
	`-trailing`	Memory Blocks
	`-trailing-garbage`	Xchars and Unicode
	-v, command-line option	Invoking Gforth
	–version, command-line option	Invoking Gforth
	–vm-commit, command-line option	Invoking Gforth

,
	`,`	Dictionary allocation

;
	`;`	Colon Definitions
	`;code`	Code and ;code
	`;CODE` ending sequence	programming-idef
	`;CODE`, name not defined via `CREATE`	programming-ambcond
	`;CODE`, processing input	programming-idef
	`;m`	Objects Glossary
	`;m` usage	Method conveniences
	`;s`	Calls and returns

:
	`:`	Colon Definitions
	`:`	The OOF base class
	`:`, passing data across	Literals
	`::`	The OOF base class
	`::`	Basic Mini-OOF Usage
	`:m`	Objects Glossary
	`:noname`	Anonymous Definitions

!
	`!`	Memory Access

?
	`?`	Examining
	`?DO`	Arbitrary control structures
	`?dup`	Data stack
	`?DUP-0=-IF`	Arbitrary control structures
	`?DUP-IF`	Arbitrary control structures
	`?LEAVE`	Arbitrary control structures

.
	`.`	Simple numeric output
	`."`	Displaying characters and strings
	`."`, how it works	How does that work?
	`.(`	Displaying characters and strings
	`.\"`	Displaying characters and strings
	`.debugline`	Debugging
	`.emacs`	Installing gforth.el
	`.fi` files	Image Files
	`.gforth-history`	Command-line editing
	`.id`	Name token
	`.name`	Name token
	`.path`	General Search Paths
	`.r`	Simple numeric output
	`.s`	Examining

'
	`'`	Execution token
	`'`	The OOF base class
	’-prefix for character strings	Number Conversion
	`'cold`	Modifying the Startup Sequence

"
	`"`, stack item type	Notation

(
	`(`	Comments
	`(local)`	ANS Forth locals

)
	`)`	Assertions

[
	`[`	Literals
	`[?DO]`	Interpreter Directives
	`[']`	Execution token
	`[]`	The OOF base class
	`[+LOOP]`	Interpreter Directives
	`[AGAIN]`	Interpreter Directives
	`[BEGIN]`	Interpreter Directives
	`[bind]`	Objects Glossary
	`[bind]` usage	Class Binding
	`[Char]`	Displaying characters and strings
	`[COMP']`	Compilation token
	`[compile]`	Macros
	`[current]`	Objects Glossary
	`[DO]`	Interpreter Directives
	`[ELSE]`	Interpreter Directives
	`[ENDIF]`	Interpreter Directives
	`[FOR]`	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
	`[NEXT]`	Interpreter Directives
	`[parent]`	Objects Glossary
	`[parent]` usage	Class Binding
	`[REPEAT]`	Interpreter Directives
	`[THEN]`	Interpreter Directives
	`[to-inst]`	Objects Glossary
	`[UNTIL]`	Interpreter Directives
	`[WHILE]`	Interpreter Directives

]
	`]`	Literals
	`]L`	Literals

@
	`@`	Memory Access
	`@local#`	Locals implementation

*
	`*`	Single precision
	`*/`	Mixed precision
	`*/mod`	Mixed precision

/
	`/`	Single precision
	`/does-handler`	Threading Words
	`/l`	Address arithmetic
	`/mod`	Single precision
	`/string`	Memory Blocks
	`/w`	Address arithmetic

\
	`\`	Comments
	`\`, editing with Emacs	Emacs and Gforth
	`\`, line length in blocks	block-idef
	`\c`	Declaring C Functions
	`\G`	Comments

&
	&-prefix for decimal numbers	Number Conversion

#
	`#`	Formatted numeric output
	#-prefix for decimal numbers	Number Conversion
	`#!`	Running Image Files
	`#>`	Formatted numeric output
	`#>>`	Formatted numeric output
	`#s`	Formatted numeric output
	`#tib`	The Text Interpreter

%
	%-prefix for binary numbers	Number Conversion
	`%align`	Structure Glossary
	`%alignment`	Structure Glossary
	`%alloc`	Structure Glossary
	`%allocate`	Structure Glossary
	`%allot`	Structure Glossary
	`%size`	Structure Glossary

+
	`+`	Single precision
	`+!`	Memory Access
	`+DO`	Arbitrary control structures
	`+field`	Forth200x Structures
	`+load`	Blocks
	`+LOOP`	Arbitrary control structures
	`+thru`	Blocks
	`+x/string`	Xchars and Unicode

<
	`<`	Numeric comparison
	`<#`	Formatted numeric output
	`<<#`	Formatted numeric output
	`<=`	Numeric comparison
	`<>`	Numeric comparison
	`<bind>`	Objects Glossary
	`<compilation`	Combined words
	`<interpretation`	Combined words
	`<to-inst>`	Objects Glossary

=
	`=`	Numeric comparison

>
	`>`	Numeric comparison
	`>=`	Numeric comparison
	`>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
	`>in`	The Text Interpreter
	`>IN` greater than input buffer	core-ambcond
	`>l`	Locals implementation
	`>name`	Name token
	`>number`	Line input and conversion
	`>order`	Word Lists
	`>r`	Return stack

~
	`~~`	Debugging
	`~~`, removal with Emacs	Emacs and Gforth

$
	$-prefix for hexadecimal numbers	Number Conversion
	`$?`	Passing Commands to the OS

0
	`0<`	Numeric comparison
	`0<=`	Numeric comparison
	`0<>`	Numeric comparison
	`0=`	Numeric comparison
	`0>`	Numeric comparison
	`0>=`	Numeric comparison
	0x-prefix for hexadecimal numbers	Number Conversion

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

2
	`2,`	Dictionary allocation
	`2!`	Memory Access
	`2@`	Memory Access
	`2*`	Bitwise operations
	`2/`	Bitwise operations
	`2>r`	Return stack
	`2Constant`	Constants
	`2drop`	Data stack
	`2dup`	Data stack
	`2field:`	Forth200x 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
	`2Variable`	Variables

A
	`a_`, stack item type	Notation
	`abort`	Exception Handling
	`ABORT"`	Exception Handling
	`ABORT"`, exception abort sequence	core-idef
	`abs`	Single precision
	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
	`action-of`	Deferred Words
	`add-lib`	Declaring OS-level libraries
	address alignment exception	core-ambcond
	address alignment exception, stack overflow	core-ambcond
	address arithmetic for structures	Why explicit structure support?
	address arithmetic restrictions, ANS vs. Gforth	Memory model
	address arithmetic words	Address arithmetic
	address of counted string	String Formats
	address unit	Address arithmetic
	address unit, size in bits	core-idef
	`ADDRESS-UNIT-BITS`	Address arithmetic
	`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
	`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
	ANS conformance of Gforth	ANS conformance
	`ans-report.fs`	ANS Report
	`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
	arrays	CREATE
	arrays tutorial	Arrays and Records Tutorial
	`asptr`	The OOF base class
	`asptr`	Class Declaration
	assembler	Assembler and Code Words
	`assembler`	Code and ;code
	`ASSEMBLER`, search order capability	programming-idef
	`assert-level`	Assertions
	`assert(`	Assertions
	`assert0(`	Assertions
	`assert1(`	Assertions
	`assert2(`	Assertions
	`assert3(`	Assertions
	assertions	Assertions
	`ASSUME-LIVE`	Where are locals visible by name?
	`at-xy`	Terminal output
	`AT-XY` can’t be performed on user output device	facility-ambcond
	Attempt to use zero-length string as a name	core-ambcond
	au (address unit)	Address arithmetic
	authors of Gforth	Origin
	auto-indentation of Forth code in Emacs	Auto-Indentation

B
	backtrace	Error messages
	backtraces with `gforth-fast`	Error messages
	`base`	Number Conversion
	`base` is not decimal (`REPRESENT`, `F.`, `FE.`, `FS.`)	floating-ambcond
	`base-execute`	Number Conversion
	basic objects usage	Basic Objects Usage
	batch processing with Gforth	Invoking Gforth
	`BEGIN`	Arbitrary control structures
	`begin-structure`	Forth200x Structures
	benchmarking Forth systems	Performance
	`Benchres`	Performance
	`bin`	General files
	`bind`	Objects Glossary
	`bind`	The OOF base class
	`bind` usage	Class Binding
	`bind'`	Objects Glossary
	bitwise operation words	Bitwise operations
	`bl`	Displaying characters and strings
	`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
	Boolean flags	Boolean Flags
	`bootmessage`	Modifying the Startup Sequence
	`bound`	The OOF base class
	`bounds`	Memory Blocks
	`break:`	Singlestep Debugger
	`break"`	Singlestep Debugger
	`broken-pipe-error`	Pipes
	`buffer`	Blocks
	bug reporting	Bugs
	`bye`	Leaving Gforth
	`bye` during `gforthmi`	gforthmi

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-function`	Declaring C Functions
	`c-library`	Defining library interfaces
	`c-library-name`	Defining library interfaces
	`c,`	Dictionary allocation
	`c`, stack item type	Notation
	C, using C for the engine	Portability
	`c!`	Memory Access
	`C"`	Displaying characters and strings
	`c@`	Memory Access
	`call-c`	Low-Level C Interface Words
	Callback functions written in Forth	Callbacks
	calling a definition	Calls and returns
	calling C functions	Calling C Functions
	`case`	Arbitrary control structures
	`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
	`cell`	Address arithmetic
	cell size	core-idef
	cell-aligned addresses	core-idef
	`cell%`	Structure Glossary
	`cell+`	Address arithmetic
	`cells`	Address arithmetic
	CFA	Execution token
	`cfalign`	Dictionary allocation
	`cfaligned`	Address arithmetic
	`cfield:`	Forth200x Structures
	changing the compilation word list (during compilation)	search-ambcond
	`char`	Displaying characters and strings
	char size	core-idef
	`char%`	Structure Glossary
	`char+`	Address arithmetic
	character editing of `ACCEPT` and `EXPECT`	core-idef
	character set	core-idef
	character strings - compiling and displaying	Displaying characters and strings
	character strings - formats	String Formats
	character strings - moving and copying	Memory Blocks
	character-aligned address requirements	core-idef
	character-set extensions and matching of names	core-idef
	characters - compiling and displaying	Displaying characters and strings
	characters tutorial	Characters and Strings Tutorial
	`chars`	Address arithmetic
	child class	Object-Oriented Terminology
	child words	User-defined Defining Words
	class	Object-Oriented Terminology
	`class`	Objects Glossary
	`class`	The OOF base class
	`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	Class Implementation
	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?`	The OOF base class
	`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
	`clearstacks`	Examining
	clock tick duration	facility-idef
	`close-file`	General files
	`close-pipe`	Pipes
	`cmove`	Memory Blocks
	`cmove>`	Memory Blocks
	`code`	Code and ;code
	code address	Threading Words
	code address	Threading Words
	`CODE` ending sequence	programming-idef
	code examination	Examining
	code field address	Execution token
	code field address	Threading Words
	code words	Assembler and Code Words
	code words, portable	Code and ;code
	`code-address!`	Threading Words
	`CODE`, processing input	programming-idef
	colon definitions	Colon Definitions
	colon definitions	Anonymous Definitions
	colon definitions, tutorial	Colon Definitions Tutorial
	colon-sys, passing data across `:`	Literals
	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`	Memory Blocks
	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
	`compilation>`	Combined words
	compile state	The Text Interpreter
	`compile-lp+!`	Locals implementation
	`compile-only`	Interpretation and Compilation Semantics
	compile-only words	Interpretation and Compilation Semantics
	`compile,`	Macros
	compiling compilation semantics	Macros
	compiling words	Compiling 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 address arithmetic	Address arithmetic
	contiguous regions and heap allocation	Heap Allocation
	contiguous regions in dictionary allocation	Dictionary allocation
	contiguous regions, ANS vs. Gforth	Memory model
	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 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
	`count`	String Formats
	counted loops	Counted Loops
	counted loops with negative increment	Counted Loops
	counted string	String Formats
	counted string, maximum size	core-idef
	counted strings	String Formats
	`cputime`	Keeping track of Time
	`cr`	Displaying characters and strings
	`Create`	CREATE
	`CREATE` ... `DOES>`	User-defined Defining Words
	`CREATE` ... `DOES>`, applications	CREATE..DOES> applications
	`CREATE` ... `DOES>`, details	CREATE..DOES> details
	`CREATE` and alignment	Address arithmetic
	`create-file`	General files
	`create-interpret/compile`	Combined words
	create...does> tutorial	Defining Words Tutorial
	creating objects	Creating objects
	cross-compiler	cross.fs
	cross-compiler	Cross Compiler
	`cross.fs`	cross.fs
	`cross.fs`	Cross Compiler
	`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
	CT (compilation token)	Compilation token
	CT, tutorial	Compilation Tokens Tutorial
	`current`	Word Lists
	`current-interface`	Objects Glossary
	`current-interface` discussion	Objects Implementation
	`current'`	Objects Glossary
	currying	CREATE..DOES> applications
	cursor control	Displaying characters and strings
	cursor positioning	Terminal output

D
	`d-`	Double precision
	`d`, stack item type	Notation
	`d.`	Simple numeric output
	`d.r`	Simple numeric output
	`d+`	Double precision
	`d<`	Numeric comparison
	`d<=`	Numeric comparison
	`d<>`	Numeric comparison
	`d=`	Numeric comparison
	`d>`	Numeric comparison
	`d>=`	Numeric comparison
	`d>f`	Floating Point
	`D>F`, d cannot be presented precisely as a float	floating-ambcond
	`d>s`	Double precision
	`D>S`, d out of range of n	double-ambcond
	`d0<`	Numeric comparison
	`d0<=`	Numeric comparison
	`d0<>`	Numeric comparison
	`d0=`	Numeric comparison
	`d0>`	Numeric comparison
	`d0>=`	Numeric comparison
	`d2*`	Bitwise operations
	`d2/`	Bitwise operations
	`dabs`	Double precision
	data examination	Examining
	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-relocatable image files	Data-Relocatable Image Files
	data-space, read-only regions	core-idef
	`dbg`	Singlestep Debugger
	debug tracer editing commands	Emacs and Gforth
	debugging	Debugging
	debugging output, finding the source location in Emacs	Emacs and Gforth
	debugging Singlestep	Singlestep Debugger
	`dec.`	Simple numeric output
	`decimal`	Number Conversion
	declaring C functions	Declaring C Functions
	decompilation tutorial	Decompilation Tutorial
	default type of locals	Gforth locals
	`Defer`	Deferred Words
	`defer`	Class Declaration
	`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 with arbitrary semantics combinations	Combined words
	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`	The OOF base class
	definitions, tutorial	Colon Definitions Tutorial
	`delete-file`	General files
	`depth`	Examining
	depth changes during interpretation	Stack depth changes
	`depth-changes.fs`	Stack depth changes
	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:`	Forth200x Structures
	`dfloat%`	Structure Glossary
	`dfloat+`	Address arithmetic
	`dfloats`	Address arithmetic
	`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
	disassembler, general	Common Disassembler
	`discode`	Common Disassembler
	`dispose`	The OOF base class
	dividing by zero	core-ambcond
	dividing by zero, floating-point	floating-ambcond
	Dividing classes	Dividing classes
	division rounding	core-idef
	division with potentially negative operands	Arithmetic
	`dmax`	Double precision
	`dmin`	Double precision
	`dnegate`	Double precision
	`DO`	Arbitrary control structures
	`DO` loops	Counted Loops
	`docol:`	Threading Words
	`docon:`	Threading Words
	`dodefer:`	Threading Words
	`dodoes` routine	DOES>
	`does-code!`	Threading Words
	`does-handler!`	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>`-handler	Threading Words
	`DOES>`-parts, stack effect	User-defined Defining Words
	`DOES>`, visibility of current definition	core-idef
	`dofield:`	Threading Words
	`DONE`	Arbitrary control structures
	double precision arithmetic words	Double precision
	double words, ambiguous conditions	double-ambcond
	double words, system documentation	The optional Double Number word set
	double-cell numbers, input format	Number Conversion
	`double%`	Structure Glossary
	doubly indirect threaded code	gforthmi
	`douser:`	Threading Words
	`dovar:`	Threading Words
	`dpl`	Number Conversion
	`drop`	Data stack
	`du<`	Numeric comparison
	`du<=`	Numeric comparison
	`du>`	Numeric comparison
	`du>=`	Numeric comparison
	`dump`	Examining
	`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-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
	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`	Code and ;code
	`end-interface`	Objects Glossary
	`end-interface` usage	Object Interfaces
	`end-interface-noname`	Objects Glossary
	`end-methods`	Objects Glossary
	`end-struct`	Structure Glossary
	`end-struct` usage	Structure Usage
	`end-structure`	Forth200x 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
	`endwith`	The OOF base class
	engine	Engine
	engine performance	Performance
	engine portability	Portability
	`engine.s`	Produced code
	engines, gforth vs. gforth-fast vs. gforth-itc	Direct or Indirect Threaded?
	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	ANS conformance
	equality of floats	Floating Point
	`erase`	Memory Blocks
	error messages	Error messages
	error output, finding the source location in Emacs	Emacs and Gforth
	`etags.fs`	Emacs Tags
	`evaluate`	Input Sources
	examining data and code	Examining
	`exception`	Exception Handling
	exception abort sequence of `ABORT"`	core-idef
	exception when including source	file-idef
	exception words, implementation-defined options	exception-idef
	exception words, system documentation	The optional Exception word set
	exceptions	Exception Handling
	exceptions tutorial	Exceptions Tutorial
	executable image file	Running Image Files
	`execute`	Execution token
	`execute-parsing`	The Input Stream
	`execute-parsing-file`	The Input Stream
	executing code on startup	Invoking Gforth
	execution semantics	Interpretation and Compilation Semantics
	execution token	Introducing the Text Interpreter
	execution token	Execution token
	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
	`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
	extended records	Structure Usage

F
	`f_`, stack item type	Notation
	`f-`	Floating Point
	`f,`	Dictionary allocation
	`f`, stack item type	Notation
	`f!`	Memory Access
	`f!` used with an address that is not float aligned	floating-ambcond
	`f.`	Simple numeric output
	`f.rdp`	Simple numeric output
	`f.s`	Examining
	`f@`	Memory Access
	`f@` used with an address that is not float aligned	floating-ambcond
	`f@local#`	Locals implementation
	`f*`	Floating Point
	`f**`	Floating Point
	`f/`	Floating Point
	`f+`	Floating Point
	`f<`	Floating Point
	`f<=`	Floating Point
	`f<>`	Floating Point
	`f=`	Floating Point
	`f>`	Floating Point
	`f>=`	Floating Point
	`f>buf-rdp`	Formatted numeric output
	`f>d`	Floating Point
	`F>D`, integer part of float cannot be represented by d	floating-ambcond
	`f>l`	Locals implementation
	`f>str-rdp`	Formatted numeric 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
	`f83name`, stack item type	Notation
	`fabs`	Floating Point
	facility words, ambiguous conditions	facility-ambcond
	facility words, implementation-defined options	facility-idef
	facility words, system documentation	The optional Facility word set
	`facos`	Floating Point
	`FACOS`, \|float\|>1	floating-ambcond
	`facosh`	Floating Point
	`FACOSH`, float<1	floating-ambcond
	factoring	Introduction
	factoring similar colon definitions	CREATE..DOES> applications
	factoring tutorial	Factoring Tutorial
	`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
	`fatan`	Floating Point
	`fatan2`	Floating Point
	`FATAN2`, both arguments are equal to zero	floating-ambcond
	`fatanh`	Floating Point
	`FATANH`, \|float\|>1	floating-ambcond
	`fconstant`	Constants
	`fcos`	Floating Point
	`fcosh`	Floating Point
	`fdepth`	Examining
	FDL, GNU Free Documentation License	GNU Free Documentation License
	`fdrop`	Floating point stack
	`fdup`	Floating point stack
	`fe.`	Simple numeric output
	`fexp`	Floating Point
	`fexpm1`	Floating Point
	`ffield:`	Forth200x Structures
	`field`	Structure Glossary
	field naming convention	Structure Naming Convention
	`field` usage	Structure Usage
	`field` usage in class definition	Basic Objects Usage
	`field:`	Forth200x 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-handling	General files
	`file-position`	General files
	`file-size`	General files
	`file-status`	General files
	`FILE-STATUS`, returned information	file-idef
	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
	first definition	Your first definition
	first field optimization	Structure Usage
	first field optimization, implementation	Structure Implementation
	flags on the command line	Invoking Gforth
	flags tutorial	Flags and Comparisons Tutorial
	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%`	Structure Glossary
	`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 dividing by zero	floating-ambcond
	floating-point numbers, input format	Number Conversion
	floating-point numbers, rounding or truncation	floating-idef
	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, `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`	Floating point stack
	`floats`	Address arithmetic
	`flog`	Floating Point
	`FLOG`, float=<0	floating-ambcond
	`floor`	Floating Point
	`FLOORED`	Single precision
	`flush`	Blocks
	`flush-file`	General files
	`flush-icache`	Code and ;code
	`fm/mod`	Mixed precision
	`fmax`	Floating Point
	`fmin`	Floating Point
	`fnegate`	Floating Point
	`fnip`	Floating point stack
	`FOR`	Arbitrary control structures
	`FOR` loops	Counted Loops
	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
	`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-related information	Forth-related information
	`forth-wordlist`	Word Lists
	`forth.el`	Emacs and Gforth
	`fover`	Floating point stack
	FP tutorial	Floating Point Tutorial
	`fp!`	Stack pointer manipulation
	`fp@`	Stack pointer manipulation
	`fp0`	Stack pointer manipulation
	`fpath`	Source Search Paths
	`fpick`	Floating point stack
	`free`	Heap Allocation
	frequently asked questions	Forth-related information
	`frot`	Floating point stack
	`fround`	Floating Point
	`fs.`	Simple numeric 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
	`ftuck`	Floating point stack
	fully relocatable image files	Fully Relocatable Image Files
	functions, tutorial	Colon Definitions Tutorial
	`fvariable`	Variables

G
	gdb disassembler	Common Disassembler
	general files	General files
	`get-block-fid`	Blocks
	`get-current`	Word Lists
	`get-order`	Word Lists
	`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-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
	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
	header space	Word Lists
	heap allocation	Heap Allocation
	`heap-new`	Objects Glossary
	`heap-new` discussion	Creating objects
	`heap-new` usage	Basic Objects Usage
	`here`	Dictionary allocation
	`hex`	Number Conversion
	`hex.`	Simple numeric output
	highlighting Forth code in Emacs	Hilighting
	hilighting Forth code in Emacs	Hilighting
	history file	Command-line editing
	`hold`	Formatted numeric output
	`how:`	Class Declaration
	hybrid direct/indirect threaded code	Direct or Indirect Threaded?

I
	`i`	Counted Loops
	I/O - blocks	Blocks
	I/O - file-handling	Files
	I/O - keyboard and display	Other I/O
	I/O - see character strings	String Formats
	I/O - see input	Line input and conversion
	I/O exception in block transfer	block-ambcond
	`id.`	Name token
	`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
	`implementation`	Objects Glossary
	implementation of locals	Locals implementation
	implementation of structures	Structure Implementation
	`implementation` usage	Object Interfaces
	implementation-defined options, block words	block-idef
	implementation-defined options, core words	core-idef
	implementation-defined options, exception words	exception-idef
	implementation-defined options, facility words	facility-idef
	implementation-defined options, file words	file-idef
	implementation-defined options, floating-point words	floating-idef
	implementation-defined options, locals words	locals-idef
	implementation-defined options, memory-allocation words	memory-idef
	implementation-defined options, programming-tools words	programming-idef
	implementation-defined options, search-order words	search-idef
	in-lining of constants	Constants
	`include`	Forth source files
	`include` search path	Search Paths
	`include-file`	Forth source files
	`INCLUDE-FILE`, file-id is invalid	file-ambcond
	`INCLUDE-FILE`, I/O exception reading or closing file-id	file-ambcond
	`include`, placement in files	Emacs Tags
	`included`	Forth source files
	`INCLUDED`, I/O exception reading or closing file-id	file-ambcond
	`INCLUDED`, named file cannot be opened	file-ambcond
	`included?`	Forth source files
	including files	Forth source files
	including files, stack effect	Forth source files
	indentation of Forth code in Emacs	Auto-Indentation
	indirect threaded inner interpreter	Threading
	`infile-execute`	Redirection
	inheritance	Object-Oriented Terminology
	`init`	The OOF base class
	`init-asm`	Code and ;code
	`init-object`	Objects Glossary
	`init-object` discussion	Creating objects
	initialization sequence of image file	Modifying the Startup Sequence
	inner interpreter implementation	Threading
	inner interpreter optimization	Scheduling
	inner interpreter, direct threaded	Threading
	inner interpreter, indirect threaded	Threading
	input buffer	The Text Interpreter
	input format for double-cell numbers	Number Conversion
	input format for floating-point numbers	Number Conversion
	input format for single-cell numbers	Number Conversion
	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, linewise from terminal	Line input and conversion
	input, single-key	Single-key input
	`inst-value`	Objects Glossary
	`inst-value` usage	Method conveniences
	`inst-value` visibility	Classes and Scoping
	`inst-var`	Objects Glossary
	`inst-var` implementation	Objects Implementation
	`inst-var` usage	Method conveniences
	`inst-var` visibility	Classes and Scoping
	instance variables	Object-Oriented Terminology
	instruction pointer	Threading
	insufficient data stack or return stack space	core-ambcond
	insufficient space for loop control parameters	core-ambcond
	insufficient space in the dictionary	core-ambcond
	integer types, ranges	core-idef
	`interface`	Objects Glossary
	interface implementation	Objects Implementation
	interface to C functions	C Interface
	`interface` usage	Object Interfaces
	interfaces for objects	Object Interfaces
	interpret state	The Text Interpreter
	Interpret/Compile states	Interpret/Compile states
	`interpret/compile:`	Combined words
	interpretation semantics	How does that work?
	interpretation semantics	Interpretation and Compilation Semantics
	interpretation semantics tutorial	Interpretation and Compilation Semantics and Immediacy Tutorial
	`interpretation>`	Combined words
	interpreter - outer	The Text Interpreter
	interpreter directives	Interpreter Directives
	Interpreting a compile-only word	core-ambcond
	Interpreting a compile-only word, for `'` etc.	core-ambcond
	Interpreting a compile-only word, for a local	locals-ambcond
	interpreting a word with undefined interpretation semantics	core-ambcond
	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`	The OOF base class
	items on the stack after interpretation	Stack depth changes

J
	`j`	Counted Loops

K
	`k`	Counted Loops
	`k-alt-mask`	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-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-next`	Single-key input
	`k-prior`	Single-key input
	`k-right`	Single-key input
	`k-shift-mask`	Single-key input
	`k-up`	Single-key input
	`kern*.fi`, relocatability	Fully Relocatable Image Files
	`key`	Single-key input
	`key-file`	General files
	`key?`	Single-key input
	`key?-file`	General files
	keyboard events, encoding in `EKEY`	facility-idef
	Kuehling, David	Emacs and Gforth

L
	`l!`	Memory Access
	labels as values	Threading
	`laddr#`	Locals implementation
	`LANG` – environment variable	Environment variables
	last word was headerless	core-ambcond
	late binding	Class Binding
	`latest`	Name token
	`latestxt`	Anonymous Definitions
	`LC_ALL` – environment variable	Environment variables
	`LC_CTYPE` – environment variable	Environment variables
	`LEAVE`	Arbitrary control structures
	leaving definitions, tutorial	Leaving definitions or loops Tutorial
	leaving Gforth	Leaving Gforth
	leaving loops, tutorial	Leaving definitions or loops Tutorial
	length of a line affected by `\`	block-idef
	`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 for images	Image Licensing Issues
	lifetime of locals	How long do locals live?
	line input from terminal	Line input and conversion
	line terminator on input	core-idef
	`link`	The OOF base class
	`list`	Blocks
	`LIST` display format	block-idef
	`list-size`	Locals implementation
	`Literal`	Literals
	literal tutorial	Literal Tutorial
	Literals	Literals
	`load`	Blocks
	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
	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 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, ANS Forth style	ANS Forth locals
	locals, default type	Gforth locals
	locals, Gforth style	Gforth locals
	locals, maximum number in a definition	locals-idef
	long long	Portability
	`LOOP`	Arbitrary control structures
	loop control parameters not available	core-ambcond
	loops without count	Simple Loops
	loops, counted	Counted Loops
	loops, 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
	`lshift`	Bitwise operations
	`LSHIFT`, large shift counts	core-ambcond

M
	`m:`	Objects Glossary
	`m:` usage	Method conveniences
	`m*`	Mixed precision
	`m*/`	Mixed precision
	`m+`	Mixed precision
	macros	Compiling words
	Macros	Macros
	macros, advanced tutorial	Advanced macros Tutorial
	mapping block ranges to files	file-idef
	`marker`	Forgetting words
	`max`	Single precision
	`maxalign`	Dictionary allocation
	`maxaligned`	Address arithmetic
	`maxdepth-.s`	Examining
	maximum depth of file input nesting	file-idef
	maximum number of locals in a definition	locals-idef
	maximum number of word lists in search order	search-idef
	maximum size of a counted string	core-idef
	maximum size of a definition name, in characters	core-idef
	maximum size of a parsed string	core-idef
	maximum size of input line	file-idef
	maximum string length for `ENVIRONMENT?`, in characters	core-idef
	memory access words	Memory Access
	memory access/allocation tutorial	Memory Tutorial
	memory alignment tutorial	Alignment Tutorial
	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
	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
	`mod`	Single precision
	modifying >IN	How does that work?
	modifying the contents of the input buffer or a string literal	core-ambcond
	most recent definition does not have a name (`IMMEDIATE`)	core-ambcond
	motivation for object-oriented programming	Why object-oriented programming?
	`move`	Memory Blocks
	`ms`	Keeping track of Time
	`MS`, repeatability to be expected	facility-idef

N
	`n`, stack item type	Notation
	`naligned`	Structure Glossary
	`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?int`	Name token
	`name>comp`	Name token
	`name>int`	Name token
	`name>string`	Name token
	names for defined words	Supplying names
	`needs`	Forth source files
	`negate`	Single precision
	negative increment for counted loops	Counted Loops
	Neon model	Comparison with other object models
	`new`	The OOF base class
	`new`	Basic Mini-OOF Usage
	`new[]`	The OOF base class
	newline character on input	core-idef
	`NEXT`	Arbitrary control structures
	`next-arg`	OS command line arguments
	`NEXT`, direct threaded	Threading
	`NEXT`, indirect threaded	Threading
	`nextname`	Supplying names
	NFA	Name token
	`nip`	Data stack
	non-graphic characters and `EMIT`	core-idef
	non-relocatable image files	Non-Relocatable Image Files
	`noname`	Anonymous Definitions
	notation of glossary entries	Notation
	`nothrow`	Exception Handling
	NT Forth performance	Performance
	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

O
	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-map` discussion	Objects Implementation
	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
	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
	`of`	Arbitrary control structures
	`off`	Boolean Flags
	`on`	Boolean Flags
	`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-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
	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
	other system documentation, block words	block-other
	other system documentation, core words	core-other
	outer interpreter	Introducing the Text Interpreter
	outer interpreter	Stacks and Postfix notation
	outer interpreter	The Text Interpreter
	`outfile-execute`	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
	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
	`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
	patching threaded code	Dynamic Superinstructions
	path for `included`	Search Paths
	`path-allot`	General Search Paths
	`path+`	General Search Paths
	`path=`	General Search Paths
	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
	`postpone`	Macros
	`postpone`	The OOF base class
	`POSTPONE` applied to `[IF]`	programming-ambcond
	`POSTPONE` or `[COMPILE]` applied to `TO`	core-ambcond
	postpone tutorial	POSTPONE Tutorial
	`postpone,`	Compilation token
	Pountain’s object-oriented model	Comparison with other object models
	`precision`	Floating Point
	precompiled Forth code	Image Files
	`previous`	Word Lists
	`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
	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
	`ptr`	The OOF base class
	`ptr`	Class Declaration
	`public`	Objects Glossary

Q
	`query`	Input Sources
	`quit`	Miscellaneous Words

R
	`r`, stack item type	Notation
	`r@`	Return stack
	`r/o`	General files
	`r/w`	General files
	`r>`	Return stack
	ranges for integer types	core-idef
	`rdrop`	Return stack
	`read-file`	General files
	`read-line`	General files
	read-only data space regions	core-idef
	reading from file positions not yet written	file-ambcond
	receiving object	Object-Oriented Terminology
	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
	registers of the inner interpreter	Code and ;code
	relocating loader	Image File Background
	relocation at load-time	Image File Background
	relocation at run-time	Image File Background
	`rename-file`	General files
	`REPEAT`	Arbitrary control structures
	repeatability to be expected from the execution of `MS`	facility-idef
	Replication	Dynamic Superinstructions
	report the words used in your program	ANS Report
	`reposition-file`	General files
	`REPOSITION-FILE`, outside the file’s boundaries	file-ambcond
	`represent`	Formatted numeric 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
	`restore`	Exception Handling
	`restore-input`	Input Sources
	`RESTORE-INPUT`, Argument type mismatch	core-ambcond
	`restrict`	Interpretation and Compilation Semantics
	result out of range	core-ambcond
	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
	returning from a definition	Calls and returns
	`roll`	Data stack
	`Root`	Word Lists
	`rot`	Data stack
	rounding of floating-point numbers	floating-idef
	`rp!`	Stack pointer manipulation
	`rp@`	Stack pointer manipulation
	`rp0`	Stack pointer manipulation
	`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"`	Displaying characters and strings
	`S"`, number of string buffers	file-idef
	`S"`, size of string buffer	file-idef
	`s\"`	Displaying characters and strings
	`s>d`	Double precision
	`s>number?`	Line input and conversion
	`s>unumber?`	Line input and conversion
	`save-buffer`	Blocks
	`save-buffers`	Blocks
	`save-input`	Input Sources
	`savesystem`	Non-Relocatable Image Files
	`savesystem` during `gforthmi`	gforthmi
	`scope`	Where are locals visible by name?
	scope of locals	Where are locals visible by name?
	scoping and classes	Classes and Scoping
	`scr`	Blocks
	`seal`	Word Lists
	`search`	Memory Blocks
	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
	`see`	Examining
	see tutorial	Decompilation Tutorial
	`see-code`	Examining
	`see-code-range`	Examining
	`SEE`, source and format of output	programming-idef
	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
	`self`	The OOF base class
	semantics tutorial	Interpretation and Compilation Semantics and Immediacy Tutorial
	semantics, interpretation and compilation	Interpretation and Compilation Semantics
	`set-current`	Word Lists
	`set-order`	Word Lists
	`set-precision`	Floating Point
	`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:`	Forth200x Structures
	`sfloat%`	Structure Glossary
	`sfloat+`	Address arithmetic
	`sfloats`	Address arithmetic
	`sh`	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
	`sign`	Formatted numeric output
	silent exiting from Gforth	Gforth in pipes
	simple defining words	CREATE
	simple loops	Simple Loops
	`simple-see`	Examining
	`simple-see-range`	Examining
	single precision arithmetic words	Single precision
	single-assignment style for locals	Locals programming style
	single-cell numbers, input format	Number Conversion
	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
	`sl@`	Memory Access
	`SLiteral`	Literals
	`slurp-fid`	General files
	`slurp-file`	General files
	`sm/rem`	Mixed precision
	`source`	The Text Interpreter
	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`	Displaying characters and strings
	space delimiters	core-idef
	`spaces`	Displaying characters and strings
	`span`	Line input and conversion
	speed, startup	Startup speed
	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
	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-effect comments, tutorial	Stack-Effect Comments Tutorial
	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
	`stderr`	General files
	stderr and pipes	Gforth in pipes
	`stdin`	General files
	`stdout`	General files
	`str<`	Memory Blocks
	`str=`	Memory Blocks
	string larger than pictured numeric output area (`f.`, `fe.`, `fs.`)	floating-ambcond
	string longer than a counted string returned by `WORD`	core-ambcond
	`string-prefix?`	Memory Blocks
	strings - see character strings	String Formats
	strings tutorial	Characters and Strings Tutorial
	`struct`	Structure Glossary
	`struct` usage	Structure Usage
	structs tutorial	Arrays and Records Tutorial
	structure extension	Structure Usage
	structure glossary	Structure Glossary
	structure implementation	Structure Implementation
	structure naming convention	Structure Naming Convention
	structure naming convention	Structure Naming Convention
	structure of Forth programs	Forth is written in Forth
	structure usage	Structure Usage
	structures	Structures
	structures containing arrays	Structure Usage
	structures containing structures	Structure Usage
	Structures in Forth200x	Forth200x Structures
	structures using address arithmetic	Why explicit structure support?
	`sub-list?`	Locals implementation
	`super`	The OOF base class
	superclass binding	Class Binding
	Superinstructions	Dynamic Superinstructions
	`sw@`	Memory Access
	`swap`	Data stack
	syntax tutorial	Syntax Tutorial
	`system`	Passing Commands to the OS
	system dictionary space required, in address units	core-other
	system documentation	ANS conformance
	system documentation, block words	The optional Block word set
	system documentation, core words	The Core Words
	system documentation, double words	The optional Double Number word set
	system documentation, exception words	The optional Exception word set
	system documentation, facility words	The optional Facility word set
	system documentation, file words	The optional File-Access word set
	system documentation, floating-point words	The optional Floating-Point word set
	system documentation, locals words	The optional Locals word set
	system documentation, memory-allocation words	The optional Memory-Allocation word set
	system documentation, programming-tools words	The optional Programming-Tools word set
	system documentation, search-order words	The optional Search-Order word set
	system prompt	core-idef

T
	`table`	Word Lists
	`TAGS` file	Emacs Tags
	target compiler	cross.fs
	target compiler	Cross Compiler
	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
	`THEN`	Arbitrary control structures
	`this`	Objects Glossary
	`this` and `catch`	Objects Implementation
	`this` implementation	Objects Implementation
	`this` usage	Method conveniences
	ThisForth performance	Performance
	threaded code implementation	Threading
	threading words	Threading Words
	`threading-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` on non-`VALUE`s	core-ambcond
	`TO` on non-`VALUE`s and non-locals	locals-ambcond
	`to-this`	Objects Glossary
	tokens for words	Tokens for Words
	TOS definition	Stacks and Postfix notation
	TOS optimization for primitives	TOS Optimization
	`toupper`	Displaying characters and strings
	trigonometric operations	Floating Point
	`true`	Boolean Flags
	truncation of floating-point numbers	floating-idef
	`try`	Exception Handling
	`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`	Arbitrary control structures
	`u`, stack item type	Notation
	`u.`	Simple numeric output
	`u.r`	Simple numeric output
	`U+DO`	Arbitrary control structures
	`u<`	Numeric comparison
	`u<=`	Numeric comparison
	`u>`	Numeric comparison
	`u>=`	Numeric comparison
	`ud`, stack item type	Notation
	`ud.`	Simple numeric output
	`ud.r`	Simple numeric output
	`ul@`	Memory Access
	`um*`	Mixed precision
	`um/mod`	Mixed precision
	undefined word	core-ambcond
	undefined word, `'`, `POSTPONE`, `[']`, `[COMPILE]`	core-ambcond
	`under+`	Single precision
	unexpected end of the input buffer	core-ambcond
	`unloop`	Arbitrary control structures
	unmapped block numbers	file-ambcond
	`UNREACHABLE`	Where are locals visible by name?
	`UNTIL`	Arbitrary control structures
	`UNTIL` loop	Simple Loops
	`unused`	Dictionary allocation
	unwind-protect	Exception Handling
	`update`	Blocks
	`UPDATE`, no current block buffer	block-ambcond
	`updated?`	Blocks
	upper and lower case	Case insensitivity
	`use`	Blocks
	`User`	Variables
	user input device, method of selecting	core-idef
	user output device, method of selecting	core-idef
	user space	Variables
	user variables	Variables
	user-defined defining words	User-defined Defining Words
	`utime`	Keeping track of Time
	`uw@`	Memory Access

V
	`Value`	Values
	value-flavoured locals	Gforth locals
	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
	versions, invoking other versions of Gforth	Invoking Gforth
	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

W
	`w`, stack item type	Notation
	`w!`	Memory Access
	`w/o`	General files
	where to go next	Where to go next
	`WHILE`	Arbitrary control structures
	`WHILE` loop	Simple Loops
	wid	Word Lists
	`wid`, stack item type	Notation
	Win32Forth performance	Performance
	wior type description	Notation
	wior values and meaning	file-idef
	`with`	The OOF base class
	`within`	Numeric comparison
	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
	wordlists tutorial	Wordlists and Search Order Tutorial
	words	Words
	`words`	Word Lists
	words used in your program	ANS Report
	words, forgetting	Forgetting words
	wordset	Notation
	`write-file`	General files
	`write-line`	General files

X
	`x-size`	Xchars and Unicode
	`x-width`	Xchars and Unicode
	`x\string-`	Xchars and Unicode
	`xc-size`	Xchars and Unicode
	`xc!+?`	Xchars and Unicode
	`xc@+`	Xchars and Unicode
	`xchar-`	Xchars and Unicode
	`xchar-encoding`	Xchars and Unicode
	`xchar+`	Xchars and Unicode
	`xemit`	Xchars and Unicode
	`xkey`	Xchars and Unicode
	`xor`	Bitwise operations
	xt	Introducing the Text Interpreter
	xt	Execution token
	XT tutorial	Execution Tokens Tutorial
	`xt-new`	Objects Glossary
	`xt-see`	Examining
	`xt`, stack item type	Notation

Z
	zero-length string as a name	core-ambcond
	Zsoter’s object-oriented model	Comparison with other object models

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 Z