runmat-vm 0.4.5

RunMat virtual machine and bytecode interpreter
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

//! Class lowering.

use crate::compiler::core::Compiler;
use crate::compiler::CompileError;
use crate::instr::Instr;

impl Compiler {
    fn attr_access_from_str(s: &str) -> runmat_builtins::Access {
        match s.to_ascii_lowercase().as_str() {
            "private" => runmat_builtins::Access::Private,
            _ => runmat_builtins::Access::Public,
        }
    }

    pub(crate) fn parse_prop_attrs(
        attrs: &Vec<runmat_parser::Attr>,
    ) -> (bool, bool, String, String) {
        let mut is_static = false;
        let mut is_dependent = false;
        let mut get_acc = runmat_builtins::Access::Public;
        let mut set_acc = runmat_builtins::Access::Public;
        for a in attrs {
            if a.name.eq_ignore_ascii_case("Static") {
                is_static = true;
            }
            if a.name.eq_ignore_ascii_case("Dependent") {
                is_dependent = true;
            }
            if a.name.eq_ignore_ascii_case("Access") {
                if let Some(v) = &a.value {
                    let acc = Self::attr_access_from_str(v.trim_matches('\'').trim());
                    get_acc = acc.clone();
                    set_acc = acc;
                }
            }
            if a.name.eq_ignore_ascii_case("GetAccess") {
                if let Some(v) = &a.value {
                    get_acc = Self::attr_access_from_str(v.trim_matches('\'').trim());
                }
            }
            if a.name.eq_ignore_ascii_case("SetAccess") {
                if let Some(v) = &a.value {
                    set_acc = Self::attr_access_from_str(v.trim_matches('\'').trim());
                }
            }
        }
        let gs = match get_acc {
            runmat_builtins::Access::Private => "private".to_string(),
            _ => "public".to_string(),
        };
        let ss = match set_acc {
            runmat_builtins::Access::Private => "private".to_string(),
            _ => "public".to_string(),
        };
        (is_static, is_dependent, gs, ss)
    }

    pub(crate) fn parse_method_attrs(attrs: &Vec<runmat_parser::Attr>) -> (bool, String) {
        let mut is_static = false;
        let mut access = runmat_builtins::Access::Public;
        for a in attrs {
            if a.name.eq_ignore_ascii_case("Static") {
                is_static = true;
            }
            if a.name.eq_ignore_ascii_case("Access") {
                if let Some(v) = &a.value {
                    access = Self::attr_access_from_str(v.trim_matches('\'').trim());
                }
            }
        }
        let acc_str = match access {
            runmat_builtins::Access::Private => "private".to_string(),
            _ => "public".to_string(),
        };
        (is_static, acc_str)
    }

    pub(crate) fn compile_class_def(
        &mut self,
        name: &str,
        super_class: &Option<String>,
        members: &[runmat_hir::HirClassMember],
    ) -> Result<(), CompileError> {
        let mut props: Vec<(String, bool, String, String)> = Vec::new();
        let mut methods: Vec<(String, String, bool, String)> = Vec::new();
        for m in members {
            match m {
                runmat_hir::HirClassMember::Properties { names, attributes } => {
                    let (is_static, is_dependent, get_access, set_access) =
                        Self::parse_prop_attrs(attributes);
                    for n in names {
                        let enc = if is_dependent {
                            format!("@dep:{n}")
                        } else {
                            n.clone()
                        };
                        props.push((enc, is_static, get_access.clone(), set_access.clone()));
                    }
                }
                runmat_hir::HirClassMember::Methods { body, attributes } => {
                    let (is_static, access) = Self::parse_method_attrs(attributes);
                    for s in body {
                        if let runmat_hir::HirStmt::Function { name: mname, .. } = s {
                            methods.push((mname.clone(), mname.clone(), is_static, access.clone()));
                        }
                    }
                }
                _ => {}
            }
        }
        self.emit(Instr::RegisterClass {
            name: name.to_string(),
            super_class: super_class.clone(),
            properties: props,
            methods,
        });
        Ok(())
    }
}