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

use std::fmt;

#[cfg(feature = "colored")]
use colored::Colorize;

use assembler::types::Globals;
use types::*;

impl fmt::Display for Instruction<u16> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Instruction::BasicOp(op, b, a) => write!(f, "{:?} {:b}, {:o}", op, b, a),
            Instruction::SpecialOp(op, a) => write!(f, "{:?} {:o}", op, a)
        }
    }
}

impl Instruction<u16> {
    #[cfg(feature = "colored")]
    pub fn retrosolve(&self, globals: &Globals) -> String {
        match *self {
            Instruction::BasicOp(op, b, a) =>
                format!("{} {}, {}",
                        format!("{:?}", op).blue(),
                        b.retrosolve(globals, false).green(),
                        a.retrosolve(globals, true).green()),
            Instruction::SpecialOp(op, a) =>
                format!("{} {}",
                        format!("{:?}", op).blue(),
                        a.retrosolve(globals, true).green()),
        }
    }

    #[cfg(not(feature = "colored"))]
    pub fn retrosolve(&self, globals: &Globals) -> String {
        match *self {
            Instruction::BasicOp(op, b, a) =>
                format!("{:?} {}, {}",
                        op,
                        b.retrosolve(globals, false),
                        a.retrosolve(globals, true)),
            Instruction::SpecialOp(op, a) =>
                format!("{:?} {}",
                        op,
                        a.retrosolve(globals, true)),
        }
    }
}

impl fmt::Binary for Value<u16> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Value::Reg(r) => write!(f, "{:?}", r),
            Value::AtReg(r) => write!(f, "[{:?}]", r),
            Value::AtRegPlus(r, v) => write!(f, "[{:?} + {}]", r, v),
            Value::Pick(n) => write!(f, "PICK {}", n),
            Value::AtAddr(v) => write!(f, "[{}]", v),
            Value::Litteral(v) => write!(f, "{}", v),
            Value::Push => write!(f, "PUSH"),
            x => write!(f, "{:?}", x)
        }
    }
}

impl fmt::Octal for Value<u16> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Value::Reg(r) => write!(f, "{:?}", r),
            Value::AtReg(r) => write!(f, "[{:?}]", r),
            Value::AtRegPlus(r, v) => write!(f, "[{:?} + {}]", r, v),
            Value::Pick(n) => write!(f, "PICK {}", n),
            Value::AtAddr(v) => write!(f, "[{}]", v),
            Value::Litteral(v) => write!(f, "{}", v),
            Value::Push => write!(f, "POP"),
            x => write!(f, "{:?}", x)
        }
    }
}

impl Value<u16> {
    pub fn retrosolve(&self, globals: &Globals, is_a: bool) -> String {
        match *self {
            Value::Reg(r) => format!("{:?}", r),
            Value::AtReg(r) => format!("[{:?}]", r),
            Value::AtRegPlus(r, v) => format!("[{:?} + {}]", r, v),
            Value::Pick(n) => format!("PICK {}", n),
            Value::AtAddr(v) => format!("[{}]", reverse(v, globals)),
            Value::Litteral(v) => reverse(v, globals).into(),
            Value::Push => if is_a {
                "POP".into()
            } else {
                "PUSH".into()
            },
            x => format!("{:?}", x)
        }
    }
}

#[cfg(feature = "colored")]
fn reverse(addr: u16, globals: &Globals) -> String {
    for (sym, infos) in globals {
        if infos.addr == addr {
            return format!("{} ({})", addr, sym.magenta());
        }
    }
    format!("{}", addr)
}

#[cfg(not(feature = "colored"))]
fn reverse(addr: u16, globals: &Globals) -> String {
    for (sym, infos) in globals {
        if infos.addr == addr {
            return format!("{} ({})", addr, sym.clone());
        }
    }
    format!("{}", addr)
}