msgpack 1.5.6 → 1.8.0

data/ext/msgpack/unpacker.h

@@ -21,9 +21,7 @@
 #include "buffer.h"
 #include "unpacker_ext_registry.h"
 
-#ifndef MSGPACK_UNPACKER_STACK_CAPACITY
 #define MSGPACK_UNPACKER_STACK_CAPACITY 128
-#endif
 
 struct msgpack_unpacker_t;
 typedef struct msgpack_unpacker_t msgpack_unpacker_t;
@@ -33,6 +31,7 @@ enum stack_type_t {
     STACK_TYPE_ARRAY,
     STACK_TYPE_MAP_KEY,
     STACK_TYPE_MAP_VALUE,
+    STACK_TYPE_RECURSIVE,
 };
 
 typedef struct {
@@ -46,32 +45,34 @@ struct msgpack_unpacker_stack_t {
     size_t depth;
     size_t capacity;
     msgpack_unpacker_stack_entry_t *data;
-    msgpack_unpacker_stack_t *parent;
 };
 
-#define MSGPACK_UNPACKER_STACK_SIZE (8+4+8+8)  /* assumes size_t <= 64bit, enum <= 32bit, VALUE <= 64bit */
-
 struct msgpack_unpacker_t {
     msgpack_buffer_t buffer;
-    msgpack_unpacker_stack_t *stack;
-    unsigned int head_byte;
+    msgpack_unpacker_stack_t stack;
+    msgpack_key_cache_t key_cache;
 
+    VALUE self;
     VALUE last_object;
 
     VALUE reading_raw;
     size_t reading_raw_remaining;
-    int reading_raw_type;
 
     VALUE buffer_ref;
 
     msgpack_unpacker_ext_registry_t *ext_registry;
 
+    int reading_raw_type;
+    unsigned int head_byte;
+
     /* options */
-    bool symbolize_keys;
-    bool freeze;
-    bool allow_unknown_ext;
-    bool optimized_symbol_ext_type;
     int symbol_ext_type;
+
+    bool use_key_cache: 1;
+    bool symbolize_keys: 1;
+    bool freeze: 1;
+    bool allow_unknown_ext: 1;
+    bool optimized_symbol_ext_type: 1;
 };
 
 #define UNPACKER_BUFFER_(uk) (&(uk)->buffer)
@@ -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);
 
@@ -103,6 +104,11 @@ static inline void msgpack_unpacker_set_symbolized_keys(msgpack_unpacker_t* uk,
     uk->symbolize_keys = enable;
 }
 
