Word Index (Gforth Manual)

Next: Concept and Word Index, Previous: Licenses, Up: Gforth [Contents][Index]

Word Index ¶

This index is a list of Forth words that have “glossary” entries within this manual. Each word is listed with its stack effect and wordset.

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

-
	Index Entry	Section

	`- n1 n2 -- n core`	Single precision
	`--> -- gforth`	Blocks
	`-DO compilation -- do-sys ; run-time n1 n2 -- \| loop-sys gforth`	Arbitrary control structures
	`-LOOP compilation do-sys -- ; run-time loop-sys1 u -- \| loop-sys2 gforth`	Arbitrary control structures
	`-rot w1 w2 w3 -- w3 w1 w2 gforth`	Data stack
	`-trailing c_addr u1 -- c_addr u2 string`	Memory Blocks
	`-trailing-garbage xc-addr u1 -- addr u2 xchar-ext`	Xchars and Unicode

,
	`, w -- core`	Dictionary allocation

;
	`; compilation colon-sys -- ; run-time nest-sys core`	Colon Definitions
	`;code compilation. colon-sys1 -- colon-sys2 tools-ext`	Code and ;code
	`;m colon-sys --; run-time: -- objects`	Objects Glossary
	`;s R:w -- gforth`	Calls and returns

:
	`: "name" -- oof`	The OOF base class
	`: "name" -- colon-sys core`	Colon Definitions
	`:: "name" -- oof`	The OOF base class
	`:: class "name" -- mini-oof`	Basic Mini-OOF Usage
	`:m "name" -- xt; run-time: object -- objects`	Objects Glossary
	`:noname -- xt colon-sys core-ext`	Anonymous Definitions

!
	`! w a-addr -- core`	Memory Access

?
	`? a-addr -- tools`	Examining
	`?DO compilation -- do-sys ; run-time w1 w2 -- \| loop-sys core-ext`	Arbitrary control structures
	`?dup w -- S:... w core`	Data stack
	`?DUP-0=-IF compilation -- orig ; run-time n -- n\| gforth`	Arbitrary control structures
	`?DUP-IF compilation -- orig ; run-time n -- n\| gforth`	Arbitrary control structures
	`?LEAVE compilation -- ; run-time f \| f loop-sys -- gforth`	Arbitrary control structures

.
	`. n -- core`	Simple numeric output
	`." compilation 'ccc"' -- ; run-time -- core`	Displaying characters and strings
	`.( compilation&interpretation "ccc<paren>" -- core-ext`	Displaying characters and strings
	`.\" compilation 'ccc"' -- ; run-time -- gforth`	Displaying characters and strings
	`.debugline nfile nline -- gforth`	Debugging
	`.id nt -- F83`	Name token
	`.name nt -- gforth-obsolete`	Name token
	`.path path-addr -- gforth`	General Search Paths
	`.r n1 n2 -- core-ext`	Simple numeric output
	`.s -- tools`	Examining

'
	`' "name" -- xt core`	Execution token
	`' "name" -- xt oof`	The OOF base class
	`'cold -- gforth`	Modifying the Startup Sequence

(
	`( compilation 'ccc<close-paren>' -- ; run-time -- core,file`	Comments
	`(local) addr u -- local`	ANS Forth locals

)
	`) -- gforth`	Assertions

[
	`[ -- core`	Literals
	`[?DO] n-limit n-index -- gforth`	Interpreter Directives
	`['] compilation. "name" -- ; run-time. -- xt core`	Execution token
	`[] n "name" -- oof`	The OOF base class
	`[+LOOP] n -- gforth`	Interpreter Directives
	`[AGAIN] -- gforth`	Interpreter Directives
	`[BEGIN] -- gforth`	Interpreter Directives
	`[bind] compile-time: "class" "selector" -- ; run-time: ... object -- ... objects`	Objects Glossary
	`[Char] compilation '<spaces>ccc' -- ; run-time -- c core`	Displaying characters and strings
	`[COMP'] compilation "name" -- ; run-time -- w xt gforth`	Compilation token
	`[compile] compilation "name" -- ; run-time ? -- ? core-ext`	Macros
	`[current] compile-time: "selector" -- ; run-time: ... object -- ... objects`	Objects Glossary
	`[DO] n-limit n-index -- gforth`	Interpreter Directives
	`[ELSE] -- tools-ext`	Interpreter Directives
	`[ENDIF] -- gforth`	Interpreter Directives
	`[FOR] n -- gforth`	Interpreter Directives
	`[IF] flag -- tools-ext`	Interpreter Directives
	`[IFDEF] "<spaces>name" -- gforth`	Interpreter Directives
	`[IFUNDEF] "<spaces>name" -- gforth`	Interpreter Directives
	`[LOOP] -- gforth`	Interpreter Directives
	`[NEXT] n -- gforth`	Interpreter Directives
	`[parent] compile-time: "selector" -- ; run-time: ... object -- ... objects`	Objects Glossary
	`[REPEAT] -- gforth`	Interpreter Directives
	`[THEN] -- tools-ext`	Interpreter Directives
	`[to-inst] compile-time: "name" -- ; run-time: w -- objects`	Objects Glossary
	`[UNTIL] flag -- gforth`	Interpreter Directives
	`[WHILE] flag -- gforth`	Interpreter Directives

]
	`] -- core`	Literals
	`]L compilation: n -- ; run-time: -- n gforth`	Literals

@
	`@ a-addr -- w core`	Memory Access
	`@local# #noffset -- w gforth`	Locals implementation

*
	`* n1 n2 -- n core`	Single precision
	`*/ n1 n2 n3 -- n4 core`	Mixed precision
	`*/mod n1 n2 n3 -- n4 n5 core`	Mixed precision

/
	`/ n1 n2 -- n core`	Single precision
	`/does-handler -- n gforth`	Threading Words
	`/l -- u gforth`	Address arithmetic
	`/mod n1 n2 -- n3 n4 core`	Single precision
	`/string c-addr1 u1 n -- c-addr2 u2 string`	Memory Blocks
	`/w -- u gforth`	Address arithmetic

\
	`\ compilation 'ccc<newline>' -- ; run-time -- core-ext,block-ext`	Comments
	`\c "rest-of-line" -- gforth`	Declaring C Functions
	`\G compilation 'ccc<newline>' -- ; run-time -- gforth`	Comments

#
	`# ud1 -- ud2 core`	Formatted numeric output
	`#! -- gforth`	Running Image Files
	`#> xd -- addr u core`	Formatted numeric output
	`#>> -- gforth`	Formatted numeric output
	`#s ud -- 0 0 core`	Formatted numeric output
	`#tib -- addr core-ext-obsolescent`	The Text Interpreter

