msgpack 1.7.1 → 1.8.0

data/ext/msgpack/extconf.rb

@@ -1,20 +1,21 @@
 require 'mkmf'
 
-have_header("ruby/st.h")
-have_header("st.h")
 have_func("rb_enc_interned_str", "ruby.h") # Ruby 3.0+
 have_func("rb_hash_new_capa", "ruby.h") # Ruby 3.2+
+have_func("rb_proc_call_with_block", "ruby.h") # CRuby (TruffleRuby doesn't have it)
+have_func("rb_gc_mark_locations", "ruby.h") # Missing on TruffleRuby
 
 append_cflags([
   "-fvisibility=hidden",
   "-I..",
   "-Wall",
-  "-O3",
   "-std=gnu99"
 ])
-append_cflags(RbConfig::CONFIG["debugflags"]) if RbConfig::CONFIG["debugflags"]
 
-append_cflags("-DRUBY_DEBUG=1") if ENV["MSGPACK_DEBUG"]
+if ENV["MSGPACK_DEBUG"]
+  append_cflags(RbConfig::CONFIG["debugflags"]) if RbConfig::CONFIG["debugflags"]
+  append_cflags("-DRUBY_DEBUG=1")
+end
 
 if RUBY_VERSION.start_with?('3.0.') && RUBY_VERSION <= '3.0.5'
   # https://bugs.ruby-lang.org/issues/18772

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,72 +200,35 @@ 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, unpacker: proc-like) */
-        options = argv[2];
-        if(rb_type(options) != T_HASH) {
-            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
-        }
+    int flags = 0;
 
-        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);
+    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")));
     }
 
-    if (options != Qnil) {
-        Check_Type(options, T_HASH);
+    if (OBJ_FROZEN(self)) {
+        rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Factory");
     }
 
-    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));
-    }
-
-    packer_proc = Qnil;
-    unpacker_proc = Qnil;
-
-    if(packer_arg != Qnil) {
-        packer_proc = rb_funcall(packer_arg, rb_intern("to_proc"), 0);
-    }
-
-    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")));
-        }
-    }
-
     if(ext_module == rb_cSymbol) {
         if(NIL_P(options) || RTEST(rb_hash_aref(options, ID2SYM(rb_intern("packer"))))) {
             fc->has_symbol_ext_type = true;
@@ -289,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;
 }
@@ -309,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

@@ -25,21 +25,26 @@
 #define MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY (1024)
 #endif
 
+#ifndef UNREACHABLE_RETURN
+// Ruby 2.5
+#define UNREACHABLE_RETURN() return
+#endif
+
 struct msgpack_packer_t;
 typedef struct msgpack_packer_t msgpack_packer_t;
 
 struct msgpack_packer_t {
     msgpack_buffer_t buffer;
 
-    bool compatibility_mode;
-    bool has_bigint_ext_type;
-    bool has_symbol_ext_type;
-
     ID to_msgpack_method;
     VALUE to_msgpack_arg;
 
     VALUE buffer_ref;
 
+    bool compatibility_mode;
+    bool has_bigint_ext_type;
+    bool has_symbol_ext_type;
+
     /* options */
     bool comaptibility_mode;
     msgpack_packer_ext_registry_t ext_registry;
@@ -47,10 +52,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);
@@ -408,27 +409,33 @@ static inline bool msgpack_packer_is_utf8_compat_string(VALUE v, int encindex)
 {
     return encindex == msgpack_rb_encindex_utf8
         || encindex == msgpack_rb_encindex_usascii
-        || (rb_enc_asciicompat(rb_enc_from_index(encindex)) && ENC_CODERANGE_ASCIIONLY(v));
+        || ENC_CODERANGE_ASCIIONLY(v);
 }
 
 static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE v)
 {
-    /* actual return type of RSTRING_LEN is long */
-    unsigned long len = RSTRING_LEN(v);
-    if(len > 0xffffffffUL) {
-        // TODO rb_eArgError?
-        rb_raise(rb_eArgError, "size of string is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
+    long len = RSTRING_LEN(v);
+
+    if(RB_UNLIKELY(len > 0xffffffffL)) {
+        rb_raise(rb_eArgError, "size of string is too long to pack: %lu bytes should be <= %ld", len, 0xffffffffL);
+        UNREACHABLE_RETURN();
     }
 
-    int encindex = ENCODING_GET(v);
-    if(msgpack_packer_is_binary(v, encindex) && !pk->compatibility_mode) {
+    if (RB_UNLIKELY(pk->compatibility_mode)) {
+        msgpack_packer_write_raw_header(pk, (unsigned int)len);
+        msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+        return;
+    }
+
+    int encindex = ENCODING_GET_INLINED(v);
+    if(msgpack_packer_is_binary(v, encindex)) {
         /* write ASCII-8BIT string using Binary type */
         msgpack_packer_write_bin_header(pk, (unsigned int)len);
         msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
     } else {
         /* write UTF-8, US-ASCII, or 7bit-safe ascii-compatible string using String type directly */
         /* in compatibility mode, packer packs String values as is */
-        if(!pk->compatibility_mode && !msgpack_packer_is_utf8_compat_string(v, encindex)) {
+        if(RB_UNLIKELY(!msgpack_packer_is_utf8_compat_string(v, encindex))) {
             /* transcode other strings to UTF-8 and write using String type */
             VALUE enc = rb_enc_from_encoding(rb_utf8_encoding()); /* rb_enc_from_encoding_index is not extern */
             v = rb_str_encode(v, enc, 0, Qnil);
@@ -457,11 +464,7 @@ static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE
 
 static inline void msgpack_packer_write_fixnum_value(msgpack_packer_t* pk, VALUE v)
 {
-#ifdef JRUBY
-    msgpack_packer_write_long(pk, FIXNUM_P(v) ? FIX2LONG(v) : rb_num2ll(v));
-#else
     msgpack_packer_write_long(pk, FIX2LONG(v));
-#endif
 }
 
 static inline void msgpack_packer_write_bignum_value(msgpack_packer_t* pk, VALUE v)

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);
 
@@ -352,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");
@@ -360,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;
@@ -424,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);
@@ -466,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);
     }