rroonga 4.0.3-x64-mingw32 → 4.0.4-x64-mingw32

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

@@ -0,0 +1,47 @@
+/*
+ * MessagePack for C FILE* buffer adaptor
+ *
+ * Copyright (C) 2013 Vladimir Volodko
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#ifndef MSGPACK_FBUFFER_H__
+#define MSGPACK_FBUFFER_H__
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup msgpack_fbuffer FILE* buffer
+ * @ingroup msgpack_buffer
+ * @{
+ */
+
+static inline int msgpack_fbuffer_write(void* data, const char* buf, unsigned int len)
+{
+	return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
+}
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/fbuffer.h */
+

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

@@ -0,0 +1,56 @@
+//
+// MessagePack for C++ FILE* buffer adaptor
+//
+// Copyright (C) 2013 Vladimir Volodko
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+#ifndef MSGPACK_FBUFFER_HPP__
+#define MSGPACK_FBUFFER_HPP__
+
+#include <cstdio>
+#include <stdexcept>
+
+namespace msgpack {
+
+
+class fbuffer {
+public:
+	explicit fbuffer(FILE* file) : m_file(file) { }
+
+public:
+	void write(const char* buf, unsigned int len)
+	{
+		if (1 != fwrite(buf, len, 1, m_file)) {
+			throw std::runtime_error("fwrite() failed");
+		}
+	}
+
+	FILE* file() const
+	{
+		return m_file;
+	}
+
+private:
+	fbuffer(const fbuffer&);
+	fbuffer& operator= (const fbuffer&);
+
+private:
+	FILE* m_file;
+};
+
+
+}  // namespace msgpack
+
+#endif /* msgpack/fbuffer.hpp */
+

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

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2008-2010 FURUHASHI Sadayuki
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -212,11 +212,20 @@ inline T& operator>> (object o, T& v)
 	return v;
 }
 
+namespace detail {
+template <typename Stream, typename T>
+struct packer_serializer {
+	static packer<Stream>& pack(packer<Stream>& o, const T& v) {
+		v.msgpack_pack(o);
+		return o;
+	}
+};
+}
+
 template <typename Stream, typename T>
 inline packer<Stream>& operator<< (packer<Stream>& o, const T& v)
 {
-	v.msgpack_pack(o);
-	return o;
+	return detail::packer_serializer<Stream, T>::pack(o, v);
 }
 
 template <typename T>

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

