Instructions¶

An instruction consists of a mnemonic and at most one operand. Each instruction represents an operation to the current value stack. If the mnemonic is foo and the operand is Bar, the instruction is written as foo Bar. If the mnemonic is baz and it takes no operand, the instruction is written as baz.

Semicolons can be placed optionally after instructions, such as foo Bar; and baz;.

Procedures¶

A procedure is a unit of processing comprised of a series of one or more instructions. A procedure is written enclosing the series of instructions by { and }.

For example, a procedure comprised of instructions foo, bar Baz and qux is written as { foo; bar Baz; qux }.

The syntax accepts inline comments headed by #.

Registers¶

Registers are data used in a run of the procedure.

Value stacks¶

The value stack is one of the registers of the run.

Values can be pushed to and popped from the value stack. When values a, b and c are pushed to the value stack, a will be the third topmost value, b will be the second topmost value, and c will be the topmost value. When values d, e, f are popped from the value stack, first the evaluator checks that the value stack contains enough values (in this case 3 values), then d is taken from the third topmost value, e is taken from the second topmost value, and f is taken from the topmost value.

Runs¶

A run starts by invoke operation, or continue operation for a KSM snapshot frame. If there is not enough resource to start the run, an exception is raised.

The run proceedes as the following.

• Fetches the instruction at the program counter, and executes it.
• Increments the program counter if the run does not end in the execution of the instruction.
• If the program counter is equal to the length of the procedure, the run ends and continue operation is performed with the topmost value of the value stack for the executor.
• Goes back to the first line.

Checks¶

When this chapter writes “checks that ...,” the specified condition is tested. If the condition turns out to be false, an exception is raised.

Exceptions¶

An exception might be raised during the run.

If so, the run ends and the exception is raised in the executor.

num Num¶

The instruction takes a num token as the operand.

The instruction pushes a num val which represents the number.

str Str¶

The instruction takes a string token as the operand.

The instruction pushes a str val which represents the string.

nada¶

The instruction pushes the value () (nada).

emptyvec¶

The instruction pushes a new empty vector.

add¶

The instruction pops two values vec and element, then checks that vec is a vector value

The instruction pushes a new vector which contains all the elements of vec, and element as the last element.

concat¶

The instruction pops two values first and second, and checks that both values are vector values.

Finally, the value pushes a new vector concatenating the two vectors first and second in the order.

dup¶

The instruction pops a value, and puts the value twice.

flip¶

The instruction pops two values, and pushes the values flipping the order.

remove¶

The instruction pops a value.

binding¶

The instruction pushes the context binding.

varref Symbol¶

The instruction takes a symbol token as the operand.

The instruction pops a value owner. And then it pushes a variable reference or a varref whose owner is owner and with the symbol.

deref Symbol¶

The instruction takes a symbol token as the operand.

The instruction pops a value owner. It checks that the the variable (owner, Symbol) is nonempty. And then it pushes the target of the variable.

fun Procedure¶

The instruction takes a procedure as the operand.

The instruction pops a value enclosingbinding. And then it pushes a function value made with the procedure. This function is said to be an enclosed function.

When an executor invokes the function, a KSM procedure run starts with the following registers.

call¶

The instruction pops values fun, recv, and args. It checks that fun is a function value, and args is a vector value.

If the instruction is not at the end of the procedure, it pushes a KSM snapshot frame with the following attributes.

And then, whether the instruction is at the end or not, the current KSM procedure run ends and invoke operation is performed on the executor with the following operands.