├── .gitignore
├── run.bat
├── debug.bat
├── .vscode
    ├── tasks.json
    └── launch.json
├── README.md
├── src
    ├── test.lox
    ├── main.odin
    ├── chunk.odin
    ├── memory.odin
    ├── value.odin
    ├── table.odin
    ├── debug.odin
    ├── scanner.odin
    ├── object.odin
    ├── vm.odin
    └── compiler.odin
└── test.lox


/.gitignore:
--------------------------------------------------------------------------------
1 | .vs/
2 | 
3 | *.exe
4 | *.pdb
5 | ols.json


--------------------------------------------------------------------------------
/run.bat:
--------------------------------------------------------------------------------
1 | @echo off
2 | 
3 | if not exist \bin mkdir \bin
4 | odin build src -out:bin/lox.exe -o:speed
5 | .\bin\lox.exe %*


--------------------------------------------------------------------------------
/debug.bat:
--------------------------------------------------------------------------------
1 | @echo off
2 | 
3 | if not exist \bin mkdir \bin
4 | odin build src -debug -out:bin/lox.exe
5 | echo Debug build complete.
6 | 
7 | echo Opening Visual Studio
8 | devenv bin/lox.exe %*


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // See https://go.microsoft.com/fwlink/?LinkId=733558
 3 |     // for the documentation about the tasks.json format
 4 |     "version": "2.0.0",
 5 |     "tasks": [
 6 |         {
 7 |             "label": "build",
 8 |             "type": "shell",
 9 |             "command": "odin build src -debug -out:bin/lox.exe"
10 |         }
11 |     ]
12 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # odinLox
 2 | An implementation of a Lox bytecode virtual machine and compiler based on Robert Nystrom's Crafting Interpreters written in the [Odin Programming Language](https://odin-lang.org/).
 3 | 
 4 | The language is complete, including modulo and NaN Boxing optimizations.
 5 | 
 6 | ## Usage - Windows
 7 | To build and run the VM, simply run:
 8 | ```
 9 | .\run
10 | ```
11 | 
12 | ## Usage - Other
13 | I've not included build scripts for other platforms but provided you have an Odin compiler you can run:
14 | ```
15 | odin build src -out:lox.exe -o:speed
16 | ```
17 | This will produce an executable for your platform.
18 | 


--------------------------------------------------------------------------------
/src/test.lox:
--------------------------------------------------------------------------------
 1 | 
 2 | class Zoo {
 3 |   init(a, b) {
 4 |     this.aarvark  = 1;
 5 |     this.baboon   = 1;
 6 |     this.cat      = 1;
 7 |     this.donkey   = 1;
 8 |     this.elephant = 1;
 9 |     this.fox      = 1;
10 |   }
11 |   ant()    { return this.aarvark; }
12 |   banana() { return this.baboon; }
13 |   tuna()   { return this.cat; }
14 |   hay()    { return this.donkey; }
15 |   grass()  { return this.elephant; }
16 |   mouse()  { return this.fox; }
17 | }
18 | 
19 | var zoo = Zoo("hello", "zoo");
20 | var sum = 0;
21 | var start = clock();
22 | var batch = 0;
23 | while (clock() - start < 10000000000) {
24 |   for (var i = 0; i < 10000; i = i + 1) {
25 |   }
26 | }
27 | 
28 | //print sum;
29 | //print batch;
30 | //print clock() - start;
31 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // Use IntelliSense to learn about possible attributes.
 3 |     // Hover to view descriptions of existing attributes.
 4 |     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 5 |     "version": "0.2.0",
 6 |     "configurations": [
 7 |         {
 8 |             "name": "(Windows) Launch",
 9 |             "type": "cppvsdbg",
10 |             "request": "launch",
11 |             "program": "${workspaceRoot}/bin/lox.exe",
12 |             "args": ["test.lox"],
13 |             "stopAtEntry": false,
14 |             "cwd": "${fileDirname}",
15 |             "environment": [],
16 |             "console": "integratedTerminal",
17 |             "preLaunchTask": "build"
18 |         }
19 |     ]
20 | }


--------------------------------------------------------------------------------
/test.lox:
--------------------------------------------------------------------------------
 1 | class Zoo {
 2 |   init() {
 3 |     this.aarvark  = 1;
 4 |     this.baboon   = 1;
 5 |     this.cat      = 1;
 6 |     this.donkey   = 1;
 7 |     this.elephant = 1;
 8 |     this.fox      = 1;
 9 |   }
10 |   ant()    { return this.aarvark; }
11 |   banana() { return this.baboon; }
12 |   tuna()   { return this.cat; }
13 |   hay()    { return this.donkey; }
14 |   grass()  { return this.elephant; }
15 |   mouse()  { return this.fox; }
16 | }
17 | 
18 | var zoo = Zoo();
19 | var sum = 0;
20 | var start = clock();
21 | var batch = 0;
22 | while (clock() - start < 10000000000) {
23 |   for (var i = 0; i < 10000; i = i + 1) {
24 |     sum = sum + zoo.ant()
25 |               + zoo.banana()
26 |               + zoo.tuna()
27 |               + zoo.hay()
28 |               + zoo.grass()
29 |               + zoo.mouse();
30 |   }
31 |   batch = batch + 1;
32 | }
33 | 
34 | print sum;
35 | print batch;
36 | print clock() - start;
37 | 


--------------------------------------------------------------------------------
/src/main.odin:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "core:bufio"
 4 | import "core:fmt"
 5 | import "core:io"
 6 | import "core:log"
 7 | import "core:mem"
 8 | import "core:os"
 9 | import "core:time"
10 | 
11 | main :: proc() {
12 | 	context.logger = log.create_console_logger()
13 | 
14 | 	// tracking_allocator: mem.Tracking_Allocator
15 | 	// mem.tracking_allocator_init(&tracking_allocator, context.allocator)
16 | 	// context.allocator = mem.tracking_allocator(&tracking_allocator)
17 | 
18 | 	initVM()
19 | 	// defer(freeVM())
20 | 
21 | 	if (len(os.args) == 1) {
22 | 		repl()
23 | 	} else if (len(os.args) == 2) {
24 | 		runFile(os.args[1])	
25 | 	} else {
26 | 		fmt.println("Usage: olox [path]")
27 | 		os.exit(64)
28 | 	}
29 | 
30 | 	// for _, leak in tracking_allocator.allocation_map {
31 | 	// 	log.warnf("%v leaked %v bytes", leak.location, leak.size)
32 | 	// }
33 | 	// for bad_free in tracking_allocator.bad_free_array {
34 | 	// 	log.warnf("%v allocation %p was freed badly", bad_free.location, bad_free.memory)
35 | 	// }
36 | }
37 | 
38 | repl :: proc() {
39 | 	line: [1024]u8
40 | 	reader: bufio.Reader
41 | 	bufio.reader_init_with_buf(&reader, io.to_reader(os.stream_from_handle(os.stdin)), line[:])
42 | 	for {
43 | 		fmt.printf("> ")
44 | 
45 | 		line, err := bufio.reader_read_slice(&reader, '\n')
46 | 		if err != nil {
47 | 			fmt.println(err)
48 | 			break;
49 | 		}
50 | 		interpret(string(line[:]))
51 | 	}
52 | }
53 | 
54 | runFile :: proc(path: string) {
55 | 	// fmt.println(os.get_current_directory())
56 | 	source, success := os.read_entire_file(path)
57 | 	if (!success) {
58 | 		fmt.printf("Could not open file \"%v\".\n", path)
59 | 		os.exit(74)
60 | 	}
61 | 	defer delete(source)
62 | 	result := interpret(string(source[:]))
63 | 
64 | 	if result == InterpretResult.COMPILE_ERROR { os.exit(65) }
65 | 	if result == InterpretResult.RUNTIME_ERROR { os.exit(70) }
66 | 
67 | }


--------------------------------------------------------------------------------
/src/chunk.odin:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "core:fmt"
 4 | 
 5 | OpCode :: enum u8 {
 6 |     CONSTANT,
 7 |     NIL,
 8 |     TRUE,
 9 |     FALSE,
10 |     POP,
11 |     GET_LOCAL,
12 |     SET_LOCAL,
13 |     GET_GLOBAL,
14 |     DEFINE_GLOBAL,
15 |     SET_GLOBAL,
16 |     GET_UPVALUE,
17 |     SET_UPVALUE,
18 |     GET_PROPERTY,
19 |     SET_PROPERTY,
20 |     GET_SUPER,
21 |     EQUAL,
22 |     GREATER,
23 |     LESS,
24 |     ADD,
25 |     SUBTRACT,
26 |     MULTIPLY,
27 |     DIVIDE,
28 |     NOT,
29 |     NEGATE,
30 |     PRINT,
31 |     JUMP,
32 |     JUMP_IF_FALSE,
33 |     LOOP,
34 |     CALL,
35 |     INVOKE,
36 |     SUPER_INVOKE,
37 |     CLOSURE,
38 |     CLOSE_UPVALUE,
39 |     RETURN,
40 |     METHOD,
41 |     CLASS,
42 |     INHERIT,
43 | }
44 | 
45 | Chunk :: struct {
46 |     code: [dynamic]u8,
47 |     lines: [dynamic]int,
48 |     constants: [dynamic]Value,
49 | }
50 | 
51 | freeChunk :: proc(c: ^Chunk) {
52 |     delete(c.code)
53 |     delete(c.constants)
54 | }
55 | 
56 | @(private = "file")
57 | writeChunk_proc :: proc(c: ^Chunk, byte: u8, line: int) {
58 |     if DEBUG_STRESS_GC {
59 |         collectGarbage()
60 |     }
61 |     append(&c.code, byte)
62 |     append(&c.lines, line)
63 | } 
64 | 
65 | @(private = "file")
66 | writeChunk_OpCode :: proc(c: ^Chunk, op: OpCode, line: int) {
67 |     writeChunk_proc(c, cast(u8)op, line)
68 | }
69 | 
70 | @(private = "file")
71 | writeChunk_Int :: proc(c: ^Chunk, i: int, line: int) {
72 |     writeChunk_proc(c, cast(u8)i, line)
73 | }
74 | 
75 | writeChunk_byte :: proc(c: ^Chunk, byte: u8, line: int) {
76 |     writeChunk_proc(c, byte, line)
77 | }
78 | 
79 | writeChunk :: proc {
80 |     writeChunk_OpCode,
81 |     writeChunk_Int,
82 |     writeChunk_byte,
83 | }
84 | 
85 | addConstant :: proc(c: ^Chunk, value: Value) -> int {
86 |     if DEBUG_STRESS_GC {
87 |         collectGarbage()
88 |     }
89 |     push(value)
90 |     append(&c.constants, value)
91 |     pop()
92 |     return len(c.constants) - 1
93 | }
94 | 


--------------------------------------------------------------------------------
/src/memory.odin:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import "core:log"
  4 | import "core:fmt"
  5 | 
  6 | DEBUG_STRESS_GC :: false
  7 | DEBUG_LOG_GC :: false
  8 | 
  9 | GC_HEAP_GROW_FACTOR :: 2
 10 | 
 11 | collectGarbage :: proc() {
 12 |     when DEBUG_LOG_GC {
 13 |         log.debug("-- gc begin")
 14 |         before := vm.bytesAllocated
 15 |     }
 16 | 
 17 |     markRoots()
 18 |     traceReferences()
 19 |     tableRemoveWhite(&vm.strings)
 20 |     sweep()
 21 | 
 22 |     vm.nextGC = vm.bytesAllocated * GC_HEAP_GROW_FACTOR
 23 | 
 24 |     when DEBUG_LOG_GC {
 25 |         log.debug("-- gc end\n")
 26 |         log.debugf("   collected %v bytes (from %v to %v) next at %v",
 27 |                 before - vm.bytesAllocated, before, vm.bytesAllocated, vm.nextGC)
 28 |     }
 29 | }
 30 | 
 31 | markObject :: proc(object: ^Obj) {
 32 |     if object == nil { return }
 33 |     if object.isMarked { return }
 34 | 
 35 |     when DEBUG_LOG_GC {
 36 |         fmt.printf("[DEBUG] --- %p mark ", object)
 37 |         printValue(OBJ_VAL(object))
 38 |         fmt.println()
 39 |     }
 40 |     object.isMarked = true
 41 | 
 42 |     append(&vm.grayStack, object)
 43 |     vm.grayCount += 1
 44 | }
 45 | 
 46 | markValue :: proc(value: Value) {
 47 |     if IS_OBJ(value) {
 48 |         markObject(AS_OBJ(value))
 49 |     }
 50 | }
 51 | 
 52 | markArray :: proc(array: ^[dynamic]Value) {
 53 |     for value in array {
 54 |         markValue(value)
 55 |     }
 56 | }
 57 | 
 58 | blackenObject :: proc(object: ^Obj) {
 59 |     when DEBUG_LOG_GC {
 60 |         fmt.printf("[DEBUG] --- %p blacken ", object)
 61 |         printValue(OBJ_VAL(object))
 62 |         fmt.println()
 63 |     }
 64 | 
 65 |     switch object.type {
 66 |         case .BOUND_METHOD: {
 67 |             bound := cast(^ObjBoundMethod) object
 68 |             markValue(bound.receiver)
 69 |             markObject(bound.method)
 70 |         }
 71 |         case .CLASS: {
 72 |             klass := cast(^ObjClass) object
 73 |             markObject(klass.name)
 74 |             markTable(&klass.methods)
 75 |         }
 76 |         case .CLOSURE: {
 77 |             closure := cast(^ObjClosure) object
 78 |             markObject(closure.function)
 79 |             for upvalue in closure.upvalues {
 80 |                 markObject(upvalue)
 81 |             }
 82 |         }
 83 |         case .FUNCTION: {
 84 |             function := cast(^ObjFunction) object
 85 |             markObject(function.name)
 86 |             markArray(&function.chunk.constants)
 87 |         }
 88 |         case .INSTANCE: {
 89 |             instance := cast(^ObjInstance) object
 90 |             markObject(instance.klass)
 91 |             markTable(&instance.fields)
 92 |         }
 93 |         case .UPVALUE:
 94 |             markValue((cast(^ObjUpvalue) object).closed)
 95 |         case .NATIVE:
 96 |             fallthrough
 97 |         case .STRING:
 98 |     }
 99 | }
