msgpack 0.0.1 → 0.2.0

data/Manifest.txt

@@ -7,16 +7,12 @@ config/requirements.rb
 ext/extconf.rb
 ext/pack.c
 ext/pack.h
-ext/pack_inline.h
 ext/rbinit.c
 ext/unpack.c
 ext/unpack.h
-ext/unpack_context.h
-ext/unpack_inline.c
-msgpack/pack/inline_context.h
-msgpack/pack/inline_impl.h
-msgpack/unpack/inline_context.h
-msgpack/unpack/inline_impl.h
+msgpack/pack_template.h
+msgpack/unpack_define.h
+msgpack/unpack_template.h
 lib/msgpack/version.rb
 script/console
 script/destroy

data/README.txt

@@ -1,8 +1,11 @@
-MessagePack
------------
+=MessagePack
+
+== DESCRIPTION:
+
 Binary-based efficient data interchange format.
 
 
+== LICENSE:
 
 Copyright (C) 2008 FURUHASHI Sadayuki
 

data/ext/extconf.rb

@@ -1,4 +1,4 @@
 require 'mkmf'
-$CFLAGS << " -I.. -Wall -O9"
+$CFLAGS << " -I.. -Wall -O4"
 create_makefile('msgpack')
 

data/ext/pack.c

@@ -15,7 +15,42 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#include "pack_inline.h"
+#include "ruby.h"
+#include <stddef.h>
+#include <stdint.h>
+
+#define msgpack_pack_inline_func(name) \
+	static void msgpack_pack_##name
+
+#define msgpack_pack_user VALUE
+
+#define msgpack_pack_append_buffer(user, buf, len) \
+	rb_str_buf_cat(user, (const void*)buf, len)
+
+/*
+static void msgpack_pack_int(VALUE x, int d);
+static void msgpack_pack_unsigned_int(VALUE x, unsigned int d);
+static void msgpack_pack_uint8(VALUE x, uint8_t d);
+static void msgpack_pack_uint16(VALUE x, uint16_t d);
+static void msgpack_pack_uint32(VALUE x, uint32_t d);
+static void msgpack_pack_uint64(VALUE x, uint64_t d);
+static void msgpack_pack_int8(VALUE x, int8_t d);
+static void msgpack_pack_int16(VALUE x, int16_t d);
+static void msgpack_pack_int32(VALUE x, int32_t d);
+static void msgpack_pack_int64(VALUE x, int64_t d);
+static void msgpack_pack_float(VALUE x, float d);
+static void msgpack_pack_double(VALUE x, double d);
+static void msgpack_pack_nil(VALUE x);
+static void msgpack_pack_true(VALUE x);
+static void msgpack_pack_false(VALUE x);
+static void msgpack_pack_array(VALUE x, unsigned int n);
+static void msgpack_pack_map(VALUE x, unsigned int n);
+static void msgpack_pack_raw(VALUE x, size_t l);
+static void msgpack_pack_raw_body(VALUE x, const void* b, size_t l);
+*/
+
+#include "msgpack/pack_template.h"
+
 
 #ifndef RUBY_VM
 #include "st.h"  // ruby hash
@@ -62,6 +97,23 @@ static VALUE MessagePack_Fixnum_to_msgpack(int argc, VALUE *argv, VALUE self)
 	return out;
 }
 
