lang/c/msgpack: added Messagepack, a binary-based efficient data interchange format.

git-svn-id: file:///Users/frsyuki/project/msgpack-git/svn/x@48 5a5092ae-2292-43ba-b2d5-dcab9c1a2731

5 files changed, 803 insertions, 0 deletions

diff --git a/msgpack/pack/inline_context.h b/msgpack/pack/inline_context.h
new file mode 100644
index 0000000..139597f
--- /dev/null
+++ b/msgpack/pack/inline_context.h
@@ -0,0 +1,2 @@
+
+
diff --git a/msgpack/pack/inline_impl.h b/msgpack/pack/inline_impl.h
new file mode 100644
index 0000000..5c4bfed
--- /dev/null
+++ b/msgpack/pack/inline_impl.h
@@ -0,0 +1,287 @@
+/*
+ * MessagePack packing routine
+ *
+ * Copyright (C) 2008 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_INLINE_IMPL_H__
+#define MSGPACK_PACK_INLINE_IMPL_H__
+
+#include <string.h>
+#include <arpa/inet.h>
+
+#ifdef __LITTLE_ENDIAN__
+
+#define STORE_16(d) \
+	((char*)&d)[1], ((char*)&d)[0]
+
+#define STORE_32(d) \
+	((char*)&d)[3], ((char*)&d)[2], ((char*)&d)[1], ((char*)&d)[0]
+
+#define STORE_64(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_32(d) \
+	((char*)&d)[0], ((char*)&d)[1], ((char*)&d)[2], ((char*)&d)[3]
+
+#define STORE_32(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
+
+
+/*
+ * Integer
+ */
+
+// wrapper
+inline void msgpack_pack_int(msgpack_pack_context x, int d)
+{
+	if(d < -32) {
+		if(d < -32768) { // signed 32
+			const unsigned char buf[5] = {0xd2, STORE_32(d)};
+			msgpack_pack_append_buffer(x, buf, 5);
+		} else if(d < -128) { // signed 16
+			const unsigned char buf[3] = {0xd1, STORE_16(d)};
+			msgpack_pack_append_buffer(x, buf, 3);
+		} else { // signed 8
+			const unsigned char buf[2] = {0xd0, (uint8_t)d};
+			msgpack_pack_append_buffer(x, buf, 2);
+		}
+	} else 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);
+		} else {
+			// unsigned 32
+			const unsigned char buf[5] = {0xce, STORE_32(d)};
+			msgpack_pack_append_buffer(x, buf, 5);
+		}
+	}
+}
+
+// wrapper
+inline void msgpack_pack_unsigned_int(msgpack_pack_context 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);
+	} else {
+		// unsigned 32
+		const unsigned char buf[5] = {0xce, STORE_32(d)};
+		msgpack_pack_append_buffer(x, buf, 5);
+	}
+}
+
+inline void msgpack_pack_unsigned_int_8(msgpack_pack_context x, uint8_t d)
+{
+	if(d < 128) {
+		msgpack_pack_append_buffer(x, &d, 1);
+	} else {
+		const unsigned char buf[2] = {0xcc, d};
+		msgpack_pack_append_buffer(x, buf, 2);
+	}
+}
+
+inline void msgpack_pack_unsigned_int_16(msgpack_pack_context x, uint16_t d)
+{
+	const unsigned char buf[3] = {0xcd, STORE_16(d)};
+	msgpack_pack_append_buffer(x, buf, 3);
+}
+
+inline void msgpack_pack_unsigned_int_32(msgpack_pack_context x, uint32_t d)
+{
+	const unsigned char buf[5] = {0xce, STORE_32(d)};
+	msgpack_pack_append_buffer(x, buf, 5);
+}
+
+inline void msgpack_pack_unsigned_int_64(msgpack_pack_context x, uint64_t d)
+{
+	// FIXME
+	const unsigned char buf[9] = {0xcf, STORE_64(d)};
+	msgpack_pack_append_buffer(x, buf, 9);
+}
+
+inline void msgpack_pack_signed_int_8(msgpack_pack_context x, int8_t d)
+{
+	if(d > 0) {
+		msgpack_pack_append_buffer(x, (uint8_t*)&d, 1);
+	} else if(d >= -32) {
+		msgpack_pack_append_buffer(x, (uint8_t*)&d, 1);
+	} else {
+		const unsigned char buf[2] = {0xd0, d};
+		msgpack_pack_append_buffer(x, buf, 2);
+	}
+}
+
+inline void msgpack_pack_signed_int_16(msgpack_pack_context x, int16_t d)
+{
+	const unsigned char buf[3] = {0xd1, STORE_16(d)};
+	msgpack_pack_append_buffer(x, buf, 3);
+}
+
+inline void msgpack_pack_signed_int_32(msgpack_pack_context x, int32_t d)
+{
+	const unsigned char buf[5] = {0xd2, STORE_32(d)};
+	msgpack_pack_append_buffer(x, buf, 5);
+}
+
+inline void msgpack_pack_signed_int_64(msgpack_pack_context x, int64_t d)
+{
+	// FIXME
+	const unsigned char buf[9] = {0xd3, STORE_64(d)};
+	msgpack_pack_append_buffer(x, buf, 9);
+}
+
+
+/*
+ * Float
+ */
+
+inline void msgpack_pack_float(msgpack_pack_context x, float d)
+{
+	uint32_t n = *((uint32_t*)&d);  // FIXME
+	const unsigned char buf[5] = {0xca, STORE_32(n)};
+	msgpack_pack_append_buffer(x, buf, 5);
+}
+
+inline void msgpack_pack_double(msgpack_pack_context x, double d)
+{
+	uint64_t n = *((uint64_t*)&d);  // FIXME
+	const unsigned char buf[9] = {0xcb, STORE_64(n)};
+	msgpack_pack_append_buffer(x, buf, 9);
+}
+
+
+/*
+ * Nil
+ */
+
+inline void msgpack_pack_nil(msgpack_pack_context x)
+{
+	static const unsigned char d = 0xc0;
+	msgpack_pack_append_buffer(x, &d, 1);
+}
+
+
+/*
+ * Boolean
+ */
+inline void msgpack_pack_true(msgpack_pack_context x)
+{
+	static const unsigned char d = 0xc3;
+	msgpack_pack_append_buffer(x, &d, 1);
+}
+
+inline void msgpack_pack_false(msgpack_pack_context x)
+{
+	static const unsigned char d = 0xc2;
+	msgpack_pack_append_buffer(x, &d, 1);
+}
+
+
+/*
+ * Array
+ */
+
+inline void msgpack_pack_array(msgpack_pack_context 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)};
+		msgpack_pack_append_buffer(x, buf, 3);
+	} else {
+		uint32_t d = (uint32_t)n;
+		unsigned char buf[5] = {0xdd, STORE_32(d)};
+		msgpack_pack_append_buffer(x, buf, 5);
+	}
+}
+
+
+/*
+ * Map
+ */
+
+inline void msgpack_pack_map(msgpack_pack_context 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)};
+		msgpack_pack_append_buffer(x, buf, 3);
+	} else {
+		uint32_t d = (uint32_t)n;
+		unsigned char buf[5] = {0xdf, STORE_32(d)};
+		msgpack_pack_append_buffer(x, buf, 5);
+	}
+}
+
+
+/*
+ * String
+ */
+
+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)
+{
+	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)};
+		msgpack_pack_append_buffer(x, buf, 3);
+	} else {
+		uint32_t d = (uint32_t)l;
+		unsigned char buf[5] = {0xdb, STORE_32(d)};
+		msgpack_pack_append_buffer(x, buf, 5);
+	}
+	msgpack_pack_append_buffer(x, b, l);
+}
+
+
+#endif /* msgpack/pack/inline_impl.h */
+
diff --git a/msgpack/unpack/callback.h b/msgpack/unpack/callback.h
new file mode 100644
index 0000000..b058a15
--- /dev/null
+++ b/msgpack/unpack/callback.h
@@ -0,0 +1,24 @@
+
+msgpack_object msgpack_unpack_init(msgpack_unpack_context* x);
+msgpack_object msgpack_unpack_unsigned_int_8(msgpack_unpack_context* x, uint8_t d);
+msgpack_object msgpack_unpack_unsigned_int_16(msgpack_unpack_context* x, uint16_t d);
+msgpack_object msgpack_unpack_unsigned_int_32(msgpack_unpack_context* x, uint32_t d);
+msgpack_object msgpack_unpack_unsigned_int_64(msgpack_unpack_context* x, uint64_t d);
+msgpack_object msgpack_unpack_signed_int_8(msgpack_unpack_context* x, int8_t d);
+msgpack_object msgpack_unpack_signed_int_16(msgpack_unpack_context* x, int16_t d);
+msgpack_object msgpack_unpack_signed_int_32(msgpack_unpack_context* x, int32_t d);
+msgpack_object msgpack_unpack_signed_int_64(msgpack_unpack_context* x, int64_t d);
+msgpack_object msgpack_unpack_float(msgpack_unpack_context* x, float d);
+msgpack_object msgpack_unpack_double(msgpack_unpack_context* x, double d);
+msgpack_object msgpack_unpack_big_int(msgpack_unpack_context* x, const void* b, unsigned int l);
+msgpack_object msgpack_unpack_big_float(msgpack_unpack_context* x, const void* b, unsigned int l);
+msgpack_object msgpack_unpack_nil(msgpack_unpack_context* x);
+msgpack_object msgpack_unpack_true(msgpack_unpack_context* x);
+msgpack_object msgpack_unpack_false(msgpack_unpack_context* x);
+msgpack_object msgpack_unpack_array_start(msgpack_unpack_context* x, unsigned int n);
+          void msgpack_unpack_array_item(msgpack_unpack_context* x, msgpack_object c, msgpack_object o);
+msgpack_object msgpack_unpack_map_start(msgpack_unpack_context* x, unsigned int n);
+          void msgpack_unpack_map_item(msgpack_unpack_context* x, msgpack_object c, msgpack_object k, msgpack_object v);
+msgpack_object msgpack_unpack_string(msgpack_unpack_context* x, const void* b, size_t l);
+msgpack_object msgpack_unpack_raw(msgpack_unpack_context* x, const void* b, size_t l);
+
diff --git a/msgpack/unpack/inline_context.h b/msgpack/unpack/inline_context.h
new file mode 100644
index 0000000..aecd566
--- /dev/null
+++ b/msgpack/unpack/inline_context.h
@@ -0,0 +1,52 @@
+/*
+ * MessagePack unpacking routine
+ *
+ * Copyright (C) 2008 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_UNPACK_INLINE_CONTEXT_H__
+#define MSGPACK_UNPACK_INLINE_CONTEXT_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef MSG_STACK_SIZE
+#define MSG_STACK_SIZE 16
+#endif
+
+typedef struct {
+	msgpack_object obj;
+	size_t count;
+	unsigned int ct;
+	union {
+		const unsigned char* terminal_trail_start;
+		msgpack_object map_key;
+	} tmp;
+} msgpack_unpacker_stack;
+
+typedef struct {
+	msgpack_unpack_context user;  // must be first
+	unsigned int cs;
+	size_t trail;
+	unsigned int top;
+	msgpack_unpacker_stack stack[MSG_STACK_SIZE];
+} msgpack_unpacker;
+
+void msgpack_unpacker_init(msgpack_unpacker* ctx);
+int msgpack_unpacker_execute(msgpack_unpacker* ctx, const char* data, size_t len, size_t* off);
+#define msgpack_unpacker_data(unpacker) (unpacker)->stack[0].obj
+
+
+#endif /* msgpack/unpack/inline_context.h */
+
diff --git a/msgpack/unpack/inline_impl.h b/msgpack/unpack/inline_impl.h
new file mode 100644
index 0000000..ec7f0fc
--- /dev/null
+++ b/msgpack/unpack/inline_impl.h
@@ -0,0 +1,438 @@
+/*
+ * MessagePack unpacking routine
+ *
+ * Copyright (C) 2008 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_UNPACK_INLINE_IMPL_H__
+#define MSGPACK_UNPACK_INLINE_IMPL_H__
+
+#include <string.h>
+#include <assert.h>
+#include <arpa/inet.h>
+/*#include <stdio.h>*/
+
+// Positive FixNum  0xxxxxxx  0x00 - 0x7f
+// Negative FixNum  111xxxxx  0xe0 - 0xff
+// Variable         110xxxxx  0xc0 - 0xdf
+//    nil              00000  0xc0
+//    string           00001  0xc1
+//    false            00010  0xc2
+//    true             00011  0xc3
+//    (?)              00100  0xc4
+//    (?)              00101  0xc5
+//    (?)              00110  0xc6
+//    (?)              00111  0xc7
+//    (?)              01000  0xc8
+//    (?)              01001  0xc9
+//    float            01010  0xca
+//    double           01011  0xcb
+//    uint  8          01100  0xcc
+//    uint 16          01101  0xcd
+//    uint 32          01110  0xce
+//    uint 64          01111  0xcf
+//    int  8           10000  0xd0
+//    int 16           10001  0xd1
+//    int 32           10010  0xd2
+//    int 64           10011  0xd3
+//    (?)              10100  0xd4
+//    (?)              10101  0xd5
+//    (big float 16)   10110  0xd6
+//    (big float 32)   10111  0xd7
+//    (big integer 16) 11000  0xd8
+//    (big integer 32) 11001  0xd9
+//    raw 16           11010  0xda
+//    raw 32           11011  0xdb
+//    array 16         11100  0xdc
+//    array 32         11101  0xdd
+//    map 16           11110  0xde
+//    map 32           11111  0xdf
+// FixRaw           101xxxxx  0xa0 - 0xbf
+// FixArray         1001xxxx  0x90 - 0x9f
+// FixMap           1000xxxx  0x80 - 0x8f
+
+
+#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
+
+static inline uint64_t ntohll(uint64_t x) {
+#ifdef __LITTLE_ENDIAN__  // FIXME
+#if defined(__bswap_64)
+	return __bswap_64(x);
+#elif defined(__DARWIN_OSSwapInt64)
+	return __DARWIN_OSSwapInt64(x);
+#else
+	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
+	return x;
+#endif
+}
+
+typedef enum {
+	CS_HEADER            = 0x00,  // nil
+
+	CS_STRING            = 0x01,
+	//CS_                = 0x02,  // false
+	//CS_                = 0x03,  // true
+
+	//CS_                = 0x04,
+	//CS_                = 0x05,
+	//CS_                = 0x06,
+	//CS_                = 0x07,
+
+	//CS_                = 0x08,
+	//CS_                = 0x09,
+	CS_FLOAT             = 0x0a,
+	CS_DOUBLE            = 0x0b,
+	CS_UNSIGNED_INT_8    = 0x0c,
+	CS_UNSIGNED_INT_16   = 0x0d,
+	CS_UNSIGNED_INT_32   = 0x0e,
+	CS_UNSIGNED_INT_64   = 0x0f,
+	CS_SIGNED_INT_8      = 0x10,
+	CS_SIGNED_INT_16     = 0x11,
+	CS_SIGNED_INT_32     = 0x12,
+	CS_SIGNED_INT_64     = 0x13,
+
+	//CS_                = 0x14,
+	//CS_                = 0x15,
+	//CS_BIG_INT_16        = 0x16,
+	//CS_BIG_INT_32        = 0x17,
+	//CS_BIG_FLOAT_16      = 0x18,
+	//CS_BIG_FLOAT_32      = 0x19,
+	CS_RAW_16            = 0x1a,
+	CS_RAW_32            = 0x1b,
+	CS_ARRAY_16          = 0x1c,
+	CS_ARRAY_32          = 0x1d,
+	CS_MAP_16            = 0x1e,
+	CS_MAP_32            = 0x1f,
+
+	//ACS_BIG_INT_VALUE,
+	//ACS_BIG_FLOAT_VALUE,
+	ACS_RAW_VALUE,
+} current_state_t;
+
+
+typedef enum {
+	CT_ARRAY_ITEM,
+	CT_MAP_KEY,
+	CT_MAP_VALUE,
+} container_type_t;
+
+
+void msgpack_unpacker_init(msgpack_unpacker* ctx)
+{
+	memset(ctx, 0, sizeof(msgpack_unpacker));  // FIXME init ctx->user?
+	ctx->cs = CS_HEADER;
+	ctx->trail = 0;
+	ctx->top = 0;
+	ctx->stack[0].obj = msgpack_unpack_init(&ctx->user);
+}
+
+int msgpack_unpacker_execute(msgpack_unpacker* ctx, const char* data, size_t len, size_t* off)
+{
+	assert(len >= *off);
+
+	const unsigned char* p = (unsigned char*)data + *off;
+	const unsigned char* const pe = (unsigned char*)data + len;
+	const void* n = NULL;
+
+	size_t trail = ctx->trail;
+	unsigned int cs = ctx->cs;
+	unsigned int top = ctx->top;
+	msgpack_unpacker_stack* stack = ctx->stack;
+	msgpack_unpack_context* user = &ctx->user;
+
+	msgpack_object obj;
+
+	int ret;
+
+#define push_simple_value(func) \
+	obj = func(user); \
+	/*printf("obj %d\n",obj);*/ \
+	goto _push
+#define push_fixed_value(func, arg) \
+	obj = func(user, arg); \
+	/*printf("obj %d\n",obj);*/ \
+	goto _push
+#define push_variable_value(func, arg, arglen) \
+	obj = func(user, arg, arglen); \
+	/*printf("obj %d\n",obj);*/ \
+	goto _push
+
+#define again_terminal_trail(_cs, from) \
+	cs = _cs; \
+	stack[top].tmp.terminal_trail_start = from; \
+	goto _terminal_trail_again
+#define again_fixed_trail(_cs, trail_len) \
+	trail = trail_len; \
+	cs = _cs; \
+	goto _fixed_trail_again
+#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \
+	trail = trail_len; \
+	if(trail == 0) { goto ifzero; } \
+	cs = _cs; \
+	goto _fixed_trail_again
+
+#define start_container(func, count_, ct_) \
+	stack[top].obj = func(user, count_); \
+	if((count_) == 0) { obj = stack[top].obj; goto _push; } \
+	if(top >= MSG_STACK_SIZE) { goto _failed; } \
+	stack[top].ct = ct_; \
+	stack[top].count = count_; \
+	/*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
+	/*printf("stack push %d\n", top);*/ \
+	++top; \
+	goto _header_again
+
+#define NEXT_CS(p) \
+	((unsigned int)*p & 0x1f)
+
+#define PTR_CAST_8(ptr)   (*(uint8_t*)ptr)
+#define PTR_CAST_16(ptr)  ntohs(*(uint16_t*)ptr)
+#define PTR_CAST_32(ptr)  ntohl(*(uint32_t*)ptr)
+#define PTR_CAST_64(ptr)  ntohll(*(uint64_t*)ptr)
+
+	if(p == pe) { goto _out; }
+	do {
+		switch(cs) {
+		case CS_HEADER:
+			switch(*p) {
+			case 0x00 ... 0x7f:  // Positive Fixnum
+				push_fixed_value(msgpack_unpack_unsigned_int_8, *(uint8_t*)p);
+			case 0xe0 ... 0xff:  // Negative Fixnum
+				push_fixed_value(msgpack_unpack_signed_int_8, *(int8_t*)p);
+			case 0xc0 ... 0xdf:  // Variable
+				switch(*p) {
+				case 0xc0:  // nil
+					push_simple_value(msgpack_unpack_nil);
+				case 0xc1:  // string
+					again_terminal_trail(NEXT_CS(p), p+1);
+				case 0xc2:  // false
+					push_simple_value(msgpack_unpack_false);
+				case 0xc3:  // true
+					push_simple_value(msgpack_unpack_true);
+				//case 0xc4:
+				//case 0xc5:
+				//case 0xc6:
+				//case 0xc7:
+				//case 0xc8:
+				//case 0xc9:
+				case 0xca:  // float
+				case 0xcb:  // double
+				case 0xcc:  // unsigned int  8
+				case 0xcd:  // unsigned int 16
+				case 0xce:  // unsigned int 32
+				case 0xcf:  // unsigned int 64
+				case 0xd0:  // signed int  8
+				case 0xd1:  // signed int 16
+				case 0xd2:  // signed int 32
+				case 0xd3:  // signed int 64
+					again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
+				//case 0xd4:
+				//case 0xd5:
+				//case 0xd6:  // big integer 16
+				//case 0xd7:  // big integer 32
+				//case 0xd8:  // big float 16
+				//case 0xd9:  // big float 32
+				case 0xda:  // raw 16
+				case 0xdb:  // raw 32
+				case 0xdc:  // array 16
+				case 0xdd:  // array 32
+				case 0xde:  // map 16
+				case 0xdf:  // map 32
+					again_fixed_trail(NEXT_CS(p), 2 << (((unsigned int)*p) & 0x01));
+				default:
+					goto _failed;
+				}
+			case 0xa0 ... 0xbf:  // FixRaw
+				again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero);
+			case 0x90 ... 0x9f:  // FixArray
+				start_container(msgpack_unpack_array_start, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM);
+			case 0x80 ... 0x8f:  // FixMap
+				start_container(msgpack_unpack_map_start, ((unsigned int)*p) & 0x0f, CT_MAP_KEY);
+
+			default:
+				goto _failed;
+			}
+			// end CS_HEADER
+
+
+		_terminal_trail_again:
+			++p;
+
+		case CS_STRING:
+			if(*p == 0) {
+				const unsigned char* start = stack[top].tmp.terminal_trail_start;
+				obj = msgpack_unpack_string(user, start, p-start);
+				goto _push;
+			}
+			goto _terminal_trail_again;
+
+
+		_fixed_trail_again:
+			++p;
+
+		default:
+			if((size_t)(pe - p) < trail) { goto _out; }
+			n = p;  p += trail - 1;
+			switch(cs) {
+			//case CS_
+			//case CS_
+			case CS_FLOAT: {
+					uint32_t x = PTR_CAST_32(n);  // FIXME
+					push_fixed_value(msgpack_unpack_float, *((float*)&x)); }
+			case CS_DOUBLE: {
+					uint64_t x = PTR_CAST_64(n);  // FIXME
+					push_fixed_value(msgpack_unpack_double, *((double*)&x)); }
+			case CS_UNSIGNED_INT_8:
+				push_fixed_value(msgpack_unpack_unsigned_int_8, (uint8_t)PTR_CAST_8(n));
+			case CS_UNSIGNED_INT_16:
+				push_fixed_value(msgpack_unpack_unsigned_int_16, (uint16_t)PTR_CAST_16(n));
+			case CS_UNSIGNED_INT_32:
+				push_fixed_value(msgpack_unpack_unsigned_int_32, (uint32_t)PTR_CAST_32(n));
+			case CS_UNSIGNED_INT_64:
+				push_fixed_value(msgpack_unpack_unsigned_int_64, (uint64_t)PTR_CAST_64(n));
+
+			case CS_SIGNED_INT_8:
+				push_fixed_value(msgpack_unpack_signed_int_8, (int8_t)PTR_CAST_8(n));
+			case CS_SIGNED_INT_16:
+				push_fixed_value(msgpack_unpack_signed_int_16, (int16_t)PTR_CAST_16(n));
+			case CS_SIGNED_INT_32:
+				push_fixed_value(msgpack_unpack_signed_int_32, (int32_t)PTR_CAST_32(n));
+			case CS_SIGNED_INT_64:
+				push_fixed_value(msgpack_unpack_signed_int_64, (int64_t)PTR_CAST_64(n));
+
+			//case CS_
+			//case CS_
+			//case CS_BIG_INT_16:
+			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, (uint16_t)PTR_CAST_16(n), _big_int_zero);
+			//case CS_BIG_INT_32:
+			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, (uint32_t)PTR_CAST_32(n), _big_int_zero);
+			//case ACS_BIG_INT_VALUE:
+			//_big_int_zero:
+			//	// FIXME
+			//	push_variable_value(msgpack_unpack_big_int, n, trail);
+
+			//case CS_BIG_FLOAT_16:
+			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, (uint16_t)PTR_CAST_16(n), _big_float_zero);
+			//case CS_BIG_FLOAT_32:
+			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, (uint32_t)PTR_CAST_32(n), _big_float_zero);
+			//case ACS_BIG_FLOAT_VALUE:
+			//_big_float_zero:
+			//	// FIXME
+			//	push_variable_value(msgpack_unpack_big_float, n, trail);
+
+			case CS_RAW_16:
+				again_fixed_trail_if_zero(ACS_RAW_VALUE, (uint16_t)PTR_CAST_16(n), _raw_zero);
+			case CS_RAW_32:
+				again_fixed_trail_if_zero(ACS_RAW_VALUE, (uint32_t)PTR_CAST_32(n), _raw_zero);
+			case ACS_RAW_VALUE:
+			_raw_zero:
+				push_variable_value(msgpack_unpack_raw, n, trail);
+
+			case CS_ARRAY_16:
+				start_container(msgpack_unpack_array_start, (uint16_t)PTR_CAST_16(n), CT_ARRAY_ITEM);
+			case CS_ARRAY_32:
+				start_container(msgpack_unpack_array_start, (uint32_t)PTR_CAST_32(n), CT_ARRAY_ITEM);
+
+			case CS_MAP_16:
+				start_container(msgpack_unpack_map_start, (uint16_t)PTR_CAST_16(n), CT_MAP_KEY);
+			case CS_MAP_32:
+				start_container(msgpack_unpack_map_start, (uint32_t)PTR_CAST_32(n), CT_MAP_KEY);
+
+			default:
+				goto _failed;
+			}
+		}
+
+_push:
+	if(top == 0) { goto _finish; }
+	msgpack_unpacker_stack* c = &stack[top-1];
+	switch(c->ct) {
+	case CT_ARRAY_ITEM:
+		msgpack_unpack_array_item(user, c->obj, obj);
+		if(--c->count == 0) {
+			obj = c->obj;
+			--top;
+			/*printf("stack pop %d\n", top);*/
+			goto _push;
+		}
+		goto _header_again;
+	case CT_MAP_KEY:
+		c->tmp.map_key = obj;
+		c->ct = CT_MAP_VALUE;
+		goto _header_again;
+	case CT_MAP_VALUE:
+		msgpack_unpack_map_item(user, c->obj, c->tmp.map_key, obj);
+		if(--c->count == 0) {
+			obj = c->obj;
+			--top;
+			/*printf("stack pop %d\n", top);*/
+			goto _push;
+		}
+		c->ct = CT_MAP_KEY;
+		goto _header_again;
+
+	default:
+		goto _failed;
+	}
+
+_header_again:
+		cs = CS_HEADER;
+		++p;
+	} while(p != pe);
+	goto _out;
+
+
+_finish:
+	stack[0].obj = obj;
+	++p;
+	ret = 1;
+	/*printf("-- finish --\n"); */
+	goto _end;
+
+_failed:
+	/*printf("** FAILED **\n"); */
+	ret = -1;
+	goto _end;
+
+_out:
+	ret = 0;
+	goto _end;
+
+_end:
+	ctx->cs = cs;
+	ctx->trail = trail;
+	ctx->top = top;
+	*off = p - (const unsigned char*)data;
+
+	return ret;
+}
+
+
+#endif /* msgpack/unpack/inline_impl.h */
+