Word Index

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

• ! w a-addr – core: Memory Access
• # ud1 – ud2 core: Formatted numeric output
• #! – gforth: Running Image Files
• #> xd – addr u core: Formatted numeric output
• #>> – gforth: Formatted numeric output
• #s ud – 0 0 core: Formatted numeric output
• #tib – addr core-ext-obsolescent: The Text Interpreter
• $? – n gforth: Passing Commands to the OS
• %align align size – gforth: Structure Glossary
• %alignment align size – align gforth: Structure Glossary
• %alloc align size – addr gforth: Structure Glossary
• %allocate align size – addr ior gforth: Structure Glossary
• %allot align size – addr gforth: Structure Glossary
• %size align size – size gforth: Structure Glossary
• ' "name" – xt core: Execution token
• ' "name" – xt oof: The OOF base class
• 'cold – gforth: Modifying the Startup Sequence
• ( compilation 'ccc<close-paren>' – ; run-time – core,file: Comments
• (local) addr u – local: ANS Forth locals
• ) – gforth: Assertions
• * n1 n2 – n core: Single precision
• */ n1 n2 n3 – n4 core: Mixed precision
• */mod n1 n2 n3 – n4 n5 core: Mixed precision
• + n1 n2 – n core: Single precision
• +! n a-addr – core: Memory Access
• +DO compilation – do-sys ; run-time n1 n2 – | loop-sys gforth: Arbitrary control structures
• +field n1 n2 "name" – n3 X:structures: Forth200x Structures
• +load i*x n – j*x gforth: Blocks
• +LOOP compilation do-sys – ; run-time loop-sys1 n – | loop-sys2 core: Arbitrary control structures
• +thru i*x n1 n2 – j*x gforth: Blocks
• +x/string xc-addr1 u1 – xc-addr2 u2 xchar: Xchars and Unicode
• , w – core: Dictionary allocation
• - n1 n2 – n core: Single precision
• --> – gforth: Blocks
• -DO compilation – do-sys ; run-time n1 n2 – | loop-sys gforth: Arbitrary control structures
• -LOOP compilation do-sys – ; run-time loop-sys1 u – | loop-sys2 gforth: Arbitrary control structures
• -rot w1 w2 w3 – w3 w1 w2 gforth: Data stack
• -trailing c_addr u1 – c_addr u2 string: Memory Blocks
• -trailing-garbage xc-addr u1 – addr u2 xchar-ext: Xchars and Unicode
• . n – core: Simple numeric output
• ." compilation 'ccc"' – ; run-time – core: Displaying characters and strings
• .( compilation&interpretation "ccc<paren>" – core-ext: Displaying characters and strings
• .\" compilation 'ccc"' – ; run-time – gforth: Displaying characters and strings
• .debugline nfile nline – gforth: Debugging
• .id nt – F83: Name token
• .name nt – gforth-obsolete: Name token
• .path path-addr – gforth: General Search Paths
• .r n1 n2 – core-ext: Simple numeric output
• .s – tools: Examining
• / n1 n2 – n core: Single precision
• /does-handler – n gforth: Threading Words
• /l – u gforth: Address arithmetic
• /mod n1 n2 – n3 n4 core: Single precision
• /string c-addr1 u1 n – c-addr2 u2 string: Memory Blocks
• /w – u gforth: Address arithmetic
• 0< n – f core: Numeric comparison
• 0<= n – f gforth: Numeric comparison
• 0<> n – f core-ext: Numeric comparison
• 0= n – f core: Numeric comparison
• 0> n – f core-ext: Numeric comparison
• 0>= n – f gforth: Numeric comparison
• 1+ n1 – n2 core: Single precision
• 1- n1 – n2 core: Single precision
• 1/f r1 – r2 gforth: Floating Point
• 2! w1 w2 a-addr – core: Memory Access
• 2* n1 – n2 core: Bitwise operations
• 2, w1 w2 – gforth: Dictionary allocation
• 2/ n1 – n2 core: Bitwise operations
• 2>r d – R:d core-ext: Return stack
• 2@ a-addr – w1 w2 core: Memory Access
• 2Constant w1 w2 "name" – double: Constants
• 2drop w1 w2 – core: Data stack
• 2dup w1 w2 – w1 w2 w1 w2 core: Data stack
• 2field: u1 "name" – u2 gforth: Forth200x Structures
• 2Literal compilation w1 w2 – ; run-time – w1 w2 double: Literals
• 2nip w1 w2 w3 w4 – w3 w4 gforth: Data stack
• 2over w1 w2 w3 w4 – w1 w2 w3 w4 w1 w2 core: Data stack
• 2r> R:d – d core-ext: Return stack
• 2r@ R:d – R:d d core-ext: Return stack
• 2rdrop R:d – gforth: Return stack
• 2rot w1 w2 w3 w4 w5 w6 – w3 w4 w5 w6 w1 w2 double-ext: Data stack
• 2swap w1 w2 w3 w4 – w3 w4 w1 w2 core: Data stack
• 2tuck w1 w2 w3 w4 – w3 w4 w1 w2 w3 w4 gforth: Data stack
• 2Variable "name" – double: Variables
• : "name" – oof: The OOF base class
• : "name" – colon-sys core: Colon Definitions
• :: "name" – oof: The OOF base class
• :: class "name" – mini-oof: Basic Mini-OOF Usage
• :m "name" – xt; run-time: object – objects: Objects Glossary
• :noname – xt colon-sys core-ext: Anonymous Definitions
• ; compilation colon-sys – ; run-time nest-sys core: Colon Definitions
• ;code compilation. colon-sys1 – colon-sys2 tools-ext: Code and ;code
• ;m colon-sys –; run-time: – objects: Objects Glossary
• ;s R:w – gforth: Calls and returns
• < n1 n2 – f core: Numeric comparison
• <# – core: Formatted numeric output
• <<# – gforth: Formatted numeric output
• <= n1 n2 – f gforth: Numeric comparison
• <> n1 n2 – f core-ext: Numeric comparison
• <bind> class selector-xt – xt objects: Objects Glossary
• <compilation compilation. orig colon-sys – gforth: Combined words
• <interpretation compilation. orig colon-sys – gforth: Combined words
• <to-inst> w xt – objects: Objects Glossary
• = n1 n2 – f core: Numeric comparison
• > n1 n2 – f core: Numeric comparison
• >= n1 n2 – f gforth: Numeric comparison
• >body xt – a_addr core: CREATE..DOES> details
• >code-address xt – c_addr gforth: Threading Words
• >definer xt – definer gforth: Threading Words
• >does-code xt – a_addr gforth: Threading Words
• >float c-addr u – f:... flag float: Line input and conversion
• >in – addr core: The Text Interpreter
• >l w – gforth: Locals implementation
• >name xt – nt|0 gforth: Name token
• >number ud1 c-addr1 u1 – ud2 c-addr2 u2 core: Line input and conversion
• >order wid – gforth: Word Lists
• >r w – R:w core: Return stack
• ? a-addr – tools: Examining
• ?DO compilation – do-sys ; run-time w1 w2 – | loop-sys core-ext: Arbitrary control structures
• ?dup w – S:... w core: Data stack
• ?DUP-0=-IF compilation – orig ; run-time n – n| gforth: Arbitrary control structures
• ?DUP-IF compilation – orig ; run-time n – n| gforth: Arbitrary control structures
• ?LEAVE compilation – ; run-time f | f loop-sys – gforth: Arbitrary control structures
• @ a-addr – w core: Memory Access
• @local# #noffset – w gforth: Locals implementation
• [ – core: Literals
• ['] compilation. "name" – ; run-time. – xt core: Execution token
• [+LOOP] n – gforth: Interpreter Directives
• [?DO] n-limit n-index – gforth: Interpreter Directives
• [] n "name" – oof: The OOF base class
• [AGAIN] – gforth: Interpreter Directives
• [BEGIN] – gforth: Interpreter Directives
• [bind] compile-time: "class" "selector" – ; run-time: ... object – ... objects: Objects Glossary
• [Char] compilation '<spaces>ccc' – ; run-time – c core: Displaying characters and strings
• [COMP'] compilation "name" – ; run-time – w xt gforth: Compilation token
• [compile] compilation "name" – ; run-time ? – ? core-ext: Macros
• [current] compile-time: "selector" – ; run-time: ... object – ... objects: Objects Glossary
• [DO] n-limit n-index – gforth: Interpreter Directives
• [ELSE] – tools-ext: Interpreter Directives
• [ENDIF] – gforth: Interpreter Directives
• [FOR] n – gforth: Interpreter Directives
• [IF] flag – tools-ext: Interpreter Directives
• [IFDEF] "<spaces>name" – gforth: Interpreter Directives
• [IFUNDEF] "<spaces>name" – gforth: Interpreter Directives
• [LOOP] – gforth: Interpreter Directives
• [NEXT] n – gforth: Interpreter Directives
• [parent] compile-time: "selector" – ; run-time: ... object – ... objects: Objects Glossary
• [REPEAT] – gforth: Interpreter Directives
• [THEN] – tools-ext: Interpreter Directives
• [to-inst] compile-time: "name" – ; run-time: w – objects: Objects Glossary
• [UNTIL] flag – gforth: Interpreter Directives
• [WHILE] flag – gforth: Interpreter Directives
• \ compilation 'ccc<newline>' – ; run-time – core-ext,block-ext: Comments
• \c "rest-of-line" – gforth: Declaring C Functions
• \G compilation 'ccc<newline>' – ; run-time – gforth: Comments
• ] – core: Literals
• ]L compilation: n – ; run-time: – n gforth: Literals
• abort ?? – ?? core,exception-ext: Exception Handling
• ABORT" compilation 'ccc"' – ; run-time f – core,exception-ext: Exception Handling
• abs n – u core: Single precision
• accept c-addr +n1 – +n2 core: Line input and conversion
• action-of interpretation "name" – xt; compilation "name" – ; run-time – xt gforth: Deferred Words
• add-lib c-addr u – gforth: Declaring OS-level libraries
• ADDRESS-UNIT-BITS – n environment: Address arithmetic
• AGAIN compilation dest – ; run-time – core-ext: Arbitrary control structures
• AHEAD compilation – orig ; run-time – tools-ext: Arbitrary control structures
• Alias xt "name" – gforth: Aliases
• align – core: Dictionary allocation
• aligned c-addr – a-addr core: Address arithmetic
• allocate u – a-addr wior memory: Heap Allocation
• allot n – core: Dictionary allocation
• also – search-ext: Word Lists
• also-path c-addr len path-addr – gforth: General Search Paths
• and w1 w2 – w core: Bitwise operations
• arg u – addr count gforth: OS command line arguments
• argc – addr gforth: OS command line arguments
• argv – addr gforth: OS command line arguments
• asptr class – oof: Class Declaration
• asptr o "name" – oof: The OOF base class
• assembler – tools-ext: Code and ;code
• assert( – gforth: Assertions
• assert-level – a-addr gforth: Assertions
• assert0( – gforth: Assertions
• assert1( – gforth: Assertions
• assert2( – gforth: Assertions
• assert3( – gforth: Assertions
• ASSUME-LIVE orig – orig gforth: Where are locals visible by name?
• at-xy u1 u2 – facility: Terminal output
• base – a-addr core: Number Conversion
• base-execute i*x xt u – j*x gforth: Number Conversion
• BEGIN compilation – dest ; run-time – core: Arbitrary control structures
• begin-structure "name" – struct-sys 0 X:structures: Forth200x Structures
• bin fam1 – fam2 file: General files
• bind ... "class" "selector" – ... objects: Objects Glossary
• bind o "name" – oof: The OOF base class
• bind' "class" "selector" – xt objects: Objects Glossary
• bl – c-char core: Displaying characters and strings
• blank c-addr u – string: Memory Blocks
• blk – addr block: Input Sources
• block u – a-addr block: Blocks
• block-included a-addr u – gforth: Blocks
• block-offset – addr gforth: Blocks
• block-position u – block: Blocks
• bootmessage – gforth: Modifying the Startup Sequence
• bound class addr "name" – oof: The OOF base class
• bounds addr u – addr+u addr gforth: Memory Blocks
• break" 'ccc"' – gforth: Singlestep Debugger
• break: – gforth: Singlestep Debugger
• broken-pipe-error – n gforth: Pipes
• buffer u – a-addr block: Blocks
• bye – tools-ext: Leaving Gforth
• c! c c-addr – core: Memory Access
• C" compilation "ccc<quote>" – ; run-time – c-addr core-ext: Displaying characters and strings
• c, c – core: Dictionary allocation
• c-function "forth-name" "c-name" "{type}" "–" "type" – gforth: Declaring C Functions
• c-library "name" – gforth: Defining library interfaces
• c-library-name c-addr u – gforth: Defining library interfaces
• c@ c-addr – c core: Memory Access
• call-c ... w – ... gforth: Low-Level C Interface Words
• case compilation – case-sys ; run-time – core-ext: Arbitrary control structures
• catch ... xt – ... n exception: Exception Handling
• cell – u gforth: Address arithmetic
• cell% – align size gforth: Structure Glossary
• cell+ a-addr1 – a-addr2 core: Address arithmetic
• cells n1 – n2 core: Address arithmetic
• cfalign – gforth: Dictionary allocation
• cfaligned addr1 – addr2 gforth: Address arithmetic
• cfield: u1 "name" – u2 X:structures: Forth200x Structures
• char '<spaces>ccc' – c core: Displaying characters and strings
• char% – align size gforth: Structure Glossary
• char+ c-addr1 – c-addr2 core: Address arithmetic
• chars n1 – n2 core: Address arithmetic
• class "name" – oof: The OOF base class
• class class – class selectors vars mini-oof: Basic Mini-OOF Usage
• class parent-class – align offset objects: Objects Glossary
• class->map class – map objects: Objects Glossary
• class-inst-size class – addr objects: Objects Glossary
• class-override! xt sel-xt class-map – objects: Objects Glossary
• class-previous class – objects: Objects Glossary
• class; – oof: Class Declaration
• class>order class – objects: Objects Glossary
• class? o – flag oof: The OOF base class
• clear-libs – gforth: Declaring OS-level libraries
• clear-path path-addr – gforth: General Search Paths
• clearstack ... – gforth: Examining
• clearstacks ... – gforth: Examining
• close-file wfileid – wior file: General files
• close-pipe wfileid – wretval wior gforth: Pipes
• cmove c-from c-to u – string: Memory Blocks
• cmove> c-from c-to u – string: Memory Blocks
• code "name" – colon-sys tools-ext: Code and ;code
• code-address! c_addr xt – gforth: Threading Words
• common-list list1 list2 – list3 gforth-internal: Locals implementation
• COMP' "name" – w xt gforth: Compilation token
• compare c-addr1 u1 c-addr2 u2 – n string: Memory Blocks
• compilation> compilation. – orig colon-sys gforth: Combined words
• compile, xt – core-ext: Macros
• compile-lp+! n – gforth: Locals implementation
• compile-only – gforth: Interpretation and Compilation Semantics
• const-does> run-time: w*uw r*ur uw ur "name" – gforth: Const-does>
• Constant w "name" – core: Constants
• construct ... object – objects: Objects Glossary
• context – addr gforth: Word Lists
• convert ud1 c-addr1 – ud2 c-addr2 core-ext-obsolescent: Line input and conversion
• count c-addr1 – c-addr2 u core: String Formats
• cputime – duser dsystem gforth: Keeping track of Time
• cr – core: Displaying characters and strings
• Create "name" – core: CREATE
• create-file c-addr u wfam – wfileid wior file: General files
• create-interpret/compile "name" – gforth: Combined words
• CS-PICK ... u – ... destu tools-ext: Arbitrary control structures
• CS-ROLL destu/origu .. dest0/orig0 u – .. dest0/orig0 destu/origu tools-ext: Arbitrary control structures
• current – addr gforth: Word Lists
• current' "selector" – xt objects: Objects Glossary
• current-interface – addr objects: Objects Glossary
• d+ d1 d2 – d double: Double precision
• d- d1 d2 – d double: Double precision
• d. d – double: Simple numeric output
• d.r d n – double: Simple numeric output
• d0< d – f double: Numeric comparison
• d0<= d – f gforth: Numeric comparison
• d0<> d – f gforth: Numeric comparison
• d0= d – f double: Numeric comparison
• d0> d – f gforth: Numeric comparison
• d0>= d – f gforth: Numeric comparison
• d2* d1 – d2 double: Bitwise operations
• d2/ d1 – d2 double: Bitwise operations
• d< d1 d2 – f double: Numeric comparison
• d<= d1 d2 – f gforth: Numeric comparison
• d<> d1 d2 – f gforth: Numeric comparison
• d= d1 d2 – f double: Numeric comparison
• d> d1 d2 – f gforth: Numeric comparison
• d>= d1 d2 – f gforth: Numeric comparison
• d>f d – r float: Floating Point
• d>s d – n double: Double precision
• dabs d – ud double: Double precision
• dbg "name" – gforth: Singlestep Debugger
• dec. n – gforth: Simple numeric output
• decimal – core: Number Conversion
• Defer "name" – gforth: Deferred Words
• defer – oof: Class Declaration
• defer! xt xt-deferred – gforth: Deferred Words
• defer@ xt-deferred – xt gforth: Deferred Words
• defers compilation "name" – ; run-time ... – ... gforth: Deferred Words
• definer! definer xt – gforth: Threading Words
• defines xt class "name" – mini-oof: Basic Mini-OOF Usage
• definitions – oof: The OOF base class
• definitions – search: Word Lists
• delete-file c-addr u – wior file: General files
• depth – +n core: Examining
• df! r df-addr – float-ext: Memory Access
• df@ df-addr – r float-ext: Memory Access
• dfalign – float-ext: Dictionary allocation
• dfaligned c-addr – df-addr float-ext: Address arithmetic
• dffield: u1 "name" – u2 X:structures: Forth200x Structures
• dfloat% – align size gforth: Structure Glossary
• dfloat+ df-addr1 – df-addr2 float-ext: Address arithmetic
• dfloats n1 – n2 float-ext: Address arithmetic
• dict-new ... class – object objects: Objects Glossary
• discode addr u – gforth: Common Disassembler
• dispose – oof: The OOF base class
• dmax d1 d2 – d double: Double precision
• dmin d1 d2 – d double: Double precision
• dnegate d1 – d2 double: Double precision
• DO compilation – do-sys ; run-time w1 w2 – loop-sys core: Arbitrary control structures
• docol: – addr gforth: Threading Words
• docon: – addr gforth: Threading Words
• dodefer: – addr gforth: Threading Words
• does-code! a_addr xt – gforth: Threading Words
• does-handler! a_addr – gforth: Threading Words
• DOES> compilation colon-sys1 – colon-sys2 ; run-time nest-sys – core: CREATE..DOES> details
• dofield: – addr gforth: Threading Words
• DONE compilation orig – ; run-time – gforth: Arbitrary control structures
• double% – align size gforth: Structure Glossary
• douser: – addr gforth: Threading Words
• dovar: – addr gforth: Threading Words
• dpl – a-addr gforth: Number Conversion
• drop w – core: Data stack
• du< ud1 ud2 – f double-ext: Numeric comparison
• du<= ud1 ud2 – f gforth: Numeric comparison
• du> ud1 ud2 – f gforth: Numeric comparison
• du>= ud1 ud2 – f gforth: Numeric comparison
• dump addr u – tools: Examining
• dup w – w w core: Data stack
• early – oof: Class Declaration
• edit-line c-addr n1 n2 – n3 gforth: Line input and conversion
• ekey – u facility-ext: Single-key input
• ekey>char u – u false | c true facility-ext: Single-key input
• ekey>fkey u1 – u2 f X:ekeys: Single-key input
• ekey? – flag facility-ext: Single-key input
• ELSE compilation orig1 – orig2 ; run-time – core: Arbitrary control structures
• emit c – core: Displaying characters and strings
• emit-file c wfileid – wior gforth: General files
• empty-buffer buffer – gforth: Blocks
• empty-buffers – block-ext: Blocks
• end-c-library – gforth: Defining library interfaces
• end-class align offset "name" – objects: Objects Glossary
• end-class class selectors vars "name" – mini-oof: Basic Mini-OOF Usage
• end-class-noname align offset – class objects: Objects Glossary
• end-code colon-sys – gforth: Code and ;code
• end-interface "name" – objects: Objects Glossary
• end-interface-noname – interface objects: Objects Glossary
• end-methods – objects: Objects Glossary
• end-struct align size "name" – gforth: Structure Glossary
• end-structure struct-sys +n – X:structures: Forth200x Structures
• endcase compilation case-sys – ; run-time x – core-ext: Arbitrary control structures
• ENDIF compilation orig – ; run-time – gforth: Arbitrary control structures
• endof compilation case-sys1 of-sys – case-sys2 ; run-time – core-ext: Arbitrary control structures
• endscope compilation scope – ; run-time – gforth: Where are locals visible by name?
• endtry compilation – ; run-time R:sys1 – gforth: Exception Handling
• endtry-iferror compilation orig1 – orig2 ; run-time R:sys1 – gforth: Exception Handling
• endwith – oof: The OOF base class
• environment-wordlist – wid gforth: Environmental Queries
• environment? c-addr u – false / ... true core: Environmental Queries
• erase addr u – core-ext: Memory Blocks
• evaluate ... addr u – ... core,block: Input Sources
• exception addr u – n gforth: Exception Handling
• execute xt – core: Execution token
• execute-parsing ... addr u xt – ... gforth: The Input Stream
• execute-parsing-file i*x fileid xt – j*x gforth: The Input Stream
• EXIT compilation – ; run-time nest-sys – core: Calls and returns
• exitm – objects: Objects Glossary
• expect c-addr +n – core-ext-obsolescent: Line input and conversion
• f! r f-addr – float: Memory Access
• f* r1 r2 – r3 float: Floating Point
• f** r1 r2 – r3 float-ext: Floating Point
• f+ r1 r2 – r3 float: Floating Point
• f, f – gforth: Dictionary allocation
• f- r1 r2 – r3 float: Floating Point
• f. r – float-ext: Simple numeric output
• f.rdp rf +nr +nd +np – gforth: Simple numeric output
• f.s – gforth: Examining
• f/ r1 r2 – r3 float: Floating Point
• f0< r – f float: Floating Point
• f0<= r – f gforth: Floating Point
• f0<> r – f gforth: Floating Point
• f0= r – f float: Floating Point
• f0> r – f gforth: Floating Point
• f0>= r – f gforth: Floating Point
• f2* r1 – r2 gforth: Floating Point
• f2/ r1 – r2 gforth: Floating Point
• f< r1 r2 – f float: Floating Point
• f<= r1 r2 – f gforth: Floating Point
• f<> r1 r2 – f gforth: Floating Point
• f= r1 r2 – f gforth: Floating Point
• f> r1 r2 – f gforth: Floating Point
• f>= r1 r2 – f gforth: Floating Point
• f>buf-rdp rf c-addr +nr +nd +np – gforth: Formatted numeric output
• f>d r – d float: Floating Point
• f>l r – gforth: Locals implementation
• f>str-rdp rf +nr +nd +np – c-addr nr gforth: Formatted numeric output
• f@ f-addr – r float: Memory Access
• f@local# #noffset – r gforth: Locals implementation
• fabs r1 – r2 float-ext: Floating Point
• facos r1 – r2 float-ext: Floating Point
• facosh r1 – r2 float-ext: Floating Point
• falign – float: Dictionary allocation
• faligned c-addr – f-addr float: Address arithmetic
• falog r1 – r2 float-ext: Floating Point
• false – f core-ext: Boolean Flags
• fasin r1 – r2 float-ext: Floating Point
• fasinh r1 – r2 float-ext: Floating Point
• fatan r1 – r2 float-ext: Floating Point
• fatan2 r1 r2 – r3 float-ext: Floating Point
• fatanh r1 – r2 float-ext: Floating Point
• fconstant r "name" – float: Constants
• fcos r1 – r2 float-ext: Floating Point
• fcosh r1 – r2 float-ext: Floating Point
• fdepth – +n float: Examining
• fdrop r – float: Floating point stack
• fdup r – r r float: Floating point stack
• fe. r – float-ext: Simple numeric output
• fexp r1 – r2 float-ext: Floating Point
• fexpm1 r1 – r2 float-ext: Floating Point
• ffield: u1 "name" – u2 X:structures: Forth200x Structures
• field align1 offset1 align size "name" – align2 offset2 gforth: Structure Glossary
• field: u1 "name" – u2 X:structures: Forth200x Structures
• file-position wfileid – ud wior file: General files
• file-size wfileid – ud wior file: General files
• file-status c-addr u – wfam wior file-ext: General files
• fill c-addr u c – core: Memory Blocks
• find c-addr – xt +-1 | c-addr 0 core,search: Word Lists
• find-name c-addr u – nt | 0 gforth: Name token
• FLiteral compilation r – ; run-time – r float: Literals
• fln r1 – r2 float-ext: Floating Point
• flnp1 r1 – r2 float-ext: Floating Point
• float – u gforth: Address arithmetic
• float% – align size gforth: Structure Glossary
• float+ f-addr1 – f-addr2 float: Address arithmetic
• floating-stack – n environment: Floating point stack
• floats n1 – n2 float: Address arithmetic
• flog r1 – r2 float-ext: Floating Point
• floor r1 – r2 float: Floating Point
• FLOORED – f environment: Single precision
• flush – block: Blocks
• flush-file wfileid – wior file-ext: General files
• flush-icache c-addr u – gforth: Code and ;code
• fm/mod d1 n1 – n2 n3 core: Mixed precision
• fmax r1 r2 – r3 float: Floating Point
• fmin r1 r2 – r3 float: Floating Point
• fnegate r1 – r2 float: Floating Point
• fnip r1 r2 – r2 gforth: Floating point stack
• FOR compilation – do-sys ; run-time u – loop-sys gforth: Arbitrary control structures
• form – urows ucols gforth: Terminal output
• Forth – search-ext: Word Lists
• forth-wordlist – wid search: Word Lists
• fover r1 r2 – r1 r2 r1 float: Floating point stack
• fp! f-addr – f:... gforth: Stack pointer manipulation
• fp0 – a-addr gforth: Stack pointer manipulation
• fp@ f:... – f-addr gforth: Stack pointer manipulation
• fpath – path-addr gforth: Source Search Paths
• fpick f:... u – f:... r gforth: Floating point stack
• free a-addr – wior memory: Heap Allocation
• frot r1 r2 r3 – r2 r3 r1 float: Floating point stack
• fround r1 – r2 float: Floating Point
• fs. r – float-ext: Simple numeric output
• fsin r1 – r2 float-ext: Floating Point
• fsincos r1 – r2 r3 float-ext: Floating Point
• fsinh r1 – r2 float-ext: Floating Point
• fsqrt r1 – r2 float-ext: Floating Point
• fswap r1 r2 – r2 r1 float: Floating point stack
• ftan r1 – r2 float-ext: Floating Point
• ftanh r1 – r2 float-ext: Floating Point
• ftuck r1 r2 – r2 r1 r2 gforth: Floating point stack
• fvariable "name" – float: Variables
• f~ r1 r2 r3 – flag float-ext: Floating Point
• f~abs r1 r2 r3 – flag gforth: Floating Point
• f~rel r1 r2 r3 – flag gforth: Floating Point
• get-block-fid – wfileid gforth: Blocks
• get-current – wid search: Word Lists
• get-order – widn .. wid1 n search: Word Lists
• getenv c-addr1 u1 – c-addr2 u2 gforth: Passing Commands to the OS
• gforth – c-addr u gforth-environment: Environmental Queries
• heap-new ... class – object objects: Objects Glossary
• here – addr core: Dictionary allocation
• hex – core-ext: Number Conversion
• hex. u – gforth: Simple numeric output
• hold char – core: Formatted numeric output
• how: – oof: Class Declaration
• i R:n – R:n n core: Counted Loops
• id. nt – gforth: Name token
• IF compilation – orig ; run-time f – core: Arbitrary control structures
• iferror compilation orig1 – orig2 ; run-time – gforth: Exception Handling
• immediate – core: Interpretation and Compilation Semantics
• implementation interface – objects: Objects Glossary
• include ... "file" – ... gforth: Forth source files
• include-file i*x wfileid – j*x file: Forth source files
• included i*x c-addr u – j*x file: Forth source files
• included? c-addr u – f gforth: Forth source files
• infile-execute ... xt file-id – ... gforth: Redirection
• init ... – oof: The OOF base class
• init-asm – gforth: Code and ;code
• init-object ... class object – objects: Objects Glossary
• inst-value align1 offset1 "name" – align2 offset2 objects: Objects Glossary
• inst-var align1 offset1 align size "name" – align2 offset2 objects: Objects Glossary
• interface – objects: Objects Glossary
• interpret/compile: interp-xt comp-xt "name" – gforth: Combined words
• interpretation> compilation. – orig colon-sys gforth: Combined words
• invert w1 – w2 core: Bitwise operations
• IS compilation/interpretation "name-deferred" – ; run-time xt – gforth: Deferred Words
• is xt "name" – oof: The OOF base class
• j R:w R:w1 R:w2 – w R:w R:w1 R:w2 core: Counted Loops
• k R:w R:w1 R:w2 R:w3 R:w4 – w R:w R:w1 R:w2 R:w3 R:w4 gforth: Counted Loops
• k-alt-mask – u X:ekeys: Single-key input
• k-ctrl-mask – u X:ekeys: Single-key input
• k-delete – u X:ekeys: Single-key input
• k-down – u X:ekeys: Single-key input
• k-end – u X:ekeys: Single-key input
• k-f1 – u X:ekeys: Single-key input
• k-f10 – u X:ekeys: Single-key input
• k-f11 – u X:ekeys: Single-key input
• k-f12 – u X:ekeys: Single-key input
• k-f2 – u X:ekeys: Single-key input
• k-f3 – u X:ekeys: Single-key input
• k-f4 – u X:ekeys: Single-key input
• k-f5 – u X:ekeys: Single-key input
• k-f6 – u X:ekeys: Single-key input
• k-f7 – u X:ekeys: Single-key input
• k-f8 – u X:ekeys: Single-key input
• k-f9 – u X:ekeys: Single-key input
• k-home – u X:ekeys: Single-key input
• k-insert – u X:ekeys: Single-key input
• k-left – u X:ekeys: Single-key input
• k-next – u X:ekeys: Single-key input
• k-prior – u X:ekeys: Single-key input
• k-right – u X:ekeys: Single-key input
• k-shift-mask – u X:ekeys: Single-key input
• k-up – u X:ekeys: Single-key input
• key – char core: Single-key input
• key-file wfileid – c gforth: General files
• key? – flag facility: Single-key input
• key?-file wfileid – f gforth: General files
• l! w c-addr – gforth: Memory Access
• laddr# #noffset – c-addr gforth: Locals implementation
• latest – nt gforth: Name token
• latestxt – xt gforth: Anonymous Definitions
• LEAVE compilation – ; run-time loop-sys – core: Arbitrary control structures
• lib-error – c-addr u gforth: Low-Level C Interface Words
• lib-sym c-addr1 u1 u2 – u3 gforth: Low-Level C Interface Words
• link "name" – class addr oof: The OOF base class
• list u – block-ext: Blocks
• list-size list – u gforth-internal: Locals implementation
• Literal compilation n – ; run-time – n core: Literals
• load i*x n – j*x block: Blocks
• LOOP compilation do-sys – ; run-time loop-sys1 – | loop-sys2 core: Arbitrary control structures
• lp! c-addr – gforth: Locals implementation
• lp! c-addr – gforth: Stack pointer manipulation
• lp+!# #noffset – gforth: Locals implementation
• lp0 – a-addr gforth: Stack pointer manipulation
• lp@ – addr gforth: Stack pointer manipulation
• lshift u1 n – u2 core: Bitwise operations
• m* n1 n2 – d core: Mixed precision
• m*/ d1 n2 u3 – dquot double: Mixed precision
• m+ d1 n – d2 double: Mixed precision
• m: – xt colon-sys; run-time: object – objects: Objects Glossary
• marker "<spaces> name" – core-ext: Forgetting words
• max n1 n2 – n core: Single precision
• maxalign – gforth: Dictionary allocation
• maxaligned addr1 – addr2 gforth: Address arithmetic
• maxdepth-.s – addr gforth: Examining
• method – oof: Class Declaration
• method m v "name" – m' v mini-oof: Basic Mini-OOF Usage
• method xt "name" – objects: Objects Glossary
• methods class – objects: Objects Glossary
• min n1 n2 – n core: Single precision
• mod n1 n2 – n core: Single precision
• move c-from c-to ucount – core: Memory Blocks
• ms u – facility-ext: Keeping track of Time
• naligned addr1 n – addr2 gforth: Structure Glossary
• name – c-addr u gforth-obsolete: The Input Stream
• name>comp nt – w xt gforth: Name token
• name>int nt – xt gforth: Name token
• name>string nt – addr count gforth: Name token
• name?int nt – xt gforth: Name token
• needs ... "name" – ... gforth: Forth source files
• negate n1 – n2 core: Single precision
• new – o oof: The OOF base class
• new class – o mini-oof: Basic Mini-OOF Usage
• new[] n – o oof: The OOF base class
• NEXT compilation do-sys – ; run-time loop-sys1 – | loop-sys2 gforth: Arbitrary control structures
• next-arg – addr u gforth: OS command line arguments
• nextname c-addr u – gforth: Supplying names
• nip w1 w2 – w2 core-ext: Data stack
• noname – gforth: Anonymous Definitions
• nothrow – gforth: Exception Handling
• object – a-addr mini-oof: Basic Mini-OOF Usage
• object – class objects: Objects Glossary
• of compilation – of-sys ; run-time x1 x2 – |x1 core-ext: Arbitrary control structures
• off a-addr – gforth: Boolean Flags
• on a-addr – gforth: Boolean Flags
• Only – search-ext: Word Lists
• open-blocks c-addr u – gforth: Blocks
• open-file c-addr u wfam – wfileid wior file: General files
• open-lib c-addr1 u1 – u2 gforth: Low-Level C Interface Words
• open-path-file addr1 u1 path-addr – wfileid addr2 u2 0 | ior gforth: General Search Paths
• open-pipe c-addr u wfam – wfileid wior gforth: Pipes
• or w1 w2 – w core: Bitwise operations
• order – search-ext: Word Lists
• os-class – c-addr u gforth-environment: Environmental Queries
• outfile-execute ... xt file-id – ... gforth: Redirection
• over w1 w2 – w1 w2 w1 core: Data stack
• overrides xt "selector" – objects: Objects Glossary
• pad – c-addr core-ext: Memory Blocks
• page – facility: Terminal output
• parse char "ccc<char>" – c-addr u core-ext: The Input Stream
• parse-name "name" – c-addr u gforth: The Input Stream
• parse-word – c-addr u gforth-obsolete: The Input Stream
• path+ path-addr "dir" – gforth: General Search Paths
• path-allot umax – gforth: General Search Paths
• path= path-addr "dir1|dir2|dir3" gforth: General Search Paths
• perform a-addr – gforth: Execution token
• pi – r gforth: Floating Point
• pick S:... u – S:... w core-ext: Data stack
• postpone "name" – core: Macros
• postpone "name" – oof: The OOF base class
• postpone, w xt – gforth: Compilation token
• precision – u float-ext: Floating Point
• previous – search-ext: Word Lists
• print object – objects: Objects Glossary
• printdebugdata – gforth: Debugging
• protected – objects: Objects Glossary
• ptr "name" – oof: The OOF base class
• ptr – oof: Class Declaration
• public – objects: Objects Glossary
• query – core-ext-obsolescent: Input Sources
• quit ?? – ?? core: Miscellaneous Words
• r/o – fam file: General files
• r/w – fam file: General files
• r> R:w – w core: Return stack
• r@ – w ; R: w – w core: Return stack
• rdrop R:w – gforth: Return stack
• read-file c-addr u1 wfileid – u2 wior file: General files
• read-line c_addr u1 wfileid – u2 flag wior file: General files
• recurse compilation – ; run-time ?? – ?? core: Calls and returns
• recursive compilation – ; run-time – gforth: Calls and returns
• refill – flag core-ext,block-ext,file-ext: The Input Stream
• rename-file c-addr1 u1 c-addr2 u2 – wior file-ext: General files
• REPEAT compilation orig dest – ; run-time – core: Arbitrary control structures
• reposition-file ud wfileid – wior file: General files
• represent r c-addr u – n f1 f2 float: Formatted numeric output
• require ... "file" – ... gforth: Forth source files
• required i*x addr u – i*x gforth: Forth source files
• resize a-addr1 u – a-addr2 wior memory: Heap Allocation
• resize-file ud wfileid – wior file: General files
• restore compilation orig1 – ; run-time – gforth: Exception Handling
• restore-input x1 .. xn n – flag core-ext: Input Sources
• restrict – gforth: Interpretation and Compilation Semantics
• roll x0 x1 .. xn n – x1 .. xn x0 core-ext: Data stack
• Root – gforth: Word Lists
• rot w1 w2 w3 – w2 w3 w1 core: Data stack
• rp! a-addr – gforth: Stack pointer manipulation
• rp0 – a-addr gforth: Stack pointer manipulation
• rp@ – a-addr gforth: Stack pointer manipulation
• rshift u1 n – u2 core: Bitwise operations
• S" compilation 'ccc"' – ; run-time – c-addr u core,file: Displaying characters and strings
• s>d n – d core: Double precision
• s>number? addr u – d f gforth: Line input and conversion
• s>unumber? c-addr u – ud flag gforth: Line input and conversion
• s\" compilation 'ccc"' – ; run-time – c-addr u gforth: Displaying characters and strings
• save-buffer buffer – gforth: Blocks
• save-buffers – block: Blocks
• save-input – x1 .. xn n core-ext: Input Sources
• savesystem "name" – gforth: Non-Relocatable Image Files
• scope compilation – scope ; run-time – gforth: Where are locals visible by name?
• scr – a-addr block-ext: Blocks
• seal – gforth: Word Lists
• search c-addr1 u1 c-addr2 u2 – c-addr3 u3 flag string: Memory Blocks
• search-wordlist c-addr count wid – 0 | xt +-1 search: Word Lists
• see "<spaces>name" – tools: Examining
• see-code "name" – gforth: Examining
• see-code-range addr1 addr2 – gforth: Examining
• selector "name" – objects: Objects Glossary
• self – o oof: The OOF base class
• set-current wid – search: Word Lists
• set-order widn .. wid1 n – search: Word Lists
• set-precision u – float-ext: Floating Point
• sf! r sf-addr – float-ext: Memory Access
• sf@ sf-addr – r float-ext: Memory Access
• sfalign – float-ext: Dictionary allocation
• sfaligned c-addr – sf-addr float-ext: Address arithmetic
• sffield: u1 "name" – u2 X:structures: Forth200x Structures
• sfloat% – align size gforth: Structure Glossary
• sfloat+ sf-addr1 – sf-addr2 float-ext: Address arithmetic
• sfloats n1 – n2 float-ext: Address arithmetic
• sh "..." – gforth: Passing Commands to the OS
• shift-args – gforth: OS command line arguments
• sign n – core: Formatted numeric output
• simple-see "name" – gforth: Examining
• simple-see-range addr1 addr2 – gforth: Examining
• sl@ c-addr – n gforth: Memory Access
• SLiteral Compilation c-addr1 u ; run-time – c-addr2 u string: Literals
• slurp-fid fid – addr u gforth: General files
• slurp-file c-addr1 u1 – c-addr2 u2 gforth: General files
• sm/rem d1 n1 – n2 n3 core: Mixed precision
• source – addr u core: The Text Interpreter
• source-id – 0 | -1 | fileid core-ext,file: Input Sources
• sourcefilename – c-addr u gforth: Forth source files
• sourceline# – u gforth: Forth source files
• sp! a-addr – S:... gforth: Stack pointer manipulation
• sp0 – a-addr gforth: Stack pointer manipulation
• sp@ S:... – a-addr gforth: Stack pointer manipulation
• space – core: Displaying characters and strings
• spaces u – core: Displaying characters and strings
• span – c-addr core-ext-obsolescent: Line input and conversion
• static – oof: Class Declaration
• stderr – wfileid gforth: General files
• stdin – wfileid gforth: General files
• stdout – wfileid gforth: General files
• str< c-addr1 u1 c-addr2 u2 – f gforth: Memory Blocks
• str= c-addr1 u1 c-addr2 u2 – f gforth: Memory Blocks
• string-prefix? c-addr1 u1 c-addr2 u2 – f gforth: Memory Blocks
• struct – align size gforth: Structure Glossary
• sub-list? list1 list2 – f gforth-internal: Locals implementation
• super "name" – oof: The OOF base class
• sw@ c-addr – n gforth: Memory Access
• swap w1 w2 – w2 w1 core: Data stack
• system c-addr u – gforth: Passing Commands to the OS
• table – wid gforth: Word Lists
• THEN compilation orig – ; run-time – core: Arbitrary control structures
• this – object objects: Objects Glossary
• threading-method – n gforth: Threading Words
• throw y1 .. ym nerror – y1 .. ym / z1 .. zn error exception: Exception Handling
• thru i*x n1 n2 – j*x block-ext: Blocks
• tib – addr core-ext-obsolescent: The Text Interpreter
• time&date – nsec nmin nhour nday nmonth nyear facility-ext: Keeping track of Time
• TO c|w|d|r "name" – core-ext,local: Values
• to-this object – objects: Objects Glossary
• toupper c1 – c2 gforth: Displaying characters and strings
• true – f core-ext: Boolean Flags
• try compilation – orig ; run-time – R:sys1 gforth: Exception Handling
• tuck w1 w2 – w2 w1 w2 core-ext: Data stack
• type c-addr u – core: Displaying characters and strings
• typewhite addr n – gforth: Displaying characters and strings
• U+DO compilation – do-sys ; run-time u1 u2 – | loop-sys gforth: Arbitrary control structures
• U-DO compilation – do-sys ; run-time u1 u2 – | loop-sys gforth: Arbitrary control structures
• u. u – core: Simple numeric output
• u.r u n – core-ext: Simple numeric output
• u< u1 u2 – f core: Numeric comparison
• u<= u1 u2 – f gforth: Numeric comparison
• u> u1 u2 – f core-ext: Numeric comparison
• u>= u1 u2 – f gforth: Numeric comparison
• ud. ud – gforth: Simple numeric output
• ud.r ud n – gforth: Simple numeric output
• ul@ c-addr – u gforth: Memory Access
• um* u1 u2 – ud core: Mixed precision
• um/mod ud u1 – u2 u3 core: Mixed precision
• under+ n1 n2 n3 – n n2 gforth: Single precision
• unloop R:w1 R:w2 – core: Arbitrary control structures
• UNREACHABLE – gforth: Where are locals visible by name?
• UNTIL compilation dest – ; run-time f – core: Arbitrary control structures
• unused – u core-ext: Dictionary allocation
• update – block: Blocks
• updated? n – f gforth: Blocks
• use "file" – gforth: Blocks
• User "name" – gforth: Variables
• utime – dtime gforth: Keeping track of Time
• uw@ c-addr – u gforth: Memory Access
• Value w "name" – core-ext: Values
• var m v size "name" – m v' mini-oof: Basic Mini-OOF Usage
• var size – oof: Class Declaration
• Variable "name" – core: Variables
• vlist – gforth: Word Lists
• Vocabulary "name" – gforth: Word Lists
• vocs – gforth: Word Lists
• w! w c-addr – gforth: Memory Access
• w/o – fam file: General files
• WHILE compilation dest – orig dest ; run-time f – core: Arbitrary control structures
• with o – oof: The OOF base class
• within u1 u2 u3 – f core-ext: Numeric comparison
• word char "<chars>ccc<char>– c-addr core: The Input Stream
• wordlist – wid search: Word Lists
• words – tools: Word Lists
• write-file c-addr u1 wfileid – wior file: General files
• write-line c-addr u fileid – ior file: General files
• x-size xc-addr u1 – u2 xchar: Xchars and Unicode
• x-width xc-addr u – n xchar-ext: Xchars and Unicode
• x\string- xc-addr1 u1 – xc-addr1 u2 xchar: Xchars and Unicode
• xc!+? xc xc-addr1 u1 – xc-addr2 u2 f xchar-ext: Xchars and Unicode
• xc-size xc – u xchar-ext: Xchars and Unicode
• xc@+ xc-addr1 – xc-addr2 xc xchar-ext: Xchars and Unicode
• xchar+ xc-addr1 – xc-addr2 xchar-ext: Xchars and Unicode
• xchar- xc-addr1 – xc-addr2 xchar-ext: Xchars and Unicode
• xchar-encoding – addr u xchar-ext: Xchars and Unicode
• xemit xc – xchar-ext: Xchars and Unicode
• xkey – xc xchar-ext: Xchars and Unicode
• xor w1 w2 – w core: Bitwise operations
• xt-new ... class xt – object objects: Objects Glossary
• xt-see xt – gforth: Examining
• ~~ – gforth: Debugging