README.md

Intcode compiler, assembler and VM

Compiler, assembler and VM for the intcode computer from Advent of Code 2019. This is mainly for fun and to try out some different Rust parsing libraries.

There are four crates in this project:

• intcode: Wrapper binary for executing the compiler, assembler or VM
• vm: An intcode VM that can run intcode files: intcode run input.int
• asm: An intcode assembler that can assemble intcode programs from intcode assembly: intcode asm input.asm
• compiler: An intcode compiler that can compile intcode programs from a higher-level language: intcode compile input.ic

Building and Installing

Building or installing requires a working Rust Installation.

Build from source and install:

$ git clone https://github.com/benediktwerner/intcode
$ cd intcode
$ cargo install --path intcode
$ intcode

To just build from source:

$ git clone https://github.com/benediktwerner/intcode
$ cd intcode
$ cargo build
$ ./target/debug/intcode

Compiler

The compiler can compile code written in a simple high-level language to intcode:

// Comment

var x;              // Variables must be declared before their first use. Globals are initialized to zero.
var y = 13;         // but they can also be declared on the first assignment

var z = input();    // Get input
print(y);           // Produce output

func fib(x) {       // Arguments and variables declared in functions are seperate for each call
    y = 42;         // Modify a global variabl
    if x < 2 {
        return 1;
    }
    return fib(x - 1) * x;  // Recursion is possible
}

print(fib(z));
print(x);           // Still zero because the function has its own scope
print(y);           // Changed to 42

const LENGTH = 6 * 7;   // Constants are computed at compile time

array a[LENGTH];        // Declare a new array with the given length. Only constant expressions can be used to specify the length

var index = 0;
while index < LENGTH {
    a[index] = fib(index);
}

print(a[LENGTH - 1]);

An extension for syntax highlighting in Visual Studio Code can be found in vscode-syntax-highlighting. It works if the file has the .ic extension.

Assembler

Example

This program computes Day 1 Part 1 in intcode:

# Comments start with '#'
start:                  # Label for jump
    in x                # Read to memory location x. The assembler automatically 'allocates' this memory after the program.
    eq x 0 tmp          # Check if input == 0. If yes, stop and print the result.
    jmp_true tmp :end   # Label targets must be prefixed with a ':' (to get the address instead of the value)
    div x 3 x
    sub x 2 x
    add total x total
    jmp :start

end:
    out total
    hlt

# Initialize 'total' to 0. The assembler does this automatically so
# this isn't really neccessary, but it shows the concept.
total: data 0

More examples can be found in the examples directory.

Instructions

Operation	Effect	Note
mov a target	target = a
add a b target	target = a + b
sub a b target	target = a - b
mul a b target	target = a * b
div a b target	target = a // b	Can be quite slow, only works for positive numbers atm.
mod a b target	target = a % b	Can be quite slow, only works for positive numbers atm
divmod a b target rest	target, rest = divmod(a, b)	Can be quite slow, only works for positive numbers atm
in target	target = input()
out a	print(a)
jmp target	goto target
jnz a target	if a != 0: goto target	Alias: jtrue
jz a target	if a == 0: goto target	Alias: jfalse
eq a b target	target = a == b
neq a b target	target = a != b
lt a b target	target = a < b
leq a b target	target = a <= b
gt a b target	target = a > b
geq a b target	target = a >= b
and a b target	target = a and b
or a b target	target = a and b
not a target	target = not a
add_rel_base a	rel_base += a
load a target	target = memory[a]
store a target	memory[target] = a
hlt	exit()	Alias: halt
data x	stores x as raw data	Accepts multiple arguments, e.g. data 1 5 13 42
array val len	stores val len times as raw data
push val	memory[rel_base] = val; rel_base += 1
pop target	rel_base -= 1; target = memory[rel_base]
call target	push(ip)
ret	goto pop(ip)

The predifined label __end can be used to get the address after all the generated code. This is useful for putting a stack after the program: add_rel_base :__end. Simply putting a label at the end of the program will not work if the program contains undeclared labels/variables because they will be put after the program.

Parameter types

• Identifier positional: some_name
• Identifier immediate: :some_name
• Identifier relative: %some_name
• Value positional: [42]
• Value immediate: 42
• Value relative: %42

License

All the code in this repository is in the public domain. Or if you prefer, you may also use it under the MIT license or CC0 license.

Note though that some parts of this code use external libraries which have their own licenses.