msgpack 1.4.2 → 1.6.0

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,52 +44,66 @@ 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_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);
     pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
@@ -103,7 +113,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 +122,54 @@ 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);
     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 +177,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 +189,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 +197,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 +205,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 +213,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,7 +226,7 @@ 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));
@@ -232,21 +242,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 +267,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 +286,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,26 +317,26 @@ 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);
+//    msgpack_packer_t *pk = MessagePack_Packer_get(self);
 //
 //    // TODO if string_or_buffer is a Buffer
 //    VALUE string = string_or_buffer;
@@ -338,17 +348,16 @@ static VALUE Packer_write_to(VALUE self, VALUE io)
 
 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
+    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();
 }
 
 static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
 {
-    PACKER(self, pk);
+    msgpack_packer_t *pk = MessagePack_Packer_get(self);
 
     int ext_type;
     VALUE ext_module;
@@ -359,12 +368,7 @@ static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
     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:
@@ -386,7 +390,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;
@@ -399,7 +403,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,6 +422,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();
 
@@ -449,7 +455,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_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

@@ -20,18 +20,18 @@
 
 static ID s_call;
 
-void msgpack_packer_ext_registry_static_init()
+void msgpack_packer_ext_registry_static_init(void)
 {
     s_call = rb_intern("call");
 }
 
-void msgpack_packer_ext_registry_static_destroy()
+void msgpack_packer_ext_registry_static_destroy(void)
 { }
 
 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,37 +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)
 {
-#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
-}
-
-#ifndef HAVE_RB_HASH_CLEAR
-
-static int
-__rb_hash_clear_clear_i(key, value, dummy)
-    VALUE key, value, dummy;
-{
-    return ST_DELETE;
+    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;
+    }
 }
 
-#endif
-
 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 */
-#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 (!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);
     }
-#endif
-    return rb_hash_aset(pkrg->hash, ext_module, e);
+
+    // 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;
 
@@ -29,9 +31,9 @@ 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 msgpack_packer_ext_registry_static_init(void);
 
-void msgpack_packer_ext_registry_static_destroy();
+void msgpack_packer_ext_registry_static_destroy(void);
 
 void msgpack_packer_ext_registry_init(msgpack_packer_ext_registry_t* pkrg);
 
@@ -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/sysdep.h

@@ -35,8 +35,11 @@
 #    define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x))
 #  else
 #    define _msgpack_be16(x) ( \
-        ((((uint16_t)x) <<  8) ) | \
-        ((((uint16_t)x) >>  8) ) )
+        ( \
+          ((((uint16_t)x) <<  8) ) | \
+          ((((uint16_t)x) >>  8) ) \
+        ) \
+          & 0x0000FFFF )
 #  endif
 #else
 #  define _msgpack_be16(x) ntohs(x)