msgpack 0.6.0-x86-mswin32-60

data/ext/msgpack/packer.h

@@ -0,0 +1,441 @@
+/*
+ * 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.
+ */
+#ifndef MSGPACK_RUBY_PACKER_H__
+#define MSGPACK_RUBY_PACKER_H__
+
+#include "buffer.h"
+
+#ifndef MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY
+#define MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY (1024)
+#endif
+
+struct msgpack_packer_t;
+typedef struct msgpack_packer_t msgpack_packer_t;
+
+struct msgpack_packer_t {
+    msgpack_buffer_t buffer;
+
+    VALUE io;
+    ID io_write_all_method;
+
+    ID to_msgpack_method;
+    VALUE to_msgpack_arg;
+
+    VALUE buffer_ref;
+};
+
+#define PACKER_BUFFER_(pk) (&(pk)->buffer)
+
+void msgpack_packer_static_init();
+
+void msgpack_packer_static_destroy();
+
+void msgpack_packer_init(msgpack_packer_t* pk);
+
+void msgpack_packer_destroy(msgpack_packer_t* pk);
+
+void msgpack_packer_mark(msgpack_packer_t* pk);
+
+static inline void msgpack_packer_set_to_msgpack_method(msgpack_packer_t* pk,
+        ID to_msgpack_method, VALUE to_msgpack_arg)
+{
+    pk->to_msgpack_method = to_msgpack_method;
+    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_write_nil(msgpack_packer_t* pk)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), 0xc0);
+}
+
+static inline void msgpack_packer_write_true(msgpack_packer_t* pk)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), 0xc3);
+}
+
+static inline void msgpack_packer_write_false(msgpack_packer_t* pk)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), 0xc2);
+}
+
+static inline void _msgpack_packer_write_fixint(msgpack_packer_t* pk, int8_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+    msgpack_buffer_write_1(PACKER_BUFFER_(pk), v);
+}
+
+static inline void _msgpack_packer_write_uint8(msgpack_packer_t* pk, uint8_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
+    msgpack_buffer_write_2(PACKER_BUFFER_(pk), 0xcc, v);
+}
+
+static inline void _msgpack_packer_write_uint16(msgpack_packer_t* pk, uint16_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+    uint16_t be = _msgpack_be16(v);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xcd, (const void*)&be, 2);
+}
+
+static inline void _msgpack_packer_write_uint32(msgpack_packer_t* pk, uint32_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+    uint32_t be = _msgpack_be32(v);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xce, (const void*)&be, 4);
+}
+
+static inline void _msgpack_packer_write_uint64(msgpack_packer_t* pk, uint64_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 9);
+    uint64_t be = _msgpack_be64(v);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xcf, (const void*)&be, 8);
+}
+
+static inline void _msgpack_packer_write_int8(msgpack_packer_t* pk, int8_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
+    msgpack_buffer_write_2(PACKER_BUFFER_(pk), 0xd0, v);
+}
+
+static inline void _msgpack_packer_write_int16(msgpack_packer_t* pk, int16_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+    uint16_t be = _msgpack_be16(v);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xd1, (const void*)&be, 2);
+}
+
+static inline void _msgpack_packer_write_int32(msgpack_packer_t* pk, int32_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+    uint32_t be = _msgpack_be32(v);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xd2, (const void*)&be, 4);
+}
+
+static inline void _msgpack_packer_write_int64(msgpack_packer_t* pk, int64_t v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 9);
+    uint64_t be = _msgpack_be64(v);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xd3, (const void*)&be, 8);
+}
+
+static inline void _msgpack_packer_write_long32(msgpack_packer_t* pk, long v)
+{
+    if(v < -0x20L) {
+        if(v < -0x8000L) {
+            _msgpack_packer_write_int32(pk, (int32_t) v);
+        } else if(v < -0x80L) {
+            _msgpack_packer_write_int16(pk, (int16_t) v);
+        } else {
+            _msgpack_packer_write_int8(pk, (int8_t) v);
+        }
+    } else if(v <= 0x7fL) {
+        _msgpack_packer_write_fixint(pk, (int8_t) v);
+    } else {
+        if(v <= 0xffL) {
+            _msgpack_packer_write_uint8(pk, (uint8_t) v);
+        } else if(v <= 0xffffL) {
+            _msgpack_packer_write_uint16(pk, (uint16_t) v);
+        } else {
+            _msgpack_packer_write_uint32(pk, (uint32_t) v);
+        }
+    }
+}
+
+static inline void _msgpack_packer_write_long_long64(msgpack_packer_t* pk, long long v)
+{
+    if(v < -0x20LL) {
+        if(v < -0x8000LL) {
+            if(v < -0x80000000LL) {
+                _msgpack_packer_write_int64(pk, (int64_t) v);
+            } else {
+                _msgpack_packer_write_int32(pk, (int32_t) v);
+            }
+        } else {
+            if(v < -0x80LL) {
+                _msgpack_packer_write_int16(pk, (int16_t) v);
+            } else {
+                _msgpack_packer_write_int8(pk, (int8_t) v);
+            }
+        }
+    } else if(v <= 0x7fLL) {
+        _msgpack_packer_write_fixint(pk, (int8_t) v);
+    } else {
+        if(v <= 0xffffLL) {
+            if(v <= 0xffLL) {
+                _msgpack_packer_write_uint8(pk, (uint8_t) v);
+            } else {
+                _msgpack_packer_write_uint16(pk, (uint16_t) v);
+            }
+        } else {
+            if(v <= 0xffffffffLL) {
+                _msgpack_packer_write_uint32(pk, (uint32_t) v);
+            } else {
+                _msgpack_packer_write_uint64(pk, (uint64_t) v);
+            }
+        }
+    }
+}
+
+static inline void msgpack_packer_write_long(msgpack_packer_t* pk, long v)
+{
+#if defined(SIZEOF_LONG)
+#  if SIZEOF_LONG <= 4
+    _msgpack_packer_write_long32(pk, v);
+#  else
+    _msgpack_packer_write_long_long64(pk, v);
+#  endif
+
+#elif defined(LONG_MAX)
+#  if LONG_MAX <= 0x7fffffffL
+    _msgpack_packer_write_long32(pk, v);
+#  else
+    _msgpack_packer_write_long_long64(pk, v);
+#  endif
+
+#else
+    if(sizeof(long) <= 4) {
+        _msgpack_packer_write_long32(pk, v);
+    } else {
+        _msgpack_packer_write_long_long64(pk, v);
+    }
+#endif
+}
+
+static inline void msgpack_packer_write_long_long(msgpack_packer_t* pk, long long v)
+{
+    /* assuming sizeof(long long) == 8 */
+    _msgpack_packer_write_long_long64(pk, v);
+}
+
+static inline void msgpack_packer_write_u64(msgpack_packer_t* pk, uint64_t v)
+{
+    if(v <= 0xffULL) {
+        if(v <= 0x7fULL) {
+            _msgpack_packer_write_fixint(pk, (int8_t) v);
+        } else {
+            _msgpack_packer_write_uint8(pk, (uint8_t) v);
+        }
+    } else {
+        if(v <= 0xffffULL) {
+            _msgpack_packer_write_uint16(pk, (uint16_t) v);
+        } else if(v <= 0xffffffffULL) {
+            _msgpack_packer_write_uint32(pk, (uint32_t) v);
+        } else {
+            _msgpack_packer_write_uint64(pk, (uint64_t) v);
+        }
+    }
+}
+
+static inline void msgpack_packer_write_double(msgpack_packer_t* pk, double v)
+{
+    msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 9);
+    union {
+        double d;
+        uint64_t u64;
+        char mem[8];
+    } castbuf = { v };
+    castbuf.u64 = _msgpack_be_double(castbuf.u64);
+    msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xcb, castbuf.mem, 8);
+}
+
+static inline void msgpack_packer_write_raw_header(msgpack_packer_t* pk, unsigned int n)
+{
+    if(n < 32) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+        unsigned char h = 0xa0 | (uint8_t) n;
+        msgpack_buffer_write_1(PACKER_BUFFER_(pk), h);
+    } else if(n < 256) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 2);
+        unsigned char be = (uint8_t) n;
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xd9, (const void*)&be, 1);
+    } else if(n < 65536) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+        uint16_t be = _msgpack_be16(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xda, (const void*)&be, 2);
+    } else {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+        uint32_t be = _msgpack_be32(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xdb, (const void*)&be, 4);
+    }
+}
+
+static inline void msgpack_packer_write_bin_header(msgpack_packer_t* pk, unsigned int n)
+{
+    if(n < 256) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+        unsigned char be = (uint8_t) n;
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xc4, (const void*)&be, 1);
+    } else if(n < 65536) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+        uint16_t be = _msgpack_be16(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xc5, (const void*)&be, 2);
+    } else {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+        uint32_t be = _msgpack_be32(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xc6, (const void*)&be, 4);
+    }
+}
+
+static inline void msgpack_packer_write_array_header(msgpack_packer_t* pk, unsigned int n)
+{
+    if(n < 16) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+        unsigned char h = 0x90 | (uint8_t) n;
+        msgpack_buffer_write_1(PACKER_BUFFER_(pk), h);
+    } else if(n < 65536) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+        uint16_t be = _msgpack_be16(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xdc, (const void*)&be, 2);
+    } else {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+        uint32_t be = _msgpack_be32(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xdd, (const void*)&be, 4);
+    }
+}
+
+static inline void msgpack_packer_write_map_header(msgpack_packer_t* pk, unsigned int n)
+{
+    if(n < 16) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 1);
+        unsigned char h = 0x80 | (uint8_t) n;
+        msgpack_buffer_write_1(PACKER_BUFFER_(pk), h);
+    } else if(n < 65536) {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 3);
+        uint16_t be = _msgpack_be16(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xde, (const void*)&be, 2);
+    } else {
+        msgpack_buffer_ensure_writable(PACKER_BUFFER_(pk), 5);
+        uint32_t be = _msgpack_be32(n);
+        msgpack_buffer_write_byte_and_data(PACKER_BUFFER_(pk), 0xdf, (const void*)&be, 4);
+    }
+}
+
+#ifdef COMPAT_HAVE_ENCODING
+static inline bool msgpack_packer_is_binary(VALUE v, int encindex)
+{
+    return encindex == msgpack_rb_encindex_ascii8bit;
+}
+
+static inline bool msgpack_packer_is_utf8_compat_string(VALUE v, int encindex)
+{
+    return encindex == msgpack_rb_encindex_utf8
+        || encindex == msgpack_rb_encindex_usascii
+#ifdef ENC_CODERANGE_ASCIIONLY
+        /* Because ENC_CODERANGE_ASCIIONLY does not scan string, it may return ENC_CODERANGE_UNKNOWN unlike */
+        /* rb_enc_str_asciionly_p. It is always faster than rb_str_encode if it is available. */
+        /* Very old Rubinius (< v1.3.1) doesn't have ENC_CODERANGE_ASCIIONLY. */
+        || (rb_enc_asciicompat(rb_enc_from_index(encindex)) && ENC_CODERANGE_ASCIIONLY(v))
+#endif
+        ;
+}
+#endif
+
+static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE v)
+{
+    /* TODO encoding conversion? */
+    /* actual return type of RSTRING_LEN is long */
+    unsigned long len = RSTRING_LEN(v);
+    if(len > 0xffffffffUL) {
+        // TODO rb_eArgError?
+        rb_raise(rb_eArgError, "size of string is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
+    }
+
+#ifdef COMPAT_HAVE_ENCODING
+    int encindex = ENCODING_GET(v);
+    if(msgpack_packer_is_binary(v, encindex)) {
+        /* write ASCII-8BIT string using Binary type */
+        msgpack_packer_write_bin_header(pk, (unsigned int)len);
+        msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+    } else {
+        /* write UTF-8, US-ASCII, or 7bit-safe ascii-compatible string using String type directly */
+        if(!msgpack_packer_is_utf8_compat_string(v, encindex)) {
+            /* transcode other strings to UTF-8 and write using String type */
+            VALUE enc = rb_enc_from_encoding(rb_utf8_encoding()); /* rb_enc_from_encoding_index is not extern */
+            v = rb_str_encode(v, enc, 0, Qnil);
+            len = RSTRING_LEN(v);
+        }
+        msgpack_packer_write_raw_header(pk, (unsigned int)len);
+        msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+    }
+#else
+    msgpack_packer_write_raw_header(pk, (unsigned int)len);
+    msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+#endif
+}
+
+static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
+{
+#ifdef HAVE_RB_SYM2STR
+    /* rb_sym2str is added since MRI 2.2.0 */
+    msgpack_packer_write_string_value(pk, rb_sym2str(v));
+#else
+    const char* name = rb_id2name(SYM2ID(v));
+    unsigned long len = strlen(name);
+    /* actual return type of strlen is size_t */
+    if(len > 0xffffffffUL) {
+        // TODO rb_eArgError?
+        rb_raise(rb_eArgError, "size of symbol is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
+    }
+    msgpack_packer_write_raw_header(pk, (unsigned int)len);
+    msgpack_buffer_append(PACKER_BUFFER_(pk), name, len);
+#endif
+}
+
+static inline void msgpack_packer_write_fixnum_value(msgpack_packer_t* pk, VALUE v)
+{
+#ifdef JRUBY
+    msgpack_packer_write_long(pk, FIXNUM_P(v) ? FIX2LONG(v) : rb_num2ll(v));
+#else
+    msgpack_packer_write_long(pk, FIX2LONG(v));
+#endif
+}
+
+static inline void msgpack_packer_write_bignum_value(msgpack_packer_t* pk, VALUE v)
+{
+    if(RBIGNUM_POSITIVE_P(v)) {
+        msgpack_packer_write_u64(pk, rb_big2ull(v));
+    } else {
+        msgpack_packer_write_long_long(pk, rb_big2ll(v));
+    }
+}
+
+static inline void msgpack_packer_write_float_value(msgpack_packer_t* pk, VALUE v)
+{
+    msgpack_packer_write_double(pk, rb_num2dbl(v));
+}
+
+void msgpack_packer_write_array_value(msgpack_packer_t* pk, VALUE v);
+
+void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v);
+
+void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v);
+
+
+#endif
+

