Skip to content

Compiler, assembler, and VM for intcode from Advent of Code 2019

License

CC0-1.0, MIT licenses found

Licenses found

CC0-1.0
LICENSE-CC0
MIT
LICENSE-MIT
Notifications You must be signed in to change notification settings

benediktwerner/intcode

Repository files navigation

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.

About

Compiler, assembler, and VM for intcode from Advent of Code 2019

Resources

License

CC0-1.0, MIT licenses found

Licenses found

CC0-1.0
LICENSE-CC0
MIT
LICENSE-MIT

Stars

Watchers

Forks

Languages