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

use crate::exception::{Exception, ExceptionType};

#[derive(Debug)]
pub struct UnexpectedEndOfCode {
    pub chunk_id: usize,
}

impl From<UnexpectedEndOfCode> for Exception {
    fn from(exception: UnexpectedEndOfCode) -> Self {
        Exception {
            exception_type: ExceptionType::Runtime,
            name: "UnexpectedEndOfCode".to_string(),
            message: format!("Chunk #{}", exception.chunk_id),
        }
    }
}

#[derive(Debug)]
pub struct EmptyCallStack;

impl From<EmptyCallStack> for Exception {
    fn from(_: EmptyCallStack) -> Self {
        Exception {
            exception_type: ExceptionType::Runtime,
            name: "EmptyCallStack".to_string(),
            message: "".to_string(),
        }
    }
}

#[derive(Debug)]
pub struct EmptyOperandStack;

impl From<EmptyOperandStack> for Exception {
    fn from(_: EmptyOperandStack) -> Self {
        Exception {
            exception_type: ExceptionType::Runtime,
            name: "EmptyOperandStack".to_string(),
            message: "Operand stack was empty".to_string(),
        }
    }
}

#[derive(Debug)]
pub struct SlotOutOfBounds;

impl From<SlotOutOfBounds> for Exception {
    fn from(_: SlotOutOfBounds) -> Self {
        Exception {
            exception_type: ExceptionType::Runtime,
            name: "SlotOutOfBounds".to_string(),
            message: "Stack slot is out of bounds".to_string(),
        }
    }
}

#[derive(Debug)]
pub struct UnknownOpCode(pub u8);

impl From<UnknownOpCode> for Exception {
    fn from(exception: UnknownOpCode) -> Self {
        Exception {
            exception_type: ExceptionType::Runtime,
            name: "UnknownOpCode".to_string(),
            message: format!("No instruction with opcode {} found", exception.0),
        }
    }
}

#[derive(Debug)]
pub struct ChunkNotFound(pub usize);

impl From<ChunkNotFound> for Exception {
    fn from(exception: ChunkNotFound) -> Self {
        Exception {
            exception_type: ExceptionType::Runtime,
            name: "ChunkNotFound".to_string(),
            message: format!("#{}", exception.0),
        }
    }
}

#[derive(Debug)]
pub struct ConstantNotFound(pub usize, pub usize);

impl From<ConstantNotFound> for Exception {
    fn from(exception: ConstantNotFound) -> Self {
        Exception {
            exception_type: ExceptionType::Runtime,
            name: "ConstantNotFound".to_string(),
            message: format!("#{}@{}", exception.0, exception.1),
        }
    }
}