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

Added bin and str families support.

Browse Source
This commit is contained in:
Takatoshi Kondo 2014-01-26 15:17:33 +00:00
parent 33d3192ca2
commit d70c44b723
15 changed files with 381 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
example/simple.c
View File

@ -14,8 +14,8 @@ int main(void)
msgpack_pack_array(&pk, 3); msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1); msgpack_pack_int(&pk, 1);
msgpack_pack_true(&pk); msgpack_pack_true(&pk);
msgpack_pack_raw(&pk, 7); msgpack_pack_str(&pk, 7);
msgpack_pack_raw_body(&pk, "example", 7); msgpack_pack_str_body(&pk, "example", 7);
/* deserialize the buffer into msgpack_object instance. */ /* deserialize the buffer into msgpack_object instance. */
/* deserialized object is valid during the msgpack_zone instance alive. */ /* deserialized object is valid during the msgpack_zone instance alive. */

15
src/msgpack/object.h
View File

@ -38,9 +38,10 @@ typedef enum {
MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02,
MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03,
MSGPACK_OBJECT_DOUBLE = 0x04, MSGPACK_OBJECT_DOUBLE = 0x04,
MSGPACK_OBJECT_RAW = 0x05, MSGPACK_OBJECT_STR = 0x05,
MSGPACK_OBJECT_ARRAY = 0x06, MSGPACK_OBJECT_ARRAY = 0x06,
MSGPACK_OBJECT_MAP = 0x07 MSGPACK_OBJECT_MAP = 0x07,
MSGPACK_OBJECT_BIN = 0x08
} msgpack_object_type; } msgpack_object_type;
@ -60,7 +61,12 @@ typedef struct {
typedef struct { typedef struct {
uint32_t size; uint32_t size;
const char* ptr; const char* ptr;
} msgpack_object_raw; } msgpack_object_str;
typedef struct {
uint32_t size;
const char* ptr;
} msgpack_object_bin;
typedef union { typedef union {
bool boolean; bool boolean;
@ -69,7 +75,8 @@ typedef union {
double dec; double dec;
msgpack_object_array array; msgpack_object_array array;
msgpack_object_map map; msgpack_object_map map;
msgpack_object_raw raw; msgpack_object_str str;
msgpack_object_bin bin;
} msgpack_object_union; } msgpack_object_union;
typedef struct msgpack_object { typedef struct msgpack_object {

44
src/msgpack/object.hpp
View File

@ -40,7 +40,8 @@ namespace type {
POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER,
NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER,
DOUBLE = MSGPACK_OBJECT_DOUBLE, DOUBLE = MSGPACK_OBJECT_DOUBLE,
RAW = MSGPACK_OBJECT_RAW, STR = MSGPACK_OBJECT_STR,
BIN = MSGPACK_OBJECT_BIN,
ARRAY = MSGPACK_OBJECT_ARRAY, ARRAY = MSGPACK_OBJECT_ARRAY,
MAP = MSGPACK_OBJECT_MAP MAP = MSGPACK_OBJECT_MAP
}; };
@ -60,7 +61,12 @@ struct object_map {
object_kv* ptr; object_kv* ptr;
}; };
struct object_raw { struct object_str {
uint32_t size;
const char* ptr;
};
struct object_bin {
uint32_t size; uint32_t size;
const char* ptr; const char* ptr;
}; };
@ -73,8 +79,8 @@ struct object {
double dec; double dec;
object_array array; object_array array;
object_map map; object_map map;
object_raw raw; object_str str;
object_raw ref; // obsolete object_bin bin;
}; };
type::object_type type; type::object_type type;
@ -228,9 +234,13 @@ inline bool operator==(const object& x, const object& y)
case type::DOUBLE: case type::DOUBLE:
return x.via.dec == y.via.dec; return x.via.dec == y.via.dec;
case type::RAW: case type::STR:
return x.via.raw.size == y.via.raw.size && return x.via.str.size == y.via.str.size &&
memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0; memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0;
case type::BIN:
return x.via.bin.size == y.via.bin.size &&
memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0;
case type::ARRAY: case type::ARRAY:
if(x.via.array.size != y.via.array.size) { if(x.via.array.size != y.via.array.size) {
@ -424,9 +434,14 @@ packer<Stream>& operator<< (packer<Stream>& o, const object& v)
o.pack_double(v.via.dec); o.pack_double(v.via.dec);
return o; return o;
case type::RAW: case type::STR:
o.pack_raw(v.via.raw.size); o.pack_str(v.via.str.size);
o.pack_raw_body(v.via.raw.ptr, v.via.raw.size); o.pack_str_body(v.via.str.ptr, v.via.str.size);
return o;
case type::BIN:
o.pack_bin(v.via.bin.size);
o.pack_bin_body(v.via.bin.ptr, v.via.bin.size);
return o; return o;
case type::ARRAY: case type::ARRAY:
@ -476,10 +491,15 @@ std::ostream& operator<< (std::ostream& s, const object& o)
s << o.via.dec; s << o.via.dec;
break; break;
case type::RAW: case type::STR:
(s << '"').write(o.via.raw.ptr, o.via.raw.size) << '"'; (s << '"').write(o.via.str.ptr, o.via.str.size) << '"';
break; break;
case type::BIN:
(s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"';
break;
case type::ARRAY: case type::ARRAY:
s << "["; s << "[";
if(o.via.array.size != 0) { if(o.via.array.size != 0) {

7
src/msgpack/pack.h
View File

@ -94,8 +94,11 @@ static int msgpack_pack_array(msgpack_packer* pk, size_t n);
static int msgpack_pack_map(msgpack_packer* pk, size_t n); static int msgpack_pack_map(msgpack_packer* pk, size_t n);
static int msgpack_pack_raw(msgpack_packer* pk, size_t l); static int msgpack_pack_str(msgpack_packer* pk, size_t l);
static int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l); static int msgpack_pack_str_body(msgpack_packer* pk, const void* b, size_t l);
static int msgpack_pack_bin(msgpack_packer* pk, size_t l);
static int msgpack_pack_bin_body(msgpack_packer* pk, const void* b, size_t l);
int msgpack_pack_object(msgpack_packer* pk, msgpack_object d); int msgpack_pack_object(msgpack_packer* pk, msgpack_object d);

41
src/msgpack/pack.hpp
View File

@ -77,8 +77,11 @@ public:
packer<Stream>& pack_map(size_t n); packer<Stream>& pack_map(size_t n);
packer<Stream>& pack_raw(size_t l); packer<Stream>& pack_str(size_t l);
packer<Stream>& pack_raw_body(const char* b, size_t l); packer<Stream>& pack_str_body(const char* b, size_t l);
packer<Stream>& pack_bin(size_t l);
packer<Stream>& pack_bin_body(const char* b, size_t l);
private: private:
template <typename T> template <typename T>
@ -643,12 +646,16 @@ inline packer<Stream>& packer<Stream>::pack_map(size_t n)
} }
template <typename Stream> template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_raw(size_t l) inline packer<Stream>& packer<Stream>::pack_str(size_t l)
{ {
if(l < 32) { if(l < 32) {
unsigned char d = 0xa0 | (uint8_t)l; unsigned char d = 0xa0 | (uint8_t)l;
char buf = take8_8(d); char buf = take8_8(d);
append_buffer(&buf, 1); append_buffer(&buf, 1);
} else if(l < 256) {
char buf[2];
buf[0] = static_cast<char>(0xd9); buf[1] = (uint8_t)l;
append_buffer(buf, 2);
} else if(l < 65536) { } else if(l < 65536) {
char buf[3]; char buf[3];
buf[0] = static_cast<char>(0xda); _msgpack_store16(&buf[1], (uint16_t)l); buf[0] = static_cast<char>(0xda); _msgpack_store16(&buf[1], (uint16_t)l);
@ -662,7 +669,33 @@ inline packer<Stream>& packer<Stream>::pack_raw(size_t l)
} }
template <typename Stream> template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_raw_body(const char* b, size_t l) inline packer<Stream>& packer<Stream>::pack_str_body(const char* b, size_t l)
{
append_buffer(b, l);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_bin(size_t l)
{
if(l < 256) {
char buf[2];
buf[0] = static_cast<char>(0xc4); buf[1] = (uint8_t)l;
append_buffer(buf, 2);
} else if(l < 65536) {
char buf[3];
buf[0] = static_cast<char>(0xc5); _msgpack_store16(&buf[1], (uint16_t)l);
append_buffer(buf, 3);
} else {
char buf[5];
buf[0] = static_cast<char>(0xc6); _msgpack_store32(&buf[1], (uint32_t)l);
append_buffer(buf, 5);
}
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_bin_body(const char* b, size_t l)
{ {
append_buffer(b, l); append_buffer(b, l);
return *this; return *this;

36
src/msgpack/pack_template.h
View File

@ -749,14 +749,18 @@ msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n)
/* /*
* Raw * Str
*/ */
msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l) msgpack_pack_inline_func(_str)(msgpack_pack_user x, size_t l)
{ {
if(l < 32) { if(l < 32) {
unsigned char d = 0xa0 | (uint8_t)l; unsigned char d = 0xa0 | (uint8_t)l;
msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
} else if(l < 256) {
unsigned char buf[2];
buf[0] = 0xd9; buf[1] = (uint8_t)l;
msgpack_pack_append_buffer(x, buf, 2);
} else if(l < 65536) { } else if(l < 65536) {
unsigned char buf[3]; unsigned char buf[3];
buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
@ -768,7 +772,33 @@ msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l)
} }
} }
msgpack_pack_inline_func(_raw_body)(msgpack_pack_user x, const void* b, size_t l) msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l)
{
msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
}
/*
* Bin
*/
msgpack_pack_inline_func(_bin)(msgpack_pack_user x, size_t l)
{
if(l < 256) {
unsigned char buf[2];
buf[0] = 0xc4; buf[1] = (uint8_t)l;
msgpack_pack_append_buffer(x, buf, 2);
} else if(l < 65536) {
unsigned char buf[3];
buf[0] = 0xc5; _msgpack_store16(&buf[1], (uint16_t)l);
msgpack_pack_append_buffer(x, buf, 3);
} else {
unsigned char buf[5];
buf[0] = 0xc6; _msgpack_store32(&buf[1], (uint32_t)l);
msgpack_pack_append_buffer(x, buf, 5);
}
}
msgpack_pack_inline_func(_bin_body)(msgpack_pack_user x, const void* b, size_t l)
{ {
msgpack_pack_append_buffer(x, (const unsigned char*)b, l); msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
} }

16
src/msgpack/type/raw.hpp
View File

@ -63,25 +63,25 @@ struct raw_ref {
inline type::raw_ref& operator>> (object const& o, type::raw_ref& v) inline type::raw_ref& operator>> (object const& o, type::raw_ref& v)
{ {
if(o.type != type::RAW) { throw type_error(); } if(o.type != type::BIN) { throw type_error(); }
v.ptr = o.via.raw.ptr; v.ptr = o.via.bin.ptr;
v.size = o.via.raw.size; v.size = o.via.bin.size;
return v; return v;
} }
template <typename Stream> template <typename Stream>
inline packer<Stream>& operator<< (packer<Stream>& o, const type::raw_ref& v) inline packer<Stream>& operator<< (packer<Stream>& o, const type::raw_ref& v)
{ {
o.pack_raw(v.size); o.pack_bin(v.size);
o.pack_raw_body(v.ptr, v.size); o.pack_bin_body(v.ptr, v.size);
return o; return o;
} }
inline void operator<< (object& o, const type::raw_ref& v) inline void operator<< (object& o, const type::raw_ref& v)
{ {
o.type = type::RAW; o.type = type::BIN;
o.via.raw.ptr = v.ptr; o.via.bin.ptr = v.ptr;
o.via.raw.size = v.size; o.via.bin.size = v.size;
} }
inline void operator<< (object::with_zone& o, const type::raw_ref& v) inline void operator<< (object::with_zone& o, const type::raw_ref& v)

22
src/msgpack/type/string.hpp
View File

@ -26,33 +26,33 @@ namespace msgpack {
inline std::string& operator>> (object const& o, std::string& v) inline std::string& operator>> (object const& o, std::string& v)
{ {
if(o.type != type::RAW) { throw type_error(); } if(o.type != type::BIN) { throw type_error(); }
v.assign(o.via.raw.ptr, o.via.raw.size); v.assign(o.via.bin.ptr, o.via.bin.size);
return v; return v;
} }
template <typename Stream> template <typename Stream>
inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v) inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
{ {
o.pack_raw(v.size()); o.pack_bin(v.size());
o.pack_raw_body(v.data(), v.size()); o.pack_bin_body(v.data(), v.size());
return o; return o;
} }
inline void operator<< (object::with_zone& o, const std::string& v) inline void operator<< (object::with_zone& o, const std::string& v)
{ {
o.type = type::RAW; o.type = type::BIN;
char* ptr = static_cast<char*>(o.zone->malloc(v.size())); char* ptr = (char*)o.zone->malloc(v.size());
o.via.raw.ptr = ptr; o.via.bin.ptr = ptr;
o.via.raw.size = (uint32_t)v.size(); o.via.bin.size = (uint32_t)v.size();
memcpy(ptr, v.data(), v.size()); memcpy(ptr, v.data(), v.size());
} }
inline void operator<< (object& o, const std::string& v) inline void operator<< (object& o, const std::string& v)
{ {
o.type = type::RAW; o.type = type::BIN;
o.via.raw.ptr = v.data(); o.via.bin.ptr = v.data();
o.via.raw.size = (uint32_t)v.size(); o.via.bin.size = (uint32_t)v.size();
} }

90
src/msgpack/unpack.hpp
View File

@ -135,11 +135,19 @@ inline void unpack_map_item(unpack_user&, object& c, object const& k, object con
++c.via.map.size; ++c.via.map.size;
} }
inline void unpack_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) inline void unpack_str(unpack_user& u, const char* b, const char* p, unsigned int l, object& o)
{ {
o.type = type::RAW; o.type = type::STR;
o.via.raw.ptr = p; o.via.str.ptr = p;
o.via.raw.size = l; o.via.str.size = l;
u.set_referenced(true);
}
inline void unpack_bin(unpack_user& u, const char* b, const char* p, unsigned int l, object& o)
{
o.type = type::BIN;
o.via.bin.ptr = p;
o.via.bin.size = l;
u.set_referenced(true); u.set_referenced(true);
} }
@ -340,9 +348,9 @@ public:
//case 0xd6: // big integer 16 //case 0xd6: // big integer 16
//case 0xd7: // big integer 32 //case 0xd7: // big integer 32
//case 0xd8: // big float 16 //case 0xd8: // big float 16
case 0xd9: // raw 8 (str 8) case 0xd9: // str 8
case 0xda: // raw 16 (str 16) case 0xda: // str 16
case 0xdb: // raw 32 (str 32) case 0xdb: // str 32
trail = 1 << ((static_cast<unsigned int>(*p) & 0x03) - 1); trail = 1 << ((static_cast<unsigned int>(*p) & 0x03) - 1);
cs_ = next_cs(p); cs_ = next_cs(p);
fixed_trail_again = true; fixed_trail_again = true;
@ -359,14 +367,14 @@ public:
off = update_attributes(p, data, trail); off = update_attributes(p, data, trail);
return -1; return -1;
} }
} else if(0xa0 <= selector && selector <= 0xbf) { // FixRaw } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr
trail = static_cast<unsigned int>(*p) & 0x1f; trail = static_cast<unsigned int>(*p) & 0x1f;
if(trail == 0) { if(trail == 0) {
unpack_raw(user_, data, n, trail, obj); unpack_str(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail); int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret; if (ret != 0) return ret;
} }
cs_ = ACS_RAW_VALUE; cs_ = ACS_STR_VALUE;
fixed_trail_again = true; fixed_trail_again = true;
} else if(0x90 <= selector && selector <= 0x9f) { // FixArray } else if(0x90 <= selector && selector <= 0x9f) { // FixArray
@ -455,47 +463,85 @@ public:
int ret = push_proc(c, obj, p, data, off, trail); int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret; if (ret != 0) return ret;
} break; } break;
case CS_BIN_8: case CS_STR_8:
case CS_RAW_8:
trail = load<uint8_t>(n); trail = load<uint8_t>(n);
if(trail == 0) { if(trail == 0) {
unpack_raw(user_, data, n, trail, obj); unpack_str(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail); int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret; if (ret != 0) return ret;
} }
else { else {
cs_ = ACS_RAW_VALUE; cs_ = ACS_STR_VALUE;
fixed_trail_again = true;
}
break;
case CS_BIN_8:
trail = load<uint8_t>(n);
if(trail == 0) {
unpack_bin(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret;
}
else {
cs_ = ACS_BIN_VALUE;
fixed_trail_again = true;
}
break;
case CS_STR_16:
trail = load<uint16_t>(n);
if(trail == 0) {
unpack_str(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret;
}
else {
cs_ = ACS_STR_VALUE;
fixed_trail_again = true; fixed_trail_again = true;
} }
break; break;
case CS_BIN_16: case CS_BIN_16:
case CS_RAW_16:
trail = load<uint16_t>(n); trail = load<uint16_t>(n);
if(trail == 0) { if(trail == 0) {
unpack_raw(user_, data, n, trail, obj); unpack_bin(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail); int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret; if (ret != 0) return ret;
} }
else { else {
cs_ = ACS_RAW_VALUE; cs_ = ACS_BIN_VALUE;
fixed_trail_again = true;
}
break;
case CS_STR_32:
trail = load<uint32_t>(n);
if(trail == 0) {
unpack_str(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret;
}
else {
cs_ = ACS_STR_VALUE;
fixed_trail_again = true; fixed_trail_again = true;
} }
break; break;
case CS_BIN_32: case CS_BIN_32:
case CS_RAW_32:
trail = load<uint32_t>(n); trail = load<uint32_t>(n);
if(trail == 0) { if(trail == 0) {
unpack_raw(user_, data, n, trail, obj); unpack_bin(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail); int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret; if (ret != 0) return ret;
} }
else { else {
cs_ = ACS_RAW_VALUE; cs_ = ACS_BIN_VALUE;
fixed_trail_again = true; fixed_trail_again = true;
} }
break; break;
case ACS_RAW_VALUE: { case ACS_STR_VALUE: {
unpack_raw(user_, data, n, trail, obj); unpack_str(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret;
} break;
case ACS_BIN_VALUE: {
unpack_bin(user_, data, n, trail, obj);
int ret = push_proc(c, obj, p, data, off, trail); int ret = push_proc(c, obj, p, data, off, trail);
if (ret != 0) return ret; if (ret != 0) return ret;
} break; } break;

9
src/msgpack/unpack_define.h
View File

@ -66,9 +66,9 @@ typedef enum {
//CS_FIXEXT_8 = 0x17, //CS_FIXEXT_8 = 0x17,
//CS_FIXEXT_16 = 0x18, //CS_FIXEXT_16 = 0x18,
CS_RAW_8 = 0x19, // str8 CS_STR_8 = 0x19, // str8
CS_RAW_16 = 0x1a, // str16 CS_STR_16 = 0x1a, // str16
CS_RAW_32 = 0x1b, // str32 CS_STR_32 = 0x1b, // str32
CS_ARRAY_16 = 0x1c, CS_ARRAY_16 = 0x1c,
CS_ARRAY_32 = 0x1d, CS_ARRAY_32 = 0x1d,
CS_MAP_16 = 0x1e, CS_MAP_16 = 0x1e,
@ -76,7 +76,8 @@ typedef enum {
//ACS_BIG_INT_VALUE, //ACS_BIG_INT_VALUE,
//ACS_BIG_FLOAT_VALUE, //ACS_BIG_FLOAT_VALUE,
ACS_RAW_VALUE ACS_STR_VALUE,
ACS_BIN_VALUE
} msgpack_unpack_state; } msgpack_unpack_state;

34
src/msgpack/unpack_template.h
View File

@ -224,9 +224,9 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
//case 0xd6: // big integer 16 //case 0xd6: // big integer 16
//case 0xd7: // big integer 32 //case 0xd7: // big integer 32
//case 0xd8: // big float 16 //case 0xd8: // big float 16
case 0xd9: // raw 8 (str 8) case 0xd9: // str 8
case 0xda: // raw 16 (str 16) case 0xda: // str 16
case 0xdb: // raw 32 (str 32) case 0xdb: // str 32
again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1));
case 0xdc: // array 16 case 0xdc: // array 16
case 0xdd: // array 32 case 0xdd: // array 32
@ -236,8 +236,8 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
default: default:
goto _failed; goto _failed;
} }
SWITCH_RANGE(0xa0, 0xbf) // FixRaw SWITCH_RANGE(0xa0, 0xbf) // FixStr
again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero); again_fixed_trail_if_zero(ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero);
SWITCH_RANGE(0x90, 0x9f) // FixArray SWITCH_RANGE(0x90, 0x9f) // FixArray
start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM); start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM);
SWITCH_RANGE(0x80, 0x8f) // FixMap SWITCH_RANGE(0x80, 0x8f) // FixMap
@ -308,18 +308,24 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
// // FIXME // // FIXME
// push_variable_value(_big_float, data, n, trail); // push_variable_value(_big_float, data, n, trail);
case CS_STR_8:
again_fixed_trail_if_zero(ACS_STR_VALUE, *(uint8_t*)n, _str_zero);
case CS_BIN_8: case CS_BIN_8:
case CS_RAW_8: again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero);
again_fixed_trail_if_zero(ACS_RAW_VALUE, *(uint8_t*)n, _raw_zero); case CS_STR_16:
again_fixed_trail_if_zero(ACS_STR_VALUE, _msgpack_load16(uint16_t,n), _str_zero);
case CS_BIN_16: case CS_BIN_16:
case CS_RAW_16: again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load16(uint16_t,n), _bin_zero);
again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load16(uint16_t,n), _raw_zero); case CS_STR_32:
again_fixed_trail_if_zero(ACS_STR_VALUE, _msgpack_load32(uint32_t,n), _str_zero);
case CS_BIN_32: case CS_BIN_32:
case CS_RAW_32: again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load32(uint32_t,n), _bin_zero);
again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load32(uint32_t,n), _raw_zero); case ACS_STR_VALUE:
case ACS_RAW_VALUE: _str_zero:
_raw_zero: push_variable_value(_str, data, n, trail);
push_variable_value(_raw, data, n, trail); case ACS_BIN_VALUE:
_bin_zero:
push_variable_value(_bin, data, n, trail);
case CS_ARRAY_16: case CS_ARRAY_16:
start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM); start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM);

