20140218-lua binder另一只轮子的雏形（2014-01-02 20:08）

书接上一回，继续补充xlb的功能。这次修改代码的代码比添加功能的代码还多，完成后大致包括

• 添加了支持overload和override函数绑定，支持绑定属性;
• 添加了构造函数绑定，释构函数绑定前面已经实现了，这次是把名字修改了;
• 修改函数参数提取过程，支持非一对一提取，即是一个函数形参可以从lua_State中提取N个参数(0<=N<=lua_gettop(L))，不过这一功能的具体用途还不是很清晰;
• 添加绑定函数执行过程错误提示;
• xlb变成单个头文件的形式;

添加绑定常量得等下一回继续。从C++调用lua这部分还没开始，还有许多功能需要实现，向luabind等学习，继续丰富其功能。xlb没有使用upvalue，纯模板编译时确定，因为还有许多功能未实现，现在仍不知道这会不会带来麻烦。

测试代码：

for k,v in pairs(clsA) do
	print(k,v);
end
objC:override_();
local f = obj.override_;
f(objC);
local f = objC.override_;
f(objC);
print(objC);
print(objC.z);
print(objC.x);
objC.x = 1;
print(objC.x);
objC:b();
local f = objC.b;
print(another);
f(obj);
print(obj.x);
for k,v in pairs(getmetatable(obj)) do
	print(k,v);
end
print(tostring(obj));
obj:NoReturn(555);
obj:NoReturn();
obj:Add(1,2);
obj:Add2(1,2,3);
obj.Add2(obj,1,2,3);
print(g(54321));
foo();
foo(1);
x=clsA.new(777);
x:Complex(x);
x = nil;
collectgarbage();

执行结果：

new     function: 0040A128
clsC::override_
clsA::override_
clsC::override_
xLB_object: 0x0022FEC4
1234
333
1
base class clsB::b() method called
xLB_object: 0x0022FEDB
base class clsB::b() method called
111
__newindex      function: 0040AFC4
__tostring      function: 0040B150
xLB_meta        xLB_clsA
xLB_super       table: 005D9B20
xLB_ancient     table: 005D9AF8
__gc    function: 0040A860
__index function: 0040AE64
xLB_object: 0x0022FED0
obj:NoReturn[a=555]
obj:NoReturn[a=8888]
clsA::Add(1,2):3 called
clsA::Add(int,int,int):1+2+3=6 called
clsA::Add(int,int,int):1+2+3=6 called
g(54321)
54323
foo called.
foo called: 1
obj:Complex[clsA*=0x005d2890, pa->x=777]
(0x005d2890)x=777,free
(0x0022fec4)x=1,free
(0x0022fed0)x=111,free

luabind.h

#ifndef _XLBINDER_H
#define _XLBINDER_H

#include <ns/xlb.h>
#include <type_traits>

struct clsAnother {
};

xLB_xodeclare(clsAnother) {
}

struct clsB {
	void b() { printf("base class clsB::b() method called\n"); }
	int z = 1234;
};

struct clsA : public clsB {
	clsA(int a=0) : x(a) {}
	~clsA() { printf("(0x%p)x=%d,free\n", this,x); }
	int Add(int a, int& b);
	void Add(int a, int b, int c) const;
	int Del(int* a);
	int Modify(int& a);
	void NoReturn(int a);
	void Complex(clsA* pa);
	int x = 999;
	void override_() { printf("clsA::override_\n"); }
}; // end of clsA

struct clsC : public clsA {
	void override_() { printf("clsC::override_\n"); }
	int y = 1000;
};

xLB_xodeclare(clsB) {
	def("b", xLB_cfunction<decltype(&clsB::b), &clsB::b>);
	def_readwrite<decltype(&clsB::z), &clsB::z>("z");
}

struct My_vter : public xLB_vter {};
template<> struct My_vter::xLB_tir<clsA*> { using type = clsA*; };

struct My_lver : public xLB_lver {
	//template<class TUP_ELE, class V> struct xLB_tir {};
};
template<class TUP_ELE>
	struct My_lver::xLB_tir<TUP_ELE, clsA*> {
		template<class TUP>
		static inline void go(lua_State* L, TUP_ELE& tuple_val, TUP& tuple, xLB_ami& ami) {
			auto obj = xLB_getdynamicud<clsA>(L, ami.next_index);
			if (obj) {
				tuple_val= obj;
				++ami.next_index;
			} else {
				ami.type_match = XLB_AMI_BAD;
				ami.extmsg = "clsA* expected";
			}
		}
	};

//struct My_dfer : public xLB_dfer {
struct My_dfer {
	template<class TUP> static inline int go(TUP& tuple) {
		return xLB_defaultarguments(tuple, 8888);
	}
};

xLB_xodeclare(clsA) {
	super<clsB>();
	constructor("new", xLB_cfunction<decltype(&xLB_newer<int>),&xLB_newer<int>,xLB_dfer,xLB_idxer<>,xLB_pper,xLB_rner_newobj>);
	def("NoReturn", xLB_cfunction<decltype(&clsA::NoReturn), &clsA::NoReturn, My_dfer, xLB_idxer<0>>);
	def("Complex", xLB_cfunction<decltype(&clsA::Complex), &clsA::Complex>);
	def("Add2", xLB_cfunction<void (clsA::*)(int, int, int) const, &clsA::Add>);
	def("Add", xLB_cfunction<
				xLB_cfunction<int (clsA::*)(int,int&), &clsA::Add>
			, xLB_cfunction<void (clsA::*)(int,int,int) const, &clsA::Add>>);
	def_readwrite<decltype(&clsA::x), &clsA::x>("x");
	def("override_", xLB_cfunction<decltype(&clsA::override_), &clsA::override_>);
	destructor();
};

