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

rewrite msgpack::object::via

Browse Source
This commit is contained in:
frsyuki 2009-02-15 18:39:30 +09:00
parent 6083300ea9
commit 761b398083
11 changed files with 165 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
c/object.c
View File

@ -98,42 +98,42 @@ static inline msgpack_object msgpack_unpack_array(unpack_user* u, unsigned int n
{ {
msgpack_object o; msgpack_object o;
o.type = MSGPACK_OBJECT_ARRAY; o.type = MSGPACK_OBJECT_ARRAY;
o.via.container.size = 0; o.via.array.size = 0;
o.via.container.ptr = msgpack_zone_malloc(u->z, n*sizeof(msgpack_object)); o.via.array.ptr = msgpack_zone_malloc(u->z, n*sizeof(msgpack_object));
if(o.via.container.ptr == NULL) { u->failed = true; } if(o.via.array.ptr == NULL) { u->failed = true; }
return o; return o;
} }
static inline void msgpack_unpack_array_item(unpack_user* u, msgpack_object* c, msgpack_object o) static inline void msgpack_unpack_array_item(unpack_user* u, msgpack_object* c, msgpack_object o)
{ {
if(u->failed) { return; } if(u->failed) { return; }
c->via.container.ptr[ c->via.container.size++ ] = o; c->via.array.ptr[ c->via.array.size++ ] = o;
} }
static inline msgpack_object msgpack_unpack_map(unpack_user* u, unsigned int n) static inline msgpack_object msgpack_unpack_map(unpack_user* u, unsigned int n)
{ {
msgpack_object o; msgpack_object o;
o.type = MSGPACK_OBJECT_MAP; o.type = MSGPACK_OBJECT_MAP;
o.via.container.size = 0; o.via.map.size = 0;
o.via.container.ptr = msgpack_zone_malloc(u->z, n*2*sizeof(msgpack_object)); o.via.map.ptr = msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv));
if(o.via.container.ptr == NULL) { u->failed = true; } if(o.via.map.ptr == NULL) { u->failed = true; }
return o; return o;
} }
static inline void msgpack_unpack_map_item(unpack_user* u, msgpack_object* c, msgpack_object k, msgpack_object v) static inline void msgpack_unpack_map_item(unpack_user* u, msgpack_object* c, msgpack_object k, msgpack_object v)
{ {
if(u->failed) { return; } if(u->failed) { return; }
c->via.container.ptr[ c->via.container.size ] = k; c->via.map.ptr[c->via.map.size].key = k;
c->via.container.ptr[ c->via.container.size+1 ] = v; c->via.map.ptr[c->via.map.size].val = v;
++c->via.container.size; ++c->via.map.size;
} }
static inline msgpack_object msgpack_unpack_raw(unpack_user* u, const char* b, const char* p, unsigned int l) static inline msgpack_object msgpack_unpack_raw(unpack_user* u, const char* b, const char* p, unsigned int l)
{ {
msgpack_object o; msgpack_object o;
o.type = MSGPACK_OBJECT_RAW; o.type = MSGPACK_OBJECT_RAW;
o.via.ref.ptr = p; o.via.raw.ptr = p;
o.via.ref.size = l; o.via.raw.size = l;
u->referenced = true; u->referenced = true;
return o; return o;
} }

32
c/object.h
View File