+static inline void msgpack_unpacker_set_key_cache(msgpack_unpacker_t* uk, bool enable)
+{
+    uk->use_key_cache = enable;
+}
+
 static inline void msgpack_unpacker_set_freeze(msgpack_unpacker_t* uk, bool enable)
 {
     uk->freeze = enable;
@@ -122,6 +128,7 @@ static inline void msgpack_unpacker_set_allow_unknown_ext(msgpack_unpacker_t* uk
 #define PRIMITIVE_STACK_TOO_DEEP -3
 #define PRIMITIVE_UNEXPECTED_TYPE -4
 #define PRIMITIVE_UNEXPECTED_EXT_TYPE -5
+#define PRIMITIVE_RECURSIVE_RAISED -6
 
 int msgpack_unpacker_read(msgpack_unpacker_t* uk, size_t target_stack_depth);
 

data/ext/msgpack/unpacker_class.c

@@ -34,18 +34,13 @@ static VALUE eUnknownExtTypeError;
 static VALUE mTypeError;  // obsoleted. only for backward compatibility. See #86.
 
 static VALUE sym_symbolize_keys;
+static VALUE sym_key_cache;
 static VALUE sym_freeze;
 static VALUE sym_allow_unknown_ext;
 
-#define UNPACKER(from, name) \
-    msgpack_unpacker_t *name = NULL; \
-    Data_Get_Struct(from, msgpack_unpacker_t, name); \
-    if(name == NULL) { \
-        rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
-    }
-
-static void Unpacker_free(msgpack_unpacker_t* uk)
+static void Unpacker_free(void *ptr)
 {
+    msgpack_unpacker_t* uk = ptr;
     if(uk == NULL) {
         return;
     }
@@ -54,17 +49,47 @@ static void Unpacker_free(msgpack_unpacker_t* uk)
     xfree(uk);
 }
 
-static void Unpacker_mark(msgpack_unpacker_t* uk)
+static void Unpacker_mark(void *ptr)
 {
+    msgpack_unpacker_t* uk = ptr;
+    msgpack_buffer_mark(uk);
     msgpack_unpacker_mark(uk);
     msgpack_unpacker_ext_registry_mark(uk->ext_registry);
 }
 
-VALUE MessagePack_Unpacker_alloc(VALUE klass)
+static size_t Unpacker_memsize(const void *ptr)
 {
-    msgpack_unpacker_t* uk = _msgpack_unpacker_new();
+    const msgpack_unpacker_t* uk = ptr;
+
+    size_t total_size = sizeof(msgpack_unpacker_t);
+
+    if (uk->ext_registry) {
+        total_size += sizeof(msgpack_unpacker_ext_registry_t) / (uk->ext_registry->borrow_count + 1);
+    }
 
-    VALUE self = Data_Wrap_Struct(klass, Unpacker_mark, Unpacker_free, uk);
+    if (uk->stack.data) {
+        total_size += (uk->stack.depth + 1) * sizeof(msgpack_unpacker_stack_t);
+    }
+
+    return total_size + msgpack_buffer_memsize(&uk->buffer);
+}
+
+const rb_data_type_t unpacker_data_type = {
+    .wrap_struct_name = "msgpack:unpacker",
+    .function = {
+        .dmark = Unpacker_mark,
+        .dfree = Unpacker_free,
+        .dsize = Unpacker_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE MessagePack_Unpacker_alloc(VALUE klass)
+{
+    msgpack_unpacker_t* uk;
+    VALUE self = TypedData_Make_Struct(klass, msgpack_unpacker_t, &unpacker_data_type, uk);
+    _msgpack_unpacker_init(uk);
+    uk->self = self;
     return self;
 }
 
@@ -95,15 +120,18 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
         rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
     }
 
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
-    uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
+    uk->buffer_ref = Qnil;
 
     MessagePack_Buffer_set_options(UNPACKER_BUFFER_(uk), io, options);
 
     if(options != Qnil) {
         VALUE v;
 
+        v = rb_hash_aref(options, sym_key_cache);
+        msgpack_unpacker_set_key_cache(uk, RTEST(v));
+
         v = rb_hash_aref(options, sym_symbolize_keys);
         msgpack_unpacker_set_symbolized_keys(uk, RTEST(v));
 
@@ -119,36 +147,44 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
 
 static VALUE Unpacker_symbolized_keys_p(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
     return uk->symbolize_keys ? Qtrue : Qfalse;
 }
 
 static VALUE Unpacker_freeze_p(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
     return uk->freeze ? Qtrue : Qfalse;
 }
 
 static VALUE Unpacker_allow_unknown_ext_p(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
     return uk->allow_unknown_ext ? Qtrue : Qfalse;
 }
 
-NORETURN(static void raise_unpacker_error(int r))
+NORETURN(static void raise_unpacker_error(msgpack_unpacker_t *uk, int r))
 {
+    uk->stack.depth = 0;
     switch(r) {
     case PRIMITIVE_EOF:
         rb_raise(rb_eEOFError, "end of buffer reached");
+        break;
     case PRIMITIVE_INVALID_BYTE:
         rb_raise(eMalformedFormatError, "invalid byte");
+        break;
     case PRIMITIVE_STACK_TOO_DEEP:
         rb_raise(eStackError, "stack level too deep");
+        break;
     case PRIMITIVE_UNEXPECTED_TYPE:
         rb_raise(eUnexpectedTypeError, "unexpected type");
+        break;
     case PRIMITIVE_UNEXPECTED_EXT_TYPE:
-    // rb_bug("unexpected extension type");
         rb_raise(eUnknownExtTypeError, "unexpected extension type");
+        break;
+    case PRIMITIVE_RECURSIVE_RAISED:
+        rb_exc_raise(msgpack_unpacker_get_last_object(uk));
+        break;
     default:
         rb_raise(eUnpackError, "logically unknown error %d", r);
     }
@@ -156,17 +192,20 @@ NORETURN(static void raise_unpacker_error(int r))
 
 static VALUE Unpacker_buffer(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
+    if (!RTEST(uk->buffer_ref)) {
+        uk->buffer_ref = MessagePack_Buffer_wrap(UNPACKER_BUFFER_(uk), self);
+    }
     return uk->buffer_ref;
 }
 
 static VALUE Unpacker_read(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     int r = msgpack_unpacker_read(uk, 0);
     if(r < 0) {
-        raise_unpacker_error(r);
+        raise_unpacker_error(uk, r);
     }
 
     return msgpack_unpacker_get_last_object(uk);
@@ -174,11 +213,11 @@ static VALUE Unpacker_read(VALUE self)
 
 static VALUE Unpacker_skip(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     int r = msgpack_unpacker_skip(uk, 0);
     if(r < 0) {
-        raise_unpacker_error(r);
+        raise_unpacker_error(uk, r);
     }
 
     return Qnil;
@@ -186,11 +225,11 @@ static VALUE Unpacker_skip(VALUE self)
 
 static VALUE Unpacker_skip_nil(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     int r = msgpack_unpacker_skip_nil(uk);
     if(r < 0) {
-        raise_unpacker_error(r);
+        raise_unpacker_error(uk, r);
     }
 
     if(r) {
@@ -201,12 +240,12 @@ static VALUE Unpacker_skip_nil(VALUE self)
 
 static VALUE Unpacker_read_array_header(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     uint32_t size;
     int r = msgpack_unpacker_read_array_header(uk, &size);
     if(r < 0) {
-        raise_unpacker_error(r);
+        raise_unpacker_error(uk, r);
     }
 
     return ULONG2NUM(size); // long at least 32 bits
@@ -214,32 +253,20 @@ static VALUE Unpacker_read_array_header(VALUE self)
 
 static VALUE Unpacker_read_map_header(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     uint32_t size;
     int r = msgpack_unpacker_read_map_header(uk, &size);
     if(r < 0) {
-        raise_unpacker_error((int)r);
+        raise_unpacker_error(uk, r);
     }
 
     return ULONG2NUM(size); // long at least 32 bits
 }
 
-
-static VALUE Unpacker_feed(VALUE self, VALUE data)
-{
-    UNPACKER(self, uk);
-
-    StringValue(data);
-
-    msgpack_buffer_append_string(UNPACKER_BUFFER_(uk), data);
-
-    return self;
-}
-
 static VALUE Unpacker_feed_reference(VALUE self, VALUE data)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     StringValue(data);
 
@@ -250,7 +277,7 @@ static VALUE Unpacker_feed_reference(VALUE self, VALUE data)
 
 static VALUE Unpacker_each_impl(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     while(true) {
         int r = msgpack_unpacker_read(uk, 0);
@@ -258,15 +285,9 @@ static VALUE Unpacker_each_impl(VALUE self)
             if(r == PRIMITIVE_EOF) {
                 return Qnil;
             }
-            raise_unpacker_error(r);
+            raise_unpacker_error(uk, r);
         }
         VALUE v = msgpack_unpacker_get_last_object(uk);
-#ifdef JRUBY
-        /* TODO JRuby's rb_yield behaves differently from Ruby 1.9.3 or Rubinius. */
-        if(rb_type(v) == T_ARRAY) {
-            v = rb_ary_new3(1, v);
-        }
-#endif
         rb_yield(v);
     }
 }
@@ -280,7 +301,7 @@ static VALUE Unpacker_rescue_EOFError(VALUE args, VALUE error)
 
 static VALUE Unpacker_each(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
 #ifdef RETURN_ENUMERATOR
     RETURN_ENUMERATOR(self, 0, 0);
@@ -311,7 +332,7 @@ static VALUE Unpacker_feed_each(VALUE self, VALUE data)
 
 static VALUE Unpacker_reset(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     _msgpack_unpacker_reset(uk);
 
@@ -320,7 +341,7 @@ static VALUE Unpacker_reset(VALUE self)
 
 static VALUE Unpacker_registered_types_internal(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     VALUE mapping = rb_hash_new();
     if (uk->ext_registry) {
@@ -334,50 +355,30 @@ static VALUE Unpacker_registered_types_internal(VALUE self)
     return mapping;
 }
 
-static VALUE Unpacker_register_type(int argc, VALUE* argv, VALUE self)
+static VALUE Unpacker_register_type_internal(VALUE self, VALUE rb_ext_type, VALUE ext_module, VALUE proc)
 {
-    UNPACKER(self, uk);
-
-    int ext_type;
-    VALUE proc;
-    VALUE arg;
-    VALUE ext_module;
-
-    switch (argc) {
-    case 1:
-        /* register_type(0x7f) {|data| block... } */
-        rb_need_block();
-        proc = rb_block_lambda();
-        arg = proc;
-        ext_module = Qnil;
-        break;
-    case 3:
-        /* register_type(0x7f, Time, :from_msgpack_ext) */
-        ext_module = argv[1];
-        arg = argv[2];
-        proc = rb_obj_method(ext_module, arg);
-        break;
-    default:
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 3)", argc);
+    if (OBJ_FROZEN(self)) {
+        rb_raise(rb_eFrozenError, "can't modify frozen MessagePack::Unpacker");
     }
 
-    ext_type = NUM2INT(argv[0]);
+    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);
     }
 
-    msgpack_unpacker_ext_registry_put(&uk->ext_registry, ext_module, ext_type, 0, proc, arg);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
+    msgpack_unpacker_ext_registry_put(self, &uk->ext_registry, ext_module, ext_type, 0, proc);
 
     return Qnil;
 }
 
 static VALUE Unpacker_full_unpack(VALUE self)
 {
-    UNPACKER(self, uk);
+    msgpack_unpacker_t *uk = MessagePack_Unpacker_get(self);
 
     int r = msgpack_unpacker_read(uk, 0);
     if(r < 0) {
-        raise_unpacker_error(r);
+        raise_unpacker_error(uk, r);
     }
 
     /* raise if extra bytes follow */
@@ -399,7 +400,6 @@ VALUE MessagePack_Unpacker_new(int argc, VALUE* argv)
 void MessagePack_Unpacker_module_init(VALUE mMessagePack)
 {
     msgpack_unpacker_static_init();
-    msgpack_unpacker_ext_registry_static_init();
 
     mTypeError = rb_define_module_under(mMessagePack, "TypeError");
 
@@ -417,6 +417,7 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     eUnknownExtTypeError = rb_define_class_under(mMessagePack, "UnknownExtTypeError", eUnpackError);
 
     sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
+    sym_key_cache = ID2SYM(rb_intern("key_cache"));
     sym_freeze = ID2SYM(rb_intern("freeze"));
     sym_allow_unknown_ext = ID2SYM(rb_intern("allow_unknown_ext"));
 
@@ -433,20 +434,14 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_method(cMessagePack_Unpacker, "skip_nil", Unpacker_skip_nil, 0);
     rb_define_method(cMessagePack_Unpacker, "read_array_header", Unpacker_read_array_header, 0);
     rb_define_method(cMessagePack_Unpacker, "read_map_header", Unpacker_read_map_header, 0);
-    rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed, 1);
-    rb_define_method(cMessagePack_Unpacker, "feed_reference", Unpacker_feed_reference, 1);
+    rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed_reference, 1);
+    rb_define_alias(cMessagePack_Unpacker, "feed_reference", "feed");
     rb_define_method(cMessagePack_Unpacker, "each", Unpacker_each, 0);
     rb_define_method(cMessagePack_Unpacker, "feed_each", Unpacker_feed_each, 1);
     rb_define_method(cMessagePack_Unpacker, "reset", Unpacker_reset, 0);
 
     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 */
-    //msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(s_unpacker), 0);
+    rb_define_private_method(cMessagePack_Unpacker, "register_type_internal", Unpacker_register_type_internal, 3);
 
     rb_define_method(cMessagePack_Unpacker, "full_unpack", Unpacker_full_unpack, 0);
 }

data/ext/msgpack/unpacker_class.h

@@ -20,6 +20,17 @@
 
 #include "unpacker.h"
 
+extern const rb_data_type_t unpacker_data_type;
+
+static inline msgpack_unpacker_t *MessagePack_Unpacker_get(VALUE object) {
+    msgpack_unpacker_t *unpacker;
+    TypedData_Get_Struct(object, msgpack_unpacker_t, &unpacker_data_type, unpacker);
+    if (!unpacker) {
+        rb_raise(rb_eArgError, "Uninitialized Unpacker object");
+    }
+    return unpacker;
+}
+
 extern VALUE cMessagePack_Unpacker;
 
 void MessagePack_Unpacker_module_init(VALUE mMessagePack);

data/ext/msgpack/unpacker_ext_registry.c

@@ -18,19 +18,6 @@
 
 #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_mark(msgpack_unpacker_ext_registry_t* ukrg)
 {
     if (ukrg) {
@@ -76,11 +63,12 @@ void msgpack_unpacker_ext_registry_release(msgpack_unpacker_ext_registry_t* ukrg
     }
 }
 
-void msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t** ukrg,
-        VALUE ext_module, int ext_type, int flags, VALUE proc, VALUE arg)
+void msgpack_unpacker_ext_registry_put(VALUE owner, msgpack_unpacker_ext_registry_t** ukrg,
+        VALUE ext_module, int ext_type, int flags, VALUE proc)
 {
     msgpack_unpacker_ext_registry_t* ext_registry = msgpack_unpacker_ext_registry_cow(*ukrg);
 
-    ext_registry->array[ext_type + 128] = rb_ary_new3(4, ext_module, proc, arg, INT2FIX(flags));
+    VALUE entry = rb_ary_new3(3, ext_module, proc, INT2FIX(flags));
+    RB_OBJ_WRITE(owner, &ext_registry->array[ext_type + 128], entry);
     *ukrg = ext_registry;
 }

data/ext/msgpack/unpacker_ext_registry.h

@@ -31,10 +31,6 @@ struct msgpack_unpacker_ext_registry_t {
     VALUE array[256];
 };
 
-void msgpack_unpacker_ext_registry_static_init();
-
-void msgpack_unpacker_ext_registry_static_destroy();
-
 void msgpack_unpacker_ext_registry_release(msgpack_unpacker_ext_registry_t* ukrg);
 
 static inline void msgpack_unpacker_ext_registry_borrow(msgpack_unpacker_ext_registry_t* src, msgpack_unpacker_ext_registry_t** dst)
@@ -47,8 +43,8 @@ static inline void msgpack_unpacker_ext_registry_borrow(msgpack_unpacker_ext_reg
 
 void msgpack_unpacker_ext_registry_mark(msgpack_unpacker_ext_registry_t* ukrg);
 
-void msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t** ukrg,
-        VALUE ext_module, int ext_type, int flags, VALUE proc, VALUE arg);
+void msgpack_unpacker_ext_registry_put(VALUE owner, msgpack_unpacker_ext_registry_t** ukrg,
+        VALUE ext_module, int ext_type, int flags, VALUE proc);
 
 static inline VALUE msgpack_unpacker_ext_registry_lookup(msgpack_unpacker_ext_registry_t* ukrg,
         int ext_type, int* ext_flags_result)
@@ -56,7 +52,7 @@ static inline VALUE msgpack_unpacker_ext_registry_lookup(msgpack_unpacker_ext_re
     if (ukrg) {
         VALUE entry = ukrg->array[ext_type + 128];
         if (entry != Qnil) {
-            *ext_flags_result = FIX2INT(rb_ary_entry(entry, 3));
+            *ext_flags_result = FIX2INT(rb_ary_entry(entry, 2));
             return rb_ary_entry(entry, 1);
         }
     }

data/lib/msgpack/buffer.rb

@@ -0,0 +1,9 @@
+module MessagePack
+  class Buffer
+    # see ext for other methods
+
+    # The semantic of duping a buffer is just too weird.
+    undef_method :dup
+    undef_method :clone
+  end
+end