packsnap 0.0.1

data/ext/packsnap/buffer.hh

@@ -0,0 +1,439 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2012 FURUHASHI Sadayuki
+ *
+ *    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_BUFFER_H__
+#define MSGPACK_RUBY_BUFFER_H__
+
+#include "compat.h"
+#include "sysdep.h"
+
+#ifndef MSGPACK_BUFFER_STRING_WRITE_REFERENCE_DEFAULT
+#define MSGPACK_BUFFER_STRING_WRITE_REFERENCE_DEFAULT (512*1024)
+#endif
+
+/* at least 23 (RSTRING_EMBED_LEN_MAX) bytes */
+#ifndef MSGPACK_BUFFER_STRING_WRITE_REFERENCE_MINIMUM
+#define MSGPACK_BUFFER_STRING_WRITE_REFERENCE_MINIMUM 256
+#endif
+
+#ifndef MSGPACK_BUFFER_STRING_READ_REFERENCE_DEFAULT
+#define MSGPACK_BUFFER_STRING_READ_REFERENCE_DEFAULT 256
+#endif
+
+/* at least 23 (RSTRING_EMBED_LEN_MAX) bytes */
+#ifndef MSGPACK_BUFFER_STRING_READ_REFERENCE_MINIMUM
+#define MSGPACK_BUFFER_STRING_READ_REFERENCE_MINIMUM 256
+#endif
+
+#ifndef MSGPACK_BUFFER_IO_BUFFER_SIZE_DEFAULT
+#define MSGPACK_BUFFER_IO_BUFFER_SIZE_DEFAULT (32*1024)
+#endif
+
+#ifndef MSGPACK_BUFFER_IO_BUFFER_SIZE_MINIMUM
+#define MSGPACK_BUFFER_IO_BUFFER_SIZE_MINIMUM (1024)
+#endif
+
+#define NO_MAPPED_STRING ((VALUE)0)
+
+struct msgpack_buffer_chunk_t;
+typedef struct msgpack_buffer_chunk_t msgpack_buffer_chunk_t;
+
+struct msgpack_buffer_t;
+typedef struct msgpack_buffer_t msgpack_buffer_t;
+
+/*
+ * msgpack_buffer_chunk_t
+ * +----------------+
+ * | filled  | free |
+ * +---------+------+
+ * ^ first   ^ last
+ */
+struct msgpack_buffer_chunk_t {
+    char* first;
+    char* last;
+    void* mem;
+    msgpack_buffer_chunk_t* next;
+    VALUE mapped_string;  /* RBString or NO_MAPPED_STRING */
+};
+
+union msgpack_buffer_cast_block_t {
+    char buffer[8];
+    uint8_t u8;
+    uint16_t u16;
+    uint32_t u32;
+    uint64_t u64;
+    int8_t i8;
+    int16_t i16;
+    int32_t i32;
+    int64_t i64;
+    float f;
+    double d;
+};
+
+struct msgpack_buffer_t {
+    char* read_buffer;
+    char* tail_buffer_end;
+
+    msgpack_buffer_chunk_t tail;
+    msgpack_buffer_chunk_t* head;
+    msgpack_buffer_chunk_t* free_list;
+
+    char* rmem_last;
+    char* rmem_end;
+    void** rmem_owner;
+
+    union msgpack_buffer_cast_block_t cast_block;
+
+    VALUE io;
+    VALUE io_buffer;
+    ID io_write_all_method;
+    ID io_partial_read_method;
+
+    size_t write_reference_threshold;
+    size_t read_reference_threshold;
+    size_t io_buffer_size;
+
+    VALUE owner;
+};
+
+/*
+ * initialization functions
+ */
+void msgpack_buffer_static_init();
+
+void msgpack_buffer_static_destroy();
+
+void msgpack_buffer_init(msgpack_buffer_t* b);
+
+void msgpack_buffer_destroy(msgpack_buffer_t* b);
+
+void msgpack_buffer_mark(msgpack_buffer_t* b);
+
+void msgpack_buffer_clear(msgpack_buffer_t* b);
+
+static inline void msgpack_buffer_set_write_reference_threshold(msgpack_buffer_t* b, size_t length)
+{
+    if(length < MSGPACK_BUFFER_STRING_WRITE_REFERENCE_MINIMUM) {
+        length = MSGPACK_BUFFER_STRING_WRITE_REFERENCE_MINIMUM;
+    }
+    b->write_reference_threshold = length;
+}
+
+static inline void msgpack_buffer_set_read_reference_threshold(msgpack_buffer_t* b, size_t length)
+{
+    if(length < MSGPACK_BUFFER_STRING_READ_REFERENCE_MINIMUM) {
+        length = MSGPACK_BUFFER_STRING_READ_REFERENCE_MINIMUM;
+    }
+    b->read_reference_threshold = length;
+}
+
+static inline void msgpack_buffer_set_io_buffer_size(msgpack_buffer_t* b, size_t length)
+{
+    if(length < MSGPACK_BUFFER_IO_BUFFER_SIZE_MINIMUM) {
+        length = MSGPACK_BUFFER_IO_BUFFER_SIZE_MINIMUM;
+    }
+    b->io_buffer_size = length;
+}
+
+static inline void msgpack_buffer_reset_io(msgpack_buffer_t* b)
+{
+    b->io = Qnil;
+}
+
+static inline bool msgpack_buffer_has_io(msgpack_buffer_t* b)
+{
+    return b->io != Qnil;
+}
+
+static inline void msgpack_buffer_reset(msgpack_buffer_t* b)
+{
+    msgpack_buffer_clear(b);
+    msgpack_buffer_reset_io(b);
+}
+
+
+/*
+ * writer functions
+ */
+
+static inline size_t msgpack_buffer_writable_size(const msgpack_buffer_t* b)
+{
+    return b->tail_buffer_end - b->tail.last;
+}
+
+static inline void msgpack_buffer_write_1(msgpack_buffer_t* b, int byte)
+{
+    (*b->tail.last++) = (char) byte;
+}
+
+static inline void msgpack_buffer_write_2(msgpack_buffer_t* b, int byte1, unsigned char byte2)
+{
+    *(b->tail.last++) = (char) byte1;
+    *(b->tail.last++) = (char) byte2;
+}
+
+static inline void msgpack_buffer_write_byte_and_data(msgpack_buffer_t* b, int byte, const void* data, size_t length)
+{
+    (*b->tail.last++) = (char) byte;
+
+    memcpy(b->tail.last, data, length);
+    b->tail.last += length;
+}
+
+void _msgpack_buffer_expand(msgpack_buffer_t* b, const char* data, size_t length, bool use_flush);
+
+size_t msgpack_buffer_flush_to_io(msgpack_buffer_t* b, VALUE io, ID write_method, bool consume);
+
+static inline size_t msgpack_buffer_flush(msgpack_buffer_t* b)
+{
+    if(b->io == Qnil) {
+        return 0;
+    }
+    return msgpack_buffer_flush_to_io(b, b->io, b->io_write_all_method, true);
+}
+
+static inline void msgpack_buffer_ensure_writable(msgpack_buffer_t* b, size_t require)
+{
+    if(msgpack_buffer_writable_size(b) < require) {
+        _msgpack_buffer_expand(b, NULL, require, true);
+    }
+}
+
+static inline void _msgpack_buffer_append_impl(msgpack_buffer_t* b, const char* data, size_t length, bool flush_to_io)
+{
+    if(length == 0) {
+        return;
+    }
+
+    if(length <= msgpack_buffer_writable_size(b)) {
+        memcpy(b->tail.last, data, length);
+        b->tail.last += length;
+        return;
+    }
+
+    _msgpack_buffer_expand(b, data, length, flush_to_io);
+}
+
+static inline void msgpack_buffer_append(msgpack_buffer_t* b, const char* data, size_t length)
+{
+    _msgpack_buffer_append_impl(b, data, length, true);
+}
+
+static inline void msgpack_buffer_append_nonblock(msgpack_buffer_t* b, const char* data, size_t length)
+{
+    _msgpack_buffer_append_impl(b, data, length, false);
+}
+
+void _msgpack_buffer_append_long_string(msgpack_buffer_t* b, VALUE string);
+
+static inline size_t msgpack_buffer_append_string(msgpack_buffer_t* b, VALUE string)
+{
+    size_t length = RSTRING_LEN(string);
+
+    if(length > b->write_reference_threshold) {
+        _msgpack_buffer_append_long_string(b, string);
+
+    } else {
+        msgpack_buffer_append(b, RSTRING_PTR(string), length);
+    }
+
+    return length;
+}
+
+
+/*
+ * IO functions
+ */
+size_t _msgpack_buffer_feed_from_io(msgpack_buffer_t* b);
+
+size_t _msgpack_buffer_read_from_io_to_string(msgpack_buffer_t* b, VALUE string, size_t length);
+
+size_t _msgpack_buffer_skip_from_io(msgpack_buffer_t* b, size_t length);
+
+
+/*
+ * reader functions
+ */
+
+static inline size_t msgpack_buffer_top_readable_size(const msgpack_buffer_t* b)
+{
+    return b->head->last - b->read_buffer;
+}
+
+size_t msgpack_buffer_all_readable_size(const msgpack_buffer_t* b);
+
+bool _msgpack_buffer_shift_chunk(msgpack_buffer_t* b);
+
+static inline void _msgpack_buffer_consumed(msgpack_buffer_t* b, size_t length)
+{
+    b->read_buffer += length;
+    if(b->read_buffer >= b->head->last) {
+        _msgpack_buffer_shift_chunk(b);
+//printf("shift %d tail_filled=%lu\n", i, b->tail.last - b->tail.first);
+    }
+}
+
+static inline int msgpack_buffer_peek_top_1(msgpack_buffer_t* b)
+{
+    return (int) (unsigned char) b->read_buffer[0];
+}
+
+static inline int msgpack_buffer_read_top_1(msgpack_buffer_t* b)
+{
+    int r = (int) (unsigned char) b->read_buffer[0];
+
+    _msgpack_buffer_consumed(b, 1);
+
+    return r;
+}
+
+static inline int msgpack_buffer_read_1(msgpack_buffer_t* b)
+{
+    if(msgpack_buffer_top_readable_size(b) <= 0) {
+        if(b->io == Qnil) {
+            return -1;
+        }
+        _msgpack_buffer_feed_from_io(b);
+    }
+
+    int r = (int) (unsigned char) b->read_buffer[0];
+    _msgpack_buffer_consumed(b, 1);
+
+    return r;
+}
+
+
+/*
+ * bulk read / skip functions
+ */
+
+size_t msgpack_buffer_read_nonblock(msgpack_buffer_t* b, char* buffer, size_t length);
+
+static inline bool msgpack_buffer_ensure_readable(msgpack_buffer_t* b, size_t require)
+{
+    if(msgpack_buffer_top_readable_size(b) < require) {
+        size_t sz = msgpack_buffer_all_readable_size(b);
+        if(sz < require) {
+            if(b->io == Qnil) {
+                return false;
+            }
+            do {
+                size_t rl = _msgpack_buffer_feed_from_io(b);
+                sz += rl;
+            } while(sz < require);
+        }
+    }
+    return true;
+}
+
+bool _msgpack_buffer_read_all2(msgpack_buffer_t* b, char* buffer, size_t length);
+
+static inline bool msgpack_buffer_read_all(msgpack_buffer_t* b, char* buffer, size_t length)
+{
+    size_t avail = msgpack_buffer_top_readable_size(b);
+    if(avail < length) {
+        return _msgpack_buffer_read_all2(b, buffer, length);
+    }
+
+    memcpy(buffer, b->read_buffer, length);
+    _msgpack_buffer_consumed(b, length);
+    return true;
+}
+
+static inline size_t msgpack_buffer_skip_nonblock(msgpack_buffer_t* b, size_t length)
+{
+    size_t avail = msgpack_buffer_top_readable_size(b);
+    if(avail < length) {
+        return msgpack_buffer_read_nonblock(b, NULL, length);
+    }
+    _msgpack_buffer_consumed(b, length);
+    return length;
+}
+
+static inline union msgpack_buffer_cast_block_t* msgpack_buffer_read_cast_block(msgpack_buffer_t* b, size_t n)
+{
+    if(!msgpack_buffer_read_all(b, b->cast_block.buffer, n)) {
+        return NULL;
+    }
+    return &b->cast_block;
+}
+
+size_t msgpack_buffer_read_to_string_nonblock(msgpack_buffer_t* b, VALUE string, size_t length);
+
+static inline size_t msgpack_buffer_read_to_string(msgpack_buffer_t* b, VALUE string, size_t length)
+{
+    if(length == 0) {
+        return 0;
+    }
+
+    size_t avail = msgpack_buffer_top_readable_size(b);
+    if(avail > 0) {
+        return msgpack_buffer_read_to_string_nonblock(b, string, length);
+    } else if(b->io != Qnil) {
+        return _msgpack_buffer_read_from_io_to_string(b, string, length);
+    } else {
+        return 0;
+    }
+}
+
+static inline size_t msgpack_buffer_skip(msgpack_buffer_t* b, size_t length)
+{
+    if(length == 0) {
+        return 0;
+    }
+
+    size_t avail = msgpack_buffer_top_readable_size(b);
+    if(avail > 0) {
+        return msgpack_buffer_skip_nonblock(b, length);
+    } else if(b->io != Qnil) {
+        return _msgpack_buffer_skip_from_io(b, length);
+    } else {
+        return 0;
+    }
+}
+
+
+VALUE msgpack_buffer_all_as_string(msgpack_buffer_t* b);
+
+VALUE msgpack_buffer_all_as_string_array(msgpack_buffer_t* b);
+
+static inline VALUE _msgpack_buffer_refer_head_mapped_string(msgpack_buffer_t* b, size_t length)
+{
+    size_t offset = b->read_buffer - b->head->first;
+    return rb_str_substr(b->head->mapped_string, offset, length);
+}
+
+static inline VALUE msgpack_buffer_read_top_as_string(msgpack_buffer_t* b, size_t length, bool suppress_reference)
+{
+#ifndef DISABLE_BUFFER_READ_REFERENCE_OPTIMIZE
+    if(!suppress_reference &&
+            b->head->mapped_string != NO_MAPPED_STRING &&
+            length >= b->read_reference_threshold) {
+        VALUE result = _msgpack_buffer_refer_head_mapped_string(b, length);
+        _msgpack_buffer_consumed(b, length);
+        return result;
+    }
+#endif
+
+    VALUE result = rb_str_new(b->read_buffer, length);
+    _msgpack_buffer_consumed(b, length);
+    return result;
+}
+
+
+#endif
+