xLB_xodeclare(clsC) {
	super<clsA>();
	def("override_", xLB_cfunction<decltype(&clsC::override_), &clsC::override_>);
}

struct mytype {
	int a;
};

void foo(int a);
int g(int a);
int h(clsA* a);
void v(int n, ...);

#endif

xlbind.cpp

#include "xlbinder.h"

//----------------------------------------------------------------------
void foo(int a) { printf("foo called: %d\n", a); }
void foo() { printf("foo called. \n" ); }
int g(int a) { printf("g(%d)\n", a); return a+2; }
int h(clsA* a) { printf("h called: %d\n", a->x); return 0; }
int h2(clsA* a) { printf("h2 called: %d\n", a->x); return 0; }
void v(int n, ...) {
	printf("%d", n);
}

//----------------------------------------------------------------------
int clsA::Add(int a, int& b) { 
	printf("clsA::Add(%d,%d):%d called\n", a,b,a+b);
	return a+b; 
}
void clsA::Add(int a, int b, int c) const { 
	printf("clsA::Add(int,int,int):%d+%d+%d=%d called\n", a,b,c,a+b+c);
}
int clsA::Del(int* a) { printf("obj:Del[int* a=%d]\n", *a); return *a-=2; };
int clsA::Modify(int& a) { printf("obj:Modify[int& a=%d]\n", a); return a*=2; }
void clsA::NoReturn(int a) { printf("obj:NoReturn[a=%d]\n", a); }
void clsA::Complex(clsA* pa) { printf("obj:Complex[clsA*=0x%p, pa->x=%d]\n", (void*)pa, pa->x); }


//----------------------------------------------------------------------
xLB_xodefine(clsAnother);
xLB_xodefine(clsA);
xLB_xodefine(clsB);
xLB_xodefine(clsC);
//----------------------------------------------------------------------------

#define test(L, s) \
	printf("run[\n%s\n]\n", s); \
	luaL_loadstring(L, s); \
	if (lua_pcall(L, 0, LUA_MULTRET, 0)) { \
		printf("%s\n", lua_tostring(L, -1)); \
		lua_pop(L, 1); \
	} \

//----------------------------------------------------------------------------
int main(int argc, char** args) {
	auto L = luaL_newstate();
	luaL_openlibs(L);

	xLB_bindxo<clsAnother>(L);
	clsAnother another;
	xLB_xoglobal<clsAnother>(L, &another, "another");

	xLB_bindxo<clsB>(L);
	xLB_bindxo<clsA>(L);
	xLB_bindxo<clsC>(L);
	clsA obj;
	obj.x = 111;
	xLB_xoglobal<clsA>(L, &obj, "obj");
	clsC objC;
	objC.x = 333;
	objC.y = 100;
	xLB_xoglobal<clsC>(L, &objC, "objC");

	//lua_register(L, "v", (xLB_cfunction<decltype(&v), &v>));
	lua_register(L, "g", (xLB_cfunction<decltype(&g), &g>));
	lua_register(L, "foo", (xLB_cfunction<
				  xLB_cfunction<void (*)(int), &foo>
				, xLB_cfunction<void (*)(), &foo>
				>));

	if (argc>=2) {
		luaL_loadfile(L, args[1]); \
		if (lua_pcall(L, 0, LUA_MULTRET, 0)) { \
			printf("%s\n", lua_tostring(L, -1)); \
			lua_pop(L, 1); \
		}
	}
	lua_close(L);
	return 0;
}

xlb.h

#ifndef _XLB_H
#define _XLB_H

#include <iostream>
#include <vector>
#include <assert.h>
#include <cstring>
#include <tuple>
#include <memory>
#include <type_traits>
#include <array>
#include <unordered_map>
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;
struct xLB_util;

#define luaL_reg luaL_Reg
#define XLB_TRAP_FLAG 0xFF
#define XLB_EXISTS_FLAG 0x1

// 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


/*---------------------------------------------------------------------------
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;
}

template<typename T>
inline T* xLB_getxo(lua_State* L, int index) {
	return xLB_getuserdata<T, xLB_xotrait<T>::meta_name>(L, index);
}
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>
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_typelist
-----------------------------------------------------------------------------*/
template<class...types> struct xLB_typelist {
	static int const size = sizeof...(types);
};

/*---------------------------------------------------------------------------
xLB_creatidxer
-----------------------------------------------------------------------------*/
template<int...> struct xLB_idxer{}; 
template<int...RPI> using xLB_rpi = xLB_idxer<RPI...>; // xLB_idxer alias
using xLB_rier = xLB_idxer<>;

template<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_arginfo
-----------------------------------------------------------------------------*/
struct xLB_arginfo {
	int from = 0;
	int to = 0;
	int type = 0;
};

/*---------------------------------------------------------------------------
xLB_typelist
-----------------------------------------------------------------------------*/
template<class VTER, class FT> struct xLB_typeforge {};

template<class VTER, class R, class Tx, class...A> 
	struct xLB_typeforge<VTER, R(Tx::*)(A...)> {
		using tuple_t = std::tuple<typename VTER::template xLB_tir<A>::type...>;
		using idxer_t = typename xLB_toidxer<A...>::type;
		using vter_arg_t = xLB_typelist<typename VTER::template xLB_tir<A>::type...>;
		using arg_t = xLB_typelist<A...>;
		using return_t = R;
		using obj_t = Tx;
		using arginfo_t = array<xLB_arginfo, sizeof...(A)>;
	};

