Lua53

简单包装,未测试.如果inline报错.可以修改项目配置或者加__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