Script() :
- state_(luaL_newstate())
+ mState(luaL_newstate())
{
- lua_pushlightuserdata(state_, this);
- lua_setfield(state_, LUA_REGISTRYINDEX, "_script_obj");
+ lua_pushlightuserdata(mState, this);
+ lua_setfield(mState, LUA_REGISTRYINDEX, "_script_obj");
}
~Script()
{
- if (isMainThread_) lua_close(state_);
+ if (mIsMainThread) lua_close(mState);
}
void importStandardLibraries()
{
- luaL_openlibs(state_);
+ luaL_openlibs(mState);
}
void importFunction(const std::string& name, const Function& function)
{
push(function);
- lua_setglobal(state_, name.c_str());
+ lua_setglobal(mState, name.c_str());
}
STATUS doString(const std::string& commands)
{
- return (STATUS)luaL_dostring(state_, commands.c_str());
+ return (STATUS)luaL_dostring(mState, commands.c_str());
}
STATUS doFile(const std::string& file)
{
- return (STATUS)luaL_dofile(state_, file.c_str());
+ return (STATUS)luaL_dofile(mState, file.c_str());
}
Script pushNewThread()
{
- return Script(state_);
+ return Script(mState);
}
void pushThread()
{
- lua_pushthread(state_);
+ lua_pushthread(mState);
}
STATUS resume(int nargs)
{
- return (STATUS)lua_resume(state_, nargs);
+ return (STATUS)lua_resume(mState, nargs);
}
STATUS getStatus() const
{
- return (STATUS)lua_status(state_);
+ return (STATUS)lua_status(mState);
}
int yield(int results)
{
- return lua_yield(state_, results);
+ return lua_yield(mState, results);
}
bool isMainThread() const
{
- return isMainThread_;
+ return mIsMainThread;
}
void throwError()
{
- lua_error(state_);
+ lua_error(mState);
}
Value getGlobalTable() const
{
- return Value(state_, GLOBALS);
+ return Value(mState, GLOBALS);
}
Value getRegistryTable() const
{
- return Value(state_, REGISTRY);
+ return Value(mState, REGISTRY);
}
Value getEnvironmentTable() const
{
- return Value(state_, ENVIRONMENT);
+ return Value(mState, ENVIRONMENT);
}
Value getTop() const
{
- return Value(state_, lua_gettop(state_));
+ return Value(mState, lua_gettop(mState));
}
/**
int getSize() const
{
- return lua_gettop(state_);
+ return lua_gettop(mState);
}
void setSize(int size)
{
- lua_settop(state_, size);
+ lua_settop(mState, size);
}
void clear()
bool checkStack(int extra)
{
- return (bool)lua_checkstack(state_, extra);
+ return (bool)lua_checkstack(mState, extra);
}
void concat(int n)
{
- lua_concat(state_, n);
+ lua_concat(mState, n);
}
template <typename T>
void push(T value)
{
- lua_pushinteger(state_, lua_Integer(value));
+ lua_pushinteger(mState, lua_Integer(value));
}
void push(bool value)
{
- lua_pushboolean(state_, int(value));
+ lua_pushboolean(mState, int(value));
}
void push(float value)
{
- lua_pushnumber(state_, (lua_Number)value);
+ lua_pushnumber(mState, (lua_Number)value);
}
void push(double value)
{
- lua_pushnumber(state_, (lua_Number)value);
+ lua_pushnumber(mState, (lua_Number)value);
}
void push(const std::string& value)
{
- lua_pushlstring(state_, value.c_str(), value.length());
+ lua_pushlstring(mState, value.c_str(), value.length());
}
void push(const char* value)
{
- lua_pushstring(state_, value);
+ lua_pushstring(mState, value);
}
void push(const char* value, size_t length)
{
- lua_pushlstring(state_, value, length);
+ lua_pushlstring(mState, value, length);
}
void push(const Function& function)
{
- functions_.push_back(function);
+ mFunctions.push_back(function);
- lua_pushlightuserdata(state_, (void*)&functions_.back());
- lua_pushcclosure(state_, dispatchCall, 1);
+ lua_pushlightuserdata(mState, (void*)&mFunctions.back());
+ lua_pushcclosure(mState, dispatchCall, 1);
}
void push(void* data)
{
- lua_pushlightuserdata(state_, data);
+ lua_pushlightuserdata(mState, data);
}
void pushNil()
{
- lua_pushnil(state_);
+ lua_pushnil(mState);
}
void pushFromThread(Script& thread, int n)
{
- lua_xmove(thread.state_, state_, n);
+ lua_xmove(thread.mState, mState, n);
}
STATUS pushCode(const std::string& filename)
{
- return (STATUS)luaL_loadfile(state_, filename.c_str());
+ return (STATUS)luaL_loadfile(mState, filename.c_str());
}
STATUS pushCode(const std::string& name, const char* buffer, size_t size)
{
- return (STATUS)luaL_loadbuffer(state_, buffer, size, name.c_str());
+ return (STATUS)luaL_loadbuffer(mState, buffer, size, name.c_str());
}
void* pushNewData(size_t size)
{
- return lua_newuserdata(state_, size);
+ return lua_newuserdata(mState, size);
}
void pushNewTable()
{
- lua_newtable(state_);
+ lua_newtable(mState);
}
STATUS call(int nargs, int nresults = LUA_MULTRET)
{
- return (STATUS)lua_pcall(state_, nargs, nresults, 0);
+ return (STATUS)lua_pcall(mState, nargs, nresults, 0);
}
void pop(int n = 1)
{
- lua_pop(state_, n);
+ lua_pop(mState, n);
}
Value operator [] (int index) const
{
- return Value(state_, index);
+ return Value(mState, index);
}
void get(const std::string& field, int index = GLOBALS) const
{
- lua_getfield(state_, index, field.c_str());
+ lua_getfield(mState, index, field.c_str());
}
void set(const std::string& field, int index = GLOBALS)
{
- lua_setfield(state_, index, field.c_str());
+ lua_setfield(mState, index, field.c_str());
}
void collectAll()
{
- lua_gc(state_, LUA_GCCOLLECT, 0);
+ lua_gc(mState, LUA_GCCOLLECT, 0);
}
void stopCollector()
{
- lua_gc(state_, LUA_GCSTOP, 0);
+ lua_gc(mState, LUA_GCSTOP, 0);
}
void restartCollector()
{
- lua_gc(state_, LUA_GCRESTART, 0);
+ lua_gc(mState, LUA_GCRESTART, 0);
}
int getUsedMemory() const
{
// in kilobytes
- return lua_gc(state_, LUA_GCCOUNT, 0);
+ return lua_gc(mState, LUA_GCCOUNT, 0);
}
void collectStep(int step)
{
- lua_gc(state_, LUA_GCSTEP, step);
+ lua_gc(mState, LUA_GCSTEP, step);
}
void tuneCollector(int pause, int step)
{
- lua_gc(state_, LUA_GCSETPAUSE, pause);
- lua_gc(state_, LUA_GCSETSTEPMUL, step);
+ lua_gc(mState, LUA_GCSETPAUSE, pause);
+ lua_gc(mState, LUA_GCSETSTEPMUL, step);
}
private:
Script(lua_State* state) :
- state_(lua_newthread(state)),
- isMainThread_(false) {}
+ mState(lua_newthread(state)),
+ mIsMainThread(false) {}
static int dispatchCall(lua_State* state)
{
return (*function)(*script);
}
- lua_State* state_;
- bool isMainThread_;
- std::list<Function> functions_;
+ lua_State* mState;
+ bool mIsMainThread;
+ std::list<Function> mFunctions;
};