msgpack template: architecture specific endian conversion

c/object.c

@@ -18,7 +18,17 @@
 #include "msgpack/object.h"
 #include "msgpack/pack.h"
 #include <stdio.h>
+
+#ifndef _MSC_VER
 #include <inttypes.h>
+#else
+#ifndef PRIu64
+#define PRIu64 "I64u"
+#endif
+#ifndef PRIi64
+#define PRIi64 "I64d"
+#endif
+#endif
 
 
 int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)

c/object.h

@@ -19,9 +19,7 @@
 #define MSGPACK_OBJECT_H__
 
 #include "msgpack/zone.h"
-#include <stdint.h>
+#include "msgpack/sys.h"
-#include <stddef.h>
-#include <stdbool.h>
 #include <stdio.h>
 
 #ifdef __cplusplus

c/pack.h

@@ -18,11 +18,9 @@
 #ifndef MSGPACK_PACK_H__
 #define MSGPACK_PACK_H__
 
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
 #include "msgpack/pack_define.h"
 #include "msgpack/object.h"
+#include <stdlib.h>
 
 #ifdef __cplusplus
 extern "C" {

c/unpack.c

@@ -101,7 +101,7 @@ static inline int template_callback_array(unpack_user* u, unsigned int n, msgpac
 {
 	o->type = MSGPACK_OBJECT_ARRAY;
 	o->via.array.size = 0;
-	o->via.array.ptr = msgpack_zone_malloc(u->z, n*sizeof(msgpack_object));
+	o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object));
 	if(o->via.array.ptr == NULL) { return -1; }
 	return 0;
 }
@@ -142,30 +142,47 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha
 #define CTX_REFERENCED(mpac) CTX_CAST((mpac)->ctx)->user.referenced
 
 