@ -41,19 +41,31 @@ typedef enum {
struct _msgpack_object; struct _msgpack_object;
struct _msgpack_object_kv;
typedef struct {
uint32_t size;
struct _msgpack_object* ptr;
} msgpack_object_array;
typedef struct {
uint32_t size;
struct _msgpack_object_kv* ptr;
} msgpack_object_map;
typedef struct {
uint32_t size;
const char* ptr;
} msgpack_object_raw;
typedef union { typedef union {
bool boolean; bool boolean;
uint64_t u64; uint64_t u64;
int64_t i64; int64_t i64;
double dec; double dec;
struct { msgpack_object_array array;
struct _msgpack_object* ptr; msgpack_object_map map;
uint32_t size; msgpack_object_raw raw;
} container;
struct {
const char* ptr;
uint32_t size;
} ref;
} msgpack_object_union; } msgpack_object_union;
typedef struct _msgpack_object { typedef struct _msgpack_object {
@ -61,6 +73,10 @@ typedef struct _msgpack_object {
msgpack_object_union via; msgpack_object_union via;
} msgpack_object; } msgpack_object;
typedef struct _msgpack_object_kv {
msgpack_object key;
msgpack_object val;
} msgpack_object_kv;
typedef enum { typedef enum {
MSGPACK_OBJECT_PARSE_SUCCESS = 0, MSGPACK_OBJECT_PARSE_SUCCESS = 0,

58
c/pack.h
View File

@ -21,6 +21,7 @@
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include "msgpack/pack_define.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -34,42 +35,43 @@ typedef struct {
msgpack_pack_write_t callback; msgpack_pack_write_t callback;
} msgpack_pack_t; } msgpack_pack_t;
void msgpack_pack_init(msgpack_pack_t* ctx, void* data, msgpack_pack_write_t callback); static void msgpack_pack_init(msgpack_pack_t* ctx, void* data, msgpack_pack_write_t callback);
msgpack_pack_t* msgpack_pack_new(void* data, msgpack_pack_write_t callback); static msgpack_pack_t* msgpack_pack_new(void* data, msgpack_pack_write_t callback);
void msgpack_pack_free(msgpack_pack_t* ctx);
int msgpack_pack_short(msgpack_pack_t* ctx, short d); static void msgpack_pack_free(msgpack_pack_t* ctx);
int msgpack_pack_int(msgpack_pack_t* ctx, int d);
int msgpack_pack_long(msgpack_pack_t* ctx, long d);
int msgpack_pack_long_long(msgpack_pack_t* ctx, long long d);
int msgpack_pack_unsigned_short(msgpack_pack_t* ctx, unsigned short d);
int msgpack_pack_unsigned_int(msgpack_pack_t* ctx, unsigned int d);
int msgpack_pack_unsigned_long(msgpack_pack_t* ctx, unsigned long d);
int msgpack_pack_unsigned_long_long(msgpack_pack_t* ctx, unsigned long long d);
int msgpack_pack_uint8(msgpack_pack_t* ctx, uint8_t d); static int msgpack_pack_short(msgpack_pack_t* ctx, short d);
int msgpack_pack_uint16(msgpack_pack_t* ctx, uint16_t d); static int msgpack_pack_int(msgpack_pack_t* ctx, int d);
int msgpack_pack_uint32(msgpack_pack_t* ctx, uint32_t d); static int msgpack_pack_long(msgpack_pack_t* ctx, long d);
int msgpack_pack_uint64(msgpack_pack_t* ctx, uint64_t d); static int msgpack_pack_long_long(msgpack_pack_t* ctx, long long d);
int msgpack_pack_int8(msgpack_pack_t* ctx, int8_t d); static int msgpack_pack_unsigned_short(msgpack_pack_t* ctx, unsigned short d);
int msgpack_pack_int16(msgpack_pack_t* ctx, int16_t d); static int msgpack_pack_unsigned_int(msgpack_pack_t* ctx, unsigned int d);
int msgpack_pack_int32(msgpack_pack_t* ctx, int32_t d); static int msgpack_pack_unsigned_long(msgpack_pack_t* ctx, unsigned long d);
int msgpack_pack_int64(msgpack_pack_t* ctx, int64_t d); static int msgpack_pack_unsigned_long_long(msgpack_pack_t* ctx, unsigned long long d);
int msgpack_pack_float(msgpack_pack_t* ctx, float d); static int msgpack_pack_uint8(msgpack_pack_t* ctx, uint8_t d);
int msgpack_pack_double(msgpack_pack_t* ctx, double d); static int msgpack_pack_uint16(msgpack_pack_t* ctx, uint16_t d);
static int msgpack_pack_uint32(msgpack_pack_t* ctx, uint32_t d);
static int msgpack_pack_uint64(msgpack_pack_t* ctx, uint64_t d);
static int msgpack_pack_int8(msgpack_pack_t* ctx, int8_t d);
static int msgpack_pack_int16(msgpack_pack_t* ctx, int16_t d);
static int msgpack_pack_int32(msgpack_pack_t* ctx, int32_t d);
static int msgpack_pack_int64(msgpack_pack_t* ctx, int64_t d);
int msgpack_pack_nil(msgpack_pack_t* ctx); static int msgpack_pack_float(msgpack_pack_t* ctx, float d);
int msgpack_pack_true(msgpack_pack_t* ctx); static int msgpack_pack_double(msgpack_pack_t* ctx, double d);
int msgpack_pack_false(msgpack_pack_t* ctx);
int msgpack_pack_array(msgpack_pack_t* ctx, unsigned int n); static int msgpack_pack_nil(msgpack_pack_t* ctx);
static int msgpack_pack_true(msgpack_pack_t* ctx);
static int msgpack_pack_false(msgpack_pack_t* ctx);
int msgpack_pack_map(msgpack_pack_t* ctx, unsigned int n); static int msgpack_pack_array(msgpack_pack_t* ctx, unsigned int n);
int msgpack_pack_raw(msgpack_pack_t* ctx, size_t l); static int msgpack_pack_map(msgpack_pack_t* ctx, unsigned int n);
int msgpack_pack_raw_body(msgpack_pack_t* ctx, const void* b, size_t l);
static int msgpack_pack_raw(msgpack_pack_t* ctx, size_t l);
static int msgpack_pack_raw_body(msgpack_pack_t* ctx, const void* b, size_t l);

2
c/zone.c
View File

@ -41,7 +41,7 @@ void msgpack_zone_free(msgpack_zone* z)
if(z->array) { if(z->array) {
size_t i; size_t i;
for(i=0; i <= z->ntail; ++i) { for(i=0; i <= z->ntail; ++i) {
free(z->array[i].ptr); free(z->array[i].alloc);
} }
} }
free(z); free(z);

48
cpp/object.cpp
View File

@ -46,16 +46,16 @@ std::ostream& operator<< (std::ostream& s, const object o)
break; break;
case type::RAW: case type::RAW:
(s << '"').write(o.via.ref.ptr, o.via.ref.size) << '"'; (s << '"').write(o.via.raw.ptr, o.via.raw.size) << '"';
break; break;
case type::ARRAY: case type::ARRAY:
s << "["; s << "[";
if(o.via.container.size != 0) { if(o.via.array.size != 0) {
object* p(o.via.container.ptr); object* p(o.via.array.ptr);
s << *p; s << *p;
++p; ++p;
for(object* const pend(o.via.container.ptr + o.via.container.size); for(object* const pend(o.via.array.ptr + o.via.array.size);
p < pend; ++p) { p < pend; ++p) {
s << ", " << *p; s << ", " << *p;
} }
@ -66,17 +66,13 @@ std::ostream& operator<< (std::ostream& s, const object o)
case type::MAP: case type::MAP:
s << "{"; s << "{";
if(o.via.container.size != 0) { if(o.via.map.size != 0) {
object* p(o.via.container.ptr); object_kv* p(o.via.map.ptr);
object* const pend(o.via.container.ptr + o.via.container.size*2); s << p->key << "=>" << p->val;
s << *p; ++p; ++p;
s << "=>"; for(object_kv* const pend(o.via.map.ptr + o.via.map.size);
s << *p; ++p; p < pend; ++p) {
while(p < pend) { s << ", " << p->key << "=>" << p->val;
s << ", ";
s << *p; ++p;
s << "=>";
s << *p; ++p;
} }
} }
s << "}"; s << "}";
@ -109,14 +105,14 @@ bool operator==(const object x, const object y)
return x.via.i64 == y.via.i64; return x.via.i64 == y.via.i64;
case type::RAW: case type::RAW:
return x.via.ref.size == y.via.ref.size && return x.via.raw.size == y.via.raw.size &&
memcmp(x.via.ref.ptr, y.via.ref.ptr, x.via.ref.size) == 0; memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0;
case type::ARRAY: case type::ARRAY:
if(x.via.container.size != y.via.container.size) { return false; } if(x.via.array.size != y.via.array.size) { return false; }
for(object* px(x.via.container.ptr), for(object* px(x.via.array.ptr),
* const pxend(x.via.container.ptr + x.via.container.size), * const pxend(x.via.array.ptr + x.via.array.size),
* py(y.via.container.ptr); * py(y.via.array.ptr);
px < pxend; ++px, ++py) { px < pxend; ++px, ++py) {
if(*px != *py) { return false; } if(*px != *py) { return false; }
} }
@ -124,12 +120,12 @@ bool operator==(const object x, const object y)
// FIXME loop optimiziation // FIXME loop optimiziation
case type::MAP: case type::MAP:
if(x.via.container.size != y.via.container.size) { return false; } if(x.via.map.size != y.via.map.size) { return false; }
for(object* px(x.via.container.ptr), for(object_kv* px(x.via.map.ptr),
* const pxend(x.via.container.ptr + x.via.container.size*2), * const pxend(x.via.map.ptr + x.via.map.size),
* py(y.via.container.ptr); * py(y.via.map.ptr);
px < pxend; ++px, ++py) { px < pxend; ++px, ++py) {
if(*px != *py) { return false; } if(px->key != py->key || px->val != py->val) { return false; }
} }
return true; return true;

56
cpp/object.hpp
View File

@ -45,20 +45,33 @@ namespace type {
} }
struct object;
struct object_kv;
struct object_array {
uint32_t size;
object* ptr;
};
struct object_map {
uint32_t size;
object_kv* ptr;
};
struct object_raw {
uint32_t size;
const char* ptr;
};
struct object { struct object {
union union_type { union union_type {
bool boolean; bool boolean;
uint64_t u64; uint64_t u64;
int64_t i64; int64_t i64;
double dec; double dec;
struct { object_array array;
object* ptr; object_map map;
uint32_t size; object_raw raw;
} container;
struct {
const char* ptr;
uint32_t size;
} ref;
}; };
type::object_type type; type::object_type type;
@ -79,6 +92,11 @@ public:
implicit_type convert(); implicit_type convert();
}; };
struct object_kv {
object key;
object val;
};
bool operator==(const object x, const object y); bool operator==(const object x, const object y);
bool operator!=(const object x, const object y); bool operator!=(const object x, const object y);
@ -258,14 +276,14 @@ packer<Stream>& operator<< (packer<Stream>& o, const object& v)
return o; return o;
case type::RAW: case type::RAW:
o.pack_raw(v.via.ref.size); o.pack_raw(v.via.raw.size);
o.pack_raw_body(v.via.ref.ptr, v.via.ref.size); o.pack_raw_body(v.via.raw.ptr, v.via.raw.size);
return o; return o;
case type::ARRAY: case type::ARRAY:
o.pack_array(v.via.container.size); o.pack_array(v.via.array.size);
for(object* p(v.via.container.ptr), for(object* p(v.via.array.ptr),
* const pend(v.via.container.ptr + v.via.container.size); * const pend(v.via.array.ptr + v.via.array.size);
p < pend; ++p) { p < pend; ++p) {
*p >> o; *p >> o;
} }
@ -273,12 +291,12 @@ packer<Stream>& operator<< (packer<Stream>& o, const object& v)
// FIXME loop optimiziation // FIXME loop optimiziation
case type::MAP: case type::MAP:
o.pack_map(v.via.container.size); o.pack_map(v.via.map.size);
for(object* p(v.via.container.ptr), for(object_kv* p(v.via.map.ptr),
* const pend(v.via.container.ptr + v.via.container.size*2); * const pend(v.via.map.ptr + v.via.map.size);
p < pend; ) { p < pend; ++p) {
*p >> o; ++p; p->key >> o;
*p >> o; ++p; p->val >> o;
} }
return o; return o;
// FIXME loop optimiziation // FIXME loop optimiziation

6
cpp/type/array.hpp
View File

@ -28,9 +28,9 @@ template <typename T>
inline std::vector<T> operator>> (object o, std::vector<T>& v) inline std::vector<T> operator>> (object o, std::vector<T>& v)
{ {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
v.resize(o.via.container.size); v.resize(o.via.array.size);
object* p = o.via.container.ptr; object* p = o.via.array.ptr;
object* const pend = o.via.container.ptr + o.via.container.size; object* const pend = o.via.array.ptr + o.via.array.size;
T* it = &v.front(); T* it = &v.front();
for(; p < pend; ++p, ++it) { for(; p < pend; ++p, ++it) {
p->convert(it); p->convert(it);

36
cpp/type/map.hpp
View File

@ -46,13 +46,13 @@ template <typename K, typename V>
inline type::assoc_vector<K,V>& operator>> (object o, type::assoc_vector<K,V>& v) inline type::assoc_vector<K,V>& operator>> (object o, type::assoc_vector<K,V>& v)
{ {
if(o.type != type::MAP) { throw type_error(); } if(o.type != type::MAP) { throw type_error(); }
v.resize(o.via.container.size); v.resize(o.via.map.size);
object* p = o.via.container.ptr; object_kv* p = o.via.map.ptr;
object* const pend = o.via.container.ptr + o.via.container.size; object_kv* const pend = o.via.map.ptr + o.via.map.size;
std::pair<K, V>* it(&v.front()); std::pair<K, V>* it(&v.front());
for(; p < pend; ++it) { for(; p < pend; ++p, ++it) {
p->convert(&it->first); ++p; p->key.convert(&it->first);
p->convert(&it->second); ++p; p->val.convert(&it->second);
} }
std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>()); std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
return v; return v;
@ -75,18 +75,18 @@ template <typename K, typename V>
inline std::map<K, V> operator>> (object o, std::map<K, V>& v) inline std::map<K, V> operator>> (object o, std::map<K, V>& v)
{ {
if(o.type != type::MAP) { throw type_error(); } if(o.type != type::MAP) { throw type_error(); }
object* p(o.via.container.ptr); object_kv* p(o.via.map.ptr);
object* const pend(o.via.container.ptr + o.via.container.size*2); object_kv* const pend(o.via.map.ptr + o.via.map.size);
while(p < pend) { for(; p != pend; ++p) {
K key; K key;
p->convert(&key); ++p; p->key.convert(&key);
typename std::map<K,V>::iterator it(v.find(key)); typename std::map<K,V>::iterator it(v.find(key));
if(it != v.end()) { if(it != v.end()) {
V val; V val;
p->convert(&val); ++p; p->val.convert(&val);
it->insert( std::pair<K,V>(key, val) ); it->insert( std::pair<K,V>(key, val) );
} else { } else {
p->convert(&it->second); ++p; p->val.convert(&it->second);
} }
} }
return v; return v;
@ -109,12 +109,12 @@ template <typename K, typename V>
inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v) inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v)
{ {
if(o.type != type::MAP) { throw type_error(); } if(o.type != type::MAP) { throw type_error(); }
object* p = o.via.container.ptr; object_kv* p(o.via.map.ptr);
object* const pend = o.via.container.ptr + o.via.container.size*2; object_kv* const pend(o.via.map.ptr + o.via.map.size);
while(p < pend) { for(; p != pend; ++p) {
std::pair<K, V> value; std::pair<K, V> value;
p->convert(&value.first); ++p; p->key.convert(&value.first);
p->convert(&value.second); ++p; p->val.convert(&value.second);
v.insert(value); v.insert(value);
} }
return v; return v;
@ -123,7 +123,7 @@ inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v)
template <typename Stream, typename K, typename V> template <typename Stream, typename K, typename V>
inline packer<Stream>& operator<< (packer<Stream>& o, const std::multimap<K,V>& v) inline packer<Stream>& operator<< (packer<Stream>& o, const std::multimap<K,V>& v)
{ {
o.pack_multimap(v.size()); o.pack_map(v.size());
for(typename std::multimap<K,V>::const_iterator it(v.begin()), it_end(v.end()); for(typename std::multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
it != it_end; ++it) { it != it_end; ++it) {
o.pack(it->first); o.pack(it->first);

10
cpp/type/raw.hpp
View File

@ -27,11 +27,11 @@ namespace msgpack {
namespace type { namespace type {
struct raw_ref { struct raw_ref {
raw_ref() : ptr(NULL), size(0) {} raw_ref() : size(0), ptr(NULL) {}
raw_ref(const char* p, uint32_t s) : ptr(p), size(s) {} raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
const char* ptr;
uint32_t size; uint32_t size;
const char* ptr;
std::string str() { return std::string(ptr, size); } std::string str() { return std::string(ptr, size); }
@ -64,8 +64,8 @@ struct raw_ref {
inline type::raw_ref& operator>> (object o, type::raw_ref& v) inline type::raw_ref& operator>> (object o, type::raw_ref& v)
{ {
if(o.type != type::RAW) { throw type_error(); } if(o.type != type::RAW) { throw type_error(); }
v.ptr = o.via.ref.ptr; v.ptr = o.via.raw.ptr;
v.size = o.via.ref.size; v.size = o.via.raw.size;
return v; return v;
} }

4
cpp/type/tuple.hpp.erb
View File

@ -136,9 +136,9 @@ type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& operator>> (
object o, object o,
type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) { type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
if(o.type != type::ARRAY) { throw type_error(); } if(o.type != type::ARRAY) { throw type_error(); }
if(o.via.container.size < <%=i+1%>) { throw type_error(); } if(o.via.array.size < <%=i+1%>) { throw type_error(); }
<%0.upto(i) {|j|%> <%0.upto(i) {|j|%>
o.via.container.ptr[<%=j%>].convert<A<%=j%>>(&v.template get<<%=j%>>());<%}%> o.via.array.ptr[<%=j%>].convert<A<%=j%>>(&v.template get<<%=j%>>());<%}%>
return v; return v;
} }
<%}%> <%}%>

22
cpp/unpack.cpp
View File

@ -104,36 +104,36 @@ static inline object msgpack_unpack_array(unpack_user* u, unsigned int n)
{ {
object o; object o;
o.type = type::ARRAY; o.type = type::ARRAY;
o.via.container.size = 0; o.via.array.size = 0;
o.via.container.ptr = (object*)u->z->malloc(n*sizeof(object)); o.via.array.ptr = (object*)u->z->malloc(n*sizeof(object));
return o; return o;
} }
static inline void msgpack_unpack_array_item(unpack_user* u, object* c, object o) static inline void msgpack_unpack_array_item(unpack_user* u, object* c, object o)
{ c->via.container.ptr[ c->via.container.size++ ] = o; } { c->via.array.ptr[c->via.array.size++] = o; }
static inline object msgpack_unpack_map(unpack_user* u, unsigned int n) static inline object msgpack_unpack_map(unpack_user* u, unsigned int n)
{ {
object o; object o;
o.type = type::MAP; o.type = type::MAP;
o.via.container.size = 0; o.via.map.size = 0;
o.via.container.ptr = (object*)u->z->malloc(n*2*sizeof(object)); o.via.map.ptr = (object_kv*)u->z->malloc(n*sizeof(object_kv));
return o; return o;
} }
static inline void msgpack_unpack_map_item(unpack_user* u, object* c, object k, object v) static inline void msgpack_unpack_map_item(unpack_user* u, object* c, object k, object v)
{ {
c->via.container.ptr[ c->via.container.size ] = k; c->via.map.ptr[c->via.map.size].key = k;
c->via.container.ptr[ c->via.container.size+1 ] = v; c->via.map.ptr[c->via.map.size].val = v;
++c->via.container.size; ++c->via.map.size;
} }
static inline object msgpack_unpack_raw(unpack_user* u, const char* b, const char* p, unsigned int l) static inline object msgpack_unpack_raw(unpack_user* u, const char* b, const char* p, unsigned int l)
{ {
object o; object o;
o.type = type::RAW; o.type = type::RAW;
o.via.ref.ptr = p; o.via.raw.ptr = p;
o.via.ref.size = l; o.via.raw.size = l;
u->referenced = true; u->referenced = true;
return o; return o;
} }
@ -332,7 +332,7 @@ object unpacker::data()
void unpacker::reset() void unpacker::reset()
{ {
if(!m_zone->empty()) { delete release_zone(); } //if(!m_zone->empty()) { delete release_zone(); }
as_ctx(m_ctx)->reset(); as_ctx(m_ctx)->reset();
} }