lox-lang 0.0.3

A Lox language runtime 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

use crate::Fun;

#[derive(Clone, Copy)]
pub(super) enum FunType {
    Script,
    Function,
    Method,
    Initializer,
}

#[derive(Debug)]
pub(super) struct Local<'compile> {
    pub(super) name: &'compile str,
    pub(super) depth: usize,
    pub(super) is_defined: bool,
    pub(super) is_captured: bool,
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct Upvalue {
    pub index: usize,
    pub is_local: bool,
}

pub(super) struct FunWrapper<'compile> {
    pub(super) enclosing: Option<Box<Self>>,
    pub(super) inner: Fun,
    pub(super) r#type: FunType,
    pub(super) locals: Vec<Local<'compile>>,
    pub(super) upvalues: Vec<Upvalue>,
    pub(super) scope_depth: usize,
}

impl<'compile> FunWrapper<'compile> {
    pub(super) fn new<T: ToString>(name: &T, r#type: FunType) -> Self {
        Self {
            enclosing: None,
            inner: Fun::new(name, 0),
            r#type,
            locals: vec![Local {
                name: if let FunType::Method | FunType::Initializer = r#type {
                    "this"
                } else {
                    ""
                },
                depth: 0,
                is_defined: true,
                is_captured: false,
            }],
            upvalues: Vec::new(),
            scope_depth: 0,
        }
    }

    pub(super) fn resolve_local(&self, query: &str) -> Option<(usize, bool)> {
        for (
            index,
            Local {
                name, is_defined, ..
            },
        ) in self.locals.iter().enumerate().rev()
        {
            if *name == query {
                return Some((index, *is_defined));
            }
        }

        None
    }

    pub(super) fn resolve_upvalue(&mut self, query: &str) -> Option<usize> {
        if let Some(parent) = &mut self.enclosing {
            if let Some((index, _)) = parent.resolve_local(query) {
                parent.locals[index].is_captured = true;
                return Some(self.add_upvalue(index, true));
            } else if let Some(index) = parent.resolve_upvalue(query) {
                return Some(self.add_upvalue(index, false));
            }
        }

        None
    }

    pub(super) fn add_upvalue(&mut self, local_index: usize, is_local: bool) -> usize {
        for (idx, u_val) in self.upvalues.iter().enumerate() {
            if u_val.index == local_index && u_val.is_local == is_local {
                return idx;
            }
        }

        self.upvalues.push(Upvalue {
            index: local_index,
            is_local,
        });
        self.upvalues.len() - 1
    }
}

#[derive(Debug)]
pub(super) struct ClassWrapper {
    pub(super) enclosing: Option<Box<Self>>,
    pub(super) name: Box<str>,
    pub(super) has_superclass: bool,
}