"

Return an empty string.

$

Return ASCII:NUL (0).

'

Return an empty string.

(

Provide a visual indication of a code group.

)

Provide a visual indication of a code group.

*

Multiply `n1` by `n2` and return the result.

Example:

+

Add `n1` to `n2` and return the result.

Example:

,

Store the specified value into the memory at `here` and increment `Heap` by 1.

Example:

-

Subtract `n2` from `n1` and return the result.

Example:

---reveal---

Switch to the exposed (public) portion of a lexical namespace.

-eq?

Compare two values for inequality. Returns `TRUE` if they are not equal or `FALSE` otherwise.

Example:

-if

Execute the quotation if the flag is `FALSE`.

-if;

Execute the quotation if the flag is `FALSE`. If false, also exit the word.

/

Divide `n` by `m` and return the integer part of the quotient.

/mod

Divide `n` by `m` and return the integer part of the quotient and remainder.

0;

If `n` is zero, drop `n` and exit the current word. If non-zero, leave `n` alone and allow execution to continue.

;

End the current definition.

?dup

Duplicate top value on stack if not zero. If zero, do nothing.

Example:

ASCII:ACK

Constant. Refers to specific ASCII code.

ASCII:BEL

Constant. Refers to specific ASCII code.

ASCII:BS

Constant. Refers to specific ASCII code.

ASCII:CAN

Constant. Refers to specific ASCII code.

ASCII:CR

Constant. Refers to specific ASCII code.

ASCII:DC1

Constant. Refers to specific ASCII code.

ASCII:DC2

Constant. Refers to specific ASCII code.

ASCII:DC3

Constant. Refers to specific ASCII code.

ASCII:DC4

Constant. Refers to specific ASCII code.

ASCII:DEL

Constant. Refers to specific ASCII code.

ASCII:DLE

Constant. Refers to specific ASCII code.

ASCII:EM

Constant. Refers to specific ASCII code.

ASCII:ENQ

Constant. Refers to specific ASCII code.

ASCII:EOT

Constant. Refers to specific ASCII code.

ASCII:ESC

Constant. Refers to specific ASCII code.

ASCII:ETB

Constant. Refers to specific ASCII code.

ASCII:ETX

Constant. Refers to specific ASCII code.

ASCII:FF

Constant. Refers to specific ASCII code.

ASCII:FS

Constant. Refers to specific ASCII code.

ASCII:GS

Constant. Refers to specific ASCII code.

ASCII:HT

Constant. Refers to specific ASCII code.

ASCII:LF

Constant. Refers to specific ASCII code.

ASCII:NAK

Constant. Refers to specific ASCII code.

ASCII:NUL

Constant. Refers to specific ASCII code.

ASCII:RS

Constant. Refers to specific ASCII code.

ASCII:SI

Constant. Refers to specific ASCII code.

ASCII:SO

Constant. Refers to specific ASCII code.

ASCII:SOH

Constant. Refers to specific ASCII code.

ASCII:SPACE

Constant. Refers to specific ASCII code.

ASCII:STX

Constant. Refers to specific ASCII code.

ASCII:SUB

Constant. Refers to specific ASCII code.

ASCII:SYN

Constant. Refers to specific ASCII code.

ASCII:US

Constant. Refers to specific ASCII code.

ASCII:VT

Constant. Refers to specific ASCII code.

Compiler

Variable. Holds the compiler state. If TRUE, the compiler is active. If FALSE, it is not.

Dictionary

Variable. Holds a pointer to the most recent dictionary header.

EOM

Constant. Returns the last addressable memory address.

FALSE

Returns `0`, the value used to indicate a FALSE result.

FREE

Returns the number of cells available to your application. This is the amount of memory, less the already consumed portion and buffers mapped for RETRO's internal use.

Heap

Variable. Holds the address of the next available cell.

I

Access the loop index for the current loop. (For loops made using `times<with-index>`)

J

Access the parent loop index for the current loop. (For loops made using `times<with-index>`)

K

Access the grandparent loop index for the current loop. (For loops made using `times<with-index>`)

NoEcho

Variable. If TRUE, allow display of the "ok" prompt and startup banner.

RewriteUnderscores

Variable. When set to `TRUE`, RETRO will replace underscores in strings with spaces. When `FALSE`, RETRO does not.

STRINGS

Return the address of the start of the temporary string pool.

ScopeList

Variable. This holds some information used by `{{` and `}}`.

