Update issue templates

Merge pull request #878 from ygj6/master
remove files in master for separating C and C++ libraries
2025-09-02 04:51:50 +02:00 · 2023-02-28 21:27:23 +09:00 · 2020-06-08 09:26:18 +09:00 · 2020-06-05 17:55:42 +08:00 · 2020-06-05 17:04:41 +09:00 · 2020-06-05 16:22:34 +09:00
94 changed files with 512 additions and 15838 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -0,0 +1,19 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+msgpack-c or msgpack-cxx version.
+e.g) msgpack-cxx 5.0.0 
+
+**To Reproduce**
+Please prepare https://stackoverflow.com/help/minimal-reproducible-example
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
--- a/1
+++ b/1
@ -1 +0,0 @@
-FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,412 @@
+# 2020-06-05 version 3.3.0
+  * Add json example for C (#870)
+  * Add both header and body packing functions for C (#870)
+  * Set default ref_size and chunk_size to vrefbuffer (#865)
+  * Add examples (#861)
+  * Improve build system (#839, #842)
+  * Improve tests (#829)
+  * Improve documents (#828)
+  * Remove some warnings (#827, #851, #871)
+  * Improve CI environment (#824, #831, #833, #834, #846, #860, 874)
+
+# 2019-12-10 version 3.2.1
+  * Fix snprintf return value checking (#821)
+  * Remove some warnings (#819)
+  * Fix fbuffer result checking (#812)
+  * Fix temporary object handling (#807)
+  * Improve cmake support (#804)
+  * Fix invalid `int main` parameter (#800)
+  * Improve supporting platform (#797, #817)
+  * Fix ZLIB error handling (#795)
+  * Remove unused variable (#793)
+  * Improve integer overflow checking (#792)
+
+# 2019-05-27 version 3.2.0
+
+  * Fix invalid include (#783)
+  * Add timespec support (#781)
+  * Fix unchecked fnprintf on C (#780)
+  * Improve integer overflow checking on C (#776)
+  * Fix warnings on `-Wconversion` (#770, #777, #784)
+  * Fix invalid passed by value on aligned_zone_size_visitor (#764)
+  * Improve windows support (#757, #779)
+  * Fix msgpack::object size caluclation error (#754)
+  * Fix memory error on example code (#753)
+  * Fix redundant memory allocation on C (#747)
+  * Fix msgpack::type::tuple base class conversion (#743)
+
+# 2018-09-09 version 3.1.1
+
+  * Add force endian set functionality (#736)
+  * Fix vrefbuffer memory management problem (#733)
+  * Fix msvc specific problem (#731, #732)
+  * Update boost from 1.61.0 to 1.68.0 (#730)
+  * Fix msgpack_timestamp type mismatch bug (#726)
+
+# 2018-08-10 version 3.1.0
+
+  * Improve documents (#687, #718)
+  * Add fuzzer support (#689)
+  * Fix msgpack::object union member access bug (#694)
+  * Improve cross platform configuration (#704)
+  * Fix out of range dereference bug of EXT (#705)
+  * Add timestamp support. std::chrono::system_clock::time_point is mapped to TIMESTAMP (#706)
+  * Add minimal timestamp support for C. The type `msgpack_timestamp` and the function `msgpack_object_to_timestamp()` are introduced (#707)
+  * Improve MSGPACK_DEFINE family name confliction probability (#710)
+  * Add no static-library build option (BUILD_SHARED_LIBS=ON) (#713, #717, #722)
+  * Add header only cmake target (#721)
+  * Add `std::byte` adaptor (#719)
+  * Remove some warnings (#720)
+
+# 2018-05-12 version 3.0.1
+
+  * Add fuzz directory to release tar ball (#686)
+  * Add include file checking for X-Code (#683)
+
+# 2018-05-09 version 3.0.0
+
+## << breaking changes >>
+
+  * Change offset parameter updating rule. If parse error happens, offset is updated to the error position. (#639, #666)
+
+## << other updates >>
+
+  * Improve cross platform configuration (#655, #677)
+  * Improve build system (#647)
+  * Improve user class adaptor (#645, #673)
+  * Improve msgpack::object visitation logic (#676)
+  * Remove some warnings (#641, 659)
+  * Add `->` and `*` operators to object_handle (#635)
+  * Improve CI environment (#631, #634, #643, #657, #662, #668)
+  * Improve documents (#630, #661)
+  * Refactoring (#670)
+  * Add OSS-Fuzz support (#672, #674, #675, #678)
+
+# 2017-08-04 version 2.1.5
+  * Improve cross platform configuration (#624)
+  * Add boost asio examples (including zlib) (#610)
+  * Remove some warnings (#611)
+  * Fix unpack visitor to treat float32/64 correctly (#613)
+  * Improve documents (#616)
+  * Fix alignment problem on some platform (#617, #518)
+  * Fix conflict std::tuple, std::pair, and boost::fusion::sequence problem (#619)
+
+# 2017-08-03 version 2.1.4 (Invalid)
+  * See https://github.com/msgpack/msgpack-c/issues/623
+
+# 2017-06-15 version 2.1.3
+  * Improve build system (#603)
+  * Add C++17 adaptors `std::optional` and `std::string_view`. (#607, #608)
+  * Improve cross platform configuration (#601)
+  * Remove some warnings (#599, #602, #605)
+
+# 2017-06-07 version 2.1.2
+
+* Improve documents (#565)
+  * Fix empty map parse bug (#568)
+  * Improve build system (#569, #570, #572, #579, #591, #592)
+  * Remove some warnings (#574, #578, #586, #588)
+  * Improve cross platform configuration (#577, #582)
+  * Add cmake package config support (#580)
+  * Fix streaming unpack bug (#585)
+
+# 2017-02-04 version 2.1.1
+
+  * Fix unpacker's buffer management bug (#561)
+  * Add boost string_view adaptor (#558)
+  * Remove some warnings (#557, #559)
+  * Improve coding style (#556)
+
+# 2017-01-10 version 2.1.0
+
+## << breaking changes >>
+
+  * Fix object internal data type is float if msgpack format is float32 (#531)
+
+## << recommended changes >>
+
+  * Add `FLOAT64` type. Please use it instead of `DOUBLE` (#531)
+  * Add `FLOAT32` type. Please use it instead of `FLOAT` (#531)
+
+## << other updates >>
+
+  * Add iterator based parse/unpack function(experimental) (#553)
+  * Add `[[deprecated]]` attribute for C++14 (#552)
+  * Fix `msgpack_unpack()` return code (#548)
+  * Fix integer overflow (#547, #549, #550)
+  * Add example codes (#542)
+  * Add MSGPACK_NVP. You can use not only variable name but also any strings (#535)
+  * Fix and Improve build system (#532, #545)
+  * Fix `gcc_atomic.hpp` include path (#529, #530)
+  * Improve CI environment (#526)
+  * Improve documents (#524)
+  * Add msgpack_unpacker_next_with_size() function (#515)
+  * Fix `as()` applying condition (#511)
+  * Fix fbuffer write (#504)
+  * Add gcc bug workaround (#499)
+  * Improve object print (#497, #500, #505, #533)
+  * Remove some warnings (#495, #506, #508, #513, #528, #538, #545)
+
+# 2016-06-25 version 2.0.0
+
+## << breaking changes >>
+
+  * Removed autotools support. Use cmake instead (#476, #479)
+  * Removed pointer version of msgpack::unpack APIs. Use reference version instead (#453)
+  * Removed MSGPACK_DISABLE_LEGACY_CONVERT. msgpack::object::convert(T*) is removed by default. Use msgpack::object::convert(T&) instead (#451)
+  * Removed msgpacl::type::nil. Use nil_t or define MSGPACK_USE_LECACY_NIL (#444)
+  * Removed std::string to msgpack::object conversion (#434)
+
+## << recommended changes >>
+
+  * Replaced msgpack::unpacked with msgpack::object_handle. msgpack::unpacked is kept as a typedef of msgpack::object_handle. (#448)
+
+## << other updates >>
+
+  * Add strict size checking adaptor. Relaxed tuple conversion (#489)
+  * Fix and Improve example codes (#487)
+  * Add C++/CLI support for nullptr (#481)
+  * Update the boost libraries that are contained by msgpack-c (#475)
+  * Fix gcc_atomic.hpp location (#474)
+  * Add C-Style array support (#466, #488)
+  * Fix include file dependency (#464)
+  * Add a visitor version of unpack API (#461)
+  * Fix JSON string conversion from "nil" to "null" (#458)
+  * Fix and Improve build system (#455, #471, #473, #486, #491)
+  * Fix comments (#452)
+  * Fix unintentional msgpack::zone moving problem (#447)
+  * Fix operator>> and << for msgpack::object (#443)
+  * Fix C++03 msgpack::zone::clear() memory access violation bug (#441)
+  * Fix TARGET_OS_IPHONE checking (#436)
+  * Fix invalid front() call for empty container (#435)
+  * Fix compile error on g++6 (C++11 only) (#426, #430)
+  * Fix zone size expansion logic (#423)
+  * Fix wrong hader file dependency (#421)
+  * Fix msvc specific problem (#420)
+  * Add v2 API support (#415)
+
+# 2016-01-22 version 1.4.0
+
+## << recommended changes >>
+
+  * Define [MSGPACK_DISABLE_LEGACY_NIL](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_nil-since-140), then `msgpack::type::nil` is replaced by with `msgpack::type::nil_t` (#408, #411, #412).
+    Replace `msgpack::type::nil` with `msgpack::type::nil_t` in client codes.
+    `msgpack::type::nil` will be removed on the version 2.0.0.
+  * Define [MSGPACK_DISABLE_LEGACY_CONVERT](https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_configure#msgpack_disable_legacy_convert-since-140), then `msgpack::object::convert(T*)` is removed (#410).
+    Replace calling `msgpack::bojectconvert(T*)` with `msgpack::bojectconvert(T&)` in client codes as follows:
+
+    ```C++
+     int i;
+     obj.convert(&i); // before
+     ```
+
+    ```C++
+     int i;
+     obj.convert(i);  // after
+     ```
+
+    `msgpack::object::convert(T*)` will be removed on the version 2.0.0.
+
+Define the macros above as follows when you compile C++ codes that use msgpack-c:
+
+```
+g++ -Ipath_to_msgpack/include -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT your_code.cpp
+
+```
+
+You can compile existing codes without defining macros above but I recommend defining them and updating your codes to fix the issues #408, #411, #412, #399, and #410. It is also a good preparation for the version 2.0.0.
+
+## << other updates >>
+
+  * Improve documents (#387, #407)
+  * Remove C++ version library (#394, #402)
+  * Add Doxyfile and ChangeLog to the distribution package (#397)
+  * Add signed/unsigned char test to travis-ci (#398)
+  * Remove some warnings (#400, #401, #409)
+  * Fix endian checking. (#404)
+
+# 2015-11-21 version 1.3.0
+
+  * Change the license from the Apache License Version 2.0 to the
+    Boost Software License, Version 1.0.(#386)
+  * Remove some warnings (#365)
+  * Add std::reference_wrapper support(#373, #384)
+  * Improve tests (#375, #378, #379, #380)
+  * Fix msvc specific problem (#376, #383)
+  * Fix typos (#381)
+
+# 2015-09-04 version 1.2.0
+
+## << breaking changes >>
+
+  * Change std::vector<unsigned char> and std::array<unsigned char>
+    mapped to BIN instead of ARRAY (#243)
+  * Remove redundant copy (#285)
+
+
+## << other updates >>
+
+  * Add array_ref to map to ARRAY (#243)
+  * Add variant type and adaptor (#349)
+  * Add object::convert_if_not_nil() (#357)
+  * Fix invalid offset update (#354)
+  * Add C++11 support on MSVC2015(#339, #347)
+  * Fix and Improve build system (#346, #350, #361, #363)
+  * Import Boost.Preprocessor as a part of msgpack-c (#312)
+  * Fix OSX with libc++ specific errors (#334, #362)
+  * Add customized containers support (#330)
+  * Add std::unique_ptr and std::shared_ptr support (#329)
+  * Add missing install files (#328)
+  * Add shared/static library switching option (#316)
+  * Improve no throw description on C++11 (#313)
+  * Import Boost.Predef as a part of msgpack-c (#312)
+  * Add map based serialize support (#306)
+  * Add Boost.Fusion support (#305)
+  * Add v4 format RAW support (#304)
+  * Fix zbuffer with empty string problem (#303)
+  * Add non default constructible class support (#302, #324, #327, #331, #332, #345)
+  * Add inline keyword to function (template) (#299)
+  * Add EXT type supporting classes (#292, #308)
+  * Fix raw_ref != comparison (#290)
+  * Add object deep copy (#288)
+  * Remove some warnings (#284, #322, #323, #335)
+  * Improve compiler version checking (#283)
+  * Add return value to object::convert() (#282)
+  * Improve move semantic support in C++11 (#279, #353)
+  * Add Boost.StringRef support (#278)
+  * Improve CI environment (#276, #294, #338)
+  * Add converting to JSON (#274, #301)
+  * Fix iOS specific problem (#270)
+  * Improve doxtgen document generation (#269)
+  * Add Boost.Optional support (#268)
+  * Fix msvc specific problem (#267, #295)
+  * Add base class serialization. (#265, #277)
+  * Add and improve examples. (#264, #310, #311, #341, #342, #344)
+  * Fix wiki URL. (#263)
+
+# 2015-04-03 version 1.1.0
+
+## << breaking changes >>
+
+  * Remove msgpack_fwd.hpp
+  * Improve user types adaptation mechanism (#262)
+    Since version 1.0.0, users need to obey the correct include order.
+    However, it is very difficult to maintain the correct order in big
+    projects. version 1.1.0 removed this order. Users don't need to
+    care about include order. Migration guide from 1.0.x to 1.1.0 has
+    been written. See https://github.com/msgpack/msgpack-c/wiki
+
+
+## << other updates >>
+
+  * Fix vector<bool> size check (#251)
+  * Fix inttypes.h inclusion on MSVC (#257)
+  * Support documents generation by Doxygen (#259)
+  * Remove C99 style variable declaration (#253)
+  * Improve documents (https://github.com/msgpack/msgpack-c/wiki)
+
+# 2015-03-22 version 1.0.1:
+
+  * Fix compilation error on Mac 10.9 (#244)
+  * Fix typos in documents (#240)
+  * Update CHANGELOG.md for version 1.0.0 (#242)
+  * Fix erb templates for the next code generation (#239)
+
+# 2015-03-10 version 1.0.0:
+
+  * Support msgpack v5 format (str, bin, and ext) https://github.com/msgpack/msgpack/blob/master/spec.md (#142)
+  * Support std::tuple, std::forward_list, std::array, std::unordered_set, std::unordered_map on C++11. tr1 unordered containers are still supported (#53, #130, #137, #154, #169)
+  * Update msgpack-c as a header-only library on C++ (#142)
+  * Move include directory (#142)
+  * Update the name of float format family on msgpack::object from 'dec' to 'f64' (#194)
+  * Remove existing elements on associative containers when unpacking (#127)
+  * Add an API versioning functionality https://github.com/msgpack/msgpack-c/wiki/cpp_versioning (#139)
+  * Add C++11 enum class support (#205)
+  * Map std::vector<char> and std::array<char> to BIN (#100)
+  * Map '\0' teminated char* and char const* to STR (#206)
+  * Add the new parameter on unpacking functions and classes to limit msgpack's bytestream size (https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker#limit-size-of-elements) (#175)
+  * Add the copy or reference choosing function on unpack() and unpacker (https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker#memory-management)
+  * Add the new unpack() overloads for C++11 https://github.com/msgpack/msgpack-c/wiki/cpp_unpacker (#128)
+  * Add a msgpack::object::with_zone (deep) copying function (#133, #163)
+  * Remove the compile-time defined limit of msgpack nest level on C++ (#218)
+  * Add the new unpack() overloads that use an existing zone (#201)
+  * Add the range-based for loop support on msgpack object array and map (#203)
+  * Add msgpack revision getter function for 'revision' (#237)
+  * Support EXT for C (#118, #129)
+  * Fix unpacking buffer allocation problem when malformed data is given (#160, #185)
+  * Add dll exporting function on MSVC (#162)
+  * Fix msgpack::zone::allocate_no_align(). Now it allocates the memory that is not aligned as expected (#171)
+  * Improve documents (https://github.com/msgpack/msgpack-c/wiki)
+  * Other bug fixes and refactoring: #62, #91, #95, #97, #107, #109, #113, #117, #119, #121, #122, #123, #126, #131, #136, #138, #140, #143, #145, #146, #150, #151, #152, #156, #157, #158, #161, #165, #170, #172, #179, #180, #181, #182, #183, #192, #195, #199, #200, #207, #211, #212, #219, #222, #224, #230, #231, #232, #233, #234, #235
+
+# 2014-07-02 version 0.5.9:
+
+  * Support std::tr1 unordered containers by default (#51, #63, #68, #69)
+  * Remove some warnings (#56)
+  * Fix segmentation fault after malloc failures (#58, #59)
+  * Fix alloc/dealloc mismatch (#52, #61)
+  * Fix sample codes (#60, #64)
+  * Support implicit conversion from integer to float/double (#54)
+  * Improve documents (#45, #75, #82, #83)
+  * Support CMake (#20, #87)
+  * Remove Ruby dependencies in bootstrap (#86, #87)
+  * Add FILE* buffer (#40)
+  * Other bug fixes and refactoring: #39, #73, #77, #79, #80, #81, #84, #90
+
+# 2013-12-23 version 0.5.8:
+
+  * Move to the new github repository msgpack/msgpack-c
+  * Support the new deserialization specification
+  * fixes the problem of unpack helpers for array and map with 32bit compilers (#37, #38)
+  * Other bug fixes and refactoring: #46, #41, #36, #35, #33, #32, #30, #29, #28, #27, #26, #25, #8, #3
+  * Update of documents: #23, #18, #17
+
+# 2011-08-08 version 0.5.7:
+
+  * fixes compile error problem with llvm-gcc and Mac OS X Lion
+
+# 2011-04-24 version 0.5.6:
+
+  * #42 fixes double-free problem on msgpack_unpacker_release_zone
+
+# 2011-02-24 version 0.5.5:
+
+  * eliminates dependency of winsock2.h header
+  * fixes msgpack_vc.postbuild.bat file
+  * fixes some implicit cast warnings
+
+# 2010-08-29 version 0.5.4:
+
+  * includes msgpack_vc2008.vcproj file in source package
+  * fixes type::fix_int types
+
+# 2010-08-27 version 0.5.3:
+
+  * adds type::fix_{u,}int{8,16,32,64} types
+  * adds msgpack_pack_fix_{u,}int{8,16,32,64} functions
+  * adds packer<Stream>::pack_fix_{u,}int{8,16,32,64} functions
+  * fixes include paths
+
+# 2010-07-14 version 0.5.2:
+
+  * type::raw::str(), operator==, operator!=, operator< and operator> are now const
+  * generates version.h using AC_OUTPUT macro in ./configure
+
+# 2010-07-06 version 0.5.1:
+
+  * Add msgpack_vrefbuffer_new and msgpack_vrefbuffer_free
+  * Add msgpack_sbuffer_new and msgpack_sbuffer_free
+  * Add msgpack_unpacker_next and msgpack_unpack_next
+  * msgpack::unpack returns void
+  * Add MSGPACK_VERSION{,_MAJOR,_MINOR} macros to check header version
+  * Add msgpack_version{,_major,_minor} functions to check library version
+  * ./configure supports --disable-cxx option not to build C++ API
+
+# 2010-04-29 version 0.5.0:
+
+  * msgpack_object_type is changed. MSGPACK_OBJECT_NIL is now 0x00.
+  * New safe streaming deserializer API.
+  * Add object::object(const T&) and object::operator=(const T&)
+  * Add operator==(object, const T&)
+  * MSGPACK_DEFINE macro defines msgpack_object(object* obj, zone* z)
+  * C++ programs doesn't need to link "msgpackc" library.
--- a/17
+++ b/17
@ -1,14 +1,5 @@
-Copyright (C) 2008-2009 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.
+Copyright (C) 2008-2015 FURUHASHI Sadayuki

+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
--- a/0
+++ b/0
--- a/202
+++ b/202
@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.
--- a/LICENSE_1_0.txt
+++ b/LICENSE_1_0.txt
@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/Makefile.am
+++ b/Makefile.am
@ -1,48 +0,0 @@
-if ENABLE_CXX
-export ERB
-SUBDIRS = c cpp
-else
-SUBDIRS = c
-endif
-
-nobase_include_HEADERS = \
-		msgpack/pack_define.h \
-		msgpack/pack_template.h \
-		msgpack/unpack_define.h \
-		msgpack/unpack_template.h
-
-EXTRA_DIST = \
-	ruby/bench.rb \
-	ruby/extconf.rb \
-	ruby/gem/README \
-	ruby/gem/Rakefile \
-	ruby/gem/test/test_helper.rb \
-	ruby/gengem.sh \
-	ruby/msgpack.gemspec \
-	ruby/pack.c \
-	ruby/pack.h \
-	ruby/rbinit.c \
-	ruby/test_case.rb \
-	ruby/test_format.rb \
-	ruby/test_pack.rb \
-	ruby/unpack.c \
-	ruby/unpack.h \
-	perl/Makefile.PL \
-	perl/MessagePack.c \
-	perl/benchmark/deserialize.pl \
-	perl/benchmark/serialize.pl \
-	perl/lib/Data/MessagePack.pm \
-	perl/lib/Data/MessagePack \
-	perl/lib/Data/MessagePack/Unpacker.pod \
-	perl/pack.c \
-	perl/ppport.h \
-	perl/t/00_compile.t \
-	perl/t/01_pack.t \
-	perl/t/02_unpack.t \
-	perl/t/03_stream_unpack.t \
-	perl/t/04_invert.t \
-	perl/t/Util.pm \
-	perl/t/data.pl \
-	perl/unpack.c \
-	perl/xt/99_pod.t
-
--- a/0
+++ b/0
--- a/16
+++ b/16
@ -1,4 +1,14 @@
-MessagePack is developed by FURUHASHI Sadayuki, licensed under Apache License,
-Version 2.0. The original software and related information is available at
-http://msgpack.sourceforge.jp/.
+This product bundles Boost Predef and Boost Preprocessor.
+They are distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)

+For details, see the following files:
+
+external/boost/predef
+include/msgpack/predef.h
+include/msgpack/predef/*
+
+external/boost/preprocessor
+include/msgpack/preprocessor.hpp
+include/msgpack/preprocessor/*
--- a/72
+++ b/72
@ -1,72 +0,0 @@
-MessagePack
-----------
-Binary-based efficient data interchange format.
-
-
-*Requirements
-
-  MessagePack is only tested on Linux and Mac OS X, but it may run on other
-  UNIX-like platforms.
-
-  Following programs are required to build:
-    - gcc >= 4.1 with C++ support
-    - ruby >= 1.8   (ruby is used as a preprocessor)
-
-
-*Installation
-
-  Simply run ./configure && make && make install to install C and C++ binding.
-
-    $ ./configure
-    $ make
-    $ sudo make install
-
-  To install Ruby binding, run ./gengem.sh script on ruby/ directory and install
-  generated gem package.
-
-    $ cd ruby
-    $ ./gengem.sh
-    $ gem install gem/pkg/msgpack-*.gem
-
-
-*Usage
-
-  C++:
-    include msgpack.hpp header and link libmsgpack library.
-    see example/simple.cc for example.
-
-      g++ simple.cc -lmsgpack
-      g++ stream.cc -lmsgpack -lpthread
-
-
-  C:
-    include msgpack.h   header and link libmsgpackc library.
-    see example/simple.c  for example.
-
-      gcc simple.c  -lmsgpackc
-
-
-  Ruby:
-    require msgpack library.
-    see example/simple.rb for example.
-
-	  ruby -rubygems simple.rb
-
-
-  API Document is available at http://msgpack.sourceforge.jp/.
-
-
-Copyright (C) 2008-2009 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.
-
--- a/README.md
+++ b/README.md
@ -0,0 +1,41 @@
+`msgpack` for C/C++
+===================
+
+It's like JSON but smaller and faster.
+
+Overview
+--------
+
+[MessagePack](http://msgpack.org/) is an efficient binary serialization
+format, which lets you exchange data among multiple languages like JSON,
+except that it's faster and smaller. Small integers are encoded into a
+single byte and short strings require only one extra byte in
+addition to the strings themselves.
+
+### C Library
+
+See [c_master](https://github.com/msgpack/msgpack-c/tree/c_master)
+
+### C++ Library
+
+See [cpp_master](https://github.com/msgpack/msgpack-c/tree/cpp_master)
+
+### Documentation
+
+You can get additional information including the tutorial on the
+[wiki](https://github.com/msgpack/msgpack-c/wiki).
+
+Contributing
+------------
+
+`msgpack-c` is developed on GitHub at [msgpack/msgpack-c](https://github.com/msgpack/msgpack-c).
+To report an issue or send a pull request, use the
+[issue tracker](https://github.com/msgpack/msgpack-c/issues).
+
+Here's the list of [great contributors](https://github.com/msgpack/msgpack-c/graphs/contributors).
+
+License
+-------
+
+`msgpack-c` is licensed under the Boost Software License, Version 1.0. See
+the [`LICENSE_1_0.txt`](./LICENSE_1_0.txt) file for details.
--- a/120
+++ b/120
@ -1,120 +0,0 @@
-#!/bin/sh
-# vim:ts=4:sw=4
-# Calls autotools to build configure script and Makefile.in.
-# Generated automatically using bootstrapper 0.2.1
-# http://bootstrapper.sourceforge.net/
-#
-# Copyright (C) 2002 Anthony Ventimiglia
-#
-# This bootstrap script is free software; you can redistribute 
-# it and/or modify it under the terms of the GNU General Public 
-# License as published by the Free Software Foundation; either 
-# version 2 of the License, or (at your option) any later version.
-#
-#
-# Calls proper programs to create configure script and Makefile.in files.
-# if run with the --clean option, bootstrap removes files it generates. To
-# clean all autogenerated files (eg: for cvs imports) first run 
-# make distclean, then bootstrap --clean
-# see bootstrapper(1) for more infor
-
-
-if test x"$1" = x"--help"; then
-	echo "$0: automatic bootstrapping utility for GNU Autotools"
-	echo "		cleans up old autogenerated files and runs autoconf,"
-	echo "		automake and aclocal on local directory"
-	echo 
-	echo "		--clean		clean up auto-generated files without"
-	echo "					creating new scripts"
-	echo 
-	exit 0
-fi
-
-
-#if [ -z "$NO_NEST" ];then
-#	cd c   && ./bootstrap $@; cd ..
-#	cd cpp && ./bootstrap $@; cd ..
-#fi
-mkdir -p ac
-
-
-ACLOCAL="aclocal"
-ACLOCAL_FILES="aclocal.m4"
-ALWAYS_CLEAN="config.status config.log config.cache libtool"
-AUTOCONF="autoconf"
-AUTOCONF_FILES="configure"
-AUTOHEADER="autoheader"
-AUTOHEADER_FILES=""
-AUTOMAKE="automake --add-missing --copy"
-AUTOMAKE_FILES="config.sub stamp-h.in ltmain.sh missing mkinstalldirs install-sh config.guess"
-CONFIG_AUX_DIR="."
-CONFIG_FILES="stamp-h ltconfig"
-CONFIG_HEADER=""
-if [ x`uname` = x"Darwin" ]; then
-	LIBTOOLIZE="glibtoolize --force --copy"
-else
-	LIBTOOLIZE="libtoolize --force --copy"
-fi
-LIBTOOLIZE_FILES="config.sub ltmain.sh config.guess"
-RM="rm"
-SUBDIRS="[]"
-
-
-# These are files created by configure, so we'll always clean them
-for i in $ALWAYS_CLEAN; do
-	test -f $i && \
-	$RM $i
-done
-
-if test x"$1" = x"--clean"; then
-	#
-	#Clean Files left by previous bootstrap run
-	#
-	if test -n "$CONFIG_AUX_DIR"; 
-		then CONFIG_AUX_DIR="$CONFIG_AUX_DIR/"
-	fi
-	# Clean Libtoolize generated files
-	for cf in $LIBTOOLIZE_FILES; do
-		cf="$CONFIG_AUX_DIR$cf"
-		test -f $cf && \
-		$RM $cf
-	done
-	#aclocal.m4 created by aclocal
-	test -f $ACLOCAL_FILES && $RM $ACLOCAL_FILES
-	#Clean Autoheader Generated files
-	for cf in $AUTOHEADER_FILES; do
-		cf=$CONFIG_AUX_DIR$cf
-		test -f $cf && \
-		$RM $cf
-	done
-	# remove config header (Usaually config.h)
-	test -n "$CONFIG_HEADER" && test -f $CONFIG_HEADER && $RM $CONFIG_HEADER
-	#Clean Automake generated files
-	for cf in $AUTOMAKE_FILES; do
-		cf=$CONFIG_AUX_DIR$cf
-		test -f $cf && \
-		$RM $cf
-	done
-	for i in $SUBDIRS; do
-		test -f $i/Makefile.in && \
-		$RM $i/Makefile.in
-	done
-	#Autoconf generated files
-	for cf in $AUTOCONF_FILES; do
-		test -f $cf && \
-		$RM $cf
-	done
-	for cf in $CONFIG_FILES; do
-		cf="$CONFIG_AUX_DIR$cf"
-		test -f $cf && \
-		$RM $cf
-	done
-else
-	$LIBTOOLIZE
-	$ACLOCAL
-	$AUTOHEADER
-	$AUTOMAKE
-	$AUTOCONF
-fi
-
-
--- a/c/Makefile.am
+++ b/c/Makefile.am
@ -1,20 +0,0 @@
-lib_LTLIBRARIES = libmsgpackc.la
-
-libmsgpackc_la_SOURCES = \
-		unpack.c \
-		object.c \
-		vrefbuffer.c \
-		zone.c
-
-nobase_include_HEADERS = \
-		msgpack.h \
-		msgpack/sbuffer.h \
-		msgpack/vrefbuffer.h \
-		msgpack/pack.h \
-		msgpack/unpack.h \
-		msgpack/object.h \
-		msgpack/zone.h
-
-# -version-info CURRENT:REVISION:AGE
-libmsgpackc_la_LDFLAGS = -version-info 1:0:0
-
--- a/c/bench.c
+++ b/c/bench.c
@ -1,323 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/time.h>
-
-#include <msgpack/pack.h>
-#include <msgpack/unpack.h>
-#include <yajl/yajl_parse.h>
-#include <yajl/yajl_gen.h>
-
-
-static struct timeval g_timer;
-
-void reset_timer()
-{
-	gettimeofday(&g_timer, NULL);
-}
-
-void show_timer(size_t bufsz)
-{
-	struct timeval endtime;
-	gettimeofday(&endtime, NULL);
-	double sec = (endtime.tv_sec - g_timer.tv_sec)
-		+ (double)(endtime.tv_usec - g_timer.tv_usec) / 1000 / 1000;
-	printf("%f sec\n", sec);
-	printf("%f MB\n", ((double)bufsz)/1024/1024);
-	printf("%f Mbps\n", ((double)bufsz)*8/sec/1000/1000);
-}
-
-
-static int reformat_null(void * ctx) { return 1; }
-static int reformat_boolean(void * ctx, int boolean) { return 1; }
-static int reformat_number(void * ctx, const char * s, unsigned int l) { return 1; }
-static int reformat_string(void * ctx, const unsigned char * stringVal, unsigned int stringLen) { return 1; }
-static int reformat_map_key(void * ctx, const unsigned char * stringVal, unsigned int stringLen) { return 1; }
-static int reformat_start_map(void * ctx) { return 1; }
-static int reformat_end_map(void * ctx) { return 1; }
-static int reformat_start_array(void * ctx) { return 1; }
-static int reformat_end_array(void * ctx) { return 1; }
-
-
-static void* unpack_uint8(void* data, uint8_t d) { return NULL; }
-static void* unpack_uint16(void* data, uint16_t d) { return NULL; }
-static void* unpack_uint32(void* data, uint32_t d) { return NULL; }
-static void* unpack_uint64(void* data, uint64_t d) { return NULL; }
-static void* unpack_int8(void* data, int8_t d) { return NULL; }
-static void* unpack_int16(void* data, int16_t d) { return NULL; }
-static void* unpack_int32(void* data, int32_t d) { return NULL; }
-static void* unpack_int64(void* data, int64_t d) { return NULL; }
-static void* unpack_float(void* data, float d) { return NULL; }
-static void* unpack_double(void* data, double d) { return NULL; }
-static void* unpack_nil(void* data) { return NULL; }
-static void* unpack_true(void* data) { return NULL; }
-static void* unpack_false(void* data) { return NULL; }
-static void* unpack_array(void* data, unsigned int n) { return NULL; }
-static void unpack_array_item(void* data, void* c, void* o) { }
-static void* unpack_map(void* data, unsigned int n) { return NULL; }
-static void unpack_map_item(void* data, void* c, void* k, void* v) { }
-static void* unpack_raw(void* data, const char* b, const char* p, unsigned int l) { /*printf("unpack raw %p %lu\n",p,l);*/ return NULL; }
-
-
-typedef struct {
-	size_t allocated;
-	size_t length;
-	char* buffer;
-} pack_buffer;
-
-static const size_t PACK_INITIAL_BUFFER_SIZE = 32*1024;
-
-static void pack_buffer_init(pack_buffer* data)
-{
-	data->buffer = malloc(PACK_INITIAL_BUFFER_SIZE);
-	data->length = 0;
-	data->allocated = PACK_INITIAL_BUFFER_SIZE;
-}
-
-static void pack_buffer_reset(pack_buffer* data)
-{
-	data->buffer = realloc(data->buffer, PACK_INITIAL_BUFFER_SIZE);
-	data->allocated = PACK_INITIAL_BUFFER_SIZE;
-	data->length = 0;
-}
-
-static void pack_buffer_free(pack_buffer* data)
-{
-	free(data->buffer);
-}
-
-static void pack_append_buffer(void* user, const char* b, unsigned int l)
-{
-	pack_buffer* data = (pack_buffer*)user;
-	if(data->allocated - data->length < l) {
-		data->buffer = realloc(data->buffer, data->allocated*2);
-		data->allocated *= 2;
-	}
-	memcpy(data->buffer + data->length, b, l);
-	data->length += l;
-}
-
-
-static const unsigned int TASK_INT_NUM = 1<<24;
-static const unsigned int TASK_STR_LEN = 1<<15;
-//static const unsigned int TASK_INT_NUM = 1<<20;
-//static const unsigned int TASK_STR_LEN = 1<<12;
-static const char* TASK_STR_PTR;
-
-
-void bench_json(void)
-{
-	puts("== JSON ==");
-
-
-	yajl_gen_config gcfg = {0, NULL};
-	yajl_gen g = yajl_gen_alloc(&gcfg);
-
-	yajl_parser_config hcfg = { 0, 0 };
-	yajl_callbacks callbacks = {
-	    reformat_null,
-	    reformat_boolean,
-	    NULL,
-	    NULL,
-	    reformat_number,
-		reformat_string,
-	    reformat_start_map,
-	    reformat_map_key,
-	    reformat_end_map,
-	    reformat_start_array,
-	    reformat_end_array
-	};
-	yajl_handle h = yajl_alloc(&callbacks, &hcfg, NULL);
-
-
-	const unsigned char * buf;
-	unsigned int len;
-
-
-	puts("generate integer");
-	reset_timer();
-	{
-		unsigned int i;
-		yajl_gen_array_open(g);
-		for(i=0; i < TASK_INT_NUM; ++i) {
-			yajl_gen_integer(g, i);
-		}
-		yajl_gen_array_close(g);
-	}
-	show_timer(len);
-
-	yajl_gen_get_buf(g, &buf, &len);
-
-	puts("----");
-	puts("parse integer");
-	reset_timer();
-	{
-		yajl_status stat = yajl_parse(h, buf, len);
-		if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
-			unsigned char * str = yajl_get_error(h, 1, buf, len);
-			fprintf(stderr, (const char *) str);
-		}
-	}
-	show_timer(len);
-
-
-	//yajl_gen_clear(g);
-	yajl_gen_free(g);
-	g = yajl_gen_alloc(&gcfg);
-	yajl_free(h);
-	h = yajl_alloc(&callbacks, &hcfg, NULL);
-
-
-	puts("----");
-	puts("generate string");
-	reset_timer();
-	{
-		unsigned int i;
-		yajl_gen_array_open(g);
-		for(i=0; i < TASK_STR_LEN; ++i) {
-			yajl_gen_string(g, (const unsigned char*)TASK_STR_PTR, i);
-		}
-		yajl_gen_array_close(g);
-	}
-	show_timer(len);
-
-	yajl_gen_get_buf(g, &buf, &len);
-
-	puts("----");
-	puts("parse string");
-	reset_timer();
-	{
-		yajl_status stat = yajl_parse(h, buf, len);
-		if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
-			unsigned char * str = yajl_get_error(h, 1, buf, len);
-			fprintf(stderr, (const char *) str);
-		}
-	}
-	show_timer(len);
-
-
-	yajl_gen_free(g);
-	yajl_free(h);
-}
-
-
-void bench_msgpack(void)
-{
-	puts("== MessagePack ==");
-
-
-	pack_buffer mpkbuf;
-	pack_buffer_init(&mpkbuf);
-
-	msgpack_pack_t* mpk = msgpack_pack_new(
-			&mpkbuf, pack_append_buffer);
-
-	msgpack_unpack_callback cb = {
-		unpack_uint8,
-		unpack_uint16,
-		unpack_uint32,
-		unpack_uint64,
-		unpack_int8,
-		unpack_int16,
-		unpack_int32,
-		unpack_int64,
-		unpack_float,
-		unpack_double,
-		unpack_nil,
-		unpack_true,
-		unpack_false,
-		unpack_array,
-		unpack_array_item,
-		unpack_map,
-		unpack_map_item,
-		unpack_raw,
-	};
-	msgpack_unpack_t* mupk = msgpack_unpack_new(NULL, &cb);
-
-
-	size_t len;
-	const char* buf;
-
-
-	puts("pack integer");
-	reset_timer();
-	{
-		unsigned int i;
-		msgpack_pack_array(mpk, TASK_INT_NUM);
-		for(i=0; i < TASK_INT_NUM; ++i) {
-			msgpack_pack_unsigned_int(mpk, i);
-		}
-	}
-	show_timer(mpkbuf.length);
-
-	len = mpkbuf.length;
-	buf = mpkbuf.buffer;
-
-	puts("----");
-	puts("unpack integer");
-	reset_timer();
-	{
-		size_t off = 0;
-		int ret = msgpack_unpack_execute(mupk, buf, len, &off);
-		if(ret < 0) {
-			fprintf(stderr, "Parse error.\n");
-		} else if(ret == 0) {
-			fprintf(stderr, "Not finished.\n");
-		}
-	}
-	show_timer(mpkbuf.length);
-
-
-	pack_buffer_reset(&mpkbuf);
-	msgpack_unpack_reset(mupk);
-
-
-	puts("----");
-	puts("pack string");
-	reset_timer();
-	{
-		unsigned int i;
-		msgpack_pack_array(mpk, TASK_STR_LEN);
-		for(i=0; i < TASK_STR_LEN; ++i) {
-			msgpack_pack_raw(mpk, i);
-			msgpack_pack_raw_body(mpk, TASK_STR_PTR, i);
-		}
-	}
-	show_timer(mpkbuf.length);
-
-	len = mpkbuf.length;
-	buf = mpkbuf.buffer;
-
-	puts("----");
-	puts("unpack string");
-	reset_timer();
-	{
-		size_t off = 0;
-		int ret = msgpack_unpack_execute(mupk, buf, len, &off);
-		if(ret < 0) {
-			fprintf(stderr, "Parse error.\n");
-		} else if(ret == 0) {
-			fprintf(stderr, "Not finished.\n");
-		}
-	}
-	show_timer(mpkbuf.length);
-
-
-	msgpack_unpack_free(mupk);
-	msgpack_pack_free(mpk);
-	pack_buffer_free(&mpkbuf);
-}
-
-int main(int argc, char* argv[])
-{
-	char* str = malloc(TASK_STR_LEN);
-	memset(str, 'a', TASK_STR_LEN);
-	TASK_STR_PTR = str;
-
-	bench_msgpack();
-	bench_json();
-
-	return 0;
-}
-
-
--- a/c/bench.mk
+++ b/c/bench.mk
@ -1,9 +0,0 @@
-
-CFLAGS  += -Wall -g -I. -I.. -O4
-LDFLAGS += -lyajl
-
-all: bench
-
-bench: bench.o pack.o unpack.o pack.h unpack.h
-	$(CC) bench.o pack.o unpack.o $(CFLAGS) $(LDFLAGS) -o $@
-
--- a/c/msgpack
+++ b/c/msgpack
@ -1 +0,0 @@
-.
--- a/c/msgpack.h
+++ b/c/msgpack.h
@ -1,23 +0,0 @@
-/*
- * MessagePack for C
- *
- * Copyright (C) 2008-2009 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 "msgpack/object.h"
-#include "msgpack/zone.h"
-#include "msgpack/pack.h"
-#include "msgpack/unpack.h"
-#include "msgpack/sbuffer.h"
-#include "msgpack/vrefbuffer.h"
--- a/c/object.c
+++ b/c/object.c
@ -1,161 +0,0 @@
-/*
- * MessagePack for C dynamic typing routine
- *
- * Copyright (C) 2008-2009 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 "msgpack/object.h"
-#include "msgpack/pack.h"
-#include <stdio.h>
-#include <inttypes.h>
-
-
-int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
-{
-	switch(d.type) {
-	case MSGPACK_OBJECT_NIL:
-		return msgpack_pack_nil(pk);
-
-	case MSGPACK_OBJECT_BOOLEAN:
-		if(d.via.boolean) {
-			return msgpack_pack_true(pk);
-		} else {
-			return msgpack_pack_false(pk);
-		}
-
-	case MSGPACK_OBJECT_POSITIVE_INTEGER:
-		return msgpack_pack_uint64(pk, d.via.u64);
-
-	case MSGPACK_OBJECT_NEGATIVE_INTEGER:
-		return msgpack_pack_int64(pk, d.via.i64);
-
-	case MSGPACK_OBJECT_DOUBLE:
-		return msgpack_pack_double(pk, d.via.dec);
-
-	case MSGPACK_OBJECT_RAW:
-		{
-			int ret = msgpack_pack_raw(pk, d.via.raw.size);
-			if(ret < 0) { return ret; }
-			return msgpack_pack_raw_body(pk, d.via.raw.ptr, d.via.raw.size);
-		}
-
-	case MSGPACK_OBJECT_ARRAY:
-		{
-			int ret = msgpack_pack_array(pk, d.via.array.size);
-			if(ret < 0) { return ret; }
-
-			msgpack_object* o = d.via.array.ptr;
-			msgpack_object* const oend = d.via.array.ptr + d.via.array.size;
-			for(; o != oend; ++o) {
-				ret = msgpack_pack_object(pk, *o);
-				if(ret < 0) { return ret; }
-			}
-
-			return 0;
-		}
-
-	case MSGPACK_OBJECT_MAP:
-		{
-			int ret = msgpack_pack_map(pk, d.via.map.size);
-			if(ret < 0) { return ret; }
-
-			msgpack_object_kv* kv = d.via.map.ptr;
-			msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size;
-			for(; kv != kvend; ++kv) {
-				ret = msgpack_pack_object(pk, kv->key);
-				if(ret < 0) { return ret; }
-				ret = msgpack_pack_object(pk, kv->val);
-				if(ret < 0) { return ret; }
-			}
-
-			return 0;
-		}
-
-	default:
-		return -1;
-	}
-}
-
-
-void msgpack_object_print(FILE* out, msgpack_object o)
-{
-	switch(o.type) {
-	case MSGPACK_OBJECT_NIL:
-		fprintf(out, "nil");
-		break;
-
-	case MSGPACK_OBJECT_BOOLEAN:
-		fprintf(out, (o.via.boolean ? "true" : "false"));
-		break;
-
-	case MSGPACK_OBJECT_POSITIVE_INTEGER:
-		fprintf(out, "%"PRIu64, o.via.u64);
-		break;
-
-	case MSGPACK_OBJECT_NEGATIVE_INTEGER:
-		fprintf(out, "%"PRIi64, o.via.i64);
-		break;
-
-	case MSGPACK_OBJECT_DOUBLE:
-		fprintf(out, "%f", o.via.dec);
-		break;
-
-	case MSGPACK_OBJECT_RAW:
-		fprintf(out, "\"");
-		fwrite(o.via.raw.ptr, o.via.raw.size, 1, out);
-		fprintf(out, "\"");
-		break;
-
-	case MSGPACK_OBJECT_ARRAY:
-		fprintf(out, "[");
-		if(o.via.array.size != 0) {
-			msgpack_object* p = o.via.array.ptr;
-			msgpack_object_print(out, *p);
-			++p;
-			msgpack_object* const pend = o.via.array.ptr + o.via.array.size;
-			for(; p < pend; ++p) {
-				fprintf(out, ", ");
-				msgpack_object_print(out, *p);
-			}
-		}
-		fprintf(out, "]");
-		break;
-		// FIXME loop optimiziation
-
-	case MSGPACK_OBJECT_MAP:
-		fprintf(out, "{");
-		if(o.via.map.size != 0) {
-			msgpack_object_kv* p = o.via.map.ptr;
-			msgpack_object_print(out, p->key);
-			fprintf(out, "=>");
-			msgpack_object_print(out, p->val);
-			++p;
-			msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size;
-			for(; p < pend; ++p) {
-				fprintf(out, ", ");
-				msgpack_object_print(out, p->key);
-				fprintf(out, "=>");
-				msgpack_object_print(out, p->val);
-			}
-		}
-		fprintf(out, "}");
-		break;
-		// FIXME loop optimiziation
-
-	default:
-		// FIXME
-		fprintf(out, "#<UNKNOWN %hu %"PRIu64">", o.type, o.via.u64);
-	}
-}
-
--- a/c/object.h
+++ b/c/object.h
@ -1,91 +0,0 @@
-/*
- * MessagePack for C dynamic typing routine
- *
- * Copyright (C) 2008-2009 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_OBJECT_H__
-#define MSGPACK_OBJECT_H__
-
-#include "msgpack/zone.h"
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef enum {
-	MSGPACK_OBJECT_NIL					= 0x01,
-	MSGPACK_OBJECT_BOOLEAN				= 0x02,
-	MSGPACK_OBJECT_POSITIVE_INTEGER		= 0x03,
-	MSGPACK_OBJECT_NEGATIVE_INTEGER		= 0x04,
-	MSGPACK_OBJECT_DOUBLE				= 0x05,
-	MSGPACK_OBJECT_RAW					= 0x06,
-	MSGPACK_OBJECT_ARRAY				= 0x07,
-	MSGPACK_OBJECT_MAP					= 0x08,
-} msgpack_object_type;
-
-
-struct msgpack_object;
-struct msgpack_object_kv;
-
-typedef struct {
-	uint32_t size;
-	struct msgpack_object* ptr;
-} msgpack_object_array;
-
-typedef struct {
-	uint32_t size;
-	struct msgpack_object_kv* ptr;
-} msgpack_object_map;
-
-typedef struct {
-	uint32_t size;
-	const char* ptr;
-} msgpack_object_raw;
-
-typedef union {
-	bool boolean;
-	uint64_t u64;
-	int64_t  i64;
-	double   dec;
-	msgpack_object_array array;
-	msgpack_object_map map;
-	msgpack_object_raw raw;
-} msgpack_object_union;
-
-typedef struct msgpack_object {
-	msgpack_object_type type;
-	msgpack_object_union via;
-} msgpack_object;
-
-typedef struct msgpack_object_kv {
-	msgpack_object key;
-	msgpack_object val;
-} msgpack_object_kv;
-
-
-void msgpack_object_print(FILE* out, msgpack_object o);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/object.h */
-
--- a/c/pack.h
+++ b/c/pack.h
@ -1,118 +0,0 @@
-/*
- * MessagePack for C packing routine
- *
- * Copyright (C) 2008-2009 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_PACK_H__
-#define MSGPACK_PACK_H__
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include "msgpack/pack_define.h"
-#include "msgpack/object.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef int (*msgpack_packer_write)(void* data, const char* buf, unsigned int len);
-
-typedef struct msgpack_packer {
-	void* data;
-	msgpack_packer_write callback;
-} msgpack_packer;
-
-static void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback);
-
-static msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback);
-static void msgpack_packer_free(msgpack_packer* pk);
-
-static int msgpack_pack_short(msgpack_packer* pk, short d);
-static int msgpack_pack_int(msgpack_packer* pk, int d);
-static int msgpack_pack_long(msgpack_packer* pk, long d);
-static int msgpack_pack_long_long(msgpack_packer* pk, long long d);
-static int msgpack_pack_unsigned_short(msgpack_packer* pk, unsigned short d);
-static int msgpack_pack_unsigned_int(msgpack_packer* pk, unsigned int d);
-static int msgpack_pack_unsigned_long(msgpack_packer* pk, unsigned long d);
-static int msgpack_pack_unsigned_long_long(msgpack_packer* pk, unsigned long long d);
-
-static int msgpack_pack_uint8(msgpack_packer* pk, uint8_t d);
-static int msgpack_pack_uint16(msgpack_packer* pk, uint16_t d);
-static int msgpack_pack_uint32(msgpack_packer* pk, uint32_t d);
-static int msgpack_pack_uint64(msgpack_packer* pk, uint64_t d);
-static int msgpack_pack_int8(msgpack_packer* pk, int8_t d);
-static int msgpack_pack_int16(msgpack_packer* pk, int16_t d);
-static int msgpack_pack_int32(msgpack_packer* pk, int32_t d);
-static int msgpack_pack_int64(msgpack_packer* pk, int64_t d);
-
-static int msgpack_pack_float(msgpack_packer* pk, float d);
-static int msgpack_pack_double(msgpack_packer* pk, double d);
-
-static int msgpack_pack_nil(msgpack_packer* pk);
-static int msgpack_pack_true(msgpack_packer* pk);
-static int msgpack_pack_false(msgpack_packer* pk);
-
-static int msgpack_pack_array(msgpack_packer* pk, unsigned int n);
-
-static int msgpack_pack_map(msgpack_packer* pk, unsigned int 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);
-
-int msgpack_pack_object(msgpack_packer* pk, msgpack_object d);
-
-
-
-#define msgpack_pack_inline_func(name) \
-	inline int msgpack_pack ## name
-
-#define msgpack_pack_inline_func_cint(name) \
-	inline int msgpack_pack ## name
-
-#define msgpack_pack_user msgpack_packer*
-
-#define msgpack_pack_append_buffer(user, buf, len) \
-	return (*(user)->callback)((user)->data, (const char*)buf, len)
-
-#include "msgpack/pack_template.h"
-
-inline void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write 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;
-}
-
-inline void msgpack_packer_free(msgpack_packer* pk)
-{
-	free(pk);
-}
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/pack.h */
-
--- a/c/sbuffer.h
+++ b/c/sbuffer.h
@ -1,85 +0,0 @@
-/*
- * MessagePack for C simple buffer implementation
- *
- * Copyright (C) 2008-2009 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_SBUFFER_H__
-#define MSGPACK_SBUFFER_H__
-
-#include <stdlib.h>
-#include <string.h>
-
-#ifndef MSGPACK_SBUFFER_INIT_SIZE
-#define MSGPACK_SBUFFER_INIT_SIZE 2048
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct msgpack_sbuffer {
-	size_t size;
-	char* data;
-	size_t alloc;
-} msgpack_sbuffer;
-
-static inline void msgpack_sbuffer_init(msgpack_sbuffer* sbuf)
-{
-	memset(sbuf, 0, sizeof(msgpack_sbuffer));
-}
-
-static inline void msgpack_sbuffer_destroy(msgpack_sbuffer* sbuf)
-{
-	free(sbuf->data);
-}
-
-static inline int msgpack_sbuffer_write(void* data, const char* buf, unsigned int len)
-{
-	msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data;
-
-	if(sbuf->alloc - sbuf->size < len) {
-		size_t nsize = (sbuf->alloc) ?
-				sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
-
-		while(nsize < sbuf->size + len) { nsize *= 2; }
-
-		void* tmp = realloc(sbuf->data, nsize);
-		if(!tmp) { return -1; }
-
-		sbuf->data = (char*)tmp;
-		sbuf->alloc = nsize;
-	}
-
-	memcpy(sbuf->data + sbuf->size, buf, len);
-	sbuf->size += len;
-	return 0;
-}
-
-static inline char* msgpack_sbuffer_release(msgpack_sbuffer* sbuf)
-{
-	char* tmp = sbuf->data;
-	sbuf->size = 0;
-	sbuf->data = NULL;
-	sbuf->alloc = 0;
-	return tmp;
-}
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/sbuffer.h */
-
--- a/c/unpack.c
+++ b/c/unpack.c
@ -1,399 +0,0 @@
-/*
- * MessagePack for C unpacking routine
- *
- * Copyright (C) 2008-2009 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 "msgpack/unpack.h"
-#include "msgpack/unpack_define.h"
-#include <stdlib.h>
-
-
-typedef struct {
-	msgpack_zone* z;
-	bool referenced;
-} unpack_user;
-
-
-#define msgpack_unpack_struct(name) \
-	struct template ## name
-
-#define msgpack_unpack_func(ret, name) \
-	ret template ## name
-
-#define msgpack_unpack_callback(name) \
-	template_callback ## name
-
-#define msgpack_unpack_object msgpack_object
-
-#define msgpack_unpack_user unpack_user
-
-
-struct template_context;
-typedef struct template_context template_context;
-
-static void template_init(template_context* ctx);
-
-static msgpack_object template_data(template_context* ctx);
-
-static int template_execute(template_context* ctx,
-		const char* data, size_t len, size_t* off);
-
-
-static inline msgpack_object template_callback_root(unpack_user* u)
-{ msgpack_object o; return o; }
-
-static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
-
-static inline int template_callback_uint16(unpack_user* u, uint16_t d, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
-
-static inline int template_callback_uint32(unpack_user* u, uint32_t d, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
-
-static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
-
-static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack_object* o)
-{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
-		else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } }
-
-static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack_object* o)
-{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
-		else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } }
-
-static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack_object* o)
-{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
-		else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } }
-
-static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_object* o)
-{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; }
-		else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } }
-
-static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_DOUBLE; o->via.dec = d; return 0; }
-
-static inline int template_callback_double(unpack_user* u, double d, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_DOUBLE; o->via.dec = d; return 0; }
-
-static inline int template_callback_nil(unpack_user* u, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_NIL; return 0; }
-
-static inline int template_callback_true(unpack_user* u, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_BOOLEAN; o->via.boolean = true; return 0; }
-
-static inline int template_callback_false(unpack_user* u, msgpack_object* o)
-{ o->type = MSGPACK_OBJECT_BOOLEAN; o->via.boolean = false; return 0; }
-
-static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o)
-{
-	o->type = MSGPACK_OBJECT_ARRAY;
-	o->via.array.size = 0;
-	o->via.array.ptr = msgpack_zone_malloc(u->z, n*sizeof(msgpack_object));
-	if(o->via.array.ptr == NULL) { return -1; }
-	return 0;
-}
-
-static inline int template_callback_array_item(unpack_user* u, msgpack_object* c, msgpack_object o)
-{ c->via.array.ptr[c->via.array.size++] = o; return 0; }
-
-static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o)
-{
-	o->type = MSGPACK_OBJECT_MAP;
-	o->via.map.size = 0;
-	o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv));
-	if(o->via.map.ptr == NULL) { return -1; }
-	return 0;
-}
-
-static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, msgpack_object k, msgpack_object v)
-{
-	c->via.map.ptr[c->via.map.size].key = k;
-	c->via.map.ptr[c->via.map.size].val = v;
-	++c->via.map.size;
-	return 0;
-}
-
-static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
-{
-	o->type = MSGPACK_OBJECT_RAW;
-	o->via.raw.ptr = p;
-	o->via.raw.size = l;
-	u->referenced = true;
-	return 0;
-}
-
-#include "msgpack/unpack_template.h"
-
-
-#define CTX_CAST(m) ((template_context*)(m))
-#define CTX_REFERENCED(mpac) CTX_CAST((mpac)->ctx)->user.referenced
-
-
-static const size_t COUNTER_SIZE = sizeof(unsigned int);
-
-static inline void init_count(void* buffer)
-{
-	*(volatile unsigned int*)buffer = 1;
-}
-
-static inline void decl_count(void* buffer)
-{
-	//if(--*(unsigned int*)buffer == 0) {
-	if(__sync_sub_and_fetch((unsigned int*)buffer, 1) == 0) {
-		free(buffer);
-	}
-}
-
-static inline void incr_count(void* buffer)
-{
-	//++*(unsigned int*)buffer;
-	__sync_add_and_fetch((unsigned int*)buffer, 1);
-}
-
-static inline unsigned int get_count(void* buffer)
-{
-	return *(volatile unsigned int*)buffer;
-}
-
-
-
-bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
-{
-	if(initial_buffer_size < COUNTER_SIZE) {
-		initial_buffer_size = COUNTER_SIZE;
-	}
-
-	char* buffer = (char*)malloc(initial_buffer_size);
-	if(buffer == NULL) {
-		return false;
-	}
-
-	void* ctx = malloc(sizeof(template_context));
-	if(ctx == NULL) {
-		free(buffer);
-		return false;
-	}
-
-	msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-	if(z == NULL) {
-		free(ctx);
-		free(buffer);
-		return false;
-	}
-
-	mpac->buffer = buffer;
-	mpac->used = COUNTER_SIZE;
-	mpac->free = initial_buffer_size - mpac->used;
-	mpac->off = COUNTER_SIZE;
-	mpac->parsed = 0;
-	mpac->initial_buffer_size = initial_buffer_size;
-	mpac->z = z;
-	mpac->ctx = ctx;
-
-	init_count(mpac->buffer);
-
-	template_init(CTX_CAST(mpac->ctx));
-	CTX_CAST(mpac->ctx)->user.z = mpac->z;
-	CTX_CAST(mpac->ctx)->user.referenced = false;
-
-	return true;
-}
-
-void msgpack_unpacker_destroy(msgpack_unpacker* mpac)
-{
-	msgpack_zone_free(mpac->z);
-	free(mpac->ctx);
-	decl_count(mpac->buffer);
-}
-
-
-msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size)
-{
-	msgpack_unpacker* mpac = (msgpack_unpacker*)malloc(sizeof(msgpack_unpacker));
-	if(mpac == NULL) {
-		return NULL;
-	}
-
-	if(!msgpack_unpacker_init(mpac, initial_buffer_size)) {
-		free(mpac);
-		return NULL;
-	}
-
-	return mpac;
-}
-
-void msgpack_unpacker_free(msgpack_unpacker* mpac)
-{
-	msgpack_unpacker_destroy(mpac);
-	free(mpac);
-}
-
-bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size)
-{
-	if(mpac->used == mpac->off && get_count(mpac->buffer) == 1
-			&& !CTX_REFERENCED(mpac)) {
-		// rewind buffer
-		mpac->free += mpac->used - COUNTER_SIZE;
-		mpac->used = COUNTER_SIZE;
-		mpac->off = COUNTER_SIZE;
-
-		if(mpac->free >= size) {
-			return true;
-		}
-	}
-
-	if(mpac->off == COUNTER_SIZE) {
-		size_t next_size = (mpac->used + mpac->free) * 2;  // include COUNTER_SIZE
-		while(next_size < size + mpac->used) {
-			next_size *= 2;
-		}
-
-		char* tmp = (char*)realloc(mpac->buffer, next_size);
-		if(tmp == NULL) {
-			return false;
-		}
-
-		mpac->buffer = tmp;
-		mpac->free = next_size - mpac->used;
-
-	} else {
-		size_t next_size = mpac->initial_buffer_size;  // include COUNTER_SIZE
-		size_t not_parsed = mpac->used - mpac->off;
-		while(next_size < size + not_parsed + COUNTER_SIZE) {
-			next_size *= 2;
-		}
-
-		char* tmp = (char*)malloc(next_size);
-		if(tmp == NULL) {
-			return false;
-		}
-
-		init_count(tmp);
-
-		memcpy(tmp+COUNTER_SIZE, mpac->buffer+mpac->off, not_parsed);
-
-		if(CTX_REFERENCED(mpac)) {
-			if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) {
-				free(tmp);
-				return false;
-			}
-			CTX_REFERENCED(mpac) = false;
-		} else {
-			decl_count(mpac->buffer);
-		}
-
-		mpac->buffer = tmp;
-		mpac->used = not_parsed + COUNTER_SIZE;
-		mpac->free = next_size - mpac->used;
-		mpac->off = COUNTER_SIZE;
-	}
-
-	return true;
-}
-
-int msgpack_unpacker_execute(msgpack_unpacker* mpac)
-{
-	size_t off = mpac->off;
-	int ret = template_execute(CTX_CAST(mpac->ctx),
-			mpac->buffer, mpac->used, &mpac->off);
-	if(mpac->off > off) {
-		mpac->parsed += mpac->off - off;
-	}
-	return ret;
-}
-
-msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac)
-{
-	return template_data(CTX_CAST(mpac->ctx));
-}
-
-msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac)
-{
-	if(!msgpack_unpacker_flush_zone(mpac)) {
-		return false;
-	}
-
-	msgpack_zone* r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-	if(r == NULL) {
-		return NULL;
-	}
-
-	msgpack_zone* old = mpac->z;
-	mpac->z = r;
-
-	return old;
-}
-
-void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac)
-{
-	msgpack_zone_clear(mpac->z);
-}
-
-bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac)
-{
-	if(CTX_REFERENCED(mpac)) {
-		if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) {
-			return false;
-		}
-		CTX_REFERENCED(mpac) = false;
-
-		incr_count(mpac->buffer);
-	}
-
-	return true;
-}
-
-void msgpack_unpacker_reset(msgpack_unpacker* mpac)
-{
-	template_init(CTX_CAST(mpac->ctx));
-	// don't reset referenced flag
-	mpac->parsed = 0;
-}
-
-
-msgpack_unpack_return
-msgpack_unpack(const char* data, size_t len, size_t* off,
-		msgpack_zone* z, msgpack_object* result)
-{
-	template_context ctx;
-	template_init(&ctx);
-
-	ctx.user.z = z;
-	ctx.user.referenced = false;
-
-	size_t noff = 0;
-	if(off != NULL) { noff = *off; }
-
-	int ret = template_execute(&ctx, data, len, &noff);
-	if(ret < 0) {
-		return MSGPACK_UNPACK_PARSE_ERROR;
-	}
-
-	if(off != NULL) { *off = noff; }
-
-	if(ret == 0) {
-		return MSGPACK_UNPACK_CONTINUE;
-	}
-
-	*result = template_data(&ctx);
-
-	if(noff < len) {
-		return MSGPACK_UNPACK_EXTRA_BYTES;
-	}
-
-	return MSGPACK_UNPACK_SUCCESS;
-}
-
--- a/c/unpack.h
+++ b/c/unpack.h
@ -1,125 +0,0 @@
-/*
- * MessagePack for C unpacking routine
- *
- * Copyright (C) 2008-2009 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_unpacker_H__
-#define msgpack_unpacker_H__
-
-#include "msgpack/zone.h"
-#include "msgpack/object.h"
-#include <stdint.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef struct msgpack_unpacker {
-	char* buffer;
-	size_t used;
-	size_t free;
-	size_t off;
-	size_t parsed;
-	msgpack_zone* z;
-	size_t initial_buffer_size;
-	void* ctx;
-} msgpack_unpacker;
-
-
-bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size);
-void msgpack_unpacker_destroy(msgpack_unpacker* mpac);
-
-msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size);
-void msgpack_unpacker_free(msgpack_unpacker* mpac);
-
-static inline bool   msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size);
-static inline char*  msgpack_unpacker_buffer(msgpack_unpacker* mpac);
-static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac);
-static inline void   msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size);
-
-
-int msgpack_unpacker_execute(msgpack_unpacker* mpac);
-
-msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac);
-
-msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac);
-
-void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac);
-
-void msgpack_unpacker_reset(msgpack_unpacker* mpac);
-
-static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac);
-
-
-
-typedef enum {
-	MSGPACK_UNPACK_SUCCESS				=  2,
-	MSGPACK_UNPACK_EXTRA_BYTES			=  1,
-	MSGPACK_UNPACK_CONTINUE				=  0,
-	MSGPACK_UNPACK_PARSE_ERROR			= -1,
-} msgpack_unpack_return;
-
-msgpack_unpack_return
-msgpack_unpack(const char* data, size_t len, size_t* off,
-		msgpack_zone* z, msgpack_object* result);
-
-
-static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac);
-
-bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac);
-
-bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size);
-
-bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size)
-{
-	if(mpac->free >= size) { return true; }
-	return msgpack_unpacker_expand_buffer(mpac, size);
-}
-
-char* msgpack_unpacker_buffer(msgpack_unpacker* mpac)
-{
-	return mpac->buffer + mpac->used;
-}
-
-size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac)
-{
-	return mpac->free;
-}
-
-void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size)
-{
-	mpac->used += size;
-	mpac->free -= size;
-}
-
-size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac)
-{
-	return mpac->parsed - mpac->off + mpac->used;
-}
-
-size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac)
-{
-	return mpac->parsed;
-}
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/unpack.h */
-
--- a/c/vrefbuffer.c
+++ b/c/vrefbuffer.c
@ -1,135 +0,0 @@
-/*
- * MessagePack for C zero-copy buffer implementation
- *
- * Copyright (C) 2008-2009 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 "msgpack/vrefbuffer.h"
-#include <stdlib.h>
-#include <string.h>
-
-bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf,
-		size_t ref_size, size_t chunk_size)
-{
-	if(chunk_size < sizeof(msgpack_vrefbuffer_chunk)+72) {
-		chunk_size = 72;
-	} else {
-		chunk_size -= sizeof(msgpack_vrefbuffer_chunk);
-	}
-
-	vbuf->chunk_size = chunk_size;
-	vbuf->ref_size = ref_size;
-
-	// glibcは72バイト以下のmallocが高速
-	size_t nfirst = (sizeof(struct iovec) < 72/2) ?
-			72 / sizeof(struct iovec) : 8;
-
-	struct iovec* array = (struct iovec*)malloc(
-			sizeof(struct iovec) * nfirst);
-	if(array == NULL) {
-		return false;
-	}
-
-	vbuf->tail  = array;
-	vbuf->end   = array + nfirst;
-	vbuf->array = array;
-
-	vbuf->chunk = (msgpack_vrefbuffer_chunk*)malloc(
-			chunk_size + sizeof(msgpack_vrefbuffer_chunk));
-	if(vbuf->chunk == NULL) {
-		free(array);
-		return false;
-	}
-
-	vbuf->chunk->next = NULL;
-	vbuf->chunk->free = chunk_size;
-
-	return true;
-}
-
-void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf)
-{
-	msgpack_vrefbuffer_chunk* c = vbuf->chunk;
-	while(true) {
-		msgpack_vrefbuffer_chunk* n = c->next;
-		free(c);
-		if(n) {
-			c = n;
-		} else {
-			break;
-		}
-	}
-	free(vbuf->array);
-}
-
-int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf,
-		const char* buf, unsigned int len)
-{
-	if(vbuf->tail == vbuf->end) {
-		const size_t nused = vbuf->end - vbuf->array;
-		const size_t nnext = nused * 2;
-
-		struct iovec* nvec = (struct iovec*)realloc(
-				vbuf->array, sizeof(struct iovec)*nnext);
-		if(nvec == NULL) {
-			return -1;
-		}
-
-		vbuf->array = nvec;
-		vbuf->end   = nvec + nnext;
-		vbuf->tail  = nvec + nused;
-	}
-
-	vbuf->tail->iov_base = (char*)buf;
-	vbuf->tail->iov_len  = len;
-	++vbuf->tail;
-
-	return 0;
-}
-
-int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf,
-		const char* buf, unsigned int len)
-{
-	msgpack_vrefbuffer_chunk* chunk = vbuf->chunk;
-	size_t cur_size = vbuf->chunk_size;
-
-	if(chunk->free < len) {
-		cur_size = (cur_size > len) ? cur_size : len;
-
-		chunk = (msgpack_vrefbuffer_chunk*)malloc(
-				cur_size + sizeof(msgpack_vrefbuffer_chunk));
-		if(chunk == NULL) {
-			return -1;
-		}
-
-		chunk->free = cur_size;
-		chunk->next = vbuf->chunk;
-		vbuf->chunk = chunk;
-	}
-
-	char* m = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk)
-		+ (cur_size - chunk->free);
-
-	memcpy(m, buf, len);
-	chunk->free -= len;
-
-	if(vbuf->tail != vbuf->array && m ==
-			(const char*)((vbuf->tail-1)->iov_base) + (vbuf->tail-1)->iov_len) {
-		(vbuf->tail-1)->iov_len += len;
-		return 0;
-	} else {
-		return msgpack_vrefbuffer_append_ref(vbuf, m, len);
-	}
-}
-
--- a/c/vrefbuffer.h
+++ b/c/vrefbuffer.h
@ -1,97 +0,0 @@
-/*
- * MessagePack for C zero-copy buffer implementation
- *
- * Copyright (C) 2008-2009 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_VREFBUFFER_H__
-#define MSGPACK_VREFBUFFER_H__
-
-#include "msgpack/zone.h"
-#include <sys/uio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#ifndef MSGPACK_VREFBUFFER_REF_SIZE
-#define MSGPACK_VREFBUFFER_REF_SIZE 32
-#endif
-
-#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE
-#define MSGPACK_VREFBUFFER_CHUNK_SIZE 2048
-#endif
-
-typedef struct msgpack_vrefbuffer_chunk {
-	size_t free;
-	struct msgpack_vrefbuffer_chunk* next;
-	/* data ... */
-} msgpack_vrefbuffer_chunk;
-
-typedef struct msgpack_vrefbuffer {
-	size_t chunk_size;
-	size_t ref_size;
-
-	struct iovec* tail;
-	struct iovec* end;
-	struct iovec* array;
-
-	msgpack_vrefbuffer_chunk* chunk;
-} msgpack_vrefbuffer;
-
-
-bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf,
-		size_t ref_size, size_t chunk_size);
-void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf);
-
-static inline int msgpack_vrefbuffer_write(void* data, const char* buf, unsigned int len);
-
-static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref);
-static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref);
-
-int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf,
-		const char* buf, unsigned int len);
-
-int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf,
-		const char* buf, unsigned int len);
-
-
-int msgpack_vrefbuffer_write(void* data, const char* buf, unsigned int len)
-{
-	msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data;
-
-	if(len < vbuf->ref_size) {
-		return msgpack_vrefbuffer_append_copy(vbuf, buf, len);
-	} else {
-		return msgpack_vrefbuffer_append_ref(vbuf, buf, len);
-	}
-}
-
-const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref)
-{
-	return vref->array;
-}
-
-size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref)
-{
-	return vref->tail - vref->array;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/vrefbuffer.h */
-
--- a/c/zone.c
+++ b/c/zone.c
@ -1,241 +0,0 @@
-/*
- * MessagePack for C memory pool implementation
- *
- * Copyright (C) 2008-2009 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 "msgpack/zone.h"
-#include <stdlib.h>
-#include <string.h>
-
-static inline bool init_chunk_array(msgpack_zone_chunk_array* ca, size_t chunk_size)
-{
-	// glibcは72バイト以下のmallocが高速
-	const size_t nfirst = (sizeof(msgpack_zone_chunk) < 72/2) ?
-			72 / sizeof(msgpack_zone_chunk) : 8;
-
-	msgpack_zone_chunk* array = (msgpack_zone_chunk*)malloc(
-			sizeof(msgpack_zone_chunk) * nfirst);
-	if(array == NULL) {
-		return false;
-	}
-
-	const size_t sz = chunk_size;
-
-	char* ptr = (char*)malloc(sz);
-	if(ptr == NULL) {
-		free(array);
-		return NULL;
-	}
-
-	ca->tail  = array;
-	ca->end   = array + nfirst;
-	ca->array = array;
-
-	array[0].free  = sz;
-	array[0].ptr   = ptr;
-	array[0].alloc = ptr;
-
-	return true;
-}
-
-static inline void destroy_chunk_array(msgpack_zone_chunk_array* ca)
-{
-	msgpack_zone_chunk* chunk = ca->array;
-	for(; chunk != ca->tail+1; ++chunk) {
-		free(chunk->alloc);
-	}
-
-	free(ca->array);
-}
-
-static inline void clear_chunk_array(msgpack_zone_chunk_array* ca)
-{
-	msgpack_zone_chunk* chunk = ca->array + 1;
-	for(; chunk != ca->tail+1; ++chunk) {
-		free(chunk->alloc);
-	}
-
-	ca->tail = ca->array;
-
-	ca->array[0].free += ca->array[0].ptr - (char*)ca->array[0].alloc;
-	ca->array[0].ptr   = (char*)ca->array[0].alloc;
-}
-
-void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size)
-{
-	msgpack_zone_chunk_array* const ca = &zone->chunk_array;
-
-	msgpack_zone_chunk* chunk = ++ca->tail;
-
-	if(chunk == ca->end) {
-		// ca->arrayに空きがない
-		// ca->arrayを拡張する
-
-		const size_t nused = ca->end - ca->array;
-		const size_t nnext = (ca->end - ca->array) * 2;
-
-		chunk = (msgpack_zone_chunk*)realloc(ca->array,
-				sizeof(msgpack_zone_chunk) * nnext);
-		if(chunk == NULL) {
-			return NULL;
-		}
-
-		ca->array        = chunk;
-		ca->end          = chunk + nnext;
-		chunk = ca->tail = chunk + nused;
-	}
-
-	size_t sz = zone->chunk_size;
-
-	while(sz < size) {
-		sz *= 2;
-	}
-
-	char* ptr = (char*)malloc(sz);
-	if(ptr == NULL) {
-		return NULL;
-	}
-
-	chunk->free  = sz - size;
-	chunk->ptr   = ptr + size;
-	chunk->alloc = ptr;
-
-	return ptr;
-}
-
-
-static inline void init_finalizer_array(msgpack_zone_finalizer_array* fa)
-{
-	fa->tail  = NULL;
-	fa->end   = NULL;
-	fa->array = NULL;
-}
-
-static inline void call_finalizer_array(msgpack_zone_finalizer_array* fa)
-{
-	// 逆順に呼び出し
-	msgpack_zone_finalizer* fin = fa->tail;
-	for(; fin != fa->array; --fin) {
-		(*(fin-1)->func)((fin-1)->data);
-	}
-}
-
-static inline void destroy_finalizer_array(msgpack_zone_finalizer_array* fa)
-{
-	call_finalizer_array(fa);
-	free(fa->array);
-}
-
-static inline void clear_finalizer_array(msgpack_zone_finalizer_array* fa)
-{
-	call_finalizer_array(fa);
-	fa->tail = fa->array;
-}
-
-bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone,
-		void (*func)(void* data), void* data)
-{
-	msgpack_zone_finalizer_array* const fa = &zone->finalizer_array;
-
-	const size_t nused = fa->end - fa->array;
-
-	size_t nnext;
-	if(nused == 0) {
-		// 初回の呼び出し：fa->tail == fa->end == fa->array == NULL
-
-		// glibcは72バイト以下のmallocが高速
-		nnext = (sizeof(msgpack_zone_finalizer) < 72/2) ?
-				72 / sizeof(msgpack_zone_finalizer) : 8;
-
-	} else {
-		nnext = nused * 2;
-	}
-
-	msgpack_zone_finalizer* tmp =
-		(msgpack_zone_finalizer*)realloc(fa->array,
-				sizeof(msgpack_zone_finalizer) * nnext);
-	if(tmp == NULL) {
-		return false;
-	}
-
-	fa->array  = tmp;
-	fa->end    = tmp + nnext;
-	fa->tail   = tmp + nused;
-
-	fa->tail->func = func;
-	fa->tail->data = data;
-
-	++fa->tail;
-
-	return true;
-}
-
-
-bool msgpack_zone_is_empty(msgpack_zone* zone)
-{
-	msgpack_zone_chunk_array* const ca = &zone->chunk_array;
-	msgpack_zone_finalizer_array* const fa = &zone->finalizer_array;
-	return ca->array[0].ptr == ca->array[0].alloc &&
-		ca->tail == ca->array &&
-		fa->tail == fa->array;
-}
-
-
-bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size)
-{
-	zone->chunk_size = chunk_size;
-
-	if(!init_chunk_array(&zone->chunk_array, chunk_size)) {
-		return false;
-	}
-
-	init_finalizer_array(&zone->finalizer_array);
-
-	return true;
-}
-
-void msgpack_zone_destroy(msgpack_zone* zone)
-{
-	destroy_finalizer_array(&zone->finalizer_array);
-	destroy_chunk_array(&zone->chunk_array);
-}
-
-void msgpack_zone_clear(msgpack_zone* zone)
-{
-	clear_finalizer_array(&zone->finalizer_array);
-	clear_chunk_array(&zone->chunk_array);
-}
-
-msgpack_zone* msgpack_zone_new(size_t chunk_size)
-{
-	msgpack_zone* zone = (msgpack_zone*)malloc(sizeof(msgpack_zone));
-	if(zone == NULL) {
-		return NULL;
-	}
-
-	if(!msgpack_zone_init(zone, chunk_size)) {
-		free(zone);
-		return NULL;
-	}
-
-	return zone;
-}
-
-void msgpack_zone_free(msgpack_zone* zone)
-{
-	msgpack_zone_destroy(zone);
-	free(zone);
-}
-
--- a/c/zone.h
+++ b/c/zone.h
@ -1,135 +0,0 @@
-/*
- * MessagePack for C memory pool implementation
- *
- * Copyright (C) 2008-2009 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_ZONE_H__
-#define MSGPACK_ZONE_H__
-
-#include <stddef.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef struct msgpack_zone_chunk {
-	size_t free;
-	char* ptr;
-	void* alloc;
-} msgpack_zone_chunk;
-
-typedef struct msgpack_zone_finalizer {
-	void (*func)(void* data);
-	void* data;
-} msgpack_zone_finalizer;
-
-typedef struct msgpack_zone_chunk_array {
-	msgpack_zone_chunk* tail;
-	msgpack_zone_chunk* end;
-	msgpack_zone_chunk* array;
-} msgpack_zone_chunk_array;
-
-typedef struct msgpack_zone_finalizer_array {
-	msgpack_zone_finalizer* tail;
-	msgpack_zone_finalizer* end;
-	msgpack_zone_finalizer* array;
-} msgpack_zone_finalizer_array;
-
-typedef struct msgpack_zone {
-	msgpack_zone_chunk_array chunk_array;
-	msgpack_zone_finalizer_array finalizer_array;
-	size_t chunk_size;
-} msgpack_zone;
-
-#ifndef MSGPACK_ZONE_CHUNK_SIZE
-#define MSGPACK_ZONE_CHUNK_SIZE 2048
-#endif
-
-bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size);
-void msgpack_zone_destroy(msgpack_zone* zone);
-
-msgpack_zone* msgpack_zone_new(size_t chunk_size);
-void msgpack_zone_free(msgpack_zone* zone);
-
-static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size);
-static inline void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size);
-
-static inline bool msgpack_zone_push_finalizer(msgpack_zone* zone,
-		void (*func)(void* data), void* data);
-
-bool msgpack_zone_is_empty(msgpack_zone* zone);
-
-void msgpack_zone_clear(msgpack_zone* zone);
-
-
-
-#ifndef MSGPACK_ZONE_ALIGN
-#define MSGPACK_ZONE_ALIGN sizeof(int)
-#endif
-
-void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size);
-
-void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size)
-{
-	msgpack_zone_chunk* chunk = zone->chunk_array.tail;
-
-	if(chunk->free < size) {
-		return msgpack_zone_malloc_expand(zone, size);
-	}
-
-	char* ptr = chunk->ptr;
-	chunk->ptr  += size;
-	chunk->free -= size;
-
-	return ptr;
-}
-
-void* msgpack_zone_malloc(msgpack_zone* zone, size_t size)
-{
-	return msgpack_zone_malloc_no_align(zone,
-			((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1));
-}
-
-
-bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone,
-		void (*func)(void* data), void* data);
-
-bool msgpack_zone_push_finalizer(msgpack_zone* zone,
-		void (*func)(void* data), void* data)
-{
-	msgpack_zone_finalizer_array* const fa = &zone->finalizer_array;
-	msgpack_zone_finalizer* fin = fa->tail;
-
-	if(fin == fa->end) {
-		return msgpack_zone_push_finalizer_expand(zone, func, data);
-	}
-
-	fin->func = func;
-	fin->data = data;
-
-	++fa->tail;
-
-	return true;
-}
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/zone.h */
-
--- a/configure.in
+++ b/configure.in
@ -1,44 +0,0 @@
-AC_INIT(msgpack/unpack_template.h)
-AC_CONFIG_AUX_DIR(ac)
-AM_INIT_AUTOMAKE(msgpack, 0.3.3)
-AC_CONFIG_HEADER(config.h)
-
-AC_SUBST(CFLAGS)
-if test "" = "$CFLAGS"; then
-	CFLAGS="-g -O4"
-fi
-
-AC_PROG_CC
-
-CFLAGS="-O4 -Wall $CFLAGS -I.."
-
-
-AC_MSG_CHECKING([if c++ api is enabled])
-AC_ARG_ENABLE(cxx,
-	AS_HELP_STRING([--disable-cxx],
-				   [don't build c++ api.]) )
-AC_MSG_RESULT($enable_cxx)
-if test "$enable_cxx" != "no"; then
-	AC_SUBST(CXXFLAGS)
-	if test "" = "$CXXFLAGS"; then
-		CXXFLAGS="-g -O4"
-	fi
-	
-	AC_CHECK_PROG(ERB, erb, erb)
-	if test "x$ERB" = x; then
-		AC_MSG_ERROR([cannot find erb. Ruby is needed to build.])
-	fi
-fi
-
-# FIXME
-AC_PROG_CXX
-
-CXXFLAGS="-O4 -Wall $CXXFLAGS -I.. -I../c"
-
-
-AM_CONDITIONAL(ENABLE_CXX, test "$enable_cxx" != "no")
-
-AC_PROG_LIBTOOL
-
-AC_OUTPUT([Makefile c/Makefile cpp/Makefile])
-
--- a/cpp/Makefile.am
+++ b/cpp/Makefile.am
@ -1,47 +0,0 @@
-lib_LTLIBRARIES = libmsgpack.la
-
-libmsgpack_la_SOURCES = \
-		object.cpp
-
-nobase_include_HEADERS = \
-		msgpack.hpp \
-		msgpack/sbuffer.hpp \
-		msgpack/vrefbuffer.hpp \
-		msgpack/pack.hpp \
-		msgpack/unpack.hpp \
-		msgpack/object.hpp \
-		msgpack/zone.hpp \
-		msgpack/type.hpp \
-		msgpack/type/array.hpp \
-		msgpack/type/boolean.hpp \
-		msgpack/type/float.hpp \
-		msgpack/type/integer.hpp \
-		msgpack/type/map.hpp \
-		msgpack/type/nil.hpp \
-		msgpack/type/raw.hpp \
-		msgpack/type/tuple.hpp
-
-# FIXME
-object.lo: msgpack/type/tuple.hpp msgpack/zone.hpp
-
-msgpack/type/tuple.hpp: msgpack/type/tuple.hpp.erb
-	$(ERB) $< > $@.tmp
-	mv $@.tmp $@
-
-msgpack/zone.hpp: msgpack/zone.hpp.erb
-	$(ERB) $< > $@.tmp
-	mv $@.tmp $@
-
-MOSTLYCLEANFILES = \
-		msgpack/type/tuple.hpp \
-		msgpack/zone.hpp
-
-EXTRA_DIST = \
-		msgpack/type/tuple.hpp.erb \
-		msgpack/zone.hpp.erb
-
-libmsgpack_la_LIBADD = -L../c -lmsgpackc
-
-# -version-info CURRENT:REVISION:AGE
-libmsgpack_la_LDFLAGS = -version-info 1:0:0
-
--- a/cpp/bench.cpp
+++ b/cpp/bench.cpp
@ -1,188 +0,0 @@
-#include <msgpack/unpack.hpp>
-#include <msgpack/pack.hpp>
-#include <string.h>
-#include <sys/time.h>
-#include <iostream>
-#include <stdexcept>
-#include <string>
-
-static const unsigned int TASK_INT_NUM = 1<<24;
-static const unsigned int TASK_STR_LEN = 1<<15;
-//static const unsigned int TASK_INT_NUM = 1<<22;
-//static const unsigned int TASK_STR_LEN = 1<<13;
-static const char* TASK_STR_PTR;
-
-
-class simple_timer {
-public:
-	void reset() { gettimeofday(&m_timeval, NULL); }
-	void show_stat(size_t bufsz)
-	{
-		struct timeval endtime;
-		gettimeofday(&endtime, NULL);
-		double sec = (endtime.tv_sec - m_timeval.tv_sec)
-			+ (double)(endtime.tv_usec - m_timeval.tv_usec) / 1000 / 1000;
-		std::cout << sec << " sec" << std::endl;
-		std::cout << (double(bufsz)/1024/1024) << " MB" << std::endl;
-		std::cout << (bufsz/sec/1000/1000*8) << " Mbps" << std::endl;
-	}
-private:
-	timeval m_timeval;
-};
-
-
-class simple_buffer {
-public:
-	static const size_t DEFAULT_INITIAL_SIZE = 32*1024;//512*1024*1024*2;
-
-	simple_buffer(size_t initial_size = DEFAULT_INITIAL_SIZE) :
-		m_storage((char*)malloc(initial_size)),
-		m_allocated(initial_size),
-		m_used(0)
-	{
-		if(!m_storage) { throw std::bad_alloc(); }
-	}
-
-	~simple_buffer()
-	{
-		free(m_storage);
-	}
-
-public:
-	inline void write(const char* buf, size_t len)
-	{
-		if(m_allocated - m_used < len) {
-			expand_buffer(len);
-		}
-		memcpy(m_storage + m_used, buf, len);
-		m_used += len;
-	}
-
-	void clear()
-	{
-		m_used = 0;
-	}
-
-private:
-	void expand_buffer(size_t req)
-	{
-		size_t nsize = m_allocated * 2;
-		size_t at_least = m_used + req;
-		while(nsize < at_least) { nsize *= 2; }
-		char* tmp = (char*)realloc(m_storage, nsize);
-		if(!tmp) { throw std::bad_alloc(); }
-		m_storage = tmp;
-		m_allocated = nsize;
-	}
-
-public:
-	size_t size() const { return m_used; }
-	const char* data() const { return m_storage; }
-
-private:
-	char* m_storage;
-	size_t m_allocated;
-	size_t m_used;
-};
-
-
-void bench_msgpack_int()
-{
-	simple_buffer buf;
-	simple_timer timer;
-
-	std::cout << "----" << std::endl;
-	std::cout << "pack integer" << std::endl;
-
-	timer.reset();
-	{
-		msgpack::packer<simple_buffer> pk(buf);
-		pk.pack_array(TASK_INT_NUM);
-		for(unsigned int i=0; i < TASK_INT_NUM; ++i) {
-			pk.pack_unsigned_int(i);
-		}
-	}
-	timer.show_stat(buf.size());
-
-
-	std::cout << "----" << std::endl;
-	std::cout << "unpack integer" << std::endl;
-
-	msgpack::zone z;
-	msgpack::object obj;
-
-	timer.reset();
-	{
-		obj = msgpack::unpack(buf.data(), buf.size(), z);
-	}
-	timer.show_stat(buf.size());
-
-	/*
-	std::cout << "----" << std::endl;
-	std::cout << "dynamic pack integer" << std::endl;
-
-	buf.clear();
-
-	timer.reset();
-	msgpack::pack(buf, obj);
-	timer.show_stat(buf.size());
-	*/
-}
-
-void bench_msgpack_str()
-{
-	simple_buffer buf;
-	simple_timer timer;
-
-	std::cout << "----" << std::endl;
-	std::cout << "pack string" << std::endl;
-
-	timer.reset();
-	{
-		msgpack::packer<simple_buffer> pk(buf);
-		pk.pack_array(TASK_STR_LEN);
-		for(unsigned int i=0; i < TASK_STR_LEN; ++i) {
-			pk.pack_raw(i);
-			pk.pack_raw_body(TASK_STR_PTR, i);
-		}
-	}
-	timer.show_stat(buf.size());
-
-
-	std::cout << "----" << std::endl;
-	std::cout << "unpack string" << std::endl;
-
-	msgpack::zone z;
-	msgpack::object obj;
-
-	timer.reset();
-	{
-		obj = msgpack::unpack(buf.data(), buf.size(), z);
-	}
-	timer.show_stat(buf.size());
-
-
-	/*
-	std::cout << "----" << std::endl;
-	std::cout << "dynamic pack string" << std::endl;
-
-	buf.clear();
-
-	timer.reset();
-	msgpack::pack(buf, obj);
-	timer.show_stat(buf.size());
-	*/
-}
-
-int main(void)
-{
-	char* str = (char*)malloc(TASK_STR_LEN);
-	memset(str, 'a', TASK_STR_LEN);
-	TASK_STR_PTR = str;
-
-	bench_msgpack_int();
-	bench_msgpack_str();
-
-	return 0;
-}
-
--- a/cpp/bench.mk
+++ b/cpp/bench.mk
@ -1,9 +0,0 @@
-
-CXXFLAGS  += -Wall -g -I. -I.. -O4
-LDFLAGS +=
-
-all: bench
-
-bench: bench.o unpack.o zone.o object.o pack.hpp unpack.hpp zone.hpp object.hpp
-	$(CXX) bench.o unpack.o zone.o object.o $(CXXFLAGS) $(LDFLAGS) -o $@
-
--- a/cpp/msgpack
+++ b/cpp/msgpack
@ -1 +0,0 @@
-.
--- a/cpp/msgpack.hpp
+++ b/cpp/msgpack.hpp
@ -1,24 +0,0 @@
-//
-// MessagePack for C++
-//
-// Copyright (C) 2008-2009 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 "msgpack/object.hpp"
-#include "msgpack/zone.hpp"
-#include "msgpack/pack.hpp"
-#include "msgpack/unpack.hpp"
-#include "msgpack/sbuffer.hpp"
-#include "msgpack/vrefbuffer.hpp"
-#include "msgpack.h"
--- a/cpp/object.cpp
+++ b/cpp/object.cpp
@ -1,139 +0,0 @@
-//
-// MessagePack for C++ dynamic typed objects
-//
-// Copyright (C) 2008-2009 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 "msgpack/object.hpp"
-
-#include <string.h>
-
-namespace msgpack {
-
-
-std::ostream& operator<< (std::ostream& s, const object o)
-{
-	switch(o.type) {
-	case type::NIL:
-		s << "nil";
-		break;
-
-	case type::BOOLEAN:
-		s << (o.via.boolean ? "true" : "false");
-		break;
-
-	case type::POSITIVE_INTEGER:
-		s << o.via.u64;
-		break;
-
-	case type::NEGATIVE_INTEGER:
-		s << o.via.i64;
-		break;
-
-	case type::DOUBLE:
-		s << o.via.dec;
-		break;
-
-	case type::RAW:
-		(s << '"').write(o.via.raw.ptr, o.via.raw.size) << '"';
-		break;
-
-	case type::ARRAY:
-		s << "[";
-		if(o.via.array.size != 0) {
-			object* p(o.via.array.ptr);
-			s << *p;
-			++p;
-			for(object* const pend(o.via.array.ptr + o.via.array.size);
-					p < pend; ++p) {
-				s << ", " << *p;
-			}
-		}
-		s << "]";
-		break;
-		// FIXME loop optimiziation
-
-	case type::MAP:
-		s << "{";
-		if(o.via.map.size != 0) {
-			object_kv* p(o.via.map.ptr);
-			s << p->key << "=>" << p->val;
-			++p;
-			for(object_kv* const pend(o.via.map.ptr + o.via.map.size);
-					p < pend; ++p) {
-				s << ", " << p->key << "=>" << p->val;
-			}
-		}
-		s << "}";
-		break;
-		// FIXME loop optimiziation
-
-	default:
-		// FIXME
-		s << "#<UNKNOWN " << (uint16_t)o.type << ">";
-	}
-	return s;
-}
-
-
-bool operator==(const object x, const object y)
-{
-	if(x.type != y.type) { return false; }
-
-	switch(x.type) {
-	case type::NIL:
-		return true;
-
-	case type::BOOLEAN:
-		return x.via.boolean == y.via.boolean;
-
-	case type::POSITIVE_INTEGER:
-		return x.via.u64 == y.via.u64;
-
-	case type::NEGATIVE_INTEGER:
-		return x.via.i64 == y.via.i64;
-
-	case type::RAW:
-		return x.via.raw.size == y.via.raw.size &&
-			memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0;
-
-	case type::ARRAY:
-		if(x.via.array.size != y.via.array.size) { return false; }
-		for(object* px(x.via.array.ptr),
-				* const pxend(x.via.array.ptr + x.via.array.size),
-				* py(y.via.array.ptr);
-				px < pxend; ++px, ++py) {
-			if(*px != *py) { return false; }
-		}
-		return true;
-		// FIXME loop optimiziation
-
-	case type::MAP:
-		if(x.via.map.size != y.via.map.size) { return false; }
-		for(object_kv* px(x.via.map.ptr),
-				* const pxend(x.via.map.ptr + x.via.map.size),
-				* py(y.via.map.ptr);
-				px < pxend; ++px, ++py) {
-			if(px->key != py->key || px->val != py->val) { return false; }
-		}
-		return true;
-
-	default:
-		return false;
-	}
-}
-
-
-}  // namespace msgpack
-
--- a/cpp/object.hpp
+++ b/cpp/object.hpp
@ -1,329 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_OBJECT_HPP__
-#define MSGPACK_OBJECT_HPP__
-
-#include "msgpack/object.h"
-#include "msgpack/pack.hpp"
-#include <stdint.h>
-#include <string.h>
-#include <stdexcept>
-#include <typeinfo>
-#include <limits>
-#include <ostream>
-
-namespace msgpack {
-
-
-class type_error : public std::bad_cast { };
-
-
-namespace type {
-	enum object_type {
-		NIL					= 0x01,
-		BOOLEAN				= 0x02,
-		POSITIVE_INTEGER	= 0x03,
-		NEGATIVE_INTEGER	= 0x04,
-		DOUBLE				= 0x05,
-		RAW					= 0x06,
-		ARRAY				= 0x07,
-		MAP					= 0x08,
-	};
-}
-
-
-struct object;
-struct object_kv;
-
-struct object_array {
-	uint32_t size;
-	object* ptr;
-};
-
-struct object_map {
-	uint32_t size;
-	object_kv* ptr;
-};
-
-struct object_raw {
-	uint32_t size;
-	const char* ptr;
-};
-
-struct object {
-	union union_type {
-		bool boolean;
-		uint64_t u64;
-		int64_t  i64;
-		double   dec;
-		object_array array;
-		object_map map;
-		object_raw raw;
-		object_raw ref;  // obsolete
-	};
-
-	type::object_type type;
-	union_type via;
-
-	bool is_nil() const { return type == type::NIL; }
-
-	template <typename T>
-	T as() const;
-
-	template <typename T>
-	void convert(T* v) const;
-
-	object();
-	object(msgpack_object obj);
-	operator msgpack_object();
-
-private:
-	struct implicit_type;
-
-public:
-	implicit_type convert() const;
-};
-
-struct object_kv {
-	object key;
-	object val;
-};
-
-bool operator==(const object x, const object y);
-bool operator!=(const object x, const object y);
-
-std::ostream& operator<< (std::ostream& s, const object o);
-
-
-template <typename Stream, typename T>
-packer<Stream>& operator<< (packer<Stream>& o, const T& v);
-
-template <typename T>
-T& operator>> (object o, T& v);
-
-
-struct object::implicit_type {
-	implicit_type(object o) : obj(o) { }
-	~implicit_type() { }
-
-	template <typename T>
-	operator T() { return obj.as<T>(); }
-
-private:
-	object obj;
-};
-
-
-template <typename Type>
-class define : public Type {
-public:
-	typedef Type msgpack_type;
-	typedef define<Type> define_type;
-
-	define() {}
-	define(const msgpack_type& v) : msgpack_type(v) {}
-
-	template <typename Packer>
-	void msgpack_pack(Packer& o) const
-	{
-		o << static_cast<const msgpack_type&>(*this);
-	}
-
-	void msgpack_unpack(object o)
-	{
-		o >> static_cast<msgpack_type&>(*this);
-	}
-};
-
-
-template <typename Stream>
-template <typename T>
-inline packer<Stream>& packer<Stream>::pack(const T& v)
-{
-	*this << v;
-	return *this;
-}
-
-inline object& operator>> (object o, object& v)
-{
-	v = o;
-	return v;
-}
-
-template <typename T>
-inline T& operator>> (object o, T& v)
-{
-	v.msgpack_unpack(o.convert());
-	return v;
-}
-
-template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const T& v)
-{
-	v.msgpack_pack(o);
-	return o;
-}
-
-
-inline bool operator!=(const object x, const object y)
-{ return !(x == y); }
-
-
-inline object::object() { }
-
-inline object::object(msgpack_object obj)
-{
-	// FIXME beter way?
-	::memcpy(this, &obj, sizeof(obj));
-}
-
-inline object::operator msgpack_object()
-{
-	// FIXME beter way?
-	msgpack_object obj;
-	::memcpy(&obj, this, sizeof(obj));
-	return obj;
-}
-
-
-inline object::implicit_type object::convert() const
-{
-	return implicit_type(*this);
-}
-
-template <typename T>
-inline void object::convert(T* v) const
-{
-	*this >> *v;
-}
-
-template <typename T>
-inline T object::as() const
-{
-	T v;
-	convert(&v);
-	return v;
-}
-
-
-// obsolete
-template <typename T>
-inline void convert(T& v, object o)
-{
-	o.convert(&v);
-}
-
-// obsolete
-template <typename Stream, typename T>
-inline void pack(packer<Stream>& o, const T& v)
-{
-	o.pack(v);
-}
-
-// obsolete
-template <typename Stream, typename T>
-inline void pack_copy(packer<Stream>& o, T v)
-{
-	pack(o, v);
-}
-
-
-template <typename Stream>
-packer<Stream>& operator<< (packer<Stream>& o, const object& v)
-{
-	switch(v.type) {
-	case type::NIL:
-		o.pack_nil();
-		return o;
-
-	case type::BOOLEAN:
-		if(v.via.boolean) {
-			o.pack_true();
-		} else {
-			o.pack_false();
-		}
-		return o;
-
-	case type::POSITIVE_INTEGER:
-		if(v.via.u64 <= (uint64_t)std::numeric_limits<uint16_t>::max()) {
-			if(v.via.u64 <= (uint16_t)std::numeric_limits<uint8_t>::max()) {
-				o.pack_uint8(v.via.u64);
-			} else {
-				o.pack_uint16(v.via.u64);
-			}
-		} else {
-			if(v.via.u64 <= (uint64_t)std::numeric_limits<uint32_t>::max()) {
-				o.pack_uint32(v.via.u64);
-			} else {
-				o.pack_uint64(v.via.u64);
-			}
-		}
-		return o;
-
-	case type::NEGATIVE_INTEGER:
-		if(v.via.i64 >= (int64_t)std::numeric_limits<int16_t>::min()) {
-			if(v.via.i64 >= (int64_t)std::numeric_limits<int8_t>::min()) {
-				o.pack_int8(v.via.i64);
-			} else {
-				o.pack_int16(v.via.i64);
-			}
-		} else {
-			if(v.via.i64 >= (int64_t)std::numeric_limits<int32_t>::min()) {
-				o.pack_int64(v.via.i64);
-			} else {
-				o.pack_int64(v.via.i64);
-			}
-		}
-		return o;
-
-	case type::RAW:
-		o.pack_raw(v.via.raw.size);
-		o.pack_raw_body(v.via.raw.ptr, v.via.raw.size);
-		return o;
-
-	case type::ARRAY:
-		o.pack_array(v.via.array.size);
-		for(object* p(v.via.array.ptr),
-				* const pend(v.via.array.ptr + v.via.array.size);
-				p < pend; ++p) {
-			o << *p;
-		}
-		return o;
-
-	case type::MAP:
-		o.pack_map(v.via.map.size);
-		for(object_kv* p(v.via.map.ptr),
-				* const pend(v.via.map.ptr + v.via.map.size);
-				p < pend; ++p) {
-			o << p->key;
-			o << p->val;
-		}
-		return o;
-
-	default:
-		throw type_error();
-	}
-}
-
-
-}  // namespace msgpack
-
-#include "msgpack/type.hpp"
-
-#endif /* msgpack/object.hpp */
-
--- a/cpp/pack.hpp
+++ b/cpp/pack.hpp
@ -1,253 +0,0 @@
-//
-// MessagePack for C++ serializing routine
-//
-// Copyright (C) 2008-2009 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_PACK_HPP__
-#define MSGPACK_PACK_HPP__
-
-#include <arpa/inet.h>  // __BYTE_ORDER
-#include <stdexcept>
-#include <limits.h>
-#include "msgpack/pack_define.h"
-
-namespace msgpack {
-
-
-template <typename Stream>
-class packer {
-public:
-	packer(Stream& s);
-	~packer();
-
-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(uint8_t d);
-	packer<Stream>& pack_int16(uint16_t d);
-	packer<Stream>& pack_int32(uint32_t d);
-	packer<Stream>& pack_int64(uint64_t d);
-
-	packer<Stream>& pack_short(int 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_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(unsigned int n);
-
-	packer<Stream>& pack_map(unsigned int n);
-
-	packer<Stream>& pack_raw(size_t l);
-	packer<Stream>& pack_raw_body(const char* b, size_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_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_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, unsigned int n);
-
-	static void _pack_map(Stream& x, unsigned int 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, unsigned int len)
-		{ x.write((const char*)buf, len); }
-
-private:
-	Stream& m_stream;
-
-private:
-	packer();
-};
-
-
-template <typename Stream, typename T>
-inline void pack(Stream& s, const T& v)
-{
-	packer<Stream>(s).pack(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_user Stream&
-
-#define msgpack_pack_append_buffer append_buffer
-
-#include "msgpack/pack_template.h"
-
-
-template <typename Stream>
-packer<Stream>::packer(Stream& s) : m_stream(s) { }
-
-template <typename Stream>
-packer<Stream>::~packer() { }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_uint8(uint8_t d)
-{ _pack_uint8(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_uint16(uint16_t d)
-{ _pack_uint16(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_uint32(uint32_t d)
-{ _pack_uint32(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_uint64(uint64_t d)
-{ _pack_uint64(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_int8(uint8_t d)
-{ _pack_int8(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_int16(uint16_t d)
-{ _pack_int16(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_int32(uint32_t d)
-{ _pack_int32(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_int64(uint64_t d)
-{ _pack_int64(m_stream, d); return *this;}
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_short(int d)
-{ _pack_short(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_int(int d)
-{ _pack_int(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_long(long d)
-{ _pack_long(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_long_long(long long d)
-{ _pack_long_long(m_stream, 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; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_unsigned_int(unsigned int d)
-{ _pack_unsigned_int(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_unsigned_long(unsigned long d)
-{ _pack_unsigned_long(m_stream, d); 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; }
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_float(float d)
-{ _pack_float(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_double(double d)
-{ _pack_double(m_stream, d); return *this; }
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_nil()
-{ _pack_nil(m_stream); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_true()
-{ _pack_true(m_stream); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_false()
-{ _pack_false(m_stream); return *this; }
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_array(unsigned int n)
-{ _pack_array(m_stream, n); return *this; }
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_map(unsigned int n)
-{ _pack_map(m_stream, n); return *this; }
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_raw(size_t l)
-{ _pack_raw(m_stream, l); return *this; }
-
-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; }
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/pack.hpp */
-
--- a/cpp/sbuffer.hpp
+++ b/cpp/sbuffer.hpp
@ -1,103 +0,0 @@
-//
-// MessagePack for C++ simple buffer implementation
-//
-// Copyright (C) 2008-2009 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_SBUFFER_HPP__
-#define MSGPACK_SBUFFER_HPP__
-
-#include "msgpack/sbuffer.h"
-#include <stdexcept>
-
-namespace msgpack {
-
-
-class sbuffer : public msgpack_sbuffer {
-public:
-	sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE)
-	{
-		base::data = (char*)::malloc(initsz);
-		if(!base::data) {
-			throw std::bad_alloc();
-		}
-
-		base::size = 0;
-		base::alloc = initsz;
-	}
-
-	~sbuffer()
-	{
-		::free(base::data);
-	}
-
-public:
-	void write(const char* buf, unsigned int len)
-	{
-		if(base::alloc - base::size < len) {
-			expand_buffer(len);
-		}
-		memcpy(base::data + base::size, buf, len);
-		base::size += len;
-	}
-
-	char* data()
-	{
-		return base::data;
-	}
-
-	const char* data() const
-	{
-		return base::data;
-	}
-
-	size_t size() const
-	{
-		return base::size;
-	}
-
-	char* release()
-	{
-		return msgpack_sbuffer_release(this);
-	}
-
-private:
-	void expand_buffer(size_t len)
-	{
-		size_t nsize = (base::alloc) ?
-				base::alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
-	
-		while(nsize < base::size + len) { nsize *= 2; }
-	
-		void* tmp = realloc(base::data, nsize);
-		if(!tmp) {
-			throw std::bad_alloc();
-		}
-	
-		base::data = (char*)tmp;
-		base::alloc = nsize;
-	}
-
-private:
-	typedef msgpack_sbuffer base;
-
-private:
-	sbuffer(const sbuffer&);
-};
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/sbuffer.hpp */
-
--- a/cpp/test.cpp
+++ b/cpp/test.cpp
@ -1,201 +0,0 @@
-#include <iostream>
-#include <string>
-#include <msgpack.hpp>
-#include <sstream>
-#include <memory>
-
-using namespace msgpack;
-
-class checker {
-public:
-	template <typename T>
-	void check(const char* d, size_t len, T should) {
-		try {
-			std::cout << "----" << std::endl;
-
-			object o;
-			try {
-				o = unpack(d, len, m_zone);
-			} catch (std::runtime_error& e) {
-				std::cout << o << std::endl;
-				std::cout << "**" << e.what() << "**" << std::endl;
-				return;
-			}
-
-			std::cout << o << std::endl;
-
-			try {
-				std::stringstream s;
-				pack(s, should);
-				std::string str(s.str());
-				object ro = unpack(str.data(), str.size(), m_zone);
-				std::cout << ro << std::endl;
-				if(ro != o) { throw std::runtime_error("NOT MATCH"); }
-			} catch (std::runtime_error& e) {
-				std::cout << "** REUNPACK FAILED **" << std::endl;
-				std::cout << e.what() << std::endl;
-			} catch (...) {
-				std::cout << "** REUNPACK FAILED **" << std::endl;
-				std::cout << "unknown error" << std::endl;
-			}
-
-		} catch (...) { m_zone.clear(); throw; }
-		m_zone.clear();
-	}
-private:
-	zone m_zone;
-};
-
-int main(void)
-{
-	checker c;
-
-#if 0
-	{  // SimpleValue
-		const char d[] = {
-			0x93, 0xc0, 0xc2, 0xc3,
-		};
-		c.check(d, sizeof(d),
-			type::make_tuple(
-				type::nil(), false, true
-			)
-		);
-	}
-
-	{  // Fixnum
-		const char d[] = {
-			0x92,
-				0x93, 0x00, 0x40, 0x7f,
-				0x93, 0xe0, 0xf0, 0xff,
-		};
-		c.check(d, sizeof(d),
-			type::make_tuple(
-				type::make_tuple(
-					0, 64, 127
-				),
-				type::make_tuple(
-					-32, -16, -1
-				)
-			)
-		);
-	}
-
-	{  // FixArray
-		const char d[] = {
-			0x92,
-				0x90,
-				0x91,
-					0x91, 0xc0,
-		};
-		std::vector<int> empty;
-		c.check(d, sizeof(d),
-			type::make_tuple(
-				empty,
-				type::make_tuple(
-					type::make_tuple(
-						type::nil()
-					)
-				)
-			)
-		);
-	}
-
-	{  // FixRaw
-		const char d[] = {
-			0x94,
-				0xa0,
-				0xa1, 'a',
-				0xa2, 'b', 'c',
-				0xa3, 'd', 'e', 'f',
-		};
-		c.check(d, sizeof(d),
-			type::make_tuple(
-				std::string(""),
-				std::string("a"),
-				std::string("bc"),
-				type::raw_ref("def", 3)
-			)
-		);
-	}
-#endif
-
-
-	static const unsigned TASK_ARRAY = 1000;
-	static const unsigned TASK_REPEAT = 10;
-	std::vector<std::string> task;
-
-	// create task
-	{
-		static char traw[64];
-		memset(traw, 'a', sizeof(traw));
-	
-		task.resize(TASK_ARRAY);
-		for(unsigned i=0; i < TASK_ARRAY; ++i) {
-			task[i] = std::string(traw, sizeof(traw));
-		}
-	}
-
-
-	std::stringstream stream;
-
-	// send message
-	{
-		for(unsigned i=0; i < TASK_REPEAT; ++i) {
-			pack(stream, task);
-		}
-		std::cout << "send " << stream.str().size() << " bytes" << std::endl;
-	}
-
-	ssize_t total_bytes = stream.str().size();
-	stream.seekg(0);
-
-	// reserive message
-	{
-		unsigned num_msg = 0;
-		static const size_t RESERVE_SIZE = 32;//*1024;
-
-		unpacker pac;
-
-		while(stream.good() && total_bytes > 0) {
-
-			// 1. reserve buffer
-			pac.reserve_buffer(RESERVE_SIZE);
-
-			// 2. read data to buffer() up to buffer_capacity() bytes
-			size_t sz = stream.readsome(
-					pac.buffer(),
-					pac.buffer_capacity());
-
-			total_bytes -= sz;
-			std::cout << "read " << sz << " bytes to capacity "
-					<< pac.buffer_capacity() << " bytes"
-					<< std::endl;
-
-			// 3. specify the number of  bytes actually copied
-			pac.buffer_consumed(sz);
-
-			// 4. repeat execute() until it returns false
-			while( pac.execute() ) {
-				// 5.1. take out the parsed object
-				object o = pac.data();
-
-				// 5.2 release the zone
-				std::auto_ptr<zone> olife( pac.release_zone() );
-
-				// 5.3 re-initialize the unpacker */
-				pac.reset();
-
-				// do some with the o and olife
-				std::cout << "message parsed: " << o << std::endl;
-				++num_msg;
-			}
-
-		}
-
-		std::cout << "stream finished" << std::endl;
-		std::cout << num_msg << " messages reached" << std::endl;
-	}
-
-	return 0;
-}
-
--- a/cpp/test.mk
+++ b/cpp/test.mk
@ -1,9 +0,0 @@
-
-CXXFLAGS  += -Wall -g -I. -I.. -O4
-LDFLAGS +=
-
-all: test
-
-test: test.o unpack.o zone.o object.o pack.hpp unpack.hpp zone.hpp object.hpp
-	$(CXX) test.o unpack.o zone.o object.o $(CXXFLAGS) $(LDFLAGS) -o $@
-
--- a/cpp/type.hpp
+++ b/cpp/type.hpp
@ -1,9 +0,0 @@
-#include "msgpack/type/array.hpp"
-#include "msgpack/type/boolean.hpp"
-#include "msgpack/type/float.hpp"
-#include "msgpack/type/integer.hpp"
-#include "msgpack/type/map.hpp"
-#include "msgpack/type/nil.hpp"
-#include "msgpack/type/raw.hpp"
-#include "msgpack/type/tuple.hpp"
-
--- a/cpp/type/array.hpp
+++ b/cpp/type/array.hpp
@ -1,57 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_TYPE_ARRAY_HPP__
-#define MSGPACK_TYPE_ARRAY_HPP__
-
-#include "msgpack/object.hpp"
-#include <vector>
-
-namespace msgpack {
-
-
-template <typename T>
-inline std::vector<T> operator>> (object o, std::vector<T>& v)
-{
-	if(o.type != type::ARRAY) { throw type_error(); }
-	v.resize(o.via.array.size);
-	object* p = o.via.array.ptr;
-	object* const pend = o.via.array.ptr + o.via.array.size;
-	T* it = &v.front();
-	for(; p < pend; ++p, ++it) {
-		p->convert(it);
-	}
-	return v;
-}
-
-
-template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::vector<T>& v)
-{
-	o.pack_array(v.size());
-	for(typename std::vector<T>::const_iterator it(v.begin()), it_end(v.end());
-			it != it_end; ++it) {
-		o.pack(*it);
-	}
-	return o;
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/array.hpp */
-
--- a/cpp/type/boolean.hpp
+++ b/cpp/type/boolean.hpp
@ -1,47 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_TYPE_BOOLEAN_HPP__
-#define MSGPACK_TYPE_BOOLEAN_HPP__
-
-#include "msgpack/object.hpp"
-#include <vector>
-
-namespace msgpack {
-
-
-inline bool& operator>> (object o, bool& v)
-{
-	if(o.type != type::BOOLEAN) { throw type_error(); }
-	v = o.via.boolean;
-	return v;
-}
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const bool& v)
-{
-	if(v) { o.pack_true(); }
-	else { o.pack_false(); }
-	return o;
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/bool.hpp */
-
--- a/cpp/type/float.hpp
+++ b/cpp/type/float.hpp
@ -1,65 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_TYPE_FLOAT_HPP__
-#define MSGPACK_TYPE_FLOAT_HPP__
-
-#include "msgpack/object.hpp"
-#include <vector>
-
-namespace msgpack {
-
-
-// FIXME check overflow, underflow
-
-
-inline float& operator>> (object o, float& v)
-{
-	if(o.type != type::DOUBLE) { throw type_error(); }
-	v = o.via.dec;
-	return v;
-}
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const float& v)
-{
-	o.pack_float(v);
-	return o;
-}
-
-
-inline double& operator>> (object o, double& v)
-{
-	if(o.type != type::DOUBLE) { throw type_error(); }
-	v = o.via.dec;
-	return v;
-}
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const double& v)
-{
-	o.pack_double(v);
-	return o;
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/float.hpp */
-
--- a/cpp/type/integer.hpp
+++ b/cpp/type/integer.hpp
@ -1,147 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_TYPE_INTEGER_HPP__
-#define MSGPACK_TYPE_INTEGER_HPP__
-
-#include "msgpack/object.hpp"
-#include <limits>
-
-namespace msgpack {
-
-
-namespace type {
-namespace detail {
-	template <typename T, bool Signed>
-	struct convert_integer_sign;
-
-	template <typename T>
-	struct convert_integer_sign<T, true> {
-		static inline T convert(object o) {
-			if(o.type == type::POSITIVE_INTEGER) {
-				if(o.via.u64 > (uint64_t)std::numeric_limits<T>::max())
-					{ throw type_error(); }
-				return o.via.u64;
-			} else if(o.type == type::NEGATIVE_INTEGER) {
-				if(o.via.i64 < (int64_t)-std::numeric_limits<T>::max())
-					{ throw type_error(); }
-				return o.via.i64;
-			}
-			throw type_error();
-		}
-	};
-	
-	template <typename T>
-	struct convert_integer_sign<T, false> {
-		static inline T convert(object o) {
-			if(o.type == type::POSITIVE_INTEGER) {
-				if(o.via.u64 > (uint64_t)std::numeric_limits<T>::max())
-					{ throw type_error(); }
-				return o.via.u64;
-			}
-			throw type_error();
-		}
-	};
-	
-	template <typename T>
-	static inline T convert_integer(object o)
-	{
-		return detail::convert_integer_sign<T, std::numeric_limits<T>::is_signed>::convert(o);
-	}
-
-}  // namespace detail
-}  // namespace type
-
-
-inline signed char& operator>> (object o, signed char& v)
-	{ v = type::detail::convert_integer<signed char>(o); return v; }
-
-inline signed short& operator>> (object o, signed short& v)
-	{ v = type::detail::convert_integer<signed short>(o); return v; }
-
-inline signed int& operator>> (object o, signed int& v)
-	{ v = type::detail::convert_integer<signed int>(o); return v; }
-
-inline signed long& operator>> (object o, signed long& v)
-	{ v = type::detail::convert_integer<signed long>(o); return v; }
-
-inline signed long long& operator>> (object o, signed long long& v)
-	{ v = type::detail::convert_integer<signed long long>(o); return v; }
-
-
-inline unsigned char& operator>> (object o, unsigned char& v)
-	{ v = type::detail::convert_integer<unsigned char>(o); return v; }
-
-inline unsigned short& operator>> (object o, unsigned short& v)
-	{ v = type::detail::convert_integer<unsigned short>(o); return v; }
-
-inline unsigned int& operator>> (object o, unsigned int& v)
-	{ v = type::detail::convert_integer<unsigned int>(o); return v; }
-
-inline unsigned long& operator>> (object o, unsigned long& v)
-	{ v = type::detail::convert_integer<unsigned long>(o); return v; }
-
-inline unsigned long long& operator>> (object o, unsigned long long& v)
-	{ v = type::detail::convert_integer<unsigned long long>(o); return v; }
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed char& v)
-	{ o.pack_int8(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed short& v)
-	{ o.pack_short(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed int& v)
-	{ o.pack_int(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed long& v)
-	{ o.pack_long(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const signed long long& v)
-	{ o.pack_long_long(v); return o; }
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned char& v)
-	{ o.pack_uint8(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned short& v)
-	{ o.pack_unsigned_short(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned int& v)
-	{ o.pack_unsigned_int(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned long& v)
-	{ o.pack_unsigned_long(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned long long& v)
-	{ o.pack_unsigned_long_long(v); return o; }
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/integer.hpp */
-
--- a/cpp/type/map.hpp
+++ b/cpp/type/map.hpp
@ -1,139 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_TYPE_MAP_HPP__
-#define MSGPACK_TYPE_MAP_HPP__
-
-#include "msgpack/object.hpp"
-#include <map>
-#include <vector>
-#include <algorithm>
-
-namespace msgpack {
-
-
-namespace type {
-
-template <typename K, typename V>
-class assoc_vector : public std::vector< std::pair<K, V> > {};
-
-namespace detail {
-	template <typename K, typename V>
-	struct pair_first_less {
-		bool operator() (const std::pair<K, V>& x, const std::pair<K, V>& y) const
-			{ return x.first < y.first; }
-	};
-}
-
-}  //namespace type
-
-
-template <typename K, typename V>
-inline type::assoc_vector<K,V>& operator>> (object o, type::assoc_vector<K,V>& v)
-{
-	if(o.type != type::MAP) { throw type_error(); }
-	v.resize(o.via.map.size);
-	object_kv* p = o.via.map.ptr;
-	object_kv* const pend = o.via.map.ptr + o.via.map.size;
-	std::pair<K, V>* it(&v.front());
-	for(; p < pend; ++p, ++it) {
-		p->key.convert(&it->first);
-		p->val.convert(&it->second);
-	}
-	std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
-	return v;
-}
-
-template <typename Stream, typename K, typename V>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::assoc_vector<K,V>& v)
-{
-	o.pack_map(v.size());
-	for(typename type::assoc_vector<K,V>::const_iterator it(v.begin()), it_end(v.end());
-			it != it_end; ++it) {
-		o.pack(it->first);
-		o.pack(it->second);
-	}
-	return o;
-}
-
-
-template <typename K, typename V>
-inline std::map<K, V> operator>> (object o, std::map<K, V>& v)
-{
-	if(o.type != type::MAP) { throw type_error(); }
-	object_kv* p(o.via.map.ptr);
-	object_kv* const pend(o.via.map.ptr + o.via.map.size);
-	for(; p != pend; ++p) {
-		K key;
-		p->key.convert(&key);
-		typename std::map<K,V>::iterator it(v.lower_bound(key));
-		if(it != v.end() && !(key < it->first)) {
-			p->val.convert(&it->second);
-		} else {
-			V val;
-			p->val.convert(&val);
-			v.insert(it, std::pair<K,V>(key, val));
-		}
-	}
-	return v;
-}
-
-template <typename Stream, typename K, typename V>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::map<K,V>& v)
-{
-	o.pack_map(v.size());
-	for(typename std::map<K,V>::const_iterator it(v.begin()), it_end(v.end());
-			it != it_end; ++it) {
-		o.pack(it->first);
-		o.pack(it->second);
-	}
-	return o;
-}
-
-
-template <typename K, typename V>
-inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v)
-{
-	if(o.type != type::MAP) { throw type_error(); }
-	object_kv* p(o.via.map.ptr);
-	object_kv* const pend(o.via.map.ptr + o.via.map.size);
-	for(; p != pend; ++p) {
-		std::pair<K, V> value;
-		p->key.convert(&value.first);
-		p->val.convert(&value.second);
-		v.insert(value);
-	}
-	return v;
-}
-
-template <typename Stream, typename K, typename V>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::multimap<K,V>& v)
-{
-	o.pack_map(v.size());
-	for(typename std::multimap<K,V>::const_iterator it(v.begin()), it_end(v.end());
-			it != it_end; ++it) {
-		o.pack(it->first);
-		o.pack(it->second);
-	}
-	return o;
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/map.hpp */
-
--- a/cpp/type/nil.hpp
+++ b/cpp/type/nil.hpp
@ -1,49 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_TYPE_NIL_HPP__
-#define MSGPACK_TYPE_NIL_HPP__
-
-#include "msgpack/object.hpp"
-
-namespace msgpack {
-
-namespace type {
-
-struct nil { };
-
-}  // namespace type
-
-
-inline type::nil& operator>> (object o, type::nil& v)
-{
-	if(o.type != type::NIL) { throw type_error(); }
-	return v;
-}
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::nil& v)
-{
-	o.pack_nil();
-	return o;
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/nil.hpp */
-
--- a/cpp/type/raw.hpp
+++ b/cpp/type/raw.hpp
@ -1,103 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_TYPE_RAW_HPP__
-#define MSGPACK_TYPE_RAW_HPP__
-
-#include "msgpack/object.hpp"
-#include <string.h>
-#include <string>
-
-namespace msgpack {
-
-namespace type {
-
-struct raw_ref {
-	raw_ref() : size(0), ptr(NULL) {}
-	raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {}
-
-	uint32_t size;
-	const char* ptr;
-
-	std::string str() { return std::string(ptr, size); }
-
-	bool operator== (const raw_ref& x)
-	{
-		return size == x.size && memcmp(ptr, x.ptr, size) == 0;
-	}
-
-	bool operator!= (const raw_ref& x)
-	{
-		return !(*this != x);
-	}
-
-	bool operator< (const raw_ref& x)
-	{
-		if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; }
-		else { return size < x.size; }
-	}
-
-	bool operator> (const raw_ref& x)
-	{
-		if(size == x.size) { return memcmp(ptr, x.ptr, size) > 0; }
-		else { return size > x.size; }
-	}
-};
-
-}  // namespace type
-
-
-inline type::raw_ref& operator>> (object o, type::raw_ref& v)
-{
-	if(o.type != type::RAW) { throw type_error(); }
-	v.ptr  = o.via.raw.ptr;
-	v.size = o.via.raw.size;
-	return v;
-}
-
-
-inline std::string& operator>> (object o, std::string& v)
-{
-	type::raw_ref r;
-	o >> r;
-	v.assign(r.ptr, r.size);
-	return v;
-}
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::raw_ref& v)
-{
-	o.pack_raw(v.size);
-	o.pack_raw_body(v.ptr, v.size);
-	return o;
-}
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
-{
-	o.pack_raw(v.size());
-	o.pack_raw_body(v.data(), v.size());
-	return o;
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/raw.hpp */
-
--- a/cpp/type/tuple.hpp.erb
+++ b/cpp/type/tuple.hpp.erb
@ -1,170 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2009 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_TYPE_TUPLE_HPP__
-#define MSGPACK_TYPE_TUPLE_HPP__
-
-#include "msgpack/object.hpp"
-
-namespace msgpack {
-
-namespace type {
-
-// FIXME operator==
-// FIXME operator!=
-<% GENERATION_LIMIT = 15 %>
-
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct tuple;
-
-template <typename Tuple, int N>
-struct tuple_element;
-
-template <typename Tuple, int N>
-struct const_tuple_element;
-
-template <typename T>
-struct tuple_type {
-	typedef T type;
-	typedef T value_type;
-	typedef T& reference;
-	typedef const T& const_reference;
-	typedef const T& transparent_reference;
-};
-
-template <typename T>
-struct tuple_type<T&> {
-	typedef T type;
-	typedef T& value_type;
-	typedef T& reference;
-	typedef const T& const_reference;
-	typedef T& transparent_reference;
-};
-
-template <typename T>
-struct tuple_type<const T&> {
-	typedef T type;
-	typedef T& value_type;
-	typedef T& reference;
-	typedef const T& const_reference;
-	typedef const T& transparent_reference;
-};
-
-
-<%0.upto(GENERATION_LIMIT) {|i|%>
-<%0.upto(i) {|j|%>
-template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
-struct tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
-	tuple_element(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : _x(x.a<%=j%>) {}
-	typename tuple_type<A<%=j%>>::reference get() { return _x; }
-	typename tuple_type<A<%=j%>>::const_reference get() const { return _x; }
-private:
-	typename tuple_type<A<%=j%>>::reference _x;
-};
-<%}%>
-<%}%>
-
-
-<%0.upto(GENERATION_LIMIT) {|i|%>
-<%0.upto(i) {|j|%>
-template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
-struct const_tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
-	const_tuple_element(const tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>& x) : _x(x.a<%=j%>) {}
-	typename tuple_type<A<%=j%>>::const_reference get() const { return _x; }
-private:
-	typename tuple_type<A<%=j%>>::const_reference _x;
-};
-<%}%>
-<%}%>
-
-
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
-{
-	return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
-}
-<%}%>
-
-
-template <>
-struct tuple<> {
-};
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
-	typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
-	tuple() {}
-	tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
-		a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
-	tuple(object o) { o.convert(this); }
-	template <int N> typename tuple_element<value_type, N>::reference get()
-		{ return tuple_element<value_type, N>(*this).get(); }
-	template <int N> typename const_tuple_element<value_type, N>::const_reference get() const
-		{ return const_tuple_element<value_type, N>(*this).get(); }
-	<%0.upto(i) {|j|%>
-	A<%=j%> a<%=j%>;<%}%>
-};
-<%}%>
-
-}  // namespace type
-
-
-inline type::tuple<>& operator>> (
-		object o,
-		type::tuple<>& v) {
-	if(o.type != type::ARRAY) { throw type_error(); }
-	return v;
-}
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& operator>> (
-		object o,
-		type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
-	if(o.type != type::ARRAY) { throw type_error(); }
-	if(o.via.array.size < <%=i+1%>) { throw type_error(); }
-	<%0.upto(i) {|j|%>
-	o.via.array.ptr[<%=j%>].convert<A<%=j%>>(&v.template get<<%=j%>>());<%}%>
-	return v;
-}
-<%}%>
-
-
-template <typename Stream>
-const packer<Stream>& operator<< (
-		packer<Stream>& o,
-		const type::tuple<>& v) {
-	o.pack_array(0);
-	return o;
-}
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename Stream, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-const packer<Stream>& operator<< (
-		packer<Stream>& o,
-		const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
-	o.pack_array(<%=i+1%>);
-	<%0.upto(i) {|j|%>
-	o.pack(v.template get<<%=j%>>());<%}%>
-	return o;
-}
-<%}%>
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/tuple.hpp */
-
--- a/cpp/unpack.hpp
+++ b/cpp/unpack.hpp
@ -1,301 +0,0 @@
-//
-// MessagePack for C++ deserializing routine
-//
-// Copyright (C) 2008-2009 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_UNPACK_HPP__
-#define MSGPACK_UNPACK_HPP__
-
-#include "msgpack/unpack.h"
-#include "msgpack/object.hpp"
-#include "msgpack/zone.hpp"
-#include <memory>
-#include <stdexcept>
-
-#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE
-#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE (32*1024)
-#endif
-
-namespace msgpack {
-
-
-struct unpack_error : public std::runtime_error {
-	unpack_error(const std::string& msg) :
-		std::runtime_error(msg) { }
-};
-
-
-class unpacker : public msgpack_unpacker {
-public:
-	unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE);
-	~unpacker();
-
-public:
-	/*! 1. reserve buffer. at least `size' bytes of capacity will be ready */
-	void reserve_buffer(size_t size);
-
-	/*! 2. read data to the buffer() up to buffer_capacity() bytes */
-	char* buffer();
-	size_t buffer_capacity() const;
-
-	/*! 3. specify the number of bytes actually copied */
-	void buffer_consumed(size_t size);
-
-	/*! 4. repeat execute() until it retunrs false */
-	bool execute();
-
-	/*! 5.1. if execute() returns true, take out the parsed object */
-	object data();
-
-	/*! 5.2. the object is valid until the zone is deleted */
-	// Note that once release_zone() from unpacker, you must delete it
-	// otherwise the memrory will leak.
-	zone* release_zone();
-
-	/*! 5.2. this method is equivalence to `delete release_zone()` */
-	void reset_zone();
-
-	/*! 5.3. after release_zone(), re-initialize unpacker */
-	void reset();
-
-	/*! 6. check if the size of message doesn't exceed assumption. */
-	size_t message_size() const;
-
-
-	// Basic usage of the unpacker is as following:
-	//
-	// msgpack::unpacker pac;
-	//
-	// while( /* readable */ ) {
-	//
-	//     // 1.
-	//     pac.reserve(1024);
-	//
-	//     // 2.
-	//     ssize_t bytes =
-	//         read(the_source, pac.buffer(), pac.buffer_capacity());
-	//
-	//     // error handling ...
-	//
-	//     // 3.
-	//     pac.buffer_consumed(bytes);
-	//
-	//     // 4.
-	//     while(pac.execute()) {
-	//         // 5.1
-	//         object o = pac.data();
-	//
-	//         // 5.2
-	//         std::auto_ptr<msgpack::zone> olife( pac.release_zone() );
-	//
-	//         // boost::shared_ptr is also usable:
-	//         // boost::shared_ptr<msgpack::zone> olife( pac.release_zone() );
-	//
-	//         // 5.3
-	//         pac.reset();
-	//
-	//         // do some with the object with the old zone.
-	//         do_something(o, olife);
-	//     }
-	// }
-	//
-
-public:
-	// These functions are usable when non-MessagePack message follows after
-	// MessagePack message.
-	size_t parsed_size() const;
-
-	/*! get address of the buffer that is not parsed */
-	char* nonparsed_buffer();
-	size_t nonparsed_size() const;
-
-	/*! skip specified size of non-parsed buffer, leaving the buffer */
-	// Note that the `size' argument must be smaller than nonparsed_size()
-	void skip_nonparsed_buffer(size_t size);
-
-	/*! remove unparsed buffer from unpacker */
-	// Note that reset() leaves non-parsed buffer.
-	void remove_nonparsed_buffer();
-
-private:
-	typedef msgpack_unpacker base;
-
-private:
-	unpacker(const unpacker&);
-};
-
-
-typedef enum {
-	UNPACK_SUCCESS				=  2,
-	UNPACK_EXTRA_BYTES			=  1,
-	UNPACK_CONTINUE				=  0,
-	UNPACK_PARSE_ERROR			= -1,
-} unpack_return;
-
-static unpack_return unpack(const char* data, size_t len, size_t* off,
-		zone* z, object* result);
-
-
-// obsolete
-static object unpack(const char* data, size_t len, zone& z, size_t* off = NULL);
-
-
-inline unpacker::unpacker(size_t initial_buffer_size)
-{
-	if(!msgpack_unpacker_init(this, initial_buffer_size)) {
-		throw std::bad_alloc();
-	}
-}
-
-inline unpacker::~unpacker()
-{
-	msgpack_unpacker_destroy(this);
-}
-
-
-inline void unpacker::reserve_buffer(size_t size)
-{
-	if(!msgpack_unpacker_reserve_buffer(this, size)) {
-		throw std::bad_alloc();
-	}
-}
-
-inline char* unpacker::buffer()
-{
-	return msgpack_unpacker_buffer(this);
-}
-
-inline size_t unpacker::buffer_capacity() const
-{
-	return msgpack_unpacker_buffer_capacity(this);
-}
-
-inline void unpacker::buffer_consumed(size_t size)
-{
-	return msgpack_unpacker_buffer_consumed(this, size);
-}
-
-
-inline bool unpacker::execute()
-{
-	int ret = msgpack_unpacker_execute(this);
-	if(ret < 0) {
-		throw unpack_error("parse error");
-	} else if(ret == 0) {
-		return false;
-	} else {
-		return true;
-	}
-}
-
-inline object unpacker::data()
-{
-	return msgpack_unpacker_data(this);
-}
-
-inline zone* unpacker::release_zone()
-{
-	if(!msgpack_unpacker_flush_zone(this)) {
-		throw std::bad_alloc();
-	}
-
-	zone* r = new zone();
-
-	msgpack_zone old = *base::z;
-	*base::z = *r;
-	*static_cast<msgpack_zone*>(r) = old;
-
-	return r;
-}
-
-inline void unpacker::reset_zone()
-{
-	msgpack_unpacker_reset_zone(this);
-}
-
-inline void unpacker::reset()
-{
-	msgpack_unpacker_reset(this);
-}
-
-inline size_t unpacker::message_size() const
-{
-	return msgpack_unpacker_message_size(this);
-}
-
-
-inline size_t unpacker::parsed_size() const
-{
-	return msgpack_unpacker_parsed_size(this);
-}
-
-inline char* unpacker::nonparsed_buffer()
-{
-	return base::buffer + base::off;
-}
-
-inline size_t unpacker::nonparsed_size() const
-{
-	return base::used - base::off;
-}
-
-inline void unpacker::skip_nonparsed_buffer(size_t size)
-{
-	base::off += size;
-}
-
-inline void unpacker::remove_nonparsed_buffer()
-{
-	base::used = base::off;
-}
-
-
-inline unpack_return unpack(const char* data, size_t len, size_t* off,
-		zone* z, object* result)
-{
-	return (unpack_return)msgpack_unpack(data, len, off,
-			z, reinterpret_cast<msgpack_object*>(result));
-}
-
-// obsolete
-inline object unpack(const char* data, size_t len, zone& z, size_t* off)
-{
-	object result;
-
-	switch( msgpack::unpack(data, len, off, &z, &result) ) {
-	case UNPACK_SUCCESS:
-		return result;
-
-	case UNPACK_EXTRA_BYTES:
-		if(off) {
-			return result;
-		} else {
-			throw unpack_error("extra bytes");
-		}
-
-	case UNPACK_CONTINUE:
-		throw unpack_error("insufficient bytes");
-
-	case UNPACK_PARSE_ERROR:
-	default:
-		throw unpack_error("parse error");
-	}
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/unpack.hpp */
-
--- a/cpp/vrefbuffer.hpp
+++ b/cpp/vrefbuffer.hpp
@ -1,85 +0,0 @@
-//
-// MessagePack for C++ zero-copy buffer implementation
-//
-// Copyright (C) 2008-2009 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_VREFBUFFER_HPP__
-#define MSGPACK_VREFBUFFER_HPP__
-
-#include "msgpack/vrefbuffer.h"
-#include <stdexcept>
-
-namespace msgpack {
-
-
-class vrefbuffer : public msgpack_vrefbuffer {
-public:
-	vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE,
-			size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE)
-	{
-		msgpack_vrefbuffer_init(this, ref_size, chunk_size);
-	}
-
-	~vrefbuffer()
-	{
-		msgpack_vrefbuffer_destroy(this);
-	}
-
-public:
-	void write(const char* buf, unsigned int len)
-	{
-		if(len < base::ref_size) {
-			append_copy(buf, len);
-		} else {
-			append_ref(buf, len);
-		}
-	}
-
-	void append_ref(const char* buf, size_t len)
-	{
-		if(msgpack_vrefbuffer_append_ref(this, buf, len) < 0) {
-			throw std::bad_alloc();
-		}
-	}
-
-	void append_copy(const char* buf, size_t len)
-	{
-		if(msgpack_vrefbuffer_append_copy(this, buf, len) < 0) {
-			throw std::bad_alloc();
-		}
-	}
-
-	const struct iovec* vector() const
-	{
-		return msgpack_vrefbuffer_vec(this);
-	}
-
-	size_t vector_size() const
-	{
-		return msgpack_vrefbuffer_veclen(this);
-	}
-
-private:
-	typedef msgpack_vrefbuffer base;
-
-private:
-	vrefbuffer(const vrefbuffer&);
-};
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/vrefbuffer.hpp */
-
--- a/cpp/zone.hpp.erb
+++ b/cpp/zone.hpp.erb
@ -1,137 +0,0 @@
-//
-// MessagePack for C++ memory pool
-//
-// Copyright (C) 2008-2009 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_ZONE_HPP__
-#define MSGPACK_ZONE_HPP__
-
-#include "msgpack/object.hpp"
-#include "msgpack/zone.h"
-#include <cstdlib>
-#include <vector>
-
-<% GENERATION_LIMIT = 15 %>
-namespace msgpack {
-
-
-class zone : public msgpack_zone {
-public:
-	zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE);
-	~zone();
-
-public:
-	void* malloc(size_t size);
-	void* malloc_no_align(size_t size);
-
-	void push_finalizer(void (*func)(void*), void* data);
-
-	void clear();
-
-	<%0.upto(GENERATION_LIMIT) {|i|%>
-	template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-	T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>);
-	<%}%>
-
-private:
-	void undo_malloc(size_t size);
-
-	template <typename T>
-	static void object_destructor(void* obj);
-
-	typedef msgpack_zone base;
-
-private:
-	zone(const zone&);
-};
-
-
-
-inline zone::zone(size_t chunk_size)
-{
-	msgpack_zone_init(this, chunk_size);
-}
-
-inline zone::~zone()
-{
-	msgpack_zone_destroy(this);
-}
-
-inline void* zone::malloc(size_t size)
-{
-	void* ptr = msgpack_zone_malloc(this, size);
-	if(!ptr) {
-		throw std::bad_alloc();
-	}
-	return ptr;
-}
-
-inline void* zone::malloc_no_align(size_t size)
-{
-	void* ptr = msgpack_zone_malloc_no_align(this, size);
-	if(!ptr) {
-		throw std::bad_alloc();
-	}
-	return ptr;
-}
-
-inline void zone::push_finalizer(void (*func)(void*), void* data)
-{
-	if(!msgpack_zone_push_finalizer(this, func, data)) {
-		throw std::bad_alloc();
-	}
-}
-
-inline void zone::clear()
-{
-	msgpack_zone_clear(this);
-}
-
-template <typename T>
-void zone::object_destructor(void* obj)
-{
-	reinterpret_cast<T*>(obj)->~T();
-}
-
-inline void zone::undo_malloc(size_t size)
-{
-	msgpack_zone_chunk* chunk = base::chunk_array.tail;
-	chunk->ptr  -= size;
-	chunk->free += size;
-}
-
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
-{
-	void* x = malloc(sizeof(T));
-	if(!msgpack_zone_push_finalizer(this, &zone::object_destructor<T>, x)) {
-		undo_malloc(sizeof(T));
-		throw std::bad_alloc();
-	}
-	try {
-		return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>);
-	} catch (...) {
-		--base::finalizer_array.tail;
-		undo_malloc(sizeof(T));
-		throw;
-	}
-}
-<%}%>
-
-}  // namespace msgpack
-
-#endif /* msgpack/zone.hpp */
-
--- a/example/protocol.cc
+++ b/example/protocol.cc
@ -1,86 +0,0 @@
-#include <msgpack.hpp>
-#include <string>
-#include <iostream>
-#include <sstream>
-
-namespace myprotocol {
-	using namespace msgpack::type;
-	using msgpack::define;
-
-	struct Get : define< tuple<uint32_t, std::string> > {
-		Get() { }
-		Get(uint32_t f, const std::string& k) :
-			define_type(msgpack_type(f, k)) { }
-		uint32_t&    flags() { return get<0>(); }
-		std::string& key()   { return get<1>(); }
-	};
-
-	struct Put : define< tuple<uint32_t, std::string, raw_ref> > {
-		Put() { }
-		Put(uint32_t f, const std::string& k, const char* valref, size_t vallen) :
-			define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { }
-		uint32_t&    flags() { return get<0>(); }
-		std::string& key()   { return get<1>(); }
-		raw_ref&     value() { return get<2>(); }
-	};
-
-	struct MultiGet : define< std::vector<Get> > {
-	};
-}
-
-
-int main(void)
-{
-	// send Get request
-	std::stringstream stream;
-	{
-		myprotocol::Get req;
-		req.flags() = 0;
-		req.key()   = "key0";
-		msgpack::pack(stream, req);
-	}
-
-	stream.seekg(0);
-
-	// receive Get request
-	{
-		std::string buffer(stream.str());
-
-		msgpack::zone mempool;
-		msgpack::object o =
-			msgpack::unpack(buffer.data(), buffer.size(), mempool);
-
-		myprotocol::Get req;
-		msgpack::convert(req, o);
-		std::cout << "received: " << o << std::endl;
-	}
-
-
-	stream.str("");
-
-
-	// send MultiGet request
-	{
-		myprotocol::MultiGet req;
-		req.push_back( myprotocol::Get(1, "key1") );
-		req.push_back( myprotocol::Get(2, "key2") );
-		req.push_back( myprotocol::Get(3, "key3") );
-		msgpack::pack(stream, req);
-	}
-
-	stream.seekg(0);
-
-	// receive MultiGet request
-	{
-		std::string buffer(stream.str());
-
-		msgpack::zone mempool;
-		msgpack::object o =
-			msgpack::unpack(buffer.data(), buffer.size(), mempool);
-
-		myprotocol::MultiGet req;
-		msgpack::convert(req, o);
-		std::cout << "received: " << o << std::endl;
-	}
-}
-
--- a/example/simple.c
+++ b/example/simple.c
@ -1,37 +0,0 @@
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void)
-{
-	/* msgpack::sbuffer is a simple buffer implementation. */
-	msgpack_sbuffer sbuf;
-	msgpack_sbuffer_init(&sbuf);
-
-	/* serialize values into the buffer using msgpack_sbuffer_write callback function. */
-	msgpack_packer pk;
-	msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
-
-	msgpack_pack_array(&pk, 3);
-	msgpack_pack_int(&pk, 1);
-	msgpack_pack_true(&pk);
-	msgpack_pack_raw(&pk, 7);
-	msgpack_pack_raw_body(&pk, "example", 7);
-
-	/* deserialize the buffer into msgpack_object instance. */
-	/* deserialized object is valid during the msgpack_zone instance alive. */
-	msgpack_zone mempool;
-	msgpack_zone_init(&mempool, 2048);
-
-	msgpack_object deserialized;
-	msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
-
-	/* print the deserialized object. */
-	msgpack_object_print(stdout, deserialized);
-	puts("");
-
-	msgpack_zone_destroy(&mempool);
-	msgpack_sbuffer_destroy(&sbuf);
-
-	return 0;
-}
-
--- a/example/simple.cc
+++ b/example/simple.cc
@ -1,37 +0,0 @@
-#include <msgpack.hpp>
-#include <string>
-#include <iostream>
-#include <sstream>
-
-int main(void)
-{
-	msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
-
-	// serialize the object into the buffer.
-	// any classes that implements write(const char*,size_t) can be a buffer.
-	std::stringstream buffer;
-	msgpack::pack(buffer, src);
-
-	// send the buffer ...
-	buffer.seekg(0);
-
-	// deserialize the buffer into msgpack::object instance.
-	std::string str(buffer.str());
-
-	// deserialized object is valid during the msgpack::zone instance alive.
-	msgpack::zone mempool;
-
-	msgpack::object deserialized;
-	msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized);
-
-	// msgpack::object supports ostream.
-	std::cout << deserialized << std::endl;
-
-	// convert msgpack::object instance into the original type.
-	// if the type is mismatched, it throws msgpack::type_error exception.
-	msgpack::type::tuple<int, bool, std::string> dst;
-	deserialized.convert(&dst);
-
-	return 0;
-}
-
--- a/example/simple.rb
+++ b/example/simple.rb
@ -1,5 +0,0 @@
-require 'msgpack'
-
-serialized = [1, -1, true, false, nil, {"key" => "value"}].to_msgpack
-p MessagePack.unpack(serialized)
-
--- a/example/stream.cc
+++ b/example/stream.cc
@ -1,136 +0,0 @@
-#include <msgpack.hpp>
-#include <iostream>
-#include <stdexcept>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <errno.h>
-#include <pthread.h>
-
-class Server {
-public:
-	Server(int sock) : m_sock(sock) { }
-
-	~Server() { }
-
-	typedef std::auto_ptr<msgpack::zone> auto_zone;
-
-	void socket_readable()
-	{
-		m_pac.reserve_buffer(1024);
-
-		ssize_t count =
-			read(m_sock, m_pac.buffer(), m_pac.buffer_capacity());
-
-		if(count < 0) {
-			if(errno == EAGAIN || errno == EINTR) {
-				return;
-			} else {
-				throw std::runtime_error(strerror(errno));
-			}
-		} else if(count == 0) {
-			throw std::runtime_error("connection closed");
-		}
-
-		m_pac.buffer_consumed(count);
-
-		while(m_pac.execute()) {
-			msgpack::object msg = m_pac.data();
-
-			auto_zone life( m_pac.release_zone() );
-
-			m_pac.reset();
-
-			process_message(msg, life);
-		}
-
-		if(m_pac.message_size() > 10*1024*1024) {
-			throw std::runtime_error("message is too large");
-		}
-	}
-
-private:
-	void process_message(msgpack::object msg, auto_zone& life)
-	{
-		std::cout << "message reached: " << msg << std::endl;
-	}
-
-private:
-	int m_sock;
-	msgpack::unpacker m_pac;
-};
-
-
-static void* run_server(void* arg)
-try {
-	Server* srv = reinterpret_cast<Server*>(arg);
-
-	while(true) {
-		srv->socket_readable();
-	}
-	return NULL;
-
-} catch (std::exception& e) {
-	std::cerr << "error while processing client packet: "
-		<< e.what() << std::endl;
-	return NULL;
-
-} catch (...) {
-	std::cerr << "error while processing client packet: "
-		<< "unknown error" << std::endl;
-	return NULL;
-}
-
-
-struct fwriter {
-	fwriter(int fd) : m_fp( fdopen(fd, "w") ) { }
-
-	void write(const char* buf, size_t buflen)
-	{
-		size_t count = fwrite(buf, buflen, 1, m_fp);
-		if(count < 1) {
-			std::cout << buflen << std::endl;
-			std::cout << count << std::endl;
-			throw std::runtime_error(strerror(errno));
-		}
-	}
-
-	void flush() { fflush(m_fp); }
-
-	void close() { fclose(m_fp); }
-
-private:
-	FILE* m_fp;
-};
-
-
-int main(void)
-{
-	int pair[2];
-	pipe(pair);
-
-	// run server thread
-	Server srv(pair[0]);
-	pthread_t thread;
-	pthread_create(&thread, NULL,
-			run_server, reinterpret_cast<void*>(&srv));
-
-	// client thread:
-	fwriter writer(pair[1]);
-	msgpack::packer<fwriter> pk(writer);
-
-	typedef msgpack::type::tuple<std::string, std::string, std::string> put_t;
-	typedef msgpack::type::tuple<std::string, std::string> get_t;
-
-	put_t req1("put", "apple", "red");
-	put_t req2("put", "lemon", "yellow");
-	get_t req3("get", "apple");
-	pk.pack(req1);
-	pk.pack(req2);
-	pk.pack(req3);
-	writer.flush();
-	writer.close();
-
-	pthread_join(thread, NULL);
-}
-
--- a/example/stream.rb
+++ b/example/stream.rb
@ -1,72 +0,0 @@
-require 'msgpack'
-
-class Server
-	def initialize(sock)
-		@sock = sock
-		@pk = MessagePack::Unpacker.new
-		@buffer = ''
-		@nread = 0
-	end
-
-	def run
-		while true
-			begin
-				data = @sock.sysread(1024)
-			rescue
-				puts "connection closed (#{$!})"
-				return
-			end
-			receive_data(data)
-		end
-	end
-
-	private
-	def receive_data(data)
-		@buffer << data
-
-		while true
-			@nread = @pk.execute(@buffer, @nread)
-
-			if @pk.finished?
-				msg = @pk.data
-				process_message(msg)
-
-				@pk.reset
-				@buffer.slice!(0, @nread)
-				@nread = 0
-
-				next unless @buffer.empty?
-			end
-
-			break
-		end
-
-		if @buffer.length > 10*1024*1024
-			raise "message is too large"
-		end
-
-	rescue
-		puts "error while processing client packet: #{$!}"
-	end
-
-	def process_message(msg)
-		puts "message reached: #{msg.inspect}"
-	end
-end
-
-
-rpipe, wpipe = IO.pipe
-
-# run server thread
-thread = Thread.new(Server.new(rpipe)) {|srv|
-	srv.run
-}
-
-# client thread:
-wpipe.write ["put", "apple", "red"].to_msgpack
-wpipe.write ["put", "lemon", "yellow"].to_msgpack
-wpipe.write ["get", "apple"].to_msgpack
-wpipe.close
-
-thread.join
-
--- a/msgpack/pack_define.h
+++ b/msgpack/pack_define.h
@ -1,26 +0,0 @@
-/*
- * MessagePack unpacking routine template
- *
- * Copyright (C) 2008-2009 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_PACK_DEFINE_H__
-#define MSGPACK_PACK_DEFINE_H__
-
-#include <stddef.h>
-#include <stdint.h>
-#include <limits.h>
-
-#endif /* msgpack/pack_define.h */
-
--- a/msgpack/pack_template.h
+++ b/msgpack/pack_template.h
@ -1,741 +0,0 @@
-/*
- * MessagePack packing routine template
- *
- * Copyright (C) 2008-2009 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.
- */
-
-#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __LITTLE_ENDIAN__
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define __BIG_ENDIAN__
-#endif
-#endif
-
-
-#ifdef __LITTLE_ENDIAN__
-
-#define STORE8_BE8(d) \
-	((uint8_t*)&d)[0]
-
-
-#define STORE16_BE8(d) \
-	((uint8_t*)&d)[0]
-
-#define STORE16_BE16(d) \
-	((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-
-#define STORE32_BE8(d) \
-	((uint8_t*)&d)[0]
-
-#define STORE32_BE16(d) \
-	((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-#define STORE32_BE32(d) \
-	((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-
-#define STORE64_BE8(d) \
-	((uint8_t*)&d)[0]
-
-#define STORE64_BE16(d) \
-	((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-#define STORE64_BE32(d) \
-	((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-#define STORE64_BE64(d) \
-	((uint8_t*)&d)[7], ((uint8_t*)&d)[6], ((uint8_t*)&d)[5], ((uint8_t*)&d)[4], \
-	((uint8_t*)&d)[3], ((uint8_t*)&d)[2], ((uint8_t*)&d)[1], ((uint8_t*)&d)[0]
-
-
-#elif __BIG_ENDIAN__
-
-#define STORE8_BE8(d) \
-	((uint8_t*)&d)[0]
-
-
-#define STORE16_BE8(d) \
-	((uint8_t*)&d)[1]
-
-#define STORE16_BE16(d) \
-	((uint8_t*)&d)[0], ((uint8_t*)&d)[1]
-
-
-#define STORE32_BE8(d) \
-	((uint8_t*)&d)[3]
-
-#define STORE32_BE16(d) \
-	((uint8_t*)&d)[2], ((uint8_t*)&d)[3]
-
-#define STORE32_BE32(d) \
-	((uint8_t*)&d)[0], ((uint8_t*)&d)[1], ((uint8_t*)&d)[2], ((uint8_t*)&d)[3]
-
-
-#define STORE64_BE8(d) \
-	((uint8_t*)&d)[7]
-
-#define STORE64_BE16(d) \
-	((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
-
-#define STORE64_BE32(d) \
-	((uint8_t*)&d)[4], ((uint8_t*)&d)[5], ((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
-
-#define STORE64_BE64(d) \
-	((uint8_t*)&d)[0], ((uint8_t*)&d)[1], ((uint8_t*)&d)[2], ((uint8_t*)&d)[3], \
-	((uint8_t*)&d)[4], ((uint8_t*)&d)[5], ((uint8_t*)&d)[6], ((uint8_t*)&d)[7]
-
-#endif
-
-#ifndef msgpack_pack_inline_func
-#error msgpack_pack_inline_func template is not defined
-#endif
-
-#ifndef msgpack_pack_user
-#error msgpack_pack_user type is not defined
-#endif
-
-#ifndef msgpack_pack_append_buffer
-#error msgpack_pack_append_buffer callback is not defined
-#endif
-
-
-/*
- * Integer
- */
-
-#define msgpack_pack_real_uint8(x, d) \
-do { \
-	if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1); \
-	} else { \
-		/* unsigned 8 */ \
-		const unsigned char buf[2] = {0xcc, STORE8_BE8(d)}; \
-		msgpack_pack_append_buffer(x, buf, 2); \
-	} \
-} while(0)
-
-#define msgpack_pack_real_uint16(x, d) \
-do { \
-	if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE16_BE8(d), 1); \
-	} else if(d < (1<<8)) { \
-		/* unsigned 8 */ \
-		const unsigned char buf[2] = {0xcc, STORE16_BE8(d)}; \
-		msgpack_pack_append_buffer(x, buf, 2); \
-	} else { \
-		/* unsigned 16 */ \
-		const unsigned char buf[3] = {0xcd, STORE16_BE16(d)}; \
-		msgpack_pack_append_buffer(x, buf, 3); \
-	} \
-} while(0)
-
-#define msgpack_pack_real_uint32(x, d) \
-do { \
-	if(d < (1<<8)) { \
-		if(d < (1<<7)) { \
-			/* fixnum */ \
-			msgpack_pack_append_buffer(x, &STORE32_BE8(d), 1); \
-		} else { \
-			/* unsigned 8 */ \
-			const unsigned char buf[2] = {0xcc, STORE32_BE8(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else { \
-		if(d < (1<<16)) { \
-			/* unsigned 16 */ \
-			const unsigned char buf[3] = {0xcd, STORE32_BE16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* unsigned 32 */ \
-			const unsigned char buf[5] = {0xce, STORE32_BE32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} \
-	} \
-} while(0)
-
-#define msgpack_pack_real_uint64(x, d) \
-do { \
-	if(d < (1ULL<<8)) { \
-		if(d < (1<<7)) { \
-			/* fixnum */ \
-			msgpack_pack_append_buffer(x, &STORE64_BE8(d), 1); \
-		} else { \
-			/* unsigned 8 */ \
-			const unsigned char buf[2] = {0xcc, STORE64_BE8(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else { \
-		if(d < (1ULL<<16)) { \
-			/* signed 16 */ \
-			const unsigned char buf[3] = {0xcd, STORE64_BE16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else if(d < (1ULL<<32)) { \
-			/* signed 32 */ \
-			const unsigned char buf[5] = {0xce, STORE64_BE32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} else { \
-			/* signed 64 */ \
-			const unsigned char buf[9] = {0xcf, STORE64_BE64(d)}; \
-			msgpack_pack_append_buffer(x, buf, 9); \
-		} \
-	} \
-} while(0)
-
-#define msgpack_pack_real_int8(x, d) \
-do { \
-	if(d < -(1<<5)) { \
-		/* signed 8 */ \
-		const unsigned char buf[2] = {0xd0, STORE8_BE8(d)}; \
-		msgpack_pack_append_buffer(x, buf, 2); \
-	} else { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1); \
-	} \
-} while(0)
-
-#define msgpack_pack_real_int16(x, d) \
-do { \
-	if(d < -(1<<5)) { \
-		if(d < -(1<<7)) { \
-			/* signed 16 */ \
-			const unsigned char buf[3] = {0xd1, STORE16_BE16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* signed 8 */ \
-			const unsigned char buf[2] = {0xd0, STORE16_BE8(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE16_BE8(d), 1); \
-	} else { \
-		if(d < (1<<8)) { \
-			/* unsigned 8 */ \
-			const unsigned char buf[2] = {0xcc, STORE16_BE8(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} else { \
-			/* unsigned 16 */ \
-			const unsigned char buf[3] = {0xcd, STORE16_BE16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} \
-	} \
-} while(0)
-
-#define msgpack_pack_real_int32(x, d) \
-do { \
-	if(d < -(1<<5)) { \
-		if(d < -(1<<15)) { \
-			/* signed 32 */ \
-			const unsigned char buf[5] = {0xd2, STORE32_BE32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} else if(d < -(1<<7)) { \
-			/* signed 16 */ \
-			const unsigned char buf[3] = {0xd1, STORE32_BE16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* signed 8 */ \
-			const unsigned char buf[2] = {0xd0, STORE32_BE8(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE32_BE8(d), 1); \
-	} else { \
-		if(d < (1<<8)) { \
-			/* unsigned 8 */ \
-			const unsigned char buf[2] = {0xcc, STORE32_BE8(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} else if(d < (1<<16)) { \
-			/* unsigned 16 */ \
-			const unsigned char buf[3] = {0xcd, STORE32_BE16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* unsigned 32 */ \
-			const unsigned char buf[5] = {0xce, STORE32_BE32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} \
-	} \
-} while(0)
-
-#define msgpack_pack_real_int64(x, d) \
-do { \
-	if(d < -(1LL<<5)) { \
-		if(d < -(1LL<<15)) { \
-			if(d < -(1LL<<31)) { \
-				/* signed 64 */ \
-				const unsigned char buf[9] = {0xd3, STORE64_BE64(d)}; \
-				msgpack_pack_append_buffer(x, buf, 9); \
-			} else { \
-				/* signed 32 */ \
-				const unsigned char buf[5] = {0xd2, STORE64_BE32(d)}; \
-				msgpack_pack_append_buffer(x, buf, 5); \
-			} \
-		} else { \
-			if(d < -(1<<7)) { \
-				/* signed 16 */ \
-				const unsigned char buf[3] = {0xd1, STORE64_BE16(d)}; \
-				msgpack_pack_append_buffer(x, buf, 3); \
-			} else { \
-				/* signed 8 */ \
-				const unsigned char buf[2] = {0xd0, STORE64_BE8(d)}; \
-				msgpack_pack_append_buffer(x, buf, 2); \
-			} \
-		} \
-	} else if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &STORE64_BE8(d), 1); \
-	} else { \
-		if(d < (1LL<<16)) { \
-			if(d < (1<<8)) { \
-				/* unsigned 8 */ \
-				const unsigned char buf[2] = {0xcc, STORE64_BE8(d)}; \
-				msgpack_pack_append_buffer(x, buf, 2); \
-			} else { \
-				/* unsigned 16 */ \
-				const unsigned char buf[3] = {0xcd, STORE64_BE16(d)}; \
-				msgpack_pack_append_buffer(x, buf, 3); \
-			} \
-		} else { \
-			if(d < (1LL<<32)) { \
-				/* unsigned 32 */ \
-				const unsigned char buf[5] = {0xce, STORE64_BE32(d)}; \
-				msgpack_pack_append_buffer(x, buf, 5); \
-			} else { \
-				/* unsigned 64 */ \
-				const unsigned char buf[9] = {0xcf, STORE64_BE64(d)}; \
-				msgpack_pack_append_buffer(x, buf, 9); \
-			} \
-		} \
-	} \
-} while(0)
-
-
-#ifdef msgpack_pack_inline_func_fastint
-
-msgpack_pack_inline_func_fastint(_uint8)(msgpack_pack_user x, uint8_t d)
-{
-	const unsigned char buf[2] = {0xcc, STORE8_BE8(d)};
-	msgpack_pack_append_buffer(x, buf, 2);
-}
-
-msgpack_pack_inline_func_fastint(_uint16)(msgpack_pack_user x, uint16_t d)
-{
-	const unsigned char buf[3] = {0xcd, STORE16_BE16(d)};
-	msgpack_pack_append_buffer(x, buf, 3);
-}
-
-msgpack_pack_inline_func_fastint(_uint32)(msgpack_pack_user x, uint32_t d)
-{
-	const unsigned char buf[5] = {0xce, STORE32_BE32(d)};
-	msgpack_pack_append_buffer(x, buf, 5);
-}
-
-msgpack_pack_inline_func_fastint(_uint64)(msgpack_pack_user x, uint64_t d)
-{
-	const unsigned char buf[9] = {0xcf, STORE64_BE64(d)};
-	msgpack_pack_append_buffer(x, buf, 9);
-}
-
-msgpack_pack_inline_func_fastint(_int8)(msgpack_pack_user x, int8_t d)
-{
-	const unsigned char buf[2] = {0xd0, STORE8_BE8(d)};
-	msgpack_pack_append_buffer(x, buf, 2);
-}
-
-msgpack_pack_inline_func_fastint(_int16)(msgpack_pack_user x, int16_t d)
-{
-	const unsigned char buf[3] = {0xd1, STORE16_BE16(d)};
-	msgpack_pack_append_buffer(x, buf, 3);
-}
-
-msgpack_pack_inline_func_fastint(_int32)(msgpack_pack_user x, int32_t d)
-{
-	const unsigned char buf[5] = {0xd2, STORE32_BE32(d)};
-	msgpack_pack_append_buffer(x, buf, 5);
-}
-
-msgpack_pack_inline_func_fastint(_int64)(msgpack_pack_user x, int64_t d)
-{
-	const unsigned char buf[9] = {0xd3, STORE64_BE64(d)};
-	msgpack_pack_append_buffer(x, buf, 9);
-}
-
-#undef msgpack_pack_inline_func_fastint
-#endif
-
-
-msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d)
-{
-	msgpack_pack_real_uint8(x, d);
-}
-
-msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d)
-{
-	msgpack_pack_real_uint16(x, d);
-}
-
-msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d)
-{
-	msgpack_pack_real_uint32(x, d);
-}
-
-msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d)
-{
-	msgpack_pack_real_uint64(x, d);
-}
-
-msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d)
-{
-	msgpack_pack_real_int8(x, d);
-}
-
-msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d)
-{
-	msgpack_pack_real_int16(x, d);
-}
-
-msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d)
-{
-	msgpack_pack_real_int32(x, d);
-}
-
-msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d)
-{
-	msgpack_pack_real_int64(x, d);
-}
-
-
-#ifdef msgpack_pack_inline_func_cint
-
-msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d)
-{
-#if defined(SIZEOF_SHORT) || defined(SHRT_MAX)
-#if SIZEOF_SHORT == 2 || SHRT_MAX == 0x7fff
-	msgpack_pack_real_int16(x, d);
-#elif SIZEOF_SHORT == 4 || SHRT_MAX == 0x7fffffff
-	msgpack_pack_real_int32(x, d);
-#else
-	msgpack_pack_real_int64(x, d);
-#endif
-#else
-if(sizeof(short) == 2) {
-	msgpack_pack_real_int16(x, d);
-} else if(sizeof(short) == 4) {
-	msgpack_pack_real_int32(x, d);
-} else {
-	msgpack_pack_real_int64(x, d);
-}
-#endif
-}
-
-msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d)
-{
-#if defined(SIZEOF_INT) || defined(INT_MAX)
-#if SIZEOF_INT == 2 || INT_MAX == 0x7fff
-	msgpack_pack_real_int16(x, d);
-#elif SIZEOF_INT == 4 || INT_MAX == 0x7fffffff
-	msgpack_pack_real_int32(x, d);
-#else
-	msgpack_pack_real_int64(x, d);
-#endif
-#else
-if(sizeof(int) == 2) {
-	msgpack_pack_real_int16(x, d);
-} else if(sizeof(int) == 4) {
-	msgpack_pack_real_int32(x, d);
-} else {
-	msgpack_pack_real_int64(x, d);
-}
-#endif
-}
-
-msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d)
-{
-#if defined(SIZEOF_LONG) || defined(LONG_MAX)
-#if SIZEOF_LONG == 2 || LONG_MAX == 0x7fffL
-	msgpack_pack_real_int16(x, d);
-#elif SIZEOF_LONG == 4 || LONG_MAX == 0x7fffffffL
-	msgpack_pack_real_int32(x, d);
-#else
-	msgpack_pack_real_int64(x, d);
-#endif
-#else
-if(sizeof(long) == 2) {
-	msgpack_pack_real_int16(x, d);
-} else if(sizeof(long) == 4) {
-	msgpack_pack_real_int32(x, d);
-} else {
-	msgpack_pack_real_int64(x, d);
-}
-#endif
-}
-
-msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d)
-{
-#if defined(SIZEOF_LONG_LONG) || defined(LLONG_MAX)
-#if SIZEOF_LONG_LONG == 2 || LLONG_MAX == 0x7fffL
-	msgpack_pack_real_int16(x, d);
-#elif SIZEOF_LONG_LONG == 4 || LLONG_MAX == 0x7fffffffL
-	msgpack_pack_real_int32(x, d);
-#else
-	msgpack_pack_real_int64(x, d);
-#endif
-#else
-if(sizeof(long long) == 2) {
-	msgpack_pack_real_int16(x, d);
-} else if(sizeof(long long) == 4) {
-	msgpack_pack_real_int32(x, d);
-} else {
-	msgpack_pack_real_int64(x, d);
-}
-#endif
-}
-
-msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned short d)
-{
-#if defined(SIZEOF_SHORT) || defined(USHRT_MAX)
-#if SIZEOF_SHORT == 2 || USHRT_MAX == 0xffffU
-	msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_SHORT == 4 || USHRT_MAX == 0xffffffffU
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-#else
-if(sizeof(unsigned short) == 2) {
-	msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned short) == 4) {
-	msgpack_pack_real_uint32(x, d);
-} else {
-	msgpack_pack_real_uint64(x, d);
-}
-#endif
-}
-
-msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d)
-{
-#if defined(SIZEOF_INT) || defined(UINT_MAX)
-#if SIZEOF_INT == 2 || UINT_MAX == 0xffffU
-	msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_INT == 4 || UINT_MAX == 0xffffffffU
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-#else
-if(sizeof(unsigned int) == 2) {
-	msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned int) == 4) {
-	msgpack_pack_real_uint32(x, d);
-} else {
-	msgpack_pack_real_uint64(x, d);
-}
-#endif
-}
-
-msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long d)
-{
-#if defined(SIZEOF_LONG) || defined(ULONG_MAX)
-#if SIZEOF_LONG == 2 || ULONG_MAX == 0xffffUL
-	msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_LONG == 4 || ULONG_MAX == 0xffffffffUL
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-#else
-if(sizeof(unsigned int) == 2) {
-	msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned int) == 4) {
-	msgpack_pack_real_uint32(x, d);
-} else {
-	msgpack_pack_real_uint64(x, d);
-}
-#endif
-}
-
-msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned long long d)
-{
-#if defined(SIZEOF_LONG_LONG) || defined(ULLONG_MAX)
-#if SIZEOF_LONG_LONG == 2 || ULLONG_MAX == 0xffffUL
-	msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_LONG_LONG == 4 || ULLONG_MAX == 0xffffffffUL
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-#else
-if(sizeof(unsigned long long) == 2) {
-	msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned long long) == 4) {
-	msgpack_pack_real_uint32(x, d);
-} else {
-	msgpack_pack_real_uint64(x, d);
-}
-#endif
-}
-
-#undef msgpack_pack_inline_func_cint
-#endif
-
-
-
-/*
- * Float
- */
-
-msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d)
-{
-	union { char buf[4]; uint32_t num; } f;
-	*((float*)&f.buf) = d;  // FIXME
-	const unsigned char buf[5] = {0xca, STORE32_BE32(f.num)};
-	msgpack_pack_append_buffer(x, buf, 5);
-}
-
-msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
-{
-	union { char buf[8]; uint64_t num; } f;
-	*((double*)&f.buf) = d;  // FIXME
-	const unsigned char buf[9] = {0xcb, STORE64_BE64(f.num)};
-	msgpack_pack_append_buffer(x, buf, 9);
-}
-
-
-/*
- * Nil
- */
-
-msgpack_pack_inline_func(_nil)(msgpack_pack_user x)
-{
-	static const unsigned char d = 0xc0;
-	msgpack_pack_append_buffer(x, &d, 1);
-}
-
-
-/*
- * Boolean
- */
-
-msgpack_pack_inline_func(_true)(msgpack_pack_user x)
-{
-	static const unsigned char d = 0xc3;
-	msgpack_pack_append_buffer(x, &d, 1);
-}
-
-msgpack_pack_inline_func(_false)(msgpack_pack_user x)
-{
-	static const unsigned char d = 0xc2;
-	msgpack_pack_append_buffer(x, &d, 1);
-}
-
-
-/*
- * Array
- */
-
-msgpack_pack_inline_func(_array)(msgpack_pack_user x, unsigned int n)
-{
-	if(n < 16) {
-		unsigned char d = 0x90 | n;
-		msgpack_pack_append_buffer(x, &d, 1);
-	} else if(n < 65536) {
-		uint16_t d = (uint16_t)n;
-		unsigned char buf[3] = {0xdc, STORE16_BE16(d)};
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		uint32_t d = (uint32_t)n;
-		unsigned char buf[5] = {0xdd, STORE32_BE32(d)};
-		msgpack_pack_append_buffer(x, buf, 5);
-	}
-}
-
-
-/*
- * Map
- */
-
-msgpack_pack_inline_func(_map)(msgpack_pack_user x, unsigned int n)
-{
-	if(n < 16) {
-		unsigned char d = 0x80 | n;
-		msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1);
-	} else if(n < 65536) {
-		uint16_t d = (uint16_t)n;
-		unsigned char buf[3] = {0xde, STORE16_BE16(d)};
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		uint32_t d = (uint32_t)n;
-		unsigned char buf[5] = {0xdf, STORE32_BE32(d)};
-		msgpack_pack_append_buffer(x, buf, 5);
-	}
-}
-
-
-/*
- * Raw
- */
-
-msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l)
-{
-	if(l < 32) {
-		unsigned char d = 0xa0 | l;
-		msgpack_pack_append_buffer(x, &STORE8_BE8(d), 1);
-	} else if(l < 65536) {
-		uint16_t d = (uint16_t)l;
-		unsigned char buf[3] = {0xda, STORE16_BE16(d)};
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		uint32_t d = (uint32_t)l;
-		unsigned char buf[5] = {0xdb, STORE32_BE32(d)};
-		msgpack_pack_append_buffer(x, buf, 5);
-	}
-}
-
-msgpack_pack_inline_func(_raw_body)(msgpack_pack_user x, const void* b, size_t l)
-{
-	msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
-}
-
-#undef msgpack_pack_inline_func
-#undef msgpack_pack_user
-#undef msgpack_pack_append_buffer
-
-#undef STORE8_BE8
-
-#undef STORE16_BE8
-#undef STORE16_BE16
-
-#undef STORE32_BE8
-#undef STORE32_BE16
-#undef STORE32_BE32
-
-#undef STORE64_BE8
-#undef STORE64_BE16
-#undef STORE64_BE32
-#undef STORE64_BE64
-
-#undef msgpack_pack_real_uint8
-#undef msgpack_pack_real_uint16
-#undef msgpack_pack_real_uint32
-#undef msgpack_pack_real_uint64
-#undef msgpack_pack_real_int8
-#undef msgpack_pack_real_int16
-#undef msgpack_pack_real_int32
-#undef msgpack_pack_real_int64
-
--- a/msgpack/unpack_define.h
+++ b/msgpack/unpack_define.h
@ -1,129 +0,0 @@
-/*
- * MessagePack unpacking routine template
- *
- * Copyright (C) 2008-2009 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_UNPACK_DEFINE_H__
-#define MSGPACK_UNPACK_DEFINE_H__
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-#include <assert.h>
-#include <stdio.h>
-#ifndef __WIN32__
-#include <arpa/inet.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#ifndef MSGPACK_MAX_STACK_SIZE
-#define MSGPACK_MAX_STACK_SIZE 16
-#endif
-
-
-#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __LITTLE_ENDIAN__
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define __BIG_ENDIAN__
-#endif
-#endif
-
-#define msgpack_betoh16(x) ntohs(x)
-#define msgpack_betoh32(x) ntohl(x)
-
-#ifdef __LITTLE_ENDIAN__
-#if defined(__bswap_64)
-#  define msgpack_betoh64(x) __bswap_64(x)
-#elif defined(__DARWIN_OSSwapInt64)
-#  define msgpack_betoh64(x) __DARWIN_OSSwapInt64(x)
-#else
-static inline uint64_t msgpack_betoh64(uint64_t x) {
-	return	((x << 56) & 0xff00000000000000ULL ) |
-			((x << 40) & 0x00ff000000000000ULL ) |
-			((x << 24) & 0x0000ff0000000000ULL ) |
-			((x <<  8) & 0x000000ff00000000ULL ) |
-			((x >>  8) & 0x00000000ff000000ULL ) |
-			((x >> 24) & 0x0000000000ff0000ULL ) |
-			((x >> 40) & 0x000000000000ff00ULL ) |
-			((x >> 56) & 0x00000000000000ffULL ) ;
-}
-#endif
-#else
-#define msgpack_betoh64(x) (x)
-#endif
-
-
-typedef enum {
-	CS_HEADER            = 0x00,  // nil
-
-	//CS_                = 0x01,
-	//CS_                = 0x02,  // false
-	//CS_                = 0x03,  // true
-
-	//CS_                = 0x04,
-	//CS_                = 0x05,
-	//CS_                = 0x06,
-	//CS_                = 0x07,
-
-	//CS_                = 0x08,
-	//CS_                = 0x09,
-	CS_FLOAT             = 0x0a,
-	CS_DOUBLE            = 0x0b,
-	CS_UINT_8            = 0x0c,
-	CS_UINT_16           = 0x0d,
-	CS_UINT_32           = 0x0e,
-	CS_UINT_64           = 0x0f,
-	CS_INT_8             = 0x10,
-	CS_INT_16            = 0x11,
-	CS_INT_32            = 0x12,
-	CS_INT_64            = 0x13,
-
-	//CS_                = 0x14,
-	//CS_                = 0x15,
-	//CS_BIG_INT_16        = 0x16,
-	//CS_BIG_INT_32        = 0x17,
-	//CS_BIG_FLOAT_16      = 0x18,
-	//CS_BIG_FLOAT_32      = 0x19,
-	CS_RAW_16            = 0x1a,
-	CS_RAW_32            = 0x1b,
-	CS_ARRAY_16          = 0x1c,
-	CS_ARRAY_32          = 0x1d,
-	CS_MAP_16            = 0x1e,
-	CS_MAP_32            = 0x1f,
-
-	//ACS_BIG_INT_VALUE,
-	//ACS_BIG_FLOAT_VALUE,
-	ACS_RAW_VALUE,
-} msgpack_unpack_state;
-
-
-typedef enum {
-	CT_ARRAY_ITEM,
-	CT_MAP_KEY,
-	CT_MAP_VALUE,
-} msgpack_container_type;
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/unpack_define.h */
-
--- a/msgpack/unpack_template.h
+++ b/msgpack/unpack_template.h
@ -1,361 +0,0 @@
-/*
- * MessagePack unpacking routine template
- *
- * Copyright (C) 2008-2009 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_unpack_func
-#error msgpack_unpack_func template is not defined
-#endif
-
-#ifndef msgpack_unpack_callback
-#error msgpack_unpack_callback template is not defined
-#endif
-
-#ifndef msgpack_unpack_struct
-#error msgpack_unpack_struct template is not defined
-#endif
-
-#ifndef msgpack_unpack_struct_decl
-#define msgpack_unpack_struct_decl(name) msgpack_unpack_struct(name)
-#endif
-
-#ifndef msgpack_unpack_object
-#error msgpack_unpack_object type is not defined
-#endif
-
-#ifndef msgpack_unpack_user
-#error msgpack_unpack_user type is not defined
-#endif
-
-
-msgpack_unpack_struct_decl(_stack) {
-	msgpack_unpack_object obj;
-	size_t count;
-	unsigned int ct;
-	msgpack_unpack_object map_key;
-};
-
-msgpack_unpack_struct_decl(_context) {
-	msgpack_unpack_user user;
-	unsigned int cs;
-	unsigned int trail;
-	unsigned int top;
-	msgpack_unpack_struct(_stack) stack[MSGPACK_MAX_STACK_SIZE];
-};
-
-
-msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
-{
-	ctx->cs = CS_HEADER;
-	ctx->trail = 0;
-	ctx->top = 0;
-	ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user);
-}
-
-msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx)
-{
-	return (ctx)->stack[0].obj;
-}
-
-
-msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off)
-{
-	assert(len >= *off);
-
-	const unsigned char* p = (unsigned char*)data + *off;
-	const unsigned char* const pe = (unsigned char*)data + len;
-	const void* n = NULL;
-
-	unsigned int trail = ctx->trail;
-	unsigned int cs = ctx->cs;
-	unsigned int top = ctx->top;
-	msgpack_unpack_struct(_stack)* stack = ctx->stack;
-	msgpack_unpack_user* user = &ctx->user;
-
-	msgpack_unpack_object obj;
-	msgpack_unpack_struct(_stack)* c = NULL;
-
-	int ret;
-
-#define push_simple_value(func) \
-	if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \
-	goto _push
-#define push_fixed_value(func, arg) \
-	if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \
-	goto _push
-#define push_variable_value(func, base, pos, len) \
-	if(msgpack_unpack_callback(func)(user, \
-		(const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \
-	goto _push
-
-#define again_fixed_trail(_cs, trail_len) \
-	trail = trail_len; \
-	cs = _cs; \
-	goto _fixed_trail_again
-#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \
-	trail = trail_len; \
-	if(trail == 0) { goto ifzero; } \
-	cs = _cs; \
-	goto _fixed_trail_again
-
-#define start_container(func, count_, ct_) \
-	if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \
-	if((count_) == 0) { obj = stack[top].obj; goto _push; } \
-	if(top >= MSGPACK_MAX_STACK_SIZE) { goto _failed; } \
-	stack[top].ct = ct_; \
-	stack[top].count = count_; \
-	/*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \
-	/*printf("stack push %d\n", top);*/ \
-	++top; \
-	goto _header_again
-
-#define NEXT_CS(p) \
-	((unsigned int)*p & 0x1f)
-
-#define PTR_CAST_8(ptr)   (*(uint8_t*)ptr)
-#define PTR_CAST_16(ptr)  msgpack_betoh16(*(uint16_t*)ptr)
-#define PTR_CAST_32(ptr)  msgpack_betoh32(*(uint32_t*)ptr)
-#define PTR_CAST_64(ptr)  msgpack_betoh64(*(uint64_t*)ptr)
-
-	if(p == pe) { goto _out; }
-	do {
-		switch(cs) {
-		case CS_HEADER:
-			switch(*p) {
-			case 0x00 ... 0x7f:  // Positive Fixnum
-				push_fixed_value(_uint8, *(uint8_t*)p);
-			case 0xe0 ... 0xff:  // Negative Fixnum
-				push_fixed_value(_int8, *(int8_t*)p);
-			case 0xc0 ... 0xdf:  // Variable
-				switch(*p) {
-				case 0xc0:  // nil
-					push_simple_value(_nil);
-				//case 0xc1:  // string
-				//	again_terminal_trail(NEXT_CS(p), p+1);
-				case 0xc2:  // false
-					push_simple_value(_false);
-				case 0xc3:  // true
-					push_simple_value(_true);
-				//case 0xc4:
-				//case 0xc5:
-				//case 0xc6:
-				//case 0xc7:
-				//case 0xc8:
-				//case 0xc9:
-				case 0xca:  // float
-				case 0xcb:  // double
-				case 0xcc:  // unsigned int  8
-				case 0xcd:  // unsigned int 16
-				case 0xce:  // unsigned int 32
-				case 0xcf:  // unsigned int 64
-				case 0xd0:  // signed int  8
-				case 0xd1:  // signed int 16
-				case 0xd2:  // signed int 32
-				case 0xd3:  // signed int 64
-					again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
-				//case 0xd4:
-				//case 0xd5:
-				//case 0xd6:  // big integer 16
-				//case 0xd7:  // big integer 32
-				//case 0xd8:  // big float 16
-				//case 0xd9:  // big float 32
-				case 0xda:  // raw 16
-				case 0xdb:  // raw 32
-				case 0xdc:  // array 16
-				case 0xdd:  // array 32
-				case 0xde:  // map 16
-				case 0xdf:  // map 32
-					again_fixed_trail(NEXT_CS(p), 2 << (((unsigned int)*p) & 0x01));
-				default:
-					goto _failed;
-				}
-			case 0xa0 ... 0xbf:  // FixRaw
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero);
-			case 0x90 ... 0x9f:  // FixArray
-				start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM);
-			case 0x80 ... 0x8f:  // FixMap
-				start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY);
-
-			default:
-				goto _failed;
-			}
-			// end CS_HEADER
-
-
-		_fixed_trail_again:
-			++p;
-
-		default:
-			if((size_t)(pe - p) < trail) { goto _out; }
-			n = p;  p += trail - 1;
-			switch(cs) {
-			//case CS_
-			//case CS_
-			case CS_FLOAT: {
-					union { uint32_t num; char buf[4]; } f;
-					f.num = PTR_CAST_32(n);  // FIXME
-					push_fixed_value(_float, *((float*)f.buf)); }
-			case CS_DOUBLE: {
-					union { uint64_t num; char buf[8]; } f;
-					f.num = PTR_CAST_64(n);  // FIXME
-					push_fixed_value(_double, *((double*)f.buf)); }
-			case CS_UINT_8:
-				push_fixed_value(_uint8, (uint8_t)PTR_CAST_8(n));
-			case CS_UINT_16:
-				push_fixed_value(_uint16, (uint16_t)PTR_CAST_16(n));
-			case CS_UINT_32:
-				push_fixed_value(_uint32, (uint32_t)PTR_CAST_32(n));
-			case CS_UINT_64:
-				push_fixed_value(_uint64, (uint64_t)PTR_CAST_64(n));
-
-			case CS_INT_8:
-				push_fixed_value(_int8, (int8_t)PTR_CAST_8(n));
-			case CS_INT_16:
-				push_fixed_value(_int16, (int16_t)PTR_CAST_16(n));
-			case CS_INT_32:
-				push_fixed_value(_int32, (int32_t)PTR_CAST_32(n));
-			case CS_INT_64:
-				push_fixed_value(_int64, (int64_t)PTR_CAST_64(n));
-
-			//case CS_
-			//case CS_
-			//case CS_BIG_INT_16:
-			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, (uint16_t)PTR_CAST_16(n), _big_int_zero);
-			//case CS_BIG_INT_32:
-			//	again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, (uint32_t)PTR_CAST_32(n), _big_int_zero);
-			//case ACS_BIG_INT_VALUE:
-			//_big_int_zero:
-			//	// FIXME
-			//	push_variable_value(_big_int, data, n, trail);
-
-			//case CS_BIG_FLOAT_16:
-			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, (uint16_t)PTR_CAST_16(n), _big_float_zero);
-			//case CS_BIG_FLOAT_32:
-			//	again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, (uint32_t)PTR_CAST_32(n), _big_float_zero);
-			//case ACS_BIG_FLOAT_VALUE:
-			//_big_float_zero:
-			//	// FIXME
-			//	push_variable_value(_big_float, data, n, trail);
-
-			case CS_RAW_16:
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, (uint16_t)PTR_CAST_16(n), _raw_zero);
-			case CS_RAW_32:
-				again_fixed_trail_if_zero(ACS_RAW_VALUE, (uint32_t)PTR_CAST_32(n), _raw_zero);
-			case ACS_RAW_VALUE:
-			_raw_zero:
-				push_variable_value(_raw, data, n, trail);
-
-			case CS_ARRAY_16:
-				start_container(_array, (uint16_t)PTR_CAST_16(n), CT_ARRAY_ITEM);
-			case CS_ARRAY_32:
-				/* FIXME security guard */
-				start_container(_array, (uint32_t)PTR_CAST_32(n), CT_ARRAY_ITEM);
-
-			case CS_MAP_16:
-				start_container(_map, (uint16_t)PTR_CAST_16(n), CT_MAP_KEY);
-			case CS_MAP_32:
-				/* FIXME security guard */
-				start_container(_map, (uint32_t)PTR_CAST_32(n), CT_MAP_KEY);
-
-			default:
-				goto _failed;
-			}
-		}
-
-_push:
-	if(top == 0) { goto _finish; }
-	c = &stack[top-1];
-	switch(c->ct) {
-	case CT_ARRAY_ITEM:
-		if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; }
-		if(--c->count == 0) {
-			obj = c->obj;
-			--top;
-			/*printf("stack pop %d\n", top);*/
-			goto _push;
-		}
-		goto _header_again;
-	case CT_MAP_KEY:
-		c->map_key = obj;
-		c->ct = CT_MAP_VALUE;
-		goto _header_again;
-	case CT_MAP_VALUE:
-		if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; }
-		if(--c->count == 0) {
-			obj = c->obj;
-			--top;
-			/*printf("stack pop %d\n", top);*/
-			goto _push;
-		}
-		c->ct = CT_MAP_KEY;
-		goto _header_again;
-
-	default:
-		goto _failed;
-	}
-
-_header_again:
-		cs = CS_HEADER;
-		++p;
-	} while(p != pe);
-	goto _out;
-
-
-_finish:
-	stack[0].obj = obj;
-	++p;
-	ret = 1;
-	/*printf("-- finish --\n"); */
-	goto _end;
-
-_failed:
-	/*printf("** FAILED **\n"); */
-	ret = -1;
-	goto _end;
-
-_out:
-	ret = 0;
-	goto _end;
-
-_end:
-	ctx->cs = cs;
-	ctx->trail = trail;
-	ctx->top = top;
-	*off = p - (const unsigned char*)data;
-
-	return ret;
-}
-
-
-#undef msgpack_unpack_func
-#undef msgpack_unpack_callback
-#undef msgpack_unpack_struct
-#undef msgpack_unpack_object
-#undef msgpack_unpack_user
-
-#undef push_simple_value
-#undef push_fixed_value
-#undef push_variable_value
-#undef again_fixed_trail
-#undef again_fixed_trail_if_zero
-#undef start_container
-
-#undef NEXT_CS
-#undef PTR_CAST_8
-#undef PTR_CAST_16
-#undef PTR_CAST_32
-#undef PTR_CAST_64
-
--- a/perl/Makefile.PL
+++ b/perl/Makefile.PL
@ -1,34 +0,0 @@
-use inc::Module::Install;
-name 'Data-MessagePack';
-all_from 'lib/Data/MessagePack.pm';
-
-perl_version '5.008005';
-license 'perl';
-can_cc or die "This module requires a C compiler";
-
-my $ccflags = '-I../ ';
-
-makemaker_args(
-    OBJECT => '$(O_FILES)',
-    LIBS => [''],
-    CCFLAGS => $ccflags,
-    clean => {
-        FILES => q{
-            *.stackdump
-            *.gcov *.gcda *.gcno
-            *.out
-            nytprof
-            cover_db
-        },
-    },
-);
-
-tests 't/*.t';
-author_tests('xt');
-
-auto_set_repository;
-build_requires 'Test::More';
-use_test_base;
-auto_include;
-WriteAll;
-
--- a/perl/MessagePack.c
+++ b/perl/MessagePack.c
@ -1,40 +0,0 @@
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "EXTERN.h"
-#include "perl.h"
-#include "XSUB.h"
-#define NEED_newCONSTSUB
-#include "ppport.h"
-#ifdef __cplusplus
-};
-#endif
-
-XS(xs_pack);
-XS(xs_unpack);
-XS(xs_unpacker_new);
-XS(xs_unpacker_execute);
-XS(xs_unpacker_execute_limit);
-XS(xs_unpacker_is_finished);
-XS(xs_unpacker_data);
-XS(xs_unpacker_reset);
-
-XS(boot_Data__MessagePack) {
-    dXSARGS;
-    HV * stash;
-
-    newXS("Data::MessagePack::pack", xs_pack, __FILE__);
-    newXS("Data::MessagePack::unpack", xs_unpack, __FILE__);
-    stash = gv_stashpvn("Data::MessagePack", strlen("Data::MessagePack"), TRUE);
-    newCONSTSUB(stash, "true", &PL_sv_yes);
-    newCONSTSUB(stash, "false", &PL_sv_no);
-
-    newXS("Data::MessagePack::Unpacker::new",           xs_unpacker_new, __FILE__);
-    newXS("Data::MessagePack::Unpacker::execute",       xs_unpacker_execute, __FILE__);
-    newXS("Data::MessagePack::Unpacker::execute_limit", xs_unpacker_execute_limit, __FILE__);
-    newXS("Data::MessagePack::Unpacker::is_finished",   xs_unpacker_is_finished, __FILE__);
-    newXS("Data::MessagePack::Unpacker::data",          xs_unpacker_data, __FILE__);
-    newXS("Data::MessagePack::Unpacker::reset",         xs_unpacker_reset, __FILE__);
-
-}
-
--- a/perl/benchmark/deserialize.pl
+++ b/perl/benchmark/deserialize.pl
@ -1,20 +0,0 @@
-use strict;
-use warnings;
-use Data::MessagePack;
-use JSON::XS;
-use Benchmark ':all';
-
-my $a = [0..2**24];
-my $j = JSON::XS::encode_json($a);
-my $m = Data::MessagePack->pack($a);
-
-print "-- deserialize\n";
-print "JSON::XS: $JSON::XS::VERSION\n";
-print "Data::MessagePack: $Data::MessagePack::VERSION\n";
-cmpthese(
-    -1 => {
-        json => sub { JSON::XS::decode_json($j)     },
-        mp   => sub { Data::MessagePack->unpack($m) },
-    }
-);
-
--- a/perl/benchmark/serialize.pl
+++ b/perl/benchmark/serialize.pl
@ -1,18 +0,0 @@
-use strict;
-use warnings;
-use Data::MessagePack;
-use JSON::XS;
-use Benchmark ':all';
-
-my $a = [0..2**24];
-
-print "-- serialize\n";
-print "JSON::XS: $JSON::XS::VERSION\n";
-print "Data::MessagePack: $Data::MessagePack::VERSION\n";
-cmpthese(
-    -1 => {
-        json => sub { JSON::XS::encode_json($a)   },
-        mp   => sub { Data::MessagePack->pack($a) },
-    }
-);
-
--- a/perl/lib/Data/MessagePack.pm
+++ b/perl/lib/Data/MessagePack.pm
@ -1,33 +0,0 @@
-package Data::MessagePack;
-use strict;
-use warnings;
-use XSLoader;
-
-our $VERSION = 0.01;
-
-XSLoader::load(__PACKAGE__, $VERSION);
-
-1;
-__END__
-
-=head1 NAME
-
-Data::MessagePack - messagepack
-
-=head1 SYNOPSIS
-
-    my $packed = Data::MessagePack->pack($dat);
-    my $unpacked = Data::MessagePack->unpack($dat);
-
-=head1 DESCRIPTION
-
-Data::MessagePack is a binary packer for perl.
-
-=head1 AUTHORS
-
-Tokuhiro Matsuno
-
-=head1 SEE ALSO
-
-L<http://msgpack.sourceforge.jp/>
-
--- a/perl/lib/Data/MessagePack/Unpacker.pod
+++ b/perl/lib/Data/MessagePack/Unpacker.pod
@ -1,52 +0,0 @@
-=head1 NAME
-
-Data::MessagePack::Unpacker - messagepack streaming deserializer
-
-=head1 SYNOPSIS
-
-    use Data::Dumper;
-    my $up = Data::MessagePack::Unpacker->new;
-    my $ret = $up->execute($v, 0);
-    if ($ret != length($v)) {
-        fail "extra bytes";
-    }
-    return Dumper($up->data);
-
-=head1 DESCRIPTION
-
-This is an streaming deserializer for messagepack.
-
-=head1 METHODS
-
-=over 4
-
-=item my $up = Data::MessagePack::Unpacker->new()
-
-create new stream deserializer
-
-=item $up->execute()
-
-=item $up->execute_limit()
-
-=item $up->is_finished()
-
-is this deserializer finished?
-
-=item $up->data()
-
-returns deserialized object.
-
-=item $up->reset()
-
-reset the stream deserializer, without memory zone.
-
-=back
-
-=head1 AUTHORS
-
-Tokuhiro Matsuno
-
-=head1 SEE ALSO
-
-L<Data::MessagePack>
-
--- a/perl/pack.c
+++ b/perl/pack.c
@ -1,155 +0,0 @@
-/*
- * code is written by tokuhirom.
- * buffer alocation technique is taken from JSON::XS. thanks to mlehmann.
- */
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "EXTERN.h"
-#include "perl.h"
-#include "XSUB.h"
-#include "ppport.h"
-#ifdef __cplusplus
-};
-#endif
-
-#include "msgpack/pack_define.h"
-
-#define msgpack_pack_inline_func(name) \
-    static inline void msgpack_pack ## name
-
-#define msgpack_pack_inline_func_cint(name) \
-    static inline void msgpack_pack ## name
-
-typedef struct {
-    char *cur; /* SvPVX (sv) + current output position */
-    char *end; /* SvEND (sv) */
-    SV *sv;    /* result scalar */
-} enc_t;
-void need(enc_t *enc, STRLEN len);
-
-#define msgpack_pack_user enc_t*
-
-#define msgpack_pack_append_buffer(enc, buf, len) \
-    need(enc, len); \
-    memcpy(enc->cur, buf, len); \
-    enc->cur += len;
-
-#include "msgpack/pack_template.h"
-
-#define _PACK_WRAPPER(t) msgpack_pack_##t
-#define PACK_WRAPPER(t) _PACK_WRAPPER(t)
-#define INIT_SIZE   32 /* initial scalar size to be allocated */
-
-void need(enc_t *enc, STRLEN len)
-{
-    if (enc->cur + len >= enc->end) {
-        STRLEN cur = enc->cur - (char *)SvPVX (enc->sv);
-        SvGROW (enc->sv, cur + (len < (cur >> 2) ? cur >> 2 : len) + 1);
-        enc->cur = SvPVX (enc->sv) + cur;
-        enc->end = SvPVX (enc->sv) + SvLEN (enc->sv) - 1;
-    }
-}
-
-static void _msgpack_pack_sv(enc_t *enc, SV* val) {
-    if (val==NULL) {
-        msgpack_pack_nil(enc);
-        return;
-    }
-
-    switch (SvTYPE(val)) {
-    case SVt_NULL:
-        msgpack_pack_nil(enc);
-        break;
-    case SVt_IV:
-        if (SvIOK_UV(val)) {
-            msgpack_pack_uint32(enc, SvUV(val));
-        } else {
-            PACK_WRAPPER(IVTYPE)(enc, SvIV(val));
-        }
-        break;
-    case SVt_PVNV:
-        {
-            STRLEN len = 0;
-            char *pv = SvPV(val, len);
-            if (len == 1 && *pv == '1') {
-                msgpack_pack_true(enc);
-            } else if (len == 0 && *pv==0) {
-                msgpack_pack_false(enc);
-            } else {
-                msgpack_pack_nil(enc);
-            }
-        }
-        break;
-    case SVt_NV:
-        PACK_WRAPPER(NVTYPE)(enc, SvNV(val));
-        break;
-    case SVt_PVAV:
-        {
-            AV* ary = (AV*)val;
-            int len = av_len(ary) + 1;
-            int i;
-            msgpack_pack_array(enc, len);
-            for (i=0; i<len; i++) {
-                SV** svp = av_fetch(ary, i, 0);
-                if (svp) {
-                    _msgpack_pack_sv(enc, *svp);
-                } else {
-                    msgpack_pack_nil(enc);
-                }
-            }
-        }
-        break;
-    case SVt_PVHV:
-        {
-            HV* hval = (HV*)val;
-            int count = hv_iterinit(hval);
-            HE* he;
-
-            msgpack_pack_map(enc, count);
-
-            while (he = hv_iternext(hval)) {
-                _msgpack_pack_sv(enc, hv_iterkeysv(he));
-                _msgpack_pack_sv(enc, HeVAL(he));
-            }
-        }
-        break;
-    case SVt_RV:
-        _msgpack_pack_sv(enc, SvRV(val));
-        break;
-    default:
-        if (SvPOKp(val)) {
-            STRLEN len;
-            char * cval = SvPV(val, len);
-            msgpack_pack_raw(enc, len);
-            msgpack_pack_raw_body(enc, cval, len);
-            return;
-        } else {
-            sv_dump(val);
-            Perl_croak(aTHX_ "msgpack for perl doesn't supported this type: %d\n", SvTYPE(val));
-        }
-    }
-}
-
-XS(xs_pack) {
-    dXSARGS;
-    if (items != 2) {
-        Perl_croak(aTHX_ "Usage: Data::MessagePack->pack($dat)");
-    }
-
-    SV* val = ST(1);
-
-    enc_t enc;
-    enc.sv        = sv_2mortal(NEWSV(0, INIT_SIZE));
-    enc.cur       = SvPVX(enc.sv);
-    enc.end       = SvEND(enc.sv);
-    SvPOK_only(enc.sv);
-
-    _msgpack_pack_sv(&enc, val);
-
-    SvCUR_set(enc.sv, enc.cur - SvPVX (enc.sv));
-    *SvEND (enc.sv) = 0; /* many xs functions expect a trailing 0 for text strings */
-
-    ST(0) = enc.sv;
-    XSRETURN(1);
-}
--- a/perl/ppport.h
+++ b/perl/ppport.h
--- a/perl/t/00_compile.t
+++ b/perl/t/00_compile.t
@ -1,6 +0,0 @@
-use strict;
-use warnings;
-use Test::More tests => 1;
-
-use_ok 'Data::MessagePack';
-
--- a/perl/t/01_pack.t
+++ b/perl/t/01_pack.t
@ -1,60 +0,0 @@
-use t::Util;
-use Test::More;
-use Data::MessagePack;
-
-sub packit {
-    local $_ = unpack("H*", Data::MessagePack->pack($_[0]));
-    s/(..)/$1 /g;
-    s/ $//;
-    $_;
-}
-
-sub pis ($$) {
-    is packit($_[0]), $_[1], 'dump ' . $_[1];
-}
-
-my @dat = (
-    0,     '00',
-    1,     '01',
-    127,   '7f',
-    128,   'cc 80',
-    255,   'cc ff',
-    256,   'cd 01 00',
-    65535, 'cd ff ff',
-    65536, 'ce 00 01 00 00',
-    -1,    'ff',
-    -32,   'e0',
-    -33,   'd0 df',
-    -128,  'd0 80',
-    -129,  'd1 ff 7f',
-    -32768, 'd1 80 00',
-    -32769, 'd2 ff ff 7f ff',
-    1.0,   'cb 3f f0 00 00 00 00 00 00',
-    "",    'a0',
-    "a",   'a1 61',
-    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 'bf 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61',
-    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 'da 00 20 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61',
-    undef, 'c0',
-    Data::MessagePack::true(), 'c3',
-    Data::MessagePack::false(), 'c2',
-    [], '90',
-    [+[]], '91 90',
-    [[], undef], '92 90 c0',
-    {'a', 0}, '81 a1 61 00',
-    8388608, 'ce 00 80 00 00',
-
-    [undef, false, true], '93 c0 c2 c3',
-    ["", "a", "bc", "def"], '94 a0 a1 61 a2 62 63 a3 64 65 66',
-    [[], [[undef]]], '92 90 91 91 c0',
-    [undef, false, true], '93 c0 c2 c3',
-    [[0, 64, 127], [-32, -16, -1]], '92 93 00 40 7f 93 e0 f0 ff',
-    [0, -128, -1, 0, -32768, -1, 0, -2147483648, -1], '99 00 d0 80 ff 00 d1 80 00 ff 00 d2 80 00 00 00 ff',
-    2147483648, 'ce 80 00 00 00',
-    -2147483648, 'd2 80 00 00 00',
-);
-plan tests => 1*(scalar(@dat)/2);
-
-for (my $i=0; $i<scalar(@dat); ) {
-    pis $dat[$i++], $dat[$i++];
-}
-
--- a/perl/t/02_unpack.t
+++ b/perl/t/02_unpack.t
@ -1,24 +0,0 @@
-use Test::More;
-use Data::MessagePack;
-use t::Util;
-no warnings 'uninitialized'; # i need this. i need this.
-
-sub unpackit {
-    my $v = $_[0];
-    $v =~ s/ //g;
-    $v = pack 'H*', $v;
-    return Data::MessagePack->unpack($v);
-}
-
-sub pis ($$) {
-    is_deeply unpackit($_[0]), $_[1], 'dump ' . $_[0];
-}
-
-my @dat = do 't/data.pl';
-
-plan tests => 1*(scalar(@dat)/2);
-
-for (my $i=0; $i<scalar(@dat); ) {
-    pis $dat[$i++], $dat[$i++];
-}
-
--- a/perl/t/03_stream_unpack.t
+++ b/perl/t/03_stream_unpack.t
@ -1,32 +0,0 @@
-use t::Util;
-use Test::More;
-use Data::MessagePack;
-
-no warnings 'uninitialized'; # i need this. i need this.
-
-my $up = Data::MessagePack::Unpacker->new;
-sub unpackit {
-    my $v = $_[0];
-    $v =~ s/ //g;
-    $v = pack 'H*', $v;
-    $up->reset;
-    my $ret = $up->execute($v, 0);
-    if ($ret != length($v)) {
-        fail "extra bytes";
-    }
-    return $up->data;
-}
-
-sub pis ($$) {
-    is_deeply unpackit($_[0]), $_[1], 'dump ' . $_[0];
-}
-
-my @dat = do 't/data.pl';
-
-plan tests => 1*(scalar(@dat)/2) + 1;
-
-isa_ok $up, 'Data::MessagePack::Unpacker';
-for (my $i=0; $i<scalar(@dat); ) {
-    pis $dat[$i++], $dat[$i++];
-}
-
--- a/perl/t/04_invert.t
+++ b/perl/t/04_invert.t
@ -1,24 +0,0 @@
-use Test::More;
-use Data::MessagePack;
-use t::Util;
-no warnings 'uninitialized'; # i need this. i need this.
-
-sub invert {
-    return Data::MessagePack->unpack(
-        Data::MessagePack->pack($_[0]),
-    );
-}
-
-sub pis ($) {
-    is_deeply invert($_[0]), $_[0], 'dump ' . $_[0];
-}
-
-my @dat = do 't/data.pl';
-
-plan tests => 1*(scalar(@dat)/2);
-
-for (my $i=0; $i<scalar(@dat); ) {
-    $i++;
-    pis $dat[$i++];
-}
-
--- a/perl/t/Util.pm
+++ b/perl/t/Util.pm
@ -1,20 +0,0 @@
-package t::Util;
-use strict;
-use warnings;
-
-sub import {
-    my $pkg = caller(0);
-
-    strict->import;
-    warnings->import;
-
-    no strict 'refs';
-    *{"$pkg\::true"} = sub () {
-        Data::MessagePack::true()
-    };
-    *{"$pkg\::false"} = sub () {
-        Data::MessagePack::false()
-    };
-}
-
-1;
--- a/perl/t/data.pl
+++ b/perl/t/data.pl
@ -1,15 +0,0 @@
-no warnings 'uninitialized'; # i need this. i need this.
-(
-    '93 c0 c2 c3' => [undef, false, true],
-    '94 a0 a1 61 a2 62 63 a3 64 65 66', ["", "a", "bc", "def"],
-    '92 90 91 91 c0', [[], [[undef]]],
-    '93 c0 c2 c3', [undef, false, true],
-    'ce 80 00 00 00', 2147483648,
-    '99 cc 00 cc 80 cc ff cd 00 00 cd 80 00 cd ff ff ce 00 00 00 00 ce 80 00 00 00 ce ff ff ff ff', [0, 128, 255, 0, 32768, 65535, 0, 2147483648, 4294967295],
-    '92 93 00 40 7f 93 e0 f0 ff', [[0, 64, 127], [-32, -16, -1]],
-    '96 dc 00 00 dc 00 01 c0 dc 00 02 c2 c3 dd 00 00 00 00 dd 00 00 00 01 c0 dd 00 00 00 02 c2 c3', [[], [undef], [false, true], [], [undef], [false, true]],
-    '96 da 00 00 da 00 01 61 da 00 02 61 62 db 00 00 00 00 db 00 00 00 01 61 db 00 00 00 02 61 62', ["", "a", "ab", "", "a", "ab"],
-    '99 d0 00 d0 80 d0 ff d1 00 00 d1 80 00 d1 ff ff d2 00 00 00 00 d2 80 00 00 00 d2 ff ff ff ff', [0, -128, -1, 0, -32768, -1, 0, -2147483648, -1],
-    '82 c2 81 c0 c0 c3 81 c0 80', {false,{undef,undef}, true,{undef,{}}},
-    '96 de 00 00 de 00 01 c0 c2 de 00 02 c0 c2 c3 c2 df 00 00 00 00 df 00 00 00 01 c0 c2 df 00 00 00 02 c0 c2 c3 c2', [{}, {undef,false}, {true,false, undef,false}, {}, {undef,false}, {true,false, undef,false}],
-)
--- a/perl/unpack.c
+++ b/perl/unpack.c
@ -1,290 +0,0 @@
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "EXTERN.h"
-#include "perl.h"
-#include "XSUB.h"
-#define NEED_newRV_noinc
-#define NEED_sv_2pv_flags
-#include "ppport.h"
-
-#ifdef __cplusplus
-};
-#endif
-
-typedef struct {
-    int finished;
-    SV* source;
-} unpack_user;
-
-#include "msgpack/unpack_define.h"
-
-#define msgpack_unpack_struct(name) \
-    struct template ## name
-
-#define msgpack_unpack_func(ret, name) \
-    ret template ## name
-
-#define msgpack_unpack_callback(name) \
-    template_callback ## name
-
-#define msgpack_unpack_object SV*
-
-#define msgpack_unpack_user unpack_user
-
-struct template_context;
-typedef struct template_context msgpack_unpack_t;
-
-static void template_init(msgpack_unpack_t* u);
-
-static SV* template_data(msgpack_unpack_t* u);
-
-static int template_execute(msgpack_unpack_t* u,
-    const char* data, size_t len, size_t* off);
-
-static inline SV* template_callback_root(unpack_user* u)
-{ return &PL_sv_undef; }
-
-static inline int template_callback_uint8(unpack_user* u, uint8_t d, SV** o)
-{ *o = newSVuv(d); return 0; }
-
-static inline int template_callback_uint16(unpack_user* u, uint16_t d, SV** o)
-{ *o = newSVuv(d); return 0; }
-
-static inline int template_callback_uint32(unpack_user* u, uint32_t d, SV** o)
-{ *o = newSVuv(d); return 0; }
-
-static inline int template_callback_uint64(unpack_user* u, uint64_t d, SV** o)
-{ *o = newSVuv(d); return 0; }
-
-static inline int template_callback_int8(unpack_user* u, int8_t d, SV** o)
-{ *o = newSViv((long)d); return 0; }
-
-static inline int template_callback_int16(unpack_user* u, int16_t d, SV** o)
-{ *o = newSViv((long)d); return 0; }
-
-static inline int template_callback_int32(unpack_user* u, int32_t d, SV** o)
-{ *o = newSViv((long)d); return 0; }
-
-static inline int template_callback_int64(unpack_user* u, int64_t d, SV** o)
-{ *o = newSViv(d); return 0; }
-
-static inline int template_callback_float(unpack_user* u, float d, SV** o)
-{ *o = newSVnv(d); return 0; }
-
-static inline int template_callback_double(unpack_user* u, double d, SV** o)
-{ *o = newSVnv(d); return 0; }
-
-static inline int template_callback_nil(unpack_user* u, SV** o)
-{ *o = &PL_sv_undef; return 0; }
-
-static inline int template_callback_true(unpack_user* u, SV** o)
-{ *o = &PL_sv_yes; return 0; }
-
-static inline int template_callback_false(unpack_user* u, SV** o)
-{ *o = &PL_sv_no; return 0;}
-
-static inline int template_callback_array(unpack_user* u, unsigned int n, SV** o)
-{ AV* a = newAV(); *o = (SV*)newRV_noinc((SV*)a); av_extend(a, n); return 0; }
-
-static inline int template_callback_array_item(unpack_user* u, SV** c, SV* o)
-{ av_push((AV*)SvRV(*c), o); SvREFCNT_inc(o); return 0; }  /* FIXME set value directry RARRAY_PTR(obj)[RARRAY_LEN(obj)++] */
-
-static inline int template_callback_map(unpack_user* u, unsigned int n, SV** o)
-{ HV * h = newHV(); *o = newRV_noinc((SV*)h); return 0; }
-
-static inline int template_callback_map_item(unpack_user* u, SV** c, SV* k, SV* v)
-{ hv_store_ent((HV*)SvRV(*c), k, v, 0); SvREFCNT_inc(v); return 0; }
-
-static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, SV** o)
-{ *o = (l == 0) ? newSVpv("", 0) : newSVpv(p, l); return 0; }
-
-#define UNPACKER(from, name) \
-	msgpack_unpack_t *name; \
-    name = INT2PTR(msgpack_unpack_t*, SvROK((from)) ? SvIV(SvRV((from))) : SvIV((from))); \
-	if(name == NULL) { \
-		Perl_croak(aTHX_ "NULL found for " # name " when shouldn't be."); \
-	}
-
-#include "msgpack/unpack_template.h"
-
-SV* _msgpack_unpack(SV* data, int limit) {
-    msgpack_unpack_t mp;
-    unpack_user u = {0, &PL_sv_undef};
-	int ret;
-	size_t from = 0;
-    STRLEN dlen;
-    const char * dptr = SvPV_const(data, dlen);
-
-	template_init(&mp);
-    mp.user = u;
-
-	mp.user.source = data;
-	ret = template_execute(&mp, dptr, (size_t)dlen, &from);
-	mp.user.source = &PL_sv_undef;
-
-	if(ret < 0) {
-        Perl_croak(aTHX_ "parse error.");
-	} else if(ret == 0) {
-        Perl_croak(aTHX_ "insufficient bytes.");
-	} else {
-		if(from < dlen) {
-            Perl_croak(aTHX_ "extra bytes.");
-		}
-        return template_data(&mp);
-	}
-}
-
-XS(xs_unpack_limit) {
-    dXSARGS;
-
-    if (items != 3) {
-        Perl_croak(aTHX_ "Usage: Data::MessagePack->unpack('datadata', $limit)");
-    }
-
-    {
-        int limit = SvIV(ST(2));
-        ST(0) = _msgpack_unpack(ST(1), limit);
-    }
-    XSRETURN(1);
-}
-
-
-XS(xs_unpack) {
-    dXSARGS;
-    msgpack_unpack_t mp;
-
-    if (items != 2) {
-        Perl_croak(aTHX_ "Usage: Data::MessagePack->unpack('datadata')");
-    }
-
-    {
-        ST(0) = _msgpack_unpack(ST(1), sv_len(ST(1)));
-    }
-
-    XSRETURN(1);
-}
-
-/* ------------------------------ stream -- */
-
-static void _reset(SV* self) {
-	UNPACKER(self, mp);
-	template_init(mp);
-	unpack_user u = {0, &PL_sv_undef};
-	mp->user = u;
-}
-
-XS(xs_unpacker_new) {
-    dXSARGS;
-    if (items != 1) {
-        Perl_croak(aTHX_ "Usage: Data::MessagePack::Unpacker->new()");
-    }
-
-    SV* self = sv_newmortal();
-	msgpack_unpack_t *mp;
-
-    Newx(mp, 1, msgpack_unpack_t);
-
-    sv_setref_pv(self, "Data::MessagePack::Unpacker", mp);
-    _reset(self);
-
-    ST(0) = self;
-    XSRETURN(1);
-}
-
-static SV* _execute_impl(SV* self, SV* data, UV off, I32 limit) {
-    UNPACKER(self, mp);
-
-    size_t from = off;
-	const char* dptr = SvPV_nolen_const(data);
-	long dlen = limit;
-	int ret;
-
-	if(from >= dlen) {
-        Perl_croak(aTHX_ "offset is bigger than data buffer size.");
-	}
-
-	mp->user.source = data;
-	ret = template_execute(mp, dptr, (size_t)dlen, &from);
-	mp->user.source = &PL_sv_undef;
-
-	if(ret < 0) {
-		Perl_croak(aTHX_ "parse error.");
-	} else if(ret > 0) {
-		mp->user.finished = 1;
-		return newSVuv(from);
-	} else {
-		mp->user.finished = 0;
-		return newSVuv(from);
-	}
-}
-
-XS(xs_unpacker_execute) {
-    dXSARGS;
-    if (items != 3) {
-        Perl_croak(aTHX_ "Usage: $unpacker->execute_limit(data, off)");
-    }
-
-    {
-        SV* self = ST(0);
-        SV* data = ST(1);
-        IV  off  = SvIV(ST(2));
-
-        ST(0) = _execute_impl(self, data, off, sv_len(data));
-    }
-
-    XSRETURN(1);
-}
-
-XS(xs_unpacker_execute_limit) {
-    dXSARGS;
-    if (items != 4) {
-        Perl_croak(aTHX_ "Usage: $unpacker->execute_limit(data, off, limit)");
-    }
-
-    SV* self = ST(0);
-    SV* data = ST(1);
-    IV off   = SvIV(ST(2));
-    IV limit = SvIV(ST(3));
-
-    ST(0) = _execute_impl(self, data, off, limit);
-
-    XSRETURN(1);
-}
-
-XS(xs_unpacker_is_finished) {
-    dXSARGS;
-    if (items != 1) {
-        Perl_croak(aTHX_ "Usage: $unpacker->is_finished()");
-    }
-
-	UNPACKER(ST(0), mp);
-    ST(0) = (mp->user.finished) ? &PL_sv_yes : &PL_sv_no;
-
-    XSRETURN(1);
-}
-
-XS(xs_unpacker_data) {
-    dXSARGS;
-    if (items != 1) {
-        Perl_croak(aTHX_ "Usage: $unpacker->data()");
-    }
-
-	UNPACKER(ST(0), mp);
-	ST(0) = template_data(mp);
-
-    XSRETURN(1);
-}
-
-XS(xs_unpacker_reset) {
-    dXSARGS;
-    if (items != 1) {
-        Perl_croak(aTHX_ "Usage: $unpacker->reset()");
-    }
-
-    _reset(ST(0));
-
-    XSRETURN(0);
-}
-
--- a/perl/xt/99_pod.t
+++ b/perl/xt/99_pod.t
@ -1,4 +0,0 @@
-use Test::More;
-eval "use Test::Pod 1.00";
-plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
-all_pod_files_ok();
--- a/ruby/bench.rb
+++ b/ruby/bench.rb
@ -1,70 +0,0 @@
-require 'rubygems'
-require 'json'
-require 'msgpack'
-
-def show10(str)
-	puts "#{str.length/1024} KB"
-	puts str[0, 10].unpack('C*').map{|x|"%02x"%x}.join(' ') + " ..."
-end
-
-ary = []
-i = 0
-while i < (1<<24)
-	#ary << (1<<24)
-	ary << i
-	i += 1
-end
-
-GC.start
-
-puts "----"
-puts "MessagePack"
-a = Time.now
-packed = MessagePack::pack(ary)
-b = Time.now
-show10(packed)
-sec = b - a
-puts "#{sec} sec."
-puts "#{packed.length.to_f / sec / 1024 / 1024 * 8} Mbps"
-
-GC.start
-
-=begin
-puts "----"
-puts "JSON"
-a = Time.now
-json = ary.to_json
-b = Time.now
-show10(json)
-puts "#{b-a} sec."
-
-ary = nil
-GC.start
-=end
-
-
-puts "----"
-puts "MessagePack"
-a = Time.now
-ary = MessagePack::unpack(packed)
-b = Time.now
-sec = b - a
-puts "#{sec} sec."
-puts "#{packed.length.to_f / sec / 1024 / 1024 * 8} Mbps"
-
-p ary.size
-p (1<<24)
-
-ary = nil
-GC.start
-
-
-=begin
-puts "----"
-puts "JSON"
-a = Time.now
-ary = JSON::load(json)
-b = Time.now
-puts "#{b-a} sec."
-=end
-
--- a/ruby/extconf.rb
+++ b/ruby/extconf.rb
@ -1,4 +0,0 @@
-require 'mkmf'
-$CFLAGS << " -I.. -Wall -O4"
-create_makefile('msgpack')
-
--- a/ruby/gem/README
+++ b/ruby/gem/README
@ -1,29 +0,0 @@
-
-= MessagePack
-
-
-== Description
-
-
-== Installation
-
-=== Archive Installation
-
-	rake install
-
-=== Gem Installation
-
-	gem install msgpack
-
-
-== Features/Problems
-
-
-== Synopsis
-
-
-== Copyright
-
-Author::    frsyuki <frsyuki@users.sourceforge.jp>
-Copyright:: Copyright (c) 2008-2009 frsyuki
-License::   Apache License, Version 2.0
--- a/ruby/gem/Rakefile
+++ b/ruby/gem/Rakefile
@ -1,133 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rake/contrib/rubyforgepublisher'
-require 'rake/contrib/sshpublisher'
-require 'fileutils'
-include FileUtils
-
-NAME              = "msgpack"
-AUTHOR            = "FURUHASHI Sadayuki"
-EMAIL             = "frsyuki _at_ users.sourceforge.jp"
-DESCRIPTION       = "Binary-based efficient data interchange format."
-RUBYFORGE_PROJECT = "msgpack"
-HOMEPATH          = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
-BIN_FILES         = %w(  )
-VERS              = "0.3.1"
-
-#REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
-REV = nil
-CLEAN.include ['**/.*.sw?', '*.gem', '.config']
-RDOC_OPTS = [
-	'--title', "#{NAME} documentation",
-	"--charset", "utf-8",
-	"--opname", "index.html",
-	"--line-numbers",
-	"--main", "README",
-	"--inline-source",
-]
-
-task :default => [:test]
-task :package => [:clean]
-
-Rake::TestTask.new("test") do |t|
-	t.libs   << "test"
-	t.pattern = "test/**/*_test.rb"
-	t.verbose = true
-end
-
-spec = Gem::Specification.new do |s|
-	s.name              = NAME
-	s.version           = VERS
-	s.platform          = Gem::Platform::RUBY
-	s.has_rdoc          = true
-	s.extra_rdoc_files  = ["README", "ChangeLog", "AUTHORS"]
-	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
-	s.summary           = DESCRIPTION
-	s.description       = DESCRIPTION
-	s.author            = AUTHOR
-	s.email             = EMAIL
-	s.homepage          = HOMEPATH
-	s.executables       = BIN_FILES
-	s.rubyforge_project = RUBYFORGE_PROJECT
-	s.bindir            = "bin"
-	s.require_path      = "ext"
-	s.autorequire       = ""
-	s.test_files        = Dir["test/test_*.rb"]
-
-	#s.add_dependency('activesupport', '>=1.3.1')
-	#s.required_ruby_version = '>= 1.8.2'
-
-	s.files = %w(README ChangeLog Rakefile) +
-		Dir.glob("{bin,doc,test,lib,templates,generator,extras,website,script}/**/*") + 
-		Dir.glob("ext/**/*.{h,c,rb}") +
-		Dir.glob("examples/**/*.rb") +
-		Dir.glob("tools/*.rb") +
-		Dir.glob("msgpack/*.h")
-
-	s.extensions = FileList["ext/**/extconf.rb"].to_a
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-	p.need_tar = true
-	p.gem_spec = spec
-end
-
-task :install do
-	name = "#{NAME}-#{VERS}.gem"
-	sh %{rake package}
-	sh %{sudo gem install pkg/#{name}}
-end
-
-task :uninstall => [:clean] do
-	sh %{sudo gem uninstall #{NAME}}
-end
-
-
-#Rake::RDocTask.new do |rdoc|
-#	rdoc.rdoc_dir = 'html'
-#	rdoc.options += RDOC_OPTS
-#	rdoc.template = "resh"
-#	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
-#	if ENV['DOC_FILES']
-#		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
-#	else
-#		rdoc.rdoc_files.include('README', 'ChangeLog')
-#		rdoc.rdoc_files.include('lib/**/*.rb')
-#		rdoc.rdoc_files.include('ext/**/*.c')
-#	end
-#end
-
-desc "Publish to RubyForge"
-task :rubyforge => [:rdoc, :package] do
-	require 'rubyforge'
-	Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'frsyuki').upload
-end
-
-desc 'Package and upload the release to rubyforge.'
-task :release => [:clean, :package] do |t|
-	v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
-	abort "Versions don't match #{v} vs #{VERS}" unless v == VERS
-	pkg = "pkg/#{NAME}-#{VERS}"
-
-	rf = RubyForge.new
-	puts "Logging in"
-	rf.login
-
-	c = rf.userconfig
-#	c["release_notes"] = description if description
-#	c["release_changes"] = changes if changes
-	c["preformatted"] = true
-
-	files = [
-		"#{pkg}.tgz",
-		"#{pkg}.gem"
-	].compact
-
-	puts "Releasing #{NAME} v. #{VERS}"
-	rf.add_release RUBYFORGE_PROJECT, NAME, VERS, *files
-end
--- a/ruby/gem/test/test_helper.rb
+++ b/ruby/gem/test/test_helper.rb
@ -1,3 +0,0 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../ext/msgpack'
-
--- a/ruby/gengem.sh
+++ b/ruby/gengem.sh
@ -1,20 +0,0 @@
-#!/bin/sh
-
-mkdir -p gem/ext
-mkdir -p gem/msgpack
-cp extconf.rb       gem/ext/
-cp pack.c           gem/ext/
-cp pack.h           gem/ext/
-cp rbinit.c         gem/ext/
-cp unpack.c         gem/ext/
-cp unpack.h         gem/ext/
-cat test_case.rb | sed "s/require ['\"]msgpack['\"]/require File.dirname(__FILE__) + '\/test_helper.rb'/" > gem/test/msgpack_test.rb
-cp ../AUTHORS        gem/AUTHORS
-cp ../ChangeLog      gem/ChangeLog
-cp ../msgpack/pack_define.h     gem/msgpack/
-cp ../msgpack/pack_template.h   gem/msgpack/
-cp ../msgpack/unpack_define.h   gem/msgpack/
-cp ../msgpack/unpack_template.h gem/msgpack/
-
-cd gem && rake --trace package
-
--- a/ruby/msgpack.gemspec
+++ b/ruby/msgpack.gemspec
@ -1,12 +0,0 @@
-Gem::Specification.new do |s|
-  s.platform = Gem::Platform::CURRENT
-  s.name = "msgpack"
-  s.version = "0.3.1"
-  s.summary = "MessagePack"
-  s.author = "FURUHASHI Sadayuki"
-  s.email = "frsyuki@users.sourceforge.jp"
-  s.homepage = "http://msgpack.sourceforge.jp/"
-  s.rubyforge_project = "msgpack"
-  s.require_paths = ["lib", "ext"]
-  s.files = ["lib/**/*", "ext/**/*"].map {|g| Dir.glob(g) }.flatten
-end
--- a/ruby/pack.c
+++ b/ruby/pack.c
@ -1,165 +0,0 @@
-/*
- * MessagePack for Ruby packing routine
- *
- * Copyright (C) 2008-2009 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 "ruby.h"
-#include "msgpack/pack_define.h"
-
-#define msgpack_pack_inline_func(name) \
-	static inline void msgpack_pack ## name
-
-#define msgpack_pack_inline_func_cint(name) \
-	static inline void msgpack_pack ## name
-
-#define msgpack_pack_user VALUE
-
-#define msgpack_pack_append_buffer(user, buf, len) \
-	rb_str_buf_cat(user, (const void*)buf, len)
-
-#include "msgpack/pack_template.h"
-
-
-#ifndef RUBY_VM
-#include "st.h"  // ruby hash
-#endif
-
-static ID s_to_msgpack;
-
-#define ARG_BUFFER(name, argc, argv) \
-	VALUE name; \
-	if(argc == 1) { \
-		name = argv[0]; \
-	} else if(argc == 0) { \
-		name = rb_str_buf_new(0); \
-	} else { \
-		rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); \
-	}
-
-static VALUE MessagePack_NilClass_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_nil(out);
-	return out;
-}
-
-static VALUE MessagePack_TrueClass_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_true(out);
-	return out;
-}
-
-static VALUE MessagePack_FalseClass_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_false(out);
-	return out;
-}
-
-
-static VALUE MessagePack_Fixnum_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_long(out, FIX2LONG(self));
-	return out;
-}
-
-
-#ifndef RBIGNUM_SIGN  // Ruby 1.8
-#define RBIGNUM_SIGN(b) (RBIGNUM(b)->sign)
-#endif
-
-static VALUE MessagePack_Bignum_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	// FIXME bignum
-	if(RBIGNUM_SIGN(self)) {  // positive
-		msgpack_pack_uint64(out, rb_big2ull(self));
-	} else {  // negative
-		msgpack_pack_int64(out, rb_big2ll(self));
-	}
-	return out;
-}
-
-static VALUE MessagePack_Float_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_double(out, rb_num2dbl(self));
-	return out;
-}
-
-static VALUE MessagePack_String_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_raw(out, RSTRING_LEN(self));
-	msgpack_pack_raw_body(out, RSTRING_PTR(self), RSTRING_LEN(self));
-	return out;
-}
-
-static VALUE MessagePack_Array_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_array(out, RARRAY_LEN(self));
-	VALUE* p = RARRAY_PTR(self);
-	VALUE* const pend = p + RARRAY_LEN(self);
-	for(;p != pend; ++p) {
-		rb_funcall(*p, s_to_msgpack, 1, out);
-	}
-	return out;
-}
-
-#ifndef RHASH_SIZE  // Ruby 1.8
-#define RHASH_SIZE(h) (RHASH(h)->tbl ? RHASH(h)->tbl->num_entries : 0)
-#endif
-
-static int MessagePack_Hash_to_msgpack_foreach(VALUE key, VALUE value, VALUE out)
-{
-	if (key == Qundef) { return ST_CONTINUE; }
-	rb_funcall(key, s_to_msgpack, 1, out);
-	rb_funcall(value, s_to_msgpack, 1, out);
-	return ST_CONTINUE;
-}
-
-static VALUE MessagePack_Hash_to_msgpack(int argc, VALUE *argv, VALUE self)
-{
-	ARG_BUFFER(out, argc, argv);
-	msgpack_pack_map(out, RHASH_SIZE(self));
-	rb_hash_foreach(self, MessagePack_Hash_to_msgpack_foreach, out);
-	return out;
-}
-
-
-static VALUE MessagePack_pack(VALUE self, VALUE data)
-{
-	return rb_funcall(data, s_to_msgpack, 0);
-}
-
-
-void Init_msgpack_pack(VALUE mMessagePack)
-{
-	s_to_msgpack = rb_intern("to_msgpack");
-	rb_define_method_id(rb_cNilClass,   s_to_msgpack, MessagePack_NilClass_to_msgpack, -1);
-	rb_define_method_id(rb_cTrueClass,  s_to_msgpack, MessagePack_TrueClass_to_msgpack, -1);
-	rb_define_method_id(rb_cFalseClass, s_to_msgpack, MessagePack_FalseClass_to_msgpack, -1);
-	rb_define_method_id(rb_cFixnum, s_to_msgpack, MessagePack_Fixnum_to_msgpack, -1);
-	rb_define_method_id(rb_cBignum, s_to_msgpack, MessagePack_Bignum_to_msgpack, -1);
-	rb_define_method_id(rb_cFloat,  s_to_msgpack, MessagePack_Float_to_msgpack, -1);
-	rb_define_method_id(rb_cString, s_to_msgpack, MessagePack_String_to_msgpack, -1);
-	rb_define_method_id(rb_cArray,  s_to_msgpack, MessagePack_Array_to_msgpack, -1);
-	rb_define_method_id(rb_cHash,   s_to_msgpack, MessagePack_Hash_to_msgpack, -1);
-	rb_define_module_function(mMessagePack, "pack", MessagePack_pack, 1);
-}
-
--- a/ruby/pack.h
+++ b/ruby/pack.h
@ -1,26 +0,0 @@
-/*
- * MessagePack for Ruby packing routine
- *
- * Copyright (C) 2008-2009 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 PACK_H__
-#define PACK_H__
-
-#include "ruby.h"
-
-void Init_msgpack_pack(VALUE mMessagePack);
-
-#endif /* pack.h */
-
--- a/ruby/rbinit.c
+++ b/ruby/rbinit.c
@ -1,29 +0,0 @@
-/*
- * MessagePack for Ruby
- *
- * Copyright (C) 2008-2009 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 "pack.h"
-#include "unpack.h"
-
-static VALUE mMessagePack;
-
-void Init_msgpack(void)
-{
-	mMessagePack = rb_define_module("MessagePack");
-	Init_msgpack_unpack(mMessagePack);
-	Init_msgpack_pack(mMessagePack);
-}
-
--- a/ruby/test_case.rb
+++ b/ruby/test_case.rb
@ -1,225 +0,0 @@
-#!/usr/bin/env ruby
-require 'msgpack'
-require 'test/unit'
-
-class MessagePackTestFormat < Test::Unit::TestCase
-	def self.it(name, &block)
-		define_method("test_#{name}", &block)
-	end
-
-	it "nil" do
-		check 1, nil
-	end
-
-	it "true" do
-		check 1, true
-	end
-
-	it "false" do
-		check 1, false
-	end
-
-	it "zero" do
-		check 1, 0
-	end
-
-	it "positive fixnum" do
-		check 1, 1
-		check 1, (1<<6)
-		check 1, (1<<7)-1
-	end
-
-	it "positive int 8" do
-		check 1, -1
-		check 2, (1<<7)
-		check 2, (1<<8)-1
-	end
-
-	it "positive int 16" do
-		check 3, (1<<8)
-		check 3, (1<<16)-1
-	end
-
-	it "positive int 32" do
-		check 5, (1<<16)
-		check 5, (1<<32)-1
-	end
-
-	it "positive int 64" do
-		check 9, (1<<32)
-		check 9, (1<<64)-1
-	end
-
-	it "negative fixnum" do
-		check 1, -1
-		check 1, -((1<<5)-1)
-		check 1, -(1<<5)
-	end
-
-	it "negative int 8" do
-		check 2, -((1<<5)+1)
-		check 2, -(1<<7)
-	end
-
-	it "negative int 16" do
-		check 3, -((1<<7)+1)
-		check 3, -(1<<15)
-	end
-
-	it "negative int 32" do
-		check 5, -((1<<15)+1)
-		check 5, -(1<<31)
-	end
-
-	it "negative int 64" do
-		check 9, -((1<<31)+1)
-		check 9, -(1<<63)
-	end
-
-	it "double" do
-		check 9, 1.0
-		check 9, 0.1
-		check 9, -0.1
-		check 9, -1.0
-	end
-
-	it "fixraw" do
-		check_raw 1, 0
-		check_raw 1, (1<<5)-1
-	end
-
-	it "raw 16" do
-		check_raw 3, (1<<5)
-		check_raw 3, (1<<16)-1
-	end
-
-	it "raw 32" do
-		check_raw 5, (1<<16)
-		#check_raw 5, (1<<32)-1  # memory error
-	end
-
-	it "fixarray" do
-		check_array 1, 0
-		check_array 1, (1<<4)-1
-	end
-
-	it "array 16" do
-		check_array 3, (1<<4)
-		check_array 3, (1<<16)-1
-	end
-
-	it "array 32" do
-		check_array 5, (1<<16)
-		#check_array 5, (1<<32)-1  # memory error
-	end
-
-	it "nil" do
-		match nil, "\xc0"
-	end
-
-	it "false" do
-		match false, "\xc2"
-	end
-
-	it "true" do
-		match true, "\xc3"
-	end
-
-	it "0" do
-		match 0, "\x00"
-	end
-
-	it "127" do
-		match 127, "\x7f"
-	end
-
-	it "128" do
-		match 128, "\xcc\x80"
-	end
-
-	it "256" do
-		match 256, "\xcd\x01\x00"
-	end
-
-	it "-1" do
-		match -1, "\xff"
-	end
-
-	it "-33" do
-		match -33, "\xd0\xdf"
-	end
-
-	it "-129" do
-		match -129, "\xd1\xff\x7f"
-	end
-
-	it "{1=>1}" do
-		match ({1=>1}), "\x81\x01\x01"
-	end
-
-	it "1.0" do
-		match 1.0, "\xcb\x3f\xf0\x00\x00\x00\x00\x00\x00"
-	end
-
-	it "[]" do
-		match [], "\x90"
-	end
-
-	it "[0, 1, ..., 14]" do
-		match (0..14).to_a, "\x9f\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e"
-	end
-
-	it "[0, 1, ..., 15]" do
-		match (0..15).to_a, "\xdc\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
-	end
-
-	it "{}" do
-		match ({}), "\x80"
-	end
-
-	it "{0=>0, 1=>1, ..., 14=>14}" do
-		a = (0..14).to_a;
-		match Hash[*a.zip(a).flatten], "\x8f\x05\x05\x0b\x0b\x00\x00\x06\x06\x0c\x0c\x01\x01\x07\x07\x0d\x0d\x02\x02\x08\x08\x0e\x0e\x03\x03\x09\x09\x04\x04\x0a\x0a"
-	end
-
-	it "{0=>0, 1=>1, ..., 15=>15}" do
-		a = (0..15).to_a;
-		match Hash[*a.zip(a).flatten], "\xde\x00\x10\x05\x05\x0b\x0b\x00\x00\x06\x06\x0c\x0c\x01\x01\x07\x07\x0d\x0d\x02\x02\x08\x08\x0e\x0e\x03\x03\x09\x09\x0f\x0f\x04\x04\x0a\x0a"
-	end
-
-#	it "fixmap" do
-#		check_map 1, 0
-#		check_map 1, (1<<4)-1
-#	end
-#
-#	it "map 16" do
-#		check_map 3, (1<<4)
-#		check_map 3, (1<<16)-1
-#	end
-#
-#	it "map 32" do
-#		check_map 5, (1<<16)
-#		#check_map 5, (1<<32)-1  # memory error
-#	end
-
-	private
-	def check(len, obj)
-		v = obj.to_msgpack
-		assert_equal(v.length, len)
-		assert_equal(MessagePack.unpack(v), obj)
-	end
-
-	def check_raw(overhead, num)
-		check num+overhead, " "*num
-	end
-
-	def check_array(overhead, num)
-		check num+overhead, Array.new(num)
-	end
-
-	def match(obj, buf)
-		assert_equal(obj.to_msgpack, buf)
-		assert_equal(MessagePack::unpack(buf), obj)
-	end
-end
-
--- a/ruby/test_format.rb
+++ b/ruby/test_format.rb
@ -1,122 +0,0 @@
-require 'msgpack'
-
-@up = MessagePack::Unpacker.new
-
-def check(bytes, should)
-	puts "----"
-	@up.reset
-	src = bytes.pack('C*')
-	ret = @up.execute(src, 0)
-	if ret != src.length
-		puts "** EXTRA BYTES **"
-	end
-	puts bytes.map{|x|"%x"%x}.join(' ')
-	data = @up.data
-	p data
-	if data != should
-		puts "** TEST FAILED **"
-		p should
-	end
-end
-
-# SimpleValue
-check([
-	0x93, 0xc0, 0xc2, 0xc3,
-], [nil,false,true])
-
-# Fixnum
-check([
-	0x92,
-		0x93, 0x00, 0x40, 0x7f,
-		0x93, 0xe0, 0xf0, 0xff,
-], [[0,64,127], [-32,-16,-1]])
-
-# FixArray
-check([
-	0x92,
-		0x90,
-		0x91,
-			0x91, 0xc0,
-], [[],[[nil]]])
-
-
-# FixRaw
-check([
-	0x94,
-		0xa0,
-		0xa1, ?a,
-		0xa2, ?b, ?c,
-		0xa3, ?d, ?e, ?f,
-], ["","a","bc","def"])
-
-# FixMap
-check([
-	0x82,
-		0xc2, 0x81,
-			0xc0, 0xc0,
-		0xc3, 0x81,
-			0xc0, 0x80,
-], {false=>{nil=>nil}, true=>{nil=>{}}})
-
-# unsigned int
-check([
-	0x99,
-		0xcc, 0,
-		0xcc, 128,
-		0xcc, 255,
-		0xcd, 0x00, 0x00,
-		0xcd, 0x80, 0x00,
-		0xcd, 0xff, 0xff,
-		0xce, 0x00, 0x00, 0x00, 0x00,
-		0xce, 0x80, 0x00, 0x00, 0x00,
-		0xce, 0xff, 0xff, 0xff, 0xff,
-], [0, 128, 255, 0, 32768, 65535, 0, 2147483648, 4294967295])
-
-# signed int
-check([
-	0x99,
-		0xd0, 0,
-		0xd0, 128,
-		0xd0, 255,
-		0xd1, 0x00, 0x00,
-		0xd1, 0x80, 0x00,
-		0xd1, 0xff, 0xff,
-		0xd2, 0x00, 0x00, 0x00, 0x00,
-		0xd2, 0x80, 0x00, 0x00, 0x00,
-		0xd2, 0xff, 0xff, 0xff, 0xff,
-], [0, -128, -1, 0, -32768, -1, 0, -2147483648, -1])
-
-# raw
-check([
-	0x96,
-		0xda, 0x00, 0x00,
-		0xda, 0x00, 0x01, ?a,
-		0xda, 0x00, 0x02, ?a, ?b,
-		0xdb, 0x00, 0x00, 0x00, 0x00,
-		0xdb, 0x00, 0x00, 0x00, 0x01, ?a,
-		0xdb, 0x00, 0x00, 0x00, 0x02, ?a, ?b,
-], ["", "a", "ab", "", "a", "ab"])
-
-# array
-check([
-	0x96,
-		0xdc, 0x00, 0x00,
-		0xdc, 0x00, 0x01, 0xc0,
-		0xdc, 0x00, 0x02, 0xc2, 0xc3,
-		0xdd, 0x00, 0x00, 0x00, 0x00,
-		0xdd, 0x00, 0x00, 0x00, 0x01, 0xc0,
-		0xdd, 0x00, 0x00, 0x00, 0x02, 0xc2, 0xc3
-], [[], [nil], [false,true], [], [nil], [false,true]])
-
-# map
-check([
-	0x96,
-		0xde, 0x00, 0x00,
-		0xde, 0x00, 0x01, 0xc0, 0xc2,
-		0xde, 0x00, 0x02, 0xc0, 0xc2, 0xc3, 0xc2,
-		0xdf, 0x00, 0x00, 0x00, 0x00,
-		0xdf, 0x00, 0x00, 0x00, 0x01, 0xc0, 0xc2,
-		0xdf, 0x00, 0x00, 0x00, 0x02, 0xc0, 0xc2, 0xc3, 0xc2,
-], [{}, {nil=>false}, {true=>false, nil=>false}, {}, {nil=>false}, {true=>false, nil=>false}])
-
-
--- a/ruby/test_pack.rb
+++ b/ruby/test_pack.rb
@ -1,58 +0,0 @@
-require 'msgpack'
-
-def check(data)
-	puts "---"
-	pack = data.to_msgpack
-	p data
-	puts pack.unpack('C*').map{|x|"%02x"%x}.join(' ')
-	re = MessagePack::unpack(pack)
-	if re != data
-		p re
-		puts "** TEST FAILED **"
-	end
-end
-
-check 0
-check 1
-check 127
-check 128
-check 255
-check 256
-check 65535
-check 65536
-check -1
-check -32
-check -33
-check -128
-check -129
-check -32768
-check -32769
-
-check 1.0
-
-check ""
-check "a"
-check "a"*31
-check "a"*32
-
-check nil
-check true
-check false
-
-check []
-check [[]]
-check [[], nil]
-
-check( {nil=>0} )
-
-check (1<<23)
-__END__
-
-ary = []
-i = 0
-while i < (1<<16)
-	ary << i
-	i += 1
-end
-check ary
-
--- a/ruby/unpack.c
+++ b/ruby/unpack.c
@ -1,318 +0,0 @@
-/*
- * MessagePack for Ruby unpacking routine
- *
- * Copyright (C) 2008-2009 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 "ruby.h"
-#include "msgpack/unpack_define.h"
-
-
-typedef struct {
-	int finished;
-	VALUE source;
-} unpack_user;
-
-
-#define msgpack_unpack_struct(name) \
-	struct template ## name
-
-#define msgpack_unpack_func(ret, name) \
-	ret template ## name
-
-#define msgpack_unpack_callback(name) \
-	template_callback ## name
-
-#define msgpack_unpack_object VALUE
-
-#define msgpack_unpack_user unpack_user
-
-
-struct template_context;
-typedef struct template_context msgpack_unpack_t;
-
-static void template_init(msgpack_unpack_t* u);
-
-static VALUE template_data(msgpack_unpack_t* u);
-
-static int template_execute(msgpack_unpack_t* u,
-		const char* data, size_t len, size_t* off);
-
-
-static inline VALUE template_callback_root(unpack_user* u)
-{ return Qnil; }
-
-static inline int template_callback_uint8(unpack_user* u, uint8_t d, VALUE* o)
-{ *o = INT2FIX(d); return 0; }
-
-static inline int template_callback_uint16(unpack_user* u, uint16_t d, VALUE* o)
-{ *o = INT2FIX(d); return 0; }
-
-static inline int template_callback_uint32(unpack_user* u, uint32_t d, VALUE* o)
-{ *o = UINT2NUM(d); return 0; }
-
-static inline int template_callback_uint64(unpack_user* u, uint64_t d, VALUE* o)
-{ *o = rb_ull2inum(d); return 0; }
-
-static inline int template_callback_int8(unpack_user* u, int8_t d, VALUE* o)
-{ *o = INT2FIX((long)d); return 0; }
-
-static inline int template_callback_int16(unpack_user* u, int16_t d, VALUE* o)
-{ *o = INT2FIX((long)d); return 0; }
-
-static inline int template_callback_int32(unpack_user* u, int32_t d, VALUE* o)
-{ *o = INT2NUM((long)d); return 0; }
-
-static inline int template_callback_int64(unpack_user* u, int64_t d, VALUE* o)
-{ *o = rb_ll2inum(d); return 0; }
-
-static inline int template_callback_float(unpack_user* u, float d, VALUE* o)
-{ *o = rb_float_new(d); return 0; }
-
-static inline int template_callback_double(unpack_user* u, double d, VALUE* o)
-{ *o = rb_float_new(d); return 0; }
-
-static inline int template_callback_nil(unpack_user* u, VALUE* o)
-{ *o = Qnil; return 0; }
-
-static inline int template_callback_true(unpack_user* u, VALUE* o)
-{ *o = Qtrue; return 0; }
-
-static inline int template_callback_false(unpack_user* u, VALUE* o)
-{ *o = Qfalse; return 0;}
-
-static inline int template_callback_array(unpack_user* u, unsigned int n, VALUE* o)
-{ *o = rb_ary_new2(n); return 0; }
-
-static inline int template_callback_array_item(unpack_user* u, VALUE* c, VALUE o)
-{ rb_ary_push(*c, o); return 0; }  // FIXME set value directry RARRAY_PTR(obj)[RARRAY_LEN(obj)++]
-
-static inline int template_callback_map(unpack_user* u, unsigned int n, VALUE* o)
-{ *o = rb_hash_new(); return 0; }
-
-static inline int template_callback_map_item(unpack_user* u, VALUE* c, VALUE k, VALUE v)
-{ rb_hash_aset(*c, k, v); return 0; }
-
-static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, VALUE* o)
-{ *o = (l == 0) ? rb_str_new(0,0) : rb_str_substr(u->source, p - b, l); return 0; }
-
-
-#include "msgpack/unpack_template.h"
-
-
-#define UNPACKER(from, name) \
-	msgpack_unpack_t *name = NULL; \
-	Data_Get_Struct(from, msgpack_unpack_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 VALUE cUnpacker;
-static VALUE eUnpackError;
-
-static void MessagePack_Unpacker_free(void* data)
-{
-	if(data) { free(data); }
-}
-
-static void MessagePack_Unpacker_mark(msgpack_unpack_t *mp)
-{
-	unsigned int i;
-	for(i=0; i < mp->top; ++i) {
-		rb_gc_mark(mp->stack[i].obj);
-		rb_gc_mark(mp->stack[i].map_key);
-	}
-}
-
-static VALUE MessagePack_Unpacker_alloc(VALUE klass)
-{
-	VALUE obj;
-	msgpack_unpack_t* mp = ALLOC_N(msgpack_unpack_t, 1);
-	obj = Data_Wrap_Struct(klass, MessagePack_Unpacker_mark,
-			MessagePack_Unpacker_free, mp);
-	return obj;
-}
-
-static VALUE MessagePack_Unpacker_reset(VALUE self)
-{
-	UNPACKER(self, mp);
-	template_init(mp);
-	unpack_user u = {0, Qnil};
-	mp->user = u;
-	return self;
-}
-
-static VALUE MessagePack_Unpacker_initialize(VALUE self)
-{
-	return MessagePack_Unpacker_reset(self);
-}
-
-
-static VALUE MessagePack_Unpacker_execute_impl(VALUE args)
-{
-	VALUE self = ((VALUE*)args)[0];
-	VALUE data = ((VALUE*)args)[1];
-
-	UNPACKER(self, mp);
-	size_t from = NUM2UINT(((VALUE*)args)[2]);
-	char* dptr = RSTRING_PTR(data);
-	long dlen = FIX2LONG(((VALUE*)args)[3]);
-	int ret;
-
-	if(from >= dlen) {
-		rb_raise(eUnpackError, "offset is bigger than data buffer size.");
-	}
-
-	mp->user.source = data;
-	ret = template_execute(mp, dptr, (size_t)dlen, &from);
-	mp->user.source = Qnil;
-
-	if(ret < 0) {
-		rb_raise(eUnpackError, "parse error.");
-	} else if(ret > 0) {
-		mp->user.finished = 1;
-		return ULONG2NUM(from);
-	} else {
-		mp->user.finished = 0;
-		return ULONG2NUM(from);
-	}
-}
-
-static VALUE MessagePack_Unpacker_execute_rescue(VALUE nouse)
-{
-	rb_gc_enable();
-#ifdef RUBY_VM
-	rb_exc_raise(rb_errinfo());
-#else
-	rb_exc_raise(ruby_errinfo);
-#endif
-}
-
-static VALUE MessagePack_Unpacker_execute_limit(VALUE self, VALUE data,
-		VALUE off, VALUE limit)
-{
-	// FIXME execute実行中はmp->topが更新されないのでGC markが機能しない
-	rb_gc_disable();
-	VALUE args[4] = {self, data, off, limit};
-	VALUE ret = rb_rescue(MessagePack_Unpacker_execute_impl, (VALUE)args,
-			MessagePack_Unpacker_execute_rescue, Qnil);
-	rb_gc_enable();
-	return ret;
-}
-
-static VALUE MessagePack_Unpacker_execute(VALUE self, VALUE data, VALUE off)
-{
-	return MessagePack_Unpacker_execute_limit(self, data, off,
-			LONG2FIX(RSTRING_LEN(data)));
-}
-
-static VALUE MessagePack_Unpacker_finished_p(VALUE self)
-{
-	UNPACKER(self, mp);
-	if(mp->user.finished) {
-		return Qtrue;
-	}
-	return Qfalse;
-}
-
-static VALUE MessagePack_Unpacker_data(VALUE self)
-{
-	UNPACKER(self, mp);
-	return template_data(mp);
-}
-
-
-static VALUE MessagePack_unpack_impl(VALUE args)
-{
-	msgpack_unpack_t* mp = (msgpack_unpack_t*)((VALUE*)args)[0];
-	VALUE data = ((VALUE*)args)[1];
-
-	size_t from = 0;
-	char* dptr = RSTRING_PTR(data);
-	long dlen = FIX2LONG(((VALUE*)args)[2]);
-	int ret;
-
-	mp->user.source = data;
-	ret = template_execute(mp, dptr, (size_t)dlen, &from);
-	mp->user.source = Qnil;
-
-	if(ret < 0) {
-		rb_raise(eUnpackError, "parse error.");
-	} else if(ret == 0) {
-		rb_raise(eUnpackError, "insufficient bytes.");
-	} else {
-		if(from < dlen) {
-			rb_raise(eUnpackError, "extra bytes.");
-		}
-		return template_data(mp);
-	}
-}
-
-static VALUE MessagePack_unpack_rescue(VALUE args)
-{
-	rb_gc_enable();
-#ifdef RUBY_VM
-	rb_exc_raise(rb_errinfo());
-#else
-	rb_exc_raise(ruby_errinfo);
-#endif
-}
-
-static VALUE MessagePack_unpack_limit(VALUE self, VALUE data, VALUE limit)
-{
-	CHECK_STRING_TYPE(data);
-
-	msgpack_unpack_t mp;
-	template_init(&mp);
-	unpack_user u = {0, Qnil};
-	mp.user = u;
-
-	rb_gc_disable();
-	VALUE args[3] = {(VALUE)&mp, data, limit};
-	VALUE ret = rb_rescue(MessagePack_unpack_impl, (VALUE)args,
-			MessagePack_unpack_rescue, Qnil);
-	rb_gc_enable();
-
-	return ret;
-}
-
-static VALUE MessagePack_unpack(VALUE self, VALUE data)
-{
-	return MessagePack_unpack_limit(self, data,
-			LONG2FIX(RSTRING_LEN(data)));
-}
-
-
-void Init_msgpack_unpack(VALUE mMessagePack)
-{
-	eUnpackError = rb_define_class_under(mMessagePack, "UnpackError", rb_eStandardError);
-	cUnpacker = rb_define_class_under(mMessagePack, "Unpacker", rb_cObject);
-	rb_define_alloc_func(cUnpacker, MessagePack_Unpacker_alloc);
-	rb_define_method(cUnpacker, "initialize", MessagePack_Unpacker_initialize, 0);
-	rb_define_method(cUnpacker, "execute", MessagePack_Unpacker_execute, 2);
-	rb_define_method(cUnpacker, "execute_limit", MessagePack_Unpacker_execute_limit, 3);
-	rb_define_method(cUnpacker, "finished?", MessagePack_Unpacker_finished_p, 0);
-	rb_define_method(cUnpacker, "data", MessagePack_Unpacker_data, 0);
-	rb_define_method(cUnpacker, "reset", MessagePack_Unpacker_reset, 0);
-	rb_define_module_function(mMessagePack, "unpack", MessagePack_unpack, 1);
-	rb_define_module_function(mMessagePack, "unpack_limit", MessagePack_unpack_limit, 2);
-}
-
-
--- a/ruby/unpack.h
+++ b/ruby/unpack.h
@ -1,26 +0,0 @@
-/*
- * MessagePack for Ruby unpacking routine
- *
- * Copyright (C) 2008-2009 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 UNPACK_H__
-#define UNPACK_H__
-
-#include "ruby.h"
-
-void Init_msgpack_unpack(VALUE mMessagePack);
-
-#endif /* unpack.h */
-
				`@ -1 +0,0 @@`
				`FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>`