/*]  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
#define IS_TYPE(T, N) \
		bool is_##N() const \
		{ \
			return (bool)lua_is##T(script_->state_, index); \
		}//
		IS_TYPE(boolean, boolean);
		IS_TYPE(cfunction, imported_function);
		IS_TYPE(function, function);
		IS_TYPE(lightuserdata, light_data);
		IS_TYPE(nil, nil);
		IS_TYPE(none, none);
		IS_TYPE(noneornil, none_or_nil);
		IS_TYPE(number, number);
		IS_TYPE(string, string);
		IS_TYPE(table, table);
		IS_TYPE(thread, thread);
		IS_TYPE(userdata, data);
#undef IS_TYPE

		/**
		 * 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;
		}

#define REQUIRE_TYPE(T) \
		const slot& require_##T(const std::string& what = #T) const \
		{ \
			if (!is_##T()) raise_type_error(what); \
			return *this; \
		}//
		REQUIRE_TYPE(boolean);
		REQUIRE_TYPE(number);
		REQUIRE_TYPE(string);
		REQUIRE_TYPE(table);
		REQUIRE_TYPE(function);
		REQUIRE_TYPE(data);
		REQUIRE_TYPE(nil);
		REQUIRE_TYPE(thread);
#undef REQUIRE_TYPE

		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.
		 */

#define GET_INT_OF_TYPE(T) \
		bool get(T& value) const \
		{ \
			if (is_number()) \
			{ \
				value = static_cast<T>(lua_tointeger(script_->state_, index)); \
				return true; \
			} \
			return false; \
		}//
		GET_INT_OF_TYPE(char);
		GET_INT_OF_TYPE(unsigned char);
		GET_INT_OF_TYPE(short);
		GET_INT_OF_TYPE(unsigned short);
		GET_INT_OF_TYPE(int);
		GET_INT_OF_TYPE(unsigned int);
		GET_INT_OF_TYPE(long);
		GET_INT_OF_TYPE(unsigned long);
		GET_INT_OF_TYPE(long long);
		GET_INT_OF_TYPE(unsigned long long);
#undef GET_INT_OF_TYPE

		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;
		}
		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();
	}

#define IMPORT_LIBRARY(L, K) \
	void import_##L##_library() \
	{ \
		push(luaopen_##L); \
		push(LUA_##K##LIBNAME); \
		call(1, 0); \
	}//
	IMPORT_LIBRARY(base, CO);
	IMPORT_LIBRARY(debug, DB);
	IMPORT_LIBRARY(io, IO);
	IMPORT_LIBRARY(math, MATH);
	IMPORT_LIBRARY(os, OS);
	IMPORT_LIBRARY(package, LOAD);
	IMPORT_LIBRARY(string, STR);
	IMPORT_LIBRARY(table, TAB);
#undef IMPORT_LIBRARY

	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.
	 */

#define PUSH_INT_OF_TYPE(T) \
	slot push(T value) \
	{ \
		lua_pushinteger(state_, static_cast<lua_Integer>(value)); \
		return top(); \
	}//
	PUSH_INT_OF_TYPE(char);
	PUSH_INT_OF_TYPE(unsigned char);
	PUSH_INT_OF_TYPE(short);
	PUSH_INT_OF_TYPE(unsigned short);
	PUSH_INT_OF_TYPE(int);
	PUSH_INT_OF_TYPE(unsigned int);
	PUSH_INT_OF_TYPE(long);
	PUSH_INT_OF_TYPE(unsigned long);
	PUSH_INT_OF_TYPE(long long);
	PUSH_INT_OF_TYPE(unsigned long long);
#undef PUSH_INT_OF_TYPE

	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_