script_core 0.2.1 → 0.2.2

data/ext/enterprise_script_service/msgpack/include/msgpack/v2/parse.hpp

@@ -241,8 +241,6 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
     const char* const pe = data + len;
     const char* n = MSGPACK_NULLPTR;
 
-    msgpack::object obj;
-
     if(m_current == pe) {
         off = static_cast<std::size_t>(m_current - m_start);
         return PARSE_CONTINUE;

data/ext/enterprise_script_service/msgpack/include/msgpack/v3/parse.hpp

@@ -250,8 +250,6 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
     const char* const pe = data + len;
     const char* n = MSGPACK_NULLPTR;
 
-    msgpack::object obj;
-
     if(m_current == pe) {
         off = static_cast<std::size_t>(m_current - m_start);
         return PARSE_CONTINUE;

data/ext/enterprise_script_service/msgpack/include/msgpack/version_master.h

@@ -1,3 +1,3 @@
 #define MSGPACK_VERSION_MAJOR    3
 #define MSGPACK_VERSION_MINOR    2
-#define MSGPACK_VERSION_REVISION 0
+#define MSGPACK_VERSION_REVISION 1

data/ext/enterprise_script_service/msgpack/include/msgpack/vrefbuffer.h

@@ -13,7 +13,7 @@
 #include "zone.h"
 #include <stdlib.h>
 
-#if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) || defined(__QNXTO__)
+#if defined(unix) || defined(__unix) || defined(__linux__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) || defined(__QNXTO__) || defined(__HAIKU__)
 #include <sys/uio.h>
 #else
 struct iovec {

data/ext/enterprise_script_service/msgpack/include/msgpack/zbuffer.h

@@ -146,6 +146,7 @@ static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf)
         case Z_STREAM_END:
             return zbuf->data;
         case Z_OK:
+        case Z_BUF_ERROR:
             if(!msgpack_zbuffer_expand(zbuf)) {
                 return NULL;
             }

data/ext/enterprise_script_service/msgpack/msgpack-config.cmake.in

@@ -6,8 +6,9 @@
 #
 # ::
 #
-#   msgpackc-static
 #   msgpackc
+#   msgpackc-cxx
+#   msgpackc-static (optional)
 #
 
 @PACKAGE_INIT@
@@ -16,8 +17,4 @@ include(CMakeFindDependencyMacro)
 
 if(NOT TARGET msgpackc AND NOT TARGET msgpackc-static)
   include("${CMAKE_CURRENT_LIST_DIR}/msgpack-targets.cmake")
-
-  if(NOT @MSGPACK_ENABLE_SHARED@)
-    add_library(msgpackc ALIAS msgpackc-static)
-  endif()
 endif()

data/ext/enterprise_script_service/msgpack/src/objectc.c

@@ -256,7 +256,7 @@ void msgpack_object_print(FILE* out, msgpack_object o)
 
 #define MSGPACK_CHECKED_CALL(ret, func, aux_buffer, aux_buffer_size, ...) \
     ret = func(aux_buffer, aux_buffer_size, __VA_ARGS__);                 \
-    if (ret <= 0 || ret > (int)aux_buffer_size) return 0;                 \
+    if (ret <= 0 || ret >= (int)aux_buffer_size) return 0;                \
     aux_buffer = aux_buffer + ret;                                        \
     aux_buffer_size = aux_buffer_size - ret                               \
 

data/ext/enterprise_script_service/msgpack/test/array_ref.cpp

@@ -25,8 +25,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
@@ -47,8 +48,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
@@ -67,8 +69,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
@@ -89,8 +92,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
@@ -184,8 +188,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
@@ -203,8 +208,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
@@ -220,8 +226,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
@@ -239,8 +246,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);

data/ext/enterprise_script_service/msgpack/test/boost_fusion.cpp

@@ -35,8 +35,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert)
     val1.f1 = 42;
     val1.f2 = 123.45;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct val2 = oh.get().as<mystruct>();
     EXPECT_TRUE(val1.f1 == val2.f1);
     EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