+
+#ifndef RBIGNUM_SIGN  // Ruby 1.8
+#define RBIGNUM_SIGN(b) (RBIGNUM(b)->sign)
+#endif
+
+static VALUE MessagePack_Bignum_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	// FIXME bignum
+	if(RBIGNUM_SIGN(self)) {  // positive
+		msgpack_pack_uint64(out, rb_big2ull(self));
+	} else {  // negative
+		msgpack_pack_int64(out, rb_big2ll(self));
+	}
+	return out;
+}
+
 static VALUE MessagePack_Float_to_msgpack(int argc, VALUE *argv, VALUE self)
 {
 	ARG_BUFFER(out, argc, argv);
@@ -72,7 +124,8 @@ static VALUE MessagePack_Float_to_msgpack(int argc, VALUE *argv, VALUE self)
 static VALUE MessagePack_String_to_msgpack(int argc, VALUE *argv, VALUE self)
 {
 	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_raw(out, RSTRING_PTR(self), RSTRING_LEN(self));
+	msgpack_pack_raw(out, RSTRING_LEN(self));
+	msgpack_pack_raw_body(out, RSTRING_PTR(self), RSTRING_LEN(self));
 	return out;
 }
 
@@ -122,6 +175,7 @@ void Init_msgpack_pack(VALUE mMessagePack)
 	rb_define_method_id(rb_cTrueClass,  s_to_msgpack, MessagePack_TrueClass_to_msgpack, -1);
 	rb_define_method_id(rb_cFalseClass, s_to_msgpack, MessagePack_FalseClass_to_msgpack, -1);
 	rb_define_method_id(rb_cFixnum, s_to_msgpack, MessagePack_Fixnum_to_msgpack, -1);
+	rb_define_method_id(rb_cBignum, s_to_msgpack, MessagePack_Bignum_to_msgpack, -1);
 	rb_define_method_id(rb_cFloat,  s_to_msgpack, MessagePack_Float_to_msgpack, -1);
 	rb_define_method_id(rb_cString, s_to_msgpack, MessagePack_String_to_msgpack, -1);
 	rb_define_method_id(rb_cArray,  s_to_msgpack, MessagePack_Array_to_msgpack, -1);

data/ext/unpack.c

@@ -16,8 +16,99 @@
  *    limitations under the License.
  */
 #include "ruby.h"
-#include "unpack_context.h"
-#include <stdio.h>
+#include "msgpack/unpack_define.h"
+
+
+typedef struct {
+	int finished;
+} msgpack_unpack_context;
+
+
+#define msgpack_unpack_struct(name) \
+	struct msgpack_unpacker_##name
+
+#define msgpack_unpack_func(ret, name) \
+	ret msgpack_unpacker_##name
+
+#define msgpack_unpack_callback(name) \
+	template_callback_##name
+
+#define msgpack_unpack_object VALUE
+
+#define msgpack_unpack_user msgpack_unpack_context
+
+
+struct msgpack_unpacker_context;
+typedef struct msgpack_unpacker_context msgpack_unpacker;
+
+static void msgpack_unpacker_init(msgpack_unpacker* ctx);
+
+static VALUE msgpack_unpacker_data(msgpack_unpacker* ctx);
+
+static int msgpack_unpacker_execute(msgpack_unpacker* ctx,
+		const char* data, size_t len, size_t* off);
+
+
+static inline VALUE template_callback_init(msgpack_unpack_context* x)
+{ return Qnil; }
+
+static inline VALUE template_callback_uint8(msgpack_unpack_context* x, uint8_t d)
+{ return INT2FIX(d); }
+
+static inline VALUE template_callback_uint16(msgpack_unpack_context* x, uint16_t d)
+{ return INT2FIX(d); }
+
+static inline VALUE template_callback_uint32(msgpack_unpack_context* x, uint32_t d)
+{ return UINT2NUM(d); }
+
+static inline VALUE template_callback_uint64(msgpack_unpack_context* x, uint64_t d)
+{ return rb_ull2inum(d); }
+
+static inline VALUE template_callback_int8(msgpack_unpack_context* x, int8_t d)
+{ return INT2FIX((long)d); }
+
+static inline VALUE template_callback_int16(msgpack_unpack_context* x, int16_t d)
+{ return INT2FIX((long)d); }
+
+static inline VALUE template_callback_int32(msgpack_unpack_context* x, int32_t d)
+{ return INT2NUM((long)d); }
+
+static inline VALUE template_callback_int64(msgpack_unpack_context* x, int64_t d)
+{ return rb_ll2inum(d); }
+
+static inline VALUE template_callback_float(msgpack_unpack_context* x, float d)
+{ return rb_float_new(d); }
+
+static inline VALUE template_callback_double(msgpack_unpack_context* x, double d)
+{ return rb_float_new(d); }
+
+static inline VALUE template_callback_nil(msgpack_unpack_context* x)
+{ return Qnil; }
+
+static inline VALUE template_callback_true(msgpack_unpack_context* x)
+{ return Qtrue; }
+
+static inline VALUE template_callback_false(msgpack_unpack_context* x)
+{ return Qfalse; }
+
+static inline VALUE template_callback_array(msgpack_unpack_context* x, unsigned int n)
+{ return rb_ary_new2(n); }
+
+static inline void template_callback_array_item(msgpack_unpack_context* x, VALUE* c, VALUE o)
+{ rb_ary_push(*c, o); }  // FIXME set value directry RARRAY_PTR(obj)[RARRAY_LEN(obj)++]
+
+static inline VALUE template_callback_map(msgpack_unpack_context* x, unsigned int n)
+{ return rb_hash_new(); }
+
+static inline void template_callback_map_item(msgpack_unpack_context* x, VALUE* c, VALUE k, VALUE v)
+{ rb_hash_aset(*c, k, v); }
+
+static inline VALUE template_callback_raw(msgpack_unpack_context* x, const char* b, const char* p, unsigned int l)
+{ return rb_str_new(p, l); }
+
+
+#include "msgpack/unpack_template.h"
+
 
 #define UNPACKER(from, name) \
 	msgpack_unpacker *name = NULL; \
@@ -45,7 +136,7 @@ static void MessagePack_Unpacker_mark(msgpack_unpacker *mp)
 	unsigned int i;
 	for(i=0; i < mp->top; ++i) {
 		rb_gc_mark(mp->stack[i].obj);
-		rb_gc_mark(mp->stack[i].tmp.map_key);
+		rb_gc_mark(mp->stack[i].map_key);
 	}
 }
 
