rroonga 5.0.1-x64-mingw32 → 5.0.2-x64-mingw32

data/vendor/local/include/msgpack/sbuffer.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_SBUFFER_H__
-#define MSGPACK_SBUFFER_H__
+#ifndef MSGPACK_SBUFFER_H
+#define MSGPACK_SBUFFER_H
 
 #include <stdlib.h>
 #include <string.h>
@@ -33,31 +33,31 @@ extern "C" {
  */
 
 typedef struct msgpack_sbuffer {
-	size_t size;
-	char* data;
-	size_t alloc;
+    size_t size;
+    char* data;
+    size_t alloc;
 } msgpack_sbuffer;
 
 static inline void msgpack_sbuffer_init(msgpack_sbuffer* sbuf)
 {
-	memset(sbuf, 0, sizeof(msgpack_sbuffer));
+    memset(sbuf, 0, sizeof(msgpack_sbuffer));
 }
 
 static inline void msgpack_sbuffer_destroy(msgpack_sbuffer* sbuf)
 {
-	free(sbuf->data);
+    free(sbuf->data);
 }
 
 static inline msgpack_sbuffer* msgpack_sbuffer_new(void)
 {
-	return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer));
+    return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer));
 }
 
 static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf)
 {
-	if(sbuf == NULL) { return; }
-	msgpack_sbuffer_destroy(sbuf);
-	free(sbuf);
+    if(sbuf == NULL) { return; }
+    msgpack_sbuffer_destroy(sbuf);
+    free(sbuf);
 }
 
 #ifndef MSGPACK_SBUFFER_INIT_SIZE
@@ -66,39 +66,46 @@ static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf)
 
 static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len)
 {
-	msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data;
-
-	if(sbuf->alloc - sbuf->size < len) {
-		void* tmp;
-		size_t nsize = (sbuf->alloc) ?
-				sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
-
-		while(nsize < sbuf->size + len) { nsize *= 2; }
-
-		tmp = realloc(sbuf->data, nsize);
-		if(!tmp) { return -1; }
-
-		sbuf->data = (char*)tmp;
-		sbuf->alloc = nsize;
-	}
-
-	memcpy(sbuf->data + sbuf->size, buf, len);
-	sbuf->size += len;
-	return 0;
+    msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data;
+
+    if(sbuf->alloc - sbuf->size < len) {
+        void* tmp;
+        size_t nsize = (sbuf->alloc) ?
+                sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
+
+        while(nsize < sbuf->size + len) {
+            size_t tmp_nsize = nsize * 2;
+            if (tmp_nsize <= nsize) {
+                nsize = sbuf->size + len;
+                break;
+            }
+            nsize = tmp_nsize;
+        }
+
+        tmp = realloc(sbuf->data, nsize);
+        if(!tmp) { return -1; }
+
+        sbuf->data = (char*)tmp;
+        sbuf->alloc = nsize;
+    }
+
+    memcpy(sbuf->data + sbuf->size, buf, len);
+    sbuf->size += len;
+    return 0;
 }
 
 static inline char* msgpack_sbuffer_release(msgpack_sbuffer* sbuf)
 {
-	char* tmp = sbuf->data;
-	sbuf->size = 0;
-	sbuf->data = NULL;
-	sbuf->alloc = 0;
-	return tmp;
+    char* tmp = sbuf->data;
+    sbuf->size = 0;
+    sbuf->data = NULL;
+    sbuf->alloc = 0;
+    return tmp;
 }
 
 static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf)
 {
-	sbuf->size = 0;
+    sbuf->size = 0;
 }
 
 /** @} */
@@ -109,4 +116,3 @@ static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf)
 #endif
 
 #endif /* msgpack/sbuffer.h */
-

data/vendor/local/include/msgpack/sbuffer.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ simple buffer implementation
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -15,98 +15,120 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 //
-#ifndef MSGPACK_SBUFFER_HPP__
-#define MSGPACK_SBUFFER_HPP__
+#ifndef MSGPACK_SBUFFER_HPP
+#define MSGPACK_SBUFFER_HPP
+
+#include "msgpack/versioning.hpp"
 
-#include "sbuffer.h"
 #include <stdexcept>
 
