fix(ci): update to latest zig

Author: robbielyman

.github/workflows/docs.yml

@@ -27,7 +27,7 @@ jobs:
         uses: actions/configure-pages@v5
       - uses: mlugg/setup-zig@v1
         with:
-          version: 0.15.0-dev.441+c1649d586
+          version: 0.15.0-dev.1034+bd97b6618
       - run: make docs
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v3

.github/workflows/tests.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        zig: ["0.14.0", "0.15.0-dev.441+c1649d586"]
+        zig: ["0.14.0", "0.15.0-dev.1034+bd97b6618"]
 
     runs-on: ${{matrix.os}}
 
@@ -31,7 +31,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        zig: ["0.14.0", "0.15.0-dev.441+c1649d586"]
+        zig: ["0.14.0", "0.15.0-dev.1034+bd97b6618"]
 
     runs-on: ${{matrix.os}}
 
@@ -45,4 +45,4 @@ jobs:
         version: ${{ matrix.zig }}
 
     - name: Run tests
-      run: make test_cross
+      run: make test_cross

build/patch.zig

@@ -14,15 +14,24 @@ pub fn main() !void {
     const patch_file_path = args[2];
     const output_path = args[3];
 
-    const patch_file = try std.fs.openFileAbsolute(patch_file_path, .{ .mode = .read_only });
-    defer patch_file.close();
-    const chunk_details = Chunk.next(allocator, patch_file) orelse @panic("No chunk data found");
+    const patch_file = patch_file: {
+        const patch_file = try std.fs.cwd().openFile(patch_file_path, .{ .mode = .read_only });
+        defer patch_file.close();
+        var patch_buf: [4096]u8 = undefined;
+        var reader = patch_file.reader(&patch_buf);
+        break :patch_file try reader.interface.allocRemaining(allocator, .unlimited);
+    };
+    const chunk_details = Chunk.init(allocator, patch_file, 0) orelse @panic("No chunk data found");
 
-    const file = try std.fs.openFileAbsolute(file_path, .{ .mode = .read_only });
+    const file = try std.fs.cwd().openFile(file_path, .{ .mode = .read_only });
     defer file.close();
+    var in_buf: [4096]u8 = undefined;
+    var reader = file.reader(&in_buf);
 
-    const output = try std.fs.createFileAbsolute(output_path, .{});
+    const output = try std.fs.cwd().createFile(output_path, .{});
     defer output.close();
+    var out_buf: [4096]u8 = undefined;
+    var writer = output.writer(&out_buf);
 
     var state: State = .copy;
 
@@ -32,26 +41,41 @@ pub fn main() !void {
 
         switch (state) {
             .copy => {
-                const line = getLine(allocator, file) orelse return;
-                _ = try output.write(line);
-                _ = try output.write("\n");
+                _ = try reader.interface.streamDelimiterEnding(&writer.interface, '\n');
+                _ = reader.interface.takeByte() catch |err| switch (err) {
+                    error.EndOfStream => {
+                        try writer.end();
+                        return;
+                    },
+                    else => return err,
+                };
+                try writer.interface.writeByte('\n');
             },
             .chunk => {
                 const chunk = chunk_details.lines[line_number - chunk_details.src];
                 switch (chunk.action) {
                     .remove => {
-                        const line = getLine(allocator, file) orelse return;
+                        const line = reader.interface.takeDelimiterExclusive('\n') catch |err| switch (err) {
+                            error.EndOfStream => return,
+                            else => return err,
+                        };
                         if (!std.mem.eql(u8, chunk.buf, line)) @panic("Failed to apply patch");
                     },
                     .keep => {
-                        const line = getLine(allocator, file) orelse return;
-                        if (!std.mem.eql(u8, chunk.buf, line)) @panic("Failed to apply patch");
-                        _ = try output.write(line);
-                        _ = try output.write("\n");
+                        const line = reader.interface.takeDelimiterExclusive('\n') catch |err| switch (err) {
+                            error.EndOfStream => return,
+                            else => return err,
+                        };
+                        if (!std.mem.eql(u8, chunk.buf, line)) {
+                            std.debug.print("exp {s}\ngot {s}\n", .{ chunk.buf, line });
+                            @panic("Failed to apply patch");
+                        }
+                        try writer.interface.writeAll(line);
+                        try writer.interface.writeByte('\n');
                     },
                     .add => {
-                        _ = try output.write(chunk.buf);
-                        _ = try output.write("\n");
+                        try writer.interface.writeAll(chunk.buf);
+                        try writer.interface.writeByte('\n');
                     },
                 }
 
@@ -62,7 +86,8 @@ pub fn main() !void {
 }
 
 fn getLine(allocator: Allocator, file: File) ?[]u8 {
-    return file.reader().readUntilDelimiterAlloc(allocator, '\n', std.math.maxInt(usize)) catch |err| switch (err) {
+    var buffer: [4096]u8 = undefined;
+    return file.reader(&buffer).readUntilDelimiterAlloc(allocator, '\n', std.math.maxInt(usize)) catch |err| switch (err) {
         error.EndOfStream => return null,
         else => @panic("Error"),
     };
@@ -82,9 +107,9 @@ const Chunk = struct {
         buf: []const u8,
     };
 
-    fn next(allocator: Allocator, file: File) ?Chunk {
-        while (true) {
-            const line = getLine(allocator, file) orelse return null;
+    fn init(arena: std.mem.Allocator, contents: []const u8, pos: usize) ?Chunk {
+        var it = std.mem.tokenizeScalar(u8, contents[pos..], '\n');
+        while (it.next()) |line| {
             if (std.mem.startsWith(u8, line, "@@")) {
                 const end = std.mem.indexOfPosLinear(u8, line, 3, "@@").?;
                 const details = line[4 .. end - 2];
@@ -95,7 +120,7 @@ const Chunk = struct {
 
                 var lines: std.ArrayListUnmanaged(Line) = .empty;
                 while (true) {
-                    const diff_line = getLine(allocator, file) orelse break;
+                    const diff_line = it.next() orelse break;
                     if (std.mem.startsWith(u8, diff_line, "@@")) break;
 
                     const action: Line.Action = switch (diff_line[0]) {
@@ -105,16 +130,17 @@ const Chunk = struct {
                         else => @panic("Bad patch file"),
                     };
 
-                    lines.append(allocator, .{ .action = action, .buf = diff_line[1..] }) catch unreachable;
+                    lines.append(arena, .{ .action = action, .buf = diff_line[1..] }) catch unreachable;
                 }
 
                 return .{
-                    .lines = lines.toOwnedSlice(allocator) catch unreachable,
+                    .lines = lines.toOwnedSlice(arena) catch unreachable,
                     .src = src,
                     .dst = dst,
                 };
             }
         }
+        return null;
     }
 
     fn getLineNumber(buf: []const u8) usize {

examples/interpreter.zig

@@ -20,15 +20,19 @@ pub fn main() anyerror!void {
     // Open all Lua standard libraries
     lua.openLibs();
 
-    var stdin = std.io.getStdIn().reader();
-    var stdout = std.io.getStdOut().writer();
+    var in_buf: [4096]u8 = undefined;
+    var out_buf: [4096]u8 = undefined;
+    var stdin_file = std.fs.File.stdin().reader(&in_buf);
+    const stdin = &stdin_file.interface;
+    var stdout_file = std.fs.File.stdout().writer(&out_buf);
+    const stdout = &stdout_file.interface;
 
     var buffer: [256]u8 = undefined;
     while (true) {
-        _ = try stdout.write("> ");
+        _ = try stdout.writeAll("> ");
 
         // Read a line of input
-        const len = try stdin.read(&buffer);
+        const len = try stdin.readSliceShort(&buffer);
         if (len == 0) break; // EOF
         if (len >= buffer.len - 1) {
             try stdout.print("error: line too long!\n", .{});