From 529a50633dffc91dd5ce58ae5a905a0ac4a5fdf9 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 15 Feb 2009 09:09:56 +0000 Subject: [PATCH] lang/c/msgpack: added C++ binding git-svn-id: file:///Users/frsyuki/project/msgpack-git/svn/x@50 5a5092ae-2292-43ba-b2d5-dcab9c1a2731 --- cpp/Makefile | 21 + cpp/msgpack | 1 + cpp/object.hpp | 760 ++++++++++++++++++++++++++++++++ cpp/test.cpp | 110 +++++ cpp/unpack.cc | 30 -- cpp/unpack.cpp | 96 ++++ cpp/unpack.h | 126 ------ cpp/unpack.hpp | 48 ++ cpp/unpack_context.h | 13 - cpp/unpack_context.hpp | 14 + cpp/unpack_inline.cpp | 72 +++ cpp/zone.cpp | 40 ++ cpp/zone.hpp.erb | 123 ++++++ msgpack/pack/inline_context.h | 2 - msgpack/pack/inline_impl.h | 66 +-- msgpack/unpack/inline_context.h | 7 + msgpack/unpack/inline_impl.h | 42 +- 17 files changed, 1361 insertions(+), 210 deletions(-) create mode 100644 cpp/Makefile create mode 120000 cpp/msgpack create mode 100644 cpp/object.hpp create mode 100644 cpp/test.cpp delete mode 100644 cpp/unpack.cc create mode 100644 cpp/unpack.cpp delete mode 100644 cpp/unpack.h create mode 100644 cpp/unpack.hpp delete mode 100644 cpp/unpack_context.h create mode 100644 cpp/unpack_context.hpp create mode 100644 cpp/unpack_inline.cpp create mode 100644 cpp/zone.cpp create mode 100644 cpp/zone.hpp.erb delete mode 100644 msgpack/pack/inline_context.h diff --git a/cpp/Makefile b/cpp/Makefile new file mode 100644 index 00000000..eafa6832 --- /dev/null +++ b/cpp/Makefile @@ -0,0 +1,21 @@ + +CXXFLAGS = -I.. -I. -Wall -g -O4 +LDFLAGS = -L. + +NEED_PREPROCESS = zone.hpp + +all: test + +%.hpp: %.hpp.erb + erb $< > $@ + +test: $(NEED_PREPROCESS) unpack.o unpack_inline.o zone.o test.o object.hpp unpack.hpp + $(CXX) $(LDFLAGS) unpack.o unpack_inline.o zone.o test.o -o $@ + +.PHONY: clean +clean: + $(RM) unpack.o unpack_inline.o zone.o + $(RM) test.o + $(RM) test + $(RM) $(NEED_PREPROCESS) + diff --git a/cpp/msgpack b/cpp/msgpack new file mode 120000 index 00000000..945c9b46 --- /dev/null +++ b/cpp/msgpack @@ -0,0 +1 @@ +. \ No newline at end of file diff --git a/cpp/object.hpp b/cpp/object.hpp new file mode 100644 index 00000000..c4e94d74 --- /dev/null +++ b/cpp/object.hpp @@ -0,0 +1,760 @@ +#ifndef MSGPACK_OBJECT_HPP__ +#define MSGPACK_OBJECT_HPP__ +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace msgpack { + + +class type_error : public std::bad_cast { }; +class cast_error : public type_error { }; +class overflow_error : public type_error { }; +class underflow_error : public type_error { }; +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) {} +public: + void* ptr; + size_t len; +public: + std::string str() { return std::string((const char*)ptr, len); } +}; + +struct const_raw { + const_raw() : ptr(NULL), len(0) {} + const_raw(const void* p, size_t l) : ptr(p), len(l) {} +public: + const void* ptr; + size_t len; +public: + std::string str() { return std::string((const char*)ptr, len); } +}; + + +struct object; + +typedef std::map map; +typedef std::vector array; + + +template +struct numeric_overflow_signed_impl; + +template +struct numeric_overflow_signed_impl { + static int test(X x) { + if( ( std::numeric_limits::is_integer && std::numeric_limits::is_integer) || + (!std::numeric_limits::is_integer && !std::numeric_limits::is_integer) ) { + if( sizeof(T) < sizeof(X) ) { + if( static_cast( std::numeric_limits::max()) < x ) { return 1; } + if( static_cast(-std::numeric_limits::max()) > x ) { return -1; } + } + } else if(std::numeric_limits::is_integer) { + if( static_cast( std::numeric_limits::max()) < x) { return 1; } + if( static_cast(-std::numeric_limits::max()) > x) { return -1; } + } + return 0; + } +}; + +template +struct numeric_overflow_signed_impl { + static int test(X x) { + if( ( std::numeric_limits::is_integer && std::numeric_limits::is_integer) || + (!std::numeric_limits::is_integer && !std::numeric_limits::is_integer) ) { + if( sizeof(T) <= sizeof(X) ) { + if( static_cast(std::numeric_limits::max()) < x ) { return 1; } + } + } else if(std::numeric_limits::is_integer) { + if( static_cast( std::numeric_limits::max()) < x) { return 1; } + } + return 0; + } +}; + +template +struct numeric_overflow_signed_impl { + static int test(X x) { + if( static_cast(0) > x ) { return -1; } + if( ( std::numeric_limits::is_integer && std::numeric_limits::is_integer) || + (!std::numeric_limits::is_integer && !std::numeric_limits::is_integer) ) { + if( sizeof(T) < sizeof(X) ) { + if( static_cast(std::numeric_limits::max()) < x ) { return 1; } + } + } else if(std::numeric_limits::is_integer) { + if( static_cast( std::numeric_limits::max()) < x) { return 1; } + } + return 0; + } +}; + +template +struct numeric_overflow_signed_impl { + static int test(X x) { + if( ( std::numeric_limits::is_integer && std::numeric_limits::is_integer) || + (!std::numeric_limits::is_integer && !std::numeric_limits::is_integer) ) { + if( sizeof(T) < sizeof(X) ) { + if( static_cast(std::numeric_limits::max()) < x ) { return 1; } + } + } else if(std::numeric_limits::is_integer) { + if( static_cast(std::numeric_limits::max()) < x ) { return 1; } + } + return 0; + } +}; + +template +struct numeric_overflow { + static int test(X x) { + return numeric_overflow_signed_impl::is_signed, std::numeric_limits::is_signed>::test(x); + } + static void check(X x) { + int r = test(x); + if(r == 1) { throw positive_overflow_error(); } + if(r == -1) { throw negative_overflow_error(); } + } +}; + + +template +struct numeric_underflow { + static bool test(X x) { + return static_cast(static_cast(x)) != x; + } + static void check(X x) { + if(test(x)) { throw underflow_error(); } + } +}; + + +struct object_class { + virtual ~object_class() {} + virtual bool isnil() const { return false; } + virtual bool xbool() const { throw cast_error(); } + virtual uint8_t xu8() const { throw cast_error(); } + virtual uint16_t xu16() const { throw cast_error(); } + virtual uint32_t xu32() const { throw cast_error(); } + virtual uint64_t xu64() const { throw cast_error(); } + virtual int8_t xi8() const { throw cast_error(); } + virtual int16_t xi16() const { throw cast_error(); } + virtual int32_t xi32() const { throw cast_error(); } + 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 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; } + bool operator!= (const object_class* x) const { return !(this->operator==(x)); } + virtual bool operator< (const object_class* x) const { throw cast_error(); } + virtual bool operator> (const object_class* x) const { throw cast_error(); } + operator bool() const { return xbool(); } // FIXME !isnil(); + operator uint8_t() const { return xu8(); } + operator uint16_t() const { return xu16(); } + operator uint32_t() const { return xu32(); } + operator uint64_t() const { return xu64(); } + operator int8_t() const { return xi8(); } + operator int16_t() const { return xi16(); } + operator int32_t() const { return xi32(); } + 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 const array&() const { return xarray(); } + operator const map&() const { return xmap(); } + virtual const object_class* inspect(std::ostream& s) const + { s << '<' << typeid(*this).name() << '>'; return this; } +protected: + template + static void check_overflow(X x) { numeric_overflow::check(x); } + template + static void check_underflow(X x) { numeric_underflow::check(x); } +}; + +inline std::ostream& operator<< (std::ostream& s, const object_class* o) + { o->inspect(s); return s; } + + +struct object_container_mixin {}; +struct object_constructor_mixin {}; + + +struct object { + explicit object() : val(NULL) {} + object(object_class* v) : val(v) {} + //object(object_class& v) : val(&v) {} + ~object() {} + bool isnil() const { return val->isnil(); } + bool xbool() const { return val->xbool(); } + uint8_t xu8() const { return val->xu8(); } + uint16_t xu16() const { return val->xu16(); } + uint32_t xu32() const { return val->xu32(); } + uint64_t xu64() const { return val->xu64(); } + int8_t xi8() const { return val->xi8(); } + int16_t xi16() const { return val->xi16(); } + int32_t xi32() const { return val->xi32(); } + 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(); } + 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); } + bool operator!= (object x) const { return val->operator!= (x.val); } + bool operator< (object x) const { return val->operator< (x.val); } + bool operator> (object x) const { return val->operator> (x.val); } + 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(); } + operator uint32_t() const { return val->operator uint32_t(); } + operator uint64_t() const { return val->operator uint64_t(); } + operator int8_t() const { return val->operator int8_t(); } + operator int16_t() const { return val->operator int16_t(); } + operator int32_t() const { return val->operator int32_t(); } + 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 raw() const { return val->operator raw(); } + operator array&() const { return val->operator array&(); } + operator map&() const { return val->operator map&(); } + const object& inspect(std::ostream& s) const + { val->inspect(s); return *this; } +private: + friend class object_container_mixin; + friend class object_constructor_mixin; + object_class* val; +}; + +inline std::ostream& operator<< (std::ostream& s, const object& o) + { o.inspect(s); return s; } + + +struct object_nil : object_class { + bool isnil() const { return true; } + bool operator== (const object_class* x) const { return typeid(*this) == typeid(*x); } + const object_class* inspect(std::ostream& s) const + { s << "nil"; return this; } +}; + +struct object_true : object_class { + bool xbool() const { return true; } + bool operator== (const object_class* x) const { return typeid(*this) == typeid(*x); } + const object_class* inspect(std::ostream& s) const + { s << "true"; return this; } +}; + +struct object_false : object_class { + bool xbool() const { return false; } + bool operator== (const object_class* x) const { return typeid(*this) == typeid(*x); } + const object_class* inspect(std::ostream& s) const + { s << "false"; return this; } +}; + +struct object_u8 : object_class { + explicit object_u8(uint8_t v) : val(v) {} + uint8_t xu8() const { return val; } + uint16_t xu16() const { return static_cast(val); } + uint32_t xu32() const { return static_cast(val); } + uint64_t xu64() const { return static_cast(val); } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { return static_cast(val); } + int32_t xi32() const { return static_cast(val); } + int64_t xi64() const { return static_cast(val); } + float xfloat() const { return static_cast(val); } + double xdouble() const { return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xu8(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xu8(); } + catch (positive_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + bool operator> (const object_class* x) const { try { return val > x->xu8(); } + catch (negative_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + const object_class* inspect(std::ostream& s) const + { s << (uint16_t)val; return this; } +private: + uint8_t val; +}; + +struct object_u16 : object_class { + explicit object_u16(uint16_t v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { return val; } + uint32_t xu32() const { return static_cast(val); } + uint64_t xu64() const { return static_cast(val); } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { check_overflow(val); + return static_cast(val); } + int32_t xi32() const { return static_cast(val); } + int64_t xi64() const { return static_cast(val); } + float xfloat() const { return static_cast(val); } + double xdouble() const { return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xu16(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xu16(); } + catch (positive_overflow_error&) { return true; } + catch (type_error&) { return false; } } + bool operator> (const object_class* x) const { try { return val > x->xu16(); } + catch (negative_overflow_error&) { return true; } + catch (type_error&) { return false; } } + const object_class* inspect(std::ostream& s) const + { s << val; return this; } +private: + uint16_t val; +}; + +struct object_u32 : object_class { + explicit object_u32(uint32_t v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { check_overflow(val); + return static_cast(val); } + uint32_t xu32() const { return val; } + uint64_t xu64() const { return static_cast(val); } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { check_overflow(val); + return static_cast(val); } + int32_t xi32() const { check_overflow(val); + return static_cast(val); } + int64_t xi64() const { return static_cast(val); } + float xfloat() const { check_underflow(val); + return static_cast(val); } + double xdouble() const { return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xu32(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xu32(); } + catch (positive_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + bool operator> (const object_class* x) const { try { return val > x->xu32(); } + catch (negative_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + const object_class* inspect(std::ostream& s) const + { s << val; return this; } +private: + uint32_t val; +}; + +struct object_u64 : object_class { + explicit object_u64(uint64_t v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { check_overflow(val); + return static_cast(val); } + uint32_t xu32() const { check_overflow(val); + return static_cast(val); } + uint64_t xu64() const { return val; } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { check_overflow(val); + return static_cast(val); } + int32_t xi32() const { check_overflow(val); + return static_cast(val); } + int64_t xi64() const { check_overflow(val); + return static_cast(val); } + float xfloat() const { check_underflow(val); + return static_cast(val); } + double xdouble() const { check_underflow(val); + return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xu64(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xu64(); } + catch (positive_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + bool operator> (const object_class* x) const { try { return val > x->xu64(); } + catch (negative_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + const object_class* inspect(std::ostream& s) const + { s << val; return this; } +private: + uint64_t val; +}; + +struct object_i8 : object_class { + explicit object_i8(int8_t v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { check_overflow(val); + return static_cast(val); } + uint32_t xu32() const { check_overflow(val); + return static_cast(val); } + uint64_t xu64() const { check_overflow(val); + return static_cast(val); } + int8_t xi8() const { return val; } + int16_t xi16() const { return static_cast(val); } + int32_t xi32() const { return static_cast(val); } + int64_t xi64() const { return static_cast(val); } + float xfloat() const { return static_cast(val); } + double xdouble() const { return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xi8(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xi8(); } + catch (positive_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + bool operator> (const object_class* x) const { try { return val > x->xi8(); } + catch (negative_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + const object_class* inspect(std::ostream& s) const + { s << (int16_t)val; return this; } +private: + int8_t val; +}; + +struct object_i16 : object_class { + explicit object_i16(int16_t v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { check_overflow(val); + return static_cast(val); } + uint32_t xu32() const { check_overflow(val); + return static_cast(val); } + uint64_t xu64() const { check_overflow(val); + return static_cast(val); } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { return val; } + int32_t xi32() const { return static_cast(val); } + int64_t xi64() const { return static_cast(val); } + float xfloat() const { return static_cast(val); } + double xdouble() const { return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xi16(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xi16(); } + catch (positive_overflow_error&) { return true; } + catch (type_error&) { return false; } } + bool operator> (const object_class* x) const { try { return val > x->xi16(); } + catch (negative_overflow_error&) { return true; } + catch (type_error&) { return false; } } + const object_class* inspect(std::ostream& s) const + { s << val; return this; } +private: + int16_t val; +}; + +struct object_i32 : object_class { + explicit object_i32(int32_t v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { check_overflow(val); + return static_cast(val); } + uint32_t xu32() const { check_overflow(val); + return static_cast(val); } + uint64_t xu64() const { check_overflow(val); + return static_cast(val); } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { check_overflow(val); + return static_cast(val); } + int32_t xi32() const { return val; } + int64_t xi64() const { return static_cast(val); } + float xfloat() const { check_underflow(val); + return static_cast(val); } + double xdouble() const { return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xi32(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xi32(); } + catch (positive_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + bool operator> (const object_class* x) const { try { return val > x->xi32(); } + catch (negative_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + const object_class* inspect(std::ostream& s) const + { s << val; return this; } +private: + int32_t val; +}; + +struct object_i64 : object_class { + explicit object_i64(int64_t v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { check_overflow(val); + return static_cast(val); } + uint32_t xu32() const { check_overflow(val); + return static_cast(val); } + uint64_t xu64() const { check_overflow(val); + return static_cast(val); } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { check_overflow(val); + return static_cast(val); } + int32_t xi32() const { check_overflow(val); + return static_cast(val); } + int64_t xi64() const { return val; } + float xfloat() const { check_underflow(val); + return static_cast(val); } + double xdouble() const { check_underflow(val); + return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xi64(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xi64(); } + catch (positive_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + bool operator> (const object_class* x) const { try { return val > x->xi64(); } + catch (negative_overflow_error&) { return true; } + catch (overflow_error&) { return false; } } + const object_class* inspect(std::ostream& s) const + { s << val; return this; } +private: + int64_t val; +}; + + +struct object_float : object_class { + object_float(float v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { check_overflow(val); + return static_cast(val); } + uint32_t xu32() const { check_overflow(val); + return static_cast(val); } + uint64_t xu64() const { check_overflow(val); + return static_cast(val); } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { check_overflow(val); + return static_cast(val); } + int32_t xi32() const { check_overflow(val); + return static_cast(val); } + int64_t xi64() const { check_overflow(val); + return static_cast(val); } + float xfloat() const { return val; } + double xdouble() const { return static_cast(val); } + bool operator== (const object_class* x) const { try { return val == x->xfloat(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return static_cast(val) < x->xdouble(); } + catch (positive_overflow_error&) { return true; } + catch (overflow_error&) { return false; } + catch (underflow_error&) { + if(val < 0.0) { + if(numeric_overflow::test(val) == -1) { return true; } + try { return static_cast(val) < x->xi64(); } + catch (type_error&) { return true; } + } else { + if(numeric_overflow::test(val) == 1) { return false; } + try { return static_cast(val) < x->xu64(); } + catch (type_error&) { return false; } + } + } } + bool operator> (const object_class* x) const { try { return static_cast(val) > x->xdouble(); } + catch (negative_overflow_error&) { return true; } + catch (overflow_error&) { return false; } + catch (underflow_error&) { + if(val < 0.0) { + if(numeric_overflow::test(val) == -1) { return false; } + try { return static_cast(val) > x->xi64(); } + catch (type_error&) { return false; } + } else { + if(numeric_overflow::test(val) == 1) { return true; } + try { return static_cast(val) > x->xu64(); } + catch (type_error&) { return true; } + } + } } + const object_class* inspect(std::ostream& s) const + { s << val; return this; } +private: + float val; +}; + + +struct object_double : object_class { + object_double(double v) : val(v) {} + uint8_t xu8() const { check_overflow(val); + return static_cast(val); } + uint16_t xu16() const { check_overflow(val); + return static_cast(val); } + uint32_t xu32() const { check_overflow(val); + return static_cast(val); } + uint64_t xu64() const { check_overflow(val); + return static_cast(val); } + int8_t xi8() const { check_overflow(val); + return static_cast(val); } + int16_t xi16() const { check_overflow(val); + return static_cast(val); } + int32_t xi32() const { check_overflow(val); + return static_cast(val); } + int64_t xi64() const { check_overflow(val); + return static_cast(val); } + float xfloat() const { check_overflow(val); + check_underflow(val); + return static_cast(val); } + double xdouble() const { return val; } + bool operator== (const object_class* x) const { try { return val == x->xdouble(); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { try { return val < x->xdouble(); } + catch (positive_overflow_error&) { return true; } + catch (overflow_error&) { return false; } + catch (underflow_error&) { + if(val < 0.0) { + if(numeric_overflow::test(val) == -1) { return true; } + try { return static_cast(val) < x->xi64(); } + catch (type_error&) { return true; } + } else { + if(numeric_overflow::test(val) == 1) { return false; } + try { return static_cast(val) < x->xu64(); } + catch (type_error&) { return false; } + } + } } + bool operator> (const object_class* x) const { try { return val > x->xdouble(); } + catch (negative_overflow_error&) { return true; } + catch (overflow_error&) { return false; } + catch (underflow_error&) { + if(val < 0.0) { + if(numeric_overflow::test(val) == -1) { return false; } + try { return static_cast(val) > x->xi64(); } + catch (type_error&) { return false; } + } else { + if(numeric_overflow::test(val) == 1) { return true; } + try { return static_cast(val) > x->xu64(); } + catch (type_error&) { return true; } + } + } } + const object_class* inspect(std::ostream& s) const + { s << val; return this; } +private: + double val; +}; + + +struct object_raw : object_class { + explicit object_raw(void* p, uint32_t l) : ptr(p), len(l) {} + raw xraw() { return raw(ptr, len); } + const_raw xraw() const { return const_raw(ptr, len); } + bool operator== (const object_class* x) const { try { const_raw xr(x->xraw()); + return len == xr.len && (ptr == xr.ptr || memcmp(ptr, xr.ptr, len) == 0); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { const_raw xr(x->xraw()); + if(len == xr.len) { return ptr != xr.ptr && memcmp(ptr, xr.ptr, len) < 0; } + else { return len < xr.len; } } + bool operator> (const object_class* x) const { const_raw xr(x->xraw()); + if(len == xr.len) { return ptr != xr.ptr && memcmp(ptr, xr.ptr, len) > 0; } + else { return len > xr.len; } } + const object_class* inspect(std::ostream& s) const + { (s << '"').write((const char*)ptr, len) << '"'; return this; } // FIXME escape +private: + void* ptr; + uint32_t len; +}; + +struct object_const_raw : object_class { + explicit object_const_raw(const void* p, uint32_t l) : ptr(p), len(l) {} + const_raw xraw() const { return const_raw(ptr, len); } + bool operator== (const object_class* x) const { try { const_raw xr(x->xraw()); + return len == xr.len && (ptr == xr.ptr || memcmp(ptr, xr.ptr, len) == 0); } + catch (type_error&) { return false; } } + bool operator< (const object_class* x) const { const_raw xr(x->xraw()); + if(len == xr.len) { return ptr != xr.ptr && memcmp(ptr, xr.ptr, len) < 0; } + else { return len < xr.len; } } + bool operator> (const object_class* x) const { const_raw xr(x->xraw()); + if(len == xr.len) { return ptr != xr.ptr && memcmp(ptr, xr.ptr, len) > 0; } + else { return len > xr.len; } } + const object_class* inspect(std::ostream& s) const + { (s << '"').write((const char*)ptr, len) << '"'; return this; } // FIXME escape +private: + const void* ptr; + uint32_t len; +}; + +struct object_array : object_class, object_container_mixin { + explicit object_array() {} + explicit object_array(uint32_t n) { val.reserve(n); } + array& xarray() { return val; } + const array& xarray() const { return val; } + bool operator== (const object_class* x) const { try { + const std::vector& xa(x->xarray()); + if(val.size() != xa.size()) { return false; } + for(std::vector::const_iterator iv(val.begin()), iv_end(val.end()), ix(xa.begin()); + iv != iv_end; + ++iv, ++ix) { + if(*iv != *ix) { return false; } + } + return true; + } catch (type_error&) { return false; } } + // FIXME operator< operator> + const object_class* inspect(std::ostream& s) const { + s << '['; + if(!val.empty()) { + std::vector::const_iterator it(val.begin()); + s << *it; + ++it; + for(std::vector::const_iterator it_end(val.end()); + it != it_end; + ++it) { + s << ", " << *it; + } + } + s << ']'; + return this; } +public: + void push_back(object o) { val.push_back(o); } +private: + std::vector val; +}; + +// FIXME hash, operator==: nil, true, false, containerを入れられない +struct object_map : object_class, object_container_mixin { + explicit object_map() {} + map& xmap() { return val; } + const map& xmap() const { return val; } + bool operator== (const object_class* x) const { try { + const std::map& xm(x->xmap()); + if(val.size() != xm.size()) { return false; } + for(std::map::const_iterator iv(val.begin()), iv_end(val.end()), ix(xm.begin()); + iv != iv_end; + ++iv, ++ix) { + if(iv->first != ix->first || iv->second != ix->first) { return false; } + } + return true; + } catch (type_error&) { return false; } } + // FIXME operator< operator> + const object_class* inspect(std::ostream& s) const { + s << '{'; + if(!val.empty()) { + std::map::const_iterator it(val.begin()); + s << it->first << "=>" << it->second; + ++it; + for(std::map::const_iterator it_end(val.end()); + it != it_end; + ++it) { + s << ", " << it->first << "=>" << it->second; + } + } + s << '}'; + return this; } +public: + void store(object k, object v) { val[k] = v; } +private: + std::map val; +}; + + +} // namespace msgpack + +#endif /* msgpack/object.hpp */ + diff --git a/cpp/test.cpp b/cpp/test.cpp new file mode 100644 index 00000000..423a6bd9 --- /dev/null +++ b/cpp/test.cpp @@ -0,0 +1,110 @@ +#include +#include + +class checker { +public: + void check(const char* d, size_t len, msgpack::object should) { + try { + std::cout << "----" << std::endl; + msgpack::object o; + try { + o = msgpack::unpack(d, len, m_zone); + } catch (std::runtime_error& e) { + std::cout << should << std::endl; + std::cout << "**" << e.what() << "**" << std::endl; + return; + } + std::cout << o << std::endl; + if(o != should) { + std::cout << "** TEST FAILED **" << std::endl; + } + } catch (...) { m_zone.clear(); throw; } + m_zone.clear(); + } +private: + msgpack::zone m_zone; +}; + +int main(void) +{ + +checker c; + +{ // SimpleValue + msgpack::zone z; + const char d[] = { + 0x93, 0xc0, 0xc2, 0xc3, + }; + c.check(d, sizeof(d), + z.narray( + z.nnil(), z.nfalse(), z.ntrue() + ) + ); +} + +{ // Fixnum + msgpack::zone z; + const char d[] = { + 0x92, + 0x93, 0x00, 0x40, 0x7f, + 0x93, 0xe0, 0xf0, 0xff, + }; + c.check(d, sizeof(d), + z.narray( + z.narray( + z.nu8(0), + z.nu8(64), + z.nu8(127) + ), + z.narray( + z.ni8(-32), + z.ni8(-16), + z.ni8(-1) + ) + ) + ); +} + +{ // FixArray + msgpack::zone z; + const char d[] = { + 0x92, + 0x90, + 0x91, + 0x91, 0xc0, + }; + c.check(d, sizeof(d), + z.narray( + z.narray(), + z.narray( + z.narray( + z.nnil() + ) + ) + ) + ); +} + +{ // FixRaw + msgpack::zone z; + const char d[] = { + 0x94, + 0xa0, + 0xa1, 'a', + 0xa2, 'b', 'c', + 0xa3, 'd', 'e', 'f', + }; + c.check(d, sizeof(d), + z.narray( + z.nraw("", 0), + z.nraw("a", 1), + z.nraw("bc", 2), + z.nraw("def", 3) + ) + ); +} + + +return 0; +} + diff --git a/cpp/unpack.cc b/cpp/unpack.cc deleted file mode 100644 index ce57e676..00000000 --- a/cpp/unpack.cc +++ /dev/null @@ -1,30 +0,0 @@ -#include "unpack.h" -#include "unpack_context.h" -#include - -msgpack_unpack_t* msgpack_unpack_new(void) -{ - msgpack_unpacker* ctx; - ctx = (msgpack_unpacker*)calloc(1, sizeof(msgpack_unpacker)); - if(ctx == NULL) { return NULL; } - msgpack_unpacker_init(ctx); - return (msgpack_unpack_t*)ctx; -} - -void msgpack_unpack_free(msgpack_unpack_t* ctx) -{ - free((msgpack_unpacker*)ctx); -} - -int msgpack_unpack_execute(msgpack_unpack_t* ctx, const char* data, size_t len, size_t* off) -{ - return msgpack_unpacker_execute( - (msgpack_unpacker*)ctx, - data, len, off); -} - -void* msgpack_unpack_data(msgpack_unpack_t* ctx) -{ - return msgpack_unpacker_data((msgpack_unpacker*)ctx); -} - diff --git a/cpp/unpack.cpp b/cpp/unpack.cpp new file mode 100644 index 00000000..0f02d3c1 --- /dev/null +++ b/cpp/unpack.cpp @@ -0,0 +1,96 @@ +#include "msgpack/unpack.hpp" +#include "unpack_context.hpp" +#include + +namespace msgpack { + +struct unpacker::context { + context(zone& z) + { + msgpack_unpacker_init(&m_ctx); + m_ctx.user = &z; + } + + ~context() { } + + int execute(const void* data, size_t len, size_t* off) + { + return msgpack_unpacker_execute(&m_ctx, (const char*)data, len, off); + } + + object_class* data() + { + return msgpack_unpacker_data(&m_ctx); + } + + void reset() + { + zone* z = m_ctx.user; + msgpack_unpacker_init(&m_ctx); + m_ctx.user = z; + } + +private: + msgpack_unpacker m_ctx; + +private: + context(); + context(const context&); +}; + + +unpacker::unpacker(zone& z) : + m_ctx(new context(z)), + m_zone(z), + m_finished(false) +{ } + + +unpacker::~unpacker() { delete m_ctx; } + + +size_t unpacker::execute(const void* data, size_t len, size_t off) +{ + int ret = m_ctx->execute(data, len, &off); + if(ret < 0) { + throw unpack_error("parse error"); + } else if(ret > 0) { + m_finished = true; + return off; + } else { + m_finished = false; + return off; + } +} + + +object unpacker::data() +{ + return object(m_ctx->data()); +} + + +void unpacker::reset() +{ + m_ctx->reset(); +} + + +object unpacker::unpack(const void* data, size_t len, zone& z) +{ + context ctx(z); + size_t off = 0; + int ret = ctx.execute(data, len, &off); + if(ret < 0) { + throw unpack_error("parse error"); + } else if(ret == 0) { + throw unpack_error("insufficient bytes"); + } else if(off < len) { + throw unpack_error("extra bytes"); + } + return ctx.data(); +} + + +} // namespace msgpack + diff --git a/cpp/unpack.h b/cpp/unpack.h deleted file mode 100644 index cf7a1682..00000000 --- a/cpp/unpack.h +++ /dev/null @@ -1,126 +0,0 @@ -#ifndef MSGPACK_UNPACK_H__ -#define MSGPACK_UNPACK_H__ - -#include -#include - -namespace MessagePack { - -class Unpacker { - class object { - template - object(const T& x) : m_obj(new holder(x)) {} - }; - - class type_error : public std::exception { }; - class cast_error : public type_error { }; - class overflow_error : public type_error { }; - class underflow_error : public type_error { }; - - struct object { - virtual ~object() {} - virtual bool isnil() const { return false; } - virtual bool xbool() const { throw cast_error(); } - virtual uint8_t xu8() const { throw cast_error(); } - virtual uint16_t xu16() const { throw cast_error(); } - virtual uint32_t xu32() const { throw cast_error(); } - virtual uint64_t xu64() const { throw cast_error(); } - virtual int8_t xi8() const { throw cast_error(); } - virtual int16_t xi16() const { throw cast_error(); } - virtual int32_t xi32() const { throw cast_error(); } - virtual int64_t xi64() const { throw cast_error(); } - virtual float xfloat() const { throw cast_error(); } - virtual double xdouble() const { throw cast_error(); } - virtual std::map& xmap() const { throw cast_error(); } - virtual std::string& xstring() const { throw cast_error(); } - virtual std::pair xraw() const { throw cast_error(); } - public: - template - inline void check_overflow(X x) { - if(std::numeric_limits::max() < x) { throw overflow_error(); } - } - template - inline void check_underflow(X x) { - if(std::numeric_limits::min() > x) { throw overflow_error(); } - } - }; - -private: - struct object_nil : object { - bool isnil() const { return true; } - }; - - struct object_true : object { - bool xbool() const { return true; } - }; - - struct object_false : object { - bool xbool() const { return false; } - }; - - struct object_u8 : object { - object_u8(uint8_t val) : m_val(val) {} - uint8_t xu8() const { return m_val; } - uint16_t xu16() const { return static_cast(m_val); } - uint32_t xu32() const { return static_cast(m_val); } - uint64_t xu64() const { return static_cast(m_val); } - int8_t xi8() const { check_overflow(m_val); return m_val; } - int16_t xi16() const { return static_cast(m_val); } - int32_t xi32() const { return static_cast(m_val); } - int64_t xi64() const { return static_cast(m_val); } - private: - uint8_t m_val; - }; - - struct object_u16 : object { - object_u16(uint16_t val) : m_val(val) {} - uint8_t xu8() const { check_overflow(m_val); return m_val; } - uint16_t xu16() const { return m_val; } - uint32_t xu32() const { return static_cast(m_val); } - uint64_t xu64() const { return static_cast(m_val); } - int8_t xi8() const { check_overflow< int8_t>(m_val); return m_val; } - int16_t xi16() const { check_overflow(m_val); return m_val; } - int32_t xi32() const { return static_cast(m_val); } - int64_t xi64() const { return static_cast(m_val); } - private: - uint16_t m_val; - }; - - ... -}; - -} // namespace MessagePack - -typedef struct { - void* (*unpack_unsigned_int_8)(void* data, uint8_t d); - void* (*unpack_unsigned_int_16)(void* data, uint16_t d); - void* (*unpack_unsigned_int_32)(void* data, uint32_t d); - void* (*unpack_unsigned_int_64)(void* data, uint64_t d); - void* (*unpack_signed_int_8)(void* data, int8_t d); - void* (*unpack_signed_int_16)(void* data, int16_t d); - void* (*unpack_signed_int_32)(void* data, int32_t d); - void* (*unpack_signed_int_64)(void* data, int64_t d); - void* (*unpack_float)(void* data, float d); - void* (*unpack_double)(void* data, double d); - void* (*unpack_big_int)(void* data, const void* b, unsigned int l); - void* (*unpack_big_float)(void* data, const void* b, unsigned int l); - void* (*unpack_nil)(void* data); - void* (*unpack_true)(void* data); - void* (*unpack_false)(void* data); - void* (*unpack_array_start)(void* data, unsigned int n); - 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_string)(void* data, const void* b, size_t l); - void* (*unpack_raw)(void* data, const void* b, size_t l); - void* data; -} msgpack_unpack_t; - -msgpack_unpack_t* msgpack_unpack_new(void); -void msgpack_unpack_free(msgpack_unpack_t* ctx); -int msgpack_unpack_execute(msgpack_unpack_t* ctx, const char* data, size_t len, size_t* off); -void* msgpack_unpack_data(msgpack_unpack_t* ctx); - -#endif /* msgpack/unpack.h */ - - diff --git a/cpp/unpack.hpp b/cpp/unpack.hpp new file mode 100644 index 00000000..61ba781a --- /dev/null +++ b/cpp/unpack.hpp @@ -0,0 +1,48 @@ +#ifndef MSGPACK_UNPACK_HPP__ +#define MSGPACK_UNPACK_HPP__ + +#include "msgpack/object.hpp" +#include "msgpack/zone.hpp" +#include + +namespace msgpack { + + +struct unpack_error : public std::runtime_error { + unpack_error(const std::string& msg) : + std::runtime_error(msg) { } +}; + + +class unpacker { +public: + unpacker(zone& z); + ~unpacker(); +public: + size_t execute(const void* data, size_t len, size_t off); + bool is_finished() { return m_finished; } + object data(); + void reset(); +private: + struct context; + context* m_ctx; + zone& m_zone; + bool m_finished; +private: + unpacker(); + unpacker(const unpacker&); +public: + static object unpack(const void* data, size_t len, zone& z); +}; + + +inline object unpack(const void* data, size_t len, zone& z) +{ + return unpacker::unpack(data, len, z); +} + + +} // namespace msgpack + +#endif /* msgpack/unpack.hpp */ + diff --git a/cpp/unpack_context.h b/cpp/unpack_context.h deleted file mode 100644 index caf22719..00000000 --- a/cpp/unpack_context.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef UNPACK_CONTEXT_H__ -#define UNPACK_CONTEXT_H__ - -#include "unpack.h" - -typedef void* msgpack_object; - -typedef msgpack_unpack_t msgpack_unpack_context; - -#include "msgpack/unpack/inline_context.h" - -#endif /* unpack_context.h */ - diff --git a/cpp/unpack_context.hpp b/cpp/unpack_context.hpp new file mode 100644 index 00000000..49a93e43 --- /dev/null +++ b/cpp/unpack_context.hpp @@ -0,0 +1,14 @@ +#ifndef UNPACK_CONTEXT_HPP__ +#define UNPACK_CONTEXT_HPP__ + +#include "msgpack/zone.hpp" +#include "msgpack/object.hpp" + +typedef msgpack::object_class* msgpack_object; + +typedef msgpack::zone* msgpack_unpack_context; + +#include "msgpack/unpack/inline_context.h" + +#endif /* unpack_context.h */ + diff --git a/cpp/unpack_inline.cpp b/cpp/unpack_inline.cpp new file mode 100644 index 00000000..82f6e7a6 --- /dev/null +++ b/cpp/unpack_inline.cpp @@ -0,0 +1,72 @@ +#include "unpack_context.hpp" + + +extern "C" { +using namespace msgpack; + + +static inline object_class* msgpack_unpack_init(zone** z) +{ return NULL; } + +static inline object_class* msgpack_unpack_unsigned_int_8(zone** z, uint8_t d) +{ return (*z)->nu8(d); } + +static inline object_class* msgpack_unpack_unsigned_int_16(zone** z, uint16_t d) +{ return (*z)->nu16(d); } + +static inline object_class* msgpack_unpack_unsigned_int_32(zone** z, uint32_t d) +{ return (*z)->nu32(d); } + +static inline object_class* msgpack_unpack_unsigned_int_64(zone** z, uint64_t d) +{ return (*z)->nu64(d); } + +static inline object_class* msgpack_unpack_signed_int_8(zone** z, int8_t d) +{ return (*z)->ni8(d); } + +static inline object_class* msgpack_unpack_signed_int_16(zone** z, int16_t d) +{ return (*z)->ni16(d); } + +static inline object_class* msgpack_unpack_signed_int_32(zone** z, int32_t d) +{ return (*z)->ni32(d); } + +static inline object_class* msgpack_unpack_signed_int_64(zone** z, int64_t d) +{ return (*z)->ni64(d); } + +static inline object_class* msgpack_unpack_float(zone** z, float d) +{ return (*z)->nfloat(d); } + +static inline object_class* msgpack_unpack_double(zone** z, double d) +{ return (*z)->ndouble(d); } + +static inline object_class* msgpack_unpack_nil(zone** z) +{ return (*z)->nnil(); } + +static inline object_class* msgpack_unpack_true(zone** z) +{ return (*z)->ntrue(); } + +static inline object_class* msgpack_unpack_false(zone** z) +{ return (*z)->nfalse(); } + +static inline object_class* msgpack_unpack_array_start(zone** z, unsigned int n) +{ return (*z)->narray(n); } + +static inline void msgpack_unpack_array_item(zone** z, object_class* c, object_class* o) +{ reinterpret_cast(c)->push_back(o); } + +static inline object_class* msgpack_unpack_map_start(zone** z, unsigned int n) +{ return (*z)->narray(); } + +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_string(zone** z, const void* b, size_t l) +{ return (*z)->nraw(b, l); } + +static inline object_class* msgpack_unpack_raw(zone** z, const void* b, size_t l) +{ return (*z)->nraw(b, l); } + + +} // extern "C" + +#include "msgpack/unpack/inline_impl.h" + diff --git a/cpp/zone.cpp b/cpp/zone.cpp new file mode 100644 index 00000000..5031467e --- /dev/null +++ b/cpp/zone.cpp @@ -0,0 +1,40 @@ +#include "zone.hpp" + +namespace msgpack { + + +void* zone::alloc() +{ + if(m_used >= m_pool.size()*MSGPACK_ZONE_CHUNK_SIZE) { + m_pool.push_back(chunk_t()); + } + void* data = m_pool[m_used/MSGPACK_ZONE_CHUNK_SIZE].cells[m_used%MSGPACK_ZONE_CHUNK_SIZE].data; + ++m_used; + return data; +} + +void zone::clear() +{ + for(size_t b=0; b < m_used/MSGPACK_ZONE_CHUNK_SIZE; ++b) { + cell_t* c(m_pool[b].cells); + for(size_t e=0; e < MSGPACK_ZONE_CHUNK_SIZE; ++e) { + reinterpret_cast(c[e].data)->~object_class(); + } + } + cell_t* c(m_pool.back().cells); + for(size_t e=0; e < m_used%MSGPACK_ZONE_CHUNK_SIZE; ++e) { + reinterpret_cast(c[e].data)->~object_class(); + } + m_used = 0; + m_pool.resize(1); + for(user_finalizer_t::reverse_iterator it(m_user_finalizer.rbegin()), it_end(m_user_finalizer.rend()); + it != it_end; + ++it) { + it->call(); + } + m_user_finalizer.clear(); +} + + +} // namespace msgpack + diff --git a/cpp/zone.hpp.erb b/cpp/zone.hpp.erb new file mode 100644 index 00000000..1a941afc --- /dev/null +++ b/cpp/zone.hpp.erb @@ -0,0 +1,123 @@ +#ifndef MSGPACK_ZONE_HPP__ +#define MSGPACK_ZONE_HPP__ + +#include "msgpack/object.hpp" +#include + +#ifndef MSGPACK_ZONE_CHUNK_SIZE +#define MSGPACK_ZONE_CHUNK_SIZE 64 +#endif + +namespace msgpack { + + +class zone { +public: +zone() : m_used(0), m_pool(1) { } +~zone() { clear(); } + +public: + template + void push_finalizer(void (*func)(void* obj, void* user), T* obj, void* user); + +public: + object_nil* nnil() { return new (alloc()) object_nil(); } + object_true* ntrue() { return new (alloc()) object_true(); } + object_false* nfalse() { return new (alloc()) object_false(); } + object_u8* nu8( uint8_t v) { return new (alloc()) object_u8(v); } + object_u16* nu16(uint16_t v) { return new (alloc()) object_u16(v); } + object_u32* nu32(uint32_t v) { return new (alloc()) object_u32(v); } + object_u64* nu64(uint64_t v) { return new (alloc()) object_u64(v); } + object_i8* ni8( int8_t v) { return new (alloc()) object_i8(v); } + object_i16* ni16( int16_t v) { return new (alloc()) object_i16(v); } + object_i32* ni32( int32_t v) { return new (alloc()) object_i32(v); } + object_i64* ni64( int64_t v) { return new (alloc()) object_i64(v); } + object_float* nfloat( float v) { return new (alloc()) object_float(v); } + object_double* ndouble( double v) { return new (alloc()) object_double(v); } + + object_raw* nraw(void* ptr, uint32_t len) + { return new (alloc()) object_raw(ptr, len); } + + object_const_raw* nraw(const void* ptr, uint32_t len) + { return new (alloc()) object_const_raw(ptr, len); } + + object_array* narray() + { return new (alloc()) object_array(); } + + object_array* narray(size_t reserve_size) + { return new (alloc()) object_array(reserve_size); } + + object_map* nmap() + { return new (alloc()) object_map(); } + +<% GENERATION_SIZE = 16 %> +<% 1.upto(GENERATION_SIZE) {|i| %> + object_array* narray(<% 1.upto(i-1) {|n| %>object o<%=n%>, <% } %>object o<%=i%>) + { object_array* a = new (alloc()) object_array(<%=i%>); + <% 1.upto(i) {|n| %>a->push_back(o<%=n%>); + <% } %>return a; } +<% } %> + +<% 1.upto(GENERATION_SIZE) {|i| %> + object_map* nmap(<% 1.upto(i-1) {|n| %>object k<%=n%>, object v<%=n%>, <% } %>object k<%=i%>, object v<%=i%>) + { object_map* m = new (alloc()) object_map(); + <% 1.upto(i) {|n| %>m->store(k<%=n%>, v<%=n%>); + <% } %>return m; } +<% } %> + +public: + void clear(); + +private: + void* alloc(); + +private: + size_t m_used; + + static const size_t MAX_OBJECT_SIZE = + sizeof(object_raw) > sizeof(object_array) + ? ( sizeof(object_raw) > sizeof(object_map) + ? sizeof(object_raw) + : sizeof(object_map) + ) + : ( sizeof(object_array) > sizeof(object_map) + ? sizeof(object_array) + : sizeof(object_map) + ) + ; + + struct cell_t { + char data[MAX_OBJECT_SIZE]; + }; + + struct chunk_t { + cell_t cells[MSGPACK_ZONE_CHUNK_SIZE]; + }; + + typedef std::vector pool_t; + pool_t m_pool; + + + class finalizer { + public: + finalizer(void (*func)(void*, void*), void* obj, void* user) : + m_obj(obj), m_user(user), m_func(func) {} + void call() { (*m_func)(m_obj, m_user); } + private: + void* m_obj; + void* m_user; + void (*m_func)(void*, void*); + }; + + typedef std::vector user_finalizer_t; + user_finalizer_t m_user_finalizer; + +private: + zone(const zone&); +}; + + +} // namespace msgpack + +#endif /* msgpack/zone.hpp */ + diff --git a/msgpack/pack/inline_context.h b/msgpack/pack/inline_context.h deleted file mode 100644 index 139597f9..00000000 --- a/msgpack/pack/inline_context.h +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/msgpack/pack/inline_impl.h b/msgpack/pack/inline_impl.h index 5c4bfed6..08a5bc15 100644 --- a/msgpack/pack/inline_impl.h +++ b/msgpack/pack/inline_impl.h @@ -23,25 +23,25 @@ #ifdef __LITTLE_ENDIAN__ -#define STORE_16(d) \ +#define STORE_BE16(d) \ ((char*)&d)[1], ((char*)&d)[0] -#define STORE_32(d) \ +#define STORE_BE32(d) \ ((char*)&d)[3], ((char*)&d)[2], ((char*)&d)[1], ((char*)&d)[0] -#define STORE_64(d) \ +#define STORE_BE64(d) \ ((char*)&d)[7], ((char*)&d)[6], ((char*)&d)[5], ((char*)&d)[4], \ ((char*)&d)[3], ((char*)&d)[2], ((char*)&d)[1], ((char*)&d)[0] #elif __BIG_ENDIAN__ -#define STORE_16(d) \ - ((char*)&d)[2], ((char*)&d)[3] +#define STORE_BE16(d) \ + ((char*)&d)[0], ((char*)&d)[1] -#define STORE_32(d) \ +#define STORE_BE32(d) \ ((char*)&d)[0], ((char*)&d)[1], ((char*)&d)[2], ((char*)&d)[3] -#define STORE_32(d) \ +#define STORE_BE64(d) \ ((char*)&d)[0], ((char*)&d)[1], ((char*)&d)[2], ((char*)&d)[3], \ ((char*)&d)[4], ((char*)&d)[5], ((char*)&d)[6], ((char*)&d)[7] @@ -57,10 +57,10 @@ inline void msgpack_pack_int(msgpack_pack_context x, int d) { if(d < -32) { if(d < -32768) { // signed 32 - const unsigned char buf[5] = {0xd2, STORE_32(d)}; + const unsigned char buf[5] = {0xd2, STORE_BE32(d)}; msgpack_pack_append_buffer(x, buf, 5); } else if(d < -128) { // signed 16 - const unsigned char buf[3] = {0xd1, STORE_16(d)}; + const unsigned char buf[3] = {0xd1, STORE_BE16(d)}; msgpack_pack_append_buffer(x, buf, 3); } else { // signed 8 const unsigned char buf[2] = {0xd0, (uint8_t)d}; @@ -75,11 +75,11 @@ inline void msgpack_pack_int(msgpack_pack_context x, int d) msgpack_pack_append_buffer(x, buf, 2); } else if(d < 65536) { // unsigned 16 - const unsigned char buf[3] = {0xcd, STORE_16(d)}; + const unsigned char buf[3] = {0xcd, STORE_BE16(d)}; msgpack_pack_append_buffer(x, buf, 3); } else { // unsigned 32 - const unsigned char buf[5] = {0xce, STORE_32(d)}; + const unsigned char buf[5] = {0xce, STORE_BE32(d)}; msgpack_pack_append_buffer(x, buf, 5); } } @@ -97,11 +97,11 @@ inline void msgpack_pack_unsigned_int(msgpack_pack_context x, unsigned int d) msgpack_pack_append_buffer(x, buf, 2); } else if(d < 65536) { // unsigned 16 - const unsigned char buf[3] = {0xcd, STORE_16(d)}; + const unsigned char buf[3] = {0xcd, STORE_BE16(d)}; msgpack_pack_append_buffer(x, buf, 3); } else { // unsigned 32 - const unsigned char buf[5] = {0xce, STORE_32(d)}; + const unsigned char buf[5] = {0xce, STORE_BE32(d)}; msgpack_pack_append_buffer(x, buf, 5); } } @@ -118,20 +118,20 @@ inline void msgpack_pack_unsigned_int_8(msgpack_pack_context x, uint8_t d) inline void msgpack_pack_unsigned_int_16(msgpack_pack_context x, uint16_t d) { - const unsigned char buf[3] = {0xcd, STORE_16(d)}; + const unsigned char buf[3] = {0xcd, STORE_BE16(d)}; msgpack_pack_append_buffer(x, buf, 3); } inline void msgpack_pack_unsigned_int_32(msgpack_pack_context x, uint32_t d) { - const unsigned char buf[5] = {0xce, STORE_32(d)}; + const unsigned char buf[5] = {0xce, STORE_BE32(d)}; msgpack_pack_append_buffer(x, buf, 5); } inline void msgpack_pack_unsigned_int_64(msgpack_pack_context x, uint64_t d) { - // FIXME - const unsigned char buf[9] = {0xcf, STORE_64(d)}; + // FIXME optimization + const unsigned char buf[9] = {0xcf, STORE_BE64(d)}; msgpack_pack_append_buffer(x, buf, 9); } @@ -149,20 +149,20 @@ inline void msgpack_pack_signed_int_8(msgpack_pack_context x, int8_t d) inline void msgpack_pack_signed_int_16(msgpack_pack_context x, int16_t d) { - const unsigned char buf[3] = {0xd1, STORE_16(d)}; + const unsigned char buf[3] = {0xd1, STORE_BE16(d)}; msgpack_pack_append_buffer(x, buf, 3); } inline void msgpack_pack_signed_int_32(msgpack_pack_context x, int32_t d) { - const unsigned char buf[5] = {0xd2, STORE_32(d)}; + const unsigned char buf[5] = {0xd2, STORE_BE32(d)}; msgpack_pack_append_buffer(x, buf, 5); } inline void msgpack_pack_signed_int_64(msgpack_pack_context x, int64_t d) { - // FIXME - const unsigned char buf[9] = {0xd3, STORE_64(d)}; + // FIXME optimization + const unsigned char buf[9] = {0xd3, STORE_BE64(d)}; msgpack_pack_append_buffer(x, buf, 9); } @@ -174,14 +174,14 @@ inline void msgpack_pack_signed_int_64(msgpack_pack_context x, int64_t d) inline void msgpack_pack_float(msgpack_pack_context x, float d) { uint32_t n = *((uint32_t*)&d); // FIXME - const unsigned char buf[5] = {0xca, STORE_32(n)}; + const unsigned char buf[5] = {0xca, STORE_BE32(n)}; msgpack_pack_append_buffer(x, buf, 5); } inline void msgpack_pack_double(msgpack_pack_context x, double d) { uint64_t n = *((uint64_t*)&d); // FIXME - const unsigned char buf[9] = {0xcb, STORE_64(n)}; + const unsigned char buf[9] = {0xcb, STORE_BE64(n)}; msgpack_pack_append_buffer(x, buf, 9); } @@ -200,6 +200,7 @@ inline void msgpack_pack_nil(msgpack_pack_context x) /* * Boolean */ + inline void msgpack_pack_true(msgpack_pack_context x) { static const unsigned char d = 0xc3; @@ -224,11 +225,11 @@ inline void msgpack_pack_array(msgpack_pack_context x, unsigned int n) msgpack_pack_append_buffer(x, &d, 1); } else if(n < 65536) { uint16_t d = (uint16_t)n; - unsigned char buf[3] = {0xdc, STORE_16(d)}; + unsigned char buf[3] = {0xdc, STORE_BE16(d)}; msgpack_pack_append_buffer(x, buf, 3); } else { uint32_t d = (uint32_t)n; - unsigned char buf[5] = {0xdd, STORE_32(d)}; + unsigned char buf[5] = {0xdd, STORE_BE32(d)}; msgpack_pack_append_buffer(x, buf, 5); } } @@ -245,18 +246,18 @@ inline void msgpack_pack_map(msgpack_pack_context x, unsigned int n) msgpack_pack_append_buffer(x, &d, 1); } else if(n < 65536) { uint16_t d = (uint16_t)n; - unsigned char buf[3] = {0xde, STORE_16(d)}; + unsigned char buf[3] = {0xde, STORE_BE16(d)}; msgpack_pack_append_buffer(x, buf, 3); } else { uint32_t d = (uint32_t)n; - unsigned char buf[5] = {0xdf, STORE_32(d)}; + unsigned char buf[5] = {0xdf, STORE_BE32(d)}; msgpack_pack_append_buffer(x, buf, 5); } } /* - * String + * Raw */ inline void msgpack_pack_string(msgpack_pack_context x, const char* b) @@ -272,16 +273,21 @@ inline void msgpack_pack_raw(msgpack_pack_context x, const void* b, size_t l) msgpack_pack_append_buffer(x, &d, 1); } else if(l < 65536) { uint16_t d = (uint16_t)l; - unsigned char buf[3] = {0xda, STORE_16(d)}; + unsigned char buf[3] = {0xda, STORE_BE16(d)}; msgpack_pack_append_buffer(x, buf, 3); } else { uint32_t d = (uint32_t)l; - unsigned char buf[5] = {0xdb, STORE_32(d)}; + unsigned char buf[5] = {0xdb, STORE_BE32(d)}; msgpack_pack_append_buffer(x, buf, 5); } msgpack_pack_append_buffer(x, b, l); } +#undef STORE_BE16(d) +#undef STORE_BE32(d) +#undef STORE_BE64(d) + + #endif /* msgpack/pack/inline_impl.h */ diff --git a/msgpack/unpack/inline_context.h b/msgpack/unpack/inline_context.h index aecd5668..d6558a39 100644 --- a/msgpack/unpack/inline_context.h +++ b/msgpack/unpack/inline_context.h @@ -25,6 +25,10 @@ #define MSG_STACK_SIZE 16 #endif +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { msgpack_object obj; size_t count; @@ -47,6 +51,9 @@ void msgpack_unpacker_init(msgpack_unpacker* ctx); int msgpack_unpacker_execute(msgpack_unpacker* ctx, const char* data, size_t len, size_t* off); #define msgpack_unpacker_data(unpacker) (unpacker)->stack[0].obj +#ifdef __cplusplus +} +#endif #endif /* msgpack/unpack/inline_context.h */ diff --git a/msgpack/unpack/inline_impl.h b/msgpack/unpack/inline_impl.h index ec7f0fcb..f610dd74 100644 --- a/msgpack/unpack/inline_impl.h +++ b/msgpack/unpack/inline_impl.h @@ -23,6 +23,10 @@ #include /*#include */ +#ifdef __cplusplus +extern "C" { +#endif + // Positive FixNum 0xxxxxxx 0x00 - 0x7f // Negative FixNum 111xxxxx 0xe0 - 0xff // Variable 110xxxxx 0xc0 - 0xdf @@ -71,13 +75,16 @@ #endif #endif -static inline uint64_t ntohll(uint64_t x) { -#ifdef __LITTLE_ENDIAN__ // FIXME +#define betoh16(x) ntohs(x) +#define betoh32(x) ntohl(x) + +#ifdef __LITTLE_ENDIAN__ #if defined(__bswap_64) - return __bswap_64(x); +# define betoh64(x) __bswap_64(x) #elif defined(__DARWIN_OSSwapInt64) - return __DARWIN_OSSwapInt64(x); +# 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 ) | @@ -86,11 +93,12 @@ static inline uint64_t ntohll(uint64_t x) { ((x >> 24) & 0x0000000000ff0000ULL ) | ((x >> 40) & 0x000000000000ff00ULL ) | ((x >> 56) & 0x00000000000000ffULL ) ; +} #endif #else - return x; +#define betoh64(x) (x) #endif -} + typedef enum { CS_HEADER = 0x00, // nil @@ -212,9 +220,9 @@ int msgpack_unpacker_execute(msgpack_unpacker* ctx, const char* data, size_t len ((unsigned int)*p & 0x1f) #define PTR_CAST_8(ptr) (*(uint8_t*)ptr) -#define PTR_CAST_16(ptr) ntohs(*(uint16_t*)ptr) -#define PTR_CAST_32(ptr) ntohl(*(uint32_t*)ptr) -#define PTR_CAST_64(ptr) ntohll(*(uint64_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 { @@ -434,5 +442,21 @@ _end: } +#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 */