ttvm 0.2.9

Runtime and compiler infrastructure API for Rust
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

pub mod env;
pub mod routine;
pub mod arch;
pub mod ir;

pub use env::*;
pub use routine::*;
pub use arch::*;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_env() {
        let mut env = Env::new();
        
        let block1 = match env.alloc(10) {
            Ok(ok) => ok,
            Err(err) => panic!("{}", err.to_string())
        };

        let block2 = match env.alloc(10) {
            Ok(ok) => ok,
            Err(err) => panic!("{}", err.to_string())
        };

        assert_eq!(block1, 1);
        assert_eq!(block2, 2);
        
        assert_eq!(match env.dealloc(block1) {
            Ok(ok) => ok,
            Err(err) => panic!("{}", err.to_string())
        }, 10);

        assert_eq!(match env.dealloc(block2) {
            Ok(ok) => ok,
            Err(err) => panic!("{}", err.to_string())
        }, 10);

        assert_eq!(*env.get_mem(), vec![Some(vec![0x0; 0]), None, None]);
        assert_eq!(*env.get_mem_mut(), vec![Some(vec![0x0; 0]), None, None]);
    
        let routine1 = match env.def(vec![RETURN, 10]) {
            Ok(ok) => ok,
            Err(err) => panic!("{}", err.to_string())
        };

        let result1 = unsafe { env.call(routine1, vec![]) };
        
        match result1 {
            Ok(ok) => {
                match ok {
                    Ok(ok) => assert_eq!(ok, 10),
                    Err(_err) => panic!("unexpected result")
                }
            },
            Err(err) => panic!("{}", err.to_string())
        };

        let routine2 = match env.def(vec![THROW, 5]) {
            Ok(ok) => ok,
            Err(err) => panic!("{}", err.to_string())
        };

        let result2 = unsafe { env.call(routine2, vec![]) };
        
        match result2 {
            Ok(ok) => {
                match ok {
                    Ok(_ok) => panic!("unexpected result"),
                    Err(err) => assert_eq!(err, 5)
                }
            },
            Err(err) => panic!("{}", err.to_string())
        };
    }

    #[test]
    fn test_routine() {
        let mut env = Env::new();
        
        let routine2 = match env.def(vec![RETURN, 20]) {
            Ok(ok) => ok,
            Err(err) => panic!("{}", err.to_string())
        };
 
        let mut routine1 = Routine::from(&mut env, vec![RETURN, 10]);

        match unsafe { routine1.call(Vec::new()) } {
            Ok(ok) => {
                match ok {
                    Ok(ok) => assert_eq!(ok, 10),
                    Err(_err) => panic!("unexpected result")
                }
            },
            Err(err) => panic!("{}", err.to_string())
        };

        routine1.push(0x0);

        assert_eq!(match routine1.get(2) {
            Some(some) => *some,
            None => panic!("could not get from address 2")
        }, 0x0);

        assert_eq!(match routine1.pop() {
            Some(some) => some,
            None => panic!("failed to pop")
        }, 0x0);

        *match routine1.get_mut(1) {
            Some(some) => some,
            None => panic!("could not get from address 1")
        } = 20;

        assert_eq!(match routine1.pop() {
            Some(some) => some,
            None => panic!("failed to pop")
        }, 20);

        let mut routine3 = Routine::from(&mut env, vec![CALL, routine2 as i128, 0, RETURN_C]);

        match unsafe { routine3.call(Vec::new()) } {
            Ok(ok) => {
                match ok {
                    Ok(ok) => assert_eq!(ok, 20),
                    Err(_err) => panic!("unexpected result")
                }
            },
            Err(err) => panic!("{}", err.to_string())
        };
    }

    #[test]
    fn test_split() {
        assert_eq!(ir::split("a b c"), vec!["a", "b", "c"]);
    }

    #[test]
    fn test_parse() {
        assert_eq!(match ir::parse("1 2 3") {
            Ok(ok) => ok,
            Err(err) => panic!("{}", err.to_string())
        }, vec![1, 2, 3]);
    }
}