PFAVR -- Glossary By ANS Word Set

Andrew Sterian
Padnos School of Engineering
Grand Valley State University

Top-Level \| Glossary \| Compiler Design \| Rationale \| Notes	Version 1.2
	February 28, 2004
Glossary by Language Category \| Glossary by Word Name \| Glossary by Source Location \| Glossary by ANS Word Set

The flags column may contain the letters I or D to indicate immediate or deferred words.

The source definition column is either of the form ID_XXXX to indicate an internal word with the given ID, or is the filename (minus the .ft extension) where the word is defined.

The ANS section column is either pforth to indicate the word is not an ANS standard word, or is the name of an ANS standard word set which describes the word.

The language category column describes the part of the Forth language that the word applies to (e.g., io, loops, math, etc.)

The description column provides a brief reference on the word.

Core Word Set

Word Name	Flags	Source Definition	ANS Section	Language Category	Description
!		ID_STORE	core	memory	( n addr -- ) Store 16-bit n at address
#		core	core	io	Part of formatted number I/O
#>		core	core	io	Part of formatted number I/O
#S		core	core	io	Part of formatted number I/O
'		ID_TICK	core	lang	( "name" -- XT ) Push ExecToken for subsequent name
(	I	core	core	lang	Comment up to next )
*		ID_TIMES	core	math	( n1 n2 -- n1*n2 ) Signed multiplication
*/		core	core	math	( n1 n2 n3 -- n1n2/n3 ) Product n1n2 is 32-bit, result is 16-bit
*/MOD		core	core	math	( n1 n2 n3 -- (n1n2)%n3 n1n2/n3 ) Product n1*n2 is 32-bit, quotent/remainder are 16-bit
+		ID_PLUS	core	math	( n1 n2 -- n1+n2 ) Signed addition
+!		ID_PLUS_STORE	core	memory	( n addr -- ) Add n to the 16-bit contents of given address
+LOOP	I	core	core	flow	( n -- ) Add n to loop counter, continue looping if not done
,		core	core	dictionary	( x -- ) Store x in exec area and advance exec pointer
-		ID_MINUS	core	math	( n1 n2 -- n1-n2 ) Signed subtraction
.		ID_DOT	core	io	( n -- ) Display n
."	I	core	core	io	( "chars" -- ) Display string at run time
/		ID_DIVIDE	core	math	( n1 n2 -- n1/n2 ) Signed division
/MOD		core	core	math	( n1 n2 -- n1%n2 n1/n2 ) Signed remainder and division
0<		ID_COMP_ZERO_LESSTHAN	core	logical	( n -- flag ) Set flag if n<0
0=		ID_COMP_ZERO_EQUAL	core	logical	( n -- flag ) Set flag if n=0
1+		core	core	math	( n -- n+1 )
1-		core	core	math	( n -- n-1 )
2!		core	core	memory	( LSB MSB addr -- ) 32-bit store: store MSB at addr, LSB at addr+1
2*		core	core	math	( n -- n<<1 ) Arithmetic left shift
2/		core	core	math	( n -- n>>1 ) Arithmetic right shift
2@		core	core	memory	( addr -- LSB MSB ) 32-bit fetch of contents at addr
2DROP		core	core	stack	( n1 n2 -- ) Drop 2 items
2DUP		core	core	stack	( n1 n2 -- n1 n2 n1 n2) Duplicate 2 items
2OVER		core	core	stack	( x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2 )
2SWAP		core	core	stack	( x1 x2 x3 x4 -- x3 x4 x1 x2 )
:		ID_COLON	core	lang	Define a new word
;	I	ID_SEMICOLON	core	lang	End a word definition
<		ID_COMP_LESSTHAN	core	logical	( n1 n2 -- flag ) Set flag if n1<n2 (signed)
<#		core	core	io	Part of formatted number I/O
=		ID_COMP_EQUAL	core	logical	( n1 n2 -- flag ) Set flag if n1=n2
>		ID_COMP_GREATERTHAN	core	logical	( n1 n2 -- flag ) Set flag if n1>n2 (signed)
>BODY		core	core	dictionary	( XT -- addr ) Used to implement VALUE/TO
>IN		ID_VAR_TO_IN	core	compiler	( -- addr ) Address of variable storing number of characters from TIB to parse area
>NUMBER		core	core	compiler	( ud1 addr1 u1 -- ud2 addr2 u2 ) See documentation
>R		ID_TO_R	core	stack	( x -- ) ( R: -- x ) Move top-of-stack to return stack
?DUP		ID_QDUP	core	stack	( x -- 0 \| x x ) Duplicate TOS if nonzero
@		ID_FETCH	core	memory	( addr -- x ) Fetch 16-bit value at given address
ABORT	D	core	core	lang	Abort current execution, clear stack, return to top level prompt
ABORT"	I	core	core	lang	( x <message> -- ) If x is non-zero, print abort string and abort
ABS		core	core	math	( x -- \|x\| ) Absolute value
ACCEPT		ID_ACCEPT	core	io	( addr n1 -- n2) Input string of at most n1 chars into addr. n2 is length of string.
ALIGN	I	core	core	compiler	Does nothing (normally aligns data pointer to some boundary)
ALIGNED	I	core	core	compiler	Does nothing (normally bumps up address to next aligned boundary)
ALLOT		core	core	dictionary	( n -- ) Increments exec pointer by n
AND		ID_AND	core	logical	( x1 x2 -- x1&x2 ) Bitwise AND
BASE		ID_VAR_BASE	core	lang	( -- addr ) Address of current number base variable
BEGIN	I	core	core	flow	Implements loop structures
BL		core	core	io	( -- 0x20 ) An ASCII blank (space) character
C!		ID_CSTORE	core	memory	( x1 addr -- ) Store 8 least-significant bits of x1 at addr
C,		core	core	dictionary	( x -- ) Store 8 least-significant bits of x in exec area, bump up exec ptr by 1 byte
C@		ID_CFETCH	core	memory	( addr -- x ) Fetch 8-bit character at given address
CELL+		core	core	memory	( addr -- addr+2 ) Increment address by 2 bytes (size of a cell)
CELLS		core	core	memory	( x -- x<<1 ) Multiply x by 2 (size of a cell)
CHAR		core	core	string	( "n" -- 'n' ) Convert next single-letter word to its ASCII integer code
CHAR+		core	core	lang	( n -- n+1 ) Add size of a character
CHARS	I	core	core	compiler	( n -- n ) Doesn't do anything (multiplies by sizeof(char))
CONSTANT		core	core	lang	( n "name" -- ) Create a constant word with value n
COUNT		core	core	string	( addr -- addr+1 u ) Convert counted string address to address+count
CR		ID_CR	core	io	Print carriage return
CREATE		ID_CREATE	core	compiler	Create a new word in the dictionary
DECIMAL		core	core	io	Set current numeric base to 10
DEPTH		ID_DEPTH	core	stack	( -- n ) Number of items pushed on stack (prior to calling DEPTH)
DO	I	core	core	flow	Begin definite loop
DOES>	I	core	core	compiler	Describe body of word defined with CREATE
DROP		ID_DROP	core	stack	( x -- ) Drops the top-of-stack
DUP		ID_DUP	core	stack	( x -- x x ) Duplicate top-of-stack
ELSE	I	core	core	flow	Introduce ELSE clause of IF/ELSE/THEN statement
EMIT	D	ID_EMIT_P	core	io	( x -- ) Display character with ASCII code x
ENVIRONMENT?			core	compiler	NOT IMPLEMENTED
EVALUATE		core	core	lang	( ix addr u -- jx ) Evaluate Forth words from given source buffer
EXECUTE		ID_EXECUTE	core	lang	( ix XT -- jx ) Execute the given token
EXIT		ID_EXIT	core	lang	( R: sys -- ) Return from the current word
FILL		ID_FILL	core	memory	( addr num val -- ) Fill num bytes starting at addr with 8-bit val
FIND		ID_FIND	core	lang	( addr -- addr 0 \| addr 1 \| addr -1 ) Find counted string at addr in dictionary
FM/MOD		ID_FM_S_MOD	core	math	( d1 n1 -- d1%n1 d1/n1 ) Floored quotient and remainder (d1 is 32 bits)
HERE		ID_HERE	core	dictionary	( -- x ) Push next location in exec area to be written to
HOLD		core	core	io	( char -- ) Adds character to formatted output
I		ID_I	core	flow	( -- n ) Pushes innermost loop index in a definite loop
IF	I	core	core	flow	Begin IF/ELSE/THEN statement
IMMEDIATE		core	core	lang	Make most recent word definition an immediate word
INVERT		core	core	logical	( n -- ~n ) One's complement
J		ID_J	core	flow	( -- n ) Pushes next-innermost loop index in a definite loop
KEY		ID_KEY	core	io	( -- n ) Pushes next key from terminal (waits for it)
LEAVE	I	core	core	flow	Leaves a definite loop prematurely
LITERAL	I	ID_LITERAL	core	lang	( x -- ) At run-time, push x on the stack
LOOP	I	core	core	flow	Increment loop count, if equal to limit, terminate loop, otherwise loop from beginning
LSHIFT		ID_LSHIFT	core	logical	( n u -- n<<u ) Logical left shift
M*		ID_D_MTIMES	core	math	( n1 n2 -- n1*n2 ) Signed multiplication, result is 32 bits
MAX		ID_MAX	core	math	( n1 n2 -- max(n1,n2) ) Maximum function
MIN		ID_MIN	core	math	( n1 n2 -- min(n1,n2) ) Minimum function
MOD		core	core	math	( n1 n2 -- n1%n2 ) Remainder function
MOVE		core	core	memory	( addr1 addr2 u -- ) Move u bytes from addr1 to addr2
NEGATE		core	core	math	( n -- -n ) Negative function
OR		ID_OR	core	logical	( x1 x2 -- x1\|x2 ) Logical OR
OVER		ID_OVER	core	stack	( x1 x2 -- x1 x2 x1 )
POSTPONE	I	core	core	lang	Compile next word into word definition
QUIT	D	core	core	lang	Interpreter loop (also ID_QUIT_P)
R>		ID_R_FROM	core	stack	( -- x ) (R: x -- ) Pop value from return stack and push to data stack
R@		ID_R_FETCH	core	stack	( -- x ) (R: x -- x) Copy value from return stack and push to data stack
RECURSE	I	core	core	lang	Go to start of this word during execution
REPEAT	I	core	core	flow	Repeat from start of BEGIN block
ROT		ID_ROT	core	stack	( x1 x2 x3 -- x2 x3 x1 ) Rotate top three stack elements
RSHIFT		ID_RSHIFT	core	logical	( x1 u -- x1>>u ) Logical right shift (NOTE: Not arithmetic right shift)
S"	I	core	core	string	Compilation: return given string ( -- caddr u ) at run-time
S>D		core	core	double	( n -- d ) Sign-extend n to double-cell d
SIGN		core	core	io	Formatted number output
SM/REM		ID_SM_S_REM	core	math	( d1 n1 -- d1%n1 d1/n1 ) Signed symmetric quotient/remainder
SOURCE		ID_SOURCE	core	compiler	( -- caddr num ) Return address and length of input buffer
SPACE		core	core	io	Emit a single space
SPACES		core	core	io	( n -- ) If n>0 emit this many spaces
STATE		ID_VAR_STATE	core	compiler	( -- addr ) Address of compilation state variable
SWAP		ID_SWAP	core	stack	( x1 x2 -- x2 x1 ) Swap two top stack elements
THEN	I	core	core	flow	Mark end of IF/ELSE/THEN statement
TYPE		ID_TYPE	core	io	( caddr u -- ) Display u bytes of string at caddr to terminal
U.		core	core	io	( u -- ) Display unsigned u in free field format
U<		ID_COMP_U_LESSTHAN	core	logical	( u1 u2 -- flag ) Sets flag if u1<u2 (unsigned)
UM*		ID_D_UMTIMES	core	math	( u1 u2 -- u1*u2 ) Compute 32-bit unsigned product
UM/MOD		ID_D_UMSMOD	core	math	( ud u1 -- ud%u1 ud/u1 ) Divide 32-bit ud by 16-bit u1 (unsigned) giving quotient/remainder
UNLOOP		core	core	flow	Must call prior to EXIT when in the middle of a loop
UNTIL	I	core	core	flow	( x -- ) Continue looping at BEGIN if x is zero
VARIABLE		core	core	lang	Create a global variable. At run time, the variable's name pushes its data address
WHILE	I	core	core	flow	Loop while flag on stack is non-zero
WORD		ID_WORD	core	lang	( char "<char>sss<char>" -- caddr ) Parse by given delimiter, return address
XOR		ID_XOR	core	logical	( x1 x2 -- x1^x2 ) Exclusive-OR
[	I	core	core	compiler	Enter interpreter mode
[']	I	core	core	compiler	At run time, place next word's XT on stack. Like ' name when not compiling.
[CHAR]	I	core	core	compiler	Compile-in runtime behavior of CHAR
]		core	core	compiler	Enter compilation mode

Core Extension Word Set

Word Name	Flags	Source Definition	ANS Section	Language Category	Description
#TIB		ID_VAR_NUM_TIB	coreext	deprecated	Deprecated...use SOURCE
.(	I	core	coreext	string	Parse and display string delimited by ending )
.R		coreext	coreext	io	( n1 n2 -- ) Display n1 right-aligned in a field n2 characters wide
0<>		ID_COMP_ZERO_NOT_EQUAL	coreext	logical	( x -- flag ) Return true flag if x is not 0
0>		ID_COMP_ZERO_GREATERTHAN	coreext	logical	( x -- flag ) Return true flag if x>0 (signed)
2>R		ID_2_TO_R	coreext	stack	( x1 x2 -- ) (R: -- x1 x2 ) Move two cells from data stack to return stack
2R>		ID_2_R_FROM	coreext	stack	( -- x1 x2 ) (R: x1 x2 -- ) Move two cells from return stack to data stack
2R@		ID_2_R_FETCH	coreext	stack	( -- x1 x2 ) (R: x1 x2 -- x1 x2 ) Copy two cells from return stack to data stack
:NONAME		core	coreext	compiler	Define code body without associated dictionary name
<>		ID_COMP_NOT_EQUAL	coreext	logical	( x1 x2 -- flag ) Return true flag if x1 != x2
?DO	I	core	coreext	flow	Like DO loop but no iterations are performed if initial value equals upper limit
AGAIN	I	core	coreext	flow	Repeat unconditionally from BEGIN
C"	I	core	coreext	deprecated	Deprecated...use S"
CASE	I	core	coreext	flow	Begin CASE/OF/ENDOF/ENDCASE structure
COMPILE,		core	coreext	compiler	( XT -- ) Append XT to exec area at current pointer, increment pointer
CONVERT		coreext	coreext	deprecated	Deprecated...use >NUMBER
ENDCASE	I	coreext	coreext	flow	Terminates CASE structure
ENDOF	I	core	coreext	flow	Terminates OF clause of CASE/OF/ENDOF/ENDCASE structure
ERASE		coreext	coreext	memory	( addr u -- ) Set u bytes of memory to 0 starting at addr
EXPECT		coreext	coreext	deprecated	Deprecated...use ACCEPT
FALSE		core	coreext	lang	( -- false ) Push false constant
HEX		core	coreext	io	Sets BASE to 16
MARKER		coreext	coreext	lang	( <name> -- ) Define a word that FORGET's itself when executed
NIP		core	coreext	stack	( x1 x2 -- x2 ) Remove element above top-of-stack
OF	I	core	coreext	flow	Start OF clause in a CASE statement
PAD		core	coreext	memory	( -- caddr ) Address of a temporary region for intermediate processing
PARSE		core	coreext	string	( char "ccc<char>" -- caddr u ) Parse with delimiter char, return addr/length.
PICK		ID_PICK	coreext	stack	( xu...x1 x0 u -- xu...x1 x0 xu ) Copy STACK[u] to TOS
QUERY		coreext	coreext	deprecated	Deprecated...use "REFILL DROP"
REFILL		ID_REFILL	coreext	io	( -- flag ) Get another line of input. Flag is true if successful.
RESTORE-INPUT			coreext	compiler	NOT IMPLEMENTED
ROLL		ID_ROLL	coreext	stack	( xu xu-1 ... x0 u -- xu-1 ... x0 xu ). Size-u rotation of stack.
SAVE-INPUT			coreext	compiler	NOT IMPLEMENTED
SOURCE-ID		core	coreext	compiler	Pushes 0 for command-line source, -1 for EVALUATE source
SPAN		coreext	coreext	deprecated	Deprecated...use ACCEPT
TIB		coreext	coreext	deprecated	Deprecated...use "SOURCE DROP"
TO	I	core	coreext	lang	Stores quantity in a VALUE
TRUE		core	coreext	lang	( -- true ) Push true constant
TUCK		core	coreext	stack	( x1 x2 -- x2 x1 x2 ) Copy top-of-stack as third element
U.R		coreext	coreext	io	( u n -- ) Display u right aligned in a field n wide
U>		ID_COMP_U_GREATERTHAN	coreext	logical	( u1 u2 -- flag ) Sets flag true only if unsigned u1>u2
UNUSED		core	coreext	dictionary	( -- u ) Returns free space in exec area
VALUE		core	coreext	lang	Declares mutable constant
WITHIN		coreext	coreext	math	( x1 x2 x3 -- flag ) Sets flag true if x1 is between x2 and x3
WORDS		coreext	coreext	utility	Display current dictionary
[COMPILE]	I	core	coreext	deprecated	Deprecated...use POSTPONE
\	I	core	coreext	lang	Comment to end-of-line

Block Word Set

No words in this word set

Double-Number Word Set

Word Name	Flags	Source Definition	ANS Section	Language Category	Description
2CONSTANT		double	double	double	( dl dh "name" -- ) Create double-word constant
2LITERAL	I	ID_2LITERAL	double	double	( x1 x2 -- ) At run-time, place x1 and x2 on the stack
2ROT		double	double	double	( x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2 ) Double-word stack rotation
2VARIABLE		double	double	double	Create a global double-word variable
D+		ID_D_PLUS	double	double	( d1 d2 -- d1+d2 ) Double-word addition
D-		ID_D_MINUS	double	double	( d1 d2 -- d1-d2 ) Double-word subtraction
D.		double	double	io	( d -- ) Display double-word in free-field format
D.R		double	double	io	( d -- ) Display double-word right-aligned
D0<		double	double	double	( d -- flag ) Set flag true if double-word d<0
D0=		double	double	double	( d -- flag ) Set flag true if double-word d=0
D2*		double	double	double	( d -- d<<1 ) Arithmetic double-word left shift
D2/		double	double	double	( d -- d>>1 ) Arithmetic double-word right shift
D<		ID_D_LESSTHAN	double	double	( d1 d2 -- flag ) Set flag true if double-word d1<d2
D=		double	double	double	( d1 d2 -- flag ) Set flag true if double-word d1=d2
D>S		double	double	double	( d -- n ) Convert double-word to single-word number
DABS		double	double	double	( d -- \|d\| ) Double-word absolute value
DMAX		double	double	double	( d1 d2 -- max(d1,d2) ) Maximum function for double-words
DMIN		double	double	double	( d1 d2 -- min(d1,d2) ) Minimum function for double-words
DNEGATE		core	double	double	( d1 -- -d1 ) Negative function for double-words
DU<		ID_D_ULESSTHAN	double	double	( ud1 ud2 -- flag ) Set flag true if unsigned double-word ud1<ud2
M*/		double	double	double	( d1 n1 +n2 -- d1n1/n2 ) Quotient is double-word, d1n1 is triple-word
M+		double	double	double	( d n -- d+n ) Double-word addition to single-word

Exception Word Set

Word Name	Flags	Source Definition	ANS Section	Language Category	Description
CATCH		core	exception	lang	See documentation
THROW		core	exception	lang	See documentation

Facility Word Set

Word Name	Flags	Source Definition	ANS Section	Language Category	Description
KEY?		ID_QTERMINAL	facility	io	( -- flag ) Returns true if key is available from terminal

File Access Word Set

No words in this word set

Floating Point Word Set

No words in this word set

Locals Word Set

No words in this word set

Memory Allocation Word Set

No words in this word set

Programming Tools Word Set

Word Name	Flags	Source Definition	ANS Section	Language Category	Description
.S		ID_DOTS	progtools	io	Display values on the stack
;CODE			progtools	compiler	Add assembly language (NOT IMPLEMENTED in pForth)
?		progtools	progtools	io	( addr -- ) Display value at addr (equivalent to "@ .")
AHEAD	I	core	progtools	flow	Implements loop structures
ASSEMBLER			progtools	compiler	Swap wordlists with the assembler wordlist (NOT IMPLEMENTED in pForth)
BYE		ID_BYE	progtools	utility	Terminates interpreter
CODE			progtools	compiler	Assembly language (NOT IMPLEMENTED in pForth)
CS-PICK			progtools	stack	NOT IMPLEMENTED in pForth
CS-ROLL			progtools	stack	NOT IMPLEMENTED in pForth
DUMP		ID_DUMP	progtools	io	( addr u -- ) Dump memory for u bytes at addr
EDITOR			progtools	utility	Swap wordlists with the editor wordlist (NOT IMPLEMENTED in pForth)
FORGET		progtools	progtools	deprecated	Deprecated...use MARKER
[ELSE]	I	progtools	progtools	preprocess	Conditional compilation
[IF]	I	progtools	progtools	preprocess	Conditional compilation
[THEN]	I	progtools	progtools	preprocess	Conditional compilation

Search Order Word Set

No words in this word set

String Word Set

Word Name	Flags	Source Definition	ANS Section	Language Category	Description
-TRAILING		strings	strings	string	(addr u1 -- addr u2 ) Reduce string addr/u1 to addr/u2 to eliminate trailing spaces
/STRING		core	strings	string	( addr u1 n -- addr2 u2 ) Chop n characters from the front of the given string
BLANK		strings	strings	string	( addr u -- ) Set u characters to spaces beginning at addr
CMOVE		ID_CMOVE	strings	memory	( addr1 addr2 u -- ) Copy u characters from addr1 to addr2 (low addresses to high)
CMOVE>		ID_CMOVE_UP	strings	memory	( addr1 addr2 u -- ) Copy u characters from addr1 to addr2 (high addresses to low)
COMPARE		ID_COMPARE	strings	string	( addr1 u1 addr2 u2 -- n ) Compare two strings, n is 0 if the same, else -1 or +1
SEARCH		strings	strings	string	( addr1 u1 addr2 u2 -- addr3 u3 flag ) Search for str2 in str1, set flag if found
SLITERAL	I	strings	strings	string	Compile in a string to return ( -- addr u ) at run time

Other Words

Word Name	Flags	Source Definition	ANS Section	Language Category	Description
",		core	pforth	compiler	( addr len -- ) Places string into code space
#COLS		coreext	pforth	utility	Constant setting # of columns per screen for WORDS
((NUMBER?))		core	pforth	compiler	Used to implement NUMBER?
(+LOOP)		ID_PLUSLOOP_P	pforth	compiler	Used to implement +LOOP
(.")		core	pforth	compiler	Used to implement ."
(2LITERAL)		ID_2LITERAL_P	pforth	compiler	Runtime support for 2LITERAL, pushes next two words on stack
(?DO)		ID_QDO_P	pforth	compiler	Used to implement ?DO
(ABORT")		core	pforth	compiler	( flag $message -- ) Calls ABORT if flag is true
(ABORT)		exception	pforth	compiler	Throws -1...used to redefine ABORT if exception.ft is used
(C")		core	pforth	compiler	Used to implement C"
(COMPILE)		core	pforth	compiler	Used by COMPILE
(CREATE)		ID_CREATE_P	pforth	compiler	Runtime support for CREATE
(D.)		double	pforth	double	( d -- caddr cnt ) Converts a double to string representation
(DO)		ID_DO_P	pforth	compiler	Runtime support for DO
(DOES>)		core	pforth	compiler	Used to implement DOES>
(EMIT)		ID_EMIT_P	pforth	compiler	Same as original EMIT
(HEXNUMBER?)		ID_HEXNUMBERQ_P	pforth	compiler	( $addr -- 0 \| n 1 ) Convert string at address as hex number
(IS)		core	pforth	compiler	Used to implement IS
(LEAVE)		ID_LEAVE_P	pforth	compiler	Supports LEAVE
(LITERAL)		ID_LITERAL_P	pforth	compiler	Supports LITERAL, pushes next code space word on stack
(LOOP)		ID_LOOP_P	pforth	compiler	Supports loops
(NUMBER?)		core	pforth	compiler	Used to implement NUMBER?
(QUIT)		ID_QUIT_P	pforth	compiler	Original implementation of QUIT, calls abort
(RANGEOF?)		core	pforth	compiler	Used to implement CASE
(S")		core	pforth	compiler	Used to implement S"
(WHAT'S)		core	pforth	compiler	Used to implement WHAT'S
,"		core	pforth	compiler	( "string" -- ) Parses string and stores in code space
-1		core	pforth	compiler	Equal to -1, saves one cell
0BRANCH		ID_ZERO_BRANCH	pforth	compiler	Supports flow control, branch if top-of-stack is 0
0STACKP		core	pforth	utility	( stack -- ) Flush user stack
0USP		core	pforth	compiler	Clear loop stack
:STACK		core	pforth	utility	( #cells "name" -- ) Define a user stack variable of given name
<=		core	pforth	logical	( a b -- f ) True if a <= b (signed)
<MARK		core	pforth	compiler	Used in forming flow control constructs
<RESOLVE		core	pforth	compiler	Used in forming flow control constructs
>=		core	pforth	logical	( a b -- f ) True if a >= b (signed)
>MARK		core	pforth	compiler	Used in forming flow control constructs
>NEWLINE		core	pforth	utility	Print newline but only if output is not at column 0
>RESOLVE		core	pforth	compiler	Used in forming flow control constructs
>STACK		core	pforth	utility	( n stack -- ) Push onto user stack, postincrement
>US		core	pforth	compiler	Push to loop stack
?COMP		core	pforth	compiler	Ensures compilation state, otherwise errors out
?CONDITION		core	pforth	compiler	Checks that CONDITIONAL_KEY is at top-of-stack, otherwise errors out
?DO_FLAG		core	pforth	compiler	Used for implementing loops
?ERROR		ID_ERRORQ_P	pforth	utility	( flag num -- ) Prints error code num if flag true
?OF	I	core	pforth	compiler	Used to implement CASE
ARSHIFT		ID_ARSHIFT	pforth	logical	( n a -- n>>a ) Arithmetic right shift
ASCII	I	core	pforth	utility	( <char> -- char ) NOTE: State-smart
AUTO.INIT		core	pforth	utility	Executed prior to accepting first interactive command
AUTO.TERM		core	pforth	utility	Executed upon 'bye'
BRANCH		ID_BRANCH	pforth	compiler	Supports flow control, unconditional branch
CASE-DEPTH		core	pforth	compiler	Used to implement CASE
CATCH-HANDLER		core	pforth	compiler	Used to implement CATCH
CELL		core	pforth	compiler	2, the size in bytes of a cell
CELL-		core	pforth	memory	( addr -- addr-2 ) Decrement address by 2 bytes (size of a cell)
CHECK.DEFER		core	pforth	compiler	Used to implement DEFER
CHECK.STACK		core	pforth	compiler	Prints error message and calls ABORT if stack underflow
CODE-BASE		ID_VAR_CODE_BASE	pforth	dictionary	( -- addr ) Get address of start of code area
CODE-LIMIT		ID_VAR_CODE_LIMIT	pforth	dictionary	( -- addr ) Get address just beyond end of code area
COMPILE	I	core	pforth	deprecated	Deprecated...use POSTPONE
CONDITIONAL_KEY		core	pforth	compiler	Magic number used in forming conditional flow control
CONTEXT		ID_VAR_CONTEXT	pforth	dictionary	( -- addr ) Get address of last dictionary definition name
CR?		coreext	pforth	utility	Carriage return if output column near #COLS
DEFER		ID_DEFER	pforth	lang	Create deferred word
DIGIT		core	pforth	compiler	( char base -- n true \| char false ) Convert a single character to a number in the given base
DO_FLAG		core	pforth	compiler	Used for implementing loops
DP		ID_VAR_DP	pforth	dictionary	( -- addr ) Get address of next code location to write to
DUNUSED		core	pforth	dictionary	( -- u ) Returns free space in dictionary area
ECHO		ID_VAR_ECHO	pforth	io	( -- addr ) Get address of variable controlling echo mode
EOL		ID_EOL	pforth	io	( -- '\n' ) Pushes newline character onto stack
EXISTS?	I	progtools	pforth	preprocess	( <name> -- flag ) Sets flag if given name is a defined word
FIND&COMPILE		core	pforth	compiler	( $word -- {n} ) Find word in dictionary and compile/execute it
FINDNFA		ID_FINDNFA	pforth	dictionary	( <name> -- addr 0 \| nfa +-1 ) Find name in dictionary
FORGET.NFA		coreext	pforth	compiler	( nfa -- ) Core of FORGET algorithm
FREEZE		coreext	pforth	compiler	Sets RFENCE to current code space address.
GDB-BREAK	I	ID_GDB_BREAK	pforth	compiler	Empty routine for setting GDB debugger breakpoints
HEADERS-BASE		ID_VAR_HEADERS_BASE	pforth	dictionary	( -- addr ) Get address of start of dictionary
HEADERS-LIMIT		ID_VAR_HEADERS_LIMIT	pforth	dictionary	( -- addr ) Get address just beyond end of dictionary area
HEADERS-PTR		ID_VAR_HEADERS_PTR	pforth	dictionary	( -- addr ) Get address of next dictionary entry to write
HLD		core	pforth	compiler	Used to implement HOLD
ID.		core	pforth	compiler	( nfa -- ) Prints string at given address, masking off length character
INTERPRET		core	pforth	compiler	Keeps parsing words, calling FIND&COMPILE for each one
IS	I	core	pforth	lang	Stores implementation in deferred word
LATEST		core	pforth	compiler	Return address of last word defined
LEAVE_FLAG		core	pforth	compiler	Used for implementing loops
LOOP-BACK		core	pforth	compiler	Used for implementing loops
LOOP-FORWARD		core	pforth	compiler	Used for implementing loops
MU/MOD		ID_D_MUSMOD	pforth	double	( AL AH B -- REM QL QH ) 32/16 unsigned divide, 32-bit result
NAME>		ID_NAME_TO_TOKEN	pforth	dictionary	( nfa -- xt ) Converts address of dict name to its XT
NO;CHECK		ID_NO_SEMI_CHECK	pforth	compiler	Suppresses next check for : ; stack level agreement
NOT		core	pforth	logical	( n -- !n ) Logical negation (equivalent to 0=)
NUMBER?	D	ID_HEXNUMBERQ_P	pforth	compiler	Deferred word, initially set to (HEXNUMBER?), then overwritten with (NUMBER?)
OF-DEPTH		core	pforth	compiler	Used to implement CASE
OK		core	pforth	compiler	Prints prompt and dumps stack if TRACE-STACK is non-zero
OUT		ID_VAR_OUT	pforth	io	( -- addr ) Get address of variable with current output column
PLACE		core	pforth	string	( addr len dest -- ) Moves a string to given destination
PREVNAME		ID_NAME_TO_PREVIOUS	pforth	dictionary	( nfa -- nfa ) Converts address of dict name to previous name's address
QUIT-QUIT		exception	pforth	compiler	Variable that, when set, terminates QUIT loop
RANGEOF	I	core	pforth	flow	Used to implement CASE
RDROP		ID_R_DROP	pforth	stack	Drop from return stack
RETURN-CODE		ID_VAR_RETURN_CODE	pforth	compiler	( -- addr ) Get address of variable with return code
RFENCE		coreext	pforth	compiler	Variable storing address below which FORGET is illegal
RP!		ID_RP_STORE	pforth	stack	( rp -- ) Make address the top of the return stack
RP@		ID_RP_FETCH	pforth	stack	( -- rp ) Address of top of return stack prior to RP@
SCAN		ID_SCAN	pforth	string	( addr cnt char -- addr' cnt' ) Find character in string
SET-SOURCE		ID_SOURCE_SET	pforth	compiler	( caddr num -- ) Set parsing source to given address
SKIP		ID_SKIP	pforth	string	( addr cnt char -- addr' cnt' ) Skip over char in string
SP!		ID_SP_STORE	pforth	stack	( sp -- ) Set address of top of stack
SP@		ID_SP_FETCH	pforth	stack	( -- sp ) Get address of top of stack
STACK.PICK		core	pforth	utility	( index stack -- n ) Grab Nth item from top of user stack
STACK>		core	pforth	utility	( stack -- n ) Pop from user stack, predecrement
STACK@		core	pforth	utility	( stack -- n ) Copy from top of user stack
STACKP		core	pforth	utility	( stack -- ptr ) Pointer to next empty location on user stack
TAB		coreext	pforth	utility	Go to next tab stop
TAB-WIDTH		coreext	pforth	utility	Variable storing spaces per tab for printing WORDS
TRACE-FLAGS		ID_VAR_TRACE_FLAGS	pforth	utility	( -- addr ) Get address of variable with trace flags
TRACE-LEVEL		ID_VAR_TRACE_LEVEL	pforth	utility	( -- addr ) Get address of variable with trace level
TRACE-STACK		ID_VAR_TRACE_STACK	pforth	utility	( -- addr ) Get address of variable with trace stack setting
UD.		core	pforth	compiler	( ud -- ) Prints double unsigned number
US>		core	pforth	compiler	Pop from loop stack
US@		core	pforth	compiler	Copy from loop stack
USTACK		core	pforth	compiler	Name of the "loop stack" used for implementing loops
VERIFY.FORGET		coreext	pforth	compiler	( nfa -- ) Calls FORGET.NFA if nfa is above RFENCE
WHAT'S	I	core	pforth	lang	( <name> -- XT ) Grabs XT of a deferred word