Stowage/msgpack-python
2
0
Fork 0
mirror of https://github.com/msgpack/msgpack-python.git synced 2026-02-06 17:59:52 +00:00
Code Issues Projects Releases Packages Wiki Activity
msgpack-python/msgpack/unpack/inline_impl.h
frsyuki 529a50633d lang/c/msgpack: added C++ binding 
git-svn-id: file:///Users/frsyuki/project/msgpack-git/svn/x@50 5a5092ae-2292-43ba-b2d5-dcab9c1a2731
2009-02-15 09:09:56 +00:00

462 lines
12 KiB
C
Raw Blame History

/*
* 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>*/
#ifdef __cplusplus
extern "C" {
#endif
// 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
#define betoh16(x) ntohs(x)
#define betoh32(x) ntohl(x)
#ifdef __LITTLE_ENDIAN__
#if defined(__bswap_64)
# define betoh64(x) __bswap_64(x)
#elif defined(__DARWIN_OSSwapInt64)
# define betoh64(x) __DARWIN_OSSwapInt64(x)
#else
static inline uint64_t betoh64(uint64_t x) {
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
#define betoh64(x) (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) betoh16(*(uint16_t*)ptr)
#define PTR_CAST_32(ptr) betoh32(*(uint32_t*)ptr)
#define PTR_CAST_64(ptr) betoh64(*(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;
}
#ifdef betoh16(x)
#undef betoh16(x)
#endif
#ifdef betoh32(x)
#undef betoh32(x)
#endif
#ifdef betoh64(x)
#undef betoh64(x)
#endif
#ifdef __cplusplus
}
#endif
#endif /* msgpack/unpack/inline_impl.h */
Reference in a new issue View git blame Copy permalink