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
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

use std;
use std::ops::*;
use std::num::Wrapping;

const RAM_SIZE: usize = 0x10000;

pub struct Ram([u16; RAM_SIZE]);

impl Default for Ram {
    fn default() -> Ram {
        Ram([0x3e0; 0x10000])
    }
}

impl Ram {
    pub fn copy<'a, T: Iterator<Item=&'a u16>>(&mut self, items: T, offset: u16) {
        let (low, high) = self.0.split_at_mut(offset as usize);
        for (from, to) in items.zip(high.iter_mut()
                                        .chain(low.iter_mut())) {
            *to = *from;
        }
    }

    pub fn iter_wrap(&self, offset: u16) -> Iter {
        self.iter()
            .skip(offset as usize)
            .chain(self.iter()
                       .take(offset as usize))
    }

    pub fn as_mut_ptr(&mut self) -> *mut u16 {
        self.0.as_mut_ptr()
    }
}

// Waiting for `-> impl Iterator`...
pub type Iter<'a> = std::iter::Chain<std::iter::Skip<std::slice::Iter<'a, u16>>,
                                 std::iter::Take<std::slice::Iter<'a, u16>>>;

impl Deref for Ram {
    type Target = [u16; RAM_SIZE];

    fn deref(&self) -> &[u16; RAM_SIZE] {
        &self.0
    }
}

impl DerefMut for Ram {
    fn deref_mut(&mut self) -> &mut [u16; RAM_SIZE] {
        &mut self.0
    }
}

impl Index<u16> for Ram {
    type Output = u16;

    fn index(&self, i: u16) -> &u16{
        &self.0[i as usize]
    }
}

impl Index<Wrapping<u16>> for Ram {
    type Output = u16;

    fn index(&self, i: Wrapping<u16>) -> &u16{
        &self.0[i.0 as usize]
    }
}

impl Index<Range<u16>> for Ram {
    type Output = [u16];

    fn index(&self, i: Range<u16>) -> &[u16] {
        &self.0[i.start as usize..i.end as usize]
    }
}

impl Index<RangeFrom<u16>> for Ram {
    type Output = [u16];

    fn index(&self, i: RangeFrom<u16>) -> &[u16] {
        &self.0[i.start as usize..]
    }
}

impl Index<RangeTo<u16>> for Ram {
    type Output = [u16];

    fn index(&self, i: RangeTo<u16>) -> &[u16] {
        &self.0[..i.end as usize]
    }
}

impl IndexMut<u16> for Ram {
    fn index_mut(&mut self, i: u16) -> &mut u16{
        &mut self.0[i as usize]
    }
}

impl IndexMut<Wrapping<u16>> for Ram {
    fn index_mut(&mut self, i: Wrapping<u16>) -> &mut u16{
        &mut self.0[i.0 as usize]
    }
}

impl IndexMut<Range<u16>> for Ram {
    fn index_mut(&mut self, i: Range<u16>) -> &mut [u16] {
        &mut self.0[i.start as usize..i.end as usize]
    }
}

impl IndexMut<RangeFrom<u16>> for Ram {
    fn index_mut(&mut self, i: RangeFrom<u16>) -> &mut [u16] {
        &mut self.0[i.start as usize..]
    }
}

impl IndexMut<RangeTo<u16>> for Ram {
    fn index_mut(&mut self, i: RangeTo<u16>) -> &mut [u16] {
        &mut self.0[..i.end as usize]
    }
}