/*

* MessagePack unpacking routine template

*

* Copyright (C) 2008-2010 FURUHASHI Sadayuki

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

#ifndef USE_CASE_RANGE

#if !defined(_MSC_VER)

#define USE_CASE_RANGE

#endif

#endif

typedef struct unpack_stack {

PyObject* obj;

Py_ssize_t size;

Py_ssize_t count;

unsigned int ct;

PyObject* map_key;

} unpack_stack;

struct unpack_context {

unpack_user user;

unsigned int cs;

unsigned int trail;

unsigned int top;

/*

unpack_stack* stack;

unsigned int stack_size;

unpack_stack embed_stack[MSGPACK_EMBED_STACK_SIZE];

*/

unpack_stack stack[MSGPACK_EMBED_STACK_SIZE];

};

static inline void unpack_init(unpack_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 = unpack_callback_root(&ctx->user);

}

/*

static inline void unpack_destroy(unpack_context* ctx)

{

if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) {

free(ctx->stack);

}

}

*/

static inline PyObject* unpack_data(unpack_context* ctx)

{

return (ctx)->stack[0].obj;

}

static inline void unpack_clear(unpack_context *ctx)

{

Py_CLEAR(ctx->stack[0].obj);

}

static inline int unpack_execute(bool construct, unpack_context* ctx, const char* data, Py_ssize_t len, Py_ssize_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 = p;

unsigned int trail = ctx->trail;

unsigned int cs = ctx->cs;

unsigned int top = ctx->top;

unpack_stack* stack = ctx->stack;

/*

unsigned int stack_size = ctx->stack_size;

*/

unpack_user* user = &ctx->user;

PyObject* obj = NULL;

unpack_stack* c = NULL;

int ret;

#define construct_cb(name) \

construct && unpack_callback ## name

#define push_simple_value(func) \

if(construct_cb(func)(user, &obj) < 0) { goto _failed; } \

goto _push

#define push_fixed_value(func, arg) \

if(construct_cb(func)(user, arg, &obj) < 0) { goto _failed; } \

goto _push

#define push_variable_value(func, base, pos, len) \

if(construct_cb(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

#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 = -3; goto _end; } \

if(construct_cb(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \

if((count_) == 0) { obj = stack[top].obj; \

if (construct_cb(func##_end)(user, &obj) < 0) { goto _failed; } \

goto _push; } \

stack[top].ct = ct_; \

stack[top].size = count_; \

stack[top].count = 0; \

++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 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: // never used

case 0xc2: // false

push_simple_value(_false);

case 0xc3: // true

push_simple_value(_true);

case 0xc4: // bin 8

again_fixed_trail(NEXT_CS(p), 1);

case 0xc5: // bin 16

again_fixed_trail(NEXT_CS(p), 2);

case 0xc6: // bin 32

again_fixed_trail(NEXT_CS(p), 4);

case 0xc7: // ext 8

again_fixed_trail(NEXT_CS(p), 1);

case 0xc8: // ext 16

again_fixed_trail(NEXT_CS(p), 2);

case 0xc9: // ext 32

again_fixed_trail(NEXT_CS(p), 4);

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(ACS_EXT_VALUE,

(1 << (((unsigned int)*p) & 0x03))+1,

_ext_zero);

case 0xd8: // fixext 16

again_fixed_trail_if_zero(ACS_EXT_VALUE, 16+1, _ext_zero);

case 0xd9: // str 8

again_fixed_trail(NEXT_CS(p), 1);

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:

ret = -2;

goto _end;

}

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

ret = -2;

goto _end;

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_EXT_8:

again_fixed_trail_if_zero(ACS_EXT_VALUE, *(uint8_t*)n+1, _ext_zero);

case CS_EXT_16:

again_fixed_trail_if_zero(ACS_EXT_VALUE,

_msgpack_load16(uint16_t,n)+1,

_ext_zero);

case CS_EXT_32:

again_fixed_trail_if_zero(ACS_EXT_VALUE,

_msgpack_load32(uint32_t,n)+1,

_ext_zero);

case CS_FLOAT: {

double f;

#if PY_VERSION_HEX >= 0x030B00A7

f = PyFloat_Unpack4((const char*)n, 0);

#else

f = _PyFloat_Unpack4((unsigned char*)n, 0);

#endif

push_fixed_value(_float, f); }

case CS_DOUBLE: {

double f;

#if PY_VERSION_HEX >= 0x030B00A7

f = PyFloat_Unpack8((const char*)n, 0);

#else

f = _PyFloat_Unpack8((unsigned char*)n, 0);

#endif

push_fixed_value(_double, 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_BIN_8:

again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero);

case CS_BIN_16:

again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load16(uint16_t,n), _bin_zero);

case CS_BIN_32:

again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load32(uint32_t,n), _bin_zero);

case ACS_BIN_VALUE:

_bin_zero:

push_variable_value(_bin, data, n, trail);

case CS_RAW_8:

again_fixed_trail_if_zero(ACS_RAW_VALUE, *(uint8_t*)n, _raw_zero);

case CS_RAW_16:

again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load16(uint16_t,n), _raw_zero);

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 ACS_EXT_VALUE:

_ext_zero:

push_variable_value(_ext, 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:

if(top == 0) { goto _finish; }

c = &stack[top-1];

switch(c->ct) {

case CT_ARRAY_ITEM:

if(construct_cb(_array_item)(user, c->count, &c->obj, obj) < 0) { goto _failed; }

if(++c->count == c->size) {

obj = c->obj;

if (construct_cb(_array_end)(user, &obj) < 0) { goto _failed; }

--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(construct_cb(_map_item)(user, c->count, &c->obj, c->map_key, obj) < 0) { goto _failed; }

if(++c->count == c->size) {

obj = c->obj;

if (construct_cb(_map_end)(user, &obj) < 0) { goto _failed; }

--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:

if (!construct)

unpack_callback_nil(user, &obj);

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;

#undef construct_cb

}

#undef NEXT_CS

#undef SWITCH_RANGE_BEGIN

#undef SWITCH_RANGE

#undef SWITCH_RANGE_DEFAULT

#undef SWITCH_RANGE_END

#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

static int unpack_construct(unpack_context *ctx, const char *data, Py_ssize_t len, Py_ssize_t *off) {

return unpack_execute(1, ctx, data, len, off);

}

static int unpack_skip(unpack_context *ctx, const char *data, Py_ssize_t len, Py_ssize_t *off) {

return unpack_execute(0, ctx, data, len, off);

}

#define unpack_container_header read_array_header

#define fixed_offset 0x90

#define var_offset 0xdc

#include "unpack_container_header.h"

#undef unpack_container_header

#undef fixed_offset

#undef var_offset

#define unpack_container_header read_map_header

#define fixed_offset 0x80

#define var_offset 0xde

#include "unpack_container_header.h"

#undef unpack_container_header

#undef fixed_offset

#undef var_offset

/* vim: set ts=4 sw=4 sts=4 expandtab */