zahl

vm.zig (12226B)

---

 const std = @import("std");
 const c = @import("chunk.zig");
 const v = @import("value.zig");
 
 const vmlog = std.log.scoped(.vm);
 
 // TODO: efficient stack implementation at some point ?
 const Stack = std.ArrayList(*v.Value);
 
 const VMError = error {
     UndefinedSymbol,
     InvalidType,
     OutOfMemory,
     NegativeIntoUnsigned,
     TargetTooSmall,
     NativeError,
 } || std.fs.File.WriteError;
 
 const CallFrame = struct {
     ip: []const c.Op,
     offset: usize,
     func: *const v.Function,
 };
 
 const CallStack = std.ArrayList(CallFrame);
 
 pub const VM = struct {
     const Self = @This();
 
     stack: Stack,
     all: std.mem.Allocator,
     call_stack: CallStack,
 
     // Global variables
     globals: std.StringHashMap(*v.Value),
 
     pub fn init(all: std.mem.Allocator) !Self {
         return Self{
             .stack = try Stack.initCapacity(all, 256),
             .all = all,
             .globals = std.StringHashMap(*v.Value).init(all),
             .call_stack = CallStack.init(all),
         };
     }
 
     pub fn setupCore(self: *Self, comptime funcs: []const v.NativeFunction) !void {
         inline for (funcs) |func| {
             try self.globals.put(func.name, try v.Value.newNative(self.all, func));
         }
     }
 
     fn push(self: *Self, val: *v.Value) !void {
         try self.stack.append(val);
     }
 
     fn pop(self: *Self) *v.Value {
         return self.stack.pop();
     }
 
     fn peek(self: *Self) *v.Value {
         return self.stack.getLast();
     }
 
     fn currentFrame(self: *Self) *CallFrame {
         return &self.call_stack.items[self.call_stack.items.len - 1];
     }
 
     pub fn interpret(self: *Self, func: *const v.Function) VMError!*v.Value {
         std.debug.assert(self.call_stack.items.len == 0);
         try self.call_stack.append(.{
             .offset = 0,
             .func = func,
             .ip = func.code.instrs.items,
         });
 
         const start_time = std.time.microTimestamp();
         const res = self.run();
         const end_time = std.time.microTimestamp();
         vmlog.info("Eval in {} us", .{end_time - start_time});
 
         return res;
     }
 
     fn advanceIp(self: *Self) void {
         self.currentFrame().ip = self.currentFrame().ip[1..];
     }
 
     fn doPopScope(self: *Self, offset: u16, amount: u16) !void {
         var valbuf: [255]*v.Value = undefined;
 
         for (0..offset) |idx| {
             valbuf[idx] = self.pop();
         }
 
         for (0..amount) |_| {
             self.pop().unref();
         }
 
 
         for (0..offset) |idx| {
             try self.push(valbuf[offset - idx - 1]);
         }
     }
 
     fn run(self: *Self) !*v.Value {
         while (true) {
             const cframe = self.currentFrame();
             const instr = cframe.ip[0];
             const cchunk = cframe.func.code;
 
             if (comptime std.log.logEnabled(.debug, .vm)) {
                 // TODO: proper logging here
                 for (self.stack.items) |val| {
                     std.debug.print("[{}] ", .{val.formatter()});
                 }
                 std.debug.print("\n", .{});
                 cchunk.disassembleInstr(instr);
             }
 
             switch (instr) {
                 .constant => |vindex| {
                     const val = cchunk.values.items[vindex];
                     try self.push(val.ref());
                     self.advanceIp();
                 },
 
                 .local => |vindex| {
                     const val = self.stack.items[vindex + cframe.offset];
                     try self.push(val.ref());
                     self.advanceIp();
                 },
 
                 .get_global => |vindex| {
                     const sym = cchunk.values.items[vindex];
                     if (!sym.isA(.symbol)) {
                         return VMError.InvalidType;
                     }
 
                     vmlog.debug("Getting {s}", .{sym.val.symbol});
 
                     if (self.globals.get(sym.val.symbol)) |found| {
                         try self.push(found.ref());
                     } else {
                         return VMError.UndefinedSymbol;
                     }
                     self.advanceIp();
                 },
 
                 .print => {
                     const val = self.stack.getLast();
 
                     var stdout = std.io.getStdOut().writer();
 
                     try stdout.print("{}\n", .{val.formatter()});
 
                     self.advanceIp();
                 },
 
                 .define_global => |index| {
                     const sym = cchunk.values.items[index];
                     const val = self.pop();
 
                     std.debug.assert(sym.isA(.symbol));
 
                     vmlog.debug("Defining {s}", .{sym.val.symbol});
                     if (try self.globals.fetchPut(sym.val.symbol, val)) |old| {
                         old.value.unref();
                     }
                     self.advanceIp();
                 },
 
                 .jumpfalse => |offset| {
                     const val = self.pop();
                     defer val.unref();
 
                     if (val.isFalsy()) {
                         cframe.ip = cchunk.instrs.items[offset..];
                     } else {
                         self.advanceIp();
                     }
                 },
                 .jump => |offset| {
                     cframe.ip = cchunk.instrs.items[offset..];
                 },
 
                 .call => |arity| {
                     const funcval = self.pop();
                     defer funcval.unref();
 
                     switch (funcval.val) {
                         .function => |func| {
                             std.debug.assert(arity == func.arity);
 
                             const offset = self.stack.items.len - arity;
 
                             const frame: CallFrame = .{.ip = func.code.instrs.items, .offset = offset, .func = &funcval.val.function};
 
                             self.advanceIp();
                             try self.call_stack.append(frame);
                         },
                         .native => |n| {
                             std.debug.assert(arity == n.arity);
 
                             const offset = self.stack.items.len - arity;
                             var new = n.code(self.stack.items[offset..], self.all) catch return VMError.NativeError;
                             errdefer new.unref();
 
                             self.advanceIp();
 
                             try self.doPopScope(0, n.arity);
 
                             try self.push(new);
                         },
                         else => return VMError.InvalidType,
                     }
                 },
 
                 .@"return" => {
                     const frame = self.call_stack.pop();
 
                     if (self.call_stack.items.len == 0) {
                         // XXX: no unref because we return
                         if (self.stack.items.len > 0) {
                             return self.pop();
                         } else {
                             return try v.Value.newNil(self.all);
                         }
                     } else {
                         try self.doPopScope(1, frame.func.arity);
                     }
                 },
 
                 .pop => pop: {
                     self.advanceIp();
                     break :pop self.pop().unref();
                 },
 
                 .popscope => |amount| {
                     try self.doPopScope(amount.offset, amount.scope);
                     self.advanceIp();
                 },
 
                 .negate => {
                     var val = self.pop();
                     defer val.unref();
 
                     std.debug.assert(val.isA(.number));
 
                     var n = try v.Int.cloneWithDifferentAllocator(val.val.number, self.all);
                     n.negate();
 
                     var new = try v.Value.newInt(self.all, n);
                     errdefer new.unref();
 
                     try self.push(new);
                     self.advanceIp();
                 },
 
                 .cons => {
                     var head = self.pop();
                     defer head.unref();
 
                     var lst = self.pop();
                     defer lst.unref();
 
                     if (!lst.isA(.list)) {
                         return VMError.InvalidType;
                     }
 
                     var newarr = try self.all.alloc(*v.Value, lst.val.list.len + 1);
 
                     newarr[0] = head.ref();
                     for (lst.val.list, 1..) |oldval, idx| {
                         newarr[idx] = oldval.ref();
                     }
 
                     errdefer {
                         for (newarr) |nval| {
                             nval.unref();
                         }
                         self.all.free(newarr);
                     }
 
                     try self.push(try v.Value.newList(self.all, newarr));
                     self.advanceIp();
                 },
 
                 .uncons => {
                     var lst = self.pop();
                     defer lst.unref();
 
                     if (!lst.isA(.list)) {
                         return VMError.InvalidType;
                     }
 
                     const oldarr = lst.val.list;
 
                     var newarr = try self.all.alloc(*v.Value, oldarr.len - 1);
 
                     for (oldarr[1..], 0..) |oldval, idx| {
                         newarr[idx] = oldval.ref();
                     }
                     errdefer {
                         for (newarr) |nval| {
                             nval.unref();
                         }
                         self.all.free(newarr);
                     }
 
                     try self.push(try v.Value.newList(self.all, newarr));
                     try self.push(oldarr[0].ref());
                     self.advanceIp();
                 },
 
                 .div => {
                     var left = self.pop();
                     defer left.unref();
 
                     var right = self.pop();
                     defer right.unref();
 
                     var div = try v.Int.init(self.all);
                     var rem = try v.Int.init(self.all);
 
                     try div.divTrunc(&rem, &left.val.number, &right.val.number);
 
                     try self.push(try v.Value.newInt(self.all, div));
                     try self.push(try v.Value.newInt(self.all, rem));
                     self.advanceIp();
                 },
 
                 inline .add, .multiply, .substract, .pow => |_, tag| {
                     var left = self.pop();
                     defer left.unref();
 
                     var right = self.pop();
                     defer right.unref();
 
                     const lnum = &left.val.number;
                     const rnum = &right.val.number;
 
                     var new = try v.Int.init(self.all);
                     errdefer new.deinit();
 
                     switch (tag) {
                         .add => try new.add(lnum, rnum),
                         .substract => try new.sub(lnum, rnum),
                         .multiply => try new.mul(lnum, rnum),
                         .pow => try new.pow(lnum, try rnum.to(u32)),
                         else => {
                             // Unreachable
                         },
                     }
 
                     try self.push(try v.Value.newInt(self.all, new));
                     self.advanceIp();
                 },
 
                 .compare => |op| {
                     var left = self.pop();
                     defer left.unref();
 
                     var right = self.pop();
                     defer right.unref();
 
                     const lnum = left.val.number;
                     const rnum = right.val.number;
 
                     try self.push(try v.Value.newBool(self.all, lnum.order(rnum).compare(op)));
                     self.advanceIp();
                 }
             }
         }
     }
 
     pub fn deinit(self: *Self) void {
         for (self.stack.items) |val| {
             val.unref();
         }
         self.stack.deinit();
 
         var iter = self.globals.iterator();
 
         while (iter.next()) |entry| {
             entry.value_ptr.*.unref();
         }
         self.globals.deinit();
 
         self.call_stack.deinit();
     }
 };