100 | 
101 | markRoots :: proc() {
102 |     for i in 0..<vm.stackIndex {
103 |         markValue(vm.stack[i])
104 |     }
105 | 
106 |     for i in 0..<vm.frameCount {
107 |         markObject(vm.frames[i].closure)
108 |     }
109 | 
110 |     for upvalue := vm.openUpvalues; upvalue != nil; upvalue = upvalue.nextUpvalue {
111 |         markObject(upvalue)
112 |     }
113 | 
114 |     markTable(&vm.globals)
115 |     markCompilerRoots()
116 | }
117 | 
118 | traceReferences :: proc() {
119 |     for vm.grayCount > 0 {
120 |         vm.grayCount -= 1
121 |         object := vm.grayStack[vm.grayCount]
122 |         blackenObject(object)
123 |     }
124 | }
125 | 
126 | sweep :: proc() {
127 |     previous: ^Obj
128 |     object := vm.objects
129 |     for object != nil {
130 |         if object.isMarked {
131 |             object.isMarked = false
132 |             previous = object
133 |             object = object.next
134 |         } else {
135 |             unreached := object
136 |             object = object.next
137 |             if previous != nil {
138 |                 previous.next = object
139 |             } else {
140 |                 vm.objects = object
141 |             }
142 | 
143 |             freeObject(unreached)
144 |         }
145 |     }
146 | }


--------------------------------------------------------------------------------
/src/value.odin:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import "core:fmt"
  4 | import "core:log"
  5 | import "core:mem"
  6 | 
  7 | 
  8 | NAN_BOXING :: true
  9 | 
 10 | when NAN_BOXING {
 11 |     Value :: distinct u64
 12 | 
 13 |     SIGN_BIT : u64 : 0x8000000000000000
 14 |     QNAN     : u64 : 0x7ffc000000000000
 15 | 
 16 |     TAG_NIL   :: 1
 17 |     TAG_FALSE :: 2
 18 |     TAG_TRUE  :: 3
 19 | 
 20 |     IS_BOOL   :: proc(value: Value) -> bool { return (u64(value) | 1) == TRUE_VAL }
 21 |     IS_NIL    :: proc(value: Value) -> bool { return (value) == NIL_VAL() }
 22 |     IS_NUMBER :: proc(value: Value) -> bool { return (u64(value) & QNAN) != QNAN }
 23 |     IS_OBJ    :: proc(value: Value) -> bool { return (u64(value) & (QNAN | SIGN_BIT)) == (QNAN | SIGN_BIT)}
 24 | 
 25 |     AS_BOOL   :: proc(value: Value) -> bool { return u64(value) == TRUE_VAL }
 26 |     AS_NUMBER :: proc(value: Value) -> f64  { return transmute(f64) value }
 27 |     AS_OBJ    :: proc(value: Value) -> ^Obj { return cast(^Obj) uintptr(u64(value) & ~(SIGN_BIT | QNAN)) }
 28 | 
 29 |     FALSE_VAL  : u64 : QNAN | TAG_FALSE
 30 |     TRUE_VAL   : u64 : QNAN | TAG_TRUE
 31 |     BOOL_VAL   :: proc(b: bool)  -> Value { return Value(TRUE_VAL) if b else Value(FALSE_VAL) }
 32 |     NIL_VAL    :: proc()         -> Value { return Value(QNAN | TAG_NIL) }
 33 |     NUMBER_VAL :: proc(num: f64) -> Value { 
 34 |         // mem.copy(&value, &num, size_of(f64))
 35 |         return transmute(Value) num
 36 |     }
 37 |     OBJ_VAL    :: proc(obj: ^Obj) -> Value { return Value(SIGN_BIT | QNAN | cast(u64) uintptr(obj))}
 38 | 
 39 | } else {
 40 |     ValueType :: enum {
 41 |         BOOL,
 42 |         NIL,
 43 |         NUMBER,
 44 |         OBJ,
 45 |     }
 46 | 
 47 |     Value :: struct {
 48 |         type: ValueType,
 49 |         variant: union {
 50 |             bool,
 51 |             f64,
 52 |             ^Obj,
 53 |         },
 54 |     }
 55 | 
 56 |     IS_BOOL   :: proc(value: Value) -> bool { return value.type == .BOOL }
 57 |     IS_NIL    :: proc(value: Value) -> bool { return value.type == .NIL }
 58 |     IS_NUMBER :: proc(value: Value) -> bool { return value.type == .NUMBER }
 59 |     IS_OBJ    :: proc(value: Value) -> bool { return value.type == .OBJ }
 60 | 
 61 |     AS_OBJ    :: proc(value: Value) -> ^Obj { return value.variant.(^Obj) }
 62 |     AS_BOOL   :: proc(value: Value) -> bool { return value.variant.(bool) }
 63 |     AS_NUMBER :: proc(value: Value) -> f64  { return value.variant.(f64) }
 64 | 
 65 |     BOOL_VAL   :: proc(value: bool) -> Value { return Value{.BOOL, value}}
 66 |     NIL_VAL    :: proc()            -> Value { return Value{.NIL, nil}}
 67 |     NUMBER_VAL :: proc(value: f64)  -> Value { return Value{.NUMBER, value}}
 68 |     OBJ_VAL    :: proc(value: ^Obj) -> Value { return Value{.OBJ, value}}
 69 | }
 70 | 
 71 | printValue :: proc(value: Value) {
 72 |     when NAN_BOXING {
 73 |         if (IS_BOOL(value)) {
 74 |             fmt.printf("true" if AS_BOOL(value) else "false")
 75 |         } else if (IS_NIL(value)) {
 76 |             fmt.printf("nil")
 77 |         } else if (IS_NUMBER(value)) {
 78 |             fmt.printf("%v", AS_NUMBER(value))
 79 |         } else if (IS_OBJ(value)) {
 80 |             printObject(AS_OBJ(value))
 81 |         }
 82 |     } else {
 83 |         #partial switch value.type {
 84 |             case .OBJ: printObject(AS_OBJ(value))
 85 |             case: fmt.print(value.variant)
 86 |         }
 87 |     }
 88 | }
 89 | 
 90 | valuesEqual :: proc(a, b: Value) -> bool {
 91 |     when NAN_BOXING {
 92 |         if (IS_NUMBER(a) && IS_NUMBER(b)) {
 93 |             return AS_NUMBER(a) == AS_NUMBER(b)
 94 |         }
 95 |         return a == b
 96 |     } else {
 97 |         if a.type != b.type { return false }
 98 |         switch a.type {
 99 |             case .BOOL:   return AS_BOOL(a) == AS_BOOL(b)
100 |             case .NIL:    return true
101 |             case .NUMBER: return AS_NUMBER(a) == AS_NUMBER(b)
102 |             // case .OBJ:    return a.variant == b.variant // Valid because of string interning
103 |             case .OBJ: return AS_OBJ(a) == AS_OBJ(b)
104 |             case: return false // unreachable
105 |         }
106 |     }
107 | }


--------------------------------------------------------------------------------
/src/table.odin:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import "core:mem"
  4 | import "core:strings"
  5 | 
  6 | TABLE_MAX_LOAD :: 0.75
  7 | 
  8 | Entry :: struct {
  9 |     key: ^ObjString,
 10 |     value: Value,
 11 | }
 12 | 
 13 | Table :: struct {
 14 |     count: int,
 15 |     capacity: int,
 16 |     entries: []Entry,
 17 | }
 18 | 
 19 | freeTable :: proc(table: ^Table) {
 20 |     delete(table.entries)
 21 | }
 22 | 
 23 | tableSet :: proc(table: ^Table, key: ^ObjString, value: Value) -> bool {
 24 |     if f32(table.count + 1) > f32(table.capacity) * TABLE_MAX_LOAD {
 25 |         capacity := growCapacity(table.capacity)
 26 |         adjustCapacity(table, capacity)
 27 |     }
 28 | 
 29 |     entry := findEntry(table.entries, table.capacity, key)
 30 |     isNewKey := entry.key == nil
 31 |     if isNewKey && IS_NIL(entry.value) { table.count += 1 }
 32 | 
 33 |     entry.key = key
 34 |     entry.value = value
 35 |     return isNewKey
 36 | }
 37 | 
 38 | tableDelete :: proc(table: ^Table, key: ^ObjString) -> bool {
 39 |     if table.count == 0 { return false }
 40 | 
 41 |     entry := findEntry(table.entries, table.capacity, key)
 42 |     if entry.key == nil { return false }
 43 | 
 44 |     entry.key = nil
 45 |     entry.value = BOOL_VAL(true)
 46 |     return true
 47 | }
 48 | 
 49 | tableAddAll :: proc(from, to: ^Table) {
 50 |     for i in 0..<from.capacity {
 51 |         entry := &from.entries[i]
 52 |         if entry.key != nil {
 53 |             tableSet(to, entry.key, entry.value)
 54 |         }
 55 |     }
 56 | }
 57 | 
 58 | tableFindString :: proc(table: ^Table, str: string, hash: u32) -> ^ObjString {
 59 |     if table.count == 0 { return nil }
 60 | 
 61 |     index := hash & u32(table.capacity - 1)
 62 |     for {
 63 |         entry := &table.entries[index]
 64 |         if entry.key == nil {
 65 |             // Stop if we find an empty non-tombstone entry.
 66 |             if IS_NIL(entry.value) { return nil }
 67 |         } else if len(entry.key.str) == len(str) && entry.key.hash == hash && strings.compare(entry.key.str, str) == 0 {
 68 |             // We found it.
 69 |             return entry.key
 70 |         }
 71 | 
 72 |         index = (index + 1) & u32(table.capacity - 1)
 73 |     }
 74 | }
 75 | 
 76 | tableRemoveWhite :: proc(table: ^Table) {
 77 |     for entry in table.entries {
 78 |         if entry.key != nil && !entry.key.obj.isMarked {
 79 |             tableDelete(table, entry.key)
 80 |         }
 81 |     }
 82 | }
 83 | 
 84 | markTable :: proc(table: ^Table) {
 85 |     for i in 0..<table.capacity {
 86 |         entry := &table.entries[i]
 87 |         markObject(entry.key)
 88 |         markValue(entry.value)
 89 |     }
 90 | }
 91 | 
 92 | findEntry :: proc(entries: []Entry, capacity: int, key: ^ObjString) -> ^Entry {
 93 |     index := key.hash & u32(capacity - 1)
 94 |     tombstone: ^Entry = nil
 95 |     for {
 96 |         entry := &entries[index]
 97 |         if entry.key == nil {
 98 |             if IS_NIL(entry.value) {
 99 |                 // Empty entry.
100 |                 return tombstone if tombstone != nil else entry
101 |             } else {
102 |                 // We found a tombstone
103 |                 if tombstone == nil { tombstone = entry }
104 |             }
105 |         } if entry.key == key {
106 |             // We found the key.
107 |             return entry
108 |         }
109 | 
110 |         index = (index + 1) & u32(capacity - 1)
111 |     }
112 | }
113 | 
114 | tableGet :: proc(table: ^Table, key: ^ObjString) -> (Value, bool) {
115 |     if table.count == 0 { return {}, false }
116 | 
117 |     entry := findEntry(table.entries, table.capacity, key)
118 |     if entry.key == nil { return {}, false }
119 | 
120 |     return entry.value, true
121 | }
122 | 
123 | adjustCapacity :: proc(table: ^Table, capacity: int) {
124 |     entries := make([]Entry, capacity)
125 |     for i in 0..<capacity {
126 |         entries[i].key = nil
127 |         entries[i].value = NIL_VAL()
128 |     }
129 | 
130 |     table.count = 0
131 |     for i in 0..<table.capacity {
132 |         entry := &table.entries[i]
133 |         if entry.key == nil { continue }
134 | 
135 |         dest := findEntry(entries, capacity, entry.key)
136 |         dest.key = entry.key
137 |         dest.value = entry.value
138 |         table.count += 1
139 |     }
140 | 
141 |     delete(table.entries)
142 |     table.entries = entries
143 |     table.capacity = capacity
144 | }
145 | 
146 | growCapacity :: proc(capacity: int) -> int {
147 |     return 8 if capacity < 8 else capacity * 2
148 | }
149 | 