+#ifndef MSGPACK_SBUFFER_INIT_SIZE
+#define MSGPACK_SBUFFER_INIT_SIZE 8192
+#endif
+
 namespace msgpack {
 
+MSGPACK_API_VERSION_NAMESPACE(v1) {
 
-class sbuffer : public msgpack_sbuffer {
+class sbuffer {
 public:
-	sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE)
-	{
-		if(initsz == 0) {
-			base::data = NULL;
-		} else {
-			base::data = (char*)::malloc(initsz);
-			if(!base::data) {
-				throw std::bad_alloc();
-			}
-		}
-
-		base::size = 0;
-		base::alloc = initsz;
-	}
-
-	~sbuffer()
-	{
-		::free(base::data);
-	}
+    sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):m_size(0), m_alloc(initsz)
+    {
+        if(initsz == 0) {
+            m_data = nullptr;
+        } else {
+            m_data = (char*)::malloc(initsz);
+            if(!m_data) {
+                throw std::bad_alloc();
+            }
+        }
+    }
+
+    ~sbuffer()
+    {
+        ::free(m_data);
+    }
 
 public:
-	void write(const char* buf, size_t len)
-	{
-		if(base::alloc - base::size < len) {
-			expand_buffer(len);
-		}
-		memcpy(base::data + base::size, buf, len);
-		base::size += len;
-	}
-
-	char* data()
-	{
-		return base::data;
-	}
-
-	const char* data() const
-	{
-		return base::data;
-	}
-
-	size_t size() const
-	{
-		return base::size;
-	}
-
-	char* release()
-	{
-		return msgpack_sbuffer_release(this);
-	}
-
-	void clear()
-	{
-		msgpack_sbuffer_clear(this);
-	}
+    void write(const char* buf, size_t len)
+    {
+        if(m_alloc - m_size < len) {
+            expand_buffer(len);
+        }
+        std::memcpy(m_data + m_size, buf, len);
+        m_size += len;
+    }
+
+    char* data()
+    {
+        return m_data;
+    }
+
+    const char* data() const
+    {
+        return m_data;
+    }
+
+    size_t size() const
+    {
+        return m_size;
+    }
+
+    char* release()
+    {
+        char* tmp = m_data;
+        m_size = 0;
+        m_data = nullptr;
+        m_alloc = 0;
+        return tmp;
+    }
+
+    void clear()
+    {
+        m_size = 0;
+    }
 
 private:
-	void expand_buffer(size_t len)
-	{
-		size_t nsize = (base::alloc > 0) ?
-				base::alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
-	
-		while(nsize < base::size + len) { nsize *= 2; }
-	
-		void* tmp = realloc(base::data, nsize);
-		if(!tmp) {
-			throw std::bad_alloc();
-		}
-	
-		base::data = (char*)tmp;
-		base::alloc = nsize;
-	}
-
+    void expand_buffer(size_t len)
+    {
+        size_t nsize = (m_alloc > 0) ?
+                m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
+
+        while(nsize < m_size + len) {
+            size_t tmp_nsize = nsize * 2;
+            if (tmp_nsize <= nsize) {
+                nsize = m_size + len;
+                break;
+            }
+            nsize = tmp_nsize;
+        }
+
+        void* tmp = ::realloc(m_data, nsize);
+        if(!tmp) {
+            throw std::bad_alloc();
+        }
+
+        m_data = static_cast<char*>(tmp);
+        m_alloc = nsize;
+    }
+
+#if defined(MSGPACK_USE_CPP03)
 private:
-	typedef msgpack_sbuffer base;
+    sbuffer(const sbuffer&);
+    sbuffer& operator=(const sbuffer&);
+#else  // defined(MSGPACK_USE_CPP03)
+    sbuffer(const sbuffer&) = delete;
+    sbuffer& operator=(const sbuffer&) = delete;
+#endif // defined(MSGPACK_USE_CPP03)
 
 private:
-	sbuffer(const sbuffer&);
+    size_t m_size;
+    char* m_data;
+    size_t m_alloc;
 };
 
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
 
 }  // namespace msgpack
 
 #endif /* msgpack/sbuffer.hpp */
-

data/vendor/local/include/msgpack/sysdep.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_SYSDEP_H__
-#define MSGPACK_SYSDEP_H__
+#ifndef MSGPACK_SYSDEP_H
+#define MSGPACK_SYSDEP_H
 
 #include <stdlib.h>
 #include <stddef.h>
@@ -36,13 +36,25 @@ typedef unsigned __int64 uint64_t;
 #include <stdbool.h>
 #endif
 
+#if defined(_MSC_VER)
+#define MSGPACK_DLLEXPORT __declspec(dllexport)
+#else  /* _MSC_VER */
+#define MSGPACK_DLLEXPORT
+#endif /* _MSC_VER */
+
 #ifdef _WIN32
 #define _msgpack_atomic_counter_header <windows.h>
 typedef long _msgpack_atomic_counter_t;
 #define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
 #define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
 #elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
+
+#if defined(__cplusplus)
+#define _msgpack_atomic_counter_header "gcc_atomic.hpp"
+#else
 #define _msgpack_atomic_counter_header "gcc_atomic.h"
+#endif
+
 #else
 typedef unsigned int _msgpack_atomic_counter_t;
 #define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1)
@@ -62,7 +74,13 @@ typedef unsigned int _msgpack_atomic_counter_t;
 #endif
 
 #else
