Previous: , Up: Gforth   [Contents][Index]

Concept and Word Index

Not all entries listed in this index are present verbatim in the text. This index also duplicates, in abbreviated form, all of the words listed in the Word Index (only the names are listed for the words here).

Jump to:   !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /   0   1   2   :   ;   <   =   >   ?   @   [   \   ]   {   ~  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  
Index Entry  Section

!: Memory Access
!!FIXME!!: Debugging
!@: Pthreads

", stack item type: Notation

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

$!: String words
$!len: String words
$+!: String words
$+!len: String words
$-prefix for hexadecimal numbers: Number Conversion
$.: String words
$?: Passing Commands to the OS
$@: String words
$@len: String words
$boot: String words
$del: String words
$exec: String words
$free: String words
$init: String words
$ins: String words
$iter: String words
$over: String words
$save: String words
$saved: String words
$slurp: String words
$slurp-file: String words
$split: String words
$tmp: String words
$Variable: String words
$[]: String words
$[]!: String words
$[]#: String words
$[]+!: String words
$[].: String words
$[]@: String words
$[]boot: String words
$[]free: String words
$[]map: String words
$[]save: String words
$[]saved: String words
$[]slurp: String words
$[]slurp-file: String words
$[]Variable: String words

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

&-prefix for decimal numbers: Number Conversion

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

(: Comments
(local): Standard Forth locals

): Assertions

*: Single precision
*/: Integer division
*/f: Integer division
*/mod: Integer division
*/modf: Integer division
*/mods: Integer division
*/s: Integer division

+: Single precision
+!: Memory Access
+!@: Pthreads
+DO: Arbitrary control structures
+field: Forth200x Structures
+fmode: General files
+load: Blocks
+LOOP: Arbitrary control structures
+ltrace: Debugging
+thru: Blocks
+TO: Values
+x/string: Xchars and Unicode

,: Dictionary allocation

-: Single precision
–, tutorial: Stack-Effect Comments Tutorial
-->: Blocks
–appl-image, command-line option: Invoking Gforth
–application, gforthmi option: gforthmi
–clear-dictionary, command-line option: Invoking Gforth
-d, command-line option: Invoking Gforth
–data-stack-size, command-line option: Invoking Gforth
–debug, command-line option: Invoking Gforth
-DFORCE_REG: Portability
–dictionary-size, command-line option: Invoking Gforth
–die-on-signal, command-line-option: Invoking Gforth
-DO: Arbitrary control structures
-DUSE_FTOS: TOS Optimization
-DUSE_NO_FTOS: TOS Optimization
-DUSE_NO_TOS: TOS Optimization
-DUSE_TOS: TOS Optimization
–dynamic command-line option: Dynamic Superinstructions
–dynamic, command-line option: Invoking Gforth
–enable-force-reg, configuration flag: Portability
-f, command-line option: Invoking Gforth
–fp-stack-size, command-line option: Invoking Gforth
-h, command-line option: Invoking Gforth
–help, command-line option: Invoking Gforth
-i, command-line option: Invoking Gforth
-i, invoke image file: Running Image Files
–image file, invoke image file: Running Image Files
–image-file, command-line option: Invoking Gforth
-l, command-line option: Invoking Gforth
–locals-stack-size, command-line option: Invoking Gforth
-LOOP: Arbitrary control structures
-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: Memory Blocks
-trailing-garbage: Xchars and Unicode
-v, command-line option: Invoking Gforth
–version, command-line option: Invoking Gforth
–vm-commit, command-line option: Invoking Gforth

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

/: Integer division
/does-handler: Threading Words
/f: Integer division
/f-stage1m: Two-stage integer division
/f-stage2m: Two-stage integer division
/l: Address arithmetic
/mod: Integer division
/modf: Integer division
/modf-stage2m: Two-stage integer division
/mods: Integer division
/s: Integer division
/string: Memory Blocks
/w: Address arithmetic

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

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

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
2Variable: Variables

:: Colon Definitions
:: The OOF base class
:, passing data across: Literals
::: The OOF base class
::: Basic Mini-OOF Usage
:m: Objects Glossary
:noname: Anonymous Definitions
:}d: Closures
:}h: Closures
:}l: Closures

;: Colon Definitions
;>: Closures
;code: Assembler Definitions
;CODE ending sequence: programming-idef
;CODE, name not defined via CREATE: programming-ambcond
;CODE, processing input: programming-idef
;m: Objects Glossary
;m usage: Method conveniences
;s: Calls and returns
;]: Quotations

