rx82 0.5.0

An emulator for the RX82 fantasy 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

use anyhow::{Context as _, Result, bail};

use crate::{bus::Bus, system::Device};

/// The system RAM.
#[non_exhaustive]
#[derive(Debug)]
pub struct Memory {
    pub data: Vec<u8>,
    pub end: u16,
    pub start: u16,
}

impl Default for Memory {
    #[inline]
    fn default() -> Self {
        Self {
            start: 0x0000,
            end: 0xBFFF,
            data: vec![0; 0xC000],
        }
    }
}

impl Device for Memory {
    /// Responds to a memory request if the [`Bus::mem`] line is active.
    #[inline]
    fn tick(&mut self, bus: &mut Bus) {
        if bus.mem && self.in_range(bus.addr) {
            match (bus.mem, bus.write) {
                (true, false) => {
                    // Memory read request
                    let data = self.get(bus.addr);
                    bus.write_data(data);
                }
                (true, true) => {
                    // Memory write request
                    self.set(bus.addr, bus.data);
                }
                _ => {}
            }
        }
    }
}

impl Memory {
    /// Returns the byte at logical address `addr`.
    ///
    /// Returns zero if the address is outside the configured memory range.
    #[inline]
    #[must_use]
    pub fn get(&self, addr: u16) -> u8 {
        let phys_addr = addr.strict_sub(self.start);
        self.data
            .get(usize::from(phys_addr))
            .copied()
            .unwrap_or_default()
    }

    /// Returns true if `addr` is in the memory's logical address range.
    #[inline]
    #[must_use]
    pub fn in_range(&self, addr: u16) -> bool {
        self.start <= addr && addr <= self.end
    }

    /// Loads `data` into memory at address `addr`.
    ///
    /// # Errors
    ///
    /// If the load exceeds bounds.
    #[inline]
    pub fn load(&mut self, addr: u16, data: &[u8]) -> Result<()> {
        if !self.in_range(addr) {
            bail!("out of range")
        }
        let phys_addr = addr.saturating_sub(self.start);
        let start = usize::from(phys_addr);
        let end = start.checked_add(data.len()).context("data too long")?;
        let slice = self.data.get_mut(start..end).context("out of bounds")?;
        slice.copy_from_slice(data);
        Ok(())
    }

    /// Sets the byte at address `addr` to `val`.
    ///
    /// If `addr` is out of range, this has no effect.
    #[inline]
    pub fn set(&mut self, addr: u16, val: u8) {
        let phys_addr = addr.saturating_sub(self.start);
        if let Some(loc) = self.data.get_mut(usize::from(phys_addr)) {
            *loc = val;
        }
    }
}

#[cfg(test)]
#[expect(clippy::expect_used, reason = "test")]
mod tests {
    use super::*;

    #[test]
    fn load_checks_bounds_correctly() {
        let mut mem = Memory::default();
        mem.load(0x0000, &[0x00]).expect("valid load failed");
        mem.load(0xBFFF, &[0x00]).expect("valid load failed");
        mem.load(0xBFFE, &[0x00, 0x00, 0x00])
            .expect_err("invalid load succeeded");
        mem.load(0xC000, &[0x00])
            .expect_err("invalid load succeeded");
        mem.load(0xFFFF, &[0x00, 0x00])
            .expect_err("invalid load succeeded");
    }
}