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

/// This enum represents a single opcode.
/// Under the hood, it's just a byte.
/// This allows non opcode bytes to be inserted in bytecode streams.
#[repr(u8)]
#[derive(Debug, PartialEq, Eq)]
pub enum Opcode {
    /// Load a constant.
    Con = 0,
    /// Load uninitialized Data.
    NotInit = 1,
    /// Delete a value off the stack.
    Del = 2,
    /// Calls out to a Rust function via FFI
    FFICall = 3,
    /// Copies topmost value on the stack.
    Copy = 4,
    /// Moves a variable onto the heap.
    Capture = 5,
    /// Save a constant into a variable.
    Save = 6,
    /// Save a value to a captured variable.
    SaveCap = 7,
    /// Push a copy of a variable onto the stack.
    Load = 8,
    /// Load a copy of a captured variable.
    LoadCap = 9,
    /// Call a function.
    Call = 10,
    /// Return from a function.
    Return = 11,
    /// Creates a closure over the current local environment.
    Closure = 12,
    /// Prints a value.
    Print = 13,
    /// Constructs a label.
    Label = 14,
    // Constructs a tuple.
    Tuple = 15,
    /// Destructures atomic data by asserting it matches exactly.
    UnData = 16,
    /// Destructures a label.
    UnLabel = 17,
    /// Sestructures a tuple.
    UnTuple = 18,
}

impl Opcode {
    /// Convert a raw byte to an opcode.
    /// Note that non-opcode bytes should never be interpreted as an opcode.
    /// Under the hood, this is just a transmute, so the regular cautions apply.
    /// This *should* never cause a crash
    /// and if it does, the vm's designed to crash hard
    /// so it'll be pretty obvious.
    pub fn from_byte(byte: u8) -> Opcode {
        unsafe { std::mem::transmute(byte) }
    }
}