Implement istr.

8 files changed, 148 insertions, 18 deletions

diff --git a/src/libzisp/gc.zig b/src/libzisp/gc.zig
index 92b4387..46ac091 100644
--- a/src/libzisp/gc.zig
+++ b/src/libzisp/gc.zig
@@ -5,18 +5,38 @@ const value = @import("value.zig");
 const Value = value.Value;
 const Hval = value.Hval;
 
-var _gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
+var _gpa = std.heap.GeneralPurposeAllocator(.{}).init;
 const gpa = _gpa.allocator();
 
-var cpool = std.heap.MemoryPool([2]Value).init(gpa);
+// Cons cells
+
+var cons_pool = std.heap.MemoryPool([2]Value).init(gpa);
 
 pub fn cons(v1: Value, v2: Value) *[2]Value {
-    const mem = cpool.create() catch @panic("OOM");
+    const mem = cons_pool.create() catch @panic("OOM");
     mem[0] = v1;
     mem[1] = v2;
     return mem;
 }
 
-pub fn alloc(count: usize) []Hval {
-    return gpa.alloc(Hval, count) catch @panic("OOM");
+// Interned strings
+
+var istr_pool = std.hash_map.StringHashMap(void).init(gpa);
+
+pub fn intern(header: value.seq.Header, str: []const u8) [*]Hval {
+    comptime {
+        std.debug.assert(@sizeOf(value.seq.Header) == 8);
+    }
+    const size = str.len + 8;
+    const copy = gpa.alloc(u8, size) catch @panic("OOM");
+    const header_bytes: [8]u8 = @bitCast(header);
+    @memcpy(copy[0..8], &header_bytes);
+    @memcpy(copy[8..size], str);
+    const entry = istr_pool.getOrPutValue(copy, {}) catch @panic("OOM");
+    return @ptrCast(entry.key_ptr);
+}
+
+pub fn istrHeader(ptr: [*]Hval) *value.seq.Header {
+    const entry_key: *[]u8 = @ptrCast(ptr);
+    return @alignCast(@ptrCast(entry_key.ptr));
 }
diff --git a/src/libzisp/io/unparser.zig b/src/libzisp/io/unparser.zig
index c25e918..dd48364 100644
--- a/src/libzisp/io/unparser.zig
+++ b/src/libzisp/io/unparser.zig
@@ -34,8 +34,7 @@ fn unparseHeap(w: anytype, v: Value) !void {
     const p, const t = value.ptr.unpack(v);
     try switch (t) {
         .pair => unparsePair(w, p),
-        .istr => @panic("not implemented"),
-        .proc => @panic("not implemented"),
+        else => @panic("not implemented"),
     };
 }
 
diff --git a/src/libzisp/value.zig b/src/libzisp/value.zig
index 6c0c2e9..aefca14 100644
--- a/src/libzisp/value.zig
+++ b/src/libzisp/value.zig
@@ -149,6 +149,7 @@ pub const double = @import("value/double.zig");
 pub const fixnum = @import("value/fixnum.zig");
 
 pub const ptr = @import("value/ptr.zig");
+pub const seq = @import("value/seq.zig");
 
 pub const rune = @import("value/rune.zig");
 pub const sstr = @import("value/sstr.zig");
@@ -158,6 +159,7 @@ pub const nil = @import("value/nil.zig");
 pub const eof = @import("value/eof.zig");
 
 pub const pair = @import("value/pair.zig");
+pub const istr = @import("value/istr.zig");
 
 // To fill up the u11 exponent part of a NaN.
 const FILL = 0x7ff;
@@ -321,4 +323,5 @@ pub const Value = packed union {
 /// A "heap value" that could be a Value or object header.
 pub const Hval = packed union {
     value: Value,
+    seq_header: seq.Header,
 };
diff --git a/src/libzisp/value/fixnum.zig b/src/libzisp/value/fixnum.zig
index c705880..80fb4ae 100644
--- a/src/libzisp/value/fixnum.zig
+++ b/src/libzisp/value/fixnum.zig
@@ -19,19 +19,15 @@ pub fn assert(v: Value) void {
 }
 
 // See detailed NaN packing docs for why the +/- 1.
-const fixnum_min = std.math.minInt(i52) + 1;
-const fixnum_max = std.math.maxInt(i52) - 1;
-
-pub fn isValidRange(int: i64) bool {
-    return fixnum_min < int and int < fixnum_max;
-}
+pub const min = std.math.minInt(i52) + 1;
+pub const max = std.math.maxInt(i52) - 1;
 
 fn assertValidRange(int: i64) void {
-    if (int < fixnum_min) {
+    if (int < min) {
         std.debug.print("int too small for fixnum: {}\n", .{int});
         @panic("int too small for fixnum");
     }
-    if (int > fixnum_max) {
+    if (int > max) {
         std.debug.print("int too large for fixnum: {}\n", .{int});
         @panic("int too large for fixnum");
     }
diff --git a/src/libzisp/value/istr.zig b/src/libzisp/value/istr.zig
index 5937531..8056d98 100644
--- a/src/libzisp/value/istr.zig
+++ b/src/libzisp/value/istr.zig
@@ -1,3 +1,58 @@
 const std = @import("std");
 
 const value = @import("../value.zig");
+const gc = @import("../gc.zig");
+
+const ptr = @import("ptr.zig");
+const seq = @import("seq.zig");
+
+const Value = value.Value;
+
+// Zig API
+
+pub fn check(v: Value) bool {
+    return ptr.checkZispTag(v, .seq);
+}
+
+pub fn assert(v: Value) void {
+    if (!check(v)) {
+        v.dump();
+        @panic("not istr");
+    }
+}
+
+pub fn intern(str: []const u8, quoted: bool) Value {
+    if (str.len > value.fixnum.max) {
+        @panic("String length out of fixnum range.");
+    }
+    const header: seq.Header = .{
+        .type = .string,
+        .info = .{ .string = .{
+            .enc = .utf8,
+            .quoted = quoted,
+            .interned = true,
+        } },
+        .size = @intCast(str.len),
+    };
+    const bytes_ptr = gc.intern(header, str);
+    return ptr.pack(bytes_ptr, .seq);
+}
+
+pub fn getHeader(v: Value) *seq.Header {
+    assert(v);
+    return gc.istrHeader(ptr.unpack(v).@"0");
+}
+
+// Zisp API
+
+pub fn pred(v: Value) Value {
+    return value.boole.pack(check(v));
+}
+
+pub fn len(v: Value) Value {
+    const l = getHeader(v).size;
+    if (l > value.fixnum.max) {
+        @panic("string length out of range");
+    }
+    return value.fixnum.pack(@intCast(l));
+}
diff --git a/src/libzisp/value/pair.zig b/src/libzisp/value/pair.zig
index 87e18e7..6ea1edf 100644
--- a/src/libzisp/value/pair.zig
+++ b/src/libzisp/value/pair.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+
 const value = @import("../value.zig");
 const gc = @import("../gc.zig");
 
diff --git a/src/libzisp/value/ptr.zig b/src/libzisp/value/ptr.zig
index 115cc2d..b07acc4 100644
--- a/src/libzisp/value/ptr.zig
+++ b/src/libzisp/value/ptr.zig
@@ -132,10 +132,10 @@ fn untagPtr(tagged: u48) struct { [*]Hval, Tag } {
 }
 
 pub const Tag = enum(u3) {
-    /// *[2]Value
+    /// Pair aka cons cell aka *[2]Value
     pair,
-    /// Interned string (symbol)
-    istr,
+    /// Sequence of various kinds (16-bit meta, 48-bit length, then data)
+    seq,
     /// Procedure
     proc,
 };
diff --git a/src/libzisp/value/seq.zig b/src/libzisp/value/seq.zig
new file mode 100644
index 0000000..5382a7e
--- /dev/null
+++ b/src/libzisp/value/seq.zig
@@ -0,0 +1,56 @@
+const builtin = @import("builtin");
+const std = @import("std");
+
+const value = @import("../value.zig");
+const gc = @import("../gc.zig");
+
+const Value = value.Value;
+
+const Endian = enum(u1) {
+    little,
+    big,
+
+    const native: Endian = switch (builtin.target.cpu.arch.endian()) {
+        .little => .little,
+        .big => .big,
+    };
+};
+
+pub const Header = packed struct(u64) {
+    type: enum(u2) {
+        values,
+        string,
+        ints,
+        floats,
+    },
+    info: packed union {
+        values: packed struct(u14) {
+            weak: bool = false,
+            _: u13 = 0,
+        },
+        string: packed struct(u14) {
+            enc: enum(u4) { utf8, utf16, utf24, utf32 },
+            endian: Endian = .native,
+            quoted: bool,
+            interned: bool,
+            _: u7 = 0,
+        },
+        ints: packed struct(u14) {
+            signed: bool,
+            endian: Endian = .native,
+            size: u12,
+        },
+        floats: packed struct(u14) {
+            double: bool,
+            endian: Endian = .native,
+            _: u12 = 0,
+        },
+    },
+    size: u48,
+
+    pub fn bytes(self: *Header) []u8 {
+        const ptr: [*]u8 = @ptrCast(self);
+        const end = 8 + self.size;
+        return ptr[8..end];
+    }
+};