Custom bit array and work around ziglang/zig#16343

Author: 190n

src/bindings.zig

@@ -80,7 +80,7 @@ export fn zip8CpuSetDisplayNotDirty(cpu: ?*anyopaque) callconv(.C) void {
 }
 
 export fn zip8CpuGetDisplay(cpu: ?*const anyopaque) callconv(.C) [*]const u8 {
-    return &cpuPtrCast(cpu).display.bytes;
+    return &cpuPtrCast(cpu).display;
 }
 
 export fn zip8CpuGetInstruction(cpu: ?*const anyopaque) callconv(.C) u16 {

src/cpu.zig

@@ -5,7 +5,9 @@ const std = @import("std");
 const Instruction = @import("./instruction.zig");
 const font_data = @import("./font.zig").font_data;
 
-pub const memory_size = @import("build_options").memory_size orelse 4096;
+const build_options = @import("build_options");
+
+pub const memory_size = build_options.memory_size orelse 4096;
 
 comptime {
     if (memory_size > 4096) {
@@ -43,10 +45,7 @@ stack: std.BoundedArray(u12, 16),
 rand: std.rand.DefaultPrng,
 
 /// display is 64x32 stored row-major
-display: std.PackedIntArray(u1, 2048) = blk: {
-    @setEvalBranchQuota(20000);
-    break :blk std.PackedIntArray(u1, 2048).initAllTo(0);
-},
+display: [display_width * display_height / 8]u8 = .{0} ** (display_width * display_height / 8),
 /// whether the contents of the screen have changed since the last time this flag was set to false
 display_dirty: bool = false,
 
@@ -89,7 +88,9 @@ pub fn init(program: []const u8, seed: u64, flags: [8]u8) error{ProgramTooLong}!
 }
 
 pub fn cycle(self: *Cpu) !void {
-    const opcode: u16 = (@as(u16, self.mem[self.pc]) << 8) | self.mem[self.pc + 1];
+    const hi: u8 = @as([*]u8, @ptrCast(&self.mem))[self.pc];
+    const lo: u8 = @as([*]u8, @ptrCast(&self.mem))[self.pc + 1];
+    const opcode: u16 = (@as(u16, hi) << 8) + lo;
     const inst = Instruction.decode(opcode);
     log.debug("{any}", .{inst});
     if (inst.exec(self) catch |e| {
@@ -138,6 +139,22 @@ pub fn setKeys(self: *Cpu, new_keys: *const [16]bool) void {
     @memcpy(&self.keys, new_keys);
 }
 
+pub fn invertPixel(self: *Cpu, x: u8, y: u8) void {
+    const pixel_index = display_width * @as(u16, y) + @as(u16, x);
+    const byte_index = pixel_index / 8;
+    const bit_index: u3 = @truncate(pixel_index);
+
+    self.display[byte_index] ^= (@as(u8, 1) << bit_index);
+}
+
+pub fn getPixel(self: *const Cpu, x: u8, y: u8) u1 {
+    const pixel_index = display_width * @as(u16, y) + @as(u16, x);
+    const byte_index = pixel_index / 8;
+    const bit_index: u3 = @truncate(pixel_index);
+
+    return @truncate(@as([*]const u8, @ptrCast(&self.display))[byte_index] >> bit_index);
+}
+
 test "Cpu.init" {
     const cpu = try Cpu.init("abc", 0, .{0} ** 8);
     try std.testing.expectEqualSlices(u8, &(.{0} ** 16), &cpu.V);
@@ -148,7 +165,7 @@ test "Cpu.init" {
     try std.testing.expectEqual(@as(usize, 0), cpu.stack.len);
 
     for (0..cpu.display.len) |i| {
-        try std.testing.expectEqual(@as(u1, 0), cpu.display.get(i));
+        try std.testing.expectEqual(@as(u8, 0), cpu.display[i]);
     }
 
     try std.testing.expectEqualSlices(bool, &(.{false} ** 16), &cpu.keys);

src/instruction.zig

@@ -111,7 +111,7 @@ fn opIllegalArithmetic(vx: u8, vy: u8) !ArithmeticOpcodeResult {
 fn op00EX(self: Instruction, cpu: *Cpu) !?u12 {
     switch (self.opcode) {
         0x00E0 => {
-            cpu.display.setAll(0);
+            @memset(&cpu.display, 0);
             cpu.display_dirty = true;
             return null;
         },
@@ -131,10 +131,10 @@ test "00E0 clear screen" {
         0x00, 0xE0,
     }, testing_seed, .{0} ** 8);
     // fill screen
-    cpu.display.setAll(1);
+    @memset(&cpu.display, 0xff);
     try cpu.cycle();
-    for (0..cpu.display.len) |i| {
-        try std.testing.expectEqual(@as(u1, 0), cpu.display.get(i));
+    for (cpu.display) |byte| {
+        try std.testing.expectEqual(@as(u8, 0), byte);
     }
     try std.testing.expect(cpu.display_dirty);
 }
@@ -639,6 +639,13 @@ test "CXNN random" {
     try std.testing.expectEqual(@as(u8, 0x00), cpu.V[0x0]);
 }
 
+export fn draw(ptr: ?*anyopaque, xReg: u8, yReg: u8, rows: u8) callconv(.C) void {
+    const cpu: *Cpu = @alignCast(@ptrCast(ptr.?));
+    const inst = Instruction.decode(0xd000 | (@as(u16, xReg) << 8) | (yReg << 4) | rows);
+    _ = inst.exec(cpu) catch unreachable;
+    cpu.pc +%= 2;
+}
+
 /// DXYN: draw an 8xN sprite from memory starting at I at (VX, VY); set VF to 1 if any pixel was
 /// turned off, 0 otherwise
 fn opDraw(self: Instruction, cpu: *Cpu) !?u12 {
@@ -648,22 +655,19 @@ fn opDraw(self: Instruction, cpu: *Cpu) !?u12 {
     const y_start = cpu.V[self.regY] % Cpu.display_height;
     for (sprite, 0..) |row, y_sprite| {
         for (0..8) |x_sprite| {
-            const mask = @as(u8, 0b10000000) >> @as(u3, @intCast(x_sprite));
-            const pixel = @intFromBool(row & mask != 0);
-            const x = x_start + x_sprite;
-            const y = y_start + y_sprite;
+            const pixel: u1 = @truncate(row >> @intCast(7 - x_sprite));
+
+            const x: u8 = @intCast(x_start + x_sprite);
+            const y: u8 = @intCast(y_start + y_sprite);
             if (x >= Cpu.display_width or y >= Cpu.display_height) {
                 continue;
             }
 
-            const index = y * Cpu.display_width + x;
-            if (pixel == 1 and cpu.display.get(index) == 1) {
-                // pixel turned off
-                cpu.V[0xF] = 1;
+            if (pixel == 1) {
+                if (cpu.getPixel(x, y) == 1) cpu.V[0xF] = 1;
+                cpu.invertPixel(x, y);
+                cpu.display_dirty = true;
             }
-            // draw using XOR
-            cpu.display.set(index, @intFromBool(pixel != cpu.display.get(index)));
-            cpu.display_dirty = cpu.display_dirty or pixel == 1;
         }
     }
     return null;
@@ -696,8 +700,7 @@ test "DXYN draw" {
     for (sprites, 0..) |pixel, y| {
         for (0..8) |x| {
             const expected: u1 = @truncate(pixel >> @intCast(7 - x));
-            const actual_index = Cpu.display_width * (y + 17) + x + 8;
-            try std.testing.expectEqual(expected, cpu.display.get(actual_index));
+            try std.testing.expectEqual(expected, cpu.getPixel(@intCast(x + 8), @intCast(y + 17)));
         }
     }
 
@@ -708,7 +711,7 @@ test "DXYN draw" {
     try std.testing.expect(cpu.display_dirty);
     // all off
     for (0..cpu.display.len) |i| {
-        try std.testing.expectEqual(@as(u1, 0), cpu.display.get(i));
+        try std.testing.expectEqual(@as(u8, 0), cpu.display[i]);
     }
 }
 
@@ -965,7 +968,7 @@ test "FX55 store registers" {
 /// FX65: load values from memory starting at I into registers [V0, VX]; set I to I + X + 1
 fn opLoad(self: Instruction, cpu: *Cpu) !?u12 {
     for (0..(@as(u8, self.regX) + 1)) |offset| {
-        cpu.V[offset] = cpu.mem[cpu.I];
+        cpu.V[offset] = @as([*]const u8, @ptrCast(&cpu.mem))[cpu.I];
         cpu.I +%= 1;
     }
     return null;