bert 1.0.0 → 1.1.0

data/.gitignore

@@ -3,3 +3,6 @@
 coverage
 rdoc
 pkg
+ext/bert/c/Makefile
+ext/bert/c/*.bundle
+ext/bert/c/*.o

data/History.txt

@@ -1,3 +1,12 @@
+= 1.1.0 / 2009-10-27
+  * Major Changes
+    * Remove reliance on Erlectricity.
+  * Bug fixes
+    * Fix unsigned int problem in C decoder
+    * Fix stack overflow segfault in C binary decoder for > 8MB binaries
+    * Optimize C bytelist decoder
+    * Fix bignum encoding
+
 = 1.0.0 / 2009-10-19
   * No changes. Production ready!
 

data/README.md

@@ -1,13 +1,14 @@
 BERT
 ====
 
-BERT is a BERT (Binary ERlang Term) serialization library for Ruby. It can
+A BERT (Binary ERlang Term) serialization library for Ruby. It can
 encode Ruby objects into BERT format and decode BERT binaries into Ruby
 objects.
 
 See the BERT specification at [bert-rpc.org](http://bert-rpc.org).
 
-Instances of the following Ruby classes will be automatically converted to the proper simple BERT type:
+Instances of the following Ruby classes will be automatically converted to the
+proper simple BERT type:
 
 * Fixnum
 * Float
@@ -15,7 +16,8 @@ Instances of the following Ruby classes will be automatically converted to the p
 * Array
 * String
 
-Instances of the following Ruby classes will be automatically converted to the proper complex BERT type:
+Instances of the following Ruby classes will be automatically converted to the
+proper complex BERT type:
 
 * NilClass
 * TrueClass
@@ -24,10 +26,11 @@ Instances of the following Ruby classes will be automatically converted to the p
 * Time
 * Regexp
 
-To designate tuples, simply prefix an Array literal with a `t` or use the BERT::Tuple class:
+To designate tuples, simply prefix an Array literal with a `t` or use the
+BERT::Tuple class:
 
     t[:foo, [1, 2, 3]]
-    BERT::Tuple.new([:foo, [1, 2, 3]])
+    BERT::Tuple[:foo, [1, 2, 3]]
 
 Both of these will be converted to (in Erlang syntax):
 

data/Rakefile

@@ -10,8 +10,10 @@ begin
     gem.email = "tom@mojombo.com"
     gem.homepage = "http://github.com/mojombo/bert"
     gem.authors = ["Tom Preston-Werner"]
-    gem.add_dependency('erlectricity', '>= 1.1.0')
     gem.add_development_dependency("thoughtbot-shoulda")
+    gem.require_paths = ["lib", "ext"]
+    gem.files.include("ext")
+    gem.extensions << 'ext/bert/c/extconf.rb'
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
 rescue LoadError
@@ -19,12 +21,42 @@ rescue LoadError
 end
 
 require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
+Rake::TestTask.new(:runtests) do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/*_test.rb'
   test.verbose = true
 end
 
+task :make do
+  Dir.chdir('ext/bert/c') { `make` }
+end
+
+task :clean do
+  ['rm -f ext/bert/c/*.bundle', 'rm -f ext/bert/c/*.o'].each do |cmd|
+    `#{cmd}` && puts(cmd)
+  end
+end
+
+task :test => :check_dependencies do
+  require 'fileutils'
+
+  puts "\nCleaning extension build files and running all specs in native ruby mode..."
+  ['rm -f ext/bert/c/*.bundle', 'rm -f ext/bert/c/*.o'].each do |cmd|
+    `#{cmd}` && puts(cmd)
+  end
+  pid = fork do
+    exec 'rake runtests'
+  end
+  Process.waitpid(pid)
+
+  puts "\nRunning `make` to build extensions and rerunning decoder specs..."
+  Dir.chdir('ext/bert/c') { `make` }
+  pid = fork do
+    exec 'rake runtests'
+  end
+  Process.waitpid(pid)
+end
+
 begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
@@ -38,8 +70,6 @@ rescue LoadError
   end
 end
 
-task :test => :check_dependencies
-
 task :default => :test
 
 require 'rake/rdoctask'

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/bench/bench.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'bert'
+require 'json'
+require 'yajl'
+require 'benchmark'
+
+ITER = 1_000
+
+tiny = t[:ok, :awesome]
+small = t[:ok, :answers, [42] * 42]
+large = ["abc" * 1000] * 100
+complex = [42, {:foo => 'bac' * 100}, t[(1..100).to_a]] * 10
+
+Benchmark.bm do |bench|
+  bench.report("BERT tiny") {ITER.times {BERT.decode(BERT.encode(tiny))}}
+  bench.report("BERT small") {ITER.times {BERT.decode(BERT.encode(small))}}
+  bench.report("BERT large") {ITER.times {BERT.decode(BERT.encode(large))}}
+  bench.report("BERT complex") {ITER.times {BERT.decode(BERT.encode(complex))}}
+
+  bench.report("JSON tiny") {ITER.times {JSON.load(JSON.dump(tiny))}}
+  bench.report("JSON small") {ITER.times {JSON.load(JSON.dump(small))}}
+  bench.report("JSON large") {ITER.times {JSON.load(JSON.dump(large))}}
+  bench.report("JSON complex") {ITER.times {JSON.load(JSON.dump(complex))}}
+
+  bench.report("YAJL tiny") {ITER.times {Yajl::Parser.parse(Yajl::Encoder.encode(tiny))}}
+  bench.report("YAJL small") {ITER.times {Yajl::Parser.parse(Yajl::Encoder.encode(small))}}
+  bench.report("YAJL large") {ITER.times {Yajl::Parser.parse(Yajl::Encoder.encode(large))}}
+  bench.report("YAJL complex") {ITER.times {Yajl::Parser.parse(Yajl::Encoder.encode(complex))}}
+
+  bench.report("Ruby tiny") {ITER.times {Marshal.load(Marshal.dump(tiny))}}
+  bench.report("Ruby small") {ITER.times {Marshal.load(Marshal.dump(small))}}
+  bench.report("Ruby large") {ITER.times {Marshal.load(Marshal.dump(large))}}
+  bench.report("Ruby complex") {ITER.times {Marshal.load(Marshal.dump(complex))}}
+end

data/bench/decode_bench.rb

@@ -0,0 +1,87 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'json'
+require 'yajl'
+require 'benchmark'
+
+ITER = 1_000
+
+def setup
+  tiny = t[:ok, :awesome]
+  small = t[:ok, :answers, [42] * 42]
+  large = ["abc" * 1000] * 100
+  complex = [42, {:foo => 'bac' * 100}, t[(1..100).to_a]] * 10
+
+  $tiny_encoded_bert = BERT.encode(tiny)
+  $small_encoded_bert = BERT.encode(small)
+  $large_encoded_bert = BERT.encode(large)
+  $complex_encoded_bert = BERT.encode(complex)
+
+  $tiny_encoded_json = JSON.dump(tiny)
+  $small_encoded_json = JSON.dump(small)
+  $large_encoded_json = JSON.dump(large)
+  $complex_encoded_json = JSON.dump(complex)
+
+  $tiny_encoded_yajl = Yajl::Encoder.encode(tiny)
+  $small_encoded_yajl = Yajl::Encoder.encode(small)
+  $large_encoded_yajl = Yajl::Encoder.encode(large)
+  $complex_encoded_yajl = Yajl::Encoder.encode(complex)
+
+  $tiny_encoded_ruby = Marshal.dump(tiny)
+  $small_encoded_ruby = Marshal.dump(small)
+  $large_encoded_ruby = Marshal.dump(large)
+  $complex_encoded_ruby = Marshal.dump(complex)
+end
+
+Benchmark.bm(13) do |bench|
+  pid = fork do
+    Dir.chdir(File.join(File.dirname(__FILE__), *%w[.. ext bert c])) { `make` }
+    require 'bert'
+    raise "Could not load C extension" unless BERT::Decode.impl == 'C'
+    setup
+    puts "BERT C Extension Decoder"
+    bench.report("BERT tiny")    {ITER.times {BERT.decode($tiny_encoded_bert)}}
+    bench.report("BERT small")   {ITER.times {BERT.decode($small_encoded_bert)}}
+    bench.report("BERT large")   {ITER.times {BERT.decode($large_encoded_bert)}}
+    bench.report("BERT complex") {ITER.times {BERT.decode($complex_encoded_bert)}}
+    puts
+  end
+  Process.waitpid(pid)
+
+  pid = fork do
+    Dir.chdir(File.join(File.dirname(__FILE__), *%w[.. ext bert c])) do
+      ['*.bundle', '*.o'].each { |pat| `rm -f #{pat}` }
+    end
+    require 'bert'
+    raise "Not using Ruby decoder" unless BERT::Decode.impl == 'Ruby'
+    setup
+    puts "BERT Pure Ruby Decoder"
+    bench.report("BERT tiny")    {ITER.times {BERT.decode($tiny_encoded_bert)}}
+    bench.report("BERT small")   {ITER.times {BERT.decode($small_encoded_bert)}}
+    bench.report("BERT large")   {ITER.times {BERT.decode($large_encoded_bert)}}
+    bench.report("BERT complex") {ITER.times {BERT.decode($complex_encoded_bert)}}
+    puts
+  end
+  Process.waitpid(pid)
+
+  require 'bert'
+  setup
+
+  bench.report("JSON tiny")      {ITER.times {JSON.load($tiny_encoded_json)}}
+  bench.report("JSON small")     {ITER.times {JSON.load($small_encoded_json)}}
+  bench.report("JSON large")     {ITER.times {JSON.load($large_encoded_json)}}
+  bench.report("JSON complex")   {ITER.times {JSON.load($complex_encoded_json)}}
+  puts
+
+  bench.report("YAJL tiny")      {ITER.times {Yajl::Parser.parse($tiny_encoded_yajl)}}
+  bench.report("YAJL small")     {ITER.times {Yajl::Parser.parse($small_encoded_yajl)}}
+  bench.report("YAJL large")     {ITER.times {Yajl::Parser.parse($large_encoded_yajl)}}
+  bench.report("YAJL complex")   {ITER.times {Yajl::Parser.parse($complex_encoded_yajl)}}
+  puts
+
+  bench.report("Ruby tiny")      {ITER.times {Marshal.load($tiny_encoded_ruby)}}
+  bench.report("Ruby small")     {ITER.times {Marshal.load($small_encoded_ruby)}}
+  bench.report("Ruby large")     {ITER.times {Marshal.load($large_encoded_ruby)}}
+  bench.report("Ruby complex")   {ITER.times {Marshal.load($complex_encoded_ruby)}}
+end

data/bench/encode_bench.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'bert'
+require 'json'
+require 'yajl'
+require 'benchmark'
+
+ITER = 1_000
+
+tiny = t[:ok, :awesome]
+small = t[:ok, :answers, [42] * 42]
+large = ["abc" * 1000] * 100
+complex = [42, {:foo => 'bac' * 100}, t[(1..100).to_a]] * 10
+
+Benchmark.bm(13) do |bench|
+  bench.report("BERT tiny")    {ITER.times {BERT.encode(tiny)}}
+  bench.report("BERT small")   {ITER.times {BERT.encode(small)}}
+  bench.report("BERT large")   {ITER.times {BERT.encode(large)}}
+  bench.report("BERT complex") {ITER.times {BERT.encode(complex)}}
+  puts
+  bench.report("JSON tiny")    {ITER.times {JSON.dump(tiny)}}
+  bench.report("JSON small")   {ITER.times {JSON.dump(small)}}
+  bench.report("JSON large")   {ITER.times {JSON.dump(large)}}
+  bench.report("JSON complex") {ITER.times {JSON.dump(complex)}}
+  puts
+  bench.report("JSON tiny")    {ITER.times {Yajl::Encoder.encode(tiny)}}
+  bench.report("JSON small")   {ITER.times {Yajl::Encoder.encode(small)}}
+  bench.report("JSON large")   {ITER.times {Yajl::Encoder.encode(large)}}
+  bench.report("JSON complex") {ITER.times {Yajl::Encoder.encode(complex)}}
+  puts
+  bench.report("Ruby tiny")    {ITER.times {Marshal.dump(tiny)}}
+  bench.report("Ruby small")   {ITER.times {Marshal.dump(small)}}
+  bench.report("Ruby large")   {ITER.times {Marshal.dump(large)}}
+  bench.report("Ruby complex") {ITER.times {Marshal.dump(complex)}}
+end

data/bench/results.txt

@@ -0,0 +1,55 @@
+        user     system      total        real
+
+Comparisons
+
+  JSON tiny  0.020000   0.000000   0.020000 (  0.017486)
+  JSON small  0.070000   0.000000   0.070000 (  0.080681)
+  JSON large 15.260000   0.600000  15.860000 ( 16.427857)
+  JSON complex  1.470000   0.010000   1.480000 (  1.558230)
+
+  YAJL tiny  0.010000   0.000000   0.010000 (  0.015537)
+  YAJL small  0.050000   0.000000   0.050000 (  0.061879)
+  YAJL large  3.610000   0.800000   4.410000 (  4.675255)
+  YAJL complex  1.030000   0.000000   1.030000 (  1.066871)
+
+  Ruby tiny  0.010000   0.000000   0.010000 (  0.007117)
+  Ruby small  0.020000   0.000000   0.020000 (  0.015964)
+  Ruby large  0.040000   0.000000   0.040000 (  0.042695)
+  Ruby complex  0.040000   0.000000   0.040000 (  0.048395)
+
+Ruby encoder / Ruby decoder
+41503465479e8762916d6997d91639f0d7308a13
+
+  BERT tiny  0.090000   0.000000   0.090000 (  0.092357)
+  BERT small  0.830000   0.000000   0.830000 (  0.853270)
+  BERT large  4.190000   0.620000   4.810000 (  4.959149)
+  BERT complex 19.380000   0.080000  19.460000 ( 20.402862)
+
+Simple C decoder / Ruby encoder
+41503465479e8762916d6997d91639f0d7308a13
+
+  BERT tiny  0.030000   0.000000   0.030000 (  0.033826)
+  BERT small  0.390000   0.010000   0.400000 (  0.413229)
+  BERT large  2.270000   0.550000   2.820000 (  3.029141)
+  BERT complex  8.680000   0.040000   8.720000 (  9.097990)
+
+Smarter Ruby decoder
+
+  BERT tiny  0.070000   0.000000   0.070000 (  0.075155)
+  BERT small  0.810000   0.010000   0.820000 (  0.831905)
+  BERT large  4.340000   0.600000   4.940000 (  5.064875)
+  BERT complex 18.460000   0.070000  18.530000 ( 19.096184)
+
+Smarter C decoder
+
+  BERT tiny  0.030000   0.000000   0.030000 (  0.035685)
+  BERT small  0.350000   0.010000   0.360000 (  0.358929)
+  BERT large  2.410000   0.560000   2.970000 (  3.056593)
+  BERT complex  7.910000   0.040000   7.950000 (  8.236641)
+
+Smart C Decoder only
+
+  BERT tiny  0.000000   0.000000   0.000000 (  0.001820)
+  BERT small  0.000000   0.000000   0.000000 (  0.003859)
+  BERT large  0.430000   0.010000   0.440000 (  0.499631)
+  BERT complex  0.080000   0.010000   0.090000 (  0.086992)

data/bert.gemspec

@@ -5,13 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bert}
-  s.version = "1.0.0"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tom Preston-Werner"]
-  s.date = %q{2009-10-19}
+  s.date = %q{2009-10-28}
   s.description = %q{BERT Serializiation for Ruby}
   s.email = %q{tom@mojombo.com}
+  s.extensions = ["ext/bert/c/extconf.rb"]
   s.extra_rdoc_files = [
     "LICENSE",
      "README.md"
@@ -24,10 +25,20 @@ Gem::Specification.new do |s|
      "README.md",
      "Rakefile",
      "VERSION",
+     "bench/bench.rb",
+     "bench/decode_bench.rb",
+     "bench/encode_bench.rb",
+     "bench/results.txt",
      "bert.gemspec",
+     "ext/bert/c/decode.c",
+     "ext/bert/c/extconf.rb",
      "lib/bert.rb",
+     "lib/bert/bert.rb",
+     "lib/bert/decode.rb",
      "lib/bert/decoder.rb",
+     "lib/bert/encode.rb",
      "lib/bert/encoder.rb",
+     "lib/bert/types.rb",
      "test/bert_test.rb",
      "test/decoder_test.rb",
      "test/encoder_test.rb",
@@ -35,7 +46,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = %q{http://github.com/mojombo/bert}
   s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
+  s.require_paths = ["lib", "ext"]
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{BERT Serializiation for Ruby}
   s.test_files = [
@@ -50,14 +61,11 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<erlectricity>, [">= 1.1.0"])
       s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
     else
-      s.add_dependency(%q<erlectricity>, [">= 1.1.0"])
       s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
     end
   else
-    s.add_dependency(%q<erlectricity>, [">= 1.1.0"])
     s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
   end
 end

data/ext/bert/c/decode.c

@@ -0,0 +1,438 @@
+#include "ruby.h"
+#include <string.h>
+
+#define ERL_VERSION       131
+#define ERL_SMALL_INT     97
+#define ERL_INT           98
+#define ERL_SMALL_BIGNUM  110
+#define ERL_LARGE_BIGNUM  111
+#define ERL_FLOAT         99
+#define ERL_ATOM          100
+#define ERL_SMALL_TUPLE   104
+#define ERL_LARGE_TUPLE   105
+#define ERL_NIL           106
+#define ERL_STRING        107
+#define ERL_LIST          108
+#define ERL_BIN           109
+
+static VALUE mBERT;
+static VALUE cDecode;
+static VALUE cTuple;
+void Init_decode();
+
+VALUE method_decode(VALUE klass, VALUE rString);
+
+VALUE read_any_raw(unsigned char **pData);
+
+// printers
+
+void p(VALUE val) {
+  rb_funcall(rb_mKernel, rb_intern("p"), 1, val);
+}
+
+// checkers
+
+void check_int(int num) {
+  char buf[17];
+  sprintf(buf, "%u", num);
+  rb_raise(rb_eStandardError, buf);
+}
+
+void check_str(char *str) {
+  rb_raise(rb_eStandardError, str);
+}
+
+// string peekers/readers
+
+unsigned int peek_1(unsigned char **pData) {
+  return (unsigned int) **pData;
+}
+
+unsigned int peek_2(unsigned char **pData) {
+  return (unsigned int) ((**pData << 8) + *(*pData + 1));
+}
+
+unsigned int peek_4(unsigned char **pData) {
+  return (unsigned int) ((**pData << 24) + (*(*pData + 1) << 16) + (*(*pData + 2) << 8) + *(*pData + 3));
+}
+
+unsigned int read_1(unsigned char **pData) {
+  unsigned int val = peek_1(pData);
+  *pData += 1;
+  return val;
+}
+
+unsigned int read_2(unsigned char **pData) {
+  unsigned int val = peek_2(pData);
+  *pData += 2;
+  return val;
+}
+
+unsigned int read_4(unsigned char **pData) {
+  unsigned int val = peek_4(pData);
+  *pData += 4;
+  return val;
+}
+
+// tuples
+
+VALUE read_tuple(unsigned char **pData, unsigned int arity);
+
+VALUE read_dict_pair(unsigned char **pData) {
+  if(read_1(pData) != ERL_SMALL_TUPLE) {
+    rb_raise(rb_eStandardError, "Invalid dict pair, not a small tuple");
+  }
+
+  int arity = read_1(pData);
+
+  if(arity != 2) {
+    rb_raise(rb_eStandardError, "Invalid dict pair, not a 2-tuple");
+  }
+
+  return read_tuple(pData, arity);
+}
+
+VALUE read_dict(unsigned char **pData) {
+  int type = read_1(pData);
+  if(!(type == ERL_LIST || type == ERL_NIL)) {
+    rb_raise(rb_eStandardError, "Invalid dict spec, not an erlang list");
+  }
+
+  unsigned int length = 0;
+  if(type == ERL_LIST) {
+    length = read_4(pData);
+  }
+
+  VALUE cHash = rb_const_get(rb_cObject, rb_intern("Hash"));
+  VALUE hash = rb_funcall(cHash, rb_intern("new"), 0);
+
+  int i;
+  for(i = 0; i < length; ++i) {
+    VALUE pair = read_dict_pair(pData);
+    VALUE first = rb_ary_entry(pair, 0);
+    VALUE last = rb_ary_entry(pair, 1);
+    rb_funcall(hash, rb_intern("store"), 2, first, last);
+  }
+
+  if(type == ERL_LIST) {
+    read_1(pData);
+  }
+
+  return hash;
+}
+
+VALUE read_complex_type(unsigned char **pData, int arity) {
+  VALUE type = read_any_raw(pData);
+  ID id = SYM2ID(type);
+  if(id == rb_intern("nil")) {
+    return Qnil;
+  } else if(id == rb_intern("true")) {
+    return Qtrue;
+  } else if(id == rb_intern("false")) {
+    return Qfalse;
+  } else if(id == rb_intern("time")) {
+    VALUE megasecs = read_any_raw(pData);
+    VALUE msecs = rb_funcall(megasecs, rb_intern("*"), 1, INT2NUM(1000000));
+    VALUE secs = read_any_raw(pData);
+    VALUE microsecs = read_any_raw(pData);
+    VALUE stamp = rb_funcall(msecs, rb_intern("+"), 1, secs);
+    return rb_funcall(rb_cTime, rb_intern("at"), 2, stamp, microsecs);
+  } else if(id == rb_intern("regex")) {
+    VALUE source = read_any_raw(pData);
+    VALUE opts = read_any_raw(pData);
+    int flags = 0;
+    if(rb_ary_includes(opts, ID2SYM(rb_intern("caseless"))))
+      flags = flags | 1;
+    if(rb_ary_includes(opts, ID2SYM(rb_intern("extended"))))
+      flags = flags | 2;
+    if(rb_ary_includes(opts, ID2SYM(rb_intern("multiline"))))
+      flags = flags | 4;
+    return rb_funcall(rb_cRegexp, rb_intern("new"), 2, source, INT2NUM(flags));
+  } else if(id == rb_intern("dict")) {
+    return read_dict(pData);
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE read_tuple(unsigned char **pData, unsigned int arity) {
+  if(arity > 0) {
+    VALUE tag = read_any_raw(pData);
+    if(SYM2ID(tag) == rb_intern("bert")) {
+      return read_complex_type(pData, arity);
+    } else {
+      VALUE tuple = rb_funcall(cTuple, rb_intern("new"), 1, INT2NUM(arity));
+      rb_ary_store(tuple, 0, tag);
+      int i;
+      for(i = 1; i < arity; ++i) {
+        rb_ary_store(tuple, i, read_any_raw(pData));
+      }
+      return tuple;
+    }
+  } else {
+    return rb_funcall(cTuple, rb_intern("new"), 0);
+  }
+}
+
+VALUE read_small_tuple(unsigned char **pData) {
+  if(read_1(pData) != ERL_SMALL_TUPLE) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a small tuple");
+  }
+
+  int arity = read_1(pData);
+  return read_tuple(pData, arity);
+}
+
+VALUE read_large_tuple(unsigned char **pData) {
+  if(read_1(pData) != ERL_LARGE_TUPLE) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a large tuple");
+  }
+
+  unsigned int arity = read_4(pData);
+  return read_tuple(pData, arity);
+}
+
+// lists
+
+VALUE read_list(unsigned char **pData) {
+  if(read_1(pData) != ERL_LIST) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an erlang list");
+  }
+
+  unsigned int size = read_4(pData);
+
+  VALUE array = rb_ary_new2(size);
+
+  int i;
+  for(i = 0; i < size; ++i) {
+    rb_ary_store(array, i, read_any_raw(pData));
+  }
+
+  read_1(pData);
+
+  return array;
+}
+
+// primitives
+
+void read_string_raw(unsigned char *dest, unsigned char **pData, unsigned int length) {
+  memcpy((char *) dest, (char *) *pData, length);
+  *(dest + length) = (unsigned char) 0;
+  *pData += length;
+}
+
+VALUE read_bin(unsigned char **pData) {
+  if(read_1(pData) != ERL_BIN) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an erlang binary");
+  }
+
+  unsigned int length = read_4(pData);
+
+  VALUE rStr = rb_str_new((char *) *pData, length);
+  *pData += length;
+
+  return rStr;
+}
+
+VALUE read_string(unsigned char **pData) {
+  if(read_1(pData) != ERL_STRING) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an erlang string");
+  }
+
+  int length = read_2(pData);
+  VALUE array = rb_ary_new2(length);
+
+  int i = 0;
+  for(i; i < length; ++i) {
+    rb_ary_store(array, i, INT2NUM(**pData));
+    *pData += 1;
+  }
+
+  return array;
+}
+
+VALUE read_atom(unsigned char **pData) {
+  if(read_1(pData) != ERL_ATOM) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an atom");
+  }
+
+  int length = read_2(pData);
+
+  unsigned char buf[length + 1];
+  read_string_raw(buf, pData, length);
+
+  return ID2SYM(rb_intern((char *) buf));
+}
+
+VALUE read_small_int(unsigned char **pData) {
+  if(read_1(pData) != ERL_SMALL_INT) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a small int");
+  }
+
+  int value = read_1(pData);
+
+  return INT2FIX(value);
+}
+
+VALUE read_int(unsigned char **pData) {
+  if(read_1(pData) != ERL_INT) {
+    rb_raise(rb_eStandardError, "Invalid Type, not an int");
+  }
+
+  long long value = read_4(pData);
+
+  long long negative = ((value >> 31) & 0x1 == 1);
+
+  if(negative) {
+    value = (value - ((long long) 1 << 32));
+  }
+
+  return INT2FIX(value);
+}
+
+VALUE read_small_bignum(unsigned char **pData) {
+  if(read_1(pData) != ERL_SMALL_BIGNUM) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a small bignum");
+  }
+
+  unsigned int size = read_1(pData);
+  unsigned int sign = read_1(pData);
+
+  VALUE num = INT2NUM(0);
+  VALUE tmp;
+
+  unsigned char buf[size + 1];
+  read_string_raw(buf, pData, size);
+
+  int i;
+  for(i = 0; i < size; ++i) {
+    tmp = INT2FIX(*(buf + i));
+    tmp = rb_funcall(tmp, rb_intern("<<"), 1, INT2NUM(i * 8));
+    num = rb_funcall(num, rb_intern("+"), 1, tmp);
+  }
+
+  if(sign) {
+    num = rb_funcall(num, rb_intern("*"), 1, INT2NUM(-1));
+  }
+
+  return num;
+}
+
+VALUE read_large_bignum(unsigned char **pData) {
+  if(read_1(pData) != ERL_LARGE_BIGNUM) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a small bignum");
+  }
+
+  unsigned int size = read_4(pData);
+  unsigned int sign = read_1(pData);
+
+  VALUE num = INT2NUM(0);
+  VALUE tmp;
+
+  unsigned char buf[size + 1];
+  read_string_raw(buf, pData, size);
+
+  int i;
+  for(i = 0; i < size; ++i) {
+    tmp = INT2FIX(*(buf + i));
+    tmp = rb_funcall(tmp, rb_intern("<<"), 1, INT2NUM(i * 8));
+
+    num = rb_funcall(num, rb_intern("+"), 1, tmp);
+  }
+
+  if(sign) {
+    num = rb_funcall(num, rb_intern("*"), 1, INT2NUM(-1));
+  }
+
+  return num;
+}
+
+VALUE read_float(unsigned char **pData) {
+  if(read_1(pData) != ERL_FLOAT) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a float");
+  }
+
+  unsigned char buf[32];
+  read_string_raw(buf, pData, 31);
+
+  VALUE rString = rb_str_new2((char *) buf);
+
+  return rb_funcall(rString, rb_intern("to_f"), 0);
+}
+
+VALUE read_nil(unsigned char **pData) {
+  if(read_1(pData) != ERL_NIL) {
+    rb_raise(rb_eStandardError, "Invalid Type, not a nil list");
+  }
+
+  return rb_ary_new2(0);
+}
+
+// read_any_raw
+
+VALUE read_any_raw(unsigned char **pData) {
+  switch(peek_1(pData)) {
+    case ERL_SMALL_INT:
+      return read_small_int(pData);
+      break;
+    case ERL_INT:
+      return read_int(pData);
+      break;
+    case ERL_FLOAT:
+      return read_float(pData);
+      break;
+    case ERL_ATOM:
+      return read_atom(pData);
+      break;
+    case ERL_SMALL_TUPLE:
+      return read_small_tuple(pData);
+      break;
+    case ERL_LARGE_TUPLE:
+      return read_large_tuple(pData);
+      break;
+    case ERL_NIL:
+      return read_nil(pData);
+      break;
+    case ERL_STRING:
+      return read_string(pData);
+      break;
+    case ERL_LIST:
+      return read_list(pData);
+      break;
+    case ERL_BIN:
+      return read_bin(pData);
+      break;
+    case ERL_SMALL_BIGNUM:
+      return read_small_bignum(pData);
+      break;
+    case ERL_LARGE_BIGNUM:
+      return read_large_bignum(pData);
+      break;
+  }
+  return Qnil;
+}
+
+VALUE method_decode(VALUE klass, VALUE rString) {
+  unsigned char *data = (unsigned char *) StringValuePtr(rString);
+
+  unsigned char **pData = &data;
+
+  // check protocol version
+  if(read_1(pData) != ERL_VERSION) {
+    rb_raise(rb_eStandardError, "Bad Magic");
+  }
+
+  return read_any_raw(pData);
+}
+
+VALUE method_impl(VALUE klass) {
+  return rb_str_new("C", 1);
+}
+
+void Init_decode() {
+  mBERT = rb_const_get(rb_cObject, rb_intern("BERT"));
+  cDecode = rb_define_class_under(mBERT, "Decode", rb_cObject);
+  cTuple = rb_const_get(mBERT, rb_intern("Tuple"));
+  rb_define_singleton_method(cDecode, "decode", method_decode, 1);
+  rb_define_singleton_method(cDecode, "impl", method_impl, 0);
+}