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
129
130
131
132
133
134

use core::{fmt, marker::PhantomData};

use luau_vm::Thread as VmThread;
use luau_vm::VmErrorResult;
use luau_vm::thread::StackGuard;

use crate::error::Error;
use crate::lua::Lua;
use crate::lua::runtime::RuntimeData;
use crate::thread::Thread;

pub(crate) struct ValueRef<'lua> {
    thread: &'lua VmThread,
    runtime: &'lua RuntimeData,
    reference: i32,
    pointer: *const (),
    _marker: PhantomData<&'lua Lua>,
}

impl<'lua> ValueRef<'lua> {
    pub(crate) const fn new(
        thread: &'lua VmThread,
        runtime: &'lua RuntimeData,
        reference: i32,
        pointer: *const (),
    ) -> Self {
        Self {
            thread,
            runtime,
            reference,
            pointer,
            _marker: PhantomData,
        }
    }

    pub(crate) fn from_stack(thread: &Thread<'lua>, index: i32) -> VmErrorResult<Self> {
        let pointer = unsafe { thread.as_vm().to_pointer(index) };
        let reference = unsafe { thread.as_vm().ref_value(index)? };
        Ok(Self::new(
            thread.reference_thread(),
            thread.runtime(),
            reference,
            pointer,
        ))
    }

    pub(crate) const fn runtime(&self) -> &'lua RuntimeData {
        self.runtime
    }

    pub(crate) const fn reference_thread(&self) -> &'lua VmThread {
        self.thread
    }

    pub(crate) fn thread(&self) -> Thread<'lua> {
        Thread::new(self.thread, self.runtime)
    }

    pub(crate) const fn pointer(&self) -> *const () {
        self.pointer
    }

    pub(crate) fn same_value(&self, other: &Self) -> bool {
        (unsafe { self.thread.same_vm(other.thread) }) && self.pointer() == other.pointer()
    }

    pub(crate) fn try_clone(&self) -> Result<Self, Error> {
        unsafe {
            let thread = self.thread();
            let vm_thread = thread.as_vm();
            let _stack = StackGuard::new(vm_thread);
            self.push()
                .map_err(|exit| Error::from_thread_exit(vm_thread, exit))?;
            let reference = vm_thread
                .ref_value(-1)
                .map_err(|exit| Error::from_thread_exit(vm_thread, exit))?;
            Ok(Self::new(
                self.thread,
                self.runtime,
                reference,
                self.pointer,
            ))
        }
    }

    pub(crate) fn push_to(&self, target: impl AsRef<VmThread>) -> Result<(), Error> {
        unsafe {
            let vm_thread = self.thread;
            let target = target.as_ref();
            if !target.same_vm(vm_thread) {
                return Err(Error::foreign_lua_handle());
            }
            if *vm_thread == *target {
                self.push()
                    .map_err(|exit| Error::from_thread_exit(vm_thread, exit))?;
            } else {
                let _stack = StackGuard::new(vm_thread);
                self.push()
                    .map_err(|exit| Error::from_thread_exit(vm_thread, exit))?;
                vm_thread
                    .x_move(target, 1)
                    .map_err(|exit| Error::from_thread_exit(vm_thread, exit))?;
            }
        }
        Ok(())
    }

    pub(crate) fn push(&self) -> VmErrorResult {
        unsafe { self.thread.get_ref(self.reference).map(drop) }
    }
}

impl Drop for ValueRef<'_> {
    fn drop(&mut self) {
        let thread = self.thread();
        unsafe {
            thread.as_vm().unref_value(self.reference);
        }
    }
}

impl PartialEq for ValueRef<'_> {
    fn eq(&self, other: &Self) -> bool {
        self.same_value(other)
    }
}

impl Eq for ValueRef<'_> {}

impl fmt::Debug for ValueRef<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "Ref({:p})", self.pointer())
    }
}