20140102-lua binder另一只轮子的雏形

书接上一回，说到要继续丰富对类型的处理。那么如何才能做到呢，应该是要支持自定义的，所以这一回要讲的就是在前面的基础上，增加支持自定义部分，其中包含以下几个部分

• 函数的默认参数设置，包括有几个默认参数和如何设置这些默认参数；
• 可以做为返回值的参数下标（Lua支持多值返回）；
• 如何将函数的结果和当做返回值的函数的参数压入到Lua；
• 如何将函数的结果压入到Lua中（看起来和上一点重复，默认情况下是调用上一条进行压入Lua）；
• 将当做返回值的函数的参数（所有需要返回的）压入Lua；
• 如何确定中间存放函数参数的值的类型；
• 从Lua中提取函数的参数；
• 将中间存放的函数的参数的值打扮成函数需要的实参；

发现没有，关键的一条，函数的调用居然没有支持自定义。

说了这么多，我们先来瞄一眼改装后的打包过程大概是个什么样子：

lua_register(L, "h", (
xLB_CFunc::b<decltype(&h), // type of function
&h, // pointer of function
0, // count of default parameters for function
xLB_dfer, // setter for default parameters for function
xLB_idxer<>, // index of parameters for return
xLB_pper, // how each value pushed into Lua
xLB_rner, // how the result of function pushed into Lua
xLB_pter, // how those parameters after function calling pushed into Lua
My_vter, // decide what type of value for saving the function parameters
My_lver, // how the value load from Lua
xLB_vper // make values as function's parameters
>()));

感觉象不象一怪物，只是绑定一个小小的函数，居然要写这么多代码。实际上支持了默认参数，如果不做自定义，只要前面两个模板参数就可以了。当然，提供更多更简便的包装办法是必须的，得等下一篇了。

主要的C++11技术前两篇都说得差不多了，这里要提一下的是，怎么设置函数的默认参数，实际上默认参数设置的自定义支持是一个星期天才写的（新鲜）。为什么要说它呢，它和别的自定义支持有啥不同呢，是因为默认参数是值，不是类型，也不是函数，没办法做为模板参数来提供给打包模板（其实你早就知道了对不）。所以C++11提供的选择不过，听说以后的版本会支持将值和对象一类的东东做为模板参数（谁说值不能做为模板参数，象int类型的值不是可以么）。说得太不准确了，一般编译器的提示是none type一类。因为我们是要支持默认参数自定义，默认参数可是啥类型的都有，唯一的选择就是把这一过程打包成一个函数，然后这个函数就可以做为模板参数传过去了（敢不敢来个直接点的）。那么它大概长啥样呢

struct xLB_dfer {
template<class TUP, int PARAM_COUNT> struct xLB_tir {
static inline void go(TUP& tuple) {}
};
};template<class TUP> struct xLB_dfer::xLB_tir<TUP, 0> {
static inline void go(TUP& tuple) {}
};template<class TUP, class T, int Idx>
static inline void xLB_default_assign(TUP& tuple, const T& A) {
std::get<Idx>(tuple) = A;
}template<int BaseIdx, class TUP, class Idxer, class...T>
struct xLB_setdp {};template<int BaseIdx, class TUP, int...Idxs, class...T>
struct xLB_setdp<BaseIdx, TUP, xLB_idxer<Idxs...>, T...> {
static inline void go(TUP& tuple, T...DA) {
xLB_each {
(xLB_default_assign<TUP, T, BaseIdx+Idxs>(tuple,DA),1)...
};
}
};template<class TUP, class...T>
static inline void xLB_set_default_param(TUP& tuple, T...DA) {
using idxer_t = typename xLB_toidxer<T...>::type;
xLB_setdp<std::tuple_size<TUP>::value - sizeof...(T), TUP, idxer_t, T...>
::go(tuple, DA...);
}

又是一堆模板，看烦了没有，先看看怎么自定义一个设置函数

struct My_dfer : public xLB_dfer {};
template<class TUP>
struct My_dfer::xLB_tir<TUP, 1> {
static inline void go(TUP& tuple) {
//std::get<0>(tuple) = 9999;
xLB_set_default_param(tuple, 8888);
}
};

这看起来还差不多，函数过程中的那两句是相同功能的，提供xLB_set_default_param是为了方便代码编写，畅想一下，用一个宏（支持不定参数），上面的代码就会变得非常直观。

从这个设置函数的编写，可以猜到其它的自定义支持过程是怎么样的，没错，跟这个几乎是一模一样，都是从xLB提供的默认类型继承，并提供特化函数。特化类型全部是以xLB_tir命名，其执行函数的名称都叫go。

再来看两个自定义，一个是类型，另一个是从Lua中提取函数参数

struct My_vter : public xLB_vter {};
template<> struct My_vter::xLB_tir<clsA*> { using type = clsA*; };struct My_lver : public xLB_lver {};
template<int BaseIdx, int idx, class TUP>
struct My_lver::xLB_tir<BaseIdx, idx, TUP, clsA*> {
static inline void go(lua_State* L, TUP& tuple, int top) {
if (idx+BaseIdx <= top) {
auto wrap = reinterpret_cast<xLB_ludwrap<clsA>*>(lua_touserdata(L, idx+BaseIdx));
auto obj = wrap->ptr(); assert(obj != nullptr);
std::get<idx>(tuple) = obj;
}
}
};

代码

xlb.h

