msgpack 0.0.1 → 0.2.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: msgpack
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - FURUHASHI Sadayuki
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-16 00:00:00 +09:00
+date: 2008-11-10 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,16 +43,12 @@ files:
 - 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/ext/pack_inline.h

@@ -1,33 +0,0 @@
-/*
- * MessagePack packing routine for Ruby
- *
- * 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 PACK_INLINE_H__
-#define PACK_INLINE_H__
-
-#include "ruby.h"
-
-typedef VALUE msgpack_pack_context;
-
-static inline void msgpack_pack_append_buffer(VALUE x, const unsigned char* b, unsigned int l)
-{
-	rb_str_buf_cat(x, (const void*)b, l);
-}
-
-#include "msgpack/pack/inline_impl.h"
-
-#endif /* pack_inline.h */
-

data/ext/unpack_context.h

@@ -1,35 +0,0 @@
-/*
- * MessagePack unpacking routine for Ruby
- *
- * 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 UNPACK_CONTEXT_H__
-#define UNPACK_CONTEXT_H__
-
-#include "ruby.h"
-#include <stddef.h>
-#include <stdbool.h>
-
-typedef VALUE msgpack_object;
-
-typedef struct {
-	bool finished;
-} msgpack_unpack_context;
-
-
-#include "msgpack/unpack/inline_context.h"
-
-#endif /* unpack_context.h */
-

data/ext/unpack_inline.c

@@ -1,81 +0,0 @@
-/*
- * MessagePack unpacking routine for Ruby
- *
- * 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.
- */
-#include "unpack_context.h"
-
-static inline VALUE msgpack_unpack_init(msgpack_unpack_context* x)
-{ return Qnil; }
-
-static inline VALUE msgpack_unpack_unsigned_int_8(msgpack_unpack_context* x, uint8_t d)
-{ return INT2FIX(d); }
-
-static inline VALUE msgpack_unpack_unsigned_int_16(msgpack_unpack_context* x, uint16_t d)
-{ return INT2FIX(d); }
-
-static inline VALUE msgpack_unpack_unsigned_int_32(msgpack_unpack_context* x, uint32_t d)
-{ return UINT2NUM(d); }
-
-static inline VALUE msgpack_unpack_unsigned_int_64(msgpack_unpack_context* x, uint64_t d)
-{ return UINT2NUM(d); }  // FIXME
-
-static inline VALUE msgpack_unpack_signed_int_8(msgpack_unpack_context* x, int8_t d)
-{ return INT2FIX((long)d); }
-
-static inline VALUE msgpack_unpack_signed_int_16(msgpack_unpack_context* x, int16_t d)
-{ return INT2FIX((long)d); }
-
-static inline VALUE msgpack_unpack_signed_int_32(msgpack_unpack_context* x, int32_t d)
-{ return INT2NUM((long)d); }
-
-static inline VALUE msgpack_unpack_signed_int_64(msgpack_unpack_context* x, int64_t d)
-{ return INT2NUM(d); }  // FIXME
-
-static inline VALUE msgpack_unpack_float(msgpack_unpack_context* x, float d)
-{ return rb_float_new(d); }
-
-static inline VALUE msgpack_unpack_double(msgpack_unpack_context* x, double d)
-{ return rb_float_new(d); }
-
-static inline VALUE msgpack_unpack_nil(msgpack_unpack_context* x)
-{ return Qnil; }
-
-static inline VALUE msgpack_unpack_true(msgpack_unpack_context* x)
-{ return Qtrue; }
-
-static inline VALUE msgpack_unpack_false(msgpack_unpack_context* x)
-{ return Qfalse; }
-
-static inline VALUE msgpack_unpack_array_start(msgpack_unpack_context* x, unsigned int n)
-{ return rb_ary_new2(n); }
-
-static inline void msgpack_unpack_array_item(msgpack_unpack_context* x, VALUE c, VALUE o)
-{ rb_ary_push(c, o); }
-
-static inline VALUE msgpack_unpack_map_start(msgpack_unpack_context* x, unsigned int n)
-{ return rb_hash_new(); }
-
-static inline void msgpack_unpack_map_item(msgpack_unpack_context* x, VALUE c, VALUE k, VALUE v)
-{ rb_hash_aset(c, k, v); }
-
-static inline VALUE msgpack_unpack_string(msgpack_unpack_context* x, const void* b, size_t l)
-{ return rb_str_new(b, l); }
-
-static inline VALUE msgpack_unpack_raw(msgpack_unpack_context* x, const void* b, size_t l)
-{ return rb_str_new(b, l); }
-
-#include "msgpack/unpack/inline_impl.h"
-

data/msgpack/pack/inline_context.h

@@ -1,2 +0,0 @@
-
-

data/msgpack/unpack/inline_context.h

@@ -1,52 +0,0 @@
-/*
- * 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 */
-

data/msgpack/unpack/inline_impl.h

@@ -1,438 +0,0 @@
-/*
- * 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 */
-