-static const size_t COUNTER_SIZE = sizeof(unsigned int);
+#ifndef _MSC_VER
+typedef unsigned int counter_t;
+#else
+typedef long counter_t;
+#endif
+
+#define COUNTER_SIZE (sizeof(volatile counter_t))
+
 
 static inline void init_count(void* buffer)
 {
-	*(volatile unsigned int*)buffer = 1;
+	*(volatile counter_t*)buffer = 1;
 }
 
 static inline void decl_count(void* buffer)
 {
-	//if(--*(unsigned int*)buffer == 0) {
+	// atomic if(--*(counter_t*)buffer == 0) { free(buffer); }
-	if(__sync_sub_and_fetch((unsigned int*)buffer, 1) == 0) {
+	if(
+#ifndef _MSC_VER
+		__sync_sub_and_fetch((counter_t*)buffer, 1) == 0
+#else
+		InterlockedDecrement((volatile counter_t*)&buffer) == 0
+#endif
+			) {
 		free(buffer);
 	}
 }
 
 static inline void incr_count(void* buffer)
 {
-	//++*(unsigned int*)buffer;
+	// atomic ++*(counter_t*)buffer;
-	__sync_add_and_fetch((unsigned int*)buffer, 1);
+#ifndef _MSC_VER
+	__sync_add_and_fetch((counter_t*)buffer, 1);
+#else
+	InterlockedIncrement((volatile counter_t*)&buffer);
+#endif
 }
 
-static inline unsigned int get_count(void* buffer)
+static inline counter_t get_count(void* buffer)
 {
-	return *(volatile unsigned int*)buffer;
+	return *(volatile counter_t*)buffer;
 }
 
 

c/unpack.h

@@ -15,13 +15,11 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef msgpack_unpacker_H__
+#ifndef MSGPACK_UNPACKER_H__
-#define msgpack_unpacker_H__
+#define MSGPACK_UNPACKER_H__
 
 #include "msgpack/zone.h"
 #include "msgpack/object.h"
-#include <stdint.h>
-#include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {

c/vrefbuffer.h

@@ -19,7 +19,16 @@
 #define MSGPACK_VREFBUFFER_H__
 
 #include "msgpack/zone.h"
+
+#ifndef _WIN32
 #include <sys/uio.h>
+#else
+struct iovec {
+	void  *iov_base;
+	size_t iov_len;
+};
+#endif
+
 
 #ifdef __cplusplus
 extern "C" {

cpp/object.hpp

@@ -20,7 +20,6 @@
 
 #include "msgpack/object.h"
 #include "msgpack/pack.hpp"
-#include <stdint.h>
 #include <string.h>
 #include <stdexcept>
 #include <typeinfo>

cpp/pack.hpp

@@ -18,10 +18,9 @@
 #ifndef MSGPACK_PACK_HPP__
 #define MSGPACK_PACK_HPP__
 
-#include <arpa/inet.h>  // __BYTE_ORDER
+#include "msgpack/pack_define.h"
 #include <stdexcept>
 #include <limits.h>
-#include "msgpack/pack_define.h"
 
 namespace msgpack {
 

msgpack/pack_define.h

@@ -18,8 +18,7 @@
 #ifndef MSGPACK_PACK_DEFINE_H__
 #define MSGPACK_PACK_DEFINE_H__
 
-#include <stddef.h>
+#include "msgpack/sys.h"
-#include <stdint.h>
 #include <limits.h>
 
 #endif /* msgpack/pack_define.h */

msgpack/pack_template.h

@@ -16,88 +16,16 @@
  *    limitations under the License.
  */
 
-#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __LITTLE_ENDIAN__
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define __BIG_ENDIAN__
-#endif
-#endif
-
-
 #ifdef __LITTLE_ENDIAN__
-
+#define TAKE8_8(d)  ((uint8_t*)&d)[0]
-#define STORE8_BE8(d) \
+#define TAKE8_16(d) ((uint8_t*)&d)[0]
-	((uint8_t*)&d)[0]
+#define TAKE8_32(d) ((uint8_t*)&d)[0]
-
+#define TAKE8_64(d) ((uint8_t*)&d)[0]
-
-#define STORE16_BE8(d) \
-	((uint8_t*)&d)[0]
-
-#define STORE16_BE16(d) \
-	((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-
-#define STORE32_BE8(d) \
-	((uint8_t*)&d)[0]
-
-#define STORE32_BE16(d) \
-	((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-#define STORE32_BE32(d) \
-	((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-
-#define STORE64_BE8(d) \
-	((uint8_t*)&d)[0]
-
-#define STORE64_BE16(d) \
-	((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-#define STORE64_BE32(d) \
-	((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-#define STORE64_BE64(d) \
-	((uint8_t*)&d)[7], ((uint8_t*)&d)[6], ((uint8_t*)&d)[5], ((uint8_t*)&d)[4], \
-	((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-
 #elif __BIG_ENDIAN__
-
+#define TAKE8_8(d)  ((uint8_t*)&d)[0]
-#define STORE8_BE8(d) \
+#define TAKE8_16(d) ((uint8_t*)&d)[1]
-	((uint8_t*)&d)[0]
+#define TAKE8_32(d) ((uint8_t*)&d)[3]
-
+#define TAKE8_64(d) ((uint8_t*)&d)[7]
-
-#define STORE16_BE8(d) \
-	((uint8_t*)&d)[1]
-
-#define STORE16_BE16(d) \
-	((uint8_t*)&d)[0], ((uint8_t*)&d)[1]
-
-
-#define STORE32_BE8(d) \
-	((uint8_t*)&d)[3]
-
-#define STORE32_BE16(d) \
-	((uint8_t*)&d)[2], ((uint8_t*)&d)[3]
-
-#define STORE32_BE32(d) \
-	((uint8_t*)&d)[0], ((uint8_t*)&d)[1], ((uint8_t*)&d)[2], ((uint8_t*)&d)[3]
-
-
-#define STORE64_BE8(d) \
-	((uint8_t*)&d)[7]
-
-#define STORE64_BE16(d) \
-	((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
-
-#define STORE64_BE32(d) \
-	((uint8_t*)&d)[4], ((uint8_t*)&d)[5], ((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
-
-#define STORE64_BE64(d) \
-	((uint8_t*)&d)[0], ((uint8_t*)&d)[1], ((uint8_t*)&d)[2], ((uint8_t*)&d)[3], \
-	((uint8_t*)&d)[4], ((uint8_t*)&d)[5], ((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
-
 #endif
 
 #ifndef msgpack_pack_inline_func
@@ -121,10 +49,10 @@
 do { \
 	if(d < (1<<7)) { \
 		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1); \
+		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
 	} else { \
 		/* unsigned 8 */ \
-		const unsigned char buf[2] = {0xcc, STORE8_BE8(d)}; \
+		unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \
 		msgpack_pack_append_buffer(x, buf, 2); \
 	} \
 } while(0)
@@ -133,14 +61,15 @@ do { \
 do { \
 	if(d < (1<<7)) { \
 		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE16_BE8(d), 1); \
+		msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
 	} else if(d < (1<<8)) { \
 		/* unsigned 8 */ \
-		const unsigned char buf[2] = {0xcc, STORE16_BE8(d)}; \
+		unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
 		msgpack_pack_append_buffer(x, buf, 2); \
 	} else { \
 		/* unsigned 16 */ \
-		const unsigned char buf[3] = {0xcd, STORE16_BE16(d)}; \
+		unsigned char buf[3]; \
+		buf[0] = 0xcd; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 		msgpack_pack_append_buffer(x, buf, 3); \
 	} \
 } while(0)
@@ -150,20 +79,22 @@ do { \
 	if(d < (1<<8)) { \
 		if(d < (1<<7)) { \
 			/* fixnum */ \
-			msgpack_pack_append_buffer(x, &STORE32_BE8(d), 1); \
+			msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
 		} else { \
 			/* unsigned 8 */ \
-			const unsigned char buf[2] = {0xcc, STORE32_BE8(d)}; \
+			unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
 			msgpack_pack_append_buffer(x, buf, 2); \
 		} \
 	} else { \
 		if(d < (1<<16)) { \
 			/* unsigned 16 */ \
-			const unsigned char buf[3] = {0xcd, STORE32_BE16(d)}; \
+			unsigned char buf[3]; \
+			buf[0] = 0xcd; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else { \
 			/* unsigned 32 */ \
-			const unsigned char buf[5] = {0xce, STORE32_BE32(d)}; \
+			unsigned char buf[5]; \
+			buf[0] = 0xce; *(uint32_t*)&buf[1] = msgpack_be32(d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} \
 	} \
@@ -174,24 +105,27 @@ do { \
 	if(d < (1ULL<<8)) { \
 		if(d < (1<<7)) { \
 			/* fixnum */ \
-			msgpack_pack_append_buffer(x, &STORE64_BE8(d), 1); \
+			msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
 		} else { \
 			/* unsigned 8 */ \
-			const unsigned char buf[2] = {0xcc, STORE64_BE8(d)}; \
+			unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
 			msgpack_pack_append_buffer(x, buf, 2); \
 		} \
 	} else { \
 		if(d < (1ULL<<16)) { \
 			/* signed 16 */ \
-			const unsigned char buf[3] = {0xcd, STORE64_BE16(d)}; \
+			unsigned char buf[3]; \
+			buf[0] = 0xcd; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else if(d < (1ULL<<32)) { \
 			/* signed 32 */ \
-			const unsigned char buf[5] = {0xce, STORE64_BE32(d)}; \
+			unsigned char buf[5]; \
+			buf[0] = 0xce; *(uint32_t*)&buf[1] = msgpack_be32(d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} else { \
 			/* signed 64 */ \
-			const unsigned char buf[9] = {0xcf, STORE64_BE64(d)}; \
+			unsigned char buf[9]; \
+			buf[0] = 0xcf; *(uint64_t*)&buf[1] = msgpack_be64(d); \
 			msgpack_pack_append_buffer(x, buf, 9); \
 		} \
 	} \
@@ -201,11 +135,11 @@ do { \
 do { \
 	if(d < -(1<<5)) { \
 		/* signed 8 */ \
-		const unsigned char buf[2] = {0xd0, STORE8_BE8(d)}; \
+		unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \
 		msgpack_pack_append_buffer(x, buf, 2); \
 	} else { \
 		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1); \
+		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
 	} \
 } while(0)
 
@@ -214,24 +148,26 @@ do { \
 	if(d < -(1<<5)) { \
 		if(d < -(1<<7)) { \
 			/* signed 16 */ \
-			const unsigned char buf[3] = {0xd1, STORE16_BE16(d)}; \
+			unsigned char buf[3]; \
+			buf[0] = 0xd1; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else { \
 			/* signed 8 */ \
-			const unsigned char buf[2] = {0xd0, STORE16_BE8(d)}; \
+			unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \
 			msgpack_pack_append_buffer(x, buf, 2); \
 		} \
 	} else if(d < (1<<7)) { \
 		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE16_BE8(d), 1); \
+		msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
 	} else { \
 		if(d < (1<<8)) { \
 			/* unsigned 8 */ \
-			const unsigned char buf[2] = {0xcc, STORE16_BE8(d)}; \
+			unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
 			msgpack_pack_append_buffer(x, buf, 2); \
 		} else { \
 			/* unsigned 16 */ \
-			const unsigned char buf[3] = {0xcd, STORE16_BE16(d)}; \
+			unsigned char buf[3]; \
+			buf[0] = 0xcd; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} \
 	} \
@@ -242,32 +178,36 @@ do { \
 	if(d < -(1<<5)) { \
 		if(d < -(1<<15)) { \
 			/* signed 32 */ \
-			const unsigned char buf[5] = {0xd2, STORE32_BE32(d)}; \
+			unsigned char buf[5]; \
+			buf[0] = 0xd2; *(uint32_t*)&buf[1] = msgpack_be32(d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} else if(d < -(1<<7)) { \
 			/* signed 16 */ \
-			const unsigned char buf[3] = {0xd1, STORE32_BE16(d)}; \
+			unsigned char buf[3]; \
+			buf[0] = 0xd1; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else { \
 			/* signed 8 */ \
-			const unsigned char buf[2] = {0xd0, STORE32_BE8(d)}; \
+			unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \
 			msgpack_pack_append_buffer(x, buf, 2); \
 		} \
 	} else if(d < (1<<7)) { \
 		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE32_BE8(d), 1); \
+		msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
 	} else { \
 		if(d < (1<<8)) { \
 			/* unsigned 8 */ \
-			const unsigned char buf[2] = {0xcc, STORE32_BE8(d)}; \
+			unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
 			msgpack_pack_append_buffer(x, buf, 2); \
 		} else if(d < (1<<16)) { \
 			/* unsigned 16 */ \
-			const unsigned char buf[3] = {0xcd, STORE32_BE16(d)}; \
+			unsigned char buf[3]; \
+			buf[0] = 0xcd; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else { \
 			/* unsigned 32 */ \
-			const unsigned char buf[5] = {0xce, STORE32_BE32(d)}; \
+			unsigned char buf[5]; \
+			buf[0] = 0xce; *(uint32_t*)&buf[1] = msgpack_be32(d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} \
 	} \
@@ -279,46 +219,52 @@ do { \
 		if(d < -(1LL<<15)) { \
 			if(d < -(1LL<<31)) { \
 				/* signed 64 */ \
-				const unsigned char buf[9] = {0xd3, STORE64_BE64(d)}; \
+				unsigned char buf[9]; \
+				buf[0] = 0xd3; *(uint64_t*)&buf[1] = msgpack_be64(d); \
 				msgpack_pack_append_buffer(x, buf, 9); \
 			} else { \
 				/* signed 32 */ \
-				const unsigned char buf[5] = {0xd2, STORE64_BE32(d)}; \
+				unsigned char buf[5]; \
+				buf[0] = 0xd2; *(uint32_t*)&buf[1] = msgpack_be32(d); \
 				msgpack_pack_append_buffer(x, buf, 5); \
 			} \
 		} else { \
 			if(d < -(1<<7)) { \
 				/* signed 16 */ \
-				const unsigned char buf[3] = {0xd1, STORE64_BE16(d)}; \
+				unsigned char buf[3]; \
+				buf[0] = 0xd1; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 				msgpack_pack_append_buffer(x, buf, 3); \
 			} else { \
 				/* signed 8 */ \
-				const unsigned char buf[2] = {0xd0, STORE64_BE8(d)}; \
+				unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \
 				msgpack_pack_append_buffer(x, buf, 2); \
 			} \
 		} \
 	} else if(d < (1<<7)) { \
 		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE64_BE8(d), 1); \
+		msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
 	} else { \
 		if(d < (1LL<<16)) { \
 			if(d < (1<<8)) { \
 				/* unsigned 8 */ \
-				const unsigned char buf[2] = {0xcc, STORE64_BE8(d)}; \
+				unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
 				msgpack_pack_append_buffer(x, buf, 2); \
 			} else { \
 				/* unsigned 16 */ \
-				const unsigned char buf[3] = {0xcd, STORE64_BE16(d)}; \
+				unsigned char buf[3]; \
+				buf[0] = 0xcd; *(uint16_t*)&buf[1] = msgpack_be16(d); \
 				msgpack_pack_append_buffer(x, buf, 3); \
 			} \
 		} else { \
 			if(d < (1LL<<32)) { \
 				/* unsigned 32 */ \
-				const unsigned char buf[5] = {0xce, STORE64_BE32(d)}; \
+				unsigned char buf[5]; \
+				buf[0] = 0xce; *(uint32_t*)&buf[1] = msgpack_be32(d); \
 				msgpack_pack_append_buffer(x, buf, 5); \
 			} else { \
 				/* unsigned 64 */ \
-				const unsigned char buf[9] = {0xcf, STORE64_BE64(d)}; \
+				unsigned char buf[9]; \
+				buf[0] = 0xcf; *(uint64_t*)&buf[1] = msgpack_be64(d); \
 				msgpack_pack_append_buffer(x, buf, 9); \
 			} \
 		} \
@@ -330,49 +276,55 @@ do { \
 
 msgpack_pack_inline_func_fastint(_uint8)(msgpack_pack_user x, uint8_t d)
 {
-	const unsigned char buf[2] = {0xcc, STORE8_BE8(d)};
+	unsigned char buf[2] = {0xcc, TAKE8_8(d)};
 	msgpack_pack_append_buffer(x, buf, 2);
 }
 
 msgpack_pack_inline_func_fastint(_uint16)(msgpack_pack_user x, uint16_t d)
 {
-	const unsigned char buf[3] = {0xcd, STORE16_BE16(d)};
+	unsigned char buf[3];
+	buf[0] = 0xcd; *(uint16_t*)&buf[1] = msgpack_be16(d);
 	msgpack_pack_append_buffer(x, buf, 3);
 }
 
 msgpack_pack_inline_func_fastint(_uint32)(msgpack_pack_user x, uint32_t d)
 {
-	const unsigned char buf[5] = {0xce, STORE32_BE32(d)};
+	unsigned char buf[5];
+	buf[0] = 0xce; *(uint32_t*)&buf[1] = msgpack_be32(d);
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
 msgpack_pack_inline_func_fastint(_uint64)(msgpack_pack_user x, uint64_t d)
 {
-	const unsigned char buf[9] = {0xcf, STORE64_BE64(d)};
+	unsigned char buf[9];
+	buf[0] = 0xcf; *(uint64_t*)&buf[1] = msgpack_be64(d);
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
 msgpack_pack_inline_func_fastint(_int8)(msgpack_pack_user x, int8_t d)
 {
-	const unsigned char buf[2] = {0xd0, STORE8_BE8(d)};
+	unsigned char buf[2] = {0xd0, TAKE8_8(d)};
 	msgpack_pack_append_buffer(x, buf, 2);
 }
 
 msgpack_pack_inline_func_fastint(_int16)(msgpack_pack_user x, int16_t d)
 {
-	const unsigned char buf[3] = {0xd1, STORE16_BE16(d)};
+	unsigned char buf[3];
+	buf[0] = 0xd1; *(uint16_t*)&buf[1] = msgpack_be16(d);
 	msgpack_pack_append_buffer(x, buf, 3);
 }
 
 msgpack_pack_inline_func_fastint(_int32)(msgpack_pack_user x, int32_t d)
 {
-	const unsigned char buf[5] = {0xd2, STORE32_BE32(d)};
+	unsigned char buf[5];
+	buf[0] = 0xd2; *(uint32_t*)&buf[1] = msgpack_be32(d);
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
 msgpack_pack_inline_func_fastint(_int64)(msgpack_pack_user x, int64_t d)
 {
-	const unsigned char buf[9] = {0xd3, STORE64_BE64(d)};
+	unsigned char buf[9];
+	buf[0] = 0xd3; *(uint64_t*)&buf[1] = msgpack_be64(d);
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
@@ -604,7 +556,8 @@ msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d)
 {
 	union { char buf[4]; uint32_t num; } f;
 	*((float*)&f.buf) = d;  // FIXME
-	const unsigned char buf[5] = {0xca, STORE32_BE32(f.num)};
+	unsigned char buf[5];
+	buf[0] = 0xca; *(uint32_t*)&buf[1] = msgpack_be32(f.num);
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
@@ -612,7 +565,8 @@ msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
 {
 	union { char buf[8]; uint64_t num; } f;
 	*((double*)&f.buf) = d;  // FIXME
-	const unsigned char buf[9] = {0xcb, STORE64_BE64(f.num)};
+	unsigned char buf[9];
+	buf[0] = 0xcb; *(uint64_t*)&buf[1] = msgpack_be64(f.num);
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
@@ -655,12 +609,12 @@ msgpack_pack_inline_func(_array)(msgpack_pack_user x, unsigned int n)
 		unsigned char d = 0x90 | n;
 		msgpack_pack_append_buffer(x, &d, 1);
 	} else if(n < 65536) {
-		uint16_t d = (uint16_t)n;
+		unsigned char buf[3];
-		unsigned char buf[3] = {0xdc, STORE16_BE16(d)};
+		buf[0] = 0xdc; *(uint16_t*)&buf[1] = msgpack_be16(n);
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
-		uint32_t d = (uint32_t)n;
+		unsigned char buf[5];
-		unsigned char buf[5] = {0xdd, STORE32_BE32(d)};
+		buf[0] = 0xdd; *(uint32_t*)&buf[1] = msgpack_be32(n);
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
 }
@@ -674,14 +628,14 @@ msgpack_pack_inline_func(_map)(msgpack_pack_user x, unsigned int n)
 {
 	if(n < 16) {
 		unsigned char d = 0x80 | n;
-		msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1);
+		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
 	} else if(n < 65536) {
-		uint16_t d = (uint16_t)n;
+		unsigned char buf[3];
-		unsigned char buf[3] = {0xde, STORE16_BE16(d)};
+		buf[0] = 0xde; *(uint16_t*)&buf[1] = msgpack_be16(n);
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
-		uint32_t d = (uint32_t)n;
+		unsigned char buf[5];
-		unsigned char buf[5] = {0xdf, STORE32_BE32(d)};
+		buf[0] = 0xdf; *(uint32_t*)&buf[1] = msgpack_be32(n);
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
 }
@@ -695,14 +649,14 @@ msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l)
 {
 	if(l < 32) {
 		unsigned char d = 0xa0 | l;
-		msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1);
+		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
 	} else if(l < 65536) {
-		uint16_t d = (uint16_t)l;
+		unsigned char buf[3];
-		unsigned char buf[3] = {0xda, STORE16_BE16(d)};
+		buf[0] = 0xda; *(uint16_t*)&buf[1] = msgpack_be16(l);
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
-		uint32_t d = (uint32_t)l;
+		unsigned char buf[5];
-		unsigned char buf[5] = {0xdb, STORE32_BE32(d)};
+		buf[0] = 0xdb; *(uint32_t*)&buf[1] = msgpack_be32(l);
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
 }
@@ -716,19 +670,10 @@ msgpack_pack_inline_func(_raw_body)(msgpack_pack_user x, const void* b, size_t l
 #undef msgpack_pack_user
 #undef msgpack_pack_append_buffer
 
-#undef STORE8_BE8
+#undef TAKE8_8
-
+#undef TAKE8_16
-#undef STORE16_BE8
+#undef TAKE8_32
-#undef STORE16_BE16
+#undef TAKE8_64
-
-#undef STORE32_BE8
-#undef STORE32_BE16
-#undef STORE32_BE32
-
-#undef STORE64_BE8
-#undef STORE64_BE16
-#undef STORE64_BE32
-#undef STORE64_BE64
 
 #undef msgpack_pack_real_uint8
 #undef msgpack_pack_real_uint16

msgpack/unpack_define.h

@@ -18,14 +18,10 @@
 #ifndef MSGPACK_UNPACK_DEFINE_H__
 #define MSGPACK_UNPACK_DEFINE_H__
 
-#include <stddef.h>
+#include "msgpack/sys.h"
-#include <stdint.h>
 #include <string.h>
 #include <assert.h>
 #include <stdio.h>
-#ifndef __WIN32__
-#include <arpa/inet.h>
-#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -37,39 +33,6 @@ extern "C" {
 #endif
 
 
-#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __LITTLE_ENDIAN__
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define __BIG_ENDIAN__
-#endif
-#endif
-
-#define msgpack_betoh16(x) ntohs(x)
-#define msgpack_betoh32(x) ntohl(x)
-
-#ifdef __LITTLE_ENDIAN__
-#if defined(__bswap_64)
-#  define msgpack_betoh64(x) __bswap_64(x)
-#elif defined(__DARWIN_OSSwapInt64)
-#  define msgpack_betoh64(x) __DARWIN_OSSwapInt64(x)
-#else
-static inline uint64_t msgpack_betoh64(uint64_t x) {
-	return	((x << 56) & 0xff00000000000000ULL ) |
-			((x << 40) & 0x00ff000000000000ULL ) |
-			((x << 24) & 0x0000ff0000000000ULL ) |
-			((x <<  8) & 0x000000ff00000000ULL ) |
-			((x >>  8) & 0x00000000ff000000ULL ) |
-			((x >> 24) & 0x0000000000ff0000ULL ) |
-			((x >> 40) & 0x000000000000ff00ULL ) |
-			((x >> 56) & 0x00000000000000ffULL ) ;
-}
-#endif
-#else
-#define msgpack_betoh64(x) (x)
-#endif
-
-
 typedef enum {
 	CS_HEADER            = 0x00,  // nil
 

msgpack/unpack_template.h

@@ -126,9 +126,9 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 	((unsigned int)*p & 0x1f)
 
 #define PTR_CAST_8(ptr)   (*(uint8_t*)ptr)
-#define PTR_CAST_16(ptr)  msgpack_betoh16(*(uint16_t*)ptr)
+#define PTR_CAST_16(ptr)  msgpack_be16(*(uint16_t*)ptr)
-#define PTR_CAST_32(ptr)  msgpack_betoh32(*(uint32_t*)ptr)
+#define PTR_CAST_32(ptr)  msgpack_be32(*(uint32_t*)ptr)
-#define PTR_CAST_64(ptr)  msgpack_betoh64(*(uint64_t*)ptr)
+#define PTR_CAST_64(ptr)  msgpack_be64(*(uint64_t*)ptr)
 
 	if(p == pe) { goto _out; }
 	do {