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).
| 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 |
| */: | | Mixed precision |
| */mod: | | Mixed precision |
|
| + | | |
|---|
| +: | | Single precision |
| +!: | | Memory Access |
| +!@: | | Pthreads |
| +DO: | | Arbitrary control structures |
| +field: | | Forth200x Structures |
| +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 |
| .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 |
| .\": | | Displaying characters and strings |
|
| / | | |
|---|
| /: | | Single precision |
| /does-handler: | | Threading Words |
| /l: | | Address arithmetic |
| /mod: | | Single precision |
| /string: | | Memory Blocks |
| /w: | | Address arithmetic |
|
| 0 | | |
|---|
| 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 | | |
|---|
| 1+: | | Single precision |
| 1-: | | Single precision |
| 1/f: | | Floating Point |
|
| 2 | | |
|---|
| 2!: | | Memory Access |
| 2*: | | Bitwise operations |
| 2,: | | Dictionary allocation |
| 2/: | | Bitwise operations |
| 2>r: | | Return stack |
| 2@: | | Memory Access |
| 2Constant: | | Constants |
| 2drop: | | Data stack |
| 2dup: | | Data stack |
| 2field:: | | Forth200x Structures |
| 2Literal: | | Literals |
| 2nip: | | Data stack |
| 2over: | | Data stack |
| 2r>: | | Return stack |
| 2r@: | | Return stack |
| 2rdrop: | | Return stack |
| 2rot: | | Data stack |
| 2swap: | | Data stack |
| 2tuck: | | Data stack |
| 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 |
|
| ; | | |
|---|
| ;: | | Colon Definitions |
| ;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 |
| <event: | | Pthreads |
| <to-inst>: | | Objects Glossary |
|
| = | | |
|---|
| =: | | Numeric comparison |
| =mkdir: | | Directories |
|
| > | | |
|---|
| >: | | 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 |
| >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 |
| ?!@: | | Pthreads |
| ???: | | Debugging |
| ?DO: | | Arbitrary control structures |
| ?dup: | | Data stack |
| ?DUP-0=-IF: | | Arbitrary control structures |
| ?dup-IF: | | Arbitrary control structures |
| ?events: | | Pthreads |
| ?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 |
| [[: | | Macros |
| []: | | The OOF base class |
|
| \ | | |
|---|
| \: | | Comments |
| \, editing with Emacs: | | Emacs and Gforth |
| \, line length in blocks: | | block-idef |
| \c: | | Declaring C Functions |
| \G: | | Comments |
|
| ] | | |
|---|
| ]: | | Literals |
| ]L: | | Literals |
| ]]: | | Macros |
| ]]2L: | | Macros |
| ]]FL: | | Macros |
| ]]L: | | Macros |
| ]]SL: | | Macros |
|
| ~ | | |
|---|
| ~~: | | Debugging |
| ~~, removal with Emacs: | | Emacs and Gforth |
| ~~1bt: | | Debugging |
| ~~bt: | | Debugging |
| ~~Value: | | Debugging |
| ~~Variable: | | Debugging |
|
| A | | |
|---|
| 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 |
| activate: | | Pthreads |
| add-lib: | | 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 |
| 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 |
| 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 |
| au (address unit): | | Address arithmetic |
| authors of Gforth: | | Origin |
| auto-indentation of Forth code in Emacs: | | Auto-Indentation |
| a_, stack item type: | | Notation |
|
| B | | |
|---|
| backtrace: | | Error messages |
| 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 |
| 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 |
| buffer: | | Blocks |
| bug reporting: | | Bugs |
| bye: | | Leaving Gforth |
| bye during gforthmi: | | gforthmi |
|
| C | | |
|---|
| C function pointers to Forth words: | | Callbacks |
| C function pointers, calling from Forth: | | Calling C function pointers |
| C functions, calls to: | | Calling C Functions |
| C functions, declarations: | | Declaring C Functions |
| C interface: | | C Interface |
| c!: | | Memory Access |
| C": | | 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-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: | | 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 |
| clearstacks: | | Examining |
| clock tick duration: | | facility-idef |
| close-dir: | | Directories |
| close-file: | | General files |
| close-pipe: | | Pipes |
| cmove: | | Memory Blocks |
| cmove>: | | Memory Blocks |
| code: | | Assembler Definitions |
| code address: | | Threading Words |
| code address: | | Threading Words |
| CODE ending sequence: | | programming-idef |
| code examination: | | Examining |
| 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 |
| compiling compilation semantics: | | Macros |
| compiling words: | | Compiling words |
| cond: | | Pthreads |
| 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 |
| critical-section: | | Pthreads |
| cross-compiler: | | cross.fs |
| cross-compiler: | | Cross Compiler |
| cross.fs: | | cross.fs |
| cross.fs: | | Cross Compiler |
| 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 | | |
|---|
| 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 |
| 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 |
| 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 |
| 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 |
| 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>: | | 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 |
| drop: | | Data stack |
| du<: | | Numeric comparison |
| du<=: | | Numeric comparison |
| du>: | | Numeric comparison |
| du>=: | | Numeric comparison |
| dump: | | Examining |
| 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 |
|
| E | | |
|---|
| e$,: | | Pthreads |
| early: | | Class Declaration |
| early binding: | | Class Binding |
| edit: | | Debugging |
| edit-line: | | Line input and conversion |
| editing in ACCEPT and EXPECT: | | core-idef |
| eflit,: | | Pthreads |
| 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 |
| elit,: | | Pthreads |
| 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 |
| etags.fs: | | Emacs Tags |
| evaluate: | | Input Sources |
| event-loop: | | Pthreads |
| event:: | | Pthreads |
| event>: | | Pthreads |
| examining data and code: | | Examining |
| exception: | | Exception Handling |
| exception abort sequence of ABORT": | | core-idef |
| 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 |
| execute-task: | | Pthreads |
| executing code on startup: | | Invoking Gforth |
| 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 | | |
|---|
| 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 |
| 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 |
| 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 |
| 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, 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: | | Single precision |
| flush: | | Blocks |
| flush-file: | | General files |
| flush-icache: | | Assembler Definitions |
| fm/mod: | | Mixed precision |
| 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-related information: | | Forth-related information |
| forth-wordlist: | | Word Lists |
| forth.el: | | Emacs and Gforth |
| 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 |
| 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 | | |
|---|
| 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-ditc: | | gforthmi |
| gforth-fast and backtraces: | | Error messages |
| gforth-fast engine: | | Direct or Indirect Threaded? |
| gforth-fast, difference from gforth: | | Error messages |
| gforth-itc engine: | | Direct or Indirect Threaded? |
| gforth.el: | | Emacs and Gforth |
| gforth.el, installation: | | Installing gforth.el |
| gforth.fi, relocatability: | | Fully Relocatable Image Files |
| GFORTHD – environment variable: | | Environment variables |
| GFORTHD – environment variable: | | gforthmi |
| GFORTHHIST – environment variable: | | Environment variables |
| gforthmi: | | gforthmi |
| GFORTHPATH – environment variable: | | Environment variables |
| GFORTHSYSTEMPREFIX – environment variable: | | Environment variables |
| giving a name to a library interface: | | Defining library interfaces |
| glossary notation format: | | Notation |
| GNU C for the engine: | | Portability |
| goals of the Gforth project: | | Goals |
|
| H | | |
|---|
| halt: | | Pthreads |
| header space: | | Word Lists |
| heap allocation: | | Heap Allocation |
| heap-new: | | Objects Glossary |
| heap-new discussion: | | Creating objects |
| heap-new usage: | | Basic Objects Usage |
| 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 | | |
|---|
| 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 |
| 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 |
| 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 |
| initiate: | | Pthreads |
| 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 |
| 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 | | |
|---|
| j: | | Counted Loops |
|
| K | | |
|---|
| 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 | | |
|---|
| 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 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 |
| 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: | | Debugging |
| lock: | | Pthreads |
| 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 |
| lshift: | | Bitwise operations |
| LSHIFT, large shift counts: | | core-ambcond |
|
| M | | |
|---|
| m*: | | Mixed precision |
| m*/: | | Mixed precision |
| 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 |
| 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: | | Single precision |
| modifying >IN: | | How does that work? |
| modifying the contents of the input buffer or a string literal: | | core-ambcond |
| 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 |
|
| N | | |
|---|
| 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 |
| newtask: | | Pthreads |
| newtask4: | | Pthreads |
| 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 |
| nothrow: | | Exception Handling |
| NT Forth performance: | | Performance |
| 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 |
|
| O | | |
|---|
| 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 |
|
| P | | |
|---|
| 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 |
| pass: | | Pthreads |
| patching threaded code: | | Dynamic Superinstructions |
| path for included: | | Search Paths |
| path+: | | General Search Paths |
| path=: | | General Search Paths |
| pause: | | Pthreads |
| 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 |
|
| Q | | |
|---|
| query: | | Input Sources |
| quit: | | Miscellaneous Words |
| quotations: | | Quotations |
|
| R | | |
|---|
| r, stack item type: | | Notation |
| r/o: | | General files |
| r/w: | | General files |
| r>: | | Return stack |
| r@: | | Return stack |
| 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 |
| receiving object: | | Object-Oriented Terminology |
| 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 |
| 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 |
| restart: | | Pthreads |
| restore: | | Exception Handling |
| restore-input: | | Input Sources |
| RESTORE-INPUT, Argument type mismatch: | | core-ambcond |
| restrict: | | Interpretation and Compilation Semantics |
| result out of range: | | core-ambcond |
| 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 |
| roll: | | Data stack |
| Root: | | Word Lists |
| rot: | | Data stack |
| rounding of floating-point numbers: | | floating-idef |
| rp!: | | Stack pointer manipulation |
| rp0: | | Stack pointer manipulation |
| rp@: | | Stack pointer manipulation |
| rshift: | | Bitwise operations |
| RSHIFT, large shift counts: | | core-ambcond |
| run-time code generation, tutorial: | | Advanced macros Tutorial |
| running Gforth: | | Invoking Gforth |
| running image files: | | Running Image Files |
| Rydqvist, Goran: | | Emacs and Gforth |
|
| S | | |
|---|
| S": | | 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 |
| see tutorial: | | Decompilation Tutorial |
| SEE, source and format of output: | | programming-idef |
| see-code: | | Examining |
| see-code-range: | | Examining |
| 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 |
| semaphore: | | Pthreads |
| 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 |
| simple-see-range: | | Examining |
| 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: | | Mixed precision |
| source: | | The Text Interpreter |
| 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 |
| 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 |
| stacksize: | | Pthreads |
| stacksize4: | | Pthreads |
| 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 |
| stop: | | Pthreads |
| stop-ns: | | Pthreads |
| 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 |
| super: | | The OOF base class |
| superclass binding: | | Class Binding |
| Superinstructions: | | Dynamic Superinstructions |
| sw@: | | Memory Access |
| swap: | | Data stack |
| 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 |
|
| T | | |
|---|
| table: | | Word Lists |
| TAGS file: | | Emacs Tags |
| target compiler: | | cross.fs |
| target compiler: | | Cross Compiler |
| task: | | Pthreads |
| 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 |
| 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 |
| tuck: | | Data stack |
| turnkey image files: | | Modifying the Startup Sequence |
| Tutorial: | | Tutorial |
| type: | | Displaying characters and strings |
| types of locals: | | Gforth locals |
| types of stack items: | | Notation |
| types tutorial: | | Types Tutorial |
| typewhite: | | Displaying characters and strings |
|
| U | | |
|---|
| U+DO: | | Arbitrary control structures |
| u, stack item type: | | Notation |
| U-DO: | | Arbitrary control structures |
| u.: | | Simple numeric output |
| u.r: | | Simple numeric output |
| 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 |
| UDefer: | | Pthreads |
| ul@: | | Memory Access |
| um*: | | Mixed precision |
| um/mod: | | Mixed precision |
| undefined word: | | core-ambcond |
| undefined word, ', POSTPONE, ['], [COMPILE]: | | core-ambcond |
| under+: | | Single precision |
| unexpected end of the input buffer: | | core-ambcond |
| unlock: | | Pthreads |
| 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': | | Pthreads |
| user-defined defining words: | | User-defined Defining Words |
| utime: | | Keeping track of Time |
| UValue: | | Pthreads |
| uw@: | | Memory Access |
|
| V | | |
|---|
| 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 |
| 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 | | |
|---|
| w!: | | Memory Access |
| w, stack item type: | | Notation |
| w/o: | | General files |
| WARNING": | | Exception Handling |
| warnings: | | Exception Handling |
| where to go next: | | Where to go next |
| 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 |
| WTF??: | | Debugging |
|
| X | | |
|---|
| 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 |
| x\string-: | | Xchars and Unicode |
|
| Z | | |
|---|
| zero-length string as a name: | | core-ambcond |
| Zsoter’s object-oriented model: | | Comparison with other object models |
|