tmp: incomplete impl of GPIO + RTC

lib/SDL.zig

@@ -1 +1 @@
-Subproject commit d66925011971fbe221fc2a7f7cb4cd8c181d9ba3
+Subproject commit 401c50ff3d0b83ad4bd89caf580ce1bd90fb5618

lib/util/bitfield.zig

@@ -14,7 +14,7 @@ fn PtrCastPreserveCV(comptime T: type, comptime PtrToT: type, comptime NewT: typ
 fn BitType(comptime FieldType: type, comptime ValueType: type, comptime shamt: usize) type {
     const self_bit: FieldType = (1 << shamt);
 
-    return extern struct {
+    return struct {
         bits: Bitfield(FieldType, shamt, 1),
 
         pub fn set(self: anytype) void {
@@ -63,7 +63,7 @@ pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bi
 
     const ValueType = std.meta.Int(.unsigned, num_bits);
 
-    return extern struct {
+    return struct {
         dummy: FieldType,
 
         fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) {

src/Gui.zig

@@ -11,6 +11,7 @@ const pitch = @import("core/ppu.zig").framebuf_pitch;
 const scale = @import("core/emu.zig").win_scale;
 
 const emu = @import("core/emu.zig");
+const asString = @import("core/util.zig").asString;
 const log = std.log.scoped(.GUI);
 
 const default_title: []const u8 = "ZBA";
@@ -53,11 +54,11 @@ pub fn init(title: [12]u8, width: i32, height: i32) Self {
     };
 }
 
-pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
+pub fn run(self: *Self, arm7tdmi: *Arm7tdmi, scheduler: *Scheduler) !void {
     var quit = std.atomic.Atomic(bool).init(false);
     var frame_rate = FpsTracker.init();
 
-    const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &frame_rate, scheduler, cpu });
+    const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &frame_rate, scheduler, arm7tdmi });
     defer thread.join();
 
     var title_buf: [0x100]u8 = [_]u8{0} ** 0x100;
@@ -68,7 +69,7 @@ pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
             switch (event.type) {
                 SDL.SDL_QUIT => break :emu_loop,
                 SDL.SDL_KEYDOWN => {
-                    const io = &cpu.bus.io;
+                    const io = &arm7tdmi.bus.io;
                     const key_code = event.key.keysym.sym;
 
                     switch (key_code) {
@@ -86,7 +87,7 @@ pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
                     }
                 },
                 SDL.SDL_KEYUP => {
-                    const io = &cpu.bus.io;
+                    const io = &arm7tdmi.bus.io;
                     const key_code = event.key.keysym.sym;
 
                     switch (key_code) {
@@ -100,12 +101,12 @@ pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
                         SDL.SDLK_s => io.keyinput.shoulder_r.set(),
                         SDL.SDLK_RETURN => io.keyinput.start.set(),
                         SDL.SDLK_RSHIFT => io.keyinput.select.set(),
-                        SDL.SDLK_i => log.err("Sample Count: {}", .{@intCast(u32, SDL.SDL_AudioStreamAvailable(cpu.bus.apu.stream)) / (2 * @sizeOf(u16))}),
+                        SDL.SDLK_i => log.err("Sample Count: {}", .{@intCast(u32, SDL.SDL_AudioStreamAvailable(arm7tdmi.bus.apu.stream)) / (2 * @sizeOf(u16))}),
                         SDL.SDLK_j => log.err("Scheduler Capacity: {} | Scheduler Event Count: {}", .{ scheduler.queue.capacity(), scheduler.queue.count() }),
                         SDL.SDLK_k => {
                             // Dump IWRAM to file
-                            log.info("PC: 0x{X:0>8}", .{cpu.r[15]});
+                            log.info("PC: 0x{X:0>8}", .{arm7tdmi.r[15]});
-                            log.info("LR: 0x{X:0>8}", .{cpu.r[14]});
+                            log.info("LR: 0x{X:0>8}", .{arm7tdmi.r[14]});
                             // const iwram_file = try std.fs.cwd().createFile("iwram.bin", .{});
                             // defer iwram_file.close();
 
@@ -119,7 +120,7 @@ pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
         }
 
         // Emulator has an internal Double Buffer
-        const framebuf = cpu.bus.ppu.framebuf.get(.Renderer);
+        const framebuf = arm7tdmi.bus.ppu.framebuf.get(.Renderer);
         _ = SDL.SDL_UpdateTexture(self.texture, null, framebuf.ptr, pitch);
         _ = SDL.SDL_RenderCopy(self.renderer, self.texture, null, null);
         SDL.SDL_RenderPresent(self.renderer);
@@ -136,13 +137,12 @@ pub fn initAudio(self: *Self, apu: *Apu) void {
     self.audio.?.play();
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: Self) void {
-    if (self.audio) |*aud| aud.deinit();
+    if (self.audio) |aud| aud.deinit();
     SDL.SDL_DestroyTexture(self.texture);
     SDL.SDL_DestroyRenderer(self.renderer);
     SDL.SDL_DestroyWindow(self.window);
     SDL.SDL_Quit();
-    self.* = undefined;
 }
 
 const Audio = struct {
@@ -169,13 +169,12 @@ const Audio = struct {
         };
     }
 
-    fn deinit(self: *This) void {
+    fn deinit(this: This) void {
-        SDL.SDL_CloseAudioDevice(self.device);
+        SDL.SDL_CloseAudioDevice(this.device);
-        self.* = undefined;
     }
 
-    pub fn play(self: *This) void {
+    pub fn play(this: *This) void {
-        SDL.SDL_PauseAudioDevice(self.device, 0);
+        SDL.SDL_PauseAudioDevice(this.device, 0);
     }
 
     export fn callback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void {

src/core/Bus.zig

@@ -49,29 +49,32 @@ io: Io,
 cpu: ?*Arm7tdmi,
 sched: *Scheduler,
 
-pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi, paths: FilePaths) !void {
+pub fn init(alloc: Allocator, sched: *Scheduler, paths: FilePaths) !Self {
-    self.* = .{
+    return Self{
-        .pak = try GamePak.init(allocator, paths.rom, paths.save),
+        .pak = try GamePak.init(alloc, paths.rom, paths.save),
-        .bios = try Bios.init(allocator, paths.bios),
+        .bios = try Bios.init(alloc, paths.bios),
-        .ppu = try Ppu.init(allocator, sched),
+        .ppu = try Ppu.init(alloc, sched),
         .apu = Apu.init(sched),
-        .iwram = try Iwram.init(allocator),
+        .iwram = try Iwram.init(alloc),
-        .ewram = try Ewram.init(allocator),
+        .ewram = try Ewram.init(alloc),
         .dma = createDmaTuple(),
         .tim = createTimerTuple(sched),
         .io = Io.init(),
-        .cpu = cpu,
+        .cpu = null,
         .sched = sched,
     };
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: Self) void {
     self.iwram.deinit();
     self.ewram.deinit();
     self.pak.deinit();
     self.bios.deinit();
     self.ppu.deinit();
-    self.* = undefined;
+}
+
+pub fn attach(self: *Self, cpu: *Arm7tdmi) void {
+    self.cpu = cpu;
 }
 
 pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {

src/core/apu.zig

@@ -444,29 +444,29 @@ const ToneSweep = struct {
             };
         }
 
-        pub fn tick(self: *This, ch1: *Self) void {
+        pub fn tick(this: *This, ch1: *Self) void {
-            if (self.timer != 0) self.timer -= 1;
+            if (this.timer != 0) this.timer -= 1;
 
-            if (self.timer == 0) {
+            if (this.timer == 0) {
                 const period = ch1.sweep.period.read();
-                self.timer = if (period == 0) 8 else period;
+                this.timer = if (period == 0) 8 else period;
-                if (!self.calc_performed) self.calc_performed = true;
+                if (!this.calc_performed) this.calc_performed = true;
 
-                if (self.enabled and period != 0) {
+                if (this.enabled and period != 0) {
-                    const new_freq = self.calcFrequency(ch1);
+                    const new_freq = this.calcFrequency(ch1);
 
                     if (new_freq <= 0x7FF and ch1.sweep.shift.read() != 0) {
                         ch1.freq.frequency.write(@truncate(u11, new_freq));
-                        self.shadow = @truncate(u11, new_freq);
+                        this.shadow = @truncate(u11, new_freq);
 
-                        _ = self.calcFrequency(ch1);
+                        _ = this.calcFrequency(ch1);
                     }
                 }
             }
         }
 
-        fn calcFrequency(self: *This, ch1: *Self) u12 {
+        fn calcFrequency(this: *This, ch1: *Self) u12 {
-            const shadow = @as(u12, self.shadow);
+            const shadow = @as(u12, this.shadow);
             const shadow_shifted = shadow >> ch1.sweep.shift.read();
             const decrease = ch1.sweep.direction.read();
 

src/core/bus/Bios.zig

@@ -8,28 +8,27 @@ pub const size = 0x4000;
 const Self = @This();
 
 buf: ?[]u8,
-allocator: Allocator,
+alloc: Allocator,
 
 addr_latch: u32,
 
-pub fn init(allocator: Allocator, maybe_path: ?[]const u8) !Self {
+pub fn init(alloc: Allocator, maybe_path: ?[]const u8) !Self {
-    const buf: ?[]u8 = if (maybe_path) |path| blk: {
+    var buf: ?[]u8 = null;
+    if (maybe_path) |path| {
         const file = try std.fs.cwd().openFile(path, .{});
         defer file.close();
-
+        buf = try file.readToEndAlloc(alloc, try file.getEndPos());
-        break :blk try file.readToEndAlloc(allocator, try file.getEndPos());
+    }
-    } else null;
 
     return Self{
         .buf = buf,
-        .allocator = allocator,
+        .alloc = alloc,
         .addr_latch = 0,
     };
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: Self) void {
-    if (self.buf) |buf| self.allocator.free(buf);
+    if (self.buf) |buf| self.alloc.free(buf);
-    self.* = undefined;
 }
 
 pub fn read(self: *Self, comptime T: type, r15: u32, addr: u32) T {

src/core/bus/Ewram.zig

@@ -5,21 +5,20 @@ const ewram_size = 0x40000;
 const Self = @This();
 
 buf: []u8,
-allocator: Allocator,
+alloc: Allocator,
 
-pub fn init(allocator: Allocator) !Self {
+pub fn init(alloc: Allocator) !Self {
-    const buf = try allocator.alloc(u8, ewram_size);
+    const buf = try alloc.alloc(u8, ewram_size);
     std.mem.set(u8, buf, 0);
 
     return Self{
         .buf = buf,
-        .allocator = allocator,
+        .alloc = alloc,
     };
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: Self) void {
-    self.allocator.free(self.buf);
+    self.alloc.free(self.buf);
-    self.* = undefined;
 }
 
 pub fn read(self: *const Self, comptime T: type, address: usize) T {

src/core/bus/GamePak.zig

@@ -10,24 +10,24 @@ const Self = @This();
 
 title: [12]u8,
 buf: []u8,
-allocator: Allocator,
+alloc: Allocator,
 backup: Backup,
 gpio: Gpio,
 
-pub fn init(allocator: Allocator, rom_path: []const u8, save_path: ?[]const u8) !Self {
+pub fn init(alloc: Allocator, rom_path: []const u8, save_path: ?[]const u8) !Self {
     const file = try std.fs.cwd().openFile(rom_path, .{});
     defer file.close();
 
-    const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
+    const file_buf = try file.readToEndAlloc(alloc, try file.getEndPos());
     const title = parseTitle(file_buf);
     const kind = Backup.guessKind(file_buf) orelse .None;
 
     var pak = Self{
         .buf = file_buf,
-        .allocator = allocator,
+        .alloc = alloc,
         .title = title,
-        .backup = try Backup.init(allocator, kind, title, save_path),
+        .gpio = Gpio.init(alloc, .Rtc),
-        .gpio = Gpio.init(allocator, .Rtc),
+        .backup = try Backup.init(alloc, kind, title, save_path),
     };
     pak.parseHeader();
 
@@ -80,11 +80,10 @@ inline fn isLarge(self: *const Self) bool {
     return self.buf.len > 0x100_0000;
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: Self) void {
+    self.alloc.free(self.buf);
     self.backup.deinit();
-    self.gpio.deinit(self.allocator);
+    self.gpio.deinit(self.alloc);
-    self.allocator.free(self.buf);
-    self.* = undefined;
 }
 
 pub fn read(self: *Self, comptime T: type, address: u32) T {
@@ -469,10 +468,10 @@ const Clock = struct {
     };
 
     const GpioData = extern union {
-        sck: Bit(u8, 0),
+        sck: Bit(u4, 0),
-        sio: Bit(u8, 1),
+        sio: Bit(u4, 1),
-        cs: Bit(u8, 2),
+        cs: Bit(u4, 2),
-        raw: u8,
+        raw: u4,
     };
 
     const Control = extern union {

src/core/bus/Iwram.zig

@@ -5,21 +5,20 @@ const iwram_size = 0x8000;
 const Self = @This();
 
 buf: []u8,
-allocator: Allocator,
+alloc: Allocator,
 
-pub fn init(allocator: Allocator) !Self {
+pub fn init(alloc: Allocator) !Self {
-    const buf = try allocator.alloc(u8, iwram_size);
+    const buf = try alloc.alloc(u8, iwram_size);
     std.mem.set(u8, buf, 0);
 
     return Self{
         .buf = buf,
-        .allocator = allocator,
+        .alloc = alloc,
     };
 }
 
-pub fn deinit(self: *Self) void {
+pub fn deinit(self: Self) void {
-    self.allocator.free(self.buf);
+    self.alloc.free(self.buf);
-    self.* = undefined;
 }
 
 pub fn read(self: *const Self, comptime T: type, address: usize) T {

src/core/bus/backup.zig

@@ -3,7 +3,7 @@ const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Backup);
 
 const escape = @import("../util.zig").escape;
-const asStringSlice = @import("../util.zig").asStringSlice;
+const asString = @import("../util.zig").asString;
 
 const backup_kinds = [5]Needle{
     .{ .str = "EEPROM_V", .kind = .Eeprom },
@@ -17,8 +17,8 @@ pub const Backup = struct {
     const Self = @This();
 
     buf: []u8,
-    allocator: Allocator,
+    alloc: Allocator,
-    kind: Kind,
+    kind: BackupKind,
 
     title: [12]u8,
     save_path: ?[]const u8,
@@ -26,15 +26,7 @@ pub const Backup = struct {
     flash: Flash,
     eeprom: Eeprom,
 
-    const Kind = enum {
+    pub fn init(alloc: Allocator, kind: BackupKind, title: [12]u8, path: ?[]const u8) !Self {
-        Eeprom,
-        Sram,
-        Flash,
-        Flash1M,
-        None,
-    };
-
-    pub fn init(allocator: Allocator, kind: Kind, title: [12]u8, path: ?[]const u8) !Self {
         log.info("Kind: {}", .{kind});
 
         const buf_size: usize = switch (kind) {
@@ -44,24 +36,24 @@ pub const Backup = struct {
             .None, .Eeprom => 0, // EEPROM is handled upon first Read Request to it
         };
 
-        const buf = try allocator.alloc(u8, buf_size);
+        const buf = try alloc.alloc(u8, buf_size);
         std.mem.set(u8, buf, 0xFF);
 
         var backup = Self{
             .buf = buf,
-            .allocator = allocator,
+            .alloc = alloc,
             .kind = kind,
             .title = title,
             .save_path = path,
             .flash = Flash.init(),
-            .eeprom = Eeprom.init(allocator),
+            .eeprom = Eeprom.init(alloc),
         };
 
-        if (backup.save_path) |p| backup.loadSaveFromDisk(allocator, p) catch |e| log.err("Failed to load save: {}", .{e});
+        if (backup.save_path) |p| backup.loadSaveFromDisk(p) catch |e| log.err("Failed to load save: {}", .{e});
         return backup;
     }
 
-    pub fn guessKind(rom: []const u8) ?Kind {
+    pub fn guessKind(rom: []const u8) ?BackupKind {
         for (backup_kinds) |needle| {
             const needle_len = needle.str.len;
 
@@ -74,15 +66,14 @@ pub const Backup = struct {
         return null;
     }
 
-    pub fn deinit(self: *Self) void {
+    pub fn deinit(self: Self) void {
-        if (self.save_path) |path| self.writeSaveToDisk(self.allocator, path) catch |e| log.err("Failed to write save: {}", .{e});
+        if (self.save_path) |path| self.writeSaveToDisk(path) catch |e| log.err("Failed to write save: {}", .{e});
-        self.allocator.free(self.buf);
+        self.alloc.free(self.buf);
-        self.* = undefined;
     }
 
-    fn loadSaveFromDisk(self: *Self, allocator: Allocator, path: []const u8) !void {
+    fn loadSaveFromDisk(self: *Self, path: []const u8) !void {
-        const file_path = try self.getSaveFilePath(allocator, path);
+        const file_path = try self.getSaveFilePath(path);
-        defer allocator.free(file_path);
+        defer self.alloc.free(file_path);
 
         // FIXME: Don't rely on this lol
         if (std.mem.eql(u8, file_path[file_path.len - 12 .. file_path.len], "untitled.sav")) {
@@ -90,8 +81,8 @@ pub const Backup = struct {
         }
 
         const file: std.fs.File = try std.fs.openFileAbsolute(file_path, .{});
-        const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
+        const file_buf = try file.readToEndAlloc(self.alloc, try file.getEndPos());
-        defer allocator.free(file_buf);
+        defer self.alloc.free(file_buf);
 
         switch (self.kind) {
             .Sram, .Flash, .Flash1M => {
@@ -106,7 +97,7 @@ pub const Backup = struct {
                 if (file_buf.len == 0x200 or file_buf.len == 0x2000) {
                     self.eeprom.kind = if (file_buf.len == 0x200) .Small else .Large;
 
-                    self.buf = try allocator.alloc(u8, file_buf.len);
+                    self.buf = try self.alloc.alloc(u8, file_buf.len);
                     std.mem.copy(u8, self.buf, file_buf);
                     return log.info("Loaded Save from {s}", .{file_path});
                 }
@@ -120,23 +111,23 @@ pub const Backup = struct {
         }
     }
 
-    fn getSaveFilePath(self: *const Self, allocator: Allocator, path: []const u8) ![]const u8 {
+    fn getSaveFilePath(self: *const Self, path: []const u8) ![]const u8 {
-        const filename = try self.getSaveFilename(allocator);
+        const filename = try self.getSaveFilename();
-        defer allocator.free(filename);
+        defer self.alloc.free(filename);
 
-        return try std.fs.path.join(allocator, &[_][]const u8{ path, filename });
+        return try std.fs.path.join(self.alloc, &[_][]const u8{ path, filename });
     }
 
-    fn getSaveFilename(self: *const Self, allocator: Allocator) ![]const u8 {
+    fn getSaveFilename(self: *const Self) ![]const u8 {
-        const title_str = asStringSlice(&escape(self.title));
+        const title = asString(escape(self.title));
-        const name = if (title_str.len != 0) title_str else "untitled";
+        const name = if (title.len != 0) title else "untitled";
 
-        return try std.mem.concat(allocator, u8, &[_][]const u8{ name, ".sav" });
+        return try std.mem.concat(self.alloc, u8, &[_][]const u8{ name, ".sav" });
     }
 
-    fn writeSaveToDisk(self: Self, allocator: Allocator, path: []const u8) !void {
+    fn writeSaveToDisk(self: Self, path: []const u8) !void {
-        const file_path = try self.getSaveFilePath(allocator, path);
+        const file_path = try self.getSaveFilePath(path);
-        defer allocator.free(file_path);
+        defer self.alloc.free(file_path);
 
         switch (self.kind) {
             .Sram, .Flash, .Flash1M, .Eeprom => {
@@ -210,13 +201,21 @@ pub const Backup = struct {
     }
 };
 
+const BackupKind = enum {
+    Eeprom,
+    Sram,
+    Flash,
+    Flash1M,
+    None,
+};
+
 const Needle = struct {
     const Self = @This();
 
     str: []const u8,
-    kind: Backup.Kind,
+    kind: BackupKind,
 
-    fn init(str: []const u8, kind: Backup.Kind) Self {
+    fn init(str: []const u8, kind: BackupKind) Self {
         return .{
             .str = str,
             .kind = kind,
@@ -231,7 +230,7 @@ const SaveError = error{
 const Flash = struct {
     const Self = @This();
 
-    state: State,
+    state: FlashState,
 
     id_mode: bool,
     set_bank: bool,
@@ -240,12 +239,6 @@ const Flash = struct {
 
     bank: u1,
 
-    const State = enum {
-        Ready,
-        Set,
-        Command,
-    };
-
     fn init() Self {
         return .{
             .state = .Ready,
@@ -300,6 +293,12 @@ const Flash = struct {
     }
 };
 
+const FlashState = enum {
+    Ready,
+    Set,
+    Command,
+};
+
 const Eeprom = struct {
     const Self = @This();
 
@@ -310,7 +309,7 @@ const Eeprom = struct {
     writer: Writer,
     reader: Reader,
 
-    allocator: Allocator,
+    alloc: Allocator,
 
     const Kind = enum {
         Unknown,
@@ -326,14 +325,14 @@ const Eeprom = struct {
         RequestEnd,
     };
 
-    fn init(allocator: Allocator) Self {
+    fn init(alloc: Allocator) Self {
         return .{
             .kind = .Unknown,
             .state = .Ready,
             .writer = Writer.init(),
             .reader = Reader.init(),
             .addr = 0,
-            .allocator = allocator,
+            .alloc = alloc,
         };
     }
 
@@ -361,7 +360,7 @@ const Eeprom = struct {
                     else => unreachable,
                 };
 
-                buf.* = self.allocator.alloc(u8, len) catch |e| {
+                buf.* = self.alloc.alloc(u8, len) catch |e| {
                     log.err("Failed to resize EEPROM buf to {} bytes", .{len});
                     std.debug.panic("EEPROM entered irrecoverable state {}", .{e});
                 };

src/core/cpu.zig

@@ -12,7 +12,7 @@ const File = std.fs.File;
 
 // ARM Instructions
 pub const arm = struct {
-    pub const InstrFn = *const fn (*Arm7tdmi, *Bus, u32) void;
+    pub const InstrFn = fn (*Arm7tdmi, *Bus, u32) void;
     const lut: [0x1000]InstrFn = populate();
 
     const processing = @import("cpu/arm/data_processing.zig").dataProcessing;
@@ -110,7 +110,7 @@ pub const arm = struct {
 
 // THUMB Instructions
 pub const thumb = struct {
-    pub const InstrFn = *const fn (*Arm7tdmi, *Bus, u16) void;
+    pub const InstrFn = fn (*Arm7tdmi, *Bus, u16) void;
     const lut: [0x400]InstrFn = populate();
 
     const processing = @import("cpu/thumb/data_processing.zig");
@@ -250,7 +250,7 @@ pub const Arm7tdmi = struct {
 
     logger: ?Logger,
 
-    pub fn init(sched: *Scheduler, bus: *Bus, log_file: ?std.fs.File) Self {
+    pub fn init(sched: *Scheduler, bus: *Bus) Self {
         return Self{
             .r = [_]u32{0x00} ** 16,
             .sched = sched,
@@ -260,10 +260,14 @@ pub const Arm7tdmi = struct {
             .banked_fiq = [_]u32{0x00} ** 10,
             .banked_r = [_]u32{0x00} ** 12,
             .banked_spsr = [_]PSR{.{ .raw = 0x0000_0000 }} ** 5,
-            .logger = if (log_file) |file| Logger.init(file) else null,
+            .logger = null,
         };
     }
 
+    pub fn attach(self: *Self, log_file: std.fs.File) void {
+        self.logger = Logger.init(log_file);
+    }
+
     inline fn bankedIdx(mode: Mode, kind: BankedKind) usize {
         const idx: usize = switch (mode) {
             .User, .System => 0,

src/core/ppu.zig

@@ -41,25 +41,28 @@ pub const Ppu = struct {
     oam: Oam,
     sched: *Scheduler,
     framebuf: FrameBuffer,
-    allocator: Allocator,
+    alloc: Allocator,
 
-    scanline_sprites: *[128]?Sprite,
+    scanline_sprites: [128]?Sprite,
     scanline: Scanline,
 
-    pub fn init(allocator: Allocator, sched: *Scheduler) !Self {
+    pub fn init(alloc: Allocator, sched: *Scheduler) !Self {
         // Queue first Hblank
         sched.push(.Draw, 240 * 4);
 
-        const sprites = try allocator.create([128]?Sprite);
+        const framebufs = try alloc.alloc(u8, (framebuf_pitch * height) * 2);
-        sprites.* = [_]?Sprite{null} ** 128;
+        std.mem.set(u8, framebufs, 0);
+
+        const scanline_buf = try alloc.alloc(?u16, width * 2);
+        std.mem.set(?u16, scanline_buf, null);
 
         return Self{
-            .vram = try Vram.init(allocator),
+            .vram = try Vram.init(alloc),
-            .palette = try Palette.init(allocator),
+            .palette = try Palette.init(alloc),
-            .oam = try Oam.init(allocator),
+            .oam = try Oam.init(alloc),
             .sched = sched,
-            .framebuf = try FrameBuffer.init(allocator),
+            .framebuf = FrameBuffer.init(framebufs),
-            .allocator = allocator,
+            .alloc = alloc,
 
             // Registers
             .win = Window.init(),
@@ -72,19 +75,17 @@ pub const Ppu = struct {
             .bldalpha = .{ .raw = 0x0000 },
             .bldy = .{ .raw = 0x0000 },
 
-            .scanline = try Scanline.init(allocator),
+            .scanline = Scanline.init(scanline_buf),
-            .scanline_sprites = sprites,
+            .scanline_sprites = [_]?Sprite{null} ** 128,
         };
     }
 
-    pub fn deinit(self: *Self) void {
+    pub fn deinit(self: Self) void {
-        self.allocator.destroy(self.scanline_sprites);
+        self.framebuf.deinit(self.alloc);
-        self.framebuf.deinit();
+        self.scanline.deinit(self.alloc);
-        self.scanline.deinit();
         self.vram.deinit();
         self.palette.deinit();
         self.oam.deinit();
-        self.* = undefined;
     }
 
     pub fn setBgOffsets(self: *Self, comptime n: u2, word: u32) void {
@@ -398,7 +399,7 @@ pub const Ppu = struct {
                 // Reset Current Scanline Pixel Buffer and list of fetched sprites
                 // in prep for next scanline
                 self.scanline.reset();
-                std.mem.set(?Sprite, self.scanline_sprites, null);
+                std.mem.set(?Sprite, &self.scanline_sprites, null);
             },
             0x1 => {
                 const fb_base = framebuf_pitch * @as(usize, scanline);
@@ -425,7 +426,7 @@ pub const Ppu = struct {
                 // Reset Current Scanline Pixel Buffer and list of fetched sprites
                 // in prep for next scanline
                 self.scanline.reset();
-                std.mem.set(?Sprite, self.scanline_sprites, null);
+                std.mem.set(?Sprite, &self.scanline_sprites, null);
             },
             0x2 => {
                 const fb_base = framebuf_pitch * @as(usize, scanline);
@@ -451,7 +452,7 @@ pub const Ppu = struct {
                 // Reset Current Scanline Pixel Buffer and list of fetched sprites
                 // in prep for next scanline
                 self.scanline.reset();
-                std.mem.set(?Sprite, self.scanline_sprites, null);
+                std.mem.set(?Sprite, &self.scanline_sprites, null);
             },
             0x3 => {
                 const vram_base = width * @sizeOf(u16) * @as(usize, scanline);
@@ -628,21 +629,20 @@ const Palette = struct {
     const Self = @This();
 
     buf: []u8,
-    allocator: Allocator,
+    alloc: Allocator,
 
-    fn init(allocator: Allocator) !Self {
+    fn init(alloc: Allocator) !Self {
-        const buf = try allocator.alloc(u8, palram_size);
+        const buf = try alloc.alloc(u8, palram_size);
         std.mem.set(u8, buf, 0);
 
         return Self{
             .buf = buf,
-            .allocator = allocator,
+            .alloc = alloc,
         };
     }
 
-    fn deinit(self: *Self) void {
+    fn deinit(self: Self) void {
-        self.allocator.free(self.buf);
+        self.alloc.free(self.buf);
-        self.* = undefined;
     }
 
     pub fn read(self: *const Self, comptime T: type, address: usize) T {
@@ -677,21 +677,20 @@ const Vram = struct {
     const Self = @This();
 
     buf: []u8,
-    allocator: Allocator,
+    alloc: Allocator,
 
-    fn init(allocator: Allocator) !Self {
+    fn init(alloc: Allocator) !Self {
-        const buf = try allocator.alloc(u8, vram_size);
+        const buf = try alloc.alloc(u8, vram_size);
         std.mem.set(u8, buf, 0);
 
         return Self{
             .buf = buf,
-            .allocator = allocator,
+            .alloc = alloc,
         };
     }
 
-    fn deinit(self: *Self) void {
+    fn deinit(self: Self) void {
-        self.allocator.free(self.buf);
+        self.alloc.free(self.buf);
-        self.* = undefined;
     }
 
     pub fn read(self: *const Self, comptime T: type, address: usize) T {
@@ -738,21 +737,20 @@ const Oam = struct {
     const Self = @This();
 
     buf: []u8,
-    allocator: Allocator,
+    alloc: Allocator,
 
-    fn init(allocator: Allocator) !Self {
+    fn init(alloc: Allocator) !Self {
-        const buf = try allocator.alloc(u8, oam_size);
+        const buf = try alloc.alloc(u8, oam_size);
         std.mem.set(u8, buf, 0);
 
         return Self{
             .buf = buf,
-            .allocator = allocator,
+            .alloc = alloc,
         };
     }
 
-    fn deinit(self: *Self) void {
+    fn deinit(self: Self) void {
-        self.allocator.free(self.buf);
+        self.alloc.free(self.buf);
-        self.* = undefined;
     }
 
     pub fn read(self: *const Self, comptime T: type, address: usize) T {
@@ -1215,38 +1213,35 @@ fn copyToSpriteBuffer(bldcnt: io.BldCnt, scanline: *Scanline, x: u9, bgr555: u16
 const Scanline = struct {
     const Self = @This();
 
-    layers: [2][]?u16,
+    buf: [2][]?u16,
-    buf: []?u16,
+    original: []?u16,
 
-    allocator: Allocator,
+    fn init(buf: []?u16) Self {
+        std.debug.assert(buf.len == width * 2);
 
-    fn init(allocator: Allocator) !Self {
+        const top_slice = buf[0..][0..width];
-        const buf = try allocator.alloc(?u16, width * 2); // Top & Bottom Scanline
+        const btm_slice = buf[width..][0..width];
-        std.mem.set(?u16, buf, null);
 
         return .{
-            // Top & Bototm Layers
+            .buf = [_][]?u16{ top_slice, btm_slice },
-            .layers = [_][]?u16{ buf[0..][0..width], buf[width..][0..width] },
+            .original = buf,
-            .buf = buf,
-            .allocator = allocator,
         };
     }
 
     fn reset(self: *Self) void {
-        std.mem.set(?u16, self.buf, null);
+        std.mem.set(?u16, self.original, null);
     }
 
-    fn deinit(self: *Self) void {
+    fn deinit(self: Self, alloc: Allocator) void {
-        self.allocator.free(self.buf);
+        alloc.free(self.original);
-        self.* = undefined;
     }
 
     fn top(self: *Self) []?u16 {
-        return self.layers[0];
+        return self.buf[0];
     }
 
     fn btm(self: *Self) []?u16 {
-        return self.layers[1];
+        return self.buf[1];
     }
 };
 
@@ -1254,36 +1249,31 @@ const Scanline = struct {
 const FrameBuffer = struct {
     const Self = @This();
 
-    layers: [2][]u8,
+    buf: [2][]u8,
-    buf: []u8,
+    original: []u8,
     current: u1,
 
-    allocator: Allocator,
-
     // TODO: Rename
     const Device = enum {
         Emulator,
         Renderer,
     };
 
-    pub fn init(allocator: Allocator) !Self {
+    pub fn init(bufs: []u8) Self {
-        const framebuf_len = framebuf_pitch * height;
+        std.debug.assert(bufs.len == framebuf_pitch * height * 2);
-        const buf = try allocator.alloc(u8, framebuf_len * 2);
+
-        std.mem.set(u8, buf, 0);
+        const front = bufs[0 .. framebuf_pitch * height];
+        const back = bufs[framebuf_pitch * height ..];
 
         return .{
-            // Front and Back Framebuffers
+            .buf = [2][]u8{ front, back },
-            .layers = [_][]u8{ buf[0..][0..framebuf_len], buf[framebuf_len..][0..framebuf_len] },
+            .original = bufs,
-            .buf = buf,
             .current = 0,
-
-            .allocator = allocator,
         };
     }
 
-    fn deinit(self: *Self) void {
+    fn deinit(self: Self, alloc: Allocator) void {
-        self.allocator.free(self.buf);
+        alloc.free(self.original);
-        self.* = undefined;
     }
 
     pub fn swap(self: *Self) void {
@@ -1291,6 +1281,6 @@ const FrameBuffer = struct {
     }
 
     pub fn get(self: *Self, comptime dev: Device) []u8 {
-        return self.layers[if (dev == .Emulator) self.current else ~self.current];
+        return self.buf[if (dev == .Emulator) self.current else ~self.current];
     }
 };

src/core/scheduler.zig

@@ -14,16 +14,15 @@ pub const Scheduler = struct {
     tick: u64,
     queue: PriorityQueue(Event, void, lessThan),
 
-    pub fn init(allocator: Allocator) Self {
+    pub fn init(alloc: Allocator) Self {
-        var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(allocator, {}) };
+        var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(alloc, {}) };
         sched.queue.add(.{ .kind = .HeatDeath, .tick = std.math.maxInt(u64) }) catch unreachable;
 
         return sched;
     }
 
-    pub fn deinit(self: *Self) void {
+    pub fn deinit(self: Self) void {
         self.queue.deinit();
-        self.* = undefined;
     }
 
     pub inline fn now(self: *const Self) u64 {

src/core/util.zig

@@ -69,7 +69,7 @@ pub fn intToBytes(comptime T: type, value: anytype) [@sizeOf(T)]u8 {
 ///
 /// This function returns a slice of everything just before the first
 /// `\0`
-pub fn asStringSlice(title: *const [12]u8) []const u8 {
+pub fn asString(title: [12]u8) []const u8 {
     var len = title.len;
     for (title) |char, i| {
         if (char == 0) {
@@ -129,45 +129,45 @@ pub const Logger = struct {
         try self.buf.writer().print(format, args);
     }
 
-    pub fn mgbaLog(self: *Self, cpu: *const Arm7tdmi, opcode: u32) void {
+    pub fn mgbaLog(self: *Self, arm7tdmi: *const Arm7tdmi, opcode: u32) void {
         const fmt_base = "{X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} cpsr: {X:0>8} | ";
         const thumb_fmt = fmt_base ++ "{X:0>4}:\n";
         const arm_fmt = fmt_base ++ "{X:0>8}:\n";
 
-        if (cpu.cpsr.t.read()) {
+        if (arm7tdmi.cpsr.t.read()) {
             if (opcode >> 11 == 0x1E) {
                 // Instruction 1 of a BL Opcode, print in ARM mode
-                const low = cpu.bus.dbgRead(u16, cpu.r[15]);
+                const low = arm7tdmi.bus.dbgRead(u16, arm7tdmi.r[15]);
                 const bl_opcode = @as(u32, opcode) << 16 | low;
 
-                self.print(arm_fmt, Self.fmtArgs(cpu, bl_opcode)) catch @panic("failed to write to log file");
+                self.print(arm_fmt, Self.fmtArgs(arm7tdmi, bl_opcode)) catch @panic("failed to write to log file");
             } else {
-                self.print(thumb_fmt, Self.fmtArgs(cpu, opcode)) catch @panic("failed to write to log file");
+                self.print(thumb_fmt, Self.fmtArgs(arm7tdmi, opcode)) catch @panic("failed to write to log file");
             }
         } else {
-            self.print(arm_fmt, Self.fmtArgs(cpu, opcode)) catch @panic("failed to write to log file");
+            self.print(arm_fmt, Self.fmtArgs(arm7tdmi, opcode)) catch @panic("failed to write to log file");
         }
     }
 
-    fn fmtArgs(cpu: *const Arm7tdmi, opcode: u32) FmtArgTuple {
+    fn fmtArgs(arm7tdmi: *const Arm7tdmi, opcode: u32) FmtArgTuple {
         return .{
-            cpu.r[0],
+            arm7tdmi.r[0],
-            cpu.r[1],
+            arm7tdmi.r[1],
-            cpu.r[2],
+            arm7tdmi.r[2],
-            cpu.r[3],
+            arm7tdmi.r[3],
-            cpu.r[4],
+            arm7tdmi.r[4],
-            cpu.r[5],
+            arm7tdmi.r[5],
-            cpu.r[6],
+            arm7tdmi.r[6],
-            cpu.r[7],
+            arm7tdmi.r[7],
-            cpu.r[8],
+            arm7tdmi.r[8],
-            cpu.r[9],
+            arm7tdmi.r[9],
-            cpu.r[10],
+            arm7tdmi.r[10],
-            cpu.r[11],
+            arm7tdmi.r[11],
-            cpu.r[12],
+            arm7tdmi.r[12],
-            cpu.r[13],
+            arm7tdmi.r[13],
-            cpu.r[14],
+            arm7tdmi.r[14],
-            cpu.r[15],
+            arm7tdmi.r[15],
-            cpu.cpsr.raw,
+            arm7tdmi.cpsr.raw,
             opcode,
         };
     }

src/main.zig

@@ -14,7 +14,7 @@ const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.CLI);
 const width = @import("core/ppu.zig").width;
 const height = @import("core/ppu.zig").height;
-const cpu_logging = @import("core/emu.zig").cpu_logging;
+const arm7tdmi_logging = @import("core/emu.zig").cpu_logging;
 pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level;
 
 // TODO: Reimpl Logging
@@ -40,26 +40,28 @@ pub fn main() anyerror!void {
     const paths = try handleArguments(allocator, &result);
     defer if (paths.save) |path| allocator.free(path);
 
-    const log_file: ?std.fs.File = if (cpu_logging) try std.fs.cwd().createFile("zba.log", .{}) else null;
-    defer if (log_file) |file| file.close();
-
     // TODO: Take Emulator Init Code out of main.zig
     var scheduler = Scheduler.init(allocator);
     defer scheduler.deinit();
 
-    var bus: Bus = undefined;
+    var bus = try Bus.init(allocator, &scheduler, paths);
-    var cpu = Arm7tdmi.init(&scheduler, &bus, log_file);
-    if (paths.bios == null) cpu.fastBoot();
-
-    try bus.init(allocator, &scheduler, &cpu, paths);
     bus.pak.setupGpio(); // FIXME: Can I not call this in main()?
     defer bus.deinit();
 
+    var arm7tdmi = Arm7tdmi.init(&scheduler, &bus);
+
+    const log_file: ?std.fs.File = if (arm7tdmi_logging) try std.fs.cwd().createFile("zba.log", .{}) else null;
+    defer if (log_file) |file| file.close();
+
+    if (log_file) |file| arm7tdmi.attach(file);
+    bus.attach(&arm7tdmi); // TODO: Shrink Surface (only CPSR and  r15?)
+    if (paths.bios == null) arm7tdmi.fastBoot();
+
     var gui = Gui.init(bus.pak.title, width, height);
     gui.initAudio(&bus.apu);
     defer gui.deinit();
 
-    try gui.run(&cpu, &scheduler);
+    try gui.run(&arm7tdmi, &scheduler);
 }
 
 fn getSavePath(allocator: Allocator) !?[]const u8 {