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

data/ext/msgpack/packer_class.h

@@ -24,9 +24,11 @@ extern VALUE cMessagePack_Packer;
 
 void MessagePack_Packer_module_init(VALUE mMessagePack);
 
-VALUE MessagePack_pack(int argc, VALUE* argv);
+VALUE MessagePack_Packer_alloc(VALUE klass);
+
+VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self);
 
-void MessagePack_Packer_initialize(msgpack_packer_t* pk, VALUE io, VALUE options);
+VALUE MessagePack_pack(int argc, VALUE* argv);
 
 #endif
 

data/ext/msgpack/packer_ext_registry.c

@@ -0,0 +1,87 @@
+/*
+ * 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.
+ */
+
+#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)
+{
+    pkrg->hash = rb_hash_new();
+    pkrg->cache = rb_hash_new();
+}
+
+void msgpack_packer_ext_registry_mark(msgpack_packer_ext_registry_t* pkrg)
+{
+    rb_gc_mark(pkrg->hash);
+    rb_gc_mark(pkrg->cache);
+}
+
+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;
+}
+
+#endif
+
+VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
+        VALUE ext_class, int ext_type, 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);
+    }
+#endif
+    return rb_hash_aset(pkrg->hash, ext_class, e);
+}
+
+VALUE msgpack_packer_ext_registry_call(msgpack_packer_ext_registry_t* pkrg,
+        VALUE proc, VALUE ext_value)
+{
+    VALUE string = rb_funcall(proc, s_call, 1, ext_value);
+    StringValue(string);
+    return string;
+}

data/ext/msgpack/packer_ext_registry.h

@@ -0,0 +1,101 @@
+/*
+ * 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_UNPACKER_PACKER_EXT_REGISTRY_H__
+#define MSGPACK_RUBY_UNPACKER_PACKER_EXT_REGISTRY_H__
+
+#include "compat.h"
+#include "ruby.h"
+
+struct msgpack_packer_ext_registry_t;
+typedef struct msgpack_packer_ext_registry_t msgpack_packer_ext_registry_t;
+
+struct msgpack_packer_ext_registry_t {
+    VALUE hash;
+    /*
+     * lookup cache for subclasses of registered classes
+     */
+    VALUE cache;
+};
+
+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);
+
+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,
+        msgpack_packer_ext_registry_t* dst);
+
+VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
+        VALUE ext_class, int ext_type, VALUE proc, VALUE arg);
+
+static int msgpack_packer_ext_find_inherited(VALUE key, VALUE value, VALUE arg)
+{
+    VALUE *args = (VALUE *) arg;
+    if(key == Qundef) {
+        return ST_CONTINUE;
+    }
+    if(rb_class_inherited_p(args[0], key) == Qtrue) {
+        args[1] = key;
+        return ST_STOP;
+    }
+    return ST_CONTINUE;
+}
+
+
+static inline VALUE msgpack_packer_ext_registry_lookup(msgpack_packer_ext_registry_t* pkrg,
+        VALUE ext_class, int* ext_type_result)
+{
+    VALUE e = rb_hash_lookup(pkrg->hash, ext_class);
+    if(e != Qnil) {
+        *ext_type_result = FIX2INT(rb_ary_entry(e, 0));
+        return rb_ary_entry(e, 1);
+    }
+
+    VALUE c = rb_hash_lookup(pkrg->cache, ext_class);
+    if(c != Qnil) {
+        *ext_type_result = FIX2INT(rb_ary_entry(c, 0));
+        return rb_ary_entry(c, 1);
+    }
+
+    /*
+     * check all keys whether it is super class of ext_class, or not
+     */
+    VALUE args[2];
+    args[0] = ext_class;
+    args[1] = Qnil;
+    rb_hash_foreach(pkrg->hash, msgpack_packer_ext_find_inherited, (VALUE) args);
+
+    VALUE hit = args[1];
+    if(hit != Qnil) {
+        rb_hash_aset(pkrg->cache, ext_class, hit);
+        return hit;
+    }
+
+    return Qnil;
+}
+
+VALUE msgpack_packer_ext_registry_call(msgpack_packer_ext_registry_t* pkrg,
+        VALUE proc, VALUE ext_value);
+
+#endif

data/ext/msgpack/rbinit.c

@@ -19,6 +19,8 @@
 #include "buffer_class.h"
 #include "packer_class.h"
 #include "unpacker_class.h"
+#include "factory_class.h"
+#include "extension_value_class.h"
 #include "core_ext.h"
 
 void Init_msgpack(void)
@@ -28,6 +30,8 @@ void Init_msgpack(void)
     MessagePack_Buffer_module_init(mMessagePack);
     MessagePack_Packer_module_init(mMessagePack);
     MessagePack_Unpacker_module_init(mMessagePack);
