/src/fluent-bit/lib/msgpack-c/include/msgpack/unpack_template.h

Source
/*
 * MessagePack unpacking routine template
 *
 * Copyright (C) 2008-2010 FURUHASHI Sadayuki
 *
 *    Distributed under the Boost Software License, Version 1.0.
 *    (See accompanying file LICENSE_1_0.txt or copy at
 *    http://www.boost.org/LICENSE_1_0.txt)
 */

#ifndef msgpack_unpack_func
#error msgpack_unpack_func template is not defined
#endif

#ifndef msgpack_unpack_callback
#error msgpack_unpack_callback template is not defined
#endif

#ifndef msgpack_unpack_struct
#error msgpack_unpack_struct template is not defined
#endif

#ifndef msgpack_unpack_struct_decl
#define msgpack_unpack_struct_decl(name) msgpack_unpack_struct(name)
#endif

#ifndef msgpack_unpack_object
#error msgpack_unpack_object type is not defined
#endif

#ifndef msgpack_unpack_user
#error msgpack_unpack_user type is not defined
#endif

#ifndef USE_CASE_RANGE
#if !defined(_MSC_VER)
#define USE_CASE_RANGE
#endif
#endif

#if defined(_KERNEL_MODE)
#undef  assert
#define assert NT_ASSERT
#endif

msgpack_unpack_struct_decl(_stack) {
    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_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
{
    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);
    }
}
*/

msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx)
{
    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);
    {
        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;

        msgpack_unpack_object obj;
        msgpack_unpack_struct(_stack)* c = NULL;

        int ret;

#define push_simple_value(func) \
        ret = msgpack_unpack_callback(func)(user, &obj); \
        if(ret < 0) { goto _failed; } \
        goto _push
#define push_fixed_value(func, arg) \
        ret = msgpack_unpack_callback(func)(user, arg, &obj); \
        if(ret < 0) { goto _failed; } \
        goto _push
#define push_variable_value(func, base, pos, len) \
        ret = msgpack_unpack_callback(func)(user, \
            (const char*)base, (const char*)pos, len, &obj); \
        if(ret < 0) { goto _failed; } \
        goto _push

#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_) \
        if(top >= MSGPACK_EMBED_STACK_SIZE) { \
            ret = MSGPACK_UNPACK_NOMEM_ERROR; \
            goto _failed; \
        } /* FIXME */ \
        ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \
        if(ret < 0) { goto _failed; } \
        if((count_) == 0) { obj = stack[top].obj; goto _push; } \
        stack[top].ct = ct_; \
        stack[top].count = count_; \
        ++top; \
        goto _header_again

#define NEXT_CS(p) \
        ((unsigned int)*p & 0x1f)

#ifdef USE_CASE_RANGE
#define SWITCH_RANGE_BEGIN     switch(*p) {
#define SWITCH_RANGE(FROM, TO) case FROM ... TO:
#define SWITCH_RANGE_DEFAULT   default:
#define SWITCH_RANGE_END       }
#else
#define SWITCH_RANGE_BEGIN     { if(0) {
#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) {
#define SWITCH_RANGE_DEFAULT   } else {
#define SWITCH_RANGE_END       } }
#endif

        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:
                        ret = MSGPACK_UNPACK_PARSE_ERROR;
                        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
                    ret = MSGPACK_UNPACK_PARSE_ERROR;
                    goto _failed;
                SWITCH_RANGE_END
                // end MSGPACK_CS_HEADER


            _fixed_trail_again:
                ++p;
                // fallthrough

            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(TARGET_OS_IPHONE)
                    // ok
#elif 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 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:
                    ret = MSGPACK_UNPACK_PARSE_ERROR;
                    goto _failed;
                }
            }

    _push:
        if(top == 0) { goto _finish; }
        c = &stack[top-1];
        switch(c->ct) {
        case MSGPACK_CT_ARRAY_ITEM:
            ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \
            if(ret < 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:
            ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \
            if(ret < 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:
            ret = MSGPACK_UNPACK_PARSE_ERROR;
            goto _failed;
        }

    _header_again:
            cs = MSGPACK_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"); */
        goto _end;

    _out:
        ret = 0;
        goto _end;

    _end:
        ctx->cs = cs;
        ctx->trail = trail;
        ctx->top = top;
        *off = (size_t)(p - (const unsigned char*)data);

        return ret;
    }
}

