Lua53

__forceinline

// lua.hpp
// Lua header files for C++
// <<extern "C">> not supplied automatically because Lua also compiles as C++

extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

#ifdef __cplusplus
/** \brief lua
*
*  lua
*/

#ifndef nullptr
#define nullptr 0
#endif // nullptr

class LUA_API Lua
{
public:
lua_State *L;
/*
** state manipulation
*/

public:
Lua(lua_Alloc f, void *ud):L(nullptr)
{
L = lua_newstate(f,ud);
}
Lua():L(NULL){
L = luaL_newstate();
}
~Lua()
{
if (L)
{
lua_close(L);
L = nullptr;
}
}
//
inline
lua_State *NewThread(){
return lua_newthread(L);
}

//
inline
lua_CFunction atpanic(lua_CFunction panicf){
return lua_atpanic(L, panicf);
}

//
inline
const lua_Number *verson(){
return lua_version(L);
}

/*
** basic stack manipulation
*/
public:
inline
int absindex(int idx){
return lua_absindex(L,idx);
}

inline
int   gettop(){
return lua_gettop(L);
}
inline
void  settop( int idx){
return lua_settop(L, idx);
}
inline
void  pushvalue( int idx){
return lua_pushvalue(L,idx);
}
inline
void  rotate( int idx, int n){
return lua_rotate(L,idx,n);
}
inline
void  copy( int fromidx, int toidx){
return lua_copy(L, fromidx, toidx);
}
inline
int   checkstack( int n){
return lua_checkstack(L,n);
}

inline
void  xmove(lua_State *to, int n){
return lua_xmove(L, to,n);
}

/*
** access functions (stack -> C)
*/

inline
int             isnumber( int idx){
return lua_isnumber(L, idx);
}
inline
int             isstring( int idx){
return lua_isstring(L, idx);
}
inline
int             iscfunction( int idx){
return lua_isfunction(L,idx);
}
inline
int             isinteger( int idx){
return lua_isinteger(L,idx);
}
inline
int isuserdata( int idx){
return lua_isuserdata(L,idx);
}
inline
int             type( int idx){
return lua_type(L,idx);
}
inline
const char     *typename( int tp){
return lua_typename(L,tp);
}

inline
lua_Number      tonumberx( int idx, int *isnum){
return lua_tonumberx(L,idx, isnum);
}
inline
lua_Integer     tointegerx( int idx, int *isnum){
return lua_tointeger(L, idx, isnum);
}
inline
int             toboolean( int idx){
return lua_toboolean(L, idx);
}
inline
const char     *tolstring( int idx, size_t *len){
return lua_tolstring(L,idx, len);
}
inline
size_t          rawlen( int idx){
return lua_rawlen(L,idx);
}
inline
lua_CFunction   tocfunction( int idx){
return lua_tocfunction(L,idx);
}
inline
void           *touserdata( int idx){
return lua_touserdata(L,idx);
}
inline
lua_State      *tothread( int idx){
return lua_tothread(L,idx);
}
inline
const void     *topointer( int idx){
return lua_topointer(L,idx);
}

/*
** Comparison and arithmetic functions
*/

inline
void  arith( int op){
lua_arith(L,op);
}

inline
int   rawequal( int idx1, int idx2){
return lua_rawequal(L, idx1, idx2);
}
inline
int   compare( int idx1, int idx2, int op){
return lua_compare(L, idx1, idx2, op);
}

/*
** push functions (C -> stack)
*/
inline
void        pushnil(){
lua_pushnil(L);
}
inline
void        pushnumber( lua_Number n){
lua_pushnumber(L, n);
}
inline
void        pushinteger( lua_Integer n){
lua_pushinteger(L, n);
}
inline
const char *pushlstring( const char *s, size_t len){
return lua_pushlstring(L,s,len);
}
inline
const char *pushstring( const char *s){
return lua_pushstring(L, s);
}
inline
const char *pushvfstring( const char *fmt,va_list argp){
return lua_pushvfstring(L, ftm, argp);
}
//check     lua_pushfstring
//implete no same
const char *pushfstring( const char *fmt, ...){
const char *ret;
va_list argp;
va_start(argp, fmt);
ret = pushvfstring(L, fmt, argp);
va_end(argp);
return ret;
}
inline
void  pushcclosure( lua_CFunction fn, int n){
lua_pushcclosure(L,fn,n);
}
inline
void  pushboolean( int b){
lua_pushboolean(L,b);
}
inline
void  pushlightuserdata( void *p){
lua_pushlightuserdata(L,p);
}
inline
int   pushthread(){
return lua_pushthread(L);
}

/*
** get functions (Lua -> stack)
*/
inline
int getglobal( const char *name){
return lua_getglobal(L, name);
}
inline
int gettable( int idx){
return lua_gettable(L, idx);
}
inline
int getfield( int idx, const char *k){
return lua_getfield(L,idx,k);
}
inline
int geti( int idx, lua_Integer n){
return lua_geti(L,idx,n);
}
inline
int rawget( int idx){
return lua_rawget(L,idx);
}
inline
int rawgeti( int idx, lua_Integer n){
return lua_rawgeti(L,idx,n);
}
inline
int rawgetp( int idx, const void *p){
return lua_rawgetp(L,idx,p);
}

inline
void  createtable( int narry, int nrec){
return lua_createtable(L,narry,nrec);
}
inline
void *newuserdata( size_t sz){
return lua_newuserdata(L,sz);
}
inline
int   getmetatable( int objindex){
return lua_getmetatable(L,objindex);
}
inline
int  getuservalue( int idx){
return lua_getuservalue(L,idx);

}

/*
** set functions (stack -> Lua)
*/
inline
void  setglobal( const char *name){
lua_setglobal(L,name);
}
inline
void  settable( int idx){
lua_settable(L,idx);
}
inline
void  setfield( int idx, const char *k){
lua_setfield(L,idx,k);
}
inline
void  seti( int idx, lua_Integer n){
lua_seti(L,idx,n);
}
inline
void  rawset( int idx){
lua_rawset(L,idx);
}
inline
void  rawseti( int idx, lua_Integer n){
lua_rawseti(L,idx,n);
}
inline
void  rawsetp( int idx, const void *p){
lua_rawsetp(L,idx,p);
}
inline
int   setmetatable( int objindex){
return lua_setmetatable(L,objindex);
}
inline
void  setuservalue( int idx){
lua_setuservalue(L,idx);
}

/*
** 'load' and 'call' functions (load and run Lua code)
*/
inline
void  callk( int nargs, int nresults,lua_KContext ctx, lua_KFunction k){
lua_callk(L,nargs,nresults, ctx,k);
}
//#define lua_call(L,n,r)       lua_callk(L, (n), (r), 0, NULL)
inline
void call(int nargs,int nresults){
lua_call(L,nargs,nresults,0,NULL)
}

inline
int   pcallk( int nargs, int nresults, int errfunc,lua_KContext ctx,
lua_KFunction k){
return lua_pcallk(L,nargs, nresults, errfunc, ctx,k);
}
//#define lua_pcall(L,n,r,f)    lua_pcallk(L, (n), (r), (f), 0, NULL)
inline
void pcall( int nargs, int nresults int errfunc){
lua_pcallk(L,nargs,nresults,errfuc,0,NULL);
}

inline
int   load( lua_Reader reader, void *dt,const char *chunkname,
const char *mode ){
return lua_load(L,reader,data,chunkname,mode);
}

inline
int dump( lua_Writer writer, void *data, int strip){
return lua_dump(L,writer,data,strip);
}

/*
** coroutine functions
*/
inline
int  yieldk( int nresults, lua_KContext ctx,lua_KFunction k){
return lua_yieldk(L,nresults, ctx,k);
}
inline
int  resume( lua_State *from, int narg){
return lua_resume(L,from,narg);
}
inline
int  status(){
return lua_status(L);
}
inline
int isyieldable(){
return lua_isyieldable(L);
}

//#define lua_yield(L,n)        lua_yieldk(L, (n), 0, NULL)
inline
int yield(int nresults){
return lua_yieldk(L,nresults,0,NULL);
}

/*
** garbage-collection function and options
*/

inline
int gc( int what, int data){
return lua_gc(L,what,data);
}

/*
** miscellaneous functions
*/

inline
int   error(){
return lua_error(L);
}

inline
int   next( int idx){
return lua_next(L,idx);
}

inline
void  concat( int n){
lua_concat(L,n);
}
inline
void  len( int idx){
lua_len(L,idx);
}

inline
size_t   stringtonumber( const char *s){
return lua_stringtonumber(L,s);
}

inline
lua_Alloc getallocf( void **ud){
return lua_getallocf(L,ud);
}
inline
void      setallocf( lua_Alloc f, void *ud){
lua_setallocf(L,f,ud);
}

/*
** {==============================================================
** some useful macros
** ===============================================================
*/

//#define lua_getextraspace(L)  ((void *)((char *)(L) - LUA_EXTRASPACE))
inline
void * getextraspace(){
return ((void *)((char *)(L) - LUA_EXTRASPACE));
}
//#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL)
inline
lua_Number tonumber(int idx){
return lua_tonumberx(L,idx,NULL);
}
//#define lua_tointeger(L,i)    lua_tointegerx(L,(i),NULL)
inline
lua_Integer tointeger(ind idx){
return lua_tointegerx(L,idx,NULL);
}

//#define lua_pop(L,n)      lua_settop(L, -(n)-1)
inline
void pop(int idx){
lua_settop(L,idx);
}

//#define lua_newtable(L)       lua_createtable(L, 0, 0)
inline
void newtable(){
lua_createtable(L,0,0);
}

//#define lua_pushcfunction(L,f)    lua_pushcclosure(L, (f), 0)
inline
void pushcfunction(lua_CFunction f){
lua_pushcclosure(L,f,0);
}
//#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
inline
void register(lua_CFunction f, const char *name){
pushcfunction(f);
setglobal(n);
}
//    #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)  vtype(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)
inline
bool isfunction(int n) { return (lua_type(L, n) ==LUA_TFUNCTION);}
inline
bool istable(int n){ return (lua_type(L, n) == LUA_TTABLE);}
inline
bool islightuserdata(int n) { return (lua_type(L, n)== LUA_TLIGHTUSERDATA);}
inline
bool isnil(int n)       { return (lua_type(L, n) == LUA_TNIL);}
inline
bool isboolean(int n)   { return (lua_type(L, n) == LUA_TBOOLEAN);}
inline
bool isthread(int n)    { return (lua_type(L, n) == LUA_TTHREAD);}
inline
bool isnone(int n)      { return (lua_type(L, n) == LUA_TNONE);}
inline
bool isnoneornil(int n) { return (lua_type(L, n) <= 0);}

//#define lua_pushliteral(L, s) lua_pushstring(L, "" s)
inline
const char *pushliteral(const char *s){
return lua_pushstring(L,""s);
}

//#define lua_pushglobaltable(L)  \
lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
inline
int pushglobaltable(){
return lua_rawgeti(L,LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS);
}

//#define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
inline
int tostring(int idx){
return lua_tolstring(L,idx,NULL);
}

//#define lua_insert(L,idx) lua_rotate(L, (idx), 1)
inline
void insert(int idx){
lua_rotate(L,idx,1);
}

//#define lua_remove(L,idx) lua_rotate(L, (idx), -1), lua_pop(L, 1))
inline
void remove(int idx){
lua_rotate(L,idx,-1);
//lua_pop(L,1);//pop(1)
lua_settop(L,1);
}

//#define lua_replace(L,idx)    lua_copy(L, -1, (idx)), lua_pop(L, 1))
inline
void replace(int idx){
lua_copy(L,-1,idx);
lua_settop(L,1);
}

/* }============================================================== */

/*
** {==============================================================
** compatibility macros for unsigned conversions
** ===============================================================
*/
#if defined(LUA_COMPAT_APIINTCASTS)

//#define lua_pushunsigned(L,n) lua_pushinteger(L, Integer)(n))
inline
void pushnsigned(lua_Integer n){
lua_pushinteger(L,n);
}
//#define lua_tounsignedx(L,i,is)   (Unsigned)lua_tointegerx(L,i,is))
inline
Unsigned tounsignedx(int idx, int *pisnum){
return (Unsigned)lua_tointegerx(L,idx, pisnum);
}
//#define lua_tounsigned(L,i)   lua_tounsignedx(L,(i),NULL)
inline
Unsigned tounsigned(int idx){
return (Unsigned)lua_tointegerx(L,idx, NULL);
}

#endif
/* }============================================================== */

/*
** {======================================================================
** Debug API
** =======================================================================
*/

/* activation record */

/* Functions to be called by the debugger in specific events */
inline void Hook( lua_Debug *ar ){
lua_Hook(L,ar);
}

inline
int getstack( int level, lua_Debug *ar){
return lua_getstack(L,level, ar);
}
inline
int getinfo( const char *what, lua_Debug *ar){
return lua_getinfo(L,what, ar);
}
inline
const char *getlocal( const lua_Debug *ar, int n){
return lua_getlocal(L,ar,n);
}
inline
const char *setlocal( const lua_Debug *ar, int n){
return lua_setlocal(L,ar,n);
}
inline
const char *getupvalue( int funcindex, int n){
return lua_getupvalue(L,funcindex,n);
}
inline
const char *setupvalue( int funcindex, int n){
return lua_setupvalue(L,funcindex, n);
}

inline
void *upvalueid( int fidx, int n){
return lua_upvalueid(L,fidx,n);
}
inline
void  upvaluejoin( int fidx1, int n1,int fidx2, int n2){
lua_upvaluejoin(L,fidx1, n1, fidx2, n2);
}

inline
void sethook( lua_Hook func, int mask, int count){
lua_sethook(L,func,mask,count);
}
inline
lua_Hook gethook(){
return lua_gethook(L);
}
inline
int gethookmask(){
return lua_gethookmask(L);
}
inline
int gethookcount(){
return lua_gethookcount(L);
}

/********************************************//**
*
* AuxLib
*
***********************************************/

inline
void L_checkversion_(lua_Number ver, size_t sz){
luaL_checkversion_(L,ver,sz);
}
void L_checkversion(){
luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES);
}
inline
int L_getmetafield( int obj, const char *e){
return luaL_getmetafield(L,obj,e);
}
inline
int L_callmeta ( int obj, const char *e){
return luaL_callmeta(L,obj,e);
}
inline
const char *L_tolstring(int idx, size_t *len){
return luaL_tolstring(L,idx,len);
}
inline
int L_argerror( int arg, const char *extramsg){
return luaL_argerror(L,arg,extramsg);
}
inline
const char *L_checklstring(int arg, size_t *l){
return luaL_checklstring(L,arg,l)
}
inline
const char *L_optlstring(int arg, const char *def, size_t *l){
return luaL_optlstring(L,arg,def,l);
}
inline
lua_Number L_checknumber(int arg){
return luaL_checknumber(L,arg);
}
inline
lua_Number L_optnumber(int arg, lua_Number def){
return luaL_optnumber(L,arg,def);
}

