lua_ir 0.8.0

lua runtime and IR generation
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

use indexmap::IndexMap;

use std::cell::RefCell;
use std::collections::BTreeMap;
use std::rc::Rc;

use crate::IntType;
use crate::LuaNumber;
use crate::LuaString;
use crate::LuaValue;

#[derive(Debug, Clone)]
pub struct LuaTable {
    /// every key except number goes here
    pub(crate) map: IndexMap<LuaValue, LuaValue>,
    /// every key with number goes here
    pub(crate) arr: BTreeMap<IntType, LuaValue>,

    /// metatable
    pub(crate) meta: Option<Rc<RefCell<LuaTable>>>,
}
impl LuaTable {
    pub fn with_capacity(capacity: usize) -> Self {
        LuaTable {
            map: IndexMap::with_capacity(capacity),
            arr: BTreeMap::new(),
            meta: None,
        }
    }
    pub fn new() -> Self {
        LuaTable {
            map: IndexMap::new(),
            arr: BTreeMap::new(),
            meta: None,
        }
    }
    pub fn get_metavalue(&self, key: &'static str) -> Option<LuaValue> {
        if let Some(meta) = &self.meta {
            meta.borrow()
                .map
                .get(&LuaValue::String(LuaString::from_static_str(key)))
                .cloned()
        } else {
            None
        }
    }
    /// get value from table.
    /// key can be any lua value.
    pub fn get(&self, key: &LuaValue) -> Option<&LuaValue> {
        match key {
            LuaValue::Number(LuaNumber::Int(n)) => self.arr.get(n),
            _ => self.map.get(key),
        }
    }

    /// get value from table.
    /// key can be any lua value.
    pub fn get_mut(&mut self, key: &LuaValue) -> Option<&mut LuaValue> {
        match key {
            LuaValue::Number(LuaNumber::Int(n)) => self.arr.get_mut(n),
            _ => self.map.get_mut(key),
        }
    }

    /// get value from array part of table.
    pub fn get_arr(&self, key: IntType) -> Option<&LuaValue> {
        self.arr.get(&key)
    }
    /// get value from array part of table.
    pub fn get_arr_mut(&mut self, key: IntType) -> Option<&mut LuaValue> {
        self.arr.get_mut(&key)
    }

    /// get value from hash part of table.
    pub fn get_table(&self, key: &LuaValue) -> Option<&LuaValue> {
        self.map.get(key)
    }
    /// get value from hash part of table.
    pub fn get_table_mut(&mut self, key: &LuaValue) -> Option<&mut LuaValue> {
        self.map.get_mut(key)
    }

    /// remove value from table
    pub fn remove(&mut self, key: &LuaValue) -> Option<LuaValue> {
        match key {
            LuaValue::Number(LuaNumber::Int(n)) => self.arr.remove(n),
            _ => self.map.swap_remove(key),
        }
    }

    /// insert value to table.
    /// key can be any lua value.
    pub fn insert(&mut self, key: LuaValue, value: LuaValue) -> Option<LuaValue> {
        match key {
            LuaValue::Nil => None,
            LuaValue::Number(LuaNumber::Int(n)) => self.arr.insert(n, value),
            _ => self.map.insert(key, value),
        }
    }
    /// insert value to array part of table.
    pub fn insert_arr(&mut self, key: IntType, value: LuaValue) -> Option<LuaValue> {
        self.arr.insert(key, value)
    }
    /// insert value to hash part of table.
    pub fn insert_table(&mut self, key: LuaValue, value: LuaValue) -> Option<LuaValue> {
        match key {
            LuaValue::Nil => None,
            LuaValue::Number(LuaNumber::Int(_)) => panic!("insert_table with integer key"),
            _ => self.map.insert(key, value),
        }
    }

    /// get length of array part of table.
    pub fn len(&self) -> IntType {
        self.arr.last_key_value().map_or(0, |(k, _)| *k).max(0)
    }
}