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

@@ -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;

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; }

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 {

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); }
 
 

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;
 

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)
 

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<const object_class*>(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<const object_class*>(val)->xraw();   }
 	const array& xarray() const { return const_cast<const object_class*>(val)->xarray(); }
 	const map&   xmap  () const { return const_cast<const object_class*>(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 <typename Stream>
+		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)
 

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);

cpp/test.cpp

@@ -4,7 +4,7 @@
 //#include <msgpack/pack.hpp>
 #include <msgpack.hpp>
 #include <sstream>
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 
 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<msgpack::zone> pz(upk.release_zone());
+				std::auto_ptr<msgpack::zone> pz(upk.release_zone());
 
 				std::cout << o << std::endl;
 				++num_msg;

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;

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);
 }

cpp/unpack_inline.cpp

@@ -71,12 +71,12 @@ static inline void msgpack_unpack_array_item(zone** z, object_class* c, object_c
 { reinterpret_cast<object_array*>(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<object_map*>(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); }
 
 

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<void>(&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(); }
 

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);
 

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;

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
 

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"