inline
lua_Integer L_checkinteger(int arg){
return luaL_checkinteger(L,arg);
}
inline
lua_Integer L_optinteger(int arg,lua_Integer def){
return luaL_optinteger(L,arg,def);
}

inline
void L_checkstack(int sz, const char *msg){
luaL_checkstack(L,sz,msg);
}
inline
void L_checktype(int arg, int t){
luaL_checktype(L,arg,t);
}
inline
void L_checkany(int arg){
luaL_checkany(L,arg);
}

inline
int   L_newmetatable(const char *tname){
return luaL_newmetatable(L,tname);
}
inline
void  L_setmetatable(const char *tname){
return luaL_setmetatable(L,tname);
}
inline
void *L_testudata(int ud, const char *tname){
return luaL_testudata(L,ud,tname);
}
inline
void *L_checkudata(int ud, const char *tname){
return luaL_checkudata(L,ud,tname);
}

inline
void L_where(int lvl){
luaL_where(L,lvl);
}
inline
int L_error(const char *fmt, ...){
va_list argp;
va_start(argp, fmt);
luaL_where(L, 1);
lua_pushvfstring(L, fmt, argp);
va_end(argp);
lua_concat(L, 2);
return lua_error(L);
}

inline
int L_checkoption(int arg, const char *def,const char *const lst[]){
return luaL_checkoption(L,arg,def,lst);
}

