msgpack 0.3.2-mswin32 → 0.3.3-mswin32

data/AUTHORS

@@ -0,0 +1 @@
+FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>

data/README

@@ -0,0 +1,29 @@
+
+= MessagePack
+
+
+== Description
+
+
+== Installation
+
+=== Archive Installation
+
+	rake install
+
+=== Gem Installation
+
+	gem install msgpack
+
+
+== Features/Problems
+
+
+== Synopsis
+
+
+== Copyright
+
+Author::    frsyuki <frsyuki@users.sourceforge.jp>
+Copyright:: Copyright (c) 2008-2009 frsyuki
+License::   Apache License, Version 2.0

data/ext/unpack.c

@@ -18,10 +18,16 @@
 #include "ruby.h"
 #include "msgpack/unpack_define.h"
 
+static ID s_sysread;
 
 typedef struct {
 	int finished;
 	VALUE source;
+	size_t offset;
+	size_t parsed;
+	VALUE buffer;
+	VALUE stream;
+	VALUE streambuf;
 } unpack_user;
 
 
@@ -144,6 +150,9 @@ static void MessagePack_Unpacker_free(void* data)
 static void MessagePack_Unpacker_mark(msgpack_unpack_t *mp)
 {
 	unsigned int i;
+	rb_gc_mark(mp->user.buffer);
+	rb_gc_mark(mp->user.stream);
+	rb_gc_mark(mp->user.streambuf);
 	for(i=0; i < mp->top; ++i) {
 		rb_gc_mark(mp->stack[i].obj);
 		rb_gc_mark(mp->stack[i].map_key); /* maybe map_key is not initialized */
@@ -164,14 +173,32 @@ static VALUE MessagePack_Unpacker_reset(VALUE self)
 	UNPACKER(self, mp);
 	template_init(mp);
 	init_stack(mp);
-	unpack_user u = {0, Qnil};
-	mp->user = u;
+	mp->user.finished = 0;
 	return self;
 }
 
-static VALUE MessagePack_Unpacker_initialize(VALUE self)
+static VALUE MessagePack_Unpacker_initialize(int argc, VALUE *argv, VALUE self)
 {
-	return MessagePack_Unpacker_reset(self);
+	VALUE stream;
+	switch(argc) {
+	case 0:
+		stream = Qnil;
+		break;
+	case 1:
+		stream = argv[0];
+		break;
+	default:
+		rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
+	}
+
+	MessagePack_Unpacker_reset(self);
+	UNPACKER(self, mp);
+	mp->user.offset = 0;
+	mp->user.parsed = 0;
+	mp->user.buffer = rb_str_new("",0);
+	mp->user.stream = stream;
+	mp->user.streambuf = rb_str_new("",0);
+	return self;
 }
 
 
@@ -249,6 +276,87 @@ static VALUE MessagePack_Unpacker_data(VALUE self)
 }
 
 