template<class VTER, class R, class Tx, class...A> 
	struct xLB_typeforge<VTER, R(Tx::*)(A...) const> {
		using tuple_t = std::tuple<typename VTER::template xLB_tir<A>::type...>;
		using idxer_t = typename xLB_toidxer<A...>::type;
		using vter_arg_t = xLB_typelist<typename VTER::template xLB_tir<A>::type...>;
		using arg_t = xLB_typelist<A...>;
		using return_t = R;
		using obj_t = Tx;
		using arginfo_t = array<xLB_arginfo, sizeof...(A)>;
	};

template<class VTER, class R, class...A> 
	struct xLB_typeforge<VTER, R(*)(A...)> {
		using tuple_t = std::tuple<typename VTER::template xLB_tir<A>::type...>;
		using idxer_t = typename xLB_toidxer<A...>::type;
		using vter_arg_t = xLB_typelist<typename VTER::template xLB_tir<A>::type...>;
		using arg_t = xLB_typelist<A...>;
		using return_t = R;
		using obj_t = void;
		using arginfo_t = array<xLB_arginfo, sizeof...(A)>;
	};

/*---------------------------------------------------------------------------
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_util
-----------------------------------------------------------------------------*/
struct xLB_util {
	static void xLB_userdata(lua_State* L, const char* LibName, lua_Number N) {
		luaL_newmetatable(L, LibName); // s: 1(ud), 2(metatable)
		lua_setmetatable(L, -2); // ud.metatable = metatable
	}

	static void newxometatable(lua_State* L, const char* meta, 
			const std::vector<luaL_reg>& rg_meta,
			const std::vector<const char*>& super_names) {
		luaL_newmetatable(L, meta);
		if (1 < rg_meta.size()) {
			luaL_setfuncs(L, &rg_meta.front(), 0);
		}
		// set metatable.metatable to itself
		lua_pushvalue(L, -1);
		lua_setmetatable(L, -2);

		lua_pushstring(L, "xLB_meta");
		lua_pushstring(L, meta);
		lua_rawset(L, -3);
		lua_pushstring(L, "xLB_ancient");
		lua_newtable(L);
		lua_rawset(L, -3);
		lua_pushstring(L, "xLB_super");
		lua_newtable(L);
		for (auto meta_name : super_names) {
			lua_pushstring(L, meta_name);
			lua_pushnumber(L, XLB_EXISTS_FLAG);
			lua_rawset(L, -3);
		}
		lua_rawset(L, -3);
		lua_pop(L, 1); // pop metatable
	}

	static void registertypetable(lua_State* L, const char* type_name, 
			std::vector<luaL_reg>& rg_type, int parent_table_index) {
		if (1 < rg_type.size()) {
			if (parent_table_index != 0) {
				lua_pushstring(L, type_name);
				luaL_newlib(L, &rg_type.front());
				if (parent_table_index < 0) { parent_table_index -= 2; }
				lua_rawset(L, parent_table_index);
			} else {
				luaL_newlib(L, &rg_type.front());
				lua_setglobal(L, type_name);
			}
		}
	}

	static int search_getter(lua_State* L, const char* meta_name,
			std::vector<const char*>& super_names) {
		int nfound = 0;
		for (auto meta_name : super_names) {
			lua_getfield(L, LUA_REGISTRYINDEX, meta_name);
			assert(lua_istable(L, -1));
			lua_pushstring(L, "__index");
			lua_rawget(L, -2);
			lua_pushvalue(L, 1);
			lua_pushvalue(L, 2);
			// Note: manual call __index, instead using lua_gettable
			// since the value one the 1 index must be userdata
			lua_pcall(L, 2, 1, 0); 
			lua_remove(L, -2); // remove metatable
			if (lua_isnil(L, -1)) {
				lua_pop(L, 1);
			} else {
				nfound = 1;
				break;
			}
		}
		return nfound;
	}

	static int search_setter(lua_State* L, const char* meta_name,
			std::vector<const char*>& super_names) {
		int nfound = 0;
		for (auto meta_name : super_names) {
			lua_getfield(L, LUA_REGISTRYINDEX, meta_name);
			assert(lua_istable(L, -1));
			lua_pushstring(L, "__newindex");
			lua_rawget(L, -2);
			lua_remove(L, -2); // remove metatable
			lua_pushvalue(L, 1);
			lua_pushvalue(L, 2);
			lua_pushvalue(L, 3);
			// Notes: push additional argument(XLB_TRAP_FLAG) for __newindex calling
			lua_pushnumber(L, XLB_TRAP_FLAG);
			// Note: manual call __newindex, instead using lua_settable
			// since the value one the 1 index must be userdata
			lua_pcall(L, 4, 1, 0); 
			if (lua_isnil(L, -1)) {
				lua_pop(L, 1);
			} else {
				nfound = 1;
				break;
			}
		}
		return nfound;
	}

	static bool isderiveduserdata(lua_State* L, int index, const char* meta_name) {
		//-1:xLB_super={...}
		std::vector<string> table_names;
		lua_pushnil(L);
		while (lua_next(L, index) != 0) {
			table_names.push_back(string(lua_tostring(L,-2)));
			lua_pop(L, 1);
		}
		while (!table_names.empty()) {
			string table_name = table_names.back();
			table_names.pop_back();
			if (table_name == meta_name) {
				return true;
			} else {
				lua_getfield(L, LUA_REGISTRYINDEX, table_name.c_str());
				lua_pushstring(L, "xLB_super");
				lua_rawget(L, -2);
				if (lua_istable(L, -1)) { 
					auto table_index = lua_gettop(L);
					lua_pushnil(L);
					while (lua_next(L, table_index) != 0) {
						table_names.push_back(string(lua_tostring(L, -2)));
						lua_pop(L, 1);
					}
				}
				lua_pop(L, 2);
			}
		}
		return false;
	}

