rroonga 5.0.1-x64-mingw32 → 5.0.2-x64-mingw32

data/vendor/local/include/msgpack/object_fwd.hpp

@@ -0,0 +1,182 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
+//
+//    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_OBJECT_FWD_HPP
+#define MSGPACK_OBJECT_FWD_HPP
+
+#include "msgpack/versioning.hpp"
+#include "msgpack/zone.hpp"
+#include "msgpack/object.h"
+
+#include <typeinfo>
+
+namespace msgpack {
+
+MSGPACK_API_VERSION_NAMESPACE(v1) {
+
+
+namespace type {
+    enum object_type {
+        NIL                 = MSGPACK_OBJECT_NIL,
+        BOOLEAN             = MSGPACK_OBJECT_BOOLEAN,
+        POSITIVE_INTEGER    = MSGPACK_OBJECT_POSITIVE_INTEGER,
+        NEGATIVE_INTEGER    = MSGPACK_OBJECT_NEGATIVE_INTEGER,
+        FLOAT               = MSGPACK_OBJECT_FLOAT,
+#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+        DOUBLE              = MSGPACK_OBJECT_DOUBLE, // obsolete
+#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
+        STR                 = MSGPACK_OBJECT_STR,
+        BIN                 = MSGPACK_OBJECT_BIN,
+        ARRAY               = MSGPACK_OBJECT_ARRAY,
+        MAP                 = MSGPACK_OBJECT_MAP,
+        EXT                 = MSGPACK_OBJECT_EXT
+    };
+}
+
+
+struct object;
+struct object_kv;
+
+struct object_array {
+    uint32_t size;
+    msgpack::object* ptr;
+};
+
+struct object_map {
+    uint32_t size;
+    msgpack::object_kv* ptr;
+};
+
+struct object_str {
+    uint32_t size;
+    const char* ptr;
+};
+
+struct object_bin {
+    uint32_t size;
+    const char* ptr;
+};
+
+struct object_ext {
+    int8_t type() const { return ptr[0]; }
+    const char* data() const { return &ptr[1]; }
+    uint32_t size;
+    const char* ptr;
+};
+
+struct object {
+    union union_type {
+        bool boolean;
+        uint64_t u64;
+        int64_t  i64;
+#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+        double   dec; // obsolete
+#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
+        double   f64;
+        msgpack::object_array array;
+        msgpack::object_map map;
+        msgpack::object_str str;
+        msgpack::object_bin bin;
+        msgpack::object_ext ext;
+    };
+
+    msgpack::type::object_type type;
+    union_type via;
+
+    bool is_nil() const { return type == msgpack::type::NIL; }
+
+    template <typename T>
+    T as() const;
+
+    template <typename T>
+    void convert(T& v) const;
+    template <typename T>
+    void convert(T* v) const;
+
+    object();
+
+    object(const msgpack_object& o);
+
+    template <typename T>
+    explicit object(const T& v);
+
+    template <typename T>
+    object(const T& v, msgpack::zone& z);
+
+    // obsolete
+    template <typename T>
+    object(const T& v, msgpack::zone* z);
+
+    template <typename T>
+    object& operator=(const T& v);
+
+    operator msgpack_object() const;
+
+    struct with_zone;
+
+private:
+    struct implicit_type;
+
+public:
+    implicit_type convert() const;
+};
+
+class type_error : public std::bad_cast { };
+
+struct object_kv {
+    msgpack::object key;
+    msgpack::object val;
+};
+
+namespace detail {
+template <typename Stream, typename T>
+struct packer_serializer;
+} // namespace detail
+
+msgpack::object const& operator>> (msgpack::object const& o, msgpack::object& v);
+
+template <typename T>
+msgpack::object const& operator>> (msgpack::object const& o, T& v);
+
+template <typename T>
+void operator<< (msgpack::object::with_zone& o, const T& v);
+
+void operator<< (msgpack::object::with_zone& o, const msgpack::object& v);
+
+void operator<< (msgpack::object::with_zone& o, const msgpack::object::with_zone& v);
+
+template <typename Stream>
+class packer;
+
+template <typename Stream>
+msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object& v);
+
+template <typename Stream>
+msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::object::with_zone& v);
+
+template <typename Stream, typename T>
+msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const T& v);
+
+template <typename T>
+void operator<< (msgpack::object::with_zone& o, const T& v);
+
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+
+} // namespace msgpack
+
+#endif // MSGPACK_OBJECT_FWD_HPP

data/vendor/local/include/msgpack/pack.h

@@ -15,8 +15,8 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-#ifndef MSGPACK_PACK_H__
-#define MSGPACK_PACK_H__
+#ifndef MSGPACK_PACK_H
+#define MSGPACK_PACK_H
 
 #include "pack_define.h"
 #include "object.h"