@@ -61,7 +152,7 @@ static VALUE MessagePack_Unpacker_alloc(VALUE klass)
 static VALUE MessagePack_Unpacker_reset(VALUE self)
 {
 	UNPACKER(self, mp);
-	mp->user.finished = false;
+	mp->user.finished = 0;
 	msgpack_unpacker_init(mp);
 	return self;
 }
@@ -85,18 +176,18 @@ static VALUE MessagePack_Unpacker_execute_impl(VALUE args)
 	int ret;
 
 	if(from >= dlen) {
-		rb_raise(eUnpackError, "Requested start is after data buffer end.");
+		rb_raise(eUnpackError, "offset is bigger than data buffer size.");
 	}
 
 	ret = msgpack_unpacker_execute(mp, dptr, (size_t)dlen, &from);
 
 	if(ret < 0) {
-		rb_raise(eUnpackError, "Parse error.");
+		rb_raise(eUnpackError, "parse error.");
 	} else if(ret > 0) {
-		mp->user.finished = true;
+		mp->user.finished = 1;
 		return ULONG2NUM(from);
 	} else {
-		mp->user.finished = false;
+		mp->user.finished = 0;
 		return ULONG2NUM(from);
 	}
 }
@@ -151,12 +242,12 @@ static VALUE MessagePack_unpack_impl(VALUE args)
 	ret = msgpack_unpacker_execute(mp, dptr, (size_t)dlen, &from);
 
 	if(ret < 0) {
-		rb_raise(eUnpackError, "Parse error.");
+		rb_raise(eUnpackError, "parse error.");
 	} else if(ret == 0) {
-		rb_raise(eUnpackError, "Insufficient bytes.");
+		rb_raise(eUnpackError, "insufficient bytes.");
 	} else {
 		if(from < dlen) {
-			rb_raise(eUnpackError, "Extra bytes.");
+			rb_raise(eUnpackError, "extra bytes.");
 		}
 		return msgpack_unpacker_data(mp);
 	}

data/lib/msgpack/version.rb

@@ -1,8 +1,8 @@
 module MessagePack
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 0
-    TINY  = 1
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/msgpack/{pack/inline_impl.h → pack_template.h}