%
	`%align align size -- gforth`	Structure Glossary
	`%alignment align size -- align gforth`	Structure Glossary
	`%alloc align size -- addr gforth`	Structure Glossary
	`%allocate align size -- addr ior gforth`	Structure Glossary
	`%allot align size -- addr gforth`	Structure Glossary
	`%size align size -- size gforth`	Structure Glossary

+
	`+ n1 n2 -- n core`	Single precision
	`+! n a-addr -- core`	Memory Access
	`+DO compilation -- do-sys ; run-time n1 n2 -- \| loop-sys gforth`	Arbitrary control structures
	`+field n1 n2 "name" -- n3 X:structures`	Forth200x Structures
	`+load ix n -- jx gforth`	Blocks
	`+LOOP compilation do-sys -- ; run-time loop-sys1 n -- \| loop-sys2 core`	Arbitrary control structures
	`+thru ix n1 n2 -- jx gforth`	Blocks
	`+x/string xc-addr1 u1 -- xc-addr2 u2 xchar`	Xchars and Unicode

<
	`< n1 n2 -- f core`	Numeric comparison
	`<# -- core`	Formatted numeric output
	`<<# -- gforth`	Formatted numeric output
	`<= n1 n2 -- f gforth`	Numeric comparison
	`<> n1 n2 -- f core-ext`	Numeric comparison
	`<bind> class selector-xt -- xt objects`	Objects Glossary
	`<compilation compilation. orig colon-sys -- gforth`	Combined words
	`<interpretation compilation. orig colon-sys -- gforth`	Combined words
	`<to-inst> w xt -- objects`	Objects Glossary

=
	`= n1 n2 -- f core`	Numeric comparison

>
	`> n1 n2 -- f core`	Numeric comparison
	`>= n1 n2 -- f gforth`	Numeric comparison
	`>body xt -- a_addr core`	CREATE..DOES> details
	`>code-address xt -- c_addr gforth`	Threading Words
	`>definer xt -- definer gforth`	Threading Words
	`>does-code xt -- a_addr gforth`	Threading Words
	`>float c-addr u -- f:... flag float`	Line input and conversion
	`>in -- addr core`	The Text Interpreter
	`>l w -- gforth`	Locals implementation
	`>name xt -- nt\|0 gforth`	Name token
	`>number ud1 c-addr1 u1 -- ud2 c-addr2 u2 core`	Line input and conversion
	`>order wid -- gforth`	Word Lists
	`>r w -- R:w core`	Return stack

~
	`~~ -- gforth`	Debugging

$
	`$? -- n gforth`	Passing Commands to the OS

0
	`0< n -- f core`	Numeric comparison
	`0<= n -- f gforth`	Numeric comparison
	`0<> n -- f core-ext`	Numeric comparison
	`0= n -- f core`	Numeric comparison
	`0> n -- f core-ext`	Numeric comparison
	`0>= n -- f gforth`	Numeric comparison

1
	`1- n1 -- n2 core`	Single precision
	`1/f r1 -- r2 gforth`	Floating Point
	`1+ n1 -- n2 core`	Single precision

2
	`2, w1 w2 -- gforth`	Dictionary allocation
	`2! w1 w2 a-addr -- core`	Memory Access
	`2@ a-addr -- w1 w2 core`	Memory Access
	`2* n1 -- n2 core`	Bitwise operations
	`2/ n1 -- n2 core`	Bitwise operations
	`2>r d -- R:d core-ext`	Return stack
	`2Constant w1 w2 "name" -- double`	Constants
	`2drop w1 w2 -- core`	Data stack
	`2dup w1 w2 -- w1 w2 w1 w2 core`	Data stack
	`2field: u1 "name" -- u2 gforth`	Forth200x Structures
	`2Literal compilation w1 w2 -- ; run-time -- w1 w2 double`	Literals
	`2nip w1 w2 w3 w4 -- w3 w4 gforth`	Data stack
	`2over w1 w2 w3 w4 -- w1 w2 w3 w4 w1 w2 core`	Data stack
	`2r@ R:d -- R:d d core-ext`	Return stack
	`2r> R:d -- d core-ext`	Return stack
	`2rdrop R:d -- gforth`	Return stack
	`2rot w1 w2 w3 w4 w5 w6 -- w3 w4 w5 w6 w1 w2 double-ext`	Data stack
	`2swap w1 w2 w3 w4 -- w3 w4 w1 w2 core`	Data stack
	`2tuck w1 w2 w3 w4 -- w3 w4 w1 w2 w3 w4 gforth`	Data stack
	`2Variable "name" -- double`	Variables

A
	`abort ?? -- ?? core,exception-ext`	Exception Handling
	`ABORT" compilation 'ccc"' -- ; run-time f -- core,exception-ext`	Exception Handling
	`abs n -- u core`	Single precision
	`accept c-addr +n1 -- +n2 core`	Line input and conversion
	`action-of interpretation "name" -- xt; compilation "name" -- ; run-time -- xt gforth`	Deferred Words
	`add-lib c-addr u -- gforth`	Declaring OS-level libraries
	`ADDRESS-UNIT-BITS -- n environment`	Address arithmetic
	`AGAIN compilation dest -- ; run-time -- core-ext`	Arbitrary control structures
	`AHEAD compilation -- orig ; run-time -- tools-ext`	Arbitrary control structures
	`Alias xt "name" -- gforth`	Aliases
	`align -- core`	Dictionary allocation
	`aligned c-addr -- a-addr core`	Address arithmetic
	`allocate u -- a-addr wior memory`	Heap Allocation
	`allot n -- core`	Dictionary allocation
	`also -- search-ext`	Word Lists
	`also-path c-addr len path-addr -- gforth`	General Search Paths
	`and w1 w2 -- w core`	Bitwise operations
	`arg u -- addr count gforth`	OS command line arguments
	`argc -- addr gforth`	OS command line arguments
	`argv -- addr gforth`	OS command line arguments
	`asptr class -- oof`	Class Declaration
	`asptr o "name" -- oof`	The OOF base class
	`assembler -- tools-ext`	Code and ;code
	`assert-level -- a-addr gforth`	Assertions
	`assert( -- gforth`	Assertions
	`assert0( -- gforth`	Assertions
	`assert1( -- gforth`	Assertions
	`assert2( -- gforth`	Assertions
	`assert3( -- gforth`	Assertions
	`ASSUME-LIVE orig -- orig gforth`	Where are locals visible by name?
	`at-xy u1 u2 -- facility`	Terminal output