+static VALUE MessagePack_Unpacker_feed(VALUE self, VALUE data)
+{
+	UNPACKER(self, mp);
+	StringValue(data);
+	rb_str_cat(mp->user.buffer, RSTRING_PTR(data), RSTRING_LEN(data));
+	return Qnil;
+}
+
+static VALUE MessagePack_Unpacker_stream_get(VALUE self)
+{
+	UNPACKER(self, mp);
+	return mp->user.stream;
+}
+
+static VALUE MessagePack_Unpacker_stream_set(VALUE self, VALUE val)
+{
+	UNPACKER(self, mp);
+	return mp->user.stream = val;
+}
+
+static VALUE MessagePack_Unpacker_fill(VALUE self)
+{
+	UNPACKER(self, mp);
+
+	if(mp->user.stream == Qnil) {
+		return Qnil;
+	}
+
+	size_t len;
+	if(RSTRING_LEN(mp->user.buffer) == 0) {
+		rb_funcall(mp->user.stream, s_sysread, 2, LONG2FIX(64*1024), mp->user.buffer);
+		len = RSTRING_LEN(mp->user.buffer);
+	} else {
+		rb_funcall(mp->user.stream, s_sysread, 2, LONG2FIX(64*1024), mp->user.streambuf);
+		len = RSTRING_LEN(mp->user.streambuf);
+		rb_str_cat(mp->user.buffer, RSTRING_PTR(mp->user.streambuf), RSTRING_LEN(mp->user.streambuf));
+	}
+
+	return LONG2FIX(len);
+}
+
+static VALUE MessagePack_Unpacker_each(VALUE self)
+{
+	UNPACKER(self, mp);
+	int ret;
+
+#ifdef RETURN_ENUMERATOR
+	RETURN_ENUMERATOR(self, 0, 0);
+#endif
+
+	while(1) {
+		if(RSTRING_LEN(mp->user.buffer) <= mp->user.offset) {
+			do_fill:
+			{
+				VALUE len = MessagePack_Unpacker_fill(self);
+				if(len == Qnil || FIX2LONG(len) == 0) {
+					break;
+				}
+			}
+		}
+
+		mp->user.source = mp->user.buffer;
+		ret = template_execute(mp, RSTRING_PTR(mp->user.buffer), RSTRING_LEN(mp->user.buffer), &mp->user.offset);
+		mp->user.source = Qnil;
+
+		if(ret < 0) {
+			rb_raise(eUnpackError, "parse error.");
+		} else if(ret > 0) {
+			VALUE data = template_data(mp);
+			template_init(mp);
+			init_stack(mp);
+			rb_yield(data);
+		} else {
+			goto do_fill;
+		}
+	}
+
+	return Qnil;
+}
+
+
 static VALUE MessagePack_unpack_impl(VALUE args)
 {
 	msgpack_unpack_t* mp = (msgpack_unpack_t*)((VALUE*)args)[0];
@@ -292,7 +400,7 @@ static VALUE MessagePack_unpack_limit(VALUE self, VALUE data, VALUE limit)
 	msgpack_unpack_t mp;
 	template_init(&mp);
 	init_stack(&mp);
-	unpack_user u = {0, Qnil};
+	unpack_user u = {0, Qnil, 0, 0, Qnil, Qnil, Qnil};
 	mp.user = u;
 
 	rb_gc_disable();
@@ -313,17 +421,22 @@ static VALUE MessagePack_unpack(VALUE self, VALUE data)
 
 void Init_msgpack_unpack(VALUE mMessagePack)
 {
+	s_sysread = rb_intern("sysread");
 	eUnpackError = rb_define_class_under(mMessagePack, "UnpackError", rb_eStandardError);
 	cUnpacker = rb_define_class_under(mMessagePack, "Unpacker", rb_cObject);
 	rb_define_alloc_func(cUnpacker, MessagePack_Unpacker_alloc);
-	rb_define_method(cUnpacker, "initialize", MessagePack_Unpacker_initialize, 0);
+	rb_define_method(cUnpacker, "initialize", MessagePack_Unpacker_initialize, -1);
 	rb_define_method(cUnpacker, "execute", MessagePack_Unpacker_execute, 2);
 	rb_define_method(cUnpacker, "execute_limit", MessagePack_Unpacker_execute_limit, 3);
 	rb_define_method(cUnpacker, "finished?", MessagePack_Unpacker_finished_p, 0);
 	rb_define_method(cUnpacker, "data", MessagePack_Unpacker_data, 0);
 	rb_define_method(cUnpacker, "reset", MessagePack_Unpacker_reset, 0);
+	rb_define_method(cUnpacker, "feed", MessagePack_Unpacker_feed, 1);
+	rb_define_method(cUnpacker, "fill", MessagePack_Unpacker_fill, 0);
+	rb_define_method(cUnpacker, "each", MessagePack_Unpacker_each, 0);
+	rb_define_method(cUnpacker, "stream", MessagePack_Unpacker_stream_get, 0);
+	rb_define_method(cUnpacker, "stream=", MessagePack_Unpacker_stream_set, 1);
 	rb_define_module_function(mMessagePack, "unpack", MessagePack_unpack, 1);
 	rb_define_module_function(mMessagePack, "unpack_limit", MessagePack_unpack_limit, 2);
 }
 
-

data/msgpack/pack_define.h

@@ -0,0 +1,26 @@
+/*
+ * MessagePack unpacking routine template
+ *
+ * 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.
+ *    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_PACK_DEFINE_H__
+#define MSGPACK_PACK_DEFINE_H__
+
+#include "msgpack/sysdep.h"
+#include <limits.h>
+#include <string.h>
+
+#endif /* msgpack/pack_define.h */
+

data/msgpack/pack_template.h

@@ -0,0 +1,686 @@
+/*
+ * MessagePack packing routine template
+ *
+ * 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.
+ *    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.
+ */
+
+#ifdef __LITTLE_ENDIAN__
+#define TAKE8_8(d)  ((uint8_t*)&d)[0]
+#define TAKE8_16(d) ((uint8_t*)&d)[0]
+#define TAKE8_32(d) ((uint8_t*)&d)[0]
+#define TAKE8_64(d) ((uint8_t*)&d)[0]
+#elif __BIG_ENDIAN__
+#define TAKE8_8(d)  ((uint8_t*)&d)[0]
+#define TAKE8_16(d) ((uint8_t*)&d)[1]
+#define TAKE8_32(d) ((uint8_t*)&d)[3]
+#define TAKE8_64(d) ((uint8_t*)&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
+ */
+
+#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); \
+	} \
+} 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], 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], d); \
+			msgpack_pack_append_buffer(x, buf, 3); \
+		} else { \
+			/* unsigned 32 */ \
+			unsigned char buf[5]; \
+			buf[0] = 0xce; _msgpack_store32(&buf[1], d); \
+			msgpack_pack_append_buffer(x, buf, 5); \
+		} \
+	} \
+} while(0)
+
+#define msgpack_pack_real_uint64(x, d) \
+do { \
+	if(d < (1ULL<<8)) { \
+		if(d < (1<<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)) { \
+			/* signed 16 */ \
+			unsigned char buf[3]; \
+			buf[0] = 0xcd; _msgpack_store16(&buf[1], d); \
+			msgpack_pack_append_buffer(x, buf, 3); \
+		} else if(d < (1ULL<<32)) { \
+			/* signed 32 */ \
+			unsigned char buf[5]; \
+			buf[0] = 0xce; _msgpack_store32(&buf[1], d); \
+			msgpack_pack_append_buffer(x, buf, 5); \
+		} else { \
+			/* signed 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); \
+	} \
+} 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], 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], 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], 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], 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], d); \
+			msgpack_pack_append_buffer(x, buf, 3); \
+		} else { \
+			/* unsigned 32 */ \
+			unsigned char buf[5]; \
+			buf[0] = 0xce; _msgpack_store32(&buf[1], 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], 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], 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], 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], 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)
+
+
+#ifdef msgpack_pack_inline_func_fastint
+
+msgpack_pack_inline_func_fastint(_uint8)(msgpack_pack_user x, uint8_t 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)
+{
+	unsigned char buf[3];
+	buf[0] = 0xcd; _msgpack_store16(&buf[1], d);
+	msgpack_pack_append_buffer(x, buf, 3);
+}
+
+msgpack_pack_inline_func_fastint(_uint32)(msgpack_pack_user x, uint32_t d)
+{
+	unsigned char buf[5];
+	buf[0] = 0xce; _msgpack_store32(&buf[1], d);
+	msgpack_pack_append_buffer(x, buf, 5);
+}
+
+msgpack_pack_inline_func_fastint(_uint64)(msgpack_pack_user x, uint64_t d)
+{
+	unsigned char buf[9];
+	buf[0] = 0xcf; _msgpack_store64(&buf[1], d);
+	msgpack_pack_append_buffer(x, buf, 9);
+}
+
+msgpack_pack_inline_func_fastint(_int8)(msgpack_pack_user x, int8_t 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)
+{
+	unsigned char buf[3];
+	buf[0] = 0xd1; _msgpack_store16(&buf[1], d);
+	msgpack_pack_append_buffer(x, buf, 3);
+}
+
+msgpack_pack_inline_func_fastint(_int32)(msgpack_pack_user x, int32_t d)
+{
+	unsigned char buf[5];
+	buf[0] = 0xd2; _msgpack_store32(&buf[1], d);
+	msgpack_pack_append_buffer(x, buf, 5);
+}
+
+msgpack_pack_inline_func_fastint(_int64)(msgpack_pack_user x, int64_t d)
+{
+	unsigned char buf[9];
+	buf[0] = 0xd3; _msgpack_store64(&buf[1], d);
+	msgpack_pack_append_buffer(x, buf, 9);
+}
+
+#undef msgpack_pack_inline_func_fastint
+#endif
+
+
+msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d)
+{
+	msgpack_pack_real_uint8(x, d);
+}
+
+msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d)
+{
+	msgpack_pack_real_uint16(x, d);
+}
+
+msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d)
+{
+	msgpack_pack_real_uint32(x, d);
+}
+
+msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d)
+{
+	msgpack_pack_real_uint64(x, d);
+}
+
+msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d)
+{
+	msgpack_pack_real_int8(x, d);
+}
+
+msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d)
+{
+	msgpack_pack_real_int16(x, d);
+}
+
+msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d)
+{
+	msgpack_pack_real_int32(x, d);
+}
+
+msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d)
+{
+	msgpack_pack_real_int64(x, d);
+}
+
+
+#ifdef msgpack_pack_inline_func_cint
+
+msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d)
+{
+#if defined(SIZEOF_SHORT) || defined(SHRT_MAX)
+#if SIZEOF_SHORT == 2 || SHRT_MAX == 0x7fff
+	msgpack_pack_real_int16(x, d);
+#elif SIZEOF_SHORT == 4 || SHRT_MAX == 0x7fffffff
+	msgpack_pack_real_int32(x, d);
+#else
+	msgpack_pack_real_int64(x, d);
+#endif
+#else
+if(sizeof(short) == 2) {
+	msgpack_pack_real_int16(x, d);
+} else if(sizeof(short) == 4) {
+	msgpack_pack_real_int32(x, d);
+} else {
+	msgpack_pack_real_int64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d)
+{
+#if defined(SIZEOF_INT) || defined(INT_MAX)
+#if SIZEOF_INT == 2 || INT_MAX == 0x7fff
+	msgpack_pack_real_int16(x, d);
+#elif SIZEOF_INT == 4 || INT_MAX == 0x7fffffff
+	msgpack_pack_real_int32(x, d);
+#else
+	msgpack_pack_real_int64(x, d);
+#endif
+#else
+if(sizeof(int) == 2) {
+	msgpack_pack_real_int16(x, d);
+} else if(sizeof(int) == 4) {
+	msgpack_pack_real_int32(x, d);
+} else {
+	msgpack_pack_real_int64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d)
+{
+#if defined(SIZEOF_LONG) || defined(LONG_MAX)
+#if SIZEOF_LONG == 2 || LONG_MAX == 0x7fffL
+	msgpack_pack_real_int16(x, d);
+#elif SIZEOF_LONG == 4 || LONG_MAX == 0x7fffffffL
+	msgpack_pack_real_int32(x, d);
+#else
+	msgpack_pack_real_int64(x, d);
+#endif
+#else
+if(sizeof(long) == 2) {
+	msgpack_pack_real_int16(x, d);
+} else if(sizeof(long) == 4) {
+	msgpack_pack_real_int32(x, d);
+} else {
+	msgpack_pack_real_int64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d)
+{
+#if defined(SIZEOF_LONG_LONG) || defined(LLONG_MAX)
+#if SIZEOF_LONG_LONG == 2 || LLONG_MAX == 0x7fffL
+	msgpack_pack_real_int16(x, d);
+#elif SIZEOF_LONG_LONG == 4 || LLONG_MAX == 0x7fffffffL
+	msgpack_pack_real_int32(x, d);
+#else
+	msgpack_pack_real_int64(x, d);
+#endif
+#else
+if(sizeof(long long) == 2) {
+	msgpack_pack_real_int16(x, d);
+} else if(sizeof(long long) == 4) {
+	msgpack_pack_real_int32(x, d);
+} else {
+	msgpack_pack_real_int64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned short d)
+{
+#if defined(SIZEOF_SHORT) || defined(USHRT_MAX)
+#if SIZEOF_SHORT == 2 || USHRT_MAX == 0xffffU
+	msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_SHORT == 4 || USHRT_MAX == 0xffffffffU
+	msgpack_pack_real_uint32(x, d);
+#else
+	msgpack_pack_real_uint64(x, d);
+#endif
+#else
+if(sizeof(unsigned short) == 2) {
+	msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned short) == 4) {
+	msgpack_pack_real_uint32(x, d);
+} else {
+	msgpack_pack_real_uint64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d)
+{
+#if defined(SIZEOF_INT) || defined(UINT_MAX)
+#if SIZEOF_INT == 2 || UINT_MAX == 0xffffU
+	msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_INT == 4 || UINT_MAX == 0xffffffffU
+	msgpack_pack_real_uint32(x, d);
+#else
+	msgpack_pack_real_uint64(x, d);
+#endif
+#else
+if(sizeof(unsigned int) == 2) {
+	msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned int) == 4) {
+	msgpack_pack_real_uint32(x, d);
+} else {
+	msgpack_pack_real_uint64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long d)
+{
+#if defined(SIZEOF_LONG) || defined(ULONG_MAX)
+#if SIZEOF_LONG == 2 || ULONG_MAX == 0xffffUL
+	msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_LONG == 4 || ULONG_MAX == 0xffffffffUL
+	msgpack_pack_real_uint32(x, d);
+#else
+	msgpack_pack_real_uint64(x, d);
+#endif
+#else
+if(sizeof(unsigned int) == 2) {
+	msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned int) == 4) {
+	msgpack_pack_real_uint32(x, d);
+} else {
+	msgpack_pack_real_uint64(x, d);
+}
+#endif
+}
+
+msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned long long d)
+{
+#if defined(SIZEOF_LONG_LONG) || defined(ULLONG_MAX)
+#if SIZEOF_LONG_LONG == 2 || ULLONG_MAX == 0xffffUL
+	msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_LONG_LONG == 4 || ULLONG_MAX == 0xffffffffUL
+	msgpack_pack_real_uint32(x, d);
+#else
+	msgpack_pack_real_uint64(x, d);
+#endif
+#else
+if(sizeof(unsigned long long) == 2) {
+	msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned long long) == 4) {
+	msgpack_pack_real_uint32(x, d);
+} else {
+	msgpack_pack_real_uint64(x, d);
+}
+#endif
+}
+
+#undef msgpack_pack_inline_func_cint
+#endif
+
+
+
+/*
+ * Float
+ */
+
+msgpack_pack_inline_func(_float)(msgpack_pack_user 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);
+}
+
+msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
+{
+	union { double f; uint64_t i; } mem;
+	mem.f = d;
+	unsigned char buf[9];
+	buf[0] = 0xcb; _msgpack_store64(&buf[1], mem.i);
+	msgpack_pack_append_buffer(x, buf, 9);
+}
+
+
+/*
+ * Nil
+ */
+
+msgpack_pack_inline_func(_nil)(msgpack_pack_user x)
+{
+	static const unsigned char d = 0xc0;
+	msgpack_pack_append_buffer(x, &d, 1);
+}
+
+
+/*
+ * Boolean
+ */
+
+msgpack_pack_inline_func(_true)(msgpack_pack_user x)
+{
+	static const unsigned char d = 0xc3;
+	msgpack_pack_append_buffer(x, &d, 1);
+}
+
+msgpack_pack_inline_func(_false)(msgpack_pack_user x)
+{
+	static const unsigned char d = 0xc2;
+	msgpack_pack_append_buffer(x, &d, 1);
+}
+
+
+/*
+ * Array
+ */
+
+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) {
+		unsigned char buf[3];
+		buf[0] = 0xdc; _msgpack_store16(&buf[1], n);
+		msgpack_pack_append_buffer(x, buf, 3);
+	} else {
+		unsigned char buf[5];
+		buf[0] = 0xdd; _msgpack_store32(&buf[1], n);
+		msgpack_pack_append_buffer(x, buf, 5);
+	}
+}
+
+
+/*
+ * Map
+ */
+
+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, &TAKE8_8(d), 1);
+	} else if(n < 65536) {
+		unsigned char buf[3];
+		buf[0] = 0xde; _msgpack_store16(&buf[1], n);
+		msgpack_pack_append_buffer(x, buf, 3);
+	} else {
+		unsigned char buf[5];
+		buf[0] = 0xdf; _msgpack_store32(&buf[1], n);
+		msgpack_pack_append_buffer(x, buf, 5);
+	}
+}
+
+
+/*
+ * Raw
+ */
+
+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, &TAKE8_8(d), 1);
+	} else if(l < 65536) {
+		unsigned char buf[3];
+		buf[0] = 0xda; _msgpack_store16(&buf[1], l);
+		msgpack_pack_append_buffer(x, buf, 3);
+	} else {
+		unsigned char buf[5];
+		buf[0] = 0xdb; _msgpack_store32(&buf[1], l);
+		msgpack_pack_append_buffer(x, buf, 5);
+	}
+}
+
+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
+
+#undef TAKE8_8
+#undef TAKE8_16
+#undef TAKE8_32
+#undef TAKE8_64
+
+#undef msgpack_pack_real_uint8
+#undef msgpack_pack_real_uint16
+#undef msgpack_pack_real_uint32
+#undef msgpack_pack_real_uint64
+#undef msgpack_pack_real_int8
+#undef msgpack_pack_real_int16
+#undef msgpack_pack_real_int32
+#undef msgpack_pack_real_int64
+