<: Numeric comparison
<#: Formatted numeric output
<<#: Formatted numeric output
<=: Numeric comparison
<>: Numeric comparison
<bind>: Objects Glossary
<to-inst>: Objects Glossary
<{:: Closures

=: Numeric comparison
=mkdir: Directories

>: Numeric comparison
>=: Numeric comparison
>addr: Closures
>body: CREATE..DOES> details
>BODY of non-CREATEd words: core-ambcond
>code-address: Threading Words
>definer: Threading Words
>does-code: Threading Words
>float: Line input and conversion
>float1: Line input and conversion
>in: The Text Interpreter
>IN greater than input buffer: core-ambcond
>l: Locals implementation
>name: Name token
>number: Line input and conversion
>order: Word Lists
>r: Return stack

?: Examining data
?!@: Pthreads
???: Debugging
?DO: Arbitrary control structures
?dup: Data stack
?DUP-0=-IF: Arbitrary control structures
?dup-IF: Arbitrary control structures
?LEAVE: Arbitrary control structures
?of: Arbitrary control structures

@: Memory Access
@local#: 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]: Displaying characters and strings
[COMP']: Compilation token
[current]: Objects Glossary
[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
[LOOP]: Interpreter Directives
[NEXT]: Interpreter Directives
[parent]: Objects Glossary
[parent] usage: Class Binding
[REPEAT]: Interpreter Directives
[THEN]: Interpreter Directives
[to-inst]: Objects Glossary
[UNTIL]: Interpreter Directives
[WHILE]: Interpreter Directives
[]: The OOF base class
[{:: Closures

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

]: Literals
]L: Literals
]]: Macros

{:: Standard Forth locals

~~: Debugging
~~, removal with Emacs: Emacs and Gforth
~~1bt: Debugging
~~bt: Debugging
~~Value: Debugging
~~Variable: Debugging

abi-code: Assembler Definitions
abort: Exception Handling
ABORT": Exception Handling
ABORT", exception abort sequence: core-idef
abs: Single precision
abstract class: Basic Objects Usage
abstract class: Basic OOF Usage
accept: Line input and conversion
ACCEPT, display after end of input: core-idef
ACCEPT, editing: core-idef
action-of: Deferred Words
add-cflags: 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: Values
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 of counted string: String Formats
address unit: Address arithmetic
address unit, size in bits: core-idef
ADDRESS-UNIT-BITS: Address arithmetic
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
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
ans-report.fs: Standard Report
arg: OS command line arguments
argc: OS command line arguments
argument input source different than current input source for RESTORE-INPUT: core-ambcond
argument type mismatch: core-ambcond
argument type mismatch, RESTORE-INPUT: core-ambcond
arguments, OS command line: OS command line arguments
argv: OS command line arguments
arithmetic words: Arithmetic
arithmetics tutorial: Arithmetics Tutorial
arrays: CREATE
arrays tutorial: Arrays and Records Tutorial
arshift: Bitwise operations
asptr: The OOF base class
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-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
attr!: Terminal output
au (address unit): Address arithmetic
authors: Help on Gforth
authors of Gforth: Origin
auto-indentation of Forth code in Emacs: Auto-Indentation
a_, stack item type: Notation

b: Locating source code definitions
backtrace: Error messages
backtrace examination: Locating exception source
backtraces with gforth-fast: Error messages
barrier: Pthreads
base: Number Conversion
base is not decimal (REPRESENT, F., FE., FS.): floating-ambcond
base-execute: Number Conversion
basic objects usage: Basic Objects Usage
batch processing with Gforth: Invoking Gforth
before-locate: Locating source code definitions
BEGIN: Arbitrary control structures
begin-structure: Forth200x Structures
benchmarking Forth systems: Performance
Benchres: Performance
bin: General files
bind: Objects Glossary
bind: The OOF base class
bind usage: Class Binding
bind': Objects Glossary
bitwise operation words: Bitwise operations
bl: Displaying characters and strings
blank: Memory Blocks
blk: Input Sources
BLK, altering BLK: block-ambcond
block: Blocks
block buffers: Blocks
block number invalid: block-ambcond
block read not possible: block-ambcond
block transfer, I/O exception: block-ambcond
block words, ambiguous conditions: block-ambcond
block words, implementation-defined options: block-idef
block words, other system documentation: block-other
block words, system documentation: The optional Block word set
block-included: Blocks
block-offset: Blocks
block-position: Blocks
blocks: Blocks
blocks file: Blocks
blocks files, use with Emacs: Blocks Files
blocks in files: file-idef
blocks.fb: Blocks
Boolean flags: Boolean Flags
bootmessage: Modifying the Startup Sequence
bound: The OOF base class
bounds: Memory Blocks
break": Singlestep Debugger
break:: Singlestep Debugger
broken-pipe-error: Pipes
bt: Locating exception source
buffer: Blocks
bug reporting: Bugs
bw: Locating uses of a word
bye: Leaving Gforth
bye during gforthmi: gforthmi

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": Displaying characters and strings
c$+!: String words
c,: Dictionary allocation
c, stack item type: Notation
C, using C for the engine: Portability
c-callback: 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@: Memory Access
call-c: Low-Level C Interface Words
Callback functions written in Forth: Callbacks
calling a definition: Calls and returns
calling C functions: Calling C Functions
case: Arbitrary control structures
case 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: Execution token
cfalign: Dictionary allocation
cfaligned: Address arithmetic
cfield:: Forth200x Structures
changing the compilation word list (during compilation): search-ambcond
char: Displaying characters and strings
char size: core-idef
char%: Structure Glossary
char+: Address arithmetic
character editing of ACCEPT and EXPECT: core-idef
character set: core-idef
character strings - compiling and displaying: Displaying characters and strings
character strings - formats: String Formats
character strings - moving and copying: Memory Blocks
character-aligned address requirements: core-idef
character-set extensions and matching of names: core-idef
characters - compiling and displaying: Displaying characters and strings
characters tutorial: Characters and Strings Tutorial
chars: Address arithmetic
child class: Object-Oriented Terminology
child words: User-defined Defining Words
class: Object-Oriented Terminology
class: Objects Glossary
class: The OOF base class
class: Basic Mini-OOF Usage
class binding: Class Binding
class binding as optimization: Class Binding
class binding, alternative to: Class Binding
class binding, implementation: Objects Implementation
class declaration: Class Declaration
class definition, restrictions: Basic Objects Usage
class definition, restrictions: Basic OOF Usage
class implementation: Class Implementation
class implementation and representation: Objects Implementation
class scoping implementation: Objects Implementation
class usage: Basic Objects Usage
class usage: Basic OOF Usage
class->map: Objects Glossary
class-inst-size: Objects Glossary
class-inst-size discussion: Creating objects
class-override!: Objects Glossary
class-previous: Objects Glossary
class;: Class Declaration
class; usage: Basic OOF Usage
class>order: Objects Glossary
class?: The OOF base class
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
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 address: Threading Words
code coverage: Code Coverage
CODE ending sequence: programming-idef
code field address: Execution token
code field address: 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
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
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 words, ambiguous conditions: core-ambcond
core words, implementation-defined options: core-idef
core words, other system documentation: core-other
core words, system documentation: The Core Words
count: String Formats
counted loops: Counted Loops
counted loops with negative increment: Counted Loops
counted string: String Formats
counted string, maximum size: core-idef
counted strings: String Formats
cputime: Keeping track of Time
cr: Displaying characters and strings
Create: CREATE
CREATE ... DOES>: User-defined Defining Words
CREATE ... DOES>, applications: CREATE..DOES> applications
CREATE ... DOES>, details: CREATE..DOES> details
CREATE and alignment: Address arithmetic
create-file: General files
create...does> tutorial: Defining Words Tutorial
creating objects: Creating objects
cross-compiler: cross.fs
cross-compiler: Cross Compiler
cross.fs: cross.fs
cross.fs: Cross Compiler
CS-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
CT (compilation token): Compilation token
CT, tutorial: Compilation Tokens Tutorial
current: Word Lists
current': Objects Glossary
current-interface: Objects Glossary
current-interface discussion: Objects Implementation
currying: CREATE..DOES> applications
cursor control: Displaying characters and strings
cursor positioning: Terminal output
c_, stack item type: Notation

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<: 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
dabs: Double precision
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
decimal: Number Conversion
declaring C functions: Declaring C Functions
decompilation tutorial: Decompilation Tutorial
default type of locals: Gforth locals
default-color: Terminal output
Defer: Deferred Words
defer: Class Declaration
defer!: Deferred Words
defer@: Deferred Words
deferred words: Deferred Words
defers: Deferred Words
definer: Threading Words
definer!: Threading Words
defines: Basic Mini-OOF Usage
defining defining words: User-defined Defining Words
defining words: Defining Words
defining words tutorial: Defining Words Tutorial
defining words with arbitrary semantics combinations: Combined words
defining words without name: Anonymous Definitions
defining words, name given in a string: Supplying names
defining words, simple: CREATE
defining words, user-defined: User-defined Defining Words
definition: Introducing the Text Interpreter
definitions: Word Lists
definitions: The OOF base class
definitions, tutorial: Colon Definitions Tutorial
delete: String words
delete-file: General files
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
dfloats: Address arithmetic
df_, stack item type: Notation
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
disassembler, general: Common Disassembler
discode: Common Disassembler
dispose: The OOF base class
dividing by zero: core-ambcond
dividing by zero, floating-point: floating-ambcond
Dividing classes: Dividing classes
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: Arbitrary control structures
DO loops: Counted Loops
docol:: Threading Words
docon:: Threading Words
documentation for a word: Locating documentation
dodefer:: Threading Words
dodoes routine: DOES>
does-code!: Threading Words
DOES>: CREATE..DOES> details
DOES> implementation: DOES>
DOES> in a separate definition: CREATE..DOES> details
DOES> in interpretation state: CREATE..DOES> details
DOES> of non-CREATEd words: core-ambcond
does> tutorial: Defining Words Tutorial
DOES>, visibility of current definition: core-idef
does>-code: Threading Words
DOES>-code: DOES>
does>-handler: Threading Words
DOES>-parts, stack effect: User-defined Defining Words
dofield:: Threading Words
DONE: Arbitrary control structures
double precision arithmetic words: Double precision
double words, ambiguous conditions: double-ambcond
double words, system documentation: The optional Double Number word set
double%: Structure Glossary
double-cell numbers, input format: Number Conversion
doubly indirect threaded code: gforthmi
douser:: Threading Words
dovar:: Threading Words
dpl: Number Conversion
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

early: Class Declaration
early binding: Class Binding
edit: Locating source code definitions
edit: Debugging
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?: Single-key input
elements of a Forth system: Review - elements of a Forth system
ELSE: Arbitrary control structures
Emacs and Gforth: Emacs and Gforth
emit: Displaying characters and strings
EMIT and non-graphic characters: core-idef
emit-file: General files
empty-buffer: Blocks
empty-buffers: Blocks
end-c-library: Defining library interfaces
end-class: Objects Glossary
end-class: Basic Mini-OOF Usage
end-class usage: Basic Objects Usage
end-class-noname: Objects Glossary
end-code: 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
endwith: The OOF base class
engine: Engine
engine performance: Performance
engine portability: Portability
engine.s: Produced code
engines, gforth vs. gforth-fast vs. gforth-itc: Direct or Indirect Threaded?
environment variables: Environment variables
environment variables: gforthmi
environment wordset: Notation
environment-wordlist: Environmental Queries
environment?: Environmental Queries
ENVIRONMENT? string length, maximum: core-idef
environmental queries: Environmental Queries
environmental restrictions: 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
etags.fs: Emacs Tags
evaluate: Input Sources
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 tutorial: Exceptions Tutorial
executable image file: Running Image Files
execute: Execution token
execute-parsing: The Input Stream
execute-parsing-file: The Input Stream
executing code on startup: Invoking Gforth
execution frequency: Code Coverage
execution semantics: Interpretation and Compilation Semantics
execution token: Introducing the Text Interpreter
execution token: Execution token
execution token of last defined word: Anonymous Definitions
execution token of words with undefined execution semantics: core-ambcond
execution tokens tutorial: Execution Tokens Tutorial
exercises: Exercises
EXIT: Calls and returns
exit in m: ... ;m: Method conveniences
exitm: Objects Glossary
exitm discussion: Method conveniences
expect: Line input and conversion
EXPECT, display after end of input: core-idef
EXPECT, editing: core-idef
explicit register declarations: Portability
exponent too big for conversion (DF!, DF@, SF!, SF@): floating-ambcond
extended records: Structure Usage

f!: 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.: Simple numeric output
f.rdp: Simple numeric output
f.s: 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<: Floating Point
f<=: Floating Point
f<>: Floating Point
f=: Floating Point
f>: Floating Point
f>=: Floating Point
f>buf-rdp: Formatted numeric output
f>d: Floating Point
F>D, integer part of float cannot be represented by d: floating-ambcond
f>l: Locals implementation
f>s: Floating Point
f>str-rdp: Formatted numeric output
f@: Memory Access
f@ used with an address that is not float aligned: floating-ambcond
f@local#: Locals implementation
fabs: Floating Point
facility words, ambiguous conditions: facility-ambcond
facility words, implementation-defined options: facility-idef
facility words, system documentation: The optional Facility word set
facos: Floating Point
FACOS, |float|>1: floating-ambcond
facosh: Floating Point
FACOSH, float<1: floating-ambcond
factoring: Introduction
factoring similar colon definitions: CREATE..DOES> applications
factoring tutorial: Factoring Tutorial
falign: Dictionary allocation
faligned: Address arithmetic
falog: Floating Point
false: Boolean Flags
fam (file access method): General files
fasin: Floating Point
FASIN, |float|>1: floating-ambcond
fasinh: Floating Point
FASINH, float<0: floating-ambcond
fatan: Floating Point
fatan2: Floating Point
FATAN2, both arguments are equal to zero: floating-ambcond
fatanh: Floating Point
FATANH, |float|>1: floating-ambcond
fconstant: Constants
fcos: Floating Point
fcosh: Floating Point
fdepth: Examining data
FDL, GNU Free Documentation License: GNU Free Documentation License
fdrop: Floating point stack
fdup: Floating point stack
fe.: Simple numeric output
fexp: Floating Point
fexpm1: Floating Point
ffield:: Forth200x Structures
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-handling: General files
file-position: General files
file-size: General files
file-status: General files
FILE-STATUS, returned information: file-idef
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
floating point arithmetic words: Floating Point
floating point numbers, format and range: floating-idef
floating point tutorial: Floating Point Tutorial
floating point unidentified fault, integer division: core-ambcond
floating-point arithmetic, pitfalls: Floating Point
floating-point comparisons: Floating Point
floating-point dividing by zero: floating-ambcond
floating-point numbers, input format: Number Conversion
floating-point numbers, rounding or truncation: floating-idef
floating-point result out of range: floating-ambcond
floating-point stack: Stack Manipulation
floating-point stack in the standard: Stack Manipulation
floating-point stack manipulation words: Floating point stack
floating-point stack size: floating-idef
floating-point stack width: floating-idef
Floating-point unidentified fault: 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: Floating point stack
floats: Address arithmetic
flog: Floating Point
FLOG, float<=0: floating-ambcond
floor: Floating Point
FLOORED: Integer division
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
FOR: Arbitrary control structures
FOR loops: Counted Loops
foreign language interface: C Interface
FORGET, deleting the compilation word list: programming-ambcond
FORGET, name can’t be found: programming-ambcond
FORGET, removing a needed definition: programming-ambcond
forgeting words: Forgetting words
form: Terminal output
format and range of floating point numbers: floating-idef
format of glossary entries: Notation
formatted numeric output: Formatted numeric output
Forth: Word Lists
Forth - an introduction: Introduction
Forth mode in Emacs: Emacs and Gforth
Forth source files: Forth source files
Forth Tutorial: Tutorial
forth-recognize: 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 tutorial: Floating Point Tutorial
fp!: Stack pointer manipulation
fp.: Simple numeric output
fp0: Stack pointer manipulation
fp@: Stack pointer manipulation
fpath: Source Search Paths
fpick: Floating point stack
free: Heap Allocation
frequently asked questions: Forth-related information
frot: Floating point stack
fround: Floating Point
fs.: Simple numeric output
fsin: Floating Point
fsincos: Floating Point
fsinh: Floating Point
fsqrt: Floating Point
FSQRT, float<0: floating-ambcond
fswap: Floating point stack
ftan: Floating Point
FTAN on an argument r1 where cos(r1) is zero: floating-ambcond
ftanh: Floating Point
fthird: Floating point stack
ftuck: Floating point stack
fully relocatable image files: Fully Relocatable Image Files
functions, tutorial: Colon Definitions Tutorial
fvariable: Variables
f_, stack item type: Notation
f~: Floating Point
f~abs: Floating Point
f~rel: Floating Point

g: Locating source code definitions
gdb disassembler: Common Disassembler
general control structures (case): General control structures with CASE
general files: General files
get-block-fid: Blocks
get-current: Word Lists
get-dir: Directories
get-order: Word Lists
get-recognizers: 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, 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

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
help: Locating documentation
here: Dictionary allocation
hex: Number Conversion
hex.: Simple numeric output
highlighting Forth code in Emacs: Hilighting
hilighting Forth code in Emacs: Hilighting
history file: Command-line editing
hold: Formatted numeric output
how:: Class Declaration
hybrid direct/indirect threaded code: Direct or Indirect Threaded?

i: Counted Loops
I/O - blocks: Blocks
I/O - file-handling: Files
I/O - keyboard and display: Other I/O
I/O - see character strings: String Formats
I/O - see input: Line input and conversion
I/O exception in block transfer: block-ambcond
id.: Name token
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
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
included: Forth source files
INCLUDED, I/O exception reading or closing file-id: file-ambcond
INCLUDED, named file cannot be opened: file-ambcond
included?: Forth source files
including files: Forth source files
including files, stack effect: Forth source files
indentation of Forth code in Emacs: Auto-Indentation
indirect threaded inner interpreter: Threading
infile-execute: Redirection
info-color: Terminal output
inheritance: Object-Oriented Terminology
init: The OOF base class
init-asm: Assembler Definitions
init-object: Objects Glossary
init-object discussion: Creating objects
initialization sequence of image file: Modifying the Startup Sequence
inner interpreter implementation: Threading
inner interpreter optimization: Scheduling
inner interpreter, direct threaded: Threading
inner interpreter, indirect threaded: Threading
input buffer: The Text Interpreter
input format for double-cell numbers: Number Conversion
input format for floating-point numbers: Number Conversion
input format for single-cell numbers: Number Conversion
input from pipes: Gforth in pipes
input line size, maximum: file-idef
input line terminator: core-idef
Input Redirection: Redirection
input sources: Input Sources
input stream: The Input Stream
input, linewise from terminal: Line input and conversion
input, single-key: Single-key input
insert: String words
inst-value: Objects Glossary
inst-value usage: Method conveniences
inst-value visibility: Classes and Scoping
inst-var: Objects Glossary
inst-var implementation: Objects Implementation
inst-var usage: Method conveniences
inst-var visibility: Classes and Scoping
instance variables: Object-Oriented Terminology
instruction pointer: Threading
insufficient data stack or return stack space: core-ambcond
insufficient space for loop control parameters: core-ambcond
insufficient space in the dictionary: core-ambcond
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 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
is: The OOF base class
items on the stack after interpretation: Stack depth changes

j: Counted Loops

k: Counted Loops
k-alt-mask: Single-key input
k-ctrl-mask: Single-key input
k-delete: Single-key input
k-down: Single-key input
k-end: Single-key input
k-f1: Single-key input
k-f10: Single-key input
k-f11: Single-key input
k-f12: Single-key input
k-f2: Single-key input
k-f3: Single-key input
k-f4: Single-key input
k-f5: Single-key input
k-f6: Single-key input
k-f7: Single-key input
k-f8: Single-key input
k-f9: Single-key input
k-home: Single-key input
k-insert: Single-key input
k-left: Single-key input
k-next: Single-key input
k-prior: Single-key input
k-right: Single-key input
k-shift-mask: Single-key input
k-up: Single-key input
kern*.fi, relocatability: Fully Relocatable Image Files
key: Single-key input
key-file: General files
key?: Single-key input
key?-file: General files
keyboard events, encoding in EKEY: facility-idef
Kuehling, David: Emacs and Gforth

l: Locating source code definitions
l!: Memory Access
labels as values: Threading
laddr#: Locals implementation
LANG – environment variable: Environment variables
last word was headerless: core-ambcond
late binding: Class Binding
latest: Name token
latestxt: Anonymous Definitions
LC_ALL – environment variable: Environment variables
LC_CTYPE – environment variable: Environment variables
LEAVE: Arbitrary control structures
leaving definitions, tutorial: Leaving definitions or loops Tutorial
leaving Gforth: Leaving Gforth
leaving loops, tutorial: Leaving definitions or loops Tutorial
length of a line affected by \: block-idef
lib-error: Low-Level C Interface Words
lib-sym: Low-Level C Interface Words
Libraries in C interface: Declaring OS-level libraries
library interface names: Defining library interfaces
license: Help on Gforth
license for images: Image Licensing Issues
lifetime of locals: How long do locals live?
line input from terminal: Line input and conversion
line terminator on input: core-idef
link: The OOF base class
list: Blocks
LIST display format: block-idef
list-size: Locals implementation
Literal: Literals
literal tutorial: Literal Tutorial
Literals: Literals
ll: Locating uses of a word
load: Blocks
loader for image files: Image File Background
loading files at startup: Invoking Gforth
loading Forth code, tutorial: Using files for Forth code Tutorial
local in interpretation state: locals-ambcond
local variables, tutorial: Local Variables Tutorial
locale and case-sensitivity: core-idef
locals: Locals
locals and return stack: Return stack
locals flavours: Gforth locals
locals implementation: Locals implementation
locals information on the control-flow stack: Locals implementation
locals lifetime: How long do locals live?
locals programming style: Locals programming style
locals stack: Stack Manipulation
locals stack: Locals implementation
locals types: Gforth locals
locals visibility: Where are locals visible by name?
locals words, ambiguous conditions: locals-ambcond
locals words, implementation-defined options: locals-idef
locals words, system documentation: The optional Locals word set
locals, 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
locate: Debugging
long long: Portability
LOOP: Arbitrary control structures
loop control parameters not available: core-ambcond
loops without count: Simple Loops
loops, counted: Counted Loops
loops, counted, tutorial: Counted loops Tutorial
loops, endless: Simple Loops
loops, indefinite, tutorial: General Loops Tutorial
lp!: Stack pointer manipulation
lp!: Locals implementation
lp+!#: Locals implementation
lp0: Stack pointer manipulation
lp@: Stack pointer manipulation
lrol: Bitwise operations
lror: Bitwise operations
lshift: Bitwise operations
LSHIFT, large shift counts: core-ambcond

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
mapping block ranges to files: file-idef
marker: Forgetting words
max: Single precision
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
memory access words: Memory Access
memory access/allocation tutorial: Memory Tutorial
memory alignment tutorial: Alignment Tutorial
memory block words: Memory Blocks
memory overcommit for dictionary and stacks: Invoking Gforth
memory words: Memory
memory-allocation word set: Heap Allocation
memory-allocation words, implementation-defined options: memory-idef
memory-allocation words, system documentation: The optional Memory-Allocation word set
message send: Object-Oriented Terminology
metacompiler: cross.fs
metacompiler: Cross Compiler
method: Object-Oriented Terminology
method: Objects Glossary
method: Class Declaration
method: Basic Mini-OOF Usage
method conveniences: Method conveniences
method map: Objects Implementation
method selector: Object-Oriented Terminology
method usage: Basic OOF Usage
methods: Objects Glossary
methods...end-methods: Dividing classes
min: Single precision
mini-oof: Mini-OOF
mini-oof example: Mini-OOF Example
mini-oof usage: Basic Mini-OOF Usage
mini-oof.fs, differences to other models: Comparison with other object models
minimum search order: search-idef
miscellaneous words: Miscellaneous Words
mixed precision arithmetic words: Mixed precision
mkdir-parents: Directories
mod: Integer division
modf: Integer division
modf-stage2m: Two-stage integer division
modifying >IN: How does that work?
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

n: Locating source code definitions
n, stack item type: Notation
naligned: Structure Glossary
name: The Input Stream
name dictionary: Introducing the Text Interpreter
name field address: Name token
name lookup, case-sensitivity: core-idef
name not defined by VALUE or (LOCAL) used by TO: locals-ambcond
name not defined by VALUE used by TO: core-ambcond
name not found: core-ambcond
name not found (', POSTPONE, ['], [COMPILE]): core-ambcond
name token: Name token
name, maximum length: core-idef
name>comp: Name token
name>compile: Name token
name>int: Name token
name>interpret: Name token
name>string: Name token
name?int: Name token
names for defined words: Supplying names
needs: Forth source files
negate: Single precision
negative increment for counted loops: Counted Loops
Neon model: Comparison with other object models
nested colon definitions: Quotations
new: The OOF base class
new: Basic Mini-OOF Usage
newline character on input: core-idef
new[]: The OOF base class
NEXT: Arbitrary control structures
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
non-graphic characters and EMIT: core-idef
non-relocatable image files: Non-Relocatable Image Files
noname: Anonymous Definitions
notation of glossary entries: Notation
notfound: Recognizers
nothrow: Exception Handling
nt: Locating exception source
NT Forth performance: Performance
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
nw: Locating uses of a word

object: Object-Oriented Terminology
object: Objects Glossary
object: Basic Mini-OOF Usage
object allocation options: Creating objects
object class: The Objects base class
object creation: Creating objects
object interfaces: Object Interfaces
object models, comparison: Comparison with other object models
object-map discussion: Objects Implementation
object-oriented programming: Objects
object-oriented programming: OOF
object-oriented programming motivation: Why object-oriented programming?
object-oriented programming style: Object-Oriented Programming Style
object-oriented terminology: Object-Oriented Terminology
objects: Objects
objects, basic usage: Basic Objects Usage
objects.fs: Objects
objects.fs: OOF
objects.fs Glossary: Objects Glossary
objects.fs implementation: Objects Implementation
objects.fs properties: Properties of the Objects model
of: Arbitrary control structures
off: Boolean Flags
on: Boolean Flags
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
options on the command line: Invoking Gforth
or: Bitwise operations
order: Word Lists
orig, control-flow stack item: Arbitrary control structures
OS command line arguments: OS command line arguments
os-class: Environmental Queries
other system documentation, block words: block-other
other system documentation, core words: core-other
outer interpreter: Introducing the Text Interpreter
outer interpreter: Stacks and Postfix notation
outer interpreter: The Text Interpreter
outfile-execute: Redirection
output in pipes: Gforth in pipes
Output Redirection: Redirection
output to terminal: Terminal output
over: Data stack
overcommit memory for dictionary and stacks: Invoking Gforth
overflow of the pictured numeric output string: core-ambcond
overrides: Objects Glossary
overrides usage: Basic Objects Usage

pad: Memory Blocks
PAD size: core-idef
PAD use by nonstandard words: core-other
page: Terminal output
parameter stack: Stack Manipulation
parameters are not of the same type (DO, ?DO, WITHIN): core-ambcond
parent class: Object-Oriented Terminology
parent class binding: Class Binding
parse: The Input Stream
parse area: The Text Interpreter
parse-name: The Input Stream
parse-word: The Input Stream
parsed string overflow: core-ambcond
parsed string, maximum size: core-idef
parsing words: How does that work?
parsing words: How does that work?
parsing words: The Text Interpreter
patching threaded code: Dynamic Superinstructions
path for included: Search Paths
path+: General Search Paths
path=: General Search Paths
pedigree of Gforth: Origin
perform: Execution token
performance of some Forth interpreters: Performance
persistent form of dictionary: Image Files
PFE performance: Performance
pi: Floating Point
pick: Data stack
pictured numeric output: Formatted numeric output
pictured numeric output buffer, size: core-idef
pictured numeric output string, overflow: core-ambcond
pipes, creating your own: Pipes
pipes, Gforth as part of: Gforth in pipes
postpone: Macros
postpone: The OOF base class
POSTPONE applied to [IF]: programming-ambcond
POSTPONE or [COMPILE] applied to TO: core-ambcond
postpone tutorial: POSTPONE Tutorial
postpone,: Compilation token
Pountain’s object-oriented model: Comparison with other object models
precision: Simple numeric output
precompiled Forth code: Image Files
previous: Word Lists
previous, search order empty: search-ambcond
primitive source format: Automatic Generation
primitive-centric threaded code: Direct or Indirect Threaded?
primitives, assembly code listing: Produced code
primitives, automatic generation: Automatic Generation
primitives, implementation: Primitives
primitives, keeping the TOS in a register: TOS Optimization
prims2x.fs: Automatic Generation
print: Objects Glossary
printdebugdata: Debugging
private discussion: Classes and Scoping
procedures, tutorial: Colon Definitions Tutorial
program data space available: core-other
programming style, arbitrary control structures: Arbitrary control structures
programming style, locals: Locals programming style
programming style, object-oriented: Object-Oriented Programming Style
programming tools: Programming Tools
programming-tools words, ambiguous conditions: programming-ambcond
programming-tools words, implementation-defined options: programming-idef
programming-tools words, system documentation: The optional Programming-Tools word set
prompt: core-idef
pronounciation of words: Notation
protected: Objects Glossary
protected discussion: Classes and Scoping
pthread: Pthreads
pthread_cond_broadcast: Pthreads
pthread_cond_signal: Pthreads
pthread_cond_timedwait: Pthreads
pthread_cond_wait: Pthreads
ptr: The OOF base class
ptr: Class Declaration
public: Objects Glossary

query: Input Sources
quit: Miscellaneous Words
quotations: Quotations

r, stack item type: Notation
r/o: General files
r/w: General files
r>: Return stack
r@: Return stack
ranges for integer types: core-idef
rdrop: Return stack
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: Recognizers
rec-dtick: Recognizers
rec-float: Recognizers
rec-nt: Recognizers
rec-num: Recognizers
rec-sequence:: Recognizers
rec-string: Recognizers
rec-tick: Recognizers
rec-to: Recognizers
receiving object: Object-Oriented Terminology
reciprocal of integer: Two-stage integer division
recognize: 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
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
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: Formatted numeric output
REPRESENT, results when float is out of range: floating-idef
require: Forth source files
require, placement in files: Emacs Tags
required: Forth source files
reserving data space: Dictionary allocation
resize: Heap Allocation
resize-file: General files
restore: Exception Handling
restore-input: Input Sources
RESTORE-INPUT, Argument type mismatch: core-ambcond
restrict: Interpretation and Compilation Semantics
Result out of range: 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
returning from a definition: Calls and returns
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": Displaying characters and strings
S", number of string buffers: file-idef
S", size of string buffer: file-idef
s>d: Double precision
s>f: Floating Point
s>number?: Line input and conversion
s>unumber?: Line input and conversion
save-buffer: Blocks
save-buffers: Blocks
save-input: Input Sources
savesystem: Non-Relocatable Image Files
savesystem during gforthmi: gforthmi
scope: Where are locals visible by name?
scope of locals: Where are locals visible by name?
scoping and classes: Classes and Scoping
scr: Blocks
seal: Word Lists
search: Memory Blocks
search order stack: Word Lists
search order, maximum depth: search-idef
search order, minimum: search-idef
search order, tutorial: Wordlists and Search Order Tutorial
search path control, source files: Source Search Paths
search path control, source files: General Search Paths
search path for files: Search Paths
search-order words, ambiguous conditions: search-ambcond
search-order words, implementation-defined options: search-idef
search-order words, system documentation: The optional Search-Order word set
search-wordlist: Word Lists
see: Examining 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: Object-Oriented Terminology
selector: Objects Glossary
selector implementation, class: Objects Implementation
selector invocation: Object-Oriented Terminology
selector invocation, restrictions: Basic Objects Usage
selector invocation, restrictions: Basic OOF Usage
selector usage: Basic Objects Usage
selectors and stack effects: Object-Oriented Programming Style
selectors common to hardly-related classes: Object Interfaces
self: The OOF base class
semantics tutorial: Interpretation and Compilation Semantics and Immediacy Tutorial
semantics, interpretation and compilation: Interpretation and Compilation Semantics
set-current: Word Lists
set-dir: Directories
set-order: Word Lists
set-precision: Simple numeric output
set-recognizers: Recognizers
sf!: Memory Access
sf@: Memory Access
sf@ or sf! used with an address that is not single-float aligned: floating-ambcond
sfalign: Dictionary allocation
sfaligned: Address arithmetic
sffield:: Forth200x Structures
sfloat%: Structure Glossary
sfloat+: Address arithmetic
sfloats: Address arithmetic
sf_, stack item type: Notation
sh: Passing Commands to the OS
Shared libraries in C interface: Declaring OS-level libraries
shell commands: Passing Commands to the OS
shift-args: OS command line arguments
sign: Formatted numeric output
silent exiting from Gforth: Gforth in pipes
simple defining words: CREATE
simple loops: Simple Loops
simple-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: Number Conversion
single-key input: Single-key input
singlestep Debugger: Singlestep Debugger
size of buffer at WORD: core-idef
size of the dictionary and the stacks: Invoking Gforth
size of the keyboard terminal buffer: core-idef
size of the pictured numeric output buffer: core-idef
size of the scratch area returned by PAD: core-idef
size parameters for command-line options: Invoking Gforth
sl@: Memory Access
SLiteral: Literals
slurp-fid: General files
slurp-file: General files
sm/rem: 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: Displaying characters and strings
space delimiters: core-idef
spaces: Displaying characters and strings
span: Line input and conversion
speed, startup: Startup speed
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
stack effect of included files: Forth source files
stack effects of selectors: Object-Oriented Programming Style
stack empty: core-ambcond
stack item types: Notation
stack manipulation tutorial: Stack Manipulation Tutorial
stack manipulation words: Stack Manipulation
stack manipulation words, floating-point stack: Floating point stack
stack manipulation words, return stack: Return stack
stack manipulations words, data stack: Data stack
stack overflow: core-ambcond
stack pointer manipulation words: Stack pointer manipulation
stack size default: Stack and Dictionary Sizes
stack size, cache-friendly: Stack and Dictionary Sizes
stack space available: core-other
stack tutorial: Stack Tutorial
stack underflow: core-ambcond
stack-effect comments, tutorial: Stack-Effect Comments Tutorial
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
stderr: General files
stderr and pipes: Gforth in pipes
stdin: General files
stdout: General files
str<: Memory Blocks
str=: Memory Blocks
string larger than pictured numeric output area (f., fe., fs.): floating-ambcond
string longer than a counted string returned by WORD: core-ambcond
string words: String words
string-prefix?: Memory Blocks
strings - see character strings: String Formats
strings tutorial: Characters and Strings Tutorial
struct: Structure Glossary
struct usage: Structure Usage
structs tutorial: Arrays and Records Tutorial
structure extension: Structure Usage
structure glossary: Structure Glossary
structure implementation: Structure Implementation
structure naming convention: Structure Naming Convention
structure naming convention: Structure Naming Convention
structure of Forth programs: Forth is written in Forth
structure usage: Structure Usage
structures: Structures
structures containing arrays: Structure Usage
structures containing structures: Structure Usage
Structures in Forth200x: Forth200x Structures
structures using address arithmetic: Why explicit structure support?
sub-list?: Locals implementation
success-color: Terminal output
super: The OOF base class
superclass binding: Class Binding
Superinstructions: Dynamic Superinstructions
sw@: Memory Access
swap: Data stack
symmetric division: Integer division
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\": Displaying characters and strings

table: Word Lists
TAGS file: Emacs Tags
target compiler: cross.fs
target compiler: Cross Compiler
terminal buffer, size: core-idef
terminal input buffer: The Text Interpreter
terminal output: Terminal output
terminal size: Terminal output
terminology for object-oriented programming: Object-Oriented Terminology
text interpreter: Introducing the Text Interpreter
text interpreter: Stacks and Postfix notation
text interpreter: The Text Interpreter
text interpreter - effect of state: How does that work?
text interpreter - input sources: The Text Interpreter
text interpreter - input sources: Input Sources
THEN: Arbitrary control structures
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-this: Objects Glossary
tokens for words: Tokens for Words
TOS definition: Stacks and Postfix notation
TOS optimization for primitives: TOS Optimization
toupper: Displaying characters and strings
trigonometric operations: Floating Point
true: Boolean Flags
truncation of floating-point numbers: floating-idef
try: Exception Handling
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*/: Integer division
u*/mod: Integer division
U+DO: Arbitrary control structures
u, stack item type: Notation
U-DO: Arbitrary control structures
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
ud, stack item type: Notation
ud.: Simple numeric output
ud.r: Simple numeric output
ud/mod: Integer division
ul@: Memory Access
um*: Mixed precision
um/mod: Integer division
umax: Single precision
umin: Single precision
umod: Integer division
umod-stage2m: Two-stage integer division
undefined word: core-ambcond
undefined word, ', POSTPONE, ['], [COMPILE]: core-ambcond
under+: Single precision
unexpected end of the input buffer: core-ambcond
unloop: Arbitrary control structures
unmapped block numbers: file-ambcond
UNREACHABLE: Where are locals visible by name?
UNTIL: Arbitrary control structures
UNTIL loop: Simple Loops
unused: Dictionary allocation
unwind-protect: Exception Handling
update: Blocks
UPDATE, no current block buffer: block-ambcond
updated?: Blocks
upper and lower case: Case insensitivity
use: Blocks
User: Variables
user input device, method of selecting: core-idef
user output device, method of selecting: core-idef
user space: Variables
user variables: Variables
user-defined defining words: User-defined Defining Words
Uses of a word: Locating uses of a word
utime: Keeping track of Time
UValue: Pthreads
uw@: Memory Access