	static bool dynamic(lua_State* L, int index, const char* meta_name) {
		bool isderived = false;
		if (lua_isuserdata(L, index)) {
			lua_getmetatable(L, index);
			lua_pushstring(L, "xLB_meta");
			lua_rawget(L, -2);
			isderived = (strcmp(meta_name, lua_tostring(L, -1)) == 0);
			lua_pop(L, 1); // pop xLB_meta's value
			if (!isderived) {
				lua_pushstring(L, "xLB_ancient");
				lua_rawget(L, -2);
				if (!lua_istable(L, -1)) {
					lua_pop(L, 1);
					lua_pushstring(L, "xLB_ancient");
					lua_newtable(L);
					lua_rawset(L, -3);
					lua_pushstring(L, "xLB_ancient");
					lua_rawget(L, -2);
				}
				lua_pushstring(L, meta_name);
				lua_rawget(L, -2);
				isderived = !lua_isnil(L, -1);
				lua_pop(L, 2);
				if (!isderived) {
					lua_pushstring(L, "xLB_super");
					lua_rawget(L, -2);
					if (lua_istable(L, -1)) {
						isderived = xLB_util::isderiveduserdata(L, lua_gettop(L), meta_name);
					}
					lua_pop(L, 1); // xLB_super's value
					if (isderived) {
						lua_pushstring(L, "xLB_ancient");
						lua_rawget(L, -2);
						lua_pushstring(L, meta_name);
						lua_pushnumber(L, 1);
						lua_rawset(L, -3);
						lua_pop(L, 1);
					}
				}
			}
			lua_pop(L, 1); // pop metatable
		}
		return isderived;
	}
};


/* 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_util::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_util::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_util::xLB_userdata(L, xLB_xotrait<T>::meta_name, 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;
}

/*---------------------------------------------------------------------------
xLB_getdynamicud
-----------------------------------------------------------------------------*/
template<class T>
inline T* xLB_getdynamicud(lua_State* L, int index) {
	if (xLB_util::dynamic(L, index, xLB_xotrait<T>::meta_name)) {
		auto wp = reinterpret_cast<xLB_ludwrap<T>*>(lua_touserdata(L, index)); // index>0
		return wp->ptr();
	} else {
		return nullptr;
	}
}

/*---------------------------------------------------------------------------
xLB_dfer
function default parameters provider
-----------------------------------------------------------------------------*/
struct xLB_dfer {
	//template<class TUP> struct xLB_tir {
		//static inline int go(TUP& tuple) { return 0; }
	//};
	template<class TUP>
		static inline int go(TUP& tuple) { return 0; }
};

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 int xLB_defaultarguments(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...);
	return sizeof...(DA);
}

/*---------------------------------------------------------------------------
xLB type match
-----------------------------------------------------------------------------*/
#define XLB_AMI_BAD           0x10000000
#define XLB_AMI_DENY          0x10000001
#define XLB_AMI_NONE          0x10000002
#define XLB_AMI_FEW           0x10000003
#define XLB_AMI_TOMUCH        0x10000003
#define XLB_AMI_SAME          0x0
#define XLB_AMI_DEFAULT       0x0
#define XLB_AMI_TRANSLATE     0x1
#define xLB_badtype(tmi) (XLB_AMI_BAD <= (tmi.type_match))
struct xLB_ami {
	int type_match = XLB_AMI_SAME;
	int narg = 0;
	int next_index = 0;
	const char* extmsg = "";
	int top = 0;
	int default_count = 0;
	int arg_count = 0;
	int return_count = 0;
	void* obj = nullptr;
};

/*---------------------------------------------------------------------------
xLB_lver
-----------------------------------------------------------------------------*/
struct xLB_lver {
	template<class TUP_ELE, class V> struct xLB_tir {
		template<class TUP>
		static inline void go(lua_State* L, TUP_ELE& tuple_val, TUP& tuple, xLB_ami& ami) {
			ami.type_match = XLB_AMI_BAD;
			ami.extmsg = "xLB_lver not implemented";
		}
	};
};

template<class Tx>
struct xLB_lver::xLB_tir<Tx*, Tx> {
	template<class TUP>
	static inline void go(lua_State* L, Tx*& tuple_val, TUP& tuple, xLB_ami& ami) {
		auto obj = xLB_getdynamicud<Tx>(L, ami.next_index); // narg==1
		if (obj) {
			tuple_val = obj;
			++ami.next_index;
		} else {
			ami.type_match = XLB_AMI_BAD;
			ami.extmsg = "self invalid";
		}
	}
};

template<class TUP_ELE>
struct xLB_lver::xLB_tir<TUP_ELE, int> {
	template<class TUP>
	static inline void go(lua_State* L, TUP_ELE& tuple_val, TUP& tuple, xLB_ami& ami) {
		auto index = ami.next_index;
		if (lua_isnumber(L, index)) {
			tuple_val = lua_tointeger(L, index);
			++ami.next_index;
		} else {
			ami.type_match = XLB_AMI_BAD;
			ami.extmsg = "integer expected";
		}
	}
};

template<class TUP_ELE>
struct xLB_lver::xLB_tir<TUP_ELE, double> {
	template<class TUP>
	static inline void go(lua_State* L, TUP_ELE& tuple_val, TUP& tuple, xLB_ami& ami) {
		auto index = ami.next_index;
		if (lua_isnumber(L, index)) {
			tuple_val = lua_tonumber(L, index);
			++ami.next_index;
		} else {
			ami.type_match = XLB_AMI_BAD;
			ami.extmsg = "double expected";
		}
	}
};

