packsnap 0.0.1

data/ext/packsnap/buffer_class.hh

@@ -0,0 +1,32 @@
+/*
+ * 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_CLASS_H__
+#define MSGPACK_RUBY_BUFFER_CLASS_H__
+
+#include "buffer.hh"
+
+extern VALUE cMessagePack_Buffer;
+
+extern "C" void MessagePack_Buffer_module_init(VALUE mMessagePack);
+
+extern "C" VALUE MessagePack_Buffer_wrap(msgpack_buffer_t* b, VALUE owner);
+
+void MessagePack_Buffer_initialize(msgpack_buffer_t* b, VALUE io, VALUE options);
+
+#endif
+

data/ext/packsnap/compat.h

@@ -0,0 +1,128 @@
+/*
+ * 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_COMPAT_H__
+#define MSGPACK_RUBY_COMPAT_H__
+
+#include "ruby.h"
+
+#if defined(HAVE_RUBY_ST_H)
+#include "ruby/st.h"  // ruby hash on Ruby 1.9
+#elif defined(HAVE_ST_H)
+#include "st.h"       // ruby hash on Ruby 1.8
+#endif
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#define COMPAT_HAVE_ENCODING
+extern int s_enc_utf8;
+extern int s_enc_ascii8bit;
+extern int s_enc_usascii;
+extern VALUE s_enc_utf8_value;
+#endif
+
+
+/* Rubinius and JRuby */
+#if defined(RUBINIUS) || defined(JRUBY)
+#define DISABLE_STR_NEW_MOVE
+#endif
+
+
+/* MRI 1.9 */
+#if defined(RUBY_VM)
+/* if FL_ALL(str, FL_USER1|FL_USER3) == STR_ASSOC_P(str) returns true, rb_str_dup will copy the string */
+#define STR_DUP_LIKELY_DOES_COPY(str) FL_ALL(str, FL_USER1|FL_USER3)
+
+/* Rubinius and JRuby */
+#elif defined(RUBINIUS) || defined(JRUBY)
+#define STR_DUP_LIKELY_DOES_COPY(str) (1)
+
+#else
+/* MRI 1.8 */
+#define STR_DUP_LIKELY_DOES_COPY(str) (!FL_TEST(str, ELTS_SHARED))
+#endif
+
+
+/* MacRuby */
+#if defined(__MACRUBY__)
+#undef COMPAT_HAVE_ENCODING
+#endif
+
+
+/* MRI 1.8 */
+#ifndef SIZET2NUM
+#define SIZET2NUM(v) ULL2NUM(v)
+#endif
+
+
+/* MRI 1.9 */
+#if defined(RUBY_VM)
+#define COMPAT_RERAISE rb_exc_raise(rb_errinfo())
+
+/* JRuby */
+#elif defined(JRUBY)
+#define COMPAT_RERAISE rb_exc_raise(rb_gv_get("$!"))
+
+/* MRI 1.8 and Rubinius */
+#else
+#define COMPAT_RERAISE rb_exc_raise(ruby_errinfo)
+#endif
+
+
+#ifndef RBIGNUM_POSITIVE_P
+
+/* Rubinius */
+#if defined(RUBINIUS)
+#define RBIGNUM_POSITIVE_P(b) (rb_funcall(b, rb_intern(">="), 1, INT2FIX(0)) == Qtrue)
+
+/* JRuby */
+#elif defined(JRUBY)
+#define RBIGNUM_POSITIVE_P(b) (rb_funcall(b, rb_intern(">="), 1, INT2FIX(0)) == Qtrue)
+#define rb_big2ull(b) rb_num2ull(b)
+/*#define rb_big2ll(b) rb_num2ll(b)*/
+
+/* MRI 1.8 */
+#else
+#define RBIGNUM_POSITIVE_P(b) (RBIGNUM(b)->sign)
+
+#endif
+#endif
+
+
+/* MRI 1.8.5 */
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+/* MRI 1.8.5 */
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+/* MRI 1.8.5 */
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#endif
+
+/* MRI 1.8.5 */
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+
+
+#endif
+

data/ext/packsnap/extconf.rb