#undef msgpack_unpack_func
#undef msgpack_unpack_callback
#undef msgpack_unpack_struct
#undef msgpack_unpack_object
#undef msgpack_unpack_user

#undef push_simple_value
#undef push_fixed_value
#undef push_variable_value
#undef again_fixed_trail
#undef again_fixed_trail_if_zero
#undef start_container

#undef NEXT_CS

#undef SWITCH_RANGE_BEGIN
#undef SWITCH_RANGE
#undef SWITCH_RANGE_DEFAULT
#undef SWITCH_RANGE_END

Coverage Report

Created: 2026-05-16 07:29

Line	Count	Source
1		/*
2		* MessagePack unpacking routine template
3		*
4		* Copyright (C) 2008-2010 FURUHASHI Sadayuki
5		*
6		* Distributed under the Boost Software License, Version 1.0.
7		* (See accompanying file LICENSE_1_0.txt or copy at
8		* http://www.boost.org/LICENSE_1_0.txt)
9		*/
10
11		#ifndef msgpack_unpack_func
12		#error msgpack_unpack_func template is not defined
13		#endif
14
15		#ifndef msgpack_unpack_callback
16		#error msgpack_unpack_callback template is not defined
17		#endif
18
19		#ifndef msgpack_unpack_struct
20		#error msgpack_unpack_struct template is not defined
21		#endif
22
23		#ifndef msgpack_unpack_struct_decl
24		#define msgpack_unpack_struct_decl(name) msgpack_unpack_struct(name)
25		#endif
26
27		#ifndef msgpack_unpack_object
28		#error msgpack_unpack_object type is not defined
29		#endif
30
31		#ifndef msgpack_unpack_user
32		#error msgpack_unpack_user type is not defined
33		#endif
34
35		#ifndef USE_CASE_RANGE
36		#if !defined(_MSC_VER)
37		#define USE_CASE_RANGE
38		#endif
39		#endif
40
41		#if defined(_KERNEL_MODE)
42		#undef assert
43		#define assert NT_ASSERT
44		#endif
45
46		msgpack_unpack_struct_decl(_stack) {
47		msgpack_unpack_object obj;
48		size_t count;
49		unsigned int ct;
50		msgpack_unpack_object map_key;
51		};
52
53		msgpack_unpack_struct_decl(_context) {
54		msgpack_unpack_user user;
55		unsigned int cs;
56		unsigned int trail;
57		unsigned int top;
58		/*
59		msgpack_unpack_struct(_stack)* stack;
60		unsigned int stack_size;
61		msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE];
62		*/
63		msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE];
64		};
65
66
67		msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
68	606k	{
69	606k	ctx->cs = MSGPACK_CS_HEADER;
70	606k	ctx->trail = 0;
71	606k	ctx->top = 0;
72		/*
73		ctx->stack = ctx->embed_stack;
74		ctx->stack_size = MSGPACK_EMBED_STACK_SIZE;
75		*/
76	606k	ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user);
77	606k	}
78
79		/*
80		msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx)
81		{
82		if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) {
83		free(ctx->stack);
84		}
85		}
86		*/
87
88		msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx)
89	602k	{
90	602k	return (ctx)->stack[0].obj;
91	602k	}
92
93
94		msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off)
95	606k	{
96	606k	assert(len >= *off);
97	606k	{
98	606k	const unsigned char* p = (unsigned char)data + off;
99	606k	const unsigned char* const pe = (unsigned char*)data + len;
100	606k	const void* n = NULL;
101
102	606k	unsigned int trail = ctx->trail;
103	606k	unsigned int cs = ctx->cs;
104	606k	unsigned int top = ctx->top;
105	606k	msgpack_unpack_struct(_stack)* stack = ctx->stack;
106		/*
107		unsigned int stack_size = ctx->stack_size;
108		*/
109	606k	msgpack_unpack_user* user = &ctx->user;
110
111	606k	msgpack_unpack_object obj;
112	606k	msgpack_unpack_struct(_stack)* c = NULL;
113
114	606k	int ret;
115
116	606k	#define push_simple_value(func) \
117	606k	ret = msgpack_unpack_callback(func)(user, &obj); \
118	485k	if(ret < 0) { goto _failed; } \
119	485k	goto _push
120	606k	#define push_fixed_value(func, arg) \
121	5.64M	ret = msgpack_unpack_callback(func)(user, arg, &obj); \
122	5.64M	if(ret < 0) { goto _failed; } \
123	5.64M	goto _push
124	606k	#define push_variable_value(func, base, pos, len) \
125	5.89M	ret = msgpack_unpack_callback(func)(user, \
126	5.89M	(const char)base, (const char)pos, len, &obj); \
127	5.89M	if(ret < 0) { goto _failed; } \
128	5.89M	goto _push
129
130	606k	#define again_fixed_trail(_cs, trail_len) \
131	2.51M	trail = trail_len; \
132	2.51M	cs = _cs; \
133	2.51M	goto _fixed_trail_again
134	606k	#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \
135	5.89M	trail = trail_len; \
136	5.89M	if(trail == 0) { goto ifzero; } \
137	5.89M	cs = _cs; \
138	5.04M	goto _fixed_trail_again
139
140	606k	#define start_container(func, count_, ct_) \
141	980k	if(top >= MSGPACK_EMBED_STACK_SIZE) { \
142	2.56k	ret = MSGPACK_UNPACK_NOMEM_ERROR; \
143	2.56k	goto _failed; \
144	2.56k	} /* FIXME */ \
145	980k	ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \
146	978k	if(ret < 0) { goto _failed; } \
147	978k	if((count_) == 0) { obj = stack[top].obj; goto _push; } \
148	977k	stack[top].ct = ct_; \
149	841k	stack[top].count = count_; \
150	841k	++top; \
151	841k	goto _header_again
152
153	606k	#define NEXT_CS(p) \
154	606k	((unsigned int)*p & 0x1f)
155
156	606k	#ifdef USE_CASE_RANGE
157	26.0M	#define SWITCH_RANGE_BEGIN switch(*p) {
158	13.0M	#define SWITCH_RANGE(FROM, TO) case FROM ... TO:
159	606k	#define SWITCH_RANGE_DEFAULT default:
160	13.0M	#define SWITCH_RANGE_END }
161		#else
162		#define SWITCH_RANGE_BEGIN { if(0) {
163		#define SWITCH_RANGE(FROM, TO) } else if(FROM <= p && p <= TO) {
164		#define SWITCH_RANGE_DEFAULT } else {
165		#define SWITCH_RANGE_END } }
166		#endif
167
168	606k	if(p == pe) { goto _out; }
169	13.0M	do {
170	13.0M	switch(cs) {
171	13.0M	case MSGPACK_CS_HEADER:
172	13.0M	SWITCH_RANGE_BEGIN
173	3.48M	SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum
174	3.48M	push_fixed_value(_uint8, (uint8_t)p);
175	3.48M	SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum
176	355k	push_fixed_value(_int8, (int8_t)p);
177	3.00M	SWITCH_RANGE(0xc0, 0xdf) // Variable
178	3.00M	switch(*p) {
179	16.0k	case 0xc0: // nil
180	16.0k	push_simple_value(_nil);
181		//case 0xc1: // string
182		// again_terminal_trail(NEXT_CS(p), p+1);
183	16.0k	case 0xc2: // false
184	11.5k	push_simple_value(_false);
185	457k	case 0xc3: // true
186	457k	push_simple_value(_true);
187	457k	case 0xc4: // bin 8
188	4.55k	case 0xc5: // bin 16
189	5.44k	case 0xc6: // bin 32
190	5.44k	again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
191	1.18k	case 0xc7: // ext 8
192	1.88k	case 0xc8: // ext 16
193	2.31k	case 0xc9: // ext 32
194	2.31k	again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03));
195	1.93k	case 0xca: // float
196	1.36M	case 0xcb: // double
197	1.37M	case 0xcc: // unsigned int 8
198	1.44M	case 0xcd: // unsigned int 16
199	1.49M	case 0xce: // unsigned int 32
200	1.69M	case 0xcf: // unsigned int 64
201	1.72M	case 0xd0: // signed int 8
202	1.74M	case 0xd1: // signed int 16
203	1.77M	case 0xd2: // signed int 32
204	1.79M	case 0xd3: // signed int 64
205	1.79M	again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
206	2.45k	case 0xd4: // fixext 1
207	4.15k	case 0xd5: // fixext 2
208	5.22k	case 0xd6: // fixext 4
209	6.20k	case 0xd7: // fixext 8
210	6.20k	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE,
211	6.20k	(1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero);
212	921	case 0xd8: // fixext 16
213	921	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero);
214
215	538k	case 0xd9: // str 8
216	662k	case 0xda: // str 16
217	663k	case 0xdb: // str 32
218	663k	again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1));
219	18.2k	case 0xdc: // array 16
220	19.6k	case 0xdd: // array 32
221	40.0k	case 0xde: // map 16
222	41.5k	case 0xdf: // map 32
223	41.5k	again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01));
224	7	default:
225	7	ret = MSGPACK_UNPACK_PARSE_ERROR;
226	7	goto _failed;
227	3.00M	}
228	5.22M	SWITCH_RANGE(0xa0, 0xbf) // FixStr
229	5.22M	again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero);
230	397k	SWITCH_RANGE(0x90, 0x9f) // FixArray
231	791k	start_container(_array, ((unsigned int)*p) & 0x0f, MSGPACK_CT_ARRAY_ITEM);
232	541k	SWITCH_RANGE(0x80, 0x8f) // FixMap
233	1.08M	start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY);
234
235	0	SWITCH_RANGE_DEFAULT
236	0	ret = MSGPACK_UNPACK_PARSE_ERROR;
237	0	goto _failed;
238	13.0M	SWITCH_RANGE_END
239		// end MSGPACK_CS_HEADER
240
241
242	7.55M	_fixed_trail_again:
243	7.55M	++p;
244		// fallthrough
245
246	7.55M	default:
247	7.55M	if((size_t)(pe - p) < trail) { goto _out; }
248	7.55M	n = p; p += trail - 1;
249	7.55M	switch(cs) {
250		//case MSGPACK_CS_
251		//case MSGPACK_CS_
252	1.93k	case MSGPACK_CS_FLOAT: {
253	1.93k	union { uint32_t i; float f; } mem;
254	1.93k	_msgpack_load32(uint32_t, n, &mem.i);
255	1.93k	push_fixed_value(_float, mem.f); }
256	1.36M	case MSGPACK_CS_DOUBLE: {
257	1.36M	union { uint64_t i; double f; } mem;
258	1.36M	_msgpack_load64(uint64_t, n, &mem.i);
259		#if defined(TARGET_OS_IPHONE)
260		// ok
261		#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
262		// https://github.com/msgpack/msgpack-perl/pull/1
263		mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL \| (mem.i >> 32UL);
264		#endif
265	1.36M	push_fixed_value(_double, mem.f); }
266	1.36M	case MSGPACK_CS_UINT_8:
267	7.36k	push_fixed_value(_uint8, (uint8_t)n);
268	68.9k	case MSGPACK_CS_UINT_16:{
269	68.9k	uint16_t tmp;
270	68.9k	_msgpack_load16(uint16_t,n,&tmp);
271	68.9k	push_fixed_value(_uint16, tmp);
272	68.9k	}
273	68.9k	case MSGPACK_CS_UINT_32:{
274	54.6k	uint32_t tmp;
275	54.6k	_msgpack_load32(uint32_t,n,&tmp);
276	54.6k	push_fixed_value(_uint32, tmp);
277	54.6k	}
278	197k	case MSGPACK_CS_UINT_64:{
279	197k	uint64_t tmp;
280	197k	_msgpack_load64(uint64_t,n,&tmp);
281	197k	push_fixed_value(_uint64, tmp);
282	197k	}
283	197k	case MSGPACK_CS_INT_8:
284	28.6k	push_fixed_value(_int8, (int8_t)n);
285	28.6k	case MSGPACK_CS_INT_16:{
286	17.7k	int16_t tmp;
287	17.7k	_msgpack_load16(int16_t,n,&tmp);
288	17.7k	push_fixed_value(_int16, tmp);
289	17.7k	}
290	30.6k	case MSGPACK_CS_INT_32:{
291	30.6k	int32_t tmp;
292	30.6k	_msgpack_load32(int32_t,n,&tmp);
293	30.6k	push_fixed_value(_int32, tmp);
294	30.6k	}
295	30.6k	case MSGPACK_CS_INT_64:{
296	25.8k	int64_t tmp;
297	25.8k	_msgpack_load64(int64_t,n,&tmp);
298	25.8k	push_fixed_value(_int64, tmp);
299	25.8k	}
300	25.8k	case MSGPACK_CS_FIXEXT_1:
301	0	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 1+1, _ext_zero);
302	0	case MSGPACK_CS_FIXEXT_2:
303	0	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 2+1, _ext_zero);
304	0	case MSGPACK_CS_FIXEXT_4:
305	0	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 4+1, _ext_zero);
306	0	case MSGPACK_CS_FIXEXT_8:
307	0	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 8+1, _ext_zero);
308	0	case MSGPACK_CS_FIXEXT_16:
309	0	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero);
310	538k	case MSGPACK_CS_STR_8:
311	538k	again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, (uint8_t)n, _str_zero);
312	3.71k	case MSGPACK_CS_BIN_8:
313	3.71k	again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, (uint8_t)n, _bin_zero);
314	1.18k	case MSGPACK_CS_EXT_8:
315	1.18k	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, ((uint8_t)n) + 1, _ext_zero);
316	123k	case MSGPACK_CS_STR_16:{
317	123k	uint16_t tmp;
318	123k	_msgpack_load16(uint16_t,n,&tmp);
319	123k	again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero);
320	123k	}
321	843	case MSGPACK_CS_BIN_16:{
322	843	uint16_t tmp;
323	843	_msgpack_load16(uint16_t,n,&tmp);
324	843	again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero);
325	843	}
326	690	case MSGPACK_CS_EXT_16:{
327	690	uint16_t tmp;
328	690	_msgpack_load16(uint16_t,n,&tmp);
329	690	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero);
330	690	}
331	1.01k	case MSGPACK_CS_STR_32:{
332	1.01k	uint32_t tmp;
333	1.01k	_msgpack_load32(uint32_t,n,&tmp);
334	1.01k	again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero);
335	1.01k	}
336	885	case MSGPACK_CS_BIN_32:{
337	885	uint32_t tmp;
338	885	_msgpack_load32(uint32_t,n,&tmp);
339	885	again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero);
340	885	}
341	428	case MSGPACK_CS_EXT_32:{
342	428	uint32_t tmp;
343	428	_msgpack_load32(uint32_t,n,&tmp);
344	428	again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero);
345	428	}
346	5.03M	case MSGPACK_ACS_STR_VALUE:
347	5.88M	_str_zero:
348	5.88M	push_variable_value(_str, data, n, trail);
349	5.88M	case MSGPACK_ACS_BIN_VALUE:
350	5.33k	_bin_zero:
351	5.33k	push_variable_value(_bin, data, n, trail);
352	9.29k	case MSGPACK_ACS_EXT_VALUE:
353	9.29k	_ext_zero:
354	9.29k	push_variable_value(_ext, data, n, trail);
355
356	18.2k	case MSGPACK_CS_ARRAY_16:{
357	18.2k	uint16_t tmp;
358	18.2k	_msgpack_load16(uint16_t,n,&tmp);
359	36.2k	start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM);
360	36.2k	}
361	1.43k	case MSGPACK_CS_ARRAY_32:{
362		/* FIXME security guard */
363	1.43k	uint32_t tmp;
364	1.43k	_msgpack_load32(uint32_t,n,&tmp);
365	2.81k	start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM);
366	2.81k	}
367
368	20.4k	case MSGPACK_CS_MAP_16:{
369	20.4k	uint16_t tmp;
370	20.4k	_msgpack_load16(uint16_t,n,&tmp);
371	40.8k	start_container(_map, tmp, MSGPACK_CT_MAP_KEY);
372	40.8k	}
373	1.47k	case MSGPACK_CS_MAP_32:{
374		/* FIXME security guard */
375	1.47k	uint32_t tmp;
376	1.47k	_msgpack_load32(uint32_t,n,&tmp);
377	2.88k	start_container(_map, tmp, MSGPACK_CT_MAP_KEY);
378	2.88k	}
379
380	0	default:
381	0	ret = MSGPACK_UNPACK_PARSE_ERROR;
382	0	goto _failed;
383	7.55M	}
384	13.0M	}
385
386	12.8M	_push:
387	12.8M	if(top == 0) { goto _finish; }
388	12.2M	c = &stack[top-1];
389	12.2M	switch(c->ct) {
390	3.98M	case MSGPACK_CT_ARRAY_ITEM:
391	3.98M	ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \
392	3.98M	if(ret < 0) { goto _failed; }
393	3.98M	if(--c->count == 0) {
394	212k	obj = c->obj;
395	212k	--top;
396		/printf("stack pop %d\n", top);/
397	212k	goto _push;
398	212k	}
399	3.77M	goto _header_again;
400	4.12M	case MSGPACK_CT_MAP_KEY:
401	4.12M	c->map_key = obj;
402	4.12M	c->ct = MSGPACK_CT_MAP_VALUE;
403	4.12M	goto _header_again;
404	4.11M	case MSGPACK_CT_MAP_VALUE:
405	4.11M	ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \
406	4.11M	if(ret < 0) { goto _failed; }
407	4.11M	if(--c->count == 0) {
408	450k	obj = c->obj;
409	450k	--top;
410		/printf("stack pop %d\n", top);/
411	450k	goto _push;
412	450k	}
413	3.66M	c->ct = MSGPACK_CT_MAP_KEY;
414	3.66M	goto _header_again;
415
416	0	default:
417	0	ret = MSGPACK_UNPACK_PARSE_ERROR;
418	0	goto _failed;
419	12.2M	}
420
421	12.4M	_header_again:
422	12.4M	cs = MSGPACK_CS_HEADER;
423	12.4M	++p;
424	12.4M	} while(p != pe);
425	201	goto _out;
426
427
428	602k	_finish:
429	602k	stack[0].obj = obj;
430	602k	++p;
431	602k	ret = 1;
432		/printf("-- finish --\n"); /
433	602k	goto _end;
434
435	2.67k	_failed:
436		/printf("* FAILED *\n"); /
437	2.67k	goto _end;
438
439	748	_out:
440	748	ret = 0;
441	748	goto _end;
442
443	606k	_end:
444	606k	ctx->cs = cs;
445	606k	ctx->trail = trail;
446	606k	ctx->top = top;
447	606k	off = (size_t)(p - (const unsigned char)data);
448
449	606k	return ret;
450	606k	}
451	606k	}
452
453		#undef msgpack_unpack_func
454		#undef msgpack_unpack_callback
455		#undef msgpack_unpack_struct
456		#undef msgpack_unpack_object
457		#undef msgpack_unpack_user
458
459		#undef push_simple_value
460		#undef push_fixed_value
461		#undef push_variable_value
462		#undef again_fixed_trail
463		#undef again_fixed_trail_if_zero
464		#undef start_container
465
466		#undef NEXT_CS
467
468		#undef SWITCH_RANGE_BEGIN
469		#undef SWITCH_RANGE
470		#undef SWITCH_RANGE_DEFAULT
471		#undef SWITCH_RANGE_END