diff --git a/lua/tolua/tolua++.h b/lua/tolua/tolua++.h index ee66b0295f..519ee7e4c5 100644 --- a/lua/tolua/tolua++.h +++ b/lua/tolua/tolua++.h @@ -20,20 +20,20 @@ #define TOLUA_API extern #endif -#define TOLUA_VERSION "tolua++-1.0.92" +#define TOLUA_VERSION "tolua++-1.0.93" #ifdef __cplusplus extern "C" { #endif -#define tolua_pushcppstring(x,y) tolua_pushstring(x,y.c_str()) -#define tolua_iscppstring tolua_isstring +#define tolua_pushcppstring(x,y) tolua_pushstring(x,y.c_str()) +#define tolua_iscppstring tolua_isstring -#define tolua_iscppstringarray tolua_isstringarray -#define tolua_pushfieldcppstring(L,lo,idx,s) tolua_pushfieldstring(L, lo, idx, s.c_str()) +#define tolua_iscppstringarray tolua_isstringarray +#define tolua_pushfieldcppstring(L,lo,idx,s) tolua_pushfieldstring(L, lo, idx, s.c_str()) #ifndef TEMPLATE_BIND - #define TEMPLATE_BIND(p) +#define TEMPLATE_BIND(p) #endif #define TOLUA_TEMPLATE_BIND(p) @@ -48,9 +48,9 @@ typedef int lua_Object; struct tolua_Error { - int index; - int array; - const char* type; + int index; + int array; + const char* type; }; typedef struct tolua_Error tolua_Error; @@ -69,19 +69,19 @@ TOLUA_API int tolua_isusertable (lua_State* L, int lo, const char* type, int def TOLUA_API int tolua_isuserdata (lua_State* L, int lo, int def, tolua_Error* err); TOLUA_API int tolua_isusertype (lua_State* L, int lo, const char* type, int def, tolua_Error* err); TOLUA_API int tolua_isvaluearray - (lua_State* L, int lo, int dim, int def, tolua_Error* err); +(lua_State* L, int lo, int dim, int def, tolua_Error* err); TOLUA_API int tolua_isbooleanarray - (lua_State* L, int lo, int dim, int def, tolua_Error* err); +(lua_State* L, int lo, int dim, int def, tolua_Error* err); TOLUA_API int tolua_isnumberarray - (lua_State* L, int lo, int dim, int def, tolua_Error* err); +(lua_State* L, int lo, int dim, int def, tolua_Error* err); TOLUA_API int tolua_isstringarray - (lua_State* L, int lo, int dim, int def, tolua_Error* err); +(lua_State* L, int lo, int dim, int def, tolua_Error* err); TOLUA_API int tolua_istablearray - (lua_State* L, int lo, int dim, int def, tolua_Error* err); +(lua_State* L, int lo, int dim, int def, tolua_Error* err); TOLUA_API int tolua_isuserdataarray - (lua_State* L, int lo, int dim, int def, tolua_Error* err); +(lua_State* L, int lo, int dim, int def, tolua_Error* err); TOLUA_API int tolua_isusertypearray - (lua_State* L, int lo, const char* type, int dim, int def, tolua_Error* err); +(lua_State* L, int lo, const char* type, int dim, int def, tolua_Error* err); TOLUA_API void tolua_open (lua_State* L); @@ -101,7 +101,7 @@ TOLUA_API void tolua_variable (lua_State* L, const char* name, lua_CFunction get TOLUA_API void tolua_array (lua_State* L,const char* name, lua_CFunction get, lua_CFunction set); /* TOLUA_API void tolua_set_call_event(lua_State* L, lua_CFunction func, char* type); */ - TOLUA_API void tolua_addbase(lua_State* L, char* name, char* base); +TOLUA_API void tolua_addbase(lua_State* L, char* name, char* base); TOLUA_API void tolua_pushvalue (lua_State* L, int lo); TOLUA_API void tolua_pushboolean (lua_State* L, int value); @@ -138,14 +138,14 @@ TOLUA_API int class_gc_event (lua_State* L); #ifdef __cplusplus static inline const char* tolua_tocppstring (lua_State* L, int narg, const char* def) { - const char* s = tolua_tostring(L, narg, def); - return s?s:""; + const char* s = tolua_tostring(L, narg, def); + return s?s:""; }; static inline const char* tolua_tofieldcppstring (lua_State* L, int lo, int index, const char* def) { - const char* s = tolua_tofieldstring(L, lo, index, def); - return s?s:""; + const char* s = tolua_tofieldstring(L, lo, index, def); + return s?s:""; }; #else diff --git a/lua/tolua/tolua_event.c b/lua/tolua/tolua_event.c index 8258867b42..b32967d968 100644 --- a/lua/tolua/tolua_event.c +++ b/lua/tolua/tolua_event.c @@ -22,112 +22,112 @@ */ static void storeatubox (lua_State* L, int lo) { - #ifdef LUA_VERSION_NUM - lua_getfenv(L, lo); - if (lua_rawequal(L, -1, TOLUA_NOPEER)) { - lua_pop(L, 1); - lua_newtable(L); - lua_pushvalue(L, -1); - lua_setfenv(L, lo); /* stack: k,v,table */ - }; - lua_insert(L, -3); - lua_settable(L, -3); /* on lua 5.1, we trade the "tolua_peers" lookup for a settable call */ - lua_pop(L, 1); - #else - /* stack: key value (to be stored) */ - lua_pushstring(L,"tolua_peers"); - lua_rawget(L,LUA_REGISTRYINDEX); /* stack: k v ubox */ - lua_pushvalue(L,lo); - lua_rawget(L,-2); /* stack: k v ubox ubox[u] */ - if (!lua_istable(L,-1)) - { - lua_pop(L,1); /* stack: k v ubox */ - lua_newtable(L); /* stack: k v ubox table */ - lua_pushvalue(L,1); - lua_pushvalue(L,-2); /* stack: k v ubox table u table */ - lua_rawset(L,-4); /* stack: k v ubox ubox[u]=table */ - } - lua_insert(L,-4); /* put table before k */ - lua_pop(L,1); /* pop ubox */ - lua_rawset(L,-3); /* store at table */ - lua_pop(L,1); /* pop ubox[u] */ - #endif +#ifdef LUA_VERSION_NUM + lua_getfenv(L, lo); + if (lua_rawequal(L, -1, TOLUA_NOPEER)) { + lua_pop(L, 1); + lua_newtable(L); + lua_pushvalue(L, -1); + lua_setfenv(L, lo); /* stack: k,v,table */ + }; + lua_insert(L, -3); + lua_settable(L, -3); /* on lua 5.1, we trade the "tolua_peers" lookup for a settable call */ + lua_pop(L, 1); +#else + /* stack: key value (to be stored) */ + lua_pushstring(L,"tolua_peers"); + lua_rawget(L,LUA_REGISTRYINDEX); /* stack: k v ubox */ + lua_pushvalue(L,lo); + lua_rawget(L,-2); /* stack: k v ubox ubox[u] */ + if (!lua_istable(L,-1)) + { + lua_pop(L,1); /* stack: k v ubox */ + lua_newtable(L); /* stack: k v ubox table */ + lua_pushvalue(L,1); + lua_pushvalue(L,-2); /* stack: k v ubox table u table */ + lua_rawset(L,-4); /* stack: k v ubox ubox[u]=table */ + } + lua_insert(L,-4); /* put table before k */ + lua_pop(L,1); /* pop ubox */ + lua_rawset(L,-3); /* store at table */ + lua_pop(L,1); /* pop ubox[u] */ +#endif } /* Module index function */ static int module_index_event (lua_State* L) { - lua_pushstring(L,".get"); - lua_rawget(L,-3); - if (lua_istable(L,-1)) - { - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); - if (lua_iscfunction(L,-1)) - { - lua_call(L,0,1); - return 1; - } - else if (lua_istable(L,-1)) - return 1; - } - /* call old index meta event */ - if (lua_getmetatable(L,1)) - { - lua_pushstring(L,"__index"); - lua_rawget(L,-2); - lua_pushvalue(L,1); - lua_pushvalue(L,2); - if (lua_isfunction(L,-1)) - { - lua_call(L,2,1); - return 1; - } - else if (lua_istable(L,-1)) - { - lua_gettable(L,-3); - return 1; - } - } - lua_pushnil(L); - return 1; + lua_pushstring(L,".get"); + lua_rawget(L,-3); + if (lua_istable(L,-1)) + { + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); + if (lua_iscfunction(L,-1)) + { + lua_call(L,0,1); + return 1; + } + else if (lua_istable(L,-1)) + return 1; + } + /* call old index meta event */ + if (lua_getmetatable(L,1)) + { + lua_pushstring(L,"__index"); + lua_rawget(L,-2); + lua_pushvalue(L,1); + lua_pushvalue(L,2); + if (lua_isfunction(L,-1)) + { + lua_call(L,2,1); + return 1; + } + else if (lua_istable(L,-1)) + { + lua_gettable(L,-3); + return 1; + } + } + lua_pushnil(L); + return 1; } /* Module newindex function */ static int module_newindex_event (lua_State* L) { - lua_pushstring(L,".set"); - lua_rawget(L,-4); - if (lua_istable(L,-1)) - { - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); - if (lua_iscfunction(L,-1)) - { - lua_pushvalue(L,1); /* only to be compatible with non-static vars */ - lua_pushvalue(L,3); /* value */ - lua_call(L,2,0); - return 0; - } - } - /* call old newindex meta event */ - if (lua_getmetatable(L,1) && lua_getmetatable(L,-1)) - { - lua_pushstring(L,"__newindex"); - lua_rawget(L,-2); - if (lua_isfunction(L,-1)) - { - lua_pushvalue(L,1); - lua_pushvalue(L,2); - lua_pushvalue(L,3); - lua_call(L,3,0); - } - } - lua_settop(L,3); - lua_rawset(L,-3); - return 0; + lua_pushstring(L,".set"); + lua_rawget(L,-4); + if (lua_istable(L,-1)) + { + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); + if (lua_iscfunction(L,-1)) + { + lua_pushvalue(L,1); /* only to be compatible with non-static vars */ + lua_pushvalue(L,3); /* value */ + lua_call(L,2,0); + return 0; + } + } + /* call old newindex meta event */ + if (lua_getmetatable(L,1) && lua_getmetatable(L,-1)) + { + lua_pushstring(L,"__newindex"); + lua_rawget(L,-2); + if (lua_isfunction(L,-1)) + { + lua_pushvalue(L,1); + lua_pushvalue(L,2); + lua_pushvalue(L,3); + lua_call(L,3,0); + } + } + lua_settop(L,3); + lua_rawset(L,-3); + return 0; } /* Class index function @@ -136,102 +136,102 @@ static int module_newindex_event (lua_State* L) */ static int class_index_event (lua_State* L) { - int t = lua_type(L,1); - if (t == LUA_TUSERDATA) - { - /* Access alternative table */ - #ifdef LUA_VERSION_NUM /* new macro on version 5.1 */ - lua_getfenv(L,1); - if (!lua_rawequal(L, -1, TOLUA_NOPEER)) { - lua_pushvalue(L, 2); /* key */ - lua_gettable(L, -2); /* on lua 5.1, we trade the "tolua_peers" lookup for a gettable call */ - if (!lua_isnil(L, -1)) - return 1; - }; - #else - lua_pushstring(L,"tolua_peers"); - lua_rawget(L,LUA_REGISTRYINDEX); /* stack: obj key ubox */ - lua_pushvalue(L,1); - lua_rawget(L,-2); /* stack: obj key ubox ubox[u] */ - if (lua_istable(L,-1)) - { - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); /* stack: obj key ubox ubox[u] value */ - if (!lua_isnil(L,-1)) - return 1; - } - #endif - lua_settop(L,2); /* stack: obj key */ - /* Try metatables */ - lua_pushvalue(L,1); /* stack: obj key obj */ - while (lua_getmetatable(L,-1)) - { /* stack: obj key obj mt */ - lua_remove(L,-2); /* stack: obj key mt */ - if (lua_isnumber(L,2)) /* check if key is a numeric value */ - { - /* try operator[] */ - lua_pushstring(L,".geti"); - lua_rawget(L,-2); /* stack: obj key mt func */ - if (lua_isfunction(L,-1)) - { - lua_pushvalue(L,1); - lua_pushvalue(L,2); - lua_call(L,2,1); - return 1; - } - } - else - { - lua_pushvalue(L,2); /* stack: obj key mt key */ - lua_rawget(L,-2); /* stack: obj key mt value */ - if (!lua_isnil(L,-1)) - return 1; - else - lua_pop(L,1); - /* try C/C++ variable */ - lua_pushstring(L,".get"); - lua_rawget(L,-2); /* stack: obj key mt tget */ - if (lua_istable(L,-1)) - { - lua_pushvalue(L,2); - lua_rawget(L,-2); /* stack: obj key mt value */ - if (lua_iscfunction(L,-1)) - { - lua_pushvalue(L,1); - lua_pushvalue(L,2); - lua_call(L,2,1); - return 1; - } - else if (lua_istable(L,-1)) - { - /* deal with array: create table to be returned and cache it in ubox */ - void* u = *((void**)lua_touserdata(L,1)); - lua_newtable(L); /* stack: obj key mt value table */ - lua_pushstring(L,".self"); - lua_pushlightuserdata(L,u); - lua_rawset(L,-3); /* store usertype in ".self" */ - lua_insert(L,-2); /* stack: obj key mt table value */ - lua_setmetatable(L,-2); /* set stored value as metatable */ - lua_pushvalue(L,-1); /* stack: obj key met table table */ - lua_pushvalue(L,2); /* stack: obj key mt table table key */ - lua_insert(L,-2); /* stack: obj key mt table key table */ - storeatubox(L,1); /* stack: obj key mt table */ - return 1; - } - } - } - lua_settop(L,3); - } - lua_pushnil(L); - return 1; - } - else if (t== LUA_TTABLE) - { - module_index_event(L); - return 1; - } - lua_pushnil(L); - return 1; + int t = lua_type(L,1); + if (t == LUA_TUSERDATA) + { + /* Access alternative table */ +#ifdef LUA_VERSION_NUM /* new macro on version 5.1 */ + lua_getfenv(L,1); + if (!lua_rawequal(L, -1, TOLUA_NOPEER)) { + lua_pushvalue(L, 2); /* key */ + lua_gettable(L, -2); /* on lua 5.1, we trade the "tolua_peers" lookup for a gettable call */ + if (!lua_isnil(L, -1)) + return 1; + }; +#else + lua_pushstring(L,"tolua_peers"); + lua_rawget(L,LUA_REGISTRYINDEX); /* stack: obj key ubox */ + lua_pushvalue(L,1); + lua_rawget(L,-2); /* stack: obj key ubox ubox[u] */ + if (lua_istable(L,-1)) + { + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); /* stack: obj key ubox ubox[u] value */ + if (!lua_isnil(L,-1)) + return 1; + } +#endif + lua_settop(L,2); /* stack: obj key */ + /* Try metatables */ + lua_pushvalue(L,1); /* stack: obj key obj */ + while (lua_getmetatable(L,-1)) + { /* stack: obj key obj mt */ + lua_remove(L,-2); /* stack: obj key mt */ + if (lua_isnumber(L,2)) /* check if key is a numeric value */ + { + /* try operator[] */ + lua_pushstring(L,".geti"); + lua_rawget(L,-2); /* stack: obj key mt func */ + if (lua_isfunction(L,-1)) + { + lua_pushvalue(L,1); + lua_pushvalue(L,2); + lua_call(L,2,1); + return 1; + } + } + else + { + lua_pushvalue(L,2); /* stack: obj key mt key */ + lua_rawget(L,-2); /* stack: obj key mt value */ + if (!lua_isnil(L,-1)) + return 1; + else + lua_pop(L,1); + /* try C/C++ variable */ + lua_pushstring(L,".get"); + lua_rawget(L,-2); /* stack: obj key mt tget */ + if (lua_istable(L,-1)) + { + lua_pushvalue(L,2); + lua_rawget(L,-2); /* stack: obj key mt value */ + if (lua_iscfunction(L,-1)) + { + lua_pushvalue(L,1); + lua_pushvalue(L,2); + lua_call(L,2,1); + return 1; + } + else if (lua_istable(L,-1)) + { + /* deal with array: create table to be returned and cache it in ubox */ + void* u = *((void**)lua_touserdata(L,1)); + lua_newtable(L); /* stack: obj key mt value table */ + lua_pushstring(L,".self"); + lua_pushlightuserdata(L,u); + lua_rawset(L,-3); /* store usertype in ".self" */ + lua_insert(L,-2); /* stack: obj key mt table value */ + lua_setmetatable(L,-2); /* set stored value as metatable */ + lua_pushvalue(L,-1); /* stack: obj key met table table */ + lua_pushvalue(L,2); /* stack: obj key mt table table key */ + lua_insert(L,-2); /* stack: obj key mt table key table */ + storeatubox(L,1); /* stack: obj key mt table */ + return 1; + } + } + } + lua_settop(L,3); + } + lua_pushnil(L); + return 1; + } + else if (t== LUA_TTABLE) + { + module_index_event(L); + return 1; + } + lua_pushnil(L); + return 1; } /* Newindex function @@ -241,160 +241,160 @@ static int class_index_event (lua_State* L) */ static int class_newindex_event (lua_State* L) { - int t = lua_type(L,1); - if (t == LUA_TUSERDATA) - { - /* Try accessing a C/C++ variable to be set */ - lua_getmetatable(L,1); - while (lua_istable(L,-1)) /* stack: t k v mt */ - { - if (lua_isnumber(L,2)) /* check if key is a numeric value */ - { - /* try operator[] */ - lua_pushstring(L,".seti"); - lua_rawget(L,-2); /* stack: obj key mt func */ - if (lua_isfunction(L,-1)) - { - lua_pushvalue(L,1); - lua_pushvalue(L,2); - lua_pushvalue(L,3); - lua_call(L,3,0); - return 0; - } - } - else - { - lua_pushstring(L,".set"); - lua_rawget(L,-2); /* stack: t k v mt tset */ - if (lua_istable(L,-1)) - { - lua_pushvalue(L,2); - lua_rawget(L,-2); /* stack: t k v mt tset func */ - if (lua_iscfunction(L,-1)) - { - lua_pushvalue(L,1); - lua_pushvalue(L,3); - lua_call(L,2,0); - return 0; - } - lua_pop(L,1); /* stack: t k v mt tset */ - } - lua_pop(L,1); /* stack: t k v mt */ - if (!lua_getmetatable(L,-1)) /* stack: t k v mt mt */ - lua_pushnil(L); - lua_remove(L,-2); /* stack: t k v mt */ - } - } - lua_settop(L,3); /* stack: t k v */ + int t = lua_type(L,1); + if (t == LUA_TUSERDATA) + { + /* Try accessing a C/C++ variable to be set */ + lua_getmetatable(L,1); + while (lua_istable(L,-1)) /* stack: t k v mt */ + { + if (lua_isnumber(L,2)) /* check if key is a numeric value */ + { + /* try operator[] */ + lua_pushstring(L,".seti"); + lua_rawget(L,-2); /* stack: obj key mt func */ + if (lua_isfunction(L,-1)) + { + lua_pushvalue(L,1); + lua_pushvalue(L,2); + lua_pushvalue(L,3); + lua_call(L,3,0); + return 0; + } + } + else + { + lua_pushstring(L,".set"); + lua_rawget(L,-2); /* stack: t k v mt tset */ + if (lua_istable(L,-1)) + { + lua_pushvalue(L,2); + lua_rawget(L,-2); /* stack: t k v mt tset func */ + if (lua_iscfunction(L,-1)) + { + lua_pushvalue(L,1); + lua_pushvalue(L,3); + lua_call(L,2,0); + return 0; + } + lua_pop(L,1); /* stack: t k v mt tset */ + } + lua_pop(L,1); /* stack: t k v mt */ + if (!lua_getmetatable(L,-1)) /* stack: t k v mt mt */ + lua_pushnil(L); + lua_remove(L,-2); /* stack: t k v mt */ + } + } + lua_settop(L,3); /* stack: t k v */ - /* then, store as a new field */ - storeatubox(L,1); - } - else if (t== LUA_TTABLE) - { - module_newindex_event(L); - } - return 0; + /* then, store as a new field */ + storeatubox(L,1); + } + else if (t== LUA_TTABLE) + { + module_newindex_event(L); + } + return 0; } static int class_call_event(lua_State* L) { - if (lua_istable(L, 1)) { - lua_pushstring(L, ".call"); - lua_rawget(L, 1); - if (lua_isfunction(L, -1)) { + if (lua_istable(L, 1)) { + lua_pushstring(L, ".call"); + lua_rawget(L, 1); + if (lua_isfunction(L, -1)) { - lua_insert(L, 1); - lua_call(L, lua_gettop(L)-1, 1); + lua_insert(L, 1); + lua_call(L, lua_gettop(L)-1, 1); - return 1; - }; - }; - tolua_error(L,"Attempt to call a non-callable object.",NULL); - return 0; + return 1; + }; + }; + tolua_error(L,"Attempt to call a non-callable object.",NULL); + return 0; }; static int do_operator (lua_State* L, const char* op) { - if (lua_isuserdata(L,1)) - { - /* Try metatables */ - lua_pushvalue(L,1); /* stack: op1 op2 */ - while (lua_getmetatable(L,-1)) - { /* stack: op1 op2 op1 mt */ - lua_remove(L,-2); /* stack: op1 op2 mt */ - lua_pushstring(L,op); /* stack: op1 op2 mt key */ - lua_rawget(L,-2); /* stack: obj key mt func */ - if (lua_isfunction(L,-1)) - { - lua_pushvalue(L,1); - lua_pushvalue(L,2); - lua_call(L,2,1); - return 1; - } - lua_settop(L,3); - } - } - tolua_error(L,"Attempt to perform operation on an invalid operand",NULL); - return 0; + if (lua_isuserdata(L,1)) + { + /* Try metatables */ + lua_pushvalue(L,1); /* stack: op1 op2 */ + while (lua_getmetatable(L,-1)) + { /* stack: op1 op2 op1 mt */ + lua_remove(L,-2); /* stack: op1 op2 mt */ + lua_pushstring(L,op); /* stack: op1 op2 mt key */ + lua_rawget(L,-2); /* stack: obj key mt func */ + if (lua_isfunction(L,-1)) + { + lua_pushvalue(L,1); + lua_pushvalue(L,2); + lua_call(L,2,1); + return 1; + } + lua_settop(L,3); + } + } + tolua_error(L,"Attempt to perform operation on an invalid operand",NULL); + return 0; } static int class_add_event (lua_State* L) { - return do_operator(L,".add"); + return do_operator(L,".add"); } static int class_sub_event (lua_State* L) { - return do_operator(L,".sub"); + return do_operator(L,".sub"); } static int class_mul_event (lua_State* L) { - return do_operator(L,".mul"); + return do_operator(L,".mul"); } static int class_div_event (lua_State* L) { - return do_operator(L,".div"); + return do_operator(L,".div"); } static int class_lt_event (lua_State* L) { - return do_operator(L,".lt"); + return do_operator(L,".lt"); } static int class_le_event (lua_State* L) { - return do_operator(L,".le"); + return do_operator(L,".le"); } static int class_eq_event (lua_State* L) { - /* copying code from do_operator here to return false when no operator is found */ - if (lua_isuserdata(L,1)) - { - /* Try metatables */ - lua_pushvalue(L,1); /* stack: op1 op2 */ - while (lua_getmetatable(L,-1)) - { /* stack: op1 op2 op1 mt */ - lua_remove(L,-2); /* stack: op1 op2 mt */ - lua_pushstring(L,".eq"); /* stack: op1 op2 mt key */ - lua_rawget(L,-2); /* stack: obj key mt func */ - if (lua_isfunction(L,-1)) - { - lua_pushvalue(L,1); - lua_pushvalue(L,2); - lua_call(L,2,1); - return 1; - } - lua_settop(L,3); - } - } + /* copying code from do_operator here to return false when no operator is found */ + if (lua_isuserdata(L,1)) + { + /* Try metatables */ + lua_pushvalue(L,1); /* stack: op1 op2 */ + while (lua_getmetatable(L,-1)) + { /* stack: op1 op2 op1 mt */ + lua_remove(L,-2); /* stack: op1 op2 mt */ + lua_pushstring(L,".eq"); /* stack: op1 op2 mt key */ + lua_rawget(L,-2); /* stack: obj key mt func */ + if (lua_isfunction(L,-1)) + { + lua_pushvalue(L,1); + lua_pushvalue(L,2); + lua_call(L,2,1); + return 1; + } + lua_settop(L,3); + } + } - lua_settop(L, 3); - lua_pushboolean(L, 0); - return 1; + lua_settop(L, 3); + lua_pushboolean(L, 0); + return 1; } /* @@ -420,43 +420,43 @@ static int class_gc_event (lua_State* L) */ TOLUA_API int class_gc_event (lua_State* L) { - void* u = *((void**)lua_touserdata(L,1)); - int top; - /*fprintf(stderr, "collecting: looking at %p\n", u);*/ - /* - lua_pushstring(L,"tolua_gc"); - lua_rawget(L,LUA_REGISTRYINDEX); - */ - lua_pushvalue(L, lua_upvalueindex(1)); - lua_pushlightuserdata(L,u); - lua_rawget(L,-2); /* stack: gc umt */ - lua_getmetatable(L,1); /* stack: gc umt mt */ - /*fprintf(stderr, "checking type\n");*/ - top = lua_gettop(L); - if (tolua_fast_isa(L,top,top-1, lua_upvalueindex(2))) /* make sure we collect correct type */ - { - /*fprintf(stderr, "Found type!\n");*/ - /* get gc function */ - lua_pushliteral(L,".collector"); - lua_rawget(L,-2); /* stack: gc umt mt collector */ - if (lua_isfunction(L,-1)) { - /*fprintf(stderr, "Found .collector!\n");*/ - } - else { - lua_pop(L,1); - /*fprintf(stderr, "Using default cleanup\n");*/ - lua_pushcfunction(L,tolua_default_collect); - } + void* u = *((void**)lua_touserdata(L,1)); + int top; + /*fprintf(stderr, "collecting: looking at %p\n", u);*/ + /* + lua_pushstring(L,"tolua_gc"); + lua_rawget(L,LUA_REGISTRYINDEX); + */ + lua_pushvalue(L, lua_upvalueindex(1)); + lua_pushlightuserdata(L,u); + lua_rawget(L,-2); /* stack: gc umt */ + lua_getmetatable(L,1); /* stack: gc umt mt */ + /*fprintf(stderr, "checking type\n");*/ + top = lua_gettop(L); + if (tolua_fast_isa(L,top,top-1, lua_upvalueindex(2))) /* make sure we collect correct type */ + { + /*fprintf(stderr, "Found type!\n");*/ + /* get gc function */ + lua_pushliteral(L,".collector"); + lua_rawget(L,-2); /* stack: gc umt mt collector */ + if (lua_isfunction(L,-1)) { + /*fprintf(stderr, "Found .collector!\n");*/ + } + else { + lua_pop(L,1); + /*fprintf(stderr, "Using default cleanup\n");*/ + lua_pushcfunction(L,tolua_default_collect); + } - lua_pushvalue(L,1); /* stack: gc umt mt collector u */ - lua_call(L,1,0); + lua_pushvalue(L,1); /* stack: gc umt mt collector u */ + lua_call(L,1,0); - lua_pushlightuserdata(L,u); /* stack: gc umt mt u */ - lua_pushnil(L); /* stack: gc umt mt u nil */ - lua_rawset(L,-5); /* stack: gc umt mt */ - } - lua_pop(L,3); - return 0; + lua_pushlightuserdata(L,u); /* stack: gc umt mt u */ + lua_pushnil(L); /* stack: gc umt mt u nil */ + lua_rawset(L,-5); /* stack: gc umt mt */ + } + lua_pop(L,3); + return 0; } @@ -465,27 +465,27 @@ TOLUA_API int class_gc_event (lua_State* L) */ TOLUA_API void tolua_moduleevents (lua_State* L) { - lua_pushstring(L,"__index"); - lua_pushcfunction(L,module_index_event); - lua_rawset(L,-3); - lua_pushstring(L,"__newindex"); - lua_pushcfunction(L,module_newindex_event); - lua_rawset(L,-3); + lua_pushstring(L,"__index"); + lua_pushcfunction(L,module_index_event); + lua_rawset(L,-3); + lua_pushstring(L,"__newindex"); + lua_pushcfunction(L,module_newindex_event); + lua_rawset(L,-3); } /* Check if the object on the top has a module metatable */ TOLUA_API int tolua_ismodulemetatable (lua_State* L) { - int r = 0; - if (lua_getmetatable(L,-1)) - { - lua_pushstring(L,"__index"); - lua_rawget(L,-2); - r = (lua_tocfunction(L,-1) == module_index_event); - lua_pop(L,2); - } - return r; + int r = 0; + if (lua_getmetatable(L,-1)) + { + lua_pushstring(L,"__index"); + lua_rawget(L,-2); + r = (lua_tocfunction(L,-1) == module_index_event); + lua_pop(L,2); + } + return r; } /* Register class events @@ -493,44 +493,44 @@ TOLUA_API int tolua_ismodulemetatable (lua_State* L) */ TOLUA_API void tolua_classevents (lua_State* L) { - lua_pushstring(L,"__index"); - lua_pushcfunction(L,class_index_event); - lua_rawset(L,-3); - lua_pushstring(L,"__newindex"); - lua_pushcfunction(L,class_newindex_event); - lua_rawset(L,-3); + lua_pushstring(L,"__index"); + lua_pushcfunction(L,class_index_event); + lua_rawset(L,-3); + lua_pushstring(L,"__newindex"); + lua_pushcfunction(L,class_newindex_event); + lua_rawset(L,-3); - lua_pushstring(L,"__add"); - lua_pushcfunction(L,class_add_event); - lua_rawset(L,-3); - lua_pushstring(L,"__sub"); - lua_pushcfunction(L,class_sub_event); - lua_rawset(L,-3); - lua_pushstring(L,"__mul"); - lua_pushcfunction(L,class_mul_event); - lua_rawset(L,-3); - lua_pushstring(L,"__div"); - lua_pushcfunction(L,class_div_event); - lua_rawset(L,-3); + lua_pushstring(L,"__add"); + lua_pushcfunction(L,class_add_event); + lua_rawset(L,-3); + lua_pushstring(L,"__sub"); + lua_pushcfunction(L,class_sub_event); + lua_rawset(L,-3); + lua_pushstring(L,"__mul"); + lua_pushcfunction(L,class_mul_event); + lua_rawset(L,-3); + lua_pushstring(L,"__div"); + lua_pushcfunction(L,class_div_event); + lua_rawset(L,-3); - lua_pushstring(L,"__lt"); - lua_pushcfunction(L,class_lt_event); - lua_rawset(L,-3); - lua_pushstring(L,"__le"); - lua_pushcfunction(L,class_le_event); - lua_rawset(L,-3); - lua_pushstring(L,"__eq"); - lua_pushcfunction(L,class_eq_event); - lua_rawset(L,-3); + lua_pushstring(L,"__lt"); + lua_pushcfunction(L,class_lt_event); + lua_rawset(L,-3); + lua_pushstring(L,"__le"); + lua_pushcfunction(L,class_le_event); + lua_rawset(L,-3); + lua_pushstring(L,"__eq"); + lua_pushcfunction(L,class_eq_event); + lua_rawset(L,-3); - lua_pushstring(L,"__call"); - lua_pushcfunction(L,class_call_event); - lua_rawset(L,-3); + lua_pushstring(L,"__call"); + lua_pushcfunction(L,class_call_event); + lua_rawset(L,-3); - lua_pushstring(L,"__gc"); - lua_pushstring(L, "tolua_gc_event"); - lua_rawget(L, LUA_REGISTRYINDEX); - /*lua_pushcfunction(L,class_gc_event);*/ - lua_rawset(L,-3); + lua_pushstring(L,"__gc"); + lua_pushstring(L, "tolua_gc_event"); + lua_rawget(L, LUA_REGISTRYINDEX); + /*lua_pushcfunction(L,class_gc_event);*/ + lua_rawset(L,-3); } diff --git a/lua/tolua/tolua_is.c b/lua/tolua/tolua_is.c index add337d19a..a5fdc4e29a 100644 --- a/lua/tolua/tolua_is.c +++ b/lua/tolua/tolua_is.c @@ -22,600 +22,600 @@ i.e. if b is equal to a or a superclass of a. */ TOLUA_API int tolua_fast_isa(lua_State *L, int mt_indexa, int mt_indexb, int super_index) { - int result; - if (lua_rawequal(L,mt_indexa,mt_indexb)) - result = 1; - else - { - if (super_index) { - lua_pushvalue(L, super_index); - } else { - lua_pushliteral(L,"tolua_super"); - lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super */ - }; - lua_pushvalue(L,mt_indexa); /* stack: super mta */ - lua_rawget(L,-2); /* stack: super super[mta] */ - lua_pushvalue(L,mt_indexb); /* stack: super super[mta] mtb */ - lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super super[mta] typenameB */ - lua_rawget(L,-2); /* stack: super super[mta] bool */ - result = lua_toboolean(L,-1); - lua_pop(L,3); - } - return result; + int result; + if (lua_rawequal(L,mt_indexa,mt_indexb)) + result = 1; + else + { + if (super_index) { + lua_pushvalue(L, super_index); + } else { + lua_pushliteral(L,"tolua_super"); + lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super */ + }; + lua_pushvalue(L,mt_indexa); /* stack: super mta */ + lua_rawget(L,-2); /* stack: super super[mta] */ + lua_pushvalue(L,mt_indexb); /* stack: super super[mta] mtb */ + lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super super[mta] typenameB */ + lua_rawget(L,-2); /* stack: super super[mta] bool */ + result = lua_toboolean(L,-1); + lua_pop(L,3); + } + return result; } /* Push and returns the corresponding object typename */ TOLUA_API const char* tolua_typename (lua_State* L, int lo) { - int tag = lua_type(L,lo); - if (tag == LUA_TNONE) - lua_pushstring(L,"[no object]"); - else if (tag != LUA_TUSERDATA && tag != LUA_TTABLE) - lua_pushstring(L,lua_typename(L,tag)); - else if (tag == LUA_TUSERDATA) - { - if (!lua_getmetatable(L,lo)) - lua_pushstring(L,lua_typename(L,tag)); - else - { - lua_rawget(L,LUA_REGISTRYINDEX); - if (!lua_isstring(L,-1)) - { - lua_pop(L,1); - lua_pushstring(L,"[undefined]"); - } - } - } - else /* is table */ - { - lua_pushvalue(L,lo); - lua_rawget(L,LUA_REGISTRYINDEX); - if (!lua_isstring(L,-1)) - { - lua_pop(L,1); - lua_pushstring(L,"table"); - } - else - { - lua_pushstring(L,"class "); - lua_insert(L,-2); - lua_concat(L,2); - } - } - return lua_tostring(L,-1); + int tag = lua_type(L,lo); + if (tag == LUA_TNONE) + lua_pushstring(L,"[no object]"); + else if (tag != LUA_TUSERDATA && tag != LUA_TTABLE) + lua_pushstring(L,lua_typename(L,tag)); + else if (tag == LUA_TUSERDATA) + { + if (!lua_getmetatable(L,lo)) + lua_pushstring(L,lua_typename(L,tag)); + else + { + lua_rawget(L,LUA_REGISTRYINDEX); + if (!lua_isstring(L,-1)) + { + lua_pop(L,1); + lua_pushstring(L,"[undefined]"); + } + } + } + else /* is table */ + { + lua_pushvalue(L,lo); + lua_rawget(L,LUA_REGISTRYINDEX); + if (!lua_isstring(L,-1)) + { + lua_pop(L,1); + lua_pushstring(L,"table"); + } + else + { + lua_pushstring(L,"class "); + lua_insert(L,-2); + lua_concat(L,2); + } + } + return lua_tostring(L,-1); } TOLUA_API void tolua_error (lua_State* L, const char* msg, tolua_Error* err) { - if (msg[0] == '#') - { - const char* expected = err->type; - const char* provided = tolua_typename(L,err->index); - if (msg[1]=='f') - { - int narg = err->index; - if (err->array) - luaL_error(L,"%s\n argument #%d is array of '%s'; array of '%s' expected.\n", - msg+2,narg,provided,expected); - else - luaL_error(L,"%s\n argument #%d is '%s'; '%s' expected.\n", - msg+2,narg,provided,expected); - } - else if (msg[1]=='v') - { - if (err->array) - luaL_error(L,"%s\n value is array of '%s'; array of '%s' expected.\n", - msg+2,provided,expected); - else - luaL_error(L,"%s\n value is '%s'; '%s' expected.\n", - msg+2,provided,expected); - } - } - else - luaL_error(L,msg); + if (msg[0] == '#') + { + const char* expected = err->type; + const char* provided = tolua_typename(L,err->index); + if (msg[1]=='f') + { + int narg = err->index; + if (err->array) + luaL_error(L,"%s\n argument #%d is array of '%s'; array of '%s' expected.\n", + msg+2,narg,provided,expected); + else + luaL_error(L,"%s\n argument #%d is '%s'; '%s' expected.\n", + msg+2,narg,provided,expected); + } + else if (msg[1]=='v') + { + if (err->array) + luaL_error(L,"%s\n value is array of '%s'; array of '%s' expected.\n", + msg+2,provided,expected); + else + luaL_error(L,"%s\n value is '%s'; '%s' expected.\n", + msg+2,provided,expected); + } + } + else + luaL_error(L,msg); } /* the equivalent of lua_is* for usertable */ static int lua_isusertable (lua_State* L, int lo, const const char* type) { - int r = 0; - if (lo < 0) lo = lua_gettop(L)+lo+1; - lua_pushvalue(L,lo); - lua_rawget(L,LUA_REGISTRYINDEX); /* get registry[t] */ - if (lua_isstring(L,-1)) - { - r = strcmp(lua_tostring(L,-1),type)==0; - if (!r) - { - /* try const */ - lua_pushstring(L,"const "); - lua_insert(L,-2); - lua_concat(L,2); - r = lua_isstring(L,-1) && strcmp(lua_tostring(L,-1),type)==0; - } - } - lua_pop(L, 1); - return r; + int r = 0; + if (lo < 0) lo = lua_gettop(L)+lo+1; + lua_pushvalue(L,lo); + lua_rawget(L,LUA_REGISTRYINDEX); /* get registry[t] */ + if (lua_isstring(L,-1)) + { + r = strcmp(lua_tostring(L,-1),type)==0; + if (!r) + { + /* try const */ + lua_pushstring(L,"const "); + lua_insert(L,-2); + lua_concat(L,2); + r = lua_isstring(L,-1) && strcmp(lua_tostring(L,-1),type)==0; + } + } + lua_pop(L, 1); + return r; } int push_table_instance(lua_State* L, int lo) { - if (lua_istable(L, lo)) { + if (lua_istable(L, lo)) { - lua_pushstring(L, ".c_instance"); - lua_gettable(L, lo); - if (lua_isuserdata(L, -1)) { + lua_pushstring(L, ".c_instance"); + lua_gettable(L, lo); + if (lua_isuserdata(L, -1)) { - lua_replace(L, lo); - return 1; - } else { + lua_replace(L, lo); + return 1; + } else { - lua_pop(L, 1); - return 0; - }; - } else { - return 0; - }; + lua_pop(L, 1); + return 0; + }; + } else { + return 0; + }; - return 0; + return 0; }; /* the equivalent of lua_is* for usertype */ static int lua_isusertype (lua_State* L, int lo, const char* type) { - if (!lua_isuserdata(L,lo)) { - if (!push_table_instance(L, lo)) { - return 0; - }; - }; - { - /* check if it is of the same type */ - int r; - const char *tn; - if (lua_getmetatable(L,lo)) /* if metatable? */ - { - lua_rawget(L,LUA_REGISTRYINDEX); /* get registry[mt] */ - tn = lua_tostring(L,-1); - r = tn && (strcmp(tn,type) == 0); - lua_pop(L, 1); - if (r) - return 1; - else - { - /* check if it is a specialized class */ - lua_pushstring(L,"tolua_super"); - lua_rawget(L,LUA_REGISTRYINDEX); /* get super */ - lua_getmetatable(L,lo); - lua_rawget(L,-2); /* get super[mt] */ - if (lua_istable(L,-1)) - { - int b; - lua_pushstring(L,type); - lua_rawget(L,-2); /* get super[mt][type] */ - b = lua_toboolean(L,-1); - lua_pop(L,3); - if (b) - return 1; - } - } - } - } - return 0; + if (!lua_isuserdata(L,lo)) { + if (!push_table_instance(L, lo)) { + return 0; + }; + }; + { + /* check if it is of the same type */ + int r; + const char *tn; + if (lua_getmetatable(L,lo)) /* if metatable? */ + { + lua_rawget(L,LUA_REGISTRYINDEX); /* get registry[mt] */ + tn = lua_tostring(L,-1); + r = tn && (strcmp(tn,type) == 0); + lua_pop(L, 1); + if (r) + return 1; + else + { + /* check if it is a specialized class */ + lua_pushstring(L,"tolua_super"); + lua_rawget(L,LUA_REGISTRYINDEX); /* get super */ + lua_getmetatable(L,lo); + lua_rawget(L,-2); /* get super[mt] */ + if (lua_istable(L,-1)) + { + int b; + lua_pushstring(L,type); + lua_rawget(L,-2); /* get super[mt][type] */ + b = lua_toboolean(L,-1); + lua_pop(L,3); + if (b) + return 1; + } + } + } + } + return 0; } TOLUA_API int tolua_isnoobj (lua_State* L, int lo, tolua_Error* err) { - if (lua_gettop(L)index = lo; - err->array = 0; - err->type = "[no object]"; - return 0; + if (lua_gettop(L)index = lo; + err->array = 0; + err->type = "[no object]"; + return 0; } TOLUA_API int tolua_isboolean (lua_State* L, int lo, int def, tolua_Error* err) { - if (def && lua_gettop(L)index = lo; - err->array = 0; - err->type = "boolean"; - return 0; + if (def && lua_gettop(L)index = lo; + err->array = 0; + err->type = "boolean"; + return 0; } TOLUA_API int tolua_isnumber (lua_State* L, int lo, int def, tolua_Error* err) { - if (def && lua_gettop(L)index = lo; - err->array = 0; - err->type = "number"; - return 0; + if (def && lua_gettop(L)index = lo; + err->array = 0; + err->type = "number"; + return 0; } TOLUA_API int tolua_isstring (lua_State* L, int lo, int def, tolua_Error* err) { - if (def && lua_gettop(L)index = lo; - err->array = 0; - err->type = "string"; - return 0; + if (def && lua_gettop(L)index = lo; + err->array = 0; + err->type = "string"; + return 0; } TOLUA_API int tolua_istable (lua_State* L, int lo, int def, tolua_Error* err) { - if (def && lua_gettop(L)index = lo; - err->array = 0; - err->type = "table"; - return 0; + if (def && lua_gettop(L)index = lo; + err->array = 0; + err->type = "table"; + return 0; } TOLUA_API int tolua_isusertable (lua_State* L, int lo, const char* type, int def, tolua_Error* err) { - if (def && lua_gettop(L)index = lo; - err->array = 0; - err->type = type; - return 0; + if (def && lua_gettop(L)index = lo; + err->array = 0; + err->type = type; + return 0; } TOLUA_API int tolua_isuserdata (lua_State* L, int lo, int def, tolua_Error* err) { - if (def && lua_gettop(L)index = lo; - err->array = 0; - err->type = "userdata"; - return 0; + if (def && lua_gettop(L)index = lo; + err->array = 0; + err->type = "userdata"; + return 0; } TOLUA_API int tolua_isvaluenil (lua_State* L, int lo, tolua_Error* err) { - if (lua_gettop(L)index = lo; - err->array = 0; - err->type = "value"; - return 1; + if (lua_gettop(L)index = lo; + err->array = 0; + err->type = "value"; + return 1; }; TOLUA_API int tolua_isvalue (lua_State* L, int lo, int def, tolua_Error* err) { - if (def || abs(lo)<=lua_gettop(L)) /* any valid index */ - return 1; - err->index = lo; - err->array = 0; - err->type = "value"; - return 0; + if (def || abs(lo)<=lua_gettop(L)) /* any valid index */ + return 1; + err->index = lo; + err->array = 0; + err->type = "value"; + return 0; } TOLUA_API int tolua_isusertype (lua_State* L, int lo, const char* type, int def, tolua_Error* err) { - if (def && lua_gettop(L)index = lo; - err->array = 0; - err->type = type; - return 0; + if (def && lua_gettop(L)index = lo; + err->array = 0; + err->type = type; + return 0; } TOLUA_API int tolua_isvaluearray - (lua_State* L, int lo, int dim, int def, tolua_Error* err) +(lua_State* L, int lo, int dim, int def, tolua_Error* err) { - if (!tolua_istable(L,lo,def,err)) - return 0; - else - return 1; + if (!tolua_istable(L,lo,def,err)) + return 0; + else + return 1; } TOLUA_API int tolua_isbooleanarray - (lua_State* L, int lo, int dim, int def, tolua_Error* err) +(lua_State* L, int lo, int dim, int def, tolua_Error* err) { - if (!tolua_istable(L,lo,def,err)) - return 0; - else - { - int i; - for (i=1; i<=dim; ++i) - { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!(lua_isnil(L,-1) || lua_isboolean(L,-1)) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "boolean"; - return 0; - } - lua_pop(L,1); - } - } - return 1; + if (!tolua_istable(L,lo,def,err)) + return 0; + else + { + int i; + for (i=1; i<=dim; ++i) + { + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!(lua_isnil(L,-1) || lua_isboolean(L,-1)) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "boolean"; + return 0; + } + lua_pop(L,1); + } + } + return 1; } TOLUA_API int tolua_isnumberarray - (lua_State* L, int lo, int dim, int def, tolua_Error* err) +(lua_State* L, int lo, int dim, int def, tolua_Error* err) { - if (!tolua_istable(L,lo,def,err)) - return 0; - else - { - int i; - for (i=1; i<=dim; ++i) - { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!lua_isnumber(L,-1) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "number"; - return 0; - } - lua_pop(L,1); - } - } - return 1; + if (!tolua_istable(L,lo,def,err)) + return 0; + else + { + int i; + for (i=1; i<=dim; ++i) + { + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!lua_isnumber(L,-1) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "number"; + return 0; + } + lua_pop(L,1); + } + } + return 1; } TOLUA_API int tolua_isstringarray - (lua_State* L, int lo, int dim, int def, tolua_Error* err) +(lua_State* L, int lo, int dim, int def, tolua_Error* err) { - if (!tolua_istable(L,lo,def,err)) - return 0; - else - { - int i; - for (i=1; i<=dim; ++i) - { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!(lua_isnil(L,-1) || lua_isstring(L,-1)) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "string"; - return 0; - } - lua_pop(L,1); - } - } - return 1; + if (!tolua_istable(L,lo,def,err)) + return 0; + else + { + int i; + for (i=1; i<=dim; ++i) + { + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!(lua_isnil(L,-1) || lua_isstring(L,-1)) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "string"; + return 0; + } + lua_pop(L,1); + } + } + return 1; } TOLUA_API int tolua_istablearray - (lua_State* L, int lo, int dim, int def, tolua_Error* err) +(lua_State* L, int lo, int dim, int def, tolua_Error* err) { - if (!tolua_istable(L,lo,def,err)) - return 0; - else - { - int i; - for (i=1; i<=dim; ++i) - { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (! lua_istable(L,-1) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "table"; - return 0; - } - lua_pop(L,1); - } - } - return 1; + if (!tolua_istable(L,lo,def,err)) + return 0; + else + { + int i; + for (i=1; i<=dim; ++i) + { + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (! lua_istable(L,-1) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "table"; + return 0; + } + lua_pop(L,1); + } + } + return 1; } TOLUA_API int tolua_isuserdataarray - (lua_State* L, int lo, int dim, int def, tolua_Error* err) +(lua_State* L, int lo, int dim, int def, tolua_Error* err) { - if (!tolua_istable(L,lo,def,err)) - return 0; - else - { - int i; - for (i=1; i<=dim; ++i) - { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "userdata"; - return 0; - } - lua_pop(L,1); - } - } - return 1; + if (!tolua_istable(L,lo,def,err)) + return 0; + else + { + int i; + for (i=1; i<=dim; ++i) + { + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "userdata"; + return 0; + } + lua_pop(L,1); + } + } + return 1; } TOLUA_API int tolua_isusertypearray - (lua_State* L, int lo, const char* type, int dim, int def, tolua_Error* err) +(lua_State* L, int lo, const char* type, int dim, int def, tolua_Error* err) { - if (!tolua_istable(L,lo,def,err)) - return 0; - else - { - int i; - for (i=1; i<=dim; ++i) - { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->type = type; - err->array = 1; - return 0; - } - lua_pop(L,1); - } - } - return 1; + if (!tolua_istable(L,lo,def,err)) + return 0; + else + { + int i; + for (i=1; i<=dim; ++i) + { + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->type = type; + err->array = 1; + return 0; + } + lua_pop(L,1); + } + } + return 1; } #if 0 int tolua_isbooleanfield - (lua_State* L, int lo, int i, int def, tolua_Error* err) +(lua_State* L, int lo, int i, int def, tolua_Error* err) { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!(lua_isnil(L,-1) || lua_isboolean(L,-1)) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "boolean"; - return 0; - } - lua_pop(L,1); - return 1; + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!(lua_isnil(L,-1) || lua_isboolean(L,-1)) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "boolean"; + return 0; + } + lua_pop(L,1); + return 1; } int tolua_isnumberfield - (lua_State* L, int lo, int i, int def, tolua_Error* err) +(lua_State* L, int lo, int i, int def, tolua_Error* err) { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!lua_isnumber(L,-1) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "number"; - return 0; - } - lua_pop(L,1); - return 1; + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!lua_isnumber(L,-1) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "number"; + return 0; + } + lua_pop(L,1); + return 1; } int tolua_isstringfield - (lua_State* L, int lo, int i, int def, tolua_Error* err) +(lua_State* L, int lo, int i, int def, tolua_Error* err) { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!(lua_isnil(L,-1) || lua_isstring(L,-1)) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "string"; - return 0; - } - lua_pop(L,1); - return 1; + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!(lua_isnil(L,-1) || lua_isstring(L,-1)) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "string"; + return 0; + } + lua_pop(L,1); + return 1; } int tolua_istablefield - (lua_State* L, int lo, int i, int def, tolua_Error* err) +(lua_State* L, int lo, int i, int def, tolua_Error* err) { - lua_pushnumber(L,i+1); - lua_gettable(L,lo); - if (! lua_istable(L,-1) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "table"; - return 0; - } - lua_pop(L,1); + lua_pushnumber(L,i+1); + lua_gettable(L,lo); + if (! lua_istable(L,-1) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "table"; + return 0; + } + lua_pop(L,1); } int tolua_isusertablefield - (lua_State* L, int lo, const char* type, int i, int def, tolua_Error* err) +(lua_State* L, int lo, const char* type, int i, int def, tolua_Error* err) { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (! lua_isusertable(L,-1,type) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = type; - return 0; - } - lua_pop(L,1); - return 1; + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (! lua_isusertable(L,-1,type) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = type; + return 0; + } + lua_pop(L,1); + return 1; } int tolua_isuserdatafield - (lua_State* L, int lo, int i, int def, tolua_Error* err) +(lua_State* L, int lo, int i, int def, tolua_Error* err) { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->array = 1; - err->type = "userdata"; - return 0; - } - lua_pop(L,1); - return 1; + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!(lua_isnil(L,-1) || lua_isuserdata(L,-1)) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->array = 1; + err->type = "userdata"; + return 0; + } + lua_pop(L,1); + return 1; } int tolua_isusertypefield - (lua_State* L, int lo, const char* type, int i, int def, tolua_Error* err) +(lua_State* L, int lo, const char* type, int i, int def, tolua_Error* err) { - lua_pushnumber(L,i); - lua_gettable(L,lo); - if (!(lua_isnil(L,-1) || lua_isusertype(L,-1,type)) && - !(def && lua_isnil(L,-1)) - ) - { - err->index = lo; - err->type = type; - err->array = 1; - return 0; - } - lua_pop(L,1); - return 1; + lua_pushnumber(L,i); + lua_gettable(L,lo); + if (!(lua_isnil(L,-1) || lua_isusertype(L,-1,type)) && + !(def && lua_isnil(L,-1)) + ) + { + err->index = lo; + err->type = type; + err->array = 1; + return 0; + } + lua_pop(L,1); + return 1; } #endif diff --git a/lua/tolua/tolua_map.c b/lua/tolua/tolua_map.c index af40b6f51a..f4058dcef8 100644 --- a/lua/tolua/tolua_map.c +++ b/lua/tolua/tolua_map.c @@ -25,22 +25,22 @@ /* Create metatable * Create and register new metatable */ -static int tolua_newmetatable (lua_State* L, char* name) +static int tolua_newmetatable (lua_State* L, const char* name) { - int r = luaL_newmetatable(L,name); + int r = luaL_newmetatable(L,name); - #ifdef LUA_VERSION_NUM /* only lua 5.1 */ - if (r) { - lua_pushvalue(L, -1); - lua_pushstring(L, name); - lua_settable(L, LUA_REGISTRYINDEX); /* reg[mt] = type_name */ - }; - #endif +#ifdef LUA_VERSION_NUM /* only lua 5.1 */ + if (r) { + lua_pushvalue(L, -1); + lua_pushstring(L, name); + lua_settable(L, LUA_REGISTRYINDEX); /* reg[mt] = type_name */ + }; +#endif - if (r) - tolua_classevents(L); /* set meta events */ - lua_pop(L,1); - return r; + if (r) + tolua_classevents(L); /* set meta events */ + lua_pop(L,1); + return r; } /* Map super classes @@ -48,72 +48,76 @@ static int tolua_newmetatable (lua_State* L, char* name) */ static void mapsuper (lua_State* L, const char* name, const char* base) { - /* push registry.super */ - lua_pushstring(L,"tolua_super"); - lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super */ - luaL_getmetatable(L,name); /* stack: super mt */ - lua_rawget(L,-2); /* stack: super table */ - if (lua_isnil(L,-1)) - { - /* create table */ - lua_pop(L,1); - lua_newtable(L); /* stack: super table */ - luaL_getmetatable(L,name); /* stack: super table mt */ - lua_pushvalue(L,-2); /* stack: super table mt table */ - lua_rawset(L,-4); /* stack: super table */ - } + /* push registry.super */ + lua_pushstring(L,"tolua_super"); + lua_rawget(L,LUA_REGISTRYINDEX); /* stack: super */ + luaL_getmetatable(L,name); /* stack: super mt */ + lua_rawget(L,-2); /* stack: super table */ + if (lua_isnil(L,-1)) + { + /* create table */ + lua_pop(L,1); + lua_newtable(L); /* stack: super table */ + luaL_getmetatable(L,name); /* stack: super table mt */ + lua_pushvalue(L,-2); /* stack: super table mt table */ + lua_rawset(L,-4); /* stack: super table */ + } - /* set base as super class */ - lua_pushstring(L,base); - lua_pushboolean(L,1); - lua_rawset(L,-3); /* stack: super table */ + /* set base as super class */ + lua_pushstring(L,base); + lua_pushboolean(L,1); + lua_rawset(L,-3); /* stack: super table */ - /* set all super class of base as super class of name */ - luaL_getmetatable(L,base); /* stack: super table base_mt */ - lua_rawget(L,-3); /* stack: super table base_table */ - if (lua_istable(L,-1)) - { - /* traverse base table */ - lua_pushnil(L); /* first key */ - while (lua_next(L,-2) != 0) - { - /* stack: ... base_table key value */ - lua_pushvalue(L,-2); /* stack: ... base_table key value key */ - lua_insert(L,-2); /* stack: ... base_table key key value */ - lua_rawset(L,-5); /* stack: ... base_table key */ - } - } - lua_pop(L,3); /* stack: */ + /* set all super class of base as super class of name */ + luaL_getmetatable(L,base); /* stack: super table base_mt */ + lua_rawget(L,-3); /* stack: super table base_table */ + if (lua_istable(L,-1)) + { + /* traverse base table */ + lua_pushnil(L); /* first key */ + while (lua_next(L,-2) != 0) + { + /* stack: ... base_table key value */ + lua_pushvalue(L,-2); /* stack: ... base_table key value key */ + lua_insert(L,-2); /* stack: ... base_table key key value */ + lua_rawset(L,-5); /* stack: ... base_table key */ + } + } + lua_pop(L,3); /* stack: */ } /* creates a 'tolua_ubox' table for base clases, and // expects the metatable and base metatable on the stack */ static void set_ubox(lua_State* L) { - /* mt basemt */ - if (!lua_isnil(L, -1)) { - lua_pushstring(L, "tolua_ubox"); - lua_rawget(L,-2); - } else { - lua_pushnil(L); - }; - /* mt basemt base_ubox */ - if (!lua_isnil(L,-1)) { - lua_pushstring(L, "tolua_ubox"); - lua_insert(L, -2); - /* mt basemt key ubox */ - lua_rawset(L,-4); - /* (mt with ubox) basemt */ - } else { - /* mt basemt nil */ - lua_pop(L, 1); - lua_pushstring(L,"tolua_ubox"); lua_newtable(L); - /* make weak value metatable for ubox table to allow userdata to be - garbage-collected */ - lua_newtable(L); lua_pushliteral(L, "__mode"); lua_pushliteral(L, "v"); lua_rawset(L, -3); /* stack: string ubox mt */ - lua_setmetatable(L, -2); /* stack:mt basemt string ubox */ - lua_rawset(L,-4); - }; + /* mt basemt */ + if (!lua_isnil(L, -1)) { + lua_pushstring(L, "tolua_ubox"); + lua_rawget(L,-2); + } else { + lua_pushnil(L); + }; + /* mt basemt base_ubox */ + if (!lua_isnil(L,-1)) { + lua_pushstring(L, "tolua_ubox"); + lua_insert(L, -2); + /* mt basemt key ubox */ + lua_rawset(L,-4); + /* (mt with ubox) basemt */ + } else { + /* mt basemt nil */ + lua_pop(L, 1); + lua_pushstring(L,"tolua_ubox"); + lua_newtable(L); + /* make weak value metatable for ubox table to allow userdata to be + garbage-collected */ + lua_newtable(L); + lua_pushliteral(L, "__mode"); + lua_pushliteral(L, "v"); + lua_rawset(L, -3); /* stack: string ubox mt */ + lua_setmetatable(L, -2); /* stack:mt basemt string ubox */ + lua_rawset(L,-4); + }; }; @@ -122,87 +126,87 @@ static void set_ubox(lua_State* L) { */ static void mapinheritance (lua_State* L, const char* name, const char* base) { - /* set metatable inheritance */ - luaL_getmetatable(L,name); + /* set metatable inheritance */ + luaL_getmetatable(L,name); - if (base && *base) - luaL_getmetatable(L,base); - else { + if (base && *base) + luaL_getmetatable(L,base); + else { - if (lua_getmetatable(L, -1)) { /* already has a mt, we don't overwrite it */ - lua_pop(L, 2); - return; - }; - luaL_getmetatable(L,"tolua_commonclass"); - }; + if (lua_getmetatable(L, -1)) { /* already has a mt, we don't overwrite it */ + lua_pop(L, 2); + return; + }; + luaL_getmetatable(L,"tolua_commonclass"); + }; - set_ubox(L); + set_ubox(L); - lua_setmetatable(L,-2); - lua_pop(L,1); + lua_setmetatable(L,-2); + lua_pop(L,1); } /* Object type */ static int tolua_bnd_type (lua_State* L) { - tolua_typename(L,lua_gettop(L)); - return 1; + tolua_typename(L,lua_gettop(L)); + return 1; } /* Take ownership */ static int tolua_bnd_takeownership (lua_State* L) { - int success = 0; - if (lua_isuserdata(L,1)) - { - if (lua_getmetatable(L,1)) /* if metatable? */ - { - lua_pop(L,1); /* clear metatable off stack */ - /* force garbage collection to avoid C to reuse a to-be-collected address */ - #ifdef LUA_VERSION_NUM - lua_gc(L, LUA_GCCOLLECT, 0); - #else - lua_setgcthreshold(L,0); - #endif + int success = 0; + if (lua_isuserdata(L,1)) + { + if (lua_getmetatable(L,1)) /* if metatable? */ + { + lua_pop(L,1); /* clear metatable off stack */ + /* force garbage collection to avoid C to reuse a to-be-collected address */ +#ifdef LUA_VERSION_NUM + lua_gc(L, LUA_GCCOLLECT, 0); +#else + lua_setgcthreshold(L,0); +#endif - success = tolua_register_gc(L,1); - } - } - lua_pushboolean(L,success!=0); - return 1; + success = tolua_register_gc(L,1); + } + } + lua_pushboolean(L,success!=0); + return 1; } /* Release ownership */ static int tolua_bnd_releaseownership (lua_State* L) { - int done = 0; - if (lua_isuserdata(L,1)) - { - void* u = *((void**)lua_touserdata(L,1)); - /* force garbage collection to avoid releasing a to-be-collected address */ - #ifdef LUA_VERSION_NUM - lua_gc(L, LUA_GCCOLLECT, 0); - #else - lua_setgcthreshold(L,0); - #endif - lua_pushstring(L,"tolua_gc"); - lua_rawget(L,LUA_REGISTRYINDEX); - lua_pushlightuserdata(L,u); - lua_rawget(L,-2); - lua_getmetatable(L,1); - if (lua_rawequal(L,-1,-2)) /* check that we are releasing the correct type */ - { - lua_pushlightuserdata(L,u); - lua_pushnil(L); - lua_rawset(L,-5); - done = 1; - } - } - lua_pushboolean(L,done!=0); - return 1; + int done = 0; + if (lua_isuserdata(L,1)) + { + void* u = *((void**)lua_touserdata(L,1)); + /* force garbage collection to avoid releasing a to-be-collected address */ +#ifdef LUA_VERSION_NUM + lua_gc(L, LUA_GCCOLLECT, 0); +#else + lua_setgcthreshold(L,0); +#endif + lua_pushstring(L,"tolua_gc"); + lua_rawget(L,LUA_REGISTRYINDEX); + lua_pushlightuserdata(L,u); + lua_rawget(L,-2); + lua_getmetatable(L,1); + if (lua_rawequal(L,-1,-2)) /* check that we are releasing the correct type */ + { + lua_pushlightuserdata(L,u); + lua_pushnil(L); + lua_rawset(L,-5); + done = 1; + } + } + lua_pushboolean(L,done!=0); + return 1; } /* Type casting @@ -210,73 +214,73 @@ static int tolua_bnd_releaseownership (lua_State* L) static int tolua_bnd_cast (lua_State* L) { -/* // old code - void* v = tolua_tousertype(L,1,NULL); - const char* s = tolua_tostring(L,2,NULL); - if (v && s) - tolua_pushusertype(L,v,s); - else - lua_pushnil(L); - return 1; -*/ + /* // old code + void* v = tolua_tousertype(L,1,NULL); + const char* s = tolua_tostring(L,2,NULL); + if (v && s) + tolua_pushusertype(L,v,s); + else + lua_pushnil(L); + return 1; + */ - void* v; - const char* s; - if (lua_islightuserdata(L, 1)) { - v = tolua_touserdata(L, 1, NULL); - } else { - v = tolua_tousertype(L, 1, 0); - }; + void* v; + const char* s; + if (lua_islightuserdata(L, 1)) { + v = tolua_touserdata(L, 1, NULL); + } else { + v = tolua_tousertype(L, 1, 0); + }; - s = tolua_tostring(L,2,NULL); - if (v && s) - tolua_pushusertype(L,v,s); - else - lua_pushnil(L); - return 1; + s = tolua_tostring(L,2,NULL); + if (v && s) + tolua_pushusertype(L,v,s); + else + lua_pushnil(L); + return 1; } /* Inheritance */ static int tolua_bnd_inherit (lua_State* L) { - /* stack: lua object, c object */ - lua_pushstring(L, ".c_instance"); - lua_pushvalue(L, -2); - lua_rawset(L, -4); - /* l_obj[".c_instance"] = c_obj */ + /* stack: lua object, c object */ + lua_pushstring(L, ".c_instance"); + lua_pushvalue(L, -2); + lua_rawset(L, -4); + /* l_obj[".c_instance"] = c_obj */ - return 0; + return 0; }; #ifdef LUA_VERSION_NUM /* lua 5.1 */ static int tolua_bnd_setpeer(lua_State* L) { - /* stack: userdata, table */ - if (!lua_isuserdata(L, -2)) { - lua_pushstring(L, "Invalid argument #1 to setpeer: userdata expected."); - lua_error(L); - }; - - if (lua_isnil(L, -1)) { + /* stack: userdata, table */ + if (!lua_isuserdata(L, -2)) { + lua_pushstring(L, "Invalid argument #1 to setpeer: userdata expected."); + lua_error(L); + }; - lua_pop(L, 1); - lua_pushvalue(L, TOLUA_NOPEER); - }; - lua_setfenv(L, -2); + if (lua_isnil(L, -1)) { - return 0; + lua_pop(L, 1); + lua_pushvalue(L, TOLUA_NOPEER); + }; + lua_setfenv(L, -2); + + return 0; }; static int tolua_bnd_getpeer(lua_State* L) { - /* stack: userdata */ - lua_getfenv(L, -1); - if (lua_rawequal(L, -1, TOLUA_NOPEER)) { - lua_pop(L, 1); - lua_pushnil(L); - }; - return 1; + /* stack: userdata */ + lua_getfenv(L, -1); + if (lua_rawequal(L, -1, TOLUA_NOPEER)) { + lua_pop(L, 1); + lua_pushnil(L); + }; + return 1; }; #endif @@ -284,105 +288,124 @@ static int tolua_bnd_getpeer(lua_State* L) { TOLUA_API void tolua_open (lua_State* L) { - int top = lua_gettop(L); - lua_pushstring(L,"tolua_opened"); - lua_rawget(L,LUA_REGISTRYINDEX); - if (!lua_isboolean(L,-1)) - { - lua_pushstring(L,"tolua_opened"); lua_pushboolean(L,1); lua_rawset(L,LUA_REGISTRYINDEX); + int top = lua_gettop(L); + lua_pushstring(L,"tolua_opened"); + lua_rawget(L,LUA_REGISTRYINDEX); + if (!lua_isboolean(L,-1)) + { + lua_pushstring(L,"tolua_opened"); + lua_pushboolean(L,1); + lua_rawset(L,LUA_REGISTRYINDEX); - #ifndef LUA_VERSION_NUM /* only prior to lua 5.1 */ - /* create peer object table */ - lua_pushstring(L, "tolua_peers"); lua_newtable(L); - /* make weak key metatable for peers indexed by userdata object */ - lua_newtable(L); lua_pushliteral(L, "__mode"); lua_pushliteral(L, "k"); lua_rawset(L, -3); /* stack: string peers mt */ - lua_setmetatable(L, -2); /* stack: string peers */ - lua_rawset(L,LUA_REGISTRYINDEX); - #endif +#ifndef LUA_VERSION_NUM /* only prior to lua 5.1 */ + /* create peer object table */ + lua_pushstring(L, "tolua_peers"); + lua_newtable(L); + /* make weak key metatable for peers indexed by userdata object */ + lua_newtable(L); + lua_pushliteral(L, "__mode"); + lua_pushliteral(L, "k"); + lua_rawset(L, -3); /* stack: string peers mt */ + lua_setmetatable(L, -2); /* stack: string peers */ + lua_rawset(L,LUA_REGISTRYINDEX); +#endif - /* create object ptr -> udata mapping table */ - lua_pushstring(L,"tolua_ubox"); lua_newtable(L); - /* make weak value metatable for ubox table to allow userdata to be - garbage-collected */ - lua_newtable(L); lua_pushliteral(L, "__mode"); lua_pushliteral(L, "v"); lua_rawset(L, -3); /* stack: string ubox mt */ - lua_setmetatable(L, -2); /* stack: string ubox */ - lua_rawset(L,LUA_REGISTRYINDEX); + /* create object ptr -> udata mapping table */ + lua_pushstring(L,"tolua_ubox"); + lua_newtable(L); + /* make weak value metatable for ubox table to allow userdata to be + garbage-collected */ + lua_newtable(L); + lua_pushliteral(L, "__mode"); + lua_pushliteral(L, "v"); + lua_rawset(L, -3); /* stack: string ubox mt */ + lua_setmetatable(L, -2); /* stack: string ubox */ + lua_rawset(L,LUA_REGISTRYINDEX); + +// /* create object ptr -> class type mapping table */ +// lua_pushstring(L, "tolua_ptr2type"); +// lua_newtable(L); +// lua_rawset(L, LUA_REGISTRYINDEX); - lua_pushstring(L,"tolua_super"); lua_newtable(L); lua_rawset(L,LUA_REGISTRYINDEX); - lua_pushstring(L,"tolua_gc"); lua_newtable(L);lua_rawset(L,LUA_REGISTRYINDEX); + lua_pushstring(L,"tolua_super"); + lua_newtable(L); + lua_rawset(L,LUA_REGISTRYINDEX); + lua_pushstring(L,"tolua_gc"); + lua_newtable(L); + lua_rawset(L,LUA_REGISTRYINDEX); - /* create gc_event closure */ - lua_pushstring(L, "tolua_gc_event"); - lua_pushstring(L, "tolua_gc"); - lua_rawget(L, LUA_REGISTRYINDEX); - lua_pushstring(L, "tolua_super"); - lua_rawget(L, LUA_REGISTRYINDEX); - lua_pushcclosure(L, class_gc_event, 2); - lua_rawset(L, LUA_REGISTRYINDEX); + /* create gc_event closure */ + lua_pushstring(L, "tolua_gc_event"); + lua_pushstring(L, "tolua_gc"); + lua_rawget(L, LUA_REGISTRYINDEX); + lua_pushstring(L, "tolua_super"); + lua_rawget(L, LUA_REGISTRYINDEX); + lua_pushcclosure(L, class_gc_event, 2); + lua_rawset(L, LUA_REGISTRYINDEX); - tolua_newmetatable(L,"tolua_commonclass"); + tolua_newmetatable(L,"tolua_commonclass"); - tolua_module(L,NULL,0); - tolua_beginmodule(L,NULL); - tolua_module(L,"tolua",0); - tolua_beginmodule(L,"tolua"); - tolua_function(L,"type",tolua_bnd_type); - tolua_function(L,"takeownership",tolua_bnd_takeownership); - tolua_function(L,"releaseownership",tolua_bnd_releaseownership); - tolua_function(L,"cast",tolua_bnd_cast); - tolua_function(L,"inherit", tolua_bnd_inherit); - #ifdef LUA_VERSION_NUM /* lua 5.1 */ - tolua_function(L, "setpeer", tolua_bnd_setpeer); - tolua_function(L, "getpeer", tolua_bnd_getpeer); - #endif + tolua_module(L,NULL,0); + tolua_beginmodule(L,NULL); + tolua_module(L,"tolua",0); + tolua_beginmodule(L,"tolua"); + tolua_function(L,"type",tolua_bnd_type); + tolua_function(L,"takeownership",tolua_bnd_takeownership); + tolua_function(L,"releaseownership",tolua_bnd_releaseownership); + tolua_function(L,"cast",tolua_bnd_cast); + tolua_function(L,"inherit", tolua_bnd_inherit); +#ifdef LUA_VERSION_NUM /* lua 5.1 */ + tolua_function(L, "setpeer", tolua_bnd_setpeer); + tolua_function(L, "getpeer", tolua_bnd_getpeer); +#endif - tolua_endmodule(L); - tolua_endmodule(L); - } - lua_settop(L,top); + tolua_endmodule(L); + tolua_endmodule(L); + } + lua_settop(L,top); } /* Copy a C object */ TOLUA_API void* tolua_copy (lua_State* L, void* value, unsigned int size) { - void* clone = (void*)malloc(size); - if (clone) - memcpy(clone,value,size); - else - tolua_error(L,"insuficient memory",NULL); - return clone; + void* clone = (void*)malloc(size); + if (clone) + memcpy(clone,value,size); + else + tolua_error(L,"insuficient memory",NULL); + return clone; } /* Default collect function */ TOLUA_API int tolua_default_collect (lua_State* tolua_S) { - void* self = tolua_tousertype(tolua_S,1,0); - free(self); - return 0; + void* self = tolua_tousertype(tolua_S,1,0); + free(self); + return 0; } /* Do clone */ TOLUA_API int tolua_register_gc (lua_State* L, int lo) { - int success = 1; - void *value = *(void **)lua_touserdata(L,lo); - lua_pushstring(L,"tolua_gc"); - lua_rawget(L,LUA_REGISTRYINDEX); - lua_pushlightuserdata(L,value); - lua_rawget(L,-2); - if (!lua_isnil(L,-1)) /* make sure that object is not already owned */ - success = 0; - else - { - lua_pushlightuserdata(L,value); - lua_getmetatable(L,lo); - lua_rawset(L,-4); - } - lua_pop(L,2); - return success; + int success = 1; + void *value = *(void **)lua_touserdata(L,lo); + lua_pushstring(L,"tolua_gc"); + lua_rawget(L,LUA_REGISTRYINDEX); + lua_pushlightuserdata(L,value); + lua_rawget(L,-2); + if (!lua_isnil(L,-1)) /* make sure that object is not already owned */ + success = 0; + else + { + lua_pushlightuserdata(L,value); + lua_getmetatable(L,lo); + lua_rawset(L,-4); + } + lua_pop(L,2); + return success; } /* Register a usertype @@ -391,12 +414,12 @@ TOLUA_API int tolua_register_gc (lua_State* L, int lo) */ TOLUA_API void tolua_usertype (lua_State* L, const char* type) { - char ctype[128] = "const "; - strncat(ctype,type,120); + char ctype[128] = "const "; + strncat(ctype,type,120); - /* create both metatables */ - if (tolua_newmetatable(L,ctype) && tolua_newmetatable(L,type)) - mapsuper(L,type,ctype); /* 'type' is also a 'const type' */ + /* create both metatables */ + if (tolua_newmetatable(L,ctype) && tolua_newmetatable(L,type)) + mapsuper(L,type,ctype); /* 'type' is also a 'const type' */ } @@ -405,13 +428,13 @@ TOLUA_API void tolua_usertype (lua_State* L, const char* type) */ TOLUA_API void tolua_beginmodule (lua_State* L, const char* name) { - if (name) - { - lua_pushstring(L,name); - lua_rawget(L,-2); - } - else - lua_pushvalue(L,LUA_GLOBALSINDEX); + if (name) + { + lua_pushstring(L,name); + lua_rawget(L,-2); + } + else + lua_pushvalue(L,LUA_GLOBALSINDEX); } /* End module @@ -419,7 +442,7 @@ TOLUA_API void tolua_beginmodule (lua_State* L, const char* name) */ TOLUA_API void tolua_endmodule (lua_State* L) { - lua_pop(L,1); + lua_pop(L,1); } /* Map module @@ -428,91 +451,91 @@ TOLUA_API void tolua_endmodule (lua_State* L) #if 1 TOLUA_API void tolua_module (lua_State* L, const char* name, int hasvar) { - if (name) - { - /* tolua module */ - lua_pushstring(L,name); - lua_rawget(L,-2); - if (!lua_istable(L,-1)) /* check if module already exists */ - { - lua_pop(L,1); - lua_newtable(L); - lua_pushstring(L,name); - lua_pushvalue(L,-2); - lua_rawset(L,-4); /* assing module into module */ - } - } - else - { - /* global table */ - lua_pushvalue(L,LUA_GLOBALSINDEX); - } - if (hasvar) - { - if (!tolua_ismodulemetatable(L)) /* check if it already has a module metatable */ - { - /* create metatable to get/set C/C++ variable */ - lua_newtable(L); - tolua_moduleevents(L); - if (lua_getmetatable(L,-2)) - lua_setmetatable(L,-2); /* set old metatable as metatable of metatable */ - lua_setmetatable(L,-2); - } - } - lua_pop(L,1); /* pop module */ + if (name) + { + /* tolua module */ + lua_pushstring(L,name); + lua_rawget(L,-2); + if (!lua_istable(L,-1)) /* check if module already exists */ + { + lua_pop(L,1); + lua_newtable(L); + lua_pushstring(L,name); + lua_pushvalue(L,-2); + lua_rawset(L,-4); /* assing module into module */ + } + } + else + { + /* global table */ + lua_pushvalue(L,LUA_GLOBALSINDEX); + } + if (hasvar) + { + if (!tolua_ismodulemetatable(L)) /* check if it already has a module metatable */ + { + /* create metatable to get/set C/C++ variable */ + lua_newtable(L); + tolua_moduleevents(L); + if (lua_getmetatable(L,-2)) + lua_setmetatable(L,-2); /* set old metatable as metatable of metatable */ + lua_setmetatable(L,-2); + } + } + lua_pop(L,1); /* pop module */ } #else TOLUA_API void tolua_module (lua_State* L, const char* name, int hasvar) { - if (name) - { - /* tolua module */ - lua_pushstring(L,name); - lua_newtable(L); - } - else - { - /* global table */ - lua_pushvalue(L,LUA_GLOBALSINDEX); - } - if (hasvar) - { - /* create metatable to get/set C/C++ variable */ - lua_newtable(L); - tolua_moduleevents(L); - if (lua_getmetatable(L,-2)) - lua_setmetatable(L,-2); /* set old metatable as metatable of metatable */ - lua_setmetatable(L,-2); - } - if (name) - lua_rawset(L,-3); /* assing module into module */ - else - lua_pop(L,1); /* pop global table */ + if (name) + { + /* tolua module */ + lua_pushstring(L,name); + lua_newtable(L); + } + else + { + /* global table */ + lua_pushvalue(L,LUA_GLOBALSINDEX); + } + if (hasvar) + { + /* create metatable to get/set C/C++ variable */ + lua_newtable(L); + tolua_moduleevents(L); + if (lua_getmetatable(L,-2)) + lua_setmetatable(L,-2); /* set old metatable as metatable of metatable */ + lua_setmetatable(L,-2); + } + if (name) + lua_rawset(L,-3); /* assing module into module */ + else + lua_pop(L,1); /* pop global table */ } #endif static void push_collector(lua_State* L, const char* type, lua_CFunction col) { - /* push collector function, but only if it's not NULL, or if there's no - collector already */ - if (!col) return; - luaL_getmetatable(L,type); - lua_pushstring(L,".collector"); - /* - if (!col) { - lua_pushvalue(L, -1); - lua_rawget(L, -3); - if (!lua_isnil(L, -1)) { - lua_pop(L, 3); - return; - }; - lua_pop(L, 1); - }; - // */ - lua_pushcfunction(L,col); + /* push collector function, but only if it's not NULL, or if there's no + collector already */ + if (!col) return; + luaL_getmetatable(L,type); + lua_pushstring(L,".collector"); + /* + if (!col) { + lua_pushvalue(L, -1); + lua_rawget(L, -3); + if (!lua_isnil(L, -1)) { + lua_pop(L, 3); + return; + }; + lua_pop(L, 1); + }; + // */ + lua_pushcfunction(L,col); - lua_rawset(L,-3); - lua_pop(L, 1); + lua_rawset(L,-3); + lua_pop(L, 1); }; /* Map C class @@ -520,42 +543,42 @@ static void push_collector(lua_State* L, const char* type, lua_CFunction col) { */ TOLUA_API void tolua_cclass (lua_State* L, const char* lname, const char* name, const char* base, lua_CFunction col) { - char cname[128] = "const "; - char cbase[128] = "const "; - strncat(cname,name,120); - strncat(cbase,base,120); + char cname[128] = "const "; + char cbase[128] = "const "; + strncat(cname,name,120); + strncat(cbase,base,120); - mapinheritance(L,name,base); - mapinheritance(L,cname,name); + mapinheritance(L,name,base); + mapinheritance(L,cname,name); - mapsuper(L,cname,cbase); - mapsuper(L,name,base); + mapsuper(L,cname,cbase); + mapsuper(L,name,base); - lua_pushstring(L,lname); - - push_collector(L, name, col); - /* - luaL_getmetatable(L,name); - lua_pushstring(L,".collector"); - lua_pushcfunction(L,col); + lua_pushstring(L,lname); - lua_rawset(L,-3); - */ - - luaL_getmetatable(L,name); - lua_rawset(L,-3); /* assign class metatable to module */ + push_collector(L, name, col); + /* + luaL_getmetatable(L,name); + lua_pushstring(L,".collector"); + lua_pushcfunction(L,col); + + lua_rawset(L,-3); + */ + + luaL_getmetatable(L,name); + lua_rawset(L,-3); /* assign class metatable to module */ + + /* now we also need to store the collector table for the const + instances of the class */ + push_collector(L, cname, col); + /* + luaL_getmetatable(L,cname); + lua_pushstring(L,".collector"); + lua_pushcfunction(L,col); + lua_rawset(L,-3); + lua_pop(L,1); + */ - /* now we also need to store the collector table for the const - instances of the class */ - push_collector(L, cname, col); - /* - luaL_getmetatable(L,cname); - lua_pushstring(L,".collector"); - lua_pushcfunction(L,col); - lua_rawset(L,-3); - lua_pop(L,1); - */ - } @@ -565,13 +588,13 @@ TOLUA_API void tolua_cclass (lua_State* L, const char* lname, const char* name, */ TOLUA_API void tolua_addbase(lua_State* L, char* name, char* base) { - char cname[128] = "const "; - char cbase[128] = "const "; - strncat(cname,name,120); - strncat(cbase,base,120); + char cname[128] = "const "; + char cbase[128] = "const "; + strncat(cname,name,120); + strncat(cbase,base,120); - mapsuper(L,cname,cbase); - mapsuper(L,name,base); + mapsuper(L,cname,cbase); + mapsuper(L,name,base); }; @@ -580,9 +603,9 @@ TOLUA_API void tolua_addbase(lua_State* L, char* name, char* base) { */ TOLUA_API void tolua_function (lua_State* L, const char* name, lua_CFunction func) { - lua_pushstring(L,name); - lua_pushcfunction(L,func); - lua_rawset(L,-3); + lua_pushstring(L,name); + lua_pushcfunction(L,func); + lua_rawset(L,-3); } /* sets the __call event for the class (expects the class' main table on top) */ @@ -603,9 +626,9 @@ TOLUA_API void tolua_set_call_event(lua_State* L, lua_CFunction func, char* type */ TOLUA_API void tolua_constant (lua_State* L, const char* name, lua_Number value) { - lua_pushstring(L,name); - tolua_pushnumber(L,value); - lua_rawset(L,-3); + lua_pushstring(L,name); + tolua_pushnumber(L,value); + lua_rawset(L,-3); } @@ -614,42 +637,42 @@ TOLUA_API void tolua_constant (lua_State* L, const char* name, lua_Number value) */ TOLUA_API void tolua_variable (lua_State* L, const char* name, lua_CFunction get, lua_CFunction set) { - /* get func */ - lua_pushstring(L,".get"); - lua_rawget(L,-2); - if (!lua_istable(L,-1)) - { - /* create .get table, leaving it at the top */ - lua_pop(L,1); - lua_newtable(L); - lua_pushstring(L,".get"); - lua_pushvalue(L,-2); - lua_rawset(L,-4); - } - lua_pushstring(L,name); - lua_pushcfunction(L,get); - lua_rawset(L,-3); /* store variable */ - lua_pop(L,1); /* pop .get table */ + /* get func */ + lua_pushstring(L,".get"); + lua_rawget(L,-2); + if (!lua_istable(L,-1)) + { + /* create .get table, leaving it at the top */ + lua_pop(L,1); + lua_newtable(L); + lua_pushstring(L,".get"); + lua_pushvalue(L,-2); + lua_rawset(L,-4); + } + lua_pushstring(L,name); + lua_pushcfunction(L,get); + lua_rawset(L,-3); /* store variable */ + lua_pop(L,1); /* pop .get table */ - /* set func */ - if (set) - { - lua_pushstring(L,".set"); - lua_rawget(L,-2); - if (!lua_istable(L,-1)) - { - /* create .set table, leaving it at the top */ - lua_pop(L,1); - lua_newtable(L); - lua_pushstring(L,".set"); - lua_pushvalue(L,-2); - lua_rawset(L,-4); - } - lua_pushstring(L,name); - lua_pushcfunction(L,set); - lua_rawset(L,-3); /* store variable */ - lua_pop(L,1); /* pop .set table */ - } + /* set func */ + if (set) + { + lua_pushstring(L,".set"); + lua_rawget(L,-2); + if (!lua_istable(L,-1)) + { + /* create .set table, leaving it at the top */ + lua_pop(L,1); + lua_newtable(L); + lua_pushstring(L,".set"); + lua_pushvalue(L,-2); + lua_rawset(L,-4); + } + lua_pushstring(L,name); + lua_pushcfunction(L,set); + lua_rawset(L,-3); /* store variable */ + lua_pop(L,1); /* pop .set table */ + } } /* Access const array @@ -657,8 +680,8 @@ TOLUA_API void tolua_variable (lua_State* L, const char* name, lua_CFunction get */ static int const_array (lua_State* L) { - luaL_error(L,"value of const array cannot be changed"); - return 0; + luaL_error(L,"value of const array cannot be changed"); + return 0; } /* Map an array @@ -666,40 +689,40 @@ static int const_array (lua_State* L) */ TOLUA_API void tolua_array (lua_State* L, const char* name, lua_CFunction get, lua_CFunction set) { - lua_pushstring(L,".get"); - lua_rawget(L,-2); - if (!lua_istable(L,-1)) - { - /* create .get table, leaving it at the top */ - lua_pop(L,1); - lua_newtable(L); - lua_pushstring(L,".get"); - lua_pushvalue(L,-2); - lua_rawset(L,-4); - } - lua_pushstring(L,name); + lua_pushstring(L,".get"); + lua_rawget(L,-2); + if (!lua_istable(L,-1)) + { + /* create .get table, leaving it at the top */ + lua_pop(L,1); + lua_newtable(L); + lua_pushstring(L,".get"); + lua_pushvalue(L,-2); + lua_rawset(L,-4); + } + lua_pushstring(L,name); - lua_newtable(L); /* create array metatable */ - lua_pushvalue(L,-1); - lua_setmetatable(L,-2); /* set the own table as metatable (for modules) */ - lua_pushstring(L,"__index"); - lua_pushcfunction(L,get); - lua_rawset(L,-3); - lua_pushstring(L,"__newindex"); - lua_pushcfunction(L,set?set:const_array); - lua_rawset(L,-3); + lua_newtable(L); /* create array metatable */ + lua_pushvalue(L,-1); + lua_setmetatable(L,-2); /* set the own table as metatable (for modules) */ + lua_pushstring(L,"__index"); + lua_pushcfunction(L,get); + lua_rawset(L,-3); + lua_pushstring(L,"__newindex"); + lua_pushcfunction(L,set?set:const_array); + lua_rawset(L,-3); - lua_rawset(L,-3); /* store variable */ - lua_pop(L,1); /* pop .get table */ + lua_rawset(L,-3); /* store variable */ + lua_pop(L,1); /* pop .get table */ } TOLUA_API void tolua_dobuffer(lua_State* L, char* B, unsigned int size, const char* name) { - #ifdef LUA_VERSION_NUM /* lua 5.1 */ - luaL_loadbuffer(L, B, size, name) || lua_pcall(L, 0, 0, 0); - #else - lua_dobuffer(L, B, size, name); - #endif +#ifdef LUA_VERSION_NUM /* lua 5.1 */ + luaL_loadbuffer(L, B, size, name) || lua_pcall(L, 0, 0, 0); +#else + lua_dobuffer(L, B, size, name); +#endif }; diff --git a/lua/tolua/tolua_push.c b/lua/tolua/tolua_push.c index 6394147555..ce9817b765 100644 --- a/lua/tolua/tolua_push.c +++ b/lua/tolua/tolua_push.c @@ -19,153 +19,159 @@ TOLUA_API void tolua_pushvalue (lua_State* L, int lo) { - lua_pushvalue(L,lo); + lua_pushvalue(L,lo); } TOLUA_API void tolua_pushboolean (lua_State* L, int value) { - lua_pushboolean(L,value); + lua_pushboolean(L,value); } TOLUA_API void tolua_pushnumber (lua_State* L, lua_Number value) { - lua_pushnumber(L,value); + lua_pushnumber(L,value); } TOLUA_API void tolua_pushstring (lua_State* L, const char* value) { - if (value == NULL) - lua_pushnil(L); - else - lua_pushstring(L,value); + if (value == NULL) + lua_pushnil(L); + else + lua_pushstring(L,value); } TOLUA_API void tolua_pushuserdata (lua_State* L, void* value) { - if (value == NULL) - lua_pushnil(L); - else - lua_pushlightuserdata(L,value); + if (value == NULL) + lua_pushnil(L); + else + lua_pushlightuserdata(L,value); } TOLUA_API void tolua_pushusertype (lua_State* L, void* value, const char* type) { - if (value == NULL) - lua_pushnil(L); - else - { - luaL_getmetatable(L, type); - lua_pushstring(L,"tolua_ubox"); - lua_rawget(L,-2); /* stack: mt ubox */ - if (lua_isnil(L, -1)) { - lua_pop(L, 1); - lua_pushstring(L, "tolua_ubox"); - lua_rawget(L, LUA_REGISTRYINDEX); - }; - lua_pushlightuserdata(L,value); - lua_rawget(L,-2); /* stack: mt ubox ubox[u] */ - if (lua_isnil(L,-1)) - { - lua_pop(L,1); /* stack: mt ubox */ - lua_pushlightuserdata(L,value); - *(void**)lua_newuserdata(L,sizeof(void *)) = value; /* stack: mt ubox u newud */ - lua_pushvalue(L,-1); /* stack: mt ubox u newud newud */ - lua_insert(L,-4); /* stack: mt newud ubox u newud */ - lua_rawset(L,-3); /* stack: mt newud ubox */ - lua_pop(L,1); /* stack: mt newud */ - /*luaL_getmetatable(L,type);*/ - lua_pushvalue(L, -2); /* stack: mt newud mt */ - lua_setmetatable(L,-2); /* stack: mt newud */ + if (value == NULL) + lua_pushnil(L); + else + { + luaL_getmetatable(L, type); /* stack: mt */ + if (lua_isnil(L, -1)) { /* NOT FOUND metatable */ + lua_pop(L, 1); + return; + } + lua_pushstring(L,"tolua_ubox"); + lua_rawget(L,-2); /* stack: mt ubox */ + if (lua_isnil(L, -1)) { + lua_pop(L, 1); + lua_pushstring(L, "tolua_ubox"); + lua_rawget(L, LUA_REGISTRYINDEX); + }; + + lua_pushlightuserdata(L,value); /* stack: mt ubox key */ + lua_rawget(L,-2); /* stack: mt ubox ubox[value] */ + + if (lua_isnil(L,-1)) + { + lua_pop(L,1); /* stack: mt ubox */ + lua_pushlightuserdata(L,value); + *(void**)lua_newuserdata(L,sizeof(void *)) = value; /* stack: mt ubox value newud */ + lua_pushvalue(L,-1); /* stack: mt ubox value newud newud */ + lua_insert(L,-4); /* stack: mt newud ubox value newud */ + lua_rawset(L,-3); /* ubox[value] = newud, stack: mt newud ubox */ + lua_pop(L,1); /* stack: mt newud */ + /*luaL_getmetatable(L,type);*/ + lua_pushvalue(L, -2); /* stack: mt newud mt */ + lua_setmetatable(L,-2); /* update mt, stack: mt newud */ - #ifdef LUA_VERSION_NUM - lua_pushvalue(L, TOLUA_NOPEER); - lua_setfenv(L, -2); - #endif - } - else - { - /* check the need of updating the metatable to a more specialized class */ - lua_insert(L,-2); /* stack: mt ubox[u] ubox */ - lua_pop(L,1); /* stack: mt ubox[u] */ - lua_pushstring(L,"tolua_super"); - lua_rawget(L,LUA_REGISTRYINDEX); /* stack: mt ubox[u] super */ - lua_getmetatable(L,-2); /* stack: mt ubox[u] super mt */ - lua_rawget(L,-2); /* stack: mt ubox[u] super super[mt] */ - if (lua_istable(L,-1)) - { - lua_pushstring(L,type); /* stack: mt ubox[u] super super[mt] type */ - lua_rawget(L,-2); /* stack: mt ubox[u] super super[mt] flag */ - if (lua_toboolean(L,-1) == 1) /* if true */ - { - lua_pop(L,3); /* mt ubox[u]*/ - lua_remove(L, -2); - return; - } - } - /* type represents a more specilized type */ - /*luaL_getmetatable(L,type); // stack: mt ubox[u] super super[mt] flag mt */ - lua_pushvalue(L, -5); /* stack: mt ubox[u] super super[mt] flag mt */ - lua_setmetatable(L,-5); /* stack: mt ubox[u] super super[mt] flag */ - lua_pop(L,3); /* stack: mt ubox[u] */ - } - lua_remove(L, -2); /* stack: ubox[u]*/ - } +#ifdef LUA_VERSION_NUM + lua_pushvalue(L, TOLUA_NOPEER); + lua_setfenv(L, -2); +#endif + } + else + { + /* check the need of updating the metatable to a more specialized class */ + lua_insert(L,-2); /* stack: mt ubox[u] ubox */ + lua_pop(L,1); /* stack: mt ubox[u] */ + lua_pushstring(L,"tolua_super"); + lua_rawget(L,LUA_REGISTRYINDEX); /* stack: mt ubox[u] super */ + lua_getmetatable(L,-2); /* stack: mt ubox[u] super mt */ + lua_rawget(L,-2); /* stack: mt ubox[u] super super[mt] */ + if (lua_istable(L,-1)) + { + lua_pushstring(L,type); /* stack: mt ubox[u] super super[mt] type */ + lua_rawget(L,-2); /* stack: mt ubox[u] super super[mt] flag */ + if (lua_toboolean(L,-1) == 1) /* if true */ + { + lua_pop(L,3); /* mt ubox[u]*/ + lua_remove(L, -2); + return; + } + } + /* type represents a more specilized type */ + /*luaL_getmetatable(L,type); // stack: mt ubox[u] super super[mt] flag mt */ + lua_pushvalue(L, -5); /* stack: mt ubox[u] super super[mt] flag mt */ + lua_setmetatable(L,-5); /* stack: mt ubox[u] super super[mt] flag */ + lua_pop(L,3); /* stack: mt ubox[u] */ + } + lua_remove(L, -2); /* stack: ubox[u]*/ + } } TOLUA_API void tolua_pushusertype_and_takeownership (lua_State* L, void* value, const char* type) { - tolua_pushusertype(L,value,type); - tolua_register_gc(L,lua_gettop(L)); + tolua_pushusertype(L,value,type); + tolua_register_gc(L,lua_gettop(L)); } TOLUA_API void tolua_pushfieldvalue (lua_State* L, int lo, int index, int v) { - lua_pushnumber(L,index); - lua_pushvalue(L,v); - lua_settable(L,lo); + lua_pushnumber(L,index); + lua_pushvalue(L,v); + lua_settable(L,lo); } TOLUA_API void tolua_pushfieldboolean (lua_State* L, int lo, int index, int v) { - lua_pushnumber(L,index); - lua_pushboolean(L,v); - lua_settable(L,lo); + lua_pushnumber(L,index); + lua_pushboolean(L,v); + lua_settable(L,lo); } TOLUA_API void tolua_pushfieldnumber (lua_State* L, int lo, int index, lua_Number v) { - lua_pushnumber(L,index); - tolua_pushnumber(L,v); - lua_settable(L,lo); + lua_pushnumber(L,index); + tolua_pushnumber(L,v); + lua_settable(L,lo); } TOLUA_API void tolua_pushfieldstring (lua_State* L, int lo, int index, const char* v) { - lua_pushnumber(L,index); - tolua_pushstring(L,v); - lua_settable(L,lo); + lua_pushnumber(L,index); + tolua_pushstring(L,v); + lua_settable(L,lo); } TOLUA_API void tolua_pushfielduserdata (lua_State* L, int lo, int index, void* v) { - lua_pushnumber(L,index); - tolua_pushuserdata(L,v); - lua_settable(L,lo); + lua_pushnumber(L,index); + tolua_pushuserdata(L,v); + lua_settable(L,lo); } TOLUA_API void tolua_pushfieldusertype (lua_State* L, int lo, int index, void* v, const char* type) { - lua_pushnumber(L,index); - tolua_pushusertype(L,v,type); - lua_settable(L,lo); + lua_pushnumber(L,index); + tolua_pushusertype(L,v,type); + lua_settable(L,lo); } TOLUA_API void tolua_pushfieldusertype_and_takeownership (lua_State* L, int lo, int index, void* v, const char* type) { - lua_pushnumber(L,index); - tolua_pushusertype(L,v,type); - tolua_register_gc(L,lua_gettop(L)); - lua_settable(L,lo); + lua_pushnumber(L,index); + tolua_pushusertype(L,v,type); + tolua_register_gc(L,lua_gettop(L)); + lua_settable(L,lo); } diff --git a/lua/tolua/tolua_to.c b/lua/tolua/tolua_to.c index 542ca67d16..455f4d83a1 100644 --- a/lua/tolua/tolua_to.c +++ b/lua/tolua/tolua_to.c @@ -19,115 +19,115 @@ TOLUA_API lua_Number tolua_tonumber (lua_State* L, int narg, lua_Number def) { - return lua_gettop(L)