/*---------------------------------------------------------------------------
xLB_fver
-----------------------------------------------------------------------------*/
template<class LVER, class TUP, class IDXER, class TYPELIST>
struct xLB_fver {};


template<class LVER, class TUP>
struct xLB_fver<LVER, TUP, xLB_idxer<>, xLB_typelist<>> {
	template<class ARGINFO>
	static inline void go(lua_State* L, TUP& tuple, ARGINFO& arginfo, xLB_ami& ami) { 
		if (ami.top >= ami.next_index) {
			ami.type_match = XLB_AMI_TOMUCH;
			ami.extmsg = "too much argument";
		}
	}
};

template<class LVER, class TUP, int narg, int...idxs, class Head, class...Tail>
struct xLB_fver<LVER, TUP, xLB_idxer<narg, idxs...>, xLB_typelist<Head, Tail...>> {
	template<class ARGINFO>
	static inline void go(lua_State* L, TUP& tuple, ARGINFO& arginfo, xLB_ami& ami) {
		if (ami.top >= ami.next_index) {
			ami.narg = narg; // Note:
			auto& ai = arginfo[narg];
			ai.from = ami.next_index;
			ai.type = lua_type(L, ami.next_index);
			LVER::template xLB_tir<typename std::tuple_element<narg, TUP>::type, Head>
					::go(L, std::get<narg>(tuple), tuple, ami);
			ai.to = ami.next_index-1;
		} else { ami.type_match = XLB_AMI_FEW; }

		if (xLB_badtype(ami)) {
			if (ami.type_match == XLB_AMI_FEW) {
				auto stack_remain = (ami.top - (ami.next_index - 1));
				auto arguments_remain = (ami.arg_count - ami.narg);
				if (stack_remain - arguments_remain + ami.default_count >= 0) {
					ami.type_match = XLB_AMI_DEFAULT;
				} else {
					ami.extmsg = "too few argument";
				}
			}
		} else {
			xLB_fver<LVER, TUP, xLB_idxer<idxs...>, xLB_typelist<Tail...>>
				::go(L, tuple, arginfo, ami);
		}
	}
};

/*---------------------------------------------------------------------------
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, int narg, T tuple_val, 
					const xLB_arginfo& ai, int& return_count) {
			static_assert(std::is_pod<T>::value, "xLB_pper is not implemented.\n");
			printf("xLB_pper is not implemented.\n");
			//lua_pushnumber(L, tuple_val); ++return_count; 
		}
	};
};

template<> struct xLB_pper::xLB_tir<int> { 
	static inline void go(lua_State* L, int narg, int tuple_val, 
				const xLB_arginfo& ai, int& return_count) { 
		lua_pushinteger(L, tuple_val); ++return_count; 
	}
};

template<> struct xLB_pper::xLB_tir<const char*> {
	static inline void go(lua_State* L, int narg, const char* tuple_val, 
				const xLB_arginfo& ai, int& return_count) { 
		lua_pushstring(L, tuple_val); ++return_count; 
	}
};

template<> struct xLB_pper::xLB_tir<double> { 
	static inline void go(lua_State* L, int narg, double tuple_val, 
				const xLB_arginfo& ai, int& return_count) { 
		lua_pushnumber(L, tuple_val); ++return_count; 
	}
};

template<> struct xLB_pper::xLB_tir<long> { 
	static inline void go(lua_State* L, int narg, long tuple_val, 
				const xLB_arginfo& ai, int& return_count) { 
		lua_pushnumber(L, tuple_val); ++return_count; 
	}
};

template<> struct xLB_pper::xLB_tir<bool> { 
	static inline void go(lua_State* L, int narg, bool tuple_val, 
				const xLB_arginfo& ai, 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> {
	template<class ARGINFO>
	static inline void go(lua_State* L, std::tuple<A...>& tuple, ARGINFO& arginfo, int& return_count) {
		xLB_each{ 
				(PPER::template xLB_tir<
						typename std::tuple_element<RPI, std::tuple<A...>>::type
					>::go(L, RPI+1, std::get<RPI>(tuple), 
							reinterpret_cast<const xLB_arginfo&>(arginfo[RPI]), 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, int narg, const R& result_of_function, 
					const xLB_arginfo& ai, int& return_count) {
			PPER::template xLB_tir<R>::go(L, narg, result_of_function, ai, return_count);
		}
	};
};

struct xLB_rner_newobj : public xLB_rner { // customize for return wrapper object;
	template<class T, class PPER> struct xLB_tir {
		static inline void go(lua_State* L, int narg, T pobj, const xLB_arginfo& pai, int& return_count) {
			using OBJ_TYPE = typename std::remove_pointer<T>::type;
			xLB_objasud<OBJ_TYPE, xLB_xotrait<OBJ_TYPE>::meta_name>(L, pobj);
			++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<int&> { using type = int; };
template<> struct xLB_vter::xLB_tir<double*> { using type = double; };

/*---------------------------------------------------------------------------
xLB_caler
-----------------------------------------------------------------------------*/
struct xLB_caler {
	template<class R, class Tx, class FT, class IDXER, class VPER, class TYPELIST, class RNER, class PPER> 
		struct xLB_tir {};
};

template<class R, class Tx, class FT, class VPER, class...A, int...idxs, class RNER, class PPER> 
struct xLB_caler::xLB_tir<R, Tx, FT, xLB_idxer<idxs...>, VPER, xLB_typelist<A...>, RNER, PPER> {
	template<class...B> static inline void go(lua_State* L, xLB_ami& ami, FT f, std::tuple<B...>& tuple) {
		R r = (reinterpret_cast<Tx*&>(ami.obj)->*f)(VPER::template xLB_tir<A,B>::go(std::get<idxs>(tuple))...);
		const xLB_arginfo ai;
		RNER::template xLB_tir<R,PPER>::go(L, 0, r, ai, ami.return_count);
	}
};