inline
int L_fileresult(int stat, const char *fname){
return luaL_fileresult(L,stat,fname);
}
inline
int L_execresult(int stat){
return luaL_execresult(L,stat);
}

/* pre-defined references */

inline
int L_ref(int t){
return luaL_ref(L,t);
}
inline
void L_unref(int t, int ref){
luaL_unref(L,t,ref);
}

inline
int L_loadfilex(const char *filename,const char *mode){
return luaL_loadfilex(L,filename,mode);
}

// luaL_loadfile(L,f)  luaL_loadfilex(L,f,NULL)
inline
int L_loadfile(const char *filename){
return luaL_loadfilex(L,filename,NULL);
}

inline
int L_loadbufferx(const char *buff, size_t sz,
const char *name, const char *mode){
return luaL_loadbufferx(L,buff,sz,name,mode);
}
inline
int L_loadstring(const char *s){
return luaL_loadstring(L,s);
}

inline
lua_State *L_newstate) (void){
return luaL_newstate()
}

inline
lua_Integer L_len(int idx){
return luaL_len(L,idx);
}

inline
const char *L_gsub(const char *s, const char *p,
const char *r){
return luaL_gsub(L,s,p,r);
}

inline
void L_setfuncs(const luaL_Reg *l, int nup){
luaL_setfuncs(L,l,nup);
}

