Claude
1c9a65c970
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01GE3SDvQn5EoxdGufk84zz2
322 lines
20 KiB
Plaintext
322 lines
20 KiB
Plaintext
# docs/reference/v4-dictionary.tsv -- the dictionary of v4 (#157): name, stack notation,
|
|
# description, tab-separated. The names are the live system's (v4/tools/mkdictionary.py
|
|
# check refuses a missing or a stale one). A row whose description starts TODO is a draft.
|
|
! ( x addr -- ) Store x in the cell at addr.
|
|
# ( ud1 -- ud2 ) Pictured output: divide ud1 by BASE, put the remainder's digit in front of the string being built, leave the quotient.
|
|
#> ( ud -- baddr u ) End pictured output: drop ud and leave the string built since <#.
|
|
#S ( ud -- 0 0 ) Pictured output: convert digits with # until the number is zero (at least one digit).
|
|
' ( -- addr ) ' xxx: the parameter field address of xxx; compiled as a literal when compiling.
|
|
( ( -- ) ( text): a comment, ended by the first ); immediate.
|
|
(.") ( -- ) The run time of .": print the string compiled after the call, and go on after it.
|
|
(ABORT") ( flag -- ) The run time of ABORT": if flag is not zero, print the string compiled after the call and ABORT.
|
|
(BITS) ( -- n ) The number of bits in a cell, counted at run time (forth79.4th; used by U/MOD).
|
|
(CONSOLE) ( -- addr ) Variable: the node that what this node prints is sent to, as messages (core.f18).
|
|
(LOG") ( level -- ) The run time of LOG-xxx": print the string compiled after the call if level is at or below LOG-LEVEL.
|
|
(LOST) ( -- addr ) Variable: a count of the messages this node has dropped -- nowhere to send them, or no room.
|
|
(ME) ( -- addr ) Variable: this node's number in the mesh.
|
|
(NB) ( -- n ) Constant: the bits in a cell, (BITS) counted once at load (forth79.4th).
|
|
(REFUSED) ( -- addr ) Variable: a count of the messages that came back to this node, refused.
|
|
(S") ( -- baddr u ) The run time of S": leave the address and length of the string compiled after the call.
|
|
(SEAL) ( -- ) What is in the dictionary now is the system: COLD returns to it and FORGET will not go below it.
|
|
(UD) ( -- addr ) Variable: U/MOD's divisor while it divides (forth79.4th).
|
|
(WORD-DEFINED) ( -- addr ) Variable: the hook told when an entry is made, with the xt its code will be at.
|
|
(WORD-FORGOTTEN) ( -- addr ) Variable: the hook told when entries are forgotten, with the word address they went from.
|
|
* ( n1 n2 -- n3 ) Multiply: the low cell of the product.
|
|
*/ ( n1 n2 n3 -- n4 ) n1 times n2 divided by n3, through a double-cell intermediate product.
|
|
*/MOD ( n1 n2 n3 -- n4 n5 ) n1 times n2 divided by n3, through a double product: n4 the remainder, n5 the quotient.
|
|
+ ( n1 n2 -- n3 ) Add.
|
|
+! ( n addr -- ) Add n to the cell at addr.
|
|
+LOOP ( n -- ) Compile-only: end a DO loop, adding n to the index; the loop ends when the index crosses the limit.
|
|
, ( x -- ) Compile x into the next cell of the dictionary.
|
|
- ( n1 n2 -- n3 ) Subtract: n1 minus n2.
|
|
-! ( n addr -- ) Subtract n from the cell at addr.
|
|
--> ( -- ) Go on loading with the next block; only in a block being loaded.
|
|
-ROT ( x1 x2 x3 -- x3 x1 x2 ) Rotate the top three values the other way from ROT.
|
|
-TRAILING ( baddr u1 -- baddr u2 ) The string without its trailing blanks.
|
|
. ( n -- ) Print n in the current BASE, then a blank.
|
|
." ( -- ) ." text": print the text -- now when interpreting, when the word runs when compiling.
|
|
.R ( n width -- ) Print n right-justified in a field of width characters.
|
|
.S ( -- ) Print the stack's depth and every value on it, the stack unchanged.
|
|
/ ( n1 n2 -- n3 ) Divide: the quotient of n1 by n2. Division by zero is error 11.
|
|
/MOD ( n1 n2 -- n3 n4 ) Divide n1 by n2: n3 the remainder, n4 the quotient.
|
|
0< ( n -- flag ) True if n is negative.
|
|
0<> ( x -- flag ) True if x is not zero.
|
|
0= ( x -- flag ) True if x is zero.
|
|
0> ( n -- flag ) True if n is greater than zero.
|
|
1+ ( n -- n+1 ) Add one.
|
|
1- ( n -- n-1 ) Subtract one.
|
|
2! ( x1 x2 addr -- ) Store the cell pair at addr: x2 at addr, x1 in the next cell.
|
|
2* ( n -- 2n ) Shift left one bit.
|
|
2+ ( n -- n+2 ) Add two.
|
|
2, ( x1 x2 -- ) Compile the cell pair into the dictionary.
|
|
2- ( n -- n-2 ) Subtract two.
|
|
2/ ( n -- n/2 ) Shift right one bit, keeping the sign.
|
|
2>R ( x1 x2 -- ) ( R: -- x1 x2 ) Compile-only: move the pair to the return stack.
|
|
2@ ( addr -- x1 x2 ) Fetch the cell pair at addr.
|
|
2DROP ( x1 x2 -- ) Drop the top pair.
|
|
2DUP ( x1 x2 -- x1 x2 x1 x2 ) Copy the top pair.
|
|
2OVER ( x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2 ) Copy the second pair to the top.
|
|
2R> ( -- x1 x2 ) ( R: x1 x2 -- ) Compile-only: move the pair from the return stack.
|
|
2R@ ( -- x1 x2 ) ( R: x1 x2 -- x1 x2 ) Compile-only: copy the pair on the return stack.
|
|
2ROT ( x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2 ) Rotate the top three pairs.
|
|
2SWAP ( x1 x2 x3 x4 -- x3 x4 x1 x2 ) Exchange the top two pairs.
|
|
79-STANDARD ( -- ) Run to be sure a FORTH-79 system is there; it is.
|
|
: ( -- ) : xxx: start a definition of xxx; it cannot be found until ; ends it.
|
|
; ( -- ) Compile-only: end the definition -- compile its return, let it be found, stop compiling.
|
|
< ( n1 n2 -- flag ) True if n1 is less than n2.
|
|
<# ( -- ) Begin pictured numeric output.
|
|
<= ( n1 n2 -- flag ) True if n1 is less than or equal to n2.
|
|
<> ( x1 x2 -- flag ) True if x1 and x2 differ.
|
|
= ( x1 x2 -- flag ) True if x1 equals x2.
|
|
> ( n1 n2 -- flag ) True if n1 is greater than n2.
|
|
>= ( n1 n2 -- flag ) True if n1 is greater than or equal to n2.
|
|
>BODY ( xt -- addr ) The parameter field of the word whose execution token is xt.
|
|
>IN ( -- addr ) Variable: the offset in the input buffer of the next character to read.
|
|
>LINK ( xt -- lfa ) The link field of the entry whose execution token is xt.
|
|
>NAME ( xt -- nfa ) The name field of the entry whose execution token is xt.
|
|
>R ( x -- ) ( R: -- x ) Compile-only: move x to the return stack.
|
|
? ( addr -- ) Print the number in the cell at addr.
|
|
?DO ( limit index -- ) Compile-only: begin a DO loop that is skipped when limit equals index.
|
|
?DUP ( x -- x x | 0 ) Copy x if it is not zero.
|
|
?TERMINAL ( -- flag ) True if a key has been pressed and is waiting.
|
|
@ ( addr -- x ) Fetch the cell at addr.
|
|
ABORT ( -- ) Empty the data and return stacks, set execution mode, return control to the terminal.
|
|
ABORT" ( flag -- ) ABORT" text": if flag is not zero, print the text and ABORT.
|
|
ABS ( n -- u ) The absolute value.
|
|
ACL-ALLOW! ( flag xt -- ) Set the word's allow flag (the word-level ACL); nothing on a pinned word.
|
|
ACL-ALLOW@ ( xt -- flag ) The word's allow flag.
|
|
ACL-HEAT@ ( xt -- heat ) How often the word has been used: its heat counter.
|
|
ACL-HOOK ( -- addr ) Variable: the execution token of the ACL recheck word, or 0 for none.
|
|
ACL-INHERIT ( src dst -- ) dst takes src's ACL mode; it is not pinned, its TTL is 0.
|
|
ACL-INIT-PRIMITIVES ( -- ) Set every word in every vocabulary to its starting ACL fields.
|
|
ACL-MODE! ( mode xt -- ) Set the word's ACL mode; nothing on a pinned word.
|
|
ACL-MODE@ ( xt -- mode ) The word's ACL mode.
|
|
ACL-PIN ( xt -- ) Pin the word: its ACL fields can no longer be changed. One-way.
|
|
ACL-PINNED? ( xt -- flag ) True if the word is pinned.
|
|
ACL-TTL! ( n xt -- ) Set the word's ACL time-to-live (0 to 65535); nothing on a pinned word.
|
|
ACL-TTL@ ( xt -- n ) The word's ACL time-to-live.
|
|
ACL-WORD-ID ( xt -- n ) A number for the word that never changes: its address.
|
|
AGAIN ( -- ) Compile-only: end a BEGIN loop that repeats for ever.
|
|
ALIGN ( -- ) Align the dictionary pointer to the next cell.
|
|
ALLOT ( n -- ) Reserve n cells of dictionary space.
|
|
AND ( x1 x2 -- x3 ) Bitwise and.
|
|
AWAIT ( node -- how ) Wait for the node's word on how its text ended: 0 QUIT, 1 completed, otherwise an error.
|
|
BASE ( -- addr ) Variable: the number base for conversion in and out.
|
|
BEGIN ( -- ) Compile-only: mark the start of a loop (UNTIL, WHILE ... REPEAT, AGAIN).
|
|
BL ( -- c ) Constant: the blank character, 32.
|
|
BLANK ( baddr u -- ) Fill u bytes from baddr with blanks.
|
|
BLK ( -- addr ) Variable: the block being interpreted, or 0 for the terminal.
|
|
BLOCK ( n -- baddr ) A buffer holding block n, read from storage if it is not already in one.
|
|
BUFFER ( n -- baddr ) A buffer assigned to block n, not read from storage.
|
|
BYE ( -- ) A cold restart of the machine (the kernel's word).
|
|
C! ( c baddr -- ) Store the byte c at baddr.
|
|
C, ( c -- ) Compile the byte c into the dictionary.
|
|
C@ ( baddr -- c ) Fetch the byte at baddr.
|
|
CASE ( -- ) Compile-only: begin a CASE ... OF ... ENDOF ... ENDCASE selection.
|
|
CELLS ( n1 -- n2 ) n1 cells, in address units.
|
|
CFA ( pfa -- cfa ) The code field address from the parameter field address.
|
|
CMOVE ( baddr1 baddr2 u -- ) Copy u bytes from baddr1 to baddr2, lowest first.
|
|
CMOVE> ( baddr1 baddr2 u -- ) Copy u bytes from baddr1 to baddr2, highest first (for overlapping moves up).
|
|
COLD ( -- ) Return the system to what it was when its capsules had just been loaded.
|
|
COMPARE ( baddr1 u1 baddr2 u2 -- n ) Compare two strings: 0 if equal, -1 if the first is lower, 1 if higher.
|
|
COMPILE ( -- ) COMPILE xxx: when the word containing this runs, compile xxx.
|
|
CONSTANT ( n -- ) CONSTANT xxx: define xxx, which leaves n.
|
|
CONTEXT ( -- addr ) Variable: the vocabulary searched first.
|
|
CONVERT ( d1 baddr1 -- d2 baddr2 ) Convert the digits from baddr1+1 into d1 in BASE; baddr2 is the first character that is not a digit.
|
|
COUNT ( baddr1 -- baddr2 u ) From a counted string: its first character's address and its length.
|
|
CR ( -- ) Print a new line.
|
|
CREATE ( -- ) CREATE xxx: an entry whose word leaves the address of its parameter field.
|
|
CURRENT ( -- addr ) Variable: the vocabulary new definitions go into.
|
|
D+ TODO ---- section 5.7: doubles ------------------------------------------------
|
|
D- TODO ---- doubles and mixed ----
|
|
D. TODO
|
|
D.R TODO
|
|
D0< TODO
|
|
D0= TODO
|
|
D2* TODO
|
|
D2/ TODO
|
|
D< TODO
|
|
D= TODO
|
|
DABS TODO
|
|
DECIMAL TODO
|
|
DEFAULT-ROUTE ( port -- ) TODO the port, by its number, leads toward every node not told of
|
|
DEFER TODO
|
|
DEFER@ TODO
|
|
DEFINITIONS TODO FORTH-79: new definitions go into the CONTEXT vocabulary from now on.
|
|
DEPTH TODO FORTH-79: how many values were on the stack before DEPTH
|
|
DMAX TODO
|
|
DMIN TODO
|
|
DNEGATE TODO
|
|
DO TODO
|
|
DOES> TODO
|
|
DROP TODO
|
|
DUMP TODO
|
|
DUP TODO ---- stack ----
|
|
ELSE TODO
|
|
EMIT TODO EMIT puts the character with what has been printed. Everything the node prints goes through EMIT. A is kept: the words that print have always been free to use it across an EMIT. As v3, only the low 8 bits of the character are printed. A BUFFER FOUND FULL is sent first. It is full when a flush of it ended in a fault -- the stack too deep to begin a message -- and what is printed next is that fault's own message: put where (OUT^) points, it would go past the buffer's end, and (OUT^) would never again be at the end to be flushed (MESH.md 7c.6).
|
|
EMPTY-BUFFERS TODO FORTH-79: forget what is in the buffers; nothing is written.
|
|
ENCLOSE ( baddr c -- baddr n1 n2 n3 ) TODO in the zero-terminated string at baddr: n1 the offset of the first character that is not c, n2 the offset of the first c after it, n3 the offset of the first character after that run of c.
|
|
ENDCASE TODO
|
|
ENDOF TODO
|
|
ERASE TODO
|
|
EXECUTE TODO
|
|
EXIT TODO FORTH-79: return from the definition at this point
|
|
EXPECT ( baddr n -- ) TODO FORTH-79: characters from the terminal are stored from baddr upward until a new-line or until n have been received; the new-line is taken but not stored. A zero is added after the text, so the buffer must hold n + 1 bytes. No action for n <= 0. SPAN is how many characters were stored (SPAN is not FORTH-79; v3 has it). A line longer than n leaves the rest, its new-line included, to be read next. It is what the prompt reads every line with, with whatever the user has left on the stack beneath it, so it works in (P) -- (P)+0 where the next character goes, (P)+1 how many more may come, (P)+2 where the first went -- and has at most three cells of its own on the data stack (D-2).
|
|
FALSE TODO
|
|
FENCE TODO
|
|
FILL TODO
|
|
FIND ( -- xt | 0 ) TODO FORTH-79: the compilation address of the next word in the input stream, or 0 if it is not in the dictionary.
|
|
FLUSH TODO As v3: the same.
|
|
FORGET TODO FORGET xxx FORTH-79: remove xxx and every word defined after it, in whatever vocabulary; the space they took is free again. A vocabulary that goes is no longer CONTEXT or CURRENT: FORTH is. A word that is not there is an error, and so is one below FENCE, which is where the capsule's own words are (code 10, "Protected word").
|
|
FORTH TODO FORTH-79: the primary vocabulary; it becomes the CONTEXT vocabulary.
|
|
GONE ( n node -- ) TODO tell the node that node n is gone. It acts on that only if this node is its centre: it forgets the way to n, and if it is waiting for n's answer the wait ends.
|
|
HERE TODO
|
|
HEX TODO
|
|
HIDDEN TODO
|
|
HOLD TODO
|
|
I TODO
|
|
IF TODO Native if leaves the flag, so both ways out of it drop it (section 2): IF a THEN if L1 drop a jump L2 L1: drop L2: IF a ELSE b THEN if L1 drop a jump L2 L1: drop b L2:
|
|
IMMEDIATE TODO
|
|
INTERPRET ( -- ) TODO FORTH-79: take words from the input stream until it is exhausted. A word in the dictionary is executed, or, when compiling and not immediate, compiled. Anything else must be a number in the current BASE: it is left on the stack, or compiled as a literal. What is neither, or a compile-only word met while interpreting, abandons the line, with v3's message: UNKNOWN WORD: 'xxx' xxx: compile-only
|
|
INVERT TODO
|
|
IS TODO
|
|
J TODO
|
|
KERNEL-WORD ( n -- ) TODO KERNEL-WORD xxx A WORD THAT ASKS THE KERNEL (docs/v4.0.0/ ENGINE.md 3.3). xxx is made a word whose whole body is "write n to the port": n is the number of a request, the port is the node's way to its kernel, and the write blocks the node until the kernel has served it (DECOMPOSITION.md section 6). xxx's arguments are whatever it finds on the data stack and its results are what the kernel leaves there. This is what a word that is a C function in v3 -- BIRTH, BLOCK, BYE -- is on a node. Not FORTH-79 and not in v3, where such a word is registered from C. The constant (PORT) is the port's word address.
|
|
KEY TODO
|
|
LATEST TODO
|
|
LEAVE TODO
|
|
LFA TODO
|
|
LINK> TODO
|
|
LIST TODO ---- LIST ---------------------------------------------------------------------- ( n -- ) as v3: a new line, "Block n", then sixteen lines of 64 characters, each after its number, and an empty line. SCR is left holding n. A character that is not printable is shown as a blank. (Q)+0 is the line, (Q)+1 the column, (Q)+2 the block's number.
|
|
LITERAL ( x -- ) TODO FORTH-79: if compiling, compile x as a literal
|
|
LOAD ( n -- ) TODO FORTH-79: interpret block n, then go on with what follows.
|
|
LOG-DEBUG TODO
|
|
LOG-DEBUG" TODO
|
|
LOG-DEBUG-STR ( baddr u -- ) TODO
|
|
LOG-ERROR TODO
|
|
LOG-ERROR" TODO
|
|
LOG-ERROR-STR ( baddr u -- ) TODO
|
|
LOG-INFO TODO
|
|
LOG-INFO" TODO
|
|
LOG-INFO-STR ( baddr u -- ) TODO
|
|
LOG-LEVEL! ( n -- ) TODO as v3: a level below 0 is 0, one above 4 is 4
|
|
LOG-LEVEL@ TODO
|
|
LOG-TEST TODO
|
|
LOG-TEST" TODO
|
|
LOG-TEST-STR ( baddr u -- ) TODO
|
|
LOG-WARN TODO
|
|
LOG-WARN" TODO
|
|
LOG-WARN-STR ( baddr u -- ) TODO
|
|
LOOP TODO
|
|
LSHIFT TODO ---- shifts ---- As v3, a count that is negative or as large as the cell is wide is an error (code 9, "Shift count out of range").
|
|
M* TODO The product's sign waits in (F), not on the return stack, for the same reason as SM/REM's.
|
|
M+ TODO
|
|
M- TODO
|
|
M/MOD TODO
|
|
MAX TODO
|
|
MIN TODO
|
|
MINT-ZUSE TODO
|
|
MOD TODO
|
|
MOVE TODO FORTH-79: n cells from addr1 to addr2, the cell at addr1 first.
|
|
NAME> TODO
|
|
NEGATE TODO
|
|
NEIGHBOUR ( node port -- ) TODO the node on the other end of the port, by its number; 0: none, or a device. Whoever wires the node tells it, and tells it again when the wiring changes. It is how a node knows who its centre is, the one node whose GONE it believes: (CENTRE).
|
|
NFA TODO
|
|
NO-ROUTE ( node -- ) TODO forget the way to that node, if one is known: what is for it then goes by the way for every node not told of, if there is one. The last way in the table takes its place.
|
|
NO-ROUTES ( -- ) TODO forget every way: for when the wiring has changed
|
|
NODE-ERROR TODO FORTH-79: clear the return stack, set execution mode, return control to the terminal; no message is given. The data stack is left as it is. NODE-ERROR, by name: how a definition written in FORTH raises an error. A store of a code that is not zero is the trap of D-18 -- the word goes no further, the message for the code is printed (-1: the word has printed its own) and the line ends with ERROR. The codes are listed in core.f18.
|
|
NOP TODO
|
|
NOT TODO
|
|
NUMBER ( baddr -- d ) TODO FORTH-79. What is not a number gives 0 and sets NODE-ERROR.
|
|
OCTAL TODO
|
|
OF TODO
|
|
OR TODO
|
|
ORDER ( -- ) TODO as v3's, but true: where names are looked for, and where new ones go
|
|
OVER TODO
|
|
PAD TODO
|
|
PAGE ( -- ) TODO clear the screen and put the cursor at the top, as v3: ESC [2J ESC [H
|
|
PFA TODO
|
|
PICK ( n -- x ) TODO FORTH-79: a copy of the n-th value, not counting n itself. 1 PICK is DUP, 2 PICK is OVER. n less than one is an error.
|
|
PORT! ( w port -- ) TODO write a cell to the port, by its number. It waits until the neighbour has taken it. This is how a node is sent a capsule of F18 code (docs/v4.0.0/MESH.md section 5): the cells go as they are, not as a message, to a node that is executing from its ports.
|
|
Q.* TODO ---- multiply ----
|
|
Q.+ TODO ---- the double words under other names ----
|
|
Q.- TODO
|
|
Q./ TODO
|
|
Q.0 TODO
|
|
Q.0= TODO
|
|
Q.1 TODO
|
|
Q.< TODO
|
|
Q.= TODO
|
|
Q.> TODO
|
|
Q.ABS TODO
|
|
Q.COS TODO
|
|
Q.EXP TODO ---- e to the x ----
|
|
Q.FROM-INT TODO ---- conversion and constants ----
|
|
Q.LOG TODO ---- natural logarithm ----
|
|
Q.MAX TODO
|
|
Q.MIN TODO
|
|
Q.NEG TODO
|
|
Q.PRINT TODO ---- printing ---- The integer part, a point, five digits, a blank; always in decimal.
|
|
Q.SCALE TODO
|
|
Q.SIN TODO
|
|
Q.SQRT TODO ---- square root ----
|
|
Q.TO-INT TODO
|
|
QUERY ( -- ) TODO FORTH-79: up to 80 characters, or a line, into TIB; >IN to 0.
|
|
QUIT TODO
|
|
R> TODO
|
|
R@ TODO
|
|
REPEAT TODO
|
|
ROLL ( n -- ) TODO FORTH-79: the n-th value, not counting n itself, is taken out and put on top. 3 ROLL is ROT, 2 ROLL is SWAP, 1 ROLL does nothing. n less than one is an error.
|
|
ROT TODO
|
|
ROUTE ( node port -- ) TODO the port, by its number, leads toward that node
|
|
RSHIFT TODO
|
|
S" ( -- baddr u ) TODO S" text" as v3. In a definition the text is compiled into it. At the prompt it is copied to PAD, where it stays until PAD is used again: WORD's buffer is overwritten by the very next word of the line.
|
|
S>D TODO
|
|
SAVE-BUFFERS TODO FORTH-79: write every block that has been UPDATEd.
|
|
SCAN TODO
|
|
SCR TODO
|
|
SEARCH TODO
|
|
SEND ( baddr u node -- ) TODO send the node u characters of text to interpret, by the way this node knows to it. What it prints there goes to that node's console. With no way to the node it is error 12.
|
|
SEND-ON ( baddr u node port -- ) TODO the same by a port this node names, by its number, whatever ways it knows: for a neighbour that has no number of its own yet, to which text is sent as to node 0.
|
|
SIGN TODO
|
|
SKIP TODO
|
|
SMUDGE TODO
|
|
SOURCE ( -- baddr u ) TODO the input buffer and how much of it is in use
|
|
SPACE TODO
|
|
SPACES TODO ---- spaces and the number base ----
|
|
SPAN TODO
|
|
STATE TODO
|
|
SWAP TODO
|
|
THEN TODO
|
|
THRU ( first last -- ) TODO as v3: LOAD each block from first to last.
|
|
TIB TODO
|
|
TRAVERSE ( baddr n -- baddr' ) TODO as v3: for n > 0, from a name's count byte to the byte after its last character; otherwise the address unchanged.
|
|
TRUE TODO
|
|
TYPE TODO
|
|
U* TODO
|
|
U. TODO
|
|
U.R TODO
|
|
U/MOD TODO
|
|
U< TODO
|
|
U> TODO
|
|
UM* TODO ---- section 4: multiply ------------------------------------------------
|
|
UNLOOP TODO
|
|
UNTIL TODO
|
|
UPDATE TODO FORTH-79: mark the block most recently asked for as changed, so that it is written before its buffer is used for another.
|
|
VARIABLE TODO FORTH-79: CREATE and one cell. The standard leaves its first value to the programme; here it is 0.
|
|
VERSION ( -- ) TODO which system this is, and its cell width
|
|
VLIST TODO
|
|
VOCABULARY TODO
|
|
WARM ( -- ) TODO as v3's message, and then ABORT: both stacks emptied, the prompt
|
|
WHILE TODO
|
|
WITHIN TODO
|
|
WORD TODO
|
|
WORDS ( -- ) TODO the names in the CONTEXT vocabulary, the newest first, a blank after each, a new line whenever one has passed column 64. Hidden entries -- a definition under way -- are not shown. (Q)+0 is the column.
|
|
XOR TODO
|
|
[ TODO
|
|
['] TODO ['] xxx the same inside a definition, whatever STATE is; and [LITERAL], which v3 has as another name for LITERAL.
|
|
[COMPILE] TODO [COMPILE] xxx FORTH-79: compile xxx even though it is immediate
|
|
[LITERAL] TODO
|
|
\ TODO
|
|
] TODO
|