@@ -156,8 +157,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
     std::stringstream ss;
     mystruct_no_def_con val1(no_def_con1(1), no_def_con2(2), no_def_con1(3));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct_no_def_con val2 = oh.get().as<mystruct_no_def_con>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -207,8 +209,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
     std::stringstream ss;
     mystruct_no_def_con_def_con val1(no_def_con1(1), no_def_con2(2), 3);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct_no_def_con_def_con val2 = oh.get().as<mystruct_no_def_con_def_con>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -224,8 +227,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair)
     std::stringstream ss;
     std::pair<bool, int> val1(false, 42);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::pair<bool, int>  val2 = oh.get().as<std::pair<bool, int> >();
     EXPECT_TRUE(val1.first == val2.first);
     EXPECT_TRUE(val1.second == val2.second);
@@ -240,8 +244,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple)
     std::stringstream ss;
     std::tuple<bool, int> val1(false, 42);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::tuple<bool, int> val2 = oh.get().as<std::tuple<bool, int> >();
     EXPECT_TRUE(val1 == val2);
 }

data/ext/enterprise_script_service/msgpack/test/boost_optional.cpp

@@ -21,8 +21,9 @@ TEST(MSGPACK_BOOST, pack_convert_nil)
     std::stringstream ss;
     boost::optional<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -32,8 +33,9 @@ TEST(MSGPACK_BOOST, pack_convert_int)
     std::stringstream ss;
     boost::optional<int> val1 = 1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -49,8 +51,9 @@ TEST(MSGPACK_BOOST, pack_convert_vector)
     v.push_back(3);
     val1 = v;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -64,8 +67,9 @@ TEST(MSGPACK_BOOST, pack_convert_vector_optional)
     val1[0] = 1;
     val1[2] = 3;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -171,8 +175,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
     std::stringstream ss;
     boost::optional<no_def_con> val1 = no_def_con(1);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<no_def_con> val2 = oh.get().as<boost::optional<no_def_con>>();
     EXPECT_TRUE(val1 == val2);
 }

data/ext/enterprise_script_service/msgpack/test/boost_string_ref.cpp

@@ -26,7 +26,8 @@ TEST(MSGPACK_BOOST, pack_convert_string_ref)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     boost::string_ref val2 = oh.get().as<boost::string_ref>();
     EXPECT_TRUE(val1 == val2);
 }

data/ext/enterprise_script_service/msgpack/test/boost_string_view.cpp

@@ -25,7 +25,8 @@ TEST(MSGPACK_BOOST, pack_convert_string_view)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     boost::string_view val2 = oh.get().as<boost::string_view>();
     EXPECT_TRUE(val1 == val2);
 }

data/ext/enterprise_script_service/msgpack/test/boost_variant.cpp

@@ -27,8 +27,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil)
     EXPECT_TRUE(val1.is_nil());
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
@@ -65,8 +66,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil_default)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
@@ -104,8 +106,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_bool());
     EXPECT_TRUE(val2.as_bool());
@@ -157,8 +160,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_uint64_t());
     EXPECT_EQ(val2.as_uint64_t(), 123U);
@@ -204,8 +208,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_int64_t());
     EXPECT_EQ(val2.as_int64_t(), -123);
@@ -251,8 +256,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_float)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_double());
     EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
@@ -298,8 +304,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_string());
     EXPECT_EQ(val2.as_string(), "ABC");
@@ -360,8 +367,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_vector_char());
     EXPECT_EQ(val2.as_vector_char(), v);
@@ -431,8 +439,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_ext());
     EXPECT_EQ(val2.as_ext(), e);
@@ -498,8 +507,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_vector());
     EXPECT_EQ(val2.as_vector(), v);
@@ -540,8 +550,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_multimap());
     EXPECT_EQ(val2.as_multimap(), v);
@@ -584,8 +595,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_str)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_boost_string_ref());
     EXPECT_EQ(val2.as_boost_string_ref(), sr);
@@ -629,8 +641,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_raw_ref());
     EXPECT_EQ(val2.as_raw_ref(), rr);
@@ -676,8 +689,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2));
     EXPECT_TRUE(val2.is_ext_ref());
@@ -726,8 +740,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_vector());
     EXPECT_EQ(val2.as_vector(), v);
@@ -779,8 +794,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_multimap());
     EXPECT_EQ(val2.as_multimap(), v);