--------------------------------------------------------------------------------
/src/debug.odin:
--------------------------------------------------------------------------------
  1 | //+private
  2 | package main
  3 | 
  4 | import "core:fmt"
  5 | 
  6 | disassembleChunk :: proc(chunk: Chunk, name: string) {
  7 |     fmt.printf("== %s ==\n", name)
  8 | 
  9 |     offset := 0; 
 10 |     for offset < len(chunk.code) {
 11 |         offset = disassembleInstruction(chunk, offset)
 12 |     }
 13 | }
 14 | 
 15 | disassembleInstruction :: proc(chunk: Chunk, offset: int) -> int {
 16 |     fmt.printf("%04d ", offset)
 17 |     if offset > 0 && chunk.lines[offset] == chunk.lines[offset - 1] {
 18 |         fmt.printf("   | ")
 19 |     } else {
 20 |         fmt.printf("%4d ", chunk.lines[offset])
 21 |     }
 22 | 
 23 |     instruction := cast(OpCode)chunk.code[offset]
 24 |     switch instruction {
 25 |     case .CONSTANT:
 26 |         return constantInstruction(.CONSTANT, chunk, offset)
 27 |     case .NIL:
 28 |         return simpleInstruction(.NIL, offset)
 29 |     case .TRUE:
 30 |         return simpleInstruction(.TRUE, offset)
 31 |     case .FALSE:
 32 |         return simpleInstruction(.FALSE, offset)
 33 |     case .POP:
 34 |         return simpleInstruction(.POP, offset)
 35 |     case .GET_LOCAL:
 36 |         return byteInstruction(.GET_LOCAL, chunk, offset)
 37 |     case .SET_LOCAL:
 38 |         return byteInstruction(.SET_LOCAL, chunk, offset)
 39 |     case .GET_GLOBAL:
 40 |         return constantInstruction(.GET_GLOBAL, chunk, offset)
 41 |     case .DEFINE_GLOBAL:
 42 |         return constantInstruction(.DEFINE_GLOBAL, chunk, offset)
 43 |     case .SET_GLOBAL:
 44 |         return constantInstruction(.SET_GLOBAL, chunk, offset)
 45 |     case .GET_UPVALUE:
 46 |         return byteInstruction(.GET_UPVALUE, chunk, offset)
 47 |     case .SET_UPVALUE:
 48 |         return byteInstruction(.SET_UPVALUE, chunk, offset)
 49 |     case .GET_PROPERTY:
 50 |         return constantInstruction(.GET_PROPERTY, chunk, offset)
 51 |     case .SET_PROPERTY:
 52 |         return constantInstruction(.SET_PROPERTY, chunk, offset)
 53 |     case .GET_SUPER:
 54 |         return constantInstruction(.GET_SUPER, chunk, offset)
 55 |     case .EQUAL:
 56 |         return simpleInstruction(.EQUAL, offset)
 57 |     case .GREATER:
 58 |         return simpleInstruction(.GREATER, offset)
 59 |     case .LESS:
 60 |         return simpleInstruction(.LESS, offset)
 61 |     case .ADD:
 62 |         return simpleInstruction(.ADD, offset)
 63 |     case .SUBTRACT:
 64 |         return simpleInstruction(.SUBTRACT, offset)
 65 |     case .METHOD:
 66 |         return constantInstruction(.METHOD, chunk, offset)
 67 |     case .MULTIPLY:
 68 |         return simpleInstruction(.MULTIPLY, offset)
 69 |     case .DIVIDE:
 70 |         return simpleInstruction(.DIVIDE, offset)
 71 |     case .NOT:
 72 |         return simpleInstruction(.NOT, offset)
 73 |     case .NEGATE:
 74 |         return simpleInstruction(.NEGATE, offset)
 75 |     case .PRINT:
 76 |         return simpleInstruction(.PRINT, offset)
 77 |     case .JUMP:
 78 |         return jumpInstruction(.JUMP, 1, chunk, offset)
 79 |     case .JUMP_IF_FALSE:
 80 |         return jumpInstruction(.JUMP_IF_FALSE, 1, chunk, offset)
 81 |     case .LOOP:
 82 |         return jumpInstruction(.LOOP, -1, chunk, offset)
 83 |     case .CALL:
 84 |         return byteInstruction(.CALL, chunk, offset)
 85 |     case .INVOKE:
 86 |         return invokeInstruction(.INVOKE, chunk, offset)
 87 |     case .SUPER_INVOKE:
 88 |         return invokeInstruction(.SUPER_INVOKE, chunk, offset)
 89 |     case .CLOSURE:
 90 |         offset := offset
 91 |         offset += 1
 92 |         constant := chunk.code[offset]
 93 |         offset += 1
 94 |         fmt.printf("%-16s %4d ", "CLOSURE", constant)
 95 |         printValue(chunk.constants[constant])
 96 |         fmt.println()
 97 | 
 98 |         function := cast(^ObjFunction) AS_OBJ(chunk.constants[constant])
 99 |         for j in 0..<function.upvalueCount {
100 |             isLocal := bool(chunk.code[offset])
101 |             offset += 1
102 |             index := chunk.code[offset]
103 |             offset += 1
104 |             fmt.printf("%04d    |               %s %d\n", offset - 2, "local" if isLocal else "upvalue", index)
105 |         }
106 |         return offset
107 | 
108 |     case .CLOSE_UPVALUE:
109 |         return simpleInstruction(.CLOSE_UPVALUE, offset)
110 |     case .RETURN:
111 |         return simpleInstruction(.RETURN, offset)
112 |     case .CLASS:
113 |         return constantInstruction(.CLASS, chunk, offset)
114 |     case .INHERIT:
115 |         return simpleInstruction(.INHERIT, offset)
116 |     case: // default
117 |         return offset + 1
118 |     }
119 | }
120 | 
121 | @(private = "file")
122 | simpleInstruction :: proc(name: OpCode, offset: int) -> int {
123 |     fmt.println(name)
124 |     return offset + 1
125 | }
126 | 
127 | @(private = "file")
128 | byteInstruction :: proc(name: OpCode, chunk: Chunk, offset: int) -> int {
129 |     slot := chunk.code[offset + 1]
130 |     buf: [32]u8
131 |     name_str := fmt.bprintf(buf[:], "%v", name)
132 |     fmt.printf("%-16v %v '\n", name_str, slot)
133 |     return offset + 2
134 | }
135 | 
136 | @(private = "file")
137 | jumpInstruction :: proc(name: OpCode, sign: int, chunk: Chunk, offset: int) -> int {
138 |     jump := u16(chunk.code[offset + 1] << 8)
139 |     jump |= u16(chunk.code[offset + 2])
140 |     fmt.printf("%-16v %4d -> %d\n", name, offset, offset + 3 + sign * int(jump))
141 |     return offset + 3
142 | }
143 | 
144 | @(private = "file")
145 | constantInstruction :: proc(name: OpCode, chunk: Chunk, offset: int) -> int {
146 |     constant := chunk.code[offset + 1]
147 |     buf: [32]u8
148 |     name_str := fmt.bprintf(buf[:], "%v", name)
149 |     fmt.printf("%-16v %v '", name_str, constant)
150 |     printValue(chunk.constants[constant])
151 |     fmt.printf("'\n")
152 |     return offset + 2
153 | }
154 | 
155 | invokeInstruction :: proc(name: OpCode, chunk: Chunk, offset: int) -> int {
156 |     constant := chunk.code[offset + 1]
157 |     argCount := chunk.code[offset + 2]
158 |     fmt.printf("%-16v (%v args) %4v '", name, argCount, constant)
159 |     printValue(chunk.constants[constant])
160 |     fmt.println("'")
161 |     return offset + 3
162 | }
163 | 
164 | 


--------------------------------------------------------------------------------
/src/scanner.odin:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import "core:fmt"
  4 | import "core:io"
  5 | import "core:mem"
  6 | import "core:strings"
  7 | import "core:unicode"
  8 | import "core:unicode/utf8"
  9 | import "core:unicode/utf8/utf8string"
 10 | 
 11 | String :: utf8string.String
 12 | 
 13 | TokenType :: enum {
 14 |     // Single-character tokens.
 15 |     LEFT_PAREN, RIGHT_PAREN,
 16 |     LEFT_BRACE, RIGHT_BRACE,
 17 |     COMMA, DOT, MINUS, PLUS,
 18 |     SEMICOLON, SLASH, STAR,
 19 | 
 20 |     // One or two character tokens.
 21 |     BANG, BANG_EQUAL,
 22 |     EQUAL, EQUAL_EQUAL,
 23 |     GREATER, GREATER_EQUAL,
 24 |     LESS, LESS_EQUAL,
 25 | 
 26 |     // Literals
 27 |     IDENTIFIER, STRING, NUMBER,
 28 | 
 29 |     // Keywords
 30 |     AND, CLASS, ELSE, FALSE,
 31 |     FOR, FUN, IF, NIL, OR,
 32 |     PRINT, RETURN, SUPER, THIS,
 33 |     TRUE, VAR, WHILE,
 34 | 
 35 |     ERROR, EOF,
 36 | }
 37 | 
 38 | Scanner :: struct {
 39 |     buf: String,
 40 |     start: int,
 41 |     current: int,
 42 |     line: int,
 43 | }
 44 | 
 45 | Token :: struct {
 46 |     type: TokenType,
 47 |     value: string,
 48 |     line: int,
 49 | }
 50 | 
 51 | scanner: Scanner
 52 | 
 53 | initScanner :: proc(source: string) {
 54 |     utf8string.init(&scanner.buf, source)
 55 |     scanner.start = 0
 56 |     scanner.current = 0
 57 |     scanner.line = 1
 58 | }
 59 | 
 60 | scanToken :: proc() -> Token {
 61 |     skipWhitespace()
 62 |     scanner.start = scanner.current
 63 |     if isAtEnd() {
 64 |         return makeToken(.EOF)
 65 |     }
 66 | 
 67 |     c := advance()
 68 |     if unicode.is_letter(c) { return identifier() }
 69 |     if unicode.is_digit(c) { return numberLiteral() }
 70 |     switch c {
 71 |         case '(': return makeToken(.LEFT_PAREN)
 72 |         case ')': return makeToken(.RIGHT_PAREN)
 73 |         case '{': return makeToken(.LEFT_BRACE)
 74 |         case '}': return makeToken(.RIGHT_BRACE)
 75 |         case ';': return makeToken(.SEMICOLON)
 76 |         case ',': return makeToken(.COMMA)
 77 |         case '.': return makeToken(.DOT)
 78 |         case '-': return makeToken(.MINUS)
 79 |         case '+': return makeToken(.PLUS)
 80 |         case '/': return makeToken(.SLASH)
 81 |         case '*': return makeToken(.STAR)
 82 |         case '!': return makeToken(.BANG_EQUAL if match('=') else .BANG)
 83 |         case '=': return makeToken(.EQUAL_EQUAL if match('=') else .EQUAL)
 84 |         case '<': return makeToken(.LESS_EQUAL if match('=') else .LESS)
 85 |         case '>': return makeToken(.GREATER_EQUAL if match('=') else .GREATER)
 86 |         case '"': return stringLiteral()
 87 |     }
 88 | 
 89 |     return errorToken("Unexpected character.")
 90 | }
 91 | 
 92 | isAtEnd :: proc() -> bool {
 93 |     return scanner.current == utf8string.len(&scanner.buf)-1
 94 | }
 95 | 
 96 | makeToken :: proc(type: TokenType) -> (token: Token) {
 97 |     token.type = type
 98 |     token.value = utf8string.slice(&scanner.buf, scanner.start, scanner.current)
 99 |     token.line = scanner.line
100 |     return
101 | }
102 | 
103 | errorToken :: proc(error_message: string) -> (token: Token) {
104 |     token.type = .ERROR
105 |     token.value = error_message
106 |     token.line = scanner.line
107 |     return
108 | }
109 | 
110 | skipWhitespace :: proc() {
111 |     for {
112 |         if isAtEnd() { return }
113 |         c := peek()
114 |         switch c {
115 |             case ' ', '\r', '\t': advance()
116 |             case '\n': {
117 |                 scanner.line += 1
118 |                 advance()
119 |             }
120 |             case '/': {
121 |                 nextChar, err := peekNext()
122 |                 if err == nil {
123 |                     if nextChar == '/' {
124 |                         // A comment goes until the end of the line.
125 |                         for peek() != '\n' && !isAtEnd() { advance() }
126 |                     } else {
127 |                         return
128 |                     }
129 |                 } else { return }
130 |             }
131 |             case: return
132 |         }
133 |     }
134 | }
135 | 
136 | checkKeyword :: proc(keyword: string, type: TokenType) -> TokenType {
137 |     slice := utf8string.slice(&scanner.buf, scanner.start, scanner.start + len(keyword))
138 |     if strings.compare(string(slice), keyword) == 0 {
139 |         return type
140 |     }
141 | 
142 |     return .IDENTIFIER
143 | }
144 | 
145 | identifierType :: proc() -> TokenType {
146 |     switch utf8string.at(&scanner.buf, scanner.start) {
147 |         case 'a': return checkKeyword("and", .AND)
148 |         case 'c': return checkKeyword("class", .CLASS)
149 |         case 'e': return checkKeyword("else", .ELSE)
150 |         case 'f': {
151 |             if scanner.current - scanner.start > 1 {
152 |                 switch utf8string.at(&scanner.buf, scanner.start + 1) {
153 |                 case 'a': return checkKeyword("false", .FALSE)
154 |                 case 'o': return checkKeyword("for", .FOR)
155 |                 case 'u': return checkKeyword("fun", .FUN) 
156 |                 }
157 |             }
158 |         }
159 |         case 'i': return checkKeyword("if", .IF)
160 |         case 'n': return checkKeyword("nil", .NIL)
161 |         case 'o': return checkKeyword("or", .OR)
162 |         case 'p': return checkKeyword("print", .PRINT)
163 |         case 'r': return checkKeyword("return", .RETURN)
164 |         case 's': return checkKeyword("super", .SUPER)
165 |         case 't': {
166 |             if scanner.current - scanner.start > 1 {
167 |                 switch utf8string.at(&scanner.buf, scanner.start + 1) {
168 |                     case 'h': return checkKeyword("this", .THIS)
169 |                     case 'r': return checkKeyword("true", .TRUE)
170 |                 }
171 |             }
172 |         }
173 |         case 'v': return checkKeyword("var", .VAR)
174 |         case 'w': return checkKeyword("while", .WHILE)
175 |     }
176 |     return .IDENTIFIER
177 | 
178 | }
179 | 
180 | identifier :: proc() -> Token {
181 |     for unicode.is_letter(peek()) || unicode.is_digit(peek()) {
182 |         advance()
183 |     }
184 |     return makeToken(identifierType())
185 | }
186 | 
187 | numberLiteral :: proc() -> Token {
188 |     for unicode.is_digit(rune(peek())) { advance() }
189 | 
190 |     // Look for a fractional part.
191 |     nextChar, _  := peekNext()
192 |     if peek() == '.' && unicode.is_digit(rune(nextChar)) {
193 |         // Consume the ".".
194 |         advance()
195 | 
196 |         for unicode.is_digit(rune(peek())) { advance() }
197 |     }
198 | 
199 |     return makeToken(.NUMBER)
200 | 
201 | }
202 | 
203 | stringLiteral :: proc() -> Token {
204 |     for peek() != '"' && !isAtEnd() {
205 |         if peek() == '\n' { scanner.line += 1 }
206 |         advance()
207 |     }
208 | 
209 |     if isAtEnd() { return errorToken("Unterminated string.") }
210 | 
211 |     // The closing quote.
212 |     advance()
213 |     return makeToken(.STRING)
214 | }
215 | 
216 | @(private = "file")
217 | advance :: proc() -> rune {
218 |     scanner.current += 1
219 |     return utf8string.at(&scanner.buf, scanner.current-1)
220 | }
221 | 
222 | @(private = "file")
223 | peek :: proc() -> rune {
224 |     return utf8string.at(&scanner.buf, scanner.current)
225 | }
226 | 
227 | peekNext :: proc() -> (rune, io.Error) {
228 |     if isAtEnd() { return ' ', io.Error.EOF }
229 |     return utf8string.at(&scanner.buf, scanner.current+1), nil
230 | }
231 | 
232 | @(private = "file")
233 | match :: proc(expected: rune) -> bool {
234 |     if isAtEnd() { return false }
235 |     if utf8string.at(&scanner.buf, scanner.current) != expected { return false }
236 |     scanner.current += 1
237 |     return true
238 | }
239 | 


