msgpack 0.3.7-x86-mingw32 → 0.3.8-x86-mingw32

data/ext/pack.c

@@ -112,6 +112,16 @@ static VALUE MessagePack_String_to_msgpack(int argc, VALUE *argv, VALUE self)
 	return out;
 }
 
+static VALUE MessagePack_Symbol_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	const char* name = rb_id2name(SYM2ID(self));
+	size_t len = strlen(name);
+	msgpack_pack_raw(out, len);
+	msgpack_pack_raw_body(out, name, len);
+	return out;
+}
+
 static VALUE MessagePack_Array_to_msgpack(int argc, VALUE *argv, VALUE self)
 {
 	ARG_BUFFER(out, argc, argv);
@@ -172,6 +182,7 @@ void Init_msgpack_pack(VALUE mMessagePack)
 	rb_define_method_id(rb_cString, s_to_msgpack, MessagePack_String_to_msgpack, -1);
 	rb_define_method_id(rb_cArray,  s_to_msgpack, MessagePack_Array_to_msgpack, -1);
 	rb_define_method_id(rb_cHash,   s_to_msgpack, MessagePack_Hash_to_msgpack, -1);
+	rb_define_method_id(rb_cSymbol, s_to_msgpack, MessagePack_Symbol_to_msgpack, -1);
 	rb_define_module_function(mMessagePack, "pack", MessagePack_pack, -1);
 }
 

data/ext/unpack.c

@@ -16,16 +16,21 @@
  *    limitations under the License.
  */
 #include "ruby.h"
+
 #include "msgpack/unpack_define.h"
 
 static ID s_sysread;
 static ID s_readpartial;
 
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+int s_ascii_8bit;
+#endif
+
 typedef struct {
 	int finished;
 	VALUE source;
 	size_t offset;
-	size_t parsed;
 	VALUE buffer;
 	VALUE stream;
 	VALUE streambuf;
@@ -138,18 +143,71 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha
 		rb_raise(rb_eTypeError, "instance of String needed"); \
 	}
 
-static VALUE cUnpacker;
-static VALUE eUnpackError;
 
-// FIXME slow operation
-static void init_stack(msgpack_unpack_t* mp)
+static VALUE template_execute_rescue(VALUE nouse)
 {
-	size_t i;
-	for(i=0; i < MSGPACK_MAX_STACK_SIZE; ++i) {
-		mp->stack[i].map_key = Qnil;  /* GC */
-	}
+	rb_gc_enable();
+#ifdef RUBY_VM
+	rb_exc_raise(rb_errinfo());
+#else
+	rb_exc_raise(ruby_errinfo);
+#endif
+}
+
+static VALUE template_execute_do(VALUE argv)
+{
+	VALUE* args = (VALUE*)argv;
+
+	msgpack_unpack_t* mp = (msgpack_unpack_t*)args[0];
+	char* dptr   = (char*)args[1];
+	size_t dlen  = (size_t)args[2];
+	size_t* from = (size_t*)args[3];
+
+	int ret = template_execute(mp, dptr, dlen, from);
+
+	return (VALUE)ret;
+}
+
+static int template_execute_wrap(msgpack_unpack_t* mp,
+		VALUE str, size_t dlen, size_t* from)
+{
+	VALUE args[4] = {
+		(VALUE)mp,
+		(VALUE)RSTRING_PTR(str),
+		(VALUE)dlen,
+		(VALUE)from,
+	};
+
+#ifdef HAVE_RUBY_ENCODING_H
+	// FIXME encodingをASCII-8BITにする
+	int enc_orig = rb_enc_get_index(str);
+	rb_enc_set_index(str, s_ascii_8bit);
+#endif
+
+	// FIXME execute実行中はmp->topが更新されないのでGC markが機能しない
+	rb_gc_disable();
+
+	mp->user.source = str;
+
+	int ret = (int)rb_rescue(template_execute_do, (VALUE)args,
+			template_execute_rescue, Qnil);
+
+	mp->user.source = Qnil;
+
+	rb_gc_enable();
+
+#ifdef HAVE_RUBY_ENCODING_H
+	rb_enc_set_index(str, enc_orig);
+#endif
+
+	return ret;
 }
 
