msgpack 0.0.1

data/License.txt

@@ -0,0 +1,13 @@
+Copyright 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.

data/Manifest.txt

@@ -0,0 +1,26 @@
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+ext/extconf.rb
+ext/pack.c
+ext/pack.h
+ext/pack_inline.h
+ext/rbinit.c
+ext/unpack.c
+ext/unpack.h
+ext/unpack_context.h
+ext/unpack_inline.c
+msgpack/pack/inline_context.h
+msgpack/pack/inline_impl.h
+msgpack/unpack/inline_context.h
+msgpack/unpack/inline_impl.h
+lib/msgpack/version.rb
+script/console
+script/destroy
+script/generate
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake

data/README.txt

@@ -0,0 +1,20 @@
+MessagePack
+-----------
+Binary-based efficient data interchange format.
+
+
+
+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.
+

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,75 @@
+require 'msgpack/version'
+
+AUTHOR = 'FURUHASHI Sadayuki'  # can also be an array of Authors
+EMAIL = "fr _at_ syuki.skr.jp"
+DESCRIPTION = "An object-oriented parser generator based on Parser Expression Grammar"
+GEM_NAME = 'msgpack' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'msgpack' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+#  ['activesupport', '>= 1.3.1']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = MessagePack::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'msgpack documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = EXTRA_DEPENDENCIES
+
+  p.spec_extras = {    # A hash of extra values to set in the gemspec.
+		:extensions => %w[ext/extconf.rb]
+	}
+end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/ext/extconf.rb

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

data/ext/pack.c

@@ -0,0 +1,131 @@
+/*
+ * 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 "pack_inline.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_int(out, FIX2INT(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_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_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/pack_inline.h

@@ -0,0 +1,33 @@
+/*
+ * 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_INLINE_H__
+#define PACK_INLINE_H__
+
+#include "ruby.h"
+
+typedef VALUE msgpack_pack_context;
+
+static inline void msgpack_pack_append_buffer(VALUE x, const unsigned char* b, unsigned int l)
+{
+	rb_str_buf_cat(x, (const void*)b, l);
+}
+
+#include "msgpack/pack/inline_impl.h"
+
+#endif /* pack_inline.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,202 @@
+/*
+ * 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 "unpack_context.h"
+#include <stdio.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].tmp.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);
+	mp->user.finished = false;
+	msgpack_unpacker_init(mp);
+	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, "Requested start is after data buffer end.");
+	}
+
+	ret = msgpack_unpacker_execute(mp, dptr, (size_t)dlen, &from);
+
+	if(ret < 0) {
+		rb_raise(eUnpackError, "Parse error.");
+	} else if(ret > 0) {
+		mp->user.finished = true;
+		return ULONG2NUM(from);
+	} else {
+		mp->user.finished = false;
+		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;
+
+	ret = msgpack_unpacker_execute(mp, dptr, (size_t)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 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);
+	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);
+}
+
+