qanglang-core 0.1.2

Core library for QangLang
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::{
    ClassHandle, ClosureHandle, FunctionHandle, HashMapHandle, NativeFunctionError, Value, Vm,
    backend::chunk::Chunk,
    memory::{INLINE_UPVALUE_COUNT, OverflowHandle, StringHandle},
};

// Re-export from closure_arena
pub use crate::memory::UpvalueSlot;

#[derive(Debug, Clone, Default, PartialEq)]
pub struct Upvalue {
    pub value: Value,
    pub is_marked: bool,
}

#[derive(Debug, Clone, Default, PartialEq)]
pub struct FunctionObject {
    pub arity: usize,
    pub name: StringHandle,
    pub chunk: Chunk,
    pub upvalue_count: usize,
}

impl FunctionObject {
    pub fn new(name: StringHandle, arity: usize) -> Self {
        Self {
            name,
            arity,
            chunk: Chunk::new(),
            upvalue_count: 0,
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct ClosureObject {
    pub function: FunctionHandle,
    pub upvalue_count: usize,
    pub inline_upvalues: [UpvalueSlot; INLINE_UPVALUE_COUNT],
    pub overflow_handle: Option<OverflowHandle>,
    pub module_context: Option<HashMapHandle>,
    pub is_marked: bool,
}

impl ClosureObject {
    pub fn new(
        function: FunctionHandle,
        upvalue_count: usize,
        module_context: Option<HashMapHandle>,
    ) -> Self {
        Self {
            function,
            upvalue_count,
            inline_upvalues: [UpvalueSlot::default(); INLINE_UPVALUE_COUNT],
            overflow_handle: None,
            module_context,
            is_marked: false,
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq)]
pub struct ClassObject {
    pub name: StringHandle,
    pub super_clazz: Option<ClassHandle>,
    pub method_table: HashMapHandle,
    pub value_table: HashMapHandle,
    pub is_marked: bool,
}

#[derive(Debug, Clone, Default, PartialEq)]
pub struct InstanceObject {
    pub clazz: ClassHandle,
    pub table: HashMapHandle,
    pub is_marked: bool,
}

#[derive(Debug, Clone, Default, PartialEq)]
pub struct BoundMethodObject {
    pub receiver: Value,
    pub closure: ClosureHandle,
    pub is_marked: bool,
}

impl BoundMethodObject {
    pub fn new(receiver: Value, closure: ClosureHandle) -> Self {
        Self {
            receiver,
            closure,
            is_marked: false,
        }
    }
}

pub type NativeFn = fn(arity: usize, vm: &mut Vm) -> Result<Option<Value>, NativeFunctionError>;

#[derive(Debug, Clone)]
pub struct NativeFunctionObject {
    pub function: NativeFn,
    pub arity: usize,
    pub name_handle: StringHandle,
}

pub type IntrinsicFn =
    fn(receiver: Value, arity: usize, vm: &mut Vm) -> Result<Option<Value>, NativeFunctionError>;

#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq)]
pub enum IntrinsicKind {
    String(StringHandle),
    Number(StringHandle),
    Array(StringHandle),
    Function(StringHandle),
}

#[derive(Debug, Clone, Copy)]
pub enum IntrinsicMethod {
    Native { function: IntrinsicFn, arity: usize },
    Call,
    Apply,
    NilSafeCall,
    NilSafeApply,
    Iter,
    ToNumber,
}

#[derive(Debug, Clone)]
pub struct BoundIntrinsicObject {
    pub receiver: Value,
    pub method: IntrinsicMethod,
    pub name_handle: StringHandle,
    pub is_marked: bool,
}

impl BoundIntrinsicObject {
    pub fn new(receiver: Value, method: IntrinsicMethod, name_handle: StringHandle) -> Self {
        Self {
            receiver,
            method,
            name_handle,
            is_marked: false,
        }
    }
}