phakebit 0.1.4

A 6502 CPU emulator
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
118
119
120
121
122
123
124

//! Models the memory

/// Abstract memory interface
pub trait Memory {
    fn get(&self, address: u16) -> u8;
    fn set(&mut self, address: u16, value: u8);
}

/// Plain memory implementation with just 64K of RAM
pub struct PlainMemory {
    state: [u8; 0x10000],
}

impl PlainMemory {
    pub fn new() -> PlainMemory {
        PlainMemory {
            state: [0; 0x10000],
        }
    }
}

impl Memory for PlainMemory {
    fn get(&self, address: u16) -> u8 {
        let idx = address as usize;
        self.state[idx]
    }

    fn set(&mut self, address: u16, value: u8) {
        let idx = address as usize;
        self.state[idx] = value;
    }
}

#[cfg(test)]
mod tests {
    use std::cell::RefCell;
    use std::rc::Rc;

    use crate::cpu::CPU;

    use super::Memory;
    use super::PlainMemory;

    #[test]
    fn gets() {
        let mut m = PlainMemory::new();
        let zero = m.get(0x0000);
        assert_eq!(zero, 0);

        m.set(0x1FF, 0x01);
        assert_eq!(m.get(0x1FF), 0x01);
    }

    #[test]
    fn memory_maps() {
        struct Chip {
            register: u8,
            read_count: u8,
        }

        impl Chip {
            fn new() -> Chip {
                Chip {
                    register: 0,
                    read_count: 0,
                }
            }
            fn read(&mut self) -> u8 {
                self.read_count += 1;
                self.register
            }
            fn write(&mut self, value: u8) {
                self.register = value;
            }
        }

        struct MappedMemory {
            state: [u8; 0x10000],
            chip: Rc<RefCell<Chip>>,
        }

        impl MappedMemory {
            fn new(chip: Rc<RefCell<Chip>>) -> MappedMemory {
                MappedMemory {
                    state: [0; 0x10000],
                    chip: chip,
                }
            }
        }

        impl Memory for MappedMemory {
            fn get(&self, address: u16) -> u8 {
                match address {
                    0x0000..=0x1FFF => self.state[address as usize],
                    0x2000..=0x3FFF => self.chip.borrow_mut().read(),
                    0x4000..=0xFFFF => self.state[address as usize],
                }
            }

            fn set(&mut self, address: u16, value: u8) {
                match address {
                    0x0000..=0x1FFF => self.state[address as usize] = value,
                    0x2000..=0x3FFF => (*self.chip).borrow_mut().write(value),
                    0x4000..=0xFFFF => self.state[address as usize] = value,
                }
            }
        }

        let chip = Rc::new(RefCell::new(Chip::new()));
        let mut m = MappedMemory::new(chip.clone());
        m.set(0x2000, 0x01);
        assert_eq!(chip.borrow_mut().read(), 0x01);
        assert_eq!(m.get(0x2000), 0x01);

        let cpu_state = crate::state::CPUState::new(m);
        let mut cpu = CPU::new(cpu_state);

        let state = cpu.get_mut_state();
        assert_eq!(state.read_byte(0x2000), 0x01);

        (*chip).borrow_mut().write(0x02);
        assert_eq!(chip.borrow_mut().read(), 0x02);
    }
}