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::collections::HashMap;
use std::iter;

use assembler::types::*;

error_chain!{
    errors {
        UnknownLabel(l: String) {
            description("unknown label")
            display("unknown label: \"{}\"", l)
        }
        UnknownLocalLabel(l: String) {
            description("unknown local label")
            display("unknown local label: \"{}\"", l)
        }
        DuplicatedLabel(l: String) {
            description("duplicated label")
            display("duplicated label: \"{}\"", l)
        }
        DuplicatedLocalLabel(l: String) {
            description("duplicated local label")
            display("duplicated local label: \"{}\"", l)
        }
        LocalBeforeGlobal(l: String) {
            description("local label before a global")
            display("local label before a global: \"{}\"", l)
        }
    }
}

pub fn link(ast: &[ParsedItem]) -> Result<(Vec<u16>, Globals)> {

    let mut bin = Vec::new();
    let mut labels = try!(extract_labels(ast));
    let mut changed = true;

    while changed {
        bin.clear();
        changed = false;
        let mut index = 0u16;
        let mut last_global = None;
        for item in ast {
            match *item {
                ParsedItem::Directive(Directive::Lcomm(ref symbol, size)) => {
                    let label = labels.get_mut(symbol).unwrap();
                    if label.addr != index {
                        label.addr = index;
                        changed = true;
                    }
                    last_global = Some(symbol.clone());

                    bin.extend(iter::repeat(0).take(size as usize));
                    index += size;
                }
                ParsedItem::Directive(ref d) =>
                    index += try!(d.append_to(&mut bin, &labels, &last_global)),
                ParsedItem::LabelDecl(ref s) => {
                    let label = labels.get_mut(s).unwrap();
                    if label.addr != index {
                        label.addr = index;
                        changed = true;
                    }
                    last_global = Some(s.clone());
                }
                ParsedItem::LocalLabelDecl(ref s) => {
                    let addr = labels.get_mut(last_global.as_ref().unwrap())
                                     .unwrap()
                                     .locals
                                     .get_mut(s)
                                     .unwrap();
                    if *addr != index {
                        changed = true;
                        *addr = index;
                    }
                }
                ParsedItem::Instruction(ref i) => {
                    let solved = try!(i.solve(&labels, &last_global));
                    bin.extend_from_slice(&[0xbeaf; 3]);
                    index += solved.encode(&mut bin[index as usize..]);
                    bin.truncate(index as usize);
                }
                _ => (),
            }
        }
    }

    Ok((bin, labels))
}

fn extract_labels(ast: &[ParsedItem]) -> Result<Globals> {
    let mut prev_label = None;
    let mut labels = HashMap::new();

    for item in ast.iter() {
        match *item {
            ParsedItem::LabelDecl(ref s) | ParsedItem::Directive(Directive::Lcomm(ref s, _)) => {
                prev_label = Some(s.clone());
                if labels.contains_key(s) {
                    try!(Err(ErrorKind::DuplicatedLabel(s.clone())));
                } else {
                    labels.insert(s.clone(), LabelInfos::default());
                }
            }
            ParsedItem::LocalLabelDecl(ref s) => {
                if prev_label.is_none() {
                    try!(Err(ErrorKind::LocalBeforeGlobal(s.clone())));
                }
                let locals = &mut labels.get_mut(prev_label.as_ref().unwrap())
                                        .unwrap()
                                        .locals;
                if locals.contains_key(s) {
                    try!(Err(ErrorKind::DuplicatedLocalLabel(s.clone())));
                } else {
                    locals.insert(s.clone(), 0);
                }
            }
            _ => (),
        }
    }

    Ok(labels)
}