s/\t/ /g

1 files changed, 327 insertions, 328 deletions

diff --git a/msgpack/pack_template.h b/msgpack/pack_template.h
index 35deb83..9e00d7e 100644
--- a/msgpack/pack_template.h
+++ b/msgpack/pack_template.h
@@ -39,269 +39,269 @@
 
 #define msgpack_pack_real_uint8(x, d) \
 do { \
-	if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
-	} else { \
-		/* unsigned 8 */ \
-		unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \
-		msgpack_pack_append_buffer(x, buf, 2); \
-	} \
+    if(d < (1<<7)) { \
+        /* fixnum */ \
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
+    } else { \
+        /* unsigned 8 */ \
+        unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \
+        msgpack_pack_append_buffer(x, buf, 2); \
+    } \
 } while(0)
 
 #define msgpack_pack_real_uint16(x, d) \
 do { \
-	if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
-	} else if(d < (1<<8)) { \
-		/* unsigned 8 */ \
-		unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
-		msgpack_pack_append_buffer(x, buf, 2); \
-	} else { \
-		/* unsigned 16 */ \
-		unsigned char buf[3]; \
-		buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-		msgpack_pack_append_buffer(x, buf, 3); \
-	} \
+    if(d < (1<<7)) { \
+        /* fixnum */ \
+        msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
+    } else if(d < (1<<8)) { \
+        /* unsigned 8 */ \
+        unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
+        msgpack_pack_append_buffer(x, buf, 2); \
+    } else { \
+        /* unsigned 16 */ \
+        unsigned char buf[3]; \
+        buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+        msgpack_pack_append_buffer(x, buf, 3); \
+    } \
 } while(0)
 
 #define msgpack_pack_real_uint32(x, d) \
 do { \
-	if(d < (1<<8)) { \
-		if(d < (1<<7)) { \
-			/* fixnum */ \
-			msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
-		} else { \
-			/* unsigned 8 */ \
-			unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else { \
-		if(d < (1<<16)) { \
-			/* unsigned 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* unsigned 32 */ \
-			unsigned char buf[5]; \
-			buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} \
-	} \
+    if(d < (1<<8)) { \
+        if(d < (1<<7)) { \
+            /* fixnum */ \
+            msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
+        } else { \
+            /* unsigned 8 */ \
+            unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } \
+    } else { \
+        if(d < (1<<16)) { \
+            /* unsigned 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else { \
+            /* unsigned 32 */ \
+            unsigned char buf[5]; \
+            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
+            msgpack_pack_append_buffer(x, buf, 5); \
+        } \
+    } \
 } while(0)
 
 #define msgpack_pack_real_uint64(x, d) \
 do { \
-	if(d < (1ULL<<8)) { \
-		if(d < (1ULL<<7)) { \
-			/* fixnum */ \
-			msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
-		} else { \
-			/* unsigned 8 */ \
-			unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else { \
-		if(d < (1ULL<<16)) { \
-			/* unsigned 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else if(d < (1ULL<<32)) { \
-			/* unsigned 32 */ \
-			unsigned char buf[5]; \
-			buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} else { \
-			/* unsigned 64 */ \
-			unsigned char buf[9]; \
-			buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
-			msgpack_pack_append_buffer(x, buf, 9); \
-		} \
-	} \
+    if(d < (1ULL<<8)) { \
+        if(d < (1ULL<<7)) { \
+            /* fixnum */ \
+            msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
+        } else { \
+            /* unsigned 8 */ \
+            unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } \
+    } else { \
+        if(d < (1ULL<<16)) { \
+            /* unsigned 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else if(d < (1ULL<<32)) { \
+            /* unsigned 32 */ \
+            unsigned char buf[5]; \
+            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
+            msgpack_pack_append_buffer(x, buf, 5); \
+        } else { \
+            /* unsigned 64 */ \
+            unsigned char buf[9]; \
+            buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
+            msgpack_pack_append_buffer(x, buf, 9); \
+        } \
+    } \
 } while(0)
 
 #define msgpack_pack_real_int8(x, d) \
 do { \
-	if(d < -(1<<5)) { \
-		/* signed 8 */ \
-		unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \
-		msgpack_pack_append_buffer(x, buf, 2); \
-	} else { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
-	} \
+    if(d < -(1<<5)) { \
+        /* signed 8 */ \
+        unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \
+        msgpack_pack_append_buffer(x, buf, 2); \
+    } else { \
+        /* fixnum */ \
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
+    } \
 } while(0)
 
 #define msgpack_pack_real_int16(x, d) \
 do { \
-	if(d < -(1<<5)) { \
-		if(d < -(1<<7)) { \
-			/* signed 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* signed 8 */ \
-			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, &TAKE8_16(d), 1); \
-	} else { \
-		if(d < (1<<8)) { \
-			/* unsigned 8 */ \
-			unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} else { \
-			/* unsigned 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} \
-	} \
+    if(d < -(1<<5)) { \
+        if(d < -(1<<7)) { \
+            /* signed 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else { \
+            /* signed 8 */ \
+            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, &TAKE8_16(d), 1); \
+    } else { \
+        if(d < (1<<8)) { \
+            /* unsigned 8 */ \
+            unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } else { \
+            /* unsigned 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } \
+    } \
 } while(0)
 
 #define msgpack_pack_real_int32(x, d) \
 do { \
-	if(d < -(1<<5)) { \
-		if(d < -(1<<15)) { \
-			/* signed 32 */ \
-			unsigned char buf[5]; \
-			buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} else if(d < -(1<<7)) { \
-			/* signed 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* signed 8 */ \
-			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, &TAKE8_32(d), 1); \
-	} else { \
-		if(d < (1<<8)) { \
-			/* unsigned 8 */ \
-			unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} else if(d < (1<<16)) { \
-			/* unsigned 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* unsigned 32 */ \
-			unsigned char buf[5]; \
-			buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} \
-	} \
+    if(d < -(1<<5)) { \
+        if(d < -(1<<15)) { \
+            /* signed 32 */ \
+            unsigned char buf[5]; \
+            buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
+            msgpack_pack_append_buffer(x, buf, 5); \
+        } else if(d < -(1<<7)) { \
+            /* signed 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else { \
+            /* signed 8 */ \
+            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, &TAKE8_32(d), 1); \
+    } else { \
+        if(d < (1<<8)) { \
+            /* unsigned 8 */ \
+            unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } else if(d < (1<<16)) { \
+            /* unsigned 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else { \
+            /* unsigned 32 */ \
+            unsigned char buf[5]; \
+            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
+            msgpack_pack_append_buffer(x, buf, 5); \
+        } \
+    } \
 } while(0)
 
 #define msgpack_pack_real_int64(x, d) \
 do { \
-	if(d < -(1LL<<5)) { \
-		if(d < -(1LL<<15)) { \
-			if(d < -(1LL<<31)) { \
-				/* signed 64 */ \
-				unsigned char buf[9]; \
-				buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \
-				msgpack_pack_append_buffer(x, buf, 9); \
-			} else { \
-				/* signed 32 */ \
-				unsigned char buf[5]; \
-				buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
-				msgpack_pack_append_buffer(x, buf, 5); \
-			} \
-		} else { \
-			if(d < -(1<<7)) { \
-				/* signed 16 */ \
-				unsigned char buf[3]; \
-				buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-				msgpack_pack_append_buffer(x, buf, 3); \
-			} else { \
-				/* signed 8 */ \
-				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, &TAKE8_64(d), 1); \
-	} else { \
-		if(d < (1LL<<16)) { \
-			if(d < (1<<8)) { \
-				/* unsigned 8 */ \
-				unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
-				msgpack_pack_append_buffer(x, buf, 2); \
-			} else { \
-				/* unsigned 16 */ \
-				unsigned char buf[3]; \
-				buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-				msgpack_pack_append_buffer(x, buf, 3); \
-			} \
-		} else { \
-			if(d < (1LL<<32)) { \
-				/* unsigned 32 */ \
-				unsigned char buf[5]; \
-				buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-				msgpack_pack_append_buffer(x, buf, 5); \
-			} else { \
-				/* unsigned 64 */ \
-				unsigned char buf[9]; \
-				buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
-				msgpack_pack_append_buffer(x, buf, 9); \
-			} \
-		} \
-	} \
+    if(d < -(1LL<<5)) { \
+        if(d < -(1LL<<15)) { \
+            if(d < -(1LL<<31)) { \
+                /* signed 64 */ \
+                unsigned char buf[9]; \
+                buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \
+                msgpack_pack_append_buffer(x, buf, 9); \
+            } else { \
+                /* signed 32 */ \
+                unsigned char buf[5]; \
+                buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
+                msgpack_pack_append_buffer(x, buf, 5); \
+            } \
+        } else { \
+            if(d < -(1<<7)) { \
+                /* signed 16 */ \
+                unsigned char buf[3]; \
+                buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
+                msgpack_pack_append_buffer(x, buf, 3); \
+            } else { \
+                /* signed 8 */ \
+                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, &TAKE8_64(d), 1); \
+    } else { \
+        if(d < (1LL<<16)) { \
+            if(d < (1<<8)) { \
+                /* unsigned 8 */ \
+                unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
+                msgpack_pack_append_buffer(x, buf, 2); \
+            } else { \
+                /* unsigned 16 */ \
+                unsigned char buf[3]; \
+                buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+                msgpack_pack_append_buffer(x, buf, 3); \
+            } \
+        } else { \
+            if(d < (1LL<<32)) { \
+                /* unsigned 32 */ \
+                unsigned char buf[5]; \
+                buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
+                msgpack_pack_append_buffer(x, buf, 5); \
+            } else { \
+                /* unsigned 64 */ \
+                unsigned char buf[9]; \
+                buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
+                msgpack_pack_append_buffer(x, buf, 9); \
+            } \
+        } \
+    } \
 } while(0)
 
 
 static inline int msgpack_pack_uint8(msgpack_packer* x, uint8_t d)
 {
-	msgpack_pack_real_uint8(x, d);
+    msgpack_pack_real_uint8(x, d);
 }
 
 static inline int msgpack_pack_uint16(msgpack_packer* x, uint16_t d)
 {
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 }
 
 static inline int msgpack_pack_uint32(msgpack_packer* x, uint32_t d)
 {
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 }
 
 static inline int msgpack_pack_uint64(msgpack_packer* x, uint64_t d)
 {
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 }
 
 static inline int msgpack_pack_int8(msgpack_packer* x, int8_t d)
 {
-	msgpack_pack_real_int8(x, d);
+    msgpack_pack_real_int8(x, d);
 }
 
 static inline int msgpack_pack_int16(msgpack_packer* x, int16_t d)
 {
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 }
 
 static inline int msgpack_pack_int32(msgpack_packer* x, int32_t d)
 {
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 }
 
 static inline int msgpack_pack_int64(msgpack_packer* x, int64_t d)
 {
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 }
 
 
@@ -311,29 +311,29 @@ static inline int msgpack_pack_short(msgpack_packer* x, short d)
 {
 #if defined(SIZEOF_SHORT)
 #if SIZEOF_SHORT == 2
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 #elif SIZEOF_SHORT == 4
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 #else
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 #endif
 
 #elif defined(SHRT_MAX)
 #if SHRT_MAX == 0x7fff
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 #elif SHRT_MAX == 0x7fffffff
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 #else
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 #endif
 
 #else
 if(sizeof(short) == 2) {
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 } else if(sizeof(short) == 4) {
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 } else {
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 }
 #endif
 }
@@ -342,29 +342,29 @@ static inline int msgpack_pack_int(msgpack_packer* x, int d)
 {
 #if defined(SIZEOF_INT)
 #if SIZEOF_INT == 2
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 #elif SIZEOF_INT == 4
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 #else
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 #endif
 
 #elif defined(INT_MAX)
 #if INT_MAX == 0x7fff
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 #elif INT_MAX == 0x7fffffff
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 #else
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 #endif
 
 #else
 if(sizeof(int) == 2) {
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 } else if(sizeof(int) == 4) {
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 } else {
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 }
 #endif
 }
@@ -373,29 +373,29 @@ static inline int msgpack_pack_long(msgpack_packer* x, long d)
 {
 #if defined(SIZEOF_LONG)
 #if SIZEOF_LONG == 2
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 #elif SIZEOF_LONG == 4
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 #else
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 #endif
 
 #elif defined(LONG_MAX)
 #if LONG_MAX == 0x7fffL
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 #elif LONG_MAX == 0x7fffffffL
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 #else
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 #endif
 
 #else
 if(sizeof(long) == 2) {
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 } else if(sizeof(long) == 4) {
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 } else {
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 }
 #endif
 }
@@ -404,29 +404,29 @@ static inline int msgpack_pack_long_long(msgpack_packer* x, long long d)
 {
 #if defined(SIZEOF_LONG_LONG)
 #if SIZEOF_LONG_LONG == 2
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 #elif SIZEOF_LONG_LONG == 4
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 #else
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 #endif
 
 #elif defined(LLONG_MAX)
 #if LLONG_MAX == 0x7fffL
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 #elif LLONG_MAX == 0x7fffffffL
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 #else
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 #endif
 
 #else
 if(sizeof(long long) == 2) {
-	msgpack_pack_real_int16(x, d);
+    msgpack_pack_real_int16(x, d);
 } else if(sizeof(long long) == 4) {
-	msgpack_pack_real_int32(x, d);
+    msgpack_pack_real_int32(x, d);
 } else {
-	msgpack_pack_real_int64(x, d);
+    msgpack_pack_real_int64(x, d);
 }
 #endif
 }
@@ -435,29 +435,29 @@ static inline int msgpack_pack_unsigned_short(msgpack_packer* x, unsigned short
 {
 #if defined(SIZEOF_SHORT)
 #if SIZEOF_SHORT == 2
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 #elif SIZEOF_SHORT == 4
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 #else
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 #endif
 
 #elif defined(USHRT_MAX)
 #if USHRT_MAX == 0xffffU
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 #elif USHRT_MAX == 0xffffffffU
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 #else
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 #endif
 
 #else
 if(sizeof(unsigned short) == 2) {
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 } else if(sizeof(unsigned short) == 4) {
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 } else {
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 }
 #endif
 }
@@ -466,29 +466,29 @@ static inline int msgpack_pack_unsigned_int(msgpack_packer* x, unsigned int d)
 {
 #if defined(SIZEOF_INT)
 #if SIZEOF_INT == 2
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 #elif SIZEOF_INT == 4
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 #else
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 #endif
 
 #elif defined(UINT_MAX)
 #if UINT_MAX == 0xffffU
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 #elif UINT_MAX == 0xffffffffU
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 #else
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 #endif
 
 #else
 if(sizeof(unsigned int) == 2) {
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 } else if(sizeof(unsigned int) == 4) {
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 } else {
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 }
 #endif
 }
@@ -497,29 +497,29 @@ static inline int msgpack_pack_unsigned_long(msgpack_packer* x, unsigned long d)
 {
 #if defined(SIZEOF_LONG)
 #if SIZEOF_LONG == 2
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 #elif SIZEOF_LONG == 4
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 #else
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 #endif
 
 #elif defined(ULONG_MAX)
 #if ULONG_MAX == 0xffffUL
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 #elif ULONG_MAX == 0xffffffffUL
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 #else
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 #endif
 
 #else
 if(sizeof(unsigned long) == 2) {
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 } else if(sizeof(unsigned long) == 4) {
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 } else {
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 }
 #endif
 }
@@ -528,29 +528,29 @@ static inline int msgpack_pack_unsigned_long_long(msgpack_packer* x, unsigned lo
 {
 #if defined(SIZEOF_LONG_LONG)
 #if SIZEOF_LONG_LONG == 2
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 #elif SIZEOF_LONG_LONG == 4
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 #else
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 #endif
 
 #elif defined(ULLONG_MAX)
 #if ULLONG_MAX == 0xffffUL
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 #elif ULLONG_MAX == 0xffffffffUL
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 #else
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 #endif
 
 #else
 if(sizeof(unsigned long long) == 2) {
-	msgpack_pack_real_uint16(x, d);
+    msgpack_pack_real_uint16(x, d);
 } else if(sizeof(unsigned long long) == 4) {
-	msgpack_pack_real_uint32(x, d);
+    msgpack_pack_real_uint32(x, d);
 } else {
-	msgpack_pack_real_uint64(x, d);
+    msgpack_pack_real_uint64(x, d);
 }
 #endif
 }
@@ -566,25 +566,25 @@ if(sizeof(unsigned long long) == 2) {
 
 static inline int msgpack_pack_float(msgpack_packer* x, float d)
 {
-	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);
+    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);
 }
 
 static inline int msgpack_pack_double(msgpack_packer* x, double d)
 {
-	union { double f; uint64_t i; } mem;
-	mem.f = d;
-	unsigned char buf[9];
-	buf[0] = 0xcb;
+    union { double f; uint64_t i; } mem;
+    mem.f = d;
+    unsigned char buf[9];
+    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);
+    msgpack_pack_append_buffer(x, buf, 9);
 }
 
 
@@ -594,8 +594,8 @@ static inline int msgpack_pack_double(msgpack_packer* x, double d)
 
 static inline int msgpack_pack_nil(msgpack_packer* x)
 {
-	static const unsigned char d = 0xc0;
-	msgpack_pack_append_buffer(x, &d, 1);
+    static const unsigned char d = 0xc0;
+    msgpack_pack_append_buffer(x, &d, 1);
 }
 
 
@@ -605,14 +605,14 @@ static inline int msgpack_pack_nil(msgpack_packer* x)
 
 static inline int msgpack_pack_true(msgpack_packer* x)
 {
-	static const unsigned char d = 0xc3;
-	msgpack_pack_append_buffer(x, &d, 1);
+    static const unsigned char d = 0xc3;
+    msgpack_pack_append_buffer(x, &d, 1);
 }
 
 static inline int msgpack_pack_false(msgpack_packer* x)
 {
-	static const unsigned char d = 0xc2;
-	msgpack_pack_append_buffer(x, &d, 1);
+    static const unsigned char d = 0xc2;
+    msgpack_pack_append_buffer(x, &d, 1);
 }
 
 
@@ -622,18 +622,18 @@ static inline int msgpack_pack_false(msgpack_packer* x)
 
 static inline int msgpack_pack_array(msgpack_packer* x, unsigned int n)
 {
-	if(n < 16) {
-		unsigned char d = 0x90 | n;
-		msgpack_pack_append_buffer(x, &d, 1);
-	} else if(n < 65536) {
-		unsigned char buf[3];
-		buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n);
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		unsigned char buf[5];
-		buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n);
-		msgpack_pack_append_buffer(x, buf, 5);
-	}
+    if(n < 16) {
+        unsigned char d = 0x90 | n;
+        msgpack_pack_append_buffer(x, &d, 1);
+    } else if(n < 65536) {
+        unsigned char buf[3];
+        buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n);
+        msgpack_pack_append_buffer(x, buf, 3);
+    } else {
+        unsigned char buf[5];
+        buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n);
+        msgpack_pack_append_buffer(x, buf, 5);
+    }
 }
 
 
@@ -643,18 +643,18 @@ static inline int msgpack_pack_array(msgpack_packer* x, unsigned int n)
 
 static inline int msgpack_pack_map(msgpack_packer* x, unsigned int n)
 {
-	if(n < 16) {
-		unsigned char d = 0x80 | n;
-		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
-	} else if(n < 65536) {
-		unsigned char buf[3];
-		buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n);
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		unsigned char buf[5];
-		buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n);
-		msgpack_pack_append_buffer(x, buf, 5);
-	}
+    if(n < 16) {
+        unsigned char d = 0x80 | n;
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
+    } else if(n < 65536) {
+        unsigned char buf[3];
+        buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n);
+        msgpack_pack_append_buffer(x, buf, 3);
+    } else {
+        unsigned char buf[5];
+        buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n);
+        msgpack_pack_append_buffer(x, buf, 5);
+    }
 }
 
 
