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>