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

diff --git a/src/Moof/Script.hh b/src/Moof/Script.hh
index f954e58..553e31a 100644
--- a/src/Moof/Script.hh
+++ b/src/Moof/Script.hh
@@ -140,6 +140,73 @@ 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 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.
+		 */
+
+		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.
 		 */
@@ -155,7 +222,7 @@ struct Script
 
 		std::string getTypeName() const
 		{
-			return std::string(lua_typename(state, (int)getType()));
+			return std::string(luaL_typename(state, index));
 		}
 
 
@@ -465,6 +532,22 @@ struct Script
 	}
 
 
+	/**
+	 * 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(state_);
+	}
+
+
 	/**
 	 * Get significant values.
 	 */
@@ -561,6 +644,10 @@ struct Script
 	{
 		lua_pushlstring(state_, value.c_str(), value.length());
 	}
+	void push(const char* value)
+	{
+		lua_pushstring(state_, value);
+	}
 	void push(const char* value, size_t length)
 	{
 		lua_pushlstring(state_, value, length);