#ifndef _XLB_H
#define _XLB_H#include <iostream>
#include <vector>
#include <assert.h>
#include <cstring>
#include <tuple>
#include <memory>
#include <type_traits>
using namespace std;extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
} // lua header files/*---------------------------------------------------------------------------
predeclare
-----------------------------------------------------------------------------*/
template<typename T> struct xLB_xotrait;
template<typename T> struct xLB_function;
template<typename T> struct xLB_xobase;// tir (Type Information Replenish)
/*---------------------------------------------------------------------------
xLB_ludwrap : light user data wrapp as user data
-----------------------------------------------------------------------------*/
/* @struct xLB_ludwrap
 * This template used to wrapper lightuserdata as userdata, and then we can
 * set metatable on its. It's instance life managered by C++ not by Lua. */
template<typename T> struct xLB_ludwrap {
T* ptr(){ return __ptr; }
T* operator->() { return __ptr; }
xLB_ludwrap(T* ptr, bool del=false) : __ptr(ptr), __del(del) {}
virtual ~xLB_ludwrap() { if (__del) { delete __ptr; } }
protected:
T* __ptr; /**< real object */
bool __del; /**< delete __ptr when xLB_ludwrap was release */
}; // end of xLB_ludwrap/*---------------------------------------------------------------------------
xLB_creatidxer
-----------------------------------------------------------------------------*/
template<int...> struct xLB_idxer{};
template<int...RPI> using xLB_rpi = xLB_idxer<RPI...>; // xLB_idxer aliastemplate<int, class Idxer, int>
struct xLB_creatidxer;template<int I, int...Idxs, int RM>
struct xLB_creatidxer<I, xLB_idxer<Idxs...>, RM> {
using type = typename
xLB_creatidxer<I+1, xLB_idxer<Idxs..., I>, RM-1>::type;
};template<int I, int...Idxs>
struct xLB_creatidxer<I, xLB_idxer<Idxs...>, 0> {
typedef xLB_idxer<Idxs...> type;
};template<typename ...Types>
struct xLB_toidxer :
xLB_creatidxer<0, xLB_idxer<>, sizeof...(Types)> {};/*---------------------------------------------------------------------------
xLB_return_void
-----------------------------------------------------------------------------*/
template<typename Tx> struct xLB_return_void {
static const bool value = true;
};template<typename Tx, class R, class ...A>
struct xLB_return_void<R (Tx::*)(A...)> {
static const bool value = std::is_void<R>::value;
};template<class R, class ...A>
 struct xLB_return_void<R (*)(A...)> {
 static const bool value = std::is_void<R>::value;
 };/*---------------------------------------------------------------------------
xLB_each
-----------------------------------------------------------------------------*/
struct xLB_each{ template<class ...T> xLB_each(T...) {} };/*---------------------------------------------------------------------------
xLB_dfer
function default parameters provider
-----------------------------------------------------------------------------*/
struct xLB_dfer {
template<class TUP, int PARAM_COUNT> struct xLB_tir {
static inline void go(TUP& tuple) {}
};
};template<class TUP> struct xLB_dfer::xLB_tir<TUP, 0> {
static inline void go(TUP& tuple) {}
};template<class TUP, class T, int Idx>
static inline void xLB_default_assign(TUP& tuple, const T& A) {
std::get<Idx>(tuple) = A;
}template<int BaseIdx, class TUP, class Idxer, class...T>
struct xLB_setdp {};template<int BaseIdx, class TUP, int...Idxs, class...T>
struct xLB_setdp<BaseIdx, TUP, xLB_idxer<Idxs...>, T...> {
static inline void go(TUP& tuple, T...DA) {
xLB_each {
(xLB_default_assign<TUP, T, BaseIdx+Idxs>(tuple,DA),1)...
};
}
};template<class TUP, class...T>
static inline void xLB_set_default_param(TUP& tuple, T...DA) {
using idxer_t = typename xLB_toidxer<T...>::type;
xLB_setdp<std::tuple_size<TUP>::value - sizeof...(T), TUP, idxer_t, T...>
::go(tuple, DA...);
}/*---------------------------------------------------------------------------
xLB_lver
-----------------------------------------------------------------------------*/
struct xLB_lver {
template<int BaseIdx, int idx, class TUP, class V> struct xLB_tir {
static inline void go(lua_State* L, TUP& tuple, int top) {
printf("Warning: xLB_lver(%s) not implemented.\n", typeid(V).name());
}
};
};template<int BaseIdx, int idx, class TUP>
struct xLB_lver::xLB_tir<BaseIdx, idx, TUP, int> {
static inline void go(lua_State* L, TUP& tuple, int top) {
if (idx+BaseIdx <= top) {
std::get<idx>(tuple) = lua_tointeger(L, idx+BaseIdx);
}
}
};template<int BaseIdx, int idx, class TUP>
struct xLB_lver::xLB_tir<BaseIdx, idx, TUP, double> {
static inline void go(lua_State* L, TUP& tuple, int top) {
if (idx+BaseIdx <= top) {
std::get<idx>(tuple) = lua_tonumber(L, idx+BaseIdx);
}
}
};/*---------------------------------------------------------------------------
xLB_fver
-----------------------------------------------------------------------------*/
template<int BaseIdx, class LVER, class IDXER, class...TA>
struct xLB_fver {};template<int BaseIdx, class LVER, int...idxs, class...TA>
struct xLB_fver<BaseIdx, LVER, xLB_idxer<idxs...>, TA...> {
using TUP = std::tuple<TA...>;
static inline void go(lua_State* L, TUP& tuple) {
xLB_each{ (LVER::template
xLB_tir<BaseIdx,idxs,TUP,TA>::go(L, tuple, lua_gettop(L)),1)... };
}
};/*---------------------------------------------------------------------------
xLB_pper
push data(parameters of function) into lua_State
-----------------------------------------------------------------------------*/
struct xLB_pper {
template<typename T> struct xLB_tir {
static inline void go(lua_State* L, T tuple_val, int& return_count) {
lua_pushnumber(L, tuple_val); ++return_count;
}
};
};template<> struct xLB_pper::xLB_tir<const char*> {
static inline void go(lua_State* L, const char* tuple_val, int& return_count) {
lua_pushstring(L, tuple_val); ++return_count;
}
};template<> struct xLB_pper::xLB_tir<double> {
static inline void go(lua_State* L, double tuple_val, int& return_count) {
lua_pushnumber(L, tuple_val); ++return_count;
}
};template<> struct xLB_pper::xLB_tir<long> {
static inline void go(lua_State* L, long tuple_val, int& return_count) {
lua_pushnumber(L, tuple_val); ++return_count;
}
};template<> struct xLB_pper::xLB_tir<bool> {
static inline void go(lua_State* L, bool tuple_val, int& return_count) {
lua_pushnumber(L, tuple_val); ++return_count;
}
};/*---------------------------------------------------------------------------
xLB_pter
push addition parameters of function into lua_State
-----------------------------------------------------------------------------*/
struct xLB_pter { template<class,class,class> struct xLB_tir {}; };template<int...RPI,class...A,class PPER>
struct xLB_pter::xLB_tir<xLB_idxer<RPI...>,std::tuple<A...>,PPER> {
static inline void go(lua_State* L, std::tuple<A...>& tuple, int& return_count) {
xLB_each{ (PPER::template xLB_tir<
typename std::tuple_element<RPI, std::tuple<A...>>::type>
::go(L, std::get<RPI>(tuple), return_count), 1)...
};
}
};/*---------------------------------------------------------------------------
xLB_rner
push result of function into lua_State
-----------------------------------------------------------------------------*/
struct xLB_rner {
template<class R, class PPER> struct xLB_tir {
static inline void go(lua_State* L, const R& result_of_function, int& return_count) {
PPER::template xLB_tir<R>::go(L, result_of_function, return_count);
}
};
};/*---------------------------------------------------------------------------
xLB_vper
change type of value according to parameter's type for calling function
-----------------------------------------------------------------------------*/
struct xLB_vper {
template<class To, class From> struct xLB_tir {
static inline const To& go(const From& tuple_val) { return tuple_val; }
};
};template<class T>struct xLB_vper::xLB_tir<T*, T*> {
static inline T* go(T* tuple_val) { return tuple_val; }
};template<>struct xLB_vper::xLB_tir<int&, int> {
static inline int& go(int& tuple_val) { return tuple_val; }
};template<>struct xLB_vper::xLB_tir<int*, int> {
static inline int* go(int& tuple_val) { return &tuple_val; }
};/*---------------------------------------------------------------------------
xLB_vter
decide type of value for saving data come from lua_State
-----------------------------------------------------------------------------*/
struct xLB_vter {
template<class PARAM_TYPE> struct xLB_tir {
using type = PARAM_TYPE;
static_assert(std::is_pod<PARAM_TYPE>::value, "Warning: xLB_vter no implement\n");
};
};template<class PARAM_TYPE> struct xLB_vter::xLB_tir<PARAM_TYPE&> {
using type = typename xLB_vter::xLB_tir<PARAM_TYPE>::type;
};template<> struct xLB_vter::xLB_tir<int*> { using type = int; };
template<> struct xLB_vter::xLB_tir<double*> { using type = double; };/*---------------------------------------------------------------------------
xLB_caler
-----------------------------------------------------------------------------*/
struct xLB_caler {
template<class FT,class,class,class...A> struct xLB_tir {};
};template<class R, class T, class VPER, class...A, class...B, int...idxs>
struct xLB_caler::xLB_tir<R (T::*)(A...), xLB_idxer<idxs...>, VPER, B...> {
static inline R go(T* obj, R (T::*f)(A...), std::tuple<B...>& tuple) {
return (obj->*f)(VPER::template xLB_tir<A,B>::go(std::get<idxs>(tuple))...);
}
};template<class T, class VPER, class...A, class...B, int...idxs>
struct xLB_caler::xLB_tir<void (T::*)(A...), xLB_idxer<idxs...>, VPER, B...> {
static inline void go(T* obj, void (T::*f)(A...), std::tuple<B...>& tuple) {
(obj->*f)(VPER::template xLB_tir<A,B>::go(std::get<idxs>(tuple))...);
}
};template<class VPER, class...A, class...B, int...idxs>
struct xLB_caler::xLB_tir<void (*)(A...), xLB_idxer<idxs...>, VPER, B...> {
static inline void go(void (*f)(A...), std::tuple<B...>& tuple) {
f(VPER::template xLB_tir<A,B>::go(std::get<idxs>(tuple))...);
}
};template<class R, class VPER, class...A, class...B, int...idxs>
struct xLB_caler::xLB_tir<R (*)(A...), xLB_idxer<idxs...>, VPER, B...> {
static inline R go(R (*f)(A...), std::tuple<B...>& tuple) {
return f(VPER::template xLB_tir<A,B>::go(std::get<idxs>(tuple))...);
}
};
/*---------------------------------------------------------------------------
xLB_adter
-----------------------------------------------------------------------------*/
template<class R, class T, class F, F f, int DFCOUNT, class DFER, class RPIdxer,
class PPER, class RNER, class PTER, class VTER, class LVER, class VPER, class...A>
int xLB_adter(lua_State* L) {
using wrap_t = xLB_ludwrap<T>;
using tuple_t = std::tuple<typename VTER::template xLB_tir<A>::type...>;
using idxer_t = typename xLB_toidxer<A...>::type;
tuple_t tuple;
DFER::template xLB_tir<tuple_t, DFCOUNT>::go(tuple);
xLB_fver<2,LVER,idxer_t,typename VTER::template xLB_tir<A>::type...>
::go(L, tuple);
auto wrap = reinterpret_cast<wrap_t*>(lua_touserdata(L, 1));
assert(wrap != nullptr);
auto obj = wrap->ptr(); assert(obj != nullptr);
R r = xLB_caler::template xLB_tir<F,idxer_t,VPER,typename VTER::template xLB_tir<A>::type...>
::go(obj, f, tuple);
int rcnt = 0;
RNER::template xLB_tir<R,PPER>::go(L,r,rcnt);
PTER::template xLB_tir<RPIdxer,tuple_t,PPER>
::go(L, tuple, rcnt);
return rcnt;
}/*---------------------------------------------------------------------------
xLB_adter_void
-----------------------------------------------------------------------------*/
template<class T, class F, F f, int DFCOUNT, class DFER, class RPIdxer,
class PPER, class RNER, class PTER, class VTER, class LVER, class VPER, class...A>
int xLB_adter_void(lua_State* L) {
using wrap_t = xLB_ludwrap<T>;
using tuple_t = std::tuple<typename VTER::template xLB_tir<A>::type...>;
using idxer_t = typename xLB_toidxer<A...>::type;
tuple_t tuple;
DFER::template xLB_tir<tuple_t, DFCOUNT>::go(tuple);
xLB_fver<2,LVER,idxer_t,typename VTER::template xLB_tir<A>::type...>
::go(L, tuple);
auto wrap = reinterpret_cast<wrap_t*>(lua_touserdata(L, 1));
assert(wrap != nullptr);
auto obj = wrap->ptr(); assert(obj != nullptr);
xLB_caler::template xLB_tir<F,idxer_t,VPER,typename VTER::template xLB_tir<A>::type...>
::go(obj, f, tuple);
int rcnt = 0;
PTER::template xLB_tir<RPIdxer,tuple_t,PPER>
::go(L, tuple, rcnt);
return rcnt;
}/*---------------------------------------------------------------------------
xLB_CFunc
-----------------------------------------------------------------------------*/
struct xLB_CFunc {
template<class F, F f, bool, int DFCOUNT, class DFER,
class RPIdxer, class PPER, class RNER,
class PTER, class VTER, class LVER, class VPER> struct xLB_tir {};template<class FT, FT f,
int DFCOUNT=0,
class DFER=xLB_dfer,
class RPIdxer=xLB_idxer<>,
class PPER=xLB_pper,
class RNER=xLB_rner,
class PTER=xLB_pter,
class VTER=xLB_vter,
class LVER=xLB_lver,
class VPER=xLB_vper
> static inline lua_CFunction b() {
return xLB_CFunc::template xLB_tir<
FT,f,xLB_return_void<FT>::value,DFCOUNT,DFER,
RPIdxer,PPER,RNER,PTER,VTER,LVER,VPER
>::func;
}
};template<class...A, void (*f)(A...), int DFCOUNT, class DFER,
class RPIdxer, class PPER, class RNER,
class PTER, class VTER, class LVER, class VPER
> struct xLB_CFunc::xLB_tir<void (*)(A...), f, true, DFCOUNT, DFER, RPIdxer, PPER, RNER, PTER, VTER, LVER, VPER> {
static int func(lua_State* L) {
using tuple_t = std::tuple<typename VTER::template xLB_tir<A>::type...>;
using idxer_t = typename xLB_toidxer<A...>::type;
tuple_t tuple;
DFER::template xLB_tir<tuple_t, DFCOUNT>::go(tuple);
xLB_fver<1,LVER,idxer_t,typename VTER::template xLB_tir<A>::type...>
::go(L, tuple);
xLB_caler::template xLB_tir<decltype(f),idxer_t,VPER,typename VTER::template xLB_tir<A>::type...>
::go(f, tuple);
int rcnt = 0;
PTER::template xLB_tir<RPIdxer,tuple_t,PPER>
::go(L, tuple, rcnt);
return rcnt;
};
};template<class...A, class R, R (*f)(A...), int DFCOUNT, class DFER,
class RPIdxer, class PPER, class RNER,
class PTER, class VTER, class LVER, class VPER
> struct xLB_CFunc::xLB_tir<R (*)(A...), f, false, DFCOUNT, DFER, RPIdxer, PPER, RNER, PTER, VTER, LVER, VPER> {
static int func(lua_State* L) {
using tuple_t = std::tuple<typename VTER::template xLB_tir<A>::type...>;
using idxer_t = typename xLB_toidxer<A...>::type;
tuple_t tuple;
DFER::template xLB_tir<tuple_t, DFCOUNT>::go(tuple);
xLB_fver<1,LVER,idxer_t,typename VTER::template xLB_tir<A>::type...>
::go(L, tuple);
R r = xLB_caler::template xLB_tir<decltype(f),idxer_t,VPER,typename VTER::template xLB_tir<A>::type...>
::go(f, tuple);
int rcnt = 0;
RNER::template xLB_tir<R,PPER>::go(L,r,rcnt);
PTER::template xLB_tir<RPIdxer,tuple_t,PPER>
::go(L, tuple, rcnt);
return rcnt;
};
};/*---------------------------------------------------------------------------
xLB_agent
-----------------------------------------------------------------------------*/
template<class Tx,Tx,bool,int,class,class,class,class,class,class,class,class>
struct xLB_agent {};template<class Tx, class R, class ...A, R (Tx::*f)(A...), int DFCOUNT, class DFER, int...RPI,
class PPER, class RNER, class PTER, class VTER, class LVER, class VPER>
struct xLB_agent<R (Tx::*)(A...), f, false, DFCOUNT, DFER, xLB_idxer<RPI...>,
PPER,RNER,PTER,VTER,LVER,VPER> {
static inline void b(const char fn[]) {
xLB_xobase<Tx>::regfunc(fn,
xLB_adter<R, Tx, R (Tx::*)(A...), f, DFCOUNT, DFER, xLB_idxer<RPI...>,
PPER,RNER,PTER,VTER,LVER,VPER, A...>);
}
};template<class Tx, class ...A, void (Tx::*f)(A...), int DFCOUNT, class DFER, int...RPI,
class PPER, class RNER, class PTER, class VTER, class LVER, class VPER>
struct xLB_agent<void (Tx::*)(A...), f, true, DFCOUNT, DFER, xLB_idxer<RPI...>,
PPER,RNER,PTER,VTER,LVER,VPER> {
static inline void b(const char fn[]) {
xLB_xobase<Tx>::regfunc(fn,
xLB_adter_void<Tx, void (Tx::*)(A...), f, DFCOUNT, DFER, xLB_idxer<RPI...>,
PPER,RNER,PTER,VTER,LVER,VPER, A...>);
}
};/*---------------------------------------------------------------------------
xlb function
-----------------------------------------------------------------------------*/
#define luaL_reg luaL_Reg/** This function create metatable with lua api and set __index and metatable
 * to itself and make it have key weak feature. */
void xLB_newmetatable(lua_State* L, const char* LibName, luaL_Reg* Lreg);/** This function set metatable named LibName to userdata at top of stack. */
void xLB_userdata(lua_State* L, const char* LibName, lua_Number N = 0);/*---------------------------------------------------------------------------
lua userdata and C++ object
-----------------------------------------------------------------------------*/
/** if the object specify by index is userdata then
 * 1. if it is instance of type xLB_ludwrap<T> then get T* address from it;
 * 2. if it is derived from T* then get T* from userdata;
 * otherwise return nullptr; */
template<typename T, const char meta[]>
T* xLB_getuserdata(lua_State* L, int index, xLB_ludwrap<T>** pWp = 0) {
using w_t = xLB_ludwrap<T>;
T* r = 0;
if (lua_isuserdata(L, index)) {
auto wp = reinterpret_cast<w_t*>(luaL_checkudata(L, index, meta));
//auto wp = reinterpret_cast<w_t*>(lua_touserdata(L, index));
if (wp) { r = wp->ptr(); if (pWp) { *pWp = wp; } }
} //else { nb_warn(true, "userdata expected"); }
return r;
}/* Wrap xo as Lua ud, and Lua do not charge object's life. */
template<typename T>
void xLB_wrapxo(lua_State* L, T* obj) {
typedef xLB_ludwrap<T> w_t;
auto place = (w_t*)(lua_newuserdata(L, sizeof(w_t)));
new(place) w_t(obj/*,false*/);
xLB_userdata(L, xLB_xotrait<T>::meta_name, 0);
}template<typename T, const char meta[]>
void xLB_objasud(lua_State* L, T* obj) {
typedef xLB_ludwrap<T> w_t;
auto place = (w_t*)(lua_newuserdata(L, sizeof(w_t)));
new(place) w_t(obj, true);
xLB_userdata(L, meta, 0);
}/* Wrap xo as Lua ud, means Lua charge object's life. */
template<typename T>
void xLB_xoasud(lua_State* L, T* obj) {
typedef xLB_ludwrap<T> w_t;
w_t* place = static_cast<w_t*>(lua_newuserdata(L, sizeof(w_t)));
new(place) w_t(obj, true);
xLB_userdata(L, xLB_xotrait<T>::meta_name, 0);
}template<typename T, const char meta[]>
int xLB_gcobj(lua_State* L) {
xLB_ludwrap<T>* wp = 0;
xLB_getuserdata<T, meta>(L, 1, &wp);
if (wp) { wp->~xLB_ludwrap<T>();}
return 0;
}template<typename T, typename...A>
T* xLB_newxo(lua_State* L, A...arg_metas) {
T* pobj = new T(arg_metas...);
xLB_objasud<T, xLB_xotrait<T>::meta_name>(L, pobj);
return pobj;
}template<typename T>
int xLB_gcxo(lua_State* L) {
xLB_ludwrap<T>* wp = nullptr;
xLB_getuserdata<T, xLB_xotrait<T>::meta_name>(L, 1, &wp);
if (wp) { wp->~xLB_ludwrap<T>(); }
return 0;
}/*---------------------------------------------------------------------------
xLB binder
-----------------------------------------------------------------------------*/
template<typename T>
unique_ptr<xLB_xotrait<T>> xLB_newxobinder() {
return unique_ptr<xLB_xotrait<T>>(new xLB_xotrait<T>());
}template<typename T>
void xLB_bindxo(lua_State* L, const char* ns=nullptr) {
xLB_xotrait<T>::reg(L, ns);
}template<typename T>
void xLB_xoglobal(lua_State* L, T* obj, const char* name) {
xLB_wrapxo(L, obj);
lua_setglobal(L, name);
}/*---------------------------------------------------------------------------
xLB ns table
-----------------------------------------------------------------------------*/
#define xLB_pushtable(L, tbl, name, ns) tbl().reg(L, name, ns);
void xLB_newnstable(lua_State* L, const char* name, const char* ns);
void xLB_newnstable(lua_State* L, const char* tn, int index);
//void xLB_getnstable(lua_State* L, const char* name, const char* ns);/*---------------------------------------------------------------------------
xo macro
-----------------------------------------------------------------------------*/
#define xLB_xoinitmember(xo_t) \
template<> const char xLB_xobase<xo_t>::meta_name[]="xLB_"#xo_t; \
template<> const char xLB_xobase<xo_t>::type_name[]=#xo_t; \
template<> xLB_pchars xLB_xobase<xo_t>::super_name_list=xLB_pchars(); \
template<> std::vector<luaL_reg> xLB_xobase<xo_t>::rg_meta={{nullptr,nullptr}}; \
template<> std::vector<luaL_reg> xLB_xobase<xo_t>::rg_type={{nullptr,nullptr}}; \#define xLB_xodefineobj(xo_t) xLB_xotrait<xo_t> xLB_xo##xo_t; \#define xLB_xodefine(xo_t) \
xLB_xoinitmember(xo_t) \
xLB_xodefineobj(xo_t) \#define xLB_xodeclare(xo_t) \
template<> struct xLB_xotrait<xo_t> : public xLB_xobase<xo_t> \/*---------------------------------------------------------------------------
xLB_method
-----------------------------------------------------------------------------*/
template<typename T> struct xLB_method {
using type = int (*)(lua_State*, T*);
};template<typename R, typename T, typename... A>
struct xLB_method<R (T::*)(A...) > {
using type = R(T::*)(A...);
};template<typename R, typename T, typename... A>
struct xLB_method<R (T::*)(A...) const > {
using type = R(T::*)(A...) const;
};template<typename T>
T* xLB_getxo(lua_State* L, int index) {
return xLB_getuserdata<T, xLB_xotrait<T>::meta_name>(L, index);
}template<typename T, typename xLB_method<T>::type f>
int xLB_xomethod(lua_State* L) {
int rc = 0;
T* obj = xLB_getxo<T>(L, 1);
if (obj) rc = f(L, obj);
return rc;
}/*---------------------------------------------------------------------------
xLB_xotrait
-----------------------------------------------------------------------------*/
template<typename T> struct xLB_xotrait{ static char meta[]; };typedef std::vector<const char*> xLB_pchars;
int xLB_search(lua_State* L, const char* method_name, const xLB_pchars& nlst);
int xLB_rawsearch(lua_State* L, const char* method_name, const char* meta_name);/*---------------------------------------------------------------------------
xLB_xobase
-----------------------------------------------------------------------------*/
template<typename X>
struct xLB_xobase {
typedef X T;
typedef xLB_xobase self_t;
typedef xLB_xobase* this_t;
typedef xLB_xotrait<T> trait_t;
typedef std::vector<luaL_reg> regs_t;
static const char meta_name[];
static const char type_name[];
static xLB_pchars super_name_list;
static regs_t rg_meta;
static regs_t rg_type;
//virtual ~xLB_xobase() = delete;static inline void regfunc(const char fn[], lua_CFunction f) {
auto it = begin(rg_meta);
rg_meta.insert(it, {fn,f});
}static int index_implement(lua_State* L) { //__index(t,k)
auto method_name = luaL_optlstring(L, 2, "", nullptr);
int nFound = xLB_rawsearch(L, method_name, meta_name);
if (!nFound) {
nFound = xLB_search(L, method_name, super_name_list);
}
return nFound;
}static void newxometatable(lua_State* L) {
luaL_newmetatable(L, trait_t::meta_name);
lua_pushstring(L, "__index");
lua_pushcfunction(L, index_implement);
lua_rawset(L, -3);
// set metatable.metatable to itself
lua_pushvalue(L, -1);
lua_setmetatable(L, -2);
luaL_setfuncs(L, &rg_meta[0], 0);
lua_pop(L, 1); // pop metatable
}template<class SUPER_XO> static void super() {
super_name_list.push_back(xLB_xotrait<SUPER_XO>::meta_name);
}template<lua_CFunction f> static void c(const char fn[]="new") {
auto it = begin(rg_type);
rg_type.insert(it, {fn,f});
}static void d() { b<xLB_gcxo<T>>("__gc"); }template<typename xLB_method<T>::type f> static void b(const char fn[]) {
regfunc(fn, xLB_xomethod<T, f>);
}template<lua_CFunction f> static void b(const char fn[]) {
regfunc(fn, f);
}template<class FT, FT f,
int DFCOUNT = 0,
class DFER=xLB_dfer,
class RPIs=xLB_idxer<>,
class PPER=xLB_pper,
class RNER=xLB_rner,
class PTER=xLB_pter,
class VTER=xLB_vter,
class LVER=xLB_lver,
class VPER=xLB_vper>
static void bx(const char fn[]) {
xLB_agent<FT, f, xLB_return_void<FT>::value, DFCOUNT, DFER, RPIs,
PPER,RNER,PTER,VTER,LVER,VPER
>::b(fn);
}static void reg(lua_State* L, const char* ns = nullptr) {
if (1 < rg_meta.size()) { newxometatable(L); }
if (1 < rg_type.size()) {
luaL_newlib(L, &rg_type[0]);
if (ns && strlen(ns)) {
lua_getglobal(L, ns);
if (LUA_TTABLE != lua_type(L, -1)) {
lua_pop(L, 1);
lua_newtable(L);
lua_setglobal(L, ns);
lua_getglobal(L, ns);
}
lua_pushstring(L, trait_t::type_name);
lua_pushvalue(L, -3);
lua_rawset(L, -3);
lua_pop(L, 2);
}
}
}
}; // end of xLB_xobase/*---------------------------------------------------------------------------
xLB_table
-----------------------------------------------------------------------------*/
template<typename X>
struct xLB_table {
typedef X T;
typedef xLB_table self_t;
typedef xLB_table* this_t;
typedef std::vector<luaL_reg> regs_t;
virtual ~xLB_table() {}
regs_t rg_table;
template<lua_CFunction f> void c(const char fn[]) {
rg_table.push_back({fn,f});
}
template<lua_CFunction f>
void b(const char fn[]) {
rg_table.push_back({fn,f});
}
void reg(lua_State* L, const char* tn, const char* ns = 0) {
if (0 < rg_table.size()) {
rg_table.push_back({nullptr,nullptr});
luaL_newlib(L, &rg_table[0]);
if (ns && strlen(ns)) {
lua_getglobal(L, ns);
int t = lua_type(L, -1);
if (LUA_TNIL == t || LUA_TTABLE != t ) {
lua_pop(L, 1);
lua_newtable(L);
lua_setglobal(L, ns);
lua_getglobal(L, ns);
}
lua_pushstring(L, tn);
lua_pushvalue(L, -3);
lua_rawset(L, -3);
lua_pop(L, 2);
}
}
}
void reg(lua_State* L, const char* tn, int index = 0) {
if (0 < rg_table.size()) {
rg_table.push_back({nullptr,nullptr});
lua_pushstring(L, tn);
luaL_newlib(L, &rg_table[0]);
if (index < 0) { index-=2; }
if (index) { lua_rawset(L, index); }
}
}
}; // end of xLB_table#endif // end of __XLB_H__

