RRQFORTH Reference Documentation

"[ASM]" is a function word that introduces inline assembly in an RRQFORTH definition. Such assembly code may return to subsequence RRQFORTH executon by means of the following instruction sequence:

Note that the FORTH compiler does not invoke an assembler so any inline assembly code must be provided in its binary form.

"0BRANCH" is a function word that implements execution conditional by means of optionally adding the subsequent branch offset, or not, to the point of execution. If the value, v, is 0 then the branch offset is added, and otherwise execution continues with the cell following the branch offset in the definition.

Note that the branch offset is a byte count and each FORTH word of a definition take up a cell of 8 bytes. The offset is relative to the cell address immediately subsequent to the offset cell. In other words, offset 0 is not branching anywhere and an offset of -16 would make a tight loop back to the branch instruction itself. The latter would pull data stack values until and including the first non-zero value.

See also 1BRANCH, BRANCH, IF, ELSE, IFBREAK and IFAGAIN.

"0=" is a function word that replaces a value with its logical complement; the result is zero if the value non-zero, and the result is non-zero if the value is zero.

This is the same function as NOT.

"0<" is a function word that replaces a value with -1 if the value is less than 0, and 0 otherwise.

See also SWAP and <.

"1BRANCH" is a function word that implements execution conditional by means of optionally adding the subsequent branch offset, or not, to the point of execution. If the value, v, is non-zero then the branch offset is added, and otherwise execution continues with the cell following the branch offset in the definition.

Note that the branch offset is a byte count and each FORTH word of a definition take up a cell of 8 bytes. The offset is relative to the cell address immediately subsequent to the offset cell. In other words, offset 0 is not branching anywhere and an offset of -16 would make a tight loop back to the branch instruction itself. The latter would pull data stack values until and including the first zero value.

See also 0BRANCH, BRANCH, IF, ELSE, IFBREAK and IFAGAIN.

"2DROP" is a function word that plainly discards the top 2 cells from the data stack.

"2DUP" is a function word that duplicates the top 2 cells on the data stack.

"2@" is a function word that pushes the two concecutive values v1 and v2 from the address a onto the data stack. Value v1 is from address a and value v2 is from address a + 8.

"2OVER" is a function word that replicates the second duble-cell pair onto the top of the data stack. This is similar to OVER but working with cell pairs rather than single cells.

"2!" is a function word that stors two concecutive values v1 and v2 to the address a from the data stack. Value v1 is stored at address a and value v2 is stored at address a + 8.

"2SWAP" is a function word the reorgnizes the top 4 cells swappping the upper and lower pair. This is similar to SWAP but working with cell pairs rather than single cells.

"C," (C-comma) is a function word that puts a byte on the HERE heap. The least significant byte of the value is put at the current free head address, which also is incremented.

See also :, [p_comma]. HERE, @, ALLOT, C! and ;.

"CFA>TFA" is a function word that pushes word tfa of the given cfa.

"C@" is a function word that pushes the byte value v from the address a.

"C!" is a function word that stores the byte value v (the least significant byte of the cell) at the address a.

"R@" is a function word that "copies" the top return stack value onto the data stack.

"R>" is a function word that "moves" the top return stack value onto the data stack.

"ABS" is a function word that replaces a value with its absolute value. To that end, the values are 64-bit signed integers.

"AGAIN" is an immediate function word that is used together with BEGIN and instead of END to implement structured execution control. AGAIN scans the datastack for the nearest preceding BEGIN marker and lays out an unconditional branch from this point the beginning of the block during execution. It thereafter performs the END compile action to end the block.

"ALLOT" is a function word that merely increments the HERE variable with n so as to claim that amount of the heap.

"AND" is a function word that replaces a value pair with their bitwise conjunction; each bit is 1 if the corresponding bits of both operands are 1 and 0 if not.

"ARGS" is a value word that holds a pointer to the command line data block which consists of a count cell followed by that many asciiz pointers and then a 0 cell.

"BASE" is a variable word for the numerical base used by input and output functions, NUMBER and [p_dot], when translating numbers between cell value form and text form. The numerical base is set to 10 or 16 by DECIMAL and HEX respectively, and those are the only two bases currently supported.

See also DIGITS, which holds the mapping table from digits to text.