--------------------------------------------------------------------------------
/src/object.odin:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import "core:log"
  4 | import "core:fmt"
  5 | import "core:strings"
  6 | 
  7 | ObjType :: enum {
  8 |     BOUND_METHOD,
  9 |     CLASS,
 10 |     CLOSURE,
 11 |     FUNCTION,
 12 |     INSTANCE,
 13 |     NATIVE,
 14 |     STRING,
 15 |     UPVALUE,
 16 | }
 17 | 
 18 | Obj :: struct {
 19 |     type: ObjType,
 20 |     isMarked: bool,
 21 |     next: ^Obj,
 22 | }
 23 | 
 24 | ObjFunction :: struct {
 25 |     using obj: Obj,
 26 |     arity: u32,
 27 |     upvalueCount: int,
 28 |     chunk: Chunk,
 29 |     name: ^ObjString,
 30 | }
 31 | 
 32 | NativeFn :: proc (argCount: u8, args: []Value) -> Value
 33 | 
 34 | ObjNative :: struct {
 35 |     using obj: Obj,
 36 |     function: NativeFn,
 37 | }
 38 | 
 39 | ObjString :: struct {
 40 |     using obj: Obj,
 41 |     str: string,
 42 |     hash: u32,
 43 | }
 44 | 
 45 | ObjUpvalue :: struct {
 46 |     using obj: Obj,
 47 |     location: ^Value,
 48 |     closed: Value,
 49 |     nextUpvalue: ^ObjUpvalue,
 50 | }
 51 | 
 52 | ObjClass :: struct {
 53 |     using obj: Obj,
 54 |     name: ^ObjString,
 55 |     methods: Table,
 56 | }
 57 | 
 58 | ObjInstance :: struct {
 59 |     using obj: Obj,
 60 |     klass: ^ObjClass,
 61 |     fields: Table,
 62 | }
 63 | 
 64 | ObjClosure :: struct {
 65 |     using obj: Obj,
 66 |     function: ^ObjFunction,
 67 |     upvalues: [dynamic]^ObjUpvalue,
 68 |     upvalueCount: int,
 69 | }
 70 | 
 71 | ObjBoundMethod :: struct {
 72 |     using obj: Obj,
 73 |     receiver: Value,
 74 |     method: ^ObjClosure,
 75 | }
 76 | 
 77 | newBoundMethod :: proc(receiver: Value, method: ^ObjClosure) -> ^ObjBoundMethod {
 78 |     bound := allocateObject(ObjBoundMethod, .BOUND_METHOD)
 79 |     bound.receiver = receiver
 80 |     bound.method = method
 81 |     return bound
 82 | }
 83 | 
 84 | newFunction :: proc() -> ^ObjFunction {
 85 |     function := allocateObject(ObjFunction, .FUNCTION)
 86 |     
 87 |     return function
 88 | }
 89 | 
 90 | newInstance :: proc(klass: ^ObjClass) -> ^ObjInstance {
 91 |     instance := allocateObject(ObjInstance, .INSTANCE)
 92 |     instance.klass = klass
 93 |     return instance
 94 | }
 95 | 
 96 | newNative :: proc(function: NativeFn) -> ^ObjNative {
 97 |     native := allocateObject(ObjNative, .NATIVE)
 98 |     native.function = function
 99 |     return native
100 | }
101 | 
102 | isObjType :: proc(value: Value, type: ObjType) -> bool {
103 |     return IS_OBJ(value) && AS_OBJ(value).type == type
104 | }
105 | 
106 | printObject :: proc(object: ^Obj) {
107 |     switch object.type {
108 |         case .BOUND_METHOD: printFunction((cast(^ObjBoundMethod) object).method.function)
109 |         case .CLASS: fmt.printf("%v", (cast(^ObjClass) object).name.str)
110 |         case .CLOSURE: printFunction((cast(^ObjClosure) object).function)
111 |         case .FUNCTION: printFunction(cast(^ObjFunction) object)
112 |         case .INSTANCE: fmt.printf("%v instance", (cast(^ObjInstance) object).klass.name.str)
113 |         case .NATIVE: fmt.print("<native fn>")
114 |         case .STRING: fmt.printf("%v", (cast(^ObjString) object).str)
115 |         case .UPVALUE: fmt.print("upvalue")
116 |         case: fmt.print(object)
117 |     }
118 | }
119 | 
120 | copyString :: proc(str: string) -> ^ObjString {
121 |     s := strings.clone(str)
122 |     hash := hashString(s)
123 | 
124 |     interned := tableFindString(&vm.strings, s, hash)
125 |     if interned != nil { return interned }
126 | 
127 |     return allocateString(s, hash)
128 | }
129 | 
130 | newUpvalue :: proc(slot: ^Value) -> ^ObjUpvalue {
131 |     upvalue := allocateObject(ObjUpvalue, .UPVALUE)
132 |     upvalue.closed = NIL_VAL()
133 |     upvalue.location = slot
134 |     return upvalue
135 | }
136 | 
137 | printFunction :: proc(function: ^ObjFunction) {
138 |     if (function.name == nil) {
139 |         fmt.printf("<script>")
140 |         return
141 |     }
142 |     fmt.printf("<fn %v>", function.name)
143 | }
144 | 
145 | allocateObject :: proc($T: typeid, type: ObjType) -> ^T {
146 |     object := new(T)
147 |     object.type = type
148 |     object.next = vm.objects
149 |     vm.objects = object
150 | 
151 |     vm.bytesAllocated += size_of(T)
152 |     if (vm.bytesAllocated > vm.nextGC) {
153 |         collectGarbage()
154 |     }
155 | 
156 |     when DEBUG_LOG_GC {
157 |         log.debugf("%p allocate %v for %v", object, size_of(T), type)
158 |     }
159 | 
160 |     return object
161 | }
162 | 
163 | newClass :: proc(name: ^ObjString) -> ^ObjClass {
164 |     klass := allocateObject(ObjClass, .CLASS)
165 |     klass.name = name
166 |     return klass
167 | }
168 | 
169 | newClosure :: proc(function: ^ObjFunction) -> (closure: ^ObjClosure) {
170 |     upvalues := make([dynamic]^ObjUpvalue, function.upvalueCount)
171 |     
172 |     closure = allocateObject(ObjClosure, .CLOSURE)
173 |     closure.function = function
174 |     closure.upvalues = upvalues
175 |     closure.upvalueCount = function.upvalueCount
176 |     return
177 | }
178 | 
179 | allocateString :: proc(str: string, hash: u32) -> ^ObjString {
180 |     lstring := allocateObject(ObjString, .STRING)
181 |     lstring.str = str
182 |     lstring.hash = hash
183 | 
184 |     push(OBJ_VAL(lstring))
185 |     tableSet(&vm.strings, lstring, NIL_VAL())
186 |     pop()
187 | 
188 |     return lstring
189 | }
190 | 
191 | hashString :: proc(str: string) -> u32 {
192 |     hash : u32 = 2166136261
193 |     for c in str {
194 |         hash ~= u32(c)
195 |         hash *= 16777619
196 |     }
197 |     return hash
198 | }
199 | 
200 | takeString :: proc(str: string) -> ^ObjString {
201 |     hash := hashString(str)
202 | 
203 |     interned := tableFindString(&vm.strings, str, hash)
204 |     if interned != nil {
205 |         delete(str)
206 |         return interned
207 |     }
208 | 
209 |     return allocateString(str, hash)
210 | }
211 | 
212 | freeObject :: proc(object: ^Obj) {
213 |     when DEBUG_LOG_GC {
214 |         log.debugf("%p free type %v", object, object.type)
215 |     }
216 | 
217 |     switch object.type {
218 |         case .BOUND_METHOD:
219 |             vm.bytesAllocated -= size_of(object)
220 |             free(object)
221 |         case .CLASS:
222 |             klass := cast(^ObjClass)object
223 |             vm.bytesAllocated -= size_of(klass.methods)
224 |             freeTable(&klass.methods)
225 |             vm.bytesAllocated -= size_of(object)
226 |             free(object)
227 |         case .CLOSURE:
228 |             vm.bytesAllocated -= size_of(object)
229 |             free(object)
230 |         case .FUNCTION:
231 |             vm.bytesAllocated -= size_of(object)
232 |             free(object)
233 |             function := cast(^ObjFunction) object
234 |             vm.bytesAllocated -= size_of(function.chunk)
235 |             freeChunk(&function.chunk)
236 |             vm.bytesAllocated -= size_of(function)
237 |             free(function)
238 |         case .INSTANCE:
239 |             instance := cast(^ObjInstance)object
240 |             freeTable(&instance.fields)
241 |             vm.bytesAllocated -= size_of(object)
242 |             free(object)
243 |         case .NATIVE:
244 |             vm.bytesAllocated -= size_of(object)
245 |             free(object)
246 |         case .STRING:
247 |             lstring := cast(^ObjString) object
248 |             vm.bytesAllocated -= size_of(lstring.str)
249 |             delete(lstring.str)
250 |             vm.bytesAllocated -= size_of(lstring)
251 |             free(lstring)
252 |         case .UPVALUE:
253 |             vm.bytesAllocated -= size_of(object)
254 |             free(object)
255 |             closure := cast(^ObjClosure) object
256 |             vm.bytesAllocated -= size_of(closure.upvalues)
257 |             delete(closure.upvalues)
258 |     }
259 | }