+
+static VALUE cUnpacker;
+static VALUE eUnpackError;
+
+
 static void MessagePack_Unpacker_free(void* data)
 {
 	if(data) { free(data); }
@@ -163,7 +221,7 @@ static void MessagePack_Unpacker_mark(msgpack_unpack_t *mp)
 	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 */
+		rb_gc_mark_maybe(mp->stack[i].map_key);
 	}
 }
 
@@ -176,15 +234,6 @@ static VALUE MessagePack_Unpacker_alloc(VALUE klass)
 	return obj;
 }
 
-static VALUE MessagePack_Unpacker_reset(VALUE self)
-{
-	UNPACKER(self, mp);
-	template_init(mp);
-	init_stack(mp);
-	mp->user.finished = 0;
-	return self;
-}
-
 static ID append_method_of(VALUE stream)
 {
 	if(rb_respond_to(stream, s_sysread)) {
@@ -208,10 +257,10 @@ static VALUE MessagePack_Unpacker_initialize(int argc, VALUE *argv, VALUE self)
 		rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
 	}
 
-	MessagePack_Unpacker_reset(self);
 	UNPACKER(self, mp);
+	template_init(mp);
+	mp->user.finished = 0;
 	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);
@@ -219,94 +268,20 @@ static VALUE MessagePack_Unpacker_initialize(int argc, VALUE *argv, VALUE self)
 	return self;
 }
 
-
-static VALUE MessagePack_Unpacker_execute_do(VALUE argv)
-{
-	VALUE* args = (VALUE*)argv;
-
-	VALUE self = args[0];
-	UNPACKER(self, mp);
-
-	VALUE data = args[1];
-
-	size_t from = (unsigned long)args[2];
-	char* dptr = RSTRING_PTR(data);
-	size_t dlen = (unsigned long)args[3];
-	int ret;
-
-	if(from >= dlen) {
-		rb_raise(eUnpackError, "offset is bigger than data buffer size.");
-	}
-
-	mp->user.source = data;
-	ret = template_execute(mp, dptr, dlen, &from);
-	mp->user.source = Qnil;
-
-	if(ret < 0) {
-		rb_raise(eUnpackError, "parse error.");
-	} else if(ret > 0) {
-		mp->user.finished = 1;
-		return ULONG2NUM(from);
-	} else {
-		mp->user.finished = 0;
-		return ULONG2NUM(from);
-	}
-}
-
-static VALUE MessagePack_Unpacker_execute_rescue(VALUE nouse)
-{
-	rb_gc_enable();
-#ifdef RUBY_VM
-	rb_exc_raise(rb_errinfo());
-#else
-	rb_exc_raise(ruby_errinfo);
-#endif
-}
-
-static inline VALUE MessagePack_Unpacker_execute_impl(VALUE self, VALUE data,
-		unsigned long off, unsigned long dlen)
-{
-	// FIXME execute実行中はmp->topが更新されないのでGC markが機能しない
-	rb_gc_disable();
-	VALUE args[4] = {self, data, (VALUE)off, (VALUE)dlen};
-	VALUE ret = rb_rescue(MessagePack_Unpacker_execute_do, (VALUE)args,
-			MessagePack_Unpacker_execute_rescue, Qnil);
-	rb_gc_enable();
-
-	return ret;
-}
-
-static VALUE MessagePack_Unpacker_execute_limit(VALUE self, VALUE data,
-		VALUE off, VALUE limit)
-{
-	CHECK_STRING_TYPE(data);
-	return MessagePack_Unpacker_execute_impl(self, data,
-			NUM2ULONG(off), NUM2ULONG(limit));
-}
-
-static VALUE MessagePack_Unpacker_execute(VALUE self, VALUE data, VALUE off)
-{
-	CHECK_STRING_TYPE(data);
-	return MessagePack_Unpacker_execute_impl(self, data,
-			NUM2ULONG(off), RSTRING_LEN(data));
-}
-
-static VALUE MessagePack_Unpacker_finished_p(VALUE self)
+static VALUE MessagePack_Unpacker_stream_get(VALUE self)
 {
 	UNPACKER(self, mp);
-	if(mp->user.finished) {
-		return Qtrue;
-	}
-	return Qfalse;
+	return mp->user.stream;
 }
 