B
	`base -- a-addr core`	Number Conversion
	`base-execute ix xt u -- jx gforth`	Number Conversion
	`BEGIN compilation -- dest ; run-time -- core`	Arbitrary control structures
	`begin-structure "name" -- struct-sys 0 X:structures`	Forth200x Structures
	`bin fam1 -- fam2 file`	General files
	`bind ... "class" "selector" -- ... objects`	Objects Glossary
	`bind o "name" -- oof`	The OOF base class
	`bind' "class" "selector" -- xt objects`	Objects Glossary
	`bl -- c-char core`	Displaying characters and strings
	`blank c-addr u -- string`	Memory Blocks
	`blk -- addr block`	Input Sources
	`block u -- a-addr block`	Blocks
	`block-included a-addr u -- gforth`	Blocks
	`block-offset -- addr gforth`	Blocks
	`block-position u -- block`	Blocks
	`bootmessage -- gforth`	Modifying the Startup Sequence
	`bound class addr "name" -- oof`	The OOF base class
	`bounds addr u -- addr+u addr gforth`	Memory Blocks
	`break: -- gforth`	Singlestep Debugger
	`break" 'ccc"' -- gforth`	Singlestep Debugger
	`broken-pipe-error -- n gforth`	Pipes
	`buffer u -- a-addr block`	Blocks
	`bye -- tools-ext`	Leaving Gforth

C
	`c-function "forth-name" "c-name" "{type}" "--" "type" -- gforth`	Declaring C Functions
	`c-library "name" -- gforth`	Defining library interfaces
	`c-library-name c-addr u -- gforth`	Defining library interfaces
	`c, c -- core`	Dictionary allocation
	`c! c c-addr -- core`	Memory Access
	`C" compilation "ccc<quote>" -- ; run-time -- c-addr core-ext`	Displaying characters and strings
	`c@ c-addr -- c core`	Memory Access
	`call-c ... w -- ... gforth`	Low-Level C Interface Words
	`case compilation -- case-sys ; run-time -- core-ext`	Arbitrary control structures
	`catch ... xt -- ... n exception`	Exception Handling
	`cell -- u gforth`	Address arithmetic
	`cell% -- align size gforth`	Structure Glossary
	`cell+ a-addr1 -- a-addr2 core`	Address arithmetic
	`cells n1 -- n2 core`	Address arithmetic
	`cfalign -- gforth`	Dictionary allocation
	`cfaligned addr1 -- addr2 gforth`	Address arithmetic
	`cfield: u1 "name" -- u2 X:structures`	Forth200x Structures
	`char '<spaces>ccc' -- c core`	Displaying characters and strings
	`char% -- align size gforth`	Structure Glossary
	`char+ c-addr1 -- c-addr2 core`	Address arithmetic
	`chars n1 -- n2 core`	Address arithmetic
	`class "name" -- oof`	The OOF base class
	`class class -- class selectors vars mini-oof`	Basic Mini-OOF Usage
	`class parent-class -- align offset objects`	Objects Glossary
	`class->map class -- map objects`	Objects Glossary
	`class-inst-size class -- addr objects`	Objects Glossary
	`class-override! xt sel-xt class-map -- objects`	Objects Glossary
	`class-previous class -- objects`	Objects Glossary
	`class; -- oof`	Class Declaration
	`class? o -- flag oof`	The OOF base class
	`class>order class -- objects`	Objects Glossary
	`clear-libs -- gforth`	Declaring OS-level libraries
	`clear-path path-addr -- gforth`	General Search Paths
	`clearstack ... -- gforth`	Examining
	`clearstacks ... -- gforth`	Examining
	`close-file wfileid -- wior file`	General files
	`close-pipe wfileid -- wretval wior gforth`	Pipes
	`cmove c-from c-to u -- string`	Memory Blocks
	`cmove> c-from c-to u -- string`	Memory Blocks
	`code "name" -- colon-sys tools-ext`	Code and ;code
	`code-address! c_addr xt -- gforth`	Threading Words
	`common-list list1 list2 -- list3 gforth-internal`	Locals implementation
	`COMP' "name" -- w xt gforth`	Compilation token
	`compare c-addr1 u1 c-addr2 u2 -- n string`	Memory Blocks
	`compilation> compilation. -- orig colon-sys gforth`	Combined words
	`compile-lp+! n -- gforth`	Locals implementation
	`compile-only -- gforth`	Interpretation and Compilation Semantics
	`compile, xt -- core-ext`	Macros
	`const-does> run-time: wuw rur uw ur "name" -- gforth`	Const-does>
	`Constant w "name" -- core`	Constants
	`construct ... object -- objects`	Objects Glossary
	`context -- addr gforth`	Word Lists
	`convert ud1 c-addr1 -- ud2 c-addr2 core-ext-obsolescent`	Line input and conversion
	`count c-addr1 -- c-addr2 u core`	String Formats
	`cputime -- duser dsystem gforth`	Keeping track of Time
	`cr -- core`	Displaying characters and strings
	`Create "name" -- core`	CREATE
	`create-file c-addr u wfam -- wfileid wior file`	General files
	`create-interpret/compile "name" -- gforth`	Combined words
	`CS-PICK ... u -- ... destu tools-ext`	Arbitrary control structures
	`CS-ROLL destu/origu .. dest0/orig0 u -- .. dest0/orig0 destu/origu tools-ext`	Arbitrary control structures
	`current -- addr gforth`	Word Lists
	`current-interface -- addr objects`	Objects Glossary
	`current' "selector" -- xt objects`	Objects Glossary

