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, 468 insertions, 0 deletions

diff --git a/src/FbTk/Luamm.cc b/src/FbTk/Luamm.cc
new file mode 100644
index 0000000..a4a6eca
--- /dev/null
+++ b/src/FbTk/Luamm.cc
@@ -0,0 +1,468 @@
+// 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.
+
+
+#include <config.h>
+
+#include "Luamm.hh"
+
+namespace lua {
+    namespace {
+        // keys for storing values in lua registry
+        const char cpp_exception_metatable[] = "lua::cpp_exception_metatable";
+        const char cpp_function_metatable [] = "lua::cpp_function_metatable";
+        const char lua_exception_namespace[] = "lua::lua_exception_namespace";
+        const char this_cpp_object                [] = "lua::this_cpp_object";
+
+        // converts C++ exceptions to strings, so lua can do something with them
+        int exception_to_string(lua_State *l)
+        {
+            std::exception_ptr *ptr = static_cast<std::exception_ptr *>(lua_touserdata(l, -1));
+            assert(ptr);
+            try {
+                std::rethrow_exception(*ptr);
+            }
+            catch(std::exception &e) {
+                lua_pushstring(l, e.what());
+            }
+            catch(...) {
+                lua_pushstring(l, ptr->__cxa_exception_type()->name());
+            }
+            return 1;
+        }
+
+        int absindex(lua_State *l, int index) throw()
+        { return index<0 && -index<=lua_gettop(l) ? lua_gettop(l)+1+index : index; }
+
+        // Just like getfield(), only without calling metamethods (or throwing random exceptions)
+        inline void rawgetfield(lua_State *l, int index, const char *k) throw(std::bad_alloc)
+        {
+            index = absindex(l, index);
+            if(not lua_checkstack(l, 1))
+                throw std::bad_alloc();
+
+            lua_pushstring(l, k);
+            lua_rawget(l, index);
+        }
+
+        // Just like setfield(), only without calling metamethods (or throwing random exceptions)
+        inline void rawsetfield(lua_State *l, int index, const char *k) throw(std::bad_alloc)
+        {
+            index = absindex(l, index);
+            if(not lua_checkstack(l, 2))
+                throw std::bad_alloc();
+
+            lua_pushstring(l, k);
+            lua_insert(l, -2);
+            lua_rawset(l, index);
+        }
+
+        int closure_trampoline(lua_State *l)
+        {
+            lua_checkstack(l, 2);
+            rawgetfield(l, REGISTRYINDEX, this_cpp_object);
+            assert(lua_islightuserdata(l, -1));
+            state *L = static_cast<state *>( lua_touserdata(l, -1) );
+            lua_pop(l, 1);
+
+            try {
+                cpp_function *fn = static_cast<cpp_function *>( L->touserdata(lua_upvalueindex(1)) );
+                assert(fn);
+                return (*fn)(L);
+            }
+            catch(lua::exception &e) {
+                // rethrow lua errors as such
+                e.push_lua_error(L);
+            }
+            catch(...) {
+                // C++ exceptions (pointers to them, actually) are stored as lua userdata and
+                // then thrown
+                L->createuserdata<std::exception_ptr>(std::current_exception());
+                L->rawgetfield(REGISTRYINDEX, cpp_exception_metatable);
+                L->setmetatable(-2);
+            }
+
+            // lua_error does longjmp(), so destructors for objects in this function will not be
+            // called
+            return lua_error(l);
+        }
+
+        /*
+         * This function is called when lua encounters an error outside of any protected
+         * environment
+         * Throwing the exception through lua code appears to work, even if it was compiled
+         * without -fexceptions. If it turns out, it fails in some conditions, it could be
+         * replaced with some longjmp() magic. But that shouldn't be necessary, as this function
+         * will not be called under normal conditions (we execute everything in protected mode).
+         */
+        int panic_throw(lua_State *l)
+        {
+            if(not lua_checkstack(l, 1))
+                throw std::bad_alloc();
+
+            rawgetfield(l, REGISTRYINDEX, this_cpp_object);
+            assert(lua_islightuserdata(l, -1));
+            state *L = static_cast<state *>( lua_touserdata(l, -1) );
+            lua_pop(l, 1);
+
+            throw lua::exception(L);
+        }
+
+        // protected mode wrappers for various lua functions
+        int safe_concat_trampoline(lua_State *l)
+        {
+            lua_concat(l, lua_gettop(l));
+            return 1;
+        }
+
+        template<int (*compare)(lua_State *, int, int)>
+            int safe_compare_trampoline(lua_State *l)
+            {
+                int r = compare(l, 1, 2);
+                lua_pop(l, 2);
+                lua_pushinteger(l, r);
+                return 1;
+            }
+
+        int safe_gc_trampoline(lua_State *l)
+        {
+            int what = lua_tointeger(l, -2);
+            int data = lua_tointeger(l, -1);
+            lua_pop(l, 2);
+            lua_pushinteger(l, lua_gc(l, what, data));
+            return 1;
+        }
+
+        template<void (*misc)(lua_State *, int), int nresults>
+            int safe_misc_trampoline(lua_State *l)
+            {
+                misc(l, 1);
+                return nresults;
+            }
+
+        int safe_next_trampoline(lua_State *l)
+        {
+            int r = lua_next(l, 1);
+            lua_checkstack(l, 1);
+            lua_pushinteger(l, r);
+            return r ? 3 : 1;
+        }
+
+    }
+
+    std::string exception::get_error_msg(state *L)
+    {
+        static const std::string default_msg("Unknown lua exception");
+
+        try {
+            return L->tostring(-1);
+        }
+        catch(not_string_error &e) {
+            return default_msg;
+        }
+    }
+
+    exception::exception(state *l)
+        : std::runtime_error(get_error_msg(l)), L(l)
+    {
+        L->checkstack(1);
+
+        L->rawgetfield(REGISTRYINDEX, lua_exception_namespace);
+        L->insert(-2);
+        key = L->ref(-2);
+        L->pop(1);
+    }
+
+    exception::~exception() throw()
+    {
+        if(not L)
+            return;
+        L->checkstack(1);
+
+        L->rawgetfield(REGISTRYINDEX, lua_exception_namespace);
+        L->unref(-1, key);
+        L->pop();
+    }
+
+    void exception::push_lua_error(state *l)
+    {
+        if(l != L)
+            throw std::runtime_error("Cannot transfer exceptions between different lua contexts");
+        l->checkstack(2);
+
+        l->rawgetfield(REGISTRYINDEX, lua_exception_namespace);
+        l->rawgeti(-1, key);
+        l->replace(-2);
+    }
+
+    state::state()
+    {
+        if(lua_State *l = luaL_newstate())
+            cobj.reset(l, &lua_close);
+        else {
+            // docs say this can happen only in case of a memory allocation error
+            throw std::bad_alloc();
+        }
+
+        // set our panic function
+        lua_atpanic(cobj.get(), panic_throw);
+
+        checkstack(2);
+
+        // store a pointer to ourselves
+        pushlightuserdata(this);
+        rawsetfield(REGISTRYINDEX, this_cpp_object);
+
+        // a metatable for C++ exceptions travelling through lua code
+        newmetatable(cpp_exception_metatable);
+        lua_pushcfunction(cobj.get(), &exception_to_string);
+        rawsetfield(-2, "__tostring");
+        pushboolean(false);
+        rawsetfield(-2, "__metatable");
+        pushdestructor<std::exception_ptr>();
+        rawsetfield(-2, "__gc");
+        pop();
+
+        // a metatable for C++ functions callable from lua code
+        newmetatable(cpp_function_metatable);
+        pushboolean(false);
+        rawsetfield(-2, "__metatable");
+        pushdestructor<cpp_function>();
+        rawsetfield(-2, "__gc");
+        pop();
+
+        // while they're travelling through C++ code, lua exceptions will reside here
+        newtable();
+        rawsetfield(REGISTRYINDEX, lua_exception_namespace);
+
+        luaL_openlibs(cobj.get());
+    }
+
+    void state::call(int nargs, int nresults, int errfunc)
+    {
+        int r = lua_pcall(cobj.get(), nargs, nresults, errfunc);
+        if(r == 0)
+            return;
+
+        if(r == LUA_ERRMEM) {
+            // memory allocation error, cross your fingers
+            throw std::bad_alloc();
+        }
+
+        checkstack(3);
+        rawgetfield(REGISTRYINDEX, cpp_exception_metatable);
+        if(getmetatable(-2)) {
+            if(rawequal(-1, -2)) {
+                // it's a C++ exception, rethrow it
+                std::exception_ptr *ptr = static_cast<std::exception_ptr *>(touserdata(-3));
+                assert(ptr);
+
+                /*
+                 * we create a copy, so we can pop the object without fearing the exception will
+                 * be collected by lua's GC
+                 */
+                std::exception_ptr t(*ptr); ptr = NULL;
+                pop(3);
+                std::rethrow_exception(t);
+            }
+            pop(2);
+        }
+        // it's a lua exception, wrap it
+        if(r == LUA_ERRERR)
+            throw lua::errfunc_error(this);
+        else
+            throw lua::exception(this);
+    }
+
+    void state::checkstack(int extra) throw(std::bad_alloc)
+    {
+        if(not lua_checkstack(cobj.get(), extra))
+            throw std::bad_alloc();
+    }
+
+    void state::concat(int n)
+    {
+        assert(n>=0);
+        checkstack(1);
+        lua_pushcfunction(cobj.get(), safe_concat_trampoline);
+        insert(-n-1);
+        call(n, 1, 0);
+    }
+
+    bool state::equal(int index1, int index2)
+    {
+        // avoid pcall overhead in trivial cases
+        if( rawequal(index1, index2) )
+            return true;
+
+        return safe_compare(&safe_compare_trampoline<lua_equal>, index1, index2);
+    }
+
+    int state::gc(int what, int data)
+    {
+        checkstack(3);
+        lua_pushcfunction(cobj.get(), safe_gc_trampoline);
+        pushinteger(what);
+        pushinteger(data);
+        call(2, 1, 0);
+        assert(isnumber(-1));
+        int r = tointeger(-1);
+        pop();
+        return r;
+    }
+
+    void state::getfield(int index, const char *k)
+    {
+        checkstack(1);
+        index = absindex(index);
+        pushstring(k);
+        gettable(index);
+    }
+
+    void state::gettable(int index)
+    {
+        checkstack(2);
+        pushvalue(index);
+        insert(-2);
+        lua_pushcfunction(cobj.get(), (&safe_misc_trampoline<&lua_gettable, 1>));
+        insert(-3);
+        call(2, 1, 0);
+    }
+
+    bool state::lessthan(int index1, int index2)
+    {
+        return safe_compare(&safe_compare_trampoline<&lua_lessthan>, index1, index2);
+    }
+
+    void state::loadfile(const char *filename)
+        throw(lua::syntax_error, lua::file_error, std::bad_alloc)
+        {
+            switch(luaL_loadfile(cobj.get(), filename)) {
+                case 0:
+                    return;
+                case LUA_ERRSYNTAX:
+                    throw lua::syntax_error(this);
+                case LUA_ERRFILE:
+                    throw lua::file_error(this);
+                case LUA_ERRMEM:
+                    throw std::bad_alloc();
+                default:
+                    assert(0);
+            }
+        }
+
+    void state::loadstring(const char *s) throw(lua::syntax_error, std::bad_alloc)
+    {
+        switch(luaL_loadstring(cobj.get(), s)) {
+            case 0:
+                return;
+            case LUA_ERRSYNTAX:
+                throw lua::syntax_error(this);
+            case LUA_ERRMEM:
+                throw std::bad_alloc();
+            default:
+                assert(0);
+        }
+    }
+
+    bool state::next(int index)
+    {
+        checkstack(2);
+        pushvalue(index);
+        insert(-2);
+        lua_pushcfunction(cobj.get(), &safe_next_trampoline);
+        insert(-3);
+
+        call(2, MULTRET, 0);
+
+        assert(isnumber(-1));
+        int r = tointeger(-1);
+        pop();
+        return r;
+    }
+
+    void state::pushclosure(const cpp_function &fn, int n)
+    {
+        checkstack(2);
+
+        createuserdata<cpp_function>(fn);
+        rawgetfield(REGISTRYINDEX, cpp_function_metatable);
+        setmetatable(-2);
+
+        insert(-n-1);
+        lua_pushcclosure(cobj.get(), &closure_trampoline, n+1);
+    }
+
+    void state::rawgetfield(int index, const char *k) throw(std::bad_alloc)
+    { lua::rawgetfield(cobj.get(), index, k); }
+
+    void state::rawsetfield(int index, const char *k) throw(std::bad_alloc)
+    { lua::rawsetfield(cobj.get(), index, k); }
+
+    bool state::safe_compare(lua_CFunction trampoline, int index1, int index2)
+    {
+        // if one of the indexes is invalid, return false
+        if(isnone(index1) || isnone(index2))
+            return false;
+
+        // convert relative indexes into absolute
+        index1 = absindex(index1);
+        index2 = absindex(index2);
+
+        checkstack(3);
+        lua_pushcfunction(cobj.get(), trampoline);
+        pushvalue(index1);
+        pushvalue(index2);
+        call(2, 1, 0);
+        assert(isnumber(-1));
+        int r = tointeger(-1);
+        pop();
+        return r;
+    }
+
+    void state::setfield(int index, const char *k)
+    {
+        checkstack(1);
+        index = absindex(index);
+        pushstring(k);
+        insert(-2);
+        settable(index);
+    }
+
+    void state::settable(int index)
+    {
+        checkstack(2);
+        pushvalue(index);
+        insert(-3);
+        lua_pushcfunction(cobj.get(), (&safe_misc_trampoline<&lua_settable, 0>));
+        insert(-4);
+        call(3, 0, 0);
+    }
+
+    std::string state::tostring(int index) throw(lua::not_string_error)
+    {
+        size_t len;
+        const char *str = lua_tolstring(cobj.get(), index, &len);
+        if(not str)
+            throw not_string_error();
+        return std::string(str, len);
+    }
+}