asciipack 0.1.3 → 0.2.0

data/ext/asciipack/unpacker.c

@@ -0,0 +1,299 @@
+#include "unpacker.h"
+
+VALUE cAsciiPack_Unpacker;
+
+static VALUE Unpacker_read(unpacker_t* ptr);
+
+static void
+unpacker_mark(unpacker_t* ptr)
+{
+}
+
+static VALUE
+Unpacker_alloc(VALUE klass)
+{
+	unpacker_t *ptr = ALLOC(unpacker_t);
+	return Data_Wrap_Struct(klass, unpacker_mark, -1, ptr);
+}
+
+static VALUE
+Unpacker_init(VALUE self, VALUE obj, int argc, VALUE *argv, VALUE size)
+{
+	UNPACKER(self, ptr);
+
+	if (!ptr) {
+		rb_raise(rb_eArgError, "unallocated unpacker");
+	}
+
+	ptr->buffer = RSTRING_PTR(obj);
+	ptr->ch = ptr->buffer;
+
+	return self;
+}
+
+static VALUE
+Unpacker_initialize(int argc, VALUE *argv, VALUE self)
+{
+	VALUE obj = *argv++;
+	VALUE size = Qnil;
+	return Unpacker_init(self, obj, argc, argv, size);
+}
+
+static unsigned short
+to_i16 (char ch)
+{
+	unsigned short ret = 0;
+	if ('0' <= ch && ch <= '9') {
+		ret += ch - '0';
+	} else if ('a' <= ch && ch <= 'f') {
+		ret += ch - 'a' + 10;
+	}
+	return ret;
+}
+
+static uint64_t
+to_i16all (unpacker_t* ptr, int len)
+{
+	uint64_t ret = 0;
+	while (len--) {
+		ret += to_i16(*ptr->ch);
+		ptr->ch++;
+		if (len != 0) ret = ret << 4;
+	}
+	return ret;
+}
+
+static uint64_t
+Unpacker_int (unpacker_t* ptr, size_t len)
+{
+	size_t n = len;
+	char* head = ptr->ch;
+	uint64_t base = 1;
+	uint64_t ret = to_i16all(ptr, len);
+
+	if ('8' <= *head) {
+		ret -= (base << (n * 4));
+	}
+	return ret;
+}
+
+static uint64_t
+Unpacker_uint (unpacker_t* ptr, size_t len)
+{
+	return to_i16all(ptr, len);
+}
+
+static double
+Unpacker_float (unpacker_t* ptr, size_t len)
+{
+	uint64_t ret = to_i16all(ptr, len);
+	/* for convert unsigned long <-> float */
+	union {
+		unsigned long u;
+		double f64;
+	} converter = {ret};
+	return converter.f64;
+}
+
+static VALUE
+Unpacker_str (unpacker_t* ptr, size_t len)
+{
+	char* head = ptr->ch;
+
+	VALUE str = rb_str_new(head, len);
+	rb_funcall(str, rb_intern("force_encoding"), 1, rb_str_new2("utf-8"));
+	return str;
+}
+
+static VALUE
+Unpacker_map (unpacker_t* ptr, size_t len)
+{
+	VALUE map = rb_hash_new();
+	VALUE key, value;
+	while (len--) {
+		key = Unpacker_read(ptr);
+		value = Unpacker_read(ptr);
+		rb_hash_aset(map, key, value);
+	}
+	return map;
+}
+
+static VALUE
+Unpacker_array (unpacker_t* ptr, size_t len)
+{
+	VALUE array = rb_ary_new2(len);
+	while (len--) {
+		rb_ary_push(array, Unpacker_read(ptr));
+	}
+	return array;
+}
+
+static VALUE
+Unpacker_read (unpacker_t* ptr)
+{
+	uint64_t num;
+
+	ptr->ch++;
+
+	switch (*(ptr->ch - 1)) {
+		case 'a': // int 4
+			num = Unpacker_int(ptr, 1);
+			return INT2FIX(num);
+
+		case 'b': // int 8
+			num = Unpacker_int(ptr, 2);
+			return INT2FIX(num);
+
+		case 'c': // int 16
+			num = Unpacker_int(ptr, 4);
+			return INT2FIX(num);
+
+		case 'd': // int 32
+			num = Unpacker_int(ptr, 8);
+			return LONG2NUM(num);
+
+		case 'e': // int 64
+			num = Unpacker_int(ptr, 16);
+			return rb_ll2inum(num);
+
+		case 'g': // uint 8
+			num = Unpacker_uint(ptr, 2);
+			return INT2FIX(num);
+
+		case 'h': // uint 16
+			num = Unpacker_uint(ptr, 4);
+			return INT2FIX(num);
+
+		case 'i': // uint 32
+			num = Unpacker_uint(ptr, 8);
+			return LONG2NUM(num);
+
+		case 'j': // uint 64
+			num = Unpacker_uint(ptr, 16);
+			return rb_ull2inum(num);
+
+		case 'k': // float 32
+			return rb_float_new(Unpacker_float(ptr, 8));
+
+		case 'l': // float 64
+			return rb_float_new(Unpacker_float(ptr, 16));
+
+		case 'n': // str 8
+			num = Unpacker_uint(ptr, 2);
+			return Unpacker_str(ptr, num);
+
+		case 'o': // str 16
+			num = Unpacker_uint(ptr, 4);
+			return Unpacker_str(ptr, num);
+
+		case 'p': // str 32
+			num = Unpacker_uint(ptr, 8);
+			return Unpacker_str(ptr, num);
+
+		case 'r': // map 4
+			num = Unpacker_uint(ptr, 1);
+			return Unpacker_map(ptr, num);
+
+		case 's': // map 8
+			num = Unpacker_uint(ptr, 2);
+			return Unpacker_map(ptr, num);
+
+		case 't': // map16
+			num = Unpacker_uint(ptr, 4);
+			return Unpacker_map(ptr, num);
+
+		case 'u': // map 32
+			num = Unpacker_uint(ptr, 8);
+			return Unpacker_map(ptr, num);
+
+		case 'v': // array 4
+			num = Unpacker_uint(ptr, 1);
+			return Unpacker_array(ptr, num);
+
+		case 'w': // array 8
+			num = Unpacker_uint(ptr, 2);
+			return Unpacker_array(ptr, num);
+
+		case 'x': // array 16
+			num = Unpacker_uint(ptr, 4);
+			return Unpacker_array(ptr, num);
+
+		case 'y': // array 32
+			num = Unpacker_uint(ptr, 8);
+			return Unpacker_array(ptr, num);
+
+		// positive fixint
+		case '0': return INT2FIX(0);
+		case '1': return INT2FIX(1);
+		case '2': return INT2FIX(2);
+		case '3': return INT2FIX(3);
+		case '4': return INT2FIX(4);
+		case '5': return INT2FIX(5);
+		case '6': return INT2FIX(6);
+		case '7': return INT2FIX(7);
+		case '8': return INT2FIX(8);
+		case '9': return INT2FIX(9);
+		case 'A': return INT2FIX(10);
+		case 'B': return INT2FIX(11);
+		case 'C': return INT2FIX(12);
+		case 'D': return INT2FIX(13);
+		case 'E': return INT2FIX(14);
+		case 'F': return INT2FIX(15);
+
+		// fixstr
+		case 'G':
+			return rb_str_new2("");
+		case 'H':
+		case 'I':
+		case 'J':
+		case 'K':
+		case 'L':
+		case 'M':
+		case 'N':
+		case 'O':
+		case 'P':
+		case 'Q':
+		case 'R':
+		case 'S':
+		case 'T':
+		case 'U':
+		case 'V':
+			num = *(ptr->ch - 1) - 'G';
+			return Unpacker_str(ptr, num);
+
+		// others
+		case 'W': return Qnil;
+		case 'X': return Qfalse;
+		case 'Y': return Qtrue;
+	}
+
+	rb_raise(rb_eArgError, "undefined type:%c", *(ptr->ch));
+	return Qnil;
+}
+
+static VALUE
+Unpacker_unpack (VALUE self)
+{
+	UNPACKER(self, ptr);
+	return Unpacker_read(ptr);
+}
+
+static VALUE
+AsciiPack_unpack (int argc, VALUE *argv, VALUE self)
+{
+	VALUE unpacker = rb_funcall(cAsciiPack_Unpacker, rb_intern("new"), 1, argv[0]);
+	return rb_funcall(unpacker, rb_intern("unpack"), 0);
+}
+
+void
+AsciiPack_Unpacker_init(VALUE mAsciiPack)
+{
+	cAsciiPack_Unpacker = rb_define_class_under(mAsciiPack, "Unpacker", rb_cObject);
+
+	rb_define_alloc_func(cAsciiPack_Unpacker, Unpacker_alloc);
+
+	rb_define_method(cAsciiPack_Unpacker, "initialize", Unpacker_initialize, -1);
+	rb_define_method(cAsciiPack_Unpacker, "unpack", Unpacker_unpack, 0);
+
+	rb_define_module_function(mAsciiPack, "unpack", AsciiPack_unpack, -1);
+}

