C++ binding for lua

copied from conky (http://conky.sf.net) and relicensed. Since I am the person who wrote it in
the first place there should not be a problem with licence conversion.

1 files changed, 341 insertions, 0 deletions

diff --git a/src/FbTk/Luamm.hh b/src/FbTk/Luamm.hh
new file mode 100644
index 0000000..1df5825
--- /dev/null
+++ b/src/FbTk/Luamm.hh
@@ -0,0 +1,341 @@
+// luamm:  C++ binding for lua
+// Copyright (C) 2010 - 2011 Pavel Labath
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+#ifndef FBTK_LUAMM_HH
+#define FBTK_LUAMM_HH
+
+#include <assert.h>
+#include <memory>
+#include <stdexcept>
+
+#include <lua.h>
+
+namespace lua {
+    class state;
+
+    typedef lua_Integer integer;
+    typedef lua_Number number;
+    typedef std::function<int(state *)> cpp_function;
+
+    enum {
+        ENVIRONINDEX = LUA_ENVIRONINDEX,
+        GLOBALSINDEX = LUA_GLOBALSINDEX,
+        REGISTRYINDEX = LUA_REGISTRYINDEX
+    };
+
+    enum {
+        GCSTOP           = LUA_GCSTOP,
+        GCRESTART        = LUA_GCRESTART,
+        GCCOLLECT        = LUA_GCCOLLECT,
+        GCCOUNT          = LUA_GCCOUNT,
+        GCCOUNTB         = LUA_GCCOUNTB,
+        GCSTEP           = LUA_GCSTEP,
+        GCSETPAUSE       = LUA_GCSETPAUSE,
+        GCSETSTEPMUL = LUA_GCSETSTEPMUL
+    };
+
+    enum {
+        MULTRET = LUA_MULTRET
+    };
+
+    enum Type {
+        TBOOLEAN           = LUA_TBOOLEAN,
+        TFUNCTION          = LUA_TFUNCTION,
+        TLIGHTUSERDATA = LUA_TLIGHTUSERDATA,
+        TNIL               = LUA_TNIL,
+        TNONE              = LUA_TNONE,
+        TNUMBER            = LUA_TNUMBER,
+        TSTRING            = LUA_TSTRING,
+        TTABLE             = LUA_TTABLE,
+        TTHREAD            = LUA_TTHREAD,
+        TUSERDATA          = LUA_TUSERDATA
+    };
+
+    // we reserve one upvalue for the function pointer
+    inline int upvalueindex(int n)
+    { return lua_upvalueindex(n+1); }
+
+    /*
+     * Lua error()s are wrapped in this class when rethrown into C++ code. what() returns the
+     * error message. push_lua_error() pushes the error onto lua stack. The error can only be
+     * pushed into the same state it was generated in.
+     */
+    class exception: public std::runtime_error {
+        /*
+         * We only allow moving, to avoid complications with multiple references. It shouldn't be
+         * difficult to modify this to work with copying, if that proves unavoidable.
+         */
+        state *L;
+        int key;
+
+        static std::string get_error_msg(state *L);
+
+        exception(const exception &) = delete;
+        const exception& operator=(const exception &) = delete;
+
+        public:
+        exception(exception &&other)
+            : std::runtime_error(std::move(other)), L(other.L), key(other.key)
+        { other.L = NULL; }
+
+        explicit exception(state *l);
+        virtual ~exception() throw();
+
+        void push_lua_error(state *l);
+    };
+
+    class not_string_error: public std::runtime_error {
+        public:
+            not_string_error()
+                : std::runtime_error("Cannot convert value to a string")
+            {}
+    };
+
+    // the name says it all
+    class syntax_error: public lua::exception {
+        syntax_error(const syntax_error &) = delete;
+        const syntax_error& operator=(const syntax_error &) = delete;
+
+        public:
+        syntax_error(state *L)
+            : lua::exception(L)
+        {}
+
+        syntax_error(syntax_error &&other)
+            : lua::exception(std::move(other))
+        {}
+    };
+
+    // loadfile() encountered an error while opening/reading the file
+    class file_error: public lua::exception {
+        file_error(const file_error &) = delete;
+        const file_error& operator=(const file_error &) = delete;
+
+        public:
+        file_error(state *L)
+            : lua::exception(L)
+        {}
+
+        file_error(file_error &&other)
+            : lua::exception(std::move(other))
+        {}
+    };
+
+    // double fault, lua encountered an error while running the error handler function
+    class errfunc_error: public lua::exception {
+        errfunc_error(const errfunc_error &) = delete;
+        const errfunc_error& operator=(const errfunc_error &) = delete;
+
+        public:
+        errfunc_error(state *L)
+            : lua::exception(L)
+        {}
+
+        errfunc_error(errfunc_error &&other)
+            : lua::exception(std::move(other))
+        {}
+    };
+
+    // a fancy wrapper around lua_State
+    class state {
+        std::shared_ptr<lua_State> cobj;
+
+        // destructor for C++ objects stored as lua userdata
+        template<typename T>
+            static int destroy_cpp_object(lua_State *l)
+            {
+                T *ptr = static_cast<T *>(lua_touserdata(l, -1));
+                assert(ptr);
+                try {
+                    // throwing exceptions in destructors is a bad idea
+                    // but we catch (and ignore) them, just in case
+                    ptr->~T();
+                }
+                catch(...) {
+                }
+                return 0;
+            }
+
+        bool safe_compare(lua_CFunction trampoline, int index1, int index2);
+        public:
+        state();
+
+        /*
+         * Lua functions come in three flavours
+         * a) functions that never throw an exception
+         * b) functions that throw only in case of a memory allocation error
+         * c) functions that throw other kinds of errors
+         *
+         * Calls to type a functions are simply forwarded to the C api.
+         * Type c functions are executed in protected mode, to make sure they don't longjmp()
+         * over us (and our destructors). This add a certain amount overhead. If you care about
+         * performance, try using the raw versions (if possible).
+         * Type b functions are not executed in protected mode atm. as memory allocation errors
+         * don't happen that often (as opposed to the type c, where the user get deliberately set
+         * a metamethod that throws an error). That means those errors will do something
+         * undefined, but hopefully that won't be a problem.
+         *
+         * Semantics are mostly identical to those of the underlying C api. Any deviation is
+         * noted in the respective functions comment. The most important difference is that
+         * instead of return values, we use exceptions to indicate errors.      The lua and C++
+         * exception mechanisms are integrated. That means one can throw a C++ exception and
+         * catch it in lua (with pcall). Lua error()s can be caught in C++ as exceptions of type
+         * lua::exception.
+         */
+
+        // type a, never throw
+        int absindex(int index) throw() { return index<0 && -index<=gettop() ? gettop()+1+index : index; }
+        bool getmetatable(int index) throw() { return lua_getmetatable(cobj.get(), index); }
+        int gettop() throw() { return lua_gettop(cobj.get()); }
+        void insert(int index) throw() { lua_insert(cobj.get(), index); }
+        bool isboolean(int index) throw() { return lua_isboolean(cobj.get(), index); }
+        bool isfunction(int index) throw() { return lua_isfunction(cobj.get(), index); }
+        bool islightuserdata(int index) throw() { return lua_islightuserdata(cobj.get(), index); }
+        bool isnil(int index) throw() { return lua_isnil(cobj.get(), index); }
+        bool isnone(int index) throw() { return lua_isnone(cobj.get(), index); }
+        bool isnumber(int index) throw() { return lua_isnumber(cobj.get(), index); }
+        bool isstring(int index) throw() { return lua_isstring(cobj.get(), index); }
+        void pop(int n = 1) throw() { lua_pop(cobj.get(), n); }
+        void pushboolean(bool b) throw() { lua_pushboolean(cobj.get(), b); }
+        void pushinteger(integer n) throw() { lua_pushinteger(cobj.get(), n); }
+        void pushlightuserdata(void *p) throw() { lua_pushlightuserdata(cobj.get(), p); }
+        void pushnil() throw() { lua_pushnil(cobj.get()); }
+        void pushnumber(number n) throw() { lua_pushnumber(cobj.get(), n); }
+        void pushvalue(int index) throw() { lua_pushvalue(cobj.get(), index); }
+        void rawget(int index) throw() { lua_rawget(cobj.get(), index); }
+        void rawgeti(int index, int n) throw() { lua_rawgeti(cobj.get(), index, n); }
+        bool rawequal(int index1, int index2) throw() { return lua_rawequal(cobj.get(), index1, index2); }
+        void replace(int index) throw() { lua_replace(cobj.get(), index); }
+        // lua_setmetatable returns int, but docs don't specify it's meaning :/
+        int setmetatable(int index) throw() { return lua_setmetatable(cobj.get(), index); }
+        void settop(int index) throw() { return lua_settop(cobj.get(), index); }
+        bool toboolean(int index) throw() { return lua_toboolean(cobj.get(), index); }
+        integer tointeger(int index) throw() { return lua_tointeger(cobj.get(), index); }
+        number tonumber(int index) throw() { return lua_tonumber(cobj.get(), index); }
+        void* touserdata(int index) throw() { return lua_touserdata(cobj.get(), index); }
+        Type type(int index) throw() { return static_cast<Type>(lua_type(cobj.get(), index)); }
+        // typename is a reserved word :/
+        const char* type_name(Type tp) throw() { return lua_typename(cobj.get(), tp); }
+        void unref(int t, int ref) throw() { return luaL_unref(cobj.get(), t, ref); }
+
+        // type b, throw only on memory allocation errors
+        // checkstack correctly throws bad_alloc, because lua_checkstack kindly informs us of
+        // that sitution
+        void checkstack(int extra) throw(std::bad_alloc);
+        const char* gsub(const char *s, const char *p, const char *r) { return luaL_gsub(cobj.get(), s, p, r); }
+        bool newmetatable(const char *tname) { return luaL_newmetatable(cobj.get(), tname); }
+        void newtable() { lua_newtable(cobj.get()); }
+        void *newuserdata(size_t size) { return lua_newuserdata(cobj.get(), size); }
+        // cpp_function can be anything that std::function can handle, everything else remains
+        // identical
+        void pushclosure(const cpp_function &fn, int n);
+        void pushfunction(const cpp_function &fn) { pushclosure(fn, 0); }
+        void pushstring(const char *s) { lua_pushstring(cobj.get(), s); }
+        void pushstring(const char *s, size_t len) { lua_pushlstring(cobj.get(), s, len); }
+        void pushstring(const std::string &s) { lua_pushlstring(cobj.get(), s.c_str(), s.size()); }
+        void rawgetfield(int index, const char *k) throw(std::bad_alloc);
+        void rawset(int index) { lua_rawset(cobj.get(), index); }
+        void rawsetfield(int index, const char *k) throw(std::bad_alloc);
+        int ref(int t) { return luaL_ref(cobj.get(), t); }
+        // len recieves length, if not null. Returned value may contain '\0'
+        const char* tocstring(int index, size_t *len = NULL) { return lua_tolstring(cobj.get(), index, len); }
+        // Don't use pushclosure() to create a __gc function. The problem is that lua calls them
+        // in an unspecified order, and we may end up destroying the object holding the
+        // std::function before we get a chance to call it. This pushes a function that simply
+        // calls ~T when the time comes. Only set it as __gc on userdata of type T.
+        template<typename T>
+            void pushdestructor()
+            { lua_pushcfunction(cobj.get(), &destroy_cpp_object<T>); }
+
+        // type c, throw everything but the kitchen sink
+        // call() is a protected mode call, we don't allow unprotected calls
+        void call(int nargs, int nresults, int errfunc = 0);
+        void concat(int n);
+        bool equal(int index1, int index2);
+        int gc(int what, int data);
+        void getfield(int index, const char *k);
+        void gettable(int index);
+        void getglobal(const char *name) { getfield(GLOBALSINDEX, name); }
+        bool lessthan(int index1, int index2);
+        void loadfile(const char *filename) throw(lua::syntax_error, lua::file_error, std::bad_alloc);
+        void loadstring(const char *s) throw(lua::syntax_error, std::bad_alloc);
+        bool next(int index);
+        // register is a reserved word :/
+        void register_fn(const char *name, const cpp_function &f) { pushfunction(f); setglobal(name); }
+        void setfield(int index, const char *k);
+        void setglobal(const char *name) { setfield(GLOBALSINDEX, name); }
+        void settable(int index);
+        // lua_tostring uses NULL to indicate conversion error, since there is no such thing as a
+        // NULL std::string, we throw an exception. Returned value may contain '\0'
+        std::string tostring(int index) throw(lua::not_string_error);
+        // allocate a new lua userdata of appropriate size, and create a object in it
+        // pushes the userdata on stack and returns the pointer
+        template<typename T, typename... Args>
+            T* createuserdata(Args&&... args);
+    };
+
+    /*
+     * Can be used to automatically pop temporary values off the lua stack on exit from the
+     * function/block (e.g. via an exception). It's destructor makes sure the stack contains
+     * exactly n items. The constructor initializes n to l.gettop()+n_, but that can be later
+     * changed with the overloaded operators. It is an error if stack contains less than n
+     * elements at entry into the destructor.
+     *
+     * Proposed stack discipline for functions is this:
+     * - called function always pops parameters off the stack.
+     * - if functions returns normally, it's return values are on the stack.
+     * - if function throws an exception, there are no return values on the stack.
+     * The last point differs from lua C api, which return an error message on the stack. But
+     * since we have exception.what() for that, putting the message on the stack is not
+     * necessary.
+     */
+    class stack_sentry {
+        state *L;
+        int n;
+
+        stack_sentry(const stack_sentry &) = delete;
+        const stack_sentry& operator=(const stack_sentry &) = delete;
+        public:
+        explicit stack_sentry(state &l, int n_ = 0) throw()
+            : L(&l), n(l.gettop()+n_)
+        { assert(n >= 0); }
+
+        ~stack_sentry()                 throw() { assert(L->gettop() >= n); L->settop(n); }
+
+        void operator++()               throw() { ++n; }
+        void operator--()               throw() { --n; assert(n >= 0); }
+        void operator+=(int n_) throw() { n+=n_; }
+        void operator-=(int n_) throw() { n-=n_; assert(n >= 0); }
+    };
+
+    template<typename T, typename... Args>
+        T* state::createuserdata(Args&&... args)
+        {
+            stack_sentry s(*this);
+
+            void *t = newuserdata(sizeof(T));
+            new(t) T(std::forward<Args>(args)...);
+            ++s;
+            return static_cast<T *>(t);
+        }
+}
+
+#endif // FBTK_LUAMM_HH