data/ext/msgpack/packer_class.c

@@ -0,0 +1,302 @@
+/*
+ * 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 "compat.h"
+#include "ruby.h"
+#include "packer.h"
+#include "packer_class.h"
+#include "buffer_class.h"
+
+VALUE cMessagePack_Packer;
+
+static ID s_to_msgpack;
+static ID s_write;
+
+//static VALUE s_packer_value;
+//static msgpack_packer_t* s_packer;
+
+#define PACKER(from, name) \
+    msgpack_packer_t* name; \
+    Data_Get_Struct(from, msgpack_packer_t, name); \
+    if(name == NULL) { \
+        rb_raise(rb_eArgError, "NULL found for " # name " when shouldn't be."); \
+    }
+
+static void Packer_free(msgpack_packer_t* pk)
+{
+    if(pk == NULL) {
+        return;
+    }
+    msgpack_packer_destroy(pk);
+    free(pk);
+}
+
+static VALUE 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);
+
+    msgpack_packer_set_to_msgpack_method(pk, s_to_msgpack, self);
+    pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
+
+    return self;
+}
+
+static VALUE Packer_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(options));
+        }
+
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
+    }
+
+    PACKER(self, pk);
+    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
+
+    // TODO MessagePack_Unpacker_initialize and options
+
+    return self;
+}
+
+static VALUE Packer_buffer(VALUE self)
+{
+    PACKER(self, pk);
+    return pk->buffer_ref;
+}
+
+static VALUE Packer_write(VALUE self, VALUE v)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_value(pk, v);
+    return self;
+}
+
+static VALUE Packer_write_nil(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_nil(pk);
+    return self;
+}
+
+static VALUE Packer_write_array_header(VALUE self, VALUE n)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_array_header(pk, NUM2UINT(n));
+    return self;
+}
+
+static VALUE Packer_write_map_header(VALUE self, VALUE n)
+{
+    PACKER(self, pk);
+    msgpack_packer_write_map_header(pk, NUM2UINT(n));
+    return self;
+}
+
+static VALUE Packer_flush(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_buffer_flush(PACKER_BUFFER_(pk));
+    return self;
+}
+
+static VALUE Packer_clear(VALUE self)
+{
+    PACKER(self, pk);
+    msgpack_buffer_clear(PACKER_BUFFER_(pk));
+    return Qnil;
+}
+
+static VALUE Packer_size(VALUE self)
+{
+    PACKER(self, pk);
+    size_t size = msgpack_buffer_all_readable_size(PACKER_BUFFER_(pk));
+    return SIZET2NUM(size);
+}
+
+static VALUE Packer_empty_p(VALUE self)
+{
+    PACKER(self, pk);
+    if(msgpack_buffer_top_readable_size(PACKER_BUFFER_(pk)) == 0) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE Packer_to_str(VALUE self)
+{
+    PACKER(self, pk);
+    return msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
+}
+
+static VALUE Packer_to_a(VALUE self)
+{
+    PACKER(self, pk);
+    return msgpack_buffer_all_as_string_array(PACKER_BUFFER_(pk));
+}
+
+static VALUE Packer_write_to(VALUE self, VALUE io)
+{
+    PACKER(self, pk);
+    size_t sz = msgpack_buffer_flush_to_io(PACKER_BUFFER_(pk), io, s_write, true);
+    return ULONG2NUM(sz);
+}
+
+//static VALUE Packer_append(VALUE self, VALUE string_or_buffer)
+//{
+//    PACKER(self, pk);
+//
+//    // TODO if string_or_buffer is a Buffer
+//    VALUE string = string_or_buffer;
+//
+//    msgpack_buffer_append_string(PACKER_BUFFER_(pk), string);
+//
+//    return self;
+//}
+
+VALUE MessagePack_pack(int argc, VALUE* argv)
+{
+    VALUE v;
+    VALUE io = Qnil;
+    VALUE options = Qnil;
+
+    if(argc == 1) {
+        v = argv[0];
+
+    } else if(argc == 2) {
+        v = argv[0];
+        if(rb_type(argv[1]) == T_HASH) {
+            options = argv[1];
+        } else {
+            io = argv[1];
+        }
+
+    } 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));
+        }
+
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
+    }
+
+    VALUE self = Packer_alloc(cMessagePack_Packer);
+    PACKER(self, pk);
+    //msgpack_packer_reset(s_packer);
+    //msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
+
+    MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
+    // TODO MessagePack_Unpacker_initialize and options
+
+    msgpack_packer_write_value(pk, v);
+
+    VALUE retval;
+    if(io != Qnil) {
+        msgpack_buffer_flush(PACKER_BUFFER_(pk));
+        retval = Qnil;
+    } else {
+        retval = msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
+    }
+
+    msgpack_buffer_clear(PACKER_BUFFER_(pk)); /* to free rmem before GC */
+
+#ifdef RB_GC_GUARD
+    /* This prevents compilers from optimizing out the `self` variable
+     * from stack. Otherwise GC free()s it. */
+    RB_GC_GUARD(self);
+#endif
+
+    return retval;
+}
+
+static VALUE MessagePack_dump_module_method(int argc, VALUE* argv, VALUE mod)
+{
+    UNUSED(mod);
+    return MessagePack_pack(argc, argv);
+}
+
+static VALUE MessagePack_pack_module_method(int argc, VALUE* argv, VALUE mod)
+{
+    UNUSED(mod);
+    return MessagePack_pack(argc, argv);
+}
+
+void MessagePack_Packer_module_init(VALUE mMessagePack)
+{
+    s_to_msgpack = rb_intern("to_msgpack");
+    s_write = rb_intern("write");
+
+    msgpack_packer_static_init();
+
+    cMessagePack_Packer = rb_define_class_under(mMessagePack, "Packer", rb_cObject);
+
+    rb_define_alloc_func(cMessagePack_Packer, Packer_alloc);
+
+    rb_define_method(cMessagePack_Packer, "initialize", 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, "flush", Packer_flush, 0);
+
+    /* delegation methods */
+    rb_define_method(cMessagePack_Packer, "clear", Packer_clear, 0);
+    rb_define_method(cMessagePack_Packer, "size", Packer_size, 0);
+    rb_define_method(cMessagePack_Packer, "empty?", Packer_empty_p, 0);
+    rb_define_method(cMessagePack_Packer, "write_to", Packer_write_to, 1);
+    rb_define_method(cMessagePack_Packer, "to_str", Packer_to_str, 0);
+    rb_define_alias(cMessagePack_Packer, "to_s", "to_str");
+    rb_define_method(cMessagePack_Packer, "to_a", Packer_to_a, 0);
+    //rb_define_method(cMessagePack_Packer, "append", Packer_append, 1);
+    //rb_define_alias(cMessagePack_Packer, "<<", "append");
+
+    //s_packer_value = Packer_alloc(cMessagePack_Packer);
+    //rb_gc_register_address(&s_packer_value);
+    //Data_Get_Struct(s_packer_value, msgpack_packer_t, s_packer);
+
+    /* MessagePack.pack(x) */
+    rb_define_module_function(mMessagePack, "pack", MessagePack_pack_module_method, -1);
+    rb_define_module_function(mMessagePack, "dump", MessagePack_dump_module_method, -1);
+}
+