@@ -0,0 +1,94 @@
+require 'mkmf'
+require 'fileutils'
+
+
+$CFLAGS << %[ -I.. -I. -Wall -O3 -g -std=c99]
+
+if warnflags = CONFIG['warnflags']
+  warnflags.slice!(/ -Wdeclaration-after-statement/)
+end
+
+def try_configure
+  return if system "./configure --disable-option-checking --disable-dependency-tracking --disable-gtest --without-gflags"
+
+  if try_run 'int main(int argc, char** argv){ return __builtin_expect(1, 1) ? 0 : 1; }'
+    $defs << '-DHAVE_BUILTIN_EXPECT'
+  end
+
+  if try_run 'int main(int argc, char** argv){ return (__builtin_ctzll(0x100000000LL) == 32) ? 0 : 1; }'
+    $defs << '-DHAVE_BUILTIN_CTZ'
+  end
+
+  have_header("ruby/st.h")
+  have_header("st.h")
+  have_header 'dlfcn.h'
+  have_header 'inttypes.h'
+  have_header 'memory.h'
+  have_header 'stddef.h'
+  have_header 'stdint.h'
+  have_header 'stdlib.h'
+  have_header 'strings.h'
+  have_header 'string.h'
+  have_header 'sys/byteswap.h'
+  have_header 'sys/endian.h'
+  have_header 'sys/mman.h'
+  have_header 'sys/resource.h'
+  have_header 'sys/stat.h'
+  have_header 'sys/types.h'
+  have_header 'unistd.h'
+  have_header 'windows.h'
+
+  if try_run 'int main(int argc, char** argv){ int i = 1; return *((char*)&i); }'
+    $defs << '-DWORDS_BIGENDIAN'
+  end
+end
+
+unless have_library 'snappy'
+  dst = File.dirname File.expand_path __FILE__
+
+  tar = 'tar'
+  tar = 'gnutar' if find_executable 'gnutar'
+
+  ver = "1.0.4"
+  src = "snappy-#{ver}"
+
+  FileUtils.rm_rf File.join dst, src
+  system "curl -s http://snappy.googlecode.com/files/#{src}.tar.gz | #{tar} xz"
+
+  src = File.join dst, src
+
+  Dir.chdir src do
+    try_configure
+  end
+
+  %w(
+config.h
+snappy-c.cc
+snappy-c.h
+snappy-internal.h
+snappy-sinksource.cc
+snappy-sinksource.h
+snappy-stubs-internal.cc
+snappy-stubs-internal.h
+snappy.cc
+snappy.h
+  ).each do |file|
+    FileUtils.copy File.join(src, file), File.join(dst, file) if FileTest.exist? File.join(src, file)
+  end
+
+  hdr = File.open(File.join(src, 'snappy-stubs-public.h.in'), 'rb'){ |f| f.read }
+  {
+    %r'#if @ac_cv_have_stdint_h@' => '#ifdef HAVE_STDINT_H',
+    %r'#if @ac_cv_have_stddef_h@' => '#ifdef HAVE_STDDEF_H',
+    %r'@SNAPPY_MAJOR@'            => '1',
+    %r'@SNAPPY_MINOR@'            => '0',
+    %r'@SNAPPY_PATCHLEVEL@'       => '4',
+  }.each { |ptn, str| hdr.gsub! ptn, str }
+  File.open(File.join(dst, 'snappy-stubs-public.h'), 'wb'){ |f| f.write hdr }
+
+  FileUtils.touch 'config.h'
+end
+
+have_library 'stdc++'
+create_makefile('packsnap/packsnap')
+

data/ext/packsnap/packer.cc

