X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FMoof%2FScript.hh;h=a1b536cf1a3d49786725c6ac8e07f57134ff84f6;hp=553e31a0717be1b242a5e0f8a2377212f4492157;hb=8a1acac01b444dccf8b57cedf08392ada2e473c1;hpb=892da43bf5796e7c5f593a6d0f53bd797a36bd3e diff --git a/src/Moof/Script.hh b/src/Moof/Script.hh index 553e31a..a1b536c 100644 --- a/src/Moof/Script.hh +++ b/src/Moof/Script.hh @@ -49,7 +49,6 @@ #include -#include #include @@ -64,7 +63,7 @@ struct Script { typedef boost::function Function; - enum TYPE + enum Type { NONE = LUA_TNONE, NIL = LUA_TNIL, @@ -78,7 +77,7 @@ struct Script THREAD = LUA_TTHREAD }; - enum STATUS + enum Status { SUCCESS = 0, YIELD = LUA_YIELD, @@ -89,7 +88,7 @@ struct Script FILE_ERROR = LUA_ERRFILE }; - enum PSEUDO_INDEX + enum PseudoIndex { REGISTRY = LUA_REGISTRYINDEX, ENVIRONMENT = LUA_ENVIRONINDEX, @@ -97,7 +96,7 @@ struct Script }; /** - * 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 @@ -126,6 +125,18 @@ struct Script index(i), state(s) {} + /** + * A copied value presently points to the same value, except the real + * index is used. That means that if a value that refers to a frame + * referenced from the top of the stack will have its normalized index + * copied into the new value object. + */ + + Value(const Value& copy) : + index(copy.getRealIndex()), + state(copy.state) {} + + // check the type of the value bool isBoolean() const { return (bool)lua_isboolean(state, index); } bool isFunction() const { return (bool)lua_isfunction(state, index); } @@ -141,17 +152,19 @@ struct Script bool isLightData() const { return (bool)lua_islightuserdata(state, 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()) { @@ -211,9 +224,9 @@ struct Script * Get the type of the value. */ - TYPE getType() const + Type getType() const { - return (TYPE)lua_type(state, index); + return (Type)lua_type(state, index); } /** @@ -456,15 +469,15 @@ struct Script 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); } @@ -476,24 +489,24 @@ struct Script 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) + 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()); } @@ -503,32 +516,32 @@ struct Script 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; } @@ -544,7 +557,7 @@ struct Script void throwError() { - lua_error(state_); + lua_error(mState); } @@ -554,22 +567,22 @@ struct Script 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)); } /** @@ -578,12 +591,12 @@ struct Script 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() @@ -602,7 +615,7 @@ struct Script bool checkStack(int extra) { - return (bool)lua_checkstack(state_, extra); + return (bool)lua_checkstack(mState, extra); } @@ -612,7 +625,7 @@ struct Script void concat(int n) { - lua_concat(state_, n); + lua_concat(mState, n); } @@ -623,77 +636,77 @@ struct Script template 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); } @@ -704,9 +717,9 @@ struct Script * 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); } @@ -716,7 +729,7 @@ struct Script void pop(int n = 1) { - lua_pop(state_, n); + lua_pop(mState, n); } @@ -726,7 +739,7 @@ struct Script Value operator [] (int index) const { - return Value(state_, index); + return Value(mState, index); } @@ -736,12 +749,12 @@ struct Script 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()); } @@ -751,55 +764,41 @@ struct Script 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) { @@ -813,9 +812,9 @@ private: return (*function)(*script); } - lua_State* state_; - bool isMainThread_; - std::list functions_; + lua_State* mState; + bool mIsMainThread; + std::list mFunctions; };