-static VALUE MessagePack_Unpacker_data(VALUE self)
+static VALUE MessagePack_Unpacker_stream_set(VALUE self, VALUE val)
 {
 	UNPACKER(self, mp);
-	return template_data(mp);
+	mp->user.stream = val;
+	mp->user.stream_append_method = append_method_of(val);
+	return val;
 }
 
-
 static VALUE MessagePack_Unpacker_feed(VALUE self, VALUE data)
 {
 	UNPACKER(self, mp);
@@ -315,20 +290,6 @@ static VALUE MessagePack_Unpacker_feed(VALUE self, VALUE 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);
-	mp->user.stream = val;
-	mp->user.stream_append_method = append_method_of(val);
-	return val;
-}
-
 static VALUE MessagePack_Unpacker_fill(VALUE self)
 {
 	UNPACKER(self, mp);
@@ -337,7 +298,7 @@ static VALUE MessagePack_Unpacker_fill(VALUE self)
 		return Qnil;
 	}
 
-	size_t len;
+	long len;
 	if(RSTRING_LEN(mp->user.buffer) == 0) {
 		rb_funcall(mp->user.stream, mp->user.stream_append_method, 2,
 				LONG2FIX(64*1024), mp->user.buffer);
@@ -372,17 +333,17 @@ static VALUE MessagePack_Unpacker_each(VALUE self)
 			}
 		}
 
-		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;
+		ret = template_execute_wrap(mp, mp->user.buffer,
+				RSTRING_LEN(mp->user.buffer), &mp->user.offset);
 
 		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;
 		}
@@ -391,73 +352,88 @@ static VALUE MessagePack_Unpacker_each(VALUE self)
 	return Qnil;
 }
 
-
-static VALUE MessagePack_unpack_do(VALUE argv)
+static inline VALUE MessagePack_unpack_impl(VALUE self, VALUE data, unsigned long dlen)
 {
-	VALUE* args = (VALUE*)argv;
+	msgpack_unpack_t mp;
+	template_init(&mp);
 
-	msgpack_unpack_t* mp = (msgpack_unpack_t*)args[0];
-	VALUE data = args[1];
+	mp.user.finished = 0;
 
 	size_t from = 0;
-	char* dptr = RSTRING_PTR(data);
-	size_t dlen = (unsigned long)args[2];
-	int ret;
-
-	mp->user.source = data;
-	ret = template_execute(mp, dptr, dlen, &from);
-	mp->user.source = Qnil;
+	int ret = template_execute_wrap(&mp, data, dlen, &from);
 
 	if(ret < 0) {
 		rb_raise(eUnpackError, "parse error.");
+
 	} else if(ret == 0) {
 		rb_raise(eUnpackError, "insufficient bytes.");
+
 	} else {
 		if(from < dlen) {
 			rb_raise(eUnpackError, "extra bytes.");
 		}
-		return template_data(mp);
+		return template_data(&mp);
 	}
 }
 
-static VALUE MessagePack_unpack_rescue(VALUE nouse)
+static VALUE MessagePack_unpack_limit(VALUE self, VALUE data, VALUE limit)
 {
-	rb_gc_enable();
-#ifdef RUBY_VM
-	rb_exc_raise(rb_errinfo());
-#else
-	rb_exc_raise(ruby_errinfo);
-#endif
+	CHECK_STRING_TYPE(data);
+	return MessagePack_unpack_impl(self, data, NUM2ULONG(limit));
 }
 
-static inline VALUE MessagePack_unpack_impl(VALUE self, VALUE data, unsigned long dlen)
+static VALUE MessagePack_unpack(VALUE self, VALUE data)
 {
-	msgpack_unpack_t mp;
-	template_init(&mp);
-	init_stack(&mp);
-	unpack_user u = {0, Qnil, 0, 0, Qnil, Qnil, Qnil};
-	mp.user = u;
+	CHECK_STRING_TYPE(data);
+	return MessagePack_unpack_impl(self, data, RSTRING_LEN(data));
+}
 
