global gravity for rigid bodies

[chaz/yoink] / src / moof / script.hh

/*]  Copyright (c) 2009-2011, Charles McGarvey  [*****************************
**]  All rights reserved.
*
* Distributable under the terms and conditions of the 2-clause BSD license;
* see the file COPYING for a complete text of the license.
*
*****************************************************************************/

#ifndef _MOOF_SCRIPT_HH_
#define _MOOF_SCRIPT_HH_

#include <cstring>
#include <iostream>
#include <map>
#include <stdexcept>
#include <string>
#include <sstream>
#include <utility>
#include <vector>

#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <lua.hpp>


/**
 * \file script.hh
 * A thin wrapper over Lua 5.1.  This is not meant as a complicated binding
 * package between C++ and Lua.  It is not meant to obscure the division
 * between C++ and Lua but rather to clarify it and make it more manageable.
 * It does not hide the concept of the Lua stack, but rather provides that
 * mechanism with a certain level of abstraction while also providing a
 * cleaner, more consistent API.
 */

namespace moof {


class script;
typedef boost::shared_ptr<script> script_ptr;

class script
{
public:

        typedef boost::function<int(script&)> function;
        typedef int (*cfunction)(script&);

        enum status
        {
                success         = 0,
                yielding        = LUA_YIELD,
                runtime_error   = LUA_ERRRUN,
                syntax_error    = LUA_ERRSYNTAX,
                memory_error    = LUA_ERRMEM,
                handler_error   = LUA_ERRERR,
                file_error      = LUA_ERRFILE
        };

        enum pseudoindex
        {
                registry_index          = LUA_REGISTRYINDEX,
                environment_index       = LUA_ENVIRONINDEX,
                globals_index           = LUA_GLOBALSINDEX
        };

        template <class T>
        static int object_finalizer(script& script)
        {
                reinterpret_cast<T*>(script[1].get_data())->~T();
                return 0;
        }

        /**
         * This is the most prominent abstraction on top of the standard Lua
         * API.  A slot object represents a value on the stack.  More
         * specifically, it represents a position on the stack.  The
         * distinction is only important 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 slot
        {
                /**
                 * You have direct access to the index of the value on the
                 * stack being represented.
                 */
                int index;

                enum type
                {
                        none            = LUA_TNONE,
                        nil             = LUA_TNIL,
                        boolean         = LUA_TBOOLEAN,
                        light_data      = LUA_TLIGHTUSERDATA,
                        number          = LUA_TNUMBER,
                        string          = LUA_TSTRING,
                        table           = LUA_TTABLE,
                        function        = LUA_TFUNCTION,
                        data            = LUA_TUSERDATA,
                        thread          = LUA_TTHREAD
                };

                static std::string type_name(type type)
                {
                        switch (type)
                        {
                                case none:      return "none";
                                case nil:       return "nil";
                                case boolean:   return "boolean";
                                case light_data:
                                case data:      return "userdata";
                                case number:    return "number";
                                case string:    return "string";
                                case table:     return "table";
                                case function:  return "function";
                                case thread:    return "thread";
                        }
                        return "?";
                }

                slot(const class script& s, int i = 0) :
                        index(i),
                        script_(const_cast<class script*>(&s)) {}

                // check the type of the value
                bool is_boolean() const
                {
                        return (bool)lua_isboolean(script_->state_, index);
                }
                bool is_imported_function() const
                {
                        return (bool)lua_iscfunction(script_->state_, index);
                }
                bool is_function() const
                {
                        return (bool)lua_isfunction(script_->state_, index);
                }
                bool is_nil() const
                {
                        return (bool)lua_isnil(script_->state_, index);
                }
                bool is_none() const
                {
                        return (bool)lua_isnone(script_->state_, index);
                }
                bool is_none_or_nil() const
                {
                        return (bool)lua_isnoneornil(script_->state_, index);
                }
                bool is_number() const
                {
                        return (bool)lua_isnumber(script_->state_, index);
                }
                bool is_string() const
                {
                        return (bool)lua_isstring(script_->state_, index);
                }
                bool is_table() const
                {
                        return (bool)lua_istable(script_->state_, index);
                }
                bool is_thread() const
                {
                        return (bool)lua_isthread(script_->state_, index);
                }
                bool is_data() const
                {
                        return (bool)lua_isuserdata(script_->state_, index);
                }
                bool is_light_data() const
                {
                        return (bool)lua_islightuserdata(script_->state_, index);
                }

