jazz_vm 0.1.5

The Jazz VM
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

use std::fmt::{Debug, Formatter};
use std::borrow::Cow;
use super::function::Function;
use super::executor::Executor;

#[derive(Debug)]
pub struct Program<'a> {
    pub functions: Vec<Function>,
    pub(super) native_functions: Vec<NativeFunction<'a>>
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct ProgramInfo<'a> {
    pub functions: Vec<Function>,
    pub native_functions: Vec<Cow<'a, str>>
}

pub struct NativeFunction<'a> {
    name: String,
    fn_impl: &'a Fn(&Executor)
}

impl<'a> Debug for NativeFunction<'a> {
    fn fmt(&self, f: &mut Formatter) -> ::std::fmt::Result {
        write!(f, "NativeFunction")
    }
}

impl<'a> NativeFunction<'a> {
    pub fn new<T: ToString>(name: T, f: &'a Fn(&Executor)) -> NativeFunction<'a> {
        NativeFunction {
            fn_impl: f,
            name: name.to_string()
        }
    }

    pub fn invoke(&self, executor: &Executor) {
        (self.fn_impl)(executor);
    }
}

impl<'a> Program<'a> {
    pub fn from_functions(fns: Vec<Function>) -> Program<'a> {
        Program {
            functions: fns,
            native_functions: Vec::new()
        }
    }

    pub fn append_native_function(&mut self, f: NativeFunction<'a>) -> usize {
        self.native_functions.push(f);
        self.native_functions.len() - 1
    }

    pub fn resolve_native_functions<T, F>(
        &mut self,
        function_list: &[T],
        resolver: F
    ) -> bool
        where
            F: Fn(&str) -> Option<NativeFunction<'a>>,
            T: AsRef<str>
    {
        let mut nf_list: Vec<NativeFunction<'a>> = Vec::new();

        for name in function_list {
            let nf = if let Some(v) = resolver(name.as_ref()) {
                v
            } else {
                return false;
            };
            nf_list.push(nf);
        }

        self.native_functions = nf_list;
        true
    }

    pub fn dump(&self) -> ProgramInfo {
        ProgramInfo {
            functions: self.functions.clone(),
            native_functions: self.native_functions.iter().map(|v| Cow::from(v.name.as_str())).collect()
        }
    }

    pub fn load<F>(info: ProgramInfo, resolver: F) -> Option<Program<'a>>
        where F: Fn(&str) -> Option<NativeFunction<'a>>
    {
        let mut program = Self::from_functions(info.functions);
        if program.resolve_native_functions(info.native_functions.as_slice(), resolver) == false {
            return None;
        }

        Some(program)
    }
}

impl<'a> ProgramInfo<'a> {
    pub fn std_serialize(&self) -> Vec<u8> {
        ::bincode::serialize(self, ::bincode::Infinite).unwrap()
    }

    pub fn std_deserialize(input: &'a [u8]) -> Option<ProgramInfo<'a>> {
        match ::bincode::deserialize(input) {
            Ok(v) => Some(v),
            Err(_) => None
        }
    }
}