33
src/objectc.c
View File

@ -54,11 +54,18 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
case MSGPACK_OBJECT_DOUBLE: case MSGPACK_OBJECT_DOUBLE:
return msgpack_pack_double(pk, d.via.dec); return msgpack_pack_double(pk, d.via.dec);
case MSGPACK_OBJECT_RAW: case MSGPACK_OBJECT_STR:
{ {
int ret = msgpack_pack_raw(pk, d.via.raw.size); int ret = msgpack_pack_str(pk, d.via.str.size);
if(ret < 0) { return ret; } if(ret < 0) { return ret; }
return msgpack_pack_raw_body(pk, d.via.raw.ptr, d.via.raw.size); return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size);
}
case MSGPACK_OBJECT_BIN:
{
int ret = msgpack_pack_bin(pk, d.via.bin.size);
if(ret < 0) { return ret; }
return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size);
} }
case MSGPACK_OBJECT_ARRAY: case MSGPACK_OBJECT_ARRAY:
@ -122,9 +129,15 @@ void msgpack_object_print(FILE* out, msgpack_object o)
fprintf(out, "%f", o.via.dec); fprintf(out, "%f", o.via.dec);
break; break;
case MSGPACK_OBJECT_RAW: case MSGPACK_OBJECT_STR:
fprintf(out, "\""); fprintf(out, "\"");
fwrite(o.via.raw.ptr, o.via.raw.size, 1, out); fwrite(o.via.str.ptr, o.via.str.size, 1, out);
fprintf(out, "\"");
break;
case MSGPACK_OBJECT_BIN:
fprintf(out, "\"");
fwrite(o.via.bin.ptr, o.via.bin.size, 1, out);
fprintf(out, "\""); fprintf(out, "\"");
break; break;
@ -188,9 +201,13 @@ bool msgpack_object_equal(const msgpack_object x, const msgpack_object y)
case MSGPACK_OBJECT_DOUBLE: case MSGPACK_OBJECT_DOUBLE:
return x.via.dec == y.via.dec; return x.via.dec == y.via.dec;
case MSGPACK_OBJECT_RAW: case MSGPACK_OBJECT_STR:
return x.via.raw.size == y.via.raw.size && return x.via.str.size == y.via.str.size &&
memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0; memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0;
case MSGPACK_OBJECT_BIN:
return x.via.bin.size == y.via.bin.size &&
memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0;
case MSGPACK_OBJECT_ARRAY: case MSGPACK_OBJECT_ARRAY:
if(x.via.array.size != y.via.array.size) { if(x.via.array.size != y.via.array.size) {

17
src/unpack.c
View File

@ -143,11 +143,20 @@ static inline int template_callback_map_item(unpack_user* u, msgpack_object* c,
return 0; return 0;
} }
static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
{ {
o->type = MSGPACK_OBJECT_RAW; o->type = MSGPACK_OBJECT_STR;
o->via.raw.ptr = p; o->via.str.ptr = p;
o->via.raw.size = l; o->via.str.size = l;
u->referenced = true;
return 0;
}
static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
{
o->type = MSGPACK_OBJECT_BIN;
o->via.bin.ptr = p;
o->via.bin.size = l;
u->referenced = true; u->referenced = true;
return 0; return 0;
} }

112
test/msgpackc_test.cpp
View File

@ -417,20 +417,20 @@ TEST(MSGPACKC, simple_buffer_map)
msgpack_sbuffer_destroy(&sbuf); msgpack_sbuffer_destroy(&sbuf);
} }
TEST(MSGPACKC, simple_buffer_raw) TEST(MSGPACKC, simple_buffer_str)
{ {
unsigned int raw_size = 7; unsigned int str_size = 7;
msgpack_sbuffer sbuf; msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf); msgpack_sbuffer_init(&sbuf);
msgpack_packer pk; msgpack_packer pk;
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_raw(&pk, raw_size); msgpack_pack_str(&pk, str_size);
msgpack_pack_raw_body(&pk, "fr", 2); msgpack_pack_str_body(&pk, "fr", 2);
msgpack_pack_raw_body(&pk, "syuki", 5); msgpack_pack_str_body(&pk, "syuki", 5);
// invalid data // invalid data
msgpack_pack_raw_body(&pk, "", 0); msgpack_pack_str_body(&pk, "", 0);
msgpack_pack_raw_body(&pk, "kzk", 0); msgpack_pack_str_body(&pk, "kzk", 0);
msgpack_zone z; msgpack_zone z;
msgpack_zone_init(&z, 2048); msgpack_zone_init(&z, 2048);
@ -438,17 +438,37 @@ TEST(MSGPACKC, simple_buffer_raw)
msgpack_unpack_return ret; msgpack_unpack_return ret;
ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
EXPECT_EQ(raw_size, obj.via.raw.size); EXPECT_EQ(str_size, obj.via.str.size);
EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
msgpack_zone_destroy(&z); msgpack_zone_destroy(&z);
msgpack_sbuffer_destroy(&sbuf); msgpack_sbuffer_destroy(&sbuf);
} }
TEST(MSGPACKC, unpack_fixstr)
{
size_t str_size = 7;
const char buf[] = {
(char)0xa7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
};
msgpack_zone z;
msgpack_zone_init(&z, 2048);
msgpack_object obj;
msgpack_unpack_return ret;
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
EXPECT_EQ(str_size, obj.via.str.size);
EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
msgpack_zone_destroy(&z);
}
TEST(MSGPACKC, unpack_str8) TEST(MSGPACKC, unpack_str8)
{ {
size_t raw_size = 7; size_t str_size = 7;
const char buf[] = { const char buf[] = {
(char)0xd9, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' (char)0xd9, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
}; };
@ -459,16 +479,56 @@ TEST(MSGPACKC, unpack_str8)
msgpack_unpack_return ret; msgpack_unpack_return ret;
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
EXPECT_EQ(raw_size, obj.via.raw.size); EXPECT_EQ(str_size, obj.via.str.size);
EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
msgpack_zone_destroy(&z);
}
TEST(MSGPACKC, unpack_str16)
{
size_t str_size = 7;
const char buf[] = {
(char)0xda, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
};
msgpack_zone z;
msgpack_zone_init(&z, 2048);
msgpack_object obj;
msgpack_unpack_return ret;
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
EXPECT_EQ(str_size, obj.via.str.size);
EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
msgpack_zone_destroy(&z);
}
TEST(MSGPACKC, unpack_str32)
{
size_t str_size = 7;
const char buf[] = {
(char)0xdb, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
};
msgpack_zone z;
msgpack_zone_init(&z, 2048);
msgpack_object obj;
msgpack_unpack_return ret;
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
EXPECT_EQ(str_size, obj.via.str.size);
EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size));
msgpack_zone_destroy(&z); msgpack_zone_destroy(&z);
} }
TEST(MSGPACKC, unpack_bin8) TEST(MSGPACKC, unpack_bin8)
{ {
size_t raw_size = 7; size_t bin_size = 7;
const char buf[] = { const char buf[] = {
(char)0xc4, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' (char)0xc4, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
}; };
@ -479,16 +539,16 @@ TEST(MSGPACKC, unpack_bin8)
msgpack_unpack_return ret; msgpack_unpack_return ret;
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
EXPECT_EQ(raw_size, obj.via.raw.size); EXPECT_EQ(bin_size, obj.via.bin.size);
EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size));
msgpack_zone_destroy(&z); msgpack_zone_destroy(&z);
} }
TEST(MSGPACKC, unpack_bin16) TEST(MSGPACKC, unpack_bin16)
{ {
size_t raw_size = 7; size_t bin_size = 7;
const char buf[] = { const char buf[] = {
(char)0xc5, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' (char)0xc5, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
}; };
@ -499,16 +559,16 @@ TEST(MSGPACKC, unpack_bin16)
msgpack_unpack_return ret; msgpack_unpack_return ret;
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
EXPECT_EQ(raw_size, obj.via.raw.size); EXPECT_EQ(bin_size, obj.via.bin.size);
EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size));
msgpack_zone_destroy(&z); msgpack_zone_destroy(&z);
} }
TEST(MSGPACKC, unpack_bin32) TEST(MSGPACKC, unpack_bin32)
{ {
size_t raw_size = 7; size_t bin_size = 7;
const char buf[] = { const char buf[] = {
(char)0xc6, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' (char)0xc6, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i'
}; };
@ -519,9 +579,9 @@ TEST(MSGPACKC, unpack_bin32)
msgpack_unpack_return ret; msgpack_unpack_return ret;
ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj);
EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
EXPECT_EQ(raw_size, obj.via.raw.size); EXPECT_EQ(bin_size, obj.via.bin.size);
EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size));
msgpack_zone_destroy(&z); msgpack_zone_destroy(&z);
} }

