msgpack 1.7.0 → 1.7.2

data/ext/msgpack/factory_class.c

@@ -75,7 +75,7 @@ static const rb_data_type_t factory_data_type = {
         .dfree = Factory_free,
         .dsize = Factory_memsize,
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static inline msgpack_factory_t *Factory_get(VALUE object)
@@ -98,7 +98,7 @@ static VALUE Factory_initialize(int argc, VALUE* argv, VALUE self)
 {
     msgpack_factory_t *fc = Factory_get(self);
 
-    msgpack_packer_ext_registry_init(&fc->pkrg);
+    msgpack_packer_ext_registry_init(self, &fc->pkrg);
     // fc->ukrg is lazily initialized
 
     fc->has_symbol_ext_type = false;
@@ -124,7 +124,7 @@ static VALUE Factory_dup(VALUE self)
     cloned_fc->has_symbol_ext_type = fc->has_symbol_ext_type;
     cloned_fc->pkrg = fc->pkrg;
     msgpack_unpacker_ext_registry_borrow(fc->ukrg, &cloned_fc->ukrg);
-    msgpack_packer_ext_registry_dup(&fc->pkrg, &cloned_fc->pkrg);
+    msgpack_packer_ext_registry_dup(clone, &fc->pkrg, &cloned_fc->pkrg);
 
     return clone;
 }
@@ -139,7 +139,7 @@ static VALUE Factory_freeze(VALUE self) {
                 // If the factory is frozen, we can safely share the packer cache between
                 // all packers. So we eagerly create it now so it's available when #packer
                 // is called.
-                fc->pkrg.cache = rb_hash_new();
+                RB_OBJ_WRITE(self, &fc->pkrg.cache, rb_hash_new());
             }
         }
 
@@ -158,7 +158,7 @@ VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self)
 
     msgpack_packer_t* pk = MessagePack_Packer_get(packer);
     msgpack_packer_ext_registry_destroy(&pk->ext_registry);
-    msgpack_packer_ext_registry_dup(&fc->pkrg, &pk->ext_registry);
+    msgpack_packer_ext_registry_borrow(packer, &fc->pkrg, &pk->ext_registry);
     pk->has_bigint_ext_type = fc->has_bigint_ext_type;
     pk->has_symbol_ext_type = fc->has_symbol_ext_type;
 
@@ -187,7 +187,7 @@ static VALUE Factory_registered_types_internal(VALUE self)
     VALUE uk_mapping = rb_hash_new();
     if (fc->ukrg) {
         for(int i=0; i < 256; i++) {
-            if(fc->ukrg->array[i] != Qnil) {
+            if(!NIL_P(fc->ukrg->array[i])) {
                 rb_hash_aset(uk_mapping, INT2FIX(i - 128), fc->ukrg->array[i]);
             }
         }
@@ -200,73 +200,39 @@ static VALUE Factory_registered_types_internal(VALUE self)
     );
 }
 