D
	`d- d1 d2 -- d double`	Double precision
	`d. d -- double`	Simple numeric output
	`d.r d n -- double`	Simple numeric output
	`d+ d1 d2 -- d double`	Double precision
	`d< d1 d2 -- f double`	Numeric comparison
	`d<= d1 d2 -- f gforth`	Numeric comparison
	`d<> d1 d2 -- f gforth`	Numeric comparison
	`d= d1 d2 -- f double`	Numeric comparison
	`d> d1 d2 -- f gforth`	Numeric comparison
	`d>= d1 d2 -- f gforth`	Numeric comparison
	`d>f d -- r float`	Floating Point
	`d>s d -- n double`	Double precision
	`d0< d -- f double`	Numeric comparison
	`d0<= d -- f gforth`	Numeric comparison
	`d0<> d -- f gforth`	Numeric comparison
	`d0= d -- f double`	Numeric comparison
	`d0> d -- f gforth`	Numeric comparison
	`d0>= d -- f gforth`	Numeric comparison
	`d2* d1 -- d2 double`	Bitwise operations
	`d2/ d1 -- d2 double`	Bitwise operations
	`dabs d -- ud double`	Double precision
	`dbg "name" -- gforth`	Singlestep Debugger
	`dec. n -- gforth`	Simple numeric output
	`decimal -- core`	Number Conversion
	`defer -- oof`	Class Declaration
	`Defer "name" -- gforth`	Deferred Words
	`defer! xt xt-deferred -- gforth`	Deferred Words
	`defer@ xt-deferred -- xt gforth`	Deferred Words
	`defers compilation "name" -- ; run-time ... -- ... gforth`	Deferred Words
	`definer! definer xt -- gforth`	Threading Words
	`defines xt class "name" -- mini-oof`	Basic Mini-OOF Usage
	`definitions -- oof`	The OOF base class
	`definitions -- search`	Word Lists
	`delete-file c-addr u -- wior file`	General files
	`depth -- +n core`	Examining
	`df! r df-addr -- float-ext`	Memory Access
	`df@ df-addr -- r float-ext`	Memory Access
	`dfalign -- float-ext`	Dictionary allocation
	`dfaligned c-addr -- df-addr float-ext`	Address arithmetic
	`dffield: u1 "name" -- u2 X:structures`	Forth200x Structures
	`dfloat% -- align size gforth`	Structure Glossary
	`dfloat+ df-addr1 -- df-addr2 float-ext`	Address arithmetic
	`dfloats n1 -- n2 float-ext`	Address arithmetic
	`dict-new ... class -- object objects`	Objects Glossary
	`discode addr u -- gforth`	Common Disassembler
	`dispose -- oof`	The OOF base class
	`dmax d1 d2 -- d double`	Double precision
	`dmin d1 d2 -- d double`	Double precision
	`dnegate d1 -- d2 double`	Double precision
	`DO compilation -- do-sys ; run-time w1 w2 -- loop-sys core`	Arbitrary control structures
	`docol: -- addr gforth`	Threading Words
	`docon: -- addr gforth`	Threading Words
	`dodefer: -- addr gforth`	Threading Words
	`does-code! a_addr xt -- gforth`	Threading Words
	`does-handler! a_addr -- gforth`	Threading Words
	`DOES> compilation colon-sys1 -- colon-sys2 ; run-time nest-sys -- core`	CREATE..DOES> details
	`dofield: -- addr gforth`	Threading Words
	`DONE compilation orig -- ; run-time -- gforth`	Arbitrary control structures
	`double% -- align size gforth`	Structure Glossary
	`douser: -- addr gforth`	Threading Words
	`dovar: -- addr gforth`	Threading Words
	`dpl -- a-addr gforth`	Number Conversion
	`drop w -- core`	Data stack
	`du< ud1 ud2 -- f double-ext`	Numeric comparison
	`du<= ud1 ud2 -- f gforth`	Numeric comparison
	`du> ud1 ud2 -- f gforth`	Numeric comparison
	`du>= ud1 ud2 -- f gforth`	Numeric comparison
	`dump addr u -- tools`	Examining
	`dup w -- w w core`	Data stack

E
	`early -- oof`	Class Declaration
	`edit-line c-addr n1 n2 -- n3 gforth`	Line input and conversion
	`ekey -- u facility-ext`	Single-key input
	`ekey? -- flag facility-ext`	Single-key input
	`ekey>char u -- u false \| c true facility-ext`	Single-key input
	`ekey>fkey u1 -- u2 f X:ekeys`	Single-key input
	`ELSE compilation orig1 -- orig2 ; run-time -- core`	Arbitrary control structures
	`emit c -- core`	Displaying characters and strings
	`emit-file c wfileid -- wior gforth`	General files
	`empty-buffer buffer -- gforth`	Blocks
	`empty-buffers -- block-ext`	Blocks
	`end-c-library -- gforth`	Defining library interfaces
	`end-class align offset "name" -- objects`	Objects Glossary
	`end-class class selectors vars "name" -- mini-oof`	Basic Mini-OOF Usage
	`end-class-noname align offset -- class objects`	Objects Glossary
	`end-code colon-sys -- gforth`	Code and ;code
	`end-interface "name" -- objects`	Objects Glossary
	`end-interface-noname -- interface objects`	Objects Glossary
	`end-methods -- objects`	Objects Glossary
	`end-struct align size "name" -- gforth`	Structure Glossary
	`end-structure struct-sys +n -- X:structures`	Forth200x Structures
	`endcase compilation case-sys -- ; run-time x -- core-ext`	Arbitrary control structures
	`ENDIF compilation orig -- ; run-time -- gforth`	Arbitrary control structures
	`endof compilation case-sys1 of-sys -- case-sys2 ; run-time -- core-ext`	Arbitrary control structures
	`endscope compilation scope -- ; run-time -- gforth`	Where are locals visible by name?
	`endtry compilation -- ; run-time R:sys1 -- gforth`	Exception Handling
	`endtry-iferror compilation orig1 -- orig2 ; run-time R:sys1 -- gforth`	Exception Handling
	`endwith -- oof`	The OOF base class
	`environment-wordlist -- wid gforth`	Environmental Queries
	`environment? c-addr u -- false / ... true core`	Environmental Queries
	`erase addr u -- core-ext`	Memory Blocks
	`evaluate ... addr u -- ... core,block`	Input Sources
	`exception addr u -- n gforth`	Exception Handling
	`execute xt -- core`	Execution token
	`execute-parsing ... addr u xt -- ... gforth`	The Input Stream
	`execute-parsing-file ix fileid xt -- jx gforth`	The Input Stream
	`EXIT compilation -- ; run-time nest-sys -- core`	Calls and returns
	`exitm -- objects`	Objects Glossary
	`expect c-addr +n -- core-ext-obsolescent`	Line input and conversion

