16 files changed, 34 insertions, 18 deletions
diff --git a/Sluift/ElementConvertors/FormConvertor.cpp b/Sluift/ElementConvertors/FormConvertor.cpp
index 90fd9fe..245e0f9 100644
--- a/Sluift/ElementConvertors/FormConvertor.cpp
+++ b/Sluift/ElementConvertors/FormConvertor.cpp
@@ -2,76 +2,76 @@
  * Copyright (c) 2013-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/ElementConvertors/FormConvertor.h>
 
 #include <memory>
 #include <sstream>
 
 #include <boost/assign/list_of.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/Lua/Check.h>
 #include <Sluift/Lua/Value.h>
 
 using namespace Swift;
 
 namespace {
     int formIndex(lua_State* L) {
         lua_getfield(L, 1, "fields");
         if (lua_type(L, -1) != LUA_TTABLE) {
             return 0;
         }
         int index = Lua::absoluteOffset(L, -1);
         lua_pushnil(L);
         for (lua_pushnil(L); lua_next(L, index) != 0; ) {
             lua_getfield(L, -1, "name");
-            if (lua_equal(L, -1, 2)) {
+            if (lua_compare(L, -1, 2, LUA_OPEQ)) {
                 lua_pop(L, 1);
                 return 1;
             }
             lua_pop(L, 2);
         }
         return 0;
     }
 
     int formNewIndex(lua_State* L) {
         lua_getfield(L, 1, "fields");
         bool foundField = false;
         if (lua_type(L, -1) == LUA_TTABLE) {
             for (lua_pushnil(L); lua_next(L, -2) != 0; ) {
                 lua_getfield(L, -1, "name");
-                if (lua_equal(L, -1, 2)) {
+                if (lua_compare(L, -1, 2, LUA_OPEQ)) {
                     lua_pushvalue(L, 3);
                     lua_setfield(L, -3, "value");
                     foundField = true;
                     lua_pop(L, 3);
                     break;
                 }
                 lua_pop(L, 2);
             }
         }
         lua_pop(L, 1);
 
         if (!foundField) {
             lua_pushvalue(L, 2);
             lua_pushvalue(L, 3);
             lua_rawset(L, 1);
         }
         return 0;
     }
 
     Lua::Table convertFieldToLua(std::shared_ptr<FormField> field) {
         Lua::Table luaField = boost::assign::map_list_of("name", Lua::valueRef(field->getName()));
         std::string type;
         switch (field->getType()) {
             case FormField::UnknownType: type = ""; break;
             case FormField::BooleanType: type = "boolean"; break;
             case FormField::FixedType: type = "fixed"; break;
             case FormField::HiddenType: type = "hidden"; break;
             case FormField::ListSingleType: type = "list-single"; break;
             case FormField::TextMultiType: type = "text-multi"; break;
             case FormField::TextPrivateType: type = "text-private"; break;
diff --git a/Sluift/ElementConvertors/PubSubAffiliationsConvertor.cpp b/Sluift/ElementConvertors/PubSubAffiliationsConvertor.cpp
index c6ba09e..8f8a660 100644
--- a/Sluift/ElementConvertors/PubSubAffiliationsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubAffiliationsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubAffiliationsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubAffiliationsConvertor::PubSubAffiliationsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubAffiliations>("pubsub_affiliations"),
         convertors(convertors) {
 }
 
 PubSubAffiliationsConvertor::~PubSubAffiliationsConvertor() {
 }
 
 std::shared_ptr<PubSubAffiliations> PubSubAffiliationsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubAffiliations> result = std::make_shared<PubSubAffiliations>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubAffiliation> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubAffiliation> payload = std::dynamic_pointer_cast<PubSubAffiliation>(convertors->convertFromLuaUntyped(L, -1, "pubsub_affiliation"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setAffiliations(items);
     }
     return result;
 }
 
 void PubSubAffiliationsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubAffiliations> payload) {
     lua_createtable(L, 0, 0);
     if (payload->getNode()) {
         lua_pushstring(L, (*payload->getNode()).c_str());
         lua_setfield(L, -2, "node");
     }
     if (!payload->getAffiliations().empty()) {
         {
             int i = 0;
             for (auto&& item : payload->getAffiliations()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
diff --git a/Sluift/ElementConvertors/PubSubEventItemConvertor.cpp b/Sluift/ElementConvertors/PubSubEventItemConvertor.cpp
index ac86024..19ab09a 100644
--- a/Sluift/ElementConvertors/PubSubEventItemConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubEventItemConvertor.cpp
@@ -12,61 +12,61 @@
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubEventItemConvertor::PubSubEventItemConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubEventItem>("pubsub_event_item"),
         convertors(convertors) {
 }
 
 PubSubEventItemConvertor::~PubSubEventItemConvertor() {
 }
 
 std::shared_ptr<PubSubEventItem> PubSubEventItemConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubEventItem> result = std::make_shared<PubSubEventItem>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "publisher");
     if (lua_isstring(L, -1)) {
         result->setPublisher(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "data");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<Payload> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<Payload> payload = std::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setData(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "id");
     if (lua_isstring(L, -1)) {
         result->setID(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubEventItemConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubEventItem> payload) {
     lua_createtable(L, 0, 0);
     if (payload->getNode()) {
         lua_pushstring(L, (*payload->getNode()).c_str());
         lua_setfield(L, -2, "node");
     }
     if (payload->getPublisher()) {
         lua_pushstring(L, (*payload->getPublisher()).c_str());
         lua_setfield(L, -2, "publisher");
diff --git a/Sluift/ElementConvertors/PubSubEventItemsConvertor.cpp b/Sluift/ElementConvertors/PubSubEventItemsConvertor.cpp
index 7a3cde1..66f798e 100644
--- a/Sluift/ElementConvertors/PubSubEventItemsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubEventItemsConvertor.cpp
@@ -7,78 +7,78 @@
 #include <Sluift/ElementConvertors/PubSubEventItemsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubEventItemsConvertor::PubSubEventItemsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubEventItems>("pubsub_event_items"),
         convertors(convertors) {
 }
 
 PubSubEventItemsConvertor::~PubSubEventItemsConvertor() {
 }
 
 std::shared_ptr<PubSubEventItems> PubSubEventItemsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubEventItems> result = std::make_shared<PubSubEventItems>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "items");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubEventItem> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubEventItem> payload = std::dynamic_pointer_cast<PubSubEventItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_item"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setItems(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "retracts");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubEventRetract> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubEventRetract> payload = std::dynamic_pointer_cast<PubSubEventRetract>(convertors->convertFromLuaUntyped(L, -1, "pubsub_event_retract"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setRetracts(items);
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubEventItemsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubEventItems> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getItems().empty()) {
         lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);
         {
             int i = 0;
             for (auto&& item : payload->getItems()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
diff --git a/Sluift/ElementConvertors/PubSubItemConvertor.cpp b/Sluift/ElementConvertors/PubSubItemConvertor.cpp
index 27fd4a3..b46419a 100644
--- a/Sluift/ElementConvertors/PubSubItemConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubItemConvertor.cpp
@@ -2,61 +2,61 @@
  * Copyright (c) 2013-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/ElementConvertors/PubSubItemConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubItemConvertor::PubSubItemConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubItem>("pubsub_item"),
         convertors(convertors) {
 }
 
 PubSubItemConvertor::~PubSubItemConvertor() {
 }
 
 std::shared_ptr<PubSubItem> PubSubItemConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubItem> result = std::make_shared<PubSubItem>();
     lua_getfield(L, -1, "data");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<Payload> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<Payload> payload = std::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setData(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "id");
     if (lua_isstring(L, -1)) {
         result->setID(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubItemConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubItem> payload) {
     lua_createtable(L, 0, 0);
     if (!payload->getData().empty()) {
         lua_createtable(L, boost::numeric_cast<int>(payload->getData().size()), 0);
         {
             int i = 0;
             for (auto&& item : payload->getData()) {
                 if (convertors->convertToLua(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
diff --git a/Sluift/ElementConvertors/PubSubItemsConvertor.cpp b/Sluift/ElementConvertors/PubSubItemsConvertor.cpp
index 5fa1bd3..0bb8eb9 100644
--- a/Sluift/ElementConvertors/PubSubItemsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubItemsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubItemsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubItemsConvertor::PubSubItemsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubItems>("pubsub_items"),
         convertors(convertors) {
 }
 
 PubSubItemsConvertor::~PubSubItemsConvertor() {
 }
 
 std::shared_ptr<PubSubItems> PubSubItemsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubItems> result = std::make_shared<PubSubItems>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubItem> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setItems(items);
     }
     lua_getfield(L, -1, "maximum_items");
     if (lua_isnumber(L, -1)) {
         result->setMaximumItems(boost::numeric_cast<unsigned int>(lua_tonumber(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "subscription_id");
     if (lua_isstring(L, -1)) {
         result->setSubscriptionID(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubItemsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubItems> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getItems().empty()) {
diff --git a/Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.cpp b/Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.cpp
index ee8a8cb..9ca76fc 100644
--- a/Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubOwnerAffiliationsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubOwnerAffiliationsConvertor::PubSubOwnerAffiliationsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubOwnerAffiliations>("pubsub_owner_affiliations"),
         convertors(convertors) {
 }
 
 PubSubOwnerAffiliationsConvertor::~PubSubOwnerAffiliationsConvertor() {
 }
 
 std::shared_ptr<PubSubOwnerAffiliations> PubSubOwnerAffiliationsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubOwnerAffiliations> result = std::make_shared<PubSubOwnerAffiliations>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubOwnerAffiliation> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubOwnerAffiliation> payload = std::dynamic_pointer_cast<PubSubOwnerAffiliation>(convertors->convertFromLuaUntyped(L, -1, "pubsub_owner_affiliation"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setAffiliations(items);
     }
     return result;
 }
 
 void PubSubOwnerAffiliationsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubOwnerAffiliations> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getAffiliations().empty()) {
         {
             int i = 0;
             for (auto&& item : payload->getAffiliations()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
         }
     }
diff --git a/Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.cpp b/Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.cpp
index 88085b5..3530efe 100644
--- a/Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubOwnerSubscriptionsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubOwnerSubscriptionsConvertor::PubSubOwnerSubscriptionsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubOwnerSubscriptions>("pubsub_owner_subscriptions"),
         convertors(convertors) {
 }
 
 PubSubOwnerSubscriptionsConvertor::~PubSubOwnerSubscriptionsConvertor() {
 }
 
 std::shared_ptr<PubSubOwnerSubscriptions> PubSubOwnerSubscriptionsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubOwnerSubscriptions> result = std::make_shared<PubSubOwnerSubscriptions>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubOwnerSubscription> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubOwnerSubscription> payload = std::dynamic_pointer_cast<PubSubOwnerSubscription>(convertors->convertFromLuaUntyped(L, -1, "pubsub_owner_subscription"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setSubscriptions(items);
     }
     return result;
 }
 
 void PubSubOwnerSubscriptionsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubOwnerSubscriptions> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getSubscriptions().empty()) {
         {
             int i = 0;
             for (auto&& item : payload->getSubscriptions()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
         }
     }
diff --git a/Sluift/ElementConvertors/PubSubPublishConvertor.cpp b/Sluift/ElementConvertors/PubSubPublishConvertor.cpp
index 63c97bc..d8a2742 100644
--- a/Sluift/ElementConvertors/PubSubPublishConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubPublishConvertor.cpp
@@ -7,61 +7,61 @@
 #include <Sluift/ElementConvertors/PubSubPublishConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubPublishConvertor::PubSubPublishConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubPublish>("pubsub_publish"),
         convertors(convertors) {
 }
 
 PubSubPublishConvertor::~PubSubPublishConvertor() {
 }
 
 std::shared_ptr<PubSubPublish> PubSubPublishConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubPublish> result = std::make_shared<PubSubPublish>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "items");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubItem> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setItems(items);
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubPublishConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubPublish> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getItems().empty()) {
         lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);
         {
             int i = 0;
             for (auto&& item : payload->getItems()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
diff --git a/Sluift/ElementConvertors/PubSubRetractConvertor.cpp b/Sluift/ElementConvertors/PubSubRetractConvertor.cpp
index c070ad6..c27ad7d 100644
--- a/Sluift/ElementConvertors/PubSubRetractConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubRetractConvertor.cpp
@@ -7,61 +7,61 @@
 #include <Sluift/ElementConvertors/PubSubRetractConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubRetractConvertor::PubSubRetractConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubRetract>("pubsub_retract"),
         convertors(convertors) {
 }
 
 PubSubRetractConvertor::~PubSubRetractConvertor() {
 }
 
 std::shared_ptr<PubSubRetract> PubSubRetractConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubRetract> result = std::make_shared<PubSubRetract>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "items");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubItem> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubItem> payload = std::dynamic_pointer_cast<PubSubItem>(convertors->convertFromLuaUntyped(L, -1, "pubsub_item"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setItems(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "notify");
     if (lua_isboolean(L, -1)) {
         result->setNotify(lua_toboolean(L, -1));
     }
     lua_pop(L, 1);
     return result;
 }
 
 void PubSubRetractConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubRetract> payload) {
     lua_createtable(L, 0, 0);
     lua_pushstring(L, payload->getNode().c_str());
     lua_setfield(L, -2, "node");
     if (!payload->getItems().empty()) {
         lua_createtable(L, boost::numeric_cast<int>(payload->getItems().size()), 0);
         {
             int i = 0;
             for (auto&& item : payload->getItems()) {
diff --git a/Sluift/ElementConvertors/PubSubSubscriptionsConvertor.cpp b/Sluift/ElementConvertors/PubSubSubscriptionsConvertor.cpp
index 3712192..2325181 100644
--- a/Sluift/ElementConvertors/PubSubSubscriptionsConvertor.cpp
+++ b/Sluift/ElementConvertors/PubSubSubscriptionsConvertor.cpp
@@ -6,61 +6,61 @@
 
 #include <Sluift/ElementConvertors/PubSubSubscriptionsConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 #include <Sluift/LuaElementConvertors.h>
 
 using namespace Swift;
 
 PubSubSubscriptionsConvertor::PubSubSubscriptionsConvertor(LuaElementConvertors* convertors) :
         GenericLuaElementConvertor<PubSubSubscriptions>("pubsub_subscriptions"),
         convertors(convertors) {
 }
 
 PubSubSubscriptionsConvertor::~PubSubSubscriptionsConvertor() {
 }
 
 std::shared_ptr<PubSubSubscriptions> PubSubSubscriptionsConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<PubSubSubscriptions> result = std::make_shared<PubSubSubscriptions>();
     lua_getfield(L, -1, "node");
     if (lua_isstring(L, -1)) {
         result->setNode(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::shared_ptr<PubSubSubscription> > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (!lua_isnil(L, -1)) {
                 if (std::shared_ptr<PubSubSubscription> payload = std::dynamic_pointer_cast<PubSubSubscription>(convertors->convertFromLuaUntyped(L, -1, "pubsub_subscription"))) {
                     items.push_back(payload);
                 }
             }
             lua_pop(L, 1);
         }
 
         result->setSubscriptions(items);
     }
     return result;
 }
 
 void PubSubSubscriptionsConvertor::doConvertToLua(lua_State* L, std::shared_ptr<PubSubSubscriptions> payload) {
     lua_createtable(L, 0, 0);
     if (payload->getNode()) {
         lua_pushstring(L, (*payload->getNode()).c_str());
         lua_setfield(L, -2, "node");
     }
     if (!payload->getSubscriptions().empty()) {
         {
             int i = 0;
             for (auto&& item : payload->getSubscriptions()) {
                 if (convertors->convertToLuaUntyped(L, item) > 0) {
                     lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
                     ++i;
                 }
             }
diff --git a/Sluift/ElementConvertors/SecurityLabelConvertor.cpp b/Sluift/ElementConvertors/SecurityLabelConvertor.cpp
index 21d9a8f..8bc323a 100644
--- a/Sluift/ElementConvertors/SecurityLabelConvertor.cpp
+++ b/Sluift/ElementConvertors/SecurityLabelConvertor.cpp
@@ -1,59 +1,59 @@
 /*
  * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Sluift/ElementConvertors/SecurityLabelConvertor.h>
 
 #include <memory>
 
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <lua.hpp>
 
 using namespace Swift;
 
 SecurityLabelConvertor::SecurityLabelConvertor() :
         GenericLuaElementConvertor<SecurityLabel>("security_label") {
 }
 
 SecurityLabelConvertor::~SecurityLabelConvertor() {
 }
 
 std::shared_ptr<SecurityLabel> SecurityLabelConvertor::doConvertFromLua(lua_State* L) {
     std::shared_ptr<SecurityLabel> result = std::make_shared<SecurityLabel>();
     lua_getfield(L, -1, "equivalent_labels");
     if (lua_type(L, -1) == LUA_TTABLE) {
         std::vector< std::string > items;
-        for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+        for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
             lua_pushnumber(L, i + 1);
             lua_gettable(L, -2);
             if (lua_isstring(L, -1)) {
                 items.push_back(std::string(lua_tostring(L, -1)));
             }
             lua_pop(L, 1);
         }
 
         result->setEquivalentLabels(items);
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "foreground_color");
     if (lua_isstring(L, -1)) {
         result->setForegroundColor(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "display_marking");
     if (lua_isstring(L, -1)) {
         result->setDisplayMarking(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "background_color");
     if (lua_isstring(L, -1)) {
         result->setBackgroundColor(std::string(lua_tostring(L, -1)));
     }
     lua_pop(L, 1);
     lua_getfield(L, -1, "label");
     if (lua_isstring(L, -1)) {
         result->setLabel(std::string(lua_tostring(L, -1)));
     }
diff --git a/Sluift/ElementConvertors/StanzaConvertor.h b/Sluift/ElementConvertors/StanzaConvertor.h
index bdaaad3..a7b4e4e 100644
--- a/Sluift/ElementConvertors/StanzaConvertor.h
+++ b/Sluift/ElementConvertors/StanzaConvertor.h
@@ -19,61 +19,61 @@
 
 namespace Swift {
     template <typename T> class StanzaConvertor : public GenericLuaElementConvertor<T> {
         public:
             StanzaConvertor(const std::string& tag)
             : GenericLuaElementConvertor<T>(tag) {
             }
 
             virtual ~StanzaConvertor() {
             }
 
             std::shared_ptr<T> getStanza(lua_State* L, LuaElementConvertors* convertors) {
                 std::shared_ptr<T> result = std::make_shared<T>();
                 lua_getfield(L, -1, "id");
                 if (lua_isstring(L, -1)) {
                     result->setID(lua_tostring(L, -1));
                 }
                 lua_pop(L, 1);
                 lua_getfield(L, -1, "from");
                 if (lua_isstring(L, -1)) {
                     result->setFrom(lua_tostring(L, -1));
                 }
                 lua_pop(L, 1);
                 lua_getfield(L, -1, "to");
                 if (lua_isstring(L, -1)) {
                     result->setTo(lua_tostring(L, -1));
                 }
                 lua_pop(L, 1);
                 lua_getfield(L, -1, "payloads");
                 if (lua_type(L, -1) == LUA_TTABLE) {
-                    for(size_t i = 0; i < lua_objlen(L, -1); ++i) {
+                    for(size_t i = 0; i < lua_rawlen(L, -1); ++i) {
                         lua_pushnumber(L, i + 1);
                         lua_gettable(L, -2);
                         if (!lua_isnil(L, -1)) {
                             std::shared_ptr<Payload> payload = std::dynamic_pointer_cast<Payload>(convertors->convertFromLua(L, -1));
                             if (!!payload) {
                                 result->addPayload(payload);
                             }
                         }
                         lua_pop(L, 1);
                     }
                 }
                 lua_pop(L, 1);
                 return result;
             }
 
             void pushStanza(lua_State* L, const std::shared_ptr<T> stanza, LuaElementConvertors* convertors) {
                 lua_createtable(L, 0, 0);
                 lua_pushstring(L, stanza->getID().c_str());
                 lua_setfield(L, -2, "id");
                 lua_pushstring(L, stanza->getFrom().toString().c_str());
                 lua_setfield(L, -2, "from");
                 lua_pushstring(L, stanza->getTo().toString().c_str());
                 lua_setfield(L, -2, "to");
                 if (!stanza->getPayloads().empty()) {
                     lua_createtable(L, boost::numeric_cast<int>(stanza->getPayloads().size()), 0);
                     {
                         int i = 0;
                         for (const auto& item : stanza->getPayloads()) {
                             if (convertors->convertToLua(L, item) > 0) {
                                 lua_rawseti(L, -2, boost::numeric_cast<int>(i+1));
diff --git a/Sluift/Lua/LuaUtils.h b/Sluift/Lua/LuaUtils.h
index b87eb38..b9f5bff 100644
--- a/Sluift/Lua/LuaUtils.h
+++ b/Sluift/Lua/LuaUtils.h
@@ -1,43 +1,58 @@
 /*
  * Copyright (c) 2013 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <lua.hpp>
 #include <boost/optional.hpp>
 #include <string>
 #include <vector>
 
 #if LUA_VERSION_NUM < 502
-#define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
+#define lua_pushglobaltable(L)              lua_pushvalue(L, LUA_GLOBALSINDEX)
+#define lua_compare(L,idx1,idx2,LUA_OPEQ)   lua_equal(L,(idx1),(idx2))
+#define lua_rawlen(L, i)                    lua_objlen(L,(i))
+#endif
+#if LUA_VERSION_NUM >= 503
+#undef luaL_register
+#define luaL_register(L, n, l)  \
+    lua_getglobal( L, n );      \
+    if( lua_isnil( L, -1 ) )    \
+    {                           \
+        lua_pop( L, 1 );        \
+        lua_newtable( L );      \
+    }                           \
+    luaL_setfuncs( L, (l), 0 ); \
+    lua_pushvalue( L, -1 );     \
+    lua_setglobal( L, n );
 #endif
 
 namespace Swift {
     namespace Lua {
         /**
          * Can be used as __tostring metamethod on a table.
          */
         int convertTableToString(lua_State* L);
 
         void registerTableToString(lua_State* L, int index);
         void registerTableEquals(lua_State* L, int index);
         void registerGetByTypeIndex(lua_State* L, int index);
         void registerHelp(lua_State* L, int index,
                 const std::string& description, const std::string& parameters, const std::string& options);
         void registerClassHelp(lua_State* L, const std::string& name, const std::string& description);
         void registerExtraHelp(lua_State* L, int index, const std::string& name);
 
         inline int absoluteOffset(lua_State* L, int index) {
             return index > 0 ? index : lua_gettop(L) + index + 1;
         }
 
         boost::optional<std::string> getStringField(lua_State* L, int index, const std::string&);
         boost::optional<bool> getBooleanField(lua_State* L, int index, const std::string&);
         boost::optional<int> getIntField(lua_State* L, int index, const std::string&);
 
         void pushStringArray(lua_State* L, const std::vector<std::string>& strings);
     }
 }
diff --git a/Sluift/client.cpp b/Sluift/client.cpp
index 75f675d..ae2f610 100644
--- a/Sluift/client.cpp
+++ b/Sluift/client.cpp
@@ -674,61 +674,61 @@ SLUIFT_LUA_FUNCTION(Client, get_next_event) {
     return 1;
 }
 
 
 SLUIFT_LUA_FUNCTION_WITH_HELP(
         Client, add_contact,
         "Add a contact to the contact list.",
         "self\n",
         "jid  The JID of the contact to add\n"
         "name  The name to use in the contact list\n"
         "groups  An array of group names to add the contact to\n") {
     Sluift::globals.eventLoop.runOnce();
     SluiftClient* client = getClient(L);
     RosterItemPayload item;
     int timeout = getGlobalTimeout(L);
 
     if (lua_type(L, 2) == LUA_TTABLE) {
         lua_getfield(L, 2, "jid");
         const char* rawJID = lua_tostring(L, -1);
         if (rawJID) {
             item.setJID(std::string(rawJID));
         }
         lua_getfield(L, 2, "name");
         const char* rawName = lua_tostring(L, -1);
         if (rawName) {
             item.setName(rawName);
         }
         lua_getfield(L, 2, "groups");
         if (!lua_isnil(L, -1)) {
             if (lua_type(L, -1) == LUA_TTABLE) {
-                for (size_t i = 1; i <= lua_objlen(L, -1); ++i) {
+                for (size_t i = 1; i <= lua_rawlen(L, -1); ++i) {
                     lua_rawgeti(L, -1, boost::numeric_cast<int>(i));
                     const char* rawGroup = lua_tostring(L, -1);
                     if (rawGroup) {
                         item.addGroup(rawGroup);
                     }
                     lua_pop(L, 1);
                 }
             }
             else {
                 throw Lua::Exception("Groups should be a table");
             }
         }
     }
     else {
         item.setJID(Lua::checkString(L, 2));
     }
 
     client->getRoster(timeout);
     if (!client->getClient()->getRoster()->containsJID(item.getJID())) {
         RosterPayload::ref roster = std::make_shared<RosterPayload>();
         roster->addItem(item);
 
         Sluift::Response response = client->sendVoidRequest(
             SetRosterRequest::create(roster, client->getClient()->getIQRouter()), timeout);
         if (response.error) {
             return response.convertToLuaResult(L);
         }
     }
     client->getClient()->getSubscriptionManager()->requestSubscription(item.getJID());
     lua_pushboolean(L, true);
diff --git a/Sluift/core.lua b/Sluift/core.lua
index daa8636..f35a603 100644
--- a/Sluift/core.lua
+++ b/Sluift/core.lua
@@ -1,39 +1,40 @@
 --[[
 	Copyright (c) 2013-2017 Isode Limited.
 	All rights reserved.
 	See the COPYING file for more information.
 --]]
 
 local sluift = select(1, ...)
 local _G = _G
-local pairs, ipairs, print, tostring, type, error, assert, next, rawset, xpcall, unpack, io = pairs, ipairs, print, tostring, type, error, assert, next, rawset, xpcall, unpack, io
+local pairs, ipairs, print, tostring, type, error, assert, next, rawset, xpcall, io = pairs, ipairs, print, tostring, type, error, assert, next, rawset, xpcall, io
+local unpack = table.unpack or unpack
 local setmetatable, getmetatable = setmetatable, getmetatable
 local string = require "string"
 local table = require "table"
 local debug = require "debug"
 _ENV = nil
 
 --------------------------------------------------------------------------------
 -- Table utility methods
 --------------------------------------------------------------------------------
 
 local function table_value_tostring(value)
 	local result = tostring(value)
 	if type(value) == 'number' then return result
 	elseif type(value) == 'boolean' then return result
 	elseif type(value) == 'string' then return "'" .. result .. "'"
 	else return '<' .. result .. '>'
 	end
 end
 
 local function table_tostring(table, print_functions, indent, accumulator, history)
 	local INDENT = '  '
 	local accumulator = accumulator or ''
 	local history = history or {}
 	local indent = indent or ''
 	accumulator = accumulator .. '{'
 	history[table] = true
 	local is_first = true
 	for key, value in pairs(table) do
 		if print_functions or type(value) ~= 'function' then
 			if not is_first then