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

use types::*;

#[derive(Serialize, Deserialize, PartialEq, Debug, Copy, Clone)]
/// Represents a place a value can come from: a register, a memory address, a pointer to memory stored in a register, or a literal value.
pub enum Address {
    /// A literal register, like R1.
    RegAbs(Register),
    /// A literal memory address, like 0x10.
    MemAbs(Word),
    /// A memory address stored in a register. This serves as one level of indirection; 
    /// for multiple indirection, multiple instructions must be used.
    MemReg(Register),
    /// A literal value. Writing to a literal value is a fault.
    Literal(Word),

}

#[derive(Serialize, Deserialize, PartialEq, Debug, Copy, Clone)]
/// Specifies a register in the machine. 
///
/// This doesn't include the instruction pointer. You have to use  use jump instructions
/// to mess with that.
pub enum Register {
    /// General purpouse register 0
    R0,
    /// General purpouse register 1
    R1,
    /// General purpouse register 2
    R2,
    /// General purpouse register 3
    R3,
    /// General purpouse register 4
    R4,
    /// General purpouse register 5
    R5,
    /// General purpouse register 6
    R6,
    /// General purpouse register 7
    R7,
    /// Stack position pointer
    SP,
    /// Stack base pointer
    BP,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Copy, Clone)]
/// Possible instructions for the machine to execute.
/// For each instruction, the first operand is a, second is b, et cetera
pub enum Instruction {
    /// Increment IP.
    NoOp,
    /// Set a equal to 0
    Zero(Address),
    /// Set b equal to a
    Move(Address, Address),
    /// Push a onto the output
    Output(Address),
    /// Pop from the input into a
    Input(Address),
    /// Add the unsigned a to b, storing the result in a
    Add(Address, Address),
    /// Subtract the unsigned b from a, storing the result in a
    Sub(Address, Address),
    /// Uncontitionally jump to the position given by a
    Jump(Address),
    /// Jump to a if the value at b is 0
    JumpIfZero(Address, Address),
    /// Jump to a if the value at b is NOT zero
    JumpNotZero(Address, Address),
    /// Push a to the stack
    Push(Address),
    /// Pop a value from the stack into the given address
    Pop(Address),
    /// Gracefully shut down the machine
    Halt,
    /// An illegal instruction. Executing this is a Fault.
    Illegal,
}