@@ -0,0 +1,137 @@
+/*
+ * 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 "packer.h"
+
+void msgpack_packer_init(msgpack_packer_t* pk)
+{
+    memset(pk, 0, sizeof(msgpack_packer_t));
+
+    msgpack_buffer_init(PACKER_BUFFER_(pk));
+
+    pk->io = Qnil;
+}
+
+void msgpack_packer_destroy(msgpack_packer_t* pk)
+{
+    msgpack_buffer_destroy(PACKER_BUFFER_(pk));
+}
+
+void msgpack_packer_mark(msgpack_packer_t* pk)
+{
+    rb_gc_mark(pk->io);
+
+    /* See MessagePack_Buffer_wrap */
+    /* msgpack_buffer_mark(PACKER_BUFFER_(pk)); */
+    rb_gc_mark(pk->buffer_ref);
+}
+
+void msgpack_packer_reset(msgpack_packer_t* pk)
+{
+    msgpack_buffer_clear(PACKER_BUFFER_(pk));
+
+    pk->io = Qnil;
+    pk->io_write_all_method = 0;
+    pk->buffer_ref = Qnil;
+}
+
+
+void msgpack_packer_write_array_value(msgpack_packer_t* pk, VALUE v)
+{
+    size_t len = RARRAY_LEN(v);
+    if(len > 0xffffffffUL) {
+        // TODO rb_eArgError?
+        rb_raise(rb_eArgError, "size of array is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
+    }
+    unsigned int len32 = (unsigned int)len;
+    msgpack_packer_write_array_header(pk, len32);
+
+    unsigned int i;
+    for(i=0; i < len32; ++i) {
+        VALUE e = rb_ary_entry(v, i);
+        msgpack_packer_write_value(pk, e);
+    }
+}
+
+static int write_hash_foreach(VALUE key, VALUE value, VALUE pk_value)
+{
+    if (key == Qundef) {
+        return ST_CONTINUE;
+    }
+    msgpack_packer_t* pk = (msgpack_packer_t*) pk_value;
+    msgpack_packer_write_value(pk, key);
+    msgpack_packer_write_value(pk, value);
+    return ST_CONTINUE;
+}
+
+void msgpack_packer_write_hash_value(msgpack_packer_t* pk, VALUE v)
+{
+    size_t len = RHASH_SIZE(v);
+    if(len > 0xffffffffUL) {
+        // TODO rb_eArgError?
+        rb_raise(rb_eArgError, "size of array is too long to pack: %lu bytes should be <= %lu", len, 0xffffffffUL);
+    }
+    unsigned int len32 = (unsigned int)len;
+    msgpack_packer_write_map_header(pk, len32);
+
+    rb_hash_foreach(v, (int (*)(...))write_hash_foreach, (VALUE) pk);
+}
+
+static void _msgpack_packer_write_other_value(msgpack_packer_t* pk, VALUE v)
+{
+    rb_funcall(v, pk->to_msgpack_method, 1, pk->to_msgpack_arg);
+}
+
+void msgpack_packer_write_value(msgpack_packer_t* pk, VALUE v)
+{
+    switch(rb_type(v)) {
+    case T_NIL:
+        msgpack_packer_write_nil(pk);
+        break;
+    case T_TRUE:
+        msgpack_packer_write_true(pk);
+        break;
+    case T_FALSE:
+        msgpack_packer_write_false(pk);
+        break;
+    case T_FIXNUM:
+        msgpack_packer_write_fixnum_value(pk, v);
+        break;
+    case T_SYMBOL:
+        msgpack_packer_write_symbol_value(pk, v);
+        break;
+    case T_STRING:
+        msgpack_packer_write_string_value(pk, v);
+        break;
+    case T_ARRAY:
+        msgpack_packer_write_array_value(pk, v);
+        break;
+    case T_HASH:
+        msgpack_packer_write_hash_value(pk, v);
+        break;
+    case T_BIGNUM:
+        msgpack_packer_write_bignum_value(pk, v);
+        break;
+    case T_FLOAT:
+        msgpack_packer_write_float_value(pk, v);
+        break;
+    default:
+        _msgpack_packer_write_other_value(pk, v);
+    }
+}
+

data/ext/packsnap/packer.h

@@ -0,0 +1,334 @@
+/*
+ * 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_PACKER_H__
+#define MSGPACK_RUBY_PACKER_H__
+
+#include "buffer.hh"
+
+#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_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);
+
+
+//void _msgpack_packer_allocate_writable_space(msgpack_packer_t* pk, size_t require);
+
+//static inline void _msgpack_packer_ensure_writable(msgpack_packer_t* pk, size_t require)
+//{
+//    if(msgpack_buffer_writable_size(PACKER_BUFFER_(pk)) < require) {
+//        _msgpack_packer_allocate_writable_space(pk, require);
+//    }
+//}
+
+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_long(msgpack_packer_t* pk, long v)
+{
+    if(v < -0x20L) {
+        if(v < -0x8000L) {
+            if(v < -0x80000000L) {
+                _msgpack_packer_write_int64(pk, (int64_t) v);
+            } else {
+                _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 <= 0xffffL) {
+            if(v <= 0xffL) {
+                _msgpack_packer_write_uint8(pk, (uint8_t) v);
+            } else {
+                _msgpack_packer_write_uint16(pk, (uint16_t) v);
+            }
+        } else {
+            if(v <= 0xffffffffL) {
+                _msgpack_packer_write_uint32(pk, (uint32_t) v);
+            } else {
+                _msgpack_packer_write_uint64(pk, (uint64_t) 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); /* FIXME _msgpack_be_double */
+    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 < 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_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);
+    }
+}
+
+
+void _msgpack_packer_write_string_to_io(msgpack_packer_t* pk, VALUE string);
+
+static inline void msgpack_packer_write_string_value(msgpack_packer_t* pk, VALUE v)
+{
+    /* TODO encoding conversion */
+    size_t 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);
+    }
+    msgpack_packer_write_raw_header(pk, (unsigned int)len);
+    msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+    //if(pk->io != Qnil && RSTRING_LEN(v) > MSGPACK_PACKER_IO_FLUSH_THRESHOLD_TO_WRITE_STRING_BODY) {
+    //    msgpack_buffer_flush_to_io(PACKER_BUFFER_(pk), pk->io, pk->io_write_all_method);
+    //    rb_funcall(pk->io, pk->io_write_all_method, 1, v);
+    //} else {
+    //    msgpack_buffer_append_string(PACKER_BUFFER_(pk), v);
+    //}
+}
+
+static inline void msgpack_packer_write_symbol_value(msgpack_packer_t* pk, VALUE v)
+{
+    const char* name = rb_id2name(SYM2ID(v));
+    size_t len = strlen(name);
+    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);
+}
+
+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(pk, rb_big2ll(v));  /* FIXME long long? */
+    }
+}
+
+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
+