msgpack 1.5.6 → 1.6.1

data/ext/msgpack/factory_class.c

@@ -37,15 +37,10 @@ struct msgpack_factory_t {
     int symbol_ext_type;
 };
 
-#define FACTORY(from, name) \
-    msgpack_factory_t *name = NULL; \
-    Data_Get_Struct(from, msgpack_factory_t, name); \
-    if(name == NULL) { \
-        rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
-    }
-
-static void Factory_free(msgpack_factory_t* fc)
+static void Factory_free(void *ptr)
 {
+    msgpack_factory_t *fc = ptr;
+
     if(fc == NULL) {
         return;
     }
@@ -54,23 +49,54 @@ static void Factory_free(msgpack_factory_t* fc)
     xfree(fc);
 }
 
-void Factory_mark(msgpack_factory_t* fc)
+void Factory_mark(void *ptr)
 {
+    msgpack_factory_t *fc = ptr;
     msgpack_packer_ext_registry_mark(&fc->pkrg);
     msgpack_unpacker_ext_registry_mark(fc->ukrg);
 }
 
-static VALUE Factory_alloc(VALUE klass)
+static size_t Factory_memsize(const void *ptr)
 {
-    msgpack_factory_t* fc = ZALLOC_N(msgpack_factory_t, 1);
+    const msgpack_factory_t *fc = ptr;
+    size_t total_size = sizeof(msgpack_factory_t);
 
-    VALUE self = Data_Wrap_Struct(klass, Factory_mark, Factory_free, fc);
-    return self;
+    if (fc->ukrg) {
+        total_size += sizeof(msgpack_unpacker_ext_registry_t) / (fc->ukrg->borrow_count + 1);
+    }
+
+    return total_size;
+}
+
+static const rb_data_type_t factory_data_type = {
+    .wrap_struct_name = "msgpack:factory",
+    .function = {
+        .dmark = Factory_mark,
+        .dfree = Factory_free,
+        .dsize = Factory_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static inline msgpack_factory_t *Factory_get(VALUE object)
+{
+    msgpack_factory_t *factory;
+    TypedData_Get_Struct(object, msgpack_factory_t, &factory_data_type, factory);
+    if (!factory) {
+        rb_raise(rb_eArgError, "Uninitialized Factory object");
+    }
+    return factory;
+}
+
+static VALUE Factory_alloc(VALUE klass)
+{
+    msgpack_factory_t *fc;
+    return TypedData_Make_Struct(klass, msgpack_factory_t, &factory_data_type, fc);
 }
 
 static VALUE Factory_initialize(int argc, VALUE* argv, VALUE self)
 {
-    FACTORY(self, fc);
+    msgpack_factory_t *fc = Factory_get(self);
 
     msgpack_packer_ext_registry_init(&fc->pkrg);
     // fc->ukrg is lazily initialized
@@ -92,8 +118,8 @@ static VALUE Factory_dup(VALUE self)
 {
     VALUE clone = Factory_alloc(rb_obj_class(self));
 
-    FACTORY(self, fc);
-    FACTORY(clone, cloned_fc);
+    msgpack_factory_t *fc = Factory_get(self);
+    msgpack_factory_t *cloned_fc = Factory_get(clone);
 
     cloned_fc->has_symbol_ext_type = fc->has_symbol_ext_type;
     cloned_fc->pkrg = fc->pkrg;
@@ -105,7 +131,7 @@ static VALUE Factory_dup(VALUE self)
 
 static VALUE Factory_freeze(VALUE self) {
     if(!rb_obj_frozen_p(self)) {
-        FACTORY(self, fc);
+        msgpack_factory_t *fc = Factory_get(self);
 
         if (RTEST(fc->pkrg.hash)) {
             rb_hash_freeze(fc->pkrg.hash);
@@ -125,14 +151,12 @@ static VALUE Factory_freeze(VALUE self) {
 
 VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self)
 {
-    FACTORY(self, fc);
+    msgpack_factory_t *fc = Factory_get(self);
 
     VALUE packer = MessagePack_Packer_alloc(cMessagePack_Packer);
     MessagePack_Packer_initialize(argc, argv, packer);
 
-    msgpack_packer_t* pk;
-    Data_Get_Struct(packer, msgpack_packer_t, pk);
-
+    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);
     pk->has_bigint_ext_type = fc->has_bigint_ext_type;
@@ -143,13 +167,12 @@ VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self)
 
 VALUE MessagePack_Factory_unpacker(int argc, VALUE* argv, VALUE self)
 {
-    FACTORY(self, fc);
+    msgpack_factory_t *fc = Factory_get(self);
 
     VALUE unpacker = MessagePack_Unpacker_alloc(cMessagePack_Unpacker);
     MessagePack_Unpacker_initialize(argc, argv, unpacker);
 
-    msgpack_unpacker_t* uk;
-    Data_Get_Struct(unpacker, msgpack_unpacker_t, uk);
+    msgpack_unpacker_t* uk = MessagePack_Unpacker_get(unpacker);
     msgpack_unpacker_ext_registry_borrow(fc->ukrg, &uk->ext_registry);
     uk->optimized_symbol_ext_type = fc->optimized_symbol_ext_type;
     uk->symbol_ext_type = fc->symbol_ext_type;
@@ -159,7 +182,7 @@ VALUE MessagePack_Factory_unpacker(int argc, VALUE* argv, VALUE self)
 
 static VALUE Factory_registered_types_internal(VALUE self)
 {
-    FACTORY(self, fc);
+    msgpack_factory_t *fc = Factory_get(self);
 
     VALUE uk_mapping = rb_hash_new();
     if (fc->ukrg) {
@@ -179,7 +202,7 @@ static VALUE Factory_registered_types_internal(VALUE self)
 
 static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
 {
-    FACTORY(self, fc);
+    msgpack_factory_t *fc = Factory_get(self);
 
     int ext_type;
     int flags = 0;

data/ext/msgpack/packer.c

@@ -20,18 +20,16 @@
 
 static ID s_call;
 
-void msgpack_packer_static_init()
+void msgpack_packer_static_init(void)
 {
     s_call = rb_intern("call");
 }
 
-void msgpack_packer_static_destroy()
+void msgpack_packer_static_destroy(void)
 { }
 
 void msgpack_packer_init(msgpack_packer_t* pk)
 {
-    memset(pk, 0, sizeof(msgpack_packer_t));
-
     msgpack_buffer_init(PACKER_BUFFER_(pk));
 }
 
@@ -45,6 +43,7 @@ void msgpack_packer_mark(msgpack_packer_t* pk)
     /* See MessagePack_Buffer_wrap */
     /* msgpack_buffer_mark(PACKER_BUFFER_(pk)); */
     rb_gc_mark(pk->buffer_ref);
+    rb_gc_mark(pk->to_msgpack_arg);
 }
 
 void msgpack_packer_reset(msgpack_packer_t* pk)

data/ext/msgpack/packer.h

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

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,10 +104,10 @@ 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);
-    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
+    pk->buffer_ref = Qnil;
 
     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,7 +230,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));
@@ -233,21 +246,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 +271,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 +290,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,38 +321,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 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);
     }
@@ -348,7 +349,7 @@ static VALUE Packer_registered_types_internal(VALUE self)
 
 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;
@@ -394,7 +395,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));
@@ -454,15 +455,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, "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

@@ -20,12 +20,12 @@
 
 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)

data/ext/msgpack/packer_ext_registry.h

@@ -31,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);
 

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/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)