xlb.cpp

#include <ns/xlb.h>/*---------------------------------------------------------------------------
lux_
-----------------------------------------------------------------------------*/
void xLB_newmetatable(lua_State* L, const char* LibName, luaL_Reg* Lreg) {
luaL_newmetatable(L, LibName);
lua_pushstring(L, "__index");
lua_pushvalue(L, -2);
lua_rawset(L, -3);
// set metatable to "key" weak table
//lua_pushstring(L, "__mode");
//lua_pushstring(L, "k");
//lua_rawset(L, -3);
// set metatable.metatable to itself
lua_pushvalue(L, -1);
lua_setmetatable(L, -2);
//luaL_register(L, nullptr, Lreg);
luaL_setfuncs(L, Lreg, 0/*no upvalue for funcs to share*/);
lua_pop(L, 1); // pop metatable
}int xLB_search(lua_State* L,
const char* method_name, const xLB_pchars& nlst) {
int nFound = 0;
for (auto meta_name : nlst) {
lua_getfield(L, LUA_REGISTRYINDEX, meta_name);
if (!lua_istable(L, -1)) {
//nb_warn(true, "%s not registered", meta_name);
return 0;
} else {
lua_pushstring(L, method_name);
lua_gettable(L, -2);
lua_replace(L, -2);
nFound = (lua_isnil(L, -1) ? 0 : 1);
if (nFound) break;
}
}
return nFound;
}int xLB_rawsearch(lua_State* L,
const char* method_name, const char* meta_name) {
//nb_warn(true, "search: %s in %s", method_name, meta_name);
lua_getfield(L, LUA_REGISTRYINDEX, meta_name);
if (!lua_istable(L, -1)) {
//nb_warn(true, "%s not registered", meta_name);
return 0;
} else {
lua_pushstring(L, method_name);
lua_rawget(L, -2);
lua_replace(L, -2);
return (lua_isnil(L, -1) ? 0 : 1);
}
}void xLB_userdata(lua_State* L, const char* LibName, lua_Number N) {
// s: 1(ud)
//int inew =
luaL_newmetatable(L, LibName); // s: 1(ud), 2(metatable)
//nb_warn(inew, "xLB-Error: %d %s", inew, LibName);
lua_setmetatable(L, -2); // userdata.metatable = metatable
}void xLB_newnstable(lua_State* L, const char* name, const char* ns) {
lua_getglobal(L, ns);
if (LUA_TTABLE == lua_type(L, -1)) {
lua_pushstring(L, name);
lua_newtable(L);
lua_rawset(L, -3);
}
lua_pop(L, 1);
}void xLB_newnstable(lua_State* L, const char* tn, int index) {
lua_pushstring(L, tn);
lua_newtable(L);
if (index < 0) { index-=2; }
lua_rawset(L, index);
}/*
void xLB_getnstable(lua_State* L, const char* name, const char* ns) {
lua_getglobal(L, ns);
lua_pushlstring(L, name, strlen(name));
lua_rawget(L, -2);
lua_insert(L, -2);
lua_pop(L, 1);
}
*/