template<class Tx, class FT, class VPER, class...A, int...idxs, class RNER, class PPER> 
struct xLB_caler::xLB_tir<void, Tx, FT, xLB_idxer<idxs...>, VPER, xLB_typelist<A...>, RNER, PPER> {
	template<class...B> static inline void go(lua_State* L, xLB_ami& ami, FT f, std::tuple<B...>& tuple) {
			(reinterpret_cast<Tx*&>(ami.obj)->*f)(VPER::template xLB_tir<A,B>::go(std::get<idxs>(tuple))...);
		}
};

template<class R, class FT, class VPER, class...A, int...idxs, class RNER, class PPER> 
struct xLB_caler::xLB_tir<R, void, FT, xLB_idxer<idxs...>, VPER, xLB_typelist<A...>, RNER, PPER> {
	template<class...B> static inline void go(lua_State* L, xLB_ami& ami, FT f, std::tuple<B...>& tuple) {
		R r = f(VPER::template xLB_tir<A,B>::go(std::get<idxs>(tuple))...);
		const xLB_arginfo ai;
		RNER::template xLB_tir<R,PPER>::go(L, 0, r, ai, ami.return_count);
	}
};

template<class FT, class VPER, class...A, int...idxs, class RNER, class PPER> 
struct xLB_caler::xLB_tir<void, void, FT, xLB_idxer<idxs...>, VPER, xLB_typelist<A...>, RNER, PPER> {
	template<class...B> static inline void go(lua_State* L, xLB_ami&, FT f, std::tuple<B...>& tuple) {
		f(VPER::template xLB_tir<A,B>::go(std::get<idxs>(tuple))...);
	}
};

/*---------------------------------------------------------------------------
xLB_each_ovlfunc
-----------------------------------------------------------------------------*/
using xLB_ovlfunc = void (*)(lua_State* L, xLB_ami& ami);

template <xLB_ovlfunc... Fs>
struct xLB_each_ovlfunc_impl;

template <xLB_ovlfunc F>
struct xLB_each_ovlfunc_impl<F> {
	static void go(lua_State* L, xLB_ami& ami) {
		ami.type_match = XLB_AMI_SAME;
		F(L, ami);
	}
};

template <xLB_ovlfunc F, xLB_ovlfunc...Fs>
struct xLB_each_ovlfunc_impl<F, Fs...> {
	static inline void go(lua_State* L, xLB_ami& ami) {
		ami.type_match = XLB_AMI_SAME;
		F(L, ami);
		if (xLB_badtype(ami)) {
			xLB_each_ovlfunc_impl<Fs...>::go(L, ami);
		}
	}
};

template <xLB_ovlfunc...Fs>
inline void xLB_each_ovlfunc(lua_State* L, xLB_ami& ami) {
	xLB_each_ovlfunc_impl<Fs...>::go(L, ami);
}

/*---------------------------------------------------------------------------
xLB_loadobj
-----------------------------------------------------------------------------*/
template<class Tx, class LVER>
struct xLB_loadobj {
	template<class TUP, class ARGINFO>
	static inline void go(lua_State* L, TUP& tuple, xLB_ami& ami, ARGINFO& arginfo) {
		if (nullptr == ami.obj) {
			LVER::template xLB_tir<Tx*, Tx>::go(L, reinterpret_cast<Tx*&>(ami.obj), tuple, ami);
		}
	}
};

template<class LVER>
struct xLB_loadobj<void, LVER> {
	template<class TUP, class ARGINFO>
	static inline void go(lua_State*, TUP& tuple, xLB_ami&, ARGINFO& arginfo) {}
};

/*---------------------------------------------------------------------------
xLB_cfunction
overload function
-----------------------------------------------------------------------------*/
template<class FT, FT f, class DFER=xLB_dfer, class RIER=xLB_rier, 
		class PPER=xLB_pper, class RNER=xLB_rner, class PTER=xLB_pter, 
		class VTER=xLB_vter, class LVER=xLB_lver, class VPER=xLB_vper
>
void xLB_cfunction(lua_State* L, xLB_ami& ami) {
	using forge_t = xLB_typeforge<VTER, FT>;
	using tuple_t = typename forge_t::tuple_t;
	using idxer_t = typename forge_t::idxer_t;
	using vter_arg_t = typename forge_t::vter_arg_t;
	using arg_t = typename forge_t::arg_t;
	using return_t = typename forge_t::return_t;
	using obj_t = typename forge_t::obj_t;
	using arginfo_t = typename forge_t::arginfo_t;
	arginfo_t arginfo;
	tuple_t tuple;
	ami.next_index = 1;
	ami.narg = 0;
	xLB_loadobj<obj_t, LVER>::go(L, tuple, ami, arginfo);
	if (!xLB_badtype(ami)) {
		ami.default_count = DFER::go(tuple);
		ami.arg_count = arg_t::size;
		xLB_fver<LVER, tuple_t, idxer_t, vter_arg_t>::go(L, tuple, arginfo, ami);
	}
	ami.return_count = ami.type_match;
	if (!xLB_badtype(ami)) {
		xLB_caler::template xLB_tir<return_t, obj_t, FT, idxer_t, VPER, arg_t, RNER, PPER>
				::go(L, ami, f, tuple);
		PTER::template xLB_tir<RIER, tuple_t, PPER>::go(L, tuple, arginfo, ami.return_count);
	}
}