"BEGIN" is an immediate function word that is used together with IFBREAK, IFAGAIN and END to implement structured execution control. BEGIN simply places the address for resolving branches back to this point during execution, and then a 0 as a marker so as to allow for an unknown number of block exit points.

"[']" is an immediate function word that reads the next word on the input stream and pushes its cfa.

"BRANCH" is a function word that implements execution transfer by means of adding the subsequent branch offset to the point of execution.

Note that the branch offset is a byte count and each FORTH word of a definition take up a cell of 8 bytes. The offset is relative to the cell address immediately subsequent to the offset cell. In other words, offset 0 is not branching anywhere and an offset of -16 would make a tight loop back to the branch instruction itself. The latter would pull data stack values until and including the first zero value.

See also 0BRANCH, 1BRANCH, IF, ELSE, IFBREAK and IFAGAIN.

"BREAK" is an immediate function word that lays out an unconditional branch out of an enclosing xef:p_begin[BEGIN]-END block. Similar to IFBREAK it lays out the branch cell followed by a reserved cell for the branch offset, and inserts the resolution address just above the required 0 on the data stack.

See also BRANCH, 0BRANCH, 1BRANCH, IF, ELSE, IFBREAK and IFAGAIN.

"[calltrace]" is a variable word that ccontains a small assembly snippet that may be used for debugging when running under gdb.

"CFA>FLAGS@" is a function word that pushes word flags of the given cfa.

"CLEAR-STREAM" is a function word that discards whatever is currently remaining in the buffer for the stream, so that a subsequent read will pull in more data from its source.

See also READ-STREAM-CHAR.

":" (colon) is a function word that starts a new forth definition. This includes reading the next word for making a new dictionary entry and setting evaluation state to compiling mode.

See also doFORTH, READ-WORD, CREATE, TFA>CFA, !, ] and ;.

"," (comma) is a function word that puts a cell value on the HERE heap.

See also :, [p_Ccomma]. HERE, @, ALLOT, ! and ;.

"CREATE" is a function word that allocates a "word header" with the indicated [n:char*] print name, and returns the "TFA" (Token Field Address) of the word. The header memory layout is as follows:

A "word" is generally understod as a marker in memory for some content as held in the memory space following the DFA (Data Field Address).

The words CFA (Code Field Address) is the most important field for RRQFORTH execution, as holding a jump address to the assembly code that implements the particular execution semantics for the word. "CREATE" will assign this as "dovariable", which makes the word push its DFA when executed. This is changed to "doforth" for RRQFORTH function words initiated by ":" (aka "COLON") or changed to "dovalue" for RRQFORTH constants created by "CONSTANT".

See also !, +, [p_comma], @, [p_Ccomma], CURRENT-WORD, DUP, HERE, HERE, R@, ROT, and doVARIABLE, as well as EXECUTE about the range of "doer" assignments and their meanings.

"CURRENT-WORDLIST" is a variable word that points out the DFA of the current word list word for FIND to use finding words. The word list word content is as follows:

Note that word lists are chained by "extension" and in general it ends with the FORTH word list. Initially the SYSTEM word list is the only other word list.

"DATA-STACK" is a variable word that harbours the data stack.

"DECIMAL" is a function word that sets BASE to 10.

"DEFINITIONS" is a function word that installs the given wordlist as the CURRENT-WORDLIST one.

"DEPTH" is a function word that pushes the count of data stack cells onto the data stack.

"DFA>TFA" is a function word that pushes word tfa of the given dfa.

"DIGITS" is a variable word that holds the character array for mapping digit values to characters. It contains the 16 characters 0-9 and a-f.

"/" (div) is a function word that replaces a pair of values with the results of signed integer division of the first, v1, divided by the second, v2. To that end, the values are 64-bit signed integers. The result is the integer quotient, q, and the discarded remainder, r, where q and r are the respectively largest and smallest integers to satisfy the formula:

"/MOD" (div-mod) is a function word that replaces a pair of values with the results of signed integer division of the first, v1, divided by the second, v2. To that end, the values are 64-bit signed integers. The result is the integer quotient, q, and the remainder, r, where q and r are the respectively largest and smallest integers to satisfy the formula:

"doDOES" is a variable word whose value is the implementation of the [p_does] execution semantics. This is the same as doFORTH but it starts at an offset into the word concerned.

"DOES>" is a function that in execution mode does nothing but in compilation mode it changes the execution semantics assignments for the most recent word to use the dodoes sematics with adjustment offset to the current heap address. I.e., the word being defined will have its execution start at whatever comes after "DOES>".

