From 29a1bbb993cf0c6881d9445f79fe4f32336d580c Mon Sep 17 00:00:00 2001 From: Chris Danford Date: Mon, 24 Jan 2005 02:11:23 +0000 Subject: [PATCH] add macros for Lua binding C++ classes --- stepmania/src/LuaBinding.h | 166 +++++++++++++++++++++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 stepmania/src/LuaBinding.h diff --git a/stepmania/src/LuaBinding.h b/stepmania/src/LuaBinding.h new file mode 100644 index 0000000000..afd6cba690 --- /dev/null +++ b/stepmania/src/LuaBinding.h @@ -0,0 +1,166 @@ +/* Based on Lua Wiki example: http://lua-users.org/wiki/SimplerCppBinding + * Modified by Chris. + */ + +#include "lua.h" +#include "lauxlib.h" +#include "LuaManager.h" + + +#define LUA_REGISTER_CLASS( T, base ) \ +class Lua##T { \ +public: \ + Lua##T() { LUA->Register( Register ); } \ + static const char className[]; \ + static Luna::RegType methods[]; \ + static void Register( lua_State* L ) { \ + Luna::Register(L); \ + if( stricmp(#base,"null") != 0 ) \ + LUA->RunScript( "getmetatable("#T").__index = "#base ); \ + } \ + static T* MakeNew( lua_State* L ) { \ + return new T; \ + } \ + LUA_##T##_METHODS( T ) \ +}; \ +static Lua##T registera; \ +const char Lua##T::className[] = #T; \ +Luna::RegType Lua##T::methods[] = { \ + LUA_##T##_METHODS_MAP( T ) \ + {0,0} \ +}; +#define LUA_METHOD_MAP( T, Method ) { #Method, Lua##T::##Method }, + + +template class Luna { + typedef struct { T *pT; } userdataType; +public: + typedef int (*mfp)(T *p, lua_State *L); + typedef struct { const char *name; mfp mfunc; } RegType; + + static void Register(lua_State *L) { + lua_newtable(L); + int methods = lua_gettop(L); + + luaL_newmetatable(L, TInfo::className); + int metatable = lua_gettop(L); + + // store method table in globals so that + // scripts can add functions written in Lua. + lua_pushstring(L, TInfo::className); + lua_pushvalue(L, methods); + lua_settable(L, LUA_GLOBALSINDEX); + + lua_pushliteral(L, "__metatable"); + lua_pushvalue(L, methods); + lua_settable(L, metatable); // hide metatable from Lua getmetatable() + + lua_pushliteral(L, "__index"); + lua_pushvalue(L, methods); + lua_settable(L, metatable); + + lua_pushliteral(L, "__tostring"); + lua_pushcfunction(L, tostring_T); + lua_settable(L, metatable); + + lua_pushliteral(L, "__gc"); + lua_pushcfunction(L, gc_T); + lua_settable(L, metatable); + + lua_newtable(L); // mt for method table + int mt = lua_gettop(L); + lua_pushliteral(L, "__call"); + lua_pushcfunction(L, new_T); + lua_pushliteral(L, "new"); + lua_pushvalue(L, -2); // dup new_T function + lua_settable(L, methods); // add new_T to method table + lua_settable(L, mt); // mt.__call = new_T + lua_setmetatable(L, methods); + + // fill method table with methods from class T + for (RegType *l = TInfo::methods; l->name; l++) { + lua_pushstring(L, l->name); + lua_pushlightuserdata(L, (void*)l); + lua_pushcclosure(L, thunk, 1); + lua_settable(L, methods); + } + + lua_pop(L, 2); // drop metatable and method table + } + + // get userdata from Lua stack and return pointer to T object + static T *check(lua_State *L, int narg) { + userdataType *ud = + static_cast(luaL_checkudata(L, narg, TInfo::className)); + if(!ud) luaL_typerror(L, narg, TInfo::className); + return ud->pT; // pointer to T object + } + +private: + Luna(); // hide default constructor + + // member function dispatcher + static int thunk(lua_State *L) { + // stack has userdata, followed by method args + T *obj = check(L, 1); // get 'self', or if you prefer, 'this' + lua_remove(L, 1); // remove self so member function args start at index 1 + // get member function from upvalue + RegType *l = static_cast(lua_touserdata(L, lua_upvalueindex(1))); + return (*(l->mfunc))(obj,L); // call member function + } + + // create a new T object and + // push onto the Lua stack a userdata containing a pointer to T object + static int new_T(lua_State *L) { + lua_remove(L, 1); // use classname:new(), instead of classname.new() + T *obj = TInfo::MakeNew(L); // call constructor for T objects + userdataType *ud = + static_cast(lua_newuserdata(L, sizeof(userdataType))); + ud->pT = obj; // store pointer to object in userdata + luaL_getmetatable(L, TInfo::className); // lookup metatable in Lua registry + lua_setmetatable(L, -2); + return 1; // userdata containing pointer to T object + } + + // garbage collection metamethod + static int gc_T(lua_State *L) { + userdataType *ud = static_cast(lua_touserdata(L, 1)); + T *obj = ud->pT; + delete obj; // call destructor for T objects + return 0; + } + + static int tostring_T (lua_State *L) { + char buff[32]; + userdataType *ud = static_cast(lua_touserdata(L, 1)); + T *obj = ud->pT; + sprintf(buff, "%p", obj); + lua_pushfstring(L, "%s (%s)", TInfo::className, buff); + return 1; + } +}; + +/* + * (c) 2001-2005 lua-users.org, Chris Danford + * All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, and/or sell copies of the Software, and to permit persons to + * whom the Software is furnished to do so, provided that the above + * copyright notice(s) and this permission notice appear in all copies of + * the Software and that both the above copyright notice(s) and this + * permission notice appear in supporting documentation. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF + * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS + * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT + * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */