1 files changed, 70 insertions, 54 deletions

diff --git a/src/libzisp.zig b/src/libzisp.zig
index df7d9fc..f6eb77c 100644
--- a/src/libzisp.zig
+++ b/src/libzisp.zig
@@ -13,6 +13,20 @@ pub const Hval = gc.Hval;
 pub const ShortString = value.ShortString;
 pub const Value = value.Value;
 
+fn benchmark(name: []const u8, iters: usize, func: fn () anyerror!void) !void {
+    var timer = try std.time.Timer.start();
+    for (0..iters) |i| {
+        _ = i;
+        try func();
+    }
+    const ns: f64 = @floatFromInt(timer.lap());
+    const secs = ns / 1_000_000_000;
+    std.debug.print(
+        "bench {s} x {}: {d:.3}s\n",
+        .{ name, iters, secs },
+    );
+}
+
 test "double" {
     const d1: f64 = 0.123456789;
     const d2: f64 = -0.987654321;
@@ -128,7 +142,7 @@ test "sstr" {
             .ReleaseSafe => 100_000_000,
             .ReleaseFast => 1_000_000_000,
         };
-        std.debug.print("Benchmarking with {} iters.\n", .{iters});
+        std.debug.print("Benchmarking sstr with {} iters.\n", .{iters});
         inline for (impls, 0..) |impl, i| {
             try benchmarkSstr(impl, i, iters);
         }
@@ -288,7 +302,7 @@ test "parse" {
 test "parse2" {
     const val = parseString(
         \\ ;; Testing some crazy datum comments
-        \\ #;"bar"#;([x #"y"]{##`,'z}) #"foo"
+        \\ ;~"bar"([x #"y"]{##`,'z}) #"foo"
         \\ ;; end
     );
 
@@ -304,7 +318,7 @@ test "parse2" {
 
 test "parse3" {
     const val = parseString(
-        \\(foo #;x #;(x y) #;x #bar [#x #"baz"] 'bat)
+        \\(foo ;~x ;~(x y) ;~x #bar [#x #"baz"] 'bat)
     );
 
     const car = value.pair.car;
@@ -322,7 +336,7 @@ test "parse3" {
 }
 
 test "parse4" {
-    const val = parseString("(foo . #;x bar #;y)");
+    const val = parseString("(foo . ;~x bar ;~y)");
 
     const s = value.sstr.unpack(value.pair.car(val));
     try std.testing.expectEqualStrings("foo", s.slice());
@@ -331,42 +345,6 @@ test "parse4" {
     try std.testing.expectEqualStrings("bar", f.slice());
 }
 
-fn parseBench(path: []const u8) !void {
-    const iters = 1000;
-
-    var buf: [8196]u8 = undefined;
-    const file = try std.fs.cwd().openFile(path, .{});
-    defer file.close();
-    const count = try file.readAll(&buf);
-
-    var fbs = std.io.fixedBufferStream(buf[0..count]);
-    const reader = fbs.reader().any();
-
-    var timer = try std.time.Timer.start();
-    for (0..iters) |i| {
-        _ = i;
-        var v: Value = undefined;
-        while (true) {
-            v = io.parser.parse(reader);
-            if (value.eof.check(v)) {
-                break;
-            }
-        }
-        try fbs.seekTo(0);
-    }
-    const ns: f64 = @floatFromInt(timer.lap());
-    const secs = ns / 1_000_000_000;
-    std.debug.print(
-        "parse {s} x {}: {d:.3}s\n",
-        .{ path, iters, secs },
-    );
-}
-
-test "parse bench" {
-    try parseBench("test-data/parser-test-1.scm");
-    try parseBench("test-data/parser-test-2.scm");
-}
-
 test "unparse" {
     var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
     var out: std.ArrayList(u8) = .init(gpa.allocator());
@@ -390,29 +368,67 @@ test "unparse2" {
     );
 }
 
-test "unparse3" {
+fn writeParseResult(str: []const u8) !void {
     const w = std.io.getStdErr().writer();
-    const v = parseString("#{foo bar['x](y)(z)}");
+    const v = parseString(str);
     try io.unparser.unparse(w, v);
+    try w.writeByte('\n');
+}
+
+test "unparse3" {
+    try writeParseResult("#{foo bar['x](y)(z)}");
 }
 
 test "unparse4" {
-    const w = std.io.getStdErr().writer();
-    const v = parseString("(foo #;bar\n)");
-    try io.unparser.unparse(w, v);
-    try w.writeByte('\n');
+    try writeParseResult("(foo ;~bar)");
 }
 
 test "unparse5" {
-    const w = std.io.getStdErr().writer();
-    const v = parseString("(#;foo foo #;bar . #;bar bar #;bar\n)");
-    try io.unparser.unparse(w, v);
-    try w.writeByte('\n');
+    try writeParseResult("(;~foo foo ;~bar . ;~bar bar ;~bar)");
 }
 
 test "unparse6" {
-    const w = std.io.getStdErr().writer();
-    const v = parseString("(foo .bar ... baz. bat.(qux))");
-    try io.unparser.unparse(w, v);
-    try w.writeByte('\n');
+    try writeParseResult("(foo bar ... baz bat.(qux))");
+}
+
+test "unparse7" {
+    try writeParseResult("#`(#,(->keyword (syntax->datum #'sym)) . in)");
+}
+
+fn parseBench(path: []const u8, iters: usize) !void {
+    const file = try std.fs.cwd().openFile(path, .{});
+    defer file.close();
+
+    var timer = try std.time.Timer.start();
+    for (0..iters) |i| {
+        _ = i;
+        // var br = std.io.bufferedReader(file.reader());
+        // const reader = br.reader().any();
+        const reader = file.reader().any();
+        var v: Value = undefined;
+        while (true) {
+            v = io.parser._parse(reader) catch |e| {
+                std.debug.print("\nfile pos: {}\n", .{
+                    try file.getPos(),
+                });
+                return e;
+            };
+            if (value.eof.check(v)) {
+                break;
+            }
+        }
+        try file.seekTo(0);
+    }
+    const ns: f64 = @floatFromInt(timer.lap());
+    const secs = ns / 1_000_000_000;
+    std.debug.print(
+        "parse {s} x {}: {d:.3}s\n",
+        .{ path, iters, secs },
+    );
+}
+
+test "parse bench" {
+    try parseBench("test-data/parser-test-1.scm", 200);
+    try parseBench("test-data/parser-test-2.scm", 800);
+    try parseBench("test-data/parser-torture.scm", 1);
 }