-	// FIXME execute実行中はmp->topが更新されないのでGC markが機能しない
-	rb_gc_disable();
-	VALUE args[3] = {(VALUE)&mp, data, (VALUE)dlen};
-	VALUE ret = rb_rescue(MessagePack_unpack_do, (VALUE)args,
-			MessagePack_unpack_rescue, Qnil);
-	rb_gc_enable();
 
-	return ret;
+/* compat */
+static VALUE MessagePack_Unpacker_execute_limit(VALUE self, VALUE data,
+		VALUE off, VALUE limit)
+{
+	CHECK_STRING_TYPE(data);
+	UNPACKER(self, mp);
+	size_t from = (size_t)NUM2ULONG(off);
+	int ret = template_execute_wrap(mp, data, NUM2ULONG(limit), &from);
+	return INT2FIX(ret);
 }
 
-static VALUE MessagePack_unpack_limit(VALUE self, VALUE data, VALUE limit)
+/* compat */
+static VALUE MessagePack_Unpacker_execute(VALUE self, VALUE data, VALUE off)
 {
 	CHECK_STRING_TYPE(data);
-	return MessagePack_unpack_impl(self, data, NUM2ULONG(limit));
+	UNPACKER(self, mp);
+	size_t from = (size_t)NUM2ULONG(off);
+	int ret = template_execute_wrap(mp, data, RSTRING_LEN(data), &from);
+	return INT2FIX(ret);
 }
 
-static VALUE MessagePack_unpack(VALUE self, VALUE data)
+/* compat */
+static VALUE MessagePack_Unpacker_finished_p(VALUE self)
 {
-	CHECK_STRING_TYPE(data);
-	return MessagePack_unpack_impl(self, data, RSTRING_LEN(data));
+	UNPACKER(self, mp);
+	if(mp->user.finished) {
+		return Qtrue;
+	}
+	return Qfalse;
+}
+
+/* compat */
+static VALUE MessagePack_Unpacker_data(VALUE self)
+{
+	UNPACKER(self, mp);
+	return template_data(mp);
+}
+
+/* compat */
+static VALUE MessagePack_Unpacker_reset(VALUE self)
+{
+	UNPACKER(self, mp);
+	template_init(mp);
+	mp->user.finished = 0;
+	return self;
 }
 
 
@@ -465,15 +441,15 @@ void Init_msgpack_unpack(VALUE mMessagePack)
 {
 	s_sysread = rb_intern("sysread");
 	s_readpartial = rb_intern("readpartial");
+
+#ifdef HAVE_RUBY_ENCODING_H
+	s_ascii_8bit = rb_enc_find_index("ASCII-8BIT");
+#endif
+
 	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, -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);
@@ -481,5 +457,12 @@ void Init_msgpack_unpack(VALUE mMessagePack)
 	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);
+
+	/* backward compatibility */
+	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);
 }
 

data/msgpack/pack_template.h