data/ext/packsnap/buffer_class.cc

@@ -0,0 +1,490 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2012 FURUHASHI Sadayuki
+ *
+ *    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 "compat.h"
+#include "ruby.h"
+#include "buffer.hh"
+#include "buffer_class.hh"
+
+VALUE cMessagePack_Buffer;
+
+static ID s_read;
+static ID s_readpartial;
+static ID s_write;
+static ID s_append;
+
+#define BUFFER(from, name) \
+    msgpack_buffer_t *name = NULL; \
+    Data_Get_Struct(from, msgpack_buffer_t, name); \
+    if(name == NULL) { \
+        rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
+    }
+
+#define CHECK_STRING_TYPE(value) \
+    value = rb_check_string_type(value); \
+    if( NIL_P(value) ) { \
+        rb_raise(rb_eTypeError, "instance of String needed"); \
+    }
+
+static void Buffer_free(void* data)
+{
+    if(data == NULL) {
+        return;
+    }
+    msgpack_buffer_t* b = (msgpack_buffer_t*) data;
+    msgpack_buffer_destroy(b);
+    free(b);
+}
+
+static VALUE Buffer_alloc(VALUE klass)
+{
+    msgpack_buffer_t* b = ALLOC_N(msgpack_buffer_t, 1);
+    msgpack_buffer_init(b);
+
+    return Data_Wrap_Struct(klass, msgpack_buffer_mark, Buffer_free, b);
+}
+
+static ID get_partial_read_method(VALUE io)
+{
+    if(rb_respond_to(io, s_readpartial)) {
+        return s_readpartial;
+    } else if(rb_respond_to(io, s_read)) {
+        return s_read;
+    } else {
+        return s_read;
+    }
+}
+
+static ID get_write_all_method(VALUE io)
+{
+    if(rb_respond_to(io, s_write)) {
+        return s_write;
+    } else if(rb_respond_to(io, s_append)) {
+        return s_append;
+    } else {
+        return s_write;
+    }
+}
+
+void MessagePack_Buffer_initialize(msgpack_buffer_t* b, VALUE io, VALUE options)
+{
+    b->io = io;
+    b->io_partial_read_method = get_partial_read_method(io);
+    b->io_write_all_method = get_write_all_method(io);
+
+    if(options != Qnil) {
+        VALUE v;
+
+        v = rb_hash_aref(options, ID2SYM(rb_intern("read_reference_threshold")));
+        if(v != Qnil) {
+            msgpack_buffer_set_read_reference_threshold(b, NUM2ULONG(v));
+        }
+
+        v = rb_hash_aref(options, ID2SYM(rb_intern("write_reference_threshold")));
+        if(v != Qnil) {
+            msgpack_buffer_set_write_reference_threshold(b, NUM2ULONG(v));
+        }
+
+        v = rb_hash_aref(options, ID2SYM(rb_intern("io_buffer_size")));
+        if(v != Qnil) {
+            msgpack_buffer_set_io_buffer_size(b, NUM2ULONG(v));
+        }
+    }
+}
+
+extern "C"
+VALUE MessagePack_Buffer_wrap(msgpack_buffer_t* b, VALUE owner)
+{
+    b->owner = owner;
+    return Data_Wrap_Struct(cMessagePack_Buffer, msgpack_buffer_mark, NULL, b);
+}
+
+static VALUE Buffer_initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE io = Qnil;
+    VALUE options = Qnil;
+
+    if(argc == 0 || (argc == 1 && argv[0] == Qnil)) {
+        /* Qnil */
+
+    } else if(argc == 1) {
+        VALUE v = argv[0];
+        if(rb_type(v) == T_HASH) {
+            options = v;
+        } else {
+            io = v;
+        }
+
+    } else if(argc == 2) {
+        io = argv[0];
+        options = argv[1];
+        if(rb_type(options) != T_HASH) {
+            rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(io));
+        }
+
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
+    }
+
+    BUFFER(self, b);
+
+    MessagePack_Buffer_initialize(b, io, options);
+
+    return self;
+}
+
+static VALUE Buffer_clear(VALUE self)
+{
+    BUFFER(self, b);
+    msgpack_buffer_clear(b);
+    return Qnil;
+}
+
+static VALUE Buffer_size(VALUE self)
+{
+    BUFFER(self, b);
+    size_t size = msgpack_buffer_all_readable_size(b);
+    return SIZET2NUM(size);
+}
+
+static VALUE Buffer_empty_p(VALUE self)
+{
+    BUFFER(self, b);
+    if(msgpack_buffer_top_readable_size(b) == 0) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE Buffer_write(VALUE self, VALUE string_or_buffer)
+{
+    BUFFER(self, b);
+
+    VALUE string = string_or_buffer;  // TODO optimize if string_or_buffer is a Buffer
+    StringValue(string);
+
+    size_t length = msgpack_buffer_append_string(b, string);
+
+    return SIZET2NUM(length);
+}
+
+static VALUE Buffer_append(VALUE self, VALUE string_or_buffer)
+{
+    BUFFER(self, b);
+
+    VALUE string = string_or_buffer;  // TODO optimize if string_or_buffer is a Buffer
+    StringValue(string);
+
+    msgpack_buffer_append_string(b, string);
+
+    return self;
+}
+
+
+#define MAKE_EMPTY_STRING(orig) \
+    if(orig == Qnil) { \
+        orig = rb_str_buf_new(0); \
+    } else { \
+        rb_str_resize(orig, 0); \
+    }
+
+static VALUE read_until_eof_rescue(VALUE args)
+{
+    msgpack_buffer_t* b = (msgpack_buffer_t*) ((VALUE*) args)[0];
+    VALUE out = ((VALUE*) args)[1];
+    unsigned long max = ((VALUE*) args)[2];
+    size_t* sz = (size_t*) ((VALUE*) args)[3];
+
+    while(true) {
+        size_t rl;
+        if(max == 0) {
+            if(out == Qnil) {
+                rl = msgpack_buffer_skip(b, b->io_buffer_size);
+            } else {
+                rl = msgpack_buffer_read_to_string(b, out, b->io_buffer_size);
+            }
+            if(rl == 0) {
+                break;
+            }
+            *sz += rl;
+
+        } else {
+            if(out == Qnil) {
+                rl = msgpack_buffer_skip(b, max);
+            } else {
+                rl = msgpack_buffer_read_to_string(b, out, max);
+            }
+            if(rl == 0) {
+                break;
+            }
+            *sz += rl;
+            if(max <= rl) {
+                break;
+            } else {
+                max -= rl;
+            }
+        }
+    }
+
+    return Qnil;
+}
+
+static VALUE read_until_eof_error(VALUE args)
+{
+    /* ignore EOFError */
+    UNUSED(args);
+    return Qnil;
+}
+
+static inline size_t read_until_eof(msgpack_buffer_t* b, VALUE out, unsigned long max)
+{
+    if(msgpack_buffer_has_io(b)) {
+        size_t sz = 0;
+        VALUE args[4] = { (VALUE)(void*) b, out, (VALUE) max, (VALUE)(void*) &sz };
+        rb_rescue2((VALUE (*)(...))read_until_eof_rescue, (VALUE)(void*) args,
+                (VALUE (*)(...))read_until_eof_error, (VALUE)(void*) args,
+                rb_eEOFError, NULL);
+        return sz;
+
+    } else {
+        if(max == 0) {
+            max = ULONG_MAX;
+        }
+        if(out == Qnil) {
+            return msgpack_buffer_skip_nonblock(b, max);
+        } else {
+            return msgpack_buffer_read_to_string_nonblock(b, out, max);
+        }
+    }
+}
+
+static inline VALUE read_all(msgpack_buffer_t* b, VALUE out)
+{
+#ifndef DISABLE_BUFFER_READ_TO_S_OPTIMIZE
+    if(out == Qnil && !msgpack_buffer_has_io(b)) {
+        /* same as to_s && clear; optimize */
+        VALUE str = msgpack_buffer_all_as_string(b);
+        msgpack_buffer_clear(b);
+        return str;
+    }
+#endif
+    MAKE_EMPTY_STRING(out);
+    read_until_eof(b, out, 0);
+    return out;
+}
+
+static VALUE Buffer_skip(VALUE self, VALUE sn)
+{
+    BUFFER(self, b);
+
+    unsigned long n = FIX2ULONG(sn);
+
+    /* do nothing */
+    if(n == 0) {
+        return ULONG2NUM(0);
+    }
+
+    size_t sz = read_until_eof(b, Qnil, n);
+    return ULONG2NUM(sz);
+}
+
+static VALUE Buffer_skip_all(VALUE self, VALUE sn)
+{
+    BUFFER(self, b);
+
+    unsigned long n = FIX2ULONG(sn);
+
+    /* do nothing */
+    if(n == 0) {
+        return self;
+    }
+
+    if(!msgpack_buffer_ensure_readable(b, n)) {
+        rb_raise(rb_eEOFError, "end of buffer reached");
+    }
+
+    msgpack_buffer_skip_nonblock(b, n);
+
+    return self;
+}
+
+static VALUE Buffer_read_all(int argc, VALUE* argv, VALUE self)
+{
+    VALUE out = Qnil;
+    unsigned long n = 0;
+    bool all = false;
+
+    switch(argc) {
+    case 2:
+        out = argv[1];
+        /* pass through */
+    case 1:
+        n = FIX2ULONG(argv[0]);
+        break;
+    case 0:
+        all = true;
+        break;
+    default:
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    }
+
+    BUFFER(self, b);
+
+    if(out != Qnil) {
+        CHECK_STRING_TYPE(out);
+    }
+
+    if(all) {
+        return read_all(b, out);
+    }
+
+    if(n == 0) {
+        /* do nothing */
+        MAKE_EMPTY_STRING(out);
+        return out;
+    }
+
+    if(!msgpack_buffer_ensure_readable(b, n)) {
+        rb_raise(rb_eEOFError, "end of buffer reached");
+    }
+
+    MAKE_EMPTY_STRING(out);
+    size_t sz = msgpack_buffer_read_to_string_nonblock(b, out, n);
+
+    return out;
+}
+
+static VALUE Buffer_read(int argc, VALUE* argv, VALUE self)
+{
+    VALUE out = Qnil;
+    unsigned long n = -1;
+    bool all = false;
+
+    switch(argc) {
+    case 2:
+        out = argv[1];
+        /* pass through */
+    case 1:
+        n = FIX2ULONG(argv[0]);
+        break;
+    case 0:
+        all = true;
+        break;
+    default:
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    }
+
+    BUFFER(self, b);
+
+    if(out != Qnil) {
+        CHECK_STRING_TYPE(out);
+    }
+
+    if(all) {
+        return read_all(b, out);
+    }
+
+    if(n == 0) {
+        /* do nothing */
+        MAKE_EMPTY_STRING(out);
+        return out;
+    }
+
+#ifndef DISABLE_BUFFER_READ_TO_S_OPTIMIZE
+    if(!msgpack_buffer_has_io(b) && out == Qnil &&
+            msgpack_buffer_all_readable_size(b) <= n) {
+        /* same as to_s && clear; optimize */
+        VALUE str = msgpack_buffer_all_as_string(b);
+        msgpack_buffer_clear(b);
+
+        if(RSTRING_LEN(str) == 0) {
+            return Qnil;
+        } else {
+            return str;
+        }
+    }
+#endif
+
+    MAKE_EMPTY_STRING(out);
+    read_until_eof(b, out, n);
+
+    if(RSTRING_LEN(out) == 0) {
+        return Qnil;
+    } else {
+        return out;
+    }
+}
+
+static VALUE Buffer_to_str(VALUE self)
+{
+    BUFFER(self, b);
+    return msgpack_buffer_all_as_string(b);
+}
+
+static VALUE Buffer_to_a(VALUE self)
+{
+    BUFFER(self, b);
+    return msgpack_buffer_all_as_string_array(b);
+}
+
+static VALUE Buffer_flush(VALUE self)
+{
+    BUFFER(self, b);
+    msgpack_buffer_flush(b);
+    return self;
+}
+
+static VALUE Buffer_write_to(VALUE self, VALUE io)
+{
+    BUFFER(self, b);
+    size_t sz = msgpack_buffer_flush_to_io(b, io, s_write, true);
+    return ULONG2NUM(sz);
+}
+
+extern "C"
+void MessagePack_Buffer_module_init(VALUE mMessagePack)
+{
+    s_read = rb_intern("read");
+    s_readpartial = rb_intern("readpartial");
+    s_write = rb_intern("write");
+    s_append = rb_intern("<<");
+
+    msgpack_buffer_static_init();
+
+    cMessagePack_Buffer = rb_define_class_under(mMessagePack, "Buffer", rb_cObject);
+
+    rb_define_alloc_func(cMessagePack_Buffer, Buffer_alloc);
+
+    rb_define_method(cMessagePack_Buffer, "initialize", (VALUE (*)(...))Buffer_initialize, -1);
+    rb_define_method(cMessagePack_Buffer, "clear", (VALUE (*)(...))Buffer_clear, 0);
+    rb_define_method(cMessagePack_Buffer, "size", (VALUE (*)(...))Buffer_size, 0);
+    rb_define_method(cMessagePack_Buffer, "empty?", (VALUE (*)(...))Buffer_empty_p, 0);
+    rb_define_method(cMessagePack_Buffer, "write", (VALUE (*)(...))Buffer_write, 1);
+    rb_define_method(cMessagePack_Buffer, "<<", (VALUE (*)(...))Buffer_append, 1);
+    rb_define_method(cMessagePack_Buffer, "skip", (VALUE (*)(...))Buffer_skip, 1);
+    rb_define_method(cMessagePack_Buffer, "skip_all", (VALUE (*)(...))Buffer_skip_all, 1);
+    rb_define_method(cMessagePack_Buffer, "read", (VALUE (*)(...))Buffer_read, -1);
+    rb_define_method(cMessagePack_Buffer, "read_all", (VALUE (*)(...))Buffer_read_all, -1);
+    rb_define_method(cMessagePack_Buffer, "flush", (VALUE (*)(...))Buffer_flush, 0);
+    rb_define_method(cMessagePack_Buffer, "write_to", (VALUE (*)(...))Buffer_write_to, 1);
+    rb_define_method(cMessagePack_Buffer, "to_str", (VALUE (*)(...))Buffer_to_str, 0);
+    rb_define_alias(cMessagePack_Buffer, "to_s", "to_str");
+    rb_define_method(cMessagePack_Buffer, "to_a", (VALUE (*)(...))Buffer_to_a, 0);
+}
+