From a217a2e323a0819ad4838d6949c343eb9864f0aa Mon Sep 17 00:00:00 2001 From: paoda Date: Thu, 8 Feb 2024 19:07:47 -0600 Subject: [PATCH] fix: update to 0.12.0-dev.2063+804cee3b9 --- build.zig | 52 +++++++++++---------------------------------------- build.zig.zon | 10 ++++++++-- src/arm.zig | 7 ++----- 3 files changed, 21 insertions(+), 48 deletions(-) diff --git a/build.zig b/build.zig index 7ef622c..f1080cf 100644 --- a/build.zig +++ b/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 bitfield_mod = b.createModule(.{ .source_file = .{ .path = "lib/bitfield.zig" }, .dependencies = &.{} }); + const util_dep = b.dependency("zba-util", .{}); // https://git.musuka.dev/paoda/zba-util + 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" }, - .dependencies = &.{ - .{ - .name = "zba-util", - .module = util_dep.module("zba-util"), - }, - .{ - .name = "bitfield", - .module = bitfield_mod, - }, + .root_source_file = .{ .path = "src/lib.zig" }, + .imports = &.{ + .{ .name = "bitfield", .module = bitfield_mod }, + .{ .name = "bitfield", .module = util_dep.module("zba-util") }, }, }); // 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 - lib_tests.addModule("bitfield", bitfield_mod); + tests.root_module.addImport("zba-util", util_dep.module("zba-util")); + 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); -} - -/// `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; - }; + test_step.dependOn(&run_tests.step); } diff --git a/build.zig.zon b/build.zig.zon index 2499f54..46b894b 100644 --- a/build.zig.zon +++ b/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", - .hash = "12209ce0e729460b997706e47a53a32f1842672cd120189e612f4871731780a30ed0", + .url = "https://git.musuka.dev/paoda/zba-util/archive/78b944a98f18592512241f71ca2267ef951c82e1.tar.gz", + .hash = "12207da7e1f5d6180666db9575f84373055b230cb4259a4b6310562293338dc10b9d", }, }, } diff --git a/src/arm.zig b/src/arm.zig index 4b21c4a..0401432 100644 --- a/src/arm.zig +++ b/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; }