                /**
                 * Check the value and throw an error if its the wrong type.
                 */
                const slot& require_type(type t) const
                {
                        if (t != type()) raise_type_error(type_name(t));
                        return *this;
                }

                const slot&
                require_boolean(const std::string& what = "boolean") const
                {
                        if (!is_boolean()) raise_type_error(what);
                        return *this;
                }
                const slot&
                require_number(const std::string& what = "number") const
                {
                        if (!is_number()) raise_type_error(what);
                        return *this;
                }
                const slot&
                require_string(const std::string& what = "string") const
                {
                        if (!is_string()) raise_type_error(what);
                        return *this;
                }
                const slot&
                require_table(const std::string& what = "table") const
                {
                        if (!is_table()) raise_type_error(what);
                        return *this;
                }
                const slot&
                require_function(const std::string& what = "function") const
                {
                        if (!is_function()) raise_type_error(what);
                        return *this;
                }
                const slot&
                require_data(const std::string& what = "userdata") const
                {
                        if (!is_data()) raise_type_error(what);
                        return *this;
                }
                const slot&
                require_nil(const std::string& what = "nil") const
                {
                        if (!is_nil()) raise_type_error(what);
                        return *this;
                }
                const slot&
                require_thread(const std::string& what = "thread") const
                {
                        if (!is_thread()) raise_type_error(what);
                        return *this;
                }

                template <class T>
                const slot&
                require_object(const std::string& what = typeid(T).name()) const
                {
                        if (!is_data()) raise_type_error(what);

                        slot metatable = push_metatable();
                        if (!metatable.is_table())
                        {
                                metatable.pop();
                                raise_type_error(what);
                        }

                        slot type = metatable.push_field("__cxxtype");
                        std::type_info* typeinfo;
                        if (!type.get(typeinfo))
                        {
                                metatable.pop();
                                raise_type_error(what);
                        }

                        metatable.pop();
                        if (*typeinfo != typeid(T)) raise_type_error(what);
                        return *this;
                }

                /**
                 * Get the type of the value.
                 */
                enum type type() const
                {
                        return (enum type)lua_type(script_->state_, index);
                }

                /**
                 * Get the name of the type of the value as a string.
                 */
                std::string type_name() const
                {
                        if (is_none())
                        {
                                return "none";
                        }
                        else if (is_data() && !is_light_data())
                        {
                                slot metatable = push_metatable();
                                if (!metatable.is_table())
                                {
                                        metatable.pop();
                                        return "userdata";
                                }

                                slot type = metatable.push_field("__cxxtype");
                                std::type_info* typeinfo;
                                if (!type.get(typeinfo))
                                {
                                        metatable.pop();
                                        return "userdata";
                                }

                                metatable.pop();
                                return typeinfo->name();
                        }
                        return luaL_typename(script_->state_, index);
                }

                /**
                 * Get the length of the value according to the definition
                 * given by Lua.
                 */
                size_t size() const
                {
                        return lua_objlen(script_->state_, index);
                }
                size_t length() const
                {
                        return size();
                }

                int positive_index() const
                {
                        if (index < 0)
                                return index + lua_gettop(script_->state_) + 1;
                        else
                                return index;
                }

                /**
                 * Get a pointer value (for userdata, tables, threads, and
                 * functions).
                 */
                const void* id() const
                {
                        return lua_topointer(script_->state_, index);
                }

                bool is_identical(const slot& rhs) const
                {
                        return script_ == rhs.script_ && index == rhs.index;
                }

                operator bool () const
                {
                        return !is_none();
                }

                bool operator == (const slot& rhs) const
                {
                        return (bool)lua_equal(script_->state_,
                                        index, rhs.index);
                }

                bool operator < (const slot& rhs) const
                {
                        return (bool)lua_lessthan(script_->state_,
                                        index, rhs.index);
                }

