msgpack 0.6.2-x64-mingw32 → 0.7.0dev1-x64-mingw32

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,213 @@
+/*
+ * 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;
+VALUE cMessagePack_DefaultFactory;
+
+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;
+};
+
+#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)
+{
+    if(fc == NULL) {
+        return;
+    }
+    msgpack_packer_ext_registry_destroy(&fc->pkrg);
+    msgpack_unpacker_ext_registry_destroy(&fc->ukrg);
+    free(fc);
+}
+
+void Factory_mark(msgpack_factory_t* fc)
+{
+    msgpack_packer_ext_registry_mark(&fc->pkrg);
+    msgpack_unpacker_ext_registry_mark(&fc->ukrg);
+}
+
+static VALUE Factory_alloc(VALUE klass)
+{
+    msgpack_factory_t* fc = ALLOC_N(msgpack_factory_t, 1);
+
+    msgpack_packer_ext_registry_init(&fc->pkrg);
+    msgpack_unpacker_ext_registry_init(&fc->ukrg);
+
+    VALUE self = Data_Wrap_Struct(klass, Factory_mark, Factory_free, fc);
+    return self;
+}
+
+static VALUE Factory_initialize(int argc, VALUE* argv, VALUE self)
+{
+    FACTORY(self, fc);
+
+    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;
+}
+
+VALUE MessagePack_Factory_packer(int argc, VALUE* argv, VALUE self)
+{
+    FACTORY(self, fc);
+
+    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_ext_registry_destroy(&pk->ext_registry);
+    msgpack_packer_ext_registry_dup(&fc->pkrg, &pk->ext_registry);
+
+    return packer;
+}
+
+VALUE MessagePack_Factory_unpacker(int argc, VALUE* argv, VALUE self)
+{
+    FACTORY(self, fc);
+
+    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_ext_registry_destroy(&uk->ext_registry);
+    msgpack_unpacker_ext_registry_dup(&fc->ukrg, &uk->ext_registry);
+
+    return unpacker;
+}
+
+static VALUE Factory_registered_types_internal(VALUE self)
+{
+    FACTORY(self, fc);
+
+    VALUE uk_mapping = rb_hash_new();
+    for(int i=0; i < 256; i++) {
+        if(fc->ukrg.array[i] != Qnil) {
+            rb_hash_aset(uk_mapping, INT2FIX(i - 128), fc->ukrg.array[i]);
+        }
+    }
+#ifdef HAVE_RB_HASH_DUP
+    return rb_ary_new3(2, rb_hash_dup(fc->pkrg.hash), uk_mapping);
+#else
+    return rb_ary_new3(2, rb_funcall(fc->pkrg.hash, rb_intern("dup"), 0), uk_mapping);
+#endif
+}
+
+static VALUE Factory_register_type(int argc, VALUE* argv, VALUE self)
+{
+    FACTORY(self, fc);
+
+    int ext_type;
+    VALUE ext_class;
+    VALUE options;
+    VALUE packer_arg, unpacker_arg;
+    VALUE packer_proc, unpacker_proc;
+
+    switch (argc) {
+    case 2:
+        /* register_type(0x7f, Time) */
+        packer_arg = ID2SYM(rb_intern("to_msgpack_ext"));
+        unpacker_arg = ID2SYM(rb_intern("from_msgpack_ext"));
+        break;
+    case 3:
+        /* register_type(0x7f, Time, packer: proc-like, unapcker: proc-like) */
+        options = argv[2];
+        if(rb_type(options) != T_HASH) {
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
+        }
+        packer_arg = rb_hash_aref(options, ID2SYM(rb_intern("packer")));
+        unpacker_arg = rb_hash_aref(options, ID2SYM(rb_intern("unpacker")));
+        break;
+    default:
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..3)", argc);
+    }
+
+    ext_type = rb_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);
+    }
+
+    ext_class = argv[1];
+    if(rb_type(ext_class) != T_CLASS) {
+        rb_raise(rb_eArgError, "expected Class but found %s.", rb_obj_classname(ext_class));
+    }
+
+    packer_proc = Qnil;
+    unpacker_proc = Qnil;
+
+    if(packer_arg != Qnil) {
+        packer_proc = rb_funcall(packer_arg, rb_intern("to_proc"), 0);
+    }
+
+    if(unpacker_arg != Qnil) {
+        if(rb_type(unpacker_arg) == T_SYMBOL || rb_type(unpacker_arg) == T_STRING) {
+            unpacker_proc = rb_obj_method(ext_class, unpacker_arg);
+        } else {
+            unpacker_proc = rb_funcall(unpacker_arg, rb_intern("method"), 1, ID2SYM(rb_intern("call")));
+        }
+    }
+
+    msgpack_packer_ext_registry_put(&fc->pkrg, ext_class, ext_type, packer_proc, packer_arg);
+
+    msgpack_unpacker_ext_registry_put(&fc->ukrg, ext_class, ext_type, unpacker_proc, unpacker_arg);
+
+    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, "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_method(cMessagePack_Factory, "register_type", Factory_register_type, -1);
+
+    cMessagePack_DefaultFactory = Factory_alloc(cMessagePack_Factory);
+    Factory_initialize(0, NULL, cMessagePack_DefaultFactory);
+    rb_define_const(mMessagePack, "DefaultFactory", cMessagePack_DefaultFactory);
+}

