---

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
!
	!:		Memory Access
	!!FIXME!!:		Debugging
	!@:		Hardware operations for multi-tasking
	!resize:		widget methods
	!size:		widget methods
"
	", stack item type:		Notation
#
	#:		Formatted numeric output
	#!:		Running Image Files
	#-prefix 10進数値用:		Literals in source code
	#>:		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
$
	$!:		＄tring words
	$!len:		＄tring words
	$+!:		＄tring words
	$+!len:		＄tring words
	$+slurp:		＄tring words
	$+slurp-file:		＄tring words
	$+[]!:		＄tring words
	$-prefix 16進数値用:		Literals in source code
	$.:		＄tring words
	$?:		Passing Commands to the OS
	$@:		＄tring words
	$@len:		＄tring words
	$boot:		＄tring words
	$del:		＄tring words
	$exec:		＄tring words
	$free:		＄tring words
	$init:		＄tring words
	$ins:		＄tring words
	$iter:		＄tring words
	$over:		＄tring words
	$save:		＄tring words
	$saved:		＄tring words
	$slurp:		＄tring words
	$slurp-file:		＄tring words
	$split:		＄tring words
	$substitute:		Substitute
	$tmp:		＄tring words
	$unescape:		Substitute
	$Variable:		＄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
%
	%-prefix 2進数値用:		Literals in source code
	%align:		Structure Glossary
	%alignment:		Structure Glossary
	%alloc:		Structure Glossary
	%allocate:		Structure Glossary
	%allot:		Structure Glossary
	%size:		Structure Glossary
&
	&-prefix 10新数値用(非標準):		Literals in source code
'
	':		Execution token
	’-prefix for characters/code points:		Literals in source code
	'cold:		Modifying the Startup Sequence
	's:		Task-local data
(
	(:		Comments
	((:		Regular Expressions
	(local):		Standard Forth locals
	(to):		User-defined TO and DEFER@
)
	):		Assertions
	)):		Regular Expressions
*
	*:		Single precision
	**}:		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
	*}:		Regular Expressions
+
	+:		Single precision
	+!:		Memory Access
	+!@:		Hardware operations for multi-tasking
	++}:		Regular Expressions
	+char:		Regular Expressions
	+chars:		Regular Expressions
	+class:		Regular Expressions
	+DO:		Counted Loops
	+field:		Forth200x Structures
	+fmode:		General files
	+load:		Blocks
	+LOOP:		Counted Loops
	+ltrace:		Debugging
	+thru:		Blocks
	+TO:		Values
	+x/string:		Xchars and Unicode
	+}:		Regular Expressions
,
	,:		Dictionary allocation
