fix: update to 0.12.0-dev.2063+804cee3b9

build.zig

@@ -15,63 +15,33 @@ pub fn build(b: *std.Build) void {
     // set a preferred release mode, allowing the user to decide how to optimize.
     const optimize = b.standardOptimizeOption(.{});
 
-    const util_dep = b.dependency("zba-util", .{});
+    const util_dep = b.dependency("zba-util", .{}); // https://git.musuka.dev/paoda/zba-util
-    const bitfield_mod = b.createModule(.{ .source_file = .{ .path = "lib/bitfield.zig" }, .dependencies = &.{} });
+    const bitfield_mod = b.createModule(.{ .root_source_file = .{ .path = "lib/bitfield.zig" } }); // https://github.com/FlorenceOS/Florence
 
     _ = b.addModule("arm32", .{
-        .source_file = .{ .path = "src/lib.zig" },
+        .root_source_file = .{ .path = "src/lib.zig" },
-        .dependencies = &.{
+        .imports = &.{
-            .{
+            .{ .name = "bitfield", .module = bitfield_mod },
-                .name = "zba-util",
+            .{ .name = "bitfield", .module = util_dep.module("zba-util") },
-                .module = util_dep.module("zba-util"),
-            },
-            .{
-                .name = "bitfield",
-                .module = bitfield_mod,
-            },
         },
     });
 
     // Creates a step for unit testing. This only builds the test executable
     // but does not run it.
-    const lib_tests = b.addTest(.{
+    const tests = b.addTest(.{
         .root_source_file = .{ .path = "src/lib.zig" },
         .target = target,
         .optimize = optimize,
     });
 
-    lib_tests.addModule("zba-util", util_dep.module("zba-util")); // https://git.musuka.dev/paoda/zba-util
+    tests.root_module.addImport("zba-util", util_dep.module("zba-util"));
-    lib_tests.addModule("bitfield", bitfield_mod);
+    tests.root_module.addImport("bitfield", bitfield_mod);
 
-    const run_lib_tests = b.addRunArtifact(lib_tests);
+    const run_tests = b.addRunArtifact(tests);
 
     // This creates a build step. It will be visible in the `zig build --help` menu,
     // and can be selected like this: `zig build test`
     // This will evaluate the `test` step rather than the default, which is "install".
     const test_step = b.step("test", "Run library tests");
-    test_step.dependOn(&run_lib_tests.step);
+    test_step.dependOn(&run_tests.step);
-}
-
-/// `arm32` will expect the depender to supply the `zba-util` library via the package maanger
-pub fn module(b: *std.Build) *std.Build.Module {
-    const bitfield = b.createModule(.{ .source_file = .{ .path = path("/lib/bitfield.zig") }, .dependencies = &.{} });
-
-    const zba_util = b.dependency("zba-util", .{}).module("zba-util");
-
-    return b.createModule(.{
-        .source_file = .{ .path = path("/src/lib.zig") },
-        .dependencies = &.{
-            .{ .name = "zba-util", .module = zba_util },
-            .{ .name = "bitfield", .module = bitfield },
-        },
-    });
-}
-
-// https://github.com/MasterQ32/SDL.zig/blob/4d565b54227b862c1540719e0e21a36d649e87d5/build.zig#L114-L120
-fn path(comptime suffix: []const u8) []const u8 {
-    if (suffix[0] != '/') @compileError("relToPath requires an absolute path!");
-    return comptime blk: {
-        const root_dir = std.fs.path.dirname(@src().file) orelse ".";
-        break :blk root_dir ++ suffix;
-    };
 }

build.zig.zon

@@ -1,10 +1,16 @@
 .{
     .name = "arm32",
     .version = "0.1.0",
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "lib/bitfield.zig",
+        "src",
+    },
     .dependencies = .{
         .@"zba-util" = .{
-            .url = "https://git.musuka.dev/paoda/zba-util/archive/322c798e384a0d24cc84ffcfa2e4a3ca807798a0.tar.gz",
+            .url = "https://git.musuka.dev/paoda/zba-util/archive/78b944a98f18592512241f71ca2267ef951c82e1.tar.gz",
-            .hash = "12209ce0e729460b997706e47a53a32f1842672cd120189e612f4871731780a30ed0",
+            .hash = "12207da7e1f5d6180666db9575f84373055b230cb4259a4b6310562293338dc10b9d",
         },
     },
 }

src/arm.zig

@@ -480,8 +480,6 @@ fn Tcm(comptime count: usize, comptime default_addr: u32) type {
         ///
         /// The caller doesn't particularly care about "why" though.
         pub fn read(self: *const @This(), comptime T: type, address: u32) ?T {
-            const readInt = std.mem.readIntSliceLittle;
-
             if (!self.enabled) return null;
             if (self.load_mode) return null;
 
@@ -489,7 +487,7 @@ fn Tcm(comptime count: usize, comptime default_addr: u32) type {
             const end_addr = self.base_address + self.virt.size;
 
             if (start_addr <= address and address < end_addr) {
-                return readInt(T, self.buf[address & self.virt.mask ..][0..@sizeOf(T)]);
+                return std.mem.readInt(T, self.buf[address & self.virt.mask ..][0..@sizeOf(T)], .little);
             }
 
             return null;
@@ -503,14 +501,13 @@ fn Tcm(comptime count: usize, comptime default_addr: u32) type {
         ///
         /// The caller doesn't particularly care about "why" though.
         pub fn write(self: *@This(), comptime T: type, address: u32, value: T) bool {
-            const writeInt = std.mem.writeIntSliceLittle;
             if (!self.enabled) return false;
 
             const start_addr = self.base_address;
             const end_addr = self.base_address + self.virt.size;
 
             if (start_addr <= address and address < end_addr) {
-                writeInt(T, self.buf[address & self.virt.mask ..][0..@sizeOf(T)], value);
+                std.mem.writeInt(T, self.buf[address & self.virt.mask ..][0..@sizeOf(T)], value, .little);
                 return true;
             }