Add sentinel structs to lua_fns

Fixes #1

Author: Dreae

src/lib.rs

@@ -12,16 +12,43 @@ pub use libc::c_int;
 /// This macro is used to wrap a rust function in an `extern "C"` trampoline
 /// to automatically pass a [`State`](state/struct.State.html) struct as the first
 /// argument instead of a `lua_State` raw pointer
+/// 
+/// # Examples
+/// 
+/// ```
+/// #[macro_use] extern crate luajit;
+///
+/// use luajit::{State, c_int, ThreadStatus};
+///
+/// fn return_42(state: &mut State) -> c_int {
+///     state.push(42);
+///
+///     1
+/// }
+///
+/// fn main() {
+///     let mut state = State::new();
+///     state.open_libs();
+///
+///     state.push(lua_fn!(return_42));
+///     state.set_global("return_42");
+///     let status = state.do_string("if return_42() ~= 42 then error() end");
+///     assert_eq!(status, ThreadStatus::Ok);
+///     
+///     // Equivalent
+///     state.register("return_42", lua_fn!(return_42).unwrap());
+/// }
+/// ```
 #[macro_export]
 macro_rules! lua_fn {
     ($method:path) => {
         {
             #[allow(unused)]
             unsafe extern "C" fn trampoline(l: *mut $crate::ffi::lua_State) -> $crate::c_int {
-                $method(&mut State::from_ptr(l))
+                $method(&mut $crate::State::from_ptr(l))
             };
 
-            Some(trampoline)
+            Some(trampoline as $crate::LuaFunction)
         }
     }
 }

src/state.rs

@@ -430,7 +430,14 @@ impl State {
     /// Registers all functions in `fns` on the global table `name`. If name
     /// is `None`, all functions are instead registered on the value on the top
     /// of the stack.
-    pub fn register_fns(&mut self, name: Option<&str>, fns: Vec<luaL_Reg>) {
+    pub fn register_fns(&mut self, name: Option<&str>, mut fns: Vec<luaL_Reg>) {
+        // Add a sentinel struct, even if one already exists adding a second
+        // shouldn't break anything and incur minimal overhead
+        fns.push(luaL_Reg {
+            name: ptr::null(),
+            func: None
+        });
+        
         match name {
             Some(s) => unsafe {
                 luaL_register(self.state, CString::new(s).unwrap().as_ptr(), fns.as_ptr());

src/types.rs

@@ -97,6 +97,20 @@ impl LuaValue for LuaFunction {
     }
 }
 
+impl LuaValue for Option<LuaFunction> {
+    fn push_val(self, l: *mut ffi::lua_State) {
+        if let Some(func) = self {
+            unsafe {
+                ffi::lua_pushcfunction(l, Some(func));
+            }
+        } else {
+            unsafe {
+                ffi::lua_pushnil(l);
+            }
+        }
+    }
+}
+
 impl <T> LuaValue for T where T: LuaObject {
     fn push_val(self, l: *mut ffi::lua_State) {
         let mut state = State::from_ptr(l);

tests/function_macros.rs

@@ -0,0 +1,30 @@
+#[macro_use] extern crate luajit;
+
+use luajit::{State, c_int, ThreadStatus};
+
+fn return_42(state: &mut State) -> c_int {
+    state.push(42);
+
+    1
+}
+
+#[test]
+fn test_lua_fn() {
+    let mut state = State::new();
+    state.open_libs();
+
+    state.register("return_42", lua_fn!(return_42).unwrap());
+    let status = state.do_string("if return_42() ~= 42 then error() end");
+    assert_eq!(status, ThreadStatus::Ok);
+}
+
+#[test]
+fn test_push_lua_function() {
+    let mut state = State::new();
+    state.open_libs();
+
+    state.push(lua_fn!(return_42));
+    state.set_global("return_42");
+    let status = state.do_string("if return_42() ~= 42 then error() end");
+    assert_eq!(status, ThreadStatus::Ok);
+}

tests/structs.rs

@@ -89,4 +89,52 @@ pub fn test_new_struct() {
         if foo:add() ~= 6 then error() end"
     );
     assert_eq!(res, ThreadStatus::Ok);
+}
+
+struct B {
+    pub val: i32
+}
+
+impl LuaObject for B {
+    fn name() -> *const i8 {
+        c_str!("B")
+    }
+
+    fn lua_fns() -> Vec<ffi::luaL_Reg> {
+        vec![
+            lua_method!("add", B, B::add),
+            ffi::luaL_Reg {
+                name: std::ptr::null(),
+                func: None
+            }
+        ]
+    }
+}
+
+impl B {
+    fn add(&mut self, state: &mut State) -> c_int {
+        let x = state.to_int(2).unwrap();
+        self.val += x;
+        state.push(self.val);
+
+        1
+    }
+}
+
+#[test]
+pub fn test_double_sentinel() {
+    let mut state = State::new();
+    state.open_libs();
+
+    state.push(B {
+        val: 1,
+    });
+
+    state.set_global("test");
+
+    let res = state.do_string("test:add(4)");
+    assert_eq!(res, ThreadStatus::Ok);
+
+    let res = state.do_string("if test:add(4) ~= 9 then error() end");
+    assert_eq!(res, ThreadStatus::Ok);
 }