Node:Word Index, Next:Concept Index, Previous:Licenses, Up:Top
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.
! w a-addr - core: Memory Access
# 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 unknown: The Text Interpreter
$? - n gforth: Passing Commands to the OS
%align align size - gforth: Structure Glossary
%alignment align size - align gforth: Structure Glossary
%alloc size align - 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
' "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
* 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
+! n a-addr - core: Memory Access
+DO compilation - do-sys ; run-time n1 n2 - | loop-sys gforth: Arbitrary control structures
+load i*x n - j*x gforth: Blocks
+LOOP compilation do-sys - ; run-time loop-sys1 n - | loop-sys2 core: Arbitrary control structures
+thru i*x n1 n2 - j*x gforth: Blocks
, w - core: Dictionary allocation
- 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
. 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 - unknown: Name token
.name nt - unknown: Name token
.path path-addr - gforth: General Search Paths
.r n1 n2 - core-ext: Simple numeric output
.s - tools: Examining
/ n1 n2 - n core: Single precision
/does-handler - n gforth: Threading Words
/mod n1 n2 - n3 n4 core: Single precision
/string c-addr1 u1 n - c-addr2 u2 string: Memory Blocks
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+ n1 - n2 core: Single precision
1- n1 - n2 core: Single precision
1/f r1 - r2 gforth: Floating Point
2! w1 w2 a-addr - core: Memory Access
2* n1 - n2 core: Bitwise operations
2, w1 w2 - gforth: Dictionary allocation
2/ n1 - n2 core: Bitwise operations
2>r d - R:d core-ext: Return stack
2@ a-addr - w1 w2 core: Memory Access
2Constant w1 w2 "name" - double: Constants
2drop w1 w2 - core: Data stack
2dup w1 w2 - w1 w2 w1 w2 core: Data stack
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 - d core-ext: Return stack
2r@ R:d - 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
: "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
; 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
< 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
<IS> "name" xt - gforth: Deferred 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 unknown: Threading Words
>does-code xt - a_addr gforth: Threading Words
>float c-addr u - flag float: Input
>in unknown: 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: Input
>order wid - gforth: Word Lists
>r w - R:w core: Return stack
? a-addr - tools: Examining
?DO compilation - do-sys ; run-time w1 w2 - | loop-sys core-ext: Arbitrary control structures
?dup w - 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
@ a-addr - w core: Memory Access
@local# #noffset - w gforth: Locals implementation
[ - core: Literals
['] compilation. "name" - ; run-time. - xt core: Execution token
[+LOOP] n - gforth: Interpreter Directives
[?DO] n-limit n-index - gforth: Interpreter Directives
[] n "name" - oof: The OOF base class
[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
[IS] compilation "name" - ; run-time xt - gforth: Deferred words
[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
\ compilation 'ccc<newline>' - ; run-time - core-ext,block-ext: Comments
\"-parse "string"<"> - c-addr u unknown: The Input Stream
\G compilation 'ccc<newline>' - ; run-time - gforth: Comments
] - core: Literals
]L compilation: n - ; run-time: - n gforth: Literals
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: Input
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 n - addr count gforth: Modifying the Startup Sequence
argc - addr gforth: Modifying the Startup Sequence
argv - addr gforth: Modifying the Startup Sequence
asptr class - oof: Class Declaration
asptr o "name" - oof: The OOF base class
assembler - tools-ext: Code and ;code
assert( - gforth: Assertions
assert-level - a-addr 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: Displaying characters and strings
base - a-addr core: Number Conversion
BEGIN compilation - dest ; run-time - core: Arbitrary control 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 unknown: 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
bound class addr "name" - oof: The OOF base class
bounds addr u - addr+u addr gforth: Memory Blocks
break" 'ccc"' - gforth: Singlestep Debugger
break: - gforth: Singlestep Debugger
broken-pipe-error - n gforth: Pipes
buffer u - a-addr block: Blocks
bye - tools-ext: Leaving Gforth
c! c c-addr - core: Memory Access
C" compilation "ccc<quote>" - ; run-time - c-addr core-ext: Displaying characters and strings
c, c - core: Dictionary allocation
c@ c-addr - c core: Memory Access
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
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>order class - objects: Objects Glossary
class? o - flag oof: The OOF base class
clear-path path-addr - gforth: General Search Paths
clearstack ... - 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, xt - core-ext: Macros
compile-lp+! n - gforth: Locals implementation
compile-only - gforth: Interpretation and Compilation Semantics
Constant w "name" - core: Constants
construct ... object - objects: Objects Glossary
context - addr gforth: Word Lists
convert ud1 c-addr1 - ud2 c-addr2 core-ext: Input
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' "selector" - xt objects: Objects Glossary
current-interface - addr objects: Objects Glossary
d+ d1 d2 - d double: Double precision
d- d1 d2 - d double: Double precision
d. d - double: Simple numeric output
d.r d n - double: Simple numeric output
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
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
dabs d - ud double: Double precision
dbg "name" - gforth: Singlestep Debugger
dec. n - gforth: Simple numeric output
decimal - core: Number Conversion
Defer "name" - gforth: Deferred words
defer - oof: Class Declaration
defers compilation "name" - ; run-time ... - ... gforth: Deferred words
definer! definer xt - unknown: 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
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
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
early - oof: Class Declaration
edit-line c-addr n1 n2 - n3 gforth: Input
ekey - u facility-ext: Input
ekey>char u - u false | c true facility-ext: Input
ekey? - flag unknown: Input
ELSE compilation orig1 - orig2 ; run-time f - 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-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
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 orig - ; run-time - 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 - ... unknown: The Input Stream
execute-parsing-file i*x fileid xt - j*x unknown: The Input Stream
EXIT compilation - ; run-time nest-sys - core: Calls and returns
exitm - objects: Objects Glossary
expect c-addr +n - core-ext: Input
f! r f-addr - float: Memory Access
f* r1 r2 - r3 float: Floating Point
f** r1 r2 - r3 float-ext: Floating Point
f+ r1 r2 - r3 float: Floating Point
f, f - gforth: Dictionary allocation
f- r1 r2 - r3 float: Floating Point
f. r - float-ext: Simple numeric output
f.rdp rf +nr +nd +np - gforth: Simple numeric output
f.s - gforth: Examining
f/ r1 r2 - r3 float: 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
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>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@ f-addr - r float: Memory Access
f@local# #noffset - r gforth: Locals implementation
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
field align1 offset1 align size "name" - align2 offset2 gforth: Structure Glossary
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
Forth - search-ext: Word Lists
forth-wordlist - wid search: Word Lists
fover r1 r2 - r1 r2 r1 float: Floating point stack
fp! f-addr - gforth: Stack pointer manipulation
fp0 - a-addr gforth: Stack pointer manipulation
fp@ - f-addr gforth: Stack pointer manipulation
fpath - path-addr gforth: Source Search Paths
fpick u - 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 gforth: 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
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
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
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 R:n - R:n n core: Counted Loops
id. nt - gforth: Name token
IF compilation - orig ; run-time f - core: Arbitrary control structures
immediate - core: Interpretation and Compilation Semantics
implementation interface - objects: Objects Glossary
include ... "file" - ... gforth: Forth source files
include-file i*x wfileid - j*x unknown: Forth source files
included i*x c-addr u - j*x file: Forth source files
included? c-addr u - f gforth: Forth source files
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 xt "name" - gforth: Deferred words
is xt "name" - oof: The OOF base class
j R:n R:d1 - n R:n R:d1 core: Counted Loops
k R:n R:d1 R:d2 - n R:n R:d1 R:d2 gforth: Counted Loops
key - char core: Input
key? - flag facility: Input
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
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 i*x n - j*x block: Blocks
LOOP compilation do-sys - ; run-time loop-sys1 - | loop-sys2 core: Arbitrary control structures
lp! c-addr - gforth: Locals implementation, Stack pointer manipulation
lp+!# #noffset - gforth: Locals implementation
lp0 - a-addr gforth: Stack pointer manipulation
lp@ - addr gforth: Stack pointer manipulation
lshift u1 n - u2 core: Bitwise operations
m* n1 n2 - d core: Mixed precision
m*/ d1 n2 u3 - dquot double: Mixed precision
m+ d1 n - d2 double: Mixed precision
m: - xt colon-sys; run-time: object - objects: Objects Glossary
marker "<spaces> name" - core-ext: Forgetting words
max n1 n2 - n core: Single precision
maxalign - gforth: Dictionary allocation
maxaligned addr1 - addr2 gforth: Address arithmetic
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 n - facility-ext: Keeping track of Time
naligned addr1 n - addr2 gforth: Structure Glossary
name - c-addr u gforth-obsolete: The Input Stream
name>comp nt - w xt gforth: Name token
name>int nt - xt gforth: Name token
name>string nt - addr count gforth: Name token
name?int nt - xt 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
nextname c-addr u - gforth: Supplying names
nip w1 w2 - w2 core-ext: Data stack
noname - gforth: Anonymous Definitions
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-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
over w1 w2 - w1 w2 w1 core: Data stack
overrides xt "selector" - objects: Objects Glossary
pad - c-addr core-ext: Input
page - facility: Displaying characters and strings
parse char "ccc<char>" - c-addr u core-ext: The Input Stream
parse-word "name" - c-addr u gforth: The Input Stream
path+ path-addr "dir" - gforth: General Search Paths
path-allot umax - unknown: 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 u - 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 "name" - oof: The OOF base class
ptr - oof: Class Declaration
public - objects: Objects Glossary
query - core-ext: Input Sources
quit ?? - ?? core: Miscellaneous Words
r/o - fam file: General files
r/w - fam file: General files
r> R:w - w core: Return stack
r@ - w ; 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 unknown: General files
recover compilation orig1 - orig2 ; run-time - gforth: Exception Handling
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 i*x addr u - j*x gforth: Forth source files
resize a-addr1 u - a-addr2 wior memory: Heap Allocation
resize-file ud wfileid - wior file: General files
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
rp0 - a-addr gforth: Stack pointer manipulation
rp@ - a-addr gforth: Stack pointer manipulation
rshift u1 n - u2 core: Bitwise operations
S" compilation 'ccc"' - ; run-time - c-addr u core,file: Displaying characters and strings
s>d n - d core: Double precision
s\" compilation 'ccc"' - ; run-time - c-addr u gforth: Displaying characters and strings
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
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
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
sign n - core: Formatted numeric output
simple-see "name" - gforth: Examining
simple-see-range addr1 addr2 - gforth: Examining
SLiteral Compilation c-addr1 u ; run-time - c-addr2 u string: Literals
slurp-fid unknown: General files
slurp-file c-addr1 u1 - c-addr2 u2 unknown: General files
sm/rem d1 n1 - n2 n3 core: Mixed precision
source - addr u core-ext,file: 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 - gforth: Stack pointer manipulation
sp0 - a-addr gforth: Stack pointer manipulation
sp@ - a-addr gforth: Stack pointer manipulation
space - core: Displaying characters and strings
spaces u - core: Displaying characters and strings
span - c-addr core-ext: Input
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
swap w1 w2 - w2 w1 core: Data stack
system c-addr u - gforth: Passing Commands to the OS
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 i*x n1 n2 - j*x block-ext: Blocks
tib unknown: The Text Interpreter
time&date - nsec nmin nhour nday nmonth nyear facility-ext: Keeping track of Time
TO w "name" - core-ext: 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 - 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+DO compilation - do-sys ; run-time u1 u2 - | loop-sys gforth: Arbitrary control structures
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< 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
um* u1 u2 - ud core: Mixed precision
um/mod ud u1 - u2 u3 core: Mixed 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
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/o - fam file: General files
What's interpretation "name" - xt; compilation "name" - ; run-time - xt gforth: Deferred words
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
xor w1 w2 - w core: Bitwise operations
xt-new ... class xt - object objects: Objects Glossary
xt-see xt - gforth: Examining
~~ compilation - ; run-time - gforth: Debugging