TIB

Constant. Returns a pointer to the text input buffer.

TRUE

Returns `-1`, the value used to indicate a TRUE result.

TempStringMax

Variable. Holds the maximum length of a temporary string.

TempStrings

Variable. Holds the number of temporary strings.

Version

Variable. This stores the version number.

[

Begin a quotation.

]

End a quotation.

a:-eq?

Compare all values in the array. Return `FALSE` if all values are equal or `TRUE` otherwise. This assumes the array contains only numeric values.

a:append

Return a new array consisting of the values in a1 followed by the values in a2.

a:begins-with?

Return `TRUE` if a1 begins with a2 or `FALSE` otherwise.

a:chop

Return a new array containing all but the last value in the source array.

a:contains-string?

Return `TRUE` if the string value is in the array or`FALSE` otherwise.

a:contains?

Return `TRUE` if the value is in the array or `FALSE` otherwise.

a:copy

Copy an array (a1) to a destination (a2).

a:counted-results

Run a quote and construct a new array from the returned values. The quote should return the values and the number of values to put into the array.

a:dup

Make a copy of an array. Return the address of the copy.

a:ends-with?

Return `TRUE` if a1 ends with a2 or `FALSE` otherwise.

a:eq?

Compare all values in the array. Return `TRUE` if all values are equal or `FALSE` otherwise. This assumes the array contains only numeric values.

a:fetch

Fetch the value stored at the specified index in the specified array.

Example:

a:filter

For each item in the initial array, run the specified quote. If the quote returns `TRUE`, copy the item into a new array. If `FALSE`, discard it. Returns a pointer to the new array.

a:for-each

Execute the quote once for each item in the array.

a:from-string

Create a new array with the characters in the source string.

a:index-of

Return the location of the first instance of the specified value in the array.

a:left

Return a new array containing the first `n` values from the source array.

a:length

Return the length of a array.

a:make

Execute quote. Return a new array containing the values the quote leaves on the stack. This is identical to doing `a:counted-results a:reverse`

a:map

Execute quote once for each item in the array. Constructs a new array from the value returned by the quote.

a:middle

Extract a new array from the middle of the specified array. This will take the values starting at `f` and extend to the `l` last value.

a:prepend

Return a new array consisting of the values in a2 followed by the values in a1.

a:reduce

Takes an array, a starting value, and a quote. This will apply the quote to each item in the array; the quote should consume two values and return one.

a:reverse

Reverse the order of items in a array. This will return a new array.

a:right

Return a new array containing the specified number of values from the right side of the array.

a:store

Store a value into the array at the specified index.

Example:

a:th

Return the actual address of the `n`th item in the array.

a:to-string

Create a new string from the provided array. This string will be stored in the temporal string buffers.

again

Close an unconditional loop. Branches back to the prior `repeat`.

allot

Allocate the specified number of cells from the `Heap`.

Example:

and

Perform a bitwise AND operation between the two provided values.