@@ -40,7 +40,7 @@ extern "C" {
  * @{
  */
 
-typedef int (*msgpack_packer_write)(void* data, const char* buf, unsigned int len);
+typedef int (*msgpack_packer_write)(void* data, const char* buf, size_t len);
 
 typedef struct msgpack_packer {
 	void* data;
@@ -52,10 +52,14 @@ static void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_w
 static msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback);
 static void msgpack_packer_free(msgpack_packer* pk);
 
+static int msgpack_pack_char(msgpack_packer* pk, char d);
+
+static int msgpack_pack_signed_char(msgpack_packer* pk, signed char d);
 static int msgpack_pack_short(msgpack_packer* pk, short d);
 static int msgpack_pack_int(msgpack_packer* pk, int d);
 static int msgpack_pack_long(msgpack_packer* pk, long d);
 static int msgpack_pack_long_long(msgpack_packer* pk, long long d);
+static int msgpack_pack_unsigned_char(msgpack_packer* pk, unsigned char d);
 static int msgpack_pack_unsigned_short(msgpack_packer* pk, unsigned short d);
 static int msgpack_pack_unsigned_int(msgpack_packer* pk, unsigned int d);
 static int msgpack_pack_unsigned_long(msgpack_packer* pk, unsigned long d);
@@ -86,9 +90,9 @@ static int msgpack_pack_nil(msgpack_packer* pk);
 static int msgpack_pack_true(msgpack_packer* pk);
 static int msgpack_pack_false(msgpack_packer* pk);
 
-static int msgpack_pack_array(msgpack_packer* pk, unsigned int n);
+static int msgpack_pack_array(msgpack_packer* pk, size_t n);
 
-static int msgpack_pack_map(msgpack_packer* pk, unsigned int n);
+static int msgpack_pack_map(msgpack_packer* pk, size_t n);
 
 static int msgpack_pack_raw(msgpack_packer* pk, size_t l);
 static int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l);

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

@@ -54,10 +54,13 @@ public:
 	packer<Stream>& pack_fix_int32(int32_t d);
 	packer<Stream>& pack_fix_int64(int64_t d);
 
+	packer<Stream>& pack_char(char d);
+	packer<Stream>& pack_signed_char(signed char d);
 	packer<Stream>& pack_short(short d);
 	packer<Stream>& pack_int(int d);
 	packer<Stream>& pack_long(long d);
 	packer<Stream>& pack_long_long(long long d);
+	packer<Stream>& pack_unsigned_char(unsigned char d);
 	packer<Stream>& pack_unsigned_short(unsigned short d);
 	packer<Stream>& pack_unsigned_int(unsigned int d);
 	packer<Stream>& pack_unsigned_long(unsigned long d);
@@ -70,9 +73,9 @@ public:
 	packer<Stream>& pack_true();
 	packer<Stream>& pack_false();
 
-	packer<Stream>& pack_array(unsigned int n);
+	packer<Stream>& pack_array(size_t n);
 
-	packer<Stream>& pack_map(unsigned int n);
+	packer<Stream>& pack_map(size_t n);
 
 	packer<Stream>& pack_raw(size_t l);
 	packer<Stream>& pack_raw_body(const char* b, size_t l);
@@ -96,10 +99,14 @@ private:
 	static void _pack_fix_int32(Stream& x, int32_t d);
 	static void _pack_fix_int64(Stream& x, int64_t d);
 
+	static void _pack_char(Stream& x, char d);
+
+	static void _pack_signed_char(Stream& x, signed char d);
 	static void _pack_short(Stream& x, short d);
 	static void _pack_int(Stream& x, int d);
 	static void _pack_long(Stream& x, long d);
 	static void _pack_long_long(Stream& x, long long d);
+	static void _pack_unsigned_char(Stream& x, unsigned char d);
 	static void _pack_unsigned_short(Stream& x, unsigned short d);
 	static void _pack_unsigned_int(Stream& x, unsigned int d);
 	static void _pack_unsigned_long(Stream& x, unsigned long d);
@@ -112,14 +119,14 @@ private:
 	static void _pack_true(Stream& x);
 	static void _pack_false(Stream& x);
 
-	static void _pack_array(Stream& x, unsigned int n);
+	static void _pack_array(Stream& x, size_t n);
 
-	static void _pack_map(Stream& x, unsigned int n);
+	static void _pack_map(Stream& x, size_t n);
 
 	static void _pack_raw(Stream& x, size_t l);
 	static void _pack_raw_body(Stream& x, const void* b, size_t l);
 
-	static void append_buffer(Stream& x, const unsigned char* buf, unsigned int len)
+	static void append_buffer(Stream& x, const unsigned char* buf, size_t len)
 		{ x.write((const char*)buf, len); }
 
 private:
@@ -238,6 +245,14 @@ inline packer<Stream>& packer<Stream>::pack_fix_int64(int64_t d)
 { _pack_fix_int64(m_stream, d); return *this;}
 
 
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_char(char d)
+{ _pack_char(m_stream, d); return *this; }
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_signed_char(signed char d)
+{ _pack_signed_char(m_stream, d); return *this; }
+
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_short(short d)
 { _pack_short(m_stream, d); return *this; }
@@ -254,6 +269,10 @@ template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_long_long(long long d)
 { _pack_long_long(m_stream, d); return *this; }
 
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_unsigned_char(unsigned char d)
+{ _pack_unsigned_char(m_stream, d); return *this; }
+
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_unsigned_short(unsigned short d)
 { _pack_unsigned_short(m_stream, d); return *this; }
@@ -294,12 +313,12 @@ inline packer<Stream>& packer<Stream>::pack_false()
 
 
 template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_array(unsigned int n)
+inline packer<Stream>& packer<Stream>::pack_array(size_t n)
 { _pack_array(m_stream, n); return *this; }
 
 
 template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_map(unsigned int n)
+inline packer<Stream>& packer<Stream>::pack_map(size_t n)
 { _pack_map(m_stream, n); return *this; }
 
 

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

@@ -372,6 +372,28 @@ msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d)
 	msgpack_pack_real_int64(x, d);
 }
 
+msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d)
+{
+#if defined(CHAR_MIN)
+#if CHAR_MIN < 0
+		msgpack_pack_real_int8(x, d);
+#else
+		msgpack_pack_real_uint8(x, d);
+#endif
+#else
+#error CHAR_MIN is not defined
+#endif
+}
+
+msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d)
+{
+	msgpack_pack_real_int8(x, d);
+}
+
+msgpack_pack_inline_func(_unsigned_char)(msgpack_pack_user x, unsigned char d)
+{
+	msgpack_pack_real_uint8(x, d);
+}
 
 #ifdef msgpack_pack_inline_func_cint
 
