ttvm 0.3.5

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

use super::*;

#[test]
fn test_byte() {
    assert_eq!(Byte::MIN, i64::MIN);
    assert_eq!(Byte::MAX, i64::MAX);

    assert_eq!(IPtr::MIN, i64::MIN);
    assert_eq!(IPtr::MAX, i64::MAX);
    
    assert_eq!(RPtr::MIN, usize::MIN);
    assert_eq!(RPtr::MAX, usize::MAX);
}

#[test]
fn test_mem() {
    let mut mem = Mem::new();

    assert_eq!(NULL, 0);
    assert_eq!(mem.size(), 1);

    let addr1 = match mem.alloc(4) {
        Ok(ok) => {
            assert_eq!(ok, 1);
            assert_eq!(mem.size(), 2);

            ok
        },
        Err(err) => panic!("{}", err.to_string())
    };
    
    match mem.get_mut(addr1) {
        Ok(ok) => {
            assert_eq!(ok.len(), 4);

            *match ok.get_mut(0) {
                Some(ok) => ok,
                None => panic!("{}", "unexpected None")
            } = 'O' as Byte;

            *match ok.get_mut(1) {
                Some(ok) => ok,
                None => panic!("{}", "unexpected None")
            } = 'K' as Byte;

            *match ok.get_mut(2) {
                Some(ok) => ok,
                None => panic!("{}", "unexpected None")
            } = 0xA; // '\n' as Byte

            *match ok.get_mut(3) {
                Some(ok) => ok,
                None => panic!("{}", "unexpected None")
            } = 0x0; // '\0' as Byte
        },
        Err(err) => panic!("{}", err.to_string())
    };

    match mem.get(addr1) {
        Ok(ok) => {
            assert_eq!(ok.len(), 4);

            assert_eq!(*match ok.get(0) {
                Some(ok) => ok,
                None => panic!("{}", "unexpected None")
            }, 'O' as Byte);

            assert_eq!(*match ok.get(1) {
                Some(ok) => ok,
                None => panic!("{}", "unexpected None")
            }, 'K' as Byte);

            assert_eq!(*match ok.get(2) {
                Some(ok) => ok,
                None => panic!("{}", "unexpected None")
            }, 0xA); // '\n' as Byte

            assert_eq!(*match ok.get(3) {
                Some(ok) => ok,
                None => panic!("{}", "unexpected None")
            }, 0x0); // '\0' as Byte

            assert_eq!(ok.len(), 4);
        },
        Err(err) => panic!("{}", err.to_string())
    };

    match mem.dealloc(addr1) {
        Ok(ok) => {
            assert_eq!(ok, 4);
            assert_eq!(mem.size(), 2);

            ok
        },
        Err(err) => panic!("{}", err.to_string())
    };

    let mut addr2 = raw::malloc(&mut mem, 10);
    assert_eq!(addr2, 2);

    addr2 = raw::realloc(&mut mem, addr2, 20);
    assert_eq!(addr2, 3);

    addr2 = raw::calloc(&mut mem, 3, 10);
    assert_eq!(addr2, 4);
    
    raw::free(&mut mem, addr2);
}