Add lua_CFunction registration support

Author: vinniefalco

Demo/Source/NewTests.cpp

@@ -84,8 +84,23 @@ struct C
   {
     v = v_;
   }
+
+  static int static_cfunc (lua_State*)
+  {
+    return 0;
+  }
+
+  int cfunc (lua_State*)
+  {
+    return 0;
+  }
 };
 
+int cfunc (lua_State*)
+{
+  return 0;
+}
+
 void byptr (A*)
 {
 }
@@ -113,7 +128,10 @@ void addToState (lua_State* L) {
       .endClass ()
       .beginClass <C> ("C")
         .addProperty ("v", &C::get, &C::set)
+        .addStaticCFunction ("static_cfunc", &C::static_cfunc)
+        .addCFunction ("cfunc", &C::cfunc)
       .endClass ()
+      .addCFunction ("cfunc", &cfunc)
       .addFunction ("byptr", &byptr)
       .addFunction ("byref", &byref)
     .endNamespace ();

LuaBridge/LuaBridge.h

@@ -128,13 +128,17 @@
 
   ## Registration
 
-  There are four types of objects that LuaBridge can register:
+  There are five types of objects that LuaBridge can register:
 
   - **Data**: Global variables, static class data members, and class data
               members.
 
   - **Functions**: Regular functions, static class members, and class member
-                   functions
+                   functions.
+
+  - **CFunctions**: A regular function, static class member function, or class
+                    member function that uses the `lua_CFunction` calling
+                    convention.
 
   - **Namespaces**: A namespace is simply a table containing registrations of
                     functions, data, properties, and other namespaces.
@@ -185,16 +189,15 @@
 
   The results are accessible to Lua as `test`, `test.detail`, and
   `test.utility`. Here we introduce the `endNamespace` function; it returns an
-  object representing the original enclosing namespace. All LuaBridge functions which 
-  create registrations return an object upon which subsequent registrations can
-  be made, allowing for an unlimited number of registrations to be chained
-  together using the dot operator `.`. Adding two objects with the same name, in
-  the same namespace, results in undefined behavior (although LuaBridge will
-  silently accept it).
+  object representing the original enclosing namespace. All LuaBridge functions
+  which  create registrations return an object upon which subsequent
+  registrations can be made, allowing for an unlimited number of registrations
+  to be chained together using the dot operator `.`. Adding two objects with the
+  same name, in the same namespace, results in undefined behavior (although
+  LuaBridge will silently accept it).
 
-  A namespace can be re-opened later to add
-  more functions. This lets you split up the registration between different
-  source files. These are equivalent:
+  A namespace can be re-opened later to add more functions. This lets you split
+  up the registration between different source files. These are equivalent:
 
       getGlobalNamespace (L)
         .beginNamespace ("test")
@@ -215,15 +218,16 @@
         .endNamespace ();
 
 
-  ### Data, Properties, and Functions
+  ### Data, Properties, Functions, and CFunctions.
 
   These are registered into a namespace using `addVariable`, `addProperty`,
-  and `addFunction`. When registered functions are called by scripts, LuaBridge
-  automatically takes care of the conversion of arguments into the appropriate
-  data type when doing so is possible. This automated system works for the
-  function's return value, and up to 8 parameters although more can be added by
-  extending the templates. Pointers, references, and objects of class type as
-  parameters are treated specially, and explained later. If we have:
+  `addFunction`, and `addCFunction`. When registered functions are called by
+  scripts, LuaBridge automatically takes care of the conversion of arguments
+  into the appropriate data type when doing so is possible. This automated
+  system works for the function's return value, and up to 8 parameters although
+  more can be added by extending the templates. Pointers, references, and
+  objects of class type as parameters are treated specially, and explained
+  later. If we have:
 
       int globalVar;
       static float staticVar;
@@ -234,8 +238,9 @@
 
       int foo () { return 42; }
       void bar (char const*) { }
+      int cFunc (lua_State* L) { return 0; }
 
-  These are registered with:
+    These are registered with:
 
       getGlobalNamespace (L)
         .beginNamespace ("test")
@@ -245,6 +250,7 @@
           .addProperty ("prop2", getString)            // read only
           .addFunction ("foo", foo)
           .addFunction ("bar", bar)
+          .addCFunction ("cfunc", cFunc)
         .endNamespace ();
 
   Variables can be marked _read-only_ by passing `false` in the second optional
@@ -259,6 +265,7 @@
       test.prop2  -- a read-only lua_String property
       test.foo    -- a function returning a lua_Number
       test.bar    -- a function taking a lua_String as a parameter
+      test.cfunc  -- a function with a variable argument list and multi-return
 
   Note that `test.prop1` and `test.prop2` both refer to the same value. However,
   since `test.prop2` is read-only, assignment does not work. These Lua
@@ -297,6 +304,8 @@
         static void setStaticProperty (float f) { staticProperty = f; }
         static void staticFunc () { }
 
+        static int staticCFunc () { return 0; }
+
         std::string dataMember;
 
         char dataProperty;
@@ -305,6 +314,8 @@
 
         void func1 () { }
         virtual void virtualFunc () { }
+
+        int cfunc (lua_State* L) { return 0; }
       };
 
       struct B : public A {
@@ -326,10 +337,12 @@
             .addStaticData ("staticData", &A::staticData)
             .addStaticProperty ("staticProperty", &A::staticProperty)
             .addStaticMethod ("staticFunc", &A::staticFunc)
+            .addStaticCFunction ("staticCFunc", &A::staticCFunc)
             .addData ("data", &A::dataMember)
             .addProperty ("prop", &A::getProperty, &A::setProperty)
             .addMethod ("func1", &A::func1)
             .addMethod ("virtualFunc", &A::virtualFunc)
+            .addCFunction ("cfunc", &A::cfunc)
           .endClass ()
           .deriveClass <B, A> ("B")
             .addData ("data", &B::dataMember2)
@@ -3440,7 +3453,7 @@ class Namespace
   */
   template <class MemFn,
             class ReturnType = typename FuncTraits <MemFn>::ReturnType>
-  struct CallMember
+  struct CallMemberFunction
   {
     typedef typename FuncTraits <MemFn>::ClassType T;
     typedef typename FuncTraits <MemFn>::Params Params;
@@ -3471,7 +3484,7 @@ class Namespace
     lua_CFunction to call a class member function with no return value.
   */
   template <class MemFn>
-  struct CallMember <MemFn, void>
+  struct CallMemberFunction <MemFn, void>
   {
     typedef typename FuncTraits <MemFn>::ClassType T;
     typedef typename FuncTraits <MemFn>::Params Params;
@@ -3495,30 +3508,54 @@ class Namespace
     }
   };
 
+  //----------------------------------------------------------------------------
+  /**
+    lua_CFunction to call a class member lua_CFunction
+  */
+  template <class T>
+  struct CallMemberCFunction
+  {
+    static int call (lua_State* L)
+    {
+      typedef int (T::*MFP)(lua_State* L);
+      T* const t = Detail::Userdata::get <T> (L, 1, false);
+      MFP const mfp = *static_cast <MFP*> (lua_touserdata (L, lua_upvalueindex (1)));
+      return (t->*mfp) (L);
+    }
+
+    static int callConst (lua_State* L)
+    {
+      typedef int (T::*MFP)(lua_State* L);
+      T const* const t = Detail::Userdata::get <T> (L, 1, true);
+      MFP const mfp = *static_cast <MFP*> (lua_touserdata (L, lua_upvalueindex (1)));
+      return (t->*mfp) (L);
+    }
+  };
+
   //----------------------------------------------------------------------------
 
   // SFINAE Helpers
 
   template <class MemFn, bool isConst>
-  struct CallMemberHelper
+  struct CallMemberFunctionHelper
   {
     static void add (lua_State* L, char const* name, MemFn mf)
     {
       new (lua_newuserdata (L, sizeof (MemFn))) MemFn (mf);
-      lua_pushcclosure (L, &CallMember <MemFn>::callConst, 1);
+      lua_pushcclosure (L, &CallMemberFunction <MemFn>::callConst, 1);
       lua_pushvalue (L, -1);
       rawsetfield (L, -5, name); // const table
       rawsetfield (L, -3, name); // class table
     }
   };
 
   template <class MemFn>
-  struct CallMemberHelper <MemFn, false>
+  struct CallMemberFunctionHelper <MemFn, false>
   {
     static void add (lua_State* L, char const* name, MemFn mf)
     {
       new (lua_newuserdata (L, sizeof (MemFn))) MemFn (mf);
-      lua_pushcclosure (L, &CallMember <MemFn>::call, 1);
+      lua_pushcclosure (L, &CallMemberFunction <MemFn>::call, 1);
       rawsetfield (L, -3, name); // class table
     }
   };
@@ -4100,6 +4137,17 @@ class Namespace
       return *this;
     }
 
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a lua_CFunction.
+    */
+    Class <T>& addStaticCFunction (char const* name, int (*const fp)(lua_State*))
+    {
+      lua_pushcfunction (L, fp);
+      rawsetfield (L, -2, name);
+      return *this;
+    }
+
     //--------------------------------------------------------------------------
     /**
       Add or replace a data member.
@@ -4148,7 +4196,7 @@ class Namespace
         rawgetfield (L, -4, "__propget");
         typedef GT (T::*get_t) () const;
         new (lua_newuserdata (L, sizeof (get_t))) get_t (get);
-        lua_pushcclosure (L, &CallMember <get_t>::callConst, 1);
+        lua_pushcclosure (L, &CallMemberFunction <get_t>::callConst, 1);
         lua_pushvalue (L, -1);
         rawsetfield (L, -4, name);
         rawsetfield (L, -2, name);
@@ -4161,7 +4209,7 @@ class Namespace
         assert (lua_istable (L, -1));
         typedef void (T::* set_t) (ST);
         new (lua_newuserdata (L, sizeof (set_t))) set_t (set);
-        lua_pushcclosure (L, &CallMember <set_t>::call, 1);
+        lua_pushcclosure (L, &CallMemberFunction <set_t>::call, 1);
         rawsetfield (L, -2, name);
         lua_pop (L, 1);
       }
@@ -4178,7 +4226,7 @@ class Namespace
       rawgetfield (L, -4, "__propget");
       typedef GT (T::*get_t) () const;
       new (lua_newuserdata (L, sizeof (get_t))) get_t (get);
-      lua_pushcclosure (L, &CallMember <get_t>::callConst, 1);
+      lua_pushcclosure (L, &CallMemberFunction <get_t>::callConst, 1);
       lua_pushvalue (L, -1);
       rawsetfield (L, -4, name);
       rawsetfield (L, -2, name);
@@ -4254,7 +4302,37 @@ class Namespace
     template <class MemFn>
     Class <T>& addMethod (char const* name, MemFn mf)
     {
-      CallMemberHelper <MemFn, FuncTraits <MemFn>::isConstMemberFunction>::add (L, name, mf);
+      CallMemberFunctionHelper <MemFn, FuncTraits <MemFn>::isConstMemberFunction>::add (L, name, mf);
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a member lua_CFunction.
+    */
+    Class <T>& addCFunction (char const* name, int (T::*mfp)(lua_State*))
+    {
+      typedef int (T::*MFP)(lua_State*);
+      assert (lua_istable (L, -1));
+      new (lua_newuserdata (L, sizeof (mfp))) MFP (mfp);
+      lua_pushcclosure (L, &CallMemberCFunction <T>::call, 1);
+      rawsetfield (L, -2, name);
+
+      return *this;
+    }
+
+    //--------------------------------------------------------------------------
+    /**
+      Add or replace a const member lua_CFunction.
+    */
+    Class <T>& addCFunction (char const* name, int (T::*mfp)(lua_State*) const)
+    {
+      typedef int (T::*MFP)(lua_State*) const;
+      assert (lua_istable (L, -1));
+      new (lua_newuserdata (L, sizeof (mfp))) MFP (mfp);
+      lua_pushcclosure (L, &CallMemberCFunction <T>::callConst, 1);
+      rawsetfield (L, -2, name);
+
       return *this;
     }
 
@@ -4519,6 +4597,17 @@ class Namespace
     return *this;
   }
 
+  //----------------------------------------------------------------------------
+  /**
+    Add or replace a lua_CFunction.
+  */
+  Namespace& addCFunction (char const* name, int (*const fp)(lua_State*))
+  {
+    lua_pushcfunction (L, fp);
+    rawsetfield (L, -2, name);
+    return *this;
+  }
+
   //----------------------------------------------------------------------------
   /**
     Open a new or existing class for registrations.