luau 0.732.0

Safe lifetime-bound Rust embedding API for the Luau runtime
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

use core::cell::Cell;
use core::ptr;

use luau_vm::state::LuaCallbacks;

use crate::hooks::debug::{self, DebugHandler};
use crate::hooks::interrupt::{self, InterruptHandle, InterruptHandler, InterruptMode};
use crate::lua::Lua;

pub(crate) struct CallbackManager {
    interrupt_handler: Option<Box<dyn InterruptHandler>>,
    interrupt_mode: InterruptMode,
    interrupt_handle: InterruptHandle,
    interrupt_active: Cell<bool>,
    debug_handler: Option<Box<dyn DebugHandler>>,
}

impl Default for CallbackManager {
    fn default() -> Self {
        Self {
            interrupt_handler: None,
            interrupt_mode: InterruptMode::Continuous,
            interrupt_handle: InterruptHandle::new(),
            interrupt_active: Cell::new(false),
            debug_handler: None,
        }
    }
}

impl Lua {
    pub(in crate::hooks) fn install_callbacks(&mut self) {
        let (thread, manager) = self.callback_parts();
        unsafe {
            manager.install(&mut *thread.callbacks());
        }
    }
}

impl CallbackManager {
    pub(in crate::hooks) fn set_interrupt_handler(&mut self, handler: Box<dyn InterruptHandler>) {
        self.interrupt_handle.clear();
        self.interrupt_mode = handler.mode();
        self.interrupt_handler = Some(handler);
    }

    pub(in crate::hooks) fn remove_interrupt_handler(&mut self) {
        self.interrupt_handle.clear();
        self.interrupt_mode = InterruptMode::Continuous;
        self.interrupt_handler = None;
    }

    pub(in crate::hooks) fn set_debug_handler(&mut self, handler: Box<dyn DebugHandler>) {
        self.debug_handler = Some(handler);
    }

    pub(in crate::hooks) fn remove_debug_handler(&mut self) {
        self.debug_handler = None;
    }

    pub(crate) fn install(&self, callbacks: &mut LuaCallbacks) {
        callbacks.execution_interrupt = self
            .has_interrupt_handler()
            .then_some(interrupt::execution_interrupt);
        callbacks.pattern_interrupt = self
            .has_interrupt_handler()
            .then_some(interrupt::pattern_interrupt);
        callbacks.gc_interrupt = self
            .has_interrupt_handler()
            .then_some(interrupt::gc_interrupt);
        callbacks.interrupt_request =
            if self.has_interrupt_handler() && self.interrupt_mode == InterruptMode::Requested {
                self.interrupt_handle.as_ptr()
            } else {
                ptr::null()
            };
        callbacks.debug_step = self.has_debug_handler().then_some(debug::debug_step);
        callbacks.debug_break = self.has_debug_handler().then_some(debug::debug_break);
        callbacks.debug_interrupt = self.has_debug_handler().then_some(debug::debug_interrupt);
        callbacks.debug_protected_error = self
            .has_debug_handler()
            .then_some(debug::debug_protected_error);
    }

    pub(in crate::hooks) fn invoke_interrupt<R>(
        &self,
        invoke: impl FnOnce(&dyn InterruptHandler, &Cell<bool>) -> R,
    ) -> Option<R> {
        let handler = self.interrupt_handler.as_deref()?;
        if self.interrupt_active.replace(true) {
            if self.interrupt_mode == InterruptMode::Requested {
                self.interrupt_handle.request();
            }
            return None;
        }

        struct ActiveGuard<'a>(&'a Cell<bool>);

        impl Drop for ActiveGuard<'_> {
            fn drop(&mut self) {
                self.0.set(false);
            }
        }

        let _active = ActiveGuard(&self.interrupt_active);
        let deferred = Cell::new(false);
        let result = invoke(handler, &deferred);
        if self.interrupt_mode == InterruptMode::Requested && deferred.get() {
            self.interrupt_handle.request();
        }
        Some(result)
    }

    pub(in crate::hooks) fn interrupt_handle(&self) -> InterruptHandle {
        self.interrupt_handle.clone()
    }

    pub(in crate::hooks) fn debug_handler(&self) -> Option<&dyn DebugHandler> {
        self.debug_handler.as_deref()
    }

    fn has_interrupt_handler(&self) -> bool {
        self.interrupt_handler.is_some()
    }

    fn has_debug_handler(&self) -> bool {
        self.debug_handler.is_some()
    }
}