rx82 0.1.0

An emulator for the RX82 retro computer system.
Documentation 
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

use anyhow::{Result, bail};

use std::{collections::HashMap, sync::LazyLock};

use crate::{cpu::Cpu, regs::Reg8, system::System};

/// Temporary opcode constants to make test programs easier to read.
pub(crate) const NOP: u8 = 0x00;
pub(crate) const LDA_N: u8 = 0x01;

/// The instruction set.
pub static INSTRUCTIONS: LazyLock<HashMap<u8, Instruction>> = LazyLock::new(|| {
    HashMap::from([
        (
            NOP,
            Instruction {
                name: "nop",
                bytes: 1,
                execute: |_| {},
                test: |_| Ok(()),
            },
        ),
        (
            LDA_N,
            Instruction {
                name: "ld a, N",
                bytes: 2,
                execute: |cpu: &mut Cpu| cpu.regs.set8(Reg8::A, cpu.operand),
                test: |sys: &mut System| -> Result<()> {
                    sys.cpu.regs.set8(Reg8::A, 0x00);
                    sys.mem.load(0x0000, &[LDA_N, 0xFF])?;
                    sys.cpu.pc = 0x0000;
                    sys.tick()?; // fetch
                    sys.debug_print();
                    sys.cpu.debug_print();
                    sys.tick()?; // memwait
                    sys.debug_print();
                    sys.cpu.debug_print();
                    sys.tick()?; // decode
                    sys.debug_print();
                    sys.cpu.debug_print();
                    sys.tick()?; // fetch operand
                    sys.debug_print();
                    sys.cpu.debug_print();
                    sys.tick()?; // memwait
                    sys.debug_print();
                    sys.cpu.debug_print();
                    sys.tick()?; // read operand
                    sys.debug_print();
                    sys.cpu.debug_print();
                    sys.tick()?; // execute
                    sys.debug_print();
                    sys.cpu.debug_print();
                    let val = sys.cpu.regs.get8(Reg8::A);
                    if val != 0xFF {
                        bail!("want A=0xFF, got A={val:02X}")
                    }
                    Ok(())
                },
            },
        ),
    ])
});

/// An instruction definition.
#[non_exhaustive]
#[derive(Clone, Debug)]
pub struct Instruction {
    /// Number of bytes the instruction requires in memory.
    pub bytes: u8,
    /// The closure that executes this instruction.
    pub execute: fn(&mut Cpu),
    /// The instruction's symbolic name.
    pub name: &'static str,
    /// The self-test closure for the instruction (run by `cargo test`).
    pub test: fn(&mut System) -> Result<()>,
}

impl Default for &Instruction {
    /// The default instruction (used in place of unknown opcodes) is `nop`.
    #[inline]
    fn default() -> Self {
        &Instruction {
            name: "nop",
            bytes: 1,
            execute: |_| {},
            test: |_| Ok(()),
        }
    }
}

#[cfg(test)]
mod tests {
    use anyhow::Context as _;

    use crate::system::System;

    use super::*;

    #[expect(
        clippy::iter_over_hash_type,
        reason = "order doesn't matter for self-test"
    )]
    #[expect(clippy::unwrap_used, reason = "test")]
    #[test]
    fn instructions_pass_self_test() {
        let mut sys = System::default();
        for (opcode, ins) in INSTRUCTIONS.iter() {
            (ins.test)(&mut sys)
                .context(format!(
                    "opcode {opcode:#04X} ({}) failed self-test",
                    ins.name
                ))
                .unwrap();
        }
    }
}