msgpack 0.2.2-x86-mingw32

data/ext/Makefile

@@ -0,0 +1,156 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = c:/MinGW/lib/ruby/1.8/i386-mingw32
+hdrdir = $(topdir)
+VPATH = $(srcdir);$(topdir);$(hdrdir)
+
+DESTDIR = c:
+exec_prefix = $(prefix)
+prefix = $(DESTDIR)/MinGW
+sharedstatedir = $(prefix)/com
+mandir = $(datarootdir)/man
+psdir = $(docdir)
+oldincludedir = $(DESTDIR)/usr/include
+localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(exec_prefix)/libexec
+sitedir = $(libdir)/ruby/site_ruby
+htmldir = $(docdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+includedir = $(prefix)/include
+infodir = $(datarootdir)/info
+vendorlibdir = $(vendordir)/$(ruby_version)
+sysconfdir = $(prefix)/etc
+libdir = $(exec_prefix)/lib
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(libdir)/ruby/vendor_ruby
+datarootdir = $(prefix)/share
+pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
+sitearchdir = $(sitelibdir)/$(sitearch)
+datadir = $(datarootdir)
+localstatedir = $(prefix)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+
+CC = gcc
+LIBRUBY = lib$(LIBRUBY_SO).a
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -g -O2  $(cflags) -I.. -Wall -O4 
+INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =   $(DEFS) $(cppflags)
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L. 
+dldflags =  -Wl,--enable-auto-image-base,--enable-auto-import,--export-all
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = gcc -shared -s
+AR = ar
+EXEEXT = .exe
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = msvcrt-ruby18
+arch = i386-mingw32
+sitearch = i386-msvcrt
+ruby_version = 1.8
+ruby = c:/MinGW/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lshell32 -lwsock32  
+SRCS = pack.c rbinit.c unpack.c
+OBJS = pack.o rbinit.o unpack.o
+TARGET = msgpack
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+$CFLAGS << " -I.. -Wall -O4"
+create_makefile('msgpack')
+

data/ext/pack.c

@@ -0,0 +1,165 @@
+/*
+ * MessagePack packing routine for Ruby
+ *
+ * Copyright (C) 2008 FURUHASHI Sadayuki
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#include "ruby.h"
+#include "msgpack/pack_define.h"
+
+#define msgpack_pack_inline_func(name) \
+	static inline void msgpack_pack_##name
+
+#define msgpack_pack_inline_func_cint(name) \
+	static inline void msgpack_pack_##name
+
+#define msgpack_pack_user VALUE
+
+#define msgpack_pack_append_buffer(user, buf, len) \
+	rb_str_buf_cat(user, (const void*)buf, len)
+
+#include "msgpack/pack_template.h"
+
+
+#ifndef RUBY_VM
+#include "st.h"  // ruby hash
+#endif
+
+static ID s_to_msgpack;
+
+#define ARG_BUFFER(name, argc, argv) \
+	VALUE name; \
+	if(argc == 1) { \
+		name = argv[0]; \
+	} else if(argc == 0) { \
+		name = rb_str_buf_new(0); \
+	} else { \
+		rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); \
+	}
+
+static VALUE MessagePack_NilClass_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	msgpack_pack_nil(out);
+	return out;
+}
+
+static VALUE MessagePack_TrueClass_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	msgpack_pack_true(out);
+	return out;
+}
+
+static VALUE MessagePack_FalseClass_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	msgpack_pack_false(out);
+	return out;
+}
+
+
+static VALUE MessagePack_Fixnum_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	msgpack_pack_long(out, FIX2LONG(self));
+	return out;
+}
+
+
+#ifndef RBIGNUM_SIGN  // Ruby 1.8
+#define RBIGNUM_SIGN(b) (RBIGNUM(b)->sign)
+#endif
+
+static VALUE MessagePack_Bignum_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	// FIXME bignum
+	if(RBIGNUM_SIGN(self)) {  // positive
+		msgpack_pack_uint64(out, rb_big2ull(self));
+	} else {  // negative
+		msgpack_pack_int64(out, rb_big2ll(self));
+	}
+	return out;
+}
+
+static VALUE MessagePack_Float_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	msgpack_pack_double(out, rb_num2dbl(self));
+	return out;
+}
+
+static VALUE MessagePack_String_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	msgpack_pack_raw(out, RSTRING_LEN(self));
+	msgpack_pack_raw_body(out, RSTRING_PTR(self), RSTRING_LEN(self));
+	return out;
+}
+
+static VALUE MessagePack_Array_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	msgpack_pack_array(out, RARRAY_LEN(self));
+	VALUE* p = RARRAY_PTR(self);
+	VALUE* const pend = p + RARRAY_LEN(self);
+	for(;p != pend; ++p) {
+		rb_funcall(*p, s_to_msgpack, 1, out);
+	}
+	return out;
+}
+
+#ifndef RHASH_SIZE  // Ruby 1.8
+#define RHASH_SIZE(h) (RHASH(h)->tbl ? RHASH(h)->tbl->num_entries : 0)
+#endif
+
+static int MessagePack_Hash_to_msgpack_foreach(VALUE key, VALUE value, VALUE out)
+{
+	if (key == Qundef) { return ST_CONTINUE; }
+	rb_funcall(key, s_to_msgpack, 1, out);
+	rb_funcall(value, s_to_msgpack, 1, out);
+	return ST_CONTINUE;
+}
+
+static VALUE MessagePack_Hash_to_msgpack(int argc, VALUE *argv, VALUE self)
+{
+	ARG_BUFFER(out, argc, argv);
+	msgpack_pack_map(out, RHASH_SIZE(self));
+	rb_hash_foreach(self, MessagePack_Hash_to_msgpack_foreach, out);
+	return out;
+}
+
+
+static VALUE MessagePack_pack(VALUE self, VALUE data)
+{
+	return rb_funcall(data, s_to_msgpack, 0);
+}
+
+
+void Init_msgpack_pack(VALUE mMessagePack)
+{
+	s_to_msgpack = rb_intern("to_msgpack");
+	rb_define_method_id(rb_cNilClass,   s_to_msgpack, MessagePack_NilClass_to_msgpack, -1);
+	rb_define_method_id(rb_cTrueClass,  s_to_msgpack, MessagePack_TrueClass_to_msgpack, -1);
+	rb_define_method_id(rb_cFalseClass, s_to_msgpack, MessagePack_FalseClass_to_msgpack, -1);
+	rb_define_method_id(rb_cFixnum, s_to_msgpack, MessagePack_Fixnum_to_msgpack, -1);
+	rb_define_method_id(rb_cBignum, s_to_msgpack, MessagePack_Bignum_to_msgpack, -1);
+	rb_define_method_id(rb_cFloat,  s_to_msgpack, MessagePack_Float_to_msgpack, -1);
+	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_module_function(mMessagePack, "pack", MessagePack_pack, 1);
+}
+

data/ext/pack.h

@@ -0,0 +1,26 @@
+/*
+ * MessagePack packing routine for Ruby
+ *
+ * Copyright (C) 2008 FURUHASHI Sadayuki
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#ifndef PACK_H__
+#define PACK_H__
+
+#include "ruby.h"
+
+void Init_msgpack_pack(VALUE mMessagePack);
+
+#endif /* pack.h */
+

data/ext/rbinit.c

@@ -0,0 +1,29 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008 FURUHASHI Sadayuki
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#include "pack.h"
+#include "unpack.h"
+
+static VALUE mMessagePack;
+
+void Init_msgpack(void)
+{
+	mMessagePack = rb_define_module("MessagePack");
+	Init_msgpack_unpack(mMessagePack);
+	Init_msgpack_pack(mMessagePack);
+}
+

data/ext/unpack.c

@@ -0,0 +1,302 @@
+/*
+ * MessagePack unpacking routine for Ruby
+ *
+ * Copyright (C) 2008 FURUHASHI Sadayuki
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#include "ruby.h"
+#include "msgpack/unpack_define.h"
+
+
+typedef struct {
+	int finished;
+	VALUE origstr;
+} msgpack_unpack_context;
+
+
+#define msgpack_unpack_struct(name) \
+	struct msgpack_unpacker_##name
+
+#define msgpack_unpack_func(ret, name) \
+	ret msgpack_unpacker_##name
+
+#define msgpack_unpack_callback(name) \
+	template_callback_##name
+
+#define msgpack_unpack_object VALUE
+
+#define msgpack_unpack_user msgpack_unpack_context
+
+
+struct msgpack_unpacker_context;
+typedef struct msgpack_unpacker_context msgpack_unpacker;
+
+static void msgpack_unpacker_init(msgpack_unpacker* ctx);
+
+static VALUE msgpack_unpacker_data(msgpack_unpacker* ctx);
+
+static int msgpack_unpacker_execute(msgpack_unpacker* ctx,
+		const char* data, size_t len, size_t* off);
+
+
+static inline VALUE template_callback_init(msgpack_unpack_context* x)
+{ return Qnil; }
+
+static inline VALUE template_callback_uint8(msgpack_unpack_context* x, uint8_t d)
+{ return INT2FIX(d); }
+
+static inline VALUE template_callback_uint16(msgpack_unpack_context* x, uint16_t d)
+{ return INT2FIX(d); }
+
+static inline VALUE template_callback_uint32(msgpack_unpack_context* x, uint32_t d)
+{ return UINT2NUM(d); }
+
+static inline VALUE template_callback_uint64(msgpack_unpack_context* x, uint64_t d)
+{ return rb_ull2inum(d); }
+
+static inline VALUE template_callback_int8(msgpack_unpack_context* x, int8_t d)
+{ return INT2FIX((long)d); }
+
+static inline VALUE template_callback_int16(msgpack_unpack_context* x, int16_t d)
+{ return INT2FIX((long)d); }
+
+static inline VALUE template_callback_int32(msgpack_unpack_context* x, int32_t d)
+{ return INT2NUM((long)d); }
+
+static inline VALUE template_callback_int64(msgpack_unpack_context* x, int64_t d)
+{ return rb_ll2inum(d); }
+
+static inline VALUE template_callback_float(msgpack_unpack_context* x, float d)
+{ return rb_float_new(d); }
+
+static inline VALUE template_callback_double(msgpack_unpack_context* x, double d)
+{ return rb_float_new(d); }
+
+static inline VALUE template_callback_nil(msgpack_unpack_context* x)
+{ return Qnil; }
+
+static inline VALUE template_callback_true(msgpack_unpack_context* x)
+{ return Qtrue; }
+
+static inline VALUE template_callback_false(msgpack_unpack_context* x)
+{ return Qfalse; }
+
+static inline VALUE template_callback_array(msgpack_unpack_context* x, unsigned int n)
+{ return rb_ary_new2(n); }
+
+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 VALUE template_callback_map(msgpack_unpack_context* x, unsigned int n)
+{ return rb_hash_new(); }
+
+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 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); }
+
+
+#include "msgpack/unpack_template.h"
+
+
+#define UNPACKER(from, name) \
+	msgpack_unpacker *name = NULL; \
+	Data_Get_Struct(from, msgpack_unpacker, name); \
+	if(name == NULL) { \
+		rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
+	}
+
+#define CHECK_STRING_TYPE(value) \
+	value = rb_check_string_type(value); \
+	if( NIL_P(value) ) { \
+		rb_raise(rb_eTypeError, "instance of String needed"); \
+	}
+
+static VALUE cUnpacker;
+static VALUE eUnpackError;
+
+static void MessagePack_Unpacker_free(void* data)
+{
+	if(data) { free(data); }
+}
+
+static void MessagePack_Unpacker_mark(msgpack_unpacker *mp)
+{
+	unsigned int i;
+	for(i=0; i < mp->top; ++i) {
+		rb_gc_mark(mp->stack[i].obj);
+		rb_gc_mark(mp->stack[i].map_key);
+	}
+}
+
+static VALUE MessagePack_Unpacker_alloc(VALUE klass)
+{
+	VALUE obj;
+	msgpack_unpacker* mp = ALLOC_N(msgpack_unpacker, 1);
+	obj = Data_Wrap_Struct(klass, MessagePack_Unpacker_mark,
+			MessagePack_Unpacker_free, mp);
+	return obj;
+}
+
+static VALUE MessagePack_Unpacker_reset(VALUE self)
+{
+	UNPACKER(self, mp);
+	msgpack_unpacker_init(mp);
+	msgpack_unpack_context ctx = {0, Qnil};
+	mp->user = ctx;
+	return self;
+}
+
+static VALUE MessagePack_Unpacker_initialize(VALUE self)
+{
+	return MessagePack_Unpacker_reset(self);
+}
+
+
+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);
+	char* dptr = RSTRING_PTR(data);
+	long dlen = RSTRING_LEN(data);
+	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;
+
+	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 VALUE MessagePack_Unpacker_execute(VALUE self, VALUE data, VALUE off)
+{
+	// FIXME execute実行中はmp->topが更新されないのでGC markが機能しない
+	rb_gc_disable();
+	VALUE args[3] = {self, data, off};
+	VALUE ret = rb_rescue(MessagePack_Unpacker_execute_impl, (VALUE)args,
+			MessagePack_Unpacker_execute_rescue, Qnil);
+	rb_gc_enable();
+	return ret;
+}
+
+static VALUE MessagePack_Unpacker_finished_p(VALUE self)
+{
+	UNPACKER(self, mp);
+	if(mp->user.finished) {
+		return Qtrue;
+	}
+	return Qfalse;
+}
+
+static VALUE MessagePack_Unpacker_data(VALUE self)
+{
+	UNPACKER(self, mp);
+	return msgpack_unpacker_data(mp);
+}
+
+
+static VALUE MessagePack_unpack_impl(VALUE args)
+{
+	msgpack_unpacker* mp = (msgpack_unpacker*)((VALUE*)args)[0];
+	VALUE data = ((VALUE*)args)[1];
+
+	size_t from = 0;
+	char* dptr = RSTRING_PTR(data);
+	long dlen = RSTRING_LEN(data);
+	int ret;
+
+	mp->user.origstr = data;
+	ret = msgpack_unpacker_execute(mp, dptr, (size_t)dlen, &from);
+	mp->user.origstr = Qnil;
+
+	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 msgpack_unpacker_data(mp);
+	}
+}
+
+static VALUE MessagePack_unpack_rescue(VALUE args)
+{
+	rb_gc_enable();
+#ifdef RUBY_VM
+	rb_exc_raise(rb_errinfo());
+#else
+	rb_exc_raise(ruby_errinfo);
+#endif
+}
+
+static VALUE MessagePack_unpack(VALUE self, VALUE data)
+{
+	CHECK_STRING_TYPE(data);
+	msgpack_unpacker mp;
+	msgpack_unpacker_init(&mp);
+	msgpack_unpack_context ctx = {0, Qnil};
+	mp.user = ctx;
+
+	rb_gc_disable();
+	VALUE args[2] = {(VALUE)&mp, data};
+	VALUE ret = rb_rescue(MessagePack_unpack_impl, (VALUE)args,
+			MessagePack_unpack_rescue, Qnil);
+	rb_gc_enable();
+	return ret;
+}
+
+
+void Init_msgpack_unpack(VALUE mMessagePack)
+{
+	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, "execute", MessagePack_Unpacker_execute, 2);
+	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);
+}
+
+

data/ext/unpack.h

@@ -0,0 +1,26 @@
+/*
+ * MessagePack unpacking routine for Ruby
+ *
+ * Copyright (C) 2008 FURUHASHI Sadayuki
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#ifndef UNPACK_H__
+#define UNPACK_H__
+
+#include "ruby.h"
+
+void Init_msgpack_unpack(VALUE mMessagePack);
+
+#endif /* unpack.h */
+

data/lib/msgpack/version.rb

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

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: msgpack
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+platform: x86-mingw32
+authors: 
+- FURUHASHI Sadayuki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-11 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: frsyuki@users.sourceforge.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/msgpack
+- lib/msgpack/version.rb
+- ext/extconf.rb
+- ext/Makefile
+- ext/msgpack.so
+- ext/pack.c
+- ext/pack.h
+- ext/pack.o
+- ext/rbinit.c
+- ext/rbinit.o
+- ext/unpack.c
+- ext/unpack.h
+- ext/unpack.o
+has_rdoc: false
+homepage: https://launchpad.net/msgpack/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: MessagePack
+test_files: []
+