data/ext/msgpack/factory_class.h

@@ -0,0 +1,35 @@
+/*
+ * 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 cMessagePack_DefaultFactory;
+
+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

@@ -25,6 +25,8 @@ static ID s_key;
 static ID s_value;
 #endif
 
+static ID s_call;
+
 void msgpack_packer_static_init()
 {
 #ifdef RUBINIUS
@@ -33,6 +35,8 @@ void msgpack_packer_static_init()
     s_key = rb_intern("key");
     s_value = rb_intern("value");
 #endif
+
+    s_call = rb_intern("call");
 }
 
 void msgpack_packer_static_destroy()
@@ -43,8 +47,6 @@ void msgpack_packer_init(msgpack_packer_t* pk)
     memset(pk, 0, sizeof(msgpack_packer_t));
 
     msgpack_buffer_init(PACKER_BUFFER_(pk));
-
-    pk->io = Qnil;
 }
 
 void msgpack_packer_destroy(msgpack_packer_t* pk)
@@ -54,8 +56,6 @@ void msgpack_packer_destroy(msgpack_packer_t* pk)
 
 void msgpack_packer_mark(msgpack_packer_t* pk)
 {
-    rb_gc_mark(pk->io);
-
     /* See MessagePack_Buffer_wrap */
     /* msgpack_buffer_mark(PACKER_BUFFER_(pk)); */
     rb_gc_mark(pk->buffer_ref);
@@ -65,8 +65,6 @@ void msgpack_packer_reset(msgpack_packer_t* pk)
 {
     msgpack_buffer_clear(PACKER_BUFFER_(pk));
 
-    pk->io = Qnil;
-    pk->io_write_all_method = 0;
     pk->buffer_ref = Qnil;
 }
 
@@ -125,7 +123,16 @@ void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v)
 
 static void _msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
 {
-    rb_funcall(v, pk->to_msgpack_method, 1, pk->to_msgpack_arg);
+    int ext_type;
+    VALUE proc = msgpack_packer_ext_registry_lookup(&pk->ext_registry,
+            rb_obj_class(v), &ext_type);
+    if(proc != Qnil) {
+        VALUE payload = rb_funcall(proc, s_call, 1, v);
+        StringValue(payload);
+        msgpack_packer_write_ext(pk, ext_type, payload);
+    } else {
+        rb_funcall(v, pk->to_msgpack_method, 1, pk->to_msgpack_arg);
+    }
 }
 
 void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v)

data/ext/msgpack/packer.h

@@ -19,6 +19,7 @@
 #define MSGPACK_RUBY_PACKER_H__
 
 #include "buffer.h"
+#include "packer_ext_registry.h"
 
 #ifndef MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY
 #define MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY (1024)
@@ -30,8 +31,6 @@ typedef struct msgpack_packer_t msgpack_packer_t;
 struct msgpack_packer_t {
     msgpack_buffer_t buffer;
 
-    VALUE io;
-    ID io_write_all_method;
     bool compatibility_mode;
 
     ID to_msgpack_method;
@@ -41,6 +40,7 @@ struct msgpack_packer_t {
 
     /* options */
     bool comaptibility_mode;
+    msgpack_packer_ext_registry_t ext_registry;
 };
 
 #define PACKER_BUFFER_(pk) (&(pk)->buffer)
@@ -62,12 +62,6 @@ static inline void msgpack_packer_set_to_msgpack_method(msgpack_packer_t* pk,
     pk->to_msgpack_arg = to_msgpack_arg;
 }
 
-static inline void msgpack_packer_set_io(msgpack_packer_t* pk, VALUE io, ID io_write_all_method)
-{
-    pk->io = io;
-    pk->io_write_all_method = io_write_all_method;
-}
-
 void msgpack_packer_reset(msgpack_packer_t* pk);
 
 static inline void msgpack_packer_set_compat(msgpack_packer_t* pk, bool enable)
@@ -345,6 +339,50 @@ static inline void msgpack_packer_write_map_header(msgpack_packer_t* pk, unsigne
     }
 }
 