                /**
                 * Convert the underlying value to a C++ type.
                 */
                template <class T>
                bool get(T& value) const
                {
                        if (is_number())
                        {
                                value = (T)lua_tointeger(script_->state_, index);
                                return true;
                        }
                        return false;
                }

                bool get(float& value) const
                {
                        if (is_number())
                        {
                                value = (float)lua_tonumber(script_->state_, index);
                                return true;
                        }
                        return false;
                }
                bool get(double& value) const
                {
                        if (is_number())
                        {
                                value = (double)lua_tonumber(script_->state_, index);
                                return true;
                        }
                        return false;
                }

                bool get(bool& value) const
                {
                        if (is_boolean())
                        {
                                value = (bool)lua_toboolean(script_->state_, index);
                                return true;
                        }
                        return false;
                }

                bool get(const char*& value, size_t& size) const
                {
                        if (is_string())
                        {
                                value = lua_tolstring(script_->state_, index, &size);
                                return true;
                        }
                        return false;
                }

                bool get(std::string& value) const
                {
                        const char*     str;
                        size_t          size;
                        if (get(str, size))
                        {
                                value.assign(str, size);
                                return true;
                        }
                        return false;
                }

                template <class T>
                bool get(T*& value) const
                {
                        if (is_data())
                        {
                                value = reinterpret_cast<T*>(lua_touserdata(script_->state_, index));
                                return true;
                        }
                        return false;
                }
                void* get_data() const
                {
                        return lua_touserdata(script_->state_, index);
                }

                template <class T>
                bool get(std::vector<T>& array) const
                {
                        if (!is_table()) return false;

                        array.clear();

                        slot    value = (*script_)[-1];
                        int     realIndex = positive_index();

                        bool done = false;
                        for (int i = 1; !done; ++i)
                        {
                                lua_rawgeti(script_->state_, realIndex, i);

                                T v;
                                if (value.get(v))
                                        array.push_back(v);
                                else
                                        done = true;

                                script_->pop();
                        }

                        return true;
                }

                template <class T>
                bool get(std::map<std::string,T>& dictionary) const
                {
                        if (!is_table()) return false;

                        dictionary.clear();

                        slot    key = (*script_)[-2];
                        slot    value = (*script_)[-1];
                        int     realIndex = positive_index();

                        script_->push_nil();
                        while (lua_next(script_->state_, realIndex) != 0)
                        {
                                std::string k;
                                if (!key.is_number() && key.get(k))
                                {
                                        T v;
                                        if (value.get(v)) dictionary[k] = v;
                                }
                                script_->pop();
                        }
                        script_->pop();

                        return true;
                }

                /**
                 * Get the value of a field from the table.
                 */
                template <class T, class V>
                bool get(T& value, const V& field) const
                {
                        bool ret = push_field(field).get(value);
                        script_->pop();
                        return ret;
                }

                template <class T, class V>
                void set_field(const T& field, const V& value)
                {
                        script_->push(field);
                        script_->push(value);
                        set_field();
                }

                void set_field()
                {
                        lua_settable(script_->state_, index);
                }

                void set_field(const std::string& field)
                {
                        set_field(field.c_str());
                }
                void set_field(const char* field)
                {
                        lua_setfield(script_->state_, index, field);
                }

                template <class T>
                void set_field(const std::string& field, const T& value)
                {
                        set_field(field.c_str(), value);
                }
                template <class T>
                void set_field(const char* field, const T& value)
                {
                        script_->push(value);
                        set_field(field);
                }

                /**
                 * Set the top value to be the metatable of this value.
                 */
                void set_metatable()
                {
                        lua_setmetatable(script_->state_, index);
                }

                /**
                 * This set method, as opposed to the others, sets the value of the
                 * actual slot.  The others set table values.
                 */
                template <class T>
                void set(T value)
                {
                        script_->push(value);
                        set();
                }

                /**
                 * Replace this value with the value at the top of the stack.
                 */
                void set()
                {
                        lua_replace(script_->state_, index);
                }