--------------------------------------------------------------------------------
/src/vm.odin:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import "core:fmt"
  4 | import "core:log"
  5 | import "core:time"
  6 | 
  7 | DEBUG_STACK_TRACE :: false
  8 | FRAMES_MAX :: 64
  9 | STACK_MAX :: FRAMES_MAX * cast(u32) max(u8)
 10 | 
 11 | CallFrame :: struct {
 12 |     closure: ^ObjClosure,
 13 |     ip: int,
 14 |     slots: []Value,
 15 | }
 16 | 
 17 | VM :: struct {
 18 |     frames: [FRAMES_MAX]CallFrame,
 19 |     frameCount: u32,
 20 | 
 21 |     stack: [STACK_MAX]Value,
 22 |     stackIndex: i32,
 23 |     strings: Table,
 24 |     initString: ^ObjString,
 25 |     globals: Table,
 26 |     openUpvalues: ^ObjUpvalue,
 27 | 
 28 |     bytesAllocated: int,
 29 |     nextGC: int,
 30 |     objects: ^Obj,
 31 |     grayStack: [dynamic]^Obj,
 32 |     grayCount: int,
 33 | }
 34 | 
 35 | InterpretResult :: enum {
 36 |     OK,
 37 |     COMPILE_ERROR,
 38 |     RUNTIME_ERROR,
 39 | }
 40 | 
 41 | vm: VM
 42 | 
 43 | clockNative :: proc(argCount: u8, args: []Value) -> Value {
 44 |     return NUMBER_VAL(f64(time.now()._nsec))
 45 | }
 46 | 
 47 | initVM :: proc() {
 48 |     resetStack()
 49 |     vm.nextGC = 1024 * 1024
 50 | 
 51 |     vm.initString = copyString("init")
 52 | 
 53 |     defineNative("clock", clockNative)
 54 | }
 55 | 
 56 | freeVM :: proc() {
 57 |     freeTable(&vm.strings)
 58 |     freeTable(&vm.globals)
 59 |     vm.initString = nil
 60 |     freeObjects()
 61 | }
 62 | 
 63 | interpret :: proc(source: string) -> InterpretResult {
 64 |     function := compile(source)
 65 |     if (function == nil) { return .COMPILE_ERROR }
 66 | 
 67 |     push(OBJ_VAL(function))
 68 |     closure := newClosure(function)
 69 |     pop()
 70 |     push(OBJ_VAL(closure))
 71 |     vmCall(closure, 0)
 72 | 
 73 | 	return run()
 74 | }
 75 | 
 76 | run :: proc() -> InterpretResult {
 77 |     frame := &vm.frames[vm.frameCount - 1]
 78 | 
 79 |     for {
 80 |         when DEBUG_STACK_TRACE {
 81 |             fmt.printf("          ")
 82 |             for i in 0..<vm.stackIndex {
 83 |                 fmt.printf("[ ")
 84 |                 printValue(vm.stack[i])
 85 |                 fmt.printf(" ]")
 86 |             }
 87 |             fmt.println()
 88 |             disassembleInstruction(frame.closure.function.chunk, frame.ip)
 89 |         }
 90 | 
 91 |         instruction := cast(OpCode) readByte()
 92 |         switch instruction {
 93 |             case .CONSTANT:
 94 |                 constant := readConstant()
 95 |                 push(constant)
 96 | 
 97 |             case .NIL: push(NIL_VAL())
 98 |             case .TRUE: push(BOOL_VAL(true))
 99 |             case .FALSE: push(BOOL_VAL(false))
100 |             case .POP: pop()
101 | 
102 |             case .GET_LOCAL:
103 |                 slot := readByte()
104 |                 push(frame.slots[slot])
105 | 
106 |             case .SET_LOCAL:
107 |                 slot := readByte()
108 |                 frame.slots[slot] = peek(0)
109 | 
110 |             case .GET_GLOBAL:
111 |                 name := readString()
112 |                 value: Value
113 |                 ok: bool
114 |                 if value, ok = tableGet(&vm.globals, name); !ok {
115 |                     runtimeError("Undefined variable '%s'.", name.str)
116 |                     return .RUNTIME_ERROR
117 |                 }
118 |                 push(value)
119 | 
120 |             case .DEFINE_GLOBAL:
121 |                 name := readString()
122 |                 tableSet(&vm.globals, name, peek(0))
123 |                 pop()
124 | 
125 |             case .SET_GLOBAL:
126 |                 name := readString()
127 |                 if tableSet(&vm.globals, name, peek(0)) {
128 |                     tableDelete(&vm.globals, name)
129 |                     runtimeError("Undefined variable '%s'.", name.str)
130 |                     return .RUNTIME_ERROR
131 |                 }
132 | 
133 |             case .GET_UPVALUE:
134 |                 slot := readByte()
135 |                 push(frame.closure.upvalues[slot-1].location^)
136 | 
137 |             case .SET_UPVALUE:
138 |                 slot := readByte()
139 |                 frame.closure.upvalues[slot-1].location^ = peek(0)
140 | 
141 |             case .GET_PROPERTY: {
142 |                 if AS_OBJ(peek(0)).type != .INSTANCE {
143 |                     runtimeError("Only instances have properties.")
144 |                     return .RUNTIME_ERROR
145 |                 }
146 | 
147 |                 instance := cast(^ObjInstance) AS_OBJ(peek(0))
148 |                 name := readString()
149 | 
150 |                 value: Value
151 |                 if value, ok := tableGet(&instance.fields, name); ok {
152 |                     pop() // instance
153 |                     push(value)
154 |                     break
155 |                 }
156 | 
157 |                 if !bindMethod(instance.klass, name) {
158 |                     return .RUNTIME_ERROR
159 |                 }
160 |             }
161 | 
162 |             case .SET_PROPERTY: {
163 |                 if AS_OBJ(peek(1)).type != .INSTANCE {
164 |                     runtimeError("Only instances have properties.")
165 |                     return .RUNTIME_ERROR
166 |                 }
167 | 
168 |                 instance := cast(^ObjInstance) AS_OBJ(peek(1))
169 |                 tableSet(&instance.fields, readString(), peek(0))
170 |                 value := pop()
171 |                 pop()
172 |                 push(value)
173 |             }
174 | 
175 |             case .GET_SUPER: {
176 |                 name := readString()
177 |                 superclass := cast(^ObjClass) AS_OBJ(pop())
178 | 
179 |                 if !bindMethod(superclass, name) {
180 |                     return .RUNTIME_ERROR
181 |                 }
182 |             }
183 | 
184 |             case .EQUAL:
185 |                 b := pop()
186 |                 a := pop()
187 |                 push(BOOL_VAL(valuesEqual(a, b)))
188 | 
189 |             case .GREATER:
190 |                 checkNumbers() or_return
191 |                 b := pop()
192 |                 a := pop()
193 |                 push(BOOL_VAL(AS_NUMBER(a) > AS_NUMBER(b)))
194 | 
195 |             case .LESS:
196 |                 checkNumbers() or_return
197 |                 b := pop()
198 |                 a := pop()
199 |                 push(BOOL_VAL(AS_NUMBER(a) < AS_NUMBER(b)))
200 | 
201 |             case .ADD:
202 |                 v1 := peek(0)
203 |                 v2 := peek(1)
204 |                 if IS_OBJ(v1) && AS_OBJ(v1).type == .STRING && IS_OBJ(v2) && AS_OBJ(v2).type == .STRING {
205 |                     concatenate()
206 |                 } else if IS_NUMBER(peek(0)) && IS_NUMBER(peek(1)) {
207 |                     b := AS_NUMBER(pop())
208 |                     a := AS_NUMBER(pop())
209 |                     push(NUMBER_VAL(a + b))
210 |                 } else {
211 |                     runtimeError("Operands must be two numbers or two strings.")
212 |                     return .RUNTIME_ERROR
213 |                 }
214 | 
215 |             case .SUBTRACT:
216 |                 checkNumbers() or_return
217 |                 b := AS_NUMBER(pop())
218 |                 a := AS_NUMBER(pop())
219 |                 push(NUMBER_VAL(a - b))
220 | 
221 |             case .MULTIPLY:
222 |                 checkNumbers() or_return
223 |                 b := AS_NUMBER(pop())
224 |                 a := AS_NUMBER(pop())
225 |                 push(NUMBER_VAL(a * b))
226 | 
227 |             case .DIVIDE:
228 |                 checkNumbers() or_return
229 |                 b := AS_NUMBER(pop())
230 |                 a := AS_NUMBER(pop())
231 |                 push(NUMBER_VAL(a / b))
232 | 
233 |             case .NOT:
234 |                 push(BOOL_VAL(isFalsey(pop())))
235 | 
236 |             case .NEGATE:
237 |                 if !IS_NUMBER(peek(0)) {
238 |                     runtimeError("Operand must be a number.")
239 |                     return .RUNTIME_ERROR
240 |                 }
241 |                 // vm.stack[vm.stackIndex-1].variant = -vm.stack[vm.stackIndex-1].variant.(f64)
242 |                 push(NUMBER_VAL(-AS_NUMBER(pop())))
243 | 
244 |             case .PRINT:
245 |                 printValue(pop())
246 |                 fmt.println()
247 | 
248 |             case .JUMP:
249 |                 offset := readShort()
250 |                 frame.ip += int(offset)
251 | 
252 |             case .JUMP_IF_FALSE:
253 |                 offset := readShort()
254 |                 if isFalsey(peek(0)) {
255 |                    frame.ip += int(offset)
256 |                 }
257 | 
258 |             case .LOOP: 
259 |                 offset := readShort()
260 |                 frame.ip -= int(offset)
261 | 
262 |             case .CALL:
263 |                 argCount := readByte()
264 |                 if !callValue(peek(i32(argCount)), argCount) {
265 |                     return .RUNTIME_ERROR
266 |                 }
267 |                 frame = &vm.frames[vm.frameCount - 1]
268 | 
269 |             case .INVOKE: {
270 |                 method := readString()
271 |                 argCount := readByte()
272 |                 if !invoke(method, argCount) {
273 |                     return .RUNTIME_ERROR
274 |                 }
275 |                 frame = &vm.frames[vm.frameCount - 1]
276 |             }
277 | 
278 |             case .SUPER_INVOKE: {
279 |                 method := readString()
280 |                 argCount := readByte()
281 |                 superclass := cast(^ObjClass) AS_OBJ(pop())
282 |                 if !invokeFromClass(superclass, method, argCount) {
283 |                     return .RUNTIME_ERROR
284 |                 }
285 |                 frame = &vm.frames[vm.frameCount - 1]
286 |             }
287 | 
288 |             case .CLOSURE:
289 |                 function := cast(^ObjFunction) AS_OBJ(readConstant())
290 |                 closure := newClosure(function)
291 |                 push(OBJ_VAL(closure))
292 |                 for i in 0..<closure.upvalueCount {
293 |                     isLocal := bool(readByte())
294 |                     index := readByte()
295 |                     if isLocal {
296 |                         closure.upvalues[i] = captureUpvalue(&frame.slots[index]) // this could be wrong
297 |                     } else {
298 |                         closure.upvalues[i] = frame.closure.upvalues[index]
299 |                     }
300 |                 }
301 | 
302 |             case .CLOSE_UPVALUE:
303 |                 closeUpvalues(&vm.stack[vm.stackIndex - 1])
304 |                 pop()
305 | 
306 |             case .RETURN:
307 |                 result := pop()
308 |                 closeUpvalues(&frame.slots[0])
309 |                 vm.frameCount -= 1
310 |                 if vm.frameCount == 0 {
311 |                     pop()
312 |                     return .OK
313 |                 }
314 | 
315 |                 // log.debug("%v", vm.stackIndex)
316 |                 vm.stackIndex -= i32(frame.closure.function.arity) + 1
317 |                 // log.debug("%v", vm.stackIndex)
318 |                 push(result)
319 |                 frame = &vm.frames[vm.frameCount - 1]
320 | 
321 |             case .CLASS:
322 |                 push(OBJ_VAL(newClass(readString())))
323 |             
324 |             case .METHOD:
325 |                 defineMethod(readString())
326 |             
327 |             case .INHERIT: {
328 |                 superclass := peek(1)
329 |                 if AS_OBJ(superclass).type != .CLASS {
330 |                     runtimeError("Superclass must be a class.")
331 |                     return .RUNTIME_ERROR
332 |                 }
333 | 
334 |                 subclass := cast(^ObjClass) AS_OBJ(peek(0))
335 |                 tableAddAll(&(cast(^ObjClass) AS_OBJ(superclass)).methods, &subclass.methods)
336 |                 pop()
337 |             }
338 |         }
339 |     }
340 | }
341 | 
342 | checkNumbers :: proc() -> InterpretResult {
343 |     if !IS_NUMBER(peek(0)) || !IS_NUMBER(peek(1)) {
344 |         runtimeError("Operands must be numbers.")
345 |         return .RUNTIME_ERROR
346 |     }
347 |     return nil
348 | }
349 | 
350 | push :: proc(value: Value) {
351 |     vm.stack[vm.stackIndex] = value
352 |     vm.stackIndex += 1
353 | }
354 | 
355 | pop :: proc() ->  Value {
356 |     vm.stackIndex -= 1
357 |     return vm.stack[vm.stackIndex]
358 | }
359 | 
360 | peek :: proc(distance: i32) -> Value {
361 |     return vm.stack[vm.stackIndex - 1 - distance]
362 | }
363 | 
364 | // renamed from 'call' because of naming collision
365 | vmCall :: proc(closure: ^ObjClosure, argCount: u8) -> bool {
366 |     if u32(argCount) != closure.function.arity {
367 |         runtimeError("Expected %v arguments but got %v.", closure.function.arity, argCount)
368 |         return false
369 |     }
370 | 
371 |     if vm.frameCount == FRAMES_MAX {
372 |         runtimeError("Stack overflow.")
373 |         return false
374 |     }
375 | 
376 |     frame := &vm.frames[vm.frameCount]
377 |     vm.frameCount += 1
378 |     frame.closure = closure
379 |     frame.ip = 0
380 |     // log.debug("%v", frame.slots)
381 |     frame.slots = vm.stack[vm.stackIndex - i32(argCount) - 1:]
382 |     // log.debug("%v", frame.slots[:10])
383 |     return true
384 | }
385 | 
386 | callValue :: proc(callee: Value, argCount: u8) -> bool {
387 |     if IS_OBJ(callee) {
388 |         calleeObject := AS_OBJ(callee)
389 |         #partial switch calleeObject.type {
390 |             case .BOUND_METHOD: {
391 |                 bound := cast(^ObjBoundMethod) calleeObject
392 |                 vm.stack[vm.stackIndex - i32(argCount) - 1] = bound.receiver
393 |                 return vmCall(bound.method, argCount)
394 |             }
395 |             case .CLASS: {
396 |                 klass := cast(^ObjClass) calleeObject
397 |                 vm.stack[vm.stackIndex - i32(argCount) - 1] = OBJ_VAL(newInstance(klass))
398 |                 if initializer, ok := tableGet(&klass.methods, vm.initString); ok {
399 |                     return vmCall(cast(^ObjClosure) AS_OBJ(initializer), argCount)
400 |                 } else if argCount != 0 {
401 |                     runtimeError("Expected 0 arguments but got %v.", argCount)
402 |                     return false
403 |                 }
404 | 
405 |                 return true
406 |             }
407 |             case .CLOSURE:
408 |                 return vmCall(cast(^ObjClosure) calleeObject, argCount)
409 |             case .NATIVE:
410 |                 native_object := cast(^ObjNative) calleeObject
411 |                 native := native_object.function
412 |                 result := native(argCount, vm.stack[vm.stackIndex - i32(argCount):])
413 |                 vm.stackIndex -= i32(argCount) + 1
414 |                 push(result)
415 |                 return true
416 |         }
417 |     }
418 |     runtimeError("Can only call functions and classes.")
419 |     return false
420 | }
421 | 
422 | invokeFromClass :: proc(klass: ^ObjClass, name: ^ObjString, argCount: u8) -> bool {
423 |     method: Value
424 |     ok: bool
425 |     if method, ok = tableGet(&klass.methods, name); !ok {
426 |         runtimeError("Undefined property '%v'.", name.str)
427 |         return false
428 |     }
429 |     return vmCall(cast(^ObjClosure) AS_OBJ(method), u8(argCount))
430 | }
431 | 
432 | invoke :: proc(name: ^ObjString, argCount: u8) -> bool {
433 |     receiver := peek(i32(argCount))
434 | 
435 |     if AS_OBJ(receiver).type != .INSTANCE {
436 |         runtimeError("Only instances have methods.")
437 |         return false
438 |     }
439 | 
440 |     instance := cast(^ObjInstance) AS_OBJ(receiver)
441 | 
442 |     if value, ok := tableGet(&instance.fields, name); ok {
443 |         vm.stack[vm.stackIndex - i32(argCount) - 1] = value
444 |         return callValue(value, argCount)
445 |     }
446 | 
447 |     return invokeFromClass(instance.klass, name, argCount)
448 | }
449 | 
450 | bindMethod :: proc(klass: ^ObjClass, name: ^ObjString) -> bool {
451 |     method: Value
452 |     ok: bool
453 |     if method, ok = tableGet(&klass.methods, name); !ok {
454 |         runtimeError("Undefined property '%s'.", name.str)
455 |         return false
456 |     }
457 | 
458 |     bound := newBoundMethod(peek(0), cast(^ObjClosure) AS_OBJ(method))
459 | 
460 |     pop()
461 |     push(OBJ_VAL(bound))
462 |     return true
463 | }
464 | 
465 | captureUpvalue :: proc(local: ^Value) -> ^ObjUpvalue {
466 |     prevUpvalue: ^ObjUpvalue
467 |     upvalue := vm.openUpvalues
468 |     for upvalue != nil && upvalue.location > local {
469 |         prevUpvalue = upvalue
470 |         upvalue = upvalue.nextUpvalue
471 |     }
472 | 
473 |     if upvalue != nil && upvalue.location == local {
474 |         return upvalue
475 |     }
476 | 
477 |     createdUpvalue := newUpvalue(local)
478 |     createdUpvalue.nextUpvalue = upvalue
479 | 
480 |     if prevUpvalue == nil {
481 |         vm.openUpvalues = createdUpvalue
482 |     } else {
483 |         prevUpvalue.nextUpvalue = createdUpvalue
484 |     }
485 | 
486 |     return createdUpvalue
487 | }
488 | 
489 | closeUpvalues :: proc(last: ^Value) {
490 |     for vm.openUpvalues != nil && vm.openUpvalues.location >= last {
491 |         upvalue := vm.openUpvalues
492 |         upvalue.closed = upvalue.location^
493 |         upvalue.location = &upvalue.closed
494 |         vm.openUpvalues = upvalue.nextUpvalue
495 |     }
496 | }
497 | 
498 | defineMethod :: proc(name: ^ObjString) {
499 |     method := peek(0)
500 |     klass := cast(^ObjClass) AS_OBJ(peek(1))
501 |     tableSet(&klass.methods, name, method)
502 |     pop()
503 | }
504 | 
505 | isFalsey :: proc(value: Value) -> bool {
506 |     return IS_NIL(value) || (IS_BOOL(value) && !AS_BOOL(value))
507 | }
508 | 
509 | concatenate :: proc() {
510 |     b := cast(^ObjString) AS_OBJ(peek(0))
511 |     a := cast(^ObjString) AS_OBJ(peek(1))
512 | 
513 |     length := len(a.str) + len(b.str)
514 |     chars := make([]byte, length)
515 |     i := 0
516 |     i =+ copy(chars[i:], a.str)
517 |     copy(chars[i:], b.str)
518 | 
519 |     result := takeString(string(chars))
520 |     pop()
521 |     pop()
522 |     push(OBJ_VAL(result))
523 | }
524 | 
525 | readByte :: proc() -> (b: u8) {
526 |     frame := &vm.frames[vm.frameCount - 1]
527 |     b = frame.closure.function.chunk.code[frame.ip]
528 |     frame.ip += 1
529 |     return
530 | }
531 | 
532 | readShort :: proc() -> (s: u16) {
533 |     frame := &vm.frames[vm.frameCount - 1]
534 |     frame.ip += 2
535 |     s = u16((frame.closure.function.chunk.code[frame.ip - 2] << 8) | frame.closure.function.chunk.code[frame.ip - 1])
536 |     return
537 | }
538 | 
539 | readConstant :: proc() -> Value {
540 |     frame := &vm.frames[vm.frameCount - 1]
541 |     return frame.closure.function.chunk.constants[readByte()]
542 | }
543 | 
544 | readString :: proc() -> ^ObjString {
545 |     return cast(^ObjString) AS_OBJ(readConstant())
546 | }
547 | 
548 | resetStack :: proc() {
549 |     vm.stackIndex = 0
550 |     vm.frameCount = 0
551 | }
552 | 
553 | runtimeError :: proc(format: string, args: ..any) {
554 |     log.errorf(format, ..args)
555 | 
556 |     for i := vm.frameCount-1; i >= 0; i -=1 {
557 |         frame := &vm.frames[i]
558 |         function := frame.closure.function
559 |         instruction_index := len(function.chunk.code) - frame.ip - 1
560 |         log.errorf("[line %v] in", function.chunk.lines[instruction_index])
561 |         if function.name == nil {
562 |             log.error("script\n")
563 |         } else {
564 |             log.errorf("%v()\n", function.name.str)
565 |         }
566 |     }
567 | 
568 |     resetStack()
569 | }
570 | 
571 | defineNative :: proc(name: string, function: NativeFn) {
572 |     push(OBJ_VAL(copyString(name)))
573 |     push(OBJ_VAL(newNative(function)))
574 |     tableSet(&vm.globals, cast(^ObjString) AS_OBJ(vm.stack[0]), vm.stack[1])
575 |     pop()
576 |     pop()
577 | }
578 | 
579 | freeObjects :: proc() {
580 |     object := vm.objects
581 |     for object != nil {
582 |         next := object.next
583 |         freeObject(object)
584 |         object = next
585 |     }
586 | 
587 |     delete(vm.grayStack);
588 | }
589 | 