+static inline void msgpack_packer_write_ext(msgpack_packer_t* pk, int ext_type, VALUE payload)
+{
+    unsigned long len = RSTRING_LEN(payload);
+    switch (len) {
+    case 1:
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
+        msgpack_buffer_write_2(PACKER_BUFFER_(pk), 0xd4, ext_type);
+        break;
+    case 2:
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
+        msgpack_buffer_write_2(PACKER_BUFFER_(pk), 0xd5, ext_type);
+        break;
+    case 4:
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
+        msgpack_buffer_write_2(PACKER_BUFFER_(pk), 0xd6, ext_type);
+        break;
+    case 8:
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
+        msgpack_buffer_write_2(PACKER_BUFFER_(pk), 0xd7, ext_type);
+        break;
+    case 16:
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
+        msgpack_buffer_write_2(PACKER_BUFFER_(pk), 0xd8, ext_type);
+        break;
+    default:
+        if(len < 255) {
+            msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+            msgpack_buffer_write_2(PACKER_BUFFER_(pk), 0xc7, len);
+            msgpack_buffer_write_1(PACKER_BUFFER_(pk), ext_type);
+        } else if(len < 65536) {
+            msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 4);
+            uint16_t be = _msgpack_be16(len);
+            msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xc8, (const void*)&be, 2);
+            msgpack_buffer_write_1(PACKER_BUFFER_(pk), ext_type);
+        } else {
+            msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 6);
+            uint32_t be = _msgpack_be32(len);
+            msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xc9, (const void*)&be, 4);
+            msgpack_buffer_write_1(PACKER_BUFFER_(pk), ext_type);
+        }
+    }
+    msgpack_buffer_append_string(PACKER_BUFFER_(pk), payload);
+}
+
 #ifdef COMPAT_HAVE_ENCODING
 static inline bool msgpack_packer_is_binary(VALUE v, int encindex)
 {

data/ext/msgpack/packer_class.c

@@ -21,6 +21,7 @@
 #include "packer.h"
 #include "packer_class.h"
 #include "buffer_class.h"
+#include "factory_class.h"
 
 VALUE cMessagePack_Packer;
 
@@ -42,24 +43,32 @@ static void Packer_free(msgpack_packer_t* pk)
     if(pk == NULL) {
         return;
     }
+    msgpack_packer_ext_registry_destroy(&pk->ext_registry);
     msgpack_packer_destroy(pk);
     free(pk);
 }
 
-static VALUE Packer_alloc(VALUE klass)
+static void Packer_mark(msgpack_packer_t* pk)
+{
+    msgpack_packer_mark(pk);
+    msgpack_packer_ext_registry_mark(&pk->ext_registry);
+}
+
+VALUE MessagePack_Packer_alloc(VALUE klass)
 {
     msgpack_packer_t* pk = ALLOC_N(msgpack_packer_t, 1);
     msgpack_packer_init(pk);
 
-    VALUE self = Data_Wrap_Struct(klass, msgpack_packer_mark, Packer_free, pk);
+    VALUE self = Data_Wrap_Struct(klass, Packer_mark, Packer_free, pk);
 
     msgpack_packer_set_to_msgpack_method(pk, s_to_msgpack, self);
+    msgpack_packer_ext_registry_init(&pk->ext_registry);
     pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
 
     return self;
 }
 
-static VALUE Packer_initialize(int argc, VALUE* argv, VALUE self)
+VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
 {
     VALUE io = Qnil;
     VALUE options = Qnil;
@@ -88,14 +97,7 @@ static VALUE Packer_initialize(int argc, VALUE* argv, VALUE self)
 
     PACKER(self, pk);
 
-    MessagePack_Packer_initialize(pk, io, options);
-
-    return self;
-}
-
-void MessagePack_Packer_initialize(msgpack_packer_t* pk, VALUE io, VALUE options)
-{
-    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
+    MessagePack_Buffer_set_options(PACKER_BUFFER_(pk), io, options);
 
     if(options != Qnil) {
         VALUE v;
@@ -103,6 +105,8 @@ void MessagePack_Packer_initialize(msgpack_packer_t* pk, VALUE io, VALUE options
         v = rb_hash_aref(options, ID2SYM(rb_intern("compatibility_mode")));
         msgpack_packer_set_compat(pk, RTEST(v));
     }
+
+    return self;
 }
 
 static VALUE Packer_buffer(VALUE self)
@@ -139,6 +143,18 @@ static VALUE Packer_write_map_header(VALUE self, VALUE n)
     return self;
 }
 
