X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2FMoof%2FScript.hh;h=9e8827abc78d5c3fb254a379b5540b64626cee21;hb=3f6e44698c38b74bb622ad81ea9d2daa636981d2;hp=a1b536cf1a3d49786725c6ac8e07f57134ff84f6;hpb=8a1acac01b444dccf8b57cedf08392ada2e473c1;p=chaz%2Fyoink

diff --git a/src/Moof/Script.hh b/src/Moof/Script.hh
index a1b536c..9e8827a 100644
--- a/src/Moof/Script.hh
+++ b/src/Moof/Script.hh
@@ -38,6 +38,7 @@
  * more consistent API.
  */
 
+#include <iostream>
 #include <list>
 #include <map>
 #include <string>
@@ -59,8 +60,10 @@ class Script;
 typedef boost::shared_ptr<Script> ScriptP;
 
 
-struct Script
+class Script
 {
+public:
+
 	typedef boost::function<int(Script&)> Function;
 
 	enum Type
@@ -77,7 +80,7 @@ struct Script
 		THREAD			= LUA_TTHREAD
 	};
 
-	enum Status
+	enum Result
 	{
 		SUCCESS			= 0,
 		YIELD			= LUA_YIELD,
@@ -97,14 +100,14 @@ struct Script
 
 	/**
 	 * 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
+	 * A Slot 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
+	 * when objects are moved around on the stack or if the Slot represents a
 	 * negative index on the stack (the value of which will change as things are
 	 * pushed onto and popped from the stack).
 	 */
 
-	struct Value
+	struct Slot
 	{
 		/**
 		 * You have direct access to the index of the value on the stack being
@@ -115,15 +118,15 @@ struct Script
 
 
 		/**
-		 * A default-constructed Value is invalid until a valid Value is
-		 * assigned to it.  The only method that should be called on such a
-		 * Value is isValid(), otherwise chaos may ensue.  In this case, the
-		 * Value will be invalid even if index is manually changed to a valid
-		 * index.  You have to index the script itself to get a valid Value.
+		 * A default-constructed Slot is invalid until a valid Slot is assigned
+		 * to it.  The only method that should be called on such a Slot is
+		 * isValid(), otherwise chaos may ensue.  In this case, the Slot will be
+		 * invalid even if index is manually changed to a valid index.  You have
+		 * to index the script itself to get a valid Slot.
 		 */
-		Value(lua_State* s = 0, int i = 0) :
+		Slot(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
@@ -132,24 +135,24 @@ struct Script
 		 * copied into the new value object.
 		 */
 
-		Value(const Value& copy) :
+		Slot(const Slot& 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 an error if its the wrong type.  There's a
@@ -168,54 +171,54 @@ struct Script
 		{
 			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()
+		Slot& requireBoolean()
 		{
-			if (!isBoolean()) luaL_typerror(state, index, "boolean");
+			if (!isBoolean()) luaL_typerror(mState, index, "boolean");
 			return *this;
 		}
-		Value& requireNumber()
+		Slot& requireNumber()
 		{
-			if (!isNumber()) luaL_typerror(state, index, "number");
+			if (!isNumber()) luaL_typerror(mState, index, "number");
 			return *this;
 		}
-		Value& requireString()
+		Slot& requireString()
 		{
-			if (!isString()) luaL_typerror(state, index, "string");
+			if (!isString()) luaL_typerror(mState, index, "string");
 			return *this;
 		}
-		Value& requireTable()
+		Slot& requireTable()
 		{
-			if (!isTable()) luaL_typerror(state, index, "table");
+			if (!isTable()) luaL_typerror(mState, index, "table");
 			return *this;
 		}
-		Value& requireFunction()
+		Slot& requireFunction()
 		{
-			if (!isFunction()) luaL_typerror(state, index, "function");
+			if (!isFunction()) luaL_typerror(mState, index, "function");
 			return *this;
 		}
-		Value& requireData()
+		Slot& requireData()
 		{
-			if (!isData()) luaL_typerror(state, index, "data");
+			if (!isData()) luaL_typerror(mState, index, "data");
 			return *this;
 		}
-		Value& requireNil()
+		Slot& requireNil()
 		{
-			if (!isNil()) luaL_typerror(state, index, "nil");
+			if (!isNil()) luaL_typerror(mState, index, "nil");
 			return *this;
 		}
-		Value& requireThread()
+		Slot& requireThread()
 		{
-			if (!isThread()) luaL_typerror(state, index, "thread");
+			if (!isThread()) luaL_typerror(mState, index, "thread");
 			return *this;
 		}
 
@@ -226,7 +229,7 @@ struct Script
 
 		Type getType() const
 		{
-			return (Type)lua_type(state, index);
+			return (Type)lua_type(mState, index);
 		}
 
 		/**
@@ -235,7 +238,7 @@ struct Script
 
 		std::string getTypeName() const
 		{
-			return std::string(luaL_typename(state, index));
+			return std::string(luaL_typename(mState, index));
 		}
 
 
@@ -245,12 +248,12 @@ struct Script
 
 		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;
 		}
 
@@ -261,40 +264,40 @@ struct Script
 
 		const void* getIdentifier() const
 		{
-			return lua_topointer(state, index);
+			return lua_topointer(mState, index);
 		}
 
 
-		bool operator == (const Value& rhs) const
+		bool operator == (const Slot& 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 Slot& rhs) const
 		{
 			return !(*this == rhs);
 		}
-		bool operator < (const Value& rhs) const
+		bool operator < (const Slot& rhs) const
 		{
-			return (bool)lua_lessthan(state, index, rhs.index);
+			return (bool)lua_lessthan(mState, index, rhs.index);
 		}
-		bool operator <= (const Value& rhs) const
+		bool operator <= (const Slot& rhs) const
 		{
 			return *this < rhs || *this == rhs;
 		}
-		bool operator > (const Value& rhs) const
+		bool operator > (const Slot& rhs) const
 		{
 			return !(*this <= rhs);
 		}
-		bool operator >= (const Value& rhs) const
+		bool operator >= (const Slot& rhs) const
 		{
 			return !(*this < rhs);
 		}
 		operator bool () const
 		{
-			return (bool)lua_toboolean(state, index);
+			return (bool)lua_toboolean(mState, index);
 		}
 
-		Value& operator = (const Value& rhs)
+		Slot& operator = (const Slot& rhs)
 		{
 			rhs.pushCopy();
 			replaceWithTop();
@@ -311,7 +314,7 @@ struct Script
 		{
 			if (isNumber())
 			{
-				value = (T)lua_tointeger(state, index);
+				value = (T)lua_tointeger(mState, index);
 				return true;
 			}
 			return false;
@@ -321,7 +324,7 @@ struct Script
 		{
 			if (isNumber())
 			{
-				value = (float)lua_tonumber(state, index);
+				value = (float)lua_tonumber(mState, index);
 				return true;
 			}
 			return false;
@@ -330,7 +333,7 @@ struct Script
 		{
 			if (isNumber())
 			{
-				value = (double)lua_tonumber(state, index);
+				value = (double)lua_tonumber(mState, index);
 				return true;
 			}
 			return false;
@@ -340,7 +343,7 @@ struct Script
 		{
 			if (isBoolean())
 			{
-				value = (bool)lua_toboolean(state, index);
+				value = (bool)lua_toboolean(mState, index);
 				return true;
 			}
 			return false;
@@ -351,7 +354,7 @@ struct Script
 			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;
 			}
@@ -365,19 +368,19 @@ struct Script
 
 			array.clear();
 
-			Value	value(state, -1);
+			Slot	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;
@@ -390,12 +393,12 @@ struct Script
 
 			dictionary.clear();
 
-			Value	key(state, -2);
-			Value	value(state, -1);
+			Slot	key(mState, -2);
+			Slot	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))
@@ -403,22 +406,21 @@ struct Script
 					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;
 		}
 
 
-
 		/**
 		 * Copy the value and push the copy to the stack.
 		 */
 
 		void pushCopy() const
 		{
-			lua_pushvalue(state, index);
+			lua_pushvalue(mState, index);
 		}
 
 		/**
@@ -427,12 +429,12 @@ struct Script
 
 		void replaceWithTop()
 		{
-			lua_replace(state, index);
+			lua_replace(mState, index);
 		}
 
 		void remove()
 		{
-			lua_remove(state, index);
+			lua_remove(mState, index);
 		}
 
 		/**
@@ -442,42 +444,47 @@ struct Script
 
 		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() :
-		mState(luaL_newstate())
+		mState(0)
 	{
-		lua_pushlightuserdata(mState, this);
-		lua_setfield(mState, LUA_REGISTRYINDEX, "_script_obj");
+		reset();
 	}
 
 	~Script()
 	{
-		if (mIsMainThread) lua_close(mState);
+		destroy();
 	}
 
 
@@ -486,12 +493,77 @@ struct Script
 		return ScriptP(new Script);
 	}
 
+	void reset()
+	{
+		if (mState) destroy();
+		mState = luaL_newstate();
+		lua_pushlightuserdata(mState, this);
+		lua_setfield(mState, LUA_REGISTRYINDEX, "Script_hh_Object");
+	}
+
 
 	void importStandardLibraries()
 	{
 		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);
@@ -499,14 +571,14 @@ struct Script
 	}
 
 
-	Status doString(const std::string& commands)
+	Result doString(const std::string& commands)
 	{
-		return (Status)luaL_dostring(mState, commands.c_str());
+		return (Result)luaL_dostring(mState, commands.c_str());
 	}
 
-	Status doFile(const std::string& file)
+	Result doFile(const std::string& file)
 	{
-		return (Status)luaL_dofile(mState, file.c_str());
+		return (Result)luaL_dofile(mState, file.c_str());
 	}
 
 
@@ -524,14 +596,14 @@ struct Script
 		lua_pushthread(mState);
 	}
 
-	Status resume(int nargs)
+	Result resume(int nargs)
 	{
-		return (Status)lua_resume(mState, nargs);
+		return (Result)lua_resume(mState, nargs);
 	}
 
-	Status getStatus() const
+	Result getStatus() const
 	{
-		return (Status)lua_status(mState);
+		return (Result)lua_status(mState);
 	}
 
 	int yield(int results)
@@ -565,24 +637,24 @@ struct Script
 	 * Get significant values.
 	 */
 
-	Value getGlobalTable() const
+	Slot getGlobalTable() const
 	{
-		return Value(mState, GLOBALS);
+		return Slot(mState, GLOBALS);
 	}
 
-	Value getRegistryTable() const
+	Slot getRegistryTable() const
 	{
-		return Value(mState, REGISTRY);
+		return Slot(mState, REGISTRY);
 	}
 
-	Value getEnvironmentTable() const
+	Slot getEnvironmentTable() const
 	{
-		return Value(mState, ENVIRONMENT);
+		return Slot(mState, ENVIRONMENT);
 	}
 
-	Value getTop() const
+	Slot getTop() const
 	{
-		return Value(mState, lua_gettop(mState));
+		return Slot(mState, lua_gettop(mState));
 	}
 
 	/**
@@ -620,10 +692,10 @@ struct Script
 
 
 	/**
-	 * Concatenates the top-most n values on the stack.
+	 * Concatenates the top-most n slots on the stack.
 	 */
 
-	void concat(int n)
+	void concat(int n = 2)
 	{
 		lua_concat(mState, n);
 	}
@@ -689,14 +761,14 @@ struct Script
 		lua_xmove(thread.mState, mState, n);
 	}
 
-	Status pushCode(const std::string& filename)
+	Result pushCode(const std::string& filename)
 	{
-		return (Status)luaL_loadfile(mState, filename.c_str());
+		return (Result)luaL_loadfile(mState, filename.c_str());
 	}
 
-	Status pushCode(const std::string& name, const char* buffer, size_t size)
+	Result pushCode(const std::string& name, const char* buffer, size_t size)
 	{
-		return (Status)luaL_loadbuffer(mState, buffer, size, name.c_str());
+		return (Result)luaL_loadbuffer(mState, buffer, size, name.c_str());
 	}
 
 	void* pushNewData(size_t size)
@@ -717,9 +789,9 @@ struct Script
 	 * is any number of return values, depending on the callee).
 	 */
 
-	Status call(int nargs, int nresults = LUA_MULTRET)
+	Result call(int nargs = 0, int nresults = LUA_MULTRET)
 	{
-		return (Status)lua_pcall(mState, nargs, nresults, 0);
+		return (Result)lua_pcall(mState, nargs, nresults, 0);
 	}
 
 
@@ -734,12 +806,12 @@ struct Script
 
 
 	/**
-	 * Index into the stack to get a Value.
+	 * Index into the stack to get a Slot.
 	 */
 
-	Value operator [] (int index) const
+	Slot operator [] (int index) const
 	{
-		return Value(mState, index);
+		return Slot(mState, index);
 	}
 
 
@@ -747,7 +819,7 @@ struct Script
 	 * Getting and setting fields of a table.
 	 */
 
-	void get(const std::string& field,  int index = GLOBALS) const
+	void pushField(const std::string& field, int index = GLOBALS) const
 	{
 		lua_getfield(mState, index, field.c_str());
 	}
@@ -794,6 +866,7 @@ struct Script
 		lua_gc(mState, LUA_GCSETSTEPMUL, step);
 	}
 
+
 private:
 
 	Script(lua_State* state) :
@@ -805,19 +878,51 @@ private:
 		const Function* function = (const Function*)lua_touserdata(state,
 				lua_upvalueindex(1));
 
-		lua_getfield(state, LUA_REGISTRYINDEX, "_script_obj");
+		lua_getfield(state, LUA_REGISTRYINDEX, "Script_hh_Object");
 		Script* script = (Script*)lua_touserdata(state, -1);
 		lua_pop(state, 1);
 
 		return (*function)(*script);
 	}
 
+	void destroy()
+	{
+		if (mIsMainThread) lua_close(mState);
+	}
+
 	lua_State*			mState;
 	bool				mIsMainThread;
 	std::list<Function>	mFunctions;
 };
 
 
+inline std::ostream& operator << (std::ostream& stream,
+		const Script::Slot& slot)
+{
+	if (slot.isString())
+	{
+		std::string str;
+		slot.get(str);
+		stream << str;
+	}
+	else if (slot.isBoolean())
+	{
+		if (slot) stream << "true";
+		else      stream << "false";
+	}
+	else if (slot.isNil())
+	{
+		stream << "nil";
+	}
+	else
+	{
+		stream << slot.getTypeName() << " (" << slot.getIdentifier() << ")";
+	}
+
+	return stream;
+}
+
+
 } // namespace Mf
 
 #endif // _MOOF_SCRIPT_HH_