rroonga 5.0.1-x64-mingw32 → 5.0.2-x64-mingw32

data/vendor/local/include/msgpack/unpack_define.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_UNPACK_DEFINE_H__
-#define MSGPACK_UNPACK_DEFINE_H__
+#ifndef MSGPACK_UNPACK_DEFINE_H
+#define MSGPACK_UNPACK_DEFINE_H
 
 #include "msgpack/sysdep.h"
 #include <stdlib.h>
@@ -35,55 +35,57 @@ extern "C" {
 
 
 typedef enum {
-	CS_HEADER            = 0x00,  // nil
-
-	//CS_                = 0x01,
-	//CS_                = 0x02,  // false
-	//CS_                = 0x03,  // true
-
-	CS_BIN_8             = 0x04,
-	CS_BIN_16            = 0x05,
-	CS_BIN_32            = 0x06,
-
-	//CS_EXT_8           = 0x07,
-	//CS_EXT_16          = 0x08,
-	//CS_EXT_32          = 0x09,
-
-	CS_FLOAT             = 0x0a,
-	CS_DOUBLE            = 0x0b,
-	CS_UINT_8            = 0x0c,
-	CS_UINT_16           = 0x0d,
-	CS_UINT_32           = 0x0e,
-	CS_UINT_64           = 0x0f,
-	CS_INT_8             = 0x10,
-	CS_INT_16            = 0x11,
-	CS_INT_32            = 0x12,
-	CS_INT_64            = 0x13,
-
-	//CS_FIXEXT_1        = 0x14,
-	//CS_FIXEXT_2        = 0x15,
-	//CS_FIXEXT_4        = 0x16,
-	//CS_FIXEXT_8        = 0x17,
-	//CS_FIXEXT_16       = 0x18,
-
-	CS_RAW_8             = 0x19, // str8
-	CS_RAW_16            = 0x1a, // str16
-	CS_RAW_32            = 0x1b, // str32
-	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,
+    MSGPACK_CS_HEADER            = 0x00,  // nil
+
+    //MSGPACK_CS_                = 0x01,
+    //MSGPACK_CS_                = 0x02,  // false
+    //MSGPACK_CS_                = 0x03,  // true
+
+    MSGPACK_CS_BIN_8             = 0x04,
+    MSGPACK_CS_BIN_16            = 0x05,
+    MSGPACK_CS_BIN_32            = 0x06,
+
+    MSGPACK_CS_EXT_8             = 0x07,
+    MSGPACK_CS_EXT_16            = 0x08,
+    MSGPACK_CS_EXT_32            = 0x09,
+
+    MSGPACK_CS_FLOAT             = 0x0a,
+    MSGPACK_CS_DOUBLE            = 0x0b,
+    MSGPACK_CS_UINT_8            = 0x0c,
+    MSGPACK_CS_UINT_16           = 0x0d,
+    MSGPACK_CS_UINT_32           = 0x0e,
+    MSGPACK_CS_UINT_64           = 0x0f,
+    MSGPACK_CS_INT_8             = 0x10,
+    MSGPACK_CS_INT_16            = 0x11,
+    MSGPACK_CS_INT_32            = 0x12,
+    MSGPACK_CS_INT_64            = 0x13,
+
+    MSGPACK_CS_FIXEXT_1          = 0x14,
+    MSGPACK_CS_FIXEXT_2          = 0x15,
+    MSGPACK_CS_FIXEXT_4          = 0x16,
+    MSGPACK_CS_FIXEXT_8          = 0x17,
+    MSGPACK_CS_FIXEXT_16         = 0x18,
+
+    MSGPACK_CS_STR_8             = 0x19, // str8
+    MSGPACK_CS_STR_16            = 0x1a, // str16
+    MSGPACK_CS_STR_32            = 0x1b, // str32
+    MSGPACK_CS_ARRAY_16          = 0x1c,
+    MSGPACK_CS_ARRAY_32          = 0x1d,
+    MSGPACK_CS_MAP_16            = 0x1e,
+    MSGPACK_CS_MAP_32            = 0x1f,
+
+    //MSGPACK_ACS_BIG_INT_VALUE,
+    //MSGPACK_ACS_BIG_FLOAT_VALUE,
+    MSGPACK_ACS_STR_VALUE,
+    MSGPACK_ACS_BIN_VALUE,
+    MSGPACK_ACS_EXT_VALUE
 } msgpack_unpack_state;
 
 
 typedef enum {
-	CT_ARRAY_ITEM,
-	CT_MAP_KEY,
-	CT_MAP_VALUE,
+    MSGPACK_CT_ARRAY_ITEM,
+    MSGPACK_CT_MAP_KEY,
+    MSGPACK_CT_MAP_VALUE
 } msgpack_container_type;
 
 

data/vendor/local/include/msgpack/unpack_template.h

@@ -47,128 +47,128 @@
 #endif
 
 msgpack_unpack_struct_decl(_stack) {
-	msgpack_unpack_object obj;
-	size_t count;
-	unsigned int ct;
-	msgpack_unpack_object map_key;
+    msgpack_unpack_object obj;
+    size_t count;
+    unsigned int ct;
+    msgpack_unpack_object map_key;
 };
 
 msgpack_unpack_struct_decl(_context) {
-	msgpack_unpack_user user;
-	unsigned int cs;
-	unsigned int trail;
-	unsigned int top;
-	/*
-	msgpack_unpack_struct(_stack)* stack;
-	unsigned int stack_size;
-	msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE];
-	*/
-	msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE];
+    msgpack_unpack_user user;
+    unsigned int cs;
+    unsigned int trail;
+    unsigned int top;
+    /*
+    msgpack_unpack_struct(_stack)* stack;
+    unsigned int stack_size;
+    msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE];
+    */
+    msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE];
 };
 
 
 msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
 {
-	ctx->cs = CS_HEADER;
-	ctx->trail = 0;
-	ctx->top = 0;
-	/*
-	ctx->stack = ctx->embed_stack;
-	ctx->stack_size = MSGPACK_EMBED_STACK_SIZE;
-	*/
-	ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user);
+    ctx->cs = MSGPACK_CS_HEADER;
+    ctx->trail = 0;
+    ctx->top = 0;
+    /*
+    ctx->stack = ctx->embed_stack;
+    ctx->stack_size = MSGPACK_EMBED_STACK_SIZE;
+    */
+    ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user);
 }
 
 /*
 msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx)
 {
-	if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) {
-		free(ctx->stack);
-	}
+    if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) {
+        free(ctx->stack);
+    }
 }
 */
 
 msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx)
 {
-	return (ctx)->stack[0].obj;
+    return (ctx)->stack[0].obj;
 }
 
 
 msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off)
 {
-	assert(len >= *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;
+    const unsigned char* p = (unsigned char*)data + *off;
+    const unsigned char* const pe = (unsigned char*)data + len;
+    const void* n = NULL;
 
-	unsigned int trail = ctx->trail;
-	unsigned int cs = ctx->cs;
-	unsigned int top = ctx->top;
-	msgpack_unpack_struct(_stack)* stack = ctx->stack;
-	/*
-	unsigned int stack_size = ctx->stack_size;
-	*/
-	msgpack_unpack_user* user = &ctx->user;
+    unsigned int trail = ctx->trail;
+    unsigned int cs = ctx->cs;
+    unsigned int top = ctx->top;
+    msgpack_unpack_struct(_stack)* stack = ctx->stack;
+    /*
+    unsigned int stack_size = ctx->stack_size;
+    */
+    msgpack_unpack_user* user = &ctx->user;
 
-	msgpack_unpack_object obj;
-	msgpack_unpack_struct(_stack)* c = NULL;
+    msgpack_unpack_object obj;
+    msgpack_unpack_struct(_stack)* c = NULL;
 
-	int ret;
+    int ret;
 
 #define push_simple_value(func) \
-	if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \
-	goto _push
+    if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \
+    goto _push
 #define push_fixed_value(func, arg) \
-	if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \
-	goto _push
+    if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \
+    goto _push
 #define push_variable_value(func, base, pos, len) \
-	if(msgpack_unpack_callback(func)(user, \
-		(const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \
-	goto _push
+    if(msgpack_unpack_callback(func)(user, \
+        (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \
+    goto _push
 
 #define again_fixed_trail(_cs, trail_len) \
-	trail = trail_len; \
-	cs = _cs; \
-	goto _fixed_trail_again
+    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
+    trail = trail_len; \
+    if(trail == 0) { goto ifzero; } \
+    cs = _cs; \
+    goto _fixed_trail_again
 
 #define start_container(func, count_, ct_) \
-	if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \
-	if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \
-	if((count_) == 0) { obj = stack[top].obj; goto _push; } \
-	stack[top].ct = ct_; \
-	stack[top].count = count_; \
-	++top; \
-	/*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
-	/*printf("stack push %d\n", top);*/ \
-	/* FIXME \
-	if(top >= stack_size) { \
-		if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \
-			size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \
-			size_t nsize = csize * 2; \
-			msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \
-			if(tmp == NULL) { goto _failed; } \
-			memcpy(tmp, ctx->stack, csize); \
-			ctx->stack = stack = tmp; \
-			ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \
-		} else { \
-			size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \
-			msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \
-			if(tmp == NULL) { goto _failed; } \
-			ctx->stack = stack = tmp; \
-			ctx->stack_size = stack_size = stack_size * 2; \
-		} \
-	} \
-	*/ \
-	goto _header_again
+    if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \
+    if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \
+    if((count_) == 0) { obj = stack[top].obj; goto _push; } \
+    stack[top].ct = ct_; \
+    stack[top].count = count_; \
+    ++top; \
+    /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
+    /*printf("stack push %d\n", top);*/ \
+    /* FIXME \
+    if(top >= stack_size) { \
+        if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \
+            size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \
+            size_t nsize = csize * 2; \
+            msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \
+            if(tmp == NULL) { goto _failed; } \
+            memcpy(tmp, ctx->stack, csize); \
+            ctx->stack = stack = tmp; \
+            ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \
+        } else { \
+            size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \
+            msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \
+            if(tmp == NULL) { goto _failed; } \
+            ctx->stack = stack = tmp; \
+            ctx->stack_size = stack_size = stack_size * 2; \
+        } \
+    } \
+    */ \
+    goto _header_again
 
 #define NEXT_CS(p) \
-	((unsigned int)*p & 0x1f)
+    ((unsigned int)*p & 0x1f)
 
 #ifdef USE_CASE_RANGE
 #define SWITCH_RANGE_BEGIN     switch(*p) {
@@ -182,224 +182,280 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 #define SWITCH_RANGE_END       } }
 #endif
 
-	if(p == pe) { goto _out; }
-	do {
-		switch(cs) {
-		case CS_HEADER:
-			SWITCH_RANGE_BEGIN
-			SWITCH_RANGE(0x00, 0x7f)  // Positive Fixnum
-				push_fixed_value(_uint8, *(uint8_t*)p);
-			SWITCH_RANGE(0xe0, 0xff)  // Negative Fixnum
-				push_fixed_value(_int8, *(int8_t*)p);
-			SWITCH_RANGE(0xc0, 0xdf)  // Variable
-				switch(*p) {
-				case 0xc0:  // nil
-					push_simple_value(_nil);
-				//case 0xc1:  // string
-				//	again_terminal_trail(NEXT_CS(p), p+1);
-				case 0xc2:  // false
-					push_simple_value(_false);
-				case 0xc3:  // true
-					push_simple_value(_true);
-				case 0xc4: // bin 8
-				case 0xc5: // bin 16
-				case 0xc6: // bin 32
-					again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
-				//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:  // raw 8 (str 8)
-				case 0xda:  // raw 16 (str 16)
-				case 0xdb:  // raw 32 (str 32)
-					again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1));
-				case 0xdc:  // array 16
-				case 0xdd:  // array 32
-				case 0xde:  // map 16
-				case 0xdf:  // map 32
-					again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01));
-				default:
-					goto _failed;
-				}
-			SWITCH_RANGE(0xa0, 0xbf)  // FixRaw
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero);
-			SWITCH_RANGE(0x90, 0x9f)  // FixArray
-				start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM);
-			SWITCH_RANGE(0x80, 0x8f)  // FixMap
-				start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY);
-
-			SWITCH_RANGE_DEFAULT
-				goto _failed;
-			SWITCH_RANGE_END
-			// end CS_HEADER
-
-
-		_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: {
-					union { uint32_t i; float f; } mem;
-					mem.i = _msgpack_load32(uint32_t,n);
-					push_fixed_value(_float, mem.f); }
-			case CS_DOUBLE: {
-					union { uint64_t i; double f; } mem;
-					mem.i = _msgpack_load64(uint64_t,n);
+    if(p == pe) { goto _out; }
+    do {
+        switch(cs) {
+        case MSGPACK_CS_HEADER:
+            SWITCH_RANGE_BEGIN
+            SWITCH_RANGE(0x00, 0x7f)  // Positive Fixnum
+                push_fixed_value(_uint8, *(uint8_t*)p);
+            SWITCH_RANGE(0xe0, 0xff)  // Negative Fixnum
+                push_fixed_value(_int8, *(int8_t*)p);
+            SWITCH_RANGE(0xc0, 0xdf)  // Variable
+                switch(*p) {
+                case 0xc0:  // nil
+                    push_simple_value(_nil);
+                //case 0xc1:  // string
+                //  again_terminal_trail(NEXT_CS(p), p+1);
+                case 0xc2:  // false
+                    push_simple_value(_false);
+                case 0xc3:  // true
+                    push_simple_value(_true);
+                case 0xc4: // bin 8
+                case 0xc5: // bin 16
+                case 0xc6: // bin 32
+                    again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
+                case 0xc7: // ext 8
+                case 0xc8: // ext 16
+                case 0xc9: // ext 32
+                    again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03));
+                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:  // fixext 1
+                case 0xd5:  // fixext 2
+                case 0xd6:  // fixext 4
+                case 0xd7:  // fixext 8
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE,
+                        (1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero);
+                case 0xd8:  // fixext 16
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero);
+
+                case 0xd9:  // str 8
+                case 0xda:  // str 16
+                case 0xdb:  // str 32
+                    again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1));
+                case 0xdc:  // array 16
+                case 0xdd:  // array 32
+                case 0xde:  // map 16
+                case 0xdf:  // map 32
+                    again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01));
+                default:
+                    goto _failed;
+                }
+            SWITCH_RANGE(0xa0, 0xbf)  // FixStr
+                again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero);
+            SWITCH_RANGE(0x90, 0x9f)  // FixArray
+                start_container(_array, ((unsigned int)*p) & 0x0f, MSGPACK_CT_ARRAY_ITEM);
+            SWITCH_RANGE(0x80, 0x8f)  // FixMap
+                start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY);
+
+            SWITCH_RANGE_DEFAULT
+                goto _failed;
+            SWITCH_RANGE_END
+            // end MSGPACK_CS_HEADER
+
+
+        _fixed_trail_again:
+            ++p;
+
+        default:
+            if((size_t)(pe - p) < trail) { goto _out; }
+            n = p;  p += trail - 1;
+            switch(cs) {
+            //case MSGPACK_CS_
+            //case MSGPACK_CS_
+            case MSGPACK_CS_FLOAT: {
+                    union { uint32_t i; float f; } mem;
+                    _msgpack_load32(uint32_t, n, &mem.i);
+                    push_fixed_value(_float, mem.f); }
+            case MSGPACK_CS_DOUBLE: {
+                    union { uint64_t i; double f; } mem;
+                    _msgpack_load64(uint64_t, n, &mem.i);
 #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
-					push_fixed_value(_double, mem.f); }
-			case CS_UINT_8:
-				push_fixed_value(_uint8, *(uint8_t*)n);
-			case CS_UINT_16:
-				push_fixed_value(_uint16, _msgpack_load16(uint16_t,n));
-			case CS_UINT_32:
-				push_fixed_value(_uint32, _msgpack_load32(uint32_t,n));
-			case CS_UINT_64:
-				push_fixed_value(_uint64, _msgpack_load64(uint64_t,n));
-
-			case CS_INT_8:
-				push_fixed_value(_int8, *(int8_t*)n);
-			case CS_INT_16:
-				push_fixed_value(_int16, _msgpack_load16(int16_t,n));
-			case CS_INT_32:
-				push_fixed_value(_int32, _msgpack_load32(int32_t,n));
-			case CS_INT_64:
-				push_fixed_value(_int64, _msgpack_load64(int64_t,n));
-
-			//case CS_
-			//case CS_
-			//case CS_BIG_INT_16:
-			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load16(uint16_t,n), _big_int_zero);
-			//case CS_BIG_INT_32:
-			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load32(uint32_t,n), _big_int_zero);
-			//case ACS_BIG_INT_VALUE:
-			//_big_int_zero:
-			//	// FIXME
-			//	push_variable_value(_big_int, data, n, trail);
-
-			//case CS_BIG_FLOAT_16:
-			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load16(uint16_t,n), _big_float_zero);
-			//case CS_BIG_FLOAT_32:
-			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load32(uint32_t,n), _big_float_zero);
-			//case ACS_BIG_FLOAT_VALUE:
-			//_big_float_zero:
-			//	// FIXME
-			//	push_variable_value(_big_float, data, n, trail);
-
-			case CS_BIN_8:
-			case CS_RAW_8:
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, *(uint8_t*)n, _raw_zero);
-			case CS_BIN_16:
-			case CS_RAW_16:
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load16(uint16_t,n), _raw_zero);
-			case CS_BIN_32:
-			case CS_RAW_32:
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load32(uint32_t,n), _raw_zero);
-			case ACS_RAW_VALUE:
-			_raw_zero:
-				push_variable_value(_raw, data, n, trail);
-
-			case CS_ARRAY_16:
-				start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM);
-			case CS_ARRAY_32:
-				/* FIXME security guard */
-				start_container(_array, _msgpack_load32(uint32_t,n), CT_ARRAY_ITEM);
-
-			case CS_MAP_16:
-				start_container(_map, _msgpack_load16(uint16_t,n), CT_MAP_KEY);
-			case CS_MAP_32:
-				/* FIXME security guard */
-				start_container(_map, _msgpack_load32(uint32_t,n), CT_MAP_KEY);
-
-			default:
-				goto _failed;
-			}
-		}
+                    push_fixed_value(_double, mem.f); }
+            case MSGPACK_CS_UINT_8:
+                push_fixed_value(_uint8, *(uint8_t*)n);
+            case MSGPACK_CS_UINT_16:{
+                uint16_t tmp;
+                _msgpack_load16(uint16_t,n,&tmp);
+                push_fixed_value(_uint16, tmp);
+            }
+            case MSGPACK_CS_UINT_32:{
+                uint32_t tmp;
+                _msgpack_load32(uint32_t,n,&tmp);
+                push_fixed_value(_uint32, tmp);
+            }
+            case MSGPACK_CS_UINT_64:{
+                uint64_t tmp;
+                _msgpack_load64(uint64_t,n,&tmp);
+                push_fixed_value(_uint64, tmp);
+            }
+            case MSGPACK_CS_INT_8:
+                push_fixed_value(_int8, *(int8_t*)n);
+            case MSGPACK_CS_INT_16:{
+                int16_t tmp;
+                _msgpack_load16(int16_t,n,&tmp);
+                push_fixed_value(_int16, tmp);
+            }
+            case MSGPACK_CS_INT_32:{
+                int32_t tmp;
+                _msgpack_load32(int32_t,n,&tmp);
+                push_fixed_value(_int32, tmp);
+            }
+            case MSGPACK_CS_INT_64:{
+                int64_t tmp;
+                _msgpack_load64(int64_t,n,&tmp);
+                push_fixed_value(_int64, tmp);
+            }
+            case MSGPACK_CS_FIXEXT_1:
+                again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 1+1, _ext_zero);
+            case MSGPACK_CS_FIXEXT_2:
+                again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 2+1, _ext_zero);
+            case MSGPACK_CS_FIXEXT_4:
+                again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 4+1, _ext_zero);
+            case MSGPACK_CS_FIXEXT_8:
+                again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 8+1, _ext_zero);
+            case MSGPACK_CS_FIXEXT_16:
+                again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero);
+            case MSGPACK_CS_STR_8:
+                again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, *(uint8_t*)n, _str_zero);
+            case MSGPACK_CS_BIN_8:
+                again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero);
+            case MSGPACK_CS_EXT_8:
+                again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero);
+            case MSGPACK_CS_STR_16:{
+                uint16_t tmp;
+                _msgpack_load16(uint16_t,n,&tmp);
+                again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero);
+            }
+            case MSGPACK_CS_BIN_16:{
+                uint16_t tmp;
+                _msgpack_load16(uint16_t,n,&tmp);
+                again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero);
+            }
+            case MSGPACK_CS_EXT_16:{
+                uint16_t tmp;
+                _msgpack_load16(uint16_t,n,&tmp);
+                again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero);
+            }
+            case MSGPACK_CS_STR_32:{
+                uint32_t tmp;
+                _msgpack_load32(uint32_t,n,&tmp);
+                again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero);
+            }
+            case MSGPACK_CS_BIN_32:{
+                uint32_t tmp;
+                _msgpack_load32(uint32_t,n,&tmp);
+                again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero);
+            }
+            case MSGPACK_CS_EXT_32:{
+                uint32_t tmp;
+                _msgpack_load32(uint32_t,n,&tmp);
+                again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero);
+            }
+            case MSGPACK_ACS_STR_VALUE:
+            _str_zero:
+                push_variable_value(_str, data, n, trail);
+            case MSGPACK_ACS_BIN_VALUE:
+            _bin_zero:
+                push_variable_value(_bin, data, n, trail);
+            case MSGPACK_ACS_EXT_VALUE:
+            _ext_zero:
+                push_variable_value(_ext, data, n, trail);
+
+            case MSGPACK_CS_ARRAY_16:{
+                uint16_t tmp;
+                _msgpack_load16(uint16_t,n,&tmp);
+                start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM);
+            }
+            case MSGPACK_CS_ARRAY_32:{
+                /* FIXME security guard */
+                uint32_t tmp;
+                _msgpack_load32(uint32_t,n,&tmp);
+                start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM);
+            }
+
+            case MSGPACK_CS_MAP_16:{
+                uint16_t tmp;
+                _msgpack_load16(uint16_t,n,&tmp);
+                start_container(_map, tmp, MSGPACK_CT_MAP_KEY);
+            }
+            case MSGPACK_CS_MAP_32:{
+                /* FIXME security guard */
+                uint32_t tmp;
+                _msgpack_load32(uint32_t,n,&tmp);
+                start_container(_map, tmp, MSGPACK_CT_MAP_KEY);
+            }
+
+            default:
+                goto _failed;
+            }
+        }
 
 _push:
