Repository: zupet/LuaTinker Branch: master Commit: 88a00fb9e7de Files: 20 Total size: 96.5 KB Directory structure: gitextract_m2jmwstv/ ├── .gitattributes ├── .gitignore ├── lauxlib.h ├── lua.h ├── lua_tinker.cpp ├── lua_tinker.h ├── luaconf.h ├── lualib.h ├── sample1.cpp ├── sample1.lua ├── sample2.cpp ├── sample2.lua ├── sample3.cpp ├── sample3.lua ├── sample4.cpp ├── sample4.lua ├── sample5.cpp ├── sample5.lua ├── sample6.cpp └── sample6.lua ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitattributes ================================================ # Auto detect text files and perform LF normalization * text=auto # Custom for Visual Studio *.cs diff=csharp *.sln merge=union *.csproj merge=union *.vbproj merge=union *.fsproj merge=union *.dbproj merge=union # Standard to msysgit *.doc diff=astextplain *.DOC diff=astextplain *.docx diff=astextplain *.DOCX diff=astextplain *.dot diff=astextplain *.DOT diff=astextplain *.pdf diff=astextplain *.PDF diff=astextplain *.rtf diff=astextplain *.RTF diff=astextplain ================================================ FILE: .gitignore ================================================ ################# ## Eclipse ################# *.pydevproject .project .metadata bin/ tmp/ *.tmp *.bak *.swp *~.nib local.properties .classpath .settings/ .loadpath # External tool builders .externalToolBuilders/ # Locally stored "Eclipse launch configurations" *.launch # CDT-specific .cproject # PDT-specific .buildpath ################# ## Visual Studio ################# ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # User-specific files *.suo *.user *.sln.docstates # Build results [Dd]ebug/ [Rr]elease/ *_i.c *_p.c *.ilk *.meta *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.vspscc .builds *.dotCover ## TODO: If you have NuGet Package Restore enabled, uncomment this #packages/ # Visual C++ cache files ipch/ *.aps *.ncb *.opensdf *.sdf # Visual Studio profiler *.psess *.vsp # ReSharper is a .NET coding add-in _ReSharper* # Installshield output folder [Ee]xpress # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish # Others [Bb]in [Oo]bj sql TestResults *.Cache ClientBin stylecop.* ~$* *.dbmdl Generated_Code #added for RIA/Silverlight projects # Backup & report files from converting an old project file to a newer # Visual Studio version. Backup files are not needed, because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML ############ ## Windows ############ # Windows image file caches Thumbs.db # Folder config file Desktop.ini ############# ## Python ############# *.py[co] # Packages *.egg *.egg-info dist build eggs parts bin var sdist develop-eggs .installed.cfg # Installer logs pip-log.txt # Unit test / coverage reports .coverage .tox #Translations *.mo #Mr Developer .mr.developer.cfg # Mac crap .DS_Store ================================================ FILE: lauxlib.h ================================================ /* ** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $ ** Auxiliary functions for building Lua libraries ** See Copyright Notice in lua.h */ #ifndef lauxlib_h #define lauxlib_h #include #include #include "lua.h" #if defined(LUA_COMPAT_GETN) LUALIB_API int (luaL_getn) (lua_State *L, int t); LUALIB_API void (luaL_setn) (lua_State *L, int t, int n); #else #define luaL_getn(L,i) ((int)lua_objlen(L, i)) #define luaL_setn(L,i,j) ((void)0) /* no op! */ #endif #if defined(LUA_COMPAT_OPENLIB) #define luaI_openlib luaL_openlib #endif /* extra error code for `luaL_load' */ #define LUA_ERRFILE (LUA_ERRERR+1) typedef struct luaL_Reg { const char *name; lua_CFunction func; } luaL_Reg; LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname, const luaL_Reg *l, int nup); LUALIB_API void (luaL_register) (lua_State *L, const char *libname, const luaL_Reg *l); LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname); LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg); LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg, size_t *l); LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg, const char *def, size_t *l); LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg); LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def); LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg); LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg, lua_Integer def); LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t); LUALIB_API void (luaL_checkany) (lua_State *L, int narg); LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); LUALIB_API void (luaL_where) (lua_State *L, int lvl); LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def, const char *const lst[]); LUALIB_API int (luaL_ref) (lua_State *L, int t); LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename); LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz, const char *name); LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); LUALIB_API lua_State *(luaL_newstate) (void); LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p, const char *r); LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx, const char *fname, int szhint); /* ** =============================================================== ** some useful macros ** =============================================================== */ #define luaL_argcheck(L, cond,numarg,extramsg) \ ((void)((cond) || luaL_argerror(L, (numarg), (extramsg)))) #define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) #define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) #define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) #define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) #define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) #define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) #define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) #define luaL_dofile(L, fn) \ (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) #define luaL_dostring(L, s) \ (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) #define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) /* ** {====================================================== ** Generic Buffer manipulation ** ======================================================= */ typedef struct luaL_Buffer { char *p; /* current position in buffer */ int lvl; /* number of strings in the stack (level) */ lua_State *L; char buffer[LUAL_BUFFERSIZE]; } luaL_Buffer; #define luaL_addchar(B,c) \ ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \ (*(B)->p++ = (char)(c))) /* compatibility only */ #define luaL_putchar(B,c) luaL_addchar(B,c) #define luaL_addsize(B,n) ((B)->p += (n)) LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B); LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); /* }====================================================== */ /* compatibility with ref system */ /* pre-defined references */ #define LUA_NOREF (-2) #define LUA_REFNIL (-1) #define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \ (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0)) #define lua_unref(L,ref) luaL_unref(L, LUA_REGISTRYINDEX, (ref)) #define lua_getref(L,ref) lua_rawgeti(L, LUA_REGISTRYINDEX, (ref)) #define luaL_reg luaL_Reg #endif ================================================ FILE: lua.h ================================================ /* ** $Id: lua.h,v 1.218.1.5 2008/08/06 13:30:12 roberto Exp $ ** Lua - An Extensible Extension Language ** Lua.org, PUC-Rio, Brazil (http://www.lua.org) ** See Copyright Notice at the end of this file */ #ifndef lua_h #define lua_h #include #include #include "luaconf.h" #define LUA_VERSION "Lua 5.1" #define LUA_RELEASE "Lua 5.1.4" #define LUA_VERSION_NUM 501 #define LUA_COPYRIGHT "Copyright (C) 1994-2008 Lua.org, PUC-Rio" #define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes" /* mark for precompiled code (`Lua') */ #define LUA_SIGNATURE "\033Lua" /* option for multiple returns in `lua_pcall' and `lua_call' */ #define LUA_MULTRET (-1) /* ** pseudo-indices */ #define LUA_REGISTRYINDEX (-10000) #define LUA_ENVIRONINDEX (-10001) #define LUA_GLOBALSINDEX (-10002) #define lua_upvalueindex(i) (LUA_GLOBALSINDEX-(i)) /* thread status; 0 is OK */ #define LUA_YIELD 1 #define LUA_ERRRUN 2 #define LUA_ERRSYNTAX 3 #define LUA_ERRMEM 4 #define LUA_ERRERR 5 typedef struct lua_State lua_State; typedef int (*lua_CFunction) (lua_State *L); /* ** functions that read/write blocks when loading/dumping Lua chunks */ typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud); /* ** prototype for memory-allocation functions */ typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); /* ** basic types */ #define LUA_TNONE (-1) #define LUA_TNIL 0 #define LUA_TBOOLEAN 1 #define LUA_TLIGHTUSERDATA 2 #define LUA_TNUMBER 3 #define LUA_TSTRING 4 #define LUA_TTABLE 5 #define LUA_TFUNCTION 6 #define LUA_TUSERDATA 7 #define LUA_TTHREAD 8 /* minimum Lua stack available to a C function */ #define LUA_MINSTACK 20 /* ** generic extra include file */ #if defined(LUA_USER_H) #include LUA_USER_H #endif /* type of numbers in Lua */ typedef LUA_NUMBER lua_Number; /* type for integer functions */ typedef LUA_INTEGER lua_Integer; /* ** state manipulation */ LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud); LUA_API void (lua_close) (lua_State *L); LUA_API lua_State *(lua_newthread) (lua_State *L); LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); /* ** basic stack manipulation */ LUA_API int (lua_gettop) (lua_State *L); LUA_API void (lua_settop) (lua_State *L, int idx); LUA_API void (lua_pushvalue) (lua_State *L, int idx); LUA_API void (lua_remove) (lua_State *L, int idx); LUA_API void (lua_insert) (lua_State *L, int idx); LUA_API void (lua_replace) (lua_State *L, int idx); LUA_API int (lua_checkstack) (lua_State *L, int sz); LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); /* ** access functions (stack -> C) */ LUA_API int (lua_isnumber) (lua_State *L, int idx); LUA_API int (lua_isstring) (lua_State *L, int idx); LUA_API int (lua_iscfunction) (lua_State *L, int idx); LUA_API int (lua_isuserdata) (lua_State *L, int idx); LUA_API int (lua_type) (lua_State *L, int idx); LUA_API const char *(lua_typename) (lua_State *L, int tp); LUA_API int (lua_equal) (lua_State *L, int idx1, int idx2); LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); LUA_API int (lua_lessthan) (lua_State *L, int idx1, int idx2); LUA_API lua_Number (lua_tonumber) (lua_State *L, int idx); LUA_API lua_Integer (lua_tointeger) (lua_State *L, int idx); LUA_API int (lua_toboolean) (lua_State *L, int idx); LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); LUA_API size_t (lua_objlen) (lua_State *L, int idx); LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx); LUA_API void *(lua_touserdata) (lua_State *L, int idx); LUA_API lua_State *(lua_tothread) (lua_State *L, int idx); LUA_API const void *(lua_topointer) (lua_State *L, int idx); /* ** push functions (C -> stack) */ LUA_API void (lua_pushnil) (lua_State *L); LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n); LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n); LUA_API void (lua_pushlstring) (lua_State *L, const char *s, size_t l); LUA_API void (lua_pushstring) (lua_State *L, const char *s); LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, va_list argp); LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...); LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n); LUA_API void (lua_pushboolean) (lua_State *L, int b); LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p); LUA_API int (lua_pushthread) (lua_State *L); /* ** get functions (Lua -> stack) */ LUA_API void (lua_gettable) (lua_State *L, int idx); LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k); LUA_API void (lua_rawget) (lua_State *L, int idx); LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n); LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz); LUA_API int (lua_getmetatable) (lua_State *L, int objindex); LUA_API void (lua_getfenv) (lua_State *L, int idx); /* ** set functions (stack -> Lua) */ LUA_API void (lua_settable) (lua_State *L, int idx); LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k); LUA_API void (lua_rawset) (lua_State *L, int idx); LUA_API void (lua_rawseti) (lua_State *L, int idx, int n); LUA_API int (lua_setmetatable) (lua_State *L, int objindex); LUA_API int (lua_setfenv) (lua_State *L, int idx); /* ** `load' and `call' functions (load and run Lua code) */ LUA_API void (lua_call) (lua_State *L, int nargs, int nresults); LUA_API int (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc); LUA_API int (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud); LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, const char *chunkname); LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data); /* ** coroutine functions */ LUA_API int (lua_yield) (lua_State *L, int nresults); LUA_API int (lua_resume) (lua_State *L, int narg); LUA_API int (lua_status) (lua_State *L); /* ** garbage-collection function and options */ #define LUA_GCSTOP 0 #define LUA_GCRESTART 1 #define LUA_GCCOLLECT 2 #define LUA_GCCOUNT 3 #define LUA_GCCOUNTB 4 #define LUA_GCSTEP 5 #define LUA_GCSETPAUSE 6 #define LUA_GCSETSTEPMUL 7 LUA_API int (lua_gc) (lua_State *L, int what, int data); /* ** miscellaneous functions */ LUA_API int (lua_error) (lua_State *L); LUA_API int (lua_next) (lua_State *L, int idx); LUA_API void (lua_concat) (lua_State *L, int n); LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud); /* ** =============================================================== ** some useful macros ** =============================================================== */ #define lua_pop(L,n) lua_settop(L, -(n)-1) #define lua_newtable(L) lua_createtable(L, 0, 0) #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) #define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) #define lua_strlen(L,i) lua_objlen(L, (i)) #define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) #define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) #define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) #define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) #define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) #define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) #define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) #define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) #define lua_pushliteral(L, s) \ lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1) #define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, (s)) #define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, (s)) #define lua_tostring(L,i) lua_tolstring(L, (i), NULL) /* ** compatibility macros and functions */ #define lua_open() luaL_newstate() #define lua_getregistry(L) lua_pushvalue(L, LUA_REGISTRYINDEX) #define lua_getgccount(L) lua_gc(L, LUA_GCCOUNT, 0) #define lua_Chunkreader lua_Reader #define lua_Chunkwriter lua_Writer /* hack */ LUA_API void lua_setlevel (lua_State *from, lua_State *to); /* ** {====================================================================== ** Debug API ** ======================================================================= */ /* ** Event codes */ #define LUA_HOOKCALL 0 #define LUA_HOOKRET 1 #define LUA_HOOKLINE 2 #define LUA_HOOKCOUNT 3 #define LUA_HOOKTAILRET 4 /* ** Event masks */ #define LUA_MASKCALL (1 << LUA_HOOKCALL) #define LUA_MASKRET (1 << LUA_HOOKRET) #define LUA_MASKLINE (1 << LUA_HOOKLINE) #define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) typedef struct lua_Debug lua_Debug; /* activation record */ /* Functions to be called by the debuger in specific events */ typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar); LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar); LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n); LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n); LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n); LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n); LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count); LUA_API lua_Hook lua_gethook (lua_State *L); LUA_API int lua_gethookmask (lua_State *L); LUA_API int lua_gethookcount (lua_State *L); struct lua_Debug { int event; const char *name; /* (n) */ const char *namewhat; /* (n) `global', `local', `field', `method' */ const char *what; /* (S) `Lua', `C', `main', `tail' */ const char *source; /* (S) */ int currentline; /* (l) */ int nups; /* (u) number of upvalues */ int linedefined; /* (S) */ int lastlinedefined; /* (S) */ char short_src[LUA_IDSIZE]; /* (S) */ /* private part */ int i_ci; /* active function */ }; /* }====================================================================== */ /****************************************************************************** * Copyright (C) 1994-2008 Lua.org, PUC-Rio. 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, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * 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. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ******************************************************************************/ #endif ================================================ FILE: lua_tinker.cpp ================================================ // lua_tinker.cpp // // LuaTinker - Simple and light C++ wrapper for Lua. // // Copyright (c) 2005-2007 Kwon-il Lee (zupet@hitel.net) // // please check Licence.txt file for licence and legal issues. #include extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" }; #include "lua_tinker.h" /*---------------------------------------------------------------------------*/ /* init */ /*---------------------------------------------------------------------------*/ void lua_tinker::init(lua_State *L) { init_s64(L); init_u64(L); } /*---------------------------------------------------------------------------*/ /* __s64 */ /*---------------------------------------------------------------------------*/ static int tostring_s64(lua_State *L) { char temp[64]; sprintf_s(temp, "%I64d", *(long long*)lua_topointer(L, 1)); lua_pushstring(L, temp); return 1; } /*---------------------------------------------------------------------------*/ static int eq_s64(lua_State *L) { lua_pushboolean(L, memcmp(lua_topointer(L, 1), lua_topointer(L, 2), sizeof(long long)) == 0); return 1; } /*---------------------------------------------------------------------------*/ static int lt_s64(lua_State *L) { lua_pushboolean(L, memcmp(lua_topointer(L, 1), lua_topointer(L, 2), sizeof(long long)) < 0); return 1; } /*---------------------------------------------------------------------------*/ static int le_s64(lua_State *L) { lua_pushboolean(L, memcmp(lua_topointer(L, 1), lua_topointer(L, 2), sizeof(long long)) <= 0); return 1; } /*---------------------------------------------------------------------------*/ void lua_tinker::init_s64(lua_State *L) { const char* name = "__s64"; lua_pushstring(L, name); lua_newtable(L); lua_pushstring(L, "__name"); lua_pushstring(L, name); lua_rawset(L, -3); lua_pushstring(L, "__tostring"); lua_pushcclosure(L, tostring_s64, 0); lua_rawset(L, -3); lua_pushstring(L, "__eq"); lua_pushcclosure(L, eq_s64, 0); lua_rawset(L, -3); lua_pushstring(L, "__lt"); lua_pushcclosure(L, lt_s64, 0); lua_rawset(L, -3); lua_pushstring(L, "__le"); lua_pushcclosure(L, le_s64, 0); lua_rawset(L, -3); lua_settable(L, LUA_GLOBALSINDEX); } /*---------------------------------------------------------------------------*/ /* __u64 */ /*---------------------------------------------------------------------------*/ static int tostring_u64(lua_State *L) { char temp[64]; sprintf_s(temp, "%I64u", *(unsigned long long*)lua_topointer(L, 1)); lua_pushstring(L, temp); return 1; } /*---------------------------------------------------------------------------*/ static int eq_u64(lua_State *L) { lua_pushboolean(L, memcmp(lua_topointer(L, 1), lua_topointer(L, 2), sizeof(unsigned long long)) == 0); return 1; } /*---------------------------------------------------------------------------*/ static int lt_u64(lua_State *L) { lua_pushboolean(L, memcmp(lua_topointer(L, 1), lua_topointer(L, 2), sizeof(unsigned long long)) < 0); return 1; } /*---------------------------------------------------------------------------*/ static int le_u64(lua_State *L) { lua_pushboolean(L, memcmp(lua_topointer(L, 1), lua_topointer(L, 2), sizeof(unsigned long long)) <= 0); return 1; } /*---------------------------------------------------------------------------*/ void lua_tinker::init_u64(lua_State *L) { const char* name = "__u64"; lua_pushstring(L, name); lua_newtable(L); lua_pushstring(L, "__name"); lua_pushstring(L, name); lua_rawset(L, -3); lua_pushstring(L, "__tostring"); lua_pushcclosure(L, tostring_u64, 0); lua_rawset(L, -3); lua_pushstring(L, "__eq"); lua_pushcclosure(L, eq_u64, 0); lua_rawset(L, -3); lua_pushstring(L, "__lt"); lua_pushcclosure(L, lt_u64, 0); lua_rawset(L, -3); lua_pushstring(L, "__le"); lua_pushcclosure(L, le_u64, 0); lua_rawset(L, -3); lua_settable(L, LUA_GLOBALSINDEX); } /*---------------------------------------------------------------------------*/ /* excution */ /*---------------------------------------------------------------------------*/ void lua_tinker::dofile(lua_State *L, const char *filename) { lua_pushcclosure(L, on_error, 0); int errfunc = lua_gettop(L); if(luaL_loadfile(L, filename) == 0) { lua_pcall(L, 0, 1, errfunc); } else { print_error(L, "%s", lua_tostring(L, -1)); } lua_remove(L, errfunc); lua_pop(L, 1); } /*---------------------------------------------------------------------------*/ void lua_tinker::dostring(lua_State *L, const char* buff) { lua_tinker::dobuffer(L, buff, strlen(buff)); } /*---------------------------------------------------------------------------*/ void lua_tinker::dobuffer(lua_State *L, const char* buff, size_t len) { lua_pushcclosure(L, on_error, 0); int errfunc = lua_gettop(L); if(luaL_loadbuffer(L, buff, len, "lua_tinker::dobuffer()") == 0) { lua_pcall(L, 0, 1, errfunc); } else { print_error(L, "%s", lua_tostring(L, -1)); } lua_remove(L, errfunc); lua_pop(L, 1); } /*---------------------------------------------------------------------------*/ /* debug helpers */ /*---------------------------------------------------------------------------*/ static void call_stack(lua_State* L, int n) { lua_Debug ar; if(lua_getstack(L, n, &ar) == 1) { lua_getinfo(L, "nSlu", &ar); const char* indent; if(n == 0) { indent = "->\t"; lua_tinker::print_error(L, "\t"); } else { indent = "\t"; } if(ar.name) lua_tinker::print_error(L, "%s%s() : line %d [%s : line %d]", indent, ar.name, ar.currentline, ar.source, ar.linedefined); else lua_tinker::print_error(L, "%sunknown : line %d [%s : line %d]", indent, ar.currentline, ar.source, ar.linedefined); call_stack(L, n+1); } } /*---------------------------------------------------------------------------*/ int lua_tinker::on_error(lua_State *L) { print_error(L, "%s", lua_tostring(L, -1)); call_stack(L, 0); return 0; } /*---------------------------------------------------------------------------*/ void lua_tinker::print_error(lua_State *L, const char* fmt, ...) { char text[4096]; va_list args; va_start(args, fmt); vsprintf_s(text, fmt, args); va_end(args); lua_pushstring(L, "_ALERT"); lua_gettable(L, LUA_GLOBALSINDEX); if(lua_isfunction(L, -1)) { lua_pushstring(L, text); lua_call(L, 1, 0); } else { printf("%s\n", text); lua_pop(L, 1); } } /*---------------------------------------------------------------------------*/ void lua_tinker::enum_stack(lua_State *L) { int top = lua_gettop(L); print_error(L, "Type:%d", top); for(int i=1; i<=lua_gettop(L); ++i) { switch(lua_type(L, i)) { case LUA_TNIL: print_error(L, "\t%s", lua_typename(L, lua_type(L, i))); break; case LUA_TBOOLEAN: print_error(L, "\t%s %s", lua_typename(L, lua_type(L, i)), lua_toboolean(L, i)?"true":"false"); break; case LUA_TLIGHTUSERDATA: print_error(L, "\t%s 0x%08p", lua_typename(L, lua_type(L, i)), lua_topointer(L, i)); break; case LUA_TNUMBER: print_error(L, "\t%s %f", lua_typename(L, lua_type(L, i)), lua_tonumber(L, i)); break; case LUA_TSTRING: print_error(L, "\t%s %s", lua_typename(L, lua_type(L, i)), lua_tostring(L, i)); break; case LUA_TTABLE: print_error(L, "\t%s 0x%08p", lua_typename(L, lua_type(L, i)), lua_topointer(L, i)); break; case LUA_TFUNCTION: print_error(L, "\t%s() 0x%08p", lua_typename(L, lua_type(L, i)), lua_topointer(L, i)); break; case LUA_TUSERDATA: print_error(L, "\t%s 0x%08p", lua_typename(L, lua_type(L, i)), lua_topointer(L, i)); break; case LUA_TTHREAD: print_error(L, "\t%s", lua_typename(L, lua_type(L, i))); break; } } } /*---------------------------------------------------------------------------*/ /* read */ /*---------------------------------------------------------------------------*/ template<> char* lua_tinker::read(lua_State *L, int index) { return (char*)lua_tostring(L, index); } template<> const char* lua_tinker::read(lua_State *L, int index) { return (const char*)lua_tostring(L, index); } template<> char lua_tinker::read(lua_State *L, int index) { return (char)lua_tonumber(L, index); } template<> unsigned char lua_tinker::read(lua_State *L, int index) { return (unsigned char)lua_tonumber(L, index); } template<> short lua_tinker::read(lua_State *L, int index) { return (short)lua_tonumber(L, index); } template<> unsigned short lua_tinker::read(lua_State *L, int index) { return (unsigned short)lua_tonumber(L, index); } template<> long lua_tinker::read(lua_State *L, int index) { return (long)lua_tonumber(L, index); } template<> unsigned long lua_tinker::read(lua_State *L, int index) { return (unsigned long)lua_tonumber(L, index); } template<> int lua_tinker::read(lua_State *L, int index) { return (int)lua_tonumber(L, index); } template<> unsigned int lua_tinker::read(lua_State *L, int index) { return (unsigned int)lua_tonumber(L, index); } template<> float lua_tinker::read(lua_State *L, int index) { return (float)lua_tonumber(L, index); } template<> double lua_tinker::read(lua_State *L, int index) { return (double)lua_tonumber(L, index); } template<> bool lua_tinker::read(lua_State *L, int index) { if(lua_isboolean(L, index)) return lua_toboolean(L, index) != 0; else return lua_tonumber(L, index) != 0; } template<> void lua_tinker::read(lua_State *L, int index) { return; } template<> long long lua_tinker::read(lua_State *L, int index) { if(lua_isnumber(L,index)) return (long long)lua_tonumber(L, index); else return *(long long*)lua_touserdata(L, index); } template<> unsigned long long lua_tinker::read(lua_State *L, int index) { if(lua_isnumber(L,index)) return (unsigned long long)lua_tonumber(L, index); else return *(unsigned long long*)lua_touserdata(L, index); } template<> lua_tinker::table lua_tinker::read(lua_State *L, int index) { return table(L, index); } /*---------------------------------------------------------------------------*/ /* push */ /*---------------------------------------------------------------------------*/ template<> void lua_tinker::push(lua_State *L, char ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, unsigned char ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, short ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, unsigned short ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, long ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, unsigned long ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, int ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, unsigned int ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, float ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, double ret) { lua_pushnumber(L, ret); } template<> void lua_tinker::push(lua_State *L, char* ret) { lua_pushstring(L, ret); } template<> void lua_tinker::push(lua_State *L, const char* ret) { lua_pushstring(L, ret); } template<> void lua_tinker::push(lua_State *L, bool ret) { lua_pushboolean(L, ret); } template<> void lua_tinker::push(lua_State *L, lua_value* ret) { if(ret) ret->to_lua(L); else lua_pushnil(L); } template<> void lua_tinker::push(lua_State *L, long long ret) { *(long long*)lua_newuserdata(L, sizeof(long long)) = ret; lua_pushstring(L, "__s64"); lua_gettable(L, LUA_GLOBALSINDEX); lua_setmetatable(L, -2); } template<> void lua_tinker::push(lua_State *L, unsigned long long ret) { *(unsigned long long*)lua_newuserdata(L, sizeof(unsigned long long)) = ret; lua_pushstring(L, "__u64"); lua_gettable(L, LUA_GLOBALSINDEX); lua_setmetatable(L, -2); } template<> void lua_tinker::push(lua_State *L, lua_tinker::table ret) { lua_pushvalue(L, ret.m_obj->m_index); } /*---------------------------------------------------------------------------*/ /* pop */ /*---------------------------------------------------------------------------*/ template<> void lua_tinker::pop(lua_State *L) { lua_pop(L, 1); } template<> lua_tinker::table lua_tinker::pop(lua_State *L) { return table(L, lua_gettop(L)); } /*---------------------------------------------------------------------------*/ /* Tinker Class Helper */ /*---------------------------------------------------------------------------*/ static void invoke_parent(lua_State *L) { lua_pushstring(L, "__parent"); lua_rawget(L, -2); if(lua_istable(L,-1)) { lua_pushvalue(L,2); lua_rawget(L, -2); if(!lua_isnil(L,-1)) { lua_remove(L,-2); } else { lua_remove(L, -1); invoke_parent(L); lua_remove(L,-2); } } } /*---------------------------------------------------------------------------*/ int lua_tinker::meta_get(lua_State *L) { lua_getmetatable(L,1); lua_pushvalue(L,2); lua_rawget(L,-2); if(lua_isuserdata(L,-1)) { user2type::invoke(L,-1)->get(L); lua_remove(L, -2); } else if(lua_isnil(L,-1)) { lua_remove(L,-1); invoke_parent(L); if(lua_isnil(L,-1)) { lua_pushfstring(L, "can't find '%s' class variable. (forgot registering class variable ?)", lua_tostring(L, 2)); lua_error(L); } } lua_remove(L,-2); return 1; } /*---------------------------------------------------------------------------*/ int lua_tinker::meta_set(lua_State *L) { lua_getmetatable(L,1); lua_pushvalue(L,2); lua_rawget(L,-2); if(lua_isuserdata(L,-1)) { user2type::invoke(L,-1)->set(L); } else if(lua_isnil(L, -1)) { lua_pushvalue(L,2); lua_pushvalue(L,3); lua_rawset(L, -4); } lua_settop(L, 3); return 0; } /*---------------------------------------------------------------------------*/ void lua_tinker::push_meta(lua_State *L, const char* name) { lua_pushstring(L, name); lua_gettable(L, LUA_GLOBALSINDEX); } /*---------------------------------------------------------------------------*/ /* table object on stack */ /*---------------------------------------------------------------------------*/ lua_tinker::table_obj::table_obj(lua_State* L, int index) :m_L(L) ,m_index(index) ,m_ref(0) { if(lua_isnil(m_L, m_index)) { m_pointer = NULL; lua_remove(m_L, m_index); } else { m_pointer = lua_topointer(m_L, m_index); } } lua_tinker::table_obj::~table_obj() { if(validate()) { lua_remove(m_L, m_index); } } void lua_tinker::table_obj::inc_ref() { ++m_ref; } void lua_tinker::table_obj::dec_ref() { if(--m_ref == 0) delete this; } bool lua_tinker::table_obj::validate() { if(m_pointer != NULL) { if(m_pointer == lua_topointer(m_L, m_index)) { return true; } else { int top = lua_gettop(m_L); for(int i=1; i<=top; ++i) { if(m_pointer == lua_topointer(m_L, i)) { m_index = i; return true; } } m_pointer = NULL; return false; } } else { return false; } } /*---------------------------------------------------------------------------*/ /* Table Object Holder */ /*---------------------------------------------------------------------------*/ lua_tinker::table::table(lua_State* L) { lua_newtable(L); m_obj = new table_obj(L, lua_gettop(L)); m_obj->inc_ref(); } lua_tinker::table::table(lua_State* L, const char* name) { lua_pushstring(L, name); lua_gettable(L, LUA_GLOBALSINDEX); if(lua_istable(L, -1) == 0) { lua_pop(L, 1); lua_newtable(L); lua_pushstring(L, name); lua_pushvalue(L, -2); lua_settable(L, LUA_GLOBALSINDEX); } m_obj = new table_obj(L, lua_gettop(L)); } lua_tinker::table::table(lua_State* L, int index) { if(index < 0) { index = lua_gettop(L) + index + 1; } m_obj = new table_obj(L, index); m_obj->inc_ref(); } lua_tinker::table::table(const table& input) { m_obj = input.m_obj; m_obj->inc_ref(); } lua_tinker::table::~table() { m_obj->dec_ref(); } /*---------------------------------------------------------------------------*/ ================================================ FILE: lua_tinker.h ================================================ // lua_tinker.h // // LuaTinker - Simple and light C++ wrapper for Lua. // // Copyright (c) 2005-2007 Kwon-il Lee (zupet@hitel.net) // // please check Licence.txt file for licence and legal issues. #if !defined(_LUA_TINKER_H_) #define _LUA_TINKER_H_ #include #include namespace lua_tinker { // init LuaTinker void init(lua_State *L); void init_s64(lua_State *L); void init_u64(lua_State *L); // string-buffer excution void dofile(lua_State *L, const char *filename); void dostring(lua_State *L, const char* buff); void dobuffer(lua_State *L, const char* buff, size_t sz); // debug helpers void enum_stack(lua_State *L); int on_error(lua_State *L); void print_error(lua_State *L, const char* fmt, ...); // dynamic type extention struct lua_value { virtual void to_lua(lua_State *L) = 0; }; // type trait template struct class_name; struct table; template struct if_ {}; template struct if_ { typedef A type; }; template struct if_ { typedef B type; }; template struct is_ptr { static const bool value = false; }; template struct is_ptr { static const bool value = true; }; template struct is_ref { static const bool value = false; }; template struct is_ref { static const bool value = true; }; template struct remove_const { typedef A type; }; template struct remove_const { typedef A type; }; template struct base_type { typedef A type; }; template struct base_type { typedef A type; }; template struct base_type { typedef A type; }; template struct class_type { typedef typename remove_const::type>::type type; }; template struct is_obj { static const bool value = true; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; template<> struct is_obj { static const bool value = false; }; ///////////////////////////////// enum { no = 1, yes = 2 }; typedef char (& no_type )[no]; typedef char (& yes_type)[yes]; struct int_conv_type { int_conv_type(int); }; no_type int_conv_tester (...); yes_type int_conv_tester (int_conv_type); no_type vfnd_ptr_tester (const volatile char *); no_type vfnd_ptr_tester (const volatile short *); no_type vfnd_ptr_tester (const volatile int *); no_type vfnd_ptr_tester (const volatile long *); no_type vfnd_ptr_tester (const volatile double *); no_type vfnd_ptr_tester (const volatile float *); no_type vfnd_ptr_tester (const volatile bool *); yes_type vfnd_ptr_tester (const volatile void *); template T* add_ptr(T&); template struct bool_to_yesno { typedef no_type type; }; template <> struct bool_to_yesno { typedef yes_type type; }; template struct is_enum { static T arg; static const bool value = ( (sizeof(int_conv_tester(arg)) == sizeof(yes_type)) && (sizeof(vfnd_ptr_tester(add_ptr(arg))) == sizeof(yes_type)) ); }; ///////////////////////////////// // from lua template struct void2val { static T invoke(void* input){ return *(T*)input; } }; template struct void2ptr { static T* invoke(void* input){ return (T*)input; } }; template struct void2ref { static T& invoke(void* input){ return *(T*)input; } }; template struct void2type { static T invoke(void* ptr) { return if_::value ,void2ptr::type> ,typename if_::value ,void2ref::type> ,void2val::type> >::type >::type::invoke(ptr); } }; struct user { user(void* p) : m_p(p) {} virtual ~user() {} void* m_p; }; template struct user2type { static T invoke(lua_State *L, int index) { return void2type::invoke(lua_touserdata(L, index)); } }; template struct lua2enum { static T invoke(lua_State *L, int index) { return (T)(int)lua_tonumber(L, index); } }; template struct lua2object { static T invoke(lua_State *L, int index) { if(!lua_isuserdata(L,index)) { lua_pushstring(L, "no class at first argument. (forgot ':' expression ?)"); lua_error(L); } return void2type::invoke(user2type::invoke(L,index)->m_p); } }; template T lua2type(lua_State *L, int index) { return if_::value ,lua2enum ,lua2object >::type::invoke(L, index); } template struct val2user : user { val2user() : user(new T) {} template val2user(T1 t1) : user(new T(t1)) {} template val2user(T1 t1, T2 t2) : user(new T(t1, t2)) {} template val2user(T1 t1, T2 t2, T3 t3) : user(new T(t1, t2, t3)) {} template val2user(T1 t1, T2 t2, T3 t3, T4 t4) : user(new T(t1, t2, t3,t4)) {} template val2user(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) : user(new T(t1, t2, t3,t4,t5)) {} ~val2user() { delete ((T*)m_p); } }; template struct ptr2user : user { ptr2user(T* t) : user((void*)t) {} }; template struct ref2user : user { ref2user(T& t) : user(&t) {} }; // to lua template struct val2lua { static void invoke(lua_State *L, T& input){ new(lua_newuserdata(L, sizeof(val2user))) val2user(input); } }; template struct ptr2lua { static void invoke(lua_State *L, T* input){ if(input) new(lua_newuserdata(L, sizeof(ptr2user))) ptr2user(input); else lua_pushnil(L); } }; template struct ref2lua { static void invoke(lua_State *L, T& input){ new(lua_newuserdata(L, sizeof(ref2user))) ref2user(input); } }; template struct enum2lua { static void invoke(lua_State *L, T val) { lua_pushnumber(L, (int)val); } }; template struct object2lua { static void invoke(lua_State *L, T val) { if_::value ,ptr2lua::type> ,typename if_::value ,ref2lua::type> ,val2lua::type> >::type >::type::invoke(L, val); push_meta(L, class_name::type>::name()); lua_setmetatable(L, -2); } }; template void type2lua(lua_State *L, T val) { if_::value ,enum2lua ,object2lua >::type::invoke(L, val); } // get value from cclosure template T upvalue_(lua_State *L) { return user2type::invoke(L, lua_upvalueindex(1)); } // read a value from lua stack template T read(lua_State *L, int index) { return lua2type(L, index); } template<> char* read(lua_State *L, int index); template<> const char* read(lua_State *L, int index); template<> char read(lua_State *L, int index); template<> unsigned char read(lua_State *L, int index); template<> short read(lua_State *L, int index); template<> unsigned short read(lua_State *L, int index); template<> long read(lua_State *L, int index); template<> unsigned long read(lua_State *L, int index); template<> int read(lua_State *L, int index); template<> unsigned int read(lua_State *L, int index); template<> float read(lua_State *L, int index); template<> double read(lua_State *L, int index); template<> bool read(lua_State *L, int index); template<> void read(lua_State *L, int index); template<> long long read(lua_State *L, int index); template<> unsigned long long read(lua_State *L, int index); template<> table read(lua_State *L, int index); // push a value to lua stack template void push(lua_State *L, T ret) { type2lua(L, ret); } template<> void push(lua_State *L, char ret); template<> void push(lua_State *L, unsigned char ret); template<> void push(lua_State *L, short ret); template<> void push(lua_State *L, unsigned short ret); template<> void push(lua_State *L, long ret); template<> void push(lua_State *L, unsigned long ret); template<> void push(lua_State *L, int ret); template<> void push(lua_State *L, unsigned int ret); template<> void push(lua_State *L, float ret); template<> void push(lua_State *L, double ret); template<> void push(lua_State *L, char* ret); template<> void push(lua_State *L, const char* ret); template<> void push(lua_State *L, bool ret); template<> void push(lua_State *L, lua_value* ret); template<> void push(lua_State *L, long long ret); template<> void push(lua_State *L, unsigned long long ret); template<> void push(lua_State *L, table ret); // pop a value from lua stack template T pop(lua_State *L) { T t = read(L, -1); lua_pop(L, 1); return t; } template<> void pop(lua_State *L); template<> table pop(lua_State *L); // functor (with return value) template struct functor { static int invoke(lua_State *L) { push(L,upvalue_(L)(read(L,1),read(L,2),read(L,3),read(L,4),read(L,5))); return 1; } }; template struct functor { static int invoke(lua_State *L) { push(L,upvalue_(L)(read(L,1),read(L,2),read(L,3),read(L,4))); return 1; } }; template struct functor { static int invoke(lua_State *L) { push(L,upvalue_(L)(read(L,1),read(L,2),read(L,3))); return 1; } }; template struct functor { static int invoke(lua_State *L) { push(L,upvalue_(L)(read(L,1),read(L,2))); return 1; } }; template struct functor { static int invoke(lua_State *L) { push(L,upvalue_(L)(read(L,1))); return 1; } }; template struct functor { static int invoke(lua_State *L) { push(L,upvalue_(L)()); return 1; } }; // functor (without return value) template struct functor { static int invoke(lua_State *L) { upvalue_(L)(read(L,1),read(L,2),read(L,3),read(L,4),read(L,5)); return 0; } }; template struct functor { static int invoke(lua_State *L) { upvalue_(L)(read(L,1),read(L,2),read(L,3),read(L,4)); return 0; } }; template struct functor { static int invoke(lua_State *L) { upvalue_(L)(read(L,1),read(L,2),read(L,3)); return 0; } }; template struct functor { static int invoke(lua_State *L) { upvalue_(L)(read(L,1),read(L,2)); return 0; } }; template struct functor { static int invoke(lua_State *L) { upvalue_(L)(read(L,1)); return 0; } }; template<> struct functor { static int invoke(lua_State *L) { upvalue_(L)(); return 0; } }; // functor (non-managed) template struct functor { static int invoke(lua_State *L) { return upvalue_(L)(L,read(L,1)); } }; template<> struct functor { static int invoke(lua_State *L) { return upvalue_(L)(L); } }; // push_functor template void push_functor(lua_State *L, RVal (*func)()) { lua_pushcclosure(L, functor::invoke, 1); } template void push_functor(lua_State *L, RVal (*func)(T1)) { lua_pushcclosure(L, functor::invoke, 1); } template void push_functor(lua_State *L, RVal (*func)(T1,T2)) { lua_pushcclosure(L, functor::invoke, 1); } template void push_functor(lua_State *L, RVal (*func)(T1,T2,T3)) { lua_pushcclosure(L, functor::invoke, 1); } template void push_functor(lua_State *L, RVal (*func)(T1,T2,T3,T4)) { lua_pushcclosure(L, functor::invoke, 1); } template void push_functor(lua_State *L, RVal (*func)(T1,T2,T3,T4,T5)) { lua_pushcclosure(L, functor::invoke, 1); } // member variable struct var_base { virtual void get(lua_State *L) = 0; virtual void set(lua_State *L) = 0; }; template struct mem_var : var_base { V T::*_var; mem_var(V T::*val) : _var(val) {} void get(lua_State *L) { push::value,V&,V>::type>(L, read(L,1)->*(_var)); } void set(lua_State *L) { read(L,1)->*(_var) = read(L, 3); } }; // class member functor (with return value) template struct mem_functor { static int invoke(lua_State *L) { push(L,(read(L,1)->*upvalue_(L))(read(L,2),read(L,3),read(L,4),read(L,5),read(L,6)));; return 1; } }; template struct mem_functor { static int invoke(lua_State *L) { push(L,(read(L,1)->*upvalue_(L))(read(L,2),read(L,3),read(L,4),read(L,5))); return 1; } }; template struct mem_functor { static int invoke(lua_State *L) { push(L,(read(L,1)->*upvalue_(L))(read(L,2),read(L,3),read(L,4))); return 1; } }; template struct mem_functor { static int invoke(lua_State *L) { push(L,(read(L,1)->*upvalue_(L))(read(L,2),read(L,3))); return 1; } }; template struct mem_functor { static int invoke(lua_State *L) { push(L,(read(L,1)->*upvalue_(L))(read(L,2))); return 1; } }; template struct mem_functor { static int invoke(lua_State *L) { push(L,(read(L,1)->*upvalue_(L))()); return 1; } }; // class member functor (without return value) template struct mem_functor { static int invoke(lua_State *L) { (read(L,1)->*upvalue_(L))(read(L,2),read(L,3),read(L,4),read(L,5),read(L,6)); return 0; } }; template struct mem_functor { static int invoke(lua_State *L) { (read(L,1)->*upvalue_(L))(read(L,2),read(L,3),read(L,4),read(L,5)); return 0; } }; template struct mem_functor { static int invoke(lua_State *L) { (read(L,1)->*upvalue_(L))(read(L,2),read(L,3),read(L,4)); return 0; } }; template struct mem_functor { static int invoke(lua_State *L) { (read(L,1)->*upvalue_(L))(read(L,2),read(L,3)); return 0; } }; template struct mem_functor { static int invoke(lua_State *L) { (read(L,1)->*upvalue_(L))(read(L,2)); return 0; } }; template struct mem_functor { static int invoke(lua_State *L) { (read(L,1)->*upvalue_(L))(); return 0; } }; // class member functor (non-managed) template struct mem_functor { static int invoke(lua_State *L) { return (read(L,1)->*upvalue_(L))(L, read(L,2)); } }; template struct mem_functor { static int invoke(lua_State *L) { return (read(L,1)->*upvalue_(L))(L); } }; // push_functor template void push_functor(lua_State *L, RVal (T::*func)()) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)() const) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1)) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1) const) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1,T2)) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1,T2) const) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1,T2,T3)) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1,T2,T3) const) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1,T2,T3,T4)) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1,T2,T3,T4) const) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1,T2,T3,T4,T5)) { lua_pushcclosure(L, mem_functor::invoke, 1); } template void push_functor(lua_State *L, RVal (T::*func)(T1,T2,T3,T4,T5) const) { lua_pushcclosure(L, mem_functor::invoke, 1); } // constructor template int constructor(lua_State *L) { new(lua_newuserdata(L, sizeof(val2user))) val2user(read(L,2),read(L,3),read(L,4),read(L,5),read(L,6)); push_meta(L, class_name::type>::name()); lua_setmetatable(L, -2); return 1; } template int constructor(lua_State *L) { new(lua_newuserdata(L, sizeof(val2user))) val2user(read(L,2),read(L,3),read(L,4),read(L,5)); push_meta(L, class_name::type>::name()); lua_setmetatable(L, -2); return 1; } template int constructor(lua_State *L) { new(lua_newuserdata(L, sizeof(val2user))) val2user(read(L,2),read(L,3),read(L,4)); push_meta(L, class_name::type>::name()); lua_setmetatable(L, -2); return 1; } template int constructor(lua_State *L) { new(lua_newuserdata(L, sizeof(val2user))) val2user(read(L,2),read(L,3)); push_meta(L, class_name::type>::name()); lua_setmetatable(L, -2); return 1; } template int constructor(lua_State *L) { new(lua_newuserdata(L, sizeof(val2user))) val2user(read(L,2)); push_meta(L, class_name::type>::name()); lua_setmetatable(L, -2); return 1; } template int constructor(lua_State *L) { new(lua_newuserdata(L, sizeof(val2user))) val2user(); push_meta(L, class_name::type>::name()); lua_setmetatable(L, -2); return 1; } // destroyer template int destroyer(lua_State *L) { ((user*)lua_touserdata(L, 1))->~user(); return 0; } // global function template void def(lua_State* L, const char* name, F func) { lua_pushstring(L, name); lua_pushlightuserdata(L, (void*)func); push_functor(L, func); lua_settable(L, LUA_GLOBALSINDEX); } // global variable template void set(lua_State* L, const char* name, T object) { lua_pushstring(L, name); push(L, object); lua_settable(L, LUA_GLOBALSINDEX); } template T get(lua_State* L, const char* name) { lua_pushstring(L, name); lua_gettable(L, LUA_GLOBALSINDEX); return pop(L); } template void decl(lua_State* L, const char* name, T object) { set(L, name, object); } // call template RVal call(lua_State* L, const char* name) { lua_pushcclosure(L, on_error, 0); int errfunc = lua_gettop(L); lua_pushstring(L, name); lua_gettable(L, LUA_GLOBALSINDEX); if(lua_isfunction(L,-1)) { lua_pcall(L, 0, 1, errfunc); } else { print_error(L, "lua_tinker::call() attempt to call global `%s' (not a function)", name); } lua_remove(L, errfunc); return pop(L); } template RVal call(lua_State* L, const char* name, T1 arg) { lua_pushcclosure(L, on_error, 0); int errfunc = lua_gettop(L); lua_pushstring(L, name); lua_gettable(L, LUA_GLOBALSINDEX); if(lua_isfunction(L,-1)) { push(L, arg); lua_pcall(L, 1, 1, errfunc); } else { print_error(L, "lua_tinker::call() attempt to call global `%s' (not a function)", name); } lua_remove(L, errfunc); return pop(L); } template RVal call(lua_State* L, const char* name, T1 arg1, T2 arg2) { lua_pushcclosure(L, on_error, 0); int errfunc = lua_gettop(L); lua_pushstring(L, name); lua_gettable(L, LUA_GLOBALSINDEX); if(lua_isfunction(L,-1)) { push(L, arg1); push(L, arg2); lua_pcall(L, 2, 1, errfunc); } else { print_error(L, "lua_tinker::call() attempt to call global `%s' (not a function)", name); } lua_remove(L, errfunc); return pop(L); } template RVal call(lua_State* L, const char* name, T1 arg1, T2 arg2, T3 arg3) { lua_pushcclosure(L, on_error, 0); int errfunc = lua_gettop(L); lua_pushstring(L, name); lua_gettable(L, LUA_GLOBALSINDEX); if(lua_isfunction(L,-1)) { push(L, arg1); push(L, arg2); push(L, arg3); lua_pcall(L, 3, 1, errfunc); } else { print_error(L, "lua_tinker::call() attempt to call global `%s' (not a function)", name); } lua_remove(L, errfunc); return pop(L); } // class helper int meta_get(lua_State *L); int meta_set(lua_State *L); void push_meta(lua_State *L, const char* name); // class init template void class_add(lua_State* L, const char* name) { class_name::name(name); lua_pushstring(L, name); lua_newtable(L); lua_pushstring(L, "__name"); lua_pushstring(L, name); lua_rawset(L, -3); lua_pushstring(L, "__index"); lua_pushcclosure(L, meta_get, 0); lua_rawset(L, -3); lua_pushstring(L, "__newindex"); lua_pushcclosure(L, meta_set, 0); lua_rawset(L, -3); lua_pushstring(L, "__gc"); lua_pushcclosure(L, destroyer, 0); lua_rawset(L, -3); lua_settable(L, LUA_GLOBALSINDEX); } // Tinker Class Inheritence template void class_inh(lua_State* L) { push_meta(L, class_name::name()); if(lua_istable(L, -1)) { lua_pushstring(L, "__parent"); push_meta(L, class_name

