msgpack 0.3.2 → 0.3.3

data/ext/unpack.c

@@ -18,10 +18,16 @@
 #include "ruby.h"
 #include "msgpack/unpack_define.h"
 
+static ID s_sysread;
 
 typedef struct {
 	int finished;
 	VALUE source;
+	size_t offset;
+	size_t parsed;
+	VALUE buffer;
+	VALUE stream;
+	VALUE streambuf;
 } unpack_user;
 
 
@@ -144,6 +150,9 @@ static void MessagePack_Unpacker_free(void* data)
 static void MessagePack_Unpacker_mark(msgpack_unpack_t *mp)
 {
 	unsigned int i;
+	rb_gc_mark(mp->user.buffer);
+	rb_gc_mark(mp->user.stream);
+	rb_gc_mark(mp->user.streambuf);
 	for(i=0; i < mp->top; ++i) {
 		rb_gc_mark(mp->stack[i].obj);
 		rb_gc_mark(mp->stack[i].map_key); /* maybe map_key is not initialized */
@@ -164,14 +173,32 @@ static VALUE MessagePack_Unpacker_reset(VALUE self)
 	UNPACKER(self, mp);
 	template_init(mp);
 	init_stack(mp);
-	unpack_user u = {0, Qnil};
-	mp->user = u;
+	mp->user.finished = 0;
 	return self;
 }
 
-static VALUE MessagePack_Unpacker_initialize(VALUE self)
+static VALUE MessagePack_Unpacker_initialize(int argc, VALUE *argv, VALUE self)
 {
-	return MessagePack_Unpacker_reset(self);
+	VALUE stream;
+	switch(argc) {
+	case 0:
+		stream = Qnil;
+		break;
+	case 1:
+		stream = argv[0];
+		break;
+	default:
+		rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
+	}
+
+	MessagePack_Unpacker_reset(self);
+	UNPACKER(self, mp);
+	mp->user.offset = 0;
+	mp->user.parsed = 0;
+	mp->user.buffer = rb_str_new("",0);
+	mp->user.stream = stream;
+	mp->user.streambuf = rb_str_new("",0);
+	return self;
 }
 
 
@@ -249,6 +276,87 @@ static VALUE MessagePack_Unpacker_data(VALUE self)
 }
 
 
