Starting Forth Words                                        -*-org-*-

<pre>
Forth words introduced by chapter in "Starting Forth"[1].

* 1. Fundamental Forth

|-------------+--------------+----------------------------------------|
| : xxx yyy ; | --           | Create word xxx with definition yyy    |
| CR          | --           | Carriage return on terminal            |
| SPACES      | n --         | Print n spaces on terminal             |
| SPACE       | --           | Print one space on terminal            |
| EMIT        | c --         | Print character ASCII c on terminal    |
| ." xxx"     | --           | Print character string xxx on terminal |
| +           | n1 n2 -- sum | Addition                               |
| .           | n --         | Pop n from stack and print             |
|-------------+--------------+----------------------------------------|

* 2. How to Get Results

|-------+----------------------+----------------------------------|
| +     | n1 n2 -- sum         | Adds                             |
| -     | n1 n2 -- diff        | Subtracts n1 - n2                |
| *     | n1 n2 -- prod        | Multiplies                       |
| /     | n1 n2 -- quot        | Divides n1 / n2 (int. quotient)  |
| /MOD  | n1 n2 -- rem quot    | n2 / n2 remainder & quotient     |
| MOD   | n1 n2 -- rem         | n1 / n2 remainder                |
| SWAP  | n1 n2 -- n2 n1       | Reverse top two stack items      |
| DUP   | n -- n n             | Duplicate top stack item         |
| OVER  | n1 n2 -- n1 n2 n1    | Copy second stack item to top    |
| ROT   | n1 n2 n3 -- n2 n3 n1 | Rotate third stack item          |
| DROP  | n --                 | Discard top stack item           |
| .S    | --                   | Stack print (non-destructive)    |
| 2SWAP | d1 d2 -- d2 d1       | Reverse top two pairs of numbers |
| 2DUP  | d -- d d             | Duplicate top pair of numbers    |
| 2OVER | d1 d2 -- d1 d2 d1    | Copy second pair to top          |
| 2DROP | d --                 | Discard top pair                 |
|-------+----------------------+----------------------------------|

* 3. The Editor (and Staff)