@@ -1,5 +1,5 @@
 /*
- * MessagePack packing routine
+ * MessagePack packing routine template
  *
  * Copyright (C) 2008 FURUHASHI Sadayuki
  *
@@ -15,58 +15,78 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_PACK_INLINE_IMPL_H__
-#define MSGPACK_PACK_INLINE_IMPL_H__
 
-#include <string.h>
-#include <arpa/inet.h>
+#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 STORE_16(d) \
+#define STORE_BE16(d) \
 	((char*)&d)[1], ((char*)&d)[0]
 
-#define STORE_32(d) \
+#define STORE_BE32(d) \
 	((char*)&d)[3], ((char*)&d)[2], ((char*)&d)[1], ((char*)&d)[0]
 
-#define STORE_64(d) \
+#define STORE_BE64(d) \
 	((char*)&d)[7], ((char*)&d)[6], ((char*)&d)[5], ((char*)&d)[4], \
 	((char*)&d)[3], ((char*)&d)[2], ((char*)&d)[1], ((char*)&d)[0]
 
 #elif __BIG_ENDIAN__
 
-#define STORE_16(d) \
-	((char*)&d)[2], ((char*)&d)[3]
+#define STORE_BE16(d) \
+	((char*)&d)[0], ((char*)&d)[1]
 
-#define STORE_32(d) \
+#define STORE_BE32(d) \
 	((char*)&d)[0], ((char*)&d)[1], ((char*)&d)[2], ((char*)&d)[3]
 
-#define STORE_32(d) \
+#define STORE_BE64(d) \
 	((char*)&d)[0], ((char*)&d)[1], ((char*)&d)[2], ((char*)&d)[3], \
 	((char*)&d)[4], ((char*)&d)[5], ((char*)&d)[6], ((char*)&d)[7]
 
 #endif
 
 
+#ifndef msgpack_pack_inline_func
+#error msgpack_pack_inline_func template is not defined
+#endif
+
+#ifndef msgpack_pack_user
+#error msgpack_pack_user type is not defined
+#endif
+
+#ifndef msgpack_pack_append_buffer
+#error msgpack_pack_append_buffer callback is not defined
+#endif
+
+
 /*
  * Integer
  */
 
 // wrapper
