new level-based controllers

[chaz/yoink] / src / Moof / Script.hh

diff --git a/src/Moof/Script.hh b/src/Moof/Script.hh
index f954e583488a786e2740c7042a4ab89782697577..553e31a0717be1b242a5e0f8a2377212f4492157 100644 (file)
--- 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);