X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FMoof%2FScript.hh;h=df00619d69e59b4dafcf644d5782e2ab53ac1eac;hp=f954e583488a786e2740c7042a4ab89782697577;hb=c9e20ac06383b20ceb5404c9237e319c2e90d157;hpb=ca0f7bdfba63140dca0bd20586d31980f3938eb2

diff --git a/src/Moof/Script.hh b/src/Moof/Script.hh
index f954e58..df00619 100644
--- a/src/Moof/Script.hh
+++ b/src/Moof/Script.hh
@@ -49,7 +49,6 @@
 
 #include <lua.hpp>
 
-#include <Moof/Exception.hh>
 #include <Moof/Log.hh>
 
 
@@ -60,11 +59,13 @@ class Script;
 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,
@@ -78,7 +79,7 @@ struct Script
 		THREAD			= LUA_TTHREAD
 	};
 
-	enum STATUS
+	enum Status
 	{
 		SUCCESS			= 0,
 		YIELD			= LUA_YIELD,
@@ -89,7 +90,7 @@ struct Script
 		FILE_ERROR		= LUA_ERRFILE
 	};
 
-	enum PSEUDO_INDEX
+	enum PseudoIndex
 	{
 		REGISTRY		= LUA_REGISTRYINDEX,
 		ENVIRONMENT		= LUA_ENVIRONINDEX,
@@ -97,7 +98,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 +127,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); }
@@ -140,13 +153,82 @@ struct Script
 		bool isData() const      { return (bool)lua_isuserdata(state, index); }
 		bool isLightData() const { return (bool)lua_islightuserdata(state, index); }
 
+		/**
+		 * 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
+		{
+			if (type != getType())
+			{
+				luaL_typerror(state, index, lua_typename(state, type));
+			}
+		}
+
+		void throwError(const char* error)
+		{
+			luaL_argerror(state, index, error);
+		}
+
+
+		Value& requireBoolean()
+		{
+			if (!isBoolean()) luaL_typerror(state, index, "boolean");
+			return *this;
+		}
+		Value& requireNumber()
+		{
+			if (!isNumber()) luaL_typerror(state, index, "number");
+			return *this;
+		}
+		Value& requireString()
+		{
+			if (!isString()) luaL_typerror(state, index, "string");
+			return *this;
+		}
+		Value& requireTable()
+		{
+			if (!isTable()) luaL_typerror(state, index, "table");
+			return *this;
+		}
+		Value& requireFunction()
+		{
+			if (!isFunction()) luaL_typerror(state, index, "function");
+			return *this;
+		}
+		Value& requireData()
+		{
+			if (!isData()) luaL_typerror(state, index, "data");
+			return *this;
+		}
+		Value& requireNil()
+		{
+			if (!isNil()) luaL_typerror(state, index, "nil");
+			return *this;
+		}
+		Value& requireThread()
+		{
+			if (!isThread()) luaL_typerror(state, 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(state, index);
 		}
 
 		/**
@@ -155,7 +237,7 @@ struct Script
 
 		std::string getTypeName() const
 		{
-			return std::string(lua_typename(state, (int)getType()));
+			return std::string(luaL_typename(state, index));
 		}
 
 
@@ -389,15 +471,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);
 	}
 
 
@@ -409,24 +491,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());
 	}
 
 
@@ -436,32 +518,48 @@ 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;
+	}
+
+
+	/**
+	 * Throw an error with the value at the top of the stack.  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.
+	 */
+
+	void throwError()
+	{
+		lua_error(mState);
 	}
 
 
@@ -471,22 +569,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));
 	}
 
 	/**
@@ -495,12 +593,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()
@@ -519,7 +617,7 @@ struct Script
 
 	bool checkStack(int extra)
 	{
-		return (bool)lua_checkstack(state_, extra);
+		return (bool)lua_checkstack(mState, extra);
 	}
 
 
@@ -529,7 +627,7 @@ struct Script
 
 	void concat(int n)
 	{
-		lua_concat(state_, n);
+		lua_concat(mState, n);
 	}
 
 
@@ -540,73 +638,77 @@ struct Script
 	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(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);
 	}
 
 
@@ -617,9 +719,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);
 	}
 
 
@@ -629,7 +731,7 @@ struct Script
 
 	void pop(int n = 1)
 	{
-		lua_pop(state_, n);
+		lua_pop(mState, n);
 	}
 
 
@@ -639,7 +741,7 @@ struct Script
 
 	Value operator [] (int index) const
 	{
-		return Value(state_, index);
+		return Value(mState, index);
 	}
 
 
@@ -649,12 +751,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());
 	}
 
 
@@ -664,55 +766,42 @@ 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)
 	{
@@ -726,9 +815,9 @@ private:
 		return (*function)(*script);
 	}
 
-	lua_State*			state_;
-	bool				isMainThread_;
-	std::list<Function>	functions_;
+	lua_State*			mState;
+	bool				mIsMainThread;
+	std::list<Function>	mFunctions;
 };