#include <lua.hpp>
-#include <Moof/Exception.hh>
#include <Moof/Log.hh>
typedef boost::shared_ptr<Script> ScriptP;
-struct Script
+class Script
{
+public:
+
typedef boost::function<int(Script&)> Function;
- enum TYPE
+ enum Type
{
NONE = LUA_TNONE,
NIL = LUA_TNIL,
THREAD = LUA_TTHREAD
};
- enum STATUS
+ enum Status
{
SUCCESS = 0,
YIELD = LUA_YIELD,
FILE_ERROR = LUA_ERRFILE
};
- enum PSEUDO_INDEX
+ enum PseudoIndex
{
REGISTRY = LUA_REGISTRYINDEX,
ENVIRONMENT = LUA_ENVIRONINDEX,
};
/**
- * This is the most noticeable abstraction on top of the standard Lua API.
+ * This is the most prominent abstraction on top of the standard Lua API.
* A Value object represents a value on the stack. More specifically, it
* represents a position on the stack. The distinction is only important
* when values are moved around on the stack or if the Value represents a
*/
Value(lua_State* s = 0, int i = 0) :
index(i),
- state(s) {}
+ mState(s) {}
/**
* A copied value presently points to the same value, except the real
Value(const Value& copy) :
index(copy.getRealIndex()),
- state(copy.state) {}
+ mState(copy.mState) {}
// check the type of the value
- bool isBoolean() const { return (bool)lua_isboolean(state, index); }
- bool isFunction() const { return (bool)lua_isfunction(state, index); }
- bool isNil() const { return (bool)lua_isnil(state, index); }
- bool isNone() const { return (bool)lua_isnone(state, index); }
- bool isValid() const { return state != 0 && !isNone(); }
- bool isNoneOrNil() const { return (bool)lua_isnoneornil(state, index); }
- bool isNumber() const { return (bool)lua_isnumber(state, index); }
- bool isString() const { return (bool)lua_isstring(state, index); }
- bool isTable() const { return (bool)lua_istable(state, index); }
- bool isThread() const { return (bool)lua_isthread(state, index); }
- bool isData() const { return (bool)lua_isuserdata(state, index); }
- bool isLightData() const { return (bool)lua_islightuserdata(state, index); }
+ bool isBoolean() const { return (bool)lua_isboolean(mState, index); }
+ bool isFunction() const { return (bool)lua_isfunction(mState, index); }
+ bool isNil() const { return (bool)lua_isnil(mState, index); }
+ bool isNone() const { return (bool)lua_isnone(mState, index); }
+ bool isValid() const { return mState != 0 && !isNone(); }
+ bool isNoneOrNil() const { return (bool)lua_isnoneornil(mState, index); }
+ bool isNumber() const { return (bool)lua_isnumber(mState, index); }
+ bool isString() const { return (bool)lua_isstring(mState, index); }
+ bool isTable() const { return (bool)lua_istable(mState, index); }
+ bool isThread() const { return (bool)lua_isthread(mState, index); }
+ bool isData() const { return (bool)lua_isuserdata(mState, index); }
+ bool isLightData() const { return (bool)lua_islightuserdata(mState, index); }
/**
- * Check the value and throw and error if its the wrong type. This
- * method never returns because it does a long jump. Consequently,
- * constructed C++ objects which exist on the stack between the current
- * frame and some lua function will not be destructed. That's not a
- * problem for objects that only exist on the stack, but any objects
- * that allocate memory on the heap (such as containers or strings) will
- * leak. Therefore, you should only call this method after cleaning up
- * such objects.
+ * Check the value and throw an error if its the wrong type. There's a
+ * little caveat: This method never returns because it does a long jump.
+ * Consequently, constructed C++ objects which exist on the stack
+ * between the current frame and some lua function will not be
+ * destructed. That's not a problem for objects that only exist on the
+ * stack, but any objects that allocate memory on the heap (such as
+ * containers or strings) will leak. Therefore, you should only call
+ * this method after cleaning up such objects. The best thing to do for
+ * defining functions is to simply check all the parameters at the
+ * get-go before any C++ objects are even constructed.
*/
- void requireType(TYPE type) const
+ void requireType(Type type) const
{
if (type != getType())
{
- luaL_typerror(state, index, lua_typename(state, type));
+ luaL_typerror(mState, index, lua_typename(mState, type));
}
}
void throwError(const char* error)
{
- luaL_argerror(state, index, error);
+ luaL_argerror(mState, index, error);
}
Value& requireBoolean()
{
- if (!isBoolean()) luaL_typerror(state, index, "boolean");
+ if (!isBoolean()) luaL_typerror(mState, index, "boolean");
return *this;
}
Value& requireNumber()
{
- if (!isNumber()) luaL_typerror(state, index, "number");
+ if (!isNumber()) luaL_typerror(mState, index, "number");
return *this;
}
Value& requireString()
{
- if (!isString()) luaL_typerror(state, index, "string");
+ if (!isString()) luaL_typerror(mState, index, "string");
return *this;
}
Value& requireTable()
{
- if (!isTable()) luaL_typerror(state, index, "table");
+ if (!isTable()) luaL_typerror(mState, index, "table");
return *this;
}
Value& requireFunction()
{
- if (!isFunction()) luaL_typerror(state, index, "function");
+ if (!isFunction()) luaL_typerror(mState, index, "function");
return *this;
}
Value& requireData()
{
- if (!isData()) luaL_typerror(state, index, "data");
+ if (!isData()) luaL_typerror(mState, index, "data");
return *this;
}
Value& requireNil()
{
- if (!isNil()) luaL_typerror(state, index, "nil");
+ if (!isNil()) luaL_typerror(mState, index, "nil");
return *this;
}
Value& requireThread()
{
- if (!isThread()) luaL_typerror(state, index, "thread");
+ if (!isThread()) luaL_typerror(mState, index, "thread");
return *this;
}
* Get the type of the value.
*/
- TYPE getType() const
+ Type getType() const
{
- return (TYPE)lua_type(state, index);
+ return (Type)lua_type(mState, index);
}
/**
std::string getTypeName() const
{
- return std::string(luaL_typename(state, index));
+ return std::string(luaL_typename(mState, index));
}
size_t getLength() const
{
- return lua_objlen(state, index);
+ return lua_objlen(mState, index);
}
int getRealIndex() const
{
- if (index < 0) return lua_gettop(state) + 1 + index;
+ if (index < 0) return lua_gettop(mState) + 1 + index;
else return index;
}
const void* getIdentifier() const
{
- return lua_topointer(state, index);
+ return lua_topointer(mState, index);
}
bool operator == (const Value& rhs) const
{
- return (bool)lua_equal(state, index, rhs.index);
+ return (bool)lua_equal(mState, index, rhs.index);
}
bool operator != (const Value& rhs) const
{
}
bool operator < (const Value& rhs) const
{
- return (bool)lua_lessthan(state, index, rhs.index);
+ return (bool)lua_lessthan(mState, index, rhs.index);
}
bool operator <= (const Value& rhs) const
{
}
operator bool () const
{
- return (bool)lua_toboolean(state, index);
+ return (bool)lua_toboolean(mState, index);
}
Value& operator = (const Value& rhs)
{
if (isNumber())
{
- value = (T)lua_tointeger(state, index);
+ value = (T)lua_tointeger(mState, index);
return true;
}
return false;
{
if (isNumber())
{
- value = (float)lua_tonumber(state, index);
+ value = (float)lua_tonumber(mState, index);
return true;
}
return false;
{
if (isNumber())
{
- value = (double)lua_tonumber(state, index);
+ value = (double)lua_tonumber(mState, index);
return true;
}
return false;
{
if (isBoolean())
{
- value = (bool)lua_toboolean(state, index);
+ value = (bool)lua_toboolean(mState, index);
return true;
}
return false;
if (isString())
{
size_t size;
- const char* str = lua_tolstring(state, index, &size);
+ const char* str = lua_tolstring(mState, index, &size);
value.assign(str, size);
return true;
}
array.clear();
- Value value(state, -1);
+ Value value(mState, -1);
int realIndex = getRealIndex();
bool done = false;
for (int i = 1; !done; ++i)
{
- lua_rawgeti(state, realIndex, i);
+ lua_rawgeti(mState, realIndex, i);
T v;
if (value.get(v)) array.push_back(v);
else done = true;
- lua_pop(state, 1);
+ lua_pop(mState, 1);
}
return true;
dictionary.clear();
- Value key(state, -2);
- Value value(state, -1);
+ Value key(mState, -2);
+ Value value(mState, -1);
int realIndex = getRealIndex();
- lua_pushnil(state);
- while (lua_next(state, realIndex) != 0)
+ lua_pushnil(mState);
+ while (lua_next(mState, realIndex) != 0)
{
std::string k;
if (!key.isNumber() && key.get(k))
T v;
if (value.get(v)) dictionary[k] = v;
}
- lua_pop(state, 1);
+ lua_pop(mState, 1);
}
- lua_pop(state, 1);
+ lua_pop(mState, 1);
return true;
}
void pushCopy() const
{
- lua_pushvalue(state, index);
+ lua_pushvalue(mState, index);
}
/**
void replaceWithTop()
{
- lua_replace(state, index);
+ lua_replace(mState, index);
}
void remove()
{
- lua_remove(state, index);
+ lua_remove(mState, index);
}
/**
void insertTopHere()
{
- lua_insert(state, index);
+ lua_insert(mState, index);
}
void pushMetatable() const
{
- lua_getmetatable(state, index);
+ lua_getmetatable(mState, index);
}
void pushField() const
{
- lua_gettable(state, index);
+ lua_gettable(mState, index);
}
void pushField(const std::string& name) const
{
- lua_getfield(state, index, name.c_str());
+ lua_getfield(mState, index, name.c_str());
+ }
+
+ void pushField(size_t index) const
+ {
+ lua_pushinteger(mState, lua_Integer(index));
+ pushField();
}
private:
- lua_State* state;
+ lua_State* mState;
};
Script() :
- state_(luaL_newstate())
+ mState(0)
{
- lua_pushlightuserdata(state_, this);
- lua_setfield(state_, LUA_REGISTRYINDEX, "_script_obj");
+ reset();
}
~Script()
{
- if (isMainThread_) lua_close(state_);
+ destroy();
}
return ScriptP(new Script);
}
+ void reset()
+ {
+ if (mState) destroy();
+ mState = luaL_newstate();
+ lua_pushlightuserdata(mState, this);
+ lua_setfield(mState, LUA_REGISTRYINDEX, "_script_obj");
+ }
+
void importStandardLibraries()
{
- luaL_openlibs(state_);
+ luaL_openlibs(mState);
+ }
+
+ void importBaseLibrary()
+ {
+ lua_pushcfunction(mState, luaopen_base);
+ push(LUA_COLIBNAME);
+ call(1, 0);
+ }
+
+ void importPackageLibrary()
+ {
+ lua_pushcfunction(mState, luaopen_package);
+ push(LUA_LOADLIBNAME);
+ call(1, 0);
+ }
+
+ void importStringLibrary()
+ {
+ lua_pushcfunction(mState, luaopen_string);
+ push(LUA_STRLIBNAME);
+ call(1, 0);
+ }
+
+ void importTableLibrary()
+ {
+ lua_pushcfunction(mState, luaopen_table);
+ push(LUA_TABLIBNAME);
+ call(1, 0);
+ }
+
+ void importMathLibrary()
+ {
+ lua_pushcfunction(mState, luaopen_math);
+ push(LUA_MATHLIBNAME);
+ call(1, 0);
}
+ void importIoLibrary()
+ {
+ lua_pushcfunction(mState, luaopen_io);
+ push(LUA_IOLIBNAME);
+ call(1, 0);
+ }
+
+ void importOsLibrary()
+ {
+ lua_pushcfunction(mState, luaopen_os);
+ push(LUA_OSLIBNAME);
+ call(1, 0);
+ }
+
+ void importDebugLibrary()
+ {
+ lua_pushcfunction(mState, luaopen_debug);
+ push(LUA_DBLIBNAME);
+ call(1, 0);
+ }
+
+
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)
+ 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)
+ 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)
+ Status resume(int nargs)
{
- return (STATUS)lua_resume(state_, nargs);
+ return (Status)lua_resume(mState, nargs);
}
- STATUS getStatus() const
+ 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)
+ 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)
+ 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);
}
* is any number of return values, depending on the callee).
*/
- STATUS call(int nargs, int nresults = LUA_MULTRET)
+ 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);
}
-
- struct Exception : public Mf::Exception
- {
- explicit Exception(unsigned error) :
- Mf::Exception(error) {}
-
- void raise()
- {
- throw *this;
- }
- };
-
-
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_;
+ void destroy()
+ {
+ if (mIsMainThread) lua_close(mState);
+ }
+
+ lua_State* mState;
+ bool mIsMainThread;
+ std::list<Function> mFunctions;
};