Documentation

; ( -- )

Return: pops the return stack into P.

<address: i32> ( -- )

Call, written as a bare label: pushes the address of the next instruction onto the return stack and jumps.

lit <value: i32> ( -- value: i32 )

Push a literal. A bare number is the same instruction.

next <address: i32> ( -- )

Loop: pops R; falls through when it was 0, otherwise pushes R-1 back and jumps.

<address: i32> ; ( -- )

Jump, written as a label followed by ;.

if <address: i32> ( flag: i32 -- )

Pops T: continues with the next instruction word if it was non-zero, jumps if it was zero.

-if <address: i32> ( value: i32 -- )

Minus-if. Pops T: continues with the next instruction word if it was negative (T[31] set), jumps if it was non-negative.

a! ( value: i32 -- )

A-Store. Stores T into register A, popping the data stack.

b! ( value: i32 -- )

B-Store. Stores T into register B, popping the data stack.

@p <address: i32> ( -- value: i32 )

Pushes the data stack, reads [P] into T, and increments P.

@+ ( -- value: i32 )

Fetch-plus. Pushes the data stack, reads [A] into T, and increments A.

@b ( -- value: i32 )

Fetch-B. Pushes the data stack and reads [B] into T.

@ ( -- value: i32 )

Fetch. Pushes the data stack and reads [A] into T.

!p <address: i32> ( value: i32 -- )

Store-P. Writes T into [P], pops the data stack, and increments P.

!b ( value: i32 -- )

Store-B. Writes T into [B] and pops the data stack.

!+ ( value: i32 -- )

Store-plus. Writes T into [A], pops the data stack, and increments A.

! ( value: i32 -- )

Writes T into [A] and pops the data stack.

+* ( s: i32, t: i32 -- s: i32, t: i32 )

Multiply step. Leaves S alone, replaces T, and shifts A: one iteration of a shift-and-add multiply.

+/ ( remainder: i32, quotient: i32 -- remainder: i32, quotient: i32 )

Divide step: A holds the dividend, [B] the divisor, T the quotient so far and S the remainder (details: example/step-by-step-div.py).

2* ( value: i32 -- shifted: i32 )

Left shift.

2/ ( value: i32 -- shifted: i32 )

Right shift (signed).

inv ( value: i32 -- inverted: i32 )

Invert all bits (was ~).

+ ( s: i32, t: i32 -- sum: i32 )

Add, or add with carry in extended arithmetic mode.

eam ( flag: i32 -- )

Set arithmetic mode: pops T, extended iff it was non-zero.

and ( s: i32, t: i32 -- bits: i32 )

xor ( s: i32, t: i32 -- bits: i32 )

Exclusive Or. Replaces T with the Boolean XOR of S and T. Pops the data stack.

drop ( value: i32 -- )

Drop. Pops the data stack.

dup ( value: i32 -- value: i32, value: i32 )

Dup. Duplicates T on the data stack.

r> ( -- value: i32 )

Moves R into T, popping the return stack and pushing the data stack.

>r ( value: i32 -- )

Moves T into R, pushing the return stack and popping the data stack.

over ( s: i32, t: i32 -- s: i32, t: i32, s: i32 )

Copies S over the top of the data stack.

a ( -- value: i32 )

Fetches the contents of register A into T, pushing the data stack.

halt ( -- )