See also !, !⇒>, →>, @, CURRENT-WORDLIST, HERE, IF, IMMEDIATE, OVER, STATE, SWAP, TFA>CFA, THEN, doDOES, as well as EXECUTE about the range of "doer" assignments and their meanings.

"doFASM" is a variable word whose value is the implementation of the execution semantics for assembly code content.

"doFORTH" is a variable word whose value is the implementation of the RRQFORTH execution semantics.

"doFASM" is a variable word whose value is the implementation of the execution semantics for assembly code implemented words. In those cases the execution leads to the word content.

The register context at entry to an assembly code implemented word is as follows:

The assembly code must ensure that rsi is preserved and that rsp and rbp are used according to their roles.

"." is a function word that prints the top stack value to stdout using the current BASE (either DECIMAL or HEX).

".TEMP" is a function word that renders a cell value as an integer using the current BASE, which is either DECIMAL or HEX. In DECIMAL BASE, a negative value is rendered as such with a leading minus sign, whereas HEX BASE rendering is unsigned.

""" (double quote) is a function word that copies the input stream text up to next double quote to PAD, and returns the [n:char*] cell pair for that string.

"doVALUE" is a variable word whose value is the implementation of the execution semantics for cell values, which are variables with a single 64-bit cell holding the value.

The execution of this result in pushing the value:

"doVARIABLE" is a variable word whose value is the implementation of the execution semantics for "variables", which basically are markers into the heap for some number block of memory.

The execution of a variable results in pushing its content address:

"DROP" is a function word that discards the top stack cell.

"DUP" is a function word that duplicates the top stack cell.

"ELSE" is an immediate function word that is used together with IF and THEN to implement structured execution control. ELSE lays out an unresolved unconditional branch as an ending for the "then-part" of the structured statement, and it then performs the branch resolution for the "else-part". To that end it replaces the stacked address which pin-points the foot address the branch offset to resolve, so that at execution time there is an appropriate conditional branch past the "then-part" and the "else-part" of the "structured statement".

"EMIT" is a function word that puts the given character code to standard output (file descriptor 1). The character is the least significant byte of the top cell.

"END" is an immediate function word that is used together with BEGIN, IFBREAK and IFAGAIN to implement structured execution control. END processes the data stack to resolve any dangling IFBREAK branch offset for the block of the matching BEGIN.

"=" is a function word that replaces a pair of values with -1 of the values are equal, and 0 otherwise.

"ERASE" is a function word that stores n NUL bytes at address a an up.

"EVALUATE-STREAM" is a function word that reads words separated by whitespace from the stream until it discovers an unknown word, or the stream is exhausted. Depending on STATE, the words are either executed or compiled, and all ther stack and heap effects are preserved. "EVALUATE-STREAM" returns with an additional 0 or 1 on the stack to respectively indicate that the last word was unkown, i.e. not found (FIND) in the current word list (CURRENT-WORDLIST) and not a NUMBER of the current BASE.

Note that numbers in the current BASE are treated as known words that are parsed into cell values. If interpreting, then the value is left on the stack. If compiling, then the value is added to the heap subsequent to first adding LIT, which is done so as to make that value be push to the data stack upon a later execution.

In the DECIMAL base, the number word may begin with a minus sign.

The words are read and executed one by one, accounting for whether its a number word or not, whether it is an IMMEDIATE word or not, and whether the state at the time of execution indicates "compiling" of "interpreting". Immediate words are executed in both interpreting and compiling state, while other words have their CFA get added to the heap so as to gain their execution effect upon a later execution.

Note that "EVALUATE-STREAM" keeps the stream (pointer) on the return stack while reading, parsing and executing.

If "EVALUATE-STREAM" ends with 0, then THIS-WORD holds the [n:chars] reference of the offending word in the stream buffer.

"EXECUTE" is a function word that transfers the execution to the indicated "Code Field Address", which typically is the CFA of an RRQFORTH word with the CFA cell containing a jump address for the code that implements the execution semnatics of the word.

The following execution semantics are predefined:

"EXIT" is a function word that terminates the rrqforth process immediately with the given exit code.

"FALSE" is a value word representing logical false.

"FDEMIT" is a function word that puts the given character code to the given file descriptor. The character is the least significant byte of the data stack cell.

"FDTELL" is a function word that prints a string to the given file descriptor.

"FIND" is a function word that searches the current word list search path for the given [n:char*] word, and returns the TFA of the matching word if any. Otherwise FIND preserves the initial data stack but adds 0 to it.

The word is sought starting with the CURRENT-WORDLIST word list, for the first occurence of a match. If not found, the search continues with the subsequent word list, and so on.

When a word is found, then the data stack is changed by discarding the [n:char*] double cell string pointer and pushing (only) the TFA of the matching word instead.

"FORTH" is a variable word for the FORTH word list, which does not have any subsequent word list.

"@" is a function word that pushes the value v from the address a.

"@n--" is a function word that pushes the value from the address, a, then decrements the cell at that address by n.

"@n++" is a function word that pushes the value from the address, a, then increments the cell at that address by n.

">=" is a function word that replaces a pair of values with -1 if the first, v1, is greater than or equal to the second, v1, otherwise 0. To that end, the values are 64-bit signed integers.

">" is a function word that replaces a pair of values with -1 if the first, v1, is greater than the second, v1, otherwise 0. To that end, the values are 64-bit signed integers.

">R" is a function word that "moves" the top data stack value onto the return stack.

"HERE" is a variable word that keeps the lowest address of the free allocation space. It get updated by all words that allocate memory.

See also ALLOT.

"HEX" is a function word that sets BASE to 16, which uses letters a-f as additional digits. (Uppercase letter are also accepted on input).

"IF" is an immediate function word that is used together with ELSE and THEN to implement structured execution control. IF results in layout of a 0BRANCH instruction with an unresolved branch offset, and places the address for resolving this instruction on the datastack. This address will then be resolved and asssigned by a subsequent ELSE or THEN so that at execution time there is an appropriate conditional branch past the "then-part" of the "structured statement".

"IFAGAIN" is an immediate function word that is used together with BEGIN, BREAK and END to implement structured execution control. IFAGAIN scans the datastack for the nearest preceding BEGIN marker and lays out a branch from this point the beginning of the block during execution.

"IFBREAK" is an immediate function word that is used together with BEGIN, IFAGAIN and END to implement structured execution control. IFBREAK simply places the address for resolving branches from this point the end of the block during execution.

"IMMEDIATE" is an immediate function word that sets the flags field of the most recent word to 1, thereby making that word an immediate word.

See also :, CURRENT-WORDLIST, @, +, !, and [p_semicolon;].

"INPUT" is a variable word for the input stream buffer used by EVALUATE-STREAM.

"[" (left bracket) is a function word that sets the stream evaluation mode to be intepreting. In this mode, words are executed immediately after parsing, by invoking their "doer".

"<=" is a function word that replaces a pair of values with -1 if the first, v1, is less than or equal to the second, v1, otherwise 0. To that end, the values are 64-bit signed integers.

"<" is a function word that replaces a pair of values with -1 if the first, v1, is less than the second, v1, otherwise 0. To that end, the values are 64-bit signed integers.

"LIT" is a function word that pushes the cell subsequent and moves excution past that. The literal value is thus layed out as if a subsequent CFA pointer in the containing definition, and the LIT execution will make the execution skip past that and instead contine with the CFA pointer following the value.

It’s not a good idea to use "LIT" interactively.

"S"" is a function word that pushes the [n:char] pointer for a string inlined subsequently to it in the containing definition. This is similar to LIT but for a string literal.

"LOAD-BUFFER-SIZE" is a variable word telling the buffer size in bytes that LOAD-FILE should use.

"LOAD-FILE" is a function word that evaluates a text file. It opens a file via OPEN-FILE and sets up a stream with a buffer of LOAD-BUFFER-SIZE bytes for reading it. The stream is passed to EVALUATE-STREAM for processing its words. Upon its return the file is closed and the stream memory is reclaimed, and then the function returns whatever EVALUATE-STREAM returns.

"(" (left parenthesis) is a function word that scans and ignores words until the next right parenthesis, or the end of the stream. This is used for comments in RRQFORTH code.

Note that the terminating right parenthesis is a word, i.e. must have whitespace before and after it.

"MALLOC" is a word that allocates memory using mmap of at least n bytes and returns the lowest address of the allocated block.

Note that this makes new page allocations for the process from the kernel, and the granularity is in pages, i.e. a multiple of 4 kb.

The memory is allocated with READ and WRITE access but not EXEC access, and flagged as PRIVATE, ANONYMOUS and LOCKED. See the "man page" of mmap for details.

See also STREAM

"-" (minus) is a function word that replaces a pair of values with the result of reducing the first, v1, with the second, v2. To that end, the values are 64-bit signed integers.

"*" is a function word that replaces a pair of values with the result of multiplying them. To that end, the values are 64-bit signed integers, and clipping the result to the least signifcant 64 bits.

"NEGATE" is a function word that replaces a value with its 2’s-complement negation. To that end, the values are 64-bit signed integers.

"NIP" is a function word that discards the second of the top two cells on the data stack.

"NL" is a value word pushing a newline character onto the data stack.

"NOT" is a function word that replaces a value with its bitwise complement; each bit is zero if non-zero, and non-zero if zero.

Compare with <<p_0equal,0⇒>.

"NUMBER" is a function word that parses a text number using BASE as numerical base, then returns the result number and a 1 on top, or just a 0 if the word didn’t parse.

A number consists of, first an optional minus sign, if in DECIMAL base, then digits 0-9 and, if in HEX base, letters a-f or A-F for values 10-15. I.e. the normal positive or negative decimal integers or normal (positive only) hexadecimal integers.

"OPEN-FILE" is a function word that opens the file named by the zero terminated character string and returns the file descriptor, or if less than 0, the system call error code.

"OR" is a function word that replaces a value pair with their bitwise disjunction; each bit is 1 if the corresponding bits of any operand is 1 and 0 if not.

"OVER" is a function word that duplicates the second top stack cell on the data stack.

"PAD" is a variable word for a 1 kb data space that is used by [p_double_quote] (only), and otherwise free for temporary use.

"PICK" is a function word that pushes the u:th data stack cell down from top onto the data stack. 0 indicates the top cell making it the same as DUP, and 1 indicates the second top cell making it the same as OVER.

"+" (plus) is a function word that replaces a pair of values with the result of adding them. To that end, the values are 64-bit signed integers.

"PROGRAM_VERSION" is a string variable hilding the version string.

"!" is a function word that stores the cell value v at the address a.

"!+" is a function word that adds n to the cell value at a.

"QUIT" is a function word that implements the root execution loop of RRQFORTH. First it resets the stacks to their original settings, and thereafter it enters loop of reading words from STDIN and executing them.

"'" (single quote) is a function word that reads and find the next word on the input stream and pushes its cfa.

"RSP" is a function word that pushes the return stack pointer value onto the data stack.

"R[n]" is a function word that pushes the address for the n:th cell on the top return stack value onto the data stack.

"READ-STREAM-CHAR" is a function word that gets the next character from the given stream buffer, possibly refilling the buffer if it is backed by a file descriptor. The refill is done by a SYS_READ call when more characters are needed. The next character is pushed on the stack, unless the stream is exhausted in which case the -1 is pushed instead.

See also STREAM.

"READ-WORD" is a function word that "reads" the next whitespace separated word from the given stream and returns the [n:char*] duoble cell pointer for it. The characters of the word are copied to PAD, and there is a limit of 1024 characters.

At the end of the stream READ-WORD returns 0 length.

"REALLOC" is a word that reallocates memory using mremap of address a of size m to be size n bytes and returns the lowest address of the allocated block.

Note that this makes new page allocations for the process from the kernel, and the granularity is in pages, i.e. a multiple of 4 kb.

The memory is reampped using the MREMAP_MAYMOVE flag,

See also MALLOC

"RETURN" is a function word that implements the ending of a FORTH definition and make execution return to the next step in the calling definition.

compile.asm: WORD p_right_bracket,],fasm

"]" (right bracket) is a function word that sets the stream evaluation mode to be compiling. In this mode words parsed into CFA pointers which are placed on the heap in the given order, unless the word is flagged as IMMEDIATE or a NUMBER. An immediate word is executed immediately, and a number is parsed and left on the stack.

Note that a word is parsed as a number only if it is not found in the wordlist; i.e., the word list may contain definitions for numbers.

"ROLL" is a function word that "moves" the u:th data stack cell down from top onto the data stack while discarding it. 0 indicates the top cell; 1 indicates the second top cell making it the same as SWAP; 2 indicates the third top cell making it the same as ROT.

"ROT" is a function word that "rotates" the top three data stack cells such that the third becomes the first while the second becomes third and the first becomes the second.

See also ROLL.

";" (semi-colon) is a function word that ends a new forth definition by means of adding an EXIT

"[p_setup_signals]" is a variable word that contains the assembly code sniippet for setting up the signal handling. rrqforth handles SEGV by restarting the interpreter loop on STDIN.

"<<" is a function word that shifts value v1 n steps left (i.e. "moving" bits towards more significant bits) to form value v2.

">>" is a function word that shifts value v1 n steps right (i.e. "moving" bits towards less significant bits) to form value v2.

"s>>" is a function word that shifts value v1 n steps right (i.e. "moving" bits towards less significant bits) to form value v2, but preserving (and copying) the sign bit.

"SP" is a value word pushing a space character onto the data stack.

"STATE" is a variable word marking whether the stream evaluator is in compiling mode (1) or interpreting (0) mode.

"STDIN" is a value word referring to the stream buffer for the standard input file descriptor.

"STREAM" is a function word that sets up a buffer for an input file descriptor or for a memory block (of size+data).

"STREAM-NCHARS" is a function word that scans ahead in the stream buffer for the next non-whitespace character, and returns its position relative to the end of the buffer. This is done without changing the stream (or filling it by reading the backing file).

"STRLEN" is a function words that counts how many bytes there are from s to the first NUL byte and returns that count, n, not including the NUL byte.

"STRNCMP" is a function words that compares up to n characters of character sequences s1 and s2, and returns the difference of the first differing characters, as in s2[i] - s1[i], or 0 if all n characters are the same.

I.e., the value v is less than 0 if string [n:s1] is alpha-numerically less than [n:s2], v is greater than 0 if [n:s1] is greater than [n:s2], and v is 0 if [n:s1] and [n:s2] are equal.

"STRNCPY" is a function words that copies n bytes of byte sequence s1 to s2.

"SWAP" is a function word the swaps the top two data stack cells.

"SYSTEM" is a variable that holds the word list data for the system calls. This is set up as separate word list from FORTH merely as a matter of segregation.

"TELL" is a function word that prints a string to stdout (file descriptor 1).

"TERMINATE0" is a function word that terminates the program with exit code 0.

"TFA>CFA" is a function word that pushes word cfa of the given tfa.

"TFA>DFA" is a function word that pushes word dfa of the given tfa.

"TFA>FLAGS@" is a function word that pushes word flags of the given tfa.

"TFA>NAMEZ" is a function word that pushes changes a tfa pointer to a pointer to the word pname’s character sequence, which is zero terminated as well as preceded by a length cell.

"THEN" is an immediate function word that is used together with IF and ELSE to implement structured execution control. THEN performs the branch resolution for the stacked address which pinpoints the foot address the branch offset to resolve, so that at execution time there is an appropriate conditional branch past the "then-part" or the "else-part" of the "structured statement".

"THIS-WORD" is a variable word used in [p_evaluate_stream:EVALUATE-STREAM] as cache for the [n:char*] values of the successive words being evaluated. This typically points into the input stream buffer and remain valid until further stream buffering functions are used.

"TRUE" is a value word representing logical true.

"TUCK" is a function word that "inserts" the top cell below the second cell on the data stack.

"!=" is a function word that replaces a pair of values with -1 of the values are unequal, and 0 otherwise.

"UNSTREAM" is a function word that releases the memory allocated for a stream, and closes the associated file if it’s a file stream.

"USE" is a function word that looks up next word given the wordlist. It reads next word on INPUT via READ-WORD, then temporarily changes CURRENT-WORDLIST to FIND the word via the given wordlist, and returns the TFA of that word, or just 0 if the word coudn’t be found.

"VERBOSE?" is a variable word that is assigned at start up to -1 or 0 signify whether or not the command line arguments includes "-v". When non-zero (i.e. running rrqforth with "-v") the evaluation loop is more verbose.

"WITHIN" is a function word that replaces a triple of values with -1 of the the first, v, is within the value range spanned by the second, lo, inclusive and third, hi, exclusive.

"WORDS" is a function word that prints all words of teh given word list to stdout (file descriptor 1).

"XOR" is a function word that replaces a value pair with their bitwise exclusion; each bit is 1 if the corresponding bits of the two operands differ and 0 if not.

"RETURN-STACK" is a variable word harbouring the return stack.