@@ -634,19 +656,24 @@ if(sizeof(unsigned long long) == 2) {
 
 msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d)
 {
+	unsigned char buf[5];
 	union { float f; uint32_t i; } mem;
 	mem.f = d;
-	unsigned char buf[5];
 	buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i);
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
 msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
 {
+	unsigned char buf[9];
 	union { double f; uint64_t i; } mem;
 	mem.f = d;
-	unsigned char buf[9];
-	buf[0] = 0xcb; _msgpack_store64(&buf[1], mem.i);
+	buf[0] = 0xcb;
+#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
+    // https://github.com/msgpack/msgpack-perl/pull/1
+    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
+#endif
+    _msgpack_store64(&buf[1], mem.i);
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
@@ -683,10 +710,10 @@ msgpack_pack_inline_func(_false)(msgpack_pack_user x)
  * Array
  */
 
-msgpack_pack_inline_func(_array)(msgpack_pack_user x, unsigned int n)
+msgpack_pack_inline_func(_array)(msgpack_pack_user x, size_t n)
 {
 	if(n < 16) {
-		unsigned char d = 0x90 | n;
+		unsigned char d = 0x90 | (uint8_t)n;
 		msgpack_pack_append_buffer(x, &d, 1);
 	} else if(n < 65536) {
 		unsigned char buf[3];
@@ -704,10 +731,10 @@ msgpack_pack_inline_func(_array)(msgpack_pack_user x, unsigned int n)
  * Map
  */
 
-msgpack_pack_inline_func(_map)(msgpack_pack_user x, unsigned int n)
+msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n)
 {
 	if(n < 16) {
-		unsigned char d = 0x80 | n;
+		unsigned char d = 0x80 | (uint8_t)n;
 		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
 	} else if(n < 65536) {
 		unsigned char buf[3];

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

@@ -64,17 +64,18 @@ static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf)
 #define MSGPACK_SBUFFER_INIT_SIZE 8192
 #endif
 
-static inline int msgpack_sbuffer_write(void* data, const char* buf, unsigned int len)
+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; }
 
-		void* tmp = realloc(sbuf->data, nsize);
+		tmp = realloc(sbuf->data, nsize);
 		if(!tmp) { return -1; }
 
 		sbuf->data = (char*)tmp;

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

@@ -47,7 +47,7 @@ public:
 	}
 
 public:
-	void write(const char* buf, unsigned int len)
+	void write(const char* buf, size_t len)
 	{
 		if(base::alloc - base::size < len) {
 			expand_buffer(len);

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

@@ -153,24 +153,24 @@ typedef unsigned int _msgpack_atomic_counter_t;
 #define _msgpack_be64(x) (x)
 
 #define _msgpack_load16(cast, from) ((cast)( \
-        (((uint16_t)((uint8_t*)from)[1]) << 8) | \
-        (((uint16_t)((uint8_t*)from)[0])     ) ))
+        (((uint16_t)((uint8_t*)from)[0]) << 8) | \
+        (((uint16_t)((uint8_t*)from)[1])     ) ))
 
 #define _msgpack_load32(cast, from) ((cast)( \
-        (((uint32_t)((uint8_t*)from)[3]) << 24) | \
-        (((uint32_t)((uint8_t*)from)[2]) << 16) | \
-        (((uint32_t)((uint8_t*)from)[1]) <<  8) | \
-        (((uint32_t)((uint8_t*)from)[0])      ) ))
+        (((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)[7]) << 56) | \
-        (((uint64_t)((uint8_t*)from)[6]) << 48) | \
-        (((uint64_t)((uint8_t*)from)[5]) << 40) | \
-        (((uint64_t)((uint8_t*)from)[4]) << 32) | \
-        (((uint64_t)((uint8_t*)from)[3]) << 24) | \
-        (((uint64_t)((uint8_t*)from)[2]) << 16) | \
-        (((uint64_t)((uint8_t*)from)[1]) << 8)  | \
-        (((uint64_t)((uint8_t*)from)[0])     )  ))
+        (((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
 
 
@@ -191,5 +191,18 @@ 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
+#endif
+
 #endif /* msgpack/sysdep.h */