Now works on 12/28 master

Khitiara · Khitiara · commit 129c66e2acda · 2026-02-03T21:54:00.000-05:00
diff --git a/build.zig.zon b/build.zig.zon
@@ -6,11 +6,12 @@
         .zfat = .{
             // .url = "git+https://github.com/CascadeOS/zfat#2806bfd983dd810c9c74b0ea6a63f783208518b5",
             // .hash = "zfat-0.16.0-SNNK9fKtTgASssfmCblZwRMLU4pndVtwxTNhYCegBOyA",
-            .path = "../zfat"
+            .path = "../zfat",
         },
         .args = .{
-            .url = "git+https://github.com/ikskuh/zig-args.git#8ae26b44a884ff20dca98ee84c098e8f8e94902f",
-            .hash = "args-0.0.0-CiLiqojRAACGzDRO7A9dw7kWSchNk29caJZkXuMCb0Cn",
+            .path = "../zig-args",
+            // .url = "git+https://github.com/ikskuh/zig-args.git#8ae26b44a884ff20dca98ee84c098e8f8e94902f",
+            // .hash = "args-0.0.0-CiLiqojRAACGzDRO7A9dw7kWSchNk29caJZkXuMCb0Cn",
         },
     },
     .paths = .{
diff --git a/src/Parser.zig b/src/Parser.zig
@@ -22,15 +22,15 @@ pub const Error = Tokenizer.Error || error{
 };
 
 pub const IO = struct {
-    fetch_file_fn: *const fn (io: *const IO, std.mem.Allocator, path: []const u8) error{ FileNotFound, IoError, OutOfMemory, InvalidPath, Canceled }![]const u8,
-    resolve_variable_fn: *const fn (io: *const IO, name: []const u8) error{UnknownVariable}![]const u8,
+    fetch_file_fn: *const fn (stdio: std.Io, io: *const IO, std.mem.Allocator, path: []const u8) error{ FileNotFound, IoError, OutOfMemory, InvalidPath, Canceled }![]const u8,
+    resolve_variable_fn: *const fn (stdio: std.Io, io: *const IO, name: []const u8) error{UnknownVariable}![]const u8,
 
-    pub fn fetch_file(io: *const IO, allocator: std.mem.Allocator, path: []const u8) error{ FileNotFound, IoError, OutOfMemory, InvalidPath, Canceled }![]const u8 {
-        return io.fetch_file_fn(io, allocator, path);
+    pub fn fetch_file(io: *const IO, stdio: std.Io, allocator: std.mem.Allocator, path: []const u8) error{ FileNotFound, IoError, OutOfMemory, InvalidPath, Canceled }![]const u8 {
+        return io.fetch_file_fn(stdio,io, allocator, path);
     }
 
-    pub fn resolve_variable(io: *const IO, name: []const u8) error{UnknownVariable}![]const u8 {
-        return io.resolve_variable_fn(io, name);
+    pub fn resolve_variable(io: *const IO, stdio: std.Io, name: []const u8) error{UnknownVariable}![]const u8 {
+        return io.resolve_variable_fn(stdio,io, name);
     }
 };
 
@@ -85,10 +85,10 @@ pub fn push_source(parser: *Parser, options: struct {
     };
 }
 
-pub fn push_file(parser: *Parser, include_path: []const u8) !void {
+pub fn push_file(parser: *Parser, stdio: std.Io, include_path: []const u8) !void {
     const abs_include_path = try parser.get_include_path(parser.arena.allocator(), include_path);
 
-    const file_contents = try parser.io.fetch_file(parser.arena.allocator(), abs_include_path);
+    const file_contents = try parser.io.fetch_file(stdio , parser.arena.allocator(), abs_include_path);
 
     const index = parser.file_stack.len;
     parser.file_stack.len += 1;
@@ -121,14 +121,14 @@ pub fn get_include_path(parser: Parser, allocator: std.mem.Allocator, rel_includ
     return abs_include_path;
 }
 
-pub fn next(parser: *Parser) (Error || error{UnexpectedEndOfFile})![]const u8 {
-    return if (try parser.next_or_eof()) |word|
+pub fn next(parser: *Parser, stdio: std.Io) (Error || error{UnexpectedEndOfFile})![]const u8 {
+    return if (try parser.next_or_eof(stdio)) |word|
         word
     else
         error.UnexpectedEndOfFile;
 }
 
-pub fn next_or_eof(parser: *Parser) Error!?[]const u8 {
+pub fn next_or_eof(parser: *Parser, stdio: std.Io) Error!?[]const u8 {
     fetch_loop: while (parser.file_stack.len > 0) {
         const top = &parser.file_stack[parser.file_stack.len - 1];
 
@@ -142,7 +142,7 @@ pub fn next_or_eof(parser: *Parser) Error!?[]const u8 {
         switch (token.type) {
             .whitespace, .comment => unreachable,
 
-            .word, .variable, .string => return try parser.resolve_value(
+            .word, .variable, .string => return try parser.resolve_value(stdio,
                 token.type,
                 top.tokenizer.get_text(token),
             ),
@@ -153,14 +153,14 @@ pub fn next_or_eof(parser: *Parser) Error!?[]const u8 {
                 if (std.mem.eql(u8, directive, "!include")) {
                     if (try fetch_token(&top.tokenizer)) |path_token| {
                         const rel_include_path = switch (path_token.type) {
-                            .word, .variable, .string => try parser.resolve_value(
+                            .word, .variable, .string => try parser.resolve_value(stdio,
                                 path_token.type,
                                 top.tokenizer.get_text(path_token),
                             ),
                             .comment, .directive, .whitespace => return error.BadDirective,
                         };
 
-                        try parser.push_file(rel_include_path);
+                        try parser.push_file(stdio, rel_include_path);
                     } else {
                         return error.ExpectedIncludePath;
                     }
@@ -190,11 +190,11 @@ fn fetch_token(tok: *Tokenizer) Tokenizer.Error!?Token {
     }
 }
 
-fn resolve_value(parser: *Parser, token_type: TokenType, text: []const u8) ![]const u8 {
+fn resolve_value(parser: *Parser, stdio: std.Io, token_type: TokenType, text: []const u8) ![]const u8 {
     return switch (token_type) {
         .word => text,
 
-        .variable => try parser.io.resolve_variable(
+        .variable => try parser.io.resolve_variable(stdio,
             text[1..],
         ),
 
diff --git a/src/components/EmptyData.zig b/src/components/EmptyData.zig
@@ -8,8 +8,9 @@ const dim = @import("../dim.zig");
 
 const EmptyData = @This();
 
-pub fn parse(ctx: dim.Context) !dim.Content {
+pub fn parse(ctx: dim.Context, stdio: std.Io) !dim.Content {
     _ = ctx;
+    _ = stdio;
     return .create_handle(undefined, .create(@This(), .{
         .render_fn = render,
     }));
diff --git a/src/components/FillData.zig b/src/components/FillData.zig
@@ -9,19 +9,18 @@ const FillData = @This();
 
 fill_value: u8,
 
-pub fn parse(ctx: dim.Context) !dim.Content {
+pub fn parse(ctx: dim.Context, stdio: std.Io) !dim.Content {
     const pf = try ctx.alloc_object(FillData);
     pf.* = .{
-        .fill_value = try ctx.parse_integer(u8, 0),
+        .fill_value = try ctx.parse_integer(stdio, u8, 0),
     };
     return .create_handle(pf, .create(@This(), .{
         .render_fn = render,
     }));
 }
 
 fn render(self: *FillData, io: std.Io,  stream: *dim.BinaryStream) dim.Content.RenderError!void {
-    _ = io;
-    var writer = stream.writer();
+    var writer = stream.writer(io);
     writer.interface.splatByteAll(
         self.fill_value,
         stream.length,
diff --git a/src/components/PasteFile.zig b/src/components/PasteFile.zig
@@ -5,10 +5,10 @@ const PasteFile = @This();
 
 file_handle: dim.FileName,
 
-pub fn parse(ctx: dim.Context) !dim.Content {
+pub fn parse(ctx: dim.Context, stdio: std.Io) !dim.Content {
     const pf = try ctx.alloc_object(PasteFile);
     pf.* = .{
-        .file_handle = try ctx.parse_file_name(),
+        .file_handle = try ctx.parse_file_name(stdio),
     };
     return .create_handle(pf, .create(@This(), .{
         .render_fn = render,
diff --git a/src/components/fs/FatFileSystem.zig b/src/components/fs/FatFileSystem.zig
@@ -18,8 +18,8 @@ ops: std.array_list.Managed(common.FsOperation),
 sector_align: ?c_uint = null,
 cluster_size: ?u32 = null,
 
-pub fn parse(ctx: dim.Context) !dim.Content {
-    const fat_type = try ctx.parse_enum(FatType);
+pub fn parse(ctx: dim.Context, stdio: std.Io) !dim.Content {
+    const fat_type = try ctx.parse_enum(stdio,FatType);
 
     const pf = try ctx.alloc_object(FAT);
     pf.* = .{
@@ -32,7 +32,7 @@ pub fn parse(ctx: dim.Context) !dim.Content {
         .updater = .init(ctx, pf),
     };
 
-    try common.parse_ops(ctx, "endfat", &appender);
+    try common.parse_ops(ctx, stdio, "endfat", &appender);
 
     try appender.updater.validate();
 
@@ -59,7 +59,7 @@ const Appender = struct {
         try self.fat.ops.append(op);
     }
 
-    pub fn parse_custom_op(self: *@This(), ctx: dim.Context, str_op: []const u8) !void {
+    pub fn parse_custom_op(self: *@This(), stdio: std.Io, ctx: dim.Context, str_op: []const u8) !void {
         const Op = enum {
             label,
             fats,
@@ -72,11 +72,11 @@ const Appender = struct {
             .{str_op},
         );
         switch (op) {
-            .label => try self.updater.set(.label, try ctx.parse_string()),
-            .fats => try self.updater.set(.fats, try ctx.parse_enum(fatfs.FatTables)),
-            .@"root-size" => try self.updater.set(.rootdir_size, try ctx.parse_integer(c_uint, 0)),
-            .@"sector-align" => try self.updater.set(.sector_align, try ctx.parse_integer(c_uint, 0)),
-            .@"cluster-size" => try self.updater.set(.cluster_size, try ctx.parse_integer(u32, 0)),
+            .label => try self.updater.set(.label, try ctx.parse_string(stdio)),
+            .fats => try self.updater.set(.fats, try ctx.parse_enum(stdio, fatfs.FatTables)),
+            .@"root-size" => try self.updater.set(.rootdir_size, try ctx.parse_integer(stdio,c_uint, 0)),
+            .@"sector-align" => try self.updater.set(.sector_align, try ctx.parse_integer(stdio, c_uint, 0)),
+            .@"cluster-size" => try self.updater.set(.cluster_size, try ctx.parse_integer(stdio, u32, 0)),
         }
     }
 };
@@ -284,10 +284,9 @@ const BinaryStreamDisk = struct {
     }
 
     fn disk_write(intf: *fatfs.Disk, io: std.Io, buff: [*]const u8, sector: fatfs.LBA, count: c_uint) fatfs.Disk.Error!void {
-        _ = io;
         const bsd: *BinaryStreamDisk = @fieldParentPtr("disk", intf);
 
-        bsd.stream.write(block_size * sector, buff[0 .. count * block_size]) catch |err| {
+        bsd.stream.write(io, block_size * sector, buff[0 .. count * block_size]) catch |err| {
             bsd.disk_error = err;
             return error.IoError;
         };
diff --git a/src/components/fs/common.zig b/src/components/fs/common.zig
@@ -49,7 +49,7 @@ fn Executor(comptime T: type) type {
                 },
 
                 .copy_file => |data| {
-                    var handle = data.source.open() catch |err| switch (err) {
+                    var handle = data.source.open(io) catch |err| switch (err) {
                         error.FileNotFound => return, // open() already reported the error
                         else => |e| return e,
                     };
@@ -61,11 +61,11 @@ fn Executor(comptime T: type) type {
                     try exec.add_file(data.path, &adapter.interface);
                 },
                 .copy_dir => |data| {
-                    var iter_dir = data.source.open_dir() catch |err| switch (err) {
+                    var iter_dir = data.source.open_dir(io) catch |err| switch (err) {
                         error.FileNotFound => return, // open() already reported the error
                         else => |e| return e,
                     };
-                    defer iter_dir.close();
+                    defer iter_dir.close(io);
 
                     var walker_memory: [16384]u8 = undefined;
                     var temp_allocator: std.heap.FixedBufferAllocator = .init(&walker_memory);
@@ -75,7 +75,7 @@ fn Executor(comptime T: type) type {
                     var walker = try iter_dir.walk(temp_allocator.allocator());
                     defer walker.deinit();
 
-                    while (walker.next() catch |err| return walk_err(err)) |entry| {
+                    while (walker.next(io) catch |err| return walk_err(err)) |entry| {
                         const path = std.fmt.bufPrintZ(&path_memory, "{s}/{s}", .{
                             data.path,
                             entry.path,
@@ -91,7 +91,7 @@ fn Executor(comptime T: type) type {
                                     .rel_path = entry.basename,
                                 };
 
-                                var file = try fname.open();
+                                var file = try fname.open(io);
                                 defer file.close(io);
 
                                 var buffer: [1024]u8 = undefined;
@@ -106,8 +106,8 @@ fn Executor(comptime T: type) type {
 
                             else => {
                                 var realpath_buffer: [std.fs.max_path_bytes]u8 = undefined;
-                                std.log.warn("cannot copy file {!s}: {s} is not a supported file type!", .{
-                                    entry.dir.realpath(entry.path, &realpath_buffer),
+                                std.log.warn("cannot copy file {s}: {s} is not a supported file type!", .{
+                                    if (entry.dir.realPathFile(io,entry.path, &realpath_buffer)) |l| realpath_buffer[0..l] else |e| @errorName(e),
                                     @tagName(entry.kind),
                                 });
                             },
@@ -157,10 +157,9 @@ fn Executor(comptime T: type) type {
             try exec.inner.mkdir(path);
         }
 
-        fn walk_err(err: (std.fs.Dir.OpenError || std.mem.Allocator.Error)) dim.Content.RenderError {
+        fn walk_err(err: (std.Io.Dir.OpenError || std.mem.Allocator.Error)) dim.Content.RenderError {
             return switch (err) {
-                error.BadPathName,
-                error.NameTooLong => error.InvalidPath,
+                error.BadPathName, error.NameTooLong => error.InvalidPath,
 
                 error.OutOfMemory => error.OutOfMemory,
                 error.FileNotFound => error.FileNotFound,
@@ -177,14 +176,15 @@ fn Executor(comptime T: type) type {
                 error.ProcessFdQuotaExceeded,
                 error.SystemFdQuotaExceeded,
                 error.NotDir,
-                error.PermissionDenied, => error.IoError,
+                error.PermissionDenied,
+                => error.IoError,
             };
         }
     };
 }
 
-fn parse_path(ctx: dim.Context) ![:0]const u8 {
-    const path = try ctx.parse_string();
+fn parse_path(ctx: dim.Context, stdio: std.Io) ![:0]const u8 {
+    const path = try ctx.parse_string(stdio);
 
     if (path.len == 0) {
         try ctx.report_nonfatal_error("Path cannot be empty!", .{});
@@ -216,41 +216,41 @@ fn parse_path(ctx: dim.Context) ![:0]const u8 {
     return try normalize(ctx.get_arena(), path);
 }
 
-pub fn parse_ops(ctx: dim.Context, end_seq: []const u8, handler: anytype) !void {
+pub fn parse_ops(ctx: dim.Context, stdio: std.Io, end_seq: []const u8, handler: anytype) !void {
     while (true) {
-        const opsel = try ctx.parse_string();
+        const opsel = try ctx.parse_string(stdio);
         if (std.mem.eql(u8, opsel, end_seq))
             return;
 
         if (std.mem.eql(u8, opsel, "mkdir")) {
-            const path = try parse_path(ctx);
+            const path = try parse_path(ctx, stdio);
             try handler.append_common_op(FsOperation{
                 .make_dir = .{ .path = path },
             });
         } else if (std.mem.eql(u8, opsel, "copy-dir")) {
-            const path = try parse_path(ctx);
-            const src = try ctx.parse_file_name();
+            const path = try parse_path(ctx, stdio);
+            const src = try ctx.parse_file_name(stdio);
 
             try handler.append_common_op(FsOperation{
                 .copy_dir = .{ .path = path, .source = src },
             });
         } else if (std.mem.eql(u8, opsel, "copy-file")) {
-            const path = try parse_path(ctx);
-            const src = try ctx.parse_file_name();
+            const path = try parse_path(ctx, stdio);
+            const src = try ctx.parse_file_name(stdio);
 
             try handler.append_common_op(FsOperation{
                 .copy_file = .{ .path = path, .source = src },
             });
         } else if (std.mem.eql(u8, opsel, "create-file")) {
-            const path = try parse_path(ctx);
-            const size = try ctx.parse_mem_size();
-            const contents = try ctx.parse_content();
+            const path = try parse_path(ctx, stdio);
+            const size = try ctx.parse_mem_size(stdio);
+            const contents = try ctx.parse_content(stdio);
 
             try handler.append_common_op(FsOperation{
                 .create_file = .{ .path = path, .size = size, .contents = contents },
             });
         } else {
-            try handler.parse_custom_op(ctx, opsel);
+            try handler.parse_custom_op(stdio, ctx, opsel);
         }
     }
 }
diff --git a/src/components/part/GptPartitionTable.zig b/src/components/part/GptPartitionTable.zig
diff --git a/src/components/part/MbrPartitionTable.zig b/src/components/part/MbrPartitionTable.zig
diff --git a/src/dim.zig b/src/dim.zig
