Fuck SFA. All my homies hate SFA.

4 files changed, 21 insertions, 75 deletions

diff --git a/src/main.zig b/src/main.zig
index a01daa9..f7e752e 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -14,8 +14,8 @@ pub fn main() !u8 {
     var stdout_writer = std.Io.File.stdout().writer(io, &stdout_buffer);
     const writer = &stdout_writer.interface;
 
-    var p, const sfa = try zisp.io.Parser.init(alloc, io);
-    defer p.deinit(sfa);
+    var p = try zisp.io.Parser.init(alloc, io);
+    defer p.deinit();
     while (true) {
         const datum = p.run(reader) catch {
             const format = "Parse error: {s}, pos: {d}, unread_char: {s}\n";
diff --git a/src/test/parse.zig b/src/test/parse.zig
index 61f8fc3..35371e5 100644
--- a/src/test/parse.zig
+++ b/src/test/parse.zig
@@ -170,8 +170,8 @@ fn parseBench(path: []const u8, iters: usize) !void {
     const file = try std.Io.Dir.cwd().openFile(io, path, .{});
     defer file.close(io);
 
-    var parser, const sfa = try zisp.io.Parser.init(alloc, io);
-    defer parser.deinit(sfa);
+    var parser = try zisp.io.Parser.init(alloc, io);
+    defer parser.deinit();
 
     var timer = try std.time.Timer.start();
     for (0..iters) |i| {
diff --git a/src/zisp/io/Parser.zig b/src/zisp/io/Parser.zig
index 9833baa..aeca539 100644
--- a/src/zisp/io/Parser.zig
+++ b/src/zisp/io/Parser.zig
@@ -115,30 +115,7 @@ pub const Context = struct {
     char: u8 = undefined,
 };
 
-pub const Alloc = struct {
-    stack: std.mem.Allocator,
-    chars: std.mem.Allocator,
-};
-
-pub fn StackFallbackAlloc(ctx_stack_cap: usize, str_chars_cap: usize) type {
-    return struct {
-        pub const ctx_stack_bytes = ctx_stack_cap * @sizeOf(Context);
-        pub const str_chars_bytes = str_chars_cap;
-
-        stack: std.heap.StackFallbackAllocator(ctx_stack_bytes),
-        chars: std.heap.StackFallbackAllocator(str_chars_bytes),
-
-        pub fn alloc(self: *@This()) Alloc {
-            return .{ .stack = self.stack.get(), .chars = self.chars.get() };
-        }
-    };
-}
-
-const def_ctx_stack_cap = 32;
-const def_str_chars_cap = 2048;
-const DefaultSfa = StackFallbackAlloc(def_ctx_stack_cap, def_str_chars_cap);
-
-alloc: Alloc,
+alloc: std.mem.Allocator,
 io: std.Io,
 input: *std.Io.Reader = undefined,
 context: Context = .{},
@@ -149,56 +126,25 @@ result: Value = undefined,
 unread_char: ?u8 = null,
 err_msg: []const u8 = undefined,
 
-pub fn init(alloc: std.mem.Allocator, io: std.Io) !struct {
-    Parser,
-    DefaultSfa,
-} {
-    return initWithSfa(def_ctx_stack_cap, def_str_chars_cap, alloc, io);
-}
-
-pub fn initWithSfa(
-    comptime init_ctx_stack_cap: usize,
-    comptime init_str_chars_cap: usize,
-    alloc: std.mem.Allocator,
-    io: std.Io,
-) !struct {
-    Parser,
-    StackFallbackAlloc(init_ctx_stack_cap, init_str_chars_cap),
-} {
-    const Sfa = StackFallbackAlloc(init_ctx_stack_cap, init_str_chars_cap);
-    var sfa: Sfa = .{
-        .stack = std.heap.stackFallback(Sfa.ctx_stack_bytes, alloc),
-        .chars = std.heap.stackFallback(Sfa.str_chars_bytes, alloc),
-    };
-    const parser: Parser = try initCustom(
-        sfa.alloc(),
-        io,
-        init_ctx_stack_cap,
-        init_str_chars_cap,
-    );
-    return .{ parser, sfa };
+pub fn init(alloc: std.mem.Allocator, io: std.Io) !Parser {
+    return initCustom(alloc, io, 32, 2048);
 }
 
 pub fn initCustom(
-    alloc: Alloc,
+    alloc: std.mem.Allocator,
     io: std.Io,
     init_ctx_stack_cap: usize,
     init_str_chars_cap: usize,
 ) !Parser {
     var p: Parser = .{ .alloc = alloc, .io = io };
-    p.stack = try .initCapacity(alloc.stack, init_ctx_stack_cap);
-    p.chars = try .initCapacity(alloc.chars, init_str_chars_cap);
+    p.stack = try .initCapacity(alloc, init_ctx_stack_cap);
+    p.chars = try .initCapacity(alloc, init_str_chars_cap);
     return p;
 }
 
-pub fn deinit(p: *Parser, sfa: anytype) void {
-    p.deinitCustom();
-    _ = sfa;
-}
-
-pub fn deinitCustom(p: *Parser) void {
-    p.stack.deinit(p.alloc.stack);
-    p.chars.deinit(p.alloc.chars);
+pub fn deinit(p: *Parser) void {
+    p.stack.deinit(p.alloc);
+    p.chars.deinit(p.alloc);
 }
 
 //
@@ -241,7 +187,7 @@ fn getUnread(p: *Parser) ?u8 {
 //
 
 fn addChar(p: *Parser, c: u8) !void {
-    try p.chars.append(p.alloc.chars, c);
+    try p.chars.append(p.alloc, c);
 }
 
 fn getCharsAsString(p: *Parser) Value {
@@ -342,11 +288,11 @@ fn err(
 }
 
 fn push(p: *Parser, next: Fn) !void {
-    try p.stack.append(p.alloc.stack, .{ .next = next });
+    try p.stack.append(p.alloc, .{ .next = next });
 }
 
 fn pushContext(p: *Parser, next: Fn) !void {
-    try p.stack.append(p.alloc.stack, .{
+    try p.stack.append(p.alloc, .{
         .next = next,
         .val = p.context.val,
         .char = p.context.char,
@@ -568,7 +514,7 @@ fn parseStringUniHexEsc(p: *Parser) !void {
     const n = std.unicode.utf8CodepointSequenceLength(uc) catch {
         return p.err(.UnicodeLengthError, msg);
     };
-    const buf = try p.chars.addManyAsSlice(p.alloc.chars, n);
+    const buf = try p.chars.addManyAsSlice(p.alloc, n);
     const n2 = std.unicode.utf8Encode(uc, buf) catch {
         return p.err(.UnicodeEncodeError, msg);
     };
diff --git a/src/zisp/io/parse.zig b/src/zisp/io/parse.zig
index 6e84b55..7d8db33 100644
--- a/src/zisp/io/parse.zig
+++ b/src/zisp/io/parse.zig
@@ -20,8 +20,8 @@ pub fn fromReader(
     io: std.Io,
     input: *std.Io.Reader,
 ) ParserErrors!Value {
-    var p, const sfa = try Parser.init(alloc, io);
-    defer p.deinit(sfa);
+    var p = try Parser.init(alloc, io);
+    defer p.deinit();
     return p.run(input);
 }
 
@@ -30,8 +30,8 @@ pub fn fromReaderNoError(
     io: std.Io,
     input: *std.Io.Reader,
 ) Value {
-    var p, const sfa = Parser.init(alloc, io) catch @panic("OOM");
-    defer p.deinit(sfa);
+    var p = Parser.init(alloc, io) catch @panic("OOM");
+    defer p.deinit();
     return p.run(input) catch |e| switch (e) {
         error.OutOfMemory => @panic("OOM"),
         error.ParseError => {