as{

Begin an assembly section.

banner

Display a welcome message on startup.

bi

Execute q1 against x, then execute q2 against a copy of x.

Example:

bi*

Execute q1 against x and q2 against y.

Example:

bi@

Execute q against x, then execute q against y.

Example:

buffer:add

Append a value to the current buffer.

buffer:empty

Reset the current buffer to an empty state.

buffer:end

Return a pointer to the current end of the active buffer.

buffer:get

Remove the last value from the current buffer.

buffer:preserve

Save and restore the current buffer before and after executing the specified quote.

buffer:set

Assign a new buffer as the current one.

buffer:size

Return the number of cells in the buffer.

buffer:start

Return the start address of the current buffer.

bye

Exit RETRO.

c:-consonant?

Return TRUE if character is a not consonant or FALSE otherwise.

c:-digit?

Return TRUE if character is a not numeric digit or FALSE otherwise.

c:-lowercase?

Return TRUE if character is not lowercase or FALSE otherwise.

c:-uppercase?

Return TRUE if character is not uppercase or FALSE otherwise.

c:-visible?

Return TRUE if character is not printable or FALSE otherwise.

c:-vowel?

Return TRUE if character is not a vowel or FALSE otherwise.

c:-whitespace?

Return TRUE if character is not whitespace, or FALSE otherwise.

c:consonant?

Return TRUE if character is a consonant or FALSE otherwise.

c:digit?

Return TRUE if character is a numeric digit or FALSE otherwise.

c:get

Read a single keypress.

c:letter?

Return TRUE if character is an ASCII letter or FALSE otherwise.

c:lowercase?

Return TRUE if character is lowercase or FALSE otherwise.

c:put

Display a single character.

c:to-lower

Convert character to lowercase equivalent.

c:to-number

Convert an ASCII digit character into the corresponding decimal value

c:to-string

Convert character into a string.

c:to-upper

Convert character to uppercase equivalent.

c:toggle-case

Convert an ASCII character to the opposite case.

c:uppercase?

Return TRUE if character is uppercase or FALSE otherwise.

c:visible?

Return TRUE if character is printable or FALSE otherwise.

c:vowel?

Return TRUE if character is a vowel or FALSE otherwise.

c:whitespace?

Return TRUE if character is whitespace, or FALSE otherwise.

call

Call a function.

case

If `n` is equal to `m`, drop both and execute the specified quote before exiting the calling word. If not equal, leave `n` on the stack and let execution continue.

choose

Execute q1 if the flag is true (-1) or q2 if the flag is false (0). Only these flags are valid when using `choose`.

class:data

Class handler for data structures.

Interpret Time: Keep the address or value on the stack.

Compile Time: Compile the value or address as a literal into the current definition.

class:macro

Class handler for compiler macros (immediate words)

Interpret Time: Execute the function at the provided address.

Compile Time: Execute the function at the provided address.

class:primitive

Class handler for primitive words (words which map to Nga instructions)

Interpret Time: Execute the function.

Compile Time: Compile the machine code in the definiton into the current definition.

class:word

Class handler for normal words.

Interpret Time: Execute the function at the provided address.

Compile Time: Compile a call to the specified address into the current definition.

clear

Clear the display.

clock:day

Return the current day.

clock:hour

Return the current hour.

clock:minute

Return the current minute.

clock:month

Return the current month.

clock:second

Return the current second.

clock:timestamp

Return a host and implementation specific timestamp.

clock:utc:day

Return the current day.

clock:utc:hour

Return the current hour.

clock:utc:minute

Return the current minute.

clock:utc:month

Return the current month.

clock:utc:second

Return the current second.

clock:utc:year

Return the current year.

clock:year

Return the current year.

compile:call

Compile a call to the specified address into the current definition.

compile:jump

Compile a jump to the specified address into the current definition.

compile:lit

Compile the code to push a number to the stack into the current definition.

compile:ret

Compile a return instruction into the current definition.

compiling?

Return `TRUE` if compiler is on or `FALSE` otherwise.

const

Create a constant returning the specified value.

copy

Copy `l` cells from memory at `s` to the memory at `d`. These should not overlap.

curry

Bind a value to a function and return a new quote that calls the bound action.

d

Inline a numeric value to the current assembly segment.

d:add-header

Create a header. Provide a string (s) for the name, a pointer to the class handler (a1) and a pointer to the word definition (a2) Generally this won't be used directly.

d:class

Given a dictionary header, return the class field.

d:create

Create a new dictionary header named the specified string. The new header will point to `here` and have a class of `class:data`.

d:for-each

Execute the specified quote once for each header in the dictionary. Before running the quote, this also pushes a pointer to the header onto the stack.

d:last

Return the most recent dictionary header.

d:last<class>

Return a pointer to the class field of the most recent dictionary header.

d:last<name>

Return a pointer to the name field of the most recent dictionary header.

d:last<xt>

Return a pointer to the xt field of the most recent dictionary header.

d:link

Given a dictionary header, return the link field.

d:lookup

Lookup the specified name in the dictionary and return a pointer to its dictionary header. This returns zero if the word is not found.

d:lookup-xt

Lookup the specified address in the dictionary and return a pointer to its dictionary header. This returns zero if the word is not found.

d:name

Given a dictionary header, return the name field.

d:words

Display a list of all named items in the `Dictionary`.

d:words-beginning-with

Display a list of all named items in the `Dictionary` that begin with the provided substring.

d:words-with

Display a list of all named items in the `Dictionary` that contain the provided substring.

d:xt

Given a dictionary header, return the xt field.

data

Change the class of the most recently defined word to `class:data`.

depth

Return the number of items on the stack.

dip

Temporarily remove n from the stack, execute the quotation, and then restore n to the stack.

does

Attach an action to the most recently created word. This is used in a manner similar to CREATE/DOES> in traditional Forth.

drop

Discard the top value on the stack.

drop-pair

Remove top two items on the stack.

dump-stack

Display the items on the data stack.

dup

Duplicate the top item on the stack.

dup-pair

Duplicate the top two items on the stack.

e:-INF

Constant. Negative infinity. For encoded floating point values.

e:-inf?

Is encoded value negative infinity?

e:INF

Constant. Infinity. For encoded floating point values.

e:MAX

Constant. Maximum value. For encoded floating point values.

e:MIN

Constant. Minimum value. For encoded floating point values.

e:NAN

Constant. Not a Number. For encoded floating point values.

e:clip

Constrain the encoded value to the allowable range.

e:inf?

Is encoded value infinity?

e:max?

Is encoded value at the maximum?

e:min?

Is encoded value at the minimum?

e:n?

Return `TRUE` if the encoded value is a valid number, or `FALSE` otherwise.

e:nan?

Is encoded value a Nan?

e:put

Display an encoded number.

e:to-f

Decode an encoded floating point value.

e:zero?

Return `TRUE` if the value is zero, or `FALSE` otherwise.

eq?

Compare two values for equality. Returns `TRUE` if they are equal or `FALSE` otherwise.

Example:

err:notfound

Error handler. Called when a word is not found by `interpret`.

f:*

Multiply two floating point numbers, returning the result.

Example:

f:+

Add two floating point numbers, returning the result.

Example:

f:-

Subtract F2 from F1 returing the result.

Example:

f:-INF

Return a value corresponding to negative infinity

f:-eq?

Compare two floating point values for inequality. Returns `TRUE` if they are not equal or `FALSE` otherwise.

f:-inf?

Return `TRUE` if floating point value is -INF or `FALSE` otherwise.

f:/

Divide floating point value F1 by F2.

f:E

Return the floating point value for Euler's number.

f:E1

Hook. Return a constant used as the scaling factor for the e: words.

f:INF

Return a value corresponding to positive infinity

f:NAN

Return a value corresponding to NaN

f:PI

Return the floating point value for PI.

f:abs

Return the absolute value for a floating point value.

f:acos

Return the arc cosine of a floating point number.

f:adepth

Return the number of items on the alternate floating point stack.

f:asin

Return the arc sine of a floating point number.

f:atan

Return the arc tangent of a floating point number.

f:between?

Return TRUE if number is between the lower (l) and upper (u) bounds. If not, return FALSE. This is inclusive of the limits.

Example:

f:case

If `n` is equal to `m`, drop both and execute the specified quote before exiting the calling word. If not equal, leave `n` on the stack and let execution continue.

f:ceiling

Return the smallest integral value greater than or equal to the specified value.

f:cos

Return the cosine of a floating point number.

f:dec

Decrement n by one.

Example:

f:depth

Return the number of items on the floating point stack.

f:drop

Discard the top item on the floating point stack.

f:drop-pair

Remove top two items on the stack.

f:dump-astack

Display the items on the alternate floating point stack.

f:dump-stack

Display the items on the floating point stack.

f:dup

Duplicate the top item on the floating point stack.

f:dup-pair

Duplicate the top two items on the stack.

f:eq?

Compare two floating point values for equality. Returns `TRUE` if they are equal or `FALSE` otherwise.

f:fetch

Fetch a stored floating point value.

f:floor

Perform a mathmatical floor operation on the floating point value.

f:gt?

Compare two floating point values for greater than.

f:inc

Increment n by one.

Example:

f:inf?

Return `TRUE` if floating point value is INF or `FALSE` otherwise.

f:limit

Return n if it is within the lower (l) and upper (u) bounds. If outside the bounds, return the closes boundary value.

Example:

f:log

Return log(F1) for base F2 for floating point values.

f:lt?

Compare two floating point values for less than.

f:max

Return the greater of two values.

Example:

f:min

Return the lesser of two values.

Example:

f:nan?

Return `TRUE` if floating point value is NaN or `FALSE` otherwise.

f:negate

Invert the sign of the floating point value.

Example:

f:negative?

Return `TRUE` if floating point value is negative or `FALSE` if not.

f:nip

Remove the second item from the stack.

f:over

Put a copy of the second floating point value over the top one.

f:pop

Pop a floating point value from the alternate stack.

f:positive?

Return `TRUE` if floating point value is positive or `FALSE` otherwise.

f:power

Return F1^F2 for floating point values.

f:push

Push a floating point value to an alternative stack.

f:put

Display a floating point number.

f:rot

Rotate the top three values.

f:round

Round a floating point value.

f:sign

Return 1 if the floating point value is positive or -1 if it is negative.

Example:

f:signed-sqrt

Return the square root of a floating point number.

f:signed-square

Return the square of a floating point number.

f:sin

Return the sine of a floating point number.

f:sqrt

Return the square root of a floating point number.

f:square

Return the square of a floating point number.

f:store

Store a floating point value to the specified memory location.

f:swap

Exchange the top and second items on the floating point stack.

f:tan

Return the tangent of a floating point number.

f:to-e

Encode the floating point value to an integer.

f:to-number

Convert a floating point value into a number.

f:to-string

Convert a floating point value into a string.

f:tuck

Tuck a copy of the top floating point value under the second one.

fetch

Fetch the value stored at the specified address.

Example:

fetch-next

Fetch the value stored at the specified address. Returns the next address and the value.

file:A

Constant for opening a file in APPEND mode.

file:R

Constant for opening a file in READ mode.

file:R+

Constant for opening a file in READ & WRITE mode.

file:W

Constant for opening a file in WRITE mode.

file:close

Given a file handle, close the file.

file:delete

Delete the named file.

file:exists?

Given a file name, return `TRUE` if it exists or `FALSE` if it does not.

file:flush

Given a file handle, flush any pending writes to disk.

file:for-each-line

Given a file name, open it and run the quote once for each line in the file.

file:open

Open a named file (s) with the given mode (m). Returns a handle identifying the file.

Example:

file:open<for-append>

Open a file for reading & writing. Returns the size (NOS) and a file ID (TOS)

file:open<for-reading>

Open a file for reading. Returns the size (NOS) and a file ID (TOS)

file:open<for-writing>

Open a file for writing. Returns the file ID

file:read

Given a file handle, read and return the next character in it.

file:read-line

Given a file handle, read a line and return a pointer to it.

file:seek

Move the current offset into a file to the specified one.

file:size

Given a file handle, return the size of the file (in bytes).

file:slurp

Given an address and a file name, read the file contents into memory starting at the address.

file:spew

Given a string (s1) and a file name (s2), write the string into the file, replacing any existing cotent.

file:tell

Given a file handle, return the current offset in the file.

file:write

Write a character to the file represented by the handle.

gopher:get

Takes an address, a server, a port, and a selector. Fetch the resource and store it at address. Return the number of bytes received.

Example:

gt?

Compare n1 and n2. Return `TRUE` if n1 is greater than n2, or `FALSE` otherwise.

gteq?

Compare n1 and n2. Return `TRUE` if n1 is greater than or equal to n2, or `FALSE` otherwise.

here

Return the next free address in memory.

hook

Add a hook point into the current word. This should only be used as the first word in a definition.

Example:

i

Assemble the instructions specified by the string into the current assembly scope.

if

Execute the quote if the flag is `TRUE`.

if;

Execute the quotation if the flag is `TRUE`. If true, also exit the word.

image:save

Save the current system to a new image file.

immediate

Change the class of the most recently defined word to `class:macro`.

include

Run the code in the specified file.

interpret

Interpret a single input token.

Example:

io:enumerate

Return the number of I/O devices.

io:file-operation

Trigger a file I/O operation. This is not intended to be used directly.

io:float-operation

Trigger a floating point operation. This is not intended to be used directly.

io:invoke

Invoke an interaction with an I/O device.

io:query

Ask an I/O device to identify itself. Returns a version (m) and device ID (N).

io:scan-for

Scan the I/O devices for a device with a specified ID. Returns the device number, or -1 if not found.

io:unix-syscall

Trigger a Unix system call. This is not intended to be used directly.

listen

Run interactive "listener" (a REPL).

lt?

Compare n1 and n2. Return `TRUE` if n1 is less than n2, or `FALSE` otherwise.

lteq?

Compare n1 and n2. Return `TRUE` if n1 is less than or equal to n2, or `FALSE` otherwise.

mod

Divide `n` by `m` and return the remainder.

n:-zero?

Return `TRUE` if number is not zero, or `FALSE` otherwise.

n:MAX

Return the maximum value that will fit in a cell.

n:MIN

Return the minimum value that will fit in a cell.

n:abs

Return the absolute value of a number.