::name()); lua_rawset(L, -3); } lua_pop(L, 1); } // Tinker Class Constructor template void class_con(lua_State* L,F func) { push_meta(L, class_name::name()); if(lua_istable(L, -1)) { lua_newtable(L); lua_pushstring(L, "__call"); lua_pushcclosure(L, func, 0); lua_rawset(L, -3); lua_setmetatable(L, -2); } lua_pop(L, 1); } // Tinker Class Functions template void class_def(lua_State* L, const char* name, F func) { push_meta(L, class_name::name()); if(lua_istable(L, -1)) { lua_pushstring(L, name); new(lua_newuserdata(L,sizeof(F))) F(func); push_functor(L, func); lua_rawset(L, -3); } lua_pop(L, 1); } // Tinker Class Variables template void class_mem(lua_State* L, const char* name, VAR BASE::*val) { push_meta(L, class_name::name()); if(lua_istable(L, -1)) { lua_pushstring(L, name); new(lua_newuserdata(L,sizeof(mem_var))) mem_var(val); lua_rawset(L, -3); } lua_pop(L, 1); } template struct class_name { // global name static const char* name(const char* name = NULL) { static char temp[256] = ""; if(name) strcpy_s(temp, name); return temp; } }; // Table Object on Stack struct table_obj { table_obj(lua_State* L, int index); ~table_obj(); void inc_ref(); void dec_ref(); bool validate(); template void set(const char* name, T object) { if(validate()) { lua_pushstring(m_L, name); push(m_L, object); lua_settable(m_L, m_index); } } template T get(const char* name) { if(validate()) { lua_pushstring(m_L, name); lua_gettable(m_L, m_index); } else { lua_pushnil(m_L); } return pop(m_L); } lua_State* m_L; int m_index; const void* m_pointer; int m_ref; }; // Table Object Holder struct table { table(lua_State* L); table(lua_State* L, int index); table(lua_State* L, const char* name); table(const table& input); ~table(); template void set(const char* name, T object) { m_obj->set(name, object); } template T get(const char* name) { return m_obj->get(name); } table_obj* m_obj; }; } // namespace lua_tinker #endif //_LUA_TINKER_H_ ================================================ FILE: luaconf.h ================================================ /* ** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $ ** Configuration file for Lua ** See Copyright Notice in lua.h */ #ifndef lconfig_h #define lconfig_h #include #include /* ** ================================================================== ** Search for "@@" to find all configurable definitions. ** =================================================================== */ /* @@ LUA_ANSI controls the use of non-ansi features. ** CHANGE it (define it) if you want Lua to avoid the use of any ** non-ansi feature or library. */ #if defined(__STRICT_ANSI__) #define LUA_ANSI #endif #if !defined(LUA_ANSI) && defined(_WIN32) #define LUA_WIN #endif #if defined(LUA_USE_LINUX) #define LUA_USE_POSIX #define LUA_USE_DLOPEN /* needs an extra library: -ldl */ #define LUA_USE_READLINE /* needs some extra libraries */ #endif #if defined(LUA_USE_MACOSX) #define LUA_USE_POSIX #define LUA_DL_DYLD /* does not need extra library */ #endif /* @@ LUA_USE_POSIX includes all functionallity listed as X/Open System @* Interfaces Extension (XSI). ** CHANGE it (define it) if your system is XSI compatible. */ #if defined(LUA_USE_POSIX) #define LUA_USE_MKSTEMP #define LUA_USE_ISATTY #define LUA_USE_POPEN #define LUA_USE_ULONGJMP #endif /* @@ LUA_PATH and LUA_CPATH are the names of the environment variables that @* Lua check to set its paths. @@ LUA_INIT is the name of the environment variable that Lua @* checks for initialization code. ** CHANGE them if you want different names. */ #define LUA_PATH "LUA_PATH" #define LUA_CPATH "LUA_CPATH" #define LUA_INIT "LUA_INIT" /* @@ LUA_PATH_DEFAULT is the default path that Lua uses to look for @* Lua libraries. @@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for @* C libraries. ** CHANGE them if your machine has a non-conventional directory ** hierarchy or if you want to install your libraries in ** non-conventional directories. */ #if defined(_WIN32) /* ** In Windows, any exclamation mark ('!') in the path is replaced by the ** path of the directory of the executable file of the current process. */ #define LUA_LDIR "!\\lua\\" #define LUA_CDIR "!\\" #define LUA_PATH_DEFAULT \ ".\\?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua" #define LUA_CPATH_DEFAULT \ ".\\?.dll;" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll" #else #define LUA_ROOT "/usr/local/" #define LUA_LDIR LUA_ROOT "share/lua/5.1/" #define LUA_CDIR LUA_ROOT "lib/lua/5.1/" #define LUA_PATH_DEFAULT \ "./?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua" #define LUA_CPATH_DEFAULT \ "./?.so;" LUA_CDIR"?.so;" LUA_CDIR"loadall.so" #endif /* @@ LUA_DIRSEP is the directory separator (for submodules). ** CHANGE it if your machine does not use "/" as the directory separator ** and is not Windows. (On Windows Lua automatically uses "\".) */ #if defined(_WIN32) #define LUA_DIRSEP "\\" #else #define LUA_DIRSEP "/" #endif /* @@ LUA_PATHSEP is the character that separates templates in a path. @@ LUA_PATH_MARK is the string that marks the substitution points in a @* template. @@ LUA_EXECDIR in a Windows path is replaced by the executable's @* directory. @@ LUA_IGMARK is a mark to ignore all before it when bulding the @* luaopen_ function name. ** CHANGE them if for some reason your system cannot use those ** characters. (E.g., if one of those characters is a common character ** in file/directory names.) Probably you do not need to change them. */ #define LUA_PATHSEP ";" #define LUA_PATH_MARK "?" #define LUA_EXECDIR "!" #define LUA_IGMARK "-" /* @@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger. ** CHANGE that if ptrdiff_t is not adequate on your machine. (On most ** machines, ptrdiff_t gives a good choice between int or long.) */ #define LUA_INTEGER ptrdiff_t /* @@ LUA_API is a mark for all core API functions. @@ LUALIB_API is a mark for all standard library functions. ** CHANGE them if you need to define those functions in some special way. ** For instance, if you want to create one Windows DLL with the core and ** the libraries, you may want to use the following definition (define ** LUA_BUILD_AS_DLL to get it). */ #if defined(LUA_BUILD_AS_DLL) #if defined(LUA_CORE) || defined(LUA_LIB) #define LUA_API __declspec(dllexport) #else #define LUA_API __declspec(dllimport) #endif #else #define LUA_API extern #endif /* more often than not the libs go together with the core */ #define LUALIB_API LUA_API /* @@ LUAI_FUNC is a mark for all extern functions that are not to be @* exported to outside modules. @@ LUAI_DATA is a mark for all extern (const) variables that are not to @* be exported to outside modules. ** CHANGE them if you need to mark them in some special way. Elf/gcc ** (versions 3.2 and later) mark them as "hidden" to optimize access ** when Lua is compiled as a shared library. */ #if defined(luaall_c) #define LUAI_FUNC static #define LUAI_DATA /* empty */ #elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ defined(__ELF__) #define LUAI_FUNC __attribute__((visibility("hidden"))) extern #define LUAI_DATA LUAI_FUNC #else #define LUAI_FUNC extern #define LUAI_DATA extern #endif /* @@ LUA_QL describes how error messages quote program elements. ** CHANGE it if you want a different appearance. */ #define LUA_QL(x) "'" x "'" #define LUA_QS LUA_QL("%s") /* @@ LUA_IDSIZE gives the maximum size for the description of the source @* of a function in debug information. ** CHANGE it if you want a different size. */ #define LUA_IDSIZE 60 /* ** {================================================================== ** Stand-alone configuration ** =================================================================== */ #if defined(lua_c) || defined(luaall_c) /* @@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that @* is, whether we're running lua interactively). ** CHANGE it if you have a better definition for non-POSIX/non-Windows ** systems. */ #if defined(LUA_USE_ISATTY) #include #define lua_stdin_is_tty() isatty(0) #elif defined(LUA_WIN) #include #include #define lua_stdin_is_tty() _isatty(_fileno(stdin)) #else #define lua_stdin_is_tty() 1 /* assume stdin is a tty */ #endif /* @@ LUA_PROMPT is the default prompt used by stand-alone Lua. @@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua. ** CHANGE them if you want different prompts. (You can also change the ** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.) */ #define LUA_PROMPT "> " #define LUA_PROMPT2 ">> " /* @@ LUA_PROGNAME is the default name for the stand-alone Lua program. ** CHANGE it if your stand-alone interpreter has a different name and ** your system is not able to detect that name automatically. */ #define LUA_PROGNAME "lua" /* @@ LUA_MAXINPUT is the maximum length for an input line in the @* stand-alone interpreter. ** CHANGE it if you need longer lines. */ #define LUA_MAXINPUT 512 /* @@ lua_readline defines how to show a prompt and then read a line from @* the standard input. @@ lua_saveline defines how to "save" a read line in a "history". @@ lua_freeline defines how to free a line read by lua_readline. ** CHANGE them if you want to improve this functionality (e.g., by using ** GNU readline and history facilities). */ #if defined(LUA_USE_READLINE) #include #include #include #define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL) #define lua_saveline(L,idx) \ if (lua_strlen(L,idx) > 0) /* non-empty line? */ \ add_history(lua_tostring(L, idx)); /* add it to history */ #define lua_freeline(L,b) ((void)L, free(b)) #else #define lua_readline(L,b,p) \ ((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \ fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */ #define lua_saveline(L,idx) { (void)L; (void)idx; } #define lua_freeline(L,b) { (void)L; (void)b; } #endif #endif /* }================================================================== */ /* @@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles @* as a percentage. ** CHANGE it if you want the GC to run faster or slower (higher values ** mean larger pauses which mean slower collection.) You can also change ** this value dynamically. */ #define LUAI_GCPAUSE 200 /* 200% (wait memory to double before next GC) */ /* @@ LUAI_GCMUL defines the default speed of garbage collection relative to @* memory allocation as a percentage. ** CHANGE it if you want to change the granularity of the garbage ** collection. (Higher values mean coarser collections. 0 represents ** infinity, where each step performs a full collection.) You can also ** change this value dynamically. */ #define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */ /* @@ LUA_COMPAT_GETN controls compatibility with old getn behavior. ** CHANGE it (define it) if you want exact compatibility with the ** behavior of setn/getn in Lua 5.0. */ #undef LUA_COMPAT_GETN /* @@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib. ** CHANGE it to undefined as soon as you do not need a global 'loadlib' ** function (the function is still available as 'package.loadlib'). */ #undef LUA_COMPAT_LOADLIB /* @@ LUA_COMPAT_VARARG controls compatibility with old vararg feature. ** CHANGE it to undefined as soon as your programs use only '...' to ** access vararg parameters (instead of the old 'arg' table). */ #define LUA_COMPAT_VARARG /* @@ LUA_COMPAT_MOD controls compatibility with old math.mod function. ** CHANGE it to undefined as soon as your programs use 'math.fmod' or ** the new '%' operator instead of 'math.mod'. */ #define LUA_COMPAT_MOD /* @@ LUA_COMPAT_LSTR controls compatibility with old long string nesting @* facility. ** CHANGE it to 2 if you want the old behaviour, or undefine it to turn ** off the advisory error when nesting [[...]]. */ #define LUA_COMPAT_LSTR 1 /* @@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name. ** CHANGE it to undefined as soon as you rename 'string.gfind' to ** 'string.gmatch'. */ #define LUA_COMPAT_GFIND /* @@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib' @* behavior. ** CHANGE it to undefined as soon as you replace to 'luaL_register' ** your uses of 'luaL_openlib' */ #define LUA_COMPAT_OPENLIB /* @@ luai_apicheck is the assert macro used by the Lua-C API. ** CHANGE luai_apicheck if you want Lua to perform some checks in the ** parameters it gets from API calls. This may slow down the interpreter ** a bit, but may be quite useful when debugging C code that interfaces ** with Lua. A useful redefinition is to use assert.h. */ #if defined(LUA_USE_APICHECK) #include #define luai_apicheck(L,o) { (void)L; assert(o); } #else #define luai_apicheck(L,o) { (void)L; } #endif /* @@ LUAI_BITSINT defines the number of bits in an int. ** CHANGE here if Lua cannot automatically detect the number of bits of ** your machine. Probably you do not need to change this. */ /* avoid overflows in comparison */ #if INT_MAX-20 < 32760 #define LUAI_BITSINT 16 #elif INT_MAX > 2147483640L /* int has at least 32 bits */ #define LUAI_BITSINT 32 #else #error "you must define LUA_BITSINT with number of bits in an integer" #endif /* @@ LUAI_UINT32 is an unsigned integer with at least 32 bits. @@ LUAI_INT32 is an signed integer with at least 32 bits. @@ LUAI_UMEM is an unsigned integer big enough to count the total @* memory used by Lua. @@ LUAI_MEM is a signed integer big enough to count the total memory @* used by Lua. ** CHANGE here if for some weird reason the default definitions are not ** good enough for your machine. (The definitions in the 'else' ** part always works, but may waste space on machines with 64-bit ** longs.) Probably you do not need to change this. */ #if LUAI_BITSINT >= 32 #define LUAI_UINT32 unsigned int #define LUAI_INT32 int #define LUAI_MAXINT32 INT_MAX #define LUAI_UMEM size_t #define LUAI_MEM ptrdiff_t #else /* 16-bit ints */ #define LUAI_UINT32 unsigned long #define LUAI_INT32 long #define LUAI_MAXINT32 LONG_MAX #define LUAI_UMEM unsigned long #define LUAI_MEM long #endif /* @@ LUAI_MAXCALLS limits the number of nested calls. ** CHANGE it if you need really deep recursive calls. This limit is ** arbitrary; its only purpose is to stop infinite recursion before ** exhausting memory. */ #define LUAI_MAXCALLS 20000 /* @@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function @* can use. ** CHANGE it if you need lots of (Lua) stack space for your C ** functions. This limit is arbitrary; its only purpose is to stop C ** functions to consume unlimited stack space. (must be smaller than ** -LUA_REGISTRYINDEX) */ #define LUAI_MAXCSTACK 8000 /* ** {================================================================== ** CHANGE (to smaller values) the following definitions if your system ** has a small C stack. (Or you may want to change them to larger ** values if your system has a large C stack and these limits are ** too rigid for you.) Some of these constants control the size of ** stack-allocated arrays used by the compiler or the interpreter, while ** others limit the maximum number of recursive calls that the compiler ** or the interpreter can perform. Values too large may cause a C stack ** overflow for some forms of deep constructs. ** =================================================================== */ /* @@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and @* syntactical nested non-terminals in a program. */ #define LUAI_MAXCCALLS 200 /* @@ LUAI_MAXVARS is the maximum number of local variables per function @* (must be smaller than 250). */ #define LUAI_MAXVARS 200 /* @@ LUAI_MAXUPVALUES is the maximum number of upvalues per function @* (must be smaller than 250). */ #define LUAI_MAXUPVALUES 60 /* @@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. */ #define LUAL_BUFFERSIZE BUFSIZ /* }================================================================== */ /* ** {================================================================== @@ LUA_NUMBER is the type of numbers in Lua. ** CHANGE the following definitions only if you want to build Lua ** with a number type different from double. You may also need to ** change lua_number2int & lua_number2integer. ** =================================================================== */ #define LUA_NUMBER_DOUBLE #define LUA_NUMBER double /* @@ LUAI_UACNUMBER is the result of an 'usual argument conversion' @* over a number. */ #define LUAI_UACNUMBER double /* @@ LUA_NUMBER_SCAN is the format for reading numbers. @@ LUA_NUMBER_FMT is the format for writing numbers. @@ lua_number2str converts a number to a string. @@ LUAI_MAXNUMBER2STR is maximum size of previous conversion. @@ lua_str2number converts a string to a number. */ #define LUA_NUMBER_SCAN "%lf" #define LUA_NUMBER_FMT "%.14g" #define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) #define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */ #define lua_str2number(s,p) strtod((s), (p)) /* @@ The luai_num* macros define the primitive operations over numbers. */ #if defined(LUA_CORE) #include #define luai_numadd(a,b) ((a)+(b)) #define luai_numsub(a,b) ((a)-(b)) #define luai_nummul(a,b) ((a)*(b)) #define luai_numdiv(a,b) ((a)/(b)) #define luai_nummod(a,b) ((a) - floor((a)/(b))*(b)) #define luai_numpow(a,b) (pow(a,b)) #define luai_numunm(a) (-(a)) #define luai_numeq(a,b) ((a)==(b)) #define luai_numlt(a,b) ((a)<(b)) #define luai_numle(a,b) ((a)<=(b)) #define luai_numisnan(a) (!luai_numeq((a), (a))) #endif /* @@ lua_number2int is a macro to convert lua_Number to int. @@ lua_number2integer is a macro to convert lua_Number to lua_Integer. ** CHANGE them if you know a faster way to convert a lua_Number to ** int (with any rounding method and without throwing errors) in your ** system. In Pentium machines, a naive typecast from double to int ** in C is extremely slow, so any alternative is worth trying. */ /* On a Pentium, resort to a trick */ #if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \ (defined(__i386) || defined (_M_IX86) || defined(__i386__)) /* On a Microsoft compiler, use assembler */ #if defined(_MSC_VER) #define lua_number2int(i,d) __asm fld d __asm fistp i #define lua_number2integer(i,n) lua_number2int(i, n) /* the next trick should work on any Pentium, but sometimes clashes with a DirectX idiosyncrasy */ #else union luai_Cast { double l_d; long l_l; }; #define lua_number2int(i,d) \ { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; } #define lua_number2integer(i,n) lua_number2int(i, n) #endif /* this option always works, but may be slow */ #else #define lua_number2int(i,d) ((i)=(int)(d)) #define lua_number2integer(i,d) ((i)=(lua_Integer)(d)) #endif /* }================================================================== */ /* @@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment. ** CHANGE it if your system requires alignments larger than double. (For ** instance, if your system supports long doubles and they must be ** aligned in 16-byte boundaries, then you should add long double in the ** union.) Probably you do not need to change this. */ #define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; } /* @@ LUAI_THROW/LUAI_TRY define how Lua does exception handling. ** CHANGE them if you prefer to use longjmp/setjmp even with C++ ** or if want/don't to use _longjmp/_setjmp instead of regular ** longjmp/setjmp. By default, Lua handles errors with exceptions when ** compiling as C++ code, with _longjmp/_setjmp when asked to use them, ** and with longjmp/setjmp otherwise. */ #if defined(__cplusplus) /* C++ exceptions */ #define LUAI_THROW(L,c) throw(c) #define LUAI_TRY(L,c,a) try { a } catch(...) \ { if ((c)->status == 0) (c)->status = -1; } #define luai_jmpbuf int /* dummy variable */ #elif defined(LUA_USE_ULONGJMP) /* in Unix, try _longjmp/_setjmp (more efficient) */ #define LUAI_THROW(L,c) _longjmp((c)->b, 1) #define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } #define luai_jmpbuf jmp_buf #else /* default handling with long jumps */ #define LUAI_THROW(L,c) longjmp((c)->b, 1) #define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } #define luai_jmpbuf jmp_buf #endif /* @@ LUA_MAXCAPTURES is the maximum number of captures that a pattern @* can do during pattern-matching. ** CHANGE it if you need more captures. This limit is arbitrary. */ #define LUA_MAXCAPTURES 32 /* @@ lua_tmpnam is the function that the OS library uses to create a @* temporary name. @@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam. ** CHANGE them if you have an alternative to tmpnam (which is considered ** insecure) or if you want the original tmpnam anyway. By default, Lua ** uses tmpnam except when POSIX is available, where it uses mkstemp. */ #if defined(loslib_c) || defined(luaall_c) #if defined(LUA_USE_MKSTEMP) #include #define LUA_TMPNAMBUFSIZE 32 #define lua_tmpnam(b,e) { \ strcpy(b, "/tmp/lua_XXXXXX"); \ e = mkstemp(b); \ if (e != -1) close(e); \ e = (e == -1); } #else #define LUA_TMPNAMBUFSIZE L_tmpnam #define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } #endif #endif /* @@ lua_popen spawns a new process connected to the current one through @* the file streams. ** CHANGE it if you have a way to implement it in your system. */ #if defined(LUA_USE_POPEN) #define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m)) #define lua_pclose(L,file) ((void)L, (pclose(file) != -1)) #elif defined(LUA_WIN) #define lua_popen(L,c,m) ((void)L, _popen(c,m)) #define lua_pclose(L,file) ((void)L, (_pclose(file) != -1)) #else #define lua_popen(L,c,m) ((void)((void)c, m), \ luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0) #define lua_pclose(L,file) ((void)((void)L, file), 0) #endif /* @@ LUA_DL_* define which dynamic-library system Lua should use. ** CHANGE here if Lua has problems choosing the appropriate ** dynamic-library system for your platform (either Windows' DLL, Mac's ** dyld, or Unix's dlopen). If your system is some kind of Unix, there ** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for ** it. To use dlopen you also need to adapt the src/Makefile (probably ** adding -ldl to the linker options), so Lua does not select it ** automatically. (When you change the makefile to add -ldl, you must ** also add -DLUA_USE_DLOPEN.) ** If you do not want any kind of dynamic library, undefine all these ** options. ** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD. */ #if defined(LUA_USE_DLOPEN) #define LUA_DL_DLOPEN #endif #if defined(LUA_WIN) #define LUA_DL_DLL #endif /* @@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State @* (the data goes just *before* the lua_State pointer). ** CHANGE (define) this if you really need that. This value must be ** a multiple of the maximum alignment required for your machine. */ #define LUAI_EXTRASPACE 0 /* @@ luai_userstate* allow user-specific actions on threads. ** CHANGE them if you defined LUAI_EXTRASPACE and need to do something ** extra when a thread is created/deleted/resumed/yielded. */ #define luai_userstateopen(L) ((void)L) #define luai_userstateclose(L) ((void)L) #define luai_userstatethread(L,L1) ((void)L) #define luai_userstatefree(L) ((void)L) #define luai_userstateresume(L,n) ((void)L) #define luai_userstateyield(L,n) ((void)L) /* @@ LUA_INTFRMLEN is the length modifier for integer conversions @* in 'string.format'. @@ LUA_INTFRM_T is the integer type correspoding to the previous length @* modifier. ** CHANGE them if your system supports long long or does not support long. */ #if defined(LUA_USELONGLONG) #define LUA_INTFRMLEN "ll" #define LUA_INTFRM_T long long #else #define LUA_INTFRMLEN "l" #define LUA_INTFRM_T long #endif /* =================================================================== */ /* ** Local configuration. You can use this space to add your redefinitions ** without modifying the main part of the file. */ #endif ================================================ FILE: lualib.h ================================================ /* ** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $ ** Lua standard libraries ** See Copyright Notice in lua.h */ #ifndef lualib_h #define lualib_h #include "lua.h" /* Key to file-handle type */ #define LUA_FILEHANDLE "FILE*" #define LUA_COLIBNAME "coroutine" LUALIB_API int (luaopen_base) (lua_State *L); #define LUA_TABLIBNAME "table" LUALIB_API int (luaopen_table) (lua_State *L); #define LUA_IOLIBNAME "io" LUALIB_API int (luaopen_io) (lua_State *L); #define LUA_OSLIBNAME "os" LUALIB_API int (luaopen_os) (lua_State *L); #define LUA_STRLIBNAME "string" LUALIB_API int (luaopen_string) (lua_State *L); #define LUA_MATHLIBNAME "math" LUALIB_API int (luaopen_math) (lua_State *L); #define LUA_DBLIBNAME "debug" LUALIB_API int (luaopen_debug) (lua_State *L); #define LUA_LOADLIBNAME "package" LUALIB_API int (luaopen_package) (lua_State *L); /* open all previous libraries */ LUALIB_API void (luaL_openlibs) (lua_State *L); #ifndef lua_assert #define lua_assert(x) ((void)0) #endif #endif ================================================ FILE: sample1.cpp ================================================ // sample1.cpp : C++ Lua ȣ Լ ˾ƺ. // #include extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" }; #include "lua_tinker.h" int cpp_func(int arg1, int arg2) { return arg1 + arg2; } int main() { // Lua ʱȭ Ѵ. lua_State* L = lua_open(); // Lua ⺻ Լ εѴ.- print() luaopen_base(L); // LuaTinker ̿ؼ Լ Ѵ. lua_tinker::def(L, "cpp_func", cpp_func); // sample1.lua ε/Ѵ. lua_tinker::dofile(L, "sample1.lua"); // sample1.lua Լ ȣѴ. int result = lua_tinker::call(L, "lua_func", 3, 4); // lua_func(3,4) printf("lua_func(3,4) = %d\n", result); // α׷ lua_close(L); return 0; } ================================================ FILE: sample1.lua ================================================ -- C++ Լ ȣѴ. result = cpp_func(1, 2) print("cpp_func(1,2) = "..result) -- Ϲ lua Լ Ѵ. function lua_func(arg1, arg2) return arg1 + arg2 end ================================================ FILE: sample2.cpp ================================================ // sample2.cpp : C++ Lua ȣ ˾ƺ. // extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" }; #include "lua_tinker.h" static int cpp_int = 100; int main() { // Lua ʱȭ Ѵ. lua_State* L = lua_open(); // Lua ⺻ Լ εѴ.- print() luaopen_base(L); // LuaTinker ̿ؼ cpp_int Lua lua_tinker::set(L, "cpp_int", cpp_int); // sample1.lua ε/Ѵ. lua_tinker::dofile(L, "sample2.lua"); // sample1.lua Լ ȣѴ. int lua_int = lua_tinker::get(L, "lua_int"); // lua_int printf("lua_int = %d\n", lua_int); // α׷ lua_close(L); return 0; } ================================================ FILE: sample2.lua ================================================ -- C++ Ѵ. print("cpp_int = "..cpp_int) -- Lua ҴѴ. lua_int = 200 ================================================ FILE: sample3.cpp ================================================ // sample3.cpp : LuaTinker Ŭ ˾ƺ. // extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" }; #include "lua_tinker.h" struct A { A(int v) : value(v) {} int value; }; struct base { base() {} const char* is_base(){ return "this is base"; } }; class test : public base { public: test(int val) : _test(val) {} ~test() {} const char* is_test(){ return "this is test"; } void ret_void() {} int ret_int() { return _test; } int ret_mul(int m) const { return _test * m; } A get() { return A(_test); } void set(A a) { _test = a.value; } int _test; }; test g_test(11); int main() { // Lua ʱȭ Ѵ. lua_State* L = lua_open(); // Lua ⺻ Լ εѴ.- print() luaopen_base(L); // Lua ڿ Լ εѴ.- string luaopen_string(L); // base Ŭ Lua ߰Ѵ. lua_tinker::class_add(L, "base"); // base Լ Ѵ. lua_tinker::class_def(L, "is_base", &base::is_base); // test Ŭ Lua ߰Ѵ. lua_tinker::class_add(L, "test"); // test base ޾ ˷ش. lua_tinker::class_inh(L); // test Ŭ ڸ Ѵ. lua_tinker::class_con(L, lua_tinker::constructor); // test Լ Ѵ. lua_tinker::class_def(L, "is_test", &test::is_test); lua_tinker::class_def(L, "ret_void", &test::ret_void); lua_tinker::class_def(L, "ret_int", &test::ret_int); lua_tinker::class_def(L, "ret_mul", &test::ret_mul); lua_tinker::class_def(L, "get", &test::get); lua_tinker::class_def(L, "set", &test::set); lua_tinker::class_mem(L, "_test", &test::_test); // Lua ȣ g_test ͸ Ѵ. lua_tinker::set(L, "g_test", &g_test); // sample3.lua ε/Ѵ. lua_tinker::dofile(L, "sample3.lua"); // α׷ lua_close(L); return 0; } ================================================ FILE: sample3.lua ================================================ -- g_test _test Ѵ. print(g_test._test) -- const char* test::is_test() Լ Ѵ. print(g_test:is_test()) -- test::ret_int() Լ Ѵ. print(g_test:ret_int()) -- temp test ü ִ´. temp = test(4) -- test _test Ѵ. print(temp._test) -- Lua ߰ A ü a ִ´. a = g_test:get() -- ü a Lua->C++ Ѵ. temp:set(a) -- test::set(A a) Լ ȣ _test ȭ ȮѴ. print(temp._test) -- ӹ θ Լ ȣ print(temp:is_base()) -- ڱ ڽ Լ ȣ print(temp:is_test()) --  ü metatable ϵ Ŭ Լ 캸 Լ ------------------------------------------------------------------------------- function objinfo(obj) local meta = getmetatable(obj) if meta ~= nil then metainfo(meta) else print("no object infomation !!") end end function metainfo(meta) if meta ~= nil then local name = meta["__name"] if name ~= nil then metainfo(meta["__parent"]) print("<"..name..">") for key,value in pairs(meta) do if not string.find(key, "__..") then if type(value) == "function" then print("\t[f] "..name..":"..key.."()") elseif type(value) == "userdata" then print("\t[v] "..name..":"..key) end end end end end end ------------------------------------------------------------------------------- -- Lua ü userdata νĵȴ. print("g_test -> ", g_test) print("temp -> ", temp) print("a -> ", a) -- C++ g_test ü 캻. print("objinfo(g_test)") objinfo(g_test) -- constructor temp ü 캻. print("objinfo(temp)") objinfo(temp) -- A ü a ü 캻. print("objinfo(a)") objinfo(a) ================================================ FILE: sample4.cpp ================================================ // sample4.cpp : table ˾ƺ. // table ؼ stack table ؼ ȴ. // Lua ̺ ͸ ö󰡰 ü ο ȴ. // ߸ ԰ų Lua 鿡 ų ִ. extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" }; #include "lua_tinker.h" int main() { // Lua ʱȭ Ѵ. lua_State* L = lua_open(); // Lua ⺻ Լ εѴ.- print() luaopen_base(L); // Lua ̺ ϰ ÿ ǪѴ. lua_tinker::table haha(L, "haha"); // haha.value = 1 ִ´. haha.set("value", 1); // table table ִ´. haha.set("inside", lua_tinker::table(L)); // haha.inside ͸ Ѵ. lua_tinker::table inside = haha.get("inside"); // inside.value = 2 ִ´. inside.set("value", 2); // sample4.lua ε/Ѵ. lua_tinker::dofile(L, "sample4.lua"); // Lua haha.test д´. const char* test = haha.get("test"); printf("haha.test = %s\n", test); // ʰ Lua ÿ ̺ Ѵ.() lua_tinker::table temp(L); // ̺.name ִ´. temp.set("name", "local table !!"); // table ڷ Ͽ print_table ȣѴ. lua_tinker::call(L, "print_table", temp); // Լ ϴ table ޴´. lua_tinker::table ret = lua_tinker::call(L, "return_table", "give me a table !!"); printf("ret.name =\t%s\n", ret.get("name")); // α׷ lua_close(L); return 0; } ================================================ FILE: sample4.lua ================================================ -- haha ̺ ȮѴ. print(haha) -- haha.value Ѵ. print(haha.value) -- haha.inside ̺ ȮѴ. print(haha.inside) -- haha.inside.value Ѵ. print(haha.inside.value) -- haha.test ִ´. haha.test = "input from lua" -- LuaTinker Է ̺ ѱ. function print_table(arg) print("arg = ", arg) print("arg.name = ", arg.name) end -- LuaTinker ̺ ѱ. function return_table(arg) local ret = {} ret.name = arg return ret end ================================================ FILE: sample5.cpp ================================================ // sample5.cpp : Defines the entry point for the console application. // extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" }; #include "lua_tinker.h" void show_error(const char* error) { printf("_ALERT -> %s\n", error); } int main() { // Lua ʱȭ Ѵ. lua_State* L = lua_open(); // Lua ⺻ Լ εѴ.- print() luaopen_base(L); // lua_State* ִ ش. printf("%s\n","-------------------------- current stack"); lua_tinker::enum_stack(L); // ÿ 1 оִ´. lua_pushnumber(L, 1); // ٽ Ѵ. printf("%s\n","-------------------------- stack after push '1'"); lua_tinker::enum_stack(L); // sample5.lua ε/Ѵ. lua_tinker::dofile(L, "sample5.lua"); // test_error() Լ ȣѴ. // test_error() test_error_3() ȣ õϴ ߻Ų. // Լ ȣ ߻ printf() ؼ µȴ. printf("%s\n","-------------------------- calling test_error()"); lua_tinker::call(L, "test_error"); // test_error_3() ʴ Լ̴. ȣ ü Ѵ. printf("%s\n","-------------------------- calling test_error_3()"); lua_tinker::call(L, "test_error_3"); // printf() ϴ ƾ ִ. // ó Լ1 ڿ ߻ ϰ ȴ. // C++ void function(const char*) ° ϴ. lua_tinker::def(L, "_ALERT", show_error); lua_tinker::call(L, "_ALERT", "test !!!"); // test_error() Լ ȣѴ. // Լ ȣ ߻ Lua ϵ _ALERT() ؼ µȴ. printf("%s\n","-------------------------- calling test_error()"); lua_tinker::call(L, "test_error"); // α׷ lua_close(L); return 0; } ================================================ FILE: sample5.lua ================================================ -- ׽Ʈ Լ function test_error() print("test_error() called !!") test_error_1() end -- ׽Ʈ Լ function test_error_1() print("test_error_1() called !!") test_error_2() end -- ׽Ʈ Լ function test_error_2() print("test_error_2() called !!") -- ʴ Լ ȣ õѴ. test_error_3() end ================================================ FILE: sample6.cpp ================================================ // sample3.cpp : LuaTinker Ŭ ˾ƺ. // extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" }; #include "lua_tinker.h" // Լ ° int(*)(lua_State*) Ǵ int(*)(lua_State*,T1) 츸 lua_yield() ִ. // Լ ڰ ʿ lua_tinker.h "functor (non-managed)" ڸƮ κ ؼ ߰ int TestFunc(lua_State* L) { printf("# TestFunc \n"); return lua_yield(L, 0); } int TestFunc2(lua_State* L, float a) { printf("# TestFunc2(L,%f) \n", a); return lua_yield(L, 0); } class TestClass { public: // Լ ° int(T::*)(lua_State*) Ǵ int(T::*)(lua_State*,T1) 츸 lua_yield() ִ. // Լ ڰ ʿ lua_tinker.h "class member functor (non-managed)" ڸƮ κ ؼ ߰ int TestFunc(lua_State* L) { printf("# TestClass::TestFunc \n"); return lua_yield(L, 0); } int TestFunc2(lua_State* L, float a) { printf("# TestClass::TestFunc2(L,%f) \n", a); return lua_yield(L, 0); } }; int main() { // Lua ʱȭ Ѵ. lua_State* L = lua_open(); // Lua ⺻ Լ εѴ.- print() luaopen_base(L); // Lua ڿ Լ εѴ.- string luaopen_string(L); // TestFunc Լ Lua Ѵ. lua_tinker::def(L, "TestFunc", &TestFunc); lua_tinker::def(L, "TestFunc2", &TestFunc2); // TestClass Ŭ Lua ߰Ѵ. lua_tinker::class_add(L, "TestClass"); // TestClass Լ Ѵ. lua_tinker::class_def(L, "TestFunc", &TestClass::TestFunc); lua_tinker::class_def(L, "TestFunc2", &TestClass::TestFunc2); // TestClass Ѵ. TestClass g_test; lua_tinker::set(L, "g_test", &g_test); // sample3.lua εѴ. lua_tinker::dofile(L, "sample6.lua"); // Thread Ѵ. lua_newthread(L); lua_pushstring(L, "ThreadTest"); lua_gettable(L, LUA_GLOBALSINDEX); // Thread Ѵ. printf("* lua_resume() ȣ\n"); lua_resume(L, 0); // Thread ٽ Ѵ. printf("* lua_resume() ȣ\n"); lua_resume(L, 0); // Thread ٽ Ѵ. printf("* lua_resume() ȣ\n"); lua_resume(L, 0); // Thread ٽ Ѵ. printf("* lua_resume() ȣ\n"); lua_resume(L, 0); // Thread ٽ Ѵ. printf("* lua_resume() ȣ\n"); lua_resume(L, 0); // α׷ lua_close(L); return 0; } ================================================ FILE: sample6.lua ================================================ -- lua coroutine ׽Ʈ Լ function ThreadTest() print("ThreadTest ") print("TestFunc ȣ") -- ο lua_yield() ȣȴ. TestFunc() TestFunc2(1.2) print("TestFunc ") print("g_test::TestFunc() ȣ") -- ο lua_yield() ȣȴ. g_test:TestFunc() g_test:TestFunc2(2.3) print("g_test::TestFunc() ") print("ThreadTest ") end