F
	`f- r1 r2 -- r3 float`	Floating Point
	`f, f -- gforth`	Dictionary allocation
	`f! r f-addr -- float`	Memory Access
	`f. r -- float-ext`	Simple numeric output
	`f.rdp rf +nr +nd +np -- gforth`	Simple numeric output
	`f.s -- gforth`	Examining
	`f@ f-addr -- r float`	Memory Access
	`f@local# #noffset -- r gforth`	Locals implementation
	`f* r1 r2 -- r3 float`	Floating Point
	`f** r1 r2 -- r3 float-ext`	Floating Point
	`f/ r1 r2 -- r3 float`	Floating Point
	`f+ r1 r2 -- r3 float`	Floating Point
	`f< r1 r2 -- f float`	Floating Point
	`f<= r1 r2 -- f gforth`	Floating Point
	`f<> r1 r2 -- f gforth`	Floating Point
	`f= r1 r2 -- f gforth`	Floating Point
	`f> r1 r2 -- f gforth`	Floating Point
	`f>= r1 r2 -- f gforth`	Floating Point
	`f>buf-rdp rf c-addr +nr +nd +np -- gforth`	Formatted numeric output
	`f>d r -- d float`	Floating Point
	`f>l r -- gforth`	Locals implementation
	`f>str-rdp rf +nr +nd +np -- c-addr nr gforth`	Formatted numeric output
	`f~ r1 r2 r3 -- flag float-ext`	Floating Point
	`f~abs r1 r2 r3 -- flag gforth`	Floating Point
	`f~rel r1 r2 r3 -- flag gforth`	Floating Point
	`f0< r -- f float`	Floating Point
	`f0<= r -- f gforth`	Floating Point
	`f0<> r -- f gforth`	Floating Point
	`f0= r -- f float`	Floating Point
	`f0> r -- f gforth`	Floating Point
	`f0>= r -- f gforth`	Floating Point
	`f2* r1 -- r2 gforth`	Floating Point
	`f2/ r1 -- r2 gforth`	Floating Point
	`fabs r1 -- r2 float-ext`	Floating Point
	`facos r1 -- r2 float-ext`	Floating Point
	`facosh r1 -- r2 float-ext`	Floating Point
	`falign -- float`	Dictionary allocation
	`faligned c-addr -- f-addr float`	Address arithmetic
	`falog r1 -- r2 float-ext`	Floating Point
	`false -- f core-ext`	Boolean Flags
	`fasin r1 -- r2 float-ext`	Floating Point
	`fasinh r1 -- r2 float-ext`	Floating Point
	`fatan r1 -- r2 float-ext`	Floating Point
	`fatan2 r1 r2 -- r3 float-ext`	Floating Point
	`fatanh r1 -- r2 float-ext`	Floating Point
	`fconstant r "name" -- float`	Constants
	`fcos r1 -- r2 float-ext`	Floating Point
	`fcosh r1 -- r2 float-ext`	Floating Point
	`fdepth -- +n float`	Examining
	`fdrop r -- float`	Floating point stack
	`fdup r -- r r float`	Floating point stack
	`fe. r -- float-ext`	Simple numeric output
	`fexp r1 -- r2 float-ext`	Floating Point
	`fexpm1 r1 -- r2 float-ext`	Floating Point
	`ffield: u1 "name" -- u2 X:structures`	Forth200x Structures
	`field align1 offset1 align size "name" -- align2 offset2 gforth`	Structure Glossary
	`field: u1 "name" -- u2 X:structures`	Forth200x Structures
	`file-position wfileid -- ud wior file`	General files
	`file-size wfileid -- ud wior file`	General files
	`file-status c-addr u -- wfam wior file-ext`	General files
	`fill c-addr u c -- core`	Memory Blocks
	`find c-addr -- xt +-1 \| c-addr 0 core,search`	Word Lists
	`find-name c-addr u -- nt \| 0 gforth`	Name token
	`FLiteral compilation r -- ; run-time -- r float`	Literals
	`fln r1 -- r2 float-ext`	Floating Point
	`flnp1 r1 -- r2 float-ext`	Floating Point
	`float -- u gforth`	Address arithmetic
	`float% -- align size gforth`	Structure Glossary
	`float+ f-addr1 -- f-addr2 float`	Address arithmetic
	`floating-stack -- n environment`	Floating point stack
	`floats n1 -- n2 float`	Address arithmetic
	`flog r1 -- r2 float-ext`	Floating Point
	`floor r1 -- r2 float`	Floating Point
	`FLOORED -- f environment`	Single precision
	`flush -- block`	Blocks
	`flush-file wfileid -- wior file-ext`	General files
	`flush-icache c-addr u -- gforth`	Code and ;code
	`fm/mod d1 n1 -- n2 n3 core`	Mixed precision
	`fmax r1 r2 -- r3 float`	Floating Point
	`fmin r1 r2 -- r3 float`	Floating Point
	`fnegate r1 -- r2 float`	Floating Point
	`fnip r1 r2 -- r2 gforth`	Floating point stack
	`FOR compilation -- do-sys ; run-time u -- loop-sys gforth`	Arbitrary control structures
	`form -- urows ucols gforth`	Terminal output
	`Forth -- search-ext`	Word Lists
	`forth-wordlist -- wid search`	Word Lists
	`fover r1 r2 -- r1 r2 r1 float`	Floating point stack
	`fp! f-addr -- f:... gforth`	Stack pointer manipulation
	`fp@ f:... -- f-addr gforth`	Stack pointer manipulation
	`fp0 -- a-addr gforth`	Stack pointer manipulation
	`fpath -- path-addr gforth`	Source Search Paths
	`fpick f:... u -- f:... r gforth`	Floating point stack
	`free a-addr -- wior memory`	Heap Allocation
	`frot r1 r2 r3 -- r2 r3 r1 float`	Floating point stack
	`fround r1 -- r2 float`	Floating Point
	`fs. r -- float-ext`	Simple numeric output
	`fsin r1 -- r2 float-ext`	Floating Point
	`fsincos r1 -- r2 r3 float-ext`	Floating Point
	`fsinh r1 -- r2 float-ext`	Floating Point
	`fsqrt r1 -- r2 float-ext`	Floating Point
	`fswap r1 r2 -- r2 r1 float`	Floating point stack
	`ftan r1 -- r2 float-ext`	Floating Point
	`ftanh r1 -- r2 float-ext`	Floating Point
	`ftuck r1 r2 -- r2 r1 r2 gforth`	Floating point stack
	`fvariable "name" -- float`	Variables

G
	`get-block-fid -- wfileid gforth`	Blocks
	`get-current -- wid search`	Word Lists
	`get-order -- widn .. wid1 n search`	Word Lists
	`getenv c-addr1 u1 -- c-addr2 u2 gforth`	Passing Commands to the OS
	`gforth -- c-addr u gforth-environment`	Environmental Queries

H
	`heap-new ... class -- object objects`	Objects Glossary
	`here -- addr core`	Dictionary allocation
	`hex -- core-ext`	Number Conversion
	`hex. u -- gforth`	Simple numeric output
	`hold char -- core`	Formatted numeric output
	`how: -- oof`	Class Declaration