+static VALUE MessagePack_Unpacker_feed(VALUE self, VALUE data)
+{
+	UNPACKER(self, mp);
+	StringValue(data);
+	rb_str_cat(mp->user.buffer, RSTRING_PTR(data), RSTRING_LEN(data));
+	return Qnil;
+}
+
+static VALUE MessagePack_Unpacker_stream_get(VALUE self)
+{
+	UNPACKER(self, mp);
+	return mp->user.stream;
+}
+
+static VALUE MessagePack_Unpacker_stream_set(VALUE self, VALUE val)
+{
+	UNPACKER(self, mp);
+	return mp->user.stream = val;
+}
+
+static VALUE MessagePack_Unpacker_fill(VALUE self)
+{
+	UNPACKER(self, mp);
+
+	if(mp->user.stream == Qnil) {
+		return Qnil;
+	}
+
+	size_t len;
+	if(RSTRING_LEN(mp->user.buffer) == 0) {
+		rb_funcall(mp->user.stream, s_sysread, 2, LONG2FIX(64*1024), mp->user.buffer);
+		len = RSTRING_LEN(mp->user.buffer);
+	} else {
+		rb_funcall(mp->user.stream, s_sysread, 2, LONG2FIX(64*1024), mp->user.streambuf);
+		len = RSTRING_LEN(mp->user.streambuf);
+		rb_str_cat(mp->user.buffer, RSTRING_PTR(mp->user.streambuf), RSTRING_LEN(mp->user.streambuf));
+	}
+
+	return LONG2FIX(len);
+}
+
+static VALUE MessagePack_Unpacker_each(VALUE self)
+{
+	UNPACKER(self, mp);
+	int ret;
+
+#ifdef RETURN_ENUMERATOR
+	RETURN_ENUMERATOR(self, 0, 0);
+#endif
+
+	while(1) {
+		if(RSTRING_LEN(mp->user.buffer) <= mp->user.offset) {
+			do_fill:
+			{
+				VALUE len = MessagePack_Unpacker_fill(self);
+				if(len == Qnil || FIX2LONG(len) == 0) {
+					break;
+				}
+			}
+		}
+
+		mp->user.source = mp->user.buffer;
+		ret = template_execute(mp, RSTRING_PTR(mp->user.buffer), RSTRING_LEN(mp->user.buffer), &mp->user.offset);
+		mp->user.source = Qnil;
+
+		if(ret < 0) {
+			rb_raise(eUnpackError, "parse error.");
+		} else if(ret > 0) {
+			VALUE data = template_data(mp);
+			template_init(mp);
+			init_stack(mp);
+			rb_yield(data);
+		} else {
+			goto do_fill;
+		}
+	}
+
+	return Qnil;
+}
+
+
 static VALUE MessagePack_unpack_impl(VALUE args)
 {
 	msgpack_unpack_t* mp = (msgpack_unpack_t*)((VALUE*)args)[0];
@@ -292,7 +400,7 @@ static VALUE MessagePack_unpack_limit(VALUE self, VALUE data, VALUE limit)
 	msgpack_unpack_t mp;
 	template_init(&mp);
 	init_stack(&mp);
-	unpack_user u = {0, Qnil};
+	unpack_user u = {0, Qnil, 0, 0, Qnil, Qnil, Qnil};
 	mp.user = u;
 
 	rb_gc_disable();
@@ -313,17 +421,22 @@ static VALUE MessagePack_unpack(VALUE self, VALUE data)
 
 void Init_msgpack_unpack(VALUE mMessagePack)
 {
+	s_sysread = rb_intern("sysread");
 	eUnpackError = rb_define_class_under(mMessagePack, "UnpackError", rb_eStandardError);
 	cUnpacker = rb_define_class_under(mMessagePack, "Unpacker", rb_cObject);
 	rb_define_alloc_func(cUnpacker, MessagePack_Unpacker_alloc);
-	rb_define_method(cUnpacker, "initialize", MessagePack_Unpacker_initialize, 0);
+	rb_define_method(cUnpacker, "initialize", MessagePack_Unpacker_initialize, -1);
 	rb_define_method(cUnpacker, "execute", MessagePack_Unpacker_execute, 2);
 	rb_define_method(cUnpacker, "execute_limit", MessagePack_Unpacker_execute_limit, 3);
 	rb_define_method(cUnpacker, "finished?", MessagePack_Unpacker_finished_p, 0);
 	rb_define_method(cUnpacker, "data", MessagePack_Unpacker_data, 0);
 	rb_define_method(cUnpacker, "reset", MessagePack_Unpacker_reset, 0);
+	rb_define_method(cUnpacker, "feed", MessagePack_Unpacker_feed, 1);
+	rb_define_method(cUnpacker, "fill", MessagePack_Unpacker_fill, 0);
+	rb_define_method(cUnpacker, "each", MessagePack_Unpacker_each, 0);
+	rb_define_method(cUnpacker, "stream", MessagePack_Unpacker_stream_get, 0);
+	rb_define_method(cUnpacker, "stream=", MessagePack_Unpacker_stream_set, 1);
 	rb_define_module_function(mMessagePack, "unpack", MessagePack_unpack, 1);
 	rb_define_module_function(mMessagePack, "unpack_limit", MessagePack_unpack_limit, 2);
 }
 
-

data/msgpack/pack_define.h

@@ -1,7 +1,7 @@
 /*
  * MessagePack unpacking routine template
  *
- * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2010 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@
 
 #include "msgpack/sysdep.h"
 #include <limits.h>
+#include <string.h>
 
 #endif /* msgpack/pack_define.h */
 

data/msgpack/pack_template.h

@@ -1,7 +1,7 @@
 /*
  * MessagePack packing routine template
  *
- * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2010 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -69,7 +69,7 @@ do { \
 	} else { \
 		/* unsigned 16 */ \
 		unsigned char buf[3]; \
-		buf[0] = 0xcd; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+		buf[0] = 0xcd; _msgpack_store16(&buf[1], d); \
 		msgpack_pack_append_buffer(x, buf, 3); \
 	} \
 } while(0)
