msgpack 1.4.4 → 1.5.1

data/ext/msgpack/packer_class.c

@@ -28,6 +28,8 @@ VALUE cMessagePack_Packer;
 static ID s_to_msgpack;
 static ID s_write;
 
+static VALUE sym_compatibility_mode;
+
 //static VALUE s_packer_value;
 //static msgpack_packer_t* s_packer;
 
@@ -68,29 +70,28 @@ VALUE MessagePack_Packer_alloc(VALUE klass)
 
 VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
 {
+    if(argc > 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    }
+
     VALUE io = Qnil;
     VALUE options = Qnil;
 
-    if(argc == 0 || (argc == 1 && argv[0] == Qnil)) {
-        /* Qnil */
-
-    } else if(argc == 1) {
-        VALUE v = argv[0];
-        if(rb_type(v) == T_HASH) {
-            options = v;
-        } else {
-            io = v;
-        }
-
-    } else if(argc == 2) {
+    if(argc >= 1) {
         io = argv[0];
+    }
+
+    if(argc == 2) {
         options = argv[1];
-        if(rb_type(options) != T_HASH) {
-            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
-        }
+    }
 
-    } else {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    if (options == Qnil && rb_type(io) == T_HASH) {
+        options = io;
+        io = Qnil;
+    }
+
+    if(options != Qnil) {
+        Check_Type(options, T_HASH);
     }
 
     PACKER(self, pk);
@@ -103,7 +104,7 @@ VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
     if(options != Qnil) {
         VALUE v;
 
-        v = rb_hash_aref(options, ID2SYM(rb_intern("compatibility_mode")));
+        v = rb_hash_aref(options, sym_compatibility_mode);
         msgpack_packer_set_compat(pk, RTEST(v));
     }
 
@@ -281,7 +282,7 @@ static VALUE Packer_flush(VALUE self)
     return self;
 }
 
-static VALUE Packer_clear(VALUE self)
+static VALUE Packer_reset(VALUE self)
 {
     PACKER(self, pk);
     msgpack_buffer_clear(PACKER_BUFFER_(pk));
@@ -339,7 +340,10 @@ static VALUE Packer_write_to(VALUE self, VALUE io)
 static VALUE Packer_registered_types_internal(VALUE self)
 {
     PACKER(self, pk);
-    return rb_hash_dup(pk->ext_registry.hash);
+    if (RTEST(pk->ext_registry.hash)) {
+        return rb_hash_dup(pk->ext_registry.hash);
+    }
+    return rb_hash_new();
 }
 
 static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
@@ -377,7 +381,7 @@ static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
         rb_raise(rb_eArgError, "expected Module/Class but found %s.", rb_obj_classname(ext_module));
     }
 
-    msgpack_packer_ext_registry_put(&pk->ext_registry, ext_module, ext_type, proc, arg);
+    msgpack_packer_ext_registry_put(&pk->ext_registry, ext_module, ext_type, 0, proc, arg);
 
     if (ext_module == rb_cSymbol) {
         pk->has_symbol_ext_type = true;
@@ -409,6 +413,8 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     s_to_msgpack = rb_intern("to_msgpack");
     s_write = rb_intern("write");
 
+    sym_compatibility_mode = ID2SYM(rb_intern("compatibility_mode"));
+
     msgpack_packer_static_init();
     msgpack_packer_ext_registry_static_init();
 
@@ -440,7 +446,8 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Packer, "flush", Packer_flush, 0);
 
     /* delegation methods */
-    rb_define_method(cMessagePack_Packer, "clear", Packer_clear, 0);
+    rb_define_method(cMessagePack_Packer, "reset", Packer_reset, 0);
+    rb_define_alias(cMessagePack_Packer, "clear", "reset");
     rb_define_method(cMessagePack_Packer, "size", Packer_size, 0);
     rb_define_method(cMessagePack_Packer, "empty?", Packer_empty_p, 0);
     rb_define_method(cMessagePack_Packer, "write_to", Packer_write_to, 1);

data/ext/msgpack/packer_ext_registry.c

@@ -30,8 +30,8 @@ void msgpack_packer_ext_registry_static_destroy()
 
 void msgpack_packer_ext_registry_init(msgpack_packer_ext_registry_t* pkrg)
 {
-    pkrg->hash = rb_hash_new();
-    pkrg->cache = rb_hash_new();
+    pkrg->hash = Qnil;
+    pkrg->cache = Qnil;
 }
 
 void msgpack_packer_ext_registry_mark(msgpack_packer_ext_registry_t* pkrg)
@@ -43,15 +43,29 @@ void msgpack_packer_ext_registry_mark(msgpack_packer_ext_registry_t* pkrg)
 void msgpack_packer_ext_registry_dup(msgpack_packer_ext_registry_t* src,
         msgpack_packer_ext_registry_t* dst)
 {
-    dst->hash = rb_hash_dup(src->hash);
-    dst->cache = rb_hash_dup(src->cache);
+    if(RTEST(src->hash) && !rb_obj_frozen_p(src->hash)) {
+        dst->hash = rb_hash_dup(src->hash);
+        dst->cache = RTEST(src->cache) ? rb_hash_dup(src->cache) : Qnil;
+    } else {
+        // If the type registry is frozen we can safely share it, and share the cache as well.
+        dst->hash = src->hash;
+        dst->cache = src->cache;
+    }
 }
 
 VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
-        VALUE ext_module, int ext_type, VALUE proc, VALUE arg)
+        VALUE ext_module, int ext_type, int flags, VALUE proc, VALUE arg)
 {
-    VALUE e = rb_ary_new3(3, INT2FIX(ext_type), proc, arg);
-    /* clear lookup cache not to miss added type */
-    rb_hash_clear(pkrg->cache);
-    return rb_hash_aset(pkrg->hash, ext_module, e);
+    if (!RTEST(pkrg->hash)) {
+        pkrg->hash = rb_hash_new();
+    }
+
+    if (RTEST(pkrg->cache)) {
+        /* clear lookup cache not to miss added type */
+        rb_hash_clear(pkrg->cache);
+    }
+
+    // TODO: Ruby embeded array limit is 3, merging `proc` and `arg` would be good.
+    VALUE entry = rb_ary_new3(4, INT2FIX(ext_type), proc, arg, INT2FIX(flags));
+    return rb_hash_aset(pkrg->hash, ext_module, entry);
 }