测试的一段代码

xlbinder.h

#ifndef _XLBINDER_H
#define _XLBINDER_H#include <ns/xlb.h>
#include <type_traits>struct clsB {
void b() { printf("base class clsB::b() method called\n"); }
};struct clsA : public clsB {
int Add(int a, int& b);
int Del(int* a);
int Modify(int& a);
void NoReturn(int a);
void Complex(clsA* pa);
int x = 999;
}; // end of clsAxLB_xodeclare(clsB) {
xLB_xotrait() {
bx<decltype(&clsB::b), &clsB::b>("b");
}
};struct My_vter : public xLB_vter {};
template<> struct My_vter::xLB_tir<clsA*> { using type = clsA*; };struct My_lver : public xLB_lver {};
template<int BaseIdx, int idx, class TUP>
struct My_lver::xLB_tir<BaseIdx, idx, TUP, clsA*> {
static inline void go(lua_State* L, TUP& tuple, int top) {
if (idx+BaseIdx <= top) {
auto wrap = reinterpret_cast<xLB_ludwrap<clsA>*>(lua_touserdata(L, idx+BaseIdx));
auto obj = wrap->ptr(); assert(obj != nullptr);
std::get<idx>(tuple) = obj;
}
}
};struct My_dfer : public xLB_dfer {};
template<class TUP>
struct My_dfer::xLB_tir<TUP, 1> {
static inline void go(TUP& tuple) {
//std::get<0>(tuple) = 9999;
xLB_set_default_param(tuple, 8888);
}
};xLB_xodeclare(clsA) {
xLB_xotrait() {
super<clsB>();
bx<decltype(&clsA::Add), &clsA::Add, 0, xLB_dfer, xLB_idxer<1,0>>("Add");
bx<decltype(&clsA::NoReturn), &clsA::NoReturn, 1, My_dfer, xLB_idxer<0>>("NoReturn");
bx<decltype(&clsA::Complex), &clsA::Complex, 0, xLB_dfer, xLB_idxer<>,
xLB_pper,
xLB_rner,
xLB_pter,
My_vter, //xLB_vter,
My_lver, //xLB_lver,
xLB_vper
>("Complex");
}
};struct mytype {
int a;
};void foo(int a);
int g(int a);
int h(clsA* a);#endif

