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

data/ext/msgpack/unpacker.h

@@ -19,6 +19,7 @@
 #define MSGPACK_RUBY_UNPACKER_H__
 
 #include "buffer.h"
+#include "unpacker_ext_registry.h"
 
 #ifndef MSGPACK_UNPACKER_STACK_CAPACITY
 #define MSGPACK_UNPACKER_STACK_CAPACITY 128
@@ -55,11 +56,15 @@ struct msgpack_unpacker_t {
 
     VALUE reading_raw;
     size_t reading_raw_remaining;
+    int reading_raw_type;
 
     VALUE buffer_ref;
 
+    msgpack_unpacker_ext_registry_t ext_registry;
+
     /* options */
     bool symbolize_keys;
+    bool allow_unknown_ext;
 };
 
 #define UNPACKER_BUFFER_(uk) (&(uk)->buffer)
@@ -91,6 +96,11 @@ static inline void msgpack_unpacker_set_symbolized_keys(msgpack_unpacker_t* uk,
     uk->symbolize_keys = enable;
 }
 
+static inline void msgpack_unpacker_set_allow_unknown_ext(msgpack_unpacker_t* uk, bool enable)
+{
+    uk->allow_unknown_ext = enable;
+}
+
 
 /* error codes */
 #define PRIMITIVE_CONTAINER_START 1
@@ -99,6 +109,7 @@ static inline void msgpack_unpacker_set_symbolized_keys(msgpack_unpacker_t* uk,
 #define PRIMITIVE_INVALID_BYTE -2
 #define PRIMITIVE_STACK_TOO_DEEP -3
 #define PRIMITIVE_UNEXPECTED_TYPE -4
+#define PRIMITIVE_UNEXPECTED_EXT_TYPE -5
 
 int msgpack_unpacker_read(msgpack_unpacker_t* uk, size_t target_stack_depth);
 

data/ext/msgpack/unpacker_class.c

@@ -19,6 +19,7 @@
 #include "unpacker.h"
 #include "unpacker_class.h"
 #include "buffer_class.h"
+#include "factory_class.h"
 
 VALUE cMessagePack_Unpacker;
 
@@ -28,7 +29,9 @@ VALUE cMessagePack_Unpacker;
 static VALUE eUnpackError;
 static VALUE eMalformedFormatError;
 static VALUE eStackError;
-static VALUE eTypeError;
+static VALUE eUnexpectedTypeError;
+static VALUE eUnknownExtTypeError;
+static VALUE mTypeError;  // obsoleted. only for backward compatibility. See #86.
 
 #define UNPACKER(from, name) \
     msgpack_unpacker_t *name = NULL; \
@@ -42,23 +45,31 @@ static void Unpacker_free(msgpack_unpacker_t* uk)
     if(uk == NULL) {
         return;
     }
+    msgpack_unpacker_ext_registry_destroy(&uk->ext_registry);
     _msgpack_unpacker_destroy(uk);
     free(uk);
 }
 
-static VALUE Unpacker_alloc(VALUE klass)
+static void Unpacker_mark(msgpack_unpacker_t* uk)
+{
+    msgpack_unpacker_mark(uk);
+    msgpack_unpacker_ext_registry_mark(&uk->ext_registry);
+}
+
+VALUE MessagePack_Unpacker_alloc(VALUE klass)
 {
     msgpack_unpacker_t* uk = ALLOC_N(msgpack_unpacker_t, 1);
     _msgpack_unpacker_init(uk);
 
-    VALUE self = Data_Wrap_Struct(klass, msgpack_unpacker_mark, Unpacker_free, uk);
+    VALUE self = Data_Wrap_Struct(klass, Unpacker_mark, Unpacker_free, uk);
 
+    msgpack_unpacker_ext_registry_init(&uk->ext_registry);
     uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
 
     return self;
 }
 
