Concept Index - Gforth Manual

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).

!: Memory Access
", stack item type: Notation
#: Formatted numeric output
#!: Running Image Files
#-prefix for decimal numbers: Number Conversion
#>: Formatted numeric output
#>>: Formatted numeric output
#s: Formatted numeric output
#tib: The Text Interpreter
$-prefix for hexadecimal numbers: Number Conversion
$?: Passing Commands to the OS
%-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
': The OOF base class
': Execution token
'-prefix for character strings: Number Conversion
'cold: Modifying the Startup Sequence
(: Comments
(local): ANS Forth locals
): Assertions
*: Single precision
*/: Mixed precision
*/mod: Mixed precision
+: Single precision
+!: Memory Access
+DO: Arbitrary control structures
+field: Forth200x Structures
+load: Blocks
+LOOP: Arbitrary control structures
+thru: Blocks
+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
-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
.\": Displaying characters and strings
.debugline: Debugging
.emacs: Installing gforth.el
.fi files: Image Files
.gforth-history: Command-line editing
.id: Name token
.name: Name token
.path: General Search Paths
.r: Simple numeric output
.s: Examining
/: Single precision
/does-handler: Threading Words
/l: Address arithmetic
/mod: Single precision
/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
:: The OOF base class
:: Colon Definitions
:, passing data across: Literals
::: Basic Mini-OOF Usage
::: The OOF base class
:m: Objects Glossary
:noname: Anonymous Definitions
;: Colon Definitions
;code: Code and ;code
;CODE ending sequence: programming-idef
;CODE, name not defined via CREATE: programming-ambcond
;CODE, processing input: programming-idef
;m: Objects Glossary
;m usage: Method conveniences
;s: Calls and returns
<: Numeric comparison
<#: Formatted numeric output
<<#: Formatted numeric output
<=: Numeric comparison
<>: Numeric comparison
<bind>: Objects Glossary
<compilation: Combined words
<interpretation: Combined words
<to-inst>: Objects Glossary
=: Numeric comparison
>: Numeric comparison
>=: Numeric comparison
>body: CREATE..DOES> details
>BODY of non-CREATEd words: core-ambcond
>code-address: Threading Words
>definer: Threading Words
>does-code: Threading Words
>float: Line input and conversion
>in: The Text Interpreter
>IN greater than input buffer: core-ambcond
>l: Locals implementation
>name: Name token
>number: Line input and conversion
>order: Word Lists
>r: Return stack
?: Examining
?DO: Arbitrary control structures
?dup: Data stack
?DUP-0=-IF: Arbitrary control structures
?DUP-IF: Arbitrary control structures
?LEAVE: Arbitrary control structures
@: Memory Access
@local#: Locals implementation
[: Literals
[']: Execution token
[+LOOP]: Interpreter Directives
[?DO]: Interpreter Directives
[]: The OOF base class
[AGAIN]: Interpreter Directives
[BEGIN]: Interpreter Directives
[bind]: Objects Glossary
[bind] usage: Class Binding
[Char]: Displaying characters and strings
[COMP']: Compilation token
[compile]: Macros
[current]: Objects Glossary
[DO]: Interpreter Directives
[ELSE]: Interpreter Directives
[ENDIF]: Interpreter Directives
[FOR]: Interpreter Directives
[IF]: Interpreter Directives
[IF] and POSTPONE: programming-ambcond
[IF], end of the input source before matching [ELSE] or [THEN]: programming-ambcond
[IFDEF]: Interpreter Directives
[IFUNDEF]: Interpreter Directives
[LOOP]: Interpreter Directives
[NEXT]: Interpreter Directives
[parent]: Objects Glossary
[parent] usage: Class Binding
[REPEAT]: Interpreter Directives
[THEN]: Interpreter Directives
[to-inst]: Objects Glossary
[UNTIL]: Interpreter Directives
[WHILE]: Interpreter Directives
\: Comments
\, editing with Emacs: Emacs and Gforth
\, line length in blocks: block-idef
\c: Declaring C Functions
\G: Comments
]: Literals
]L: Literals
a_, stack item type: Notation
abort: Exception Handling
ABORT": Exception Handling
ABORT", exception abort sequence: core-idef
abs: Single precision
abstract class: Basic OOF Usage
abstract class: Basic Objects Usage
accept: Line input and conversion
ACCEPT, display after end of input: core-idef
ACCEPT, editing: core-idef
action-of: Deferred Words
add-lib: Declaring OS-level libraries
address alignment exception: core-ambcond
address alignment exception, stack overflow: core-ambcond
address arithmetic for structures: Why explicit structure support?
address arithmetic restrictions, ANS vs. Gforth: Memory model
address arithmetic words: Address arithmetic
address of counted string: String Formats
address unit: Address arithmetic
address unit, size in bits: core-idef
ADDRESS-UNIT-BITS: Address arithmetic
AGAIN: Arbitrary control structures
AHEAD: Arbitrary control structures
Alias: Aliases
aliases: Aliases
align: Dictionary allocation
aligned: Address arithmetic
aligned addresses: core-idef
alignment faults: core-ambcond
alignment of addresses for types: Address arithmetic
alignment tutorial: Alignment Tutorial
allocate: Heap Allocation
allot: Dictionary allocation
also: Word Lists
also, 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 conformance of Gforth: ANS conformance
ans-report.fs: ANS Report
arg: OS command line arguments
argc: OS command line arguments
argument input source different than current input source for RESTORE-INPUT: core-ambcond
argument type mismatch: core-ambcond
argument type mismatch, RESTORE-INPUT: core-ambcond
arguments, OS command line: OS command line arguments
argv: OS command line arguments
arithmetic words: Arithmetic
arithmetics tutorial: Arithmetics Tutorial
arrays: CREATE
arrays tutorial: Arrays and Records Tutorial
asptr: Class Declaration
asptr: The OOF base class
assembler: Code and ;code
assembler: Assembler and Code Words
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
au (address unit): Address arithmetic
authors of Gforth: Origin
auto-indentation of Forth code in Emacs: Auto-Indentation
backtrace: Error messages
backtraces with gforth-fast: Error messages
base: Number Conversion
base is not decimal (REPRESENT, F., FE., FS.): floating-ambcond
base-execute: Number Conversion
basic objects usage: Basic Objects Usage
batch processing with Gforth: Invoking Gforth
BEGIN: Arbitrary control structures
begin-structure: Forth200x Structures
benchmarking Forth systems: Performance
Benchres: Performance
bin: General files
bind: The OOF base class
bind: Objects Glossary
bind usage: Class Binding
bind': Objects Glossary
bitwise operation words: Bitwise operations
bl: Displaying characters and strings
blank: Memory Blocks
blk: Input Sources
BLK, altering BLK: block-ambcond
block: Blocks
block buffers: Blocks
block number invalid: block-ambcond
block read not possible: block-ambcond
block transfer, I/O exception: block-ambcond
block words, ambiguous conditions: block-ambcond
block words, implementation-defined options: block-idef
block words, other system documentation: block-other
block words, system documentation: The optional Block word set
block-included: Blocks
block-offset: Blocks
block-position: Blocks
blocks: Blocks
blocks file: Blocks
blocks files, use with Emacs: Blocks Files
blocks in files: file-idef
blocks.fb: Blocks
Boolean flags: Boolean Flags
bootmessage: Modifying the Startup Sequence
bound: The OOF base class
bounds: Memory Blocks
break": Singlestep Debugger
break:: Singlestep Debugger
broken-pipe-error: Pipes
buffer: Blocks
bug reporting: Bugs
bye: Leaving Gforth
bye during gforthmi: gforthmi
C 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,: Dictionary allocation
c, stack item type: Notation
C, using C for the engine: Portability
c-function: Declaring C Functions
c-library: Defining library interfaces
c-library-name: Defining library interfaces
c@: Memory Access
c_, stack item type: Notation
call-c: Low-Level C Interface Words
Callback functions written in Forth: Callbacks
calling a definition: Calls and returns
calling C functions: Calling C Functions
case: Arbitrary control structures
CASE control structure: Selection
case sensitivity: Case insensitivity
case-sensitivity characteristics: core-idef
case-sensitivity for name lookup: core-idef
catch: Exception Handling
catch and backtraces: Error messages
catch and this: Objects Implementation
catch in m: ... ;m: Method conveniences
cell: Address arithmetic
cell size: core-idef
cell%: Structure Glossary
cell+: Address arithmetic
cell-aligned addresses: core-idef
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: Basic Mini-OOF Usage
class: The OOF base class
class: Objects Glossary
class: Object-Oriented Terminology
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 OOF Usage
class definition, restrictions: Basic Objects Usage
class implementation: Class Implementation
class implementation and representation: Objects Implementation
class scoping implementation: Objects Implementation
class usage: Basic OOF Usage
class usage: Basic Objects 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
clearstacks: Examining
clock tick duration: facility-idef
close-file: General files
close-pipe: Pipes
cmove: Memory Blocks
cmove>: Memory Blocks
code: Code and ;code
code address: Threading Words
CODE ending sequence: programming-idef
code examination: Examining
code field address: Threading Words
code field address: Execution token
code words: Assembler and Code Words
code words, portable: Code and ;code
CODE, processing input: programming-idef
code-address!: Threading Words
colon definitions: Anonymous Definitions
colon definitions: Colon Definitions
colon definitions, tutorial: Colon Definitions Tutorial
colon-sys, passing data across :: Literals
combined words: Combined words
command line arguments, OS: OS command line arguments
command-line editing: Command-line editing
command-line options: Invoking Gforth
comment editing commands: Emacs and Gforth
comments: Comments
comments tutorial: Comments Tutorial
common-list: Locals implementation
COMP': 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: Interpretation and Compilation Semantics
compilation semantics: How does that work?
compilation semantics tutorial: Interpretation and Compilation Semantics and Immediacy Tutorial
compilation token: Compilation token
compilation tokens, tutorial: Compilation Tokens Tutorial
compilation word list: Word Lists
compilation word list, change before definition ends: search-ambcond
compilation>: Combined words
compile state: The Text Interpreter
compile,: Macros
compile-lp+!: Locals implementation
compile-only: Interpretation and Compilation Semantics
compile-only words: Interpretation and Compilation Semantics
compiling compilation semantics: Macros
compiling words: Compiling words
conditional compilation: Interpreter Directives
conditionals, tutorial: Conditional execution Tutorial
const-does>: Const-does>
Constant: Constants
constants: Constants
construct: Objects Glossary
construct discussion: Creating objects
context: Word Lists
context-sensitive help: Emacs and Gforth
contiguous regions and address arithmetic: Address arithmetic
contiguous regions and heap allocation: Heap Allocation
contiguous regions in dictionary allocation: Dictionary allocation
contiguous regions, ANS vs. Gforth: Memory model
contributors to Gforth: Origin
control characters as delimiters: core-idef
control structures: Control Structures
control structures for selection: Selection
control structures programming style: Arbitrary control structures
control structures, user-defined: Arbitrary control structures
control-flow stack: Arbitrary control structures
control-flow stack items, locals information: Locals implementation
control-flow stack underflow: programming-ambcond
control-flow stack, format: core-idef
convert: Line input and conversion
convertin strings to numbers: Line input and conversion
core words, ambiguous conditions: core-ambcond
core words, implementation-defined options: core-idef
core words, other system documentation: core-other
core words, system documentation: The Core Words
count: String Formats
counted loops: Counted Loops
counted loops with negative increment: Counted Loops
counted string: String Formats
counted string, maximum size: core-idef
counted strings: String Formats
cputime: Keeping track of Time
cr: Displaying characters and strings
Create: CREATE
CREATE ... DOES>: User-defined Defining Words
CREATE ... DOES>, applications: CREATE..DOES> applications
CREATE ... DOES>, details: CREATE..DOES> details
CREATE and alignment: Address arithmetic
create-file: General files
create-interpret/compile: Combined words
create...does> tutorial: Defining Words Tutorial
creating objects: Creating objects
cross-compiler: Cross Compiler
cross-compiler: cross.fs
cross.fs: Cross Compiler
cross.fs: cross.fs
CS-PICK: Arbitrary control structures
CS-PICK, fewer than u+1 items on the control flow-stack: programming-ambcond
CS-ROLL: Arbitrary control structures
CS-ROLL, fewer than u+1 items on the control flow-stack: programming-ambcond
CT (compilation token): Compilation token
CT, tutorial: Compilation Tokens Tutorial
current: Word Lists
current': 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
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
data examination: Examining
data space - reserving some: Dictionary allocation
data space available: core-other
data space containing definitions gets de-allocated: core-ambcond
data space pointer not properly aligned, ,, C,: core-ambcond
data space read/write with incorrect alignment: core-ambcond
data stack: Stack Manipulation
data stack manipulation words: Data stack
data-relocatable image files: Data-Relocatable Image Files
data-space, read-only regions: core-idef
dbg: Singlestep Debugger
debug tracer editing commands: Emacs and Gforth
debugging: Debugging
debugging output, finding the source location in Emacs: Emacs and Gforth
debugging Singlestep: Singlestep Debugger
dec.: Simple numeric output
decimal: Number Conversion
declaring C functions: Declaring C Functions
decompilation tutorial: Decompilation Tutorial
default type of locals: Gforth locals
defer: Class Declaration
Defer: Deferred Words
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: The OOF base class
definitions: Word Lists
definitions, tutorial: Colon Definitions Tutorial
delete-file: General files
depth: Examining
depth changes during interpretation: Stack depth changes
depth-changes.fs: Stack depth changes
design of stack effects, tutorial: Designing the stack effect Tutorial
dest, control-flow stack item: Arbitrary control structures
df!: Memory Access
df@: Memory Access
df@ or df! used with an address that is not double-float aligned: floating-ambcond
df_, stack item type: Notation
dfalign: Dictionary allocation
dfaligned: Address arithmetic
dffield:: Forth200x Structures
dfloat%: Structure Glossary
dfloat+: Address arithmetic
dfloats: Address arithmetic
dict-new: Objects Glossary
dict-new discussion: Creating objects
dictionary: The Text Interpreter
dictionary in persistent form: Image Files
dictionary overflow: core-ambcond
dictionary size default: Stack and Dictionary Sizes
digits > 35: core-idef
direct threaded inner interpreter: Threading
disassembler, general: Common Disassembler
discode: Common Disassembler
dispose: The OOF base class
dividing by zero: core-ambcond
dividing by zero, floating-point: floating-ambcond
Dividing classes: Dividing classes
division rounding: core-idef
division with potentially negative operands: Arithmetic
dmax: Double precision
dmin: Double precision
dnegate: Double precision
DO: Arbitrary control structures
DO loops: Counted Loops
docol:: Threading Words
docon:: Threading Words
dodefer:: Threading Words
dodoes routine: DOES>
does-code!: Threading Words
does-handler!: Threading Words
DOES>: CREATE..DOES> details
DOES> implementation: DOES>
DOES> in a separate definition: CREATE..DOES> details
DOES> in interpretation state: CREATE..DOES> details
DOES> of non-CREATEd words: core-ambcond