msgpack 1.5.6 → 1.8.0

data/ext/msgpack/packer_class.c

@@ -33,15 +33,9 @@ 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;
     }
@@ -50,21 +44,37 @@ 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;
 }
 
@@ -94,9 +104,9 @@ VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
         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);
@@ -113,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;
@@ -168,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());
@@ -180,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;
@@ -188,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;
@@ -196,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;
@@ -204,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);
@@ -217,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);
     }
@@ -233,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;
 }
@@ -258,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);
@@ -277,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_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 {
@@ -308,80 +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 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);
+    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);
-
-    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);
+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_type = NUM2INT(argv[0]);
+    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);
     }
 
-    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;
@@ -394,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));
@@ -414,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);
@@ -454,15 +434,9 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     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 = 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 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);
 
 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/rbinit.c

@@ -22,7 +22,7 @@
 #include "factory_class.h"
 #include "extension_value_class.h"
 
-void Init_msgpack(void)
+RUBY_FUNC_EXPORTED void Init_msgpack(void)
 {
     VALUE mMessagePack = rb_define_module("MessagePack");
 

data/ext/msgpack/rmem.c

@@ -65,11 +65,10 @@ void* _msgpack_rmem_alloc2(msgpack_rmem_t* pm)
     /* allocate new chunk */
     c = pm->array_last++;
 
-    /* move to head */
-    msgpack_rmem_chunk_t tmp = pm->head;
-    pm->head = *c;
-    *c = tmp;
+    /* move head to array */
+    *c = pm->head;
 
+    pm->head.pages = NULL; /* make sure we don't point to another chunk's pages in case xmalloc triggers GC */
     pm->head.mask = 0xffffffff & (~1);  /* "& (~1)" means first chunk is already allocated */
     pm->head.pages = xmalloc(MSGPACK_RMEM_PAGE_SIZE * 32);
 

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)