--------------------------------------------------------------------------------
/src/compiler.odin:
--------------------------------------------------------------------------------
  1 | //+private file
  2 | package main
  3 | 
  4 | import "core:log"
  5 | import "core:strconv"
  6 | import "core:strings"
  7 | 
  8 | DEBUG_PRINT_CODE :: false
  9 | 
 10 | Parser :: struct {
 11 | 	current: Token,
 12 | 	previous: Token,
 13 |     hadError: bool,
 14 |     panicMode: bool,
 15 | }
 16 | 
 17 | Precedence :: enum {
 18 |     NONE,
 19 |     ASSIGNMENT, // =
 20 |     OR,         // or
 21 |     AND,        // and
 22 |     EQUALITY,   // == !=
 23 |     COMPARISON, // < > <= >=
 24 |     TERM,       // + -
 25 |     FACTOR,     // * /
 26 |     UNARY,      // ! -
 27 |     CALL,       // . ()
 28 |     PRIMARY,
 29 | }
 30 | 
 31 | ParseFn :: #type proc(canAssign: bool)
 32 | 
 33 | ParseRule :: struct {
 34 |     prefix: ParseFn,
 35 |     infix: ParseFn,
 36 |     precedence: Precedence,
 37 | }
 38 | 
 39 | U8_MAX :: cast(int)max(u8)
 40 | 
 41 | Local :: struct {
 42 |     name: Token,
 43 |     depth: int,
 44 |     isCaptured: bool,
 45 | }
 46 | 
 47 | Upvalue :: struct {
 48 |     index: u8,
 49 |     isLocal: bool,
 50 | }
 51 | 
 52 | FunctionType :: enum {
 53 |     FUNCTION,
 54 |     INITIALIZER,
 55 |     METHOD,
 56 |     SCRIPT,
 57 | }
 58 | 
 59 | Compiler :: struct {
 60 |     enclosing: ^Compiler,
 61 |     function: ^ObjFunction,
 62 |     type: FunctionType,
 63 | 
 64 |     locals: [U8_MAX + 1]Local,
 65 |     localCount: int,
 66 |     upvalues: [U8_MAX + 1]Upvalue,
 67 |     scopeDepth: int,
 68 | }
 69 | 
 70 | ClassCompiler :: struct {
 71 |     enclosing: ^ClassCompiler,
 72 |     hasSuperclass: bool,
 73 | }
 74 | 
 75 | parser: Parser
 76 | current: ^Compiler = nil
 77 | currentClass: ^ClassCompiler = nil
 78 | compilingChunk: ^Chunk
 79 | 
 80 | currentChunk :: proc() -> ^Chunk {
 81 |     return &current.function.chunk
 82 | }
 83 | 
 84 | compile :: proc(source: string) -> ^ObjFunction {
 85 |     initScanner(source)
 86 |     compiler: Compiler
 87 |     initCompiler(&compiler, .SCRIPT)
 88 | 
 89 | 	advance()
 90 | 	for !match(.EOF) {
 91 |         declaration()
 92 |     }
 93 | 	consume(.EOF, "Expect end of expression.")
 94 |     function := endCompiler()
 95 |     return function if !parser.hadError else nil
 96 | }
 97 | 
 98 | markCompilerRoots :: proc() {
 99 |     compiler := current
100 |     for compiler != nil {
101 |         markObject(compiler.function)
102 |         compiler = compiler.enclosing
103 |     }
104 | }
105 | 
106 | advance :: proc() {
107 | 	parser.previous = parser.current
108 | 
109 | 	for {
110 | 		parser.current = scanToken()
111 | 		if parser.current.type != .ERROR { break }
112 | 
113 | 		errorAtCurrent(parser.current.value)
114 | 	}
115 | }
116 | 
117 | consume :: proc(type: TokenType, message: string) {
118 |     if parser.current.type == type {
119 |         advance()
120 |         return
121 |     }
122 | 
123 |     errorAtCurrent(message)
124 | }
125 | 
126 | check :: proc(type: TokenType) -> bool {
127 |     return parser.current.type == type
128 | }
129 | 
130 | @(private = "file")
131 | match :: proc(type: TokenType) -> bool {
132 |     if !check(type) { return false }
133 |     advance()
134 |     return true
135 | } 
136 | 
137 | // Emitters
138 | 
139 | emitByte_u8 :: proc(byte: u8) {
140 |     writeChunk(currentChunk(), byte, parser.previous.line)
141 | }
142 | 
143 | emitByte_OpCode :: proc(byte: OpCode) {
144 |     writeChunk(currentChunk(), u8(byte), parser.previous.line)
145 | }
146 | 
147 | emitByte :: proc {
148 |     emitByte_u8,
149 |     emitByte_OpCode,
150 | }
151 | 
152 | emitBytes_u8 :: proc(byte1: OpCode, byte2: u8) {
153 |     emitByte(byte1)
154 |     emitByte(byte2)
155 | }
156 | 
157 | emitBytes_OpCode :: proc(byte1, byte2: OpCode) {
158 |     emitByte(byte1)
159 |     emitByte(byte2)
160 | }
161 | 
162 | emitBytes :: proc {
163 |     emitBytes_u8,
164 |     emitBytes_OpCode,
165 | }
166 | 
167 | emitLoop :: proc(loopStart: int) {
168 |     emitByte(OpCode.LOOP)
169 | 
170 |     offset := len(currentChunk().code) - loopStart + 2
171 |     if offset > int(max(u16)) {
172 |         error("Loop body too large.")
173 |     }
174 | 
175 |     emitByte(u8((offset >> 8) & 0xff))
176 |     emitByte(u8(offset & 0xff))
177 | }
178 | 
179 | emitJump :: proc(instruction: OpCode) -> int {
180 |     emitByte(instruction)
181 |     emitByte(0xff)
182 |     emitByte(0xff)
183 |     return len(currentChunk().code) - 2
184 | }
185 | 
186 | emitReturn :: proc() {
187 |     if current.type == .INITIALIZER {
188 |         emitBytes(OpCode.GET_LOCAL, 0)
189 |     } else {
190 |         emitByte(OpCode.NIL)
191 |     }
192 |     emitByte(OpCode.RETURN)
193 | }
194 | 
195 | emitConstant :: proc(value: Value) {
196 |     emitBytes(OpCode.CONSTANT, makeConstant(value))
197 | }
198 | 
199 | patchJump :: proc(offset: int) {
200 |     // -2 to adjust for the bytecode for the jump offset itself.
201 |     jump := len(currentChunk().code) - offset - 2
202 | 
203 |     if jump > int(max(u16)) {
204 |         error("Too much code to jump over.")
205 |     }
206 | 
207 |     currentChunk().code[offset] =  u8((jump >> 8) & 0xff)
208 |     currentChunk().code[offset + 1] = u8(jump & 0xff)
209 | }
210 | 
211 | //
212 | 
213 | initCompiler :: proc(compiler: ^Compiler, type: FunctionType) {
214 |     compiler.enclosing = current
215 |     compiler.type = type
216 |     compiler.function = newFunction()
217 |     current = compiler
218 | 
219 |     if type != .SCRIPT {
220 |         current.function.name = copyString(parser.previous.value)
221 |     }
222 | 
223 |     local := &current.locals[current.localCount]
224 |     current.localCount += 1
225 |     local.depth = 0
226 |     local.name.value = ""
227 | 
228 |     if type != .FUNCTION {
229 |         local.name.value = "this"
230 |     } else {
231 |         local.name.value = ""
232 |     }
233 | }
234 | 
235 | makeConstant :: proc(value: Value) -> u8 {
236 |     constant := addConstant(currentChunk(), value)
237 |     if constant > U8_MAX {
238 |         error("Too many constants in one chunk.")
239 |         return 0
240 |     }
241 | 
242 |     return cast(u8) constant
243 | }
244 | 
245 | endCompiler :: proc() -> ^ObjFunction {
246 |     emitReturn()
247 |     function := current.function
248 | 
249 |     when DEBUG_PRINT_CODE {
250 |         if !parser.hadError {
251 |             disassembleChunk(currentChunk()^, function.name.str if function.name != nil  else "<script>")
252 |         }
253 |     }
254 | 
255 |     current = current.enclosing
256 |     return function
257 | }
258 | 
259 | beginScope :: proc() {
260 |     current.scopeDepth += 1
261 | }
262 | 
263 | endScope :: proc() {
264 |     current.scopeDepth -= 1
265 | 
266 |     for current.localCount > 0 && current.locals[current.localCount - 1].depth > current.scopeDepth {
267 |         if current.locals[current.localCount - 1].isCaptured {
268 |             emitByte(OpCode.CLOSE_UPVALUE)
269 |         } else {
270 |             emitByte(OpCode.POP)
271 |         }
272 |         current.localCount -= 1
273 |     }
274 | }
275 | 
276 | binary :: proc(canAssign: bool) {
277 |     operatoryType := parser.previous.type
278 |     rule := getRule(operatoryType)
279 |     parsePrecedence(cast(Precedence)(int(rule.precedence) + 1))
280 | 
281 |     #partial switch (operatoryType) {
282 |         case .BANG_EQUAL:    emitBytes(OpCode.EQUAL, OpCode.NOT)
283 |         case .EQUAL_EQUAL:   emitByte(OpCode.EQUAL)
284 |         case .GREATER:       emitByte(OpCode.GREATER)
285 |         case .GREATER_EQUAL: emitBytes(OpCode.LESS, OpCode.NOT)
286 |         case .LESS:          emitByte(OpCode.LESS)
287 |         case .LESS_EQUAL:    emitBytes(OpCode.GREATER, OpCode.NOT)
288 |         case .PLUS:          emitByte(OpCode.ADD)
289 |         case .MINUS:         emitByte(OpCode.SUBTRACT)
290 |         case .STAR:          emitByte(OpCode.MULTIPLY)
291 |         case .SLASH:         emitByte(OpCode.DIVIDE)
292 |     }
293 | }
294 | 
295 | call :: proc(canAssign: bool) {
296 |     argCount := argumentList()
297 |     emitBytes(.CALL, argCount)
298 | }
299 | 
300 | dot :: proc(canAssign: bool) {
301 |     consume(.IDENTIFIER, "Expect property name after '.'.")
302 |     name := identifierConstant(parser.previous)
303 | 
304 |     if canAssign && match(.EQUAL) {
305 |         expression()
306 |         emitBytes(OpCode.SET_PROPERTY, name)
307 |     } else if match(.LEFT_PAREN) {
308 |         argCount := argumentList()
309 |         emitBytes(OpCode.INVOKE, name)
310 |         emitByte(argCount)
311 |     } else {
312 |         emitBytes(OpCode.GET_PROPERTY, name)
313 |     }
314 | }
315 | 
316 | literal :: proc(canAssign: bool) {
317 |     #partial switch parser.previous.type {
318 |         case .FALSE: emitByte(OpCode.FALSE)
319 |         case .NIL:   emitByte(OpCode.NIL)
320 |         case .TRUE:  emitByte(OpCode.TRUE)
321 |     }
322 | }
323 | 
324 | expression :: proc() {
325 |     parsePrecedence(.ASSIGNMENT)
326 | }
327 | 
328 | block :: proc() {
329 |     for !check(.RIGHT_BRACE) && !check(.EOF) {
330 |         declaration()
331 |     }
332 | 
333 |     consume(.RIGHT_BRACE, "Expect '}' after block.")
334 | }
335 | 
336 | function :: proc(type: FunctionType) {
337 |     compiler: Compiler
338 |     initCompiler(&compiler, type)
339 |     beginScope()
340 |     
341 |     consume(.LEFT_PAREN, "Expect '(' after function name.")
342 |     if !check(.RIGHT_PAREN) {
343 |         for {
344 |             current.function.arity += 1
345 |             if current.function.arity > 255 {
346 |                 errorAtCurrent("Can't have more than 255 parameters.")
347 |             }
348 |             constant := parseVariable("Expect parameter name.")
349 |             defineVariable(constant)
350 | 
351 |             if !match(.COMMA) { break }
352 |         }
353 |     }
354 |     consume(.RIGHT_PAREN, "Expect ')' after parameters.")
355 |     consume(.LEFT_BRACE, "Expect '{' before function body.")
356 |     block()
357 | 
358 |     function := endCompiler()
359 |     emitBytes(OpCode.CLOSURE, makeConstant(OBJ_VAL(function)))
360 | 
361 |     for i in 0..<function.upvalueCount {
362 |         emitByte_u8(1 if compiler.upvalues[i].isLocal else 0)
363 |         emitByte(compiler.upvalues[i].index)
364 |     }
365 | }
366 | 
367 | method :: proc() {
368 |     consume(.IDENTIFIER, "Expect method name.")
369 |     constant := identifierConstant(parser.previous)
370 | 
371 |     type := FunctionType.METHOD
372 |     if len(parser.previous.value) == 4 && strings.compare(parser.previous.value, "init") == 0 {
373 |         type = .INITIALIZER
374 |     }
375 |     function(type)
376 |     emitBytes(OpCode.METHOD, constant)
377 | }
378 | 
379 | classDeclaration :: proc() {
380 |     consume(.IDENTIFIER, "Expect class name.")
381 |     className := parser.previous
382 |     nameConstant := identifierConstant(parser.previous)
383 |     declareVariable()
384 | 
385 |     emitBytes(OpCode.CLASS, nameConstant)
386 |     defineVariable(nameConstant)
387 | 
388 |     classCompiler := ClassCompiler{currentClass, false}
389 |     currentClass = &classCompiler
390 | 
391 |     if match(.LESS) {
392 |         consume(.IDENTIFIER, "Expect superclass name.")
393 |         variable(false)
394 | 
395 |         if identifiersEqual(className, parser.previous) {
396 |             error("A class can't inherit from itself.")
397 |         }
398 | 
399 |         beginScope()
400 |         addLocal(syntheticToken("super"))
401 |         defineVariable(0)
402 | 
403 |         namedVariable(className, false)
404 |         emitByte(OpCode.INHERIT)
405 |         classCompiler.hasSuperclass = true
406 |     }
407 | 
408 |     namedVariable(className, false)
409 |     consume(.LEFT_BRACE, "Expect '{' before class body.")
410 |     for !check(.RIGHT_BRACE) && !check(.EOF) {
411 |         method()
412 |     }
413 |     consume(.RIGHT_BRACE, "Expect '}' after class body.")
414 |     emitByte(OpCode.POP)
415 | 
416 |     if classCompiler.hasSuperclass {
417 |         endScope()
418 |     }
419 | 
420 |     currentClass = currentClass.enclosing
421 | }
422 | 
423 | funDeclaration :: proc() {
424 |     global := parseVariable("Expect function name.")
425 |     markInitialized()
426 |     function(.FUNCTION)
427 |     defineVariable(global)
428 | }
429 | 
430 | varDeclaration :: proc() {
431 |     global := parseVariable("Expect variable name.")
432 | 
433 |     if match(.EQUAL) {
434 |         expression()
435 |     } else {
436 |         emitByte(OpCode.NIL)
437 |     }
438 |     consume(.SEMICOLON, "Expect ';' after variable declaration.")
439 | 
440 |     defineVariable(global)
441 | }
442 | 
443 | expressionStatement :: proc() {
444 |     expression()
445 |     consume(.SEMICOLON, "Expect ';' after expression.")
446 |     emitByte(OpCode.POP)
447 | }
448 | 
449 | forStatement :: proc() {
450 |     beginScope()
451 |     consume(.LEFT_PAREN, "Expect '(' after 'for'.")
452 |     if match(.SEMICOLON) {
453 |         // No initializer.
454 |     } else if match(.VAR) {
455 |         varDeclaration()
456 |     } else {
457 |         expressionStatement()
458 |     }
459 | 
460 |     loopStart := len(currentChunk().code)
461 |     exitJump := -1
462 |     if !match(.SEMICOLON) {
463 |         expression()
464 |         consume(.SEMICOLON, "Expect ';' after loop condition.")
465 | 
466 |         // Jump out of the loop if the condition is false.
467 |         exitJump = emitJump(.JUMP_IF_FALSE)
468 |         emitByte(OpCode.POP)
469 |     }
470 | 
471 |     if !match(.RIGHT_PAREN) {
472 |         bodyJump := emitJump(.JUMP)
473 |         incrementStart := len(currentChunk().code)
474 |         expression()
475 |         emitByte(OpCode.POP)
476 |         consume(.RIGHT_PAREN, "Expect ')' after for clauses.")
477 | 
478 |         emitLoop(loopStart)
479 |         loopStart = incrementStart
480 |         patchJump(bodyJump)
481 |     }
482 | 
483 |     statement()
484 |     emitLoop(loopStart)
485 | 
486 |     if exitJump != -1 {
487 |         patchJump(exitJump)
488 |         emitByte(OpCode.POP)
489 |     }
490 |     endScope()
491 | }
492 | 
493 | ifStatement :: proc() {
494 |     consume(.LEFT_PAREN, "Expect '(' after 'if'.")
495 |     expression()
496 |     consume(.RIGHT_PAREN, "Expect ')' after condition.")
497 | 
498 |     thenJump := emitJump(OpCode.JUMP_IF_FALSE)
499 |     emitByte(OpCode.POP)
500 |     statement()
501 | 
502 |     elseJump := emitJump(OpCode.JUMP)
503 | 
504 |     patchJump(thenJump)
505 |     emitByte(OpCode.POP)
506 | 
507 |     if match(.ELSE) {
508 |         statement()
509 |     }
510 |     patchJump(elseJump)
511 | }
512 | 
513 | printStatement :: proc() {
514 |     expression()
515 |     consume(.SEMICOLON, "Expect ';' after value.")
516 |     emitByte(OpCode.PRINT)
517 | }
518 | 
519 | returnStatement :: proc() {
520 |     if current.type == .SCRIPT {
521 |         error("Can't return from  top-level code.")
522 |     }
523 | 
524 |     if match(.SEMICOLON) {
525 |         emitReturn()
526 |     } else {
527 |         if current.type == .INITIALIZER {
528 |             error("Can't return a value from an initializer.")
529 |         }
530 |         expression()
531 |         consume(.SEMICOLON, "Expect ';' after return value.")
532 |         emitByte(OpCode.RETURN)
533 |     }
534 | }
535 | 
536 | whileStatement :: proc() {
537 |     loopStart := len(currentChunk().code)
538 |     consume(.LEFT_PAREN, "Expect '(' after 'while'.")
539 |     expression()
540 |     consume(.RIGHT_PAREN, "Expect ')' after condition.")
541 | 
542 |     exitJump := emitJump(.JUMP_IF_FALSE)
543 |     emitByte(OpCode.POP)
544 |     statement()
545 |     emitLoop(loopStart)
546 | 
547 |     patchJump(exitJump)
548 |     emitByte(OpCode.POP)
549 | }
550 | 
551 | syncronize :: proc() {
552 |     parser.panicMode = false
553 | 
554 |     for parser.current.type != .EOF {
555 |         if parser.previous.type == .SEMICOLON { return }
556 |         #partial switch parser.current.type {
557 |             case .CLASS, .FUN, .VAR, .FOR, .IF, .WHILE, .PRINT, .RETURN: return
558 |             case: // Do nothing
559 |         }
560 | 
561 |         advance()
562 |     }
563 | }
564 | 
565 | declaration :: proc() {
566 |     if match(.CLASS) {
567 |         classDeclaration()
568 |     } else if match(.FUN) {
569 |         funDeclaration()
570 |     } else if match(.VAR) {
571 |         varDeclaration()
572 |     } else {
573 |         statement()
574 |     }
575 | 
576 |     if parser.panicMode { syncronize() }
577 | }
578 | 
579 | statement :: proc() {
580 |     if match(.PRINT) {
581 |         printStatement()
582 |     } else if match(.FOR) {
583 |         forStatement()
584 |     } else if match(.IF) {
585 |         ifStatement()
586 |     } else if match(.RETURN) {
587 |         returnStatement()
588 |     } else if match(.WHILE) {
589 |         whileStatement()
590 |     } else if match(.LEFT_BRACE) {
591 |         beginScope()
592 |         block()
593 |         endScope()
594 |     } else {
595 |         expressionStatement()
596 |     }
597 | }
598 | 
599 | grouping :: proc(canAssign: bool) {
600 |     expression()
601 |     consume(.RIGHT_PAREN, "Expect ')' after expression.")
602 | }
603 | 
604 | number :: proc(canAssign: bool) {
605 |     value := strconv.atof(parser.previous.value)
606 |     emitConstant(NUMBER_VAL(value))
607 | }
608 | 
609 | or_ :: proc(canAssign: bool) {
610 |     elseJump := emitJump(.JUMP_IF_FALSE)
611 |     endJump := emitJump(.JUMP)
612 | 
613 |     patchJump(elseJump)
614 |     emitByte(OpCode.POP)
615 | 
616 |     parsePrecedence(.OR)
617 |     patchJump(endJump)
618 | }
619 | 
620 | 
621 | lstring :: proc(canAssign: bool) {
622 |     str := parser.previous.value[1:len(parser.previous.value)-1] // remove the "" from the string literal
623 |     emitConstant(OBJ_VAL(copyString(str)))
624 | }
625 | 
626 | namedVariable :: proc(name: Token, canAssign: bool) {
627 |     getOp, setOp: OpCode
628 |     arg := resolveLocal(current, name)
629 |     if arg != -1 {
630 |         getOp = .GET_LOCAL
631 |         setOp = .SET_LOCAL
632 |     } else if arg = resolveUpvalue(current, name); arg != -1 {
633 |         getOp = .GET_UPVALUE
634 |         setOp = .SET_UPVALUE
635 |     } else {
636 |         arg = int(identifierConstant(name))
637 |         getOp = .GET_GLOBAL
638 |         setOp = .SET_GLOBAL
639 |     }
640 | 
641 |     if canAssign && match(.EQUAL) {
642 |         expression()
643 |         emitBytes(setOp, u8(arg))
644 |     } else {
645 |         emitBytes(getOp, u8(arg))
646 |     }
647 | 
648 | }
649 | 
650 | variable :: proc(canAssign: bool) {
651 |     namedVariable(parser.previous, canAssign)
652 | }
653 | 
654 | syntheticToken :: proc(text: string) -> (token: Token) {
655 |     token.value = text;
656 |     return
657 | }
658 | 
659 | super :: proc(canAssign: bool) {
660 |     if currentClass == nil {
661 |         error("Can't use 'super' outside of a class.")
662 |     } else if !currentClass.hasSuperclass {
663 |         error("Can't use 'super' in a class with no superclass.")
664 |     }
665 | 
666 |     consume(.DOT, "Expect '.' after 'super'.")
667 |     consume(.IDENTIFIER, "Expect superclass method name.")
668 |     name := identifierConstant(parser.previous)
669 | 
670 |     namedVariable(syntheticToken("this"), false)
671 |     if match(.LEFT_PAREN) {
672 |         argCount := argumentList()
673 |         namedVariable(syntheticToken("super"), false)
674 |         emitBytes(OpCode.SUPER_INVOKE, name)
675 |         emitByte(argCount)
676 |     } else {
677 |         namedVariable(syntheticToken("super"), false)
678 |         emitBytes(OpCode.GET_SUPER, name)
679 |     }
680 | }
681 | 
682 | this :: proc(canAssign: bool) {
683 |     if currentClass == nil {
684 |         error("Can't use 'this' outside of a class.")
685 |         return
686 |     }
687 |     variable(false)
688 | }
689 | 
690 | unary :: proc(canAssign: bool) {
691 |     operatorType := parser.previous.type
692 | 
693 |     // Compile the operand
694 |     parsePrecedence(.UNARY)
695 | 
696 |     // Emit the operator instruction
697 |     #partial switch operatorType {
698 |         case .BANG:  emitByte(OpCode.NOT)
699 |         case .MINUS: emitByte(OpCode.NEGATE)
700 |     }
701 | }
702 | 
703 | rules: []ParseRule = {
704 |     TokenType.LEFT_PAREN    = ParseRule{ grouping, call,   .CALL },
705 |     TokenType.RIGHT_PAREN   = ParseRule{ nil,      nil,    .NONE },
706 |     TokenType.LEFT_BRACE    = ParseRule{ nil,      nil,    .NONE },
707 |     TokenType.RIGHT_BRACE   = ParseRule{ nil,      nil,    .NONE },
708 |     TokenType.COMMA         = ParseRule{ nil,      nil,    .NONE },
709 |     TokenType.DOT           = ParseRule{ nil,      dot,    .CALL },
710 |     TokenType.MINUS         = ParseRule{ unary,    binary, .TERM },
711 |     TokenType.PLUS          = ParseRule{ nil,      binary, .TERM },
712 |     TokenType.SEMICOLON     = ParseRule{ nil,      nil,    .NONE },
713 |     TokenType.SLASH         = ParseRule{ nil,      binary, .FACTOR },
714 |     TokenType.STAR          = ParseRule{ nil,      binary, .FACTOR },
715 |     TokenType.BANG          = ParseRule{ unary,    nil,    .NONE },
716 |     TokenType.BANG_EQUAL    = ParseRule{ nil,      binary, .EQUALITY },
717 |     TokenType.EQUAL         = ParseRule{ nil,      nil,    .NONE },
718 |     TokenType.EQUAL_EQUAL   = ParseRule{ nil,      binary, .EQUALITY },
719 |     TokenType.GREATER       = ParseRule{ nil,      binary, .COMPARISON },
720 |     TokenType.GREATER_EQUAL = ParseRule{ nil,      binary, .COMPARISON },
721 |     TokenType.LESS          = ParseRule{ nil,      binary, .COMPARISON },
722 |     TokenType.LESS_EQUAL    = ParseRule{ nil,      binary, .COMPARISON },
723 |     TokenType.IDENTIFIER    = ParseRule{ variable, nil,    .NONE },
724 |     TokenType.STRING        = ParseRule{ lstring,  nil,    .NONE },
725 |     TokenType.NUMBER        = ParseRule{ number,   nil,    .NONE },
726 |     TokenType.AND           = ParseRule{ nil,      and_,    .AND },
727 |     TokenType.CLASS         = ParseRule{ nil,      nil,    .NONE },
728 |     TokenType.ELSE          = ParseRule{ nil,      nil,    .NONE },
729 |     TokenType.FALSE         = ParseRule{ literal,  nil,    .NONE },
730 |     TokenType.FOR           = ParseRule{ nil,      nil,    .NONE },
731 |     TokenType.FUN           = ParseRule{ nil,      nil,    .NONE },
732 |     TokenType.IF            = ParseRule{ nil,      nil,    .NONE },
733 |     TokenType.NIL           = ParseRule{ literal,  nil,    .NONE },
734 |     TokenType.OR            = ParseRule{ nil,      or_,    .OR   },
735 |     TokenType.PRINT         = ParseRule{ nil,      nil,    .NONE },
736 |     TokenType.RETURN        = ParseRule{ nil,      nil,    .NONE },
737 |     TokenType.SUPER         = ParseRule{ super,    nil,    .NONE },
738 |     TokenType.THIS          = ParseRule{ this,     nil,    .NONE },
739 |     TokenType.TRUE          = ParseRule{ literal,  nil,    .NONE },
740 |     TokenType.VAR           = ParseRule{ nil,      nil,    .NONE },
741 |     TokenType.WHILE         = ParseRule{ nil,      nil,    .NONE },
742 |     TokenType.ERROR         = ParseRule{ nil,      nil,    .NONE },
743 |     TokenType.EOF           = ParseRule{ nil,      nil,    .NONE },
744 | }
745 | 
746 | parsePrecedence :: proc(precedence: Precedence) {
747 |     advance()
748 |     prefixRule := getRule(parser.previous.type).prefix
749 |     if prefixRule == nil {
750 |         error("Expect expression.")
751 |         return
752 |     }
753 | 
754 |     canAssign := precedence <= .ASSIGNMENT
755 |     prefixRule(canAssign)
756 | 
757 |     for precedence <= getRule(parser.current.type).precedence {
758 |         advance()
759 |         infixRule := getRule(parser.previous.type).infix
760 |         infixRule(canAssign)
761 |     }
762 | 
763 |     if canAssign && match(.EQUAL) {
764 |         error("Invalid assignment target.")
765 |     }
766 | }
767 | 
768 | identifierConstant :: proc(name: Token) -> u8 {
769 |     return makeConstant(OBJ_VAL(copyString(name.value)))
770 | }
771 | 
772 | identifiersEqual :: proc(a, b: Token) -> bool {
773 |     if len(a.value) != len(b.value) { return false }
774 |     return strings.compare(a.value, b.value) == 0
775 | }
776 | 
777 | resolveLocal :: proc(compiler: ^Compiler, name: Token) -> int {
778 |     for i := compiler.localCount-1; i >= 0; i -= 1 {
779 |         local := &compiler.locals[i]
780 |         if identifiersEqual(name, local.name) {
781 |             if local.depth == -1 {
782 |                 error("Can't read local variable in its own initializer.")
783 |             }
784 |             return i
785 |         }
786 |     }
787 |     return -1
788 | }
789 | 
790 | addUpvalue :: proc(compiler: ^Compiler, index: u8, isLocal: bool) -> int {
791 |     upvalueCount := &compiler.function.upvalueCount
792 | 
793 |     for i in 0..<upvalueCount^ {
794 |         upvalue := &compiler.upvalues[i]
795 |         if upvalue.index == index && upvalue.isLocal == isLocal {
796 |             return i
797 |         }
798 |     }
799 | 
800 |     if upvalueCount^ == U8_MAX {
801 |         error("Too many closure variables in function.")
802 |         return 0
803 |     }
804 | 
805 |     compiler.upvalues[upvalueCount^].isLocal = isLocal
806 |     compiler.upvalues[upvalueCount^].index = index
807 |     upvalueCount^ += 1
808 |     return upvalueCount^
809 | }
810 | 
811 | resolveUpvalue :: proc(compiler: ^Compiler, name: Token) -> int {
812 |     if compiler.enclosing == nil { return -1 }
813 | 
814 |     local := resolveLocal(compiler.enclosing, name)
815 |     if local != -1 {
816 |         compiler.enclosing.locals[local].isCaptured = true
817 |         return addUpvalue(compiler, u8(local), true)
818 |     }
819 | 
820 |     upvalue := resolveUpvalue(compiler.enclosing, name)
821 |     if upvalue != -1 {
822 |         return addUpvalue(compiler, u8(upvalue), false)
823 |     }
824 | 
825 |     return -1
826 | }
827 | 
828 | addLocal :: proc(name: Token) {
829 |     if current.localCount == U8_MAX + 1 {
830 |         error("Too many local variables in function.")
831 |         return
832 |     }
833 | 
834 |     local := &current.locals[current.localCount]
835 |     current.localCount += 1
836 |     local.name = name
837 |     local.depth = -1
838 | }
839 | 
840 | declareVariable :: proc() {
841 |     if current.scopeDepth == 0 { return }
842 | 
843 |     name := &parser.previous
844 |     for i := current.localCount-1; i >= 0; i -=1 {
845 |         local := &current.locals[i]
846 |         if local.depth != -1 && local.depth < current.scopeDepth {
847 |             break
848 |         }
849 | 
850 |         if identifiersEqual(name^, local.name) {
851 |             error("Already a variable with this name in this scope.")
852 |         }
853 |     }
854 |     addLocal(name^)
855 | }
856 | 
857 | parseVariable :: proc(errorMessage: string) -> u8 {
858 |     consume(.IDENTIFIER, errorMessage)
859 | 
860 |     declareVariable()
861 |     if current.scopeDepth > 0 { return 0 }
862 |     return identifierConstant(parser.previous)
863 | }
864 | 
865 | markInitialized :: proc() {
866 |     if current.scopeDepth == 0 { return }
867 |     current.locals[current.localCount-1].depth = current.scopeDepth
868 | }
869 | 
870 | defineVariable :: proc(global: u8) {
871 |     if current.scopeDepth > 0 {
872 |         markInitialized()
873 |         return
874 |     }
875 | 
876 |     emitBytes(OpCode.DEFINE_GLOBAL, global)
877 | }
878 | 
879 | argumentList :: proc() -> u8 {
880 |     argCount: u8 = 0
881 |     if !check(.RIGHT_PAREN) {
882 |         for {
883 |             expression()
884 |             if argCount == 255 {
885 |                 error("Can't have more than 255 arguments.")
886 |             }
887 |             argCount += 1
888 |             if !match(.COMMA) { break }
889 |         }
890 |     }
891 |     consume(.RIGHT_PAREN, "Expect ')' after arguments.")
892 |     return argCount
893 | }
894 | 
895 | and_ :: proc(canAssign: bool) {
896 |     endJump := emitJump(.JUMP_IF_FALSE)
897 | 
898 |     emitByte(OpCode.POP)
899 |     parsePrecedence(.AND)
900 | 
901 |     patchJump(endJump)
902 | }
903 | 
904 | getRule :: proc(type: TokenType) -> ParseRule {
905 |     return rules[type]
906 | }
907 | 
908 | errorAtCurrent :: proc(message: string) {
909 | 	errorAt(parser.current, message)
910 | }
911 | 
912 | error :: proc(message: string) {
913 |     errorAt(parser.previous, message)
914 | }
915 | 
916 | errorAt :: proc(token: Token, message: string) {
917 |     if parser.panicMode { return }
918 |     parser.panicMode = true
919 |     log.errorf("[line %v] Error", token.line)
920 | 
921 |     if token.type == .EOF {
922 |         log.errorf(" at end")
923 |     } else if token.type == .ERROR {
924 |         // Nothing
925 |     } else {
926 |         log.errorf(" at '%v'", token.value)
927 |     }
928 | 
929 |     log.errorf(": %v\n", message)
930 |     parser.hadError = true
931 | }


--------------------------------------------------------------------------------