script_core 0.1.1 → 0.2.0

data/ext/enterprise_script_service/msgpack/include/msgpack/v1/detail/cpp03_zone.hpp

@@ -55,7 +55,7 @@ class zone {
             ++m_tail;
         }
         void push_expand(void (*func)(void*), void* data) {
-            const size_t nused = m_end - m_array;
+            const size_t nused = static_cast<size_t>(m_end - m_array);
             size_t nnext;
             if(nused == 0) {
                 nnext = (sizeof(finalizer) < 72/2) ?
@@ -246,12 +246,12 @@ inline char* zone::get_aligned(char* ptr, size_t align)
 inline void* zone::allocate_align(size_t size, size_t align)
 {
     char* aligned = get_aligned(m_chunk_list.m_ptr, align);
-    size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+    size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     if (m_chunk_list.m_free < adjusted_size) {
         size_t enough_size = size + align - 1;
         char* ptr = allocate_expand(enough_size);
         aligned = get_aligned(ptr, align);
-        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+        adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     }
     m_chunk_list.m_free -= adjusted_size;
     m_chunk_list.m_ptr  += adjusted_size;

data/ext/enterprise_script_service/msgpack/include/msgpack/v1/detail/cpp11_zone.hpp

@@ -61,7 +61,7 @@ private:
             ++m_tail;
         }
         void push_expand(void (*func)(void*), void* data) {
-            const size_t nused = m_end - m_array;
+            const size_t nused = static_cast<size_t>(m_end - m_array);
             size_t nnext;
             if(nused == 0) {
                 nnext = (sizeof(finalizer) < 72/2) ?
@@ -239,12 +239,12 @@ inline char* zone::get_aligned(char* ptr, size_t align)
 inline void* zone::allocate_align(size_t size, size_t align)
 {
     char* aligned = get_aligned(m_chunk_list.m_ptr, align);
-    size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+    size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     if (m_chunk_list.m_free < adjusted_size) {
         size_t enough_size = size + align - 1;
         char* ptr = allocate_expand(enough_size);
         aligned = get_aligned(ptr, align);
-        adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+        adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
     }
     m_chunk_list.m_free -= adjusted_size;
     m_chunk_list.m_ptr  += adjusted_size;

data/ext/enterprise_script_service/msgpack/include/msgpack/v1/object.hpp

@@ -352,8 +352,8 @@ struct object_pack_visitor {
         return true;
     }
     bool visit_ext(const char* v, uint32_t size) {
-        m_packer.pack_ext(size, *v);
-        m_packer.pack_ext_body(v, size);
+        m_packer.pack_ext(size - 1, static_cast<int8_t>(*v));
+        m_packer.pack_ext_body(v + 1, size - 1);
         return true;
     }
     bool start_array(uint32_t num_elements) {
@@ -467,7 +467,7 @@ struct object_stringize_visitor {
         return true;
     }
     bool visit_bin(const char* v, uint32_t size) {
-        (m_os << '"').write(v, size) << '"';
+        (m_os << '"').write(v, static_cast<std::streamsize>(size)) << '"';
         return true;
     }
     bool visit_ext(const char* /*v*/, uint32_t /*size*/) {
@@ -527,7 +527,7 @@ private:
 };
 
 struct aligned_zone_size_visitor {
-    explicit aligned_zone_size_visitor(std::size_t s)
+    explicit aligned_zone_size_visitor(std::size_t& s)
         :m_size(s) {}
     bool visit_nil() {
         return true;
@@ -596,7 +596,7 @@ struct aligned_zone_size_visitor {
         return true;
     }
 private:
-    std::size_t m_size;
+    std::size_t& m_size;
 };
 
 inline std::size_t aligned_zone_size(msgpack::object const& obj) {
@@ -938,7 +938,7 @@ struct object_equal_visitor {
     }
     bool visit_ext(const char* v, uint32_t size) {
         if (m_ptr->type != msgpack::type::EXT ||
-            m_ptr->via.ext.size != size ||
+            m_ptr->via.ext.size != size - 1 ||
             std::memcmp(m_ptr->via.ext.ptr, v, size) != 0) {
             m_result = false;
             return false;

data/ext/enterprise_script_service/msgpack/include/msgpack/v1/object_fwd.hpp

@@ -40,7 +40,7 @@ struct object_bin {
 };
 
 struct object_ext {
-    int8_t type() const { return ptr[0]; }
+    int8_t type() const { return static_cast<int8_t>(ptr[0]); }
     const char* data() const { return &ptr[1]; }
     uint32_t size;
     const char* ptr;

data/ext/enterprise_script_service/msgpack/include/msgpack/v1/pack.hpp

@@ -16,6 +16,7 @@
 #include <limits>
 #include <cstring>
 #include <climits>
+#include <ostream>
 
 namespace msgpack {
 
@@ -271,6 +272,20 @@ public:
      */
     packer<Stream>& pack_char(char d);
 
+    /// Packing wchar_t
+    /**
+     * The byte size of the packed data depends on `d`.
+     * If `d` is zero or positive, the packed type is positive fixnum, or uint*,
+     * else the packed type is negative fixnum, or int*
+     * The minimum byte size expression is used.
+     * See https://github.com/msgpack/msgpack/blob/master/spec.md#formats-int
+     *
+     * @param d a packing object.
+     *
+     * @return The reference of `*this`.
+     */
+    packer<Stream>& pack_wchar(wchar_t d);
+
     /// Packing signed char
     /**
      * The byte size of the packed data depends on `d`.
@@ -604,7 +619,15 @@ private:
     void pack_imp_int64(T d);
 
     void append_buffer(const char* buf, size_t len)
-        { m_stream.write(buf, len); }
+    {
+        append_buffer(&Stream::write, buf, len);
+    }
+
+    template <typename Ret, typename Cls, typename SizeType>
+    void append_buffer(Ret (Cls::*)(const char*, SizeType), const char* buf, size_t len)
+    {
+        m_stream.write(buf, static_cast<SizeType>(len));
+    }
 
 private:
     Stream& m_stream;
@@ -781,7 +804,7 @@ template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_int16(int16_t d)
 {
     char buf[3];
-    buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], d);
+    buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], (uint16_t)d);
     append_buffer(buf, 3);
     return *this;
 }
@@ -790,7 +813,7 @@ template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_int32(int32_t d)
 {
     char buf[5];
-    buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], d);
+    buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], (uint32_t)d);
     append_buffer(buf, 5);
     return *this;
 }
@@ -820,6 +843,18 @@ inline packer<Stream>& packer<Stream>::pack_char(char d)
     return *this;
 }
 
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_wchar(wchar_t d)
+{
+    if (d < 0) {
+        pack_imp_int64(static_cast<int64_t>(d));
+    }
+    else {
+        pack_imp_uint64(static_cast<uint64_t>(d));
+    }
+    return *this;
+}
+
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_signed_char(signed char d)
 {
@@ -1202,7 +1237,7 @@ inline packer<Stream>& packer<Stream>::pack_str(uint32_t l)
         append_buffer(&buf, 1);
     } else if(l < 256) {
         char buf[2];
-        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<uint8_t>(l);
+        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<char>(l);
         append_buffer(buf, 2);
     } else if(l < 65536) {
         char buf[3];
@@ -1256,7 +1291,7 @@ inline packer<Stream>& packer<Stream>::pack_bin(uint32_t l)
 {
     if(l < 256) {
         char buf[2];
-        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<uint8_t>(l);
+        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<char>(l);
         append_buffer(buf, 2);
     } else if(l < 65536) {
         char buf[3];

data/ext/enterprise_script_service/msgpack/include/msgpack/v1/unpack.hpp

@@ -78,19 +78,19 @@ inline void unpack_uint64(uint64_t d, msgpack::object& o)
 { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
 
 inline void unpack_int8(int8_t d, msgpack::object& o)
-{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
+{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = static_cast<uint64_t>(d); }
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_int16(int16_t d, msgpack::object& o)
-{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
+{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = static_cast<uint64_t>(d); }
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_int32(int32_t d, msgpack::object& o)
-{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
+{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = static_cast<uint64_t>(d); }
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_int64(int64_t d, msgpack::object& o)
-{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
+{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = static_cast<uint64_t>(d); }
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_float(float d, msgpack::object& o)
@@ -418,10 +418,10 @@ private:
             m_stack[0].set_obj(obj);
             ++m_current;
             /*printf("-- finish --\n"); */
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
         }
         else if (ret < 0) {
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
         }
         else {
             m_cs = MSGPACK_CS_HEADER;
@@ -461,7 +461,7 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
     msgpack::object obj;
 
     if(m_current == pe) {
-        off = m_current - m_start;
+        off = static_cast<std::size_t>(m_current - m_start);
         return 0;
     }
     bool fixed_trail_again = false;
@@ -544,7 +544,7 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
                 int ret = push_proc(obj, off);
                 if (ret != 0) return ret;
             } else {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return -1;
             }
             // end MSGPACK_CS_HEADER
@@ -555,7 +555,7 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
                 fixed_trail_again = false;
             }
             if(static_cast<std::size_t>(pe - m_current) < m_trail) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return 0;
             }
             n = m_current;
@@ -830,13 +830,13 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
                 if (ret != 0) return ret;
             } break;
             default:
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return -1;
             }
         }
     } while(m_current != pe);
 
-    off = m_current - m_start;
+    off = static_cast<std::size_t>(m_current - m_start);
     return 0;
 }
 

data/ext/enterprise_script_service/msgpack/include/msgpack/v1/vrefbuffer.hpp

@@ -117,7 +117,7 @@ public:
     void append_ref(const char* buf, size_t len)
     {
         if(m_tail == m_end) {
-            const size_t nused = m_tail - m_array;
+            const size_t nused = static_cast<size_t>(m_tail - m_array);
             const size_t nnext = nused * 2;
 
             iovec* nvec = static_cast<iovec*>(::realloc(
@@ -145,11 +145,11 @@ public:
             if(sz < len) {
                 sz = len;
             }
-             
+
             if(sizeof(chunk) + sz < sz){
                 throw std::bad_alloc();
             }
-            
+
             chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
             if(!c) {
                 throw std::bad_alloc();
@@ -184,7 +184,7 @@ public:
 
     size_t vector_size() const
     {
-        return m_tail - m_array;
+        return static_cast<size_t>(m_tail - m_array);
     }
 
     void migrate(vrefbuffer* to)
@@ -202,11 +202,11 @@ public:
 
         empty->next = MSGPACK_NULLPTR;
 
-        const size_t nused = m_tail - m_array;
+        const size_t nused = static_cast<size_t>(m_tail - m_array);
         if(to->m_tail + nused < m_end) {
-            const size_t tosize = to->m_tail - to->m_array;
+            const size_t tosize = static_cast<size_t>(to->m_tail - to->m_array);
             const size_t reqsize = nused + tosize;
-            size_t nnext = (to->m_end - to->m_array) * 2;
+            size_t nnext = static_cast<size_t>(to->m_end - to->m_array) * 2;
             while(nnext < reqsize) {
                 size_t tmp_nnext = nnext * 2;
                 if (tmp_nnext <= nnext) {

data/ext/enterprise_script_service/msgpack/include/msgpack/v1/zbuffer.hpp

@@ -47,7 +47,7 @@ public:
     void write(const char* buf, size_t len)
     {
         m_stream.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(buf));
-        m_stream.avail_in = len;
+        m_stream.avail_in = static_cast<uInt>(len);
 
         while(m_stream.avail_in > 0) {
             if(m_stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
@@ -91,7 +91,7 @@ public:
 
     size_t size() const
     {
-        return reinterpret_cast<char*>(m_stream.next_out) - m_data;
+        return static_cast<size_t>(reinterpret_cast<char*>(m_stream.next_out) - m_data);
     }
 
     void reset()
@@ -104,7 +104,7 @@ public:
 
     void reset_buffer()
     {
-        m_stream.avail_out += reinterpret_cast<char*>(m_stream.next_out) - m_data;
+        m_stream.avail_out += static_cast<uInt>(reinterpret_cast<char*>(m_stream.next_out) - m_data);
         m_stream.next_out = reinterpret_cast<Bytef*>(m_data);
     }
 
@@ -120,7 +120,7 @@ public:
 private:
     bool expand()
     {
-        size_t used = reinterpret_cast<char*>(m_stream.next_out) - m_data;
+        size_t used = static_cast<size_t>(reinterpret_cast<char*>(m_stream.next_out) - m_data);
         size_t csize = used + m_stream.avail_out;
         size_t nsize = (csize == 0) ? m_init_size : csize * 2;
 
@@ -131,7 +131,7 @@ private:
 
         m_data = tmp;
         m_stream.next_out  = reinterpret_cast<Bytef*>(tmp + used);
-        m_stream.avail_out = nsize - used;
+        m_stream.avail_out = static_cast<uInt>(nsize - used);
 
         return true;
     }

data/ext/enterprise_script_service/msgpack/include/msgpack/v2/adaptor/int_decl.hpp

@@ -30,7 +30,7 @@ struct is_signed;
 
 
 template <bool Signed>
-struct object_char_sign;
+struct object_sign;
 
 //using v1::type::detail::convert_integer_sign;
 

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

@@ -85,7 +85,7 @@ public:
         msgpack::object* obj = m_stack.back();
         if(v >= 0) {
             obj->type = msgpack::type::POSITIVE_INTEGER;
-            obj->via.u64 = v;
+            obj->via.u64 = static_cast<uint64_t>(v);
         }
         else {
             obj->type = msgpack::type::NEGATIVE_INTEGER;

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

@@ -71,27 +71,27 @@ private:
         ++m_current;
         if (size == 0) {
             if (!sv(size)) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_STOP_VISITOR;
             }
             if (!ev()) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_STOP_VISITOR;
             }
             parse_return ret = m_stack.consume(holder());
             if (ret != PARSE_CONTINUE) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return ret;
             }
         }
         else {
             if (!sv(size)) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_STOP_VISITOR;
             }
             parse_return ret = m_stack.push(holder(), sv.type(), static_cast<uint32_t>(size));
             if (ret != PARSE_CONTINUE) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return ret;
             }
         }
@@ -102,12 +102,12 @@ private:
     parse_return after_visit_proc(bool visit_result, std::size_t& off) {
         ++m_current;
         if (!visit_result) {
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
             return PARSE_STOP_VISITOR;
         }
         parse_return ret = m_stack.consume(holder());
         if (ret != PARSE_CONTINUE) {
-            off = m_current - m_start;
+            off = static_cast<std::size_t>(m_current - m_start);
         }
         m_cs = MSGPACK_CS_HEADER;
         return ret;
@@ -244,7 +244,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
     msgpack::object obj;
 
     if(m_current == pe) {
-        off = m_current - m_start;
+        off = static_cast<std::size_t>(m_current - m_start);
         return PARSE_CONTINUE;
     }
     bool fixed_trail_again = false;
@@ -326,7 +326,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 parse_return upr = after_visit_proc(visret, off);
                 if (upr != PARSE_CONTINUE) return upr;
             } else {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 holder().visitor().parse_error(off - 1, off);
                 return PARSE_PARSE_ERROR;
             }
@@ -338,7 +338,7 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 fixed_trail_again = false;
             }
             if(static_cast<std::size_t>(pe - m_current) < m_trail) {
-                off = m_current - m_start;
+                off = static_cast<std::size_t>(m_current - m_start);
                 return PARSE_CONTINUE;
             }
             n = m_current;
@@ -608,14 +608,14 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
                 if (ret != PARSE_CONTINUE) return ret;
             } break;
             default:
-                off = m_current - m_start;
-                holder().visitor().parse_error(n - m_start - 1, n - m_start);
+                off = static_cast<std::size_t>(m_current - m_start);
+                holder().visitor().parse_error(static_cast<std::size_t>(n - m_start - 1), static_cast<std::size_t>(n - m_start));
                 return PARSE_PARSE_ERROR;
             }
         }
     } while(m_current != pe);
 
-    off = m_current - m_start;
+    off = static_cast<std::size_t>(m_current - m_start);
     return PARSE_CONTINUE;
 }