+    MessagePack_Factory_module_init(mMessagePack);
+    MessagePack_ExtensionValue_module_init(mMessagePack);
     MessagePack_core_ext_module_init();
 }
 

data/ext/msgpack/unpacker.c

@@ -18,12 +18,18 @@
 
 #include "unpacker.h"
 #include "rmem.h"
+#include "extension_value_class.h"
 
 #if !defined(DISABLE_RMEM) && !defined(DISABLE_UNPACKER_STACK_RMEM) && \
         MSGPACK_UNPACKER_STACK_CAPACITY * MSGPACK_UNPACKER_STACK_SIZE <= MSGPACK_RMEM_PAGE_SIZE
 #define UNPACKER_STACK_RMEM
 #endif
 
+static int RAW_TYPE_STRING = 256;
+static int RAW_TYPE_BINARY = 257;
+
+static ID s_call;
+
 #ifdef UNPACKER_STACK_RMEM
 static msgpack_rmem_t s_stack_rmem;
 #endif
@@ -33,6 +39,8 @@ void msgpack_unpacker_static_init()
 #ifdef UNPACKER_STACK_RMEM
     msgpack_rmem_init(&s_stack_rmem);
 #endif
+
+    s_call = rb_intern("call");
 }
 
 void msgpack_unpacker_static_destroy()
@@ -150,12 +158,31 @@ static inline int object_complete_string(msgpack_unpacker_t* uk, VALUE str)
 static inline int object_complete_binary(msgpack_unpacker_t* uk, VALUE str)
 {
 #ifdef COMPAT_HAVE_ENCODING
-    // TODO ruby 2.0 has String#b method
     ENCODING_SET(str, msgpack_rb_encindex_ascii8bit);
 #endif
     return object_complete(uk, str);
 }
 
+static inline int object_complete_ext(msgpack_unpacker_t* uk, int ext_type, VALUE str)
+{
+#ifdef COMPAT_HAVE_ENCODING
+    ENCODING_SET(str, msgpack_rb_encindex_ascii8bit);
+#endif
+
+    VALUE proc = msgpack_unpacker_ext_registry_lookup(&uk->ext_registry, ext_type);
+    if(proc != Qnil) {
+        VALUE obj = rb_funcall(proc, s_call, 1, str);
+        return object_complete(uk, obj);
+    }
+
+    if(uk->allow_unknown_ext) {
+        VALUE obj = MessagePack_ExtensionValue_new(ext_type, str);
+        return object_complete(uk, obj);
+    }
+
+    return PRIMITIVE_UNEXPECTED_EXT_TYPE;
+}
+
 /* stack funcs */
 static inline msgpack_unpacker_stack_t* _msgpack_unpacker_stack_top(msgpack_unpacker_t* uk)
 {
@@ -242,12 +269,19 @@ static int read_raw_body_cont(msgpack_unpacker_t* uk)
         uk->reading_raw_remaining = length = length - n;
     } while(length > 0);
 
-    object_complete_string(uk, uk->reading_raw);
+    int ret;
+    if(uk->reading_raw_type == RAW_TYPE_STRING) {
+        ret = object_complete_string(uk, uk->reading_raw);
+    } else if(uk->reading_raw_type == RAW_TYPE_BINARY) {
+        ret = object_complete_binary(uk, uk->reading_raw);
+    } else {
+        ret = object_complete_ext(uk, uk->reading_raw_type, uk->reading_raw);
+    }
     uk->reading_raw = Qnil;
-    return PRIMITIVE_OBJECT_COMPLETE;
+    return ret;
 }
 
-static inline int read_raw_body_begin(msgpack_unpacker_t* uk, bool str)
+static inline int read_raw_body_begin(msgpack_unpacker_t* uk, int raw_type)
 {
     /* assuming uk->reading_raw == Qnil */
 
@@ -258,18 +292,22 @@ static inline int read_raw_body_begin(msgpack_unpacker_t* uk, bool str)
          * because rb_hash_aset freezes keys and it causes copying */
         bool will_freeze = is_reading_map_key(uk);
         VALUE string = msgpack_buffer_read_top_as_string(UNPACKER_BUFFER_(uk), length, will_freeze);
-        if(str == true) {
-            object_complete_string(uk, string);
+        int ret;
+        if(raw_type == RAW_TYPE_STRING) {
+            ret = object_complete_string(uk, string);
+        } else if(raw_type == RAW_TYPE_BINARY) {
+            ret = object_complete_binary(uk, string);
         } else {
-            object_complete_binary(uk, string);
+            ret = object_complete_ext(uk, raw_type, string);
         }
         if(will_freeze) {
             rb_obj_freeze(string);
         }
         uk->reading_raw_remaining = 0;
-        return PRIMITIVE_OBJECT_COMPLETE;
+        return ret;
     }
 
+    uk->reading_raw_type = raw_type;
     return read_raw_body_cont(uk);
 }
 
