gmodx 0.1.0

A swiss army knife for creating binary modules for Garry's Mod in 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
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

#![allow(static_mut_refs)]

use std::{error::Error, fmt::Display, os::raw::c_int};

use crate::{
    lua::{self, upvalue_index},
    lua_shared,
};

unsafe extern "C" {
    fn get_lua_call_rust() -> CFunction;
    fn set_api_table(napi: *const lua_shared::ApiTable);
}

#[repr(C)]
struct FunctionData {
    func: RustFunction,
    one_shot: bool,
}

pub type CFunction = lua_shared::lua_CFunction;
pub type RawCFunction = unsafe extern "C" fn(lua::State) -> i32;
pub type RustFunctionResult = Result<i32, Box<dyn Error + Send + Sync>>;
pub type RustFunction = fn(lua::State) -> RustFunctionResult;

pub trait FunctionReturn {
    fn handle_result(self, l: lua::State) -> RustFunctionResult;
}

impl FunctionReturn for i32 {
    #[inline(always)]
    fn handle_result(self, _: lua::State) -> RustFunctionResult {
        Ok(self)
    }
}

impl FunctionReturn for () {
    #[inline(always)]
    fn handle_result(self, _: lua::State) -> RustFunctionResult {
        Ok(0)
    }
}

impl<T, E> FunctionReturn for Result<T, E>
where
    T: FunctionReturn,
    E: Display,
{
    #[inline(always)]
    fn handle_result(self, l: lua::State) -> RustFunctionResult {
        match self {
            Ok(val) => val.handle_result(l),
            Err(err) => Err(err.to_string().into()),
        }
    }
}

impl lua::State {
    #[inline]
    pub fn push_function(self, func: RustFunction) {
        self.push_function_x(func, false);
    }

    #[inline]
    pub fn push_function_x(self, func: RustFunction, one_shot: bool) {
        let data_ptr =
            self.raw_new_userdata(std::mem::size_of::<FunctionData>()) as *mut FunctionData;
        unsafe {
            data_ptr.write(FunctionData { func, one_shot });
        }

        // Now only 1 upvalue instead of 2
        self.push_cclosure(unsafe { get_lua_call_rust() }, 1);
    }
}

// So this way of calling from Lua -> C -> Rust is for maximum safety.
// This is because lua_error can longjmp out of the function, skipping any
// Rust stack unwinding, which is undefined behavior.
extern "C-unwind" fn rust_lua_callback(l: *mut lua_shared::lua_State, result: *mut c_int) -> bool {
    let l = lua::State(l);

    let data_ptr = l.raw_to_userdata(upvalue_index(1)) as *mut FunctionData;
    if data_ptr.is_null() {
        l.push_string("attempt to call a nil value");
        return false;
    }

    let data = unsafe { &mut *data_ptr };

    #[inline(always)]
    fn release(l: lua::State, data: &mut FunctionData) {
        if data.one_shot {
            // Remove the function data from the stack
            l.push_bool(false);
            l.replace(upvalue_index(1));
        }
    }

    match (data.func)(l) {
        Ok(v) => unsafe {
            *result = v;
            release(l, data);
            true
        },
        Err(err) => {
            l.push_string(&err.to_string());
            release(l, data);
            false
        }
    }
}

inventory::submit! {
    crate::open_close::new(
        1, // Load after lua_shared
        "lua/function.rs/api_table",
        |_| unsafe {
            set_api_table(&lua_shared::ApiTable {
                error: Some(lua_shared::lua_shared().lua_error),
                rust_lua_callback: Some(rust_lua_callback),
            });
        },
        |_| unsafe {
            set_api_table(std::ptr::null());
        },
    )
}