-static VALUE Unpacker_initialize(int argc, VALUE* argv, VALUE self)
+VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
 {
     VALUE io = Qnil;
     VALUE options = Qnil;
@@ -90,21 +101,19 @@ static VALUE Unpacker_initialize(int argc, VALUE* argv, VALUE self)
 
     UNPACKER(self, uk);
 
-    MessagePack_Unpacker_initialize(uk, io, options);
-
-    return self;
-}
-
-void MessagePack_Unpacker_initialize(msgpack_unpacker_t* uk, VALUE io, VALUE options)
-{
-    MessagePack_Buffer_initialize(UNPACKER_BUFFER_(uk), io, options);
+    MessagePack_Buffer_set_options(UNPACKER_BUFFER_(uk), io, options);
 
     if(options != Qnil) {
         VALUE v;
 
         v = rb_hash_aref(options, ID2SYM(rb_intern("symbolize_keys")));
         msgpack_unpacker_set_symbolized_keys(uk, RTEST(v));
+
+        v = rb_hash_aref(options, ID2SYM(rb_intern("allow_unknown_ext")));
+        msgpack_unpacker_set_allow_unknown_ext(uk, RTEST(v));
     }
+
+    return self;
 }
 
 static void raise_unpacker_error(int r)
@@ -117,7 +126,9 @@ static void raise_unpacker_error(int r)
     case PRIMITIVE_STACK_TOO_DEEP:
         rb_raise(eStackError, "stack level too deep");
     case PRIMITIVE_UNEXPECTED_TYPE:
-        rb_raise(eTypeError, "unexpected type");
+        rb_raise(eUnexpectedTypeError, "unexpected type");
+    case PRIMITIVE_UNEXPECTED_EXT_TYPE:
+        rb_raise(eUnknownExtTypeError, "unexpected extension type");
     default:
         rb_raise(eUnpackError, "logically unknown error %d", r);
     }
@@ -283,6 +294,13 @@ static VALUE Unpacker_each(VALUE self)
 
 static VALUE Unpacker_feed_each(VALUE self, VALUE data)
 {
+#ifdef RETURN_ENUMERATOR
+    {
+        VALUE argv[] = { data };
+        RETURN_ENUMERATOR(self, sizeof(argv) / sizeof(VALUE), argv);
+    }
+#endif
+
     // TODO optimize
     Unpacker_feed(self, data);
     return Unpacker_each(self);
@@ -297,39 +315,83 @@ static VALUE Unpacker_reset(VALUE self)
     return Qnil;
 }
 
-VALUE MessagePack_unpack(int argc, VALUE* argv)
+static VALUE Unpacker_registered_types_internal(VALUE self)
 {
-    VALUE src;
-    VALUE options = Qnil;
+    UNPACKER(self, uk);
 
-    switch(argc) {
-    case 2:
-        options = argv[1];
-        if(rb_type(options) != T_HASH) {
-            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
+    VALUE mapping = rb_hash_new();
+    for(int i=0; i < 256; i++) {
+        if(uk->ext_registry.array[i] != Qnil) {
+            rb_hash_aset(mapping, INT2FIX(i - 128), uk->ext_registry.array[i]);
         }
-        /* pass-through */
+    }
+
+    return mapping;
+}
+
+static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
+{
+    UNPACKER(self, uk);
+
+    int ext_type;
+    VALUE proc;
+    VALUE arg;
+    VALUE ext_class;
+
+    switch (argc) {
     case 1:
-        src = argv[0];
+        /* register_type(0x7f) {|data| block... } */
+        rb_need_block();
+#ifdef HAVE_RB_BLOCK_LAMBDA
+        proc = rb_block_lambda();
+#else
+        /* MRI 1.8 */
+        proc = rb_block_proc();
+#endif
+        arg = proc;
+        ext_class = Qnil;
+        break;
+    case 3:
+        /* register_type(0x7f, Time, :from_msgpack_ext) */
+        ext_class = argv[1];
+        arg = argv[2];
+        proc = rb_obj_method(ext_class, arg);
         break;
     default:
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 3)", argc);
     }
 
-    VALUE self = Unpacker_alloc(cMessagePack_Unpacker);
-    UNPACKER(self, uk);
-    //_msgpack_unpacker_reset(s_unpacker);
-    //msgpack_buffer_reset_io(UNPACKER_BUFFER_(s_unpacker));
+    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);
+    }
 