-inline void msgpack_pack_int(msgpack_pack_context x, int d)
+msgpack_pack_inline_func(int)(msgpack_pack_user x, int d)
 {
 	if(d < -32) {
-		if(d < -32768) { // signed 32
-			const unsigned char buf[5] = {0xd2, STORE_32(d)};
+		if(d < -32768) {
+			// signed 32
+			const unsigned char buf[5] = {0xd2, STORE_BE32(d)};
 			msgpack_pack_append_buffer(x, buf, 5);
-		} else if(d < -128) { // signed 16
-			const unsigned char buf[3] = {0xd1, STORE_16(d)};
+		} else if(d < -128) {
+			// signed 16
+			const unsigned char buf[3] = {0xd1, STORE_BE16(d)};
 			msgpack_pack_append_buffer(x, buf, 3);
-		} else { // signed 8
+		} else {
+			// signed 8
 			const unsigned char buf[2] = {0xd0, (uint8_t)d};
 			msgpack_pack_append_buffer(x, buf, 2);
 		}
-	} else if(d < 128) { // fixnum
+	} else if(d < 128) {
+		// fixnum
 		msgpack_pack_append_buffer(x, (uint8_t*)&d, 1);
 	} else {
 		if(d < 256) {
@@ -75,38 +95,42 @@ inline void msgpack_pack_int(msgpack_pack_context x, int d)
 			msgpack_pack_append_buffer(x, buf, 2);
 		} else if(d < 65536) {
 			// unsigned 16
-			const unsigned char buf[3] = {0xcd, STORE_16(d)};
+			const unsigned char buf[3] = {0xcd, STORE_BE16(d)};
 			msgpack_pack_append_buffer(x, buf, 3);
 		} else {
 			// unsigned 32
-			const unsigned char buf[5] = {0xce, STORE_32(d)};
+			const unsigned char buf[5] = {0xce, STORE_BE32(d)};
 			msgpack_pack_append_buffer(x, buf, 5);
 		}
 	}
 }
 
 // wrapper
-inline void msgpack_pack_unsigned_int(msgpack_pack_context x, unsigned int d)
+msgpack_pack_inline_func(unsigned_int)(msgpack_pack_user x, unsigned int d)
 {
-	if(d < 128) {
-		// fixnum
-		msgpack_pack_append_buffer(x, (uint8_t*)&d, 1);
-	} else if(d < 256) {
-		// unsigned 8
-		const unsigned char buf[2] = {0xcc, (uint8_t)d};
-		msgpack_pack_append_buffer(x, buf, 2);
-	} else if(d < 65536) {
-		// unsigned 16
-		const unsigned char buf[3] = {0xcd, STORE_16(d)};
-		msgpack_pack_append_buffer(x, buf, 3);
+	if(d < 256) {
+		if(d < 128) {
+			// fixnum
+			msgpack_pack_append_buffer(x, (unsigned char*)&d, 1);
+		} else {
+			// unsigned 8
+			const unsigned char buf[2] = {0xcc, (uint8_t)d};
+			msgpack_pack_append_buffer(x, buf, 2);
+		}
 	} else {
-		// unsigned 32
-		const unsigned char buf[5] = {0xce, STORE_32(d)};
-		msgpack_pack_append_buffer(x, buf, 5);
+		if(d < 65536) {
+			// unsigned 16
+			const unsigned char buf[3] = {0xcd, STORE_BE16(d)};
+			msgpack_pack_append_buffer(x, buf, 3);
+		} else {
+			// unsigned 32
+			const unsigned char buf[5] = {0xce, STORE_BE32(d)};
+			msgpack_pack_append_buffer(x, buf, 5);
+		}
 	}
 }
 
-inline void msgpack_pack_unsigned_int_8(msgpack_pack_context x, uint8_t d)
+msgpack_pack_inline_func(uint8)(msgpack_pack_user x, uint8_t d)
 {
 	if(d < 128) {
 		msgpack_pack_append_buffer(x, &d, 1);
@@ -116,26 +140,25 @@ inline void msgpack_pack_unsigned_int_8(msgpack_pack_context x, uint8_t d)
 	}
 }
 
-inline void msgpack_pack_unsigned_int_16(msgpack_pack_context x, uint16_t d)
+msgpack_pack_inline_func(uint16)(msgpack_pack_user x, uint16_t d)
 {
-	const unsigned char buf[3] = {0xcd, STORE_16(d)};
+	const unsigned char buf[3] = {0xcd, STORE_BE16(d)};
 	msgpack_pack_append_buffer(x, buf, 3);
 }
 
-inline void msgpack_pack_unsigned_int_32(msgpack_pack_context x, uint32_t d)
+msgpack_pack_inline_func(uint32)(msgpack_pack_user x, uint32_t d)
 {
-	const unsigned char buf[5] = {0xce, STORE_32(d)};
+	const unsigned char buf[5] = {0xce, STORE_BE32(d)};
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
-inline void msgpack_pack_unsigned_int_64(msgpack_pack_context x, uint64_t d)
+msgpack_pack_inline_func(uint64)(msgpack_pack_user x, uint64_t d)
 {
-	// FIXME
-	const unsigned char buf[9] = {0xcf, STORE_64(d)};
+	const unsigned char buf[9] = {0xcf, STORE_BE64(d)};
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
-inline void msgpack_pack_signed_int_8(msgpack_pack_context x, int8_t d)
+msgpack_pack_inline_func(int8)(msgpack_pack_user x, int8_t d)
 {
 	if(d > 0) {
 		msgpack_pack_append_buffer(x, (uint8_t*)&d, 1);
@@ -147,22 +170,21 @@ inline void msgpack_pack_signed_int_8(msgpack_pack_context x, int8_t d)
 	}
 }
 
-inline void msgpack_pack_signed_int_16(msgpack_pack_context x, int16_t d)
+msgpack_pack_inline_func(int16)(msgpack_pack_user x, int16_t d)
 {
-	const unsigned char buf[3] = {0xd1, STORE_16(d)};
+	const unsigned char buf[3] = {0xd1, STORE_BE16(d)};
 	msgpack_pack_append_buffer(x, buf, 3);
 }
 
-inline void msgpack_pack_signed_int_32(msgpack_pack_context x, int32_t d)
+msgpack_pack_inline_func(int32)(msgpack_pack_user x, int32_t d)
 {
-	const unsigned char buf[5] = {0xd2, STORE_32(d)};
+	const unsigned char buf[5] = {0xd2, STORE_BE32(d)};
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
-inline void msgpack_pack_signed_int_64(msgpack_pack_context x, int64_t d)
+msgpack_pack_inline_func(int64)(msgpack_pack_user x, int64_t d)
 {
-	// FIXME
-	const unsigned char buf[9] = {0xd3, STORE_64(d)};
+	const unsigned char buf[9] = {0xd3, STORE_BE64(d)};
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
@@ -171,17 +193,17 @@ inline void msgpack_pack_signed_int_64(msgpack_pack_context x, int64_t d)
  * Float
  */
 
-inline void msgpack_pack_float(msgpack_pack_context x, float d)
+msgpack_pack_inline_func(float)(msgpack_pack_user x, float d)
 {
 	uint32_t n = *((uint32_t*)&d);  // FIXME
-	const unsigned char buf[5] = {0xca, STORE_32(n)};
+	const unsigned char buf[5] = {0xca, STORE_BE32(n)};
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
-inline void msgpack_pack_double(msgpack_pack_context x, double d)
+msgpack_pack_inline_func(double)(msgpack_pack_user x, double d)
 {
 	uint64_t n = *((uint64_t*)&d);  // FIXME
-	const unsigned char buf[9] = {0xcb, STORE_64(n)};
+	const unsigned char buf[9] = {0xcb, STORE_BE64(n)};
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
@@ -190,7 +212,7 @@ inline void msgpack_pack_double(msgpack_pack_context x, double d)
  * Nil
  */
 
-inline void msgpack_pack_nil(msgpack_pack_context x)
+msgpack_pack_inline_func(nil)(msgpack_pack_user x)
 {
 	static const unsigned char d = 0xc0;
 	msgpack_pack_append_buffer(x, &d, 1);
@@ -200,13 +222,14 @@ inline void msgpack_pack_nil(msgpack_pack_context x)
 /*
  * Boolean
  */
-inline void msgpack_pack_true(msgpack_pack_context x)
+
+msgpack_pack_inline_func(true)(msgpack_pack_user x)
 {
 	static const unsigned char d = 0xc3;
 	msgpack_pack_append_buffer(x, &d, 1);
 }
 
-inline void msgpack_pack_false(msgpack_pack_context x)
+msgpack_pack_inline_func(false)(msgpack_pack_user x)
 {
 	static const unsigned char d = 0xc2;
 	msgpack_pack_append_buffer(x, &d, 1);
@@ -217,18 +240,18 @@ inline void msgpack_pack_false(msgpack_pack_context x)
  * Array
  */
 
-inline void msgpack_pack_array(msgpack_pack_context x, unsigned int n)
+msgpack_pack_inline_func(array)(msgpack_pack_user x, unsigned int n)
 {
 	if(n < 16) {
 		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] = {0xdc, STORE_16(d)};
+		unsigned char buf[3] = {0xdc, STORE_BE16(d)};
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
 		uint32_t d = (uint32_t)n;
-		unsigned char buf[5] = {0xdd, STORE_32(d)};
+		unsigned char buf[5] = {0xdd, STORE_BE32(d)};
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
 }
@@ -238,50 +261,53 @@ inline void msgpack_pack_array(msgpack_pack_context x, unsigned int n)
  * Map
  */
 
-inline void msgpack_pack_map(msgpack_pack_context x, unsigned int n)
+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, &d, 1);
 	} else if(n < 65536) {
 		uint16_t d = (uint16_t)n;
-		unsigned char buf[3] = {0xde, STORE_16(d)};
+		unsigned char buf[3] = {0xde, STORE_BE16(d)};
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
 		uint32_t d = (uint32_t)n;
-		unsigned char buf[5] = {0xdf, STORE_32(d)};
+		unsigned char buf[5] = {0xdf, STORE_BE32(d)};
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
 }
 
 
 /*
- * String
+ * Raw
  */
 
-inline void msgpack_pack_string(msgpack_pack_context x, const char* b)
-{
-	uint32_t l = strlen(b);
-	msgpack_pack_append_buffer(x, (const unsigned char*)b, l+1);
-}
-
-inline void msgpack_pack_raw(msgpack_pack_context x, const void* b, size_t l)
+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, &d, 1);
 	} else if(l < 65536) {
 		uint16_t d = (uint16_t)l;
-		unsigned char buf[3] = {0xda, STORE_16(d)};
+		unsigned char buf[3] = {0xda, STORE_BE16(d)};
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
 		uint32_t d = (uint32_t)l;
-		unsigned char buf[5] = {0xdb, STORE_32(d)};
+		unsigned char buf[5] = {0xdb, STORE_BE32(d)};
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
-	msgpack_pack_append_buffer(x, b, l);
 }
 
+msgpack_pack_inline_func(raw_body)(msgpack_pack_user x, const void* b, size_t l)
+{
+	msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
+}
+
+#undef msgpack_pack_inline_func
+#undef msgpack_pack_user
+#undef msgpack_pack_append_buffer
 
-#endif /* msgpack/pack/inline_impl.h */
+#undef STORE_BE16
+#undef STORE_BE32
+#undef STORE_BE64