libraries have been updated to 0.15

lib/p2/src/structures/utils.zig

@@ -14,13 +14,15 @@ pub fn createFileWithPath(filePath: []const u8) !std.fs.File {
     return file;
 }
 
-pub fn loadFileAlloc(filename: []const u8, comptime alignment: usize, allocator: std.mem.Allocator) ![]u8 {
+pub fn loadFileAlloc(filename: []const u8, comptime alignment: std.mem.Alignment, allocator: std.mem.Allocator) ![]u8 {
     var file = try std.fs.cwd().openFile(filename, .{});
     defer file.close();
     const filesize = (try file.stat()).size + 1; // add null byte
-    const buffer: []align(alignment) u8 = try allocator.alignedAlloc(u8, alignment, filesize);
+    const buffer: []u8 = try allocator.alignedAlloc(u8, alignment, filesize);
     errdefer allocator.free(buffer);
-    try file.reader().readNoEof(buffer[0 .. buffer.len - 1]);
+    const fileReadBuffer = try file.readToEndAlloc(allocator, buffer.len - 1);
+    defer allocator.free(fileReadBuffer);
+    std.mem.copyForwards(u8, buffer, fileReadBuffer);
     buffer[buffer.len - 1] = 0;
     return buffer;
 }

lib/packer/src/PackedFileEntry.zig

@@ -37,15 +37,15 @@ pub fn calculateHeaderLen() usize {
     return 184;
 }
 
-pub fn loadFromReader(self: *@This(), reader: anytype) !void {
+pub fn loadFromReader(self: *@This(), reader: *std.Io.Reader) !void {
     var bytesRead: usize = 0;
-    bytesRead += try reader.read(p2.u64_to_slice(&self.fileOffset));
+    bytesRead += try reader.readSliceShort(p2.u64_to_slice(&self.fileOffset));
-    bytesRead += try reader.read(p2.u64_to_slice(&self.fileLen));
+    bytesRead += try reader.readSliceShort(p2.u64_to_slice(&self.fileLen));
-    bytesRead += try reader.read(p2.u32_to_slice(&self.fileNameLen));
+    bytesRead += try reader.readSliceShort(p2.u32_to_slice(&self.fileNameLen));
-    bytesRead += try reader.read(p2.u32_to_slice(&self.typeLen));
+    bytesRead += try reader.readSliceShort(p2.u32_to_slice(&self.typeLen));
 
-    bytesRead += try reader.read(&self.fileName);
+    bytesRead += try reader.readSliceShort(&self.fileName);
-    bytesRead += try reader.read(&self.typeName);
+    bytesRead += try reader.readSliceShort(&self.typeName);
 
     std.debug.assert(bytesRead == calculateHeaderLen());
 
@@ -54,7 +54,7 @@ pub fn loadFromReader(self: *@This(), reader: anytype) !void {
 
 // returns bytes written, not a true serialize function,
 // writes out it's contents as it's meant to be read back to the writer.
-pub fn writeHeader(self: @This(), writer: anytype, elementsCount: u32) !usize {
+pub fn writeHeader(self: @This(), writer: *std.Io.Writer, elementsCount: u32) !usize {
     _ = elementsCount;
     var bytesWritten: usize = 0;
 
@@ -100,18 +100,18 @@ pub const ReaderIterator = struct {
 
     // this iterator becomes invalidated if anythign else modifies
     // the iterator is finished
-    pub fn init(reader: anytype) !@This() {
+    pub fn init(reader: *std.Io.Reader) !@This() {
         var bytesRead: usize = 0;
 
         // read and verify magic
         var magic: [4]u8 align(4) = undefined;
-        try p2.assert(try reader.read(&magic) == 4);
+        try p2.assert(try reader.readSliceShort(&magic) == 4);
         try p2.assert(p2.arrayTo_u32(magic) == constants.PackerMagic);
         bytesRead += 4;
 
         // read the number of header entries
         var entriesCount_read: [4]u8 align(4) = undefined;
-        try p2.assert(try reader.read(&entriesCount_read) == 4);
+        try p2.assert(try reader.readSliceShort(&entriesCount_read) == 4);
         const entriesCount = p2.arrayTo_u32(entriesCount_read);
         std.debug.print("entriesCount = {d}\n", .{entriesCount});
         bytesRead += 4;
@@ -122,7 +122,7 @@ pub const ReaderIterator = struct {
         };
     }
 
-    pub fn next(self: *@This(), reader: anytype) !?PackedFileEntry {
+    pub fn next(self: *@This(), reader: *std.Io.Reader) !?PackedFileEntry {
         std.debug.print("readCount = {d}\n", .{self.readCount});
         if (self.readCount == self.totalCount)
             return null;

lib/packer/src/packer.zig

@@ -18,7 +18,7 @@ pub const PackerBytesRef = struct {
     raw_bytes: []const u8,
 };
 
-const PackedArchiveContents = std.ArrayListAlignedUnmanaged(u8, 8);
+const PackedArchiveContents = std.ArrayListAlignedUnmanaged(u8, .@"8");
 
 // only responsible for reading and writing archives from disk
 // not intended to be the end API
@@ -73,7 +73,7 @@ pub const PackedArchive = struct {
         self.finished = true;
     }
 
-    fn loadHeadersFromReader(self: *@This(), reader: anytype) !usize {
+    fn loadHeadersFromReader(self: *@This(), reader: *std.io.Reader) !usize {
         var iterator = try PackedFileEntry.ReaderIterator.init(reader);
         while (try iterator.next(reader)) |entry| {
             try self.headerEntries.append(self.allocator, entry);
@@ -81,17 +81,17 @@ pub const PackedArchive = struct {
         return iterator.bytesRead;
     }
 
-    fn loadContentFromReader(self: *@This(), reader: anytype) !usize {
+    fn loadContentFromReader(self: *@This(), reader: *std.io.Reader) !usize {
         const writer = self.contents.writer(self.allocator);
         var totalRead: usize = 0;
 
         var readBuffer: [1024]u8 = undefined;
-        var bytesRead = try reader.read(&readBuffer);
+        var bytesRead = try reader.readSliceShort(&readBuffer);
         totalRead += bytesRead;
         _ = try writer.write((&readBuffer)[0..bytesRead]);
 
         while (bytesRead > 0) {
-            bytesRead = try reader.read(&readBuffer);
+            bytesRead = try reader.readSliceShort(&readBuffer);
             _ = try writer.write((&readBuffer)[0..bytesRead]);
             totalRead += bytesRead;
         }
@@ -105,7 +105,7 @@ pub const PackedArchive = struct {
 
     pub fn loadFromBytes(self: *@This(), bytes: []const u8) !void {
         try p2.assert(self.finished != true);
-        var reader = std.io.fixedBufferStream(bytes);
+        var reader = std.io.Reader.fixed(bytes);
         const bytesRead = try self.loadHeadersFromReader(&reader);
         self.setContentRefToOffset(bytes, bytesRead);
         try self.finishBuilding(true);
@@ -117,9 +117,12 @@ pub const PackedArchive = struct {
         const file = try std.fs.cwd().openFile(filePath, .{});
         defer file.close();
 
-        const reader = file.reader();
+        const buf = try self.allocator.alloc(u8, 8192);
-        _ = try self.loadHeadersFromReader(reader);
+        defer self.allocator.free(buf);
-        const contentBytes = try self.loadContentFromReader(reader);
+
+        var reader = file.reader(buf);
+        _ = try self.loadHeadersFromReader(&reader.interface);
+        const contentBytes = try self.loadContentFromReader(&reader.interface);
 
         try self.finishBuilding(false);
 
@@ -132,7 +135,12 @@ pub const PackedArchive = struct {
         const file = try p2.createFileWithPath(filePath);
         defer file.close();
 
-        const writer = file.writer();
+        const buf = try self.allocator.alloc(u8, 8192);
+        defer self.allocator.free(buf);
+
+        var w = file.writer(buf);
+        const writer = &w.interface;
+
         // write out pack magic and number of header elements to indicate start of file.
         try writer.writeAll(&@as([4]u8, @bitCast(PackerMagic)));
         try writer.writeAll(&@as([4]u8, @bitCast(

lib/packer/src/packerfs.zig

@@ -162,7 +162,7 @@ pub const PackerFS = struct {
         try self.anyWatchCallbacks.append(self.allocator, .{ .func = callback, .ctx = ctx });
     }
 
-    pub fn watchCallback(path: [*c]const u8, ctx: ?*anyopaque) callconv(.C) void {
+    pub fn watchCallback(path: [*c]const u8, ctx: ?*anyopaque) callconv(.c) void {
         const self: *@This() = @ptrCast(@alignCast(ctx));
 
         for (self.fileWatchCallbacks.items) |*watch| {
@@ -222,14 +222,17 @@ pub const PackerFS = struct {
         const file = try std.fs.cwd().openFile(filePath, .{});
         defer file.close();
 
-        const reader = file.reader();
+        const buf = try self.allocator.alloc(u8, 8192);
-        var iterator = try PackedFileEntry.ReaderIterator.init(reader);
+        defer self.allocator.free(buf);
+
+        var reader = file.reader(buf);
+        var iterator = try PackedFileEntry.ReaderIterator.init(&reader.interface);
 
         const pakMountingIndex = self.pakMountings.items.len;
 
         try self.pakMountings.append(self.allocator, .{ .filePath = try self.stringAlloc().dupe(u8, filePath) });
 
-        while (try iterator.next(reader)) |headerEntry| {
+        while (try iterator.next(&reader.interface)) |headerEntry| {
             var HeaderName = Name.Make(headerEntry.getFileName());
 
             if (self.fileHandlesByName.get(HeaderName.handle())) |oldFileHeaderIndex| {
@@ -343,7 +346,7 @@ pub const PackerFS = struct {
         const fullPath = try std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ basePath, path });
         defer self.allocator.free(fullPath);
 
-        const fileBytes: []align(8) u8 = @alignCast(p2.loadFileAlloc(fullPath, 8, self.allocator) catch |err| switch (err) {
+        const fileBytes: []align(8) u8 = @alignCast(p2.loadFileAlloc(fullPath, .@"8", self.allocator) catch |err| switch (err) {
             error.FileNotFound => {
                 return null;
             },
@@ -397,7 +400,7 @@ pub const PackerFS = struct {
         if (!pakMountingRef.isFileMounted()) {
             // std.debug.print("mounting file: {s}\n", .{pakMountingRef.filePath});
             // std.debug.print("loading mount ref {s}\n", .{pakMountingRef.filePath});
-            const fileBytes: []align(8) u8 = @alignCast(p2.loadFileAlloc(pakMountingRef.filePath, 8, self.allocator) catch |err| switch (err) {
+            const fileBytes: []align(8) u8 = @alignCast(p2.loadFileAlloc(pakMountingRef.filePath, .@"8", self.allocator) catch |err| switch (err) {
                 error.FileNotFound => {
                     return null;
                 },

lib/packer/src/watcher.zig

@@ -1,7 +1,7 @@
-pub const CallbackType = *const fn ([*c]const u8, ?*anyopaque) callconv(.C) void;
+pub const CallbackType = *const fn ([*c]const u8, ?*anyopaque) callconv(.c) void;
 
 pub extern fn createWatchPoint(
     [*c]const u8,
     CallbackType,
     ?*anyopaque,
-) callconv(.C) ?*anyopaque;
+) callconv(.c) ?*anyopaque;

lib/packer/tests/test.zig

@@ -60,7 +60,10 @@ test "packer forward path" {
         archive3.getFileByName("testFile.txt").?.raw_bytes,
     ));
 
-    const writer = std.io.getStdErr().writer();
+    var buf: [8192]u8 = undefined;
+    var w = std.fs.File.stderr().writer(&buf);
+    const writer = &w.interface;
+    defer writer.flush() catch {};
 
     try p2.xxdWrite(writer, archive.getFileByName("lost_empire.obj").?.raw_bytes[0..0x40], .{});
 
@@ -89,7 +92,11 @@ test "packerfs_test" {
 
     std.debug.print("mapping len {d} lost_empire len {d}\n", .{ lost_empire_mapping.bytes.len, lost_empire.len });
 
-    const writer = std.io.getStdErr().writer();
+    var buf: [8192]u8 = undefined;
+    var w = std.fs.File.stderr().writer(&buf);
+    const writer = &w.interface;
+    defer writer.flush() catch {};
+
     try p2.xxdWrite(writer, lost_empire_mapping.bytes[0..0x40], .{});
     std.debug.print("\n", .{});
     try p2.xxdWrite(writer, lost_empire[0..0x40], .{});

lib/sdl3/build.zig

@@ -86,7 +86,18 @@ pub fn build(b: *std.Build) void {
     mod.addIncludePath(b.path("SDL/include"));
     mod.linkLibrary(sdl3_lib);
 
-    const test_step = b.step("test", "run unit tests for sdl3");
+    const test_step2 = b.step("test", "run unit tests for sdl3");
+    const tests2 = b.addExecutable(.{
+        .name = "hello-sdl",
+        .root_module = b.createModule(.{
+            .target = target,
+            .optimize = optimize,
+            .root_source_file = b.path("src/samples/compiletest.zig"),
+            .link_libc = true,
+        }),
+    });
+
+    const test_step = b.step("test-triangle", "run unit tests for sdl3");
     const tests = b.addExecutable(.{
         .name = "hello-triangle",
         .root_module = b.createModule(.{
@@ -105,6 +116,10 @@ pub fn build(b: *std.Build) void {
     const runArtifact = b.addRunArtifact(tests);
     test_step.dependOn(&runArtifact.step);
 
+    const runArtifact2 = b.addRunArtifact(tests2);
+    test_step2.dependOn(&runArtifact2.step);
+
     b.installArtifact(sdl3_lib);
     b.installArtifact(tests);
+    b.installArtifact(tests2);
 }