msgpack 0.2.2-mswin32 → 0.3.1-mswin32

data/ext/pack.c

@@ -1,7 +1,7 @@
 /*
- * MessagePack packing routine for Ruby
+ * MessagePack for Ruby packing routine
  *
- * Copyright (C) 2008 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -19,10 +19,10 @@
 #include "msgpack/pack_define.h"
 
 #define msgpack_pack_inline_func(name) \
-	static inline void msgpack_pack_##name
+	static inline void msgpack_pack ## name
 
 #define msgpack_pack_inline_func_cint(name) \
-	static inline void msgpack_pack_##name
+	static inline void msgpack_pack ## name
 
 #define msgpack_pack_user VALUE
 

data/ext/pack.h

@@ -1,7 +1,7 @@
 /*
- * MessagePack packing routine for Ruby
+ * MessagePack for Ruby packing routine
  *
- * Copyright (C) 2008 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2009 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/ext/rbinit.c

@@ -1,7 +1,7 @@
 /*
  * MessagePack for Ruby
  *
- * Copyright (C) 2008 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2009 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/ext/unpack.c

@@ -1,7 +1,7 @@
 /*
- * MessagePack unpacking routine for Ruby
+ * MessagePack for Ruby unpacking routine
  *
- * Copyright (C) 2008 FURUHASHI Sadayuki
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -21,99 +21,99 @@
 
 typedef struct {
 	int finished;
-	VALUE origstr;
-} msgpack_unpack_context;
+	VALUE source;
+} unpack_user;
 
 
 #define msgpack_unpack_struct(name) \
-	struct msgpack_unpacker_##name
+	struct template ## name
 
 #define msgpack_unpack_func(ret, name) \
-	ret msgpack_unpacker_##name
+	ret template ## name
 
 #define msgpack_unpack_callback(name) \
-	template_callback_##name
+	template_callback ## name
 
 #define msgpack_unpack_object VALUE
 
-#define msgpack_unpack_user msgpack_unpack_context
+#define msgpack_unpack_user unpack_user
 
 
-struct msgpack_unpacker_context;
-typedef struct msgpack_unpacker_context msgpack_unpacker;
+struct template_context;
+typedef struct template_context msgpack_unpack_t;
 
-static void msgpack_unpacker_init(msgpack_unpacker* ctx);
+static void template_init(msgpack_unpack_t* u);
 
-static VALUE msgpack_unpacker_data(msgpack_unpacker* ctx);
+static VALUE template_data(msgpack_unpack_t* u);
 
-static int msgpack_unpacker_execute(msgpack_unpacker* ctx,
+static int template_execute(msgpack_unpack_t* u,
 		const char* data, size_t len, size_t* off);
 
 
-static inline VALUE template_callback_init(msgpack_unpack_context* x)
+static inline VALUE template_callback_root(unpack_user* u)
 { return Qnil; }
 
-static inline VALUE template_callback_uint8(msgpack_unpack_context* x, uint8_t d)
-{ return INT2FIX(d); }
+static inline int template_callback_uint8(unpack_user* u, uint8_t d, VALUE* o)
+{ *o = INT2FIX(d); return 0; }
 
-static inline VALUE template_callback_uint16(msgpack_unpack_context* x, uint16_t d)
-{ return INT2FIX(d); }
+static inline int template_callback_uint16(unpack_user* u, uint16_t d, VALUE* o)
+{ *o = INT2FIX(d); return 0; }
 
-static inline VALUE template_callback_uint32(msgpack_unpack_context* x, uint32_t d)
-{ return UINT2NUM(d); }
+static inline int template_callback_uint32(unpack_user* u, uint32_t d, VALUE* o)
+{ *o = UINT2NUM(d); return 0; }
 
-static inline VALUE template_callback_uint64(msgpack_unpack_context* x, uint64_t d)
-{ return rb_ull2inum(d); }
+static inline int template_callback_uint64(unpack_user* u, uint64_t d, VALUE* o)
+{ *o = rb_ull2inum(d); return 0; }
 
-static inline VALUE template_callback_int8(msgpack_unpack_context* x, int8_t d)
-{ return INT2FIX((long)d); }
+static inline int template_callback_int8(unpack_user* u, int8_t d, VALUE* o)
+{ *o = INT2FIX((long)d); return 0; }
 
-static inline VALUE template_callback_int16(msgpack_unpack_context* x, int16_t d)
-{ return INT2FIX((long)d); }
+static inline int template_callback_int16(unpack_user* u, int16_t d, VALUE* o)
+{ *o = INT2FIX((long)d); return 0; }
 
-static inline VALUE template_callback_int32(msgpack_unpack_context* x, int32_t d)
-{ return INT2NUM((long)d); }
+static inline int template_callback_int32(unpack_user* u, int32_t d, VALUE* o)
+{ *o = INT2NUM((long)d); return 0; }
 
-static inline VALUE template_callback_int64(msgpack_unpack_context* x, int64_t d)
-{ return rb_ll2inum(d); }
+static inline int template_callback_int64(unpack_user* u, int64_t d, VALUE* o)
+{ *o = rb_ll2inum(d); return 0; }
 
-static inline VALUE template_callback_float(msgpack_unpack_context* x, float d)
-{ return rb_float_new(d); }
+static inline int template_callback_float(unpack_user* u, float d, VALUE* o)
+{ *o = rb_float_new(d); return 0; }
 
-static inline VALUE template_callback_double(msgpack_unpack_context* x, double d)
-{ return rb_float_new(d); }
+static inline int template_callback_double(unpack_user* u, double d, VALUE* o)
+{ *o = rb_float_new(d); return 0; }
 
-static inline VALUE template_callback_nil(msgpack_unpack_context* x)
-{ return Qnil; }
+static inline int template_callback_nil(unpack_user* u, VALUE* o)
+{ *o = Qnil; return 0; }
 
-static inline VALUE template_callback_true(msgpack_unpack_context* x)
-{ return Qtrue; }
+static inline int template_callback_true(unpack_user* u, VALUE* o)
+{ *o = Qtrue; return 0; }
 
-static inline VALUE template_callback_false(msgpack_unpack_context* x)
-{ return Qfalse; }
+static inline int template_callback_false(unpack_user* u, VALUE* o)
+{ *o = Qfalse; return 0;}
 
-static inline VALUE template_callback_array(msgpack_unpack_context* x, unsigned int n)
-{ return rb_ary_new2(n); }
+static inline int template_callback_array(unpack_user* u, unsigned int n, VALUE* o)
+{ *o = rb_ary_new2(n); return 0; }
 
-static inline void template_callback_array_item(msgpack_unpack_context* x, VALUE* c, VALUE o)
-{ rb_ary_push(*c, o); }  // FIXME set value directry RARRAY_PTR(obj)[RARRAY_LEN(obj)++]
+static inline int template_callback_array_item(unpack_user* u, VALUE* c, VALUE o)
+{ rb_ary_push(*c, o); return 0; }  // FIXME set value directry RARRAY_PTR(obj)[RARRAY_LEN(obj)++]
 
-static inline VALUE template_callback_map(msgpack_unpack_context* x, unsigned int n)
-{ return rb_hash_new(); }
+static inline int template_callback_map(unpack_user* u, unsigned int n, VALUE* o)
+{ *o = rb_hash_new(); return 0; }
 
-static inline void template_callback_map_item(msgpack_unpack_context* x, VALUE* c, VALUE k, VALUE v)
-{ rb_hash_aset(*c, k, v); }
+static inline int template_callback_map_item(unpack_user* u, VALUE* c, VALUE k, VALUE v)
+{ rb_hash_aset(*c, k, v); return 0; }
 
-static inline VALUE template_callback_raw(msgpack_unpack_context* x, const char* b, const char* p, unsigned int l)
-{ return l == 0 ? rb_str_new(0,0) : rb_str_substr(x->origstr, p - b, l); }
+static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, VALUE* o)
+{ *o = (l == 0) ? rb_str_new(0,0) : rb_str_substr(u->source, p - b, l); return 0; }
 
 
 #include "msgpack/unpack_template.h"
 
 
 #define UNPACKER(from, name) \
-	msgpack_unpacker *name = NULL; \
-	Data_Get_Struct(from, msgpack_unpacker, name); \
+	msgpack_unpack_t *name = NULL; \
+	Data_Get_Struct(from, msgpack_unpack_t, name); \
 	if(name == NULL) { \
 		rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
 	}
@@ -132,7 +132,7 @@ static void MessagePack_Unpacker_free(void* data)
 	if(data) { free(data); }
 }
 
-static void MessagePack_Unpacker_mark(msgpack_unpacker *mp)
+static void MessagePack_Unpacker_mark(msgpack_unpack_t *mp)
 {
 	unsigned int i;
 	for(i=0; i < mp->top; ++i) {
@@ -144,7 +144,7 @@ static void MessagePack_Unpacker_mark(msgpack_unpacker *mp)
 static VALUE MessagePack_Unpacker_alloc(VALUE klass)
 {
 	VALUE obj;
-	msgpack_unpacker* mp = ALLOC_N(msgpack_unpacker, 1);
+	msgpack_unpack_t* mp = ALLOC_N(msgpack_unpack_t, 1);
 	obj = Data_Wrap_Struct(klass, MessagePack_Unpacker_mark,
 			MessagePack_Unpacker_free, mp);
 	return obj;
@@ -153,9 +153,9 @@ static VALUE MessagePack_Unpacker_alloc(VALUE klass)
 static VALUE MessagePack_Unpacker_reset(VALUE self)
 {
 	UNPACKER(self, mp);
-	msgpack_unpacker_init(mp);
-	msgpack_unpack_context ctx = {0, Qnil};
-	mp->user = ctx;
+	template_init(mp);
+	unpack_user u = {0, Qnil};
+	mp->user = u;
 	return self;
 }
 
@@ -169,21 +169,20 @@ static VALUE MessagePack_Unpacker_execute_impl(VALUE args)
 {
 	VALUE self = ((VALUE*)args)[0];
 	VALUE data = ((VALUE*)args)[1];
-	VALUE off  = ((VALUE*)args)[2];
 
 	UNPACKER(self, mp);
-	size_t from = NUM2UINT(off);
+	size_t from = NUM2UINT(((VALUE*)args)[2]);
 	char* dptr = RSTRING_PTR(data);
-	long dlen = RSTRING_LEN(data);
+	long dlen = FIX2LONG(((VALUE*)args)[3]);
 	int ret;
 
 	if(from >= dlen) {
 		rb_raise(eUnpackError, "offset is bigger than data buffer size.");
 	}
 
-	mp->user.origstr = data;
-	ret = msgpack_unpacker_execute(mp, dptr, (size_t)dlen, &from);
-	mp->user.origstr = Qnil;
+	mp->user.source = data;
+	ret = template_execute(mp, dptr, (size_t)dlen, &from);
+	mp->user.source = Qnil;
 
 	if(ret < 0) {
 		rb_raise(eUnpackError, "parse error.");
@@ -206,17 +205,24 @@ static VALUE MessagePack_Unpacker_execute_rescue(VALUE nouse)
 #endif
 }
 
-static VALUE MessagePack_Unpacker_execute(VALUE self, VALUE data, VALUE off)
+static VALUE MessagePack_Unpacker_execute_limit(VALUE self, VALUE data,
+		VALUE off, VALUE limit)
 {
 	// FIXME execute実行中はmp->topが更新されないのでGC markが機能しない
 	rb_gc_disable();
-	VALUE args[3] = {self, data, off};
+	VALUE args[4] = {self, data, off, limit};
 	VALUE ret = rb_rescue(MessagePack_Unpacker_execute_impl, (VALUE)args,
 			MessagePack_Unpacker_execute_rescue, Qnil);
 	rb_gc_enable();
 	return ret;
 }
 
+static VALUE MessagePack_Unpacker_execute(VALUE self, VALUE data, VALUE off)
+{
+	return MessagePack_Unpacker_execute_limit(self, data, off,
+			LONG2FIX(RSTRING_LEN(data)));
+}
+
 static VALUE MessagePack_Unpacker_finished_p(VALUE self)
 {
 	UNPACKER(self, mp);
@@ -229,23 +235,23 @@ static VALUE MessagePack_Unpacker_finished_p(VALUE self)
 static VALUE MessagePack_Unpacker_data(VALUE self)
 {
 	UNPACKER(self, mp);
-	return msgpack_unpacker_data(mp);
+	return template_data(mp);
 }
 
 
 static VALUE MessagePack_unpack_impl(VALUE args)
 {
-	msgpack_unpacker* mp = (msgpack_unpacker*)((VALUE*)args)[0];
+	msgpack_unpack_t* mp = (msgpack_unpack_t*)((VALUE*)args)[0];
 	VALUE data = ((VALUE*)args)[1];
 
 	size_t from = 0;
 	char* dptr = RSTRING_PTR(data);
-	long dlen = RSTRING_LEN(data);
+	long dlen = FIX2LONG(((VALUE*)args)[2]);
 	int ret;
 
-	mp->user.origstr = data;
-	ret = msgpack_unpacker_execute(mp, dptr, (size_t)dlen, &from);
-	mp->user.origstr = Qnil;
+	mp->user.source = data;
+	ret = template_execute(mp, dptr, (size_t)dlen, &from);
+	mp->user.source = Qnil;
 
 	if(ret < 0) {
 		rb_raise(eUnpackError, "parse error.");
@@ -255,7 +261,7 @@ static VALUE MessagePack_unpack_impl(VALUE args)
 		if(from < dlen) {
 			rb_raise(eUnpackError, "extra bytes.");
 		}
-		return msgpack_unpacker_data(mp);
+		return template_data(mp);
 	}
 }
 
@@ -269,22 +275,30 @@ static VALUE MessagePack_unpack_rescue(VALUE args)
 #endif
 }
 
-static VALUE MessagePack_unpack(VALUE self, VALUE data)
+static VALUE MessagePack_unpack_limit(VALUE self, VALUE data, VALUE limit)
 {
 	CHECK_STRING_TYPE(data);
-	msgpack_unpacker mp;
-	msgpack_unpacker_init(&mp);
-	msgpack_unpack_context ctx = {0, Qnil};
-	mp.user = ctx;
+
+	msgpack_unpack_t mp;
+	template_init(&mp);
+	unpack_user u = {0, Qnil};
+	mp.user = u;
 
 	rb_gc_disable();
-	VALUE args[2] = {(VALUE)&mp, data};
+	VALUE args[3] = {(VALUE)&mp, data, limit};
 	VALUE ret = rb_rescue(MessagePack_unpack_impl, (VALUE)args,
 			MessagePack_unpack_rescue, Qnil);
 	rb_gc_enable();
+
 	return ret;
 }
 
+static VALUE MessagePack_unpack(VALUE self, VALUE data)
+{
+	return MessagePack_unpack_limit(self, data,
+			LONG2FIX(RSTRING_LEN(data)));
+}
+
 
 void Init_msgpack_unpack(VALUE mMessagePack)
 {
@@ -293,10 +307,12 @@ void Init_msgpack_unpack(VALUE mMessagePack)
 	rb_define_alloc_func(cUnpacker, MessagePack_Unpacker_alloc);
 	rb_define_method(cUnpacker, "initialize", MessagePack_Unpacker_initialize, 0);
 	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_module_function(mMessagePack, "unpack", MessagePack_unpack, 1);
+	rb_define_module_function(mMessagePack, "unpack_limit", MessagePack_unpack_limit, 2);
 }
 
 

data/ext/unpack.h

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: msgpack
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.3.1
 platform: mswin32
 authors: 
 - FURUHASHI Sadayuki
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-11 00:00:00 +09:00
+date: 2009-03-04 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -22,8 +22,6 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/msgpack
-- lib/msgpack/version.rb
 - ext/extconf.rb
 - ext/Makefile
 - ext/msgpack.so
@@ -36,7 +34,7 @@ files:
 - ext/unpack.h
 - ext/unpack.o
 has_rdoc: false
-homepage: https://launchpad.net/msgpack/
+homepage: http://msgpack.sourceforge.jp/
 post_install_message: 
 rdoc_options: []
 
@@ -57,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: msgpack
 rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2

data/lib/msgpack/version.rb

@@ -1,9 +0,0 @@
-module MessagePack
-  module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 2
-    TINY  = 1
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end