chore: fix linting errors

Author: nathanleiby

src/apu/pulse_register.rs

@@ -6,14 +6,14 @@ use bitfields::bitfield;
 struct PulseEnvelope {
     /// Duty Cycle
     #[bits(2)]
-    D: u8,
+    d: u8,
     /// Envelope loop / length counter halt
-    L: bool,
+    l: bool,
     /// Constant volume/envelope flag
-    C: bool,
+    c: bool,
     /// Volume/envelope divider period
     #[bits(4)]
-    V: u8,
+    v: u8,
 }
 
 /// PulseSweep
@@ -22,19 +22,19 @@ struct PulseEnvelope {
 // #[derive(Copy, Clone)] // Attributes are passed to the struct.
 struct PulseSweep {
     /// Enabled flag
-    E: bool,
+    e: bool,
     /// Period
     /// The divider's period is P + 1 half-frames
     #[bits(3)]
-    P: u8,
+    p: u8,
     /// Negate flag
     /// 0: add to period, sweeping toward lower frequencies
     /// 1: subtract from period, sweeping toward higher frequencies
-    N: bool,
+    n: bool,
     /// Shift count (number of bits).
     /// If SSS is 0, then behaves like E=0.
     #[bits(3)]
-    S: u8,
+    s: u8,
 }
 
 /// https://www.nesdev.org/wiki/APU_Pulse
@@ -56,38 +56,38 @@ impl PulseRegister {
     // data[0]
 
     fn duty_cycle(&self) -> u8 {
-        PulseEnvelope::from_bits(self.data[0]).D()
+        PulseEnvelope::from_bits(self.data[0]).d()
     }
 
     fn is_length_counter_halted(&self) -> bool {
-        PulseEnvelope::from_bits(self.data[0]).L()
+        PulseEnvelope::from_bits(self.data[0]).l()
     }
 
     fn is_constant_volume(&self) -> bool {
-        PulseEnvelope::from_bits(self.data[0]).C()
+        PulseEnvelope::from_bits(self.data[0]).c()
     }
 
     fn envelope_period(&self) -> u8 {
-        PulseEnvelope::from_bits(self.data[0]).V()
+        PulseEnvelope::from_bits(self.data[0]).v()
     }
 
     // data[1]
 
     fn is_sweep_enabled(&self) -> bool {
         let s = PulseSweep::from_bits(self.data[1]);
-        s.E() && s.S() > 0
+        s.e() && s.s() > 0
     }
 
     fn is_sweep_negated(&self) -> bool {
-        PulseSweep::from_bits(self.data[1]).N()
+        PulseSweep::from_bits(self.data[1]).n()
     }
 
     fn sweep_period(&self) -> u8 {
-        PulseSweep::from_bits(self.data[1]).P()
+        PulseSweep::from_bits(self.data[1]).p()
     }
 
     fn sweep_shift_count(&self) -> u8 {
-        PulseSweep::from_bits(self.data[1]).S()
+        PulseSweep::from_bits(self.data[1]).s()
     }
 
     // data[2] and data[3]

src/cpu.rs

@@ -1,4 +1,3 @@
-
 use crate::{
     bus::Bus,
     ops::{addressing_mode_to_size, is_official, lookup_opcode, OpName},
@@ -1862,4 +1861,26 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn test_stack_push_pop() {
+        let mut cpu = Cpu::new();
+
+        cpu.stack_push(0x12);
+        cpu.stack_push(0x34);
+
+        assert_eq!(cpu.stack_pop(), 0x34);
+        assert_eq!(cpu.stack_pop(), 0x12);
+    }
+
+    #[test]
+    fn test_stack_push_pop_u16() {
+        let mut cpu = Cpu::new();
+
+        cpu.stack_push_u16(0x1234);
+        cpu.stack_push_u16(0x2345);
+
+        assert_eq!(cpu.stack_pop_u16(), 0x2345);
+        assert_eq!(cpu.stack_pop_u16(), 0x1234);
+    }
 }

src/ppu.rs

@@ -172,8 +172,8 @@ impl Ppu {
         assert!(which_nametable <= 3);
         let nt_start = which_nametable * 0x400;
 
-        let TILE_ROWS = 30;
-        let TILE_COLS = 32;
+        let tile_rows = 30;
+        let tile_cols = 32;
         match self.mirroring {
             Mirroring::Vertical => {
                 let x_scroll: usize = self.registers.scroll.x_scroll as usize;
@@ -189,18 +189,18 @@ impl Ppu {
                     [0x400, 0x800]
                 };
 
-                for tile_y in 0..TILE_ROWS {
+                for tile_y in 0..tile_rows {
                     for (nt_idx, &nt_start) in nts.iter().enumerate() {
-                        for tile_x in 0..TILE_COLS {
-                            let offset = tile_y * TILE_COLS + tile_x;
+                        for tile_x in 0..tile_cols {
+                            let offset = tile_y * tile_cols + tile_x;
                             let tile_n = self.vram
                                 [self.mirror_vram_addr((nt_start + offset) as u16) as usize];
                             let bgp_idx = self.palette_for_bg_tile((tile_x, tile_y), nt_start);
                             let palette = self.lookup_palette(bgp_idx);
                             frame.draw_bg_tile(
                                 pattern_table,
                                 tile_n as usize,
-                                (tile_x + TILE_COLS * nt_idx, tile_y),
+                                (tile_x + tile_cols * nt_idx, tile_y),
                                 x_scroll,
                                 0,
                                 palette,
@@ -218,18 +218,18 @@ impl Ppu {
                     [0x800, 0]
                 };
 
-                for tile_y in 0..TILE_ROWS {
+                for tile_y in 0..tile_rows {
                     for (nt_idx, &nt_start) in nts.iter().enumerate() {
-                        for tile_x in 0..TILE_COLS {
-                            let offset = tile_y * TILE_COLS + tile_x;
+                        for tile_x in 0..tile_cols {
+                            let offset = tile_y * tile_cols + tile_x;
                             let tile_n = self.vram
                                 [self.mirror_vram_addr((nt_start + offset) as u16) as usize];
                             let bgp_idx = self.palette_for_bg_tile((tile_x, tile_y), nt_start);
                             let palette = self.lookup_palette(bgp_idx);
                             frame.draw_bg_tile(
                                 pattern_table,
                                 tile_n as usize,
-                                (tile_x, tile_y + TILE_ROWS * nt_idx),
+                                (tile_x, tile_y + tile_rows * nt_idx),
                                 0,
                                 y_scroll,
                                 palette,

src/rom.rs

@@ -43,16 +43,16 @@ impl Rom {
         let prg_rom_banks = header[4];
         let chr_rom_banks = header[5];
         let control_byte_1 = header[6];
-        let control_byte_2 = header[7];
+        // let control_byte_2 = header[7];
         // let size_of_prg_ram_times_8kb = header[8];
 
         let has_trainer_bytes = control_byte_1 ^ (1 << 2) == 0;
         let is_four_screen = control_byte_1 & (1 << 3) > 0;
         let is_vertical_screen = control_byte_1 & 1 > 0;
 
-        let lo = (control_byte_1 & 0b1111_0000) >> 4;
-        let hi = control_byte_2 & 0b1111_0000;
-        let rom_mapper_type = hi + lo;
+        // let lo = (control_byte_1 & 0b1111_0000) >> 4;
+        // let hi = control_byte_2 & 0b1111_0000;
+        // let rom_mapper_type = hi + lo;
 
         let mapper = Mapper::Zero;