diff --git a/sol/lua_function.hpp b/sol/lua_function.hpp
index c69941e7..61a5249d 100644
--- a/sol/lua_function.hpp
+++ b/sol/lua_function.hpp
@@ -27,6 +27,37 @@
 #include <memory>
 
 namespace sol {
+namespace detail {
+template<typename T, std::size_t n>
+void get_upvalue_ptr( lua_State* L, T*& data, std::size_t datasize, std::array<void*, n> voiddata, int& upvalue ) {
+	for ( std::size_t i = 0, d = 0; d < datasize; ++i, d += sizeof( void* ) ) {
+		voiddata[ i ] = lua_touserdata( L, lua_upvalueindex( upvalue++ ) );
+	}
+	data = reinterpret_cast<T*>( static_cast<void*>( voiddata.data( ) ) );
+}
+template<typename T, std::size_t n>
+void get_upvalue_ptr( lua_State* L, T*& data, std::array<void*, n> voiddata, int& upvalue ) {
+	get_upvalue_ptr( L, data, sizeof( T ), voiddata, upvalue );
+}
+template<typename T>
+void get_upvalue_ptr( lua_State* L, T*& data, int& upvalue ) {
+	const static std::size_t data_t_count = ( sizeof(T)+( sizeof(void*)-1 ) ) / sizeof( void* );
+	typedef std::array<void*, data_t_count> data_t;
+	data_t voiddata{{}};
+	return get_upvalue_ptr(L, data, voiddata, upvalue);
+}
+template<typename T>
+void get_upvalue( lua_State* L, T& data, int& upvalue ) {
+	const static std::size_t data_t_count = ( sizeof(T)+( sizeof(void*)-1 ) ) / sizeof( void* );
+	typedef std::array<void*, data_t_count> data_t;
+	data_t voiddata{ { } };
+	for ( std::size_t i = 0, d = 0; d < sizeof(T); ++i, d += sizeof( void* ) ) {
+		voiddata[ i ] = lua_touserdata( L, lua_upvalueindex( upvalue++ ) );
+	}
+	data = *reinterpret_cast<T*>( static_cast<void*>( voiddata.data( ) ) );
+}
+} // detail
+
 
 template<typename TFx>
 struct static_lua_func {
@@ -47,10 +78,9 @@ struct static_lua_func {
     }
 
     static int call(lua_State* L) {
-        void* functiondata = lua_touserdata(L, lua_upvalueindex(1));
-        //if (functiondata == nullptr)
-        //    throw sol_error("call from lua to c++ function has null function pointer data");
-        fx_t* fx = reinterpret_cast<fx_t*>(functiondata);
+        int upvalue = 1;
+        fx_t* fx;
+	   detail::get_upvalue( L, fx, upvalue );
         int r = typed_call(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), fx, L);
         return r;
     }
@@ -74,7 +104,9 @@ struct static_object_lua_func {
 
     template<typename TR, typename... Args>
     static int typed_call(types<TR>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
-        auto fx = [ &item, &ifx ] (Args&&... args) -> TR { return (item.*ifx)(std::forward<Args>(args)...); };
+        auto fx = [ &item, &ifx ] (Args&&... args) -> TR { 
+		   return (item.*ifx)(std::forward<Args>(args)...); 
+	   };
         auto r = stack::pop_call(L, fx, types<Args...>());
         stack::push(L, std::move(r));
         return 1;
@@ -89,20 +121,19 @@ struct static_object_lua_func {
     }
 
     static int call(lua_State* L) {
-        const static std::size_t data_t_count = (sizeof(fx_t)+(sizeof(void*)-1)) / sizeof(void*);
-        typedef std::array<void*, data_t_count> data_t;
-        data_t fxptrdata;
-        int upvalue = 1;
-        for (std::size_t i = 0; i < fxptrdata.size(); ++i) {
-            fxptrdata[ i ] = lua_touserdata(L, lua_upvalueindex(upvalue++));
-        }
-        void* objectdata = lua_touserdata(L, lua_upvalueindex(upvalue++));
-        //if (objectdata == nullptr)
-        //    throw sol_error("call from lua to c++ function has null object data");
-        fx_t* fxptr = reinterpret_cast<fx_t*>(static_cast<void*>(fxptrdata.data()));
-        fx_t& mem_ptr = *fxptr;
-        T& obj = *static_cast<T*>(objectdata);
-        int r = typed_call(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), obj, mem_ptr, L);
+        const static std::size_t data_t_count = ( sizeof(fx_t)+( sizeof(void*)-1 ) ) / sizeof( void* );
+	   typedef std::array<void*, data_t_count> data_t;
+	   int upvalue = 1;
+	   data_t data = { { } };
+	   fx_t* fxptr;
+	   for ( std::size_t i = 0, d = 0; d < sizeof(fx_t*); ++i, d += sizeof( void* ) ) {
+		   data[ i ] = lua_touserdata( L, lua_upvalueindex( upvalue++ ) );
+	   }
+	   fxptr = reinterpret_cast<fx_t*>( static_cast<void*>( data.data( ) ) ); 
+	   fx_t& mem_ptr = *fxptr;
+	   void* objectdata = lua_touserdata( L, lua_upvalueindex( upvalue++ ) );
+	   T& obj = *static_cast<T*>( objectdata );
+	   int r = typed_call( tuple_types<typename fx_traits::return_type>( ), typename fx_traits::args_type( ), obj, mem_ptr, L );
         return r;
     }
 
@@ -127,7 +158,7 @@ struct lua_func {
         void** puserdata = static_cast<void**>(lua_touserdata(L, 1));
         void* userdata = *puserdata;
         lua_func* ptr = static_cast<lua_func*>(userdata);
-        std::default_delete<lua_func> dx{ };
+        std::default_delete<lua_func> dx{};
         dx(ptr);
         return 0;
     }
diff --git a/sol/stack.hpp b/sol/stack.hpp
index 925cf9a9..1fa8a024 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -27,6 +27,7 @@
 #include <utility>
 #include <type_traits>
 #include <array>
+#include <cstring>
 
 namespace sol {
 template<typename T, typename R = void>
@@ -183,6 +184,21 @@ inline void push(lua_State* L, const std::array<T, N>& data) {
     }
 }
 
+template <typename T>
+inline int push_user( lua_State* L, T& item ) {
+	typedef typename std::decay<T>::type TValue;
+	const static std::size_t itemsize = sizeof( TValue );
+	const static std::size_t voidsize = sizeof( void* );
+	const static std::size_t voidsizem1 = voidsize - 1;
+	const static std::size_t data_t_count = (sizeof(TValue) + voidsizem1) / voidsize;
+	typedef std::array<void*, data_t_count> data_t;
+
+	data_t data{{}};
+	std::memcpy( std::addressof( data[ 0 ] ), std::addressof( item ), itemsize );
+	push( L, data );
+	return data_t_count;
+}
+
 namespace detail {
 template<typename T, std::size_t... I>
 inline void push(lua_State* L, indices<I...>, const T& tuplen) {
diff --git a/sol/table.hpp b/sol/table.hpp
index e19ef713..bcf635bb 100644
--- a/sol/table.hpp
+++ b/sol/table.hpp
@@ -41,8 +41,8 @@ namespace detail {
 }
 class table : virtual public reference {
 public:
-    table() noexcept: reference() {}
-    table(lua_State* L, int index = -1): reference(L, index) {
+    table() noexcept : reference() {}
+    table(lua_State* L, int index = -1) : reference(L, index) {
         type_assert(L, index, type::table);
     }
 
@@ -70,12 +70,12 @@ public:
     template<typename T, typename TFx>
     table& set_function(T&& key, TFx&& fx) {
         typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
-       return set_isfunction_fx(std::is_function<clean_fx>(), std::forward<T>(key), std::forward<TFx>(fx));
+        return set_isfunction_fx(std::is_function<clean_fx>(), std::forward<T>(key), std::forward<TFx>(fx));
     }
 
     template<typename T, typename TFx, typename TObj>
     table& set_function(T&& key, TFx&& fx, TObj&& obj) {
-        return set_lvalue_fx(std::integral_constant<bool, std::is_lvalue_reference<TObj>::value || std::is_pointer<TObj>::value>(), 
+        return set_lvalue_fx(std::integral_constant<bool, std::is_lvalue_reference<TObj>::value || std::is_pointer<TObj>::value>(),
             std::forward<T>(key), std::forward<TFx>(fx), std::forward<TObj>(obj));
     }
 
@@ -92,10 +92,10 @@ private:
 
     template<typename T, typename TFx>
     table& set_isfunction_fx(std::false_type, T&& key, TFx&& fx) {
-       typedef typename std::decay<TFx>::type clean_lambda;
-       typedef typename detail::function_traits<decltype(&clean_lambda::operator())>::free_function_pointer_type raw_func_t;
-       typedef std::is_convertible<clean_lambda, raw_func_t> isconvertible;
-       return set_isconvertible_fx(isconvertible(), std::forward<T>(key), std::forward<TFx>(fx));
+        typedef typename std::decay<TFx>::type clean_lambda;
+        typedef typename detail::function_traits<decltype(&clean_lambda::operator())>::free_function_pointer_type raw_func_t;
+        typedef std::is_convertible<clean_lambda, raw_func_t> isconvertible;
+        return set_isconvertible_fx(isconvertible(), std::forward<T>(key), std::forward<TFx>(fx));
     }
 
     template<typename T, typename TFx>
@@ -107,9 +107,9 @@ private:
 
     template<typename T, typename TFx>
     table& set_isconvertible_fx(std::false_type, T&& key, TFx&& fx) {
-       typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
-       std::unique_ptr<lua_func> sptr(new lambda_lua_func<clean_fx>(std::forward<TFx>(fx)));
-       return set_fx(std::forward<T>(key), std::move(sptr));
+        typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
+        std::unique_ptr<lua_func> sptr(new lambda_lua_func<clean_fx>(std::forward<TFx>(fx)));
+        return set_fx(std::forward<T>(key), std::move(sptr));
     }
 
     template<typename T, typename TFx, typename TObj>
@@ -128,20 +128,15 @@ private:
     table& set_fx(std::true_type, T&& key, TFx&& fx, TObj&& obj) {
         typedef typename std::decay<TObj>::type decay_of_to;
         typedef typename std::decay<TFx>::type decay_of_tfx;
-        const static std::size_t data_t_count = (sizeof(decay_of_tfx)+(sizeof(void*)-1)) / sizeof(void*);
-        typedef std::array<void*, data_t_count> data_t;
-
-        std::string fkey(key);
         
+        std::string fkey(key);
+
         // Layout: 
         // idx 1...n: verbatim data of member function pointer
         // idx n + 1: is the object's void pointer
         // We don't need to store the size, because the other side is templated
         // with the same member function pointer type
         decay_of_tfx fxptr(std::forward<TFx>(fx));
-        data_t fxptrdata;
-        std::size_t fxptrsize = sizeof(fxptr);
-        std::memcpy(std::addressof(fxptrdata[ 0 ]), std::addressof(fxptr), fxptrsize);
         void* userobjdata = static_cast<void*>(detail::get_ptr(obj));
         lua_CFunction freefunc = &static_object_lua_func<decay_of_to, TFx>::call;
         const char* freefuncname = fkey.c_str();
@@ -150,12 +145,12 @@ private:
             { nullptr, nullptr }
         };
 
-        
+
         push();
 
-        stack::push(state(), fxptrdata);
+        int upvalues = stack::push_user(state(), fxptr);
         stack::push(state(), userobjdata);
-        luaL_setfuncs(state(), funcreg, fxptrdata.size() + 1);
+        luaL_setfuncs(state(), funcreg, upvalues + 1);
 
         lua_pop(state(), 1);
         return *this;
@@ -164,50 +159,50 @@ private:
     template<typename T, typename TFx>
     table& set_fx(std::false_type, T&& key, TFx&& fx) {
         typedef typename std::decay<TFx>::type ptr_fx;
-       std::string fkey(key);
-       ptr_fx target(std::forward<TFx>(fx));
-       void* userdata = reinterpret_cast<void*>(target);
-       lua_CFunction freefunc = &static_lua_func<TFx>::call;
-       const char* freefuncname = fkey.c_str();
-       const luaL_Reg funcreg[ 2 ] = {
-           { freefuncname, freefunc },
-         { nullptr, nullptr }
-       };
+        std::string fkey(key);
+        ptr_fx target(std::forward<TFx>(fx));
+        lua_CFunction freefunc = &static_lua_func<TFx>::call;
+        const char* freefuncname = fkey.c_str();
+        const luaL_Reg funcreg[ 2 ] = {
+            { freefuncname, freefunc },
+            { nullptr, nullptr }
+        };
 
-       push();
+        push();
 
-       stack::push(state(), userdata);
-       luaL_setfuncs(state(), funcreg, 1);
+	   int upvalues = stack::push_user( state( ), target );
+        luaL_setfuncs(state(), funcreg, upvalues);
 
-       lua_pop(state(), 1);
-       return *this;
+        lua_pop(state(), 1);
+        return *this;
     }
 
     template<typename T>
     table& set_fx(T&& key, std::unique_ptr<lua_func> luafunc) {
         std::string fkey(key);
-       std::string metakey("sol.stateful.");
-       metakey += fkey;
-       metakey += ".meta";
-       lua_func* target = luafunc.release();
+        std::string metakey("sol.stateful.");
+        metakey += fkey;
+        metakey += ".meta";
+        lua_func* target = luafunc.release();
         void* userdata = reinterpret_cast<void*>(target);
         lua_CFunction freefunc = &lua_func::call;
         const char* freefuncname = fkey.c_str();
-       const char* metatablename = metakey.c_str();
-        const luaL_Reg funcreg[2] = {
+        const char* metatablename = metakey.c_str();
+        const luaL_Reg funcreg[ 2 ] = {
             { freefuncname, freefunc },
-          { nullptr, nullptr }
-       };
+            { nullptr, nullptr }
+        };
 
-       int exists = luaL_newmetatable(state(), metatablename);
-       lua_pushstring(state(), "__gc");
-       lua_pushcclosure(state(), &lua_func::gc, 0);
-       lua_settable(state(), -3);
-       push();
+        if (luaL_newmetatable(state(), metatablename) == 1) {
+            lua_pushstring(state(), "__gc");
+            lua_pushcclosure(state(), &lua_func::gc, 0);
+            lua_settable(state(), -3);
+        }
+
+	   push();
+        stack::push_user(state(), userdata, metatablename);
+        luaL_setfuncs(state(), funcreg, 1);
 
-       stack::push_user(state(), userdata, metatablename);
-       luaL_setfuncs(state(), funcreg, 1);
-       
         lua_pop(state(), 1);
         return *this;
     }