ed-precompiled_msgpack 1.8.0-arm64-darwin

data/ext/msgpack/extconf.rb

@@ -0,0 +1,53 @@
+require 'mkmf'
+
+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",
+  "-std=gnu99"
+])
+
+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
+  append_cflags("-DRB_ENC_INTERNED_STR_NULL_CHECK=1")
+end
+
+# checking if Hash#[]= (rb_hash_aset) dedupes string keys (Ruby 2.6+)
+h = {}
+x = {}
+r = rand.to_s
+h[%W(#{r}).join('')] = :foo
+x[%W(#{r}).join('')] = :foo
+if x.keys[0].equal?(h.keys[0])
+  append_cflags("-DHASH_ASET_DEDUPE=1")
+else
+  append_cflags("-DHASH_ASET_DEDUPE=0")
+end
+
+# checking if String#-@ (str_uminus) directly interns frozen strings... ' (Ruby 3.0+)
+begin
+  s = rand.to_s.freeze
+  if (-s).equal?(s) && (-s.dup).equal?(s)
+    append_cflags("-DSTR_UMINUS_DEDUPE_FROZEN=1")
+  else
+    append_cflags("-DSTR_UMINUS_DEDUPE_FROZEN=0")
+  end
+rescue NoMethodError
+  append_cflags("-DSTR_UMINUS_DEDUPE_FROZEN=0")
+end
+
+if warnflags = CONFIG['warnflags']
+  warnflags.slice!(/ -Wdeclaration-after-statement/)
+end
+
+create_makefile('msgpack/msgpack')

data/ext/msgpack/extension_value_class.c

@@ -0,0 +1,34 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "factory_class.h"
+
+VALUE cMessagePack_ExtensionValue;
+
+VALUE MessagePack_ExtensionValue_new(int ext_type, VALUE payload)
+{
+    return rb_struct_new(cMessagePack_ExtensionValue, INT2FIX(ext_type), payload);
+}
+
+void MessagePack_ExtensionValue_module_init(VALUE mMessagePack)
+{
+    /* rb_struct_define_under is not available ruby < 2.1 */
+    //cMessagePack_ExtensionValue = rb_struct_define_under(mMessagePack, "ExtensionValue", "type", "payload", NULL);
+    cMessagePack_ExtensionValue = rb_struct_define(NULL, "type", "payload", NULL);
+    rb_define_const(mMessagePack, "ExtensionValue", cMessagePack_ExtensionValue);
+}

data/ext/msgpack/extension_value_class.h

@@ -0,0 +1,31 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2015 Sadayuki Furuhashi
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#ifndef MSGPACK_RUBY_EXTENSION_VALUE_CLASS_H__
+#define MSGPACK_RUBY_EXTENSION_VALUE_CLASS_H__
+
+#include "compat.h"
+#include "sysdep.h"
+
+extern VALUE cMessagePack_ExtensionValue;
+
+VALUE MessagePack_ExtensionValue_new(int ext_type, VALUE payload);
+
+void MessagePack_ExtensionValue_module_init(VALUE mMessagePack);
+
+#endif
+

data/ext/msgpack/factory_class.c

@@ -0,0 +1,276 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "factory_class.h"
+#include "packer_ext_registry.h"
+#include "unpacker_ext_registry.h"
+#include "buffer_class.h"
+#include "packer_class.h"
+#include "unpacker_class.h"
+
+VALUE cMessagePack_Factory;
+
+struct msgpack_factory_t;
+typedef struct msgpack_factory_t msgpack_factory_t;
+
+struct msgpack_factory_t {
+    msgpack_packer_ext_registry_t pkrg;
+    msgpack_unpacker_ext_registry_t *ukrg;
+    bool has_bigint_ext_type;
+    bool has_symbol_ext_type;
+    bool optimized_symbol_ext_type;
+    int symbol_ext_type;
+};
+
+static void Factory_free(void *ptr)
+{
+    msgpack_factory_t *fc = ptr;
+
+    if(fc == NULL) {
+        return;
+    }
+    msgpack_packer_ext_registry_destroy(&fc->pkrg);
+    msgpack_unpacker_ext_registry_release(fc->ukrg);
+    xfree(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 size_t Factory_memsize(const void *ptr)
+{
+    const msgpack_factory_t *fc = ptr;
+    size_t total_size = sizeof(msgpack_factory_t);
+
+    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 | RUBY_TYPED_WB_PROTECTED
+};
+
+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)
+{
+    msgpack_factory_t *fc = Factory_get(self);
+
+    msgpack_packer_ext_registry_init(self, &fc->pkrg);
+    // fc->ukrg is lazily initialized
+
+    fc->has_symbol_ext_type = false;
+
+    switch (argc) {
+    case 0:
+        break;
+    default:
+        // TODO options is not supported yet
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
+    }
+
+    return Qnil;
+}
+
+static VALUE Factory_dup(VALUE self)
+{
+    VALUE clone = Factory_alloc(rb_obj_class(self));
+
+    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;
+    msgpack_unpacker_ext_registry_borrow(fc->ukrg, &cloned_fc->ukrg);
+    msgpack_packer_ext_registry_dup(clone, &fc->pkrg, &cloned_fc->pkrg);
+
+    return clone;
+}
+
+static VALUE Factory_freeze(VALUE self) {
+    if(!rb_obj_frozen_p(self)) {
+        msgpack_factory_t *fc = Factory_get(self);
+
+        if (RTEST(fc->pkrg.hash)) {
+            rb_hash_freeze(fc->pkrg.hash);
+            if (!RTEST(fc->pkrg.cache)) {
+                // 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.
+                RB_OBJ_WRITE(self, &fc->pkrg.cache, rb_hash_new());
+            }
+        }
+
+        rb_obj_freeze(self);
+    }
+
+    return self;
+}
+
+VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self)
+{
+    msgpack_factory_t *fc = Factory_get(self);
+
+    VALUE packer = MessagePack_Packer_alloc(cMessagePack_Packer);
+    MessagePack_Packer_initialize(argc, argv, packer);
+
+    msgpack_packer_t* pk = MessagePack_Packer_get(packer);
+    msgpack_packer_ext_registry_destroy(&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;
+
+    return packer;
+}
+
+VALUE MessagePack_Factory_unpacker(int argc, VALUE* argv, VALUE self)
+{
+    msgpack_factory_t *fc = Factory_get(self);
+
+    VALUE unpacker = MessagePack_Unpacker_alloc(cMessagePack_Unpacker);
+    MessagePack_Unpacker_initialize(argc, argv, unpacker);
+
+    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;
+
+    return unpacker;
+}
+
+static VALUE Factory_registered_types_internal(VALUE self)
+{
+    msgpack_factory_t *fc = Factory_get(self);
+
+    VALUE uk_mapping = rb_hash_new();
+    if (fc->ukrg) {
+        for(int i=0; i < 256; i++) {
+            if(!NIL_P(fc->ukrg->array[i])) {
+                rb_hash_aset(uk_mapping, INT2FIX(i - 128), fc->ukrg->array[i]);
+            }
+        }
+    }
+
+    return rb_ary_new3(
+        2,
+        RTEST(fc->pkrg.hash) ? rb_hash_dup(fc->pkrg.hash) : rb_hash_new(),
+        uk_mapping
+    );
+}
+
+static VALUE Factory_register_type_internal(VALUE self, VALUE rb_ext_type, VALUE ext_module, VALUE options)
+{
+    msgpack_factory_t *fc = Factory_get(self);
+
+    Check_Type(rb_ext_type, T_FIXNUM);
+
+    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));
+    }
+
+    int flags = 0;
+
+    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 (OBJ_FROZEN(self)) {
+        rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Factory");
+    }
+
+    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);
+    }
+
+    if(ext_module == rb_cSymbol) {
+        if(NIL_P(options) || RTEST(rb_hash_aref(options, ID2SYM(rb_intern("packer"))))) {
+            fc->has_symbol_ext_type = true;
+        }
+        if(RTEST(options) && RTEST(rb_hash_aref(options, ID2SYM(rb_intern("optimized_symbols_parsing"))))) {
+            fc->optimized_symbol_ext_type = true;
+        }
+    }
+
+    if(RTEST(options)) {
+        if(RTEST(rb_hash_aref(options, ID2SYM(rb_intern("oversized_integer_extension"))))) {
+            if(ext_module == rb_cInteger) {
+                fc->has_bigint_ext_type = true;
+            } else {
+                rb_raise(rb_eArgError, "oversized_integer_extension: true is only for Integer class");
+            }
+        }
+
+        if(RTEST(rb_hash_aref(options, ID2SYM(rb_intern("recursive"))))) {
+            flags |= MSGPACK_EXT_RECURSIVE;
+        }
+    }
+
+    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;
+}
+
+void MessagePack_Factory_module_init(VALUE mMessagePack)
+{
+    cMessagePack_Factory = rb_define_class_under(mMessagePack, "Factory", rb_cObject);
+
+    rb_define_alloc_func(cMessagePack_Factory, Factory_alloc);
+
+    rb_define_method(cMessagePack_Factory, "initialize", Factory_initialize, -1);
+    rb_define_method(cMessagePack_Factory, "dup", Factory_dup, 0);
+    rb_define_method(cMessagePack_Factory, "freeze", Factory_freeze, 0);
+
+    rb_define_method(cMessagePack_Factory, "packer", MessagePack_Factory_packer, -1);
+    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_private_method(cMessagePack_Factory, "register_type_internal", Factory_register_type_internal, 3);
+}