+static VALUE Packer_write_ext(VALUE self, VALUE type, VALUE data)
+{
+    PACKER(self, pk);
+    int ext_type = rb_num2int(type);
+    if(ext_type < -128 || ext_type > 127) {
+        rb_raise(rb_eRangeError, "integer %d too big to convert to `signed char'", ext_type);
+    }
+    StringValue(data);
+    msgpack_packer_write_ext(pk, ext_type, data);
+    return self;
+}
+
 static VALUE Packer_flush(VALUE self)
 {
     PACKER(self, pk);
@@ -201,51 +217,77 @@ static VALUE Packer_write_to(VALUE self, VALUE io)
 //    return self;
 //}
 
-VALUE MessagePack_pack(int argc, VALUE* argv)
+static VALUE Packer_registered_types_internal(VALUE self)
 {
-    VALUE v;
-    VALUE io = Qnil;
-    VALUE options = Qnil;
+    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
+}
 
-    if(argc == 1) {
-        v = argv[0];
+static VALUE Packer_register_type(int argc, VALUE* argv, VALUE self)
+{
+    PACKER(self, pk);
 
-    } else if(argc == 2) {
-        v = argv[0];
-        if(rb_type(argv[1]) == T_HASH) {
-            options = argv[1];
-        } else {
-            io = argv[1];
-        }
+    int ext_type;
+    VALUE ext_class;
+    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);
+    }
 
-    } else if(argc == 3) {
-        v = argv[0];
-        io = argv[1];
-        options = argv[2];
-        if(rb_type(options) != T_HASH) {
-            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
-        }
+    ext_type = rb_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);
+    }
 
-    } else {
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
+    ext_class = argv[1];
+    if(rb_type(ext_class) != T_CLASS) {
+        rb_raise(rb_eArgError, "expected Class but found %s.", rb_obj_classname(ext_class));
     }
 
-    VALUE self = Packer_alloc(cMessagePack_Packer);
-    PACKER(self, pk);
+    msgpack_packer_ext_registry_put(&pk->ext_registry, ext_class, ext_type, proc, arg);
 
-    if (options != Qnil) {
-      pk->compatibility_mode = RTEST(rb_hash_aref(options, ID2SYM(rb_intern("compatibility_mode"))));
-    }
+    return Qnil;
+}
+
+VALUE MessagePack_pack(int argc, VALUE* argv)
+{
+    VALUE v;
 
-    //msgpack_packer_reset(s_packer);
-    //msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
+    if (argc < 0 || argc > 3) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
+    }
+    v = argv[0];
 
-    MessagePack_Packer_initialize(pk, io, options);
+    VALUE self = MessagePack_Factory_packer(argc - 1, argv + 1, cMessagePack_DefaultFactory);
+    PACKER(self, pk);
 
     msgpack_packer_write_value(pk, v);
 
     VALUE retval;
-    if(io != Qnil) {
+    if(msgpack_buffer_has_io(PACKER_BUFFER_(pk))) {
         msgpack_buffer_flush(PACKER_BUFFER_(pk));
         retval = Qnil;
     } else {
@@ -281,18 +323,20 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     s_write = rb_intern("write");
 
     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, Packer_alloc);
+    rb_define_alloc_func(cMessagePack_Packer, MessagePack_Packer_alloc);
 
-    rb_define_method(cMessagePack_Packer, "initialize", Packer_initialize, -1);
+    rb_define_method(cMessagePack_Packer, "initialize", MessagePack_Packer_initialize, -1);
     rb_define_method(cMessagePack_Packer, "buffer", Packer_buffer, 0);
     rb_define_method(cMessagePack_Packer, "write", Packer_write, 1);
     rb_define_alias(cMessagePack_Packer, "pack", "write");
     rb_define_method(cMessagePack_Packer, "write_nil", Packer_write_nil, 0);
     rb_define_method(cMessagePack_Packer, "write_array_header", Packer_write_array_header, 1);
     rb_define_method(cMessagePack_Packer, "write_map_header", Packer_write_map_header, 1);
+    rb_define_method(cMessagePack_Packer, "write_ext", Packer_write_ext, 2);
     rb_define_method(cMessagePack_Packer, "flush", Packer_flush, 0);
 
     /* delegation methods */
@@ -306,7 +350,10 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     //rb_define_method(cMessagePack_Packer, "append", Packer_append, 1);
     //rb_define_alias(cMessagePack_Packer, "<<", "append");
 
-    //s_packer_value = Packer_alloc(cMessagePack_Packer);
+    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);