I
	`i R:n -- R:n n core`	Counted Loops
	`id. nt -- gforth`	Name token
	`IF compilation -- orig ; run-time f -- core`	Arbitrary control structures
	`iferror compilation orig1 -- orig2 ; run-time -- gforth`	Exception Handling
	`immediate -- core`	Interpretation and Compilation Semantics
	`implementation interface -- objects`	Objects Glossary
	`include ... "file" -- ... gforth`	Forth source files
	`include-file ix wfileid -- jx file`	Forth source files
	`included ix c-addr u -- jx file`	Forth source files
	`included? c-addr u -- f gforth`	Forth source files
	`infile-execute ... xt file-id -- ... gforth`	Redirection
	`init ... -- oof`	The OOF base class
	`init-asm -- gforth`	Code and ;code
	`init-object ... class object -- objects`	Objects Glossary
	`inst-value align1 offset1 "name" -- align2 offset2 objects`	Objects Glossary
	`inst-var align1 offset1 align size "name" -- align2 offset2 objects`	Objects Glossary
	`interface -- objects`	Objects Glossary
	`interpret/compile: interp-xt comp-xt "name" -- gforth`	Combined words
	`interpretation> compilation. -- orig colon-sys gforth`	Combined words
	`invert w1 -- w2 core`	Bitwise operations
	`IS compilation/interpretation "name-deferred" -- ; run-time xt -- gforth`	Deferred Words
	`is xt "name" -- oof`	The OOF base class

J
	`j R:w R:w1 R:w2 -- w R:w R:w1 R:w2 core`	Counted Loops

K
	`k R:w R:w1 R:w2 R:w3 R:w4 -- w R:w R:w1 R:w2 R:w3 R:w4 gforth`	Counted Loops
	`k-alt-mask -- u X:ekeys`	Single-key input
	`k-ctrl-mask -- u X:ekeys`	Single-key input
	`k-delete -- u X:ekeys`	Single-key input
	`k-down -- u X:ekeys`	Single-key input
	`k-end -- u X:ekeys`	Single-key input
	`k-f1 -- u X:ekeys`	Single-key input
	`k-f10 -- u X:ekeys`	Single-key input
	`k-f11 -- u X:ekeys`	Single-key input
	`k-f12 -- u X:ekeys`	Single-key input
	`k-f2 -- u X:ekeys`	Single-key input
	`k-f3 -- u X:ekeys`	Single-key input
	`k-f4 -- u X:ekeys`	Single-key input
	`k-f5 -- u X:ekeys`	Single-key input
	`k-f6 -- u X:ekeys`	Single-key input
	`k-f7 -- u X:ekeys`	Single-key input
	`k-f8 -- u X:ekeys`	Single-key input
	`k-f9 -- u X:ekeys`	Single-key input
	`k-home -- u X:ekeys`	Single-key input
	`k-insert -- u X:ekeys`	Single-key input
	`k-left -- u X:ekeys`	Single-key input
	`k-next -- u X:ekeys`	Single-key input
	`k-prior -- u X:ekeys`	Single-key input
	`k-right -- u X:ekeys`	Single-key input
	`k-shift-mask -- u X:ekeys`	Single-key input
	`k-up -- u X:ekeys`	Single-key input
	`key -- char core`	Single-key input
	`key-file wfileid -- c gforth`	General files
	`key? -- flag facility`	Single-key input
	`key?-file wfileid -- f gforth`	General files

L
	`l! w c-addr -- gforth`	Memory Access
	`laddr# #noffset -- c-addr gforth`	Locals implementation
	`latest -- nt gforth`	Name token
	`latestxt -- xt gforth`	Anonymous Definitions
	`LEAVE compilation -- ; run-time loop-sys -- core`	Arbitrary control structures
	`lib-error -- c-addr u gforth`	Low-Level C Interface Words
	`lib-sym c-addr1 u1 u2 -- u3 gforth`	Low-Level C Interface Words
	`link "name" -- class addr oof`	The OOF base class
	`list u -- block-ext`	Blocks
	`list-size list -- u gforth-internal`	Locals implementation
	`Literal compilation n -- ; run-time -- n core`	Literals
	`load ix n -- jx block`	Blocks
	`LOOP compilation do-sys -- ; run-time loop-sys1 -- \| loop-sys2 core`	Arbitrary control structures
	`lp! c-addr -- gforth`	Stack pointer manipulation
	`lp! c-addr -- gforth`	Locals implementation
	`lp@ -- addr gforth`	Stack pointer manipulation
	`lp+!# #noffset -- gforth`	Locals implementation
	`lp0 -- a-addr gforth`	Stack pointer manipulation
	`lshift u1 n -- u2 core`	Bitwise operations

M
	`m: -- xt colon-sys; run-time: object -- objects`	Objects Glossary
	`m* n1 n2 -- d core`	Mixed precision
	`m*/ d1 n2 u3 -- dquot double`	Mixed precision
	`m+ d1 n -- d2 double`	Mixed precision
	`marker "<spaces> name" -- core-ext`	Forgetting words
	`max n1 n2 -- n core`	Single precision
	`maxalign -- gforth`	Dictionary allocation
	`maxaligned addr1 -- addr2 gforth`	Address arithmetic
	`maxdepth-.s -- addr gforth`	Examining
	`method -- oof`	Class Declaration
	`method m v "name" -- m' v mini-oof`	Basic Mini-OOF Usage
	`method xt "name" -- objects`	Objects Glossary
	`methods class -- objects`	Objects Glossary
	`min n1 n2 -- n core`	Single precision
	`mod n1 n2 -- n core`	Single precision
	`move c-from c-to ucount -- core`	Memory Blocks
	`ms u -- facility-ext`	Keeping track of Time

N
	`naligned addr1 n -- addr2 gforth`	Structure Glossary
	`name -- c-addr u gforth-obsolete`	The Input Stream
	`name?int nt -- xt gforth`	Name token
	`name>comp nt -- w xt gforth`	Name token
	`name>int nt -- xt gforth`	Name token
	`name>string nt -- addr count gforth`	Name token
	`needs ... "name" -- ... gforth`	Forth source files
	`negate n1 -- n2 core`	Single precision
	`new -- o oof`	The OOF base class
	`new class -- o mini-oof`	Basic Mini-OOF Usage
	`new[] n -- o oof`	The OOF base class
	`NEXT compilation do-sys -- ; run-time loop-sys1 -- \| loop-sys2 gforth`	Arbitrary control structures
	`next-arg -- addr u gforth`	OS command line arguments
	`nextname c-addr u -- gforth`	Supplying names
	`nip w1 w2 -- w2 core-ext`	Data stack
	`noname -- gforth`	Anonymous Definitions
	`nothrow -- gforth`	Exception Handling