+
 #include <arpa/inet.h>  /* __BYTE_ORDER */
+#  if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__OpenBSD__) && \
+       !(defined(__sun) && defined(__SVR4))
+#    include <byteswap.h>
+#  endif
+
 #endif
 
 #if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
@@ -126,53 +144,27 @@ typedef unsigned int _msgpack_atomic_counter_t;
       ((((uint64_t)x) >> 56)                         ) )
 #endif
 
-#define _msgpack_load16(cast, from) ((cast)( \
-        (((uint16_t)((uint8_t*)(from))[0]) << 8) | \
-        (((uint16_t)((uint8_t*)(from))[1])     ) ))
-
-#define _msgpack_load32(cast, from) ((cast)( \
-        (((uint32_t)((uint8_t*)(from))[0]) << 24) | \
-        (((uint32_t)((uint8_t*)(from))[1]) << 16) | \
-        (((uint32_t)((uint8_t*)(from))[2]) <<  8) | \
-        (((uint32_t)((uint8_t*)(from))[3])      ) ))
-
-#define _msgpack_load64(cast, from) ((cast)( \
-        (((uint64_t)((uint8_t*)(from))[0]) << 56) | \
-        (((uint64_t)((uint8_t*)(from))[1]) << 48) | \
-        (((uint64_t)((uint8_t*)(from))[2]) << 40) | \
-        (((uint64_t)((uint8_t*)(from))[3]) << 32) | \
-        (((uint64_t)((uint8_t*)(from))[4]) << 24) | \
-        (((uint64_t)((uint8_t*)(from))[5]) << 16) | \
-        (((uint64_t)((uint8_t*)(from))[6]) << 8)  | \
-        (((uint64_t)((uint8_t*)(from))[7])     )  ))
-
-#else
+#else  /* __LITTLE_ENDIAN__ */
 
 #define _msgpack_be16(x) (x)
 #define _msgpack_be32(x) (x)
 #define _msgpack_be64(x) (x)
 
-#define _msgpack_load16(cast, from) ((cast)( \
-        (((uint16_t)((uint8_t*)from)[0]) << 8) | \
-        (((uint16_t)((uint8_t*)from)[1])     ) ))
-
-#define _msgpack_load32(cast, from) ((cast)( \
-        (((uint32_t)((uint8_t*)from)[0]) << 24) | \
-        (((uint32_t)((uint8_t*)from)[1]) << 16) | \
-        (((uint32_t)((uint8_t*)from)[2]) <<  8) | \
-        (((uint32_t)((uint8_t*)from)[3])      ) ))
-
-#define _msgpack_load64(cast, from) ((cast)( \
-        (((uint64_t)((uint8_t*)from)[0]) << 56) | \
-        (((uint64_t)((uint8_t*)from)[1]) << 48) | \
-        (((uint64_t)((uint8_t*)from)[2]) << 40) | \
-        (((uint64_t)((uint8_t*)from)[3]) << 32) | \
-        (((uint64_t)((uint8_t*)from)[4]) << 24) | \
-        (((uint64_t)((uint8_t*)from)[5]) << 16) | \
-        (((uint64_t)((uint8_t*)from)[6]) << 8)  | \
-        (((uint64_t)((uint8_t*)from)[7])     )  ))
 #endif
 
+#define _msgpack_load16(cast, from, to) do {       \
+        memcpy((cast*)(to), (from), sizeof(cast)); \
+        *(to) = _msgpack_be16(*(to));              \
+    } while (0);
+
+#define _msgpack_load32(cast, from, to) do {       \
+        memcpy((cast*)(to), (from), sizeof(cast)); \
+        *(to) = _msgpack_be32(*(to));              \
+    } while (0);
+#define _msgpack_load64(cast, from, to) do {       \
+        memcpy((cast*)(to), (from), sizeof(cast)); \
+        *(to) = _msgpack_be64(*(to));              \
+    } while (0);
 
 #define _msgpack_store16(to, num) \
     do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
@@ -192,17 +184,20 @@ typedef unsigned int _msgpack_atomic_counter_t;
 
 
 #if !defined(__cplusplus) && defined(_MSC_VER)
-#if !defined(FALSE)
-#define FALSE (0)
-#endif
-#if !defined(TRUE)
-#define TRUE (!FALSE)
-#endif
-#define bool int
-#define true TRUE
-#define false FALSE
-#define inline __inline
+#  if !defined(FALSE)
+#    define FALSE (0)
+#  endif
+#  if !defined(TRUE)
+#    define TRUE (!FALSE)
+#  endif
+#  if _MSC_VER >= 1800
+#    include <stdbool.h>
+#  else
+#    define bool int
+#    define true TRUE
+#    define false FALSE
+#  endif
+#  define inline __inline
 #endif
 
 #endif /* msgpack/sysdep.h */
-