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 fi