├── .gitignore
├── src
    ├── tests.zig
    ├── common.zig
    ├── chunk.zig
    ├── table.zig
    ├── debug.zig
    ├── scanner.zig
    ├── value.zig
    ├── memory.zig
    ├── main.zig
    ├── object.zig
    ├── vm.zig
    └── compiler.zig
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | .vscode
2 | zig-cache
3 | zig-out
4 | scripts/


--------------------------------------------------------------------------------
/src/tests.zig:
--------------------------------------------------------------------------------
1 | const main = @import("./main.zig");
2 | const std = @import("std");
3 | 
4 | test {
5 |     std.testing.refAllDecls(@This());
6 | }
7 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ZLox
 2 | 
 3 | A stack-based bytecode Virtual Machine for the [Lox Programming Language](https://craftinginterpreters.com/the-lox-language.html) written in [Zig](https://ziglang.org/).
 4 | 
 5 | ## Run
 6 | 
 7 | Start REPL:  
 8 | ```bash
 9 | $ zig build run
10 | > print 1+1;
11 | 2
12 | >
13 | ```
14 | 
15 | ## Test
16 | 
17 | ```bash
18 | $ zig build test
19 | All tests passed.
20 | ```
21 | 
22 | ## Troubleshoot
23 | 
24 | Enable tracing:  
25 | ```bash
26 | $ zig build -Denable-tracing
27 | ```
28 | 
29 | Enable disassembly:  
30 | ```bash
31 | $ zig build -Denable-dump
32 | ```
33 | 
34 | For more build options use `zig build --help`


--------------------------------------------------------------------------------
/src/common.zig:
--------------------------------------------------------------------------------
 1 | const Value = @import("./value.zig").Value;
 2 | const std = @import("std");
 3 | const builtin = @import("builtin");
 4 | pub const alloc = if (builtin.mode == std.builtin.Mode.Debug) std.testing.allocator else std.heap.c_allocator;
 5 | pub const trace_enabled = @import("build_options").trace_enable;
 6 | pub const dump_enabled = @import("build_options").dump_code;
 7 | pub const stress_gc = @import("build_options").stress_gc;
 8 | pub const log_gc = @import("build_options").log_gc;
 9 | pub const nan_boxing = @import("build_options").nan_boxing;
10 | pub const gc_heap_growth_factor = 2;
11 | pub const stdout = if (builtin.is_test) buffer_stream.writer() else std.io.getStdOut().writer();
12 | pub const stderr = std.io.getStdErr().writer();
13 | 
14 | pub var buffer: if (builtin.is_test) [1 << 10 << 10]u8 else [0]u8 = if (builtin.is_test) .{0} ** (1 << 10 << 10) else .{};
15 | pub var buffer_stream = if (builtin.is_test) std.io.fixedBufferStream(buffer[0..]) else @compileError("only used for testing");
16 | 
17 | pub fn add(a: f64, b: f64) Value {
18 |     return Value.Number(a + b);
19 | }
20 | 
21 | pub fn sub(a: f64, b: f64) Value {
22 |     return Value.Number(a - b);
23 | }
24 | 
25 | pub fn mul(a: f64, b: f64) Value {
26 |     return Value.Number(a * b);
27 | }
28 | 
29 | pub fn div(a: f64, b: f64) Value {
30 |     return Value.Number(a / b);
31 | }
32 | 
33 | pub fn greater(a: f64, b: f64) Value {
34 |     return Value.Boolean(a > b);
35 | }
36 | 
37 | pub fn less(a: f64, b: f64) Value {
38 |     return Value.Boolean(a < b);
39 | }
40 | 
41 | pub inline fn growCapacity(old_c: anytype) @TypeOf(old_c) {
42 |     return if (old_c < 8) 8 else old_c * 2;
43 | }
44 | 


--------------------------------------------------------------------------------
/src/chunk.zig:
--------------------------------------------------------------------------------
 1 | const std = @import("std");
 2 | const memory = @import("./memory.zig");
 3 | const common = @import("./common.zig");
 4 | const ValueArray = @import("./value.zig").ValueArray;
 5 | const Value = @import("./value.zig").Value;
 6 | 
 7 | pub const OpCode = enum(u8) {
 8 |     op_constant, // arg 1: constant index
 9 |     op_nil,
10 |     op_true,
11 |     op_false,
12 |     op_pop,
13 |     op_get_local,
14 |     op_get_global,
15 |     op_get_upvalue,
16 |     op_define_global,
17 |     op_set_local,
18 |     op_set_global,
19 |     op_set_upvalue,
20 |     op_get_property,
21 |     op_set_property,
22 |     op_equal,
23 |     op_greater,
24 |     op_less,
25 |     op_add,
26 |     op_subtract,
27 |     op_multiply,
28 |     op_divide,
29 |     op_not,
30 |     op_negate,
31 |     op_print,
32 |     op_jump,
33 |     op_jump_if_false,
34 |     op_loop,
35 |     op_call,
36 |     op_invoke,
37 |     op_super_invoke,
38 |     op_closure,
39 |     op_close_upvalue,
40 |     op_return,
41 |     op_class,
42 |     op_inherit,
43 |     op_get_super,
44 |     op_method,
45 | };
46 | 
47 | pub const Chunk = struct {
48 |     allocator: std.mem.Allocator,
49 |     count: u32 = 0,
50 |     capacity: u32 = 0,
51 |     code: [*]u8 = undefined,
52 |     constants: ValueArray,
53 |     lines: [*]u32 = undefined,
54 | 
55 |     pub fn init(allocator: std.mem.Allocator) Chunk {
56 |         return .{
57 |             .allocator = allocator,
58 |             .constants = ValueArray.init(allocator),
59 |         };
60 |     }
61 | 
62 |     pub fn writeChunk(self: *Chunk, byte: u8, line: u32) void {
63 |         if (self.capacity <= self.count) {
64 |             const old_c = self.capacity;
65 |             self.capacity = common.growCapacity(old_c);
66 |             self.code = memory.growArray(u8, self.code, old_c, self.capacity);
67 |             self.lines = memory.growArray(u32, self.lines, old_c, self.capacity);
68 |         }
69 |         self.code[self.count] = byte;
70 |         self.lines[self.count] = line;
71 |         self.count += 1;
72 |     }
73 | 
74 |     pub fn addConstant(self: *Chunk, value: Value) u32 {
75 |         memory.vm.push(value);
76 |         self.constants.writeValueArray(value);
77 |         _ = memory.vm.pop();
78 |         return @intCast(u32, self.constants.count - 1);
79 |     }
80 | 
81 |     pub fn freeChunk(self: *Chunk) void {
82 |         memory.freeArray(u8, self.code, self.capacity);
83 |         memory.freeArray(u32, self.lines, self.capacity);
84 |         self.count = 0;
85 |         self.capacity = 0;
86 |         self.code = undefined;
87 |         self.constants.freeValueArray();
88 |     }
89 | };
90 | 


--------------------------------------------------------------------------------
/src/table.zig:
--------------------------------------------------------------------------------
  1 | const std = @import("std");
  2 | const memory = @import("./memory.zig");
  3 | const common = @import("./common.zig");
  4 | const Value = @import("./value.zig").Value;
  5 | const object = @import("./object.zig");
  6 | const ObjString = object.ObjString;
  7 | const Obj = object.Obj;
  8 | 
  9 | const alloc = @import("./common.zig").alloc;
 10 | 
 11 | pub const Table = struct {
 12 |     const Self = @This();
 13 |     const max_load = 0.75;
 14 | 
 15 |     count: usize = 0,
 16 |     capacity: usize = 0,
 17 |     entries: [*]Entry = undefined,
 18 | 
 19 |     pub fn initTable() Self {
 20 |         return .{};
 21 |     }
 22 | 
 23 |     pub fn freeTable(self: *Self) void {
 24 |         memory.freeArray(Entry, self.entries, self.capacity);
 25 |         self.capacity = 0;
 26 |         self.count = 0;
 27 |     }
 28 | 
 29 |     pub fn tableSet(self: *Self, key: *ObjString, value: Value) bool {
 30 |         if (self.count + 1 > @floatToInt(usize, @intToFloat(f32, self.capacity) * max_load)) {
 31 |             const capacity = common.growCapacity(self.capacity);
 32 |             self.adjustCapacity(capacity);
 33 |         }
 34 |         const entry = findEntry(self.entries, self.capacity, key);
 35 |         const isNewKey = entry.key == null;
 36 |         if (isNewKey and entry.value.isNil()) self.count += 1;
 37 | 
 38 |         entry.key = key;
 39 |         entry.value = value;
 40 |         return isNewKey;
 41 |     }
 42 | 
 43 |     pub fn tableGet(self: *Self, key: *ObjString) ?Value {
 44 |         if (self.count == 0) return null;
 45 | 
 46 |         const entry = findEntry(self.entries, self.capacity, key);
 47 |         if (entry.key == null) return null;
 48 | 
 49 |         return entry.value;
 50 |     }
 51 | 
 52 |     pub fn tableDelete(self: *Self, key: *ObjString) bool {
 53 |         if (self.count == 0) return false;
 54 | 
 55 |         const entry = findEntry(self.entries, self.capacity, key);
 56 |         if (entry.key == null) return false;
 57 | 
 58 |         entry.key = null;
 59 |         entry.value = Value.Boolean(true);
 60 |         return true;
 61 |     }
 62 | 
 63 |     pub fn findString(self: *Self, chars: [*]const u8, length: usize, hash: u32) ?*ObjString {
 64 |         if (self.count == 0) return null;
 65 | 
 66 |         var index = hash & (self.capacity - 1);
 67 |         while (true) {
 68 |             const entry = &self.entries[index];
 69 |             if (entry.key == null) {
 70 |                 if (entry.value.isNil()) return null;
 71 |             } else if (entry.key.?.hash == hash and std.mem.eql(u8, entry.key.?.chars[0..length], chars[0..length])) {
 72 |                 return entry.key;
 73 |             }
 74 |             index = (index + 1) & (self.capacity - 1);
 75 |         }
 76 |     }
 77 | 
 78 |     pub fn removeWhite(self: *Self) void {
 79 |         for (self.entries[0..self.capacity]) |*entry| {
 80 |             if (entry.key) |key| {
 81 |                 if (!key.obj.is_marked) {
 82 |                     _ = self.tableDelete(key);
 83 |                 }
 84 |             }
 85 |         }
 86 |     }
 87 | 
 88 |     pub fn markTable(self: *Self) void {
 89 |         for (self.entries[0..self.capacity]) |*entry| {
 90 |             memory.markObject(@ptrCast(?*Obj, entry.key));
 91 |             memory.markValue(&entry.value);
 92 |         }
 93 |     }
 94 | 
 95 |     pub fn tableAddAll(to: *Self, from: *Self) void {
 96 |         for (from.entries[0..from.capacity]) |entry| {
 97 |             if (entry.key) |key| {
 98 |                 _ = to.tableSet(key, entry.value);
 99 |             }
100 |         }
101 |     }
102 | 
103 |     fn adjustCapacity(self: *Self, capacity: usize) void {
104 |         const entries = memory.allocate(Entry, capacity);
105 |         for (entries[0..capacity]) |*entry| {
106 |             entry.key = null;
107 |             entry.value = Value.Nil();
108 |         }
109 | 
110 |         self.count = 0;
111 |         for (self.entries[0..self.capacity]) |*entry| {
112 |             if (entry.key == null) continue;
113 |             const dest = findEntry(entries, capacity, entry.key.?);
114 |             dest.key = entry.key;
115 |             dest.value = entry.value;
116 |             self.count += 1;
117 |         }
118 |         memory.freeArray(Entry, self.entries, self.capacity);
119 | 
120 |         self.entries = entries;
121 |         self.capacity = capacity;
122 |     }
123 | };
124 | 
125 | const Entry = struct {
126 |     key: ?*ObjString,
127 |     value: Value,
128 | };
129 | 
130 | fn findEntry(entries: [*]Entry, capacity: usize, key: *ObjString) *Entry {
131 |     var index = key.hash & (capacity - 1);
132 |     var tombstone: ?*Entry = null;
133 |     while (true) {
134 |         const entry = &entries[index];
135 |         if (entry.key == null) {
136 |             if (entry.value.isNil()) {
137 |                 return tombstone orelse entry;
138 |             } else {
139 |                 if (tombstone == null) tombstone = entry;
140 |             }
141 |         } else if (entry.key == key) return entry;
142 |         index = (index + 1) & (capacity - 1);
143 |     }
144 | }
145 | 


--------------------------------------------------------------------------------
/src/debug.zig:
--------------------------------------------------------------------------------
  1 | const chunk = @import("./chunk.zig");
  2 | const std = @import("std");
  3 | const value = @import("./value.zig");
  4 | const common = @import("./common.zig");
  5 | 
  6 | const stdout = common.stdout;
  7 | 
  8 | pub fn disassembleChunk(c: *chunk.Chunk, name: []const u8) void {
  9 |     stdout.print("== {s} ==\n", .{name}) catch unreachable;
 10 |     var offset: u32 = 0;
 11 |     while (offset < c.count) {
 12 |         offset = disassembleInstruction(c, offset);
 13 |     }
 14 | }
 15 | 
 16 | pub fn disassembleInstruction(c: *chunk.Chunk, offset: u32) u32 {
 17 |     stdout.print("{d:0>4} ", .{offset}) catch unreachable;
 18 |     if (offset > 0 and c.lines[offset] == c.lines[offset - 1]) {
 19 |         stdout.print("   | ", .{}) catch unreachable;
 20 |     } else {
 21 |         stdout.print("{d:4} ", .{c.lines[offset]}) catch unreachable;
 22 |     }
 23 |     const instruction = c.code[offset];
 24 |     return switch (@intToEnum(chunk.OpCode, instruction)) {
 25 |         .op_return => simpleInstruction("OP_RETURN", offset),
 26 |         .op_constant => constantInstruction("OP_CONSTANT", c, offset),
 27 |         .op_not => simpleInstruction("OP_NOT", offset),
 28 |         .op_negate => simpleInstruction("OP_NEGATE", offset),
 29 |         .op_add => simpleInstruction("OP_ADD", offset),
 30 |         .op_subtract => simpleInstruction("OP_SUBTRACT", offset),
 31 |         .op_multiply => simpleInstruction("OP_MULTIPLY", offset),
 32 |         .op_divide => simpleInstruction("OP_DIVIDE", offset),
 33 |         .op_nil => simpleInstruction("OP_NIL", offset),
 34 |         .op_true => simpleInstruction("OP_TRUE", offset),
 35 |         .op_false => simpleInstruction("OP_FALSE", offset),
 36 |         .op_equal => simpleInstruction("OP_EQUAL", offset),
 37 |         .op_greater => simpleInstruction("OP_GREATER", offset),
 38 |         .op_less => simpleInstruction("OP_LESS", offset),
 39 |         .op_print => simpleInstruction("OP_PRINT", offset),
 40 |         .op_pop => simpleInstruction("OP_POP", offset),
 41 |         .op_define_global => constantInstruction("OP_DEFINE_GLOBAL", c, offset),
 42 |         .op_get_global => constantInstruction("OP_GET_GLOBAL", c, offset),
 43 |         .op_set_global => constantInstruction("OP_SET_GLOBAL", c, offset),
 44 |         .op_get_local => byteInstruction("OP_GET_LOCAL", c, offset),
 45 |         .op_set_local => byteInstruction("OP_SET_LOCAL", c, offset),
 46 |         .op_jump => jumpInstruction("OP_JUMP", 1, c, offset),
 47 |         .op_jump_if_false => jumpInstruction("OP_JUMP_IF_FALSE", 1, c, offset),
 48 |         .op_loop => jumpInstruction("OP_LOOP", -1, c, offset),
 49 |         .op_call => byteInstruction("OP_CALL", c, offset),
 50 |         .op_get_upvalue => byteInstruction("OP_GET_UPVALUE", c, offset),
 51 |         .op_set_upvalue => byteInstruction("OP_SET_UPVALUE", c, offset),
 52 |         .op_close_upvalue => simpleInstruction("OP_CLOSE_UPVALUE", offset),
 53 |         .op_closure => blk: {
 54 |             var offset_t = offset;
 55 |             offset_t += 1;
 56 |             const con = c.code[offset_t];
 57 |             offset_t += 1;
 58 |             stdout.print("{s:<16} {d:4} ", .{ "OP_CLOSURE", con }) catch unreachable;
 59 |             value.printValue(c.constants.values[con], stdout);
 60 |             stdout.print("\n", .{}) catch unreachable;
 61 |             const function = c.constants.values[con].asObject().asFunction();
 62 |             var i: usize = 0;
 63 |             while (i < function.upvalue_count) : (i += 1) {
 64 |                 const is_local = c.code[offset_t];
 65 |                 offset_t += 1;
 66 |                 const index = c.code[offset_t];
 67 |                 offset_t += 1;
 68 |                 const name: []const u8 = if (is_local == 1) "local" else "upvalue";
 69 |                 stdout.print("{d:0>4}      |                     {s} {d}\n", .{ offset_t - 2, name, index }) catch unreachable;
 70 |             }
 71 |             break :blk offset_t;
 72 |         },
 73 |         .op_class => constantInstruction("OP_CLASS", c, offset),
 74 |         .op_get_property => constantInstruction("OP_GET_PROPERTY", c, offset),
 75 |         .op_set_property => constantInstruction("OP_SET_PROPERTY", c, offset),
 76 |         .op_method => constantInstruction("OP_METHOD", c, offset),
 77 |         .op_invoke => invokeInstruction("OP_INVOKE", c, offset),
 78 |         .op_inherit => simpleInstruction("OP_INHERIT", offset),
 79 |         .op_get_super => constantInstruction("OP_GET_SUPER", c, offset),
 80 |         .op_super_invoke => invokeInstruction("OP_SUPER_INVOKE", c, offset),
 81 |     };
 82 | }
 83 | 
 84 | fn simpleInstruction(name: []const u8, offset: u32) u32 {
 85 |     stdout.print("{s}\n", .{name}) catch unreachable;
 86 |     return offset + 1;
 87 | }
 88 | 
 89 | fn byteInstruction(name: []const u8, c: *chunk.Chunk, offset: u32) u32 {
 90 |     const slot = c.code[offset + 1];
 91 |     stdout.print("{s:<16} {d:4}\n", .{ name, slot }) catch unreachable;
 92 |     return offset + 2;
 93 | }
 94 | 
 95 | fn constantInstruction(name: []const u8, c: *chunk.Chunk, offset: u32) u32 {
 96 |     const index = c.code[offset + 1];
 97 |     stdout.print("{s:<16} {d:4} '", .{ name, index }) catch unreachable;
 98 |     value.printValue(c.constants.values[index], stdout);
 99 |     stdout.print("'\n", .{}) catch unreachable;
100 |     return offset + 2;
101 | }
102 | 
103 | fn jumpInstruction(name: []const u8, sign: isize, c: *chunk.Chunk, offset: u32) u32 {
104 |     var jump: u16 = c.code[offset + 1];
105 |     jump <<= 8;
106 |     jump |= c.code[offset + 2];
107 |     stdout.print("{s:<16} {d:4} -> {d}\n", .{ name, offset, offset + 3 + sign * jump }) catch unreachable;
108 |     return offset + 3;
109 | }
110 | 
111 | fn invokeInstruction(name: []const u8, c: *chunk.Chunk, offset: u32) u32 {
112 |     const constant = c.code[offset + 1];
113 |     const arg_count = c.code[offset + 2];
114 |     stdout.print("{s:<16} ({d} args) {d:4} ", .{ name, arg_count, constant }) catch unreachable;
115 |     value.printValue(c.constants.values[constant], stdout);
116 |     stdout.print("\n", .{}) catch unreachable;
117 |     return offset + 3;
118 | }
119 | 


--------------------------------------------------------------------------------
/src/scanner.zig:
--------------------------------------------------------------------------------
  1 | const std = @import("std");
  2 | 
  3 | pub const Token = struct {
  4 |     t: TokenType,
  5 |     start: [*]const u8,
  6 |     length: usize,
  7 |     line: usize,
  8 | };
  9 | 
 10 | pub const TokenType = enum(u8) {
 11 | 
 12 |     // single char
 13 |     left_paren,
 14 |     right_paren,
 15 |     left_brace,
 16 |     right_brace,
 17 |     comma,
 18 |     dot,
 19 |     minus,
 20 |     plus,
 21 |     semicolon,
 22 |     slash,
 23 |     star,
 24 |     // multi char
 25 |     bang,
 26 |     bang_equal,
 27 |     equal,
 28 |     equal_equal,
 29 |     greater,
 30 |     greater_equal,
 31 |     less,
 32 |     less_equal,
 33 |     // literals
 34 |     identifier,
 35 |     string,
 36 |     number,
 37 |     // keywords
 38 |     lox_and,
 39 |     lox_class,
 40 |     lox_else,
 41 |     lox_false,
 42 |     lox_for,
 43 |     lox_fun,
 44 |     lox_if,
 45 |     lox_nil,
 46 |     lox_or,
 47 |     lox_print,
 48 |     lox_return,
 49 |     lox_super,
 50 |     lox_this,
 51 |     lox_true,
 52 |     lox_var,
 53 |     lox_while,
 54 |     lox_error,
 55 |     lox_eof,
 56 | };
 57 | 
 58 | pub const Scanner = struct {
 59 |     start: [*]const u8,
 60 |     current: [*]const u8,
 61 |     line: usize = 1,
 62 | 
 63 |     const Self = @This();
 64 | 
 65 |     pub fn init(source: [:0]const u8) Self {
 66 |         return .{
 67 |             .start = source.ptr,
 68 |             .current = source.ptr,
 69 |         };
 70 |     }
 71 | 
 72 |     pub fn scanToken(self: *Self) Token {
 73 |         self.skipWhitespace();
 74 |         self.start = self.current;
 75 |         if (self.isAtEnd()) return self.makeToken(.lox_eof);
 76 | 
 77 |         const c = self.advance();
 78 |         if (isAlpha(c)) {
 79 |             return self.identifier();
 80 |         }
 81 |         if (std.ascii.isDigit(c)) {
 82 |             return self.number();
 83 |         }
 84 | 
 85 |         switch (c) {
 86 |             '(' => return self.makeToken(.left_paren),
 87 |             ')' => return self.makeToken(.right_paren),
 88 |             '{' => return self.makeToken(.left_brace),
 89 |             '}' => return self.makeToken(.right_brace),
 90 |             ';' => return self.makeToken(.semicolon),
 91 |             ',' => return self.makeToken(.comma),
 92 |             '.' => return self.makeToken(.dot),
 93 |             '-' => return self.makeToken(.minus),
 94 |             '+' => return self.makeToken(.plus),
 95 |             '/' => return self.makeToken(.slash),
 96 |             '*' => return self.makeToken(.star),
 97 | 
 98 |             '!' => return self.makeToken(if (self.match('=')) .bang_equal else .bang),
 99 |             '=' => return self.makeToken(if (self.match('=')) .equal_equal else .equal),
100 |             '<' => return self.makeToken(if (self.match('=')) .less_equal else .less),
101 |             '>' => return self.makeToken(if (self.match('=')) .greater_equal else .greater),
102 | 
103 |             '"' => return self.string(),
104 | 
105 |             else => return self.errorToken("Unexpected character."),
106 |         }
107 |     }
108 | 
109 |     fn identifier(self: *Self) Token {
110 |         while (isAlpha(self.peek()) or std.ascii.isDigit(self.peek())) _ = self.advance();
111 |         return self.makeToken(self.identifierType());
112 |     }
113 | 
114 |     fn number(self: *Self) Token {
115 |         while (std.ascii.isDigit(self.peek())) {
116 |             _ = self.advance();
117 |         }
118 | 
119 |         if (self.peek() == '.' and std.ascii.isDigit(self.peekNext())) {
120 |             _ = self.advance();
121 |             while (std.ascii.isDigit(self.peek())) {
122 |                 _ = self.advance();
123 |             }
124 |         }
125 | 
126 |         return self.makeToken(.number);
127 |     }
128 | 
129 |     fn string(self: *Self) Token {
130 |         while (self.peek() != '"' and !self.isAtEnd()) {
131 |             if (self.peek() == '\n') self.line += 1;
132 |             _ = self.advance();
133 |         }
134 |         if (self.isAtEnd()) {
135 |             return self.errorToken("Unterminated string.");
136 |         }
137 | 
138 |         // closing quote
139 |         _ = self.advance();
140 |         return self.makeToken(.string);
141 |     }
142 | 
143 |     fn identifierType(self: *Self) TokenType {
144 |         return switch (self.start[0]) {
145 |             'a' => self.checkKeyword(1, 2, "nd", .lox_and),
146 |             'c' => self.checkKeyword(1, 4, "lass", .lox_class),
147 |             'e' => self.checkKeyword(1, 3, "lse", .lox_else),
148 |             'f' => blk: {
149 |                 if (@ptrToInt(self.current) - @ptrToInt(self.start) > 1) {
150 |                     break :blk switch (self.start[1]) {
151 |                         'a' => self.checkKeyword(2, 3, "lse", .lox_false),
152 |                         'o' => self.checkKeyword(2, 1, "r", .lox_for),
153 |                         'u' => self.checkKeyword(2, 1, "n", .lox_fun),
154 |                         else => .identifier,
155 |                     };
156 |                 } else break :blk .identifier;
157 |             },
158 |             't' => blk: {
159 |                 if (@ptrToInt(self.current) - @ptrToInt(self.start) > 1) {
160 |                     break :blk switch (self.start[1]) {
161 |                         'h' => self.checkKeyword(2, 2, "is", .lox_this),
162 |                         'r' => self.checkKeyword(2, 2, "ue", .lox_true),
163 |                         else => .identifier,
164 |                     };
165 |                 } else break :blk .identifier;
166 |             },
167 |             'i' => self.checkKeyword(1, 1, "f", .lox_if),
168 |             'n' => self.checkKeyword(1, 2, "il", .lox_nil),
169 |             'o' => self.checkKeyword(1, 1, "r", .lox_or),
170 |             'p' => self.checkKeyword(1, 4, "rint", .lox_print),
171 |             'r' => self.checkKeyword(1, 5, "eturn", .lox_return),
172 |             's' => self.checkKeyword(1, 4, "uper", .lox_super),
173 |             'v' => self.checkKeyword(1, 2, "ar", .lox_var),
174 |             'w' => self.checkKeyword(1, 4, "hile", .lox_while),
175 |             else => .identifier,
176 |         };
177 |     }
178 | 
179 |     inline fn isAlpha(char: u8) bool {
180 |         return std.ascii.isAlpha(char) or char == '_';
181 |     }
182 | 
183 |     inline fn checkKeyword(self: *Self, comptime start: comptime_int, comptime length: comptime_int, rest: [:0]const u8, t: TokenType) TokenType {
184 |         if (@ptrToInt(self.current) - @ptrToInt(self.start) == start + length and
185 |             std.mem.eql(u8, (self.start + start)[0..length], rest[0..length]))
186 |         {
187 |             return t;
188 |         }
189 |         return .identifier;
190 |     }
191 | 
192 |     fn isAtEnd(self: *Self) bool {
193 |         return self.current[0] == 0;
194 |     }
195 | 
196 |     fn advance(self: *Self) u8 {
197 |         defer self.current += 1;
198 |         return self.current[0];
199 |     }
200 | 
201 |     fn skipWhitespace(self: *Self) void {
202 |         while (true) {
203 |             const c = self.peek();
204 |             switch (c) {
205 |                 ' ', '\r', '\t' => _ = self.advance(),
206 |                 '\n' => {
207 |                     self.line += 1;
208 |                     _ = self.advance();
209 |                 },
210 |                 '/' => {
211 |                     if (self.peekNext() == '/') {
212 |                         while (self.peek() != '\n' and !self.isAtEnd()) {
213 |                             _ = self.advance();
214 |                         }
215 |                     } else return;
216 |                 },
217 |                 else => return,
218 |             }
219 |         }
220 |     }
221 | 
222 |     fn peek(self: *Self) u8 {
223 |         return self.current[0];
224 |     }
225 | 
226 |     fn peekNext(self: *Self) u8 {
227 |         if (self.isAtEnd()) return 0;
228 |         return self.current[1];
229 |     }
230 | 
231 |     fn match(self: *Self, char: u8) bool {
232 |         if (self.isAtEnd()) return false;
233 |         if (self.current[0] != char) return false;
234 |         self.current += 1;
235 |         return true;
236 |     }
237 | 
238 |     fn makeToken(self: *Self, t: TokenType) Token {
239 |         return .{
240 |             .t = t,
241 |             .start = self.start,
242 |             .length = @ptrToInt(self.current) - @ptrToInt(self.start),
243 |             .line = self.line,
244 |         };
245 |     }
246 | 
247 |     fn errorToken(self: *Self, message: []const u8) Token {
248 |         return .{
249 |             .t = .lox_error,
250 |             .start = message.ptr,
251 |             .length = message.len,
252 |             .line = self.line,
253 |         };
254 |     }
255 | };
256 | 


--------------------------------------------------------------------------------
/src/value.zig:
--------------------------------------------------------------------------------
  1 | const std = @import("std");
  2 | const memory = @import("./memory.zig");
  3 | const object = @import("./object.zig");
  4 | const common = @import("./common.zig");
  5 | const Obj = object.Obj;
  6 | 
  7 | pub const ValueType = enum {
  8 |     val_bool,
  9 |     val_nil,
 10 |     val_number,
 11 |     val_obj,
 12 | };
 13 | 
 14 | const ensureSize = blk: {
 15 |     if (common.nan_boxing) {
 16 |         if (@sizeOf(Value) > @sizeOf(u64)) {
 17 |             @compileError("Expected Value to be 8 byte large with NaN boxing.");
 18 |         }
 19 |     }
 20 |     break :blk undefined;
 21 | };
 22 | 
 23 | pub const Value = if (common.nan_boxing)
 24 |     struct {
 25 |         const QNAN = 0x7ffc << 48;
 26 |         const SIGN_BIT = 1 << 63;
 27 |         const TAG_NIL = 1;
 28 |         const TAG_FALSE = 2;
 29 |         const TAG_TRUE = 3;
 30 |         v: u64,
 31 |         pub inline fn Boolean(value: bool) Value {
 32 |             const tag: u64 = if (value) TAG_TRUE else TAG_FALSE;
 33 |             return .{ .v = QNAN | tag };
 34 |         }
 35 |         pub inline fn Nil() Value {
 36 |             return .{ .v = QNAN | TAG_NIL };
 37 |         }
 38 |         pub inline fn Number(value: f64) Value {
 39 |             return .{ .v = @bitCast(u64, value) };
 40 |         }
 41 |         pub inline fn Object(obj: *Obj) Value {
 42 |             return .{ .v = SIGN_BIT | QNAN | @ptrToInt(obj) };
 43 |         }
 44 | 
 45 |         pub inline fn asBoolean(self: *const Value) bool {
 46 |             return self.v == QNAN | TAG_TRUE;
 47 |         }
 48 |         pub inline fn asObject(self: *const Value) *Obj {
 49 |             return @intToPtr(*Obj, self.v & ~(@intCast(u64, (SIGN_BIT | QNAN))));
 50 |         }
 51 |         pub inline fn asNumber(self: *const Value) f64 {
 52 |             return @bitCast(f64, self.v);
 53 |         }
 54 | 
 55 |         pub inline fn isBool(self: *const Value) bool {
 56 |             return self.v | 1 == QNAN | TAG_TRUE;
 57 |         }
 58 |         pub inline fn isNumber(self: *const Value) bool {
 59 |             return self.v & QNAN != QNAN;
 60 |         }
 61 |         pub inline fn isNil(self: *const Value) bool {
 62 |             return self.v == QNAN | TAG_NIL;
 63 |         }
 64 |         pub inline fn isObject(self: *const Value) bool {
 65 |             return self.v & (QNAN | SIGN_BIT) == (QNAN | SIGN_BIT);
 66 |         }
 67 |         pub inline fn isString(self: *const Value) bool {
 68 |             if (!self.isObject()) return false;
 69 |             return self.asObject().t == .obj_string;
 70 |         }
 71 |         pub inline fn isFunction(self: *const Value) bool {
 72 |             if (!self.isObject()) return false;
 73 |             return self.asObject().t == .obj_function;
 74 |         }
 75 |         pub inline fn isClass(self: *const Value) bool {
 76 |             if (!self.isObject()) return false;
 77 |             return self.asObject().t == .obj_class;
 78 |         }
 79 |         pub inline fn isInstance(self: *const Value) bool {
 80 |             if (!self.isObject()) return false;
 81 |             return self.asObject().t == .obj_instance;
 82 |         }
 83 |         pub inline fn isBoundMethod(self: *const Value) bool {
 84 |             if (!self.isObject()) return false;
 85 |             return self.asObject().t == .obj_bound_method;
 86 |         }
 87 |     }
 88 | else
 89 |     struct {
 90 |         t: ValueType,
 91 |         as: union {
 92 |             boolean: bool,
 93 |             number: f64,
 94 |             obj: *Obj,
 95 |         },
 96 | 
 97 |         pub inline fn Boolean(value: bool) Value {
 98 |             return .{ .t = .val_bool, .as = .{
 99 |                 .boolean = value,
100 |             } };
101 |         }
102 |         pub inline fn Nil() Value {
103 |             return .{ .t = .val_nil, .as = .{
104 |                 .number = 0,
105 |             } };
106 |         }
107 |         pub inline fn Number(value: f64) Value {
108 |             return .{ .t = .val_number, .as = .{
109 |                 .number = value,
110 |             } };
111 |         }
112 |         pub inline fn Object(obj: *Obj) Value {
113 |             return .{ .t = .val_obj, .as = .{
114 |                 .obj = obj,
115 |             } };
116 |         }
117 | 
118 |         pub inline fn asBoolean(self: *const Value) bool {
119 |             return self.as.boolean;
120 |         }
121 |         pub inline fn asObject(self: *const Value) *Obj {
122 |             return self.as.obj;
123 |         }
124 |         pub inline fn asNumber(self: *const Value) f64 {
125 |             return self.as.number;
126 |         }
127 | 
128 |         pub inline fn isBool(self: *const Value) bool {
129 |             return self.t == .val_bool;
130 |         }
131 |         pub inline fn isNumber(self: *const Value) bool {
132 |             return self.t == .val_number;
133 |         }
134 |         pub inline fn isNil(self: *const Value) bool {
135 |             return self.t == .val_nil;
136 |         }
137 |         pub inline fn isObject(self: *const Value) bool {
138 |             return self.t == .val_obj;
139 |         }
140 |         pub inline fn isString(self: *const Value) bool {
141 |             if (!self.isObject()) return false;
142 |             return self.asObject().t == .obj_string;
143 |         }
144 |         pub inline fn isFunction(self: *const Value) bool {
145 |             if (!self.isObject()) return false;
146 |             return self.asObject().t == .obj_function;
147 |         }
148 |         pub inline fn isClass(self: *const Value) bool {
149 |             if (!self.isObject()) return false;
150 |             return self.asObject().t == .obj_class;
151 |         }
152 |         pub inline fn isInstance(self: *const Value) bool {
153 |             if (!self.isObject()) return false;
154 |             return self.asObject().t == .obj_instance;
155 |         }
156 |         pub inline fn isBoundMethod(self: *const Value) bool {
157 |             if (!self.isObject()) return false;
158 |             return self.asObject().t == .obj_bound_method;
159 |         }
160 |     };
161 | 
162 | pub fn printValue(v: Value, writer: anytype) void {
163 |     if (common.nan_boxing) {
164 |         if (v.isBool()) {
165 |             (if (v.asBoolean()) writer.print("true", .{}) else writer.print("false", .{})) catch unreachable;
166 |         }
167 |         if (v.isNil()) {
168 |             writer.print("nil", .{}) catch unreachable;
169 |         }
170 |         if (v.isNumber()) {
171 |             writer.print("{d}", .{v.asNumber()}) catch unreachable;
172 |         }
173 |         if (v.isObject()) {
174 |             v.asObject().print(writer);
175 |         }
176 |     } else {
177 |         switch (v.t) {
178 |             .val_bool => (if (v.asBoolean()) writer.print("true", .{}) else writer.print("false", .{})) catch unreachable,
179 |             .val_nil => writer.print("nil", .{}) catch unreachable,
180 |             .val_number => writer.print("{d}", .{v.as.number}) catch unreachable,
181 |             .val_obj => v.as.obj.print(writer),
182 |         }
183 |     }
184 | }
185 | 
186 | pub fn valuesEqual(val1: Value, val2: Value) bool {
187 |     if (common.nan_boxing) {
188 |         if (val1.isNumber() and val2.isNumber()) {
189 |             return val1.asNumber() == val2.asNumber();
190 |         }
191 |         return val1.v == val2.v;
192 |     } else {
193 |         if (val1.t != val2.t) return false;
194 |         switch (val1.t) {
195 |             .val_bool => return val1.asBoolean() == val2.asBoolean(),
196 |             .val_nil => return true,
197 |             .val_number => return val1.asNumber() == val2.asNumber(),
198 |             .val_obj => return val1.asObject() == val2.asObject(),
199 |         }
200 |     }
201 | }
202 | 
203 | pub const ValueArray = struct {
204 |     allocator: std.mem.Allocator,
205 |     capacity: u32 = 0,
206 |     count: u32 = 0,
207 |     values: [*]Value = undefined,
208 | 
209 |     pub fn init(allocator: std.mem.Allocator) ValueArray {
210 |         return .{
211 |             .allocator = allocator,
212 |         };
213 |     }
214 | 
215 |     pub fn writeValueArray(self: *ValueArray, value: Value) void {
216 |         if (self.capacity <= self.count) {
217 |             const old_c = self.capacity;
218 |             self.capacity = if (old_c < 8) 8 else old_c * 2;
219 |             self.values = memory.growArray(Value, self.values, old_c, self.capacity);
220 |         }
221 |         self.values[self.count] = value;
222 |         self.count += 1;
223 |     }
224 | 
225 |     pub fn freeValueArray(self: *ValueArray) void {
226 |         memory.freeArray(Value, self.values, self.capacity);
227 |         self.count = 0;
228 |         self.capacity = 0;
229 |         self.values = undefined;
230 |     }
231 | };
232 | 
233 | test "refAllDecls" {
234 |     const file = @import("./value.zig");
235 |     std.testing.refAllDecls(file);
236 | }
237 | 


--------------------------------------------------------------------------------
/src/memory.zig:
--------------------------------------------------------------------------------
  1 | const std = @import("std");
  2 | const object = @import("./object.zig");
  3 | const compiler = @import("./compiler.zig");
  4 | const common = @import("./common.zig");
  5 | const value = @import("./value.zig");
  6 | const VM = @import("./vm.zig").VM;
  7 | const Value = value.Value;
  8 | const ValueArray = value.ValueArray;
  9 | const Obj = object.Obj;
 10 | const ObjString = object.ObjString;
 11 | const ObjFunction = object.ObjFunction;
 12 | const ObjNative = object.ObjNative;
 13 | const ObjClosure = object.ObjClosure;
 14 | const ObjUpvalue = object.ObjUpvalue;
 15 | const ObjClass = object.ObjClass;
 16 | const ObjInstance = object.ObjInstance;
 17 | const ObjBoundMethod = object.ObjBoundMethod;
 18 | 
 19 | // TODO remove alloc parameters
 20 | const alloc: std.mem.Allocator = common.alloc;
 21 | 
 22 | pub var vm: *VM = undefined;
 23 | 
 24 | pub fn initGC(_vm: *VM) void {
 25 |     vm = _vm;
 26 |     object.initGC(_vm);
 27 | }
 28 | 
 29 | pub fn growArray(comptime t: type, ptr: [*]t, old_cap: u32, new_cap: u32) [*]t {
 30 |     return reallocate(ptr, old_cap, new_cap) orelse ptr;
 31 | }
 32 | 
 33 | pub fn freeArray(comptime t: type, ptr: [*]t, old_count: usize) void {
 34 |     _ = reallocate(ptr, old_count, 0);
 35 |     return;
 36 | }
 37 | 
 38 | fn free(comptime t: type, ptr: *t) void {
 39 |     _ = reallocate(@ptrCast([*]t, ptr), 1, 0);
 40 |     return;
 41 | }
 42 | 
 43 | pub fn allocate(comptime t: type, count: usize) [*]t {
 44 |     if (count < 1) return undefined;
 45 |     var tmp: [*]t = undefined;
 46 |     return reallocate(tmp, 0, count).?;
 47 | }
 48 | 
 49 | pub fn reallocate(pointer: anytype, old_size: usize, new_size: usize) ?@TypeOf(pointer) {
 50 |     const info = @typeInfo(@TypeOf(pointer));
 51 |     if (info != .Pointer) {
 52 |         unreachable;
 53 |     }
 54 |     vm.bytes_allocated += @intCast(isize, new_size) - @intCast(isize, old_size);
 55 |     if (comptime common.stress_gc) {
 56 |         if (new_size > old_size) {
 57 |             collectGarbage();
 58 |         }
 59 |     }
 60 |     if (vm.bytes_allocated > vm.next_gc) {
 61 |         collectGarbage();
 62 |     }
 63 |     if (new_size == 0) {
 64 |         alloc.free(pointer[0..old_size]);
 65 |         return null;
 66 |     }
 67 |     if (old_size == 0) {
 68 |         return (alloc.alloc(info.Pointer.child, new_size) catch std.os.exit(1)).ptr;
 69 |     }
 70 |     return (alloc.realloc(pointer[0..old_size], new_size) catch std.os.exit(1)).ptr;
 71 | }
 72 | 
 73 | pub fn freeObjects() void {
 74 |     var obj = VM.objects;
 75 |     while (obj) |o| {
 76 |         const next = o.next;
 77 |         freeObject(o);
 78 |         obj = next;
 79 |     }
 80 |     VM.objects = null;
 81 | }
 82 | 
 83 | fn freeObject(o: *Obj) void {
 84 |     if (comptime common.log_gc) {
 85 |         const stdout = common.stdout;
 86 |         stdout.print("{*} free type {any}\n", .{ o, o.t }) catch unreachable;
 87 |     }
 88 | 
 89 |     switch (o.t) {
 90 |         .obj_string => {
 91 |             const str = o.asString();
 92 |             freeArray(u8, str.chars, str.length + 1);
 93 |             free(ObjString, str);
 94 |         },
 95 |         .obj_function => {
 96 |             const function = o.asFunction();
 97 |             function.chunk().freeChunk();
 98 |             free(ObjFunction, function);
 99 |         },
100 |         .obj_native => {
101 |             free(ObjNative, o.asNative());
102 |         },
103 |         .obj_closure => {
104 |             const closure = o.asClosure();
105 |             freeArray(?*ObjUpvalue, closure.upvalues, closure.upvalue_count);
106 |             free(ObjClosure, o.asClosure());
107 |         },
108 |         .obj_upvalue => {
109 |             free(ObjUpvalue, o.asUpvalue());
110 |         },
111 |         .obj_class => {
112 |             o.asClass().methods().freeTable();
113 |             free(ObjClass, o.asClass());
114 |         },
115 |         .obj_instance => {
116 |             const instance = o.asInstance();
117 |             instance.fields().freeTable();
118 |             free(ObjInstance, instance);
119 |         },
120 |         .obj_bound_method => {
121 |             free(ObjBoundMethod, o.asBoundMethod());
122 |         },
123 |     }
124 | }
125 | 
126 | fn collectGarbage() void {
127 |     if (comptime common.log_gc) {
128 |         const stdout = common.stdout;
129 |         stdout.print("-- gc begin\n", .{}) catch unreachable;
130 |     }
131 |     const before = vm.bytes_allocated;
132 | 
133 |     markRoots();
134 |     traceReferences();
135 |     VM.strings.removeWhite();
136 |     sweep();
137 |     vm.next_gc = vm.bytes_allocated * common.gc_heap_growth_factor;
138 | 
139 |     if (comptime common.log_gc) {
140 |         const stdout = common.stdout;
141 |         stdout.print("-- gc end\n", .{}) catch unreachable;
142 |         stdout.print("   collected {d} bytes (from {d} to {d}) next at {d}\n", .{ before - vm.bytes_allocated, before, vm.bytes_allocated, vm.next_gc }) catch unreachable;
143 |     }
144 | }
145 | 
146 | fn markRoots() void {
147 |     markObject(@ptrCast(*Obj, vm.init_string));
148 |     for (vm.stack) |*slot| {
149 |         markValue(slot);
150 |     }
151 |     for (vm.frames[0..vm.frame_count]) |frame| {
152 |         markObject(@ptrCast(*Obj, frame.closure));
153 |     }
154 |     var up_value = vm.open_upvalues;
155 |     while (up_value) |uval| : (up_value = uval.next) {
156 |         markObject(@ptrCast(*Obj, uval));
157 |     }
158 |     vm.globals.markTable();
159 |     compiler.markCompilerRoots();
160 | }
161 | 
162 | fn traceReferences() void {
163 |     while (vm.gray_count > 0) {
164 |         vm.gray_count -= 1;
165 |         var obj = vm.gray_stack[vm.gray_count];
166 |         blackenObject(obj);
167 |     }
168 | }
169 | 
170 | fn sweep() void {
171 |     var previous: ?*Obj = null;
172 |     var obj = VM.objects;
173 |     while (obj) |o| {
174 |         if (o.is_marked) {
175 |             o.is_marked = false;
176 |             previous = obj;
177 |             obj = o.next;
178 |         } else {
179 |             var unreached = o;
180 |             obj = o.next;
181 |             if (previous) |p| {
182 |                 p.next = obj;
183 |             } else {
184 |                 VM.objects = obj;
185 |             }
186 | 
187 |             freeObject(unreached);
188 |         }
189 |     }
190 | }
191 | 
192 | pub fn blackenObject(obj: *Obj) void {
193 |     if (comptime common.log_gc) {
194 |         const stdout = common.stdout;
195 |         stdout.print("{*} blacken ", .{obj}) catch unreachable;
196 |         value.printValue(Value.Object(obj), stdout);
197 |         stdout.print("\n", .{}) catch unreachable;
198 |     }
199 |     switch (obj.t) {
200 |         .obj_upvalue => {
201 |             markValue(obj.asUpvalue().closed());
202 |         },
203 |         .obj_function => {
204 |             var function = obj.asFunction();
205 |             markObject(@ptrCast(?*Obj, function.name));
206 |             markArray(&function.chunk().constants);
207 |         },
208 |         .obj_closure => {
209 |             var closure = obj.asClosure();
210 |             markObject(@ptrCast(*Obj, closure.function));
211 |             for (closure.upvalues[0..closure.upvalue_count]) |uv| {
212 |                 markObject(@ptrCast(?*Obj, uv));
213 |             }
214 |         },
215 |         .obj_instance => {
216 |             var instance = obj.asInstance();
217 |             markObject(@ptrCast(*Obj, instance.class));
218 |             instance.fields().markTable();
219 |         },
220 |         .obj_class => {
221 |             const class = obj.asClass();
222 |             markObject(@ptrCast(*Obj, class.name));
223 |             class.methods().markTable();
224 |         },
225 |         .obj_bound_method => {
226 |             const bound = obj.asBoundMethod();
227 |             markValue(bound.receiver());
228 |             markObject(@ptrCast(*Obj, bound.method));
229 |         },
230 |         .obj_native, .obj_string => {},
231 |     }
232 | }
233 | 
234 | pub fn markValue(slot: *Value) void {
235 |     if (slot.isObject()) {
236 |         markObject(slot.asObject());
237 |     }
238 | }
239 | 
240 | pub fn markArray(array: *ValueArray) void {
241 |     for (array.values[0..array.count]) |*val| {
242 |         markValue(val);
243 |     }
244 | }
245 | 
246 | pub fn markObject(obj: ?*Obj) void {
247 |     if (obj) |o| {
248 |         if (o.is_marked) return;
249 |         if (comptime common.log_gc) {
250 |             const stdout = common.stdout;
251 |             stdout.print("{*} mark ", .{o}) catch unreachable;
252 |             value.printValue(Value.Object(o), stdout);
253 |             stdout.print("\n", .{}) catch unreachable;
254 |         }
255 |         o.is_marked = true;
256 | 
257 |         if (vm.gray_stack.len < vm.gray_count + 1) {
258 |             const gray_capacity = common.growCapacity(vm.gray_stack.len);
259 |             vm.gray_stack = alloc.realloc(vm.gray_stack, gray_capacity) catch std.os.exit(1);
260 |         }
261 |         vm.gray_stack[vm.gray_count] = o;
262 |         vm.gray_count += 1;
263 |     }
264 | }
265 | 


--------------------------------------------------------------------------------
/src/main.zig:
--------------------------------------------------------------------------------
  1 | const std = @import("std");
  2 | const chunk = @import("./chunk.zig");
  3 | const vm = @import("./vm.zig");
  4 | const common = @import("./common.zig");
  5 | 
  6 | const stdout = common.stdout;
  7 | const stdin = std.io.getStdIn().reader();
  8 | var alloc = @import("./common.zig").alloc;
  9 | 
 10 | var v: vm.VM = .{};
 11 | 
 12 | pub fn main() anyerror!void {
 13 |     v.initVM();
 14 |     defer v.freeVM();
 15 |     var args = std.process.args();
 16 |     _ = args.skip();
 17 |     var argv: [1][]const u8 = undefined;
 18 |     var index: u8 = 0;
 19 |     while (args.next(alloc)) |arg| {
 20 |         if (index >= 1) break;
 21 |         argv[index] = arg catch continue;
 22 |         index += 1;
 23 |     }
 24 |     if (index == 0) {
 25 |         repl();
 26 |     } else if (index == 1) {
 27 |         runFile(argv[0]);
 28 |     } else {
 29 |         std.log.err("Usage: clox [path]\n", .{});
 30 |     }
 31 | }
 32 | 
 33 | fn repl() void {
 34 |     var line: [1024]u8 = undefined;
 35 |     while (true) {
 36 |         stdout.print("> ", .{}) catch unreachable;
 37 | 
 38 |         if (stdin.readUntilDelimiterOrEof(&line, '\n') catch null) |slice| {
 39 |             var source = line[0 .. slice.len + 1];
 40 |             source[slice.len] = 0;
 41 |             _ = v.interpret(source[0..slice.len :0]);
 42 |         } else {
 43 |             stdout.print("\n", .{}) catch unreachable;
 44 |             break;
 45 |         }
 46 |     }
 47 | }
 48 | 
 49 | fn runFile(path: []const u8) void {
 50 |     const source = readFile(path);
 51 |     const result = v.interpret(source);
 52 |     alloc.free(source);
 53 |     switch (result) {
 54 |         vm.InterpretResult.interpret_compile_error => std.os.exit(65),
 55 |         vm.InterpretResult.interpret_runtime_error => std.os.exit(70),
 56 |         else => {},
 57 |     }
 58 | }
 59 | 
 60 | fn readFile(path: []const u8) [:0]const u8 {
 61 |     var file = std.fs.cwd().openFile(path, .{}) catch {
 62 |         std.log.err("Could not open file {s}.\n", .{path});
 63 |         std.os.exit(74);
 64 |     };
 65 |     defer file.close();
 66 | 
 67 |     var buffer = alloc.alloc(u8, (file.stat() catch std.os.exit(74)).size + 1) catch {
 68 |         std.log.err("Could not allocate memory.\n", .{});
 69 |         std.os.exit(74);
 70 |     };
 71 | 
 72 |     const length = file.readAll(buffer) catch {
 73 |         std.log.err("Could not read file {s}.\n", .{path});
 74 |         std.os.exit(74);
 75 |     };
 76 |     buffer[length] = 0;
 77 |     return buffer[0..length :0];
 78 | }
 79 | 
 80 | test "main-test" {
 81 |     v.initVM();
 82 |     defer v.freeVM();
 83 |     try std.testing.expectEqual(v.interpret("print -(3*8) == ---24;"), vm.InterpretResult.interpret_ok);
 84 | }
 85 | 
 86 | test "main-string" {
 87 |     v.initVM();
 88 |     defer v.freeVM();
 89 |     try std.testing.expectEqual(v.interpret("print \"hello!\";"), vm.InterpretResult.interpret_ok);
 90 | }
 91 | 
 92 | test "global var" {
 93 |     v.initVM();
 94 |     defer v.freeVM();
 95 |     try std.testing.expectEqual(v.interpret(
 96 |         \\var breakfast = "corn flakes";
 97 |         \\breakfast = breakfast + " " + breakfast;
 98 |         \\print breakfast;
 99 |     ), vm.InterpretResult.interpret_ok);
100 | }
101 | 
102 | test "local var" {
103 |     v.initVM();
104 |     defer v.freeVM();
105 |     common.buffer_stream.reset();
106 |     const expected = "hello another world\n";
107 |     try std.testing.expectEqual(v.interpret(
108 |         \\var global = "hello";
109 |         \\{
110 |         \\  var local = "world";
111 |         \\  {
112 |         \\    var local = " another ";
113 |         \\    global = global + local;
114 |         \\  }
115 |         \\  global = global + local;
116 |         \\}
117 |         \\print global;
118 |     ), vm.InterpretResult.interpret_ok);
119 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
120 | }
121 | 
122 | test "loops" {
123 |     v.initVM();
124 |     defer v.freeVM();
125 |     common.buffer_stream.reset();
126 |     const expected = "1000\n";
127 |     try std.testing.expectEqual(v.interpret(
128 |         \\var counter = 0;
129 |         \\for (var index = 0; index < 1000; index = index + 1) {
130 |         \\  counter = counter + 1;
131 |         \\}
132 |         \\print counter;
133 |     ), vm.InterpretResult.interpret_ok);
134 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
135 | }
136 | 
137 | test "functions" {
138 |     v.initVM();
139 |     defer v.freeVM();
140 |     common.buffer_stream.reset();
141 |     const expected = "true\nfalse\ntrue\n";
142 |     try std.testing.expectEqual(v.interpret(
143 |         \\fun even(num) {
144 |         \\  if (num == 0) return true;
145 |         \\  return odd(num - 1);
146 |         \\}
147 |         \\fun odd(num) {
148 |         \\  if (num == 0) return false;
149 |         \\  return even(num - 1);
150 |         \\}
151 |         \\print even(22);
152 |         \\print even(21);
153 |         \\print odd(3);
154 |     ), vm.InterpretResult.interpret_ok);
155 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
156 | }
157 | 
158 | test "closure_outer" {
159 |     v.initVM();
160 |     defer v.freeVM();
161 |     common.buffer_stream.reset();
162 |     const expected = "outside\n";
163 |     try std.testing.expectEqual(v.interpret(
164 |         \\fun outer() {
165 |         \\var x = "outside";
166 |         \\fun inner() {
167 |         \\print x;
168 |         \\}
169 |         \\inner();
170 |         \\}
171 |         \\outer();
172 |     ), vm.InterpretResult.interpret_ok);
173 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
174 | }
175 | 
176 | test "closure_reference" {
177 |     v.initVM();
178 |     defer v.freeVM();
179 |     common.buffer_stream.reset();
180 |     const expected = "updated\n";
181 |     try std.testing.expectEqual(v.interpret(
182 |         \\var globalSet;
183 |         \\var globalGet;
184 |         \\fun main() {
185 |         \\    var a = "initial";
186 |         \\    fun set() { a = "updated"; }
187 |         \\    fun get() { print a; }
188 |         \\    globalSet = set;
189 |         \\    globalGet = get;
190 |         \\}
191 |         \\main();
192 |         \\globalSet();
193 |         \\globalGet();
194 |     ), vm.InterpretResult.interpret_ok);
195 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
196 | }
197 | 
198 | test "field_access" {
199 |     v.initVM();
200 |     defer v.freeVM();
201 |     common.buffer_stream.reset();
202 |     const expected = "3\n";
203 |     try std.testing.expectEqual(v.interpret(
204 |         \\class Pair {}
205 |         \\var pair = Pair();
206 |         \\pair.first = 1;
207 |         \\pair.second = 2;
208 |         \\print pair.first + pair.second;
209 |     ), vm.InterpretResult.interpret_ok);
210 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
211 | }
212 | 
213 | test "methods" {
214 |     v.initVM();
215 |     defer v.freeVM();
216 |     common.buffer_stream.reset();
217 |     const expected = "Enjoy your cup of coffee and chicory\n";
218 |     try std.testing.expectEqual(v.interpret(
219 |         \\class CoffeeMaker {
220 |         \\    init(coffee) {
221 |         \\        this.coffee = coffee;
222 |         \\    }
223 |         \\    brew() {
224 |         \\        print "Enjoy your cup of " + this.coffee;
225 |         \\        this.coffee = nil;
226 |         \\    }
227 |         \\}
228 |         \\var maker = CoffeeMaker("coffee and chicory");
229 |         \\maker.brew();
230 |     ), vm.InterpretResult.interpret_ok);
231 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
232 | }
233 | 
234 | test "field call" {
235 |     v.initVM();
236 |     defer v.freeVM();
237 |     common.buffer_stream.reset();
238 |     const expected = "indirection\n";
239 |     try std.testing.expectEqual(v.interpret(
240 |         \\class CoffeeMaker {
241 |         \\    init() {
242 |         \\        fun f() {
243 |         \\          print this.word;
244 |         \\        }
245 |         \\        this.fn = f;
246 |         \\    }
247 |         \\}
248 |         \\var maker = CoffeeMaker();
249 |         \\maker.word = "indirection";
250 |         \\maker.fn();
251 |     ), vm.InterpretResult.interpret_ok);
252 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
253 | }
254 | 
255 | test "super" {
256 |     v.initVM();
257 |     defer v.freeVM();
258 |     common.buffer_stream.reset();
259 |     const expected = "Cutting food...\nCooking at 90 degrees!\n";
260 |     try std.testing.expectEqual(v.interpret(
261 |         \\class Base {
262 |         \\    cook() {
263 |         \\        print "Cooking at " + this.getTemp();
264 |         \\    }
265 |         \\    getTemp() {
266 |         \\        return "100 degrees!";
267 |         \\    }
268 |         \\}
269 |         \\class Derived < Base {
270 |         \\    getTemp() {
271 |         \\        return "90 degrees!";
272 |         \\    }
273 |         \\    cook() {
274 |         \\        print "Cutting food...";
275 |         \\        super.cook();
276 |         \\    }
277 |         \\}
278 |         \\var d = Derived();
279 |         \\d.cook();
280 |     ), vm.InterpretResult.interpret_ok);
281 |     try std.testing.expectEqualStrings(expected, common.buffer_stream.getWritten());
282 | }
283 | 


--------------------------------------------------------------------------------
/src/object.zig:
--------------------------------------------------------------------------------
  1 | const std = @import("std");
  2 | const memory = @import("./memory.zig");
  3 | const table = @import("./table.zig");
  4 | const common = @import("./common.zig");
  5 | const VM = @import("./vm.zig").VM;
  6 | const Value = @import("./value.zig").Value;
  7 | const Chunk = @import("./chunk.zig").Chunk;
  8 | const Table = table.Table;
  9 | const alloc = common.alloc;
 10 | 
 11 | var vm: *VM = undefined;
 12 | 
 13 | pub fn initGC(_vm: *VM) void {
 14 |     vm = _vm;
 15 | }
 16 | 
 17 | pub const ObjType = enum(u8) { obj_bound_method, obj_string, obj_function, obj_native, obj_closure, obj_upvalue, obj_class, obj_instance };
 18 | 
 19 | pub const Obj = extern struct {
 20 |     const Self = @This();
 21 |     t: ObjType,
 22 |     is_marked: bool,
 23 |     next: ?*Obj = null,
 24 | 
 25 |     pub fn asString(self: *Self) *ObjString {
 26 |         return @ptrCast(*ObjString, @alignCast(@alignOf(ObjString), self));
 27 |     }
 28 | 
 29 |     pub fn asFunction(self: *Self) *ObjFunction {
 30 |         return @ptrCast(*ObjFunction, @alignCast(@alignOf(ObjFunction), self));
 31 |     }
 32 | 
 33 |     pub fn asNative(self: *Self) *ObjNative {
 34 |         return @ptrCast(*ObjNative, @alignCast(@alignOf(ObjNative), self));
 35 |     }
 36 | 
 37 |     pub fn asClosure(self: *Self) *ObjClosure {
 38 |         return @ptrCast(*ObjClosure, @alignCast(@alignOf(ObjClosure), self));
 39 |     }
 40 | 
 41 |     pub fn asUpvalue(self: *Self) *ObjUpvalue {
 42 |         return @ptrCast(*ObjUpvalue, @alignCast(@alignOf(ObjUpvalue), self));
 43 |     }
 44 | 
 45 |     pub fn asClass(self: *Self) *ObjClass {
 46 |         return @ptrCast(*ObjClass, @alignCast(@alignOf(ObjClass), self));
 47 |     }
 48 | 
 49 |     pub fn asInstance(self: *Self) *ObjInstance {
 50 |         return @ptrCast(*ObjInstance, @alignCast(@alignOf(ObjInstance), self));
 51 |     }
 52 | 
 53 |     pub fn asBoundMethod(self: *Self) *ObjBoundMethod {
 54 |         return @ptrCast(*ObjBoundMethod, @alignCast(@alignOf(ObjBoundMethod), self));
 55 |     }
 56 | 
 57 |     pub fn print(self: *Self, writer: anytype) void {
 58 |         switch (self.t) {
 59 |             .obj_string => {
 60 |                 writer.print("{s}", .{self.asString().chars[0..self.asString().length]}) catch unreachable;
 61 |             },
 62 |             .obj_function => {
 63 |                 printFunction(self.asFunction(), writer);
 64 |             },
 65 |             .obj_native => {
 66 |                 writer.print("<native fn>", .{}) catch unreachable;
 67 |             },
 68 |             .obj_closure => {
 69 |                 printFunction(self.asClosure().function, writer);
 70 |             },
 71 |             .obj_upvalue => {
 72 |                 writer.print("upvalue", .{}) catch unreachable;
 73 |             },
 74 |             .obj_class => {
 75 |                 writer.print("{s}", .{self.asClass().name.chars[0..self.asClass().name.length]}) catch unreachable;
 76 |             },
 77 |             .obj_instance => {
 78 |                 writer.print("{s} instance", .{self.asInstance().class.name.chars[0..self.asInstance().class.name.length]}) catch unreachable;
 79 |             },
 80 |             .obj_bound_method => {
 81 |                 printFunction(self.asBoundMethod().method.function, writer);
 82 |             },
 83 |         }
 84 |     }
 85 | };
 86 | 
 87 | pub const ObjFunction = extern struct {
 88 |     obj: Obj,
 89 |     arity: usize,
 90 |     _chunk: [@sizeOf(Chunk)]u8 align(@alignOf(Chunk)) = undefined,
 91 |     name: ?*ObjString,
 92 |     upvalue_count: u8,
 93 |     pub inline fn chunk(self: *ObjFunction) *Chunk {
 94 |         return @ptrCast(*Chunk, &self._chunk);
 95 |     }
 96 | };
 97 | 
 98 | pub const ObjClosure = extern struct {
 99 |     obj: Obj,
100 |     function: *ObjFunction,
101 |     upvalues: [*]?*ObjUpvalue,
102 |     upvalue_count: usize,
103 | };
104 | 
105 | pub const ObjClass = extern struct {
106 |     obj: Obj,
107 |     name: *ObjString,
108 |     _methods: [@sizeOf(Table)]u8 align(@alignOf(Table)),
109 | 
110 |     pub inline fn methods(self: *ObjClass) *Table {
111 |         return @ptrCast(*Table, &self._methods);
112 |     }
113 | };
114 | 
115 | pub const ObjInstance = extern struct {
116 |     obj: Obj,
117 |     class: *ObjClass,
118 |     _fields: [@sizeOf(Table)]u8 align(@alignOf(Table)),
119 | 
120 |     pub inline fn fields(self: *ObjInstance) *Table {
121 |         return @ptrCast(*Table, &self._fields);
122 |     }
123 | };
124 | 
125 | pub const ObjBoundMethod = extern struct {
126 |     obj: Obj,
127 |     _receiver: [@sizeOf(Value)]u8 align(@alignOf(Value)),
128 |     method: *ObjClosure,
129 | 
130 |     pub inline fn receiver(self: *ObjBoundMethod) *Value {
131 |         return @ptrCast(*Value, &self._receiver);
132 |     }
133 | };
134 | 
135 | pub const NativeFn = fn (arg_count: usize, args: [*]Value) Value;
136 | 
137 | pub const ObjNative = extern struct {
138 |     obj: Obj,
139 |     _function: [@sizeOf(NativeFn)]u8 align(@alignOf(NativeFn)) = undefined,
140 | 
141 |     pub inline fn function(self: *ObjNative) *NativeFn {
142 |         return @ptrCast(*NativeFn, &self._function);
143 |     }
144 | };
145 | 
146 | pub const ObjString = extern struct {
147 |     obj: Obj,
148 |     length: usize,
149 |     chars: [*]u8,
150 |     hash: u32,
151 | };
152 | 
153 | pub const ObjUpvalue = extern struct {
154 |     obj: Obj,
155 |     location: *Value,
156 |     next: ?*ObjUpvalue,
157 |     _closed: [@sizeOf(Value)]u8 align(@alignOf(Value)),
158 | 
159 |     pub inline fn closed(self: *ObjUpvalue) *Value {
160 |         return @ptrCast(*Value, &self._closed);
161 |     }
162 | };
163 | 
164 | pub fn newInstance(class: *ObjClass) *Obj {
165 |     const instance = allocateObject(ObjInstance, .obj_instance);
166 |     instance.class = class;
167 |     instance.fields().* = Table.initTable();
168 |     return @ptrCast(*Obj, instance);
169 | }
170 | 
171 | pub fn newBoundMethod(receiver: Value, method: *ObjClosure) *Obj {
172 |     const bound = allocateObject(ObjBoundMethod, .obj_bound_method);
173 |     bound.receiver().* = receiver;
174 |     bound.method = method;
175 |     return @ptrCast(*Obj, bound);
176 | }
177 | 
178 | pub fn newClass(name: *ObjString) *Obj {
179 |     const class = allocateObject(ObjClass, .obj_class);
180 |     class.name = name;
181 |     class.methods().* = Table.initTable();
182 |     return @ptrCast(*Obj, class);
183 | }
184 | 
185 | pub fn newClosure(function: *ObjFunction) *ObjClosure {
186 |     const upvalues = memory.allocate(?*ObjUpvalue, function.upvalue_count);
187 |     for (upvalues[0..function.upvalue_count]) |*upvalue| {
188 |         upvalue.* = null;
189 |     }
190 |     var closure = allocateObject(ObjClosure, .obj_closure);
191 |     closure.upvalues = upvalues;
192 |     closure.upvalue_count = function.upvalue_count;
193 |     closure.function = function;
194 |     return closure;
195 | }
196 | 
197 | pub fn newFunction() *ObjFunction {
198 |     var function = allocateObject(ObjFunction, .obj_function);
199 |     function.arity = 0;
200 |     function.name = null;
201 |     function.chunk().* = Chunk.init(alloc);
202 |     function.upvalue_count = 0;
203 |     return function;
204 | }
205 | 
206 | pub fn newNative(function: NativeFn) *Obj {
207 |     var native = allocateObject(ObjNative, .obj_native);
208 |     native.function().* = function;
209 |     return @ptrCast(*Obj, native);
210 | }
211 | 
212 | pub fn newUpvalue(slot: *Value) *ObjUpvalue {
213 |     var upvalue = allocateObject(ObjUpvalue, .obj_upvalue);
214 |     upvalue.location = slot;
215 |     upvalue.next = null;
216 |     upvalue.closed().* = Value.Nil();
217 |     return upvalue;
218 | }
219 | 
220 | pub fn copyString(chars: [*]const u8, length: usize) *Obj {
221 |     const hash = hashString(chars, length);
222 |     const interned = VM.strings.findString(chars, length, hash);
223 |     var string: *ObjString = undefined;
224 |     if (interned) |i| {
225 |         string = i;
226 |     } else {
227 |         var heap_chars = memory.allocate(u8, length + 1)[0 .. length + 1];
228 |         std.mem.copy(u8, heap_chars, chars[0..length]);
229 |         heap_chars[length] = 0;
230 |         string = allocateString(heap_chars[0..length], hash);
231 |     }
232 | 
233 |     return @ptrCast(*Obj, string);
234 | }
235 | 
236 | pub fn takeString(chars: [*]u8, length: usize) *Obj {
237 |     const hash = hashString(chars, length);
238 |     const interned = VM.strings.findString(chars, length, hash);
239 |     var string: *ObjString = undefined;
240 |     if (interned) |i| {
241 |         memory.freeArray(u8, chars, length + 1);
242 |         string = i;
243 |     } else {
244 |         string = allocateString(chars[0..length], hash);
245 |     }
246 |     return @ptrCast(*Obj, string);
247 | }
248 | 
249 | fn printFunction(function: *ObjFunction, writer: anytype) void {
250 |     if (function.name) |name| {
251 |         writer.print("<fn {s}>", .{name.chars[0..name.length]}) catch unreachable;
252 |     } else {
253 |         writer.print("<script>", .{}) catch unreachable;
254 |     }
255 | }
256 | 
257 | fn allocateString(chars: []u8, hash: u32) *ObjString {
258 |     var string = allocateObject(ObjString, .obj_string);
259 |     string.length = chars.len;
260 |     string.chars = chars.ptr;
261 |     string.hash = hash;
262 |     vm.push(Value.Object(@ptrCast(*Obj, string)));
263 |     _ = VM.strings.tableSet(string, Value.Nil());
264 |     _ = vm.pop();
265 |     return string;
266 | }
267 | 
268 | fn hashString(key: [*]const u8, length: usize) u32 {
269 |     var hash: u32 = 2166136261;
270 |     var i: usize = 0;
271 |     while (i < length) : (i += 1) {
272 |         hash ^= key[i];
273 |         hash *%= 16777619;
274 |     }
275 |     return hash;
276 | }
277 | 
278 | fn allocateObject(comptime t: type, obj_t: ObjType) *t {
279 |     var obj = &memory.allocate(t, 1)[0];
280 |     obj.obj.t = obj_t;
281 |     obj.obj.is_marked = false;
282 |     obj.obj.next = VM.objects;
283 |     VM.objects = &obj.obj;
284 | 
285 |     if (comptime common.log_gc) {
286 |         const stdout = common.stdout;
287 |         stdout.print("{*} allocate {d} for {any}\n", .{ obj, @sizeOf(t), obj_t }) catch unreachable;
288 |     }
289 | 
290 |     return obj;
291 | }
292 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Mozilla Public License Version 2.0
  2 | ==================================
  3 | 
  4 | 1. Definitions
  5 | --------------
  6 | 
  7 | 1.1. "Contributor"
  8 |     means each individual or legal entity that creates, contributes to
  9 |     the creation of, or owns Covered Software.
 10 | 
 11 | 1.2. "Contributor Version"
 12 |     means the combination of the Contributions of others (if any) used
 13 |     by a Contributor and that particular Contributor's Contribution.
 14 | 
 15 | 1.3. "Contribution"
 16 |     means Covered Software of a particular Contributor.
 17 | 
 18 | 1.4. "Covered Software"
 19 |     means Source Code Form to which the initial Contributor has attached
 20 |     the notice in Exhibit A, the Executable Form of such Source Code
 21 |     Form, and Modifications of such Source Code Form, in each case
 22 |     including portions thereof.
 23 | 
 24 | 1.5. "Incompatible With Secondary Licenses"
 25 |     means
 26 | 
 27 |     (a) that the initial Contributor has attached the notice described
 28 |         in Exhibit B to the Covered Software; or
 29 | 
 30 |     (b) that the Covered Software was made available under the terms of
 31 |         version 1.1 or earlier of the License, but not also under the
 32 |         terms of a Secondary License.
 33 | 
 34 | 1.6. "Executable Form"
 35 |     means any form of the work other than Source Code Form.
 36 | 
 37 | 1.7. "Larger Work"
 38 |     means a work that combines Covered Software with other material, in
 39 |     a separate file or files, that is not Covered Software.
 40 | 
 41 | 1.8. "License"
 42 |     means this document.
 43 | 
 44 | 1.9. "Licensable"
 45 |     means having the right to grant, to the maximum extent possible,
 46 |     whether at the time of the initial grant or subsequently, any and
 47 |     all of the rights conveyed by this License.
 48 | 
 49 | 1.10. "Modifications"
 50 |     means any of the following:
 51 | 
 52 |     (a) any file in Source Code Form that results from an addition to,
 53 |         deletion from, or modification of the contents of Covered
 54 |         Software; or
 55 | 
 56 |     (b) any new file in Source Code Form that contains any Covered
 57 |         Software.
 58 | 
 59 | 1.11. "Patent Claims" of a Contributor
 60 |     means any patent claim(s), including without limitation, method,
 61 |     process, and apparatus claims, in any patent Licensable by such
 62 |     Contributor that would be infringed, but for the grant of the
 63 |     License, by the making, using, selling, offering for sale, having
 64 |     made, import, or transfer of either its Contributions or its
 65 |     Contributor Version.
 66 | 
 67 | 1.12. "Secondary License"
 68 |     means either the GNU General Public License, Version 2.0, the GNU
 69 |     Lesser General Public License, Version 2.1, the GNU Affero General
 70 |     Public License, Version 3.0, or any later versions of those
 71 |     licenses.
 72 | 
 73 | 1.13. "Source Code Form"
 74 |     means the form of the work preferred for making modifications.
 75 | 
 76 | 1.14. "You" (or "Your")
 77 |     means an individual or a legal entity exercising rights under this
 78 |     License. For legal entities, "You" includes any entity that
 79 |     controls, is controlled by, or is under common control with You. For
 80 |     purposes of this definition, "control" means (a) the power, direct
 81 |     or indirect, to cause the direction or management of such entity,
 82 |     whether by contract or otherwise, or (b) ownership of more than
 83 |     fifty percent (50%) of the outstanding shares or beneficial
 84 |     ownership of such entity.
 85 | 
 86 | 2. License Grants and Conditions
 87 | --------------------------------
 88 | 
 89 | 2.1. Grants
 90 | 
 91 | Each Contributor hereby grants You a world-wide, royalty-free,
 92 | non-exclusive license:
 93 | 
 94 | (a) under intellectual property rights (other than patent or trademark)
 95 |     Licensable by such Contributor to use, reproduce, make available,
 96 |     modify, display, perform, distribute, and otherwise exploit its
 97 |     Contributions, either on an unmodified basis, with Modifications, or
 98 |     as part of a Larger Work; and
 99 | 
100 | (b) under Patent Claims of such Contributor to make, use, sell, offer
101 |     for sale, have made, import, and otherwise transfer either its
102 |     Contributions or its Contributor Version.
103 | 
104 | 2.2. Effective Date
105 | 
106 | The licenses granted in Section 2.1 with respect to any Contribution
107 | become effective for each Contribution on the date the Contributor first
108 | distributes such Contribution.
109 | 
110 | 2.3. Limitations on Grant Scope
111 | 
112 | The licenses granted in this Section 2 are the only rights granted under
113 | this License. No additional rights or licenses will be implied from the
114 | distribution or licensing of Covered Software under this License.
115 | Notwithstanding Section 2.1(b) above, no patent license is granted by a
116 | Contributor:
117 | 
118 | (a) for any code that a Contributor has removed from Covered Software;
119 |     or
120 | 
121 | (b) for infringements caused by: (i) Your and any other third party's
122 |     modifications of Covered Software, or (ii) the combination of its
123 |     Contributions with other software (except as part of its Contributor
124 |     Version); or
125 | 
126 | (c) under Patent Claims infringed by Covered Software in the absence of
127 |     its Contributions.
128 | 
129 | This License does not grant any rights in the trademarks, service marks,
130 | or logos of any Contributor (except as may be necessary to comply with
131 | the notice requirements in Section 3.4).
132 | 
133 | 2.4. Subsequent Licenses
134 | 
135 | No Contributor makes additional grants as a result of Your choice to
136 | distribute the Covered Software under a subsequent version of this
137 | License (see Section 10.2) or under the terms of a Secondary License (if
138 | permitted under the terms of Section 3.3).
139 | 
140 | 2.5. Representation
141 | 
142 | Each Contributor represents that the Contributor believes its
143 | Contributions are its original creation(s) or it has sufficient rights
144 | to grant the rights to its Contributions conveyed by this License.
145 | 
146 | 2.6. Fair Use
147 | 
148 | This License is not intended to limit any rights You have under
149 | applicable copyright doctrines of fair use, fair dealing, or other
150 | equivalents.
151 | 
152 | 2.7. Conditions
153 | 
154 | Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
155 | in Section 2.1.
156 | 
157 | 3. Responsibilities
158 | -------------------
159 | 
160 | 3.1. Distribution of Source Form
161 | 
162 | All distribution of Covered Software in Source Code Form, including any
163 | Modifications that You create or to which You contribute, must be under
164 | the terms of this License. You must inform recipients that the Source
165 | Code Form of the Covered Software is governed by the terms of this
166 | License, and how they can obtain a copy of this License. You may not
167 | attempt to alter or restrict the recipients' rights in the Source Code
168 | Form.
169 | 
170 | 3.2. Distribution of Executable Form
171 | 
172 | If You distribute Covered Software in Executable Form then:
173 | 
174 | (a) such Covered Software must also be made available in Source Code
175 |     Form, as described in Section 3.1, and You must inform recipients of
176 |     the Executable Form how they can obtain a copy of such Source Code
177 |     Form by reasonable means in a timely manner, at a charge no more
178 |     than the cost of distribution to the recipient; and
179 | 
180 | (b) You may distribute such Executable Form under the terms of this
181 |     License, or sublicense it under different terms, provided that the
182 |     license for the Executable Form does not attempt to limit or alter
183 |     the recipients' rights in the Source Code Form under this License.
184 | 
185 | 3.3. Distribution of a Larger Work
186 | 
187 | You may create and distribute a Larger Work under terms of Your choice,
188 | provided that You also comply with the requirements of this License for
189 | the Covered Software. If the Larger Work is a combination of Covered
190 | Software with a work governed by one or more Secondary Licenses, and the
191 | Covered Software is not Incompatible With Secondary Licenses, this
192 | License permits You to additionally distribute such Covered Software
193 | under the terms of such Secondary License(s), so that the recipient of
194 | the Larger Work may, at their option, further distribute the Covered
195 | Software under the terms of either this License or such Secondary
196 | License(s).
197 | 
198 | 3.4. Notices
199 | 
200 | You may not remove or alter the substance of any license notices
201 | (including copyright notices, patent notices, disclaimers of warranty,
202 | or limitations of liability) contained within the Source Code Form of
203 | the Covered Software, except that You may alter any license notices to
204 | the extent required to remedy known factual inaccuracies.
205 | 
206 | 3.5. Application of Additional Terms
207 | 
208 | You may choose to offer, and to charge a fee for, warranty, support,
209 | indemnity or liability obligations to one or more recipients of Covered
210 | Software. However, You may do so only on Your own behalf, and not on
211 | behalf of any Contributor. You must make it absolutely clear that any
212 | such warranty, support, indemnity, or liability obligation is offered by
213 | You alone, and You hereby agree to indemnify every Contributor for any
214 | liability incurred by such Contributor as a result of warranty, support,
215 | indemnity or liability terms You offer. You may include additional
216 | disclaimers of warranty and limitations of liability specific to any
217 | jurisdiction.
218 | 
219 | 4. Inability to Comply Due to Statute or Regulation
220 | ---------------------------------------------------
221 | 
222 | If it is impossible for You to comply with any of the terms of this
223 | License with respect to some or all of the Covered Software due to
224 | statute, judicial order, or regulation then You must: (a) comply with
225 | the terms of this License to the maximum extent possible; and (b)
226 | describe the limitations and the code they affect. Such description must
227 | be placed in a text file included with all distributions of the Covered
228 | Software under this License. Except to the extent prohibited by statute
229 | or regulation, such description must be sufficiently detailed for a
230 | recipient of ordinary skill to be able to understand it.
231 | 
232 | 5. Termination
233 | --------------
234 | 
235 | 5.1. The rights granted under this License will terminate automatically
236 | if You fail to comply with any of its terms. However, if You become
237 | compliant, then the rights granted under this License from a particular
238 | Contributor are reinstated (a) provisionally, unless and until such
239 | Contributor explicitly and finally terminates Your grants, and (b) on an
240 | ongoing basis, if such Contributor fails to notify You of the
241 | non-compliance by some reasonable means prior to 60 days after You have
242 | come back into compliance. Moreover, Your grants from a particular
243 | Contributor are reinstated on an ongoing basis if such Contributor
244 | notifies You of the non-compliance by some reasonable means, this is the
245 | first time You have received notice of non-compliance with this License
246 | from such Contributor, and You become compliant prior to 30 days after
247 | Your receipt of the notice.
248 | 
249 | 5.2. If You initiate litigation against any entity by asserting a patent
250 | infringement claim (excluding declaratory judgment actions,
251 | counter-claims, and cross-claims) alleging that a Contributor Version
252 | directly or indirectly infringes any patent, then the rights granted to
253 | You by any and all Contributors for the Covered Software under Section
254 | 2.1 of this License shall terminate.
255 | 
256 | 5.3. In the event of termination under Sections 5.1 or 5.2 above, all
257 | end user license agreements (excluding distributors and resellers) which
258 | have been validly granted by You or Your distributors under this License
259 | prior to termination shall survive termination.
260 | 
261 | ************************************************************************
262 | *                                                                      *
263 | *  6. Disclaimer of Warranty                                           *
264 | *  -------------------------                                           *
265 | *                                                                      *
266 | *  Covered Software is provided under this License on an "as is"       *
267 | *  basis, without warranty of any kind, either expressed, implied, or  *
268 | *  statutory, including, without limitation, warranties that the       *
269 | *  Covered Software is free of defects, merchantable, fit for a        *
270 | *  particular purpose or non-infringing. The entire risk as to the     *
271 | *  quality and performance of the Covered Software is with You.        *
272 | *  Should any Covered Software prove defective in any respect, You     *
273 | *  (not any Contributor) assume the cost of any necessary servicing,   *
274 | *  repair, or correction. This disclaimer of warranty constitutes an   *
275 | *  essential part of this License. No use of any Covered Software is   *
276 | *  authorized under this License except under this disclaimer.         *
277 | *                                                                      *
278 | ************************************************************************
279 | 
280 | ************************************************************************
281 | *                                                                      *
282 | *  7. Limitation of Liability                                          *
283 | *  --------------------------                                          *
284 | *                                                                      *
285 | *  Under no circumstances and under no legal theory, whether tort      *
286 | *  (including negligence), contract, or otherwise, shall any           *
287 | *  Contributor, or anyone who distributes Covered Software as          *
288 | *  permitted above, be liable to You for any direct, indirect,         *
289 | *  special, incidental, or consequential damages of any character      *
290 | *  including, without limitation, damages for lost profits, loss of    *
291 | *  goodwill, work stoppage, computer failure or malfunction, or any    *
292 | *  and all other commercial damages or losses, even if such party      *
293 | *  shall have been informed of the possibility of such damages. This   *
294 | *  limitation of liability shall not apply to liability for death or   *
295 | *  personal injury resulting from such party's negligence to the       *
296 | *  extent applicable law prohibits such limitation. Some               *
297 | *  jurisdictions do not allow the exclusion or limitation of           *
298 | *  incidental or consequential damages, so this exclusion and          *
299 | *  limitation may not apply to You.                                    *
300 | *                                                                      *
301 | ************************************************************************
302 | 
303 | 8. Litigation
304 | -------------
305 | 
306 | Any litigation relating to this License may be brought only in the
307 | courts of a jurisdiction where the defendant maintains its principal
308 | place of business and such litigation shall be governed by laws of that
309 | jurisdiction, without reference to its conflict-of-law provisions.
310 | Nothing in this Section shall prevent a party's ability to bring
311 | cross-claims or counter-claims.
312 | 
313 | 9. Miscellaneous
314 | ----------------
315 | 
316 | This License represents the complete agreement concerning the subject
317 | matter hereof. If any provision of this License is held to be
318 | unenforceable, such provision shall be reformed only to the extent
319 | necessary to make it enforceable. Any law or regulation which provides
320 | that the language of a contract shall be construed against the drafter
321 | shall not be used to construe this License against a Contributor.
322 | 
323 | 10. Versions of the License
324 | ---------------------------
325 | 
326 | 10.1. New Versions
327 | 
328 | Mozilla Foundation is the license steward. Except as provided in Section
329 | 10.3, no one other than the license steward has the right to modify or
330 | publish new versions of this License. Each version will be given a
331 | distinguishing version number.
332 | 
333 | 10.2. Effect of New Versions
334 | 
335 | You may distribute the Covered Software under the terms of the version
336 | of the License under which You originally received the Covered Software,
337 | or under the terms of any subsequent version published by the license
338 | steward.
339 | 
340 | 10.3. Modified Versions
341 | 
342 | If you create software not governed by this License, and you want to
343 | create a new license for such software, you may create and use a
344 | modified version of this License if you rename the license and remove
345 | any references to the name of the license steward (except to note that
346 | such modified license differs from this License).
347 | 
348 | 10.4. Distributing Source Code Form that is Incompatible With Secondary
349 | Licenses
350 | 
351 | If You choose to distribute Source Code Form that is Incompatible With
352 | Secondary Licenses under the terms of this version of the License, the
353 | notice described in Exhibit B of this License must be attached.
354 | 
355 | Exhibit A - Source Code Form License Notice
356 | -------------------------------------------
357 | 
358 |   This Source Code Form is subject to the terms of the Mozilla Public
359 |   License, v. 2.0. If a copy of the MPL was not distributed with this
360 |   file, You can obtain one at http://mozilla.org/MPL/2.0/.
361 | 
362 | If it is not possible or desirable to put the notice in a particular
363 | file, then You may include the notice in a location (such as a LICENSE
364 | file in a relevant directory) where a recipient would be likely to look
365 | for such a notice.
366 | 
367 | You may add additional accurate notices of copyright ownership.
368 | 
369 | Exhibit B - "Incompatible With Secondary Licenses" Notice
370 | ---------------------------------------------------------
371 | 
372 |   This Source Code Form is "Incompatible With Secondary Licenses", as
373 |   defined by the Mozilla Public License, v. 2.0.
374 | 


--------------------------------------------------------------------------------
/src/vm.zig:
--------------------------------------------------------------------------------
  1 | const std = @import("std");
  2 | const chunk = @import("./chunk.zig");
  3 | const debug = @import("./debug.zig");
  4 | const compiler = @import("./compiler.zig");
  5 | const memory = @import("./memory.zig");
  6 | const object = @import("./object.zig");
  7 | const value = @import("./value.zig");
  8 | const common = @import("./common.zig");
  9 | const Table = @import("./table.zig").Table;
 10 | const Chunk = chunk.Chunk;
 11 | const Value = value.Value;
 12 | const Obj = object.Obj;
 13 | const ObjFunction = object.ObjFunction;
 14 | const ObjClosure = object.ObjClosure;
 15 | const ObjNative = object.ObjNative;
 16 | const ObjUpvalue = object.ObjUpvalue;
 17 | 
 18 | const alloc = common.alloc;
 19 | var stdout = common.stdout;
 20 | var stderr = common.stderr;
 21 | 
 22 | fn clockNative(_: usize, _: [*]Value) Value {
 23 |     var ts = std.os.timespec{ .tv_sec = 0, .tv_nsec = 0 };
 24 |     std.os.clock_gettime(std.os.CLOCK.MONOTONIC, &ts) catch std.os.exit(1);
 25 |     return Value.Number(@intToFloat(f64, ts.tv_sec) + @intToFloat(f64, ts.tv_nsec) / 1_000_000_000.0);
 26 | }
 27 | 
 28 | const CallFrame = struct {
 29 |     closure: *ObjClosure,
 30 |     ip: [*]u8,
 31 |     slots: [*]Value,
 32 | };
 33 | 
 34 | pub const VM = struct {
 35 |     const frames_max = 64;
 36 |     const stack_max = frames_max * 256;
 37 |     pub var objects: ?*object.Obj = null; // linked list of allocated objects
 38 |     pub var strings: Table = undefined;
 39 |     init_string: ?*object.ObjString = null,
 40 |     bytes_allocated: isize = undefined,
 41 |     next_gc: isize = undefined,
 42 |     gray_count: usize = 0,
 43 |     gray_stack: []*Obj = &.{},
 44 |     frames: [frames_max]CallFrame = undefined,
 45 |     open_upvalues: ?*ObjUpvalue = null,
 46 |     frame_count: usize = 0,
 47 |     frame: *CallFrame = undefined,
 48 |     globals: Table = undefined,
 49 |     stack: *[stack_max]Value = undefined,
 50 |     chunk: *Chunk = undefined,
 51 |     stack_top: [*]Value = undefined,
 52 | 
 53 |     pub fn initVM(self: *VM) void {
 54 |         var vm = self;
 55 |         vm.bytes_allocated = 0;
 56 |         vm.next_gc = 1024 * 1024;
 57 |         memory.initGC(vm);
 58 |         vm.globals = Table.initTable();
 59 |         vm.stack = alloc.create([stack_max]Value) catch std.os.exit(1);
 60 |         vm.resetStack();
 61 |         strings = Table.initTable();
 62 |         vm.defineNative("clock", clockNative);
 63 |         vm.init_string = object.copyString("init", 4).asString();
 64 |     }
 65 | 
 66 |     pub fn freeVM(self: *VM) void {
 67 |         strings.freeTable();
 68 |         self.globals.freeTable();
 69 |         memory.freeObjects();
 70 |         alloc.destroy(self.stack);
 71 |         alloc.free(self.gray_stack);
 72 |         self.gray_count = 0;
 73 |         self.gray_stack = &.{};
 74 |         self.open_upvalues = null;
 75 |         self.frame_count = 0;
 76 |         objects = null;
 77 |         self.init_string = null;
 78 |     }
 79 | 
 80 |     pub fn interpret(self: *VM, source: [:0]const u8) InterpretResult {
 81 |         const function = compiler.compile(source) orelse return .interpret_compile_error;
 82 |         self.push(Value.Object(@ptrCast(*Obj, function)));
 83 |         const closure = object.newClosure(function);
 84 |         _ = self.pop();
 85 |         self.push(Value.Object(@ptrCast(*Obj, closure)));
 86 |         _ = self.call(closure, 0);
 87 | 
 88 |         return self.run();
 89 |     }
 90 | 
 91 |     fn run(self: *VM) InterpretResult {
 92 |         self.frame = &self.frames[self.frame_count - 1];
 93 |         while (true) {
 94 |             if (common.trace_enabled) {
 95 |                 stdout.print("          ", .{}) catch unreachable;
 96 |                 for (self.stack) |*v| {
 97 |                     if (@ptrToInt(v) >= @ptrToInt(self.stack_top)) {
 98 |                         break;
 99 |                     }
100 |                     stdout.print("[ ", .{}) catch unreachable;
101 |                     value.printValue(v.*, stdout);
102 |                     stdout.print(" ]", .{}) catch unreachable;
103 |                 }
104 |                 stdout.print("\n", .{}) catch unreachable;
105 |                 _ = debug.disassembleInstruction(self.frame.closure.function.chunk(), @intCast(u32, @ptrToInt(self.frame.ip) - @ptrToInt(self.frame.closure.function.chunk().code)));
106 |             }
107 |             const inst = @intToEnum(chunk.OpCode, self.readByte());
108 |             switch (inst) {
109 |                 .op_return => {
110 |                     const result = self.pop();
111 |                     self.closeUpvalues(&self.frame.slots[0]);
112 |                     self.frame_count -= 1;
113 |                     if (self.frame_count == 0) {
114 |                         _ = self.pop();
115 |                         return .interpret_ok;
116 |                     }
117 | 
118 |                     self.stack_top = self.frame.slots;
119 |                     self.push(result);
120 |                     self.frame = &self.frames[self.frame_count - 1];
121 |                 },
122 |                 .op_closure => {
123 |                     const function = self.readConstant().asObject().asFunction();
124 |                     const closure = object.newClosure(function);
125 |                     self.push(Value.Object(@ptrCast(*Obj, closure)));
126 |                     var i: usize = 0;
127 |                     while (i < closure.upvalue_count) : (i += 1) {
128 |                         const is_local = self.readByte();
129 |                         const index = self.readByte();
130 |                         if (is_local == 1) {
131 |                             closure.upvalues[i] = self.captureUpvalue(&(self.frame.slots + index)[0]);
132 |                         } else {
133 |                             closure.upvalues[i] = self.frame.closure.upvalues[index];
134 |                         }
135 |                     }
136 |                 },
137 |                 .op_close_upvalue => {
138 |                     self.closeUpvalues(&(self.stack_top - 1)[0]);
139 |                     _ = self.pop();
140 |                 },
141 |                 .op_call => {
142 |                     const arg_count = self.readByte();
143 |                     if (!self.callValue(self.peek(arg_count), arg_count)) {
144 |                         return .interpret_runtime_error;
145 |                     }
146 |                     self.frame = &self.frames[self.frame_count - 1];
147 |                 },
148 |                 .op_invoke => {
149 |                     const method = self.readString();
150 |                     const arg_count = self.readByte();
151 |                     if (!self.invoke(method, arg_count)) {
152 |                         return .interpret_runtime_error;
153 |                     }
154 |                     self.frame = &self.frames[self.frame_count - 1];
155 |                 },
156 |                 .op_super_invoke => {
157 |                     const method = self.readString();
158 |                     const arg_count = self.readByte();
159 |                     const super = self.pop().asObject().asClass();
160 |                     if (!self.invokeFromClass(super, method, arg_count)) {
161 |                         return .interpret_runtime_error;
162 |                     }
163 |                     self.frame = &self.frames[self.frame_count - 1];
164 |                 },
165 |                 .op_get_super => {
166 |                     const name = self.readString();
167 |                     const super = self.pop().asObject().asClass();
168 | 
169 |                     if (!self.bindMethod(super, name)) {
170 |                         return .interpret_runtime_error;
171 |                     }
172 |                 },
173 |                 .op_jump => {
174 |                     const offset = self.readShort();
175 |                     self.frame.ip += offset;
176 |                 },
177 |                 .op_loop => {
178 |                     const offset = self.readShort();
179 |                     self.frame.ip -= offset;
180 |                 },
181 |                 .op_jump_if_false => {
182 |                     const offset = self.readShort();
183 |                     if (isFalsey(self.peek(0))) self.frame.ip += offset;
184 |                 },
185 |                 .op_constant => {
186 |                     const constant = self.readConstant();
187 |                     self.push(constant);
188 |                 },
189 |                 .op_nil => self.push(Value.Nil()),
190 |                 .op_true => self.push(Value.Boolean(true)),
191 |                 .op_false => self.push(Value.Boolean(false)),
192 |                 .op_equal => {
193 |                     var a = self.pop();
194 |                     var b = self.pop();
195 |                     self.push(Value.Boolean(value.valuesEqual(a, b)));
196 |                 },
197 |                 .op_negate => {
198 |                     if (!self.peek(0).isNumber()) {
199 |                         self.runtimeError("Operand must be a number", .{});
200 |                         return .interpret_runtime_error;
201 |                     }
202 |                     self.push(Value.Number(-(self.pop().asNumber())));
203 |                 },
204 |                 .op_print => {
205 |                     value.printValue(self.pop(), stdout);
206 |                     stdout.print("\n", .{}) catch unreachable;
207 |                 },
208 |                 .op_pop => {
209 |                     _ = self.pop();
210 |                 },
211 |                 .op_get_local => {
212 |                     const slot = self.readByte();
213 |                     self.push(self.frame.slots[slot]);
214 |                 },
215 |                 .op_get_global => {
216 |                     const name = self.readString();
217 |                     if (self.globals.tableGet(name)) |v| {
218 |                         self.push(v);
219 |                     } else {
220 |                         self.runtimeError("Undefined variable '{s}'", .{name.chars[0..name.length]});
221 |                         return .interpret_runtime_error;
222 |                     }
223 |                 },
224 |                 .op_get_upvalue => {
225 |                     const slot = self.readByte();
226 |                     self.push(self.frame.closure.upvalues[slot].?.location.*);
227 |                 },
228 |                 .op_define_global => {
229 |                     const name = self.readString();
230 |                     _ = self.globals.tableSet(name, self.peek(0));
231 |                     _ = self.pop();
232 |                 },
233 |                 .op_set_local => {
234 |                     const slot = self.readByte();
235 |                     self.frame.slots[slot] = self.peek(0);
236 |                 },
237 |                 .op_set_global => {
238 |                     const name = self.readString();
239 |                     if (self.globals.tableSet(name, self.peek(0))) {
240 |                         _ = self.globals.tableDelete(name);
241 |                         self.runtimeError("Undefined variable '{s}'", .{name.chars[0..name.length]});
242 |                         return .interpret_runtime_error;
243 |                     }
244 |                 },
245 |                 .op_set_upvalue => {
246 |                     const slot = self.readByte();
247 |                     self.frame.closure.upvalues[slot].?.location.* = self.peek(0);
248 |                 },
249 |                 .op_greater => self.binary_op(common.greater) orelse return .interpret_runtime_error,
250 |                 .op_less => self.binary_op(common.less) orelse return .interpret_runtime_error,
251 |                 .op_add => {
252 |                     const a = self.peek(0);
253 |                     const b = self.peek(1);
254 |                     if (a.isString() and b.isString()) self.concatenate() else if (a.isNumber() and b.isNumber()) {
255 |                         _ = self.pop();
256 |                         _ = self.pop();
257 |                         self.push(Value.Number(a.asNumber() + b.asNumber()));
258 |                     } else {
259 |                         self.runtimeError("Operand must be two numbers or two strings.", .{});
260 |                         return .interpret_runtime_error;
261 |                     }
262 |                 },
263 |                 .op_subtract => self.binary_op(common.sub) orelse return .interpret_runtime_error,
264 |                 .op_multiply => self.binary_op(common.mul) orelse return .interpret_runtime_error,
265 |                 .op_divide => self.binary_op(common.div) orelse return .interpret_runtime_error,
266 |                 .op_not => self.push(Value.Boolean(isFalsey(self.pop()))),
267 |                 .op_class => {
268 |                     self.push(Value.Object(object.newClass(self.readString())));
269 |                 },
270 |                 .op_inherit => {
271 |                     const super = self.peek(1);
272 |                     if (!super.isClass()) {
273 |                         self.runtimeError("Superclass must be a class.", .{});
274 |                         return .interpret_runtime_error;
275 |                     }
276 |                     const sub = self.peek(0).asObject().asClass();
277 |                     sub.methods().tableAddAll(super.asObject().asClass().methods());
278 |                     _ = self.pop();
279 |                 },
280 |                 .op_method => {
281 |                     self.defineMethod(self.readString());
282 |                 },
283 |                 .op_get_property => {
284 |                     if (!self.peek(0).isInstance()) {
285 |                         self.runtimeError("Only instances have properties.", .{});
286 |                         return .interpret_runtime_error;
287 |                     }
288 |                     const instance = self.peek(0).asObject().asInstance();
289 |                     const name = self.readString();
290 | 
291 |                     if (instance.fields().tableGet(name)) |v| {
292 |                         _ = self.pop();
293 |                         self.push(v);
294 |                     } else if (!self.bindMethod(instance.class, name)) {
295 |                         return .interpret_runtime_error;
296 |                     }
297 |                 },
298 |                 .op_set_property => {
299 |                     if (!self.peek(1).isInstance()) {
300 |                         self.runtimeError("Only instances have properties.", .{});
301 |                         return .interpret_runtime_error;
302 |                     }
303 |                     const instance = self.peek(1).asObject().asInstance();
304 |                     _ = instance.fields().tableSet(self.readString(), self.peek(0));
305 |                     const v = self.pop();
306 |                     _ = self.pop();
307 |                     self.push(v);
308 |                 },
309 |             }
310 |         }
311 |     }
312 | 
313 |     pub fn push(self: *VM, val: Value) void {
314 |         std.debug.assert(@ptrToInt(self.stack_top) - @ptrToInt(self.stack) < stack_max);
315 |         self.stack_top.* = val;
316 |         self.stack_top += 1;
317 |     }
318 | 
319 |     pub fn pop(self: *VM) Value {
320 |         std.debug.assert(@ptrToInt(self.stack_top) - @ptrToInt(self.stack) > 0);
321 |         self.stack_top -= 1;
322 |         return self.stack_top[0];
323 |     }
324 | 
325 |     fn callValue(self: *VM, callee: Value, arg_count: usize) bool {
326 |         if (callee.isObject()) {
327 |             switch (callee.asObject().t) {
328 |                 .obj_closure => {
329 |                     return self.call(callee.asObject().asClosure(), arg_count);
330 |                 },
331 |                 .obj_native => {
332 |                     const native = callee.asObject().asNative().function().*;
333 |                     const result = native(arg_count, self.stack_top - arg_count);
334 |                     self.stack_top -= arg_count + 1;
335 |                     self.push(result);
336 |                     return true;
337 |                 },
338 |                 .obj_class => {
339 |                     const class = callee.asObject().asClass();
340 |                     (self.stack_top - arg_count - 1)[0] = Value.Object(object.newInstance(class));
341 |                     if (class.methods().tableGet(self.init_string.?)) |init| {
342 |                         return self.call(init.asObject().asClosure(), arg_count);
343 |                     } else if (arg_count > 0) {
344 |                         self.runtimeError("Expected 0 arguments but got {d}.", .{arg_count});
345 |                         return false;
346 |                     }
347 |                     return true;
348 |                 },
349 |                 .obj_bound_method => {
350 |                     const bound = callee.asObject().asBoundMethod();
351 |                     (self.stack_top - arg_count - 1)[0] = bound.receiver().*;
352 |                     return self.call(bound.method, arg_count);
353 |                 },
354 |                 else => {},
355 |             }
356 |         }
357 |         self.runtimeError("Can only call functions and classes.", .{});
358 |         return false;
359 |     }
360 | 
361 |     fn invoke(self: *VM, name: *object.ObjString, arg_count: u8) bool {
362 |         const receiver = self.peek(arg_count);
363 |         if (!receiver.isInstance()) {
364 |             self.runtimeError("Only instances have methods.", .{});
365 |             return false;
366 |         }
367 |         const instance = receiver.asObject().asInstance();
368 |         if (instance.fields().tableGet(name)) |field| {
369 |             (self.stack_top - arg_count - 1)[0] = field;
370 |             return self.callValue(field, arg_count);
371 |         }
372 |         return self.invokeFromClass(instance.class, name, arg_count);
373 |     }
374 | 
375 |     fn invokeFromClass(self: *VM, klass: *object.ObjClass, name: *object.ObjString, arg_count: u8) bool {
376 |         if (klass.methods().tableGet(name)) |method| {
377 |             return self.call(method.asObject().asClosure(), arg_count);
378 |         } else {
379 |             self.runtimeError("Undefined property '{s}'.", .{name.chars[0..name.length]});
380 |             return false;
381 |         }
382 |     }
383 | 
384 |     fn bindMethod(self: *VM, klass: *object.ObjClass, name: *object.ObjString) bool {
385 |         var method: ?Value = klass.methods().tableGet(name);
386 |         if (method) |m| {
387 |             const bound = object.newBoundMethod(self.peek(0), m.asObject().asClosure());
388 |             _ = self.pop();
389 |             self.push(Value.Object(bound));
390 |             return true;
391 |         } else {
392 |             self.runtimeError("Undefined property '{s}'.", .{name.chars[0..name.length]});
393 |             return false;
394 |         }
395 |     }
396 | 
397 |     fn captureUpvalue(self: *VM, local: *Value) *ObjUpvalue {
398 |         var prev_upvalue: ?*ObjUpvalue = null;
399 |         var upvalue = self.open_upvalues;
400 |         while (upvalue != null and @ptrToInt(upvalue.?.location) > @ptrToInt(local)) {
401 |             prev_upvalue = upvalue;
402 |             upvalue = upvalue.?.next;
403 |         }
404 |         if (upvalue != null and upvalue.?.location == local) {
405 |             return upvalue.?;
406 |         }
407 |         const created_upvalue = object.newUpvalue(local);
408 |         created_upvalue.next = upvalue;
409 |         if (prev_upvalue) |prev| {
410 |             prev.next = created_upvalue;
411 |         } else {
412 |             self.open_upvalues = created_upvalue;
413 |         }
414 |         return created_upvalue;
415 |     }
416 | 
417 |     fn closeUpvalues(self: *VM, last: *Value) void {
418 |         while (self.open_upvalues != null and @ptrToInt(self.open_upvalues.?.location) >= @ptrToInt(last)) {
419 |             const upvalue = self.open_upvalues.?;
420 |             upvalue.closed().* = upvalue.location.*;
421 |             upvalue.location = upvalue.closed();
422 |             self.open_upvalues = self.open_upvalues.?.next;
423 |         }
424 |     }
425 | 
426 |     fn defineMethod(self: *VM, name: *object.ObjString) void {
427 |         const method = self.peek(0);
428 |         const klass = self.peek(1).asObject().asClass();
429 |         _ = klass.methods().tableSet(name, method);
430 |         _ = self.pop();
431 |     }
432 | 
433 |     fn call(self: *VM, callee: *ObjClosure, arg_count: usize) bool {
434 |         if (arg_count != callee.function.arity) {
435 |             self.runtimeError("Expected {d} arguments but got {d}.", .{ callee.function.arity, arg_count });
436 |             return false;
437 |         }
438 |         if (self.frame_count == frames_max) {
439 |             self.runtimeError("Stack overflow.", .{});
440 |             return false;
441 |         }
442 |         var frame = &self.frames[self.frame_count];
443 |         self.frame_count += 1;
444 |         frame.closure = callee;
445 |         frame.ip = callee.function.chunk().code;
446 |         frame.slots = self.stack_top - arg_count - 1;
447 |         return true;
448 |     }
449 | 
450 |     fn resetStack(self: *VM) void {
451 |         self.stack_top = self.stack;
452 |     }
453 | 
454 |     fn runtimeError(self: *VM, comptime format: []const u8, args: anytype) void {
455 |         stderr.print(format, args) catch unreachable;
456 |         stderr.writeByte('\n') catch unreachable;
457 |         var index: isize = @intCast(isize, self.frame_count) - 1;
458 |         while (index >= 0) : (index -= 1) {
459 |             const frame = &self.frames[@intCast(usize, index)];
460 |             const function = frame.closure.function;
461 |             const instruction = @ptrToInt(frame.ip) - @ptrToInt(function.chunk().code) - 1;
462 |             stderr.print("[line {d}] in ", .{function.chunk().lines[instruction]}) catch unreachable;
463 |             if (function.name) |name| {
464 |                 stderr.print("{s}()\n", .{name.chars[0..name.length]}) catch unreachable;
465 |             } else {
466 |                 stderr.print("script\n", .{}) catch unreachable;
467 |             }
468 |         }
469 |         self.resetStack();
470 |     }
471 | 
472 |     fn defineNative(self: *VM, name: []const u8, function: object.NativeFn) void {
473 |         self.push(Value.Object(object.copyString(name.ptr, name.len)));
474 |         self.push(Value.Object(object.newNative(function)));
475 |         _ = self.globals.tableSet(self.stack[0].asObject().asString(), self.stack[1]);
476 |         _ = self.pop();
477 |         _ = self.pop();
478 |     }
479 | 
480 |     fn peek(self: *VM, distance: usize) Value {
481 |         return (self.stack_top - 1 - distance)[0];
482 |     }
483 | 
484 |     fn isFalsey(val: Value) bool {
485 |         return val.isNil() or (val.isBool() and !val.asBoolean());
486 |     }
487 | 
488 |     fn concatenate(self: *VM) void {
489 |         const b = self.peek(0).asObject().asString();
490 |         const a = self.peek(1).asObject().asString();
491 |         const length = a.length + b.length;
492 |         const chars = memory.allocate(u8, length + 1);
493 |         std.mem.copy(u8, chars[0..a.length], a.chars[0..a.length]);
494 |         std.mem.copy(u8, chars[a.length..length], b.chars[0..b.length]);
495 |         chars[length] = 0;
496 |         const result = object.takeString(chars, length);
497 |         _ = self.pop();
498 |         _ = self.pop();
499 |         self.push(Value.Object(result));
500 |     }
501 | 
502 |     inline fn readByte(self: *VM) u8 {
503 |         defer self.frame.ip += 1;
504 |         return self.frame.ip[0];
505 |     }
506 | 
507 |     inline fn readConstant(self: *VM) Value {
508 |         return self.frame.closure.function.chunk().constants.values[self.readByte()];
509 |     }
510 | 
511 |     inline fn readString(self: *VM) *object.ObjString {
512 |         return self.readConstant().asObject().asString();
513 |     }
514 | 
515 |     inline fn binary_op(self: *VM, comptime op: fn (f64, f64) Value) ?void {
516 |         if (!self.peek(0).isNumber() or !self.peek(1).isNumber()) {
517 |             self.runtimeError("Operands must be numbers.", .{});
518 |             return null;
519 |         }
520 |         const b = self.pop().asNumber();
521 |         const a = self.pop().asNumber();
522 |         self.push(op(a, b));
523 |         return;
524 |     }
525 | 
526 |     inline fn readShort(self: *VM) u16 {
527 |         self.frame.ip += 2;
528 |         return (@intCast(u16, (self.frame.ip - 2)[0]) << 8) | (self.frame.ip - 1)[0];
529 |     }
530 | };
531 | 
532 | pub const InterpretResult = enum {
533 |     interpret_ok,
534 |     interpret_compile_error,
535 |     interpret_runtime_error,
536 | };
537 | 


--------------------------------------------------------------------------------
/src/compiler.zig:
--------------------------------------------------------------------------------
  1 | const std = @import("std");
  2 | const scanner = @import("./scanner.zig");
  3 | const memory = @import("./memory.zig");
  4 | const common = @import("./common.zig");
  5 | const debug = @import("./debug.zig");
  6 | const object = @import("./object.zig");
  7 | const Chunk = @import("./chunk.zig").Chunk;
  8 | const Value = @import("./value.zig").Value;
  9 | const OpCode = @import("./chunk.zig").OpCode;
 10 | const TokenType = scanner.TokenType;
 11 | const Token = scanner.Token;
 12 | const ObjFunction = object.ObjFunction;
 13 | const Obj = object.Obj;
 14 | 
 15 | const stdout = common.stdout;
 16 | const stderr = common.stderr;
 17 | 
 18 | const Parser = struct {
 19 |     current: Token = undefined,
 20 |     previous: Token = undefined,
 21 |     had_error: bool = false,
 22 |     panic_mode: bool = false,
 23 | };
 24 | 
 25 | const Precedence = enum(u8) {
 26 |     prec_none,
 27 |     prec_assignment,
 28 |     prec_or,
 29 |     prec_and,
 30 |     prec_equality,
 31 |     prec_comparison,
 32 |     prec_term,
 33 |     prec_factor,
 34 |     prec_unary,
 35 |     prec_call,
 36 |     prec_primary,
 37 | };
 38 | 
 39 | const ParseFn = fn (can_assign: bool) void;
 40 | 
 41 | const ParseRule = struct {
 42 |     prefix: ?ParseFn,
 43 |     infix: ?ParseFn,
 44 |     precedence: Precedence,
 45 | };
 46 | 
 47 | const Compiler = struct {
 48 |     enclosing: ?*Compiler,
 49 |     function: *ObjFunction,
 50 |     fun_t: FunctionType,
 51 |     locals: [256]Local = undefined,
 52 |     local_count: u8 = 0,
 53 |     scope_depth: usize = 0,
 54 |     upvalues: [256]Upvalue = undefined,
 55 | 
 56 |     fn init(self: *Compiler, fun_t: FunctionType) void {
 57 |         var c: Compiler = .{ .enclosing = current, .fun_t = fun_t, .function = object.newFunction() };
 58 |         self.* = c;
 59 |         current = self;
 60 |         if (fun_t != .type_script) {
 61 |             c.function.name = object.copyString(p.previous.start, p.previous.length).asString();
 62 |         }
 63 |         var local = &self.locals[self.local_count];
 64 |         local.depth = 0;
 65 |         local.is_captured = false;
 66 |         if (fun_t != .type_function) {
 67 |             local.name.start = "this";
 68 |             local.name.length = 4;
 69 |         } else {
 70 |             local.name.start = "";
 71 |             local.name.length = 0;
 72 |         }
 73 |         self.local_count += 1;
 74 |     }
 75 | };
 76 | 
 77 | const ClassCompiler = struct {
 78 |     enclosing: ?*ClassCompiler,
 79 |     has_superclass: bool,
 80 | };
 81 | 
 82 | const Local = struct {
 83 |     name: Token,
 84 |     depth: isize,
 85 |     is_captured: bool,
 86 | };
 87 | 
 88 | const Upvalue = struct {
 89 |     index: u8,
 90 |     is_local: bool,
 91 | };
 92 | 
 93 | const FunctionType = enum { type_function, type_script, type_method, type_initializer };
 94 | 
 95 | const rules: [@enumToInt(TokenType.lox_eof) + 1]ParseRule = blk: {
 96 |     comptime var tmp: [@enumToInt(TokenType.lox_eof) + 1]ParseRule = .{.{ .prefix = null, .infix = null, .precedence = .prec_none }} ** (@enumToInt(TokenType.lox_eof) + 1);
 97 |     tmp[@enumToInt(TokenType.left_paren)] = .{ .prefix = grouping, .infix = call, .precedence = .prec_call };
 98 |     tmp[@enumToInt(TokenType.minus)] = .{ .prefix = unary, .infix = binary, .precedence = .prec_term };
 99 |     tmp[@enumToInt(TokenType.bang)] = .{ .prefix = unary, .infix = null, .precedence = .prec_none };
100 |     tmp[@enumToInt(TokenType.bang_equal)] = .{ .prefix = null, .infix = binary, .precedence = .prec_equality };
101 |     tmp[@enumToInt(TokenType.equal_equal)] = .{ .prefix = null, .infix = binary, .precedence = .prec_equality };
102 |     tmp[@enumToInt(TokenType.greater)] = .{ .prefix = null, .infix = binary, .precedence = .prec_comparison };
103 |     tmp[@enumToInt(TokenType.greater_equal)] = .{ .prefix = null, .infix = binary, .precedence = .prec_comparison };
104 |     tmp[@enumToInt(TokenType.less)] = .{ .prefix = null, .infix = binary, .precedence = .prec_comparison };
105 |     tmp[@enumToInt(TokenType.less_equal)] = .{ .prefix = null, .infix = binary, .precedence = .prec_comparison };
106 |     tmp[@enumToInt(TokenType.plus)] = .{ .prefix = null, .infix = binary, .precedence = .prec_term };
107 |     tmp[@enumToInt(TokenType.slash)] = .{ .prefix = null, .infix = binary, .precedence = .prec_factor };
108 |     tmp[@enumToInt(TokenType.star)] = .{ .prefix = null, .infix = binary, .precedence = .prec_factor };
109 |     tmp[@enumToInt(TokenType.number)] = .{ .prefix = number, .infix = null, .precedence = .prec_none };
110 |     tmp[@enumToInt(TokenType.lox_false)] = .{ .prefix = literal, .infix = null, .precedence = .prec_none };
111 |     tmp[@enumToInt(TokenType.lox_true)] = .{ .prefix = literal, .infix = null, .precedence = .prec_none };
112 |     tmp[@enumToInt(TokenType.lox_nil)] = .{ .prefix = literal, .infix = null, .precedence = .prec_none };
113 |     tmp[@enumToInt(TokenType.string)] = .{ .prefix = string, .infix = null, .precedence = .prec_none };
114 |     tmp[@enumToInt(TokenType.identifier)] = .{ .prefix = variable, .infix = null, .precedence = .prec_none };
115 |     tmp[@enumToInt(TokenType.lox_and)] = .{ .prefix = null, .infix = and_, .precedence = .prec_and };
116 |     tmp[@enumToInt(TokenType.lox_or)] = .{ .prefix = null, .infix = or_, .precedence = .prec_or };
117 |     tmp[@enumToInt(TokenType.dot)] = .{ .prefix = null, .infix = dot, .precedence = .prec_call };
118 |     tmp[@enumToInt(TokenType.lox_this)] = .{ .prefix = this_, .infix = null, .precedence = .prec_none };
119 |     tmp[@enumToInt(TokenType.lox_super)] = .{ .prefix = super_, .infix = null, .precedence = .prec_none };
120 |     break :blk tmp;
121 | };
122 | 
123 | var p: Parser = undefined;
124 | var current: ?*Compiler = null;
125 | var current_class: ?*ClassCompiler = null;
126 | var s: scanner.Scanner = undefined;
127 | 
128 | fn getRule(t: TokenType) *const ParseRule {
129 |     return &rules[@enumToInt(t)];
130 | }
131 | 
132 | fn currentChunk() *Chunk {
133 |     return current.?.function.chunk();
134 | }
135 | 
136 | pub fn compile(source: [:0]const u8) ?*ObjFunction {
137 |     p = Parser{};
138 |     s = scanner.Scanner.init(source);
139 |     var compiler: Compiler = undefined;
140 |     Compiler.init(&compiler, .type_script);
141 |     advance();
142 |     while (!match(.lox_eof)) declaration();
143 |     const fun = endCompiler();
144 |     return if (p.had_error) null else fun;
145 | }
146 | 
147 | pub fn markCompilerRoots() void {
148 |     var compiler: ?*Compiler = current;
149 |     while (compiler) |comp| : (compiler = comp.enclosing) {
150 |         memory.markObject(@ptrCast(*Obj, comp.function));
151 |     }
152 | }
153 | 
154 | fn synchronize() void {
155 |     p.panic_mode = false;
156 | 
157 |     while (p.current.t != .lox_eof) {
158 |         if (p.previous.t == .semicolon) return;
159 |         switch (p.current.t) {
160 |             .lox_class, .lox_fun, .lox_var, .lox_for, .lox_if, .lox_while, .lox_print, .lox_return => return,
161 |             else => {},
162 |         }
163 |         advance();
164 |     }
165 | }
166 | 
167 | fn expression() void {
168 |     parsePrecedence(.prec_assignment);
169 | }
170 | 
171 | fn block() void {
172 |     while (!check(.right_brace) and !check(.lox_eof)) declaration();
173 |     consume(.right_brace, "Expect '}' after block.");
174 | }
175 | 
176 | fn function(t: FunctionType) void {
177 |     var c: Compiler = undefined;
178 |     Compiler.init(&c, t);
179 |     beginScope();
180 | 
181 |     consume(.left_paren, "Expect '(' after functions name.");
182 |     if (!check(.right_paren)) {
183 |         while (true) {
184 |             current.?.function.arity += 1;
185 |             if (current.?.function.arity > 255) {
186 |                 errorAtCurrent("Can't have more than 255 parameters.");
187 |             }
188 |             const constant = parseVariable("Expect parameter name.");
189 |             defineVariable(constant);
190 |             if (!match(.comma)) break;
191 |         }
192 |     }
193 |     consume(.right_paren, "Expect ')' after parameters.");
194 |     consume(.left_brace, "Expect '{' before function body.");
195 |     block();
196 | 
197 |     const fun = endCompiler();
198 |     emitBytes(&.{ @enumToInt(OpCode.op_closure), makeConstant(Value.Object(@ptrCast(*object.Obj, fun))) });
199 | 
200 |     for (c.upvalues[0..fun.upvalue_count]) |upvalue| {
201 |         emitByte(if (upvalue.is_local) 1 else 0);
202 |         emitByte(upvalue.index);
203 |     }
204 | }
205 | 
206 | fn method() void {
207 |     consume(.identifier, "Expect method name.");
208 |     const constant = identifierConstant(&p.previous);
209 |     const t: FunctionType = if (p.previous.length == 4 and std.mem.eql(u8, @ptrCast(*const [4]u8, p.previous.start), "init"))
210 |         .type_initializer
211 |     else
212 |         .type_method;
213 |     function(t);
214 |     emitBytes(&.{ @enumToInt(OpCode.op_method), constant });
215 | }
216 | 
217 | fn beginScope() void {
218 |     current.?.scope_depth += 1;
219 | }
220 | 
221 | fn endScope() void {
222 |     current.?.scope_depth -= 1;
223 |     while (current.?.local_count > 0 and current.?.locals[@intCast(usize, current.?.local_count - 1)].depth > current.?.scope_depth) {
224 |         if (current.?.locals[current.?.local_count - 1].is_captured) {
225 |             emitByte(@enumToInt(OpCode.op_close_upvalue));
226 |         } else {
227 |             emitByte(@enumToInt(OpCode.op_pop));
228 |         }
229 |         current.?.local_count -= 1;
230 |     }
231 | }
232 | 
233 | fn varDeclaration() void {
234 |     const global = parseVariable("Expect variable name.");
235 | 
236 |     if (match(.equal)) expression() else emitByte(@enumToInt(OpCode.op_nil));
237 |     consume(.semicolon, "Expect ';' after a variable declaration.");
238 | 
239 |     defineVariable(global);
240 | }
241 | 
242 | fn funDeclaration() void {
243 |     const global = parseVariable("Expect function name");
244 |     markInitialized();
245 |     function(.type_function);
246 |     defineVariable(global);
247 | }
248 | 
249 | fn defineVariable(global: u8) void {
250 |     if (current.?.scope_depth > 0) {
251 |         markInitialized();
252 |         return;
253 |     }
254 |     emitBytes(&.{ @enumToInt(OpCode.op_define_global), global });
255 | }
256 | 
257 | fn markInitialized() void {
258 |     if (current.?.scope_depth == 0) return;
259 |     current.?.locals[current.?.local_count - 1].depth = @intCast(isize, current.?.scope_depth);
260 | }
261 | 
262 | fn declareVariable() void {
263 |     if (current.?.scope_depth == 0) return;
264 |     const name = &p.previous;
265 |     var i: usize = current.?.local_count;
266 |     while (i >= 0) : (i -= 1) {
267 |         const local = &current.?.locals[i];
268 |         if (local.depth != -1 and local.depth < current.?.scope_depth) break;
269 |         if (identifiersEqual(name, &local.name)) {
270 |             errorAtPrevious("Already a variable with this name in this scope.");
271 |         }
272 |     }
273 |     addLocal(name.*);
274 | }
275 | 
276 | fn addLocal(name: Token) void {
277 |     defer current.?.local_count += 1;
278 |     if (current.?.local_count >= 256) {
279 |         errorAtPrevious("Too many local variables in function.");
280 |         return;
281 |     }
282 |     const local = &current.?.locals[current.?.local_count];
283 |     local.name = name;
284 |     local.depth = -1;
285 |     local.is_captured = false;
286 | }
287 | 
288 | fn syntheticToken(text: []const u8) Token {
289 |     return .{
290 |         .t = TokenType.lox_nil,
291 |         .start = text.ptr,
292 |         .length = text.len,
293 |         .line = 0,
294 |     };
295 | }
296 | 
297 | fn expressionStatement() void {
298 |     expression();
299 |     consume(.semicolon, "Expect ';' after expression.");
300 |     emitByte(@enumToInt(OpCode.op_pop));
301 | }
302 | 
303 | fn ifStatement() void {
304 |     consume(.left_paren, "Expect '(' after 'if'.");
305 |     expression();
306 |     consume(.right_paren, "Expect ')' after condition.");
307 | 
308 |     const then_jump = emitJump(.op_jump_if_false);
309 |     emitByte(@enumToInt(OpCode.op_pop));
310 |     statement();
311 |     const else_jump = emitJump(.op_jump);
312 |     patchJump(then_jump);
313 | 
314 |     emitByte(@enumToInt(OpCode.op_pop));
315 |     if (match(.lox_else)) statement();
316 |     patchJump(else_jump);
317 | }
318 | 
319 | fn and_(_: bool) void {
320 |     const end_jump = emitJump(.op_jump_if_false);
321 | 
322 |     emitByte(@enumToInt(OpCode.op_pop));
323 |     parsePrecedence(.prec_and);
324 | 
325 |     patchJump(end_jump);
326 | }
327 | 
328 | fn or_(_: bool) void {
329 |     const else_jump = emitJump(.op_jump_if_false);
330 |     const end_jump = emitJump(.op_jump);
331 | 
332 |     patchJump(else_jump);
333 |     emitByte(@enumToInt(OpCode.op_pop));
334 | 
335 |     parsePrecedence(.prec_or);
336 |     patchJump(end_jump);
337 | }
338 | 
339 | fn printStatement() void {
340 |     expression();
341 |     consume(.semicolon, "Expect ';' after value.");
342 |     emitByte(@enumToInt(OpCode.op_print));
343 | }
344 | 
345 | fn whileStatement() void {
346 |     const loop_start = currentChunk().count;
347 |     consume(.left_paren, "Expect '(' after 'while'.");
348 |     expression();
349 |     consume(.right_paren, "Expect ')' after condition");
350 | 
351 |     const exit_jump = emitJump(.op_jump_if_false);
352 |     emitByte(@enumToInt(OpCode.op_pop));
353 |     statement();
354 |     emitLoop(loop_start);
355 | 
356 |     patchJump(exit_jump);
357 |     emitByte(@enumToInt(OpCode.op_pop));
358 | }
359 | 
360 | fn forStatement() void {
361 |     beginScope();
362 |     defer endScope();
363 |     consume(.left_paren, "Expect '(' after 'for'.");
364 |     if (match(.semicolon)) {} else if (match(.lox_var)) {
365 |         varDeclaration();
366 |     } else {
367 |         expressionStatement();
368 |     }
369 | 
370 |     var loop_start = currentChunk().count;
371 |     var exit_jump: ?u32 = null;
372 |     if (!match(.semicolon)) {
373 |         expression();
374 |         consume(.semicolon, "Expect ';' after loop condition");
375 |         exit_jump = emitJump(.op_jump_if_false);
376 |         emitByte(@enumToInt(OpCode.op_pop));
377 |     }
378 | 
379 |     if (!match(.right_paren)) {
380 |         const body_jump = emitJump(.op_jump);
381 |         const increment_start = currentChunk().count;
382 |         expression();
383 |         emitByte(@enumToInt(OpCode.op_pop));
384 |         consume(.right_paren, "Expect ')' after for clauses");
385 | 
386 |         emitLoop(loop_start);
387 |         loop_start = increment_start;
388 |         patchJump(body_jump);
389 |     }
390 | 
391 |     statement();
392 |     emitLoop(loop_start);
393 |     if (exit_jump) |ej| {
394 |         patchJump(ej);
395 |         emitByte(@enumToInt(OpCode.op_pop));
396 |     }
397 | }
398 | 
399 | fn declaration() void {
400 |     if (match(.lox_class)) classDeclaration() else if (match(.lox_fun)) funDeclaration() else if (match(.lox_var)) varDeclaration() else statement();
401 | 
402 |     if (p.panic_mode) synchronize();
403 | }
404 | 
405 | fn classDeclaration() void {
406 |     consume(.identifier, "Expect class name.");
407 |     var class_name = p.previous;
408 |     const name_constant = identifierConstant(&p.previous);
409 |     declareVariable();
410 | 
411 |     emitBytes(&.{ @enumToInt(OpCode.op_class), name_constant });
412 |     defineVariable(name_constant);
413 | 
414 |     var class_compiler = ClassCompiler{ .enclosing = current_class, .has_superclass = false };
415 |     current_class = &class_compiler;
416 | 
417 |     if (match(.less)) {
418 |         consume(.identifier, "Expect superclass name.");
419 |         variable(false);
420 |         if (identifiersEqual(&class_name, &p.previous)) {
421 |             errorAtPrevious("A class can't inherit from itself.");
422 |         }
423 |         beginScope();
424 |         addLocal(syntheticToken("super"));
425 |         defineVariable(0);
426 |         namedVariable(&class_name, false);
427 |         emitByte(@enumToInt(OpCode.op_inherit));
428 |         class_compiler.has_superclass = true;
429 |     }
430 | 
431 |     namedVariable(&class_name, false);
432 |     consume(.left_brace, "Expect '{' before class body.");
433 |     while (!check(.right_brace) and !check(.lox_eof)) {
434 |         method();
435 |     }
436 |     consume(.right_brace, "Expect '}' after class body.");
437 |     emitByte(@enumToInt(OpCode.op_pop));
438 | 
439 |     if (class_compiler.has_superclass) {
440 |         endScope();
441 |     }
442 | 
443 |     current_class = current_class.?.enclosing;
444 | }
445 | 
446 | fn statement() void {
447 |     if (match(.lox_print)) {
448 |         printStatement();
449 |     } else if (match(.lox_for)) {
450 |         forStatement();
451 |     } else if (match(.lox_if)) {
452 |         ifStatement();
453 |     } else if (match(.lox_return)) {
454 |         returnStatement();
455 |     } else if (match(.lox_while)) {
456 |         whileStatement();
457 |     } else if (match(.left_brace)) {
458 |         beginScope();
459 |         block();
460 |         endScope();
461 |     } else {
462 |         expressionStatement();
463 |     }
464 | }
465 | 
466 | fn returnStatement() void {
467 |     if (current.?.fun_t == .type_script) errorAtPrevious("Can't return from top-level code.");
468 |     if (match(.semicolon)) emitReturn() else {
469 |         if (current.?.fun_t == .type_initializer) {
470 |             errorAtCurrent("Can't return a value from an initializer.");
471 |         }
472 |         expression();
473 |         consume(.semicolon, "Expect ';' after return value.");
474 |         emitByte(@enumToInt(OpCode.op_return));
475 |     }
476 | }
477 | 
478 | fn number(_: bool) void {
479 |     var value = std.fmt.parseFloat(f64, p.previous.start[0..p.previous.length]) catch {
480 |         errorAtPrevious("Invalid character in number.");
481 |         return;
482 |     };
483 |     emitConstant(Value.Number(value));
484 | }
485 | 
486 | fn string(_: bool) void {
487 |     emitConstant(Value.Object(object.copyString(p.previous.start + 1, p.previous.length - 2)));
488 | }
489 | 
490 | fn variable(can_assign: bool) void {
491 |     namedVariable(&p.previous, can_assign);
492 | }
493 | 
494 | fn this_(_: bool) void {
495 |     if (current_class) |_| {
496 |         variable(false);
497 |     } else {
498 |         errorAtPrevious("Can't use 'this' outside of a class.");
499 |     }
500 | }
501 | 
502 | fn super_(_: bool) void {
503 |     if (current_class) |cc| {
504 |         if (!cc.has_superclass) {
505 |             errorAtPrevious("Can't use 'super' in a class with no superclass.");
506 |         }
507 |         consume(.dot, "Expect '.' after 'super'.");
508 |         consume(.identifier, "Expect superclass method name.");
509 |         const name = identifierConstant(&p.previous);
510 | 
511 |         namedVariable(&syntheticToken("this"), false);
512 |         if (match(.left_paren)) {
513 |             const arg_count = argumentList();
514 |             namedVariable(&syntheticToken("super"), false);
515 |             emitBytes(&.{ @enumToInt(OpCode.op_super_invoke), name });
516 |             emitByte(arg_count);
517 |         } else {
518 |             namedVariable(&syntheticToken("super"), true);
519 |             emitBytes(&.{ @enumToInt(OpCode.op_get_super), name });
520 |         }
521 |     } else {
522 |         errorAtPrevious("Can't use 'super' outside of a class.");
523 |     }
524 | }
525 | 
526 | fn namedVariable(name: *Token, can_assign: bool) void {
527 |     var getOp: u8 = undefined;
528 |     var setOp: u8 = undefined;
529 |     var arg = resolveLocal(current.?, name);
530 |     if (arg) |_| {
531 |         getOp = @enumToInt(OpCode.op_get_local);
532 |         setOp = @enumToInt(OpCode.op_set_local);
533 |     } else {
534 |         arg = resolveUpvalue(current.?, name);
535 |         if (arg) |_| {
536 |             getOp = @enumToInt(OpCode.op_get_upvalue);
537 |             setOp = @enumToInt(OpCode.op_set_upvalue);
538 |         } else {
539 |             arg = identifierConstant(name);
540 |             getOp = @enumToInt(OpCode.op_get_global);
541 |             setOp = @enumToInt(OpCode.op_set_global);
542 |         }
543 |     }
544 |     if (can_assign and match(.equal)) {
545 |         expression();
546 |         emitBytes(&.{ setOp, arg.? });
547 |     } else {
548 |         emitBytes(&.{ getOp, arg.? });
549 |     }
550 | }
551 | 
552 | fn grouping(_: bool) void {
553 |     expression();
554 |     consume(.right_paren, "Expect ')' after expression.");
555 | }
556 | 
557 | fn call(_: bool) void {
558 |     const arg_count = argumentList();
559 |     emitBytes(&.{ @enumToInt(OpCode.op_call), arg_count });
560 | }
561 | 
562 | fn dot(can_assign: bool) void {
563 |     consume(.identifier, "Expect property name after '.'.");
564 |     const name = identifierConstant(&p.previous);
565 | 
566 |     if (can_assign and match(.equal)) {
567 |         expression();
568 |         emitBytes(&.{ @enumToInt(OpCode.op_set_property), name });
569 |     } else if (match(.left_paren)) {
570 |         const arg_count = argumentList();
571 |         emitBytes(&.{ @enumToInt(OpCode.op_invoke), name });
572 |         emitByte(arg_count);
573 |     } else {
574 |         emitBytes(&.{ @enumToInt(OpCode.op_get_property), name });
575 |     }
576 | }
577 | 
578 | fn argumentList() u8 {
579 |     var arg_count: u8 = 0;
580 |     if (!check(.right_paren)) {
581 |         while (true) {
582 |             expression();
583 |             if (arg_count == 255) {
584 |                 errorAtPrevious("Can't have more than 255 arguments.");
585 |             }
586 |             arg_count += 1;
587 |             if (!match(.comma)) break;
588 |         }
589 |     }
590 |     consume(.right_paren, "Expect ')' after arguments.");
591 |     return arg_count;
592 | }
593 | 
594 | fn unary(_: bool) void {
595 |     const operator_type = p.previous.t;
596 | 
597 |     parsePrecedence(.prec_unary);
598 | 
599 |     switch (operator_type) {
600 |         .bang => emitByte(@enumToInt(OpCode.op_not)),
601 |         .minus => emitByte(@enumToInt(OpCode.op_negate)),
602 |         else => unreachable,
603 |     }
604 | }
605 | 
606 | fn binary(_: bool) void {
607 |     const operator_type = p.previous.t;
608 |     const rule = getRule(operator_type);
609 |     parsePrecedence(@intToEnum(Precedence, @enumToInt(rule.precedence) + 1));
610 |     switch (operator_type) {
611 |         .bang_equal => emitBytes(&.{ @enumToInt(OpCode.op_equal), @enumToInt(OpCode.op_not) }),
612 |         .equal_equal => emitByte(@enumToInt(OpCode.op_equal)),
613 |         .greater => emitByte(@enumToInt(OpCode.op_greater)),
614 |         .greater_equal => emitBytes(&.{ @enumToInt(OpCode.op_less), @enumToInt(OpCode.op_not) }),
615 |         .less => emitByte(@enumToInt(OpCode.op_less)),
616 |         .less_equal => emitBytes(&.{ @enumToInt(OpCode.op_greater), @enumToInt(OpCode.op_not) }),
617 |         .plus => emitByte(@enumToInt(OpCode.op_add)),
618 |         .minus => emitByte(@enumToInt(OpCode.op_subtract)),
619 |         .star => emitByte(@enumToInt(OpCode.op_multiply)),
620 |         .slash => emitByte(@enumToInt(OpCode.op_divide)),
621 |         else => return,
622 |     }
623 | }
624 | 
625 | fn literal(_: bool) void {
626 |     switch (p.previous.t) {
627 |         .lox_false => emitByte(@enumToInt(OpCode.op_false)),
628 |         .lox_true => emitByte(@enumToInt(OpCode.op_true)),
629 |         .lox_nil => emitByte(@enumToInt(OpCode.op_nil)),
630 |         else => unreachable,
631 |     }
632 | }
633 | 
634 | fn parsePrecedence(precedence: Precedence) void {
635 |     advance();
636 |     const prefix_rule = getRule(p.previous.t).prefix;
637 |     var can_assign: bool = undefined;
638 |     if (prefix_rule) |rule| {
639 |         can_assign = @enumToInt(precedence) <= @enumToInt(Precedence.prec_assignment);
640 |         rule(can_assign);
641 |     } else {
642 |         errorAtPrevious("Expect expression.");
643 |         return;
644 |     }
645 | 
646 |     while (@enumToInt(precedence) <= @enumToInt(getRule(p.current.t).precedence)) {
647 |         advance();
648 |         const infix_rule = getRule(p.previous.t).infix;
649 |         infix_rule.?(can_assign);
650 |     }
651 |     if (can_assign and match(.equal)) {
652 |         errorAtPrevious("Invalid assignment target.");
653 |     }
654 | }
655 | 
656 | fn parseVariable(errorMessage: []const u8) u8 {
657 |     consume(.identifier, errorMessage);
658 |     declareVariable();
659 |     if (current.?.scope_depth > 0) return 0;
660 |     return identifierConstant(&p.previous);
661 | }
662 | 
663 | fn identifierConstant(name: *Token) u8 {
664 |     return makeConstant(Value.Object(object.copyString(name.start, name.length)));
665 | }
666 | 
667 | fn identifiersEqual(a: *Token, b: *Token) bool {
668 |     return std.mem.eql(u8, a.start[0..a.length], b.start[0..b.length]);
669 | }
670 | 
671 | fn resolveLocal(compiler: *Compiler, name: *Token) ?u8 {
672 |     var i: isize = compiler.local_count;
673 |     i -= 1;
674 |     while (i >= 0) : (i -= 1) {
675 |         const local = &compiler.locals[@intCast(u8, i)];
676 |         if (identifiersEqual(name, &local.name)) {
677 |             if (local.depth == -1) {
678 |                 errorAtPrevious("Can't read local variable in its own initializer.");
679 |             }
680 |             return @intCast(u8, i);
681 |         }
682 |     }
683 |     return null;
684 | }
685 | 
686 | fn resolveUpvalue(compiler: *Compiler, name: *Token) ?u8 {
687 |     const enc = compiler.enclosing orelse return null;
688 |     const local = resolveLocal(enc, name);
689 |     if (local) |index| {
690 |         enc.locals[index].is_captured = true;
691 |         return addUpvalue(compiler, index, true);
692 |     }
693 | 
694 |     const upvalue = resolveUpvalue(enc, name);
695 |     if (upvalue) |index| {
696 |         return addUpvalue(compiler, index, false);
697 |     }
698 |     return null;
699 | }
700 | 
701 | fn addUpvalue(compiler: *Compiler, index: u8, is_local: bool) u8 {
702 |     const upvalue_count = compiler.function.upvalue_count;
703 | 
704 |     for (compiler.upvalues[0..upvalue_count]) |*upvalue, i| {
705 |         if (upvalue.index == index and upvalue.is_local == is_local) return @intCast(u8, i);
706 |     }
707 | 
708 |     if (upvalue_count == 256) {
709 |         errorAtPrevious("Too many closure variables in function.");
710 |         return 0;
711 |     }
712 | 
713 |     compiler.upvalues[upvalue_count].is_local = is_local;
714 |     compiler.upvalues[upvalue_count].index = index;
715 |     compiler.function.upvalue_count += 1;
716 |     return upvalue_count;
717 | }
718 | 
719 | fn advance() void {
720 |     p.previous = p.current;
721 | 
722 |     while (true) {
723 |         p.current = s.scanToken();
724 |         if (p.current.t != .lox_error) break;
725 | 
726 |         errorAtCurrent(p.current.start[0..p.current.length]);
727 |     }
728 | }
729 | 
730 | fn consume(t: TokenType, message: []const u8) void {
731 |     if (p.current.t == t) {
732 |         advance();
733 |         return;
734 |     }
735 | 
736 |     errorAtCurrent(message);
737 | }
738 | 
739 | fn match(token: TokenType) bool {
740 |     if (!check(token)) return false;
741 |     advance();
742 |     return true;
743 | }
744 | 
745 | fn check(token: TokenType) bool {
746 |     return p.current.t == token;
747 | }
748 | 
749 | fn makeConstant(value: Value) u8 {
750 |     const constant = currentChunk().addConstant(value);
751 |     if (constant >= std.math.maxInt(u8)) {
752 |         errorAtPrevious("Too many constants in one chunk.");
753 |         return 0;
754 |     }
755 | 
756 |     return @intCast(u8, constant);
757 | }
758 | 
759 | fn emitByte(byte: u8) void {
760 |     currentChunk().writeChunk(byte, @intCast(u32, p.previous.line));
761 | }
762 | 
763 | fn emitBytes(bytes: []const u8) void {
764 |     for (bytes) |byte| {
765 |         emitByte(byte);
766 |     }
767 | }
768 | 
769 | fn emitJump(instruction: OpCode) u32 {
770 |     emitByte(@enumToInt(instruction));
771 |     emitByte(0xFF);
772 |     emitByte(0xFF);
773 |     return currentChunk().count - 2;
774 | }
775 | 
776 | fn emitLoop(start: u32) void {
777 |     emitByte(@enumToInt(OpCode.op_loop));
778 |     const offset = currentChunk().count - start + 2;
779 |     if (offset > 0xFFFF) errorAtPrevious("Loop body too large.");
780 |     emitByte(@truncate(u8, offset >> 8));
781 |     emitByte(@truncate(u8, offset));
782 | }
783 | 
784 | fn patchJump(offset: u32) void {
785 |     const jump = currentChunk().count - offset - 2;
786 |     if (jump > 0xFFFF) {
787 |         errorAtPrevious("Too much code to jump over.");
788 |     }
789 |     currentChunk().code[offset] = @truncate(u8, jump >> 8);
790 |     currentChunk().code[offset + 1] = @truncate(u8, jump);
791 | }
792 | 
793 | fn emitReturn() void {
794 |     if (current.?.fun_t == .type_initializer) {
795 |         emitBytes(&.{ @enumToInt(OpCode.op_get_local), 0 });
796 |     } else {
797 |         emitByte(@enumToInt(OpCode.op_nil));
798 |     }
799 |     emitByte(@enumToInt(OpCode.op_return));
800 | }
801 | 
802 | fn emitConstant(value: Value) void {
803 |     emitBytes(&.{ @enumToInt(OpCode.op_constant), makeConstant(value) });
804 | }
805 | 
806 | fn endCompiler() *ObjFunction {
807 |     emitReturn();
808 |     const fun = current.?.function;
809 |     if (comptime common.dump_enabled) {
810 |         if (!p.had_error) {
811 |             debug.disassembleChunk(currentChunk(), if (fun.name) |name| name.chars[0..name.length] else "<script>");
812 |         }
813 |     }
814 |     current = current.?.enclosing;
815 |     return fun;
816 | }
817 | 
818 | fn errorAtCurrent(message: []const u8) void {
819 |     errorAt(&p.current, message);
820 | }
821 | 
822 | // aka error()
823 | fn errorAtPrevious(message: []const u8) void {
824 |     errorAt(&p.previous, message);
825 | }
826 | 
827 | fn errorAt(token: *Token, message: []const u8) void {
828 |     if (p.panic_mode) return;
829 |     p.panic_mode = true;
830 |     stderr.print("[line {d}] Error", .{token.line}) catch unreachable;
831 | 
832 |     if (token.t == .lox_eof) {
833 |         stderr.print(" at end", .{}) catch unreachable;
834 |     } else if (token.t == .lox_error) {
835 |         // Nothing
836 |     } else {
837 |         stderr.print(" at '{s}\n'", .{token.start[0..token.length]}) catch unreachable;
838 |     }
839 | 
840 |     stderr.print(": {s}\n", .{message}) catch unreachable;
841 |     p.had_error = true;
842 | }
843 | 


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