generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-10-17 03:03:24 +02:00
Code Issues Projects Releases Wiki Activity

Fixed #220.

Browse Source 
Added MSGPACK_ prefix to unpack macros.
This commit is contained in:
Takatoshi Kondo
2015-02-19 17:44:42 +09:00
parent b4eba4ba09
commit c675881f3b
3 changed files with 166 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
include/msgpack/unpack.hpp
View File

@@ -410,14 +410,14 @@ inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) ==
class context {
public:
context(unpack_reference_func f, void* user_data, unpack_limit const& limit)
:m_trail(0), m_user(f, user_data, limit), m_cs(CS_HEADER), m_top(0)
:m_trail(0), m_user(f, user_data, limit), m_cs(MSGPACK_CS_HEADER), m_top(0)
{
m_stack[0].set_obj(object());
}
void init()
{
m_cs = CS_HEADER;
m_cs = MSGPACK_CS_HEADER;
m_trail = 0;
m_top = 0;
m_stack[0].set_obj(object());
@@ -467,7 +467,7 @@ private:
m_stack[m_top].set_container_type(container_type);
m_stack[m_top].set_count(tmp);
++m_top;
m_cs = CS_HEADER;
m_cs = MSGPACK_CS_HEADER;
++m_current;
}
}
@@ -487,7 +487,7 @@ private:
m_stack_idx = m_top - 1;
unpack_stack* sp = &m_stack[m_stack_idx];
switch(sp->container_type()) {
case CT_ARRAY_ITEM:
case MSGPACK_CT_ARRAY_ITEM:
unpack_array_item(sp->obj(), obj);
if(sp->decl_count() == 0) {
obj = sp->obj();
@@ -498,12 +498,12 @@ private:
finish = true;
}
break;
case CT_MAP_KEY:
case MSGPACK_CT_MAP_KEY:
sp->set_map_key(obj);
sp->set_container_type(CT_MAP_VALUE);
sp->set_container_type(MSGPACK_CT_MAP_VALUE);
finish = true;
break;
case CT_MAP_VALUE:
case MSGPACK_CT_MAP_VALUE:
unpack_map_item(sp->obj(), sp->map_key(), obj);
if(sp->decl_count() == 0) {
obj = sp->obj();
@@ -511,7 +511,7 @@ private:
/*printf("stack pop %d\n", m_top);*/
}
else {
sp->set_container_type(CT_MAP_KEY);
sp->set_container_type(MSGPACK_CT_MAP_KEY);
finish = true;
}
break;
@@ -534,7 +534,7 @@ private:
off = m_current - m_start;
}
else {
m_cs = CS_HEADER;
m_cs = MSGPACK_CS_HEADER;
++m_current;
}
return ret;
@@ -579,7 +579,7 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
}
bool fixed_trail_again = false;
do {
if (m_cs == CS_HEADER) {
if (m_cs == MSGPACK_CS_HEADER) {
fixed_trail_again = false;
int selector = *reinterpret_cast<const unsigned char*>(m_current);
if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum
@@ -632,17 +632,17 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_STR_VALUE;
m_cs = MSGPACK_ACS_STR_VALUE;
fixed_trail_again = true;
}
} else if(0x90 <= selector && selector <= 0x9f) { // FixArray
int ret = push_aggregate<fix_tag>(
unpack_array(), CT_ARRAY_ITEM, obj, m_current, off);
unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, m_current, off);
if (ret != 0) return ret;
} else if(0x80 <= selector && selector <= 0x8f) { // FixMap
int ret = push_aggregate<fix_tag>(
unpack_map(), CT_MAP_KEY, obj, m_current, off);
unpack_map(), MSGPACK_CT_MAP_KEY, obj, m_current, off);
if (ret != 0) return ret;
} else if(selector == 0xc2) { // false
unpack_false(obj);
@@ -660,9 +660,9 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
off = m_current - m_start;
return -1;
}
// end CS_HEADER
// end MSGPACK_CS_HEADER
}
if (m_cs != CS_HEADER || fixed_trail_again) {
if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) {
if (fixed_trail_again) {
++m_current;
fixed_trail_again = false;
@@ -674,16 +674,16 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
n = m_current;
m_current += m_trail - 1;
switch(m_cs) {
//case CS_
//case CS_
case CS_FLOAT: {
//case MSGPACK_CS_
//case MSGPACK_CS_
case MSGPACK_CS_FLOAT: {
union { uint32_t i; float f; } mem;
load<uint32_t>(mem.i, n);
unpack_float(mem.f, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_DOUBLE: {
case MSGPACK_CS_DOUBLE: {
union { uint64_t i; double f; } mem;
load<uint64_t>(mem.i, n);
#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
@@ -694,88 +694,88 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_UINT_8: {
case MSGPACK_CS_UINT_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
unpack_uint8(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_UINT_16: {
case MSGPACK_CS_UINT_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
unpack_uint16(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_UINT_32: {
case MSGPACK_CS_UINT_32: {
uint32_t tmp;
load<uint32_t>(tmp, n);
unpack_uint32(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_UINT_64: {
case MSGPACK_CS_UINT_64: {
uint64_t tmp;
load<uint64_t>(tmp, n);
unpack_uint64(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_INT_8: {
case MSGPACK_CS_INT_8: {
int8_t tmp;
load<int8_t>(tmp, n);
unpack_int8(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_INT_16: {
case MSGPACK_CS_INT_16: {
int16_t tmp;
load<int16_t>(tmp, n);
unpack_int16(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_INT_32: {
case MSGPACK_CS_INT_32: {
int32_t tmp;
load<int32_t>(tmp, n);
unpack_int32(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_INT_64: {
case MSGPACK_CS_INT_64: {
int64_t tmp;
load<int64_t>(tmp, n);
unpack_int64(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_FIXEXT_1: {
case MSGPACK_CS_FIXEXT_1: {
unpack_ext(m_user, n, 1+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_FIXEXT_2: {
case MSGPACK_CS_FIXEXT_2: {
unpack_ext(m_user, n, 2+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_FIXEXT_4: {
case MSGPACK_CS_FIXEXT_4: {
unpack_ext(m_user, n, 4+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_FIXEXT_8: {
case MSGPACK_CS_FIXEXT_8: {
unpack_ext(m_user, n, 8+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_FIXEXT_16: {
case MSGPACK_CS_FIXEXT_16: {
unpack_ext(m_user, n, 16+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_STR_8: {
case MSGPACK_CS_STR_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
m_trail = tmp;
@@ -785,11 +785,11 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_STR_VALUE;
m_cs = MSGPACK_ACS_STR_VALUE;
fixed_trail_again = true;
}
} break;
case CS_BIN_8: {
case MSGPACK_CS_BIN_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
m_trail = tmp;
@@ -799,11 +799,11 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_BIN_VALUE;
m_cs = MSGPACK_ACS_BIN_VALUE;
fixed_trail_again = true;
}
} break;
case CS_EXT_8: {
case MSGPACK_CS_EXT_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
m_trail = tmp + 1;
@@ -813,11 +813,11 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_EXT_VALUE;
m_cs = MSGPACK_ACS_EXT_VALUE;
fixed_trail_again = true;
}
} break;
case CS_STR_16: {
case MSGPACK_CS_STR_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
m_trail = tmp;
@@ -827,11 +827,11 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_STR_VALUE;
m_cs = MSGPACK_ACS_STR_VALUE;
fixed_trail_again = true;
}
} break;
case CS_BIN_16: {
case MSGPACK_CS_BIN_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
m_trail = tmp;
@@ -841,11 +841,11 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_BIN_VALUE;
m_cs = MSGPACK_ACS_BIN_VALUE;
fixed_trail_again = true;
}
} break;
case CS_EXT_16: {
case MSGPACK_CS_EXT_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
m_trail = tmp + 1;
@@ -855,11 +855,11 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_EXT_VALUE;
m_cs = MSGPACK_ACS_EXT_VALUE;
fixed_trail_again = true;
}
} break;
case CS_STR_32: {
case MSGPACK_CS_STR_32: {
uint32_t tmp;
load<uint32_t>(tmp, n);
m_trail = tmp;
@@ -869,11 +869,11 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_STR_VALUE;
m_cs = MSGPACK_ACS_STR_VALUE;
fixed_trail_again = true;
}
} break;
case CS_BIN_32: {
case MSGPACK_CS_BIN_32: {
uint32_t tmp;
load<uint32_t>(tmp, n);
m_trail = tmp;
@@ -883,11 +883,11 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_BIN_VALUE;
m_cs = MSGPACK_ACS_BIN_VALUE;
fixed_trail_again = true;
}
} break;
case CS_EXT_32: {
case MSGPACK_CS_EXT_32: {
uint32_t tmp;
load<uint32_t>(tmp, n);
check_ext_size<sizeof(std::size_t)>(tmp);
@@ -899,45 +899,45 @@ inline int context::execute(const char* data, std::size_t len, std::size_t& off)
if (ret != 0) return ret;
}
else {
m_cs = ACS_EXT_VALUE;
m_cs = MSGPACK_ACS_EXT_VALUE;
fixed_trail_again = true;
}
} break;
case ACS_STR_VALUE: {
case MSGPACK_ACS_STR_VALUE: {
unpack_str(m_user, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case ACS_BIN_VALUE: {
case MSGPACK_ACS_BIN_VALUE: {
unpack_bin(m_user, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case ACS_EXT_VALUE: {
case MSGPACK_ACS_EXT_VALUE: {
unpack_ext(m_user, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_ARRAY_16: {
case MSGPACK_CS_ARRAY_16: {
int ret = push_aggregate<uint16_t>(
unpack_array(), CT_ARRAY_ITEM, obj, n, off);
unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, n, off);
if (ret != 0) return ret;
} break;
case CS_ARRAY_32: {
case MSGPACK_CS_ARRAY_32: {
/* FIXME security guard */
int ret = push_aggregate<uint32_t>(
unpack_array(), CT_ARRAY_ITEM, obj, n, off);
unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, n, off);
if (ret != 0) return ret;
} break;
case CS_MAP_16: {
case MSGPACK_CS_MAP_16: {
int ret = push_aggregate<uint16_t>(
unpack_map(), CT_MAP_KEY, obj, n, off);
unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off);
if (ret != 0) return ret;
} break;
case CS_MAP_32: {
case MSGPACK_CS_MAP_32: {
/* FIXME security guard */
int ret = push_aggregate<uint32_t>(
unpack_map(), CT_MAP_KEY, obj, n, off);
unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off);
if (ret != 0) return ret;
} break;
default:

80
include/msgpack/unpack_define.h
View File

@@ -35,57 +35,57 @@ extern "C" {
typedef enum {
CS_HEADER = 0x00, // nil
MSGPACK_CS_HEADER = 0x00, // nil
//CS_ = 0x01,
//CS_ = 0x02, // false
//CS_ = 0x03, // true
//MSGPACK_CS_ = 0x01,
//MSGPACK_CS_ = 0x02, // false
//MSGPACK_CS_ = 0x03, // true
CS_BIN_8 = 0x04,
CS_BIN_16 = 0x05,
CS_BIN_32 = 0x06,
MSGPACK_CS_BIN_8 = 0x04,
MSGPACK_CS_BIN_16 = 0x05,
MSGPACK_CS_BIN_32 = 0x06,
CS_EXT_8 = 0x07,
CS_EXT_16 = 0x08,
CS_EXT_32 = 0x09,
MSGPACK_CS_EXT_8 = 0x07,
MSGPACK_CS_EXT_16 = 0x08,
MSGPACK_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,
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,
CS_FIXEXT_1 = 0x14,
CS_FIXEXT_2 = 0x15,
CS_FIXEXT_4 = 0x16,
CS_FIXEXT_8 = 0x17,
CS_FIXEXT_16 = 0x18,
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,
CS_STR_8 = 0x19, // str8
CS_STR_16 = 0x1a, // str16
CS_STR_32 = 0x1b, // str32
CS_ARRAY_16 = 0x1c,
CS_ARRAY_32 = 0x1d,
CS_MAP_16 = 0x1e,
CS_MAP_32 = 0x1f,
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,
//ACS_BIG_INT_VALUE,
//ACS_BIG_FLOAT_VALUE,
ACS_STR_VALUE,
ACS_BIN_VALUE,
ACS_EXT_VALUE
//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;

130
include/msgpack/unpack_template.h
View File

@@ -69,7 +69,7 @@ msgpack_unpack_struct_decl(_context) {
msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
{
ctx->cs = CS_HEADER;
ctx->cs = MSGPACK_CS_HEADER;
ctx->trail = 0;
ctx->top = 0;
/*
@@ -185,7 +185,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
if(p == pe) { goto _out; }
do {
switch(cs) {
case CS_HEADER:
case MSGPACK_CS_HEADER:
SWITCH_RANGE_BEGIN
SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum
push_fixed_value(_uint8, *(uint8_t*)p);
@@ -224,10 +224,10 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
case 0xd5: // fixext 2
case 0xd6: // fixext 4
case 0xd7: // fixext 8
again_fixed_trail_if_zero(ACS_EXT_VALUE,
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(ACS_EXT_VALUE, 16+1, _ext_zero);
again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero);
case 0xd9: // str 8
case 0xda: // str 16
@@ -242,16 +242,16 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
goto _failed;
}
SWITCH_RANGE(0xa0, 0xbf) // FixStr
again_fixed_trail_if_zero(ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero);
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, CT_ARRAY_ITEM);
start_container(_array, ((unsigned int)*p) & 0x0f, MSGPACK_CT_ARRAY_ITEM);
SWITCH_RANGE(0x80, 0x8f) // FixMap
start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY);
start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY);
SWITCH_RANGE_DEFAULT
goto _failed;
SWITCH_RANGE_END
// end CS_HEADER
// end MSGPACK_CS_HEADER
_fixed_trail_again:
@@ -261,13 +261,13 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
if((size_t)(pe - p) < trail) { goto _out; }
n = p; p += trail - 1;
switch(cs) {
//case CS_
//case CS_
case CS_FLOAT: {
//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 CS_DOUBLE: {
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
@@ -275,118 +275,118 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
#endif
push_fixed_value(_double, mem.f); }
case CS_UINT_8:
case MSGPACK_CS_UINT_8:
push_fixed_value(_uint8, *(uint8_t*)n);
case CS_UINT_16:{
case MSGPACK_CS_UINT_16:{
uint16_t tmp;
_msgpack_load16(uint16_t,n,&tmp);
push_fixed_value(_uint16, tmp);
}
case CS_UINT_32:{
case MSGPACK_CS_UINT_32:{
uint32_t tmp;
_msgpack_load32(uint32_t,n,&tmp);
push_fixed_value(_uint32, tmp);
}
case CS_UINT_64:{
case MSGPACK_CS_UINT_64:{
uint64_t tmp;
_msgpack_load64(uint64_t,n,&tmp);
push_fixed_value(_uint64, tmp);
}
case CS_INT_8:
case MSGPACK_CS_INT_8:
push_fixed_value(_int8, *(int8_t*)n);
case CS_INT_16:{
case MSGPACK_CS_INT_16:{
int16_t tmp;
_msgpack_load16(int16_t,n,&tmp);
push_fixed_value(_int16, tmp);
}
case CS_INT_32:{
case MSGPACK_CS_INT_32:{
int32_t tmp;
_msgpack_load32(int32_t,n,&tmp);
push_fixed_value(_int32, tmp);
}
case CS_INT_64:{
case MSGPACK_CS_INT_64:{
int64_t tmp;
_msgpack_load64(int64_t,n,&tmp);
push_fixed_value(_int64, tmp);
}
case CS_FIXEXT_1:
again_fixed_trail_if_zero(ACS_EXT_VALUE, 1+1, _ext_zero);
case CS_FIXEXT_2:
again_fixed_trail_if_zero(ACS_EXT_VALUE, 2+1, _ext_zero);
case CS_FIXEXT_4:
again_fixed_trail_if_zero(ACS_EXT_VALUE, 4+1, _ext_zero);
case CS_FIXEXT_8:
again_fixed_trail_if_zero(ACS_EXT_VALUE, 8+1, _ext_zero);
case CS_FIXEXT_16:
again_fixed_trail_if_zero(ACS_EXT_VALUE, 16+1, _ext_zero);
case CS_STR_8:
again_fixed_trail_if_zero(ACS_STR_VALUE, *(uint8_t*)n, _str_zero);
case CS_BIN_8:
again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero);
case CS_EXT_8:
again_fixed_trail_if_zero(ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero);
case CS_STR_16:{
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(ACS_STR_VALUE, tmp, _str_zero);
again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero);
}
case CS_BIN_16:{
case MSGPACK_CS_BIN_16:{
uint16_t tmp;
_msgpack_load16(uint16_t,n,&tmp);
again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero);
again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero);
}
case CS_EXT_16:{
case MSGPACK_CS_EXT_16:{
uint16_t tmp;
_msgpack_load16(uint16_t,n,&tmp);
again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp + 1, _ext_zero);
again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero);
}
case CS_STR_32:{
case MSGPACK_CS_STR_32:{
uint32_t tmp;
_msgpack_load32(uint32_t,n,&tmp);
again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero);
again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero);
}
case CS_BIN_32:{
case MSGPACK_CS_BIN_32:{
uint32_t tmp;
_msgpack_load32(uint32_t,n,&tmp);
again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero);
again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero);
}
case CS_EXT_32:{
case MSGPACK_CS_EXT_32:{
uint32_t tmp;
_msgpack_load32(uint32_t,n,&tmp);
again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp + 1, _ext_zero);
again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero);
}
case ACS_STR_VALUE:
case MSGPACK_ACS_STR_VALUE:
_str_zero:
push_variable_value(_str, data, n, trail);
case ACS_BIN_VALUE:
case MSGPACK_ACS_BIN_VALUE:
_bin_zero:
push_variable_value(_bin, data, n, trail);
case ACS_EXT_VALUE:
case MSGPACK_ACS_EXT_VALUE:
_ext_zero:
push_variable_value(_ext, data, n, trail);
case CS_ARRAY_16:{
case MSGPACK_CS_ARRAY_16:{
uint16_t tmp;
_msgpack_load16(uint16_t,n,&tmp);
start_container(_array, tmp, CT_ARRAY_ITEM);
start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM);
}
case CS_ARRAY_32:{
case MSGPACK_CS_ARRAY_32:{
/* FIXME security guard */
uint32_t tmp;
_msgpack_load32(uint32_t,n,&tmp);
start_container(_array, tmp, CT_ARRAY_ITEM);
start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM);
}
case CS_MAP_16:{
case MSGPACK_CS_MAP_16:{
uint16_t tmp;
_msgpack_load16(uint16_t,n,&tmp);
start_container(_map, tmp, CT_MAP_KEY);
start_container(_map, tmp, MSGPACK_CT_MAP_KEY);
}
case CS_MAP_32:{
case MSGPACK_CS_MAP_32:{
/* FIXME security guard */
uint32_t tmp;
_msgpack_load32(uint32_t,n,&tmp);
start_container(_map, tmp, CT_MAP_KEY);
start_container(_map, tmp, MSGPACK_CT_MAP_KEY);
}
default:
@@ -398,7 +398,7 @@ _push:
if(top == 0) { goto _finish; }
c = &stack[top-1];
switch(c->ct) {
case CT_ARRAY_ITEM:
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;
@@ -407,11 +407,11 @@ _push:
goto _push;
}
goto _header_again;
case CT_MAP_KEY:
case MSGPACK_CT_MAP_KEY:
c->map_key = obj;
c->ct = CT_MAP_VALUE;
c->ct = MSGPACK_CT_MAP_VALUE;
goto _header_again;
case CT_MAP_VALUE:
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;
@@ -419,7 +419,7 @@ _push:
/*printf("stack pop %d\n", top);*/
goto _push;
}
c->ct = CT_MAP_KEY;
c->ct = MSGPACK_CT_MAP_KEY;
goto _header_again;
default:
@@ -427,7 +427,7 @@ _push:
}
_header_again:
cs = CS_HEADER;
cs = MSGPACK_CS_HEADER;
++p;
} while(p != pe);
goto _out;