xlbinder.cpp

#include "xlbinder.h"//----------------------------------------------------------------------
int clsA::Add(int a, int& b) {
printf("clsA::Add(%d,%d):%d called\n", a,b,a+b);
b+=123;
return a+b;
}
int clsA::Del(int* a) { printf("obj:Del called: %d\n", *a); return *a = 2; };
int clsA::Modify(int& a) { return a*=2; }
void clsA::NoReturn(int a) { printf("obj:NoReturn called: %d\n", a*3); }
void clsA::Complex(clsA* pa) { printf("Complex %d\n", pa->x); }//----------------------------------------------------------------------
void foo(int a) { printf("foo called: %d\n", a); }
int g(int a) { printf("g called: %d\n", a); return a+2; }
int h(clsA* a) { printf("h called: %d\n", a->x); return 0; }//----------------------------------------------------------------------
xLB_xodefine(clsA);
xLB_xodefine(clsB);
//----------------------------------------------------------------------------//----------------------------------------------------------------------------
int main() {
std::cout << "xLB test ... \n";
auto L = luaL_newstate();
luaL_openlibs(L);
xLB_bindxo<clsB>(L);
xLB_bindxo<clsA>(L);
clsA obj;
obj.x = 99;
xLB_xoglobal<clsA>(L, &obj, "obj");
luaL_dostring(L, "print('Lua{');");
luaL_dostring(L, "print('getmetatable(obj)={');");
luaL_dostring(L, "for k,v in pairs(getmetatable(obj)) do print('  ' .. k .. '=' .. tostring(v)); end");
luaL_dostring(L, "print('}');");
luaL_dostring(L, "print(obj:Complex(obj));");
luaL_dostring(L, "print(obj:Add(99,2));");luaL_dostring(L, "x = obj:NoReturn(8); ");
luaL_dostring(L, "print('obj:NoReturn(8)=' .. tostring(x));");
luaL_dostring(L, "x = obj:NoReturn(); ");
luaL_dostring(L, "print('obj:NoReturn(default_param)=' .. tostring(x));");//---
lua_register(L, "foo", (xLB_CFunc::b<decltype(&foo), &foo, 1, My_dfer>()));
luaL_dostring(L, "x = foo(1901);");
luaL_dostring(L, "print('foo(1901)=' .. tostring(x));");
luaL_dostring(L, "x = foo();");
luaL_dostring(L, "print('foo(default_param)=' .. tostring(x));");lua_register(L, "g", (xLB_CFunc::b<decltype(&g), &g, 0, xLB_dfer, xLB_idxer<0>>()));
luaL_dostring(L, "print(g(1999));");lua_register(L, "h", (
xLB_CFunc::b<decltype(&h), // type of function
&h, // pointer of function
0, // count of default parameters for function
xLB_dfer, // setter for default parameters for function
xLB_idxer<>, // index of parameters for return
xLB_pper, // how each value pushed into Lua
xLB_rner, // how the result of function pushed into Lua
xLB_pter, // how those parameters after function calling pushed into Lua
My_vter, // decide what type of value for saving the function parameters
My_lver, // how the value load from Lua
xLB_vper // make values as function's parameters
>()));
luaL_dostring(L, "h(obj);");
luaL_dostring(L, "obj:b()"); // call base class methodlua_close(L);
printf("}\n");
return 0;
}

输出结果：

xLB test ...
Lua{
getmetatable(obj)={
  Add=function: 004094D0
  __index=function: 004096A0
  Complex=function: 00409214
  NoReturn=function: 00409300
}
Complex 99clsA::Add(99,2):101 called
224     99      125
obj:NoReturn called: 24
obj:NoReturn(8)=8
obj:NoReturn called: 26664
obj:NoReturn(default_param)=8888
foo called: 1901
foo(1901)=nil
foo called: 8888
foo(default_param)=nil
g called: 1999
2001    1999
h called: 99
base class clsB::b() method called
}