@@ -664,23 +664,23 @@ static inline int msgpack_pack_map(msgpack_packer* x, unsigned int n)
 
 static inline int msgpack_pack_raw(msgpack_packer* x, size_t l)
 {
-	if(l < 32) {
-		unsigned char d = 0xa0 | (uint8_t)l;
-		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
-	} else if(l < 65536) {
-		unsigned char buf[3];
-		buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		unsigned char buf[5];
-		buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l);
-		msgpack_pack_append_buffer(x, buf, 5);
-	}
+    if(l < 32) {
+        unsigned char d = 0xa0 | (uint8_t)l;
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
+    } else if(l < 65536) {
+        unsigned char buf[3];
+        buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
+        msgpack_pack_append_buffer(x, buf, 3);
+    } else {
+        unsigned char buf[5];
+        buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l);
+        msgpack_pack_append_buffer(x, buf, 5);
+    }
 }
 
 static inline int msgpack_pack_raw_body(msgpack_packer* x, const void* b, size_t l)
 {
-	msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
+    msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
 }
 
 #undef msgpack_pack_append_buffer
@@ -698,4 +698,3 @@ static inline int msgpack_pack_raw_body(msgpack_packer* x, const void* b, size_t
 #undef msgpack_pack_real_int16
 #undef msgpack_pack_real_int32
 #undef msgpack_pack_real_int64
-