@@ -43,8 +43,8 @@ extern "C" {
 typedef int (*msgpack_packer_write)(void* data, const char* buf, size_t len);
 
 typedef struct msgpack_packer {
-	void* data;
-	msgpack_packer_write callback;
+    void* data;
+    msgpack_packer_write callback;
 } msgpack_packer;
 
 static void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback);
@@ -94,8 +94,14 @@ static int msgpack_pack_array(msgpack_packer* pk, size_t n);
 
 static int msgpack_pack_map(msgpack_packer* pk, size_t n);
 
-static int msgpack_pack_raw(msgpack_packer* pk, size_t l);
-static int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l);
+static int msgpack_pack_str(msgpack_packer* pk, size_t l);
+static int msgpack_pack_str_body(msgpack_packer* pk, const void* b, size_t l);
+
+static int msgpack_pack_bin(msgpack_packer* pk, size_t l);
+static int msgpack_pack_bin_body(msgpack_packer* pk, const void* b, size_t l);
+
+static int msgpack_pack_ext(msgpack_packer* pk, size_t l, int8_t type);
+static int msgpack_pack_ext_body(msgpack_packer* pk, const void* b, size_t l);
 
 int msgpack_pack_object(msgpack_packer* pk, msgpack_object d);
 
@@ -104,38 +110,38 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d);
 
 
 #define msgpack_pack_inline_func(name) \
-	inline int msgpack_pack ## name
+    inline int msgpack_pack ## name
 
 #define msgpack_pack_inline_func_cint(name) \
-	inline int msgpack_pack ## name
+    inline int msgpack_pack ## name
 
 #define msgpack_pack_inline_func_fixint(name) \
-	inline int msgpack_pack_fix ## name
+    inline int msgpack_pack_fix ## name
 
 #define msgpack_pack_user msgpack_packer*
 
 #define msgpack_pack_append_buffer(user, buf, len) \
-	return (*(user)->callback)((user)->data, (const char*)buf, len)
+    return (*(user)->callback)((user)->data, (const char*)buf, len)
 
 #include "pack_template.h"
 
 inline void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback)
 {
-	pk->data = data;
-	pk->callback = callback;
+    pk->data = data;
+    pk->callback = callback;
 }
 
 inline msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback)
 {
-	msgpack_packer* pk = (msgpack_packer*)calloc(1, sizeof(msgpack_packer));
-	if(!pk) { return NULL; }
-	msgpack_packer_init(pk, data, callback);
-	return pk;
+    msgpack_packer* pk = (msgpack_packer*)calloc(1, sizeof(msgpack_packer));
+    if(!pk) { return NULL; }
+    msgpack_packer_init(pk, data, callback);
+    return pk;
 }
 
 inline void msgpack_packer_free(msgpack_packer* pk)
 {
-	free(pk);
+    free(pk);
 }
 
 

data/vendor/local/include/msgpack/pack.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ serializing routine
 //
-// Copyright (C) 2008-2010 FURUHASHI Sadayuki
+// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -15,323 +15,1048 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 //
-#ifndef MSGPACK_PACK_HPP__
-#define MSGPACK_PACK_HPP__
+#ifndef MSGPACK_PACK_HPP
+#define MSGPACK_PACK_HPP
+
+#include "msgpack/versioning.hpp"
 
-#include "pack_define.h"
 #include <stdexcept>