@@ -89,12 +89,12 @@ do { \
 		if(d < (1<<16)) { \
 			/* unsigned 16 */ \
 			unsigned char buf[3]; \
-			buf[0] = 0xcd; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+			buf[0] = 0xcd; _msgpack_store16(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else { \
 			/* unsigned 32 */ \
 			unsigned char buf[5]; \
-			buf[0] = 0xce; *(uint32_t*)&buf[1] = _msgpack_be32(d); \
+			buf[0] = 0xce; _msgpack_store32(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} \
 	} \
@@ -115,17 +115,17 @@ do { \
 		if(d < (1ULL<<16)) { \
 			/* signed 16 */ \
 			unsigned char buf[3]; \
-			buf[0] = 0xcd; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+			buf[0] = 0xcd; _msgpack_store16(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else if(d < (1ULL<<32)) { \
 			/* signed 32 */ \
 			unsigned char buf[5]; \
-			buf[0] = 0xce; *(uint32_t*)&buf[1] = _msgpack_be32(d); \
+			buf[0] = 0xce; _msgpack_store32(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} else { \
 			/* signed 64 */ \
 			unsigned char buf[9]; \
-			buf[0] = 0xcf; *(uint64_t*)&buf[1] = _msgpack_be64(d); \
+			buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 9); \
 		} \
 	} \
@@ -149,7 +149,7 @@ do { \
 		if(d < -(1<<7)) { \
 			/* signed 16 */ \
 			unsigned char buf[3]; \
-			buf[0] = 0xd1; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+			buf[0] = 0xd1; _msgpack_store16(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else { \
 			/* signed 8 */ \
@@ -167,7 +167,7 @@ do { \
 		} else { \
 			/* unsigned 16 */ \
 			unsigned char buf[3]; \
-			buf[0] = 0xcd; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+			buf[0] = 0xcd; _msgpack_store16(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} \
 	} \
@@ -179,12 +179,12 @@ do { \
 		if(d < -(1<<15)) { \
 			/* signed 32 */ \
 			unsigned char buf[5]; \
-			buf[0] = 0xd2; *(uint32_t*)&buf[1] = _msgpack_be32(d); \
+			buf[0] = 0xd2; _msgpack_store32(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} else if(d < -(1<<7)) { \
 			/* signed 16 */ \
 			unsigned char buf[3]; \
-			buf[0] = 0xd1; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+			buf[0] = 0xd1; _msgpack_store16(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else { \
 			/* signed 8 */ \
@@ -202,12 +202,12 @@ do { \
 		} else if(d < (1<<16)) { \
 			/* unsigned 16 */ \
 			unsigned char buf[3]; \
-			buf[0] = 0xcd; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+			buf[0] = 0xcd; _msgpack_store16(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else { \
 			/* unsigned 32 */ \
 			unsigned char buf[5]; \
-			buf[0] = 0xce; *(uint32_t*)&buf[1] = _msgpack_be32(d); \
+			buf[0] = 0xce; _msgpack_store32(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} \
 	} \
@@ -220,19 +220,19 @@ do { \
 			if(d < -(1LL<<31)) { \
 				/* signed 64 */ \
 				unsigned char buf[9]; \
-				buf[0] = 0xd3; *(uint64_t*)&buf[1] = _msgpack_be64(d); \
+				buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \
 				msgpack_pack_append_buffer(x, buf, 9); \
 			} else { \
 				/* signed 32 */ \
 				unsigned char buf[5]; \
-				buf[0] = 0xd2; *(uint32_t*)&buf[1] = _msgpack_be32(d); \
+				buf[0] = 0xd2; _msgpack_store32(&buf[1], d); \
 				msgpack_pack_append_buffer(x, buf, 5); \
 			} \
 		} else { \
 			if(d < -(1<<7)) { \
 				/* signed 16 */ \
 				unsigned char buf[3]; \
-				buf[0] = 0xd1; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+				buf[0] = 0xd1; _msgpack_store16(&buf[1], d); \
 				msgpack_pack_append_buffer(x, buf, 3); \
 			} else { \
 				/* signed 8 */ \
@@ -252,19 +252,19 @@ do { \
 			} else { \
 				/* unsigned 16 */ \
 				unsigned char buf[3]; \
-				buf[0] = 0xcd; *(uint16_t*)&buf[1] = _msgpack_be16(d); \
+				buf[0] = 0xcd; _msgpack_store16(&buf[1], d); \
 				msgpack_pack_append_buffer(x, buf, 3); \
 			} \
 		} else { \
 			if(d < (1LL<<32)) { \
 				/* unsigned 32 */ \
 				unsigned char buf[5]; \
-				buf[0] = 0xce; *(uint32_t*)&buf[1] = _msgpack_be32(d); \
+				buf[0] = 0xce; _msgpack_store32(&buf[1], d); \
 				msgpack_pack_append_buffer(x, buf, 5); \
 			} else { \
 				/* unsigned 64 */ \
 				unsigned char buf[9]; \
-				buf[0] = 0xcf; *(uint64_t*)&buf[1] = _msgpack_be64(d); \
+				buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
 				msgpack_pack_append_buffer(x, buf, 9); \
 			} \
 		} \
@@ -283,21 +283,21 @@ msgpack_pack_inline_func_fastint(_uint8)(msgpack_pack_user x, uint8_t d)
 msgpack_pack_inline_func_fastint(_uint16)(msgpack_pack_user x, uint16_t d)
 {
 	unsigned char buf[3];
-	buf[0] = 0xcd; *(uint16_t*)&buf[1] = _msgpack_be16(d);
+	buf[0] = 0xcd; _msgpack_store16(&buf[1], d);
 	msgpack_pack_append_buffer(x, buf, 3);
 }
 
 msgpack_pack_inline_func_fastint(_uint32)(msgpack_pack_user x, uint32_t d)
 {
 	unsigned char buf[5];
-	buf[0] = 0xce; *(uint32_t*)&buf[1] = _msgpack_be32(d);
+	buf[0] = 0xce; _msgpack_store32(&buf[1], d);
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
 msgpack_pack_inline_func_fastint(_uint64)(msgpack_pack_user x, uint64_t d)
 {
 	unsigned char buf[9];
-	buf[0] = 0xcf; *(uint64_t*)&buf[1] = _msgpack_be64(d);
+	buf[0] = 0xcf; _msgpack_store64(&buf[1], d);
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
@@ -310,21 +310,21 @@ msgpack_pack_inline_func_fastint(_int8)(msgpack_pack_user x, int8_t d)
 msgpack_pack_inline_func_fastint(_int16)(msgpack_pack_user x, int16_t d)
 {
 	unsigned char buf[3];
-	buf[0] = 0xd1; *(uint16_t*)&buf[1] = _msgpack_be16(d);
+	buf[0] = 0xd1; _msgpack_store16(&buf[1], d);
 	msgpack_pack_append_buffer(x, buf, 3);
 }
 
 msgpack_pack_inline_func_fastint(_int32)(msgpack_pack_user x, int32_t d)
 {
 	unsigned char buf[5];
-	buf[0] = 0xd2; *(uint32_t*)&buf[1] = _msgpack_be32(d);
+	buf[0] = 0xd2; _msgpack_store32(&buf[1], d);
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
 msgpack_pack_inline_func_fastint(_int64)(msgpack_pack_user x, int64_t d)
 {
 	unsigned char buf[9];
-	buf[0] = 0xd3; *(uint64_t*)&buf[1] = _msgpack_be64(d);
+	buf[0] = 0xd3; _msgpack_store64(&buf[1], d);
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
@@ -554,19 +554,19 @@ if(sizeof(unsigned long long) == 2) {
 
 msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d)
 {
-	union { char buf[4]; uint32_t num; } f;
-	*((float*)&f.buf) = d;  // FIXME
+	union { float f; uint32_t i; } mem;
+	mem.f = d;
 	unsigned char buf[5];
-	buf[0] = 0xca; *(uint32_t*)&buf[1] = _msgpack_be32(f.num);
+	buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i);
 	msgpack_pack_append_buffer(x, buf, 5);
 }
 
 msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
 {
-	union { char buf[8]; uint64_t num; } f;
-	*((double*)&f.buf) = d;  // FIXME
+	union { double f; uint64_t i; } mem;
+	mem.f = d;
 	unsigned char buf[9];
-	buf[0] = 0xcb; *(uint64_t*)&buf[1] = _msgpack_be64(f.num);
+	buf[0] = 0xcb; _msgpack_store64(&buf[1], mem.i);
 	msgpack_pack_append_buffer(x, buf, 9);
 }
 
@@ -610,11 +610,11 @@ msgpack_pack_inline_func(_array)(msgpack_pack_user x, unsigned int n)
 		msgpack_pack_append_buffer(x, &d, 1);
 	} else if(n < 65536) {
 		unsigned char buf[3];
-		buf[0] = 0xdc; *(uint16_t*)&buf[1] = _msgpack_be16(n);
+		buf[0] = 0xdc; _msgpack_store16(&buf[1], n);
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
 		unsigned char buf[5];
-		buf[0] = 0xdd; *(uint32_t*)&buf[1] = _msgpack_be32(n);
+		buf[0] = 0xdd; _msgpack_store32(&buf[1], n);
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
 }
@@ -631,11 +631,11 @@ msgpack_pack_inline_func(_map)(msgpack_pack_user x, unsigned int n)
 		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
 	} else if(n < 65536) {
 		unsigned char buf[3];
-		buf[0] = 0xde; *(uint16_t*)&buf[1] = _msgpack_be16(n);
+		buf[0] = 0xde; _msgpack_store16(&buf[1], n);
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
 		unsigned char buf[5];
-		buf[0] = 0xdf; *(uint32_t*)&buf[1] = _msgpack_be32(n);
+		buf[0] = 0xdf; _msgpack_store32(&buf[1], n);
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
 }
@@ -652,11 +652,11 @@ msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l)
 		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
 	} else if(l < 65536) {
 		unsigned char buf[3];
-		buf[0] = 0xda; *(uint16_t*)&buf[1] = _msgpack_be16(l);
+		buf[0] = 0xda; _msgpack_store16(&buf[1], l);
 		msgpack_pack_append_buffer(x, buf, 3);
 	} else {
 		unsigned char buf[5];
-		buf[0] = 0xdb; *(uint32_t*)&buf[1] = _msgpack_be32(l);
+		buf[0] = 0xdb; _msgpack_store32(&buf[1], l);
 		msgpack_pack_append_buffer(x, buf, 5);
 	}
 }

data/msgpack/sysdep.h

@@ -1,7 +1,7 @@
 /*
  * MessagePack system dependencies
  *
- * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2010 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -48,6 +48,17 @@ typedef unsigned int _msgpack_atomic_counter_t;
 
 #ifdef _WIN32
 #include <winsock2.h>
+
+#ifdef __cplusplus
+/* numeric_limits<T>::min,max */
+#ifdef max
+#undef max
+#endif
+#ifdef min
+#undef min
+#endif
+#endif
+
 #else
 #include <arpa/inet.h>  /* __BYTE_ORDER */
 #endif
@@ -90,5 +101,18 @@ typedef unsigned int _msgpack_atomic_counter_t;
 #endif
 
 
+#define _msgpack_store16(to, num) \
+	do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0);
+#define _msgpack_store32(to, num) \
+	do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0);
+#define _msgpack_store64(to, num) \
+	do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0);
+
+
+#define _msgpack_load16(cast, from) ((cast)_msgpack_be16(*(uint16_t*)from))
+#define _msgpack_load32(cast, from) ((cast)_msgpack_be32(*(uint32_t*)from))
+#define _msgpack_load64(cast, from) ((cast)_msgpack_be64(*(uint64_t*)from))
+
+
 #endif /* msgpack/sysdep.h */
 

data/msgpack/unpack_define.h

@@ -1,7 +1,7 @@
 /*
  * MessagePack unpacking routine template
  *
- * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2010 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.

data/msgpack/unpack_template.h

@@ -1,7 +1,7 @@
 /*
  * MessagePack unpacking routine template
  *
- * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2010 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -130,11 +130,6 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 #define NEXT_CS(p) \
 	((unsigned int)*p & 0x1f)
 
-#define PTR_CAST_8(ptr)   (*(uint8_t*)ptr)
-#define PTR_CAST_16(ptr)  _msgpack_be16(*(uint16_t*)ptr)
-#define PTR_CAST_32(ptr)  _msgpack_be32(*(uint32_t*)ptr)
-#define PTR_CAST_64(ptr)  _msgpack_be64(*(uint64_t*)ptr)
-
 #ifdef USE_CASE_RANGE
 #define SWITCH_RANGE_BEGIN     switch(*p) {
 #define SWITCH_RANGE(FROM, TO) case FROM ... TO:
@@ -222,70 +217,70 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 			//case CS_
 			//case CS_
 			case CS_FLOAT: {
-					union { uint32_t num; char buf[4]; } f;
-					f.num = PTR_CAST_32(n);  // FIXME
-					push_fixed_value(_float, *((float*)f.buf)); }
+					union { uint32_t i; float f; } mem;
+					mem.i = _msgpack_load32(uint32_t,n);
+					push_fixed_value(_float, mem.f); }
 			case CS_DOUBLE: {
-					union { uint64_t num; char buf[8]; } f;
-					f.num = PTR_CAST_64(n);  // FIXME
-					push_fixed_value(_double, *((double*)f.buf)); }
+					union { uint64_t i; double f; } mem;
+					mem.i = _msgpack_load64(uint64_t,n);
+					push_fixed_value(_double, mem.f); }
 			case CS_UINT_8:
-				push_fixed_value(_uint8, (uint8_t)PTR_CAST_8(n));
+				push_fixed_value(_uint8, *(uint8_t*)n);
 			case CS_UINT_16:
-				push_fixed_value(_uint16, (uint16_t)PTR_CAST_16(n));
+				push_fixed_value(_uint16, _msgpack_load16(uint16_t,n));
 			case CS_UINT_32:
-				push_fixed_value(_uint32, (uint32_t)PTR_CAST_32(n));
+				push_fixed_value(_uint32, _msgpack_load32(uint32_t,n));
 			case CS_UINT_64:
-				push_fixed_value(_uint64, (uint64_t)PTR_CAST_64(n));
+				push_fixed_value(_uint64, _msgpack_load64(uint64_t,n));
 
 			case CS_INT_8:
-				push_fixed_value(_int8, (int8_t)PTR_CAST_8(n));
+				push_fixed_value(_int8, *(int8_t*)n);
 			case CS_INT_16:
-				push_fixed_value(_int16, (int16_t)PTR_CAST_16(n));
+				push_fixed_value(_int16, _msgpack_load16(int16_t,n));
 			case CS_INT_32:
-				push_fixed_value(_int32, (int32_t)PTR_CAST_32(n));
+				push_fixed_value(_int32, _msgpack_load32(int32_t,n));
 			case CS_INT_64:
-				push_fixed_value(_int64, (int64_t)PTR_CAST_64(n));
+				push_fixed_value(_int64, _msgpack_load64(int64_t,n));
 
 			//case CS_
 			//case CS_
 			//case CS_BIG_INT_16:
-			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, (uint16_t)PTR_CAST_16(n), _big_int_zero);
+			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load16(uint16_t,n), _big_int_zero);
 			//case CS_BIG_INT_32:
-			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, (uint32_t)PTR_CAST_32(n), _big_int_zero);
+			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load32(uint32_t,n), _big_int_zero);
 			//case ACS_BIG_INT_VALUE:
 			//_big_int_zero:
 			//	// FIXME
 			//	push_variable_value(_big_int, data, n, trail);
 
 			//case CS_BIG_FLOAT_16:
-			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, (uint16_t)PTR_CAST_16(n), _big_float_zero);
+			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load16(uint16_t,n), _big_float_zero);
 			//case CS_BIG_FLOAT_32:
-			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, (uint32_t)PTR_CAST_32(n), _big_float_zero);
+			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load32(uint32_t,n), _big_float_zero);
 			//case ACS_BIG_FLOAT_VALUE:
 			//_big_float_zero:
 			//	// FIXME
 			//	push_variable_value(_big_float, data, n, trail);
 
 			case CS_RAW_16:
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, (uint16_t)PTR_CAST_16(n), _raw_zero);
+				again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load16(uint16_t,n), _raw_zero);
 			case CS_RAW_32:
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, (uint32_t)PTR_CAST_32(n), _raw_zero);
+				again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load32(uint32_t,n), _raw_zero);
 			case ACS_RAW_VALUE:
 			_raw_zero:
 				push_variable_value(_raw, data, n, trail);
 
 			case CS_ARRAY_16:
-				start_container(_array, (uint16_t)PTR_CAST_16(n), CT_ARRAY_ITEM);
+				start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM);
 			case CS_ARRAY_32:
 				/* FIXME security guard */
-				start_container(_array, (uint32_t)PTR_CAST_32(n), CT_ARRAY_ITEM);
+				start_container(_array, _msgpack_load32(uint32_t,n), CT_ARRAY_ITEM);
 
 			case CS_MAP_16:
-				start_container(_map, (uint16_t)PTR_CAST_16(n), CT_MAP_KEY);
+				start_container(_map, _msgpack_load16(uint16_t,n), CT_MAP_KEY);
 			case CS_MAP_32:
 				/* FIXME security guard */
-				start_container(_map, (uint32_t)PTR_CAST_32(n), CT_MAP_KEY);
+				start_container(_map, _msgpack_load32(uint32_t,n), CT_MAP_KEY);
 
 			default:
 				goto _failed;
@@ -371,8 +366,4 @@ _end:
 #undef start_container
 
 #undef NEXT_CS
-#undef PTR_CAST_8
-#undef PTR_CAST_16
-#undef PTR_CAST_32
-#undef PTR_CAST_64
 

metadata

@@ -1,20 +1,20 @@
 --- !ruby/object:Gem::Specification 
 name: msgpack
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - FURUHASHI Sadayuki
-autorequire: ""
+autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-11 00:00:00 +09:00
+date: 2010-03-02 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
-description: Binary-based efficient data interchange format.
-email: frsyuki _at_ users.sourceforge.jp
+description: 
+email: frsyuki@users.sourceforge.jp
 executables: []
 
 extensions: 
@@ -24,42 +24,31 @@ extra_rdoc_files:
 - ChangeLog
 - AUTHORS
 files: 
-- README
-- ChangeLog
-- Rakefile
-- test/msgpack_test.rb
-- test/test_helper.rb
-- ext/pack.h
-- ext/unpack.h
+- ext/extconf.rb
 - ext/pack.c
+- ext/pack.h
 - ext/rbinit.c
 - ext/unpack.c
-- ext/extconf.rb
+- ext/unpack.h
 - msgpack/pack_define.h
 - msgpack/pack_template.h
 - msgpack/sysdep.h
 - msgpack/unpack_define.h
 - msgpack/unpack_template.h
+- test/msgpack_test.rb
+- test/test_helper.rb
+- README
+- ChangeLog
 - AUTHORS
 has_rdoc: true
 homepage: http://msgpack.sourceforge.jp/
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --title
-- msgpack documentation
-- --charset
-- utf-8
-- --opname
-- index.html
-- --line-numbers
-- --main
-- README
-- --inline-source
-- --exclude
-- ^(examples|extras)/
+rdoc_options: []
+
 require_paths: 
+- lib
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
@@ -79,6 +68,6 @@ rubyforge_project: msgpack
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Binary-based efficient data interchange format.
+summary: MessagePack, a binary-based efficient data interchange format.
 test_files: 
 - test/test_helper.rb

data/Rakefile

@@ -1,133 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rake/contrib/rubyforgepublisher'
-require 'rake/contrib/sshpublisher'
-require 'fileutils'
-include FileUtils
-
-NAME              = "msgpack"
-AUTHOR            = "FURUHASHI Sadayuki"
-EMAIL             = "frsyuki _at_ users.sourceforge.jp"
-DESCRIPTION       = "Binary-based efficient data interchange format."
-RUBYFORGE_PROJECT = "msgpack"
-HOMEPATH          = "http://msgpack.sourceforge.jp/"
-BIN_FILES         = %w(  )
-VERS              = "0.3.2"
-
-#REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
-REV = nil
-CLEAN.include ['**/.*.sw?', '*.gem', '.config']
-RDOC_OPTS = [
-	'--title', "#{NAME} documentation",
-	"--charset", "utf-8",
-	"--opname", "index.html",
-	"--line-numbers",
-	"--main", "README",
-	"--inline-source",
-]
-
-task :default => [:test]
-task :package => [:clean]
-
-Rake::TestTask.new("test") do |t|
-	t.libs   << "test"
-	t.pattern = "test/**/*_test.rb"
-	t.verbose = true
-end
-
-spec = Gem::Specification.new do |s|
-	s.name              = NAME
-	s.version           = VERS
-	s.platform          = Gem::Platform::RUBY
-	s.has_rdoc          = false
-	s.extra_rdoc_files  = ["README", "ChangeLog", "AUTHORS"]
-	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
-	s.summary           = DESCRIPTION
-	s.description       = DESCRIPTION
-	s.author            = AUTHOR
-	s.email             = EMAIL
-	s.homepage          = HOMEPATH
-	s.executables       = BIN_FILES
-	s.rubyforge_project = RUBYFORGE_PROJECT
-	s.bindir            = "bin"
-	s.require_path      = "ext"
-	s.autorequire       = ""
-	s.test_files        = Dir["test/test_*.rb"]
-
-	#s.add_dependency('activesupport', '>=1.3.1')
-	#s.required_ruby_version = '>= 1.8.2'
-
-	s.files = %w(README ChangeLog Rakefile) +
-		Dir.glob("{bin,doc,test,lib,templates,generator,extras,website,script}/**/*") + 
-		Dir.glob("ext/**/*.{h,c,rb}") +
-		Dir.glob("examples/**/*.rb") +
-		Dir.glob("tools/*.rb") +
-		Dir.glob("msgpack/*.h")
-
-	s.extensions = FileList["ext/**/extconf.rb"].to_a
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-	p.need_tar = true
-	p.gem_spec = spec
-end
-
-task :install do
-	name = "#{NAME}-#{VERS}.gem"
-	sh %{rake package}
-	sh %{sudo gem install pkg/#{name}}
-end
-
-task :uninstall => [:clean] do
-	sh %{sudo gem uninstall #{NAME}}
-end
-
-
-#Rake::RDocTask.new do |rdoc|
-#	rdoc.rdoc_dir = 'html'
-#	rdoc.options += RDOC_OPTS
-#	rdoc.template = "resh"
-#	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
-#	if ENV['DOC_FILES']
-#		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
-#	else
-#		rdoc.rdoc_files.include('README', 'ChangeLog')
-#		rdoc.rdoc_files.include('lib/**/*.rb')
-#		rdoc.rdoc_files.include('ext/**/*.c')
-#	end
-#end
-
-desc "Publish to RubyForge"
-task :rubyforge => [:rdoc, :package] do
-	require 'rubyforge'
-	Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'frsyuki').upload
-end
-
-desc 'Package and upload the release to rubyforge.'
-task :release => [:clean, :package] do |t|
-	v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
-	abort "Versions don't match #{v} vs #{VERS}" unless v == VERS
-	pkg = "pkg/#{NAME}-#{VERS}"
-
-	rf = RubyForge.new
-	puts "Logging in"
-	rf.login
-
-	c = rf.userconfig
-#	c["release_notes"] = description if description
-#	c["release_changes"] = changes if changes
-	c["preformatted"] = true
-
-	files = [
-		"#{pkg}.tgz",
-		"#{pkg}.gem"
-	].compact
-
-	puts "Releasing #{NAME} v. #{VERS}"
-	rf.add_release RUBYFORGE_PROJECT, NAME, VERS, *files
-end