blip

2 files changed, 70 insertions, 18 deletions

diff --git a/src/libzisp/io/parser.zig b/src/libzisp/io/parser.zig
index 8093ffe..209c548 100644
--- a/src/libzisp/io/parser.zig
+++ b/src/libzisp/io/parser.zig
@@ -257,7 +257,7 @@ const cons = value.pair.cons;
 const is_test = builtin.is_test;
 const is_debug = builtin.mode == .Debug;
 
-const detailed_debug = false;
+pub var detailed_debug = false;
 
 // In debug, we want to see if we leak, so very small numbers.
 const init_stack_capacity = if (is_debug) 32 else 32;
@@ -474,7 +474,9 @@ pub fn _parse(input: std.io.AnyReader) !Value {
         return e;
     };
     if (s.unused_char) |c| {
-        std.debug.panic("Invalid trailing character: {c}\n", .{c});
+        if (c != ' ') {
+            std.debug.panic("Invalid trailing character: {c}\n", .{c});
+        }
     }
     return s.result;
 }
@@ -577,16 +579,16 @@ fn parseDatum(s: *State, c: u8) !void {
 }
 
 fn parseDotString(s: *State) !void {
-    try s.addChar('.');
-    while (try s.read()) |c| {
+    var n: u48 = 1;
+    while (try s.read()) |c| : (n += 1) {
         switch (try checkBlanks(s, c)) {
-            .yes => return dotString(s, false),
-            .skip_unit => return dotString(s, true),
+            .yes => return dotString(s, n, false),
+            .skip_unit => return dotString(s, n, true),
             .no => switch (c) {
-                '.' => try s.addChar('.'),
+                '.' => {},
                 ')', ']', '}' => {
                     s.unused_char = c;
-                    return dotString(s, false);
+                    return dotString(s, n, false);
                 },
                 else => return s.err(.InvalidCharacter, "dot string"),
             },
@@ -595,9 +597,12 @@ fn parseDotString(s: *State) !void {
     unreachable;
 }
 
-fn dotString(s: *State, skip_unit: bool) !void {
-    const lstail = s.chars.items.len == 1;
-    const result = if (lstail) LSTAIL else s.getBareString();
+fn dotString(s: *State, n: u48, skip_unit: bool) !void {
+    const result = if (n == 1) LSTAIL else r: {
+        const buf = try s.chars.addManyAsSlice(s.chars_alloc, n);
+        @memset(buf, '.');
+        break :r s.getBareString();
+    };
     if (skip_unit) {
         s.context.val = result;
         return s.subr(.parse_unit, .return_context);
@@ -619,6 +624,7 @@ fn endOneDatum(s: *State) !void {
             .no => return parseJoin(s, d, c),
         }
     }
+    s.unused_char = ' ';
     return s.retval(d);
 }
 
@@ -628,13 +634,17 @@ fn skipUnitAndReturn(s: *State, d: Value) !void {
 }
 
 fn returnContext(s: *State) !void {
+    s.unused_char = ' ';
     return s.retval(s.context.val);
 }
 
 fn parseJoin(s: *State, d: Value, c: u8) !void {
-    s.context.val = d;
-    s.context.char = c;
     switch (c) {
+        ')', ']', '}' => {
+            // shortcut
+            s.unused_char = c;
+            return s.retval(d);
+        },
         '.', ':', '|' => {
             s.context.char = c;
             s.unused_char = try s.readNoEof("join datum");
@@ -644,6 +654,7 @@ fn parseJoin(s: *State, d: Value, c: u8) !void {
             s.unused_char = c;
         },
     }
+    s.context.val = d;
     return s.subr(.parse_join_datum, .join_data);
 }
 
@@ -718,17 +729,34 @@ fn isBareEsc(c: u8) bool {
 
 fn parseBareString(s: *State, c: u8) !Value {
     try s.addChar(c);
-    return parseBareStringRest(s);
+    var is_num = false;
+    if (std.ascii.isDigit(c)) {
+        is_num = true;
+    } else if (c == '+' or c == '-') {
+        const c2 = try s.read() orelse return s.getBareString();
+        if (std.ascii.isDigit(c2)) {
+            try s.addChar(c2);
+            is_num = true;
+        } else if (isBareChar(c2)) {
+            try s.addChar(c2);
+        } else if (c2 == '\\') {
+            try s.addChar(try parseBareEsc(s));
+        } else {
+            s.unused_char = c2;
+            return s.getBareString();
+        }
+    }
+    return parseBareStringRest(s, is_num);
 }
 
 fn parseBareEscString(s: *State) !Value {
     try s.addChar(try parseBareEsc(s));
-    return parseBareStringRest(s);
+    return parseBareStringRest(s, false);
 }
 
-fn parseBareStringRest(s: *State) !Value {
+fn parseBareStringRest(s: *State, is_num: bool) !Value {
     while (try s.read()) |c| {
-        if (isBareChar(c)) {
+        if (isBareChar(c) or (is_num and c == '.')) {
             try s.addChar(c);
         } else if (c == '\\') {
             try s.addChar(try parseBareEsc(s));
@@ -1046,9 +1074,10 @@ fn parseQuoteExpr(s: *State, c1: u8, next: Fn) !void {
         return s.jump(next, cons(q, try parseBareString(s, c)));
     }
 
+    try s.push(next);
     s.context.val = q;
     s.unused_char = c;
-    return s.subr(.parse_list_element, .end_quote_expr);
+    return s.subr(.parse_unit, .end_quote_expr);
 }
 
 fn endQuoteExpr(s: *State) !void {
diff --git a/src/libzisp/io/unparser.zig b/src/libzisp/io/unparser.zig
index d65ffb0..d703182 100644
--- a/src/libzisp/io/unparser.zig
+++ b/src/libzisp/io/unparser.zig
@@ -2,6 +2,9 @@ const std = @import("std");
 
 const value = @import("../value.zig");
 
+const istr = value.istr;
+const seq = value.seq;
+
 const ShortString = value.ShortString;
 const OtherTag = value.OtherTag;
 const Value = value.Value;
@@ -33,6 +36,7 @@ fn unparseHeap(w: anytype, v: Value) !void {
     const p, const t = value.ptr.unpack(v);
     try switch (t) {
         .pair => unparsePair(w, @ptrCast(p)),
+        .seq => unparseSeq(w, @ptrCast(p)),
         else => @panic("not implemented"),
     };
 }
@@ -97,3 +101,22 @@ fn unparsePair(w: anytype, p: *[2]Value) !void {
     }
     try w.writeByte(')');
 }
+
+fn unparseSeq(w: anytype, p: *seq.Header) !void {
+    const h = istr.getHeaderFromPtr(@ptrCast(p));
+    switch (h.type) {
+        .string => try unparseString(w, h),
+        else => @panic("not implemented"),
+    }
+}
+
+fn unparseString(w: anytype, h: *seq.Header) !void {
+    const info = h.info.string;
+    if (info.quoted) {
+        try w.writeByte('"');
+    }
+    try w.writeAll(h.bytes());
+    if (info.quoted) {
+        try w.writeByte('"');
+    }
+}