tsuki 0.4.8

Lua 5.4 ported to 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

use crate::lobject::{Proto, UpVal};
use crate::value::UnsafeValue;
use crate::{Object, Value};
use alloc::boxed::Box;
use core::cell::Cell;
use core::marker::PhantomPinned;
use core::num::NonZero;

/// Lua function.
///
/// The only way to create the value of this type is either [Lua::load()](crate::Lua::load()) or
/// [Context::load()](crate::Context::load()).
#[repr(C)]
pub struct LuaFn<D> {
    pub(crate) hdr: Object<D>,
    pub(crate) p: Cell<*mut Proto<D>>,
    pub(crate) upvals: Box<[Cell<*mut UpVal<D>>]>,
    pin: PhantomPinned,
}

impl<D> LuaFn<D> {
    /// Set upvalue of this function. Return `v` if `i` is not a valid index.
    ///
    /// # Panics
    /// - If `i` is zero.
    /// - If `v` was created from a different [Lua](crate::Lua) instance.
    pub fn set_upvalue<'a>(
        &self,
        i: impl TryInto<NonZero<usize>>,
        v: Value<'a, D>,
    ) -> Result<(), Value<'a, D>> {
        // Check if index valid.
        let i = i.try_into().ok().unwrap().get() - 1;
        let u = match self.upvals.get(i) {
            Some(v) => v.get(),
            None => return Err(v),
        };

        // Check if v come from the same Lua.
        let v = UnsafeValue::from(v);

        if unsafe { v.tt_ & 1 << 6 != 0 && (*v.value_.gc).global != (*u).hdr.global } {
            panic!("attempt to set upvalue with a value created from different Lua instance");
        }

        // Set value.
        unsafe { (*u).v.get().write(v) };

        if unsafe { v.tt_ & 1 << 6 != 0 && (*u).hdr.marked.get() & 1 << 5 != 0 } {
            if unsafe { (*v.value_.gc).marked.get() & (1 << 3 | 1 << 4) != 0 } {
                unsafe { (*u).hdr.global().gc.barrier(u.cast(), v.value_.gc) };
            }
        }

        Ok(())
    }
}