zahl

value.zig (7144B)

---

 const std = @import("std");
 const c = @import("chunk.zig");
 pub const Int = std.math.big.int.Managed;
 
 pub const Special = enum {
     // Builtin math operations
     @"+",
     @"/",
     @"*",
     @"^",
     @"-",
     @"%",
 
     @"let*",
     @"if",
     @"defn!",
     @"print!",
 
 
     // Comparisons
     @"=",
     @"<",
 
     // List manipulation
     cons,
     fst,
     rest,
     list,
 
     // somewhat imperative programming ?
     do,
 };
 
 pub const Function = struct {
     const Self = @This();
 
     code: c.Chunk,
     all: std.mem.Allocator,
     arity: u16,
     name: []const u8 = "_main",
 
     pub fn init(all: std.mem.Allocator) Self {
         return Self {
             .code = c.Chunk.init(all),
             .all = all,
             .arity = 0,
         };
     }
 
     pub fn deinit(self: *Self) void {
         self.code.deinit();
     }
 };
 
 pub const NativeError = error {
     InvalidType,
     OutOfMemory
 };
 
 pub const NativePayload = *const fn(args: []*Value, all: std.mem.Allocator) anyerror!*Value;
 pub const NativeFunction = struct {
     arity: u16,
     name: []const u8,
     code: NativePayload,
 };
 
 const vallog = std.log.scoped(.val);
 pub const Value = struct {
     const Self = @This();
 
     const Payload = union(enum) {
         number: Int,
         list: []*Value,
         symbol: []const u8,
         special: Special,
         function: Function,
         native: NativeFunction,
         true,
         false,
         nil,
     };
 
     // XXX: It is very important that payload is not modified !
     val: Payload,
     all: std.mem.Allocator,
     refcount: usize,
 
     pub const Tag: type = @typeInfo(Payload).Union.tag_type.?;
 
     fn init(payload: Payload, all: std.mem.Allocator) !*Self {
         var new = try all.create(Self);
         new.val = payload;
         new.all = all;
         new.refcount = 1;
 
         return new;
     }
 
     pub fn newInt(all: std.mem.Allocator, val: anytype) !*Self {
         var payload = if (@TypeOf(val) == Int) val else (try Int.initSet(all, val));
 
         if (intcache.get(payload)) |cached| {
             payload.deinit();
             return cached.ref();
         } else {
             var new = try Self.init(.{ .number = payload }, all);
             try intcache.put(payload, new);
             return new.ref();
         }
     }
 
     // orig has to be allocated with all
     pub fn newSymbol(all: std.mem.Allocator, orig: []const u8) !*Self {
         return try Self.init(.{ .symbol = orig }, all);
     }
 
     // lst has to be allocated with all
     pub fn newList(all: std.mem.Allocator, lst: []*Value) !*Self {
         return try Self.init(.{ .list = lst }, all);
     }
 
     pub fn newNil(all: std.mem.Allocator) !*Self {
         return try Self.init(.nil, all);
     }
 
     pub fn newSpecial(all: std.mem.Allocator, val: Special) !*Self {
         return try Self.init(.{ .special = val }, all);
     }
 
     pub fn newBool(all: std.mem.Allocator, val: bool) !*Self {
         _ = all;
         return if (val) trueval.ref() else falseval.ref();
     }
 
     pub fn newFunction(all: std.mem.Allocator, val: Function) !*Self {
         return try Self.init(.{ .function = val }, all);
     }
 
     pub fn newNative(all: std.mem.Allocator, val: NativeFunction) !*Self {
         return try Self.init(.{.native = val}, all);
     }
 
     pub fn ref(self: *Self) *Self {
         self.refcount += 1;
         return self;
     }
 
     pub fn weakref(self: *Self) *Self {
         // TODO: implement something to avoid invalid accesses later ?
         return self;
     }
 
     pub fn unref(self: *Self) void {
         self.refcount -= 1;
 
         if (self.refcount == 0) {
             self.deinit();
         }
     }
 
     pub fn deinit(self: *Self) void {
         vallog.debug("Destroy {}", .{self.formatter()});
         switch (self.val) {
             .number => |_| {
                 // XXX: numbers are freed when the cache is cleared
             },
             .list => |lst| {
                 for (lst) |val| {
                     val.unref();
                 }
                 self.all.free(lst);
             },
             .symbol => |_| {
                 // Symbols are interned
                 // self.all.free(sym);
             },
             .function => |*fun| {
                 fun.deinit();
             },
             .native => |_| {
 
             },
             .nil, .special, .true, .false => {},
         }
         self.all.destroy(self);
     }
 
     pub fn isA(self: Self, tag: Tag) bool {
         return @as(Tag, self.val) == tag;
     }
 
     pub fn isFalsy(self: Self) bool {
         return switch (self.val) {
             .false, .nil => true,
             else => false,
         };
     }
 
     pub fn formatter(self: *const Self) std.fmt.Formatter(Self.format) {
         return .{ .data = self };
     }
 
     fn format(self: *const Self, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
         switch (self.val) {
             .number => |num| {
                 if (fmt.len > 0 and fmt[0] == 'f') {
                     const digits = try num.toString(self.all, 10, std.fmt.Case.upper);
                     defer self.all.free(digits);
                     try writer.writeAll(digits);
                 } else {
                     try std.fmt.format(writer, "{}", .{num});
                 }
             },
             .list => |lst| {
                 try writer.writeByte('(');
                 for (lst, 0..) |sub, idx| {
                     if (idx > 0) {
                         try writer.writeByte(' ');
                     }
                     try sub.format(fmt, options, writer);
                 }
                 try writer.writeByte(')');
             },
             .symbol => |sym| try writer.writeAll(sym),
             .special => |s| try writer.writeAll(@tagName(s)),
             .function => |f| try writer.print("<function {s}>", .{f.name}),
             .native => |n| try writer.print("<native {s}>", .{n.name}),
             inline .nil, .true, .false => |_, tag| try writer.writeAll(@tagName(tag)),
         }
     }
 };
 
 var trueval: *Value = undefined;
 var falseval: *Value = undefined;
 
 const IntHashContext = struct {
     pub fn hash(_: @This(), v: Int) u64 {
         var wh = std.hash.Wyhash.init(0xDEADBEEF);
         for (v.limbs[0..v.len()]) |limb| {
             wh.update(std.mem.asBytes(&limb));
         }
         return wh.final();
     }
 
     pub fn eql(_: @This(), left: Int, right: Int) bool {
         return left.eql(right);
     }
 };
 
 const IntHashMap = std.HashMap(Int, *Value, IntHashContext, 80);
 
 // FIXME: this seems to be a good idea (20% perf gain) but consumes too much memory.
 // maybe having some garbage collection is good for ints ?
 var intcache: IntHashMap = undefined;
 
 pub fn init(all: std.mem.Allocator) !void {
     trueval = try Value.init(.true, all);
     falseval = try Value.init(.false, all);
     intcache = IntHashMap.init(all);
 }
 
 pub fn deinit() void {
     trueval.unref();
     falseval.unref();
 
     var iter = intcache.iterator();
 
     while (iter.next()) |entry| {
         // First unref to avoid invalid memory accesses
         entry.value_ptr.*.unref();
         entry.key_ptr.deinit();
     }
 
     intcache.deinit();
 }