                void set_nil()
                {
                        script_->push_nil();
                        set();
                }

                void remove()
                {
                        lua_remove(script_->state_, index);
                }

                /**
                 * Remove this value and everything above it.
                 */
                void pop()
                {
                        if
                                (index < 0) script_->pop(-index);
                        else
                                script_->pop(script_->stack_size() -
                                                index + 1);
                }

                /**
                 * Inserts the top-most value on the stack at position index,
                 * shifting other values as needed.
                 */
                void insert_top_here()
                {
                        lua_insert(script_->state_, index);
                }

                /**
                 * Copy the value and push the copy to the stack.
                 */
                slot push_copy() const
                {
                        lua_pushvalue(script_->state_, index);
                        return script_->top();
                }
                
                slot push_metatable() const
                {
                        lua_getmetatable(script_->state_, index);
                        return script_->top();
                }

                slot push_environment() const
                {
                        lua_getfenv(script_->state_, index);
                        return script_->top();
                }

                slot push_field() const
                {
                        lua_gettable(script_->state_, index);
                        return script_->top();
                }

                template <class T>
                slot push_field(T index) const
                {
                        script_->push(index);
                        return push_field();
                }

                slot push_field(const std::string& name) const
                {
                        return push_field(name.c_str());
                }
                slot push_field(const char* name) const
                {
                        lua_getfield(script_->state_, index, name);
                        return script_->top();
                }

                class script& script()
                {
                        return *script_;
                }

                const class script& script() const
                {
                        return *script_;
                }

                /**
                 * Throw an exception with a message formatted to communicate
                 * a type mismatch with the argument represented by this slot.
                 */
                int raise_type_error(const std::string& expected) const
                {
                        lua_Debug ar;
                        lua_getstack(script_->state_, 0, &ar);
                        lua_getinfo(script_->state_, "n", &ar);
                        const char* func = ar.name ? ar.name : "unknown function";

                        std::ostringstream stream;
                        stream << "bad argument " << index << " to '" << func
                                   << "' (" << expected << " expected, got "
                                   << type_name() << ")";

                        throw std::invalid_argument(stream.str());
                        return 0;
                }

                /**
                 * Throw a generic error concerning this particular slot.
                 */
                int raise(const std::string& message) const
                {
                        lua_Debug ar;
                        lua_getstack(script_->state_, 0, &ar);
                        lua_getinfo(script_->state_, "n", &ar);
                        const char* func = ar.name ? ar.name : "unknown function";

                        std::ostringstream stream;
                        stream << "bad argument " << index << " to '" << func
                                   << "' (" << message << ")";

                        throw std::invalid_argument(stream.str());
                        return 0;
                }

        private:

                mutable class script* script_;
        };

        script() :
                state_(0)
        {
                reset();
        }

        ~script()
        {
                destroy();
        }

        static script_ptr alloc()
        {
                return script_ptr(new script);
        }

        void reset()
        {
                if (state_) destroy();
                state_ = luaL_newstate();
        }

        void import_standard_libraries()
        {
                luaL_openlibs(state_);
        }

        void import_safe_standard_libraries()
        {
                import_base_library();
                import_string_library();
                import_table_library();
                import_math_library();
                import_os_library();
                import_debug_library();

                slot g = globals();

                push_nil(); g.set_field("dofile");
                push_nil(); g.set_field("loadfile");
                push_nil(); g.set_field("require");
                push_nil(); g.set_field("io");
                push_nil(); g.set_field("package");
                slot os = g.push_field("os");
                push_nil(); os.set_field("execute");
                push_nil(); os.set_field("exit");
                push_nil(); os.set_field("getenv");
                push_nil(); os.set_field("remove");
                push_nil(); os.set_field("rename");
                push_nil(); os.set_field("tmpname");
                pop();
        }