-	if(top == 0) { goto _finish; }
-	c = &stack[top-1];
-	switch(c->ct) {
-	case CT_ARRAY_ITEM:
-		if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; }
-		if(--c->count == 0) {
-			obj = c->obj;
-			--top;
-			/*printf("stack pop %d\n", top);*/
-			goto _push;
-		}
-		goto _header_again;
-	case CT_MAP_KEY:
-		c->map_key = obj;
-		c->ct = CT_MAP_VALUE;
-		goto _header_again;
-	case CT_MAP_VALUE:
-		if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; }
-		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;
-	}
+    if(top == 0) { goto _finish; }
+    c = &stack[top-1];
+    switch(c->ct) {
+    case MSGPACK_CT_ARRAY_ITEM:
+        if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; }
+        if(--c->count == 0) {
+            obj = c->obj;
+            --top;
+            /*printf("stack pop %d\n", top);*/
+            goto _push;
+        }
+        goto _header_again;
+    case MSGPACK_CT_MAP_KEY:
+        c->map_key = obj;
+        c->ct = MSGPACK_CT_MAP_VALUE;
+        goto _header_again;
+    case MSGPACK_CT_MAP_VALUE:
+        if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; }
+        if(--c->count == 0) {
+            obj = c->obj;
+            --top;
+            /*printf("stack pop %d\n", top);*/
+            goto _push;
+        }
+        c->ct = MSGPACK_CT_MAP_KEY;
+        goto _header_again;
+
+    default:
+        goto _failed;
+    }
 
 _header_again:
-		cs = CS_HEADER;
-		++p;
-	} while(p != pe);
-	goto _out;
+        cs = MSGPACK_CS_HEADER;
+        ++p;
+    } while(p != pe);
+    goto _out;
 
 
 _finish:
-	stack[0].obj = obj;
-	++p;
-	ret = 1;
-	/*printf("-- finish --\n"); */
-	goto _end;
+    stack[0].obj = obj;
+    ++p;
+    ret = 1;
+    /*printf("-- finish --\n"); */
+    goto _end;
 
 _failed:
-	/*printf("** FAILED **\n"); */
-	ret = -1;
-	goto _end;
+    /*printf("** FAILED **\n"); */
+    ret = -1;
+    goto _end;
 
 _out:
-	ret = 0;
-	goto _end;
+    ret = 0;
+    goto _end;
 
 _end:
-	ctx->cs = cs;
-	ctx->trail = trail;
-	ctx->top = top;
-	*off = (size_t)(p - (const unsigned char*)data);
+    ctx->cs = cs;
+    ctx->trail = trail;
+    ctx->top = top;
+    *off = (size_t)(p - (const unsigned char*)data);
 
-	return ret;
+    return ret;
 }
 
 
@@ -418,3 +474,7 @@ _end:
 
 #undef NEXT_CS
 
+#undef SWITCH_RANGE_BEGIN
+#undef SWITCH_RANGE
+#undef SWITCH_RANGE_DEFAULT
+#undef SWITCH_RANGE_END