ttvm 0.1.8

Runtime and compiler infrastructure 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

use super::*;

pub type RTError = mtk::BasicError;

pub struct Routine {
    bytes: Vec<Byte>,
    mems: *mut Vec<*mut Mem>
}

impl Routine {
    pub fn new(mems: &mut Vec<*mut Mem>) -> Routine {
        Routine {
            bytes: Vec::new(),
            mems
        }
    }

    pub fn from(bytes: Vec<Byte>, mems: &mut Vec<*mut Mem>) -> Routine {
        Routine { bytes, mems }
    }

    pub fn push(&mut self, byte: Byte) {
        self.bytes.push(byte);
    }

    pub fn push_vec(&mut self, bytes: Vec<Byte>) {
        for byte in bytes {
            self.bytes.push(byte);
        }
    }

    pub fn call(&mut self) -> Option<RTError> {
        let mut b: Byte;
        let mut i: usize = 0;
        
        while i != self.len() {
            b = match self.bytes.get(i) {
                Some(some) => *some,
                None => return Some(RTError::with_message(format!("{}", i)))
            };

            if b == SYS_EXIT {
                break;
            } else if b == SYS_WRITE {
                i = i + 1;

                let l = match self.bytes.get(i) {
                    Some(some) => *some,
                    None => return Some(RTError::with_message(format!("{}", i)))
                };

                i = i + 1;

                let r = match self.bytes.get(i) {
                    Some(some) => *some,
                    None => return Some(RTError::with_message(format!("{}", i)))
                };

                let raw_copy = unsafe {
                    match (*self.mems).get(r as usize) {
                        Some(some) => (**some).clone_into_vec(),
                        None => return Some(RTError::with_message(format!("{}", i)))
                    }
                };

                let mut string: String = String::new();

                for byte in raw_copy {
                    string.push(byte as u8 as char);
                }

                if l == stdout() {
                    print!("{}", string);
                } else if l == stderr() {
                    print!("{}", string);
                } else {
                    return Some(RTError::with_message(format!("{}: SYS_WRITE: unknown output device pointer {}", i, l)));
                }
            }
        }

        None
    }

    pub fn len(&self) -> usize {
        self.bytes.len()
    }

    pub fn clone_into_vec(&self) -> Vec<Byte> {
        self.bytes.clone()
    }
}