From 1278eb3c63e2371283e07c0360b044728d72c704 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 15 Feb 2009 09:09:57 +0000 Subject: [PATCH] lang/c/msgpack: fix types git-svn-id: file:///Users/frsyuki/project/msgpack-git/svn/x@63 5a5092ae-2292-43ba-b2d5-dcab9c1a2731 --- c/bench.c | 2 +- c/bench_inline.c | 2 -- c/unpack.h | 2 +- c/unpack_inline.c | 2 +- cpp/bench.cpp | 6 ++-- cpp/object.cpp | 19 +++++----- cpp/object.hpp | 61 +++++++++++++++++---------------- cpp/pack.hpp | 4 +-- cpp/test.cpp | 6 ++-- cpp/unpack.cpp | 6 ++-- cpp/unpack.hpp | 4 +-- cpp/unpack_inline.cpp | 4 +-- cpp/zone.hpp.erb | 28 ++++++++++----- msgpack/unpack/callback.h | 2 +- msgpack/unpack/inline_context.h | 2 +- msgpack/unpack/inline_impl.h | 4 +-- ruby/unpack_inline.c | 2 +- 17 files changed, 85 insertions(+), 71 deletions(-) diff --git a/c/bench.c b/c/bench.c index 91f0c21f..6b8466f2 100644 --- a/c/bench.c +++ b/c/bench.c @@ -55,7 +55,7 @@ static void* unpack_array_start(void* data, unsigned int n) { return NULL; } static void unpack_array_item(void* data, void* c, void* o) { } static void* unpack_map_start(void* data, unsigned int n) { return NULL; } static void unpack_map_item(void* data, void* c, void* k, void* v) { } -static void* unpack_raw(void* data, const void* b, const void* p, size_t l) { /*printf("unpack raw %p %lu\n",p,l);*/ return NULL; } +static void* unpack_raw(void* data, const char* b, const char* p, unsigned int l) { /*printf("unpack raw %p %lu\n",p,l);*/ return NULL; } typedef struct { size_t allocated; diff --git a/c/bench_inline.c b/c/bench_inline.c index 5390319a..bb3c4316 100644 --- a/c/bench_inline.c +++ b/c/bench_inline.c @@ -56,8 +56,6 @@ static inline void* msgpack_unpack_signed_int_32(msgpack_unpack_context* x, int3 static inline void* msgpack_unpack_signed_int_64(msgpack_unpack_context* x, int64_t d) { return NULL; } static inline void* msgpack_unpack_float(msgpack_unpack_context* x, float d) { return NULL; } static inline void* msgpack_unpack_double(msgpack_unpack_context* x, double d) { return NULL; } -static inline void* msgpack_unpack_big_int(msgpack_unpack_context* x, const void* b, unsigned int l) { return NULL; } -static inline void* msgpack_unpack_big_float(msgpack_unpack_context* x, const void* b, unsigned int l) { return NULL; } static inline void* msgpack_unpack_nil(msgpack_unpack_context* x) { return NULL; } static inline void* msgpack_unpack_true(msgpack_unpack_context* x) { return NULL; } static inline void* msgpack_unpack_false(msgpack_unpack_context* x) { return NULL; } diff --git a/c/unpack.h b/c/unpack.h index 094328ec..63674390 100644 --- a/c/unpack.h +++ b/c/unpack.h @@ -39,7 +39,7 @@ typedef struct { void (*unpack_array_item)(void* data, void* c, void* o); void* (*unpack_map_start)(void* data, unsigned int n); void (*unpack_map_item)(void* data, void* c, void* k, void* v); - void* (*unpack_raw)(void* data, const void* b, const void* p, size_t l); + void* (*unpack_raw)(void* data, const char* b, const char* p, unsigned int l); } msgpack_unpack_callback; typedef struct { diff --git a/c/unpack_inline.c b/c/unpack_inline.c index d758d3e2..52822825 100644 --- a/c/unpack_inline.c +++ b/c/unpack_inline.c @@ -71,7 +71,7 @@ static inline void* msgpack_unpack_map_start(msgpack_unpack_t* x, unsigned int n static inline void msgpack_unpack_map_item(msgpack_unpack_t* x, void* c, void* k, void* v) { x->callback.unpack_map_item(x->data, c, k, v); } -static inline void* msgpack_unpack_raw(msgpack_unpack_t* x, const void* b, const void* p, size_t l) +static inline void* msgpack_unpack_raw(msgpack_unpack_t* x, const char* b, const char* p, unsigned int l) { return x->callback.unpack_raw(x->data, b, p, l); } diff --git a/cpp/bench.cpp b/cpp/bench.cpp index 649c0cc7..4133a2e9 100644 --- a/cpp/bench.cpp +++ b/cpp/bench.cpp @@ -10,7 +10,7 @@ static const unsigned int TASK_INT_NUM = 1<<24; static const unsigned int TASK_STR_LEN = 1<<15; //static const unsigned int TASK_INT_NUM = 1<<23; //static const unsigned int TASK_STR_LEN = 1<<14; -static const void* TASK_STR_PTR; +static const char* TASK_STR_PTR; class simple_timer { @@ -49,7 +49,7 @@ public: } public: - inline void write(const void* buf, size_t len) + inline void write(const char* buf, size_t len) { if(m_allocated - m_used < len) { expand_buffer(len); @@ -168,7 +168,7 @@ void bench_msgpack_str() int main(void) { - void* str = malloc(TASK_STR_LEN); + char* str = (char*)malloc(TASK_STR_LEN); memset(str, 'a', TASK_STR_LEN); TASK_STR_PTR = str; diff --git a/cpp/object.cpp b/cpp/object.cpp index d6815ac4..4068007a 100644 --- a/cpp/object.cpp +++ b/cpp/object.cpp @@ -320,29 +320,30 @@ FLOAT_OBJECT(double) EXTRA \ bool object_##NAME::operator== (const object_class* x) const \ try { \ - const_raw xr(x->xraw()); \ + raw xr(x->xraw()); \ return len == xr.len && (ptr == xr.ptr || memcmp(ptr, xr.ptr, len) == 0); \ } catch (type_error&) { return false; } \ bool object_##NAME::operator< (const object_class* x) const { \ - const_raw xr(x->xraw()); \ + raw xr(x->xraw()); \ if(len == xr.len) { return ptr != xr.ptr && memcmp(ptr, xr.ptr, len) < 0; } \ else { return len < xr.len; } } \ bool object_##NAME::operator> (const object_class* x) const { \ - const_raw xr(x->xraw()); \ + raw xr(x->xraw()); \ if(len == xr.len) { return ptr != xr.ptr && memcmp(ptr, xr.ptr, len) > 0; } \ else { return len > xr.len; } } \ void object_##NAME::pack(dynamic_packer& p) const \ { p.pack_raw(ptr, len); } \ const object_class* object_##NAME::inspect(std::ostream& s) const \ - { (s << '"').write((const char*)ptr, len) << '"'; return this; } // FIXME escape + { (s << '"').write(ptr, len) << '"'; return this; } // FIXME escape +// FIXME +RAW_OBJECT(mutable_raw_ref, + /*mutable_raw object_mutable_raw_ref::xraw() { return mutable_raw(ptr, len); }*/ + raw object_mutable_raw_ref::xraw() const { return raw(ptr, len); } ) + RAW_OBJECT(raw_ref, - raw object_raw_ref::xraw() { return raw(ptr, len); } - const_raw object_raw_ref::xraw() const { return const_raw(ptr, len); } ) - -RAW_OBJECT(const_raw_ref, - const_raw object_const_raw_ref::xraw() const { return const_raw(ptr, len); } ) + raw object_raw_ref::xraw() const { return raw(ptr, len); } ) #undef RAW_OBJECT(NAME, EXTRA) diff --git a/cpp/object.hpp b/cpp/object.hpp index 959d84ec..9f91677a 100644 --- a/cpp/object.hpp +++ b/cpp/object.hpp @@ -37,25 +37,25 @@ class positive_overflow_error : public overflow_error { }; class negative_overflow_error : public overflow_error { }; -struct raw { - explicit raw() : ptr(NULL), len(0) {} - explicit raw(void* p, size_t l) : ptr(p), len(l) {} +struct mutable_raw { + explicit mutable_raw() : ptr(NULL), len(0) {} + explicit mutable_raw(char* p, size_t l) : ptr(p), len(l) {} public: - void* ptr; + char* ptr; size_t len; public: - std::string str() { return std::string((const char*)ptr, len); } + std::string str() { return std::string(ptr, len); } }; -struct const_raw { - explicit const_raw() : ptr(NULL), len(0) {} - explicit const_raw(const void* p, size_t l) : ptr(p), len(l) {} - const_raw(const raw& m) : ptr(m.ptr), len(m.len) {} +struct raw { + explicit raw() : ptr(NULL), len(0) {} + explicit raw(const char* p, size_t l) : ptr(p), len(l) {} + raw(const mutable_raw& m) : ptr(m.ptr), len(m.len) {} public: - const void* ptr; + const char* ptr; size_t len; public: - std::string str() { return std::string((const char*)ptr, len); } + std::string str() { return std::string(ptr, len); } }; @@ -81,10 +81,10 @@ struct object_class { virtual int64_t xi64 () const { throw cast_error(); } virtual float xfloat () const { throw cast_error(); } virtual double xdouble() const { throw cast_error(); } - virtual raw xraw () { throw cast_error(); } - virtual array& xarray () { throw cast_error(); } - virtual map& xmap () { throw cast_error(); } - virtual const_raw xraw () const { throw cast_error(); } + //virtual mutable_raw xraw () { throw cast_error(); } // FIXME + virtual array& xarray() { throw cast_error(); } + virtual map& xmap () { throw cast_error(); } + virtual raw xraw () const { throw cast_error(); } virtual const array& xarray() const { throw cast_error(); } virtual const map& xmap () const { throw cast_error(); } virtual bool operator== (const object_class* x) const { return false; } @@ -103,10 +103,10 @@ struct object_class { operator int64_t() const { return xi64(); } operator float() const { return xfloat(); } operator double() const { return xdouble(); } - operator raw() { return xraw(); } - operator array&() { return xarray(); } - operator map&() { return xmap(); } - operator const_raw() const { return xraw(); } + //operator mutable_raw() { return xraw(); } // FIXME + operator array&() { return xarray(); } + operator map&() { return xmap(); } + operator raw() const { return xraw(); } operator const array&() const { return xarray(); } operator const map&() const { return xmap(); } virtual const object_class* inspect(std::ostream& s) const @@ -138,10 +138,10 @@ struct object { int64_t xi64 () const { return val->xi64(); } float xfloat () const { return val->xfloat(); } double xdouble() const { return val->xdouble(); } - raw xraw () { return val->xraw(); } - array& xarray () { return val->xarray(); } - map& xmap () { return val->xmap(); } - const_raw xraw () const { return const_cast(val)->xraw(); } + //mutable_raw xraw () { return val->xraw(); } // FIXME + array& xarray() { return val->xarray(); } + map& xmap () { return val->xmap(); } + raw xraw () const { return const_cast(val)->xraw(); } const array& xarray() const { return const_cast(val)->xarray(); } const map& xmap () const { return const_cast(val)->xmap(); } bool operator== (object x) const { return val->operator== (x.val); } @@ -149,6 +149,8 @@ struct object { bool operator< (object x) const { return val->operator< (x.val); } bool operator> (object x) const { return val->operator> (x.val); } void pack(dynamic_packer& p) const { val->pack(p); } + template + void pack(Stream& s) const { dynamic_packer p(s); pack(p); } operator bool() const { return val->operator bool(); } operator uint8_t() const { return val->operator uint8_t(); } operator uint16_t() const { return val->operator uint16_t(); } @@ -160,10 +162,10 @@ struct object { operator int64_t() const { return val->operator int64_t(); } operator float() const { return val->operator float(); } operator double() const { return val->operator double(); } - operator raw() { return val->operator raw(); } - operator array&() { return val->operator array&(); } - operator map&() { return val->operator map&(); } - operator const_raw() const { return val->operator const_raw(); } + //operator mutable_raw() { return val->operator mutable_raw(); } // FIXME + operator array&() { return val->operator array&(); } + operator map&() { return val->operator map&(); } + operator raw() const { return val->operator raw(); } operator const array&() const { return val->operator const array&(); } operator const map&() const { return val->operator const map&(); } const object& inspect(std::ostream& s) const @@ -275,8 +277,9 @@ private: \ uint32_t len; \ }; -RAW_CLASS(raw_ref, void*, raw xraw(); const_raw xraw() const; ) -RAW_CLASS(const_raw_ref, const void*, const_raw xraw() const; ) +// FIXME +RAW_CLASS(mutable_raw_ref, char*, /*mutable_raw xraw();*/ raw xraw() const; ) +RAW_CLASS(raw_ref, const char*, raw xraw() const; ) #undef RAW_CLASS(NAME, TYPE, EXTRA) diff --git a/cpp/pack.hpp b/cpp/pack.hpp index 94b5b9af..95806792 100644 --- a/cpp/pack.hpp +++ b/cpp/pack.hpp @@ -50,7 +50,7 @@ public: void pack_array(unsigned int n) { pack_array_impl(m_stream, n); } void pack_map(unsigned int n) { pack_map_impl(m_stream, n); } void pack_string(const char* b) { pack_string_impl(m_stream, b); } - void pack_raw(const void* b, size_t l) { pack_raw_impl(m_stream, b, l); } + void pack_raw(const char* b, size_t l) { pack_raw_impl(m_stream, (const void*)b, l); } private: static void pack_int_impl(Stream& x, int d); @@ -134,7 +134,7 @@ public: void pack_array(unsigned int n) { pack_array_impl(m_stream, n); } void pack_map(unsigned int n) { pack_map_impl(m_stream, n); } void pack_string(const char* b) { pack_string_impl(m_stream, b); } - void pack_raw(const void* b, size_t l) { pack_raw_impl(m_stream, b, l); } + void pack_raw(const char* b, size_t l) { pack_raw_impl(m_stream, (const void*)b, l); } private: static void pack_int_impl(dynamic_stream& x, int d); diff --git a/cpp/test.cpp b/cpp/test.cpp index b63f9a15..68050a3c 100644 --- a/cpp/test.cpp +++ b/cpp/test.cpp @@ -4,7 +4,7 @@ //#include #include #include -#include +#include class checker { public: @@ -176,7 +176,7 @@ int main(void) // 2. read data to buffer() up to buffer_capacity() bytes size_t sz = stream.readsome( - (char*)upk.buffer(), + upk.buffer(), upk.buffer_capacity()); total_bytes -= sz; @@ -195,7 +195,7 @@ int main(void) msgpack::object o = upk.data(); // 5.2. the parsed object is valid until the zone is deleted - boost::scoped_ptr pz(upk.release_zone()); + std::auto_ptr pz(upk.release_zone()); std::cout << o << std::endl; ++num_msg; diff --git a/cpp/unpack.cpp b/cpp/unpack.cpp index de330517..fe7f4b51 100644 --- a/cpp/unpack.cpp +++ b/cpp/unpack.cpp @@ -31,9 +31,9 @@ struct unpacker::context { ~context() { } - int execute(const void* data, size_t len, size_t* off) + int execute(const char* data, size_t len, size_t* off) { - return msgpack_unpacker_execute(&m_ctx, (const char*)data, len, off); + return msgpack_unpacker_execute(&m_ctx, data, len, off); } object_class* data() @@ -171,7 +171,7 @@ void unpacker::reset() } -object unpacker::unpack(const void* data, size_t len, zone& z) +object unpacker::unpack(const char* data, size_t len, zone& z) { context ctx(&z); size_t off = 0; diff --git a/cpp/unpack.hpp b/cpp/unpack.hpp index f5896f35..473e8e9e 100644 --- a/cpp/unpack.hpp +++ b/cpp/unpack.hpp @@ -100,7 +100,7 @@ private: unpacker(const unpacker&); public: - static object unpack(const void* data, size_t len, zone& z); + static object unpack(const char* data, size_t len, zone& z); }; @@ -136,7 +136,7 @@ inline void unpacker::remove_nonparsed_buffer() { m_used = m_off; } -inline object unpack(const void* data, size_t len, zone& z) +inline object unpack(const char* data, size_t len, zone& z) { return unpacker::unpack(data, len, z); } diff --git a/cpp/unpack_inline.cpp b/cpp/unpack_inline.cpp index 37e0b666..40f27699 100644 --- a/cpp/unpack_inline.cpp +++ b/cpp/unpack_inline.cpp @@ -71,12 +71,12 @@ static inline void msgpack_unpack_array_item(zone** z, object_class* c, object_c { reinterpret_cast(c)->push_back(o); } static inline object_class* msgpack_unpack_map_start(zone** z, unsigned int n) -{ return (*z)->narray(); } +{ return (*z)->nmap(); } static inline void msgpack_unpack_map_item(zone** z, object_class* c, object_class* k, object_class* v) { reinterpret_cast(c)->store(k, v); } -static inline object_class* msgpack_unpack_raw(zone** z, const void* b, const void* p, size_t l) +static inline object_class* msgpack_unpack_raw(zone** z, const char* b, const char* p, unsigned int l) { return (*z)->nraw_ref(p, l); } diff --git a/cpp/zone.hpp.erb b/cpp/zone.hpp.erb index d63fae86..8af8da28 100644 --- a/cpp/zone.hpp.erb +++ b/cpp/zone.hpp.erb @@ -58,19 +58,20 @@ public: object_float* nfloat (float v) { return new (alloc()) object_float(v); } object_double* ndouble(double v) { return new (alloc()) object_double(v); } - object_raw_ref* nraw_ref(void* ptr, uint32_t len) + + object_mutable_raw_ref* nraw_ref(char* ptr, uint32_t len) + { return new (alloc()) object_mutable_raw_ref(ptr, len); } + + object_raw_ref* nraw_ref(const char* ptr, uint32_t len) { return new (alloc()) object_raw_ref(ptr, len); } - object_const_raw_ref* nraw_ref(const void* ptr, uint32_t len) - { return new (alloc()) object_const_raw_ref(ptr, len); } - - object_raw_ref* nraw_copy(const void* ptr, uint32_t len) + object_mutable_raw_ref* nraw_copy(const char* ptr, uint32_t len) { - void* copy = malloc(len); + char* copy = (char*)malloc(len); if(!copy) { throw std::bad_alloc(); } - object_raw_ref* o; + object_mutable_raw_ref* o; try { - o = new (alloc()) object_raw_ref(copy, len); + o = new (alloc()) object_mutable_raw_ref(copy, len); push_finalizer(&zone::finalize_free, NULL, copy); } catch (...) { free(copy); @@ -80,6 +81,17 @@ public: return o; } + + object_mutable_raw_ref* nraw_cstr_ref(char* str) + { return nraw_ref(str, strlen(str)); } + + object_raw_ref* nraw_cstr_ref(const char* str) + { return nraw_ref(str, strlen(str)); } + + object_mutable_raw_ref* nraw_cstr_copy(const char* str) + { return nraw_copy(str, strlen(str)); } + + object_array* narray() { return new (alloc()) object_array(); } diff --git a/msgpack/unpack/callback.h b/msgpack/unpack/callback.h index 51508cca..315bb9e6 100644 --- a/msgpack/unpack/callback.h +++ b/msgpack/unpack/callback.h @@ -20,5 +20,5 @@ msgpack_object msgpack_unpack_array_start(msgpack_unpack_context* x, unsigned in msgpack_object msgpack_unpack_map_start(msgpack_unpack_context* x, unsigned int n); void msgpack_unpack_map_item(msgpack_unpack_context* x, msgpack_object c, msgpack_object k, msgpack_object v); msgpack_object msgpack_unpack_string(msgpack_unpack_context* x, const void* b, size_t l); -msgpack_object msgpack_unpack_raw(msgpack_unpack_context* x, const void* b, const void* p, size_t l); +msgpack_object msgpack_unpack_raw(msgpack_unpack_context* x, const char* b, const char* p, unsigned int l); diff --git a/msgpack/unpack/inline_context.h b/msgpack/unpack/inline_context.h index 22698d5e..e764c092 100644 --- a/msgpack/unpack/inline_context.h +++ b/msgpack/unpack/inline_context.h @@ -42,7 +42,7 @@ typedef struct { typedef struct { msgpack_unpack_context user; // must be first unsigned int cs; - size_t trail; + unsigned int trail; unsigned int top; msgpack_unpacker_stack stack[MSG_STACK_SIZE]; } msgpack_unpacker; diff --git a/msgpack/unpack/inline_impl.h b/msgpack/unpack/inline_impl.h index fdbe7f67..443a40cb 100644 --- a/msgpack/unpack/inline_impl.h +++ b/msgpack/unpack/inline_impl.h @@ -168,7 +168,7 @@ int msgpack_unpacker_execute(msgpack_unpacker* ctx, const char* data, size_t len const unsigned char* const pe = (unsigned char*)data + len; const void* n = NULL; - size_t trail = ctx->trail; + unsigned int trail = ctx->trail; unsigned int cs = ctx->cs; unsigned int top = ctx->top; msgpack_unpacker_stack* stack = ctx->stack; @@ -187,7 +187,7 @@ int msgpack_unpacker_execute(msgpack_unpacker* ctx, const char* data, size_t len /*printf("obj %d\n",obj);*/ \ goto _push #define push_variable_value(func, base, pos, len) \ - obj = func(user, (const void*)base, (const void*)pos, len); \ + obj = func(user, (const char*)base, (const char*)pos, len); \ /*printf("obj %d\n",obj);*/ \ goto _push diff --git a/ruby/unpack_inline.c b/ruby/unpack_inline.c index b30754b4..849441c4 100644 --- a/ruby/unpack_inline.c +++ b/ruby/unpack_inline.c @@ -71,7 +71,7 @@ static inline VALUE msgpack_unpack_map_start(msgpack_unpack_context* x, unsigned static inline void msgpack_unpack_map_item(msgpack_unpack_context* x, VALUE c, VALUE k, VALUE v) { rb_hash_aset(c, k, v); } -static inline VALUE msgpack_unpack_raw(msgpack_unpack_context* x, const void* b, const void* p, size_t l) +static inline VALUE msgpack_unpack_raw(msgpack_unpack_context* x, const char* b, const char* p, unsigned int l) { return rb_str_new(p, l); } #include "msgpack/unpack/inline_impl.h"