        void import_base_library()
        {
                push(luaopen_base);
                push(LUA_COLIBNAME);
                call(1, 0);
        }
        void import_package_library()
        {
                push(luaopen_package);
                push(LUA_LOADLIBNAME);
                call(1, 0);
        }
        void import_string_library()
        {
                push(luaopen_string);
                push(LUA_STRLIBNAME);
                call(1, 0);
        }
        void import_table_library()
        {
                push(luaopen_table);
                push(LUA_TABLIBNAME);
                call(1, 0);
        }
        void import_math_library()
        {
                push(luaopen_math);
                push(LUA_MATHLIBNAME);
                call(1, 0);
        }
        void import_io_library()
        {
                push(luaopen_io);
                push(LUA_IOLIBNAME);
                call(1, 0);
        }
        void import_os_library()
        {
                push(luaopen_os);
                push(LUA_OSLIBNAME);
                call(1, 0);
        }
        void import_debug_library()
        {
                push(luaopen_debug);
                push(LUA_DBLIBNAME);
                call(1, 0);
        }

        void
        import_function(const std::string& name, const function& function)
        {
                push(function);
                lua_setglobal(state_, name.c_str());
        }

        status do_string(const std::string& commands)
        {
                return status(luaL_dostring(state_, commands.c_str()));
        }

        status do_file(const std::string& file)
        {
                return status(luaL_dofile(state_, file.c_str()));
        }

        /*
         * Thread-handling methods.
         */

        script push_new_thread()
        {
                return script(state_);
        }

        slot push_thread()
        {
                lua_pushthread(state_);
                return top();
        }

        status resume(int nargs)
        {
                return status(lua_resume(state_, nargs));
        }

        status thread_status() const
        {
                return status(lua_status(state_));
        }

        int yield(int results)
        {
                return lua_yield(state_, results);
        }

        bool is_main_thread() const
        {
                bool is_main = lua_pushthread(state_);
                lua_pop(state_, 1);
                return is_main;
        }

        /**
         * Throw an error with the value at the top of the stack.  If this is
         * called from an imported function, the error will be caught and
         * returned on the stack when the execution aborts.
         */
        int raise()
        {
                throw std::runtime_error("");
                return 0;
        }

        /**
         * Throw an error with a given message describing the problem.  If this
         * is called from an imported function, the error will be caught and
         * returned on the stack when the execution aborts.
         */
        int raise(const std::string& message)
        {
                throw std::runtime_error(message);
                return 0;
        }

        /*
         * Get significant values.
         */

        slot globals() const
        {
                return slot(*this, globals_index);
        }
        slot registry() const
        {
                return slot(*this, registry_index);
        }
        slot environment() const
        {
                return slot(*this, environment_index);
        }
        slot top() const
        {
                return slot(*this, stack_size());
        }

        /**
         * Set the size of the stack.
         * \param size The stack size.
         */
        void stack_size(int size)
        {
                lua_settop(state_, size);
        }

        /**
         * Get the size of the stack; this is also the index of the top-most
         * value.
         * \return The stack size.
         */
        int stack_size() const
        {
                return lua_gettop(state_);
        }

        /**
         * Clear the stack, setting its size to zero.
         */
        void clear_stack()
        {
                stack_size(0);
        }

        /**
         * Makes sure there is at least extra more places on the stack.
         * Returns false if space couldn't be created.  Just like with the
         * regular Lua API, you are responsible to make sure the stack is big
         * enough to hold whatever you want to push on it.  This is usually
         * only an issue if you're pushing stuff in a loop.
         */
        bool check_stack(int extra)
        {
                return (bool)lua_checkstack(state_, extra);
        }

        /**
         * Concatenates the top-most n slots on the stack.
         */
        void concatenate(int n = 2)
        {
                lua_concat(state_, n);
        }

        /*
         * Push some values onto the stack.
         */