-#include <limits.h>
+#include <limits>
+#include <cstring>
+#include <climits>
+
+#include "sysdep.h"
 
 namespace msgpack {
 
+MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 template <typename Stream>
 class packer {
 public:
-	packer(Stream* s);
-	packer(Stream& s);
-	~packer();
+    packer(Stream* s);
+    packer(Stream& s);
 
 public:
-	template <typename T>
-	packer<Stream>& pack(const T& v);
-
-	packer<Stream>& pack_uint8(uint8_t d);
-	packer<Stream>& pack_uint16(uint16_t d);
-	packer<Stream>& pack_uint32(uint32_t d);
-	packer<Stream>& pack_uint64(uint64_t d);
-	packer<Stream>& pack_int8(int8_t d);
-	packer<Stream>& pack_int16(int16_t d);
-	packer<Stream>& pack_int32(int32_t d);
-	packer<Stream>& pack_int64(int64_t d);
-
-	packer<Stream>& pack_fix_uint8(uint8_t d);
-	packer<Stream>& pack_fix_uint16(uint16_t d);
-	packer<Stream>& pack_fix_uint32(uint32_t d);
-	packer<Stream>& pack_fix_uint64(uint64_t d);
-	packer<Stream>& pack_fix_int8(int8_t d);
-	packer<Stream>& pack_fix_int16(int16_t d);
-	packer<Stream>& pack_fix_int32(int32_t d);
-	packer<Stream>& pack_fix_int64(int64_t d);
-
-	packer<Stream>& pack_char(char d);
-	packer<Stream>& pack_signed_char(signed char d);
-	packer<Stream>& pack_short(short d);
-	packer<Stream>& pack_int(int d);
-	packer<Stream>& pack_long(long d);
-	packer<Stream>& pack_long_long(long long d);
-	packer<Stream>& pack_unsigned_char(unsigned char d);
-	packer<Stream>& pack_unsigned_short(unsigned short d);
-	packer<Stream>& pack_unsigned_int(unsigned int d);
-	packer<Stream>& pack_unsigned_long(unsigned long d);
-	packer<Stream>& pack_unsigned_long_long(unsigned long long d);
-
-	packer<Stream>& pack_float(float d);
-	packer<Stream>& pack_double(double d);
-
-	packer<Stream>& pack_nil();
-	packer<Stream>& pack_true();
-	packer<Stream>& pack_false();
-
-	packer<Stream>& pack_array(size_t n);
-
-	packer<Stream>& pack_map(size_t n);
-
-	packer<Stream>& pack_raw(size_t l);
-	packer<Stream>& pack_raw_body(const char* b, size_t l);
+    template <typename T>
+    packer<Stream>& pack(const T& v);
+
+    packer<Stream>& pack_uint8(uint8_t d);
+    packer<Stream>& pack_uint16(uint16_t d);
+    packer<Stream>& pack_uint32(uint32_t d);
+    packer<Stream>& pack_uint64(uint64_t d);
+    packer<Stream>& pack_int8(int8_t d);
+    packer<Stream>& pack_int16(int16_t d);
+    packer<Stream>& pack_int32(int32_t d);
+    packer<Stream>& pack_int64(int64_t d);
+
+    packer<Stream>& pack_fix_uint8(uint8_t d);
+    packer<Stream>& pack_fix_uint16(uint16_t d);
+    packer<Stream>& pack_fix_uint32(uint32_t d);
+    packer<Stream>& pack_fix_uint64(uint64_t d);
+    packer<Stream>& pack_fix_int8(int8_t d);
+    packer<Stream>& pack_fix_int16(int16_t d);
+    packer<Stream>& pack_fix_int32(int32_t d);
+    packer<Stream>& pack_fix_int64(int64_t d);
+
+    packer<Stream>& pack_char(char d);
+    packer<Stream>& pack_signed_char(signed char d);
+    packer<Stream>& pack_short(short d);
+    packer<Stream>& pack_int(int d);
+    packer<Stream>& pack_long(long d);
+    packer<Stream>& pack_long_long(long long d);
+    packer<Stream>& pack_unsigned_char(unsigned char d);
+    packer<Stream>& pack_unsigned_short(unsigned short d);
+    packer<Stream>& pack_unsigned_int(unsigned int d);
+    packer<Stream>& pack_unsigned_long(unsigned long d);
+    packer<Stream>& pack_unsigned_long_long(unsigned long long d);
+
+    packer<Stream>& pack_float(float d);
+    packer<Stream>& pack_double(double d);
+
+    packer<Stream>& pack_nil();
+    packer<Stream>& pack_true();
+    packer<Stream>& pack_false();
+
+    packer<Stream>& pack_array(uint32_t n);
+
+	packer<Stream>& pack_map(uint32_t n);
+
+	packer<Stream>& pack_str(uint32_t l);
+	packer<Stream>& pack_str_body(const char* b, uint32_t l);
+
+	packer<Stream>& pack_bin(uint32_t l);
+	packer<Stream>& pack_bin_body(const char* b, uint32_t l);
+
+    packer<Stream>& pack_ext(size_t l, int8_t type);
+	packer<Stream>& pack_ext_body(const char* b, uint32_t l);
 
 private:
-	static void _pack_uint8(Stream& x, uint8_t d);
-	static void _pack_uint16(Stream& x, uint16_t d);
-	static void _pack_uint32(Stream& x, uint32_t d);
-	static void _pack_uint64(Stream& x, uint64_t d);
-	static void _pack_int8(Stream& x, int8_t d);
-	static void _pack_int16(Stream& x, int16_t d);
-	static void _pack_int32(Stream& x, int32_t d);
-	static void _pack_int64(Stream& x, int64_t d);
-
-	static void _pack_fix_uint8(Stream& x, uint8_t d);
-	static void _pack_fix_uint16(Stream& x, uint16_t d);
-	static void _pack_fix_uint32(Stream& x, uint32_t d);
-	static void _pack_fix_uint64(Stream& x, uint64_t d);
-	static void _pack_fix_int8(Stream& x, int8_t d);
-	static void _pack_fix_int16(Stream& x, int16_t d);
-	static void _pack_fix_int32(Stream& x, int32_t d);
-	static void _pack_fix_int64(Stream& x, int64_t d);
-
-	static void _pack_char(Stream& x, char d);
-
-	static void _pack_signed_char(Stream& x, signed char d);
-	static void _pack_short(Stream& x, short d);
-	static void _pack_int(Stream& x, int d);
-	static void _pack_long(Stream& x, long d);
-	static void _pack_long_long(Stream& x, long long d);
-	static void _pack_unsigned_char(Stream& x, unsigned char d);
-	static void _pack_unsigned_short(Stream& x, unsigned short d);
-	static void _pack_unsigned_int(Stream& x, unsigned int d);
-	static void _pack_unsigned_long(Stream& x, unsigned long d);
-	static void _pack_unsigned_long_long(Stream& x, unsigned long long d);
-
-	static void _pack_float(Stream& x, float d);
-	static void _pack_double(Stream& x, double d);
-
-	static void _pack_nil(Stream& x);
-	static void _pack_true(Stream& x);
-	static void _pack_false(Stream& x);
-
-	static void _pack_array(Stream& x, size_t n);
-
-	static void _pack_map(Stream& x, size_t n);
-
-	static void _pack_raw(Stream& x, size_t l);
-	static void _pack_raw_body(Stream& x, const void* b, size_t l);
-
-	static void append_buffer(Stream& x, const unsigned char* buf, size_t len)
-		{ x.write((const char*)buf, len); }
+    template <typename T>
+    void pack_imp_uint8(T d);
+    template <typename T>
+    void pack_imp_uint16(T d);
+    template <typename T>
+    void pack_imp_uint32(T d);
+    template <typename T>
+    void pack_imp_uint64(T d);
+    template <typename T>
+    void pack_imp_int8(T d);
+    template <typename T>
+    void pack_imp_int16(T d);
+    template <typename T>
+    void pack_imp_int32(T d);
+    template <typename T>
+    void pack_imp_int64(T d);
+
+    void append_buffer(const char* buf, size_t len)
+        { m_stream.write(buf, len); }
 
 private:
-	Stream& m_stream;
+    Stream& m_stream;
 
+#if defined(MSGPACK_USE_CPP03)
 private:
-	packer();
+    packer(const packer&);
+    packer& operator=(const packer&);
+#else  // defined(MSGPACK_USE_CPP03)
+    packer(const packer&) = delete;
+    packer& operator=(const packer&) = delete;
+#endif // defined(MSGPACK_USE_CPP03)
+    packer();
 };
 
 
 template <typename Stream, typename T>
 inline void pack(Stream* s, const T& v)
 {
-	packer<Stream>(s).pack(v);
+    packer<Stream>(*s).pack(v);
 }
 
 template <typename Stream, typename T>
 inline void pack(Stream& s, const T& v)
 {
-	packer<Stream>(s).pack(v);
+    packer<Stream>(s).pack(v);
 }
 
+// serialize operator
+template <typename Stream, typename T>
+inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const T& v)
+{
+    return detail::packer_serializer<Stream, T>::pack(o, v);
+}
 