-static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
+static VALUE Factory_register_type_internal(VALUE self, VALUE rb_ext_type, VALUE ext_module, VALUE options)
 {
     msgpack_factory_t *fc = Factory_get(self);
 
-    int ext_type;
-    int flags = 0;
-    VALUE ext_module;
-    VALUE options = Qnil;
-    VALUE packer_arg, unpacker_arg;
-    VALUE packer_proc, unpacker_proc;
+    Check_Type(rb_ext_type, T_FIXNUM);
 
-    if (OBJ_FROZEN(self)) {
-        rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Factory");
+    if(rb_type(ext_module) != T_MODULE && rb_type(ext_module) != T_CLASS) {
+        rb_raise(rb_eArgError, "expected Module/Class but found %s.", rb_obj_classname(ext_module));
     }
 
-    switch (argc) {
-    case 2:
-        /* register_type(0x7f, Time) */
-        packer_arg = ID2SYM(rb_intern("to_msgpack_ext"));
-        unpacker_arg = ID2SYM(rb_intern("from_msgpack_ext"));
-        break;
-    case 3:
-        /* register_type(0x7f, Time, packer: proc-like, unapcker: proc-like) */
-        options = argv[2];
-        if(rb_type(options) != T_HASH) {
-            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
-        }
-        packer_arg = rb_hash_aref(options, ID2SYM(rb_intern("packer")));
-        unpacker_arg = rb_hash_aref(options, ID2SYM(rb_intern("unpacker")));
-        break;
-    default:
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
-    }
+    int flags = 0;
 
-    if (options != Qnil) {
+    VALUE packer_proc = Qnil;
+    VALUE unpacker_proc = Qnil;
+    if(!NIL_P(options)) {
         Check_Type(options, T_HASH);
+        packer_proc = rb_hash_aref(options, ID2SYM(rb_intern("packer")));
+        unpacker_proc = rb_hash_aref(options, ID2SYM(rb_intern("unpacker")));
     }
 
-    ext_type = NUM2INT(argv[0]);
-    if(ext_type < -128 || ext_type > 127) {
-        rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
-    }
-
-    ext_module = argv[1];
-    if(rb_type(ext_module) != T_MODULE && rb_type(ext_module) != T_CLASS) {
-        rb_raise(rb_eArgError, "expected Module/Class but found %s.", rb_obj_classname(ext_module));
-    }
-
-    packer_proc = Qnil;
-    unpacker_proc = Qnil;
-
-    if(packer_arg != Qnil) {
-        packer_proc = rb_funcall(packer_arg, rb_intern("to_proc"), 0);
+    if (OBJ_FROZEN(self)) {
+        rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Factory");
     }
 
-    if(unpacker_arg != Qnil) {
-        if(rb_type(unpacker_arg) == T_SYMBOL || rb_type(unpacker_arg) == T_STRING) {
-            unpacker_proc = rb_obj_method(ext_module, unpacker_arg);
-        } else if (rb_respond_to(unpacker_arg, rb_intern("call"))) {
-            unpacker_proc = unpacker_arg;
-        } else {
-            unpacker_proc = rb_funcall(unpacker_arg, rb_intern("method"), 1, ID2SYM(rb_intern("call")));
-        }
+    int ext_type = NUM2INT(rb_ext_type);
+    if(ext_type < -128 || ext_type > 127) {
+        rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
     }
 
     if(ext_module == rb_cSymbol) {
-        fc->has_symbol_ext_type = true;
+        if(NIL_P(options) || RTEST(rb_hash_aref(options, ID2SYM(rb_intern("packer"))))) {
+            fc->has_symbol_ext_type = true;
+        }
         if(RTEST(options) && RTEST(rb_hash_aref(options, ID2SYM(rb_intern("optimized_symbols_parsing"))))) {
             fc->optimized_symbol_ext_type = true;
         }
@@ -286,8 +252,8 @@ static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
         }
     }
 
-    msgpack_packer_ext_registry_put(&fc->pkrg, ext_module, ext_type, flags, packer_proc, packer_arg);
-    msgpack_unpacker_ext_registry_put(&fc->ukrg, ext_module, ext_type, flags, unpacker_proc, unpacker_arg);
+    msgpack_packer_ext_registry_put(self, &fc->pkrg, ext_module, ext_type, flags, packer_proc);
+    msgpack_unpacker_ext_registry_put(self, &fc->ukrg, ext_module, ext_type, flags, unpacker_proc);
 
     return Qnil;
 }
@@ -306,5 +272,5 @@ void MessagePack_Factory_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Factory, "unpacker", MessagePack_Factory_unpacker, -1);
 
     rb_define_private_method(cMessagePack_Factory, "registered_types_internal", Factory_registered_types_internal, 0);
-    rb_define_method(cMessagePack_Factory, "register_type", Factory_register_type, -1);
+    rb_define_private_method(cMessagePack_Factory, "register_type_internal", Factory_register_type_internal, 3);
 }

data/ext/msgpack/packer.c

@@ -17,16 +17,11 @@
  */
 
 #include "packer.h"
+#include "buffer_class.h"
 
-static ID s_call;
-
-void msgpack_packer_static_init(void)
-{
-    s_call = rb_intern("call");
-}
-
-void msgpack_packer_static_destroy(void)
-{ }
+#if !defined(HAVE_RB_PROC_CALL_WITH_BLOCK)
+#define rb_proc_call_with_block(recv, argc, argv, block) rb_funcallv(recv, rb_intern("call"), argc, argv)
+#endif
 
 void msgpack_packer_init(msgpack_packer_t* pk)
 {
@@ -100,14 +95,13 @@ struct msgpack_call_proc_args_t;
 typedef struct msgpack_call_proc_args_t msgpack_call_proc_args_t;
 struct msgpack_call_proc_args_t {
     VALUE proc;
-    VALUE arg;
-    VALUE packer;
+    VALUE args[2];
 };
 
 VALUE msgpack_packer_try_calling_proc(VALUE value)
 {
     msgpack_call_proc_args_t *args = (msgpack_call_proc_args_t *)value;
-    return rb_funcall(args->proc, s_call, 2, args->arg, args->packer);
+    return rb_proc_call_with_block(args->proc, 2, args->args, Qnil);
 }
 
 bool msgpack_packer_try_write_with_ext_type_lookup(msgpack_packer_t* pk, VALUE v)
@@ -121,11 +115,13 @@ bool msgpack_packer_try_write_with_ext_type_lookup(msgpack_packer_t* pk, VALUE v
     }
 
     if(ext_flags & MSGPACK_EXT_RECURSIVE) {
+        VALUE held_buffer = MessagePack_Buffer_hold(&pk->buffer);
+
         msgpack_buffer_t parent_buffer = pk->buffer;
         msgpack_buffer_init(PACKER_BUFFER_(pk));
 
         int exception_occured = 0;
-        msgpack_call_proc_args_t args = { proc, v, pk->to_msgpack_arg };
+        msgpack_call_proc_args_t args = { proc, { v, pk->to_msgpack_arg } };
         rb_protect(msgpack_packer_try_calling_proc, (VALUE)&args, &exception_occured);
 
         if (exception_occured) {
@@ -139,8 +135,10 @@ bool msgpack_packer_try_write_with_ext_type_lookup(msgpack_packer_t* pk, VALUE v
             pk->buffer = parent_buffer;
             msgpack_packer_write_ext(pk, ext_type, payload);
         }
+
+        RB_GC_GUARD(held_buffer);
     } else {
-        VALUE payload = rb_funcall(proc, s_call, 1, v);
+        VALUE payload = rb_proc_call_with_block(proc, 1, &v, Qnil);
         StringValue(payload);
         msgpack_packer_write_ext(pk, ext_type, payload);
     }

data/ext/msgpack/packer.h

@@ -47,10 +47,6 @@ struct msgpack_packer_t {
 
 #define PACKER_BUFFER_(pk) (&(pk)->buffer)
 
-void msgpack_packer_static_init(void);
-
-void msgpack_packer_static_destroy(void);
-
 void msgpack_packer_init(msgpack_packer_t* pk);
 
 void msgpack_packer_destroy(msgpack_packer_t* pk);

data/ext/msgpack/packer_class.c

@@ -106,8 +106,8 @@ VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
 
     msgpack_packer_t *pk = MessagePack_Packer_get(self);
 
-    msgpack_packer_ext_registry_init(&pk->ext_registry);
-    pk->buffer_ref = Qnil;
+    msgpack_packer_ext_registry_init(self, &pk->ext_registry);
+    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
 
     MessagePack_Buffer_set_options(PACKER_BUFFER_(pk), io, options);
 
@@ -233,7 +233,12 @@ static VALUE Packer_write_extension(VALUE self, VALUE obj)
     msgpack_packer_t *pk = MessagePack_Packer_get(self);
     Check_Type(obj, T_STRUCT);
 
-    int ext_type = FIX2INT(RSTRUCT_GET(obj, 0));
+    VALUE rb_ext_type = RSTRUCT_GET(obj, 0);
+    if(!RB_TYPE_P(rb_ext_type, T_FIXNUM)) {
+        rb_raise(rb_eRangeError, "integer %s too big to convert to `signed char'", RSTRING_PTR(rb_String(rb_ext_type)));
+    }
+
+    int ext_type = FIX2INT(rb_ext_type);
     if(ext_type < -128 || ext_type > 127) {
         rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
     }
@@ -347,7 +352,7 @@ static VALUE Packer_registered_types_internal(VALUE self)
     return rb_hash_new();
 }
 
-static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
+static VALUE Packer_register_type_internal(VALUE self, VALUE rb_ext_type, VALUE ext_module, VALUE proc)
 {
     if (OBJ_FROZEN(self)) {
         rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Packer");
@@ -355,38 +360,12 @@ static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
 
     msgpack_packer_t *pk = MessagePack_Packer_get(self);
 
-    int ext_type;
-    VALUE ext_module;
-    VALUE proc;
-    VALUE arg;
-
-    switch (argc) {
-    case 2:
-        /* register_type(0x7f, Time) {|obj| block... } */
-        rb_need_block();
-        proc = rb_block_lambda();
-        arg = proc;
-        break;
-    case 3:
-        /* register_type(0x7f, Time, :to_msgpack_ext) */
-        arg = argv[2];
-        proc = rb_funcall(arg, rb_intern("to_proc"), 0);
-        break;
-    default:
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
-    }
-
-    ext_type = NUM2INT(argv[0]);
+    int ext_type = NUM2INT(rb_ext_type);
     if(ext_type < -128 || ext_type > 127) {
         rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
     }
 
-    ext_module = argv[1];
-    if(rb_type(ext_module) != T_MODULE && rb_type(ext_module) != T_CLASS) {
-        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, 0, proc, arg);
+    msgpack_packer_ext_registry_put(self, &pk->ext_registry, ext_module, ext_type, 0, proc);
 
     if (ext_module == rb_cSymbol) {
         pk->has_symbol_ext_type = true;
@@ -419,10 +398,6 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     s_write = rb_intern("write");
 
     sym_compatibility_mode = ID2SYM(rb_intern("compatibility_mode"));
-
-    msgpack_packer_static_init();
-    msgpack_packer_ext_registry_static_init();
-
     cMessagePack_Packer = rb_define_class_under(mMessagePack, "Packer", rb_cObject);
 
     rb_define_alloc_func(cMessagePack_Packer, MessagePack_Packer_alloc);
@@ -461,7 +436,7 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Packer, "to_a", Packer_to_a, 0);
 
     rb_define_private_method(cMessagePack_Packer, "registered_types_internal", Packer_registered_types_internal, 0);
-    rb_define_method(cMessagePack_Packer, "register_type", Packer_register_type, -1);
+    rb_define_method(cMessagePack_Packer, "register_type_internal", Packer_register_type_internal, 3);
 
     rb_define_method(cMessagePack_Packer, "full_pack", Packer_full_pack, 0);
 }

data/ext/msgpack/packer_ext_registry.c

@@ -18,20 +18,10 @@
 
 #include "packer_ext_registry.h"
 
-static ID s_call;
-
-void msgpack_packer_ext_registry_static_init(void)
-{
-    s_call = rb_intern("call");
-}
-
-void msgpack_packer_ext_registry_static_destroy(void)
-{ }
-
-void msgpack_packer_ext_registry_init(msgpack_packer_ext_registry_t* pkrg)
+void msgpack_packer_ext_registry_init(VALUE owner, msgpack_packer_ext_registry_t* pkrg)
 {
-    pkrg->hash = Qnil;
-    pkrg->cache = Qnil;
+    RB_OBJ_WRITE(owner, &pkrg->hash, Qnil);
+    RB_OBJ_WRITE(owner, &pkrg->cache, Qnil);
 }
 
 void msgpack_packer_ext_registry_mark(msgpack_packer_ext_registry_t* pkrg)
@@ -40,32 +30,45 @@ void msgpack_packer_ext_registry_mark(msgpack_packer_ext_registry_t* pkrg)
     rb_gc_mark(pkrg->cache);
 }
 
-void msgpack_packer_ext_registry_dup(msgpack_packer_ext_registry_t* src,
+void msgpack_packer_ext_registry_borrow(VALUE owner, msgpack_packer_ext_registry_t* src,
         msgpack_packer_ext_registry_t* dst)
 {
-    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;
+    if(RTEST(src->hash)) {
+        if(rb_obj_frozen_p(src->hash)) {
+            // If the type registry is frozen we can safely share it, and share the cache as well.
+            RB_OBJ_WRITE(owner, &dst->hash, src->hash);
+            RB_OBJ_WRITE(owner, &dst->cache, src->cache);
+        } else {
+            RB_OBJ_WRITE(owner, &dst->hash, rb_hash_dup(src->hash));
+            RB_OBJ_WRITE(owner, &dst->cache, NIL_P(src->cache) ? Qnil : rb_hash_dup(src->cache));
+        }
     } 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;
+        RB_OBJ_WRITE(owner, &dst->hash, Qnil);
+        RB_OBJ_WRITE(owner, &dst->cache, Qnil);
     }
 }
 
-VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
-        VALUE ext_module, int ext_type, int flags, VALUE proc, VALUE arg)
+void msgpack_packer_ext_registry_dup(VALUE owner, msgpack_packer_ext_registry_t* src,
+        msgpack_packer_ext_registry_t* dst)
 {
-    if (!RTEST(pkrg->hash)) {
-        pkrg->hash = rb_hash_new();
+    RB_OBJ_WRITE(owner, &dst->hash, NIL_P(src->hash) ? Qnil : rb_hash_dup(src->hash));
+    RB_OBJ_WRITE(owner, &dst->cache, NIL_P(src->cache) ? Qnil : rb_hash_dup(src->cache));
+}
+
+void msgpack_packer_ext_registry_put(VALUE owner, msgpack_packer_ext_registry_t* pkrg,
+        VALUE ext_module, int ext_type, int flags, VALUE proc)
+{
+    if(NIL_P(pkrg->hash)) {
+        RB_OBJ_WRITE(owner, &pkrg->hash, rb_hash_new());
     }
 
-    if (RTEST(pkrg->cache)) {
+    if(NIL_P(pkrg->cache)) {
+        RB_OBJ_WRITE(owner, &pkrg->cache, rb_hash_new());
+    } else {
         /* 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);
+    VALUE entry = rb_ary_new3(3, INT2FIX(ext_type), proc, INT2FIX(flags));
+    rb_hash_aset(pkrg->hash, ext_module, entry);
 }

data/ext/msgpack/packer_ext_registry.h

@@ -31,22 +31,21 @@ struct msgpack_packer_ext_registry_t {
     VALUE cache; // lookup cache for ext types inherited from a super class
 };
 
-void msgpack_packer_ext_registry_static_init(void);
-
-void msgpack_packer_ext_registry_static_destroy(void);
-
-void msgpack_packer_ext_registry_init(msgpack_packer_ext_registry_t* pkrg);
+void msgpack_packer_ext_registry_init(VALUE owner, msgpack_packer_ext_registry_t* pkrg);
 
 static inline void msgpack_packer_ext_registry_destroy(msgpack_packer_ext_registry_t* pkrg)
 { }
 
 void msgpack_packer_ext_registry_mark(msgpack_packer_ext_registry_t* pkrg);
 
-void msgpack_packer_ext_registry_dup(msgpack_packer_ext_registry_t* src,
+void msgpack_packer_ext_registry_borrow(VALUE owner, 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, int flags, VALUE proc, VALUE arg);
+void msgpack_packer_ext_registry_dup(VALUE owner, msgpack_packer_ext_registry_t* src,
+        msgpack_packer_ext_registry_t* dst);
+
+void msgpack_packer_ext_registry_put(VALUE owner, msgpack_packer_ext_registry_t* pkrg,
+        VALUE ext_module, int ext_type, int flags, VALUE proc);
 
 static int msgpack_packer_ext_find_superclass(VALUE key, VALUE value, VALUE arg)
 {
@@ -68,7 +67,7 @@ static inline VALUE msgpack_packer_ext_registry_fetch(msgpack_packer_ext_registr
     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));
+        *ext_flags_result = FIX2INT(rb_ary_entry(type, 2));
         return rb_ary_entry(type, 1);
     }
 
@@ -77,7 +76,7 @@ static inline VALUE msgpack_packer_ext_registry_fetch(msgpack_packer_ext_registr
         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));
+            *ext_flags_result = FIX2INT(rb_ary_entry(type_inht, 2));
             return rb_ary_entry(type_inht, 1);
         }
     }
@@ -129,12 +128,9 @@ 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));
+        *ext_flags_result = FIX2INT(rb_ary_entry(superclass_type, 2));
         return rb_ary_entry(superclass_type, 1);
     }
 

data/ext/msgpack/unpacker.c

@@ -19,17 +19,15 @@
 #include "unpacker.h"
 #include "rmem.h"
 #include "extension_value_class.h"
+#include <assert.h>
 
-_Static_assert(
-    sizeof(msgpack_unpacker_stack_entry_t) * MSGPACK_UNPACKER_STACK_CAPACITY <= MSGPACK_RMEM_PAGE_SIZE,
-    "msgpack_unpacker_stack_entry_t is too big to fit MSGPACK_UNPACKER_STACK_CAPACITY in MSGPACK_RMEM_PAGE_SIZE"
-);
+#if !defined(HAVE_RB_PROC_CALL_WITH_BLOCK)
+#define rb_proc_call_with_block(recv, argc, argv, block) rb_funcallv(recv, rb_intern("call"), argc, argv)
+#endif
 
 static int RAW_TYPE_STRING = 256;
 static int RAW_TYPE_BINARY = 257;
 
-static ID s_call;
-
 static msgpack_rmem_t s_stack_rmem;
 
 #if !defined(HAVE_RB_HASH_NEW_CAPA)
@@ -41,9 +39,9 @@ static inline VALUE rb_hash_new_capa(long capa)
 
 void msgpack_unpacker_static_init(void)
 {
-    msgpack_rmem_init(&s_stack_rmem);
+    assert(sizeof(msgpack_unpacker_stack_entry_t) * MSGPACK_UNPACKER_STACK_CAPACITY <= MSGPACK_RMEM_PAGE_SIZE);
 
-    s_call = rb_intern("call");
+    msgpack_rmem_init(&s_stack_rmem);
 }
 
 void msgpack_unpacker_static_destroy(void)
@@ -180,7 +178,8 @@ static inline int object_complete_ext(msgpack_unpacker_t* uk, int ext_type, VALU
 
     if(proc != Qnil) {
         VALUE obj;
-        obj = rb_funcall(proc, s_call, 1, str == Qnil ? rb_str_buf_new(0) : str);
+        VALUE arg = (str == Qnil ? rb_str_buf_new(0) : str);
+        obj = rb_proc_call_with_block(proc, 1, &arg, Qnil);
         return object_complete(uk, obj);
     }
 
@@ -310,7 +309,7 @@ static inline int read_raw_body_begin(msgpack_unpacker_t* uk, int raw_type)
             child_stack->parent = uk->stack;
             uk->stack = child_stack;
 
-            obj = rb_funcall(proc, s_call, 1, uk->self);
+            obj = rb_proc_call_with_block(proc, 1, &uk->self, Qnil);
 
             uk->stack = child_stack->parent;
             _msgpack_unpacker_free_stack(child_stack);

data/ext/msgpack/unpacker_class.c

@@ -346,43 +346,19 @@ static VALUE Unpacker_registered_types_internal(VALUE self)
     return mapping;
 }
 
-static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
+static VALUE Unpacker_register_type_internal(VALUE self, VALUE rb_ext_type, VALUE ext_module, VALUE proc)
 {
     if (OBJ_FROZEN(self)) {
         rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Unpacker");
     }
 
-    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
-
-    int ext_type;
-    VALUE proc;
-    VALUE arg;
-    VALUE ext_module;
-
-    switch (argc) {
-    case 1:
-        /* register_type(0x7f) {|data| block... } */
-        rb_need_block();
-        proc = rb_block_lambda();
-        arg = proc;
-        ext_module = Qnil;
-        break;
-    case 3:
-        /* register_type(0x7f, Time, :from_msgpack_ext) */
-        ext_module = argv[1];
-        arg = argv[2];
-        proc = rb_obj_method(ext_module, arg);
-        break;
-    default:
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 3)", argc);
-    }
-
-    ext_type = NUM2INT(argv[0]);
+    int ext_type = NUM2INT(rb_ext_type);
     if(ext_type < -128 || ext_type > 127) {
         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, 0, proc, arg);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
+    msgpack_unpacker_ext_registry_put(self, &uk->ext_registry, ext_module, ext_type, 0, proc);
 
     return Qnil;
 }
@@ -415,7 +391,6 @@ VALUE MessagePack_Unpacker_new(int argc, VALUE* argv)
 void MessagePack_Unpacker_module_init(VALUE mMessagePack)
 {
     msgpack_unpacker_static_init();
-    msgpack_unpacker_ext_registry_static_init();
 
     mTypeError = rb_define_module_under(mMessagePack, "TypeError");
 
@@ -456,7 +431,7 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Unpacker, "reset", Unpacker_reset, 0);
 
     rb_define_private_method(cMessagePack_Unpacker, "registered_types_internal", Unpacker_registered_types_internal, 0);
-    rb_define_method(cMessagePack_Unpacker, "register_type", Unpacker_register_type, -1);
+    rb_define_private_method(cMessagePack_Unpacker, "register_type_internal", Unpacker_register_type_internal, 3);
 
     rb_define_method(cMessagePack_Unpacker, "full_unpack", Unpacker_full_unpack, 0);
 }

data/ext/msgpack/unpacker_ext_registry.c

@@ -18,19 +18,6 @@
 
 #include "unpacker_ext_registry.h"
 
-static ID s_call;
-static ID s_dup;
-
-void msgpack_unpacker_ext_registry_static_init(void)
-{
-    s_call = rb_intern("call");
-    s_dup = rb_intern("dup");
-}
-
-
-void msgpack_unpacker_ext_registry_static_destroy(void)
-{ }
-
 void msgpack_unpacker_ext_registry_mark(msgpack_unpacker_ext_registry_t* ukrg)
 {
     if (ukrg) {
@@ -76,11 +63,12 @@ void msgpack_unpacker_ext_registry_release(msgpack_unpacker_ext_registry_t* ukrg
     }
 }
 
-void msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t** ukrg,
-        VALUE ext_module, int ext_type, int flags, VALUE proc, VALUE arg)
+void msgpack_unpacker_ext_registry_put(VALUE owner, msgpack_unpacker_ext_registry_t** ukrg,
+        VALUE ext_module, int ext_type, int flags, VALUE proc)
 {
     msgpack_unpacker_ext_registry_t* ext_registry = msgpack_unpacker_ext_registry_cow(*ukrg);
 
-    ext_registry->array[ext_type + 128] = rb_ary_new3(4, ext_module, proc, arg, INT2FIX(flags));
+    VALUE entry = rb_ary_new3(3, ext_module, proc, INT2FIX(flags));
+    RB_OBJ_WRITE(owner, &ext_registry->array[ext_type + 128], entry);
     *ukrg = ext_registry;
 }

data/ext/msgpack/unpacker_ext_registry.h

@@ -31,10 +31,6 @@ struct msgpack_unpacker_ext_registry_t {
     VALUE array[256];
 };
 
-void msgpack_unpacker_ext_registry_static_init(void);
-
-void msgpack_unpacker_ext_registry_static_destroy(void);
-
 void msgpack_unpacker_ext_registry_release(msgpack_unpacker_ext_registry_t* ukrg);
 
 static inline void msgpack_unpacker_ext_registry_borrow(msgpack_unpacker_ext_registry_t* src, msgpack_unpacker_ext_registry_t** dst)
@@ -47,8 +43,8 @@ static inline void msgpack_unpacker_ext_registry_borrow(msgpack_unpacker_ext_reg
 
 void msgpack_unpacker_ext_registry_mark(msgpack_unpacker_ext_registry_t* ukrg);
 
-void msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t** ukrg,
-        VALUE ext_module, int ext_type, int flags, VALUE proc, VALUE arg);
+void msgpack_unpacker_ext_registry_put(VALUE owner, msgpack_unpacker_ext_registry_t** ukrg,
+        VALUE ext_module, int ext_type, int flags, VALUE proc);
 
 static inline VALUE msgpack_unpacker_ext_registry_lookup(msgpack_unpacker_ext_registry_t* ukrg,
         int ext_type, int* ext_flags_result)
@@ -56,7 +52,7 @@ static inline VALUE msgpack_unpacker_ext_registry_lookup(msgpack_unpacker_ext_re
     if (ukrg) {
         VALUE entry = ukrg->array[ext_type + 128];
         if (entry != Qnil) {
-            *ext_flags_result = FIX2INT(rb_ary_entry(entry, 3));
+            *ext_flags_result = FIX2INT(rb_ary_entry(entry, 2));
             return rb_ary_entry(entry, 1);
         }
     }