        slot push(char value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(unsigned char value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(short value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(unsigned short value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(int value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(unsigned int value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(long value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(unsigned long value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(long long value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }
        slot push(unsigned long long value)
        {
                lua_pushinteger(state_, lua_Integer(value));
                return top();
        }

        slot push(bool value)
        {
                lua_pushboolean(state_, int(value));
                return top();
        }

        slot push(float value)
        {
                lua_pushnumber(state_, lua_Number(value));
                return top();
        }
        slot push(double value)
        {
                lua_pushnumber(state_, lua_Number(value));
                return top();
        }

        slot push(const std::string& value)
        {
                lua_pushlstring(state_, value.c_str(), value.length());
                return top();
        }
        slot push(const char* value)
        {
                lua_pushstring(state_, value);
                return top();
        }
        slot push(const char* value, size_t length)
        {
                lua_pushlstring(state_, value, length);
                return top();
        }

        slot push(const function& function)
        {
                push<script::function>(function);
                push_pointer(this);
                push(call_functor, 2);
                return top();
        }
        slot push(cfunction function)
        {
                push_pointer(function);
                push_pointer(this);
                push(call_function, 2);
                return top();
        }

        template <class T>
        slot push(const T& object)
        {
                void* storage;
                slot copy = push_data(storage, sizeof(T));
                new(storage) T(object);

                push_class_metatable<T>();
                copy.set_metatable();
                return copy;
        }

        template <class T>
        slot push_class(const function& ctor)
        {
                slot metatable = push_class_metatable<T>();

                slot constructor = push_table();
                push(ctor);
                constructor.set_field("__call");
                metatable.set_metatable();

                return metatable;
        }
        template <class T>
        slot push_class(cfunction ctor)
        {
                slot metatable = push_class_metatable<T>();

                slot constructor = push_table();
                push(ctor);
                constructor.set_field("__call");
                metatable.set_metatable();

                return metatable;
        }

        slot push_nil()
        {
                lua_pushnil(state_);
                return top();
        }

        slot push_from_thread(script& thread, int n)
        {
                lua_xmove(thread.state_, state_, n);
                return top();
        }

        slot push_code(const std::string& file, status& result)
        {
                result = status(luaL_loadfile(state_, file.c_str()));
                return top();
        }

        slot push_code(const std::string& name,
                        const char* buffer, size_t size, status& result)
        {
                result = status(luaL_loadbuffer(state_,
                                        buffer, size, name.c_str()));
                return top();
        }

        slot push_data(void*& data, size_t size)
        {
                data = lua_newuserdata(state_, size);
                return top();
        }

        template <class T>
        slot push_pointer(const T* ptr)
        {
                lua_pushlightuserdata(state_,
                                const_cast<void*>((const void*)ptr));
                return top();
        }
        slot push_pointer(cfunction function)
        {
                return push_pointer((void*)function);
        }

        slot push_table(const std::string& name, int narr = 0, int nrec = 0)
        {
                if (name.empty()) return globals().push_field("_G");

                slot table = globals().push_field(name);
                if (table.is_table()) return table;

                pop();
                push_table(narr, nrec);
                globals().set_field(name);

                return globals().push_field(name);
        }
        slot push_table(int narr = 0, int nrec = 0)
        {
                lua_createtable(state_, narr, nrec);
                return top();
        }

        slot push_metatable(const std::string& type, bool& is_new)
        {
                is_new = luaL_newmetatable(state_, type.c_str());
                return top();
        }
        slot push_metatable(const std::string& type)
        {
                luaL_newmetatable(state_, type.c_str());
                return top();
        }

        template <class T>
        slot push_type()
        {
                return push_pointer(&typeid(T));
        }

        /**
         * Call a function on the stack.  The correct procedure is to push a
         * function onto the stack followed by nargs arguments.  This method
         * will pop them off upon return, leaving up to nresults return values
         * (default is any number of return values, depending on the callee).
         */
        status call(int nargs = 0, int nresults = LUA_MULTRET)
        {
                return status(lua_pcall(state_, nargs, nresults, 0));
        }

        /**
         * Pops n values from the top of the stack.
         */
        void pop(int n = 1)
        {
                lua_pop(state_, n);
        }

        /**
         * Index into the stack to get a slot.
         */
        slot operator [] (int index) const
        {
                return slot(*this, index);
        }

        /*
         * Control over the garbage collection process.
         */

        void collect_garbage()
        {
                lua_gc(state_, LUA_GCCOLLECT, 0);
        }
        void collect_garbage(int step)
        {
                lua_gc(state_, LUA_GCSTEP, step);
        }

        void disable_garbage_collector()
        {
                lua_gc(state_, LUA_GCSTOP, 0);
        }
        void enable_garbage_collector()
        {
                lua_gc(state_, LUA_GCRESTART, 0);
        }

        float memory_used() const
        {
                // in kilobytes
                return lua_gc(state_, LUA_GCCOUNT, 0) +
                           lua_gc(state_, LUA_GCCOUNTB, 0) / 1024.0f;
        }

        void tune_garbage_collector(int pause, int step = 200)
        {
                lua_gc(state_, LUA_GCSETPAUSE, pause);
                lua_gc(state_, LUA_GCSETSTEPMUL, step);
        }

private:

        script(lua_State* state) :
                state_(lua_newthread(state)) {}

        slot push(lua_CFunction function, int upvalues = 0)
        {
                lua_pushcclosure(state_, function, upvalues);
                return top();
        }

        template <class T>
        slot push_class_metatable()
        {
                bool is_new;
                slot metatable = push_metatable(typeid(T).name(), is_new);
                if (is_new)
                {
                        metatable.push_copy();                  // class behavior
                        metatable.set_field("__index");
                        push_type<T>();
                        metatable.set_field("__cxxtype");       // type_info
                        push(object_finalizer_<T>);
                        metatable.set_field("__gc");            // finalizer
                        //push(object_tostring_<T>);
                        //metatable.set_field("__tostring");    // tostring
                }
                return metatable;
        }

        template <class T>
        static int object_tostring_(lua_State* state)
        {
                std::ostringstream stream;
                stream << *reinterpret_cast<T*>(lua_touserdata(state, 1));
                lua_pushlstring(state,
                                stream.str().c_str(), stream.str().length());
                return 1;
        }

        template <class T>
        static int object_finalizer_(lua_State* state)
        {
                reinterpret_cast<T*>(lua_touserdata(state, 1))->~T();
                return 0;
        }

        static int call_functor(lua_State* state)
        {
                function* function = (script::function*)lua_touserdata(state,
                                lua_upvalueindex(1));

                script* script = (moof::script*)lua_touserdata(state,
                                lua_upvalueindex(2));

                try
                {
                        return (*function)(*script);
                }
                catch (const std::exception& e)
                {
                        if (0 < std::strlen(e.what()))
                        {
                                luaL_where(state, 1);
                                lua_pushstring(state, e.what());
                                lua_concat(state, 2);
                        }
                        return lua_error(state);
                }
                catch (const char* e)
                {
                        luaL_where(state, 1);
                        lua_pushstring(state, e);
                        lua_concat(state, 2);
                        return lua_error(state);
                }
                catch (...)
                {
                        return lua_error(state);
                }
        }

        static int call_function(lua_State* state)
        {
                cfunction function = (cfunction)lua_touserdata(state,
                                lua_upvalueindex(1));

                script* script = (moof::script*)lua_touserdata(state,
                                lua_upvalueindex(2));

                try
                {
                        return function(*script);
                }
                catch (const std::exception& e)
                {
                        if (0 < std::strlen(e.what()))
                        {
                                luaL_where(state, 1);
                                lua_pushstring(state, e.what());
                                lua_concat(state, 2);
                        }
                        return lua_error(state);
                }
                catch (const char* e)
                {
                        luaL_where(state, 1);
                        lua_pushstring(state, e);
                        lua_concat(state, 2);
                        return lua_error(state);
                }
                catch (...)
                {
                        return lua_error(state);
                }
        }

        void destroy()
        {
                if (is_main_thread()) lua_close(state_);
        }

        lua_State*                      state_;
};

using namespace std::rel_ops;

/**
 * Output a script value to a stream.
 */
inline std::ostream&
operator << (std::ostream& stream, const script::slot& slot)
{
        std::string     str;
        bool            boolean;

        if (slot.get(str))
        {
                stream << str;
        }
        else if (slot.get(boolean))
        {
                if (boolean) stream << "true";
                else stream << "false";
        }
        else if (slot.is_nil())
        {
                stream << "nil";
        }
        else
        {
                stream << slot.type_name() << " (" << slot.id() << ")";
        }

        return stream;
}


} // namespace moof

#endif // _MOOF_SCRIPT_HH_