msgpack 1.4.2 → 1.7.3

data/ext/msgpack/packer_class.c

@@ -28,18 +28,14 @@ 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;
 
-#define PACKER(from, name) \
-    msgpack_packer_t* name; \
-    Data_Get_Struct(from, msgpack_packer_t, name); \
-    if(name == NULL) { \
-        rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
-    }
-
-static void Packer_free(msgpack_packer_t* pk)
+static void Packer_free(void *ptr)
 {
+    msgpack_packer_t* pk = ptr;
     if(pk == NULL) {
         return;
     }
@@ -48,54 +44,69 @@ static void Packer_free(msgpack_packer_t* pk)
     xfree(pk);
 }
 
-static void Packer_mark(msgpack_packer_t* pk)
+static void Packer_mark(void *ptr)
 {
+    msgpack_packer_t* pk = ptr;
+    msgpack_buffer_mark(pk);
     msgpack_packer_mark(pk);
     msgpack_packer_ext_registry_mark(&pk->ext_registry);
 }
 
-VALUE MessagePack_Packer_alloc(VALUE klass)
+static size_t Packer_memsize(const void *ptr)
 {
-    msgpack_packer_t* pk = ZALLOC_N(msgpack_packer_t, 1);
-    msgpack_packer_init(pk);
+    const msgpack_packer_t* pk = ptr;
+    return sizeof(msgpack_packer_t) + msgpack_buffer_memsize(&pk->buffer);
+}
 
-    VALUE self = Data_Wrap_Struct(klass, Packer_mark, Packer_free, pk);
+const rb_data_type_t packer_data_type = {
+    .wrap_struct_name = "msgpack:packer",
+    .function = {
+        .dmark = Packer_mark,
+        .dfree = Packer_free,
+        .dsize = Packer_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
 
-    msgpack_packer_set_to_msgpack_method(pk, s_to_msgpack, self);
 
+VALUE MessagePack_Packer_alloc(VALUE klass)
+{
+    msgpack_packer_t* pk;
+    VALUE self = TypedData_Make_Struct(klass, msgpack_packer_t, &packer_data_type, pk);
+    msgpack_packer_init(pk);
+    msgpack_packer_set_to_msgpack_method(pk, s_to_msgpack, self);
     return self;
 }
 
 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);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
 
-    msgpack_packer_ext_registry_init(&pk->ext_registry);
+    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);
@@ -103,7 +114,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));
     }
 
@@ -112,54 +123,57 @@ VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
 
 static VALUE Packer_compatibility_mode_p(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     return pk->compatibility_mode ? Qtrue : Qfalse;
 }
 
 static VALUE Packer_buffer(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
+    if (!RTEST(pk->buffer_ref)) {
+        pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
+    }
     return pk->buffer_ref;
 }
 
 static VALUE Packer_write(VALUE self, VALUE v)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_value(pk, v);
     return self;
 }
 
 static VALUE Packer_write_nil(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_nil(pk);
     return self;
 }
 
 static VALUE Packer_write_true(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_true(pk);
     return self;
 }
 
 static VALUE Packer_write_false(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_false(pk);
     return self;
 }
 
 static VALUE Packer_write_float(VALUE self, VALUE obj)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_float_value(pk, obj);
     return self;
 }
 
 static VALUE Packer_write_string(VALUE self, VALUE obj)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     Check_Type(obj, T_STRING);
     msgpack_packer_write_string_value(pk, obj);
     return self;
@@ -167,7 +181,7 @@ static VALUE Packer_write_string(VALUE self, VALUE obj)
 
 static VALUE Packer_write_bin(VALUE self, VALUE obj)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     Check_Type(obj, T_STRING);
 
     VALUE enc = rb_enc_from_encoding(rb_ascii8bit_encoding());
@@ -179,7 +193,7 @@ static VALUE Packer_write_bin(VALUE self, VALUE obj)
 
 static VALUE Packer_write_array(VALUE self, VALUE obj)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     Check_Type(obj, T_ARRAY);
     msgpack_packer_write_array_value(pk, obj);
     return self;
@@ -187,7 +201,7 @@ static VALUE Packer_write_array(VALUE self, VALUE obj)
 
 static VALUE Packer_write_hash(VALUE self, VALUE obj)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     Check_Type(obj, T_HASH);
     msgpack_packer_write_hash_value(pk, obj);
     return self;
@@ -195,7 +209,7 @@ static VALUE Packer_write_hash(VALUE self, VALUE obj)
 
 static VALUE Packer_write_symbol(VALUE self, VALUE obj)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     Check_Type(obj, T_SYMBOL);
     msgpack_packer_write_symbol_value(pk, obj);
     return self;
