1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use instant::Duration;

use crate::cpu::{
  mos6502::{Mos6502, Mos6502Variant},
  Cpu,
};
use crate::memory::BlockMemory;
use crate::platform::{PlatformProvider, WindowConfig};
use crate::roms::RomFile;
use crate::systems::System;
use std::cell::Cell;
use std::rc::Rc;
use std::sync::Arc;

use super::BuildableSystem;

pub struct KlausSystemConfig {
  pub pc_report: Option<Rc<Cell<u16>>>,
  pub variant: Mos6502Variant,
}

/// A factory for creating a system that runs Klaus Dormann's 6502 CPU test suite.
impl BuildableSystem<RomFile, KlausSystemConfig> for KlausSystem {
  fn build(
    rom: RomFile,
    config: KlausSystemConfig,
    _platform: Arc<dyn PlatformProvider>,
  ) -> Box<dyn System> {
    let rom = BlockMemory::from_file(0x10000, rom).set_writeable(true);
    let mut cpu = Mos6502::new(rom, config.variant);

    cpu.registers.pc.load(0x0400);

    Box::new(KlausSystem {
      cpu,
      pc: config.pc_report,
    })
  }
}

/// A system used to run Klaus Dormann's 6502 CPU test suite.
pub struct KlausSystem {
  cpu: Mos6502,
  pc: Option<Rc<Cell<u16>>>,
}

impl System for KlausSystem {
  fn get_cpu_mut(&mut self) -> Box<&mut dyn Cpu> {
    Box::new(&mut self.cpu)
  }

  fn tick(&mut self) -> Duration {
    self.cpu.tick();
    if let Some(pc) = &self.pc {
      pc.set(self.cpu.registers.pc.address());
    }
    Duration::ZERO
  }

  fn reset(&mut self) {
    self.cpu.reset();
  }

  fn render(&mut self, _framebuffer: &mut [u8], _window: WindowConfig) {}
}

#[cfg(test)]
mod tests {
  use crate::{
    platform::{Platform, TextPlatform},
    roms::DiskLoadable,
  };

  use super::*;

  #[test]
  fn test_klaus_6502() {
    let roms = RomFile::from_file("bin/klaus_6502.bin");
    let platform = TextPlatform::new();
    let pc = Rc::new(Cell::new(0));

    let mut system = KlausSystem::build(
      roms,
      KlausSystemConfig {
        pc_report: Some(pc.clone()),
        variant: Mos6502Variant::NMOS,
      },
      platform.provider(),
    );

    for _ in 0..=100000000 {
      system.tick();
    }

    assert_eq!(pc.get(), 0x3469);
  }

  #[test]
  fn test_klaus_65c02() {
    let roms = RomFile::from_file("bin/klaus_65C02.bin");
    let platform = TextPlatform::new();
    let pc = Rc::new(Cell::new(0));

    let mut system = KlausSystem::build(
      roms,
      KlausSystemConfig {
        pc_report: Some(pc.clone()),
        variant: Mos6502Variant::CMOS,
      },
      platform.provider(),
    );

    for _ in 0..=100000000 {
      system.tick();
    }

    assert_eq!(pc.get(), 0x24f1);
  }
}