data/ext/asciipack/unpacker.h

@@ -0,0 +1,25 @@
+#ifndef UNPACKER_H
+#  define UNPACKER_H
+
+#include <stdlib.h>
+
+struct unpacker {
+	char* buffer;
+	char* ch;
+};
+typedef struct unpacker unpacker_t;
+
+#define UNPACKER(from, name) \
+	unpacker_t* name; \
+	Data_Get_Struct(from, unpacker_t, name); \
+	if (name == NULL) { \
+		rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be.'"); \
+	}
+
+#include "ruby.h"
+
+extern VALUE cAsciiPack_Unpacker;
+void AsciiPack_Unpacker_init(VALUE mAsciiPack);
+
+#endif /* ifndef UNPACKER_H */
+

data/lib/asciipack/version.rb

@@ -1,3 +1,3 @@
 module AsciiPack
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/lib/asciipack.rb

@@ -1,3 +1,3 @@
+here = File.expand_path(File.dirname(__FILE__))
+require File.join(here, 'asciipack', 'asciipack')
 require "asciipack/version"
-require 'asciipack/packer.rb'
-require 'asciipack/unpacker.rb'

data/spec/bench.rb

@@ -7,51 +7,70 @@ require 'asciipack'
 require 'json'
 require 'msgpack'
 
-def json_asciipack(name, obj)
+def count
+  10000
+end
+
+def reports (obj)
   obj = [obj]
   json = obj.to_json
   ap = AsciiPack.pack obj
   ms = Marshal.dump obj
   msg = MessagePack.pack obj
 
-  p '[' + name + ']'
-  bench "AsciiPack.pack" do AsciiPack.pack obj end
-  bench "AsciiPack.unpack" do AsciiPack.unpack ap end
-  bench "JSON.generate" do obj.to_json end
-  bench "JSON.parse" do JSON.parse json end
-  bench "Marshal.dump" do Marshal.dump obj end
-  bench "Marshal.load" do Marshal.load ms end
-  bench "MessagePack.pack" do MessagePack.pack obj end
-  bench "MessagePack.unpack" do MessagePack.unpack msg end
-  p({
-    :ap => ap.length,
-    :json => json.length,
-    :marshal => ms.length,
-    :msgpack => msg.length
-  })
+  {
+    "AsciiPack.pack" => lambda { AsciiPack.pack obj },
+    "AsciiPack.unpack" => lambda { AsciiPack.unpack ap },
+    "MessagePack.pack" => lambda { MessagePack.pack obj },
+    "MessagePack.unpack" => lambda { MessagePack.unpack msg },
+    "JSON.generate" => lambda { obj.to_json },
+    "JSON.parse" => lambda { JSON.parse json },
+    "Marshal.dump" => lambda { Marshal.dump obj },
+    "Marshal.load" => lambda { Marshal.load ms },
+  }
 end
 
-def bench(name)
-  t = Time.now
-  100000.times {
-    yield
+def json_asciipack(name, obj)
+  print("|" + name + "|")
+
+  results = []
+  reports(obj).each { |_, func|
+    t = Time.now
+    count.times {
+      func.call
+    }
+    results << "%.1f" % ((Time.now - t) * 1000)
   }
-  p name + ': ' + (Time.now - t).to_s + 's'
+  puts results.join("|") + "|"
 end
 
+puts("|object|" + reports(0).keys.join("|") + "|")
+puts("|---|" + reports(0).keys.map{"---"}.join("|") + "|")
+
+map16 = {}
+a = '@'
+0x100.times {|i| map16[i.to_s] = 0 }
+
 tt = Time.now
 {
   "positive fixint" => 0,
-  "uint 4" => 16,
+  "uint 64" => 0xffffffffffffffff,
   "int 4" => -1,
-  "fixstr" => "",
-  "str 8" => '0123456789abcdef',
+  "int 64" => -0x8000000000000000,
   "float 64" => 1/3,
+  "fixstr" => "a",
+  "str 32" => 'a' * 0x10000,
   "map 4" => {},
+  "map 16" => map16,
   "array 4" => [],
+  "array 16" => Array.new(0x100,0),
   "nil" => nil,
 }.each { |key, value|
   json_asciipack key, value
 }
 
-p 'total: ' + (Time.now - tt).to_s + 's'
+puts "\n"
+puts "count:#{count}"
+puts "unit:/ms"
+puts 'total:' + (Time.now - tt).to_s + 's'
+

data/spec/format_spec.rb

@@ -64,39 +64,41 @@ describe AsciiPack do
     format 1.0, T.float64, 17
     format 0.1, T.float64, 17
     format -0.1, T.float64, 17
-    expect(AsciiPack.pack(-0.1)).to eq(T.float64 + 'bfb999999999999a')
-    expect(AsciiPack.pack(1.0)).to eq(T.float64 + '3ff0000000000000')
-    expect(AsciiPack.pack(1.0000000000000002)).to eq(T.float64 + '3ff0000000000001')
-    expect(AsciiPack.pack(1.0000000000000004)).to eq(T.float64 + '3ff0000000000002')
-    expect(AsciiPack.pack(1/3.0)).to eq(T.float64 + '3fd5555555555555')
-    expect(AsciiPack.pack(Float::NAN)).to eq(T.float64 + '7fffffffffffffff')
-    expect(AsciiPack.pack(1 / 0.0)).to eq(T.float64 + '7ff0000000000000')
-    expect(AsciiPack.pack(-1 / 0.0)).to eq(T.float64 + 'fff0000000000000')
+    check_each_other(-0.1, T.float64 + 'bfb999999999999a')
+    check_each_other(1.0, T.float64 + '3ff0000000000000')
+    check_each_other(1.0000000000000002, T.float64 + '3ff0000000000001')
+    check_each_other(1.0000000000000004, T.float64 + '3ff0000000000002')
+    check_each_other(1/3.0, T.float64 + '3fd5555555555555')
+    expect(AsciiPack.pack(Float::NAN)).to eq(T.float64 + '7ff8000000000000')
+    check_each_other(1 / 0.0, T.float64 + '7ff0000000000000')
+    check_each_other(-1 / 0.0, T.float64 + 'fff0000000000000')
   end
 
-  it "fixbin" do
-    format "", T.fixbin_0, 1
-    format " ", T.fixbin_1, 2
-    format "あ", T.fixbin_1, 2
-    format "漢字", T.fixbin_2, 3
-    format " " * 0xe, T.fixbin_E, 15
-    format " " * 0xf, T.fixbin_F, 16
+  it "fixstr" do
+    format "", T.fixstr_0, 1
+    format " ", T.fixstr_1, 2
+    format "あ", T.fixstr_3, 4
+    format "漢字", T.fixstr_6, 7
+    format " " * 0xe, T.fixstr_E, 15
+    format " " * 0xf, T.fixstr_F, 16
   end
 
-  it "bin 8" do
-    format "a" * 0x10, T.bin8, 3 + 0x10
-    format "a" * 0xff, T.bin8, 3 + 0xff
+  it "str 8" do
+    format "a" * 0x10, T.str8, 3 + 0x10
+    format "a" * 0xff, T.str8, 3 + 0xff
   end
 
-  it "bin 16" do
-    format "a" * 0x100, T.bin16, 5 + 0x100
-    format "a" * 0xffff, T.bin16, 5 + 0xffff
+  it "str 16" do
+    100.times {
+    format "a" * 0x100, T.str16, 5 + 0x100
+    format "a" * 0xffff, T.str16, 5 + 0xffff
+    }
   end
 
-  it "bin 32" do
-    format "a" * 0x10000, T.bin32, 9 + 0x10000
+  it "str 32" do
+    format "a" * 0x10000, T.str32, 9 + 0x10000
     # FIXME too late
-    # format "a" * 0xffffffff, T.bin32, 9 + 0xffffffff
+    # format "a" * 0xffffffff, T.str32, 9 + 0xffffffff
   end
 
   it "map 4" do
@@ -141,6 +143,15 @@ describe AsciiPack do
     # format_array 0xffffffff, T.array32
   end
 
+  it "recursive array" do
+    array = [0]
+    1000.times {
+      array = [array]
+    }
+    ap = AsciiPack.pack(array)
+    expect(AsciiPack.unpack(ap)).to eq(array)
+  end
+
   it "nil" do
     format nil, T.nil, 1
   end
@@ -161,6 +172,11 @@ def format (object, first, length)
   expect(AsciiPack.unpack(ap)).to eq(object)
 end
 
+def check_each_other (object, ap)
+  expect(AsciiPack.pack(object)).to eq(ap)
+  expect(AsciiPack.unpack(ap)).to eq(object)
+end
+
 def format_map (count, first)
   map = {}
   count.times{ |i| map[i] = 0 }

data/spec/spec_helper.rb

@@ -15,9 +15,9 @@ T = OpenStruct.new({
   :float32           => 'k',
   :float64           => 'l',
 #   (blank)            => 'm',
-  :bin8              => 'n',
-  :bin16             => 'o',
-  :bin32             => 'p',
+  :str8              => 'n',
+  :str16             => 'o',
+  :str32             => 'p',
 #   (blank)            => 'q',
   :map4              => 'r',
   :map8              => 's',
@@ -44,22 +44,22 @@ T = OpenStruct.new({
   :positive_fixint_D => 'D',
   :positive_fixint_E => 'E',
   :positive_fixint_F => 'F',
-  :fixbin_0          => 'G',
-  :fixbin_1          => 'H',
-  :fixbin_2          => 'I',
-  :fixbin_3          => 'J',
-  :fixbin_4          => 'K',
-  :fixbin_5          => 'L',
-  :fixbin_6          => 'M',
-  :fixbin_7          => 'N',
-  :fixbin_8          => 'O',
-  :fixbin_9          => 'P',
-  :fixbin_A          => 'Q',
-  :fixbin_B          => 'R',
-  :fixbin_C          => 'S',
-  :fixbin_D          => 'T',
-  :fixbin_E          => 'U',
-  :fixbin_F          => 'V',
+  :fixstr_0          => 'G',
+  :fixstr_1          => 'H',
+  :fixstr_2          => 'I',
+  :fixstr_3          => 'J',
+  :fixstr_4          => 'K',
+  :fixstr_5          => 'L',
+  :fixstr_6          => 'M',
+  :fixstr_7          => 'N',
+  :fixstr_8          => 'O',
+  :fixstr_9          => 'P',
+  :fixstr_A          => 'Q',
+  :fixstr_B          => 'R',
+  :fixstr_C          => 'S',
+  :fixstr_D          => 'T',
+  :fixstr_E          => 'U',
+  :fixstr_F          => 'V',
   :nil               => 'W',
   :false             => 'X',
   :true              => 'Y',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: asciipack
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-16 00:00:00.000000000 Z
+date: 2013-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,10 +52,25 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
 description: AsciiPack is an object serialization inspired by MessagePack.
 email: co000ri@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/asciipack/extconf.rb
 extra_rdoc_files: []
 files:
 - .gitignore
@@ -64,9 +79,13 @@ files:
 - README.md
 - Rakefile
 - asciipack.gemspec
+- ext/asciipack/extconf.rb
+- ext/asciipack/init.c
+- ext/asciipack/packer.c
+- ext/asciipack/packer.h
+- ext/asciipack/unpacker.c
+- ext/asciipack/unpacker.h
 - lib/asciipack.rb
-- lib/asciipack/packer.rb
-- lib/asciipack/unpacker.rb
 - lib/asciipack/version.rb
 - spec/bench.rb
 - spec/format_spec.rb