LithosAnanke/docs/reference/v4-dictionary.tsv

# 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+	( d1 d2 -- d3 )	Add two double-cell numbers.
D-	( d1 d2 -- d3 )	Subtract d2 from d1.
D.	( d -- )	Print the double-cell number d, then a blank.
D.R	( d width -- )	Print d right-justified in a field of width characters.
D0<	( d -- flag )	True if d is negative.
D0=	( d -- flag )	True if d is zero.
D2*	( d1 -- d2 )	Shift d1 left one bit.
D2/	( d1 -- d2 )	Shift d1 right one bit, keeping the sign.
D<	( d1 d2 -- flag )	True if d1 is less than d2.
D=	( d1 d2 -- flag )	True if d1 equals d2.
DABS	( d -- ud )	The absolute value of d.
DECIMAL	( -- )	Set BASE to ten.
DEFAULT-ROUTE	( port -- )	The port, by its number, leads toward every node this node has not been told of.
DEFER	( -- )	DEFER xxx: define xxx, whose action is set later by IS; run unset, it is error 15.
DEFER@	( -- xt )	DEFER@ xxx: the execution token xxx runs now; compiled when compiling.
DEFINITIONS	( -- )	New definitions go into the CONTEXT vocabulary from now on.
DEPTH	( -- n )	The number of values on the stack before DEPTH.
DMAX	( d1 d2 -- d3 )	The greater of two doubles.
DMIN	( d1 d2 -- d3 )	The lesser of two doubles.
DNEGATE	( d -- -d )	Negate a double-cell number.
DO	( limit index -- )	Compile-only: begin a counted loop, ended by LOOP or +LOOP.
DOES>	( -- )	Compile-only: in a defining word, what the words it defines do, with their parameter field's address on the stack.
DROP	( x -- )	Drop the top value.
DUMP	( baddr u -- )	Print u bytes from baddr in the current BASE, with their addresses.
DUP	( x -- x x )	Copy the top value.
ELSE	( -- )	Compile-only: the other branch of IF ... ELSE ... THEN.
EMIT	( c -- )	Print the character c.
EMPTY-BUFFERS	( -- )	Forget what is in the block buffers; nothing is written.
ENCLOSE	( baddr c -- baddr n1 n2 n3 )	Find a word delimited by c in the string at baddr: n1 its start, n2 its end, n3 the offset after the delimiter.
ENDCASE	( x -- )	Compile-only: end a CASE selection, dropping the value if no OF matched.
ENDOF	( -- )	Compile-only: end an OF branch; go on after ENDCASE.
ERASE	( baddr u -- )	Fill u bytes from baddr with zeros.
EXECUTE	( xt -- )	Run the word whose execution token is xt.
EXIT	( -- )	Compile-only: return from the definition at this point.
EXPECT	( baddr n -- )	Read up to n characters, or a line, from the terminal into baddr; SPAN holds how many.
FALSE	( -- 0 )	Constant: the false flag, zero.
FENCE	( -- addr )	Variable: FORGET will not remove anything below the address it holds.
FILL	( baddr u c -- )	Fill u bytes from baddr with the byte c.
FIND	( -- xt | 0 )	FIND xxx: the execution token of xxx, from the input stream, or 0 if it is not found.
FLUSH	( -- )	Write every changed block (SAVE-BUFFERS).
FORGET	( -- )	FORGET xxx: remove xxx and every word defined after it, never below FENCE.
FORTH	( -- )	Make FORTH, the primary vocabulary, the CONTEXT vocabulary.
GONE	( n node -- )	Tell the node that node n is gone; it acts on that only if this node is its centre.
HERE	( -- addr )	The address of the next free dictionary cell.
HEX	( -- )	Set BASE to sixteen.
HIDDEN	( -- )	Hide the newest entry: it cannot be found until revealed.
HOLD	( c -- )	Pictured output: put the character c in front of the string being built.
I	( -- n )	Compile-only: the index of the innermost DO loop.
IF	( flag -- )	Compile-only: run what follows if flag is not zero, else skip to ELSE or THEN.
IMMEDIATE	( -- )	Make the newest definition run when compiling instead of being compiled.
INTERPRET	( -- )	Interpret words from the input stream until it is exhausted.
INVERT	( x1 -- x2 )	Invert every bit.
IS	( xt -- )	IS xxx: make the deferred word xxx run xt; compiled when compiling.
J	( -- n )	Compile-only: the index of the next outer DO loop.
KERNEL-WORD	( n -- )	KERNEL-WORD xxx: define xxx, a word that asks the kernel to do request n (as BYE, BLOCK).
KEY	( -- c )	Wait for a key and leave its character.
LATEST	( -- xt )	The newest entry of the CURRENT vocabulary.
LEAVE	( -- )	Compile-only: leave the innermost DO loop at its next LOOP or +LOOP.
LFA	( xt -- addr )	The link field of the entry (>LINK).
LINK>	( addr -- xt )	The entry that a link field points to.
LIST	( n -- )	Print block n as 16 lines of 64 characters; SCR holds n.
LITERAL	( x -- )	If compiling, compile x as a literal.
LOAD	( n -- )	Interpret block n, then go on with what follows.
LOG-DEBUG	( -- 4 )	Constant: the debug log level.
LOG-DEBUG"	( -- )	LOG-DEBUG" text": log the text at the debug level.
LOG-DEBUG-STR	( baddr u -- )	Log the string at the debug level.
LOG-ERROR	( -- 0 )	Constant: the error log level.
LOG-ERROR"	( -- )	LOG-ERROR" text": log the text at the error level.
LOG-ERROR-STR	( baddr u -- )	Log the string at the error level.
LOG-INFO	( -- 2 )	Constant: the info log level.
LOG-INFO"	( -- )	LOG-INFO" text": log the text at the info level.
LOG-INFO-STR	( baddr u -- )	Log the string at the info level.
LOG-LEVEL!	( n -- )	Set the log level, held to 0 .. 4: messages at or below it are printed.
LOG-LEVEL@	( -- n )	The log level.
LOG-TEST	( -- 3 )	Constant: the test log level.
LOG-TEST"	( -- )	LOG-TEST" text": log the text at the test level.
LOG-TEST-STR	( baddr u -- )	Log the string at the test level.
LOG-WARN	( -- 1 )	Constant: the warning log level.
LOG-WARN"	( -- )	LOG-WARN" text": log the text at the warning level.
LOG-WARN-STR	( baddr u -- )	Log the string at the warning level.
LOOP	( -- )	Compile-only: end a DO loop, adding one to the index.
LSHIFT	( x1 u -- x2 )	Shift x1 left u bits; a count that is negative or a cell wide or more is error 9.
M*	( n1 n2 -- d )	Multiply: the double-cell product, signed.
M+	( d1 n -- d2 )	Add a single-cell number to a double.
M-	( d1 n -- d2 )	Subtract a single-cell number from a double.
M/MOD	( d n1 -- n2 n3 )	Divide d by n1: n2 the remainder, n3 the quotient.
MAX	( n1 n2 -- n3 )	The greater of two numbers.
MIN	( n1 n2 -- n3 )	The lesser of two numbers.
MINT-ZUSE	( -- )	Mint the real Zuse onto a second stick: asks for the stick, writes nothing until YES (the kernel's word; STICK.md 6a).
MOD	( n1 n2 -- n3 )	The remainder of n1 divided by n2.
MOVE	( addr1 addr2 n -- )	Copy n cells from addr1 to addr2, the first cell first.
NAME>	( baddr -- xt )	The entry whose name field is at baddr.
NEGATE	( n -- -n )	Negate.
NEIGHBOUR	( node port -- )	Record the node on the other end of the port, by its number; 0: none.
NFA	( xt -- baddr )	The name field of the entry (>NAME).
NO-ROUTE	( node -- )	Forget the way to that node, if one is known.
NO-ROUTES	( -- )	Forget every way to every node: for when the wiring has changed.
NODE-ERROR	( -- addr )	Variable: storing a non-zero code raises that error -- the word goes no further and the line ends with ERROR.
NOP	( -- )	Do nothing.
NOT	( flag1 -- flag2 )	True if flag1 is zero (as 0=).
NUMBER	( baddr -- d )	Convert the counted string at baddr to a double; what is not a number gives 0 and sets NODE-ERROR.
OCTAL	( -- )	Set BASE to eight.
OF	( x1 x2 -- | x1 )	Compile-only: in CASE, run the branch to ENDOF if x1 equals x2.
OR	( x1 x2 -- x3 )	Bitwise or.
ORDER	( -- )	Print where names are looked for, and where new ones go.
OVER	( x1 x2 -- x1 x2 x1 )	Copy the second value to the top.
PAD	( -- baddr )	A scratch area for text.
PAGE	( -- )	Clear the screen and put the cursor at the top.
PFA	( xt -- addr )	The parameter field of the entry.
PICK	( n -- x )	A copy of the n-th value, not counting n itself: 1 PICK is DUP.
PORT!	( w port -- )	Write a cell to the port, by its number; waits until the neighbour reads it.
Q.*	( q1 q2 -- q3 )	Multiply two Q48.16 fixed-point numbers.
Q.+	( q1 q2 -- q3 )	Add two Q48.16 numbers (D+).
Q.-	( q1 q2 -- q3 )	Subtract q2 from q1 (D-).
Q./	( q1 q2 -- q3 )	Divide q1 by q2; by zero is error 11.
Q.0	( -- q )	The Q48.16 zero, 0 0.
Q.0=	( q -- flag )	True if q is zero.
Q.1	( -- q )	The Q48.16 one, 65536 0.
Q.<	( q1 q2 -- flag )	True if q1 is less than q2.
Q.=	( q1 q2 -- flag )	True if q1 equals q2.
Q.>	( q1 q2 -- flag )	True if q1 is greater than q2.
Q.ABS	( q1 -- q2 )	The absolute value.
Q.COS	( q1 -- q2 )	The cosine of q1, in radians.
Q.EXP	( q1 -- q2 )	e to the power q1.
Q.FROM-INT	( n -- q )	The integer n as a Q48.16 number.
Q.LOG	( q1 -- q2 )	The natural logarithm of q1; not above zero is error 12.
Q.MAX	( q1 q2 -- q3 )	The greater of two Q48.16 numbers.
Q.MIN	( q1 q2 -- q3 )	The lesser of two Q48.16 numbers.
Q.NEG	( q1 -- q2 )	Negate.
Q.PRINT	( q -- )	Print q: the integer part, a point, five digits, a blank; always in decimal.
Q.SCALE	( -- q )	The scale of the fraction, 65536 0 (1.0).
Q.SIN	( q1 -- q2 )	The sine of q1, in radians.
Q.SQRT	( q1 -- q2 )	The square root of q1; below zero is error 12.
Q.TO-INT	( q -- n )	The integer part of q.
QUERY	( -- )	Read up to 80 characters, or a line, from the terminal into TIB; set >IN to 0.
QUIT	( -- )	Empty the return stack, set execution mode and go back to the terminal, without a message.
R>	( -- x ) ( R: x -- )	Compile-only: move the top of the return stack to the data stack.
R@	( -- x ) ( R: x -- x )	Compile-only: copy the top of the return stack.
REPEAT	( -- )	Compile-only: end a BEGIN ... WHILE ... REPEAT loop, jumping back to BEGIN.
ROLL	( n -- )	Move the n-th value, not counting n itself, to the top: 2 ROLL is ROT.
ROT	( x1 x2 x3 -- x2 x3 x1 )	Rotate the third value to the top.
ROUTE	( node port -- )	The port, by its number, leads toward that node.
RSHIFT	( x1 u -- x2 )	Shift x1 right u bits, filling with zeros; a count that is negative or a cell wide or more is error 9.
S"	( -- baddr u )	S" text": the text's address and length; compiled into the definition when compiling.
S>D	( n -- d )	Extend n to a double-cell number, keeping its sign.
SAVE-BUFFERS	( -- )	Write every block that has been UPDATEd.
SCAN	( baddr u c -- baddr' u' )	Skip to the first byte c in the string: what is left of it from there.
SCR	( -- addr )	Variable: the block most recently LISTed.
SEARCH	( baddr1 u1 baddr2 u2 -- baddr3 u3 flag )	Look for the second string in the first: if found, true and the first from there on.
SEND	( baddr u node -- )	Send the node u characters of text to interpret, by the way this node knows to it.
SEND-ON	( baddr u node port -- )	Send the node text to interpret by the port named, whatever ways are known.
SIGN	( n -- )	Pictured output: put a minus sign in front if n is negative.
SKIP	( baddr u c -- baddr' u' )	Skip the leading bytes c of the string: what is left of it.
SMUDGE	( -- )	Toggle the newest entry's hidden flag.
SOURCE	( -- baddr u )	The input buffer and how much of it is in use.
SPACE	( -- )	Print a blank.
SPACES	( n -- )	Print n blanks.
SPAN	( -- addr )	Variable: how many characters the last EXPECT read.
STATE	( -- addr )	Variable: not zero while compiling.
SWAP	( x1 x2 -- x2 x1 )	Exchange the top two values.
THEN	( -- )	Compile-only: end an IF ... THEN or IF ... ELSE ... THEN.
THRU	( first last -- )	LOAD each block from first to last.
TIB	( -- baddr )	The terminal input buffer.
TRAVERSE	( baddr n -- baddr' )	Step across a name field: for n > 0 from its count byte to its last byte, for n < 0 back.
TRUE	( -- -1 )	Constant: the true flag, all bits set.
TYPE	( baddr u -- )	Print the u characters at baddr.
U*	( u1 u2 -- ud )	The unsigned double-cell product (forth79.4th).
U.	( u -- )	Print u, unsigned, then a blank.
U.R	( u width -- )	Print u, unsigned, right-justified in a field of width characters.
U/MOD	( ud u1 -- u2 u3 )	Unsigned divide: u2 the remainder, u3 the quotient; by zero is error 11 (forth79.4th).
U<	( u1 u2 -- flag )	True if u1 is less than u2, unsigned.
U>	( u1 u2 -- flag )	True if u1 is greater than u2, unsigned.
UM*	( u1 u2 -- ud )	Multiply, unsigned: the double-cell product.
UNLOOP	( -- )	Compile-only: discard the innermost DO loop's index and limit, before an EXIT from inside it.
UNTIL	( flag -- )	Compile-only: end a BEGIN loop, jumping back to BEGIN while flag is zero.
UPDATE	( -- )	Mark the block most recently asked for as changed, so it is written.
VARIABLE	( -- )	VARIABLE xxx: define xxx, which leaves the address of one cell.
VERSION	( -- )	Print which system this is, and its cell width.
VLIST	( -- )	List the names in the CONTEXT vocabulary (WORDS).
VOCABULARY	( -- )	VOCABULARY xxx: define a vocabulary xxx; running it makes it the CONTEXT vocabulary.
WARM	( -- )	Print the system's message and ABORT: both stacks emptied, the prompt.
WHILE	( flag -- )	Compile-only: in BEGIN ... WHILE ... REPEAT, leave the loop if flag is zero.
WITHIN	( n low high -- flag )	True if low <= n < high.
WORD	( c -- baddr )	Read the next word from the input stream, delimited by c, as a counted string.
WORDS	( -- )	List the names in the CONTEXT vocabulary, the newest first.
XOR	( x1 x2 -- x3 )	Bitwise exclusive or.
[	( -- )	Stop compiling: interpret what follows; immediate.
[']	( -- xt )	Compile-only: ['] xxx compiles xxx's execution token as a literal.
[COMPILE]	( -- )	Compile-only: [COMPILE] xxx compiles xxx even though it is immediate.
[LITERAL]	( x -- )	Another name for LITERAL, as v3 has it.
\	( -- )	\ text: a comment to the end of the line; immediate.
]	( -- )	Start compiling what follows.