/*---------------------------------------------------------------------------
xLB_cfunction
overload function
-----------------------------------------------------------------------------*/
template<xLB_ovlfunc F, xLB_ovlfunc...Fs>
int xLB_cfunction(lua_State* L) {
	xLB_ami ami; 
	ami.top = lua_gettop(L);
	ami.obj = nullptr;
	xLB_each_ovlfunc<F, Fs...>(L, ami);
	if (xLB_badtype(ami)) {
		return luaL_argerror(L, ami.next_index, ami.extmsg);
	}
	return ami.return_count;
}

/*---------------------------------------------------------------------------
xLB_cfunction
normal function
-----------------------------------------------------------------------------*/
template<class FT, FT f, 
		class DFER=xLB_dfer,
		class RIER=xLB_rier, 
		class PPER=xLB_pper,
		class RNER=xLB_rner,
		class PTER=xLB_pter,
		class VTER=xLB_vter, 
		class LVER=xLB_lver, 
		class VPER=xLB_vper
> int xLB_cfunction(lua_State* L) {
	using forge_t = xLB_typeforge<VTER, FT>;
	using tuple_t = typename forge_t::tuple_t;
	using idxer_t = typename forge_t::idxer_t;
	using vter_arg_t = typename forge_t::vter_arg_t;
	using arg_t = typename forge_t::arg_t;
	using return_t = typename forge_t::return_t;
	using obj_t = typename forge_t::obj_t;
	using arginfo_t = typename forge_t::arginfo_t;
	arginfo_t arginfo;
	tuple_t tuple;
	xLB_ami ami; 
	ami.top = lua_gettop(L);
	ami.next_index = 1;
	xLB_loadobj<obj_t, LVER>::go(L, tuple, ami, arginfo);
	if (!xLB_badtype(ami)) {
		ami.default_count = DFER::go(tuple);
		ami.arg_count = arg_t::size;
		xLB_fver<LVER, tuple_t, idxer_t, vter_arg_t>::go(L, tuple, arginfo, ami);
	}
	if (xLB_badtype(ami)) {
		return luaL_argerror(L, ami.next_index, ami.extmsg);
	}
	ami.return_count = 0;
	xLB_caler::template xLB_tir<return_t, obj_t, FT,idxer_t,VPER, arg_t, RNER, PPER>
		::go(L, ami, f, tuple);
	PTER::template xLB_tir<RIER,tuple_t,PPER>::go(L, tuple, arginfo, ami.return_count);
	return ami.return_count;
}

/*---------------------------------------------------------------------------
xLB_getter
-----------------------------------------------------------------------------*/
template<class PT> struct xLB_proptype { };
template<class P, class Tx> struct xLB_proptype<P Tx::*> {
	using obj_t = Tx;
	using property_t = P;
};

template<class PT, PT property, class PPER>
int xLB_getter(lua_State* L) { // t,k
	using forge_t = xLB_proptype<PT>;
	using obj_t = typename forge_t::obj_t;
	using property_t = typename forge_t::property_t;
	// use wrapper to get obj pointer
	using wrap_t = xLB_ludwrap<obj_t>;
	auto wrap = reinterpret_cast<wrap_t*>(lua_touserdata(L, 1));
	auto obj = wrap->ptr(); assert(obj != nullptr);
	auto return_count = 0;
	if (obj) {
		xLB_arginfo ai;
		PPER::template xLB_tir<typename std::remove_reference<property_t>::type>
				::go(L, 1, (*obj).*property, ai, return_count);
	} else {
		printf("xLB_getdynamicud failed.\n");
	}
	return return_count;
}

template<class PT, PT property, class VTER, class LVER>
int xLB_setter(lua_State* L) { // t,k,v
	using forge_t = xLB_proptype<PT>;
	using obj_t = typename forge_t::obj_t;
	using property_t = typename forge_t::property_t;
	// use wrapper to get obj pointer
	using wrap_t = xLB_ludwrap<obj_t>;
	auto wrap = reinterpret_cast<wrap_t*>(lua_touserdata(L, 1));
	auto obj = wrap->ptr(); assert(obj != nullptr);
	auto return_count = 0;
	if (obj) {
		xLB_ami ami; 
		ami.top = lua_gettop(L);
		ami.obj = obj;
		ami.next_index = 3;
		using vter_t = typename VTER::template xLB_tir<property_t>::type;
		std::tuple<vter_t> tuple;
		LVER::template xLB_tir<vter_t,
				 property_t>::go(L, std::get<0>(tuple), tuple, ami);
		(*obj).*property = std::get<0>(tuple);
	} else {
		printf("xLB_getdynamicud failed.\n");
	}
	return return_count;
}

/*---------------------------------------------------------------------------
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, int parent_table_index = 0) {
	xLB_xotrait<T>::register_(L, parent_table_index);
}

template<typename T>
void xLB_xoglobal(lua_State* L, T* obj, const char* name) {
	xLB_wrapxo(L, obj);
	lua_setglobal(L, name);
}

/*---------------------------------------------------------------------------
xLB_xomethod
-----------------------------------------------------------------------------*/
template<typename T> struct xLB_xomethod {
	using type = int (*)(lua_State*, T*);
};

template<typename R, typename T, typename... A>
struct xLB_xomethod<R (T::*)(A...) > {
	using type = R(T::*)(A...);
};

template<typename R, typename T, typename... A>
struct xLB_xomethod<R (T::*)(A...) const > {
	using type = R(T::*)(A...) const;
};

template<typename T, typename xLB_xomethod<T>::type f>
int xLB_xomethod_simple(lua_State* L) {
	int rc = 0;
	T* obj = xLB_getxo<T>(L, 1);
	if (obj) rc = f(L, obj);
	return rc;
}