|---------------+-----------+----------------------------------------|
| USE xxx       | --        | Use file xxx as Forth "disk"           |
| LIST          | n --      | List disk block n                      |
| LOAD          | n --      | Compile disk block n                   |
| ( xxx)        | --        | Comment                                |
| UPDATE        | --        | Mark current block modified            |
| EMPTY-BUFFERS | --        | Mark all blocks unmodified             |
| BLOCK         | u -- addr | Swap-in block u from mass storage      |
| INCLUDE xxx   | --        | Compile text file xxx                  |
| FORGET xxx    | --        | Remove definitions from xxx onward     |
| MARKER xxx    | --        | Set dictionary restore point           |
|               |           | (Executing xxx will remove later defs. |
|---------------+-----------+----------------------------------------|

* 4. Decisions, Decisions ...

|----------------------+----------+-----------------------------------------|
| IF xxx THEN          | IF: f -- | Execute xxx if f true (non-zero)        |
| IF xxx ELSE yyy THEN | IF: f -- | Execute xxx if f true, yyy if false (0) |
|----------------------+----------+-----------------------------------------|

|-------------+---------------+-----------------------------------|
| =           | n1 n2 -- f    | Test n1 = n2                      |
| -           | n1 n2 -- diff | (Equiv. to test n1 != n2)         |
| <           | n1 n2 -- f    | Test n1 < n2                      |
| >           | n1 n2 -- f    | Test n1 > n2                      |
| 0=          | n -- f        | Test n = 0                        |
| 0<          | n -- f        | Test n < 0                        |
| 0>          | n --f         | Test n > 0                        |
| AND         | n1 n2 -- and  | Logical and                       |
| OR          | n1 n2 -- or   | Logical or                        |
| ?DUP        | 0 -- 0        | Duplicate if n non-zero           |
|             | n -- n n      |                                   |
| ABORT" xxx" | f --          | If f true, abort with message xxx |
| ?STACK      | -- f          | True if stack underflow           |
| INVERT      | f -- f        | Logical not                       |
|-------------+---------------+-----------------------------------|

* 5. The Philosophy of Fixed Point

|--------+----------------------+-------------------------------------------|
| 1+     | n -- n+1             | Add one                                   |
| 1-     | n -- n11             | Subtract one                              |
| 2+     | n -- n+2             | Add two                                   |
| 2-     | n -- n-2             | Subtract two                              |
| 2*     | n -- n*2             | Mult. by two/Bit shift left               |
| 2/     | n -- n/1             | Div. by two/Bit shift right               |
| ABS    | n -- n-abs           | Absolute value                            |
| NEGATE | n -- -n              | Reverse sign                              |
| MIN    | n1 n2 -- min         | Minimum                                   |
| MAX    | n1 n2 -- max         | Maximum                                   |
| >R     | n --                 | Pop to return stack                       |
| R>     | -- n                 | Push from return stack                    |
| I      | -- n                 | Push copy of return stack top             |
| R@     | -- n                 | Push copy of return stack top             |
| J      | n -- n+1             | Push copy of return stack 3rd item        |
| */     | n1 n2 n3 -- quot     | n1*n2/n3 (intermed. result double-length) |
| */MOD  | n1 n2 n3 -- rem quot | n1*n2/n3 remainder, quotient              |
|--------+----------------------+-------------------------------------------|

* 6. Throw It For a Loop

|----------------------------+--------------------+--------------------------------|
| DO xxx LOOP                | DO: limit index -- | Execute xxx limit-index times  |
| DO xxx +LOOP               | DO: limit index -- | Execute xxx incrementing by n  |
|                            | +LOOP: n --        | from index to limit            |
| BEGIN xxx UNTIL            | UNTIL: f --        | Repeat xxx until f true        |
| BEGIN xxx WHILE yyy REPEAT | WHILE: f --        | Repeat xxx, then yyy if f true |
|----------------------------+--------------------+--------------------------------|

|-------+------------+----------------------------------------------------------|
| LEAVE | --         | Terminate loop immediately                               |
| U.R   | u width -- | Print u right-justified in field width                   |
| PAGE  | --         | Clear terminal and move cursor to upper left-hand corner |
| QUIT  | --         | Terminate task (supress "ok")                            |
| XX    | --         | Clear stacks (undefined word)                            |
|-------+------------+----------------------------------------------------------|

* 7. A Number of Kinds of Numbers

|-----------+---------------------+------------------------------------------------|
| U.        | u --                | Print unsigned number                          |
| UM*       | u1 u2 -- ud         | Return product of u1, u2 (single -> double)    |
| UM/MOD    | ud u1 -- u2 u3      | Divide double by single, return single-length  |
|           |                     | quotient, remainder                            |
| U<        | u1 u2 -- f          | Return u1<u2                                   |
| HEX       | --                  | Hexadecimal mode                               |
| OCTAL     | --                  | Octal mode                                     |
| DECIMAL   | --                  | Decimal mode                                   |
| <# xxx #> | d -- addr u         | Format unsigned double to string               |
| #         | --                  | Insert low digit in number format              |
| #S        | --                  | Insert rest of high digits in format           |
| c HOLD    | --                  | Insert ASCII code c in format                  |
| [CHAR] a  | -- c                | Return ASCII code for character a              |
| SIGN      | n -- n              | Insert minus sign in format if n<0             |
| D+        | d1 d2 -- d-sum      | Add (double-length)                            |
| D-        | d1 d2 -- d-diff     | Subtract (double-length)                       |
| DABS      | d -- d-abs          | Absolute value (double-length)                 |
| DNEGATE   | d -- -d             | Reverse sign (double-length)                   |
| DMAX      | d1 d2 -- d-max      | Maximum (double-length)                        |
| DMIN      | d1 d2 -- d-min      | Minimum (double-length)                        |
| D=        | d1 d2 -- f          | Test d1=d2 (double-length)                     |
| D0=       | d -- f              | Test d=0 (double-length)                       |
| D<        | d1 d2 -- f          | Test d1<d2 (double-length)                     |
| DU<       | ud1 ud2 -- f        | Test ud1<ud2 (double-length unsigned)          |
| D.R       | d width --          | Print d right-justified in field width         |
| M+        | d n -- d-sum        | Add d+n (mixed precision)                      |
| SM/REM    | d n1 -- n2 n3       | Divide d/n1 giving symmetric quot. n3, rem. n2 |
| FM/MOD    | d n1 -- n2 n3       | Divide d/n1 giving floored quot. n3, rem. n2   |
| M*        | n1 n2 -- d-prod     | Multiply n1*n2 giving double-length            |
| M*/       | d n1 n2 -- d-result | d*n1/n2 giving double-length                   |
|-----------+---------------------+------------------------------------------------|

* 8. Variables, Constants, and Arrays

|---------------+--------------+------------------------------------------------|
| CONSTANT xxx  | n --         | Create constant xxx with value n               |
|               | xxx: -- n    | xxx returns n                                  |
| VARIABLE xxx  | --           | Create variable xxx                            |
|               | xxx: -- addr | xxx returns var. address                       |
| CREATE xxx    | --           | Create dictionary entry xxx                    |
|               | xxx: -- addr | xxx returns entry address                      |
| !             | n addr --    | Store n at addr                                |
| @             | addr -- n    | Return contents of addr                        |
| ?             | addr --      | Print contents of addr                         |
| +!            | n addr --    | Add n to contents of addr                      |
| ALLOT         | n --         | Extend prev. dict. entry by n bytes            |
| CELL          | -- n         | Returns number of bytes per cell               |
| CELLS         | n -- bytes   | Returns bytes in n cells                       |
| ,             | n --         | Compile n into next cell in dict.              |
| C!            | b addr --    | Store 8-bit value b in addr                    |
| C@            | addr -- b    | Return 8-bit val. b from addr                  |
| FILL          | addr n b --  | Fill n bytes of mem. with b starting from addr |
| BASE          | -- addr      | Variable containing current numeric base       |
| 2CONSTANT xxx | d --         | Create double-length constant xxx              |
|               | xxx: -- d    |                                                |
| 2VARIABLE xxx | --           | Create double-length variable xxx              |
|               | xxx: -- addr |                                                |
| 2!            | d addr --    | Store double-length at addr                    |
| 2@            | addr -- d    | Fetch double-length fro addr                   |
| C,            | b --         | Compile b into next byte in dict.              |
| DUMP          | addr u --    | Display u bytes of mem. starting from addr     |
| ERASE         | addr n --    | Fill n bytes of mem. with 0 starting from addr |
|---------------+--------------+------------------------------------------------|

* Notes
  
[1] Leo Brodie. Starting Forth. Forth, Inc. 2003.
    http://www.forth.com/starting-forth/index.html
    accessed Nov. 1, 2011.

</pre>