@@ -113,17 +113,17 @@ do { \
 		} \
 	} else { \
 		if(d < (1ULL<<16)) { \
-			/* signed 16 */ \
+			/* unsigned 16 */ \
 			unsigned char buf[3]; \
 			buf[0] = 0xcd; _msgpack_store16(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 3); \
 		} else if(d < (1ULL<<32)) { \
-			/* signed 32 */ \
+			/* unsigned 32 */ \
 			unsigned char buf[5]; \
 			buf[0] = 0xce; _msgpack_store32(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 5); \
 		} else { \
-			/* signed 64 */ \
+			/* unsigned 64 */ \
 			unsigned char buf[9]; \
 			buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
 			msgpack_pack_append_buffer(x, buf, 9); \

data/msgpack/unpack_define.h

@@ -19,6 +19,7 @@
 #define MSGPACK_UNPACK_DEFINE_H__
 
 #include "msgpack/sysdep.h"
+#include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <stdio.h>
@@ -28,8 +29,8 @@ extern "C" {
 #endif
 
 
-#ifndef MSGPACK_MAX_STACK_SIZE
-#define MSGPACK_MAX_STACK_SIZE 16
+#ifndef MSGPACK_EMBED_STACK_SIZE
+#define MSGPACK_EMBED_STACK_SIZE 32
 #endif
 
 

data/msgpack/unpack_template.h

@@ -58,7 +58,12 @@ msgpack_unpack_struct_decl(_context) {
 	unsigned int cs;
 	unsigned int trail;
 	unsigned int top;
-	msgpack_unpack_struct(_stack) stack[MSGPACK_MAX_STACK_SIZE];
+	/*
+	msgpack_unpack_struct(_stack)* stack;
+	unsigned int stack_size;
+	msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE];
+	*/
+	msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE];
 };
 
 
@@ -67,9 +72,22 @@ msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
 	ctx->cs = CS_HEADER;
 	ctx->trail = 0;
 	ctx->top = 0;
+	/*
+	ctx->stack = ctx->embed_stack;
+	ctx->stack_size = MSGPACK_EMBED_STACK_SIZE;
+	*/
 	ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user);
 }
 
+/*
+msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx)
+{
+	if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) {
+		free(ctx->stack);
+	}
+}
+*/
+
 msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx)
 {
 	return (ctx)->stack[0].obj;
@@ -88,6 +106,9 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 	unsigned int cs = ctx->cs;
 	unsigned int top = ctx->top;
 	msgpack_unpack_struct(_stack)* stack = ctx->stack;
+	/*
+	unsigned int stack_size = ctx->stack_size;
+	*/
 	msgpack_unpack_user* user = &ctx->user;
 
 	msgpack_unpack_object obj;
@@ -117,14 +138,33 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c
 	goto _fixed_trail_again
 
 #define start_container(func, count_, ct_) \
+	if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \
 	if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \
 	if((count_) == 0) { obj = stack[top].obj; goto _push; } \
-	if(top >= MSGPACK_MAX_STACK_SIZE) { goto _failed; } \
 	stack[top].ct = ct_; \
 	stack[top].count = count_; \
+	++top; \
 	/*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
 	/*printf("stack push %d\n", top);*/ \
-	++top; \
+	/* FIXME \
+	if(top >= stack_size) { \
+		if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \
+			size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \
+			size_t nsize = csize * 2; \
+			msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \
+			if(tmp == NULL) { goto _failed; } \
+			memcpy(tmp, ctx->stack, csize); \
+			ctx->stack = stack = tmp; \
+			ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \
+		} else { \
+			size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \
+			msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \
+			if(tmp == NULL) { goto _failed; } \
+			ctx->stack = stack = tmp; \
+			ctx->stack_size = stack_size = stack_size * 2; \
+		} \
+	} \
+	*/ \
 	goto _header_again
 
 #define NEXT_CS(p) \

data/test/msgpack_test.rb

@@ -202,6 +202,22 @@ class MessagePackTestFormat < Test::Unit::TestCase
 #		#check_map 5, (1<<32)-1  # memory error
 #	end
 
+	it "gc mark" do
+		obj = [{["a","b"]=>["c","d"]}, ["e","f"], "d"]
+		pac = MessagePack::Unpacker.new
+		parsed = 0
+		obj.to_msgpack.split(//).each do |b|
+			pac.feed(b)
+			pac.each {|o|
+				GC.start
+				assert_equal(obj, o)
+				parsed += 1
+			}
+			GC.start
+		end
+		assert_equal(parsed, 1)
+	end
+
 	private
 	def check(len, obj)
 		v = obj.to_msgpack

metadata

@@ -4,8 +4,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 7
-  version: 0.3.7
+  - 8
+  version: 0.3.8
 platform: x86-mingw32
 authors: 
 - FURUHASHI Sadayuki
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-06 00:00:00 +09:00
+date: 2010-04-22 00:00:00 +09:00
 default_executable: 
 dependencies: []