-    /* prefer reference than copying; see MessagePack_Unpacker_module_init */
-    msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(uk), 0);
+    msgpack_unpacker_ext_registry_put(&uk->ext_registry, ext_class, ext_type, proc, arg);
+
+    return Qnil;
+}
+
+VALUE MessagePack_unpack(int argc, VALUE* argv)
+{
+    VALUE src;
+    VALUE self;
+
+    if (argc < 0 || argc > 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+    }
+    src = argv[0];
 
     if(rb_type(src) == T_STRING) {
-        MessagePack_Unpacker_initialize(uk, Qnil, options);
+        self = MessagePack_Factory_unpacker(argc - 1, argv + 1, cMessagePack_DefaultFactory);
+        UNPACKER(self, uk);
         msgpack_buffer_append_string(UNPACKER_BUFFER_(uk), src);
     } else {
-        MessagePack_Unpacker_initialize(uk, src, options);
+        self = MessagePack_Factory_unpacker(argc, argv, cMessagePack_DefaultFactory);
     }
+    UNPACKER(self, uk);
+
+    /* prefer reference than copying; see MessagePack_Unpacker_module_init */
+    msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(uk), 0);
 
     int r = msgpack_unpacker_read(uk, 0);
     if(r < 0) {
@@ -337,8 +399,9 @@ VALUE MessagePack_unpack(int argc, VALUE* argv)
     }
 
     /* raise if extra bytes follow */
-    if(msgpack_buffer_top_readable_size(UNPACKER_BUFFER_(uk)) > 0) {
-        rb_raise(eMalformedFormatError, "extra bytes follow after a deserialized object");
+    size_t extra = msgpack_buffer_top_readable_size(UNPACKER_BUFFER_(uk));
+    if(extra > 0) {
+        rb_raise(eMalformedFormatError, "%zd extra bytes after the deserialized object", extra);
     }
 
 #ifdef RB_GC_GUARD
@@ -362,9 +425,19 @@ static VALUE MessagePack_unpack_module_method(int argc, VALUE* argv, VALUE mod)
     return MessagePack_unpack(argc, argv);
 }
 
+VALUE MessagePack_Unpacker_new(int argc, VALUE* argv)
+{
+    VALUE self = MessagePack_Unpacker_alloc(cMessagePack_Unpacker);
+    MessagePack_Unpacker_initialize(argc, argv, self);
+    return self;
+}
+
 void MessagePack_Unpacker_module_init(VALUE mMessagePack)
 {
     msgpack_unpacker_static_init();
+    msgpack_unpacker_ext_registry_static_init();
+
+    mTypeError = rb_define_module_under(mMessagePack, "TypeError");
 
     cMessagePack_Unpacker = rb_define_class_under(mMessagePack, "Unpacker", rb_cObject);
 
@@ -374,11 +447,14 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
 
     eStackError = rb_define_class_under(mMessagePack, "StackError", eUnpackError);
 
-    eTypeError = rb_define_class_under(mMessagePack, "TypeError", rb_eStandardError);
+    eUnexpectedTypeError = rb_define_class_under(mMessagePack, "UnexpectedTypeError", eUnpackError);
+    rb_include_module(eUnexpectedTypeError, mTypeError);
+
+    eUnknownExtTypeError = rb_define_class_under(mMessagePack, "UnknownExtTypeError", eUnpackError);
 
-    rb_define_alloc_func(cMessagePack_Unpacker, Unpacker_alloc);
+    rb_define_alloc_func(cMessagePack_Unpacker, MessagePack_Unpacker_alloc);
 
-    rb_define_method(cMessagePack_Unpacker, "initialize", Unpacker_initialize, -1);
+    rb_define_method(cMessagePack_Unpacker, "initialize", MessagePack_Unpacker_initialize, -1);
     rb_define_method(cMessagePack_Unpacker, "buffer", Unpacker_buffer, 0);
     rb_define_method(cMessagePack_Unpacker, "read", Unpacker_read, 0);
     rb_define_alias(cMessagePack_Unpacker, "unpack", "read");
@@ -392,7 +468,10 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Unpacker, "feed_each", Unpacker_feed_each, 1);
     rb_define_method(cMessagePack_Unpacker, "reset", Unpacker_reset, 0);
 
-    //s_unpacker_value = Unpacker_alloc(cMessagePack_Unpacker);
+    rb_define_private_method(cMessagePack_Unpacker, "registered_types_internal", Unpacker_registered_types_internal, 0);
+    rb_define_method(cMessagePack_Unpacker, "register_type", Unpacker_register_type, -1);
+
+    //s_unpacker_value = MessagePack_Unpacker_alloc(cMessagePack_Unpacker);
     //rb_gc_register_address(&s_unpacker_value);
     //Data_Get_Struct(s_unpacker_value, msgpack_unpacker_t, s_unpacker);
     /* prefer reference than copying */