data/ext/msgpack/factory_class.h

@@ -0,0 +1,33 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2015 Sadayuki Furuhashi
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#ifndef MSGPACK_RUBY_FACTORY_CLASS_H__
+#define MSGPACK_RUBY_FACTORY_CLASS_H__
+
+#include "compat.h"
+#include "sysdep.h"
+
+extern VALUE cMessagePack_Factory;
+
+extern VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self);
+
+extern VALUE MessagePack_Factory_unpacker(int argc, VALUE* argv, VALUE self);
+
+void MessagePack_Factory_module_init(VALUE mMessagePack);
+
+#endif
+

data/ext/msgpack/packer.c

@@ -0,0 +1,199 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2013 Sadayuki Furuhashi
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include "packer.h"
+#include "buffer_class.h"
+
+#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)
+{
+    msgpack_buffer_init(PACKER_BUFFER_(pk));
+}
+
+void msgpack_packer_destroy(msgpack_packer_t* pk)
+{
+    msgpack_buffer_destroy(PACKER_BUFFER_(pk));
+}
+
+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)
+{
+    msgpack_buffer_clear(PACKER_BUFFER_(pk));
+
+    pk->buffer_ref = Qnil;
+}
+
+
+void msgpack_packer_write_array_value(msgpack_packer_t* pk, VALUE v)
+{
+    /* actual return type of RARRAY_LEN is long */
+    unsigned long len = RARRAY_LEN(v);
+    if(len > 0xffffffffUL) {
+        rb_raise(rb_eArgError, "size of array is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
+    }
+    unsigned int len32 = (unsigned int)len;
+    msgpack_packer_write_array_header(pk, len32);
+
+    unsigned int i;
+    for(i=0; i < len32; ++i) {
+        VALUE e = rb_ary_entry(v, i);
+        msgpack_packer_write_value(pk, e);
+    }
+}
+
+static int write_hash_foreach(VALUE key, VALUE value, VALUE pk_value)
+{
+    if (key == Qundef) {
+        return ST_CONTINUE;
+    }
+    msgpack_packer_t* pk = (msgpack_packer_t*) pk_value;
+    msgpack_packer_write_value(pk, key);
+    msgpack_packer_write_value(pk, value);
+    return ST_CONTINUE;
+}
+
+void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v)
+{
+    /* actual return type of RHASH_SIZE is long (if SIZEOF_LONG == SIZEOF_VOIDP
+     * or long long (if SIZEOF_LONG_LONG == SIZEOF_VOIDP. See st.h. */
+    unsigned long len = RHASH_SIZE(v);
+    if(len > 0xffffffffUL) {
+        rb_raise(rb_eArgError, "size of array is too long to pack: %ld bytes should be <= %lu", len, 0xffffffffUL);
+    }
+    unsigned int len32 = (unsigned int)len;
+    msgpack_packer_write_map_header(pk, len32);
+
+    rb_hash_foreach(v, write_hash_foreach, (VALUE) pk);
+}
+
+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 args[2];
+};
+
+VALUE msgpack_packer_try_calling_proc(VALUE value)
+{
+    msgpack_call_proc_args_t *args = (msgpack_call_proc_args_t *)value;
+    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)
+{
+    int ext_type, ext_flags;
+
+    VALUE proc = msgpack_packer_ext_registry_lookup(&pk->ext_registry, v, &ext_type, &ext_flags);
+
+    if(proc == Qnil) {
+        return false;
+    }
+
+    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 } };
+        rb_protect(msgpack_packer_try_calling_proc, (VALUE)&args, &exception_occured);
+
+        if (exception_occured) {
+            msgpack_buffer_destroy(PACKER_BUFFER_(pk));
+            pk->buffer = parent_buffer;
+            rb_jump_tag(exception_occured); // re-raise the exception
+        } else {
+            VALUE payload = msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
+            StringValue(payload);
+            msgpack_buffer_destroy(PACKER_BUFFER_(pk));
+            pk->buffer = parent_buffer;
+            msgpack_packer_write_ext(pk, ext_type, payload);
+        }
+
+        RB_GC_GUARD(held_buffer);
+    } else {
+        VALUE payload = rb_proc_call_with_block(proc, 1, &v, Qnil);
+        StringValue(payload);
+        msgpack_packer_write_ext(pk, ext_type, payload);
+    }
+
+    return true;
+}
+
+void msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
+{
+    if(!(msgpack_packer_try_write_with_ext_type_lookup(pk, v))) {
+        rb_funcall(v, pk->to_msgpack_method, 1, pk->to_msgpack_arg);
+    }
+}
+
+void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v)
+{
+    switch(rb_type(v)) {
+    case T_NIL:
+        msgpack_packer_write_nil(pk);
+        break;
+    case T_TRUE:
+        msgpack_packer_write_true(pk);
+        break;
+    case T_FALSE:
+        msgpack_packer_write_false(pk);
+        break;
+    case T_FIXNUM:
+        msgpack_packer_write_fixnum_value(pk, v);
+        break;
+    case T_SYMBOL:
+        msgpack_packer_write_symbol_value(pk, v);
+        break;
+    case T_STRING:
+        if(rb_class_of(v) == rb_cString || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) {
+            msgpack_packer_write_string_value(pk, v);
+        }
+        break;
+    case T_ARRAY:
+        if(rb_class_of(v) == rb_cArray || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) {
+            msgpack_packer_write_array_value(pk, v);
+        }
+        break;
+    case T_HASH:
+        if(rb_class_of(v) == rb_cHash || !msgpack_packer_try_write_with_ext_type_lookup(pk, v)) {
+            msgpack_packer_write_hash_value(pk, v);
+        }
+        break;
+    case T_BIGNUM:
+        msgpack_packer_write_bignum_value(pk, v);
+        break;
+    case T_FLOAT:
+        msgpack_packer_write_float_value(pk, v);
+        break;
+    default:
+        msgpack_packer_write_other_value(pk, v);
+    }
+}
+