luaur-bytecode 0.1.0

Luau bytecode format and builder (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

use crate::records::bytecode_builder::BytecodeBuilder;
use alloc::string::String;
use luaur_common::macros::luau_assert::LUAU_ASSERT;

pub struct HotComment {
    pub content: String,
    pub header: bool,
}

pub fn has_native_comment_directive(hotcomments: &[HotComment]) -> bool {
    for hc in hotcomments {
        if hc.content.is_empty()
            || hc.content.as_bytes().first() == Some(&b' ')
            || hc.content.as_bytes().first() == Some(&b'\t')
        {
            continue;
        }

        if hc.header {
            let bytes = hc.content.as_bytes();
            let space_pos = bytes.iter().position(|&b| b == b' ' || b == b'\t');

            let first = if let Some(pos) = space_pos {
                &hc.content[..pos]
            } else {
                &hc.content[..]
            };

            if first == "native" {
                return true;
            }
        }
    }

    false
}

impl BytecodeBuilder {
    pub fn end_function(&mut self, maxstacksize: u8, numupvalues: u8, flags: u8) {
        LUAU_ASSERT!(self.current_function != u32::MAX);

        let current_function = self.current_function;
        let dump = if let Some(dump_fn) = self.dump_function_ptr {
            let mut dumpinstoffs =
                core::mem::take(&mut self.functions[current_function as usize].dumpinstoffs);
            let dump = dump_fn(self, &mut dumpinstoffs);
            self.functions[current_function as usize].dumpinstoffs = dumpinstoffs;
            Some(dump)
        } else {
            None
        };
        {
            let func = &mut self.functions[current_function as usize];
            func.maxstacksize = maxstacksize;
            func.numupvalues = numupvalues;

            if let Some(dump) = dump {
                func.dump = dump;
            }

            func.data.reserve(32 + self.insns.len() * 7);
        }

        if let Some(encoder) = self.encoder {
            unsafe {
                (*encoder).encode(&mut self.insns);
            }
        }

        let mut data = String::new();
        self.write_function(&mut data, current_function, flags);
        self.functions[current_function as usize].data = data;

        self.current_function = u32::MAX;
        self.total_instruction_count += self.insns.len();

        self.insns.clear();
        self.lines.clear();
        self.constants.clear();
        self.protos.clear();
        self.jumps.clear();
        self.fb_slots.clear();
        self.table_shapes.clear();

        self.debug_locals.clear();
        self.debug_upvals.clear();

        self.typed_locals.clear();
        self.typed_upvals.clear();

        self.constant_map.clear();
        self.table_shape_map.clear();
        self.proto_map.clear();

        self.debug_remarks.clear();
        self.debug_remark_buffer.clear();
    }
}