data/ext/msgpack/packer_ext_registry.h

@@ -21,6 +21,8 @@
 #include "compat.h"
 #include "ruby.h"
 
+#define MSGPACK_EXT_RECURSIVE 0b0001
+
 struct msgpack_packer_ext_registry_t;
 typedef struct msgpack_packer_ext_registry_t msgpack_packer_ext_registry_t;
 
@@ -44,7 +46,7 @@ void msgpack_packer_ext_registry_dup(msgpack_packer_ext_registry_t* src,
         msgpack_packer_ext_registry_t* dst);
 
 VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
-        VALUE ext_module, int ext_type, VALUE proc, VALUE arg);
+        VALUE ext_module, int ext_type, int flags, VALUE proc, VALUE arg);
 
 static int msgpack_packer_ext_find_superclass(VALUE key, VALUE value, VALUE arg)
 {
@@ -60,59 +62,60 @@ static int msgpack_packer_ext_find_superclass(VALUE key, VALUE value, VALUE arg)
 }
 
 static inline VALUE msgpack_packer_ext_registry_fetch(msgpack_packer_ext_registry_t* pkrg,
-        VALUE lookup_class, int* ext_type_result)
+        VALUE lookup_class, int* ext_type_result, int* ext_flags_result)
 {
     // fetch lookup_class from hash, which is a hash to register classes
     VALUE type = rb_hash_lookup(pkrg->hash, lookup_class);
     if(type != Qnil) {
         *ext_type_result = FIX2INT(rb_ary_entry(type, 0));
+        *ext_flags_result = FIX2INT(rb_ary_entry(type, 3));
         return rb_ary_entry(type, 1);
     }
 
     // fetch lookup_class from cache, which stores results of searching ancestors from pkrg->hash
-    VALUE type_inht = rb_hash_lookup(pkrg->cache, lookup_class);
-    if(type_inht != Qnil) {
-        *ext_type_result = FIX2INT(rb_ary_entry(type_inht, 0));
-        return rb_ary_entry(type_inht, 1);
+    if (RTEST(pkrg->cache)) {
+        VALUE type_inht = rb_hash_lookup(pkrg->cache, lookup_class);
+        if(type_inht != Qnil) {
+            *ext_type_result = FIX2INT(rb_ary_entry(type_inht, 0));
+            *ext_flags_result = FIX2INT(rb_ary_entry(type_inht, 3));
+            return rb_ary_entry(type_inht, 1);
+        }
     }
 
     return Qnil;
 }
 
 static inline VALUE msgpack_packer_ext_registry_lookup(msgpack_packer_ext_registry_t* pkrg,
-        VALUE instance, int* ext_type_result)
+        VALUE instance, int* ext_type_result, int* ext_flags_result)
 {
-    VALUE lookup_class;
     VALUE type;
 
-    /*
-     * 1. check whether singleton_class of this instance is registered (or resolved in past) or not.
-     *
-     * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
-     * String have no singleton class and raise a TypeError when trying to get
-     * it. See implementation of #singleton_class in ruby's source code:
-     * VALUE rb_singleton_class(VALUE obj);
-     *
-     * Since all but symbols are already filtered out when reaching this code
-     * only symbols are checked here.
-     */
-    if (!SYMBOL_P(instance)) {
-      lookup_class = rb_singleton_class(instance);
-
-      type = msgpack_packer_ext_registry_fetch(pkrg, lookup_class, ext_type_result);
+    if (pkrg->hash == Qnil) { // No extensions registered
+        return Qnil;
+    }
 
-      if(type != Qnil) {
-          return type;
-      }
+   /*
+    * 1. check whether singleton_class or class of this instance is registered (or resolved in past) or not.
+    *
+    * Objects of type Integer (Fixnum, Bignum), Float, Symbol and frozen
+    * `rb_class_of` returns the singleton_class if the object has one, or the "real class" otherwise.
+    */
+    VALUE lookup_class = rb_class_of(instance);
+    type = msgpack_packer_ext_registry_fetch(pkrg, lookup_class, ext_type_result, ext_flags_result);
+    if(type != Qnil) {
+        return type;
     }
 
     /*
-     * 2. check the class of instance is registered (or resolved in past) or not.
+     * 2. If the object had a singleton_class check if the real class of instance is registered
+     * (or resolved in past) or not.
      */
-    type = msgpack_packer_ext_registry_fetch(pkrg, rb_obj_class(instance), ext_type_result);
-
-    if(type != Qnil) {
-        return type;
+    VALUE real_class = rb_obj_class(instance);
+    if(lookup_class != real_class) {
+        type = msgpack_packer_ext_registry_fetch(pkrg, real_class, ext_type_result, ext_flags_result);
+        if(type != Qnil) {
+            return type;
+        }
     }
 
     /*
@@ -126,8 +129,12 @@ static inline VALUE msgpack_packer_ext_registry_lookup(msgpack_packer_ext_regist
     VALUE superclass = args[1];
     if(superclass != Qnil) {
         VALUE superclass_type = rb_hash_lookup(pkrg->hash, superclass);
+        if (!RTEST(pkrg->cache)) {
+            pkrg->cache = rb_hash_new();
+        }
         rb_hash_aset(pkrg->cache, lookup_class, superclass_type);
         *ext_type_result = FIX2INT(rb_ary_entry(superclass_type, 0));
+        *ext_flags_result = FIX2INT(rb_ary_entry(superclass_type, 3));
         return rb_ary_entry(superclass_type, 1);
     }
 

data/ext/msgpack/unpacker.c

@@ -52,9 +52,19 @@ void msgpack_unpacker_static_destroy()
 
 #define HEAD_BYTE_REQUIRED 0xc1
 
-void _msgpack_unpacker_init(msgpack_unpacker_t* uk)
+static inline msgpack_unpacker_stack_t* _msgpack_unpacker_new_stack(void) {
+#ifdef UNPACKER_STACK_RMEM
+    return msgpack_rmem_alloc(&s_stack_rmem);
+    /*memset(uk->stack, 0, MSGPACK_UNPACKER_STACK_CAPACITY);*/
+#else
+    /*uk->stack = calloc(MSGPACK_UNPACKER_STACK_CAPACITY, sizeof(msgpack_unpacker_stack_t));*/
+    return xmalloc(MSGPACK_UNPACKER_STACK_CAPACITY * sizeof(msgpack_unpacker_stack_t));
+#endif
+}
+
+msgpack_unpacker_t* _msgpack_unpacker_new(void)
 {
-    memset(uk, 0, sizeof(msgpack_unpacker_t));
+    msgpack_unpacker_t* uk = ZALLOC_N(msgpack_unpacker_t, 1);
 
     msgpack_buffer_init(UNPACKER_BUFFER_(uk));
 
@@ -63,24 +73,23 @@ void _msgpack_unpacker_init(msgpack_unpacker_t* uk)
     uk->last_object = Qnil;
     uk->reading_raw = Qnil;
 
-#ifdef UNPACKER_STACK_RMEM
-    uk->stack = msgpack_rmem_alloc(&s_stack_rmem);
-    /*memset(uk->stack, 0, MSGPACK_UNPACKER_STACK_CAPACITY);*/
-#else
-    /*uk->stack = calloc(MSGPACK_UNPACKER_STACK_CAPACITY, sizeof(msgpack_unpacker_stack_t));*/
-    uk->stack = xmalloc(MSGPACK_UNPACKER_STACK_CAPACITY * sizeof(msgpack_unpacker_stack_t));
-#endif
+    uk->stack = _msgpack_unpacker_new_stack();
     uk->stack_capacity = MSGPACK_UNPACKER_STACK_CAPACITY;
+
+    return uk;
+}
+
+static inline void _msgpack_unpacker_free_stack(msgpack_unpacker_stack_t* stack) {
+    #ifdef UNPACKER_STACK_RMEM
+        msgpack_rmem_free(&s_stack_rmem, stack);
+    #else
+        xfree(stack);
+    #endif
 }
 
 void _msgpack_unpacker_destroy(msgpack_unpacker_t* uk)
 {
-#ifdef UNPACKER_STACK_RMEM
-    msgpack_rmem_free(&s_stack_rmem, uk->stack);
-#else
-    xfree(uk->stack);
-#endif
-
+    _msgpack_unpacker_free_stack(uk->stack);
     msgpack_buffer_destroy(UNPACKER_BUFFER_(uk));
 }
 
@@ -164,14 +173,17 @@ static inline int object_complete_ext(msgpack_unpacker_t* uk, int ext_type, VALU
         return object_complete_symbol(uk, rb_str_intern(str));
     }
 
-    VALUE proc = msgpack_unpacker_ext_registry_lookup(&uk->ext_registry, ext_type);
+    int ext_flags;
+    VALUE proc = msgpack_unpacker_ext_registry_lookup(uk->ext_registry, ext_type, &ext_flags);
+
     if(proc != Qnil) {
-        VALUE obj = rb_funcall(proc, s_call, 1, str);
+        VALUE obj;
+        obj = rb_funcall(proc, s_call, 1, str == Qnil ? rb_str_buf_new(0) : str);
         return object_complete(uk, obj);
     }
 
     if(uk->allow_unknown_ext) {
-        VALUE obj = MessagePack_ExtensionValue_new(ext_type, str);
+        VALUE obj = MessagePack_ExtensionValue_new(ext_type, str == Qnil ? rb_str_buf_new(0) : str);
         return object_complete(uk, obj);
     }
 
@@ -281,29 +293,57 @@ static inline int read_raw_body_begin(msgpack_unpacker_t* uk, int raw_type)
 {
     /* assuming uk->reading_raw == Qnil */
 
+    int ext_flags;
+    VALUE proc;
+
+    if(!(raw_type == RAW_TYPE_STRING || raw_type == RAW_TYPE_BINARY)) {
+        proc = msgpack_unpacker_ext_registry_lookup(uk->ext_registry, raw_type, &ext_flags);
+        if(proc != Qnil && ext_flags & MSGPACK_EXT_RECURSIVE) {
+            VALUE obj;
+            uk->last_object = Qnil;
+            reset_head_byte(uk);
+            size_t ext_size = uk->reading_raw_remaining;
+            uk->reading_raw_remaining = 0;
+
+            msgpack_unpacker_stack_t* stack = uk->stack;
+            size_t stack_depth = uk->stack_depth;
+            size_t stack_capacity = uk->stack_capacity;
+
+            uk->stack = _msgpack_unpacker_new_stack();
+            uk->stack_depth = 0;
+            uk->stack_capacity = MSGPACK_UNPACKER_STACK_CAPACITY;
+
+            obj = rb_funcall(proc, s_call, 1, uk->buffer.owner);
+
+            _msgpack_unpacker_free_stack(uk->stack);
+            uk->stack = stack;
+            uk->stack_depth = stack_depth;
+            uk->stack_capacity = stack_capacity;
+
+            msgpack_buffer_skip(UNPACKER_BUFFER_(uk), ext_size);
+            return object_complete(uk, obj);
+        }
+    }
+
     /* try optimized read */
     size_t length = uk->reading_raw_remaining;
     if(length <= msgpack_buffer_top_readable_size(UNPACKER_BUFFER_(uk))) {
         int ret;
         if ((uk->optimized_symbol_ext_type && uk->symbol_ext_type == raw_type) || (uk->symbolize_keys && is_reading_map_key(uk))) {
-            VALUE symbol = msgpack_buffer_read_top_as_symbol(UNPACKER_BUFFER_(uk), length);
+            VALUE symbol = msgpack_buffer_read_top_as_symbol(UNPACKER_BUFFER_(uk), length, raw_type != RAW_TYPE_BINARY);
             ret = object_complete_symbol(uk, symbol);
         } else {
-            /* don't use zerocopy for hash keys but get a frozen string directly
-             * because rb_hash_aset freezes keys and it causes copying */
-            bool will_freeze = uk->freeze || is_reading_map_key(uk);
-            VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze, raw_type == RAW_TYPE_STRING);
+            bool will_freeze = uk->freeze;
             if(raw_type == RAW_TYPE_STRING || raw_type == RAW_TYPE_BINARY) {
+               /* don't use zerocopy for hash keys but get a frozen string directly
+                * because rb_hash_aset freezes keys and it causes copying */
+                will_freeze = will_freeze || is_reading_map_key(uk);
+                VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze, raw_type == RAW_TYPE_STRING);
                 ret = object_complete(uk, string);
             } else {
+                VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, false, false);
                 ret = object_complete_ext(uk, raw_type, string);
             }
-
-# if !HASH_ASET_DEDUPE
-            if(will_freeze) {
-                rb_obj_freeze(string);
-            }
-# endif
         }
         uk->reading_raw_remaining = 0;
         return ret;
@@ -373,7 +413,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 uint8_t length = cb->u8;
                 int ext_type = (signed char) cb->buffer[1];
                 if(length == 0) {
-                    return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
+                    return object_complete_ext(uk, ext_type, Qnil);
                 }
                 uk->reading_raw_remaining = length;
                 return read_raw_body_begin(uk, ext_type);
@@ -385,7 +425,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 uint16_t length = _msgpack_be16(cb->u16);
                 int ext_type = (signed char) cb->buffer[2];
                 if(length == 0) {
-                    return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
+                    return object_complete_ext(uk, ext_type, Qnil);
                 }
                 uk->reading_raw_remaining = length;
                 return read_raw_body_begin(uk, ext_type);
@@ -397,7 +437,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 uint32_t length = _msgpack_be32(cb->u32);
                 int ext_type = (signed char) cb->buffer[4];
                 if(length == 0) {
-                    return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
+                    return object_complete_ext(uk, ext_type, Qnil);
                 }
                 uk->reading_raw_remaining = length;
                 return read_raw_body_begin(uk, ext_type);

data/ext/msgpack/unpacker.h

@@ -60,7 +60,7 @@ struct msgpack_unpacker_t {
 
     VALUE buffer_ref;
 
-    msgpack_unpacker_ext_registry_t ext_registry;
+    msgpack_unpacker_ext_registry_t *ext_registry;
 
     /* options */
     bool symbolize_keys;
@@ -86,7 +86,7 @@ void msgpack_unpacker_static_init();
 
 void msgpack_unpacker_static_destroy();
 
-void _msgpack_unpacker_init(msgpack_unpacker_t* uk);
+msgpack_unpacker_t* _msgpack_unpacker_new(void);
 
 void _msgpack_unpacker_destroy(msgpack_unpacker_t* uk);
 

data/ext/msgpack/unpacker_class.c

@@ -33,6 +33,10 @@ static VALUE eUnexpectedTypeError;
 static VALUE eUnknownExtTypeError;
 static VALUE mTypeError;  // obsoleted. only for backward compatibility. See #86.
 
+static VALUE sym_symbolize_keys;
+static VALUE sym_freeze;
+static VALUE sym_allow_unknown_ext;
+
 #define UNPACKER(from, name) \
     msgpack_unpacker_t *name = NULL; \
     Data_Get_Struct(from, msgpack_unpacker_t, name); \
@@ -45,7 +49,7 @@ static void Unpacker_free(msgpack_unpacker_t* uk)
     if(uk == NULL) {
         return;
     }
-    msgpack_unpacker_ext_registry_destroy(&uk->ext_registry);
+    msgpack_unpacker_ext_registry_release(uk->ext_registry);
     _msgpack_unpacker_destroy(uk);
     xfree(uk);
 }
@@ -53,13 +57,12 @@ static void Unpacker_free(msgpack_unpacker_t* uk)
 static void Unpacker_mark(msgpack_unpacker_t* uk)
 {
     msgpack_unpacker_mark(uk);
-    msgpack_unpacker_ext_registry_mark(&uk->ext_registry);
+    msgpack_unpacker_ext_registry_mark(uk->ext_registry);
 }
 
 VALUE MessagePack_Unpacker_alloc(VALUE klass)
 {
-    msgpack_unpacker_t* uk = ZALLOC_N(msgpack_unpacker_t, 1);
-    _msgpack_unpacker_init(uk);
+    msgpack_unpacker_t* uk = _msgpack_unpacker_new();
 
     VALUE self = Data_Wrap_Struct(klass, Unpacker_mark, Unpacker_free, uk);
     return self;
@@ -84,7 +87,7 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
     } else if(argc == 2) {
         io = argv[0];
         options = argv[1];
-        if(rb_type(options) != T_HASH) {
+        if(options != Qnil && rb_type(options) != T_HASH) {
             rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
         }
 
@@ -94,7 +97,6 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
 
     UNPACKER(self, uk);
 
-    msgpack_unpacker_ext_registry_init(&uk->ext_registry);
     uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
 
     MessagePack_Buffer_set_options(UNPACKER_BUFFER_(uk), io, options);
@@ -102,13 +104,13 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
     if(options != Qnil) {
         VALUE v;
 
-        v = rb_hash_aref(options, ID2SYM(rb_intern("symbolize_keys")));
+        v = rb_hash_aref(options, sym_symbolize_keys);
         msgpack_unpacker_set_symbolized_keys(uk, RTEST(v));
 
-        v = rb_hash_aref(options, ID2SYM(rb_intern("freeze")));
+        v = rb_hash_aref(options, sym_freeze);
         msgpack_unpacker_set_freeze(uk, RTEST(v));
 
-        v = rb_hash_aref(options, ID2SYM(rb_intern("allow_unknown_ext")));
+        v = rb_hash_aref(options, sym_allow_unknown_ext);
         msgpack_unpacker_set_allow_unknown_ext(uk, RTEST(v));
     }
 
@@ -133,7 +135,7 @@ static VALUE Unpacker_allow_unknown_ext_p(VALUE self)
     return uk->allow_unknown_ext ? Qtrue : Qfalse;
 }
 
-static void raise_unpacker_error(int r)
+NORETURN(static void raise_unpacker_error(int r))
 {
     switch(r) {
     case PRIMITIVE_EOF:
@@ -145,6 +147,7 @@ static void raise_unpacker_error(int r)
     case PRIMITIVE_UNEXPECTED_TYPE:
         rb_raise(eUnexpectedTypeError, "unexpected type");
     case PRIMITIVE_UNEXPECTED_EXT_TYPE:
+    // rb_bug("unexpected extension type");
         rb_raise(eUnknownExtTypeError, "unexpected extension type");
     default:
         rb_raise(eUnpackError, "logically unknown error %d", r);
@@ -222,34 +225,6 @@ static VALUE Unpacker_read_map_header(VALUE self)
     return ULONG2NUM(size);
 }
 
-static VALUE Unpacker_peek_next_type(VALUE self)
-{
-    UNPACKER(self, uk);
-
-    int r = msgpack_unpacker_peek_next_object_type(uk);
-    if(r < 0) {
-        raise_unpacker_error(r);
-    }
-
-    switch((enum msgpack_unpacker_object_type) r) {
-    case TYPE_NIL:
-        return rb_intern("nil");
-    case TYPE_BOOLEAN:
-        return rb_intern("boolean");
-    case TYPE_INTEGER:
-        return rb_intern("integer");
-    case TYPE_FLOAT:
-        return rb_intern("float");
-    case TYPE_RAW:
-        return rb_intern("raw");
-    case TYPE_ARRAY:
-        return rb_intern("array");
-    case TYPE_MAP:
-        return rb_intern("map");
-    default:
-        rb_raise(eUnpackError, "logically unknown type %d", r);
-    }
-}
 
 static VALUE Unpacker_feed(VALUE self, VALUE data)
 {
@@ -296,9 +271,10 @@ static VALUE Unpacker_each_impl(VALUE self)
     }
 }
 
-static VALUE Unpacker_rescue_EOFError(VALUE self)
+static VALUE Unpacker_rescue_EOFError(VALUE args, VALUE error)
 {
-    UNUSED(self);
+    UNUSED(args);
+    UNUSED(error);
     return Qnil;
 }
 
@@ -347,9 +323,11 @@ static VALUE Unpacker_registered_types_internal(VALUE self)
     UNPACKER(self, uk);
 
     VALUE mapping = rb_hash_new();
-    for(int i=0; i < 256; i++) {
-        if(uk->ext_registry.array[i] != Qnil) {
-            rb_hash_aset(mapping, INT2FIX(i - 128), uk->ext_registry.array[i]);
+    if (uk->ext_registry) {
+        for(int i=0; i < 256; i++) {
+            if(uk->ext_registry->array[i] != Qnil) {
+                rb_hash_aset(mapping, INT2FIX(i - 128), uk->ext_registry->array[i]);
+            }
         }
     }
 
@@ -388,7 +366,7 @@ static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
         rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
     }
 
-    msgpack_unpacker_ext_registry_put(&uk->ext_registry, ext_module, ext_type, proc, arg);
+    msgpack_unpacker_ext_registry_put(&uk->ext_registry, ext_module, ext_type, 0, proc, arg);
 
     return Qnil;
 }
@@ -438,6 +416,10 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
 
     eUnknownExtTypeError = rb_define_class_under(mMessagePack, "UnknownExtTypeError", eUnpackError);
 
+    sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
+    sym_freeze = ID2SYM(rb_intern("freeze"));
+    sym_allow_unknown_ext = ID2SYM(rb_intern("allow_unknown_ext"));
+
     rb_define_alloc_func(cMessagePack_Unpacker, MessagePack_Unpacker_alloc);
 
     rb_define_method(cMessagePack_Unpacker, "initialize", MessagePack_Unpacker_initialize, -1);
@@ -451,7 +433,6 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Unpacker, "skip_nil", Unpacker_skip_nil, 0);
     rb_define_method(cMessagePack_Unpacker, "read_array_header", Unpacker_read_array_header, 0);
     rb_define_method(cMessagePack_Unpacker, "read_map_header", Unpacker_read_map_header, 0);
-    //rb_define_method(cMessagePack_Unpacker, "peek_next_type", Unpacker_peek_next_type, 0);  // TODO
     rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed, 1);
     rb_define_method(cMessagePack_Unpacker, "feed_reference", Unpacker_feed_reference, 1);
     rb_define_method(cMessagePack_Unpacker, "each", Unpacker_each, 0);