/*---------------------------------------------------------------------------
luavar_info
-----------------------------------------------------------------------------*/
struct luavar_info {
	enum { readonly, readwrite, writeonly, function };
	int type;
	lua_CFunction getter;
	lua_CFunction setter;
};

/*---------------------------------------------------------------------------
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<> std::vector<const char*> xLB_xobase<xo_t>::super_names=std::vector<const char*>(); \
template<> std::vector<luaL_reg> xLB_xobase<xo_t>::rg_type={{nullptr,nullptr}}; \
template<> std::vector<luaL_reg> xLB_xobase<xo_t>::rg_meta={{nullptr,nullptr}}; \
template<> std::unordered_map<string, luavar_info> xLB_xobase<xo_t>::property_map={}; \

#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_xotrait(); \
	}; \
	xLB_xotrait<xo_t>::xLB_xotrait() \


/*---------------------------------------------------------------------------
xLB_xotrait
-----------------------------------------------------------------------------*/
template<typename T> struct xLB_xotrait {};

/*---------------------------------------------------------------------------
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 std::vector<const char*> super_names;
	static regs_t rg_meta;
	static regs_t rg_type;
	static std::unordered_map<string, luavar_info> property_map;

	static inline void regfunc(const char fn[], lua_CFunction f) {
		property_map[fn] = { luavar_info::function, f, nullptr };
	}

	static int index_handler(lua_State* L) { //__index(t,k)
		auto var_name = luaL_optlstring(L, 2, "", nullptr);
		auto iter = property_map.find(var_name);
		int nfound = 0;
		if (iter != property_map.end()) {
			switch (iter->second.type) {
				case luavar_info::readonly:
				case luavar_info::readwrite:
					iter->second.getter(L);
					nfound = 1;
					break;
				case luavar_info::function:
					lua_pushcfunction(L, iter->second.getter);
					nfound = 1;
					break;
			}
		}
		if (0 == nfound) {
			nfound = xLB_util::search_getter(L, meta_name, super_names);
		}
		return nfound;
	}

	static int newindex_handler(lua_State* L) { // __newindex(t,k,v)
		auto var_name = luaL_optlstring(L, 2, "", nullptr);
		auto iter = property_map.find(var_name);
		auto top = lua_gettop(L);
		int nfound = 0;
		if (iter != property_map.end()) {
			switch (iter->second.type) {
				case luavar_info::writeonly:
				case luavar_info::readwrite:
					iter->second.setter(L);
					if (top == 4) { // meant called by search_setter
						lua_pushnumber(L, XLB_TRAP_FLAG);
					}
					nfound = 2;
				break;
			}
		}
		if (0 == nfound) {
			nfound = xLB_util::search_setter(L, meta_name, super_names);
		}
		if (2 == nfound) { // have found it
			if (4 == top) { nfound = 1; }
			else { nfound = 0; }
		} else {
			if (4 == top) { lua_pushnil(L); nfound = 1; }
		}
		return nfound;
	}

	static int tostring_handler(lua_State* L) {
		auto obj = xLB_getdynamicud<T>(L, 1);
		auto return_count = 1;
		if (obj) {
			lua_pushfstring(L, "xLB_object: 0x%p", obj);
		} else {
			lua_getglobal(L, "tostring");
			lua_pushvalue(L, 1);
			lua_pcall(L, 1, 1, 0);
		}
		return return_count;
	}

	template<class SUPER_XO> static void super() { 
		super_names.push_back(xLB_xotrait<SUPER_XO>::meta_name); 
	}

	template<lua_CFunction f> static void c(const char fn[]="new") { 
		rg_type.insert(begin(rg_type), {fn,f});
	}

	template<typename...A> static inline T* xLB_newer(A...arg_metas) { 
		return new T(arg_metas...); 
	}

	static void destructor() { 
		rg_meta.insert(begin(rg_meta), {"__gc", xLB_gcxo<T>});
	}

	template<typename xLB_xomethod<T>::type f> static void b(const char fn[]) { 
		regfunc(fn, xLB_xomethod_simple<T, f>);
	}

	template<lua_CFunction f> static void b(const char fn[]) { regfunc(fn, f); }

	static inline void def(const char fn[], lua_CFunction f) { regfunc(fn, f); }
	static inline void constructor(const char fn[], lua_CFunction f) {
		rg_type.insert(begin(rg_type), {fn, f});
	}
	template<class PT, PT property, class PPER=xLB_pper>
	static inline void def_readonly(const char property_name[]) {
		property_map[property_name] = { luavar_info::readonly, 
				xLB_getter<PT, property, PPER>,
				nullptr,
		};		
	}
	template<class PT, PT property, class PPER=xLB_pper, class VTER=xLB_vter, class LVER=xLB_lver>
	static inline void def_readwrite(const char property_name[]) {
		property_map[property_name] = { luavar_info::readwrite, 
				xLB_getter<PT, property, PPER>,
				xLB_setter<PT, property, VTER, LVER>,
		};		
	}

	static void register_(lua_State* L, int parent_table_index = 0) {
		rg_meta.insert(begin(rg_meta), {"__index", &index_handler});
		rg_meta.insert(begin(rg_meta), {"__newindex", &newindex_handler});
		rg_meta.insert(begin(rg_meta), {"__tostring", &tostring_handler});
		xLB_util::newxometatable(L, meta_name, rg_meta, super_names);
		xLB_util::registertypetable(L, trait_t::type_name, rg_type, parent_table_index);
	}
}; // end of xLB_xobase

#endif // end of __XLB_H__