-
	-:		Single precision
	–, tutorial:		Stack-Effect Comments Tutorial
	--:		Locals definition words
	-->:		Blocks
	->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
	-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:		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
	–image file, invoke image file:		Running Image Files
	–image-file, command-line option:		Invoking Gforth
	-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
	–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:		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
	-[do:		Counted Loops
	-\d:		Regular Expressions
	-\s:		Regular Expressions
	-`:		Regular Expressions
.
	.:		Simple numeric output
	.":		Miscellaneous output
	.", how it works:		How does that work?
	.(:		Miscellaneous output
	...:		Examining data
	..char:		Regular Expressions
	.?:		Regular Expressions
	.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
	.r:		Simple numeric output
	.recognizers:		Default Recognizers
	.s:		Examining data
	.substitute:		Substitute
	.unresolved:		Forward
	.voc:		Word Lists
	.widget:		widget methods
	.\":		Miscellaneous output
/
	/:		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
0
	0<:		Numeric comparison
	0<=:		Numeric comparison
	0<>:		Numeric comparison
	0=:		Numeric comparison
	0>:		Numeric comparison
	0>=:		Numeric comparison
	0x-prefix 16進数値用(非標準):		Literals in source code
1
	1+:		Single precision
	1-:		Single precision
	1/f:		Floating Point
2
	2!:		Memory Access
	2*:		Bitwise operations
	2,:		Dictionary allocation
	2/:		Bitwise operations
	2>r:		Return stack
	2@:		Memory Access
	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
	2Value:		Values
	2Variable:		Variables
	2varue:		Varues
:
	::		Colon Definitions
	:, passing data across:		Literals
	:::		Basic Mini-OOF Usage
	:m:		Objects Glossary
	:noname:		Anonymous Definitions
	:}:		Locals definition words
	:}d:		Closures
	:}h:		Closures
	:}h1:		Closures
	:}l:		Closures
	:}xt:		Closures
;
	;:		Colon Definitions
	;>:		Closures
	;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
	;]:		Quotations
<
	<:		Numeric comparison
	<#:		Formatted numeric output
	<<:		Regular Expressions
	<<":		Regular Expressions
	<<#:		Formatted numeric output
	<=:		Numeric comparison
	<>:		Numeric comparison
	<bind>:		Objects Glossary
	<to-inst>:		Objects Glossary
	<{::		Closures
=
	=:		Numeric comparison
	=mkdir:		Directories
>
	>:		Numeric comparison
	>=:		Numeric comparison
	>>:		Regular Expressions
	>addr:		Closures
	>animate:		widget methods
	>body:		CREATE..DOES> details
	>BODY of non-CREATEd words:		core-ambcond
	>code-address:		Threading Words
	>compile:		Dealing with existing Recognizers
	>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
	>interpret:		Dealing with existing Recognizers
	>l:		Locals implementation
	>name:		Name token
	>number:		Line input and conversion
	>o:		Mini-OOF2
	>order:		Word Lists
	>postpone:		Dealing with existing Recognizers
	>pow2:		Bitwise operations
	>r:		Return stack
	>string-execute:		String words
	>time&date&tz:		Keeping track of Time
?
	?:		Examining data
	?!@:		Hardware operations for multi-tasking
	???:		Debugging
	?cov+:		Code Coverage
	?DO:		Counted Loops
	?dup:		Data stack
	?DUP-0=-IF:		Arbitrary control structures
	?dup-IF:		Arbitrary control structures
	?events:		Message queues
	?EXIT:		Calls and returns
	?inside:		actor methods
	?LEAVE:		Counted Loops
	?of:		Arbitrary control structures
@
	@:		Memory Access
	@localn:		Locals implementation
[
	[:		Literals
	[']:		Execution token
	[+LOOP]:		Interpreter Directives
	[::		Quotations
	[?DO]:		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
	[defined]:		Interpreter Directives
	[DO]:		Interpreter Directives
	[ELSE]:		Interpreter Directives
	[ENDIF]:		Interpreter Directives
	[FOR]:		Interpreter Directives
	[IFDEF]:		Interpreter Directives
	[IFUNDEF]:		Interpreter Directives
	[IF]:		Interpreter Directives
	[IF] and POSTPONE:		programming-ambcond
	[IF], end of the input source before matching [ELSE] or [THEN]:		programming-ambcond
	[I]:		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
	[undefined]:		Interpreter Directives
	[UNTIL]:		Interpreter Directives
	[WHILE]:		Interpreter Directives
	[{::		Closures
\
	\:		Comments
	\$:		Regular Expressions
	\(:		Regular Expressions
	\):		Regular Expressions
	\, editing with Emacs:		Emacs and Gforth
	\, line length in blocks:		block-idef
	\0:		Regular Expressions
	\c:		Declaring C Functions
	\d:		Regular Expressions
	\G:		Comments
	\s:		Regular Expressions
	\\\:		Forth source files
	\^:		Regular Expressions
]
	]:		Literals
	]L:		Literals
	]nocov:		Code Coverage
	]]:		Macros
`
	`:		Regular Expressions
	` prefix:		Execution token
	` prefix of word:		Literals in source code
	`?:		Regular Expressions
	`` prefix of word:		Literals in source code
{
	{:		Locals definition words
	{*:		Regular Expressions
	{**:		Regular Expressions
	{+:		Regular Expressions
	{++:		Regular Expressions
	{::		Locals definition words
	{{:		Regular Expressions
|
	|:		Locals definition words
	||:		Regular Expressions
}
	}:		Locals definition words
	}}:		Regular Expressions
~
	~~:		Debugging
	~~, removal with Emacs:		Emacs and Gforth
	~~1bt:		Debugging
	~~bt:		Debugging
	~~Value:		Debugging
	~~Variable:		Debugging
A
	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
	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
	address alignment exception:		core-ambcond
	address alignment exception, stack overflow:		core-ambcond
	address arithmetic for structures:		Why explicit structure support?
	address arithmetic words:		Address arithmetic
	address unit:		Address arithmetic
	address unit, size in bits:		core-idef
	ADDRESS-UNIT-BITS:		Environmental Queries
	adjust-buffer:		Heap Allocation
	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, too many word lists in search order:		search-ambcond
	also-path:		General Search Paths
	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
	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(:		Assertions
	assert-level:		Assertions
	assert0(:		Assertions
	assert1(:		Assertions
	assert2(:		Assertions
	assert3(:		Assertions
	assertions:		Assertions
	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
	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
	a_, stack item type:		Notation
B
	b:		Locating source code definitions
	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:		Forth200x 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%:		Heap Allocation
	buffer::		Variables
	bug reporting:		Bugs
	bw:		Locating uses of a word
	bw-cover:		Code Coverage
	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!:		Memory Access
	C":		Counted string words
	c$+!:		＄tring words
	c,:		Dictionary allocation
	c, stack item type:		Notation
	C, using C for the engine:		Portability
	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::		Locals definition words
	c>s:		Special Memory Accesses
	c?:		Regular Expressions
	c@:		Memory Access
	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
	cell:		Address arithmetic
	cell size:		core-idef
	cell%:		Structure Glossary
	cell+:		Address arithmetic
	cell-:		Address arithmetic
	cell-aligned addresses:		core-idef
	cell/:		Address arithmetic
	cells:		Address arithmetic
	CFA:		Threading Words
	cfalign:		Dictionary allocation
	cfaligned:		Address arithmetic
	cfield::		Forth200x Structures
	changing the compilation word list (during compilation):		search-ambcond
	char:		String and character literals
	char size:		core-idef
	char%:		Structure Glossary
	char+:		Address arithmetic
	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 words:		User-defined defining words using CREATE
	cilk-bye:		Cilk
	cilk-init:		Cilk
	cilk-sync:		Cilk
	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>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
	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, processing input:		programming-idef
	code-address!:		Threading Words
	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':		Compilation token
	comp-i.fs:		gforthmi
	comp.lang.forth:		Forth-related information
	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
	compile state:		The Text Interpreter
	compile,:		Macros
	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
	compiled code examination:		Examining compiled code
	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 heap allocation:		Heap Allocation
	contiguous regions in dictionary allocation:		Dictionary allocation
	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
	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 されたワード以外の DOES>:		core-ambcond
	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
	ct (compilation token):		Compilation token
	CT, tutorial:		Compilation Tokens Tutorial
	ctz:		Bitwise operations
	current:		Word Lists
	current':		Objects Glossary
	current-interface:		Objects Glossary
	current-interface discussion:		Objects Implementation
	currying:		CREATE..DOES> applications
	cursor positioning:		Terminal output
	C^:		Locals definition words
	c_, stack item type:		Notation
D
	d:		widget methods
	d+:		Double precision
	d, stack item type:		Notation
	d-:		Double precision
	d.:		Simple numeric output
	d.r:		Simple numeric output
	d0<:		Numeric comparison
	d0<=:		Numeric comparison
	d0<>:		Numeric comparison
	d0=:		Numeric comparison
	d0>:		Numeric comparison
	d0>=:		Numeric comparison
	d2*:		Bitwise operations
	d2/:		Bitwise operations
	D::		Locals definition words
	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
	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!:		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:		Memory Blocks
	delete-file:		General files
	delta-i:		Counted Loops
	depth:		Examining data
	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!:		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
	dfloat/:		Address arithmetic
	dfloats:		Address arithmetic
	df_, stack item type:		Notation
	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
	doabicode::		Threading Words
	docol,:		Threading Words
	docol::		Threading Words
	docon,:		Threading Words
	docon::		Threading Words
	dodefer,:		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> tutorial:		Defining Words Tutorial
	DOES>, visibility of current definition:		core-idef
	does>-code:		Threading Words
	DOES>-code:		DOES>
	DOES>-parts, stack effect:		User-defined defining words using CREATE
	dofield,:		Threading Words
	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%:		Structure Glossary
	double-cell numbers, input format:		Literals in source code
	doubly indirect threaded code:		gforthmi
	douser,:		Threading Words
	douser::		Threading Words
	dovalue,:		Threading Words
	dovalue::		Threading Words
	dovar,:		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
	D^:		Locals definition words
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>char:		Single-key input
	ekey>fkey:		Single-key input
	ekey>xchar:		Single-key input
	ekey?:		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:		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
	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 and code:		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:		Heap Allocation
	extend-structure:		Forth200x Structures
	extended records:		Structure Usage
F
	f!:		Memory Access
	f! used with an address that is not float aligned:		floating-ambcond
	f*:		Floating Point
	f**:		Floating Point
	f+:		Floating Point
	f,:		Dictionary allocation
	f, stack item type:		Notation
	f-:		Floating Point
	f-rot:		Floating point stack
	f.:		Floating-point output
	f.rdp:		Floating-point output
	f.s:		Examining data
	f.s-precision:		Examining data
	f/:		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
	F::		Locals definition words
	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@:		Memory Access
	f@ used with an address that is not float aligned:		floating-ambcond
	f@localn:		Locals implementation
	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
	fexp:		Floating Point
	fexpm1:		Floating Point
	ffield::		Forth200x Structures
	ffourth:		Floating point stack
	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-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 assertion output:		Assertions
	filenames in ~~ output:		Debugging
	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:		Structure Usage
	first field optimization, implementation:		Structure Implementation
	fkey.:		Single-key input
	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
	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
	fp0:		Stack pointer manipulation
	fp@:		Stack pointer manipulation
	fpath:		Source Search Paths
	fpick:		Floating point stack
	free:		Heap Allocation
	free-closure:		Closures
	free-mem-var:		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
	fvariable:		Variables
	fvarue:		Varues
	F^:		Locals definition words
	f_, stack item type:		Notation
	f~:		Floating Point
	f~abs:		Floating Point
	f~rel:		Floating Point
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
	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
	hmcopy,:		Threading Words
	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 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, placement in files:		Emacs Tags
	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
	included:		Forth source files
	INCLUDED, I/O exception reading or closing file-id:		file-ambcond
	INCLUDED, named file cannot be opened:		file-ambcond
	included-locale:		i18n and l10n
	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
	infile-id:		Redirection
	infinity:		Floating Point
	info-color:		Terminal output
	inheritance(継承):		Object-Oriented Terminology
	init-asm:		Assembler Definitions
	init-buffer:		Heap Allocation
	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, linewise from terminal:		Line input and conversion
	input, single-key:		Single-key input
	input-color:		Terminal output
	insert:		Memory Blocks
	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
	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 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
	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
	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!:		Special Memory Accesses
	L":		i18n and l10n
	l,:		Dictionary allocation
	l>s:		Special Memory Accesses
	l@:		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::		Forth200x 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!:		i18n and l10n
	locale-csv:		i18n and l10n
	locale-csv-out:		i18n and l10n
	locale-file:		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
	lp0:		Stack pointer manipulation
	lp@:		Stack pointer manipulation
	lp@:		Locals implementation
	lrol:		Bitwise operations
	lror:		Bitwise operations
	lshift:		Bitwise operations
	LSHIFT, large shift counts:		core-ambcond
	LU":		i18n and l10n
M
	m*:		Mixed precision
	m*/:		Integer division
	m+:		Mixed precision
	m::		Objects Glossary
	m: usage:		Method conveniences
	macros:		Compiling words
	Macros:		Macros
	macros, advanced tutorial:		Advanced macros Tutorial
	macros-wordlist:		Substitute
	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 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 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:		User-defined TO and DEFER@
	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$:		widget methods
	name, maximum length:		core-idef
	name>compile:		Name token
	name>interpret:		Name token
	name>link:		Name token
	name>string:		Name token
	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, direct threaded:		Threading
	NEXT, indirect threaded:		Threading
	next-arg:		OS command line arguments
	next-case:		Arbitrary control structures
	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
	notation of glossary entries:		Notation
	notfound:		Dealing with existing Recognizers
	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
	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 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-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
	object-[]:		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
	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 binding:		Class Binding
	parent class(親クラス):		Object-Oriented Terminology
	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
	postpone:		Macros
	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
	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, 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/o:		General files
	r/w:		General files
	r>:		Return stack
	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 Reader
	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-dtick:		Dealing with existing Recognizers
	rec-float:		Dealing with existing Recognizers
	rec-moof2:		Mini-OOF2
	rec-nt:		Dealing with existing Recognizers
	rec-num:		Dealing with existing Recognizers
	rec-string:		Dealing with existing Recognizers
	rec-tick:		Dealing with existing Recognizers
	rec-to:		Dealing with existing Recognizers
	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
	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
	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
	rp0:		Stack pointer manipulation
	rp@:		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":		String and character literals
	S", number of string buffers:		file-idef
	S", size of string buffer:		file-idef
	s+:		String words
	s//:		Regular Expressions
	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:		Heap 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
	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
	see:		Examining compiled code
	see tutorial:		Decompilation Tutorial
	SEE, source and format of output:		programming-idef
	see-code:		Examining compiled code
	see-code-range:		Examining compiled code
	select:		Boolean Flags
	selection control structures:		Selection
	selector implementation, class:		Objects Implementation
	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, 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-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-to:		User-defined TO and DEFER@
	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
	sfloat/:		Address arithmetic
	sfloats:		Address arithmetic
	sf_, stack item type:		Notation
	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
	SLiteral:		Literals
	slurp-fid:		General files
	slurp-file:		General files
	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
	sp0:		Stack pointer manipulation
	sp@:		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 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
	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-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,:		Counted string words
	string-parse:		The Input Stream
	string-prefix?:		String words
	string-suffix?:		String words
	strings - see character strings:		String representations
	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
	substitute:		Substitute
	success-color:		Terminal output
	superclass binding:		Class Binding
	Superinstructions:		Dynamic Superinstructions
	swap:		Data stack
	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
	s\":		String and character literals
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
	threaded code implementation:		Threading
	threading words:		Threading Words
	threading, direct or indirect?:		Direct or Indirect Threaded?
	threading-method:		Threading Words
	throw:		Exception Handling
	THROW-codes used in the system:		exception-idef
	thru:		Blocks
	tib:		The Text Interpreter
	tick (’):		Execution token
	TILE performance:		Performance
	time&date:		Keeping track of Time
	time-related words:		Keeping track of Time
	TMP, TEMP - environment variable:		Environment variables
	TO:		Values
	TO on non-VALUEs:		core-ambcond
	TO on non-VALUEs and non-locals:		locals-ambcond
	to-method::		User-defined TO and DEFER@
	to-table::		User-defined TO and DEFER@
	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-method::		Dealing with existing Recognizers
	translate-nt:		Dealing with existing Recognizers
	translate-num:		Dealing with existing Recognizers
	translate-state:		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*/:		Integer division
	u*/mod:		Integer division
	U+DO:		Counted Loops
	u, stack item type:		Notation
	U-DO:		Counted Loops
	u-[do:		Counted Loops
	u.:		Simple numeric output
	u.r:		Simple numeric output
	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<:		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':		Task-local data
	user-defined defining words:		User-defined Defining Words
	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
	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!:		Special Memory Accesses
	w,:		Dictionary allocation
	w, stack item type:		Notation
	w-color:		widget methods
	w/o:		General files
	W::		Locals definition words
	w>s:		Special Memory Accesses
	w@:		Special Memory Accesses
	WA::		Locals definition words
	walign:		Address arithmetic
	waligned:		Address arithmetic
	WARNING":		Exception Handling
	warning-color:		Terminal output
	warnings:		Exception Handling
	wbe:		Special Memory Accesses
	wfield::		Forth200x 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
	ww:		Locating uses of a word
	W^:		Locals definition words
X
	x:		widget methods
	x!:		Special Memory Accesses
	x,:		Dictionary allocation
	x-size:		Xchars and Unicode
	x-width:		Xchars and Unicode
	x>s:		Special Memory Accesses
	x@:		Special Memory Accesses
	xalign:		Address arithmetic
	xaligned:		Address arithmetic
	xbe:		Special Memory Accesses
	xc!+:		Xchars and Unicode
	xc!+?:		Xchars and Unicode
	xc,:		Xchars and Unicode
	xc-size:		Xchars and Unicode
	xc-width:		Xchars and Unicode
	xc@:		Xchars and Unicode
	xc@+:		Xchars and Unicode
	xc@+?:		Xchars and Unicode
	xchar+:		Xchars and Unicode
	xchar-:		Xchars and Unicode
	XCHAR-ENCODING:		Environmental Queries
	XCHAR-MAXMEM:		Environmental Queries
	xd!:		Special Memory Accesses
	xd,:		Dictionary allocation
	xd>s:		Special Memory Accesses
	xd@:		Special Memory Accesses
	xdbe:		Special Memory Accesses
	xdle:		Special Memory Accesses
	xemit:		Displaying characters and strings
	xfield::		Forth200x 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, stack item type:		Notation
	xt-new:		Objects Glossary
	xt-see:		Examining compiled code
	xt-see-code:		Examining compiled code
	xt-simple-see:		Examining compiled code
	XT::		Locals definition words
	xt>name:		Name token
	XTA::		Locals definition words
	xywh:		widget methods
	xywhd:		widget methods
	x\string-:		Xchars and Unicode
Y
	y:		widget methods
Z
	zero-length string as a name:		core-ambcond
	Zsoter’s object-oriented model:		Comparison with other object models
イ
	インスタンス変数(instance variables):		Object-Oriented Terminology
オ
	オブジェクト(object):		Object-Oriented Terminology
	オブジェクト(object):		Objects Glossary
	オブジェクト(object):		Basic Mini-OOF Usage
ク
	クラス(class):		Object-Oriented Terminology
	クラス(class):		Objects Glossary
	クラス(class):		Basic Mini-OOF Usage
セ
	セレクター(selector):		Object-Oriented Terminology
	セレクター(selector):		Objects Glossary
	セレクター呼び出し(selector invocation):		Object-Oriented Terminology
メ
	メソッド(method):		Object-Oriented Terminology
	メソッド(method):		Objects Glossary
	メソッド(method):		Class Declaration
	メソッド(method):		Basic Mini-OOF Usage
受
	受信オブジェクト(receiving object):		Object-Oriented Terminology
子
	子クラス(child class):		Object-Oriented Terminology

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   イ   オ   ク   セ   メ   受   子