Value: Values
value-flavoured locals: Gforth locals
values: Values
var: Class Declaration
var: Basic Mini-OOF Usage
Variable: Variables
variable-flavoured locals: Gforth locals
variables: Variables
variadic C functions: Declaring C Functions
versions, invoking other versions of Gforth: Invoking Gforth
view: Debugging
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

w!: Memory Access
w, stack item type: Notation
w/o: General files
WARNING": Exception Handling
warning-color: Terminal output
warnings: Exception Handling
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
Win32Forth performance: Performance
wior type description: Notation
wior values and meaning: file-idef
with: The OOF base class
within: Numeric comparison
word: Introducing the Text Interpreter
word: The Input Stream
WORD buffer size: core-idef
word glossary entry format: Notation
word list for defining locals: Locals implementation
word lists: Word Lists
word lists - example: Word list example
word lists - why use them?: Why use word lists?
word name too long: core-ambcond
WORD, string overflow: core-ambcond
wordlist: Word Lists
wordlists tutorial: Wordlists and Search Order Tutorial
words: Words
words: Word Lists
words used in your program: Standard Report
words, forgetting: Forgetting words
wordset: Notation
write-file: General files
write-line: General files
wrol: Bitwise operations
wror: Bitwise operations
WTF??: Debugging
ww: Locating uses of a word

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

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

Jump to:   !   "   #   $   %   &   '   (   )   *   +   ,   -   .   /   0   1   2   :   ;   <   =   >   ?   @   [   \   ]   {   ~  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  

Previous: Word Index, Up: Gforth   [Contents][Index]