dcpu 0.5.0

An assembler, debugger and emulator for the DCPU-16
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

use std::any::Any;

use enum_primitive::FromPrimitive;

use emulator::Cpu;
use emulator::device::*;
use types::Register;

const ONE_MS: u16 = 100;
const MEMORY_SIZE: usize = 16;
const DEFAULT_MEM_VALUE: [u16; MEMORY_SIZE] = [0xffff; MEMORY_SIZE];
const INT_VALUE: u16 = 0xfff0;

enum_from_primitive! {
#[allow(non_camel_case_types)]
#[derive(Debug, Copy, Clone)]
enum Command {
    GET = 1,
    SET = 2,
    RESET = 3,
}
}

#[derive(Debug)]
pub struct Eeprom<D: Device> {
    mem: [u16; MEMORY_SIZE],
    inner: D,
}

impl<D: Device> Eeprom<D> {
    pub fn new(inner: D) -> Eeprom<D> {
        Eeprom {
            mem: DEFAULT_MEM_VALUE,
            inner: inner,
        }
    }
}

impl<D: Device> Device for Eeprom<D> {
    fn hardware_id(&self) -> u32 {
        self.inner.hardware_id()
    }

    fn hardware_version(&self) -> u16 {
        self.inner.hardware_version()
    }

    fn manufacturer(&self) -> u32 {
        self.inner.manufacturer()
    }

    fn interrupt(&mut self, cpu: &mut Cpu) -> Result<InterruptDelay> {
        let a = cpu.registers[Register::A];
        if a == INT_VALUE {
            let b = cpu.registers[Register::B];
            let x = cpu.registers[Register::X] as usize;

            match Command::from_u16(b) {
                Some(Command::GET) => {
                    match self.mem.get(x) {
                        Some(word) => cpu.registers[Register::Y] = *word,
                        None => unimplemented!(),
                    }
                    Ok(ONE_MS)
                }
                Some(Command::SET) => {
                    match self.mem.get_mut(x) {
                        Some(word) => *word &= cpu.registers[Register::Y],
                        None => unimplemented!(),
                    }
                    Ok(5 * ONE_MS)
                }
                Some(Command::RESET) => {
                    self.mem = DEFAULT_MEM_VALUE;
                    Ok(10 * ONE_MS)
                }
                None => unimplemented!(),
            }
        } else {
            self.inner.interrupt(cpu)
        }
    }

    fn tick(&mut self, cpu: &mut Cpu, current_tick: u64) -> Result<TickResult> {
        self.inner.tick(cpu, current_tick)
    }

    fn inspect(&self) {
        self.inner.inspect();
        println!("Eeprom: {:?}", self.mem);
    }

    fn as_any(&mut self) -> &mut Any {
        &mut self.inner
    }
}