@@ -203,7 +217,7 @@ static VALUE Packer_write_symbol(VALUE self, VALUE obj)
 
 static VALUE Packer_write_int(VALUE self, VALUE obj)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
 
     if (FIXNUM_P(obj)) {
         msgpack_packer_write_fixnum_value(pk, obj);
@@ -216,10 +230,15 @@ static VALUE Packer_write_int(VALUE self, VALUE obj)
 
 static VALUE Packer_write_extension(VALUE self, VALUE obj)
 {
-    PACKER(self, pk);
+    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);
     }
@@ -232,21 +251,21 @@ static VALUE Packer_write_extension(VALUE self, VALUE obj)
 
 static VALUE Packer_write_array_header(VALUE self, VALUE n)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_array_header(pk, NUM2UINT(n));
     return self;
 }
 
 static VALUE Packer_write_map_header(VALUE self, VALUE n)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_map_header(pk, NUM2UINT(n));
     return self;
 }
 
 static VALUE Packer_write_bin_header(VALUE self, VALUE n)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_bin_header(pk, NUM2UINT(n));
     return self;
 }
@@ -257,14 +276,14 @@ static VALUE Packer_write_float32(VALUE self, VALUE numeric)
       rb_raise(rb_eArgError, "Expected numeric");
     }
 
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_packer_write_float(pk, (float)rb_num2dbl(numeric));
     return self;
 }
 
 static VALUE Packer_write_ext(VALUE self, VALUE type, VALUE data)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     int ext_type = NUM2INT(type);
     if(ext_type < -128 || ext_type > 127) {
         rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
@@ -276,28 +295,28 @@ static VALUE Packer_write_ext(VALUE self, VALUE type, VALUE data)
 
 static VALUE Packer_flush(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_buffer_flush(PACKER_BUFFER_(pk));
     return self;
 }
 
-static VALUE Packer_clear(VALUE self)
+static VALUE Packer_reset(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     msgpack_buffer_clear(PACKER_BUFFER_(pk));
     return Qnil;
 }
 
 static VALUE Packer_size(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     size_t size = msgpack_buffer_all_readable_size(PACKER_BUFFER_(pk));
     return SIZET2NUM(size);
 }
 
 static VALUE Packer_empty_p(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     if(msgpack_buffer_top_readable_size(PACKER_BUFFER_(pk)) == 0) {
         return Qtrue;
     } else {
@@ -307,86 +326,46 @@ static VALUE Packer_empty_p(VALUE self)
 
 static VALUE Packer_to_str(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     return msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
 }
 
 static VALUE Packer_to_a(VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     return msgpack_buffer_all_as_string_array(PACKER_BUFFER_(pk));
 }
 
 static VALUE Packer_write_to(VALUE self, VALUE io)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
     size_t sz = msgpack_buffer_flush_to_io(PACKER_BUFFER_(pk), io, s_write, true);
-    return ULONG2NUM(sz);
+    return SIZET2NUM(sz);
 }
 
-//static VALUE Packer_append(VALUE self, VALUE string_or_buffer)
-//{
-//    PACKER(self, pk);
-//
-//    // TODO if string_or_buffer is a Buffer
-//    VALUE string = string_or_buffer;
-//
-//    msgpack_buffer_append_string(PACKER_BUFFER_(pk), string);
-//
-//    return self;
-//}
-
 static VALUE Packer_registered_types_internal(VALUE self)
 {
-    PACKER(self, pk);
-#ifdef HAVE_RB_HASH_DUP
-    return rb_hash_dup(pk->ext_registry.hash);
-#else
-    return rb_funcall(pk->ext_registry.hash, rb_intern("dup"), 0);
-#endif
-}
-
-static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
-{
-    PACKER(self, pk);
-
-    int ext_type;
-    VALUE ext_module;
-    VALUE proc;
-    VALUE arg;
-
-    switch (argc) {
-    case 2:
-        /* register_type(0x7f, Time) {|obj| block... } */
-        rb_need_block();
-#ifdef HAVE_RB_BLOCK_LAMBDA
-        proc = rb_block_lambda();
-#else
-        /* MRI 1.8 */
-        proc = rb_block_proc();
-#endif
-        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);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
+    if (RTEST(pk->ext_registry.hash)) {
+        return rb_hash_dup(pk->ext_registry.hash);
     }
+    return rb_hash_new();
+}
 
-    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);
+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");
     }
 