@@ -298,7 +336,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
         }
         /* read_raw_body_begin sets uk->reading_raw */
         uk->reading_raw_remaining = count;
-        return read_raw_body_begin(uk, true);
+        return read_raw_body_begin(uk, RAW_TYPE_STRING);
 
     SWITCH_RANGE(b, 0x90, 0x9f)  // FixArray
         int count = b & 0x0f;
@@ -327,9 +365,41 @@ static int read_primitive(msgpack_unpacker_t* uk)
         case 0xc3:  // true
             return object_complete(uk, Qtrue);
 
-        //case 0xc7: // ext 8
-        //case 0xc8: // ext 16
-        //case 0xc9: // ext 32
+        case 0xc7: // ext 8
+            {
+                READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 2);
+                uint8_t length = cb->u8;
+                int ext_type = cb->buffer[1];
+                if(length == 0) {
+                    return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
+                }
+                uk->reading_raw_remaining = length;
+                return read_raw_body_begin(uk, ext_type);
+            }
+
+        case 0xc8: // ext 16
+            {
+                READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 3);
+                uint16_t length = cb->u16;
+                int ext_type = cb->buffer[2];
+                if(length == 0) {
+                    return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
+                }
+                uk->reading_raw_remaining = length;
+                return read_raw_body_begin(uk, ext_type);
+            }
+
+        case 0xc9: // ext 32
+            {
+                READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 5);
+                uint32_t length = cb->u32;
+                int ext_type = cb->buffer[4];
+                if(length == 0) {
+                    return object_complete_ext(uk, ext_type, rb_str_buf_new(0));
+                }
+                uk->reading_raw_remaining = length;
+                return read_raw_body_begin(uk, ext_type);
+            }
 
         case 0xca:  // float
             {
@@ -401,11 +471,46 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 return object_complete(uk, rb_ll2inum(i64));
             }
 
-        //case 0xd4:  // fixext 1
-        //case 0xd5:  // fixext 2
-        //case 0xd6:  // fixext 4
-        //case 0xd7:  // fixext 8
-        //case 0xd8:  // fixext 16
+        case 0xd4:  // fixext 1
+            {
+                READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
+                int ext_type = cb->i8;
+                uk->reading_raw_remaining = 1;
+                return read_raw_body_begin(uk, ext_type);
+            }
+
+        case 0xd5:  // fixext 2
+            {
+                READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
+                int ext_type = cb->i8;
+                uk->reading_raw_remaining = 2;
+                return read_raw_body_begin(uk, ext_type);
+            }
+
+        case 0xd6:  // fixext 4
+            {
+                READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
+                int ext_type = cb->i8;
+                uk->reading_raw_remaining = 4;
+                return read_raw_body_begin(uk, ext_type);
+            }
+
+        case 0xd7:  // fixext 8
+            {
+                READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
+                int ext_type = cb->i8;
+                uk->reading_raw_remaining = 8;
+                return read_raw_body_begin(uk, ext_type);
+            }
+
+        case 0xd8:  // fixext 16
+            {
+                READ_CAST_BLOCK_OR_RETURN_EOF(cb, uk, 1);
+                int ext_type = cb->i8;
+                uk->reading_raw_remaining = 16;
+                return read_raw_body_begin(uk, ext_type);
+            }
+
 
         case 0xd9:  // raw 8 / str 8
             {
@@ -416,7 +521,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;
-                return read_raw_body_begin(uk, true);
+                return read_raw_body_begin(uk, RAW_TYPE_STRING);
             }
 
         case 0xda:  // raw 16 / str 16
@@ -428,7 +533,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;
-                return read_raw_body_begin(uk, true);
+                return read_raw_body_begin(uk, RAW_TYPE_STRING);
             }
 
         case 0xdb:  // raw 32 / str 32
@@ -440,7 +545,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;
-                return read_raw_body_begin(uk, true);
+                return read_raw_body_begin(uk, RAW_TYPE_STRING);
             }
 
         case 0xc4:  // bin 8
@@ -452,7 +557,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;
-                return read_raw_body_begin(uk, false);
+                return read_raw_body_begin(uk, RAW_TYPE_BINARY);
             }
 
         case 0xc5:  // bin 16
@@ -464,7 +569,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;
-                return read_raw_body_begin(uk, false);
+                return read_raw_body_begin(uk, RAW_TYPE_BINARY);
             }
 
         case 0xc6:  // bin 32
@@ -476,7 +581,7 @@ static int read_primitive(msgpack_unpacker_t* uk)
                 }
                 /* read_raw_body_begin sets uk->reading_raw */
                 uk->reading_raw_remaining = count;
-                return read_raw_body_begin(uk, false);
+                return read_raw_body_begin(uk, RAW_TYPE_BINARY);
             }
 
         case 0xdc:  // array 16