inline
int L_getsubtable(int idx, const char *fname){
return luaL_getsubtable(L,idx,fname);
}

inline
void L_traceback(lua_State *L1,const char *msg, int level){
return luaL_traceback(L,L1,msg,level);
}

inline
void L_requiref(const char *modname,
lua_CFunction openf, int glb){
luaL_requiref(L,modname,openf,glb);
}

/*
** ===============================================================
** some useful macros
** ===============================================================
*/

inline
void L_newlibtabl(const char *name){
lua_createtable(L,0,sizeof(l)/sizeof((l)[0]) - 1);
}

inline
void L_newlib(const char *l){
luaL_checkversion(L);
luaL_newlibtable(L,l);
luaL_setfuncs(L,l,0);
}

inline
void L_argcheck(int cond,
int numarg,
const char *extramsg){
((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
}
inline
const char * L_checkstring(){
return luaL_checklstring(L, (n), NULL);
}
inline
const char * L_optstring ( int arg, const char *def){
return luaL_optlstring(L, (arg), (d), NULL);
}

inline
const char * L_typename(int idx){
return lua_typename(L, lua_type(L,(i)));
}

inline
int L_dofile(const char *fn){
return (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0));
}

inline
int L_dostring(const char *fn){
return (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0));
}

inline
int L_getmetatable(const char *fn){
return (lua_getfield(L, LUA_REGISTRYINDEX, (n)));
}

inline
int L_loadbuffer(const char *buff, size_t size,
const char *name)
return luaL_loadbufferx(L,s,sz,n,NULL);
}

/* compatibility with old module system */
#if defined(LUA_COMPAT_MODULE)

inline
void L_pushmodule(const char *modname,
int sizehint){
luaL_pushmodule(L,modname,sizehint);
}
inline
void L_openlib(const char *libname,
const luaL_Reg *l, int nup){
return luaL_openlib(L,libname,l,nup);
}

inline
void L_register( const char *n,
const luaL_Reg *l){
(luaL_openlib(L,(n),(l),0));
}

#endif

};
#endif //__cplusplus