
Z88 CamelForth v3.06 Glossary

Key to wordsets (uppercase=main set, lowercase=extension set): C=core; B=block; D=double-number; E=exception; Y=facility; F=file-access; T=programming tools; O=search-order; S=string; Z=non-standard; *=present in optional loadable file only.

C   !               x a-addr --                   Store cell                              memory
Z   !L              x dl-addr --                  Store cell to far memory                far-memory
C   #               ud1 -- ud2                    Convert a digit                         number
C   #>              ud -- c-addr u                End conversion                          number
Z   #INIT           -- n                          Size of initial uservariable data       memory
C   #S              ud1 -- ud2                    Convert remaining digits                number
Z   #TASKS          -- addr                       Number of active tasks                  multi
C   '               "<spaces>name" -- xt          Find word in dictionary                 string
CF  (               "ccc<paren>" --               Skip comment                            interpreter
Z   (ACC_EVT)       deferred: m l a p c -- m l a pAction to take on ACCEPT events         i/o
Z   (ACC_MAIL)      deferred: m l a p -- m l a p  Action to take each iteration of ACCEPT i/o
Z   (COLD)          deferred: --                  Cold start action                       misc
Z   (KEY)           deferred: u --                Action to take on KEY events            i/o
Z   (PKGERR)        deferred: rc --               Action to take on package errors        packages
Z   (PKGMIA)        deferred: callid --           Action to take on RC_PNF error          packages
Z   (PW)            --                            Default action for PW                   misc
Z   (RC_DRAW)       deferred: --                  RC_DRAW error action                    i/o
Z   (RC_ESC)        deferred: --                  RC_ESC error action                     i/o
Z   (RC_PNF)        pkgid --                      Standard action for RC_PNF error        packages
Z   (RC_QUIT)       deferred: --                  RC_QUIT error action                    i/o
Z   (RUN)           xt --                         Default action for RUN                  multi
C   *               n1 n2 -- n3                   Signed multiply                         arithmetic
C   */              n1 n2 n3 -- n4                Signed multiply,divide                  arithmetic
C   */MOD           n1 n2 n3 -- n4 n5             Signed multiply,divide (n5=quot)        arithmetic
Z   *CLI            c-addr n --                   Send string to CLI                      misc
Z   *NAME           c-addr n --                   Name CamelForth instantiation           misc
C   +               n1/u1 n2/u2 -- n3/u3          Add                                     arithmetic
C   +!              n/u a-addr --                 Add to memory cell                      memory
C   +LOOP           Runtime: n --                 Compile stepped loop end                structures
C   ,               x --                          Compile cell                            compiling
C   -               n1/u1 n2/u2 -- n3/u3          Subtract n2/u2 from n1/u1               arithmetic
Z   -1              -- -1                         Push -1 onto the stack                  constants
S   -TRAILING       c-addr u1 -- c-addr u2        Trim trailing spaces                    string
C   .               n --                          Display signed number                   number
C   ."              "ccc<quote>" --               Compile code to display string          i/o
c   .(              "ccc<paren>" --               Parse and display input del'd by )      tools
c   .R              n1 n2 --                      Display signed number right-just        number
T   .S              --                            Display data stack contents             tools
C   /               n1 n2 -- n3                   Signed division                         arithmetic
C   /MOD            n1 n2 -- n3 n4                Signed division (n3=rem,n4=quot)        arithmetic
S   /STRING         c-addr u n -- c-addr' u'      String minus first n chars              string
Z   0               -- 0                          Push 0 onto the stack                   constants
Z   0"              "ccc<quote>" --               Compile null-terminated string          string
C   0<              n -- flag                     Test TOS<0                              comparison
c   0<>             n/u -- flag                   Test inequality to zero                 comparison
C   0=              n/u -- flag                   Test TOS=0                              comparison
c   0>              n -- flag                     Test if greater than zero               comparison
Z   0PAD            -- a-addr                     Null-term string scratch pad            string
Z   0TYPE           c-addr --                     Type null-terminated string (OZ)        i/o
Z   1               -- 1                          Push 1 onto the stack                   constants
C   1+              n1/u1 -- n2/u2                Increment                               arithmetic
C   1-              n1/u1 -- n2/u2                Decrement                               arithmetic
C   2!              x1 x2 a-addr --               Store two cells                         memory
C   2*              x1 -- x2                      Arithmetic left shift                   arithmetic
C   2/              x1 -- x2                      Arithmetic right shift                  arithmetic
c   2>R             x1 x2 --  R: -- x1 x2         Double-push to return stack             stack
C   2@              a-addr -- x1 x2               Fetch two cells                         memory
C   2DROP           x1 x2 --                      Drop two cells                          stack
C   2DUP            x1 x2 -- x1 x2 x1 x2          Duplicate top two cells                 stack
C   2OVER           x1x2x3x4 -- x1x2x3x4x1x2      Double-cell OVER                        stack
c   2R>             -- x1 x2  R: x1 x2 --         Double-pop from return stack            stack
c   2R@             -- x1 x2  R: x1 x2 -- x1 x2   Double fetch from return stack          stack
C   2SWAP           x1 x2 x3 x4 -- x3 x4 x1 x2    Swap top two pairs                      stack
C   :               "<spaces>name" --             Begin colon definition                  defining
c   :NONAME         -- xt                         Start unnamed colon definition          defining
C   ;               --                            End colon definition                    defining
C   <               n1 n2 -- flag                 Test n1<n2 (signed)                     comparison
C   <#              --                            Begin number conversion                 number
c   <>              x1 x2 -- flag                 Test inequality                         comparison
C   =               x1 x2 -- flag                 Test equality                           comparison
C   >               n1 n2 -- flag                 Test n1>n2 (signed)                     comparison
Z   ><              x1 -- x2                      Swap bytes                              arithmetic
C   >BODY           xt -- a-addr                  Address of parameter field              compiling
Z   >FAR            addr -- dl-addr               Convert local address to far            far-memory
C   >IN             -- a-addr                     Input pointer                           interpreter
Z   >LOWER          c-addr n --                   Make string lowercase                   string
C   >NUMBER         ud addr u -- ud' addr' u'     Convert string to number                number
C   >R              x --    R: -- x               Push to return stack                    stack
Z   >UPPER          c-addr n --                   Make string uppercase                   string
T   ?               a-addr --                     Display cell contents                   tools
c   ?DO             n1/u1 n2/u2 --                Execute loop if n1/u1 <> n2/u2          structures
C   ?DUP            x -- 0 | x x                  DUP if non-zero top of stack            stack
Z   ?IF             Runtime: x -- x               Compile non-destructive conditional branchstructures
C   @               a-addr -- x                   Fetch cell                              memory
Z   @L              dl-addr -- x                  Fetch cell from far memory              far-memory
Ce  ABORT           i*x --  R: j*x --             Generate exception -1                   exception
Ce  ABORT"          i*x x -- |i*x  R:j*x-- |j*x   Exception -2 if TOS non-zero            exception
Z   ABORT"S         -- a-addr                     String for ABORT"                       exception
C   ABS             n -- +n                       Absolute value                          arithmetic
C   ACCEPT          c-addr +n1|-n1 -- +n2         Get line from terminal                  i/o
c   AGAIN           Runtime: --                   Compile unconditional branch            structures
C   ALIGN           --                            Align dataspace pointer                 memory
C   ALIGNED         addr -- a-addr                Align address                           memory
Z   ALLOCATE        ud -- dl-addr ior             Allocate ud bytes                       far-memory
C   ALLOT           n --                          Allocate dataspace address units        memory
o   ALSO            --                            Duplicate first search wordlist         wordlists
C   AND             x1 x2 -- x3                   Logical AND                             arithmetic
Y   AT-XY           u1 u2 --                      Move cursor to col u1, row u2           i/o
Z   AT?             -- x y                        Get current cursor position             i/o
Z   AWAKE?          task -- task'|0               Find task linking to this one           multi
Z   AYT?            pkgid -- ver | 0              Package "are-you-there?"                packages
C   BASE            -- a-addr                     Conversion radix                        arithmetic
C   BEGIN           Runtime: --                   Compile target for branch               structures
F   BIN             fam -- fam'                   Convert access method to binary         file
C   BL              -- char                       ASCII space character                   i/o
S   BLANK           c-addr u --                   Fill memory with blanks                 string
B   BLK             -- a-addr                     Input block                             block
Z   BLKS            n --                                                                  Allocate block buffers
B   BLOCK           u -- c-addr                   Read block and get buffer address       block
B   BUFFER          u -- c-addr                   Get address of buffer for block         block
t   BYE             --                            Exit to operating system                misc
C   C!              char c-addr --                Store character                         memory
Z   C!L             char dl-addr --               Store character to far memory           far-memory
C   C,              char --                       Compile character                       compiling
C   C@              c-addr -- char                Fetch character                         memory
Z   C@L             dl-addr -- char               Fetch character from far memory         far-memory
Z   CAMEL           --                            Standard cold start word                misc
c   CASE            Runtime: x1 -- x1             Compile conditional select start        structures
E   CATCH           i*x xt -- j*x 0 | i*x n       Execute word, catching exceptions       exception
C   CELL+           a-addr1 -- a-addr2            Add cell size to address                memory
C   CELLS           n1 -- n2                      Size of n1 cells                        memory
Z   CEMIT           char --                       Ouput character (ANSI)                  i/o
C   CHAR            "<spaces>char" -- char        Parse ASCII char                        string
C   CHAR+           c-addr1 -- c-addr2            Add char size to address                memory
C   CHARS           n1 -- n2                      Size of n1 chars                        memory
Z   CHECKMAIL       c-addr--false|caddr' n true   Check for new mail                      misc
Z   CINIT           --                            Initialise console window               i/o
Z   CKEY            -- char                       Get keyboard character (ANSI)           i/o
F   CLOSE-FILE      id -- ior                     Close file                              file
S   CMOVE           c-addr1 c-addr2 u --          Move string from bottom                 string
S   CMOVE>          c-addr1 c-addr2 u --          Move string from top                    string
Z   CMOVEL          dl-addr1 dl-addr2 u --        Move bytes in far memory                far-memory
t   CODE            "<spaces>name" --             Start code definition                   defining
Z   COLD            --                            Cold start Forth system                 misc
S   COMPARE         caddr1 u1 caddr2 u2 -- n      Compare strings                         string
c   COMPILE,        xt --                         Compile execution token                 compiling
C   CONSTANT        x "<spaces>name" --           Define a constant                       defining
Z   COS             n1 -- n2                      Get 1000*COS of angle                   arithmetic
Z   COS*            n1 n2 -- n3                   Multiply n1 by COS of n2                arithmetic
C   COUNT           c-addr1 -- c-addr2 u          Counted to string                       string
C   CR              --                            Output newline                          i/o
C   CREATE          "<spaces>name" --             Create new definition                   defining
F   CREATE-FILE     c-addr u fam -- id ior        Create new file                         file
Z   CTYPE           c-addr +n --                  Output string (ANSI)                    i/o
D   D+              d1 d2 -- d3                   Double number addition                  arithmetic
D   D-              d1 d2 -- d3                   Double number subtraction               arithmetic
D   DABS            d -- +d                       Absolute double number                  arithmetic
C   DECIMAL         --                            Set base to decimal                     number
Z   DEFER           "name" --                     Define deferred word                    defining
O   DEFINITIONS     --                            Set compilation to first search         wordlists
Z   DEFUDG          addr char --                  Define UDG                              windows
F   DELETE-FILE     c-addr u -- ior               Delete file                             file
C   DEPTH           -- +n                         Number of items on stack                stack
D   DNEGATE         d1 -- d2                      Double number negate                    arithmetic
C   DO              Runtime: n1 n2 --             Compile loop start                      structures
C   DOES>           --                            Change action of latest definition      defining
Z   DP              -- a-addr                     Current dataspace pointer               compiling
C   DROP            x --                          Discard top of stack                    stack
d   DU<             ud1 ud2 -- flag               Test ud1<ud2 (unsigned)                 comparison
t*  DUMP            c-addr u --                   Dump data in hex                        tools
C   DUP             x -- x x                      Duplicate top of stack                  stack
Z   EALIGN          char --                       Set text alignment                      windows
Z   EAPPLY          n --                          Apply effects to n chars                windows
Z   EAPPLYX         n --                          Apply (XOR) effects to n chars          windows
Z   ECLR            char --                       Clear text effect                       windows
t*  EDITOR          --                            Set first wordlist in search-order to Editorblock
y   EKEY            deferred: -- u                Get keyboard event                      i/o
y   EKEY>CHAR       u -- u false | char true      Convert keyboard event to character     i/o
y   EKEY?           -- flag                       Test if keyboard event available        i/o
C   ELSE            Runtime: --                   Resolve cond/compile uncond branch      structures
C   EMIT            deferred: char --             Emit character to terminal              i/o
y   EMIT?           -- flag                       Test if output device ready             i/o
b   EMPTY-BUFFERS   --                            Unassign block buffers                  block
c   ENDCASE         Runtime: x1 --                Resolve conditional select struct       structures
c   ENDOF           Runtime: --                   Resolve select                          structures
C   ENVIRONMENT?    c-addr u -- false|i*x true    System query                            environment
Z   ENVVAR          n*x n "<spaces>name" --       Create new environment variable         environment
c   ERASE           c-addr u --                   Fill memory with nulls                  memory
Z   ESCAPE          --                            Standard RC_ESC error word              misc
Z   ESET            char --                       Set text effect                         windows
Z   ETOG            char --                       Toggle text effect                      windows
CB  EVALUATE        i*x caddr u -- j*x            Interpret string                        interpreter
C   EXECUTE         i*x xt -- j*x                 Execute Forth word                      compiling
C   EXIT            --                            Exit a colon definition                 structures
Z   EXP?            -- flag                       Test for expanded Z88                   misc
Z   EXTEND-FILE     ud id -- ior                  Extend file to new size                 file
c   FALSE           -- flag                       False                                   comparison
Z   FAST?           -- flag                                                               Get fast compilation mode
Z   FCODE           "<spaces>name" --             Start fast code definition              defining
F   FILE-POSITION   id -- ud ior                  Get current filepointer                 file
F   FILE-SIZE       id -- ud ior                  Get size of file                        file
f   FILE-STATUS     c-addr u -- addr ior          Get status: addr of cre/upd times       file
C   FILL            c-addr u char --              Fill memory with char                   string
CO  FIND            c-addr--c-addr 0|xt 1|xt -1   Find word in dictionary                 string
B   FLUSH           --                            Save and unassign block buffers         block
f   FLUSH-FILE      id -- ior                     Flush file from buffer                  file
C   FM/MOD          d1 n1 -- n2 n3                Floored signed division (n3=quot)       arithmetic
Z   FNEXT           --                            End fast code definition                defining
Z   FOR             Runtime: u --                 Compile loop start                      structures
o   FORTH           --                            Set first search to FORTH-WORDLIST      wordlists
O   FORTH-WORDLIST  -- wid                        Wordlist containing FORTH words         wordlists
Z   FREE            dl-addr -- ior                Free allocation at dl-addr              far-memory
Z   FREEALL         --                            Free all far memory                     far-memory
Z   FWORDS          u1 u2 --                      Display fast words in search-order      tools
Z   GBASE           -- addr                       Variable containing pointer to map      graphics
Z   GBOX            w h --                        Draw box (relative)                     graphics
Z   GCIRCLE         x y r --                      Draw circle                             graphics
Z   GELLIPSE        x y w h --                    Draw ellipse                            graphics
O   GET-CURRENT     -- wid                        Get compilation wordlist                wordlists
O   GET-ORDER       -- widn...wid1 n              Get search order                        wordlists
Z   GFILL           x y --                        Fill with solid pixels                  graphics
Z   GLINE           w h --                        Draw line (relative)                    graphics
Z   GLINETO         x y --                        Draw line (absolute)                    graphics
Z   GMODE           -- caddr                      Mode cvariable                          graphics
Z   GMOVE           x y --                        Define last point                       graphics
Z   GPAGE           --                            Clear graphics area                     graphics
Z   GPATTERN        x y c-addr --                 Fill with pattern                       graphics
Z   GPIXEL          x y --                        Draw pixel                              graphics
Z   GPOS?           -- x y                        Get last point                          graphics
Z   GREY            --                            Grey out current window                 windows
Z   GSET?           x y -- flag                   Test if pixel set                       graphics
Z   GSHADE          x y --                        Fill with alternate pixels              graphics
C   HERE            -- addr                       Get dataspace pointer                   memory
c   HEX             --                            Set base to hexadecimal                 number
C   HOLD            char --                       Insert char in numeric output           number
Z   HOLE            -- a-addr                     Hole to give back on pre-emption        misc
C   I               -- n  R: s1 s2 -- s1 s2       Get inner loop index                    structures
C   IF              Runtime: x --                 Compile conditional branch              structures
C   IMMEDIATE       --                            Make last definition immediate          defining
Z   INACC?          -- c-addr                     Char variable; true if in ACCEPT        i/o
F   INCLUDE-FILE    i*x id -- j*x                 Interpret from file                     file
F   INCLUDED        i*x c-addr u -- j*x           Interpret from file                     file
Z   INT>T&D         addr -- s min h d mth y       Convert internal machine time/date      misc
Z   INTT&D          -- addr                       Get internal machine time & date        misc
C   INVERT          x1 -- x2                      Bitwise inversion                       arithmetic
Z   IS              xt "name" --                  Set deferred word action                defining
C   J               -- n  R: 4*s -- 4*s           Get 2nd loop index                      structures
Z   JOIN            n1 n2 -- x                    Join bytes into word (n2 high)          arithmetic
C   KEY             deferred: -- char             Get character from terminal             i/o
Y   KEY?            -- flag                       Test if keyboard char available         i/o
Z   LATEST          -- a-addr                     Last word link                          compiling
C   LEAVE           --                            Compile loop exit                       structures
Z   LINK            -- task                       Current task (holds next task)          multi
b*  LIST            u --                          List block                              block
C   LITERAL         x --                          Compile literal to definition           compiling
B   LOAD            i*x u -- j*x                  Interpret from block                    block
C   LOOP            Runtime: --                   Compile loop end                        structures
C   LSHIFT          x1 u -- x2                    Logical left shift of u places          arithmetic
C   M*              n1 n2 -- d                    Mixed multiply                          arithmetic
D   M+              d1/ud1 n -- d2/ud2            Add to double number                    arithmetic
Z   MAP             c-addr u n --                 Map block range to file                 block
C   MAX             n1 n2 -- n3                   Maximum value                           arithmetic
C   MIN             n1 n2 -- n3                   Minimum value                           arithmetic
C   MOD             n1 n2 -- n3                   Signed remainder                        arithmetic
C   MOVE            addr1 addr2 u --              Smart address unit movee                memory
y   MS              u --                          Wait at least u milliseconds            misc
Z   MULTI           --                            Enable multitasking                     multi
C   NEGATE          n1 -- n2                      Mathematical inversion                  arithmetic
Z   NEXT            --                            End code definition (jump to NEXT)      defining
c   NIP             x1 x2 -- x2                   Discard 2nd stack item                  stack
Z   NJOIN           x1 x2 n -- x                  Join n hi bits (x2) with x1             arithmetic
Z   NOOP            --                            Do nothing                              misc
Z   NS              --                            Set name/codespace to dataspace         compiling
Z   NSPLIT          x n -- x1 x2                  Split: n hi bits (x2), rest low (x1)    arithmetic
c   OF              Runtime: x1 x2 -- | x1        Compile select                          structures
o   ONLY            --                            Set minimum search order                wordlists
F   OPEN-FILE       c-addr u fam -- id ior        Open existing file                      file
Z   OPENMAP         id --                         Open window to map area                 graphics
Z   OPENPOPUP       x y w h c-addr id --          Open "popup" dialog box                 windows
Z   OPENTITLED      x y w h c-addr id --          Open window with title                  windows
Z   OPENWINDOW      x y w h id --                 Open text window                        windows
C   OR              x1 x2 -- x3                   Logical OR                              arithmetic
o   ORDER           --                            Display search order                    wordlists
Z   OS_ESC          u -- x                        OZ ESCape handling                      misc
C   OVER            x1 x2 -- x1 x2 x1             Copy 2nd stack item to top              stack
c   PAD             -- a-addr                     Scratch pad                             string
Y   PAGE            --                            New output page                         i/o
c   PARSE           "ccc<char>" -- c-addr n       Parse input delimited by char           string
Z   PAUSE           --                            Switch tasks                            multi
Z   PC!             char c-addr --                Output to port                          memory
Z   PC@             c-addr -- char                Input from port                         memory
Z   PID             -- pid                        Get current process ID                  packages
Z   PKGCALL         rs np mv re callid "name"--   Define C-style package call             packages
Z   PKGERR          rc --                         Standard action for package errors      packages
Z   PKGINF          pkgid -- 0addr Dmem hdls u    Get package information                 packages
Z   PKGS?           -- flag                       Check for package handling              packages
Z   POLARITY        n -- 0 | 1 | -1               Get sign of number                      arithmetic
Z   POOL            ud "name" --                  Create pool for up to ud bytes          far-memory
C   POSTPONE        "<spaces>name" --             Postpone action of next word            compiling
o   PREVIOUS        --                            Drop first wordlist in search order     wordlists
Z   PURGE           --                            Stop all tasks                          multi
Z   PW              deferred: --                  Pause for user                          deferred
C   QUIT            --  R: i*x --                 Interpret from keyboard                 interpreter
F   R/O             -- fam                        Read-only access method                 file
F   R/W             -- fam                        Read-write access method                file
C   R>              -- x  R: x--                  Pop from return stack                   stack
C   R@              -- x  R: x -- x               Fetch from return stack                 stack
Z   RAM             --                            Set dataspace to RAM                    compiling
Z   RAND            u --                          Seed random number generator            misc
F   READ-FILE       c-addr u1 id -- u2 ior        Read file (u2=chars read)               file
F   READ-LINE       c-addr u1 id -- u2 flag ior   Read line (u2=chars read)               file
C   RECURSE         --                            Recurse current definition              defining
cbf REFILL          -- flag                       Refill source from input                interpreter
f   RENAME-FILE     c-addr1 u1 c-addr2 u2 --ior   Rename file                             file
C   REPEAT          Runtime: --                   Compile uncond,resolve cond branch      structures
F   REPOSITION-FILE ud id -- ior                  Change filepointer                      file
F   RESIZE-FILE     ud id -- ior                  Change size of file                     file
c   RESTORE-INPUT   x1..xn n -- flag              Restore current input                   interpreter
Z   RND             u1 -- u2                      Get random number                       misc
Z   ROM1            --                            Set dataspace to ROM segment 1          compiling
Z   ROM2            --                            Set dataspace to ROM segment 2          compiling
C   ROT             x1 x2 x3 -- x2 x3 x1          Rotate top three items                  stack
C   RSHIFT          x1 u -- x2                    Logical right shift of u places         arithmetic
Z   RUN             deferred: xt --               Run xt as a task                        multi
CF  S"              "ccc<quote>" -- c-addr u      Compile/parse string                    string
Z   S=              c-addr1 c-addr2 u -- n        String compare, n=string1-string2       string
Z   S>0             c-addr n -- c-addr'           Convert to nul-terminated string        string
C   S>D             n -- d                        Single to double number                 arithmetic
B   SAVE-BUFFERS    --                            Save updated block buffers              block
c   SAVE-INPUT      -- x1..xn n                   Save current input                      interpreter
Z   SCAN            c-addr u char -- c-addr' u'   Find matching char                      string
b*  SCR             -- a-addr                     Number of last listed screen            block
Z   SCRDOWN         --                            Scroll window down                      windows
Z   SCRUP           --                            Scroll window up                        windows
S   SEARCH          ca1 u1 ca2 u2 -- ca3 u3 f     Search string for substring             string
O   SEARCH-WORDLIST caddr u wid -- 0|xt 1|xt -1   Search in specified wordlist            wordlists
Z   SENDMAIL        c-addr1|0 caddr-2 n --        Send data to mailbox                    misc
O   SET-CURRENT     wid --                        Set compilation wordlist                wordlists
O   SET-ORDER       widn...wid1 n                 Set search order                        wordlists
C   SIGN            n --                          Insert minus sign if n negative         number
Z   SIN             n1 -- n2                      Get 1000*SIN of angle                   arithmetic
Z   SIN*            n1 n2 -- n3                   Multiply n1 by SIN of n2                arithmetic
Z   SINGLE          --                            Disable multitasking                    multi
Z   SLEEP           task --                       Deactivate task                         multi
S   SLITERAL        c-addr u --                   Compile literal string                  string
C   SM/REM          d1 n1 -- n2 n3                Symmetric signed division (n3=quot)     arithmetic
C   SOURCE          -- c-addr n                   Get source specification                interpreter
cF  SOURCE-ID       -- u                          Input source identifier                 interpreter
C   SPACE           --                            Output space                            i/o
C   SPACES          n --                          Output spaces                           i/o
Z   SPLIT           x -- n1 n2                    Split word into bytes (n2 high)         arithmetic
C   STATE           -- a-addr                     Compiler state                          compiling
Z   STEP            Runtime: --                   Compile loop end                        structures
Z   STOP            --                            Halt current task                       multi
C   SWAP            x1 x2 -- x2 x1                Swap top two items                      stack
Z   TASK!           xt task --                    Initialise task                         multi
Z   TASK:           "spaces<name>" --             Create new task                         multi
Z   TERM            -- task                       Terminal task                           multi
C   THEN            Runtime: --                   Resolve branch                          structures
E   THROW           k*x n -- k*x | i*x n          If TOS non-zero, generate exception     exception
b   THRU            i*x u1 u2 -- j*x              Interpret from multiple blocks          block
c   TIB             -- a-addr                     Address of TIB                          interpreter
y   TIME&DATE       -- s min h d mth y            Get current time & date                 misc
c   TO              x "<spaces>name" --           Change named value                      defining
c   TRUE            -- flag                       True                                    comparison
c   TUCK            x1 x2 -- x2 x1 x2             Copy top item below 2nd                 stack
C   TYPE            deferred: c-addr u --         Type string to terminal                 i/o
C   U.              u --                          Display unsigned number                 number
c   U.R             u n --                        Display unsigned number right-just      number
Z   U0              -- a-addr                     User variables base                     memory
C   U<              u1 u2 -- flag                 Test u1<u2 (unsigned)                   comparison
c   U>              u1 u2 -- flag                 Test u1>u2 (unsigned)                   comparison
Z   UD*             ud1 u2 -- ud3                 Mixed multiply                          arithmetic
Z   UD/MOD          ud1 u2 -- u3 ud4              Mixed divide                            arithmetic
Z   UDG             char --                       Display UDG                             windows
Z   UINIT           -- a-addr                     Initial uservariable values             memory
C   UM*             u1 u2 -- ud                   Unsigned single>double multiply         arithmetic
C   UM/MOD          ud u1 -- u2 u3                Unsigned d>s divide (u2=rem,u3=quo)     arithmetic
Z   UMAX            u1 u2 -- u3                   Unsigned maximum                        arithmetic
Z   UMIN            u1 u2 -- u3                   Unsigned minimum                        arithmetic
Z   UNGREY          --                            Ungrey current window                   windows
C   UNLOOP          R: s1 s2 --                   Drop loop parameters                    structures
Z   UNMAP           n --                          Unmap block range                       block
C   UNTIL           Runtime: x --                 Compile cond branch resolution          structures
c   UNUSED          -- u                          Size of current dataspace unused        compiling
B   UPDATE          --                            Mark block buffer as updated            block
c   VALUE           x "<spaces>name" --           Create named value                      defining
C   VARIABLE        "<spaces>name" --             Define a variable                       defining
Z   VOCABULARY      "<spaces>name" --             Create new vocabulary                   wordlists
F   W/O             -- fam                        Write-only access method                file
Z   WAKE            task --                       Activate task                           multi
C   WHILE           Runtime: x --                 Compile cond branch                     structures
Z   WINDOW          id --                         Select window for output                windows
Z   WINDOW?         -- w h id                     Enquire current window parameters       windows
c   WITHIN          n1|u1 n2|u2 n3|u3 -- flag     Test if n1/u1 within range              arithmetic
C   WORD            char "ccc<char>" -- c-addr    Parse word delimited by char            string
O   WORDLIST        -- wid                        Create new empty wordlist               wordlists
T   WORDS           --                            Display words in search-order           tools
F   WRITE-FILE      c-addr u1 id -- ior           Write file                              file
F   WRITE-LINE      c-addr u1 id -- ior           Write line                              file
Z   XCHAR           char --                       Display special character               windows
Z   XLINE           char --                       Display line character                  windows
C   XOR             x1 x2 -- x3                   Logical XOR                             arithmetic
C   [               --                            Enter interpretative state              compiling
C   [']             "<spaces>name" --             Find word and compile exec. token       compiling
C   [CHAR]          "<spaces>char" --             Compile character literal               compiling
cb  \               --                            Skip one-line comment                   interpreter
C   ]               --                            Enter compilation state                 compiling
Z   {               --                            Enter fast compilation mode             compiling
Z   }               --                            Leave fast compilation mode             compiling