O
	`object -- a-addr mini-oof`	Basic Mini-OOF Usage
	`object -- class objects`	Objects Glossary
	`of compilation -- of-sys ; run-time x1 x2 -- \|x1 core-ext`	Arbitrary control structures
	`off a-addr -- gforth`	Boolean Flags
	`on a-addr -- gforth`	Boolean Flags
	`Only -- search-ext`	Word Lists
	`open-blocks c-addr u -- gforth`	Blocks
	`open-file c-addr u wfam -- wfileid wior file`	General files
	`open-lib c-addr1 u1 -- u2 gforth`	Low-Level C Interface Words
	`open-path-file addr1 u1 path-addr -- wfileid addr2 u2 0 \| ior gforth`	General Search Paths
	`open-pipe c-addr u wfam -- wfileid wior gforth`	Pipes
	`or w1 w2 -- w core`	Bitwise operations
	`order -- search-ext`	Word Lists
	`os-class -- c-addr u gforth-environment`	Environmental Queries
	`outfile-execute ... xt file-id -- ... gforth`	Redirection
	`over w1 w2 -- w1 w2 w1 core`	Data stack
	`overrides xt "selector" -- objects`	Objects Glossary

P
	`pad -- c-addr core-ext`	Memory Blocks
	`page -- facility`	Terminal output
	`parse char "ccc<char>" -- c-addr u core-ext`	The Input Stream
	`parse-name "name" -- c-addr u gforth`	The Input Stream
	`parse-word -- c-addr u gforth-obsolete`	The Input Stream
	`path-allot umax -- gforth`	General Search Paths
	`path+ path-addr "dir" -- gforth`	General Search Paths
	`path= path-addr "dir1\|dir2\|dir3" gforth`	General Search Paths
	`perform a-addr -- gforth`	Execution token
	`pi -- r gforth`	Floating Point
	`pick S:... u -- S:... w core-ext`	Data stack
	`postpone "name" -- core`	Macros
	`postpone "name" -- oof`	The OOF base class
	`postpone, w xt -- gforth`	Compilation token
	`precision -- u float-ext`	Floating Point
	`previous -- search-ext`	Word Lists
	`print object -- objects`	Objects Glossary
	`printdebugdata -- gforth`	Debugging
	`protected -- objects`	Objects Glossary
	`ptr -- oof`	Class Declaration
	`ptr "name" -- oof`	The OOF base class
	`public -- objects`	Objects Glossary

Q
	`query -- core-ext-obsolescent`	Input Sources
	`quit ?? -- ?? core`	Miscellaneous Words

R
	`r@ -- w ; R: w -- w core`	Return stack
	`r/o -- fam file`	General files
	`r/w -- fam file`	General files
	`r> R:w -- w core`	Return stack
	`rdrop R:w -- gforth`	Return stack
	`read-file c-addr u1 wfileid -- u2 wior file`	General files
	`read-line c_addr u1 wfileid -- u2 flag wior file`	General files
	`recurse compilation -- ; run-time ?? -- ?? core`	Calls and returns
	`recursive compilation -- ; run-time -- gforth`	Calls and returns
	`refill -- flag core-ext,block-ext,file-ext`	The Input Stream
	`rename-file c-addr1 u1 c-addr2 u2 -- wior file-ext`	General files
	`REPEAT compilation orig dest -- ; run-time -- core`	Arbitrary control structures
	`reposition-file ud wfileid -- wior file`	General files
	`represent r c-addr u -- n f1 f2 float`	Formatted numeric output
	`require ... "file" -- ... gforth`	Forth source files
	`required ix addr u -- ix gforth`	Forth source files
	`resize a-addr1 u -- a-addr2 wior memory`	Heap Allocation
	`resize-file ud wfileid -- wior file`	General files
	`restore compilation orig1 -- ; run-time -- gforth`	Exception Handling
	`restore-input x1 .. xn n -- flag core-ext`	Input Sources
	`restrict -- gforth`	Interpretation and Compilation Semantics
	`roll x0 x1 .. xn n -- x1 .. xn x0 core-ext`	Data stack
	`Root -- gforth`	Word Lists
	`rot w1 w2 w3 -- w2 w3 w1 core`	Data stack
	`rp! a-addr -- gforth`	Stack pointer manipulation
	`rp@ -- a-addr gforth`	Stack pointer manipulation
	`rp0 -- a-addr gforth`	Stack pointer manipulation
	`rshift u1 n -- u2 core`	Bitwise operations

S
	`S" compilation 'ccc"' -- ; run-time -- c-addr u core,file`	Displaying characters and strings
	`s\" compilation 'ccc"' -- ; run-time -- c-addr u gforth`	Displaying characters and strings
	`s>d n -- d core`	Double precision
	`s>number? addr u -- d f gforth`	Line input and conversion
	`s>unumber? c-addr u -- ud flag gforth`	Line input and conversion
	`save-buffer buffer -- gforth`	Blocks
	`save-buffers -- block`	Blocks
	`save-input -- x1 .. xn n core-ext`	Input Sources
	`savesystem "name" -- gforth`	Non-Relocatable Image Files
	`scope compilation -- scope ; run-time -- gforth`	Where are locals visible by name?
	`scr -- a-addr block-ext`	Blocks
	`seal -- gforth`	Word Lists
	`search c-addr1 u1 c-addr2 u2 -- c-addr3 u3 flag string`	Memory Blocks
	`search-wordlist c-addr count wid -- 0 \| xt +-1 search`	Word Lists
	`see "<spaces>name" -- tools`	Examining
	`see-code "name" -- gforth`	Examining
	`see-code-range addr1 addr2 -- gforth`	Examining
	`selector "name" -- objects`	Objects Glossary
	`self -- o oof`	The OOF base class
	`set-current wid -- search`	Word Lists
	`set-order widn .. wid1 n -- search`	Word Lists
	`set-precision u -- float-ext`	Floating Point
	`sf! r sf-addr -- float-ext`	Memory Access
	`sf@ sf-addr -- r float-ext`	Memory Access
	`sfalign -- float-ext`	Dictionary allocation
	`sfaligned c-addr -- sf-addr float-ext`	Address arithmetic
	`sffield: u1 "name" -- u2 X:structures`	Forth200x Structures
	`sfloat% -- align size gforth`	Structure Glossary
	`sfloat+ sf-addr1 -- sf-addr2 float-ext`	Address arithmetic
	`sfloats n1 -- n2 float-ext`	Address arithmetic
	`sh "..." -- gforth`	Passing Commands to the OS
	`shift-args -- gforth`	OS command line arguments
	`sign n -- core`	Formatted numeric output
	`simple-see "name" -- gforth`	Examining
	`simple-see-range addr1 addr2 -- gforth`	Examining
	`sl@ c-addr -- n gforth`	Memory Access
	`SLiteral Compilation c-addr1 u ; run-time -- c-addr2 u string`	Literals
	`slurp-fid fid -- addr u gforth`	General files
	`slurp-file c-addr1 u1 -- c-addr2 u2 gforth`	General files
	`sm/rem d1 n1 -- n2 n3 core`	Mixed precision
	`source -- addr u core`	The Text Interpreter
	`source-id -- 0 \| -1 \| fileid core-ext,file`	Input Sources
	`sourcefilename -- c-addr u gforth`	Forth source files
	`sourceline# -- u gforth`	Forth source files
	`sp! a-addr -- S:... gforth`	Stack pointer manipulation
	`sp@ S:... -- a-addr gforth`	Stack pointer manipulation
	`sp0 -- a-addr gforth`	Stack pointer manipulation
	`space -- core`	Displaying characters and strings
	`spaces u -- core`	Displaying characters and strings
	`span -- c-addr core-ext-obsolescent`	Line input and conversion
	`static -- oof`	Class Declaration
	`stderr -- wfileid gforth`	General files
	`stdin -- wfileid gforth`	General files
	`stdout -- wfileid gforth`	General files
	`str< c-addr1 u1 c-addr2 u2 -- f gforth`	Memory Blocks
	`str= c-addr1 u1 c-addr2 u2 -- f gforth`	Memory Blocks
	`string-prefix? c-addr1 u1 c-addr2 u2 -- f gforth`	Memory Blocks
	`struct -- align size gforth`	Structure Glossary
	`sub-list? list1 list2 -- f gforth-internal`	Locals implementation
	`super "name" -- oof`	The OOF base class
	`sw@ c-addr -- n gforth`	Memory Access
	`swap w1 w2 -- w2 w1 core`	Data stack
	`system c-addr u -- gforth`	Passing Commands to the OS