-#define msgpack_pack_inline_func(name) \
-	template <typename Stream> \
-	inline void packer<Stream>::_pack ## name
-
-#define msgpack_pack_inline_func_cint(name) \
-	template <typename Stream> \
-	inline void packer<Stream>::_pack ## name
-
-#define msgpack_pack_inline_func_fixint(name) \
-	template <typename Stream> \
-	inline void packer<Stream>::_pack_fix ## name
 
-#define msgpack_pack_user Stream&
 
-#define msgpack_pack_append_buffer append_buffer
+#if defined(__LITTLE_ENDIAN__)
+template <typename T>
+inline char take8_8(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+template <typename T>
+inline char take8_16(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+template <typename T>
+inline char take8_32(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+template <typename T>
+inline char take8_64(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
 
-#include "pack_template.h"
+#elif defined(__BIG_ENDIAN__)
 
+template <typename T>
+inline char take8_8(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
+}
+template <typename T>
+inline char take8_16(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[1]);
+}
+template <typename T>
+inline char take8_32(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[3]);
+}
+template <typename T>
+inline char take8_64(T d) {
+    return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[7]);
+}
 
-template <typename Stream>
-packer<Stream>::packer(Stream* s) : m_stream(*s) { }
+#endif
 
 template <typename Stream>
-packer<Stream>::packer(Stream& s) : m_stream(s) { }
+inline packer<Stream>::packer(Stream* s) : m_stream(*s) { }
 
 template <typename Stream>
-packer<Stream>::~packer() { }
+inline packer<Stream>::packer(Stream& s) : m_stream(s) { }
 
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_uint8(uint8_t d)
-{ _pack_uint8(m_stream, d); return *this; }
+{ pack_imp_uint8(d); return *this; }
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_uint16(uint16_t d)
-{ _pack_uint16(m_stream, d); return *this; }
+{ pack_imp_uint16(d); return *this; }
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_uint32(uint32_t d)
-{ _pack_uint32(m_stream, d); return *this; }
+{ pack_imp_uint32(d); return *this; }
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_uint64(uint64_t d)
-{ _pack_uint64(m_stream, d); return *this; }
+{ pack_imp_uint64(d); return *this; }
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_int8(int8_t d)
-{ _pack_int8(m_stream, d); return *this; }
+{ pack_imp_int8(d); return *this; }
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_int16(int16_t d)
-{ _pack_int16(m_stream, d); return *this; }
+{ pack_imp_int16(d); return *this; }
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_int32(int32_t d)
-{ _pack_int32(m_stream, d); return *this; }
+{ pack_imp_int32(d); return *this; }
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_int64(int64_t d)
-{ _pack_int64(m_stream, d); return *this;}
+{ pack_imp_int64(d); return *this;}
 
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_uint8(uint8_t d)
-{ _pack_fix_uint8(m_stream, d); return *this; }
+{
+    char buf[2] = {static_cast<char>(0xccu), take8_8(d)};
+    append_buffer(buf, 2);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_uint16(uint16_t d)
-{ _pack_fix_uint16(m_stream, d); return *this; }
+{
+    char buf[3];
+    buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], d);
+    append_buffer(buf, 3);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_uint32(uint32_t d)
-{ _pack_fix_uint32(m_stream, d); return *this; }
+{
+    char buf[5];
+    buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], d);
+    append_buffer(buf, 5);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_uint64(uint64_t d)
-{ _pack_fix_uint64(m_stream, d); return *this; }
+{
+    char buf[9];
+    buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
+    append_buffer(buf, 9);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_int8(int8_t d)
-{ _pack_fix_int8(m_stream, d); return *this; }
+{
+    char buf[2] = {static_cast<char>(0xd0u), take8_8(d)};
+    append_buffer(buf, 2);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_int16(int16_t d)
-{ _pack_fix_int16(m_stream, d); return *this; }
+{
+    char buf[3];
+    buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], d);
+    append_buffer(buf, 3);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_int32(int32_t d)
-{ _pack_fix_int32(m_stream, d); return *this; }
+{
+    char buf[5];
+    buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], d);
+    append_buffer(buf, 5);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_fix_int64(int64_t d)
-{ _pack_fix_int64(m_stream, d); return *this;}
+{
+    char buf[9];
+    buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
+    append_buffer(buf, 9);
+    return *this;
+}
 
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_char(char d)
-{ _pack_char(m_stream, d); return *this; }
+{
+#if defined(CHAR_MIN)
+#if CHAR_MIN < 0
+    pack_imp_int8(d);
+#else
+    pack_imp_uint8(d);
+#endif
+#else
+#error CHAR_MIN is not defined
+#endif
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_signed_char(signed char d)
-{ _pack_signed_char(m_stream, d); return *this; }
+{
+    pack_imp_int8(d);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_short(short d)
-{ _pack_short(m_stream, d); return *this; }
+{
+#if defined(SIZEOF_SHORT)
+#if SIZEOF_SHORT == 2
+    pack_imp_int16(d);
+#elif SIZEOF_SHORT == 4
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#elif defined(SHRT_MAX)
+#if SHRT_MAX == 0x7fff
+    pack_imp_int16(d);
+#elif SHRT_MAX == 0x7fffffff
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#else
+    if(sizeof(short) == 2) {
+        pack_imp_int16(d);
+    } else if(sizeof(short) == 4) {
+        pack_imp_int32(d);
+    } else {
+        pack_imp_int64(d);
+    }
+#endif
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_int(int d)
-{ _pack_int(m_stream, d); return *this; }
+{
+#if defined(SIZEOF_INT)
+#if SIZEOF_INT == 2
+    pack_imp_int16(d);
+#elif SIZEOF_INT == 4
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#elif defined(INT_MAX)
+#if INT_MAX == 0x7fff
+    pack_imp_int16(d);
+#elif INT_MAX == 0x7fffffff
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#else
+    if(sizeof(int) == 2) {
+        pack_imp_int16(d);
+    } else if(sizeof(int) == 4) {
+        pack_imp_int32(d);
+    } else {
+        pack_imp_int64(d);
+    }
+#endif
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_long(long d)
-{ _pack_long(m_stream, d); return *this; }
+{
+#if defined(SIZEOF_LONG)
+#if SIZEOF_LONG == 2
+    pack_imp_int16(d);
+#elif SIZEOF_LONG == 4
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#elif defined(LONG_MAX)
+#if LONG_MAX == 0x7fffL
+    pack_imp_int16(d);
+#elif LONG_MAX == 0x7fffffffL
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#else
+    if(sizeof(long) == 2) {
+        pack_imp_int16(d);
+    } else if(sizeof(long) == 4) {
+        pack_imp_int32(d);
+    } else {
+        pack_imp_int64(d);
+    }
+#endif
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_long_long(long long d)
-{ _pack_long_long(m_stream, d); return *this; }
+{
+#if defined(SIZEOF_LONG_LONG)
+#if SIZEOF_LONG_LONG == 2
+    pack_imp_int16(d);
+#elif SIZEOF_LONG_LONG == 4
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#elif defined(LLONG_MAX)
+#if LLONG_MAX == 0x7fffL
+    pack_imp_int16(d);
+#elif LLONG_MAX == 0x7fffffffL
+    pack_imp_int32(d);
+#else
+    pack_imp_int64(d);
+#endif
+
+#else
+    if(sizeof(long long) == 2) {
+        pack_imp_int16(d);
+    } else if(sizeof(long long) == 4) {
+        pack_imp_int32(d);
+    } else {
+        pack_imp_int64(d);
+    }
+#endif
+    return *this;
+}
+
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_unsigned_char(unsigned char d)
-{ _pack_unsigned_char(m_stream, d); return *this; }
+{
+    pack_imp_uint8(d);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_unsigned_short(unsigned short d)
-{ _pack_unsigned_short(m_stream, d); return *this; }
+{
+#if defined(SIZEOF_SHORT)
+#if SIZEOF_SHORT == 2
+    pack_imp_uint16(d);
+#elif SIZEOF_SHORT == 4
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#elif defined(USHRT_MAX)
+#if USHRT_MAX == 0xffffU
+    pack_imp_uint16(d);
+#elif USHRT_MAX == 0xffffffffU
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#else
+    if(sizeof(unsigned short) == 2) {
+        pack_imp_uint16(d);
+    } else if(sizeof(unsigned short) == 4) {
+        pack_imp_uint32(d);
+    } else {
+        pack_imp_uint64(d);
+    }
+#endif
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_unsigned_int(unsigned int d)
-{ _pack_unsigned_int(m_stream, d); return *this; }
+{
+#if defined(SIZEOF_INT)
+#if SIZEOF_INT == 2
+    pack_imp_uint16(d);
+#elif SIZEOF_INT == 4
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#elif defined(UINT_MAX)
+#if UINT_MAX == 0xffffU
+    pack_imp_uint16(d);
+#elif UINT_MAX == 0xffffffffU
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#else
+    if(sizeof(unsigned int) == 2) {
+        pack_imp_uint16(d);
+    } else if(sizeof(unsigned int) == 4) {
+        pack_imp_uint32(d);
+    } else {
+        pack_imp_uint64(d);
+    }
+#endif
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_unsigned_long(unsigned long d)
-{ _pack_unsigned_long(m_stream, d); return *this; }
+{
+#if defined(SIZEOF_LONG)
+#if SIZEOF_LONG == 2
+    pack_imp_uint16(d);
+#elif SIZEOF_LONG == 4
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#elif defined(ULONG_MAX)
+#if ULONG_MAX == 0xffffUL
+    pack_imp_uint16(d);
+#elif ULONG_MAX == 0xffffffffUL
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#else
+    if(sizeof(unsigned long) == 2) {
+        pack_imp_uint16(d);
+    } else if(sizeof(unsigned long) == 4) {
+        pack_imp_uint32(d);
+    } else {
+        pack_imp_uint64(d);
+    }
+#endif
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_unsigned_long_long(unsigned long long d)
-{ _pack_unsigned_long_long(m_stream, d); return *this; }
+{
+#if defined(SIZEOF_LONG_LONG)
+#if SIZEOF_LONG_LONG == 2
+    pack_imp_uint16(d);
+#elif SIZEOF_LONG_LONG == 4
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#elif defined(ULLONG_MAX)
+#if ULLONG_MAX == 0xffffUL
+    pack_imp_uint16(d);
+#elif ULLONG_MAX == 0xffffffffUL
+    pack_imp_uint32(d);
+#else
+    pack_imp_uint64(d);
+#endif
+
+#else
+    if(sizeof(unsigned long long) == 2) {
+        pack_imp_uint16(d);
+    } else if(sizeof(unsigned long long) == 4) {
+        pack_imp_uint32(d);
+    } else {
+        pack_imp_uint64(d);
+    }
+#endif
+    return *this;
+}
 
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_float(float d)
-{ _pack_float(m_stream, d); return *this; }
+{
+    union { float f; uint32_t i; } mem;
+    mem.f = d;
+    char buf[5];
+    buf[0] = static_cast<char>(0xcau); _msgpack_store32(&buf[1], mem.i);
+    append_buffer(buf, 5);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_double(double d)
-{ _pack_double(m_stream, d); return *this; }
+{
+    union { double f; uint64_t i; } mem;
+    mem.f = d;
+    char buf[9];
+    buf[0] = static_cast<char>(0xcbu);
+#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
+    // https://github.com/msgpack/msgpack-perl/pull/1
+    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
+#endif
+    _msgpack_store64(&buf[1], mem.i);
+    append_buffer(buf, 9);
+    return *this;
+}
 
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_nil()
-{ _pack_nil(m_stream); return *this; }
+{
+    const char d = static_cast<char>(0xc0u);
+    append_buffer(&d, 1);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_true()
-{ _pack_true(m_stream); return *this; }
+{
+    const char d = static_cast<char>(0xc3u);
+    append_buffer(&d, 1);
+    return *this;
+}
 
 template <typename Stream>
 inline packer<Stream>& packer<Stream>::pack_false()
-{ _pack_false(m_stream); return *this; }
+{
+    const char d = static_cast<char>(0xc2u);
+    append_buffer(&d, 1);
+    return *this;
+}
+
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_array(uint32_t n)
+{
+    if(n < 16) {
+        char d = static_cast<char>(0x90u | n);
+        append_buffer(&d, 1);
+    } else if(n < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xdcu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xddu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_map(uint32_t n)
+{
+    if(n < 16) {
+        unsigned char d = static_cast<unsigned char>(0x80u | n);
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    } else if(n < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xdeu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xdfu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_str(uint32_t l)
+{
+    if(l < 32) {
+        unsigned char d = 0xa0u | static_cast<uint8_t>(l);
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    } else if(l < 256) {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<uint8_t>(l);
+        append_buffer(buf, 2);
+    } else if(l < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_str_body(const char* b, uint32_t l)
+{
+    append_buffer(b, l);
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_bin(uint32_t l)
+{
+    if(l < 256) {
+        char buf[2];
+        buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<uint8_t>(l);
+        append_buffer(buf, 2);
+    } else if(l < 65536) {
+        char buf[3];
+        buf[0] = static_cast<char>(0xc5u); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
+        append_buffer(buf, 3);
+    } else {
+        char buf[5];
+        buf[0] = static_cast<char>(0xc6u); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
+        append_buffer(buf, 5);
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_bin_body(const char* b, uint32_t l)
+{
+    append_buffer(b, l);
+    return *this;
+}
 
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_ext(size_t l, int8_t type)
+{
+    switch(l) {
+    case 1: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd4u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    case 2: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd5u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    case 4: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd6u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    case 8: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd7u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    case 16: {
+        char buf[2];
+        buf[0] = static_cast<char>(0xd8u);
+        buf[1] = static_cast<char>(type);
+        append_buffer(buf, 2);
+    } break;
+    default:
+        if(l < 256) {
+            char buf[3];
+            buf[0] = static_cast<char>(0xc7u);
+            buf[1] = static_cast<char>(l);
+            buf[2] = static_cast<char>(type);
+            append_buffer(buf, 3);
+        } else if(l < 65536) {
+            char buf[4];
+            buf[0] = static_cast<char>(0xc8u);
+            _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
+            buf[3] = static_cast<char>(type);
+            append_buffer(buf, 4);
+        } else {
+            char buf[6];
+            buf[0] = static_cast<char>(0xc9u);
+            _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
+            buf[5] = static_cast<char>(type);
+            append_buffer(buf, 6);
+        }
+        break;
+    }
+    return *this;
+}
+
+template <typename Stream>
+inline packer<Stream>& packer<Stream>::pack_ext_body(const char* b, uint32_t l)
+{
+    append_buffer(b, l);
+    return *this;
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_uint8(T d)
+{
+    if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    } else {
+        /* unsigned 8 */
+        char buf[2] = {static_cast<char>(0xccu), take8_8(d)};
+        append_buffer(buf, 2);
+    }
+}
+
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_uint16(T d)
+{
+    if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_16(d);
+        append_buffer(&buf, 1);
+    } else if(d < (1<<8)) {
+        /* unsigned 8 */
+        char buf[2] = {static_cast<char>(0xccu), take8_16(d)};
+        append_buffer(buf, 2);
+    } else {
+        /* unsigned 16 */
+        char buf[3];
+        buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+        append_buffer(buf, 3);
+    }
+}
 
 template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_array(size_t n)
-{ _pack_array(m_stream, n); return *this; }
+template <typename T>
+inline void packer<Stream>::pack_imp_uint32(T d)
+{
+    if(d < (1<<8)) {
+        if(d < (1<<7)) {
+            /* fixnum */
+            char buf = take8_32(d);
+            append_buffer(&buf, 1);
+        } else {
+            /* unsigned 8 */
+            char buf[2] = {static_cast<char>(0xccu), take8_32(d)};
+            append_buffer(buf, 2);
+        }
+    } else {
+        if(d < (1<<16)) {
+            /* unsigned 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+            append_buffer(buf, 3);
+        } else {
+            /* unsigned 32 */
+            char buf[5];
+            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
+            append_buffer(buf, 5);
+        }
+    }
+}
 
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_uint64(T d)
+{
+    if(d < (1ULL<<8)) {
+        if(d < (1ULL<<7)) {
+            /* fixnum */
+            char buf = take8_64(d);
+            append_buffer(&buf, 1);
+        } else {
+            /* unsigned 8 */
+            char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
+            append_buffer(buf, 2);
+        }
+    } else {
+        if(d < (1ULL<<16)) {
+            /* unsigned 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+            append_buffer(buf, 3);
+        } else if(d < (1ULL<<32)) {
+            /* unsigned 32 */
+            char buf[5];
+            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
+            append_buffer(buf, 5);
+        } else {
+            /* unsigned 64 */
+            char buf[9];
+            buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
+            append_buffer(buf, 9);
+        }
+    }
+}
 
 template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_map(size_t n)
-{ _pack_map(m_stream, n); return *this; }
+template <typename T>
+inline void packer<Stream>::pack_imp_int8(T d)
+{
+    if(d < -(1<<5)) {
+        /* signed 8 */
+        char buf[2] = {static_cast<char>(0xd0u), take8_8(d)};
+        append_buffer(buf, 2);
+    } else {
+        /* fixnum */
+        char buf = take8_8(d);
+        append_buffer(&buf, 1);
+    }
+}
 
+template <typename Stream>
+template <typename T>
+inline void packer<Stream>::pack_imp_int16(T d)
+{
+    if(d < -(1<<5)) {
+        if(d < -(1<<7)) {
+            /* signed 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
+            append_buffer(buf, 3);
+        } else {
+            /* signed 8 */
+            char buf[2] = {static_cast<char>(0xd0u), take8_16(d)};
+            append_buffer(buf, 2);
+        }
+    } else if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_16(d);
+        append_buffer(&buf, 1);
+    } else {
+        if(d < (1<<8)) {
+            /* unsigned 8 */
+            char buf[2] = {static_cast<char>(0xccu), take8_16(d)};
+            append_buffer(buf, 2);
+        } else {
+            /* unsigned 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+            append_buffer(buf, 3);
+        }
+    }
+}
 
 template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_raw(size_t l)
-{ _pack_raw(m_stream, l); return *this; }
+template <typename T>
+inline void packer<Stream>::pack_imp_int32(T d)
+{
+    if(d < -(1<<5)) {
+        if(d < -(1<<15)) {
+            /* signed 32 */
+            char buf[5];
+            buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
+            append_buffer(buf, 5);
+        } else if(d < -(1<<7)) {
+            /* signed 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
+            append_buffer(buf, 3);
+        } else {
+            /* signed 8 */
+            char buf[2] = { static_cast<char>(0xd0u), take8_32(d)};
+            append_buffer(buf, 2);
+        }
+    } else if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_32(d);
+        append_buffer(&buf, 1);
+    } else {
+        if(d < (1<<8)) {
+            /* unsigned 8 */
+            char buf[2] = { static_cast<char>(0xccu), take8_32(d)};
+            append_buffer(buf, 2);
+        } else if(d < (1<<16)) {
+            /* unsigned 16 */
+            char buf[3];
+            buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+            append_buffer(buf, 3);
+        } else {
+            /* unsigned 32 */
+            char buf[5];
+            buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
+            append_buffer(buf, 5);
+        }
+    }
+}
 
 template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_raw_body(const char* b, size_t l)
-{ _pack_raw_body(m_stream, b, l); return *this; }
+template <typename T>
+inline void packer<Stream>::pack_imp_int64(T d)
+{
+    if(d < -(1LL<<5)) {
+        if(d < -(1LL<<15)) {
+            if(d < -(1LL<<31)) {
+                /* signed 64 */
+                char buf[9];
+                buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
+                append_buffer(buf, 9);
+            } else {
+                /* signed 32 */
+                char buf[5];
+                buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
+                append_buffer(buf, 5);
+            }
+        } else {
+            if(d < -(1<<7)) {
+                /* signed 16 */
+                char buf[3];
+                buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
+                append_buffer(buf, 3);
+            } else {
+                /* signed 8 */
+                char buf[2] = {static_cast<char>(0xd0u), take8_64(d)};
+                append_buffer(buf, 2);
+            }
+        }
+    } else if(d < (1<<7)) {
+        /* fixnum */
+        char buf = take8_64(d);
+        append_buffer(&buf, 1);
+    } else {
+        if(d < (1LL<<16)) {
+            if(d < (1<<8)) {
+                /* unsigned 8 */
+                char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
+                append_buffer(buf, 2);
+            } else {
+                /* unsigned 16 */
+                char buf[3];
+                buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
+                append_buffer(buf, 3);
+            }
+        } else {
+            if(d < (1LL<<32)) {
+                /* unsigned 32 */
+                char buf[5];
+                buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
+                append_buffer(buf, 5);
+            } else {
+                /* unsigned 64 */
+                char buf[9];
+                buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
+                append_buffer(buf, 9);
+            }
+        }
+    }
+}
 
+}  // MSGPACK_API_VERSION_NAMESPACE(v1)
 
 }  // namespace msgpack
 
 #endif /* msgpack/pack.hpp */
-