-    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_t *pk = MessagePack_Packer_get(self);
+
+    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_packer_ext_registry_put(&pk->ext_registry, ext_module, ext_type, 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;
@@ -399,7 +378,7 @@ VALUE Packer_full_pack(VALUE self)
 {
     VALUE retval;
 
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
 
     if(msgpack_buffer_has_io(PACKER_BUFFER_(pk))) {
         msgpack_buffer_flush(PACKER_BUFFER_(pk));
@@ -418,9 +397,7 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     s_to_msgpack = rb_intern("to_msgpack");
     s_write = rb_intern("write");
 
-    msgpack_packer_static_init();
-    msgpack_packer_ext_registry_static_init();
-
+    sym_compatibility_mode = ID2SYM(rb_intern("compatibility_mode"));
     cMessagePack_Packer = rb_define_class_under(mMessagePack, "Packer", rb_cObject);
 
     rb_define_alloc_func(cMessagePack_Packer, MessagePack_Packer_alloc);
@@ -449,22 +426,17 @@ 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);
     rb_define_method(cMessagePack_Packer, "to_str", Packer_to_str, 0);
     rb_define_alias(cMessagePack_Packer, "to_s", "to_str");
     rb_define_method(cMessagePack_Packer, "to_a", Packer_to_a, 0);
-    //rb_define_method(cMessagePack_Packer, "append", Packer_append, 1);
-    //rb_define_alias(cMessagePack_Packer, "<<", "append");
 
     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);
-
-    //s_packer_value = MessagePack_Packer_alloc(cMessagePack_Packer);
-    //rb_gc_register_address(&s_packer_value);
-    //Data_Get_Struct(s_packer_value, msgpack_packer_t, s_packer);
+    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_class.h

@@ -22,6 +22,17 @@
 
 extern VALUE cMessagePack_Packer;
 
+extern const rb_data_type_t packer_data_type;
+
+static inline msgpack_packer_t *MessagePack_Packer_get(VALUE object) {
+    msgpack_packer_t *packer;
+    TypedData_Get_Struct(object, msgpack_packer_t, &packer_data_type, packer);
+    if (!packer) {
+        rb_raise(rb_eArgError, "Uninitialized Packer object");
+    }
+    return packer;
+}
+
 void MessagePack_Packer_module_init(VALUE mMessagePack);
 
 VALUE MessagePack_Packer_alloc(VALUE klass);

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()
-{
-    s_call = rb_intern("call");
-}
-
-void msgpack_packer_ext_registry_static_destroy()
-{ }
-
-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 = rb_hash_new();
-    pkrg->cache = rb_hash_new();
+    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,40 +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)
 {
-#ifdef HAVE_RB_HASH_DUP
-    dst->hash = rb_hash_dup(src->hash);
-    dst->cache = rb_hash_dup(src->cache);
-#else
-    dst->hash = rb_funcall(src->hash, rb_intern("dup"), 0);
-    dst->cache = rb_funcall(src->cache, rb_intern("dup"), 0);
-#endif
+    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 {
+        RB_OBJ_WRITE(owner, &dst->hash, Qnil);
+        RB_OBJ_WRITE(owner, &dst->cache, Qnil);
+    }
 }
 
-#ifndef HAVE_RB_HASH_CLEAR
-
-static int
-__rb_hash_clear_clear_i(key, value, dummy)
-    VALUE key, value, dummy;
+void msgpack_packer_ext_registry_dup(VALUE owner, msgpack_packer_ext_registry_t* src,
+        msgpack_packer_ext_registry_t* dst)
 {
-    return ST_DELETE;
+    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));
 }
 
-#endif
-
-VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
-        VALUE ext_module, int ext_type, VALUE proc, VALUE arg)
+void msgpack_packer_ext_registry_put(VALUE owner, msgpack_packer_ext_registry_t* pkrg,
+        VALUE ext_module, int ext_type, int flags, VALUE proc)
 {
-    VALUE e = rb_ary_new3(3, INT2FIX(ext_type), proc, arg);
-    /* clear lookup cache not to miss added type */
-#ifdef HAVE_RB_HASH_CLEAR
-    rb_hash_clear(pkrg->cache);
-#else
-    if(FIX2INT(rb_funcall(pkrg->cache, rb_intern("size"), 0)) > 0) {
-        rb_hash_foreach(pkrg->cache, __rb_hash_clear_clear_i, 0);
+    if(NIL_P(pkrg->hash)) {
+        RB_OBJ_WRITE(owner, &pkrg->hash, rb_hash_new());
     }
-#endif
-    return rb_hash_aset(pkrg->hash, ext_module, e);
+
+    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);
+    }
+
+    VALUE entry = rb_ary_new3(3, INT2FIX(ext_type), proc, INT2FIX(flags));
+    rb_hash_aset(pkrg->hash, ext_module, entry);
 }