34
test/streaming_c.cc
View File

@ -8,15 +8,20 @@ TEST(streaming, basic)
msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
// 1, 2, 3, "raw", ["data"], {0.3: 0.4} // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4}
EXPECT_EQ(0, msgpack_pack_int(pk, 1)); EXPECT_EQ(0, msgpack_pack_int(pk, 1));
EXPECT_EQ(0, msgpack_pack_int(pk, 2)); EXPECT_EQ(0, msgpack_pack_int(pk, 2));
EXPECT_EQ(0, msgpack_pack_int(pk, 3)); EXPECT_EQ(0, msgpack_pack_int(pk, 3));
EXPECT_EQ(0, msgpack_pack_raw(pk, 3)); EXPECT_EQ(0, msgpack_pack_str(pk, 3));
EXPECT_EQ(0, msgpack_pack_raw_body(pk, "raw", 3)); EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3));
EXPECT_EQ(0, msgpack_pack_array(pk, 1)); EXPECT_EQ(0, msgpack_pack_array(pk, 1));
EXPECT_EQ(0, msgpack_pack_raw(pk, 4)); EXPECT_EQ(0, msgpack_pack_str(pk, 8));
EXPECT_EQ(0, msgpack_pack_raw_body(pk, "data", 4)); EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8));
EXPECT_EQ(0, msgpack_pack_bin(pk, 3));
EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3));
EXPECT_EQ(0, msgpack_pack_array(pk, 1));
EXPECT_EQ(0, msgpack_pack_bin(pk, 8));
EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8));
EXPECT_EQ(0, msgpack_pack_map(pk, 1)); EXPECT_EQ(0, msgpack_pack_map(pk, 1));
EXPECT_EQ(0, msgpack_pack_float(pk, 0.4)); EXPECT_EQ(0, msgpack_pack_float(pk, 0.4));
EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); EXPECT_EQ(0, msgpack_pack_double(pk, 0.8));
@ -67,17 +72,28 @@ TEST(streaming, basic)
EXPECT_EQ(3, obj.via.u64); EXPECT_EQ(3, obj.via.u64);
break; break;
case 3: case 3:
EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type);
EXPECT_EQ(std::string("raw",3), std::string(obj.via.raw.ptr, obj.via.raw.size)); EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size));
break; break;
case 4: case 4:
EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
EXPECT_EQ(1, obj.via.array.size); EXPECT_EQ(1, obj.via.array.size);
e = obj.via.array.ptr[0]; e = obj.via.array.ptr[0];
EXPECT_EQ(MSGPACK_OBJECT_RAW, e.type); EXPECT_EQ(MSGPACK_OBJECT_STR, e.type);
EXPECT_EQ(std::string("data",4), std::string(e.via.raw.ptr, e.via.raw.size)); EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size));
break; break;
case 5: case 5:
EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type);
EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size));
break;
case 6:
EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type);
EXPECT_EQ(1, obj.via.array.size);
e = obj.via.array.ptr[0];
EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type);
EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size));
break;
case 7:
EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type);
EXPECT_EQ(1, obj.via.map.size); EXPECT_EQ(1, obj.via.map.size);
e = obj.via.map.ptr[0].key; e = obj.via.map.ptr[0].key;