data/ext/msgpack/unpacker_class.h

@@ -24,9 +24,11 @@ extern VALUE cMessagePack_Unpacker;
 
 void MessagePack_Unpacker_module_init(VALUE mMessagePack);
 
-VALUE MessagePack_unpack(int argc, VALUE* argv);
+VALUE MessagePack_Unpacker_alloc(VALUE klass);
+
+VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self);
 
-void MessagePack_Unpacker_initialize(msgpack_unpacker_t* uk, VALUE io, VALUE options);
+VALUE MessagePack_unpack(int argc, VALUE* argv);
 
 #endif
 

data/ext/msgpack/unpacker_ext_registry.c

@@ -0,0 +1,68 @@
+/*
+ * 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 "unpacker_ext_registry.h"
+
+static ID s_call;
+static ID s_dup;
+
+void msgpack_unpacker_ext_registry_static_init()
+{
+    s_call = rb_intern("call");
+    s_dup = rb_intern("dup");
+}
+
+void msgpack_unpacker_ext_registry_static_destroy()
+{ }
+
+void msgpack_unpacker_ext_registry_init(msgpack_unpacker_ext_registry_t* ukrg)
+{
+    for(int i=0; i < 256; i++) {
+        ukrg->array[i] = Qnil;
+    }
+}
+
+void msgpack_unpacker_ext_registry_mark(msgpack_unpacker_ext_registry_t* ukrg)
+{
+    for(int i=0; i < 256; i++) {
+        rb_gc_mark(ukrg->array[i]);
+    }
+}
+
+void msgpack_unpacker_ext_registry_dup(msgpack_unpacker_ext_registry_t* src,
+        msgpack_unpacker_ext_registry_t* dst)
+{
+    for(int i=0; i < 256; i++) {
+        dst->array[i] = src->array[i];
+    }
+}
+
+VALUE msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t* ukrg,
+        VALUE ext_class, int ext_type, VALUE proc, VALUE arg)
+{
+    VALUE e = rb_ary_new3(3, ext_class, proc, arg);
+    VALUE before = ukrg->array[ext_type + 128];
+    ukrg->array[ext_type + 128] = e;
+    return before;
+}
+
+VALUE msgpack_unpacker_ext_registry_call(msgpack_unpacker_ext_registry_t* ukrg,
+        VALUE proc, VALUE ext_data)
+{
+    return rb_funcall(proc, s_call, 1, ext_data);
+}

data/ext/msgpack/unpacker_ext_registry.h

@@ -0,0 +1,62 @@
+/*
+ * 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_PACKER_PACKER_EXT_REGISTRY_H__
+#define MSGPACK_RUBY_PACKER_PACKER_EXT_REGISTRY_H__
+
+#include "compat.h"
+#include "ruby.h"
+
+struct msgpack_unpacker_ext_registry_t;
+typedef struct msgpack_unpacker_ext_registry_t msgpack_unpacker_ext_registry_t;
+
+struct msgpack_unpacker_ext_registry_t {
+    VALUE array[256];
+    //int bitmap;
+};
+
+void msgpack_unpacker_ext_registry_static_init();
+
+void msgpack_unpacker_ext_registry_static_destroy();
+
+void msgpack_unpacker_ext_registry_init(msgpack_unpacker_ext_registry_t* ukrg);
+
+static inline void msgpack_unpacker_ext_registry_destroy(msgpack_unpacker_ext_registry_t* ukrg)
+{ }
+
+void msgpack_unpacker_ext_registry_mark(msgpack_unpacker_ext_registry_t* ukrg);
+
+void msgpack_unpacker_ext_registry_dup(msgpack_unpacker_ext_registry_t* src,
+        msgpack_unpacker_ext_registry_t* dst);
+
+VALUE msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t* ukrg,
+        VALUE ext_class, int ext_type, VALUE proc, VALUE arg);
+
+static inline VALUE msgpack_unpacker_ext_registry_lookup(msgpack_unpacker_ext_registry_t* ukrg,
+        int ext_type)
+{
+    VALUE e = ukrg->array[ext_type + 128];
+    if(e == Qnil) {
+        return Qnil;
+    }
+    return rb_ary_entry(e, 1);
+}
+
+VALUE msgpack_unpacker_ext_registry_call(msgpack_unpacker_ext_registry_t* ukrg,
+        VALUE proc, VALUE ext_data);
+
+#endif