data/ext/msgpack/unpacker.c

@@ -20,7 +20,7 @@
 #include "rmem.h"
 #include "extension_value_class.h"
 
-#if !defined(DISABLE_RMEM) && !defined(DISABLE_UNPACKER_STACK_RMEM) && \
+#if !defined(DISABLE_UNPACKER_STACK_RMEM) && \
         MSGPACK_UNPACKER_STACK_CAPACITY * MSGPACK_UNPACKER_STACK_SIZE <= MSGPACK_RMEM_PAGE_SIZE
 #define UNPACKER_STACK_RMEM
 #endif
@@ -41,7 +41,7 @@ static inline VALUE rb_hash_new_capa(long capa)
 }
 #endif
 
-void msgpack_unpacker_static_init()
+void msgpack_unpacker_static_init(void)
 {
 #ifdef UNPACKER_STACK_RMEM
     msgpack_rmem_init(&s_stack_rmem);
@@ -50,7 +50,7 @@ void msgpack_unpacker_static_init()
     s_call = rb_intern("call");
 }
 
-void msgpack_unpacker_static_destroy()
+void msgpack_unpacker_static_destroy(void)
 {
 #ifdef UNPACKER_STACK_RMEM
     msgpack_rmem_destroy(&s_stack_rmem);
@@ -72,10 +72,8 @@ static inline msgpack_unpacker_stack_t* _msgpack_unpacker_new_stack(void) {
     return stack;
 }
 
-msgpack_unpacker_t* _msgpack_unpacker_new(void)
+void _msgpack_unpacker_init(msgpack_unpacker_t* uk)
 {
-    msgpack_unpacker_t* uk = ZALLOC_N(msgpack_unpacker_t, 1);
-
     msgpack_buffer_init(UNPACKER_BUFFER_(uk));
 
     uk->head_byte = HEAD_BYTE_REQUIRED;
@@ -84,8 +82,6 @@ msgpack_unpacker_t* _msgpack_unpacker_new(void)
     uk->reading_raw = Qnil;
 
     uk->stack = _msgpack_unpacker_new_stack();
-
-    return uk;
 }
 
 static inline void _msgpack_unpacker_free_stack(msgpack_unpacker_stack_t* stack) {
@@ -124,6 +120,7 @@ void msgpack_unpacker_mark(msgpack_unpacker_t* uk)
     /* See MessagePack_Buffer_wrap */
     /* msgpack_buffer_mark(UNPACKER_BUFFER_(uk)); */
     rb_gc_mark(uk->buffer_ref);
+    rb_gc_mark(uk->self);
 }
 
 void _msgpack_unpacker_reset(msgpack_unpacker_t* uk)
@@ -326,7 +323,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->buffer.owner);
+            obj = rb_funcall(proc, s_call, 1, uk->self);
 
             uk->stack = child_stack->parent;
             _msgpack_unpacker_free_stack(child_stack);

data/ext/msgpack/unpacker.h

@@ -56,6 +56,7 @@ struct msgpack_unpacker_t {
     msgpack_unpacker_stack_t *stack;
     unsigned int head_byte;
 
+    VALUE self;
     VALUE last_object;
 
     VALUE reading_raw;
@@ -86,11 +87,11 @@ enum msgpack_unpacker_object_type {
     TYPE_MAP,
 };
 
-void msgpack_unpacker_static_init();
+void msgpack_unpacker_static_init(void);
 
-void msgpack_unpacker_static_destroy();
+void msgpack_unpacker_static_destroy(void);
 
-msgpack_unpacker_t* _msgpack_unpacker_new(void);
+void _msgpack_unpacker_init(msgpack_unpacker_t*);
 
 void _msgpack_unpacker_destroy(msgpack_unpacker_t* uk);