T
	`table -- wid gforth`	Word Lists
	`THEN compilation orig -- ; run-time -- core`	Arbitrary control structures
	`this -- object objects`	Objects Glossary
	`threading-method -- n gforth`	Threading Words
	`throw y1 .. ym nerror -- y1 .. ym / z1 .. zn error exception`	Exception Handling
	`thru ix n1 n2 -- jx block-ext`	Blocks
	`tib -- addr core-ext-obsolescent`	The Text Interpreter
	`time&date -- nsec nmin nhour nday nmonth nyear facility-ext`	Keeping track of Time
	`TO c\|w\|d\|r "name" -- core-ext,local`	Values
	`to-this object -- objects`	Objects Glossary
	`toupper c1 -- c2 gforth`	Displaying characters and strings
	`true -- f core-ext`	Boolean Flags
	`try compilation -- orig ; run-time -- R:sys1 gforth`	Exception Handling
	`tuck w1 w2 -- w2 w1 w2 core-ext`	Data stack
	`type c-addr u -- core`	Displaying characters and strings
	`typewhite addr n -- gforth`	Displaying characters and strings

U
	`U-DO compilation -- do-sys ; run-time u1 u2 -- \| loop-sys gforth`	Arbitrary control structures
	`u. u -- core`	Simple numeric output
	`u.r u n -- core-ext`	Simple numeric output
	`U+DO compilation -- do-sys ; run-time u1 u2 -- \| loop-sys gforth`	Arbitrary control structures
	`u< u1 u2 -- f core`	Numeric comparison
	`u<= u1 u2 -- f gforth`	Numeric comparison
	`u> u1 u2 -- f core-ext`	Numeric comparison
	`u>= u1 u2 -- f gforth`	Numeric comparison
	`ud. ud -- gforth`	Simple numeric output
	`ud.r ud n -- gforth`	Simple numeric output
	`ul@ c-addr -- u gforth`	Memory Access
	`um* u1 u2 -- ud core`	Mixed precision
	`um/mod ud u1 -- u2 u3 core`	Mixed precision
	`under+ n1 n2 n3 -- n n2 gforth`	Single precision
	`unloop R:w1 R:w2 -- core`	Arbitrary control structures
	`UNREACHABLE -- gforth`	Where are locals visible by name?
	`UNTIL compilation dest -- ; run-time f -- core`	Arbitrary control structures
	`unused -- u core-ext`	Dictionary allocation
	`update -- block`	Blocks
	`updated? n -- f gforth`	Blocks
	`use "file" -- gforth`	Blocks
	`User "name" -- gforth`	Variables
	`utime -- dtime gforth`	Keeping track of Time
	`uw@ c-addr -- u gforth`	Memory Access

V
	`Value w "name" -- core-ext`	Values
	`var m v size "name" -- m v' mini-oof`	Basic Mini-OOF Usage
	`var size -- oof`	Class Declaration
	`Variable "name" -- core`	Variables
	`vlist -- gforth`	Word Lists
	`Vocabulary "name" -- gforth`	Word Lists
	`vocs -- gforth`	Word Lists

W
	`w! w c-addr -- gforth`	Memory Access
	`w/o -- fam file`	General files
	`WHILE compilation dest -- orig dest ; run-time f -- core`	Arbitrary control structures
	`with o -- oof`	The OOF base class
	`within u1 u2 u3 -- f core-ext`	Numeric comparison
	`word char "<chars>ccc<char>-- c-addr core`	The Input Stream
	`wordlist -- wid search`	Word Lists
	`words -- tools`	Word Lists
	`write-file c-addr u1 wfileid -- wior file`	General files
	`write-line c-addr u fileid -- ior file`	General files

X
	`x-size xc-addr u1 -- u2 xchar`	Xchars and Unicode
	`x-width xc-addr u -- n xchar-ext`	Xchars and Unicode
	`x\string- xc-addr1 u1 -- xc-addr1 u2 xchar`	Xchars and Unicode
	`xc-size xc -- u xchar-ext`	Xchars and Unicode
	`xc!+? xc xc-addr1 u1 -- xc-addr2 u2 f xchar-ext`	Xchars and Unicode
	`xc@+ xc-addr1 -- xc-addr2 xc xchar-ext`	Xchars and Unicode
	`xchar- xc-addr1 -- xc-addr2 xchar-ext`	Xchars and Unicode
	`xchar-encoding -- addr u xchar-ext`	Xchars and Unicode
	`xchar+ xc-addr1 -- xc-addr2 xchar-ext`	Xchars and Unicode
	`xemit xc -- xchar-ext`	Xchars and Unicode
	`xkey -- xc xchar-ext`	Xchars and Unicode
	`xor w1 w2 -- w core`	Bitwise operations
	`xt-new ... class xt -- object objects`	Objects Glossary
	`xt-see xt -- gforth`	Examining

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