Merge pull request #1053 from redboltz/unify_project_name_c

Unify all package related names to msgpack-c.

.github/workflows/coverage.yml

@@ -0,0 +1,53 @@
+name: coverage
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+    - c_master
+    tags:
+    - '*'
+
+jobs:
+
+  codecov:
+    timeout-minutes: 30
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: install depends
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-multilib lcov
+    - name: Compile tests
+      run: |
+        # install gtest
+        BASE=`pwd`
+        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+        unzip -q googletest-release-1.7.0.zip
+        cd googletest-release-1.7.0
+        g++ -m64 src/gtest-all.cc -I. -Iinclude -c -fPIC
+        g++ -m64 src/gtest_main.cc -I. -Iinclude -c -fPIC
+        ar -rv libgtest.a gtest-all.o
+        ar -rv libgtest_main.a gtest_main.o
+        mkdir -p ${BASE}/usr/include
+        cp -r include/gtest ${BASE}/usr/include
+        mkdir -p ${BASE}/usr/lib
+        mv *.a ${BASE}/usr/lib
+        cd ..
+
+        mkdir build && cd build
+        CMAKE_LIBRARY_PATH="${BASE}/build" GTEST_ROOT="${BASE}/usr" CMAKE_PREFIX_PATH="${BASE}/usr/gcc/lib64/cmake" cmake -DMSGPACK_32BIT=OFF -DBUILD_SHARED_LIBS=ON -DMSGPACK_CHAR_SIGN=signed -DMSGPACK_BUILD_EXAMPLES=ON -DMSGPACK_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug -DMSGPACK_GEN_COVERAGE=ON ..
+        make -j4
+        make test
+    - name: Upload coverage to Codecov
+      working-directory: build
+      run: |
+        # Create lcov report
+        lcov --capture --directory . --output-file coverage.info
+        lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter system-files
+        lcov --list coverage.info # debug info
+        # Uploading report to CodeCov
+        bash <(curl -s https://codecov.io/bash) -f coverage.info || echo "Codecov did not collect coverage reports"

.github/workflows/gha.yml

@@ -0,0 +1,233 @@
+name: CI
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+    - c_master
+    tags:
+    - '*'
+
+jobs:
+  macos:
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3]
+    steps:
+    - uses: actions/checkout@v1
+    - name: build and test
+      env:
+        CC: clang
+        CXX: clang++
+      shell: bash
+      run: |
+        BASE=`pwd`;
+
+        # matrix config
+        ACTION="ci/build_cmake.sh"
+        export ARCH="64"
+        if [ ${{ matrix.pattern }} == 0 ]; then
+          export SHARED="ON"
+          export SAN="-fsanitize=address -fno-omit-frame-pointer"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 1 ]; then
+          export SHARED="ON"
+          export SAN="-fsanitize=address -fno-omit-frame-pointer"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 2 ]; then
+          export SHARED="OFF"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 3 ]; then
+          export SHARED="OFF"
+          export CHAR_SIGN="unsigned"
+        fi
+
+        # install gtest
+        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+        unzip -q googletest-release-1.7.0.zip
+        cd googletest-release-1.7.0
+        $CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c
+        $CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c
+        ar -rv libgtest.a gtest-all.o
+        ar -rv libgtest_main.a gtest_main.o
+        mkdir -p ${BASE}/usr/include
+        cp -r include/gtest ${BASE}/usr/include
+        mkdir -p ${BASE}/usr/lib
+        mv *.a ${BASE}/usr/lib
+        cd ..
+
+        # build and test
+        CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" GTEST_ROOT="${BASE}/usr" CFLAGS="-Werror -g -fsanitize=undefined  -fno-sanitize-recover=all" CXXFLAGS="-Werror -g -ggdb3 -fsanitize=undefined  -fno-sanitize-recover=all" ${ACTION}
+
+  linux:
+    runs-on: ubuntu-18.04
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3, 4, 5, 6, 7, 8]
+    steps:
+    - uses: actions/checkout@v1
+    - name: install build depends
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-multilib clang-8 valgrind
+    - name: build and test
+      shell: bash
+      run: |
+        BASE=`pwd`;
+
+        # matrix config
+        if [ ${{ matrix.pattern }} == 0 ]; then
+          export CC=clang
+          export CXX=clang++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="64"
+          export SHARED="ON"
+          export SAN="-fsanitize=address -fno-omit-frame-pointer"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 1 ]; then
+          export CC=clang
+          export CXX=clang++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="32"
+          export SHARED="ON"
+          export SAN="-fsanitize=address -fno-omit-frame-pointer"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 2 ]; then
+          export CC=clang
+          export CXX=clang++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="64"
+          export SHARED="ON"
+          export SAN="-fsanitize=address -fno-omit-frame-pointer"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 3 ]; then
+          export CC=clang
+          export CXX=clang++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="32"
+          export SHARED="OFF"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 4 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="64"
+          export SHARED="ON"
+          export SAN="-fsanitize=address -fno-omit-frame-pointer"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 5 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="32"
+          export SHARED="ON"
+          export SAN="-fsanitize=address -fno-omit-frame-pointer"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 6 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="64"
+          export SHARED="ON"
+          export SAN="-fsanitize=address -fno-omit-frame-pointer"
+          export CHAR_SIGN="unsigned"
+        fi
+        if [ ${{ matrix.pattern }} == 7 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake.sh"
+          export ARCH="32"
+          export SHARED="OFF"
+          export CHAR_SIGN="signed"
+        fi
+        if [ ${{ matrix.pattern }} == 8 ]; then
+          export CC=gcc
+          export CXX=g++
+          ACTION="ci/build_cmake_embedded.sh"
+          export ARCH="64"
+        fi
+
+        # install gtest
+        wget https://github.com/google/googletest/archive/release-1.7.0.zip -O googletest-release-1.7.0.zip
+        unzip -q googletest-release-1.7.0.zip
+        cd googletest-release-1.7.0
+        $CXX -m${ARCH} src/gtest-all.cc -I. -Iinclude -c -fPIC
+        $CXX -m${ARCH} src/gtest_main.cc -I. -Iinclude -c -fPIC
+        ar -rv libgtest.a gtest-all.o
+        ar -rv libgtest_main.a gtest_main.o
+        mkdir -p ${BASE}/usr/include
+        cp -r include/gtest ${BASE}/usr/include
+        mkdir -p ${BASE}/usr/lib
+        mv *.a ${BASE}/usr/lib
+        cd ..
+
+        # install zlib
+        if [ ${ARCH} == 32 ]; then
+          sudo apt-get install lib32z1-dev
+        fi
+
+        # build and test
+        CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" GTEST_ROOT="${BASE}/usr" CFLAGS="-Werror -g -fsanitize=undefined  -fno-sanitize-recover=all" CXXFLAGS="-Werror -g -ggdb3 -fsanitize=undefined  -fno-sanitize-recover=all" ${ACTION}
+
+  windows:
+    runs-on: windows-2019
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3]
+    steps:
+    - uses: actions/checkout@v2.0.0
+    - name: Cache vcpkg
+      id: cache-vcpkg
+      uses: actions/cache@v1.1.2
+      with:
+        path: C:/vcpkg/installed
+        key: windows-2019-vcpkg-v2
+    - name: Build dependencies
+      if: steps.cache-vcpkg.outputs.cache-hit != 'true'
+      shell: powershell
+      run: |
+        vcpkg install gtest:x64-windows gtest:x86-windows
+        vcpkg install zlib:x64-windows zlib:x86-windows
+    - name: Build and test
+      shell: powershell
+      run: |
+        if (${{ matrix.pattern }} -eq 0) {
+          $ARCH="x64"
+          $SHARED="ON"
+        }
+        elseif (${{ matrix.pattern }} -eq 1) {
+          $ARCH="x64"
+          $SHARED="OFF"
+        }
+        elseif (${{ matrix.pattern }} -eq 2) {
+          $ARCH="Win32"
+          $SHARED="ON"
+        }
+        else {
+          $ARCH="Win32"
+          $SHARED="OFF"
+        }
+
+        $CUR=(Get-Location).Path
+        md build
+        cd build
+        cmake -A $ARCH -DBUILD_SHARED_LIBS=$SHARED -DCMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" "-DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 /EHsc /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING" ..
+        cmake --build . --config Release
+        $pathbak="$env:PATH"
+        $env:PATH="C:\vcpkg\installed\x64-windows\bin;$CUR\build\Release;$pathbak"
+        ctest -V
+        $env:PATH=$pathbak

.gitignore

@@ -1,5 +1,7 @@
 # Files generated by the bootstrap script.
 /INSTALL
+/AUTHORS
+/ChangeLog
 /NEWS
 /README
 /ac/
@@ -17,8 +19,9 @@ Makefile.in
 /config.log
 /config.status
 /libtool
-/msgpack.pc
+/msgpack-c.pc
 /src/msgpack/version.h
+/src/msgpack/version.hpp
 /stamp-h1
 Makefile
 .deps

.travis.yml

@@ -1,25 +0,0 @@
-language: cpp
-cache:
-  - apt
-compiler:
-  - clang
-  - gcc
-before_install:
-# We need this line to have g++4.8 available in apt
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-  - sudo apt-get update -qq
-  - sudo apt-get update
-  - sudo apt-get install valgrind
-  - sudo apt-get install libgtest-dev
-  - "cd /usr/src/gtest && sudo cmake . && sudo cmake --build . && sudo mv libg* /usr/local/lib/ ; cd -"
-install:
-  - sudo apt-get install -qq gcc-4.8 g++-4.8
-# We want to compile with g++ 4.8 when rather than the default g++
-  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90
-
-env:
-  - ACTION="ci/build_autotools.sh" PARAM="cpp03"
-  - ACTION="ci/build_cmake.sh"     PARAM="cpp03"
-
-script:
-  - git clean -xdf && ${ACTION} ${PARAM}

AUTHORS

@@ -1 +0,0 @@
-FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>

CHANGELOG.md

@@ -0,0 +1,434 @@
+# 2023-02-28 version 6.0.0
+## << breaking changes >>
+  * Change CMake package name of C library to msgpack-c (#1053)
+    Unified all C package, library, cmake, tarball name become msgpack-c.
+
+# 2023-01-10 version 5.0.0
+  * Add additional address sanitizer for CI. (#1023)
+## << breaking changes >>
+  * Change CMake package name of C library to msgpackc (#1044, #1049)
+
+# 2021-08-01 version 4.0.0
+  * Fix and improve alignment logic (#962)
+  * Fix iovec name conflict (#953)
+  * Fix empty string print (#942)
+  * Fix buffer ptr size (#899)
+  * Fix UB. Check null pointer before using memcpy() (#890)
+  * Improve CI environment (#885, #899)
+
+## << breaking changes >>
+* Separate C part of the msgpack-c from C/C++ mixed msgpack-c (#876, #878)
+
+
+# 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.

CMakeLists.txt

@@ -1,193 +1,333 @@
-CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6)
+CMAKE_MINIMUM_REQUIRED (VERSION 2.8.12)
-PROJECT (msgpack)
 
-SET (VERSION 0.5.9)
+IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR
-SET (VERSION_MAJOR 0)
+    (CMAKE_VERSION VERSION_EQUAL 3.1))
-SET (VERSION_MINOR 5)
+    CMAKE_POLICY(SET CMP0054 NEW)
+ENDIF ()
 
+PROJECT (msgpack-c)
+
+FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.h contents)
+STRING (REGEX MATCH "#define MSGPACK_VERSION_MAJOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
+SET (VERSION_MAJOR ${CMAKE_MATCH_1})
+STRING (REGEX MATCH "#define MSGPACK_VERSION_MINOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
+SET (VERSION_MINOR ${CMAKE_MATCH_1})
+STRING (REGEX MATCH "#define MSGPACK_VERSION_REVISION *([0-9a-zA-Z_]*)" NULL_OUT ${contents})
+SET (VERSION_REVISION ${CMAKE_MATCH_1})
+SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION})
+
+LIST (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
 SET (prefix ${CMAKE_INSTALL_PREFIX})
 SET (exec_prefix "\${prefix}")
 SET (libdir "\${exec_prefix}/lib")
 SET (includedir "\${prefix}/include")
 
+OPTION (MSGPACK_32BIT "32bit compile" OFF)
+
+INCLUDE(TestBigEndian)
+TEST_BIG_ENDIAN(BIGENDIAN)
+IF (BIGENDIAN)
+    SET(MSGPACK_ENDIAN_BIG_BYTE 1)
+    SET(MSGPACK_ENDIAN_LITTLE_BYTE 0)
+ELSE ()
+    SET(MSGPACK_ENDIAN_BIG_BYTE 0)
+        SET(MSGPACK_ENDIAN_LITTLE_BYTE 1)
+ENDIF ()
+
+CONFIGURE_FILE (
+    cmake/sysdep.h.in
+    include/msgpack/sysdep.h
+    @ONLY
+)
+
+CONFIGURE_FILE (
+    cmake/pack_template.h.in
+    include/msgpack/pack_template.h
+    @ONLY
+)
+
+IF (APPLE)
+    SET(CMAKE_MACOSX_RPATH ON)
+    SET(CMAKE_SKIP_BUILD_RPATH FALSE)
+    SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
+    SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+    SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+    LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
+    IF ("${isSystemDir}" STREQUAL "-1")
+        SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+    ENDIF ()
+ENDIF ()
+
+IF (MSGPACK_32BIT)
+   IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+      SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
+      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
+   ELSEIF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+      SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
+      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
+   ENDIF ()
+ENDIF ()
+
+OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
+
+IF (MSGPACK_CHAR_SIGN)
+   SET (CMAKE_C_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_C_FLAGS}")
+ENDIF ()
+
 FIND_PACKAGE (GTest)
 FIND_PACKAGE (ZLIB)
 FIND_PACKAGE (Threads)
 IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND)
     OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON)
+    OPTION (MSGPACK_GEN_COVERAGE "Enable running gcov to get a test coverage report." OFF)
 ENDIF ()
 
-OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON)
+IF (DEFINED BUILD_SHARED_LIBS)
-
+    IF (BUILD_SHARED_LIBS)
-INCLUDE (CheckCXXSourceCompiles)
+        IF (DEFINED MSGPACK_ENABLE_SHARED AND NOT MSGPACK_ENABLE_SHARED)
-CHECK_CXX_SOURCE_COMPILES ("
+            MESSAGE(WARNING "MSGPACK_ENABLE_SHARED is overridden to ON by BUILD_SHARED_LIBS")
-#include <bits/atomicity.h>
+        ENDIF ()
-int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; }
+        SET (MSGPACK_ENABLE_SHARED ON)
-int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; }
+        IF (DEFINED MSGPACK_ENABLE_STATIC AND MSGPACK_ENABLE_STATIC)
-int main(int argc, char * argv[])
+            MESSAGE(WARNING "MSGPACK_ENABLE_STATIC is overridden to OFF by BUILD_SHARED_LIBS")
-{
+        ENDIF ()
-	atomic_sub(1);
+        SET (MSGPACK_ENABLE_STATIC OFF)
-	atomic_add(1);
+    ELSE ()
-}
+        IF (DEFINED MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_SHARED)
-" MSGPACK_ENABLE_GCC_CXX_ATOMIC)
+            MESSAGE(WARNING "MSGPACK_ENABLE_SHARED is overridden to OFF by BUILD_SHARED_LIBS")
-
+        ENDIF ()
-IF (MSGPACK_ENABLE_CXX)
+        SET (MSGPACK_ENABLE_SHARED OFF)
-	LIST (APPEND msgpack_SOURCES
+        IF (DEFINED MSGPACK_ENABLE_STATIC AND NOT MSGPACK_ENABLE_STATIC)
-		src/object.cpp
+            MESSAGE(WARNING "MSGPACK_ENABLE_STATIC is overridden to ON by BUILD_SHARED_LIBS")
-	)
+        ENDIF ()
+        SET (MSGPACK_ENABLE_STATIC ON)
+    ENDIF ()
+ELSE ()
+    IF (NOT DEFINED MSGPACK_ENABLE_SHARED)
+        SET (MSGPACK_ENABLE_SHARED ON)
+    ENDIF ()
+    IF (NOT DEFINED MSGPACK_ENABLE_STATIC)
+        SET (MSGPACK_ENABLE_STATIC ON)
+    ENDIF ()
+    SET (BUILD_SHARED_LIBS ${MSGPACK_ENABLE_SHARED})
 ENDIF ()
 
-IF (MSGPACK_ENABLE_GCC_CXX_ATOMIC)
+INCLUDE (Files.cmake)
-	LIST (APPEND msgpack_SOURCES
-		src/gcc_atomic.cpp
-	)
-ENDIF ()
-
-
-LIST (APPEND msgpack_SOURCES
-	src/unpack.c
-	src/objectc.c
-	src/version.c
-	src/vrefbuffer.c
-	src/zone.c
-)
-
-LIST (APPEND msgpack_HEADERS
-	src/msgpack/pack_define.h
-	src/msgpack/pack_template.h
-	src/msgpack/unpack_define.h
-	src/msgpack/unpack_template.h
-	src/msgpack/sysdep.h
-	src/msgpack/sbuffer.h
-	src/msgpack/version.h
-	src/msgpack/vrefbuffer.h
-	src/msgpack/zbuffer.h
-	src/msgpack/fbuffer.h
-	src/msgpack/pack.h
-	src/msgpack/unpack.h
-	src/msgpack/object.h
-	src/msgpack/zone.h
-)
-
-IF (MSGPACK_ENABLE_CXX)
-	LIST (APPEND msgpack_HEADERS
-		src/msgpack.hpp
-		src/msgpack/sbuffer.hpp
-		src/msgpack/vrefbuffer.hpp
-		src/msgpack/zbuffer.hpp
-		src/msgpack/fbuffer.hpp
-		src/msgpack/pack.hpp
-		src/msgpack/unpack.hpp
-		src/msgpack/object.hpp
-		src/msgpack/zone.hpp
-		src/msgpack/type.hpp
-		src/msgpack/type/bool.hpp
-		src/msgpack/type/deque.hpp
-		src/msgpack/type/float.hpp
-		src/msgpack/type/fixint.hpp
-		src/msgpack/type/int.hpp
-		src/msgpack/type/list.hpp
-		src/msgpack/type/map.hpp
-		src/msgpack/type/nil.hpp
-		src/msgpack/type/pair.hpp
-		src/msgpack/type/raw.hpp
-		src/msgpack/type/set.hpp
-		src/msgpack/type/string.hpp
-		src/msgpack/type/vector.hpp
-		src/msgpack/type/tuple.hpp
-		src/msgpack/type/define.hpp
-		src/msgpack/type/tr1/unordered_map.hpp
-		src/msgpack/type/tr1/unordered_set.hpp
-	)
-ENDIF ()
-
-EXECUTE_PROCESS (
-	COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack
-)
 
 CONFIGURE_FILE (
-	src/msgpack/version.h.in
+    msgpack-c.pc.in
-	${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.h
+    msgpack-c.pc
-)
-
-CONFIGURE_FILE (
-	msgpack.pc.in
-	msgpack.pc
     @ONLY
 )
 
-INCLUDE_DIRECTORIES (
+IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
-	./
+    ADD_LIBRARY (msgpack-c
-	src/
+        ${msgpack-c_SOURCES}
-	src/msgpack/
+        ${msgpack-c_HEADERS}
-	${CMAKE_CURRENT_BINARY_DIR}/src/
+    )
-	${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/
-)
 
-ADD_LIBRARY (msgpack SHARED
+    SET_TARGET_PROPERTIES (msgpack-c PROPERTIES SOVERSION 2 VERSION 2.0.0)
-	${msgpack_SOURCES}
-	${msgpack_HEADERS}
-)
 
-ADD_LIBRARY (msgpack-static STATIC
+    TARGET_INCLUDE_DIRECTORIES (msgpack-c
-	${msgpack_SOURCES}
+        PUBLIC
-	${msgpack_HEADERS}
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-)
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include/msgpack>
+            $<INSTALL_INTERFACE:include>
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+ENDIF ()
 
-SET_TARGET_PROPERTIES (msgpack-static PROPERTIES OUTPUT_NAME "msgpack")
+
-SET_TARGET_PROPERTIES (msgpack PROPERTIES IMPORT_SUFFIX "_import.lib")
+IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
-SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 3.0.0)
+    ADD_LIBRARY (msgpack-c-static STATIC
+        ${msgpack-c_SOURCES}
+        ${msgpack-c_HEADERS}
+    )
+
+    TARGET_INCLUDE_DIRECTORIES (msgpack-c-static
+        PUBLIC
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include/msgpack>
+            $<INSTALL_INTERFACE:include>
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+
+    SET_TARGET_PROPERTIES (msgpack-c-static PROPERTIES OUTPUT_NAME "msgpack-c")
+
+    IF (MSGPACK_ENABLE_SHARED)
+        IF (MSVC)
+            SET_TARGET_PROPERTIES (msgpack-c PROPERTIES IMPORT_SUFFIX "_import.lib")
+        ELSEIF (MINGW)
+            SET_TARGET_PROPERTIES (msgpack-c PROPERTIES IMPORT_SUFFIX ".dll.a")
+        ENDIF ()
+    ENDIF ()
+ENDIF ()
+
+IF (MSGPACK_GEN_COVERAGE)
+    IF (NOT MSGPACK_BUILD_TESTS)
+        MESSAGE(FATAL_ERROR "Coverage requires -DMSGPACK_BUILD_TESTS=ON")
+    ENDIF ()
+    STRING(TOUPPER "${CMAKE_BUILD_TYPE}" UPPER_CMAKE_BUILD_TYPE)
+    IF (NOT "${UPPER_CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
+        MESSAGE(FATAL_ERROR "Coverage requires -DCMAKE_BUILD_TYPE=Debug")
+    ENDIF ()
+
+    INCLUDE(CodeCoverage)
+    SET (CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} ${COVERAGE_FLAGS}")
+
+    SETUP_TARGET_FOR_COVERAGE(coverage make coverage test)
+ENDIF ()
 
 IF (MSGPACK_BUILD_TESTS)
     ENABLE_TESTING ()
+    list(APPEND CMAKE_CTEST_ARGUMENTS "--output-on-failure")
+    # MEMORYCHECK_COMMAND_OPTIONS needs to place prior to CTEST_MEMORYCHECK_COMMAND
+    SET (MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --show-leak-kinds=definite,possible --error-exitcode=1")
+    FIND_PROGRAM(CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
+    INCLUDE(Dart)
     ADD_SUBDIRECTORY (test)
 ENDIF ()
 
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
-	SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3 -DPIC")
+    IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
-	SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3" )
+        SET_PROPERTY (TARGET msgpack-c APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra -DPIC")
-ENDIF ()
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-	IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-		STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-	ELSE ()
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
     ENDIF ()
+    IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
+       SET_PROPERTY (TARGET msgpack-c-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra" )
+    ENDIF ()
+ENDIF ()
+
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+    IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
+        SET_PROPERTY (TARGET msgpack-c APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    ENDIF ()
+    IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
+        SET_PROPERTY (TARGET msgpack-c-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    ENDIF ()
+ENDIF ()
+
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+    IF (CMAKE_C_FLAGS MATCHES "/W[0-4]")
+        STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+    ELSE ()
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 /WX")
+    ENDIF ()
+ENDIF ()
+
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+    IF (CMAKE_C_FLAGS MATCHES "/W[0-4]")
+        STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+    ELSE ()
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 /WX")
+    ENDIF ()
+ENDIF ()
+
+IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC10")
+    SET_SOURCE_FILES_PROPERTIES(${msgpack-c_SOURCES} PROPERTIES LANGUAGE C)
+ENDIF ()
+
+IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
+    SET (CMAKE_C_FLAGS   "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_C_FLAGS}")
+ENDIF ()
+
+IF (NOT DEFINED CMAKE_INSTALL_BINDIR)
+    SET(CMAKE_INSTALL_BINDIR bin)
 ENDIF ()
 
 IF (NOT DEFINED CMAKE_INSTALL_LIBDIR)
     SET(CMAKE_INSTALL_LIBDIR lib)
 ENDIF ()
 
-INSTALL (TARGETS msgpack msgpack-static DESTINATION ${CMAKE_INSTALL_LIBDIR})
+IF (MSGPACK_BUILD_EXAMPLES)
-INSTALL (DIRECTORY src/msgpack DESTINATION include)
+    ADD_SUBDIRECTORY (example)
-INSTALL (DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack DESTINATION include)
+ENDIF ()
-INSTALL (FILES src/msgpack.h src/msgpack.hpp DESTINATION include)
+
-INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
+    SET (MSGPACK_INSTALLTARGETS msgpack-c)
+ENDIF ()
+
+IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
+    LIST (APPEND MSGPACK_INSTALLTARGETS msgpack-c-static)
+ENDIF ()
+
+INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} EXPORT msgpack-c-targets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+FOREACH (file ${msgpack-c_common_HEADERS})
+    GET_FILENAME_COMPONENT (dir ${file} PATH)
+    INSTALL (FILES ${file} DESTINATION ${CMAKE_INSTALL_PREFIX}/${dir})
+ENDFOREACH ()
+FOREACH (file ${msgpack-c_configured_HEADERS})
+    GET_FILENAME_COMPONENT (dir ${file} PATH)
+    INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/${file} DESTINATION ${CMAKE_INSTALL_PREFIX}/${dir})
+ENDFOREACH ()
+IF (NOT MSVC)
+    INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack-c.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+ENDIF ()
 
 # Doxygen
 FIND_PACKAGE (Doxygen)
 IF (DOXYGEN_FOUND)
-	ADD_CUSTOM_TARGET (
+    LIST (APPEND Doxyfile_c_CONTENT
-		doxygen_c
         COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS      = *.h" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY   = doc_c" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
+        COMMAND ${CMAKE_COMMAND} -E echo "INPUT              = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
+        COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL        = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME       = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
+        COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH    = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
+    )
+    IF (DOXYGEN_DOT_FOUND)
+        LIST (APPEND Doxyfile_c_CONTENT
+            COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT       = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
+        )
+    ENDIF ()
+    ADD_CUSTOM_TARGET (
+        doxygen
+        ${Doxyfile_c_CONTENT}
         COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
         VERBATIM
     )
-	ADD_CUSTOM_TARGET (
+ENDIF ()
-		doxygen_cpp
+
-		COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+INCLUDE (CMakePackageConfigHelpers)
-		COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS      = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+
-		COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY   = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+SET (CMAKE_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/msgpack-c")
-		COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME       = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+
-		COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+WRITE_BASIC_PACKAGE_VERSION_FILE (
-		VERBATIM
+    msgpack-c-config-version.cmake
-	)
+    VERSION ${VERSION}
-	ADD_CUSTOM_TARGET (
+    COMPATIBILITY SameMajorVersion
-		doxygen
+)
-		DEPENDS doxygen_c doxygen_cpp
+
+IF (NOT CMAKE_VERSION VERSION_LESS 3.0)
+    EXPORT (EXPORT msgpack-c-targets
+        FILE "${CMAKE_CURRENT_BINARY_DIR}/msgpack-c-targets.cmake"
     )
 ENDIF ()
+
+CONFIGURE_PACKAGE_CONFIG_FILE (msgpack-c-config.cmake.in
+    msgpack-c-config.cmake
+    INSTALL_DESTINATION "${CMAKE_INSTALL_CMAKEDIR}"
+)
+
+INSTALL (EXPORT msgpack-c-targets
+    FILE
+        msgpack-c-targets.cmake
+    DESTINATION
+        "${CMAKE_INSTALL_CMAKEDIR}"
+)
+
+INSTALL (
+    FILES
+        "${CMAKE_CURRENT_BINARY_DIR}/msgpack-c-config.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/msgpack-c-config-version.cmake"
+    DESTINATION
+        "${CMAKE_INSTALL_CMAKEDIR}"
+)

COPYING

@@ -1,14 +1,5 @@
-Copyright (C) 2008-2010 FURUHASHI Sadayuki
+Copyright (C) 2008-2015 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.
 
+   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)

ChangeLog

@@ -1,72 +0,0 @@
-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.
-

Doxyfile

@@ -281,7 +281,7 @@ TYPEDEF_HIDES_STRUCT   = NO
 # causing a significant performance penality.
 # If the system has enough physical memory increasing the cache will improve the
 # performance by keeping more symbols in memory. Note that the value works on
-# a logarithmic scale so increasing the size by one will rougly double the
+# a logarithmic scale so increasing the size by one will roughly double the
 # memory usage. The cache size is given by this formula:
 # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
 # corresponding to a cache size of 2^16 = 65536 symbols

Files.cmake

@@ -0,0 +1,41 @@
+# Source files
+SET (msgpack-c_SOURCES
+    src/objectc.c
+    src/unpack.c
+    src/version.c
+    src/vrefbuffer.c
+    src/zone.c
+)
+
+# Header files
+SET (msgpack-c_common_HEADERS
+    include/msgpack.h
+    include/msgpack/fbuffer.h
+    include/msgpack/gcc_atomic.h
+    include/msgpack/object.h
+    include/msgpack/pack.h
+    include/msgpack/pack_define.h
+    include/msgpack/sbuffer.h
+    include/msgpack/timestamp.h
+    include/msgpack/unpack.h
+    include/msgpack/unpack_define.h
+    include/msgpack/unpack_template.h
+    include/msgpack/util.h
+    include/msgpack/version.h
+    include/msgpack/version_master.h
+    include/msgpack/vrefbuffer.h
+    include/msgpack/zbuffer.h
+    include/msgpack/zone.h
+)
+
+# Header files will configured
+SET (msgpack-c_configured_HEADERS
+    include/msgpack/pack_template.h
+    include/msgpack/sysdep.h
+)
+
+# All header files
+LIST (APPEND msgpack-c_HEADERS
+    ${msgpack-c_common_HEADERS}
+    ${msgpack-c_configured_HEADERS}
+)

LICENSE

@@ -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.

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.

Makefile.am

@@ -1,21 +0,0 @@
-SUBDIRS = src test
-
-DOC_FILES = \
-		README.md \
-		LICENSE \
-		NOTICE \
-		msgpack_vc8.vcproj \
-		msgpack_vc8.sln \
-		msgpack_vc.postbuild.bat
-
-EXTRA_DIST = \
-		$(DOC_FILES) CMakeLists.txt test/CMakeLists.txt
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = msgpack.pc
-
-doxygen:
-	./preprocess clean
-	cd src && $(MAKE) doxygen
-	./preprocess
-

NOTICE

@@ -1,4 +1,14 @@
-MessagePack is developed by FURUHASHI Sadayuki, licensed under Apache License,
+This product bundles Boost Predef and Boost Preprocessor.
-Version 2.0. The original software and related information is available at
+They are distributed under the Boost Software License, Version 1.0.
-http://msgpack.sourceforge.jp/.
+(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/*

QUICKSTART-C.md

@@ -2,14 +2,15 @@
 
 The serialization library is production-ready.
 
-Currently, no RPC implementation is not available.
+Currently, RPC implementation is not available.
 
 # Install
 
+## Install with package manager
 
-## Mac OS X with MacPorts
+### MacOS with MacPorts
 
-On Mac OS X, you can install MessagePack for C using MacPorts.
+On MacOS, you can install MessagePack for C using MacPorts.
 
 ```
 $ sudo port install msgpack
@@ -20,51 +21,47 @@ You might need to run `sudo port selfupdate` before installing to update the pac
 You can also install via Homebrew.
 
 ```
-$ sudo brew install msgpack
+$ brew install msgpack
 ```
 
-## FreeBSD with Ports Collection
+### FreeBSD with Ports Collection
 
-On FreeBSD, you can use Ports Collection. Install [net/msgpack|http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/] package.
+On FreeBSD, you can use Ports Collection. Install [net/msgpack](http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/) package.
 
-## Gentoo Linux with Portage
+### Gentoo Linux with Portage
 
-On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack|http://gentoo-portage.com/dev-libs/msgpack] package.
+On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack](http://gentoo-portage.com/dev-libs/msgpack) package.
 
-## Other UNIX-like platform with ./configure
+### Windows with vcpkg
 
-On the other UNIX-like platforms, download source package from [Releases|http://msgpack.org/releases/cpp/] and run `./configure && make && make install`.
+There are several package managers available, and vcpkg is typical.
 
 ```
-$ wget http://msgpack.org/releases/cpp/msgpack-0.5.5.tar.gz
+$ vcpkg install msgpack:x64-windows
-$ tar zxvf msgpack-0.5.5.tar.gz
-$ cd msgpack-0.5.5
-$ ./configure
-$ make
-$ sudo make install
 ```
+## Install with source code
 
-## Windows
+### Build with cmake
 
-On Windows, download source package from [here|https://sourceforge.net/projects/msgpack/files/] and extract it.
+You need to install cmake (2.8.12 or higher) first.
-Then open `msgpack_vc8.vcproj` file and build it using batch build. It builds libraries on `lib/` folder and header files on `include/` folder.
-
-You can build using command line as follows:
 
 ```
-> vcbuild msgpack_vc2008.vcproj
+$ git clone https://github.com/msgpack/msgpack-c.git
-> dir lib       % DLL files are here
+$ cd msgpack-c
-> dir include   % header files are here
+$ mkdir build
+$ cd build
+$ cmake ..
+$ cmake --build .
+$ cmake --build . --target install
 ```
+### Build with autotools
 
-## Install from git repository
+In versions 1.4.2 and below, you can use `autotools` to build on UNIX-like platforms.
-
-You need to install gcc (4.1.0 or higher), autotools.
-
 ```
-$ git clone git@github.com:msgpack/msgpack.git
+$ wget https://github.com/msgpack/msgpack-c/archive/cpp-1.3.0.tar.gz
-$ cd msgpack/cpp
+$ tar zxvf msgpack-1.3.0.tar.gz
-$ ./bootstrap
+$ cd msgpack-1.3.0
+$ ./bootstrap  # If the 'configure' script already exists, you can omit this step.
 $ ./configure
 $ make
 $ sudo make install
@@ -88,21 +85,22 @@ int main(void) {
 
         /* serializes ["Hello", "MessagePack"]. */
         msgpack_pack_array(pk, 2);
-        msgpack_pack_raw(pk, 5);
+        msgpack_pack_bin(pk, 5);
-        msgpack_pack_raw_body(pk, "Hello", 5);
+        msgpack_pack_bin_body(pk, "Hello", 5);
-        msgpack_pack_raw(pk, 11);
+        msgpack_pack_bin(pk, 11);
-        msgpack_pack_raw_body(pk, "MessagePack", 11);
+        msgpack_pack_bin_body(pk, "MessagePack", 11);
 
         /* deserializes it. */
         msgpack_unpacked msg;
         msgpack_unpacked_init(&msg);
-        bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
+        msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
 
         /* prints the deserialized object. */
         msgpack_object obj = msg.data;
         msgpack_object_print(stdout, obj);  /*=> ["Hello", "MessagePack"] */
 
         /* cleaning */
+        msgpack_unpacked_destroy(&msg);
         msgpack_sbuffer_free(buffer);
         msgpack_packer_free(pk);
 }
@@ -128,20 +126,21 @@ int main(void) {
 
            /* serializes ["Hello", "MessagePack"]. */
            msgpack_pack_array(pk, 3);
-           msgpack_pack_raw(pk, 5);
+           msgpack_pack_bin(pk, 5);
-           msgpack_pack_raw_body(pk, "Hello", 5);
+           msgpack_pack_bin_body(pk, "Hello", 5);
-           msgpack_pack_raw(pk, 11);
+           msgpack_pack_bin(pk, 11);
-           msgpack_pack_raw_body(pk, "MessagePack", 11);
+           msgpack_pack_bin_body(pk, "MessagePack", 11);
            msgpack_pack_int(pk, j);
 
            /* deserializes it. */
            msgpack_unpacked msg;
            msgpack_unpacked_init(&msg);
-           bool success = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
+           msgpack_unpack_return ret = msgpack_unpack_next(&msg, buffer->data, buffer->size, NULL);
 
            /* prints the deserialized object. */
            msgpack_object obj = msg.data;
            msgpack_object_print(stdout, obj);  /*=> ["Hello", "MessagePack"] */
+           msgpack_unpacked_destroy(&msg);
            puts("");
         }
 
@@ -184,7 +183,7 @@ int main(void) {
         }
 
         /* results:
-         * $ gcc stream.cc -lmsgpack -o stream
+         * $ gcc stream.cc -lmsgpack-c -o stream
          * $ ./stream
          * 1
          * 2

QUICKSTART-CPP.md

@@ -1,159 +0,0 @@
-# Implementation Status
-
-The serialization library is production-ready.
-
-Currently, RPC implementation is testing phase. Requires newer kernel, not running on RHEL5/CentOS5.
-
-# Install
-
-Same as QuickStart for C Language.
-
-# Serialization QuickStart for C+\+
-
-## First program
-
-Include `msgpack.hpp` header and link `msgpack` library to use MessagePack on your program.
-
-```cpp
-#include <msgpack.hpp>
-#include <vector>
-#include <string>
-#include <iostream>
-
-int main(void) {
-        // serializes this object.
-        std::vector<std::string> vec;
-        vec.push_back("Hello");
-        vec.push_back("MessagePack");
-
-        // serialize it into simple buffer.
-        msgpack::sbuffer sbuf;
-        msgpack::pack(sbuf, vec);
-
-        // deserialize it.
-        msgpack::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
-
-        // print the deserialized object.
-        msgpack::object obj = msg.get();
-        std::cout << obj << std::endl;  //=> ["Hello", "MessagePack"]
-
-        // convert it into statically typed object.
-        std::vector<std::string> rvec;
-        obj.convert(&rvec);
-}
-```
-
-Compile it as follows:
-
-```
-$ g++ hello.cc -lmsgpack -o hello
-$ ./hello
-["Hello", "MessagePack"]
-```
-
-## Streaming feature
-
-```cpp
-#include <msgpack.hpp>
-#include <iostream>
-#include <string>
-
-int main(void) {
-        // serializes multiple objects using msgpack::packer.
-        msgpack::sbuffer buffer;
-
-        msgpack::packer<msgpack::sbuffer> pk(&buffer);
-        pk.pack(std::string("Log message ... 1"));
-        pk.pack(std::string("Log message ... 2"));
-        pk.pack(std::string("Log message ... 3"));
-
-        // deserializes these objects using msgpack::unpacker.
-        msgpack::unpacker pac;
-
-        // feeds the buffer.
-        pac.reserve_buffer(buffer.size());
-        memcpy(pac.buffer(), buffer.data(), buffer.size());
-        pac.buffer_consumed(buffer.size());
-
-        // now starts streaming deserialization.
-        msgpack::unpacked result;
-        while(pac.next(&result)) {
-            std::cout << result.get() << std::endl;
-        }
-
-        // results:
-        // $ g++ stream.cc -lmsgpack -o stream
-        // $ ./stream
-        // "Log message ... 1"
-        // "Log message ... 2"
-        // "Log message ... 3"
-}
-```
-
-### Streaming into an array or map
-
-```cpp
-#include <msgpack.hpp>
-#include <iostream>
-#include <string>
-
-int main(void) {
-        // serializes multiple objects into one message containing an array using msgpack::packer.
-        msgpack::sbuffer buffer;
-
-        msgpack::packer<msgpack::sbuffer> pk(&buffer);
-        pk.pack_array(3);
-        pk.pack(std::string("Log message ... 1"));
-        pk.pack(std::string("Log message ... 2"));
-        pk.pack(std::string("Log message ... 3"));
-
-        // serializes multiple objects into one message containing a map using msgpack::packer.
-        msgpack::sbuffer buffer2;
-
-        msgpack::packer<msgpack::sbuffer> pk2(&buffer2);
-        pk2.pack_map(2);
-        pk2.pack(std::string("x"));
-        pk2.pack(3);
-        pk2.pack(std::string("y"));
-        pk2.pack(3.4321);
-
-}
-```
-
-
-## User-defined classes
-
-You can use serialize/deserializes user-defined classes using `MSGPACK_DEFINE` macro.
-
-```cpp
-#include <msgpack.hpp>
-#include <vector>
-#include <string>
-
-class myclass {
-private:
-    std::string m_str;
-    std::vector<int> m_vec;
-public:
-    MSGPACK_DEFINE(m_str, m_vec);
-};
-
-int main(void) {
-        std::vector<myclass> vec;
-        // add some elements into vec...
-
-        // you can serialize myclass directly
-        msgpack::sbuffer sbuf;
-        msgpack::pack(sbuf, vec);
-
-        msgpack::unpacked msg;
-        msgpack::unpack(&msg, sbuf.data(), sbuf.size());
-
-        msgpack::object obj = msg.get();
-
-        // you can convert object to myclass directly
-        std::vector<myclass> rvec;
-        obj.convert(&rvec);
-}
-```

README.md

@@ -1,161 +1,139 @@
-# Msgpack for C/C++
+`msgpack` for C
+===================
 
-It's like JSON but small and fast.
+Version 6.0.0 [![Build Status](https://github.com/msgpack/msgpack-c/workflows/CI/badge.svg?branch=c_master)](https://github.com/msgpack/msgpack-c/actions) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/c_master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/c_master)
+[![codecov](https://codecov.io/gh/msgpack/msgpack-c/branch/c_master/graph/badge.svg)](https://codecov.io/gh/msgpack/msgpack-c/branch/c_master)
 
+It's like JSON but smaller and faster.
 
-## Overview
+Overview
+--------
 
-MessagePack is an efficient binary serialization format. It lets you exchange data among multiple languages like JSON. But it's faster and smaller. Small integers are encoded into a single byte, and typical short strings require only one extra byte in addition to the strings themselves.
+[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.
 
+Example
+-------
 
-## License
+```c
+#include <msgpack.h>
+#include <stdio.h>
 
-Msgpack is Copyright (C) 2008-2010 FURUHASHI Sadayuki and licensed under the Apache License, Version 2.0 (the "License"). For details see the `COPYING` file in this directory.
+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);
 
-## Contributing
+    msgpack_pack_array(&pk, 3);
+    msgpack_pack_int(&pk, 1);
+    msgpack_pack_true(&pk);
+    msgpack_pack_str(&pk, 7);
+    msgpack_pack_str_body(&pk, "example", 7);
 
-The source for msgpack-c is held at [msgpack-c](https://github.com/msgpack/msgpack-c) github.com site.
+    /* 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);
 
-To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack/msgpack-c/issues) at github.com.
+    msgpack_object deserialized;
+    msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized);
 
-## Version
+    /* print the deserialized object. */
-0.5.9 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c)
+    msgpack_object_print(stdout, deserialized);
+    puts("");
 
-## Using Msgpack
+    msgpack_zone_destroy(&mempool);
+    msgpack_sbuffer_destroy(&sbuf);
+
+    return 0;
+}
+```
+
+See [`QUICKSTART-C.md`](./QUICKSTART-C.md) for more details.
+
+Usage
+-----
 
 ### Building and Installing
 
 #### Install from git repository
 
-##### Using autotools
+##### Using the Terminal (CLI)
-You will need gcc (4.1.0 or higher), autotools.
 
-```
+You will need:
-$ git clone https://github.com/msgpack/msgpack-c.git
-$ cd msgpack-c
-$ ./bootstrap
-$ ./configure
-$ make
-$ sudo make install
-```
 
-##### Using cmake
+ - `gcc >= 4.1.0`
-You will need gcc (4.1.0 or higher), cmake.
+ - `cmake >= 2.8.0`
 
-```
+How to build:
-$ git clone https://github.com/msgpack/msgpack-c.git
-$ cd msgpack-c
-$ cmake .
-$ make
-```
 
-#### Install from package
+    $ git clone https://github.com/msgpack/msgpack-c.git
+    $ cd msgpack-c
+    $ git checkout c_master
+    $ cmake .
+    $ make
+    $ sudo make install
 
-##### UNIX-like platform with ./configure
+How to run tests:
 
-On typical UNIX-like platforms, download source package from [Releases](https://github.com/msgpack/msgpack-c/releases) and run `./configure && make && make install`. Example:
+In order to run tests you must have the [GoogleTest](https://github.com/google/googletest) framework installed. If you do not currently have it, install it and re-run `cmake`.
+Then:
 
-```
+    $ make test
-$ wget https://github.com/msgpack/msgpack-c/releases/download/cpp-0.5.9/msgpack-0.5.9.tar.gz
-$ tar zxvf msgpack-0.5.9.tar.gz
-$ cd msgpack-0.5.9
-$ ./configure
-$ make
-$ sudo make install
-```
 
-##### FreeBSD with Ports Collection
+When you use the C part of `msgpack-c`, you need to build and link the library. By default, both static/shared libraries are built. If you want to build only static library, set `BUILD_SHARED_LIBS=OFF` to cmake. If you want to build only shared library, set `BUILD_SHARED_LIBS=ON`.
 
-On FreeBSD, you can use Ports Collection. Install [net/msgpack](http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/) package.
+#### GUI on Windows
-
-##### Gentoo Linux with Portage
-
-On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack](http://gentoo-portage.com/dev-libs/msgpack) package.
-
-##### Mac OS X with MacPorts
-
-On Mac OS X, you can install MessagePack for C using MacPorts.
-
-```
-$ sudo port install msgpack
-```
-
-You might need to run `sudo port selfupdate` before installing to update the package repository.
-
-You can also install via Homebrew.
-
-```
-$ sudo brew install msgpack
-```
-
-
-##### Windows
 
 Clone msgpack-c git repository.
 
-```
+    $ git clone https://github.com/msgpack/msgpack-c.git
-$ git clone https://github.com/msgpack/msgpack-c.git
-```
 
 or using GUI git client.
 
 e.g.) tortoise git https://code.google.com/p/tortoisegit/
 
-Launch cmake GUI client. http://www.cmake.org/cmake/resources/software.html
+1. Checkout to c_master branch
 
-Set 'Where is the source code:' text box and 'Where to build the binaries:' text box.
+2. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
 
-Click 'Configure' button.
+3. Set 'Where is the source code:' text box and 'Where to build
+the binaries:' text box.
 
-Choose your Visual Studio version.
+4. Click 'Configure' button.
 
-Click 'Generate' button.
+5. Choose your Visual Studio version.
 
-Open the created msgpack.sln on Visual Studio.
+6. Click 'Generate' button.
 
-Build all.
+7. Open the created msgpack.sln on Visual Studio.
 
-### Linking with an Application
+8. Build all.
 
-Include `msgpack.hpp` (or `msgpack.h` for C) in your application and link with libmsgpack. Here is a typical gcc link command:
+### Documentation
 
-    g++ myapp.cpp -lmsgpack -o myapp
+You can get additional information including the tutorial on the
+[wiki](https://github.com/msgpack/msgpack-c/wiki).
 
+Contributing
+------------
 
-### Code Example
+`msgpack-c` is developed on GitHub at [msgpack/msgpack-c](https://github.com/msgpack/msgpack-c).
-```CPP
+To report an issue or send a pull request, use the
-#include <msgpack.hpp>
+[issue tracker](https://github.com/msgpack/msgpack-c/issues).
-#include <vector>
-#include <string>
-#include <iostream>
 
-int main() {
+Here's the list of [great contributors](https://github.com/msgpack/msgpack-c/graphs/contributors).
-    // This is target object.
-    std::vector<std::string> target;
-    target.push_back("Hello,");
-    target.push_back("World!");
 
-    // Serialize it.
+License
-    msgpack::sbuffer sbuf;  // simple buffer
+-------
-    msgpack::pack(&sbuf, target);
 
-    // Deserialize the serialized data.
+`msgpack-c` is licensed under the Boost Software License, Version 1.0. See
-    msgpack::unpacked msg;    // includes memory pool and deserialized object
+the [`LICENSE_1_0.txt`](./LICENSE_1_0.txt) file for details.
-    msgpack::unpack(&msg, sbuf.data(), sbuf.size());
-    msgpack::object obj = msg.get();
-
-    // Print the deserialized object to stdout.
-    std::cout << obj << std::endl;    // ["Hello," "World!"]
-
-    // Convert the deserialized object to staticaly typed object.
-    std::vector<std::string> result;
-    obj.convert(&result);
-
-    // If the type is mismatched, it throws msgpack::type_error.
-    obj.as<int>();  // type is mismatched, msgpack::type_error is thrown
-}
-```
-### Quickstart Guides
-
-For more detailed examples see [QuickStart for C](QUICKSTART-C.md) and [QuickStart for C++](QUICKSTART-CPP.md).

README_crosslang.md

@@ -1,38 +0,0 @@
-MessagePack cross-language test cases
-=====================================
-
-## cases
-
-Valid serialized data are stored in "cases.mpac" and "cases_compact.mpac".
-These files describe same objects. And "cases.json" describes an array of the described objects.
-
-Thus you can verify your implementations as comparing the objects.
-
-
-## crosslang
-
-The *crosslang* tool reads serialized data from stdin and writes re-serialize data to stdout.
-
-There are C++ and Ruby implementation of crosslang tool. You can verify your implementation
-as comparing that implementations.
-
-### C++ version
-
-    $ cd ../cpp && ./configure && make && make install
-    or
-    $ port install msgpack  # MacPorts
-    
-    $ g++ -Wall crosslang.cc -lmsgpack -o crosslang
-
-    $ ./crosslang
-    Usage: ./crosslang [in-file] [out-file]
-
-### Ruby version
-
-    $ gem install msgpack
-    or
-    $ port install rb_msgpack   # MacPorts
-
-    $ ruby crosslang.rb
-    Usage: crosslang.rb [in-file] [out-file]
-

appveyor.yml

@@ -0,0 +1,43 @@
+version: 6.0.0.{build}
+
+branches:
+  only:
+  - c_master
+
+image:
+- Visual Studio 2015
+environment:
+  matrix:
+    - msvc: '"Visual Studio 10 2010"'
+    - msvc: '"Visual Studio 11 2012"'
+    - msvc: '"Visual Studio 12 2013"'
+    - msvc: '"Visual Studio 14 2015"'
+build_script:
+- appveyor DownloadFile https://github.com/google/googletest/archive/release-1.7.0.zip -FileName googletest-release-1.7.0.zip
+- 7z x googletest-release-1.7.0.zip > NUL
+- cd googletest-release-1.7.0
+- md build
+- cd build
+- cmake -G %msvc% -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 ..
+- cmake --build . --config Release
+- cd ..
+- cd ..
+- appveyor DownloadFile http://zlib.net/zlib-1.2.13.tar.gz -FileName zlib-1.2.13.tar.gz
+- 7z x zlib-1.2.13.tar.gz > NUL
+- 7z x zlib-1.2.13.tar > NUL
+- cd zlib-1.2.13
+- md build
+- cd build
+- cmake -G %msvc% ..
+- cmake --build . --config Release
+- copy zconf.h ..
+- cd ..
+- cd ..
+- md build
+- cd build
+- cmake -G %msvc% -DGTEST_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest.lib -DGTEST_MAIN_LIBRARY=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release\gtest_main.lib -DGTEST_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\include -DZLIB_LIBRARY=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.13\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.13 -DCMAKE_CXX_FLAGS='"/D_VARIADIC_MAX=10 /EHsc"' ..
+- cmake --build . --config Release -v
+
+test_script:
+- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.13\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release
+- ctest -V

bootstrap

@@ -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
-
-
-mkdir -p ac
-test -f AUTHORS   || touch AUTHORS
-test -f COPYING   || touch COPYING
-test -f ChangeLog || touch ChangeLog
-test -f NEWS      || touch NEWS
-test -f README    || cp -f README.md README
-
-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
-
-

cases.json

@@ -1 +0,0 @@
-[false,true,null,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,127,127,255,65535,4294967295,-32,-32,-128,-32768,-2147483648,0.0,-0.0,1.0,-1.0,"a","a","a","","","",[0],[0],[0],[],[],[],{},{},{},{"a":97},{"a":97},{"a":97},[[]],[["a"]]]

cases_gen.rb

@@ -1,99 +0,0 @@
-#
-# MessagePack format test case
-#
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'msgpack'
-require 'json'
-
-source = <<EOF
-c2                          # false
-c3                          # true
-c0                          # nil
-00                          # 0 Positive FixNum
-cc 00                       # 0 uint8
-cd 00 00                    # 0 uint16
-ce 00 00 00 00              # 0 uint32
-cf 00 00 00 00 00 00 00 00  # 0 uint64
-d0 00                       # 0 int8
-d1 00 00                    # 0 int16
-d2 00 00 00 00              # 0 int32
-d3 00 00 00 00 00 00 00 00  # 0 int64
-ff                          # -1 Negative FixNum
-d0 ff                       # -1 int8
-d1 ff ff                    # -1 int16
-d2 ff ff ff ff              # -1 int32
-d3 ff ff ff ff ff ff ff ff  # -1 int64
-7f                          # 127 Positive FixNum
-cc 7f                       # 127 uint8
-cd 00 ff                    # 255 uint16
-ce 00 00 ff ff              # 65535 uint32
-cf 00 00 00 00 ff ff ff ff  # 4294967295 uint64
-e0                          # -32 Negative FixNum
-d0 e0                       # -32 int8
-d1 ff 80                    # -128 int16
-d2 ff ff 80 00              # -32768 int32
-d3 ff ff ff ff 80 00 00 00  # -2147483648 int64
-#ca 00 00 00 00              # 0.0 float
-cb 00 00 00 00 00 00 00 00  # 0.0 double
-#ca 80 00 00 00              # -0.0 float
-cb 80 00 00 00 00 00 00 00  # -0.0 double
-cb 3f f0 00 00 00 00 00 00  # 1.0 double
-cb bf f0 00 00 00 00 00 00  # -1.0 double
-a1 61                       # "a" FixRaw
-da 00 01 61                 # "a" raw 16
-db 00 00 00 01 61           # "a" raw 32
-a0                          # "" FixRaw
-da 00 00                    # "" raw 16
-db 00 00 00 00              # "" raw 32
-91 00                       # [0] FixArray
-dc 00 01 00                 # [0] array 16
-dd 00 00 00 01 00           # [0] array 32
-90                          # [] FixArray
-dc 00 00                    # [] array 16
-dd 00 00 00 00              # [] array 32
-80                          # {} FixMap
-de 00 00                    # {} map 16
-df 00 00 00 00              # {} map 32
-81 a1 61 61                 # {"a"=>97} FixMap
-de 00 01 a1 61 61           # {"a"=>97} map 16
-df 00 00 00 01 a1 61 61     # {"a"=>97} map 32
-91 90                       # [[]]
-91 91 a1 61                 # [["a"]]
-EOF
-
-source.gsub!(/\#.+$/,'')
-bytes = source.strip.split(/\s+/).map {|x| x.to_i(16) }.pack('C*')
-
-objs = []
-compact_bytes = ""
-
-pac = MessagePack::Unpacker.new
-pac.feed(bytes)
-pac.each {|obj|
-	p obj
-	objs << obj
-	compact_bytes << obj.to_msgpack
-}
-
-json = objs.to_json
-
-# self check
-cpac = MessagePack::Unpacker.new
-cpac.feed(compact_bytes)
-cpac.each {|cobj|
-	obj = objs.shift
-	if obj != cobj
-		puts "** SELF CHECK FAILED **"
-		puts "expected: #{obj.inspect}"
-		puts "actual: #{cobj.inspect}"
-		exit 1
-	end
-}
-
-File.open("cases.mpac","w") {|f| f.write(bytes) }
-File.open("cases_compact.mpac","w") {|f| f.write(compact_bytes) }
-File.open("cases.json","w") {|f| f.write(json) }
-

ci/build_cmake.sh

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 
 mkdir build
 
@@ -16,13 +16,17 @@ then
     exit $ret
 fi
 
-if [ $1 = "cpp11" ]
+if [ "${ARCH}" == "32" ]
 then
-  cmake -DMSGPACK_CXX11=ON ..
+    export BIT32="ON"
+    export ARCH_FLAG="-m32"
 else
-  cmake  ..
+    export BIT32="OFF"
+    export ARCH_FLAG="-m64"
 fi
 
+cmake -DMSGPACK_32BIT=${BIT32} -DBUILD_SHARED_LIBS=${SHARED} -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DCMAKE_CXX_FLAGS="${ARCH_FLAG} ${CXXFLAGS} ${SAN}" -DCMAKE_C_FLAGS="${CFLAGS} ${SAN}" ..
+
 ret=$?
 if [ $ret -ne 0 ]
 then
@@ -37,7 +41,7 @@ then
     exit $ret
 fi
 
-make test
+ctest -VV
 
 ret=$?
 if [ $ret -ne 0 ]
@@ -45,6 +49,7 @@ then
     exit $ret
 fi
 
+cmake -DMSGPACK_32BIT=${BIT32} -DBUILD_SHARED_LIBS=${SHARED} -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DCMAKE_CXX_FLAGS="${ARCH_FLAG} ${CXXFLAGS}" -DCMAKE_C_FLAGS="${CFLAGS}" ..
 make install DESTDIR=`pwd`/install
 
 ret=$?
@@ -53,4 +58,56 @@ then
     exit $ret
 fi
 
+if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]
+then
+    ctest -T memcheck | tee memcheck.log
+
+    ret=${PIPESTATUS[0]}
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+    cat memcheck.log | grep "Memory Leak" > /dev/null
+    ret=$?
+    if [ $ret -eq 0 ]
+    then
+        exit 1
+    fi
+fi
+
+if [ "${ARCH}" != "32" ]
+then
+    mkdir install-test
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    cd install-test
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    cmake -DCMAKE_PREFIX_PATH=`pwd`/../install/usr/local/lib/cmake ../../example/cmake
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    make
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+fi
+
 exit 0

ci/build_cmake_embedded.sh

@@ -1,18 +1,6 @@
-#!/bin/sh
+#!/bin/bash
 
-./bootstrap
+cd example/cmake
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-if [ $1 = "cpp11" ]
-then
-    ./configure CXXFLAGS="-std=c++11"
-else
-    ./configure
-fi
 
 ret=$?
 if [ $ret -ne 0 ]
@@ -20,7 +8,7 @@ then
     exit $ret
 fi
 
-make
+rm -f msgpack-c
 
 ret=$?
 if [ $ret -ne 0 ]
@@ -28,7 +16,7 @@ then
     exit $ret
 fi
 
-make check
+ln -s ../.. msgpack-c
 
 ret=$?
 if [ $ret -ne 0 ]
@@ -36,7 +24,31 @@ then
     exit $ret
 fi
 
-make install DESTDIR=`pwd`/install
+mkdir build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+cd build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+cmake -DEXAMPLE_MSGPACK_EMBEDDED=ON ..
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make example example-static
 
 ret=$?
 if [ $ret -ne 0 ]

cmake/CodeCoverage.cmake

@@ -0,0 +1,55 @@
+# Check prereqs
+FIND_PROGRAM(GCOV_PATH gcov)
+FIND_PROGRAM(LCOV_PATH lcov)
+FIND_PROGRAM(GENHTML_PATH genhtml)
+
+IF(NOT GCOV_PATH)
+	MESSAGE(FATAL_ERROR "gcov not found! Aborting...")
+ENDIF()
+
+IF(NOT CMAKE_COMPILER_IS_GNUCC AND NOT CMAKE_COMPILER_IS_GNUCXX)
+	# Clang version 3.0.0 and greater now supports gcov as well.
+	MESSAGE(STATUS "Compiler is not GNU gcc! Clang Version 3.0.0 and greater supports gcov as well, but older versions don't.")
+	IF(NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang" AND NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+		MESSAGE(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+	ENDIF()
+ENDIF()
+
+SET(COVERAGE_FLAGS "-g -O0 --coverage")
+
+FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _testrunner _outputname)
+
+	IF(NOT LCOV_PATH)
+		MESSAGE(FATAL_ERROR "lcov not found! Aborting...")
+	ENDIF()
+
+	IF(NOT GENHTML_PATH)
+		MESSAGE(FATAL_ERROR "genhtml not found! Aborting...")
+	ENDIF()
+
+	# Setup target
+	ADD_CUSTOM_TARGET(${_targetname}
+
+		# Cleanup lcov
+		${LCOV_PATH} --directory . --zerocounters
+
+		# Run tests
+		COMMAND ${_testrunner} ${ARGV3}
+
+		# Capturing lcov counters and generating report
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info --base-directory ${CMAKE_SOURCE_DIR} --no-external --quiet
+		COMMAND ${LCOV_PATH} --remove ${_outputname}.info '*/test/*' '*/fuzz/*' --output-file ${_outputname}.info.cleaned --quiet
+		COMMAND ${GENHTML_PATH} -o ${_outputname} ${_outputname}.info.cleaned --prefix ${CMAKE_SOURCE_DIR}
+		# COMMAND ${CMAKE_COMMAND} -E remove ${_outputname}.info ${_outputname}.info.cleaned
+
+		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+		COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+	)
+
+	# Show info where to find the report
+	ADD_CUSTOM_COMMAND(TARGET ${_targetname} POST_BUILD
+		COMMAND ;
+		COMMENT "Open ./${_outputname}/index.html in your browser to view the coverage report."
+	)
+
+ENDFUNCTION()

cmake/pack_template.h.in

@@ -0,0 +1,952 @@
+/*
+ * MessagePack packing routine template
+ *
+ * Copyright (C) 2008-2010 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)
+ */
+
+#ifndef MSGPACK_ENDIAN_BIG_BYTE
+#define MSGPACK_ENDIAN_BIG_BYTE @MSGPACK_ENDIAN_BIG_BYTE@
+#endif
+#ifndef MSGPACK_ENDIAN_LITTLE_BYTE
+#define MSGPACK_ENDIAN_LITTLE_BYTE @MSGPACK_ENDIAN_LITTLE_BYTE@
+#endif
+
+#if MSGPACK_ENDIAN_LITTLE_BYTE
+#define TAKE8_8(d)  ((uint8_t*)&d)[0]
+#define TAKE8_16(d) ((uint8_t*)&d)[0]
+#define TAKE8_32(d) ((uint8_t*)&d)[0]
+#define TAKE8_64(d) ((uint8_t*)&d)[0]
+#elif MSGPACK_ENDIAN_BIG_BYTE
+#define TAKE8_8(d)  ((uint8_t*)&d)[0]
+#define TAKE8_16(d) ((uint8_t*)&d)[1]
+#define TAKE8_32(d) ((uint8_t*)&d)[3]
+#define TAKE8_64(d) ((uint8_t*)&d)[7]
+#else
+#error msgpack-c supports only big endian and little endian
+#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
+
+#if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable : 4204)   /* nonstandard extension used: non-constant aggregate initializer */
+#endif
+
+/*
+ * Integer
+ */
+
+#define msgpack_pack_real_uint8(x, d) \
+do { \
+    if(d < (1<<7)) { \
+        /* fixnum */ \
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
+    } else { \
+        /* unsigned 8 */ \
+        unsigned char buf[2] = {0xcc, TAKE8_8(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, &TAKE8_16(d), 1); \
+    } else if(d < (1<<8)) { \
+        /* unsigned 8 */ \
+        unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
+        msgpack_pack_append_buffer(x, buf, 2); \
+    } else { \
+        /* unsigned 16 */ \
+        unsigned char buf[3]; \
+        buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)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, &TAKE8_32(d), 1); \
+        } else { \
+            /* unsigned 8 */ \
+            unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } \
+    } else { \
+        if(d < (1<<16)) { \
+            /* unsigned 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else { \
+            /* unsigned 32 */ \
+            unsigned char buf[5]; \
+            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
+            msgpack_pack_append_buffer(x, buf, 5); \
+        } \
+    } \
+} while(0)
+
+#define msgpack_pack_real_uint64(x, d) \
+do { \
+    if(d < (1ULL<<8)) { \
+        if(d < (1ULL<<7)) { \
+            /* fixnum */ \
+            msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
+        } else { \
+            /* unsigned 8 */ \
+            unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } \
+    } else { \
+        if(d < (1ULL<<16)) { \
+            /* unsigned 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else if(d < (1ULL<<32)) { \
+            /* unsigned 32 */ \
+            unsigned char buf[5]; \
+            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
+            msgpack_pack_append_buffer(x, buf, 5); \
+        } else { \
+            /* unsigned 64 */ \
+            unsigned char buf[9]; \
+            buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
+            msgpack_pack_append_buffer(x, buf, 9); \
+        } \
+    } \
+} while(0)
+
+#define msgpack_pack_real_int8(x, d) \
+do { \
+    if(d < -(1<<5)) { \
+        /* signed 8 */ \
+        unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \
+        msgpack_pack_append_buffer(x, buf, 2); \
+    } else { \
+        /* fixnum */ \
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
+    } \
+} while(0)
+
+#define msgpack_pack_real_int16(x, d) \
+do { \
+    if(d < -(1<<5)) { \
+        if(d < -(1<<7)) { \
+            /* signed 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else { \
+            /* signed 8 */ \
+            unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } \
+    } else if(d < (1<<7)) { \
+        /* fixnum */ \
+        msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
+    } else { \
+        if(d < (1<<8)) { \
+            /* unsigned 8 */ \
+            unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } else { \
+            /* unsigned 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)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 */ \
+            unsigned char buf[5]; \
+            buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
+            msgpack_pack_append_buffer(x, buf, 5); \
+        } else if(d < -(1<<7)) { \
+            /* signed 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else { \
+            /* signed 8 */ \
+            unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } \
+    } else if(d < (1<<7)) { \
+        /* fixnum */ \
+        msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
+    } else { \
+        if(d < (1<<8)) { \
+            /* unsigned 8 */ \
+            unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
+            msgpack_pack_append_buffer(x, buf, 2); \
+        } else if(d < (1<<16)) { \
+            /* unsigned 16 */ \
+            unsigned char buf[3]; \
+            buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+            msgpack_pack_append_buffer(x, buf, 3); \
+        } else { \
+            /* unsigned 32 */ \
+            unsigned char buf[5]; \
+            buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)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 */ \
+                unsigned char buf[9]; \
+                buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \
+                msgpack_pack_append_buffer(x, buf, 9); \
+            } else { \
+                /* signed 32 */ \
+                unsigned char buf[5]; \
+                buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
+                msgpack_pack_append_buffer(x, buf, 5); \
+            } \
+        } else { \
+            if(d < -(1<<7)) { \
+                /* signed 16 */ \
+                unsigned char buf[3]; \
+                buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
+                msgpack_pack_append_buffer(x, buf, 3); \
+            } else { \
+                /* signed 8 */ \
+                unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \
+                msgpack_pack_append_buffer(x, buf, 2); \
+            } \
+        } \
+    } else if(d < (1<<7)) { \
+        /* fixnum */ \
+        msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
+    } else { \
+        if(d < (1LL<<16)) { \
+            if(d < (1<<8)) { \
+                /* unsigned 8 */ \
+                unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
+                msgpack_pack_append_buffer(x, buf, 2); \
+            } else { \
+                /* unsigned 16 */ \
+                unsigned char buf[3]; \
+                buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
+                msgpack_pack_append_buffer(x, buf, 3); \
+            } \
+        } else { \
+            if(d < (1LL<<32)) { \
+                /* unsigned 32 */ \
+                unsigned char buf[5]; \
+                buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
+                msgpack_pack_append_buffer(x, buf, 5); \
+            } else { \
+                /* unsigned 64 */ \
+                unsigned char buf[9]; \
+                buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
+                msgpack_pack_append_buffer(x, buf, 9); \
+            } \
+        } \
+    } \
+} while(0)
+
+
+#ifdef msgpack_pack_inline_func_fixint
+
+msgpack_pack_inline_func_fixint(_uint8)(msgpack_pack_user x, uint8_t d)
+{
+    unsigned char buf[2] = {0xcc, TAKE8_8(d)};
+    msgpack_pack_append_buffer(x, buf, 2);
+}
+
+msgpack_pack_inline_func_fixint(_uint16)(msgpack_pack_user x, uint16_t d)
+{
+    unsigned char buf[3];
+    buf[0] = 0xcd; _msgpack_store16(&buf[1], d);
+    msgpack_pack_append_buffer(x, buf, 3);
+}
+
+msgpack_pack_inline_func_fixint(_uint32)(msgpack_pack_user x, uint32_t d)
+{
+    unsigned char buf[5];
+    buf[0] = 0xce; _msgpack_store32(&buf[1], d);
+    msgpack_pack_append_buffer(x, buf, 5);
+}
+
+msgpack_pack_inline_func_fixint(_uint64)(msgpack_pack_user x, uint64_t d)
+{
+    unsigned char buf[9];
+    buf[0] = 0xcf; _msgpack_store64(&buf[1], d);
+    msgpack_pack_append_buffer(x, buf, 9);
+}
+
+msgpack_pack_inline_func_fixint(_int8)(msgpack_pack_user x, int8_t d)
+{
+    unsigned char buf[2] = {0xd0, TAKE8_8(d)};
+    msgpack_pack_append_buffer(x, buf, 2);
+}
+
+msgpack_pack_inline_func_fixint(_int16)(msgpack_pack_user x, int16_t d)
+{
+    unsigned char buf[3];
+    buf[0] = 0xd1; _msgpack_store16(&buf[1], d);
+    msgpack_pack_append_buffer(x, buf, 3);
+}
+
+msgpack_pack_inline_func_fixint(_int32)(msgpack_pack_user x, int32_t d)
+{
+    unsigned char buf[5];
+    buf[0] = 0xd2; _msgpack_store32(&buf[1], d);
+    msgpack_pack_append_buffer(x, buf, 5);
+}
+
+msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d)
+{
+    unsigned char buf[9];
+    buf[0] = 0xd3; _msgpack_store64(&buf[1], d);
+    msgpack_pack_append_buffer(x, buf, 9);
+}
+
+#undef msgpack_pack_inline_func_fixint
+#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);
+}
+
+msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d)
+{
+#if defined(CHAR_MIN)
+#if CHAR_MIN < 0
+        msgpack_pack_real_int8(x, d);
+#else
+        msgpack_pack_real_uint8(x, d);
+#endif
+#else
+#error CHAR_MIN is not defined
+#endif
+}
+
+msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d)
+{
+    msgpack_pack_real_int8(x, d);
+}
+
+msgpack_pack_inline_func(_unsigned_char)(msgpack_pack_user x, unsigned char d)
+{
+    msgpack_pack_real_uint8(x, d);
+}
+
+#ifdef msgpack_pack_inline_func_cint
+
+msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d)
+{
+#if defined(SIZEOF_SHORT)
+#if SIZEOF_SHORT == 2
+    msgpack_pack_real_int16(x, d);
+#elif SIZEOF_SHORT == 4
+    msgpack_pack_real_int32(x, d);
+#else
+    msgpack_pack_real_int64(x, d);
+#endif
+
+#elif defined(SHRT_MAX)
+#if SHRT_MAX == 0x7fff
+    msgpack_pack_real_int16(x, d);
+#elif 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)
+#if SIZEOF_INT == 2
+    msgpack_pack_real_int16(x, d);
+#elif SIZEOF_INT == 4
+    msgpack_pack_real_int32(x, d);
+#else
+    msgpack_pack_real_int64(x, d);
+#endif
+
+#elif defined(INT_MAX)
+#if INT_MAX == 0x7fff
+    msgpack_pack_real_int16(x, d);
+#elif 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)
+#if SIZEOF_LONG == 2
+    msgpack_pack_real_int16(x, d);
+#elif SIZEOF_LONG == 4
+    msgpack_pack_real_int32(x, d);
+#else
+    msgpack_pack_real_int64(x, d);
+#endif
+
+#elif defined(LONG_MAX)
+#if LONG_MAX == 0x7fffL
+    msgpack_pack_real_int16(x, d);
+#elif 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)
+#if SIZEOF_LONG_LONG == 2
+    msgpack_pack_real_int16(x, d);
+#elif SIZEOF_LONG_LONG == 4
+    msgpack_pack_real_int32(x, d);
+#else
+    msgpack_pack_real_int64(x, d);
+#endif
+
+#elif defined(LLONG_MAX)
+#if LLONG_MAX == 0x7fffL
+    msgpack_pack_real_int16(x, d);
+#elif 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)
+#if SIZEOF_SHORT == 2
+    msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_SHORT == 4
+    msgpack_pack_real_uint32(x, d);
+#else
+    msgpack_pack_real_uint64(x, d);
+#endif
+
+#elif defined(USHRT_MAX)
+#if USHRT_MAX == 0xffffU
+    msgpack_pack_real_uint16(x, d);
+#elif 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)
+#if SIZEOF_INT == 2
+    msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_INT == 4
+    msgpack_pack_real_uint32(x, d);
+#else
+    msgpack_pack_real_uint64(x, d);
+#endif
+
+#elif defined(UINT_MAX)
+#if UINT_MAX == 0xffffU
+    msgpack_pack_real_uint16(x, d);
+#elif 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)
+#if SIZEOF_LONG == 2
+    msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_LONG == 4
+    msgpack_pack_real_uint32(x, d);
+#else
+    msgpack_pack_real_uint64(x, d);
+#endif
+
+#elif defined(ULONG_MAX)
+#if ULONG_MAX == 0xffffUL
+    msgpack_pack_real_uint16(x, d);
+#elif ULONG_MAX == 0xffffffffUL
+    msgpack_pack_real_uint32(x, d);
+#else
+    msgpack_pack_real_uint64(x, d);
+#endif
+
+#else
+if(sizeof(unsigned long) == 2) {
+    msgpack_pack_real_uint16(x, d);
+} else if(sizeof(unsigned long) == 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)
+#if SIZEOF_LONG_LONG == 2
+    msgpack_pack_real_uint16(x, d);
+#elif SIZEOF_LONG_LONG == 4
+    msgpack_pack_real_uint32(x, d);
+#else
+    msgpack_pack_real_uint64(x, d);
+#endif
+
+#elif defined(ULLONG_MAX)
+#if ULLONG_MAX == 0xffffUL
+    msgpack_pack_real_uint16(x, d);
+#elif 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)
+{
+    unsigned char buf[5];
+    union { float f; uint32_t i; } mem;
+    mem.f = d;
+    buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i);
+    msgpack_pack_append_buffer(x, buf, 5);
+}
+
+msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
+{
+    unsigned char buf[9];
+    union { double f; uint64_t i; } mem;
+    mem.f = d;
+    buf[0] = 0xcb;
+#if defined(TARGET_OS_IPHONE)
+    // ok
+#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
+    // https://github.com/msgpack/msgpack-perl/pull/1
+    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
+#endif
+    _msgpack_store64(&buf[1], mem.i);
+    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, size_t n)
+{
+    if(n < 16) {
+        unsigned char d = 0x90 | (uint8_t)n;
+        msgpack_pack_append_buffer(x, &d, 1);
+    } else if(n < 65536) {
+        unsigned char buf[3];
+        buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n);
+        msgpack_pack_append_buffer(x, buf, 3);
+    } else {
+        unsigned char buf[5];
+        buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n);
+        msgpack_pack_append_buffer(x, buf, 5);
+    }
+}
+
+
+/*
+ * Map
+ */
+
+msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n)
+{
+    if(n < 16) {
+        unsigned char d = 0x80 | (uint8_t)n;
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
+    } else if(n < 65536) {
+        unsigned char buf[3];
+        buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n);
+        msgpack_pack_append_buffer(x, buf, 3);
+    } else {
+        unsigned char buf[5];
+        buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n);
+        msgpack_pack_append_buffer(x, buf, 5);
+    }
+}
+
+
+/*
+ * Str
+ */
+
+msgpack_pack_inline_func(_str)(msgpack_pack_user x, size_t l)
+{
+    if(l < 32) {
+        unsigned char d = 0xa0 | (uint8_t)l;
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
+    } else if(l < 256) {
+        unsigned char buf[2];
+        buf[0] = 0xd9; buf[1] = (uint8_t)l;
+        msgpack_pack_append_buffer(x, buf, 2);
+    } else if(l < 65536) {
+        unsigned char buf[3];
+        buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
+        msgpack_pack_append_buffer(x, buf, 3);
+    } else {
+        unsigned char buf[5];
+        buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l);
+        msgpack_pack_append_buffer(x, buf, 5);
+    }
+}
+
+msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l)
+{
+    msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
+}
+
+/*
+ * Raw (V4)
+ */
+
+msgpack_pack_inline_func(_v4raw)(msgpack_pack_user x, size_t l)
+{
+    if(l < 32) {
+        unsigned char d = 0xa0 | (uint8_t)l;
+        msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
+    } else if(l < 65536) {
+        unsigned char buf[3];
+        buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
+        msgpack_pack_append_buffer(x, buf, 3);
+    } else {
+        unsigned char buf[5];
+        buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l);
+        msgpack_pack_append_buffer(x, buf, 5);
+    }
+}
+
+msgpack_pack_inline_func(_v4raw_body)(msgpack_pack_user x, const void* b, size_t l)
+{
+    msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
+}
+
+/*
+ * Bin
+ */
+
+msgpack_pack_inline_func(_bin)(msgpack_pack_user x, size_t l)
+{
+    if(l < 256) {
+        unsigned char buf[2];
+        buf[0] = 0xc4; buf[1] = (uint8_t)l;
+        msgpack_pack_append_buffer(x, buf, 2);
+    } else if(l < 65536) {
+        unsigned char buf[3];
+        buf[0] = 0xc5; _msgpack_store16(&buf[1], (uint16_t)l);
+        msgpack_pack_append_buffer(x, buf, 3);
+    } else {
+        unsigned char buf[5];
+        buf[0] = 0xc6; _msgpack_store32(&buf[1], (uint32_t)l);
+        msgpack_pack_append_buffer(x, buf, 5);
+    }
+}
+
+msgpack_pack_inline_func(_bin_body)(msgpack_pack_user x, const void* b, size_t l)
+{
+    msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
+}
+
+/*
+ * Ext
+ */
+
+msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type)
+{
+    switch(l) {
+    case 1: {
+        unsigned char buf[2];
+        buf[0] = 0xd4;
+        buf[1] = (unsigned char)type;
+        msgpack_pack_append_buffer(x, buf, 2);
+    } break;
+    case 2: {
+        unsigned char buf[2];
+        buf[0] = 0xd5;
+        buf[1] = (unsigned char)type;
+        msgpack_pack_append_buffer(x, buf, 2);
+    } break;
+    case 4: {
+        unsigned char buf[2];
+        buf[0] = 0xd6;
+        buf[1] = (unsigned char)type;
+        msgpack_pack_append_buffer(x, buf, 2);
+    } break;
+    case 8: {
+        unsigned char buf[2];
+        buf[0] = 0xd7;
+        buf[1] = (unsigned char)type;
+        msgpack_pack_append_buffer(x, buf, 2);
+    } break;
+    case 16: {
+        unsigned char buf[2];
+        buf[0] = 0xd8;
+        buf[1] = (unsigned char)type;
+        msgpack_pack_append_buffer(x, buf, 2);
+    } break;
+    default:
+        if(l < 256) {
+            unsigned char buf[3];
+            buf[0] = 0xc7;
+            buf[1] = (unsigned char)l;
+            buf[2] = (unsigned char)type;
+            msgpack_pack_append_buffer(x, buf, 3);
+        } else if(l < 65536) {
+            unsigned char buf[4];
+            buf[0] = 0xc8;
+            _msgpack_store16(&buf[1], l);
+            buf[3] = (unsigned char)type;
+            msgpack_pack_append_buffer(x, buf, 4);
+        } else {
+            unsigned char buf[6];
+            buf[0] = 0xc9;
+            _msgpack_store32(&buf[1], l);
+            buf[5] = (unsigned char)type;
+            msgpack_pack_append_buffer(x, buf, 6);
+        }
+        break;
+    }
+}
+
+msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l)
+{
+    msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
+}
+
+msgpack_pack_inline_func(_timestamp)(msgpack_pack_user x, const msgpack_timestamp* d)
+{
+    if ((((int64_t)d->tv_sec) >> 34) == 0) {
+        uint64_t data64 = ((uint64_t) d->tv_nsec << 34) | (uint64_t)d->tv_sec;
+        if ((data64 & 0xffffffff00000000L) == 0)   {
+            // timestamp 32
+            char buf[4];
+            uint32_t data32 = (uint32_t)data64;
+            msgpack_pack_ext(x, 4, -1);
+            _msgpack_store32(buf, data32);
+            msgpack_pack_append_buffer(x, buf, 4);
+        } else {
+            // timestamp 64
+            char buf[8];
+            msgpack_pack_ext(x, 8, -1);
+            _msgpack_store64(buf, data64);
+            msgpack_pack_append_buffer(x, buf, 8);
+        }
+    } else  {
+        // timestamp 96
+        char buf[12];
+        _msgpack_store32(&buf[0], d->tv_nsec);
+        _msgpack_store64(&buf[4], d->tv_sec);
+        msgpack_pack_ext(x, 12, -1);
+        msgpack_pack_append_buffer(x, buf, 12);
+    }
+}
+
+#undef msgpack_pack_inline_func
+#undef msgpack_pack_user
+#undef msgpack_pack_append_buffer
+
+#undef TAKE8_8
+#undef TAKE8_16
+#undef TAKE8_32
+#undef TAKE8_64
+
+#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
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#endif

cmake/sysdep.h.in

@@ -0,0 +1,228 @@
+/*
+ * MessagePack system dependencies
+ *
+ * Copyright (C) 2008-2010 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)
+ */
+#ifndef MSGPACK_SYSDEP_H
+#define MSGPACK_SYSDEP_H
+
+#include <stdlib.h>
+#include <stddef.h>
+
+#ifndef MSGPACK_ENDIAN_BIG_BYTE
+#define MSGPACK_ENDIAN_BIG_BYTE @MSGPACK_ENDIAN_BIG_BYTE@
+#endif
+#ifndef MSGPACK_ENDIAN_LITTLE_BYTE
+#define MSGPACK_ENDIAN_LITTLE_BYTE @MSGPACK_ENDIAN_LITTLE_BYTE@
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+#   define snprintf(buf, len, format,...) _snprintf_s(buf, len, _TRUNCATE, format, __VA_ARGS__)
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1600
+    typedef signed __int8 int8_t;
+    typedef unsigned __int8 uint8_t;
+    typedef signed __int16 int16_t;
+    typedef unsigned __int16 uint16_t;
+    typedef signed __int32 int32_t;
+    typedef unsigned __int32 uint32_t;
+    typedef signed __int64 int64_t;
+    typedef unsigned __int64 uint64_t;
+#   if defined(_WIN64)
+        typedef signed __int64 intptr_t;
+        typedef unsigned __int64 uintptr_t;
+#   else
+        typedef signed __int32 intptr_t;
+        typedef unsigned __int32 uintptr_t;
+#   endif
+#elif defined(_MSC_VER)  // && _MSC_VER >= 1600
+#   include <stdint.h>
+#else
+#   include <stdint.h>
+#   include <stdbool.h>
+#endif
+
+#if !defined(MSGPACK_DLLEXPORT)
+#if defined(_MSC_VER)
+#   define MSGPACK_DLLEXPORT __declspec(dllexport)
+#else  /* _MSC_VER */
+#   define MSGPACK_DLLEXPORT
+#endif /* _MSC_VER */
+#endif
+
+#ifdef _WIN32
+#   if defined(_KERNEL_MODE)
+#       define _msgpack_atomic_counter_header <ntddk.h>
+#   else
+#       define _msgpack_atomic_counter_header <windows.h>
+#       if !defined(WIN32_LEAN_AND_MEAN)
+#           define WIN32_LEAN_AND_MEAN
+#       endif /* WIN32_LEAN_AND_MEAN */
+#   endif
+    typedef long _msgpack_atomic_counter_t;
+#if defined(_AMD64_) || defined(_M_X64) || defined(_M_ARM64)
+#    define _msgpack_sync_decr_and_fetch(ptr) _InterlockedDecrement(ptr)
+#    define _msgpack_sync_incr_and_fetch(ptr) _InterlockedIncrement(ptr)
+#else
+#    define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
+#    define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
+#endif
+#elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
+
+#   if defined(__cplusplus)
+#       define _msgpack_atomic_counter_header "msgpack/gcc_atomic.hpp"
+#   else
+#       define _msgpack_atomic_counter_header "msgpack/gcc_atomic.h"
+#   endif
+
+#else
+    typedef unsigned int _msgpack_atomic_counter_t;
+#   define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1)
+#   define _msgpack_sync_incr_and_fetch(ptr) __sync_add_and_fetch(ptr, 1)
+#endif
+
+#ifdef _WIN32
+
+#   ifdef __cplusplus
+    /* numeric_limits<T>::min,max */
+#       ifdef max
+#           undef max
+#       endif
+#       ifdef min
+#           undef min
+#       endif
+#   endif
+
+#elif defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
+
+#include <arpa/inet.h>  /* __BYTE_ORDER */
+#   if defined(linux)
+#       include <byteswap.h>
+#   endif
+
+#endif
+
+#if !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE)
+#include <msgpack/predef/other/endian.h>
+#endif // !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE)
+
+#if MSGPACK_ENDIAN_LITTLE_BYTE
+
+#   if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
+#       define _msgpack_be16(x) ntohs((uint16_t)x)
+#   else
+#       if defined(ntohs)
+#           define _msgpack_be16(x) ntohs(x)
+#       elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#           define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x))
+#       else
+#           define _msgpack_be16(x) ( \
+                ((((uint16_t)x) <<  8) ) | \
+                ((((uint16_t)x) >>  8) ) )
+#        endif
+#   endif
+
+#   if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
+#       define _msgpack_be32(x) ntohl((uint32_t)x)
+#   else
+#       if defined(ntohl)
+#           define _msgpack_be32(x) ntohl(x)
+#       elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#           define _msgpack_be32(x) ((uint32_t)_byteswap_ulong((unsigned long)x))
+#       else
+#           define _msgpack_be32(x) \
+                ( ((((uint32_t)x) << 24)               ) | \
+                  ((((uint32_t)x) <<  8) & 0x00ff0000U ) | \
+                  ((((uint32_t)x) >>  8) & 0x0000ff00U ) | \
+                  ((((uint32_t)x) >> 24)               ) )
+#       endif
+#   endif
+
+#   if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#        define _msgpack_be64(x) (_byteswap_uint64(x))
+#   elif defined(bswap_64)
+#        define _msgpack_be64(x) bswap_64(x)
+#   elif defined(__DARWIN_OSSwapInt64)
+#        define _msgpack_be64(x) __DARWIN_OSSwapInt64(x)
+#   else
+#        define _msgpack_be64(x) \
+             ( ((((uint64_t)x) << 56)                         ) | \
+               ((((uint64_t)x) << 40) & 0x00ff000000000000ULL ) | \
+               ((((uint64_t)x) << 24) & 0x0000ff0000000000ULL ) | \
+               ((((uint64_t)x) <<  8) & 0x000000ff00000000ULL ) | \
+               ((((uint64_t)x) >>  8) & 0x00000000ff000000ULL ) | \
+               ((((uint64_t)x) >> 24) & 0x0000000000ff0000ULL ) | \
+               ((((uint64_t)x) >> 40) & 0x000000000000ff00ULL ) | \
+               ((((uint64_t)x) >> 56)                         ) )
+#   endif
+
+#elif MSGPACK_ENDIAN_BIG_BYTE
+
+#   define _msgpack_be16(x) (x)
+#   define _msgpack_be32(x) (x)
+#   define _msgpack_be64(x) (x)
+
+#else
+#   error msgpack-c supports only big endian and little endian
+#endif /* MSGPACK_ENDIAN_LITTLE_BYTE */
+
+#define _msgpack_load16(cast, from, to) do {       \
+        memcpy((cast*)(to), (from), sizeof(cast)); \
+        *(to) = (cast)_msgpack_be16(*(to));      \
+    } while (0);
+
+#define _msgpack_load32(cast, from, to) do {       \
+        memcpy((cast*)(to), (from), sizeof(cast)); \
+        *(to) = (cast)_msgpack_be32(*(to));        \
+    } while (0);
+#define _msgpack_load64(cast, from, to) do {       \
+        memcpy((cast*)(to), (from), sizeof(cast)); \
+        *(to) = (cast)_msgpack_be64(*(to));        \
+    } while (0);
+
+#define _msgpack_store16(to, num) \
+    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
+#define _msgpack_store32(to, num) \
+    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
+#define _msgpack_store64(to, num) \
+    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
+
+/*
+#define _msgpack_load16(cast, from) \
+    ({ cast val; memcpy(&val, (char*)from, 2); _msgpack_be16(val); })
+#define _msgpack_load32(cast, from) \
+    ({ cast val; memcpy(&val, (char*)from, 4); _msgpack_be32(val); })
+#define _msgpack_load64(cast, from) \
+    ({ cast val; memcpy(&val, (char*)from, 8); _msgpack_be64(val); })
+*/
+
+
+#if !defined(__cplusplus) && defined(_MSC_VER)
+#  if !defined(_KERNEL_MODE)
+#    if !defined(FALSE)
+#      define FALSE (0)
+#    endif
+#    if !defined(TRUE)
+#      define TRUE (!FALSE)
+#    endif
+#  endif
+#  if _MSC_VER >= 1800
+#    include <stdbool.h>
+#  else
+#    define bool int
+#    define true TRUE
+#    define false FALSE
+#  endif
+#  define inline __inline
+#endif
+
+#ifdef __APPLE__
+#  include <TargetConditionals.h>
+#endif
+
+#endif /* msgpack/sysdep.h */

codecov.yml

@@ -0,0 +1,36 @@
+codecov:
+  notify:
+    require_ci_to_pass: yes
+
+coverage:
+  precision: 2
+  round: down
+  range: "70...100"
+
+  status:
+    project: yes
+    patch: yes
+    changes: no
+
+parsers:
+  gcov:
+    branch_detection:
+      conditional: yes
+      loop: yes
+      method: no
+      macro: no
+
+comment:
+  layout: "header, diff"
+  behavior: default
+  require_changes: no
+
+ignore:
+  - "test"
+  - "fuzz"
+  - "erb"
+  - "ci"
+  - "cmake"
+  - "examle"
+  - "external"
+  - "usr"

configure.in

@@ -1,100 +0,0 @@
-AC_INIT(src/object.cpp)
-AC_CONFIG_AUX_DIR(ac)
-AM_INIT_AUTOMAKE(msgpack, 0.5.9)
-AC_CONFIG_HEADER(config.h)
-
-AC_SUBST(CFLAGS)
-CFLAGS="-O3 -Wall $CFLAGS"
-
-AC_SUBST(CXXFLAGS)
-CXXFLAGS="-O3 -Wall $CXXFLAGS"
-
-
-AC_PROG_CC
-
-
-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_PROG_CXX
-	AM_PROG_CC_C_O
-fi
-AM_CONDITIONAL(ENABLE_CXX, test "$enable_cxx" != "no")
-
-
-AC_PROG_LIBTOOL
-AM_PROG_AS
-
-
-AC_MSG_CHECKING([if debug option is enabled])
-AC_ARG_ENABLE(debug,
-	AS_HELP_STRING([--disable-debug],
-				   [disable assert macros and omit -g option]) )
-AC_MSG_RESULT([$enable_debug])
-if test "$enable_debug" != "no"; then
-	CXXFLAGS="$CXXFLAGS -g"
-	CFLAGS="$CFLAGS -g"
-else
-	CXXFLAGS="$CXXFLAGS -DNDEBUG"
-	CFLAGS="$CFLAGS -DNDEBUG"
-fi
-
-
-AC_CACHE_CHECK([for __sync_* atomic operations], msgpack_cv_atomic_ops, [
-	AC_TRY_LINK([
-		int atomic_sub(int i) { return __sync_sub_and_fetch(&i, 1); }
-		int atomic_add(int i) { return __sync_add_and_fetch(&i, 1); }
-	], [atomic_sub(1); atomic_add(1);], msgpack_cv_atomic_ops="yes")
-	])
-if test "$msgpack_cv_atomic_ops" != "yes"; then
-	if test "$enable_cxx" = "no"; then
-		AC_MSG_ERROR([__sync_* atomic operations are not found. Try to enable C++ support.
-If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
-add CFLAGS="-march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
-
-  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
-					  ])
-	fi
-
-	AC_LANG_PUSH([C++])
-	AC_CACHE_CHECK([for __gnu_cxx::__exchange_and_add], msgpack_cv_gcc_cxx_atomic_ops, [
-		AC_TRY_LINK([
-			#include <bits/atomicity.h>
-			int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; }
-			int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; }
-		], [atomic_sub(1); atomic_add(1);], msgpack_cv_gcc_cxx_atomic_ops="yes")
-		])
-	AC_LANG_POP([C++])
-
-	if test "$msgpack_cv_gcc_cxx_atomic_ops" != "yes"; then
-		AC_MSG_ERROR([__sync_* atomic operations nor __gnu_cxx::__exchange_and_add are not found.
-
-If you are using gcc >= 4.1 and the default target CPU architecture is "i386", try to
-add CFLAGS="-march=i686" and CXXFLAGS="-march=i686" options to ./configure as follows:
-
-  $ ./configure CFLAGS="-march=i686" CXXFLAGS="-march=i686"
-])
-
-	else
-		enable_gcc_cxx_atomic=yes
-	fi
-fi
-
-AM_CONDITIONAL(ENABLE_GCC_CXX_ATOMIC, test "$enable_gcc_cxx_atomic" = "yes")
-
-
-major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'`
-minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'`
-AC_SUBST(VERSION_MAJOR, $major)
-AC_SUBST(VERSION_MINOR, $minor)
-
-
-AC_OUTPUT([Makefile
-		   msgpack.pc
-		   src/Makefile
-		   src/msgpack/version.h
-		   test/Makefile])
-

crosslang.cc

@@ -1,133 +0,0 @@
-//
-// MessagePack cross-language test tool
-//
-// $ cd ../cpp && ./configure && make && make install
-// or
-// $ port install msgpack  # MacPorts
-//
-// $ g++ -Wall crosslang.cc -lmsgpack
-//
-#include <msgpack.hpp>
-#include <iostream>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-
-static int run(int infd, int outfd)
-try {
-	msgpack::unpacker pac;
-
-	while(true) {
-		pac.reserve_buffer(32*1024);
-
-		ssize_t count =
-			read(infd, pac.buffer(), pac.buffer_capacity());
-
-		if(count <= 0) {
-			if(count == 0) {
-				return 0;
-			}
-			if(errno == EAGAIN || errno == EINTR) {
-				continue;
-			}
-			return 1;
-		}
-
-		pac.buffer_consumed(count);
-
-		msgpack::unpacked result;
-		while(pac.next(&result)) {
-			msgpack::sbuffer sbuf;
-			msgpack::pack(sbuf, result.get());
-
-			const char* p = sbuf.data();
-			const char* const pend = p + sbuf.size();
-			while(p < pend) {
-				ssize_t bytes = write(outfd, p, pend-p);
-
-				if(bytes <= 0) {
-					if(count == 0) {
-						return 0;
-					}
-					if(errno == EAGAIN || errno == EINTR) {
-						continue;
-					}
-					return 1;
-				}
-
-				p += bytes;
-			}
-
-		}
-	}
-
-	return 0;
-
-} catch (std::exception& e) {
-	std::cerr << e.what() << std::endl;
-	return 1;
-}
-
-static void usage(const char* prog)
-{
-	printf(
-		"Usage: %s [in-file] [out-file]\n"
-		"\n"
-		"This tool is for testing of MessagePack implementation.\n"
-		"This does following behavior:\n"
-		"\n"
-		"  1. Reads objects serialized by MessagePack from <in-file> (default: stdin)\n"
-		"  2. Re-serializes the objects using C++ implementation of MessagePack (Note that C++ implementation is considered valid)\n"
-		"  3. Writes the re-serialized objects into <out-file> (default: stdout)\n"
-		"\n"
-		, prog);
-	exit(1);
-}
-
-int main(int argc, char* argv[])
-{
-	int infd = 0;
-	int outfd = 1;
-
-	if(argc < 1 || argc > 3) {
-		usage(argv[0]);
-	}
-
-	for(int i=1; i < argc; ++i) {
-		if(strlen(argv[i]) > 1 && argv[i][0] == '-') {
-			usage(argv[0]);
-		}
-	}
-
-	if(argc >= 2) {
-		const char* fname = argv[1];
-		if(strcmp(fname, "-") != 0) {
-			infd = open(fname, O_RDONLY);
-			if(infd < 0) {
-				perror("can't open input file");
-				exit(1);
-			}
-		}
-	}
-
-	if(argc >= 3) {
-		const char* fname = argv[2];
-		if(strcmp(fname, "-") != 0) {
-			outfd = open(fname, O_WRONLY | O_CREAT| O_TRUNC, 0666);
-			if(outfd < 0) {
-				perror("can't open output file");
-				exit(1);
-			}
-		}
-	}
-
-	int code = run(infd, outfd);
-
-	close(infd);
-	close(outfd);
-
-	return code;
-}
-

crosslang.rb

@@ -1,88 +0,0 @@
-#
-# MessagePack cross-language test tool
-#
-# $ gem install msgpack
-# or
-# $ port install rb_msgpack   # MacPorts
-#
-begin
-require 'rubygems'
-rescue LoadError
-end
-require 'msgpack'
-
-def run(inio, outio)
-	pac = MessagePack::Unpacker.new(inio)
-
-	begin
-		pac.each {|obj|
-			outio.write MessagePack.pack(obj)
-			outio.flush
-		}
-	rescue EOFError
-		return 0
-	rescue
-		$stderr.puts $!
-		return 1
-	end
-
-	return 0
-end
-
-def usage
-	puts <<EOF
-Usage: #{$0} [in-file] [out-file]
-
-This tool is for testing of MessagePack implementation.
-This does following behavior:
-
-  1. Reads objects serialized by MessagePack from <in-file> (default: stdin)
-  2. Re-serializes the objects using Ruby implementation of MessagePack (Note that Ruby implementation is considered valid)
-  3. Writes the re-serialized objects into <out-file> (default: stdout)
-
-EOF
-	exit 1
-end
-
-inio = $stdin
-outio = $stdout
-
-if ARGV.length > 2
-	usage
-end
-
-ARGV.each {|str|
-	if str.size > 1 && str[0] == ?-
-		usage
-	end
-}
-
-if fname = ARGV[0]
-	unless fname == "-"
-		begin
-			inio = File.open(fname)
-		rescue
-			puts "can't open output file: #{$!}"
-			exit 1
-		end
-	end
-end
-
-if fname = ARGV[1]
-	unless fname == "-"
-		begin
-			outio = File.open(fname, "w")
-		rescue
-			puts "can't open output file: #{$!}"
-			exit 1
-		end
-	end
-end
-
-code = run(inio, outio)
-
-inio.close
-outio.close
-
-exit code
-

example/CMakeLists.txt

@@ -0,0 +1,44 @@
+FIND_PACKAGE (cJSON)
+
+LIST (APPEND exec_PROGRAMS
+    boundary.c
+    lib_buffer_unpack.c
+    simple_c.c
+    speed_test_uint32_array.c
+    speed_test_uint64_array.c
+    user_buffer_unpack.c
+)
+IF (cJSON_FOUND)
+    LIST (APPEND exec_PROGRAMS jsonconv.c)
+ENDIF ()
+
+FOREACH (source_file ${exec_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        msgpack-c
+    )
+    IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
+    ENDIF ()
+
+    IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
+    ENDIF ()
+
+    IF ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+        IF (CMAKE_C_FLAGS MATCHES "/W[0-4]")
+            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        ELSE ()
+            SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3 /WX")
+        ENDIF ()
+    ENDIF ()
+ENDFOREACH ()
+
+IF (cJSON_FOUND)
+    TARGET_LINK_LIBRARIES (jsonconv ${CJSON_LIBRARIES})
+    TARGET_INCLUDE_DIRECTORIES(jsonconv PRIVATE ${CJSON_INCLUDE_DIRS})
+ENDIF ()

example/boundary.c

@@ -0,0 +1,296 @@
+/* gcc boundary.c -o boundary -Wconversion -Wpointer-sign */
+#include <msgpack.h>
+#include <stdio.h>
+#include <assert.h>
+
+static inline unsigned char atohex(char a)
+{
+    int x;
+    if (a >= 'a') {
+        x = a - 'a' + 10;
+    } else if (a >= 'A') {
+        x = a - 'A' + 10;
+    } else {
+        x = a - '0';
+    }
+    assert(x >= 0 && x < 16);
+    return (unsigned char)x;
+}
+
+// Return 0 if equal
+static inline int bytesncmp(char *data, const char *bytes, size_t len)
+{
+    size_t n = len >> 1;
+    size_t i = 0;
+    int diff;
+    for (; i < n; i++) {
+        diff = (unsigned char)data[i] - (atohex(bytes[2 * i]) << 4) - atohex(bytes[2 * i + 1]);
+        if (diff != 0) {
+            return diff;
+        }
+    }
+    return 0;
+}
+
+int main()
+{
+    msgpack_sbuffer sbuf;
+    msgpack_packer *x;
+    size_t offset = 0;
+    char data[65536];
+    msgpack_timestamp ts[] = {
+        { 0xFFFFFFFF, 0 },
+        { 0x100000000, 0 },
+        { 0x3FFFFFFFF, 0 },
+        { 0x400000000, 0 },
+        { INT64_MAX, UINT32_MAX }
+    };
+
+#define check_sbuffer(b)                                     \
+    do {                                                     \
+        size_t len = strlen(#b);                             \
+        assert((sbuf.size - offset) * 2 == len);             \
+        assert(bytesncmp(sbuf.data + offset, #b, len) == 0); \
+        offset = sbuf.size;                                  \
+    } while (0)
+
+    msgpack_sbuffer_init(&sbuf);
+    x = msgpack_packer_new(&sbuf, msgpack_sbuffer_write);
+
+    msgpack_pack_fix_uint8(x, 0); check_sbuffer(cc00);          /* cc 00 */
+    msgpack_pack_fix_uint8(x, 0xFF); check_sbuffer(ccff);       /* cc ff */
+    msgpack_pack_fix_uint16(x, 0); check_sbuffer(cd0000);       /* cd 00 00 */
+    msgpack_pack_fix_uint16(x, 0xFFFF); check_sbuffer(cdffff);  /* cd ff ff */
+    msgpack_pack_fix_uint32(x, 0); check_sbuffer(ce00000000);   /* ce 00 00 00 00 */
+    msgpack_pack_fix_uint32(x, 0xFFFFFFFF); check_sbuffer(ceffffffff);  /* ce ff ff ff ff */
+    msgpack_pack_fix_uint64(x, 0); check_sbuffer(cf0000000000000000);   /* cf 00 00 00 00 00 00 00 00 */
+    msgpack_pack_fix_uint64(x, 0xFFFFFFFFFFFFFFFF); check_sbuffer(cfffffffffffffffff);  /* cf ff ff ff ff ff ff ff ff */
+
+    msgpack_pack_uint8(x, 0); check_sbuffer(00);            /* 00 */
+    msgpack_pack_uint8(x, 0x7F); check_sbuffer(7f);         /* 7f */
+    msgpack_pack_uint8(x, 0x80); check_sbuffer(cc80);       /* cc 80 */
+    msgpack_pack_uint8(x, 0xFF); check_sbuffer(ccff);       /* cc ff */
+
+    msgpack_pack_uint16(x, 0); check_sbuffer(00);           /* 00 */
+    msgpack_pack_uint16(x, 0x7F); check_sbuffer(7f);        /* 7f */
+    msgpack_pack_uint16(x, 0x80); check_sbuffer(cc80);      /* cc 80 */
+    msgpack_pack_uint16(x, 0xFF); check_sbuffer(ccff);      /* cc ff */
+    msgpack_pack_uint16(x, 0x100); check_sbuffer(cd0100);   /* cd 01 00 */
+    msgpack_pack_uint16(x, 0xFFFF); check_sbuffer(cdffff);  /* cd ff ff */
+
+    msgpack_pack_uint32(x, 0); check_sbuffer(00);           /* 00 */
+    msgpack_pack_uint32(x, 0x7F); check_sbuffer(7f);        /* 7f */
+    msgpack_pack_uint32(x, 0x80); check_sbuffer(cc80);      /* cc 80 */
+    msgpack_pack_uint32(x, 0xFF); check_sbuffer(ccff);      /* cc ff */
+    msgpack_pack_uint32(x, 0x100); check_sbuffer(cd0100);   /* cd 01 00 */
+    msgpack_pack_uint32(x, 0xFFFF); check_sbuffer(cdffff);  /* cd ff ff */
+    msgpack_pack_uint32(x, 0x10000); check_sbuffer(ce00010000);     /* ce 00 01 00 00 */
+    msgpack_pack_uint32(x, 0xFFFFFFFF); check_sbuffer(ceffffffff);  /* ce ff ff ff ff */
+
+    msgpack_pack_uint64(x, 0); check_sbuffer(00);           /* 00 */
+    msgpack_pack_uint64(x, 0x7F); check_sbuffer(7f);        /* 7f */
+    msgpack_pack_uint64(x, 0x80); check_sbuffer(cc80);      /* cc 80 */
+    msgpack_pack_uint64(x, 0xFF); check_sbuffer(ccff);      /* cc ff */
+    msgpack_pack_uint64(x, 0x100); check_sbuffer(cd0100);   /* cd 01 00 */
+    msgpack_pack_uint64(x, 0xFFFF); check_sbuffer(cdffff);  /* cd ff ff */
+    msgpack_pack_uint64(x, 0x10000); check_sbuffer(ce00010000);     /* ce 00 01 00 00 */
+    msgpack_pack_uint64(x, 0xFFFFFFFF); check_sbuffer(ceffffffff);  /* ce ff ff ff ff */
+    msgpack_pack_uint64(x, 0x100000000); check_sbuffer(cf0000000100000000);         /* cf 00 00 00 01 00 00 00 00 */
+    msgpack_pack_uint64(x, 0xFFFFFFFFFFFFFFFF); check_sbuffer(cfffffffffffffffff);  /* cf ff ff ff ff ff ff ff ff */
+
+    msgpack_pack_fix_int8(x, 0x7F); check_sbuffer(d07f);            /* d0 7f */
+    msgpack_pack_fix_int8(x, -0x7F-1); check_sbuffer(d080);         /* d0 80 */
+    msgpack_pack_fix_int16(x, 0x7FFF); check_sbuffer(d17fff);       /* d1 7f ff */
+    msgpack_pack_fix_int16(x, -0x7FFF-1); check_sbuffer(d18000);    /* d1 80 00 */
+    msgpack_pack_fix_int32(x, 0x7FFFFFFF); check_sbuffer(d27fffffff);       /* d2 7f ff ff ff */
+    msgpack_pack_fix_int32(x, -0x7FFFFFFF-1); check_sbuffer(d280000000);    /* d2 80 00 00 00 */
+    msgpack_pack_fix_int64(x, 0x7FFFFFFFFFFFFFFF); check_sbuffer(d37fffffffffffffff);       /* d3 7f ff ff ff ff ff ff ff */
+    msgpack_pack_fix_int64(x, -0x7FFFFFFFFFFFFFFF-1); check_sbuffer(d38000000000000000);    /* d3 80 00 00 00 00 00 00 00 */
+
+    msgpack_pack_int8(x, -0x7F-1); check_sbuffer(d080);         /* d0 80 */
+    msgpack_pack_int8(x, -0x21); check_sbuffer(d0df);           /* d0 df */
+    msgpack_pack_int8(x, -0x20); check_sbuffer(e0);             /* e0 */
+    msgpack_pack_int8(x, -1); check_sbuffer(ff);                /* ff */
+    msgpack_pack_int8(x, 0); check_sbuffer(00);                 /* 00 */
+    msgpack_pack_int8(x, 0x7F); check_sbuffer(7f);              /* 7f */
+
+    msgpack_pack_int16(x, -0x7FFF-1); check_sbuffer(d18000);    /* d1 80 00 */
+    msgpack_pack_int16(x, -0x81); check_sbuffer(d1ff7f);        /* d1 ff 7f */
+    msgpack_pack_int16(x, -0x80); check_sbuffer(d080);          /* d0 80 */
+    msgpack_pack_int16(x, -0x21); check_sbuffer(d0df);          /* d0 df */
+    msgpack_pack_int16(x, -0x20); check_sbuffer(e0);            /* e0 */
+    msgpack_pack_int16(x, -0x1); check_sbuffer(ff);             /* ff */
+    msgpack_pack_int16(x, 0); check_sbuffer(00);                /* 00 */
+    msgpack_pack_int16(x, 0x7F); check_sbuffer(7f);             /* 7f */
+    msgpack_pack_int16(x, 0x80); check_sbuffer(cc80);           /* cc 80 */
+    msgpack_pack_int16(x, 0xFF); check_sbuffer(ccff);           /* cc ff */
+    msgpack_pack_int16(x, 0x100); check_sbuffer(cd0100);        /* cd 01 00 */
+    msgpack_pack_int16(x, 0x7FFF); check_sbuffer(cd7fff);       /* cd 7f ff */
+
+    msgpack_pack_int32(x, -0x7FFFFFFF-1); check_sbuffer(d280000000);    /* d2 80 00 00 00 */
+    msgpack_pack_int32(x, -0x8001); check_sbuffer(d2ffff7fff);          /* d2 ff ff 7f ff */
+    msgpack_pack_int32(x, -0x8000); check_sbuffer(d18000);              /* d1 80 00 */
+    msgpack_pack_int32(x, -0x81); check_sbuffer(d1ff7f);                /* d1 ff 7f */
+    msgpack_pack_int32(x, -0x80); check_sbuffer(d080);                  /* d0 80 */
+    msgpack_pack_int32(x, -0x21); check_sbuffer(d0df);                  /* d0 df */
+    msgpack_pack_int32(x, -0x20); check_sbuffer(e0);                    /* e0 */
+    msgpack_pack_int32(x, -0x1); check_sbuffer(ff);                     /* ff */
+    msgpack_pack_int32(x, 0); check_sbuffer(00);                        /* 00 */
+    msgpack_pack_int32(x, 0x7F); check_sbuffer(7f);                     /* 7f */
+    msgpack_pack_int32(x, 0x80); check_sbuffer(cc80);                   /* cc 80 */
+    msgpack_pack_int32(x, 0xFF); check_sbuffer(ccff);                   /* cc ff */
+    msgpack_pack_int32(x, 0x100); check_sbuffer(cd0100);                /* cd 01 00 */
+    msgpack_pack_int32(x, 0xFFFF); check_sbuffer(cdffff);               /* cd ff ff */
+    msgpack_pack_int32(x, 0x10000); check_sbuffer(ce00010000);          /* ce 00 01 00 00 */
+    msgpack_pack_int32(x, 0x7FFFFFFF); check_sbuffer(ce7fffffff);       /* ce 7f ff ff ff */
+
+    msgpack_pack_int64(x, -0x7FFFFFFFFFFFFFFF-1); check_sbuffer(d38000000000000000);    /* d3 80 00 00 00 00 00 00 00 */
+    msgpack_pack_int64(x, -((1LL<<31)+1)); check_sbuffer(d3ffffffff7fffffff);   /* d3 ff ff ff ff 7f ff ff ff */
+    msgpack_pack_int64(x, -(1LL<<31)); check_sbuffer(d280000000);               /* d2 80 00 00 00 */
+    msgpack_pack_int64(x, -0x8001); check_sbuffer(d2ffff7fff);                  /* d2 ff ff 7f ff */
+    msgpack_pack_int64(x, -0x8000); check_sbuffer(d18000);                      /* d1 80 00 */
+    msgpack_pack_int64(x, -0x81); check_sbuffer(d1ff7f);                        /* d1 ff 7f */
+    msgpack_pack_int64(x, -0x80); check_sbuffer(d080);                          /* d0 80 */
+    msgpack_pack_int64(x, -0x21); check_sbuffer(d0df);                          /* d0 df */
+    msgpack_pack_int64(x, -0x20); check_sbuffer(e0);                            /* e0 */
+    msgpack_pack_int64(x, -0x1); check_sbuffer(ff);                             /* ff */
+    msgpack_pack_int64(x, 0); check_sbuffer(00);                                /* 00 */
+    msgpack_pack_int64(x, 0x7F); check_sbuffer(7f);                             /* 7f */
+    msgpack_pack_int64(x, 0x80); check_sbuffer(cc80);                           /* cc 80 */
+    msgpack_pack_int64(x, 0xFF); check_sbuffer(ccff);                           /* cc ff */
+    msgpack_pack_int64(x, 0x100); check_sbuffer(cd0100);                        /* cd 01 00 */
+    msgpack_pack_int64(x, 0xFFFF); check_sbuffer(cdffff);                       /* cd ff ff */
+    msgpack_pack_int64(x, 0x10000); check_sbuffer(ce00010000);                  /* ce 00 01 00 00 */
+    msgpack_pack_int64(x, 0xFFFFFFFF); check_sbuffer(ceffffffff);               /* ce ff ff ff ff */
+    msgpack_pack_int64(x, 0x100000000); check_sbuffer(cf0000000100000000);      /* cf 00 00 00 01 00 00 00 00 */
+    msgpack_pack_int64(x, 0x7FFFFFFFFFFFFFFF); check_sbuffer(cf7fffffffffffffff);   /* cf 7f ff ff ff ff ff ff ff */
+
+    msgpack_pack_nil(x);    check_sbuffer(c0);          /* c0 */
+    msgpack_pack_false(x);  check_sbuffer(c2);          /* c2 */
+    msgpack_pack_true(x);   check_sbuffer(c3);          /* c3 */
+
+    msgpack_pack_float(x, 1.0); check_sbuffer(ca3f800000);          /* ca 3f 80 00 00 */
+    msgpack_pack_double(x, 1.0); check_sbuffer(cb3ff0000000000000); /* cb 3f f0 00 00 00 00 00 00 */
+
+    msgpack_pack_unsigned_char(x, UINT8_MAX);       /* same as msgpack_pack_uint8() */
+    msgpack_pack_unsigned_short(x, (unsigned short)UINT64_MAX);
+    msgpack_pack_unsigned_int(x, (unsigned int)UINT64_MAX);
+    msgpack_pack_unsigned_long(x, (unsigned long)UINT64_MAX);
+    msgpack_pack_unsigned_long_long(x, (unsigned long long)UINT64_MAX);
+
+    msgpack_pack_signed_char(x, INT8_MAX);          /* same as msgpack_pack_int8() */
+
+#define check_sbuffer_n(b)                                   \
+    do {                                                     \
+        size_t len = strlen(#b);                             \
+        assert(bytesncmp(sbuf.data + offset, #b, len) == 0); \
+        offset = sbuf.size;                                  \
+    } while (0)
+
+#define fill_str(n) msgpack_pack_str_body(x, data, n)
+
+    offset = sbuf.size;
+    msgpack_pack_str(x, 0); /* "" */ check_sbuffer(a0); /* a0 */
+    msgpack_pack_str(x, 31);
+    fill_str(31); check_sbuffer_n(bf);                  /* bf ... */
+    msgpack_pack_str(x, 32);
+    fill_str(32); check_sbuffer_n(d920);                /* d9 20 ... */
+    msgpack_pack_str(x, 255);
+    fill_str(255); check_sbuffer_n(d9ff);               /* d9 ff ... */
+    msgpack_pack_str(x, 256);
+    fill_str(256); check_sbuffer_n(da0100);             /* da 01 00 ... */
+    msgpack_pack_str(x, 65535);
+    fill_str(65535); check_sbuffer_n(daffff);           /* da ff ff ... */
+    msgpack_pack_str(x, 65536);
+    fill_str(65536); check_sbuffer_n(db00010000);       /* db 00 01 00 00 ... */
+
+#define fill_map(n)                                             \
+    do {                                                        \
+        size_t i = 0;                                           \
+        for (; i < n * 2; i++) { msgpack_pack_int8(x, 0x1); }   \
+    } while (0);
+
+    msgpack_pack_map(x, 0); /* {} */ check_sbuffer(80); /* 80 */
+    msgpack_pack_map(x, 1);
+    fill_map(1); check_sbuffer_n(81);                   /* 81 ... */
+    msgpack_pack_map(x, 15);
+    fill_map(15); check_sbuffer_n(8f);                  /* 8f ... */
+    msgpack_pack_map(x, 16);
+    fill_map(16); check_sbuffer_n(de0010);              /* de 00 10 ... */
+    msgpack_pack_map(x, 65535);
+    fill_map(65535); check_sbuffer_n(deffff);           /* de ff ff ... */
+    msgpack_pack_map(x, 65536);
+    fill_map(65536); check_sbuffer_n(df00010000);       /* df 00 01 00 00 ... */
+
+#define fill_array(n)                                       \
+    do {                                                    \
+        size_t i = 0;                                       \
+        for (; i < n; i++) { msgpack_pack_int8(x, 0x1); }   \
+    } while (0);
+
+    msgpack_pack_array(x, 0); /* [] */ check_sbuffer(90);   /* 90 */
+    msgpack_pack_array(x, 1);
+    fill_array(1); check_sbuffer_n(91);                 /* 91 ... */
+    msgpack_pack_array(x, 15);
+    fill_array(15); check_sbuffer_n(9f);                /* 9f ... */
+    msgpack_pack_array(x, 16);
+    fill_array(16); check_sbuffer_n(dc0010);            /* dc 00 10 ... */
+    msgpack_pack_array(x, 65535);
+    fill_array(65535); check_sbuffer_n(dcffff);         /* dc ff ff ... */
+    msgpack_pack_array(x, 65536);
+    fill_array(65536); check_sbuffer_n(dd00010000);     /* dd 00 01 00 00 ... */
+
+#define fill_bin(n) msgpack_pack_bin_body(x, data, n)
+
+    msgpack_pack_bin(x, 0); check_sbuffer(c400);        /* c4 00 */
+    msgpack_pack_bin(x, 1);
+    fill_bin(1); check_sbuffer_n(c401);                 /* c4 01 ... */
+    msgpack_pack_bin(x, 255);
+    fill_bin(255); check_sbuffer_n(c4ff);               /* c4 ff ... */
+    msgpack_pack_bin(x, 256);
+    fill_bin(256); check_sbuffer_n(c50100);             /* c5 01 00 ... */
+    msgpack_pack_bin(x, 65535);
+    fill_bin(65535); check_sbuffer_n(c5ffff);           /* c5 ff ff ... */
+    msgpack_pack_bin(x, 65536);
+    fill_bin(65536); check_sbuffer_n(c600010000);       /* c6 00 01 00 00 ... */
+
+#define fill_ext(n) msgpack_pack_ext_body(x, data, n)
+
+    msgpack_pack_ext(x, 1, 0x7F);
+    fill_ext(1); check_sbuffer_n(d47f);                 /* d4 7f ... */
+    msgpack_pack_ext(x, 2, 0x7F);
+    fill_ext(2); check_sbuffer_n(d57f);                 /* d5 7f ... */
+    msgpack_pack_ext(x, 4, 0x7F);
+    fill_ext(4); check_sbuffer_n(d67f);                 /* d6 7f ... */
+    msgpack_pack_ext(x, 8, 0x7F);
+    fill_ext(8); check_sbuffer_n(d77f);                 /* d7 7f ... */
+    msgpack_pack_ext(x, 16, 0x7F);
+    fill_ext(16); check_sbuffer_n(d87f);                /* d8 7f ... */
+
+    msgpack_pack_ext(x, 0, 0x7F); check_sbuffer(c7007f); /* c7 00 7f */
+    msgpack_pack_ext(x, 3, 0x7F);
+    fill_ext(3); check_sbuffer_n(c7037f);               /* c7 03 7f */
+    msgpack_pack_ext(x, 5, 0x7F);
+    fill_ext(5); check_sbuffer_n(c7057f);               /* c7 05 7f */
+    msgpack_pack_ext(x, 17, 0x7F);
+    fill_ext(17); check_sbuffer_n(c7117f);              /* c7 11 7f */
+    msgpack_pack_ext(x, 255, 0x7F);
+    fill_ext(255); check_sbuffer_n(c7ff7f);             /* c7 ff 7f ... */
+    msgpack_pack_ext(x, 256, 0x7F);
+    fill_ext(256); check_sbuffer_n(c801007f);           /* c8 01 00 7f ... */
+    msgpack_pack_ext(x, 65535, 0x7F);
+    fill_ext(65535); check_sbuffer_n(c8ffff7f);         /* c8 ff ff 7f ... */
+    msgpack_pack_ext(x, 65536, 0x7F);
+    fill_ext(65536); check_sbuffer_n(c9000100007f);     /* c9 00 01 00 00 7f ... */
+
+    msgpack_pack_timestamp(x, ts); check_sbuffer(d6ffffffffff); /* d6 ff ff ff ff ff */
+    msgpack_pack_timestamp(x, ts + 1); check_sbuffer(d7ff0000000100000000); /* d7 ff 00 00 00 01 00 00 00 00 */
+    msgpack_pack_timestamp(x, ts + 2); check_sbuffer(d7ff00000003ffffffff); /* d7 ff 00 00 00 03 ff ff ff ff */
+    msgpack_pack_timestamp(x, ts + 3); check_sbuffer(c70cff000000000000000400000000);   /* c7 0c ff 00 00 00 00 00 00 00 04 00 00 00 00 */
+    msgpack_pack_timestamp(x, ts + 4); check_sbuffer(c70cffffffffff7fffffffffffffff);   /* c7 0c ff ff ff ff ff 7f ff ff ff ff ff ff ff */
+
+    msgpack_sbuffer_destroy(&sbuf);
+    msgpack_packer_free(x);
+
+    return 0;
+}

example/cmake/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required (VERSION 3.0)
+project (example)
+
+if(EXAMPLE_MSGPACK_EMBEDDED)
+    add_subdirectory(msgpack-c)
+    set(msgpack-c_DIR ${CMAKE_CURRENT_BINARY_DIR}/msgpack-c)
+endif()
+
+find_package(msgpack-c REQUIRED)
+
+add_executable (${PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/../simple_c.c)
+target_link_libraries(${PROJECT_NAME} msgpack-c)
+
+if(TARGET msgpack-c-static)
+    add_executable (${PROJECT_NAME}-static ${CMAKE_CURRENT_LIST_DIR}/../simple_c.c)
+    target_link_libraries(${PROJECT_NAME}-static msgpack-c-static)
+endif()

example/custom.cc

@@ -1,58 +0,0 @@
-#include <msgpack.hpp>
-#include <string>
-#include <iostream>
-
-class old_class {
-public:
-	old_class() : value("default") { }
-
-	std::string value;
-
-	MSGPACK_DEFINE(value);
-};
-
-class new_class {
-public:
-	new_class() : value("default"), flag(-1) { }
-
-	std::string value;
-	int flag;
-
-	MSGPACK_DEFINE(value, flag);
-};
-
-int main(void)
-{
-	{
-		old_class oc;
-		new_class nc;
-
-		msgpack::sbuffer sbuf;
-		msgpack::pack(sbuf, oc);
-
-		msgpack::zone zone;
-		msgpack::object obj;
-		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj);
-
-		obj.convert(&nc);
-
-		std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl;
-	}
-
-	{
-		new_class nc;
-		old_class oc;
-
-		msgpack::sbuffer sbuf;
-		msgpack::pack(sbuf, nc);
-
-		msgpack::zone zone;
-		msgpack::object obj;
-		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj);
-
-		obj.convert(&oc);
-
-		std::cout << obj << " value=" << oc.value << std::endl;
-	}
-}
-

example/jsonconv.c

@@ -0,0 +1,419 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <msgpack.h>
+#include <cjson/cJSON.h>
+
+#if defined(_MSC_VER)
+#if _MSC_VER >= 1800
+#include <inttypes.h>
+#else
+#define PRIu64 "I64u"
+#define PRIi64 "I64i"
+#define PRIi8 "i"
+#endif
+#else
+#include <inttypes.h>
+#endif
+
+#if defined(_KERNEL_MODE)
+#  undef  snprintf
+#  define snprintf _snprintf
+#endif
+
+#define DEBUG(...) printf(__VA_ARGS__)
+
+static char *format_string(const char *input)
+{
+    const char *inptr;
+    char *output;
+    char *outptr;
+    size_t output_length = 0;
+    /* numbers of additional characters*/
+    size_t escape_characters = 0;
+
+    if (input == NULL) {
+        return NULL;
+    }
+
+    for (inptr = input; *inptr; inptr++) {
+        switch (*inptr) {
+        case '\"':
+        case '\\':
+        case '\b':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\t':
+            /* one character escape sequence */
+            escape_characters++;
+            break;
+        default:
+            break;
+        }
+    }
+    output_length = (size_t)(inptr - input) + escape_characters;
+
+    output = (char *)malloc(output_length + 1);
+    if (output == NULL) {
+        return NULL;
+    }
+
+    /* no add characters*/
+    if (escape_characters == 0) {
+        memcpy(output, input, output_length);
+        output[output_length] = '\0';
+        return output;
+    }
+
+    outptr = output;
+    /* copy string */
+    for (inptr = input; *inptr != '\0'; (void)inptr++, outptr++) {
+        if ((*inptr > 31) && (*inptr != '\"') && (*inptr != '\\')) {
+            /* normal character, copy */
+            *outptr = *inptr;
+        } else {
+            /* character needs to be escaped */
+            *outptr++ = '\\';
+            switch (*inptr)
+            {
+            case '\\':
+                *outptr = '\\';
+                break;
+            case '\"':
+                *outptr = '\"';
+                break;
+            case '\b':
+                *outptr = 'b';
+                break;
+            case '\f':
+                *outptr = 'f';
+                break;
+            case '\n':
+                *outptr = 'n';
+                break;
+            case '\r':
+                *outptr = 'r';
+                break;
+            case '\t':
+                *outptr = 't';
+                break;
+            default:
+                break;
+            }
+        }
+    }
+
+    output[output_length] = '\0';
+    return output;
+}
+
+/*
+ * Pack cJSON object.
+ * return 0 success, others failed
+ */
+static int parse_cjson_object(msgpack_packer *pk, cJSON *node)
+{
+    int ret, sz, i;
+    cJSON *child;
+    char *strvalue;
+
+    if (node == NULL) {
+        return -1;
+    }
+
+    switch (node->type & 0xFF) {
+    case cJSON_Invalid:
+        return -1;
+
+    case cJSON_False:
+        return msgpack_pack_false(pk);
+
+    case cJSON_True:
+        return msgpack_pack_true(pk);
+
+    case cJSON_NULL:
+        return msgpack_pack_nil(pk);
+
+    case cJSON_String:
+        strvalue = format_string(node->valuestring);
+        if (strvalue != NULL) {
+            ret = msgpack_pack_str_with_body(pk, strvalue, strlen(strvalue));
+            free(strvalue);
+            return ret;
+        } else {
+            return -1;
+        }
+
+    case cJSON_Number:
+        if (isnan(node->valuedouble) || isinf(node->valuedouble)) {
+            ret = msgpack_pack_nil(pk);
+        } else if (node->valuedouble == node->valueint) {
+            ret = msgpack_pack_int(pk, node->valueint);
+        } else {
+            ret = msgpack_pack_double(pk, node->valuedouble);
+        }
+        return ret;
+
+    case cJSON_Array:
+        sz = cJSON_GetArraySize(node);
+        if (msgpack_pack_array(pk, sz) != 0) {
+            return -1;
+        }
+        for (i = 0; i < sz; i++) {
+            if (parse_cjson_object(pk, cJSON_GetArrayItem(node, i)) != 0) {
+                return -1;
+            }
+        }
+        return 0;
+
+    case cJSON_Object:
+        sz = cJSON_GetArraySize(node);
+        if (msgpack_pack_map(pk, sz) != 0) {
+            return -1;
+        }
+        for (i = 0; i < sz; i++) {
+            child = cJSON_GetArrayItem(node, i);
+            strvalue = format_string(child->string);
+            if (strvalue == NULL) {
+                return -1;
+            }
+
+            if (msgpack_pack_str_with_body(pk, strvalue, strlen(strvalue)) != 0) {
+                free(strvalue);
+                return -1;
+            }
+            free(strvalue);
+            if (parse_cjson_object(pk, child) != 0) {
+                return -1;
+            }
+        }
+        return 0;
+
+    default:
+        DEBUG("unknown type.\n");
+        return -1;
+    }
+    return 0;
+}
+
+/*
+ * Pack json string to msgpack format data.
+ * return 0 success, -1 failed
+ */
+int msgpack_pack_jsonstr(msgpack_packer *pk, const char *jsonstr)
+{
+    int status;
+    cJSON *node;
+    const char *end = NULL;
+
+    if (pk == NULL || jsonstr == NULL) {
+        return -1;
+    }
+
+    node = cJSON_ParseWithOpts(jsonstr, &end, 1);
+    if (node == NULL) {
+        DEBUG("parse error: unexpected string `%s`\n", end);
+        return -1;
+    }
+    status = parse_cjson_object(pk, node);
+    cJSON_Delete(node);
+
+    return status;
+}
+
+static int bytes_contain_zero(const msgpack_object_bin *bin)
+{
+    size_t i;
+    for (i = 0; i < bin->size; i++) {
+        if (bin->ptr[i] == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+#define PRINT_JSONSTR_CALL(ret, func, aux_buffer, aux_buffer_size, ...) \
+    ret = func(aux_buffer, aux_buffer_size, __VA_ARGS__);               \
+    if (ret <= 0)                                                       \
+        return ret;                                                     \
+    if (ret > aux_buffer_size)                                          \
+        return 0;                                                       \
+    aux_buffer = aux_buffer + ret;                                      \
+    aux_buffer_size = aux_buffer_size - ret
+
+/*
+ * Convert msgpack format data to json string.
+ * return >0: success, 0: length of buffer not enough, -1: failed
+ */
+size_t msgpack_object_print_jsonstr(char *buffer, size_t length, const msgpack_object o)
+{
+    char *aux_buffer = buffer;
+    size_t aux_buffer_size = length;
+    size_t ret;
+
+    switch (o.type) {
+    case MSGPACK_OBJECT_NIL:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "null");
+        break;
+
+    case MSGPACK_OBJECT_BOOLEAN:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false"));
+        break;
+
+    case MSGPACK_OBJECT_POSITIVE_INTEGER:
+#if defined(PRIu64)
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64);
+#else
+        if (o.via.u64 > ULONG_MAX) {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", ULONG_MAX);
+        } else {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64);
+        }
+#endif
+        break;
+
+    case MSGPACK_OBJECT_NEGATIVE_INTEGER:
+#if defined(PRIi64)
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64);
+#else
+        if (o.via.i64 > LONG_MAX) {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", LONG_MAX);
+        } else if (o.via.i64 < LONG_MIN) {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", LONG_MIN);
+        } else {
+            PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64);
+        }
+#endif
+        break;
+
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%f", o.via.f64);
+        break;
+
+    case MSGPACK_OBJECT_STR:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"%.*s\"", (int)o.via.str.size, o.via.str.ptr);
+        break;
+
+    case MSGPACK_OBJECT_BIN:
+        if (bytes_contain_zero(&o.via.bin)) {
+            DEBUG("the value contains zero\n");
+            return -1;
+        }
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"%.*s\"", (int)o.via.bin.size, o.via.bin.ptr);
+        break;
+
+    case MSGPACK_OBJECT_EXT:
+        DEBUG("not support type: MSGPACK_OBJECT_EXT.\n");
+        return -1;
+
+    case MSGPACK_OBJECT_ARRAY:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "[");
+        if (o.via.array.size != 0) {
+            msgpack_object *p = o.via.array.ptr;
+            msgpack_object *const pend = o.via.array.ptr + o.via.array.size;
+            PRINT_JSONSTR_CALL(ret, msgpack_object_print_jsonstr, aux_buffer, aux_buffer_size, *p);
+            ++p;
+            for (; p < pend; ++p) {
+                PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ",");
+                PRINT_JSONSTR_CALL(ret, msgpack_object_print_jsonstr, aux_buffer, aux_buffer_size, *p);
+            }
+        }
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "]");
+        break;
+
+    case MSGPACK_OBJECT_MAP:
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "{");
+        if (o.via.map.size != 0) {
+            msgpack_object_kv *p = o.via.map.ptr;
+            msgpack_object_kv *const pend = o.via.map.ptr + o.via.map.size;
+
+            for (; p < pend; ++p) {
+                if (p->key.type != MSGPACK_OBJECT_STR) {
+                    DEBUG("the key of in a map must be string.\n");
+                    return -1;
+                }
+                if (p != o.via.map.ptr) {
+                    PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ",");
+                }
+                PRINT_JSONSTR_CALL(ret, msgpack_object_print_jsonstr, aux_buffer, aux_buffer_size, p->key);
+                PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ":");
+                PRINT_JSONSTR_CALL(ret, msgpack_object_print_jsonstr, aux_buffer, aux_buffer_size, p->val);
+            }
+        }
+        PRINT_JSONSTR_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "}");
+        break;
+
+    default:
+        DEBUG("unknown type.\n");
+        return -1;
+    }
+
+    return length - aux_buffer_size;
+}
+#undef PRINT_JSONSTR_CALL
+
+static void test(const char *name, const char *input, const char *expect)
+{
+    msgpack_sbuffer sbuf;
+    {
+        // pack
+        msgpack_packer pk;
+        msgpack_sbuffer_init(&sbuf);
+        msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
+        if (msgpack_pack_jsonstr(&pk, input) < 0) {
+            msgpack_sbuffer_destroy(&sbuf);
+            printf("%s: invalid json string.\n", name);
+            return;
+        }
+    }
+
+    {
+        // unpack
+#define MAX_JSONLEN 1024
+        msgpack_zone z;
+        msgpack_object obj;
+        size_t jsonstrlen = MAX_JSONLEN - 1;
+        char jsonparsed[MAX_JSONLEN];
+
+        msgpack_zone_init(&z, jsonstrlen);
+        msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
+        jsonstrlen = msgpack_object_print_jsonstr(jsonparsed, jsonstrlen, obj);
+        jsonparsed[jsonstrlen] = '\0';
+
+        //compare input and output
+        if (expect == NULL) {
+            expect = input;
+        }
+        if (strcmp(expect, jsonparsed) == 0) {
+            printf("%s: ok\n", name);
+        } else {
+            printf("%s: failed\n", name);
+        }
+        msgpack_zone_destroy(&z);
+    }
+    msgpack_sbuffer_destroy(&sbuf);
+}
+
+int main()
+{
+    test("null", "null", NULL);
+    test("boolean", "false", NULL);
+    test("single string", "\"frsyuki\"", NULL);
+    test("single number", "\"100\"", NULL);
+    test("space", "[{\"valuespace\":\"\",\"\":\"keyspace\"},\"\",[\"\"]]", NULL);
+    test("quote", "\"My name is Tom (\\\"Bee\\\") Kobe\"", NULL);
+    test("escape", "\"\\\\b\\f\\n\\r\\t\"", NULL);
+    test("escape2", "\"\b\f\n\r\t\"", "\"\\b\\f\\n\\r\\t\"");
+    test("map", "{\"name\":\"Tom (\\\"Bee\\\") Kobe\",\"type\":\"image\",\"data\":{\"width\":360,\"height\":460,\"title\":\"View me\",\"ips\":[116,943,256,711]}}", NULL);
+    test("array", "[\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"]", NULL);
+    test("number array", "[[101,121,-33],[119,911,171],[0,2,-3]]", NULL);
+    test("mix array", "[{\"name\":\"Tom\",\"city\":\"London\",\"country\":\"UK\",\"longitude\":23},{\"name\":\"Jack\",\"city\":\"Birmingham\",\"country\":\"UK\",\"longitude\":-22}]", NULL);
+    test("unicode", "\"\\u5C71\\u5DDD\\u7570\\u57DF\\u98A8\\u6708\\u540C\\u5929\"", "\"山川異域風月同天\"");
+    test("utf8", "\"山川異域風月同天\"", NULL);
+    test("double", "12.34", "12.340000");
+
+    return 0;
+}

example/lib_buffer_unpack.c

@@ -0,0 +1,127 @@
+#include <msgpack.h>
+#include <stdio.h>
+#include <assert.h>
+
+
+typedef struct receiver {
+    msgpack_sbuffer sbuf;
+    size_t rest;
+} receiver;
+
+void receiver_init(receiver *r) {
+    msgpack_packer pk;
+
+    msgpack_sbuffer_init(&r->sbuf);
+    msgpack_packer_init(&pk, &r->sbuf, msgpack_sbuffer_write);
+    /* 1st object */
+    msgpack_pack_array(&pk, 3);
+    msgpack_pack_int(&pk, 1);
+    msgpack_pack_true(&pk);
+    msgpack_pack_str(&pk, 7);
+    msgpack_pack_str_body(&pk, "example", 7);
+    /* 2nd object */
+    msgpack_pack_str(&pk, 6);
+    msgpack_pack_str_body(&pk, "second", 6);
+    /* 3rd object */
+    msgpack_pack_array(&pk, 2);
+    msgpack_pack_int(&pk, 42);
+    msgpack_pack_false(&pk);
+    r->rest = r->sbuf.size;
+}
+
+size_t receiver_recv(receiver *r, char* buf, size_t try_size) {
+    size_t off = r->sbuf.size - r->rest;
+
+    size_t actual_size = try_size;
+    if (actual_size > r->rest) actual_size = r->rest;
+
+    memcpy(buf, r->sbuf.data + off, actual_size);
+    r->rest -= actual_size;
+
+    return actual_size;
+}
+
+size_t receiver_to_unpacker(receiver* r, size_t request_size,
+        msgpack_unpacker *unpacker)
+{
+    size_t recv_len;
+    // make sure there's enough room, or expand the unpacker accordingly
+    if (msgpack_unpacker_buffer_capacity(unpacker) < request_size) {
+        msgpack_unpacker_reserve_buffer(unpacker, request_size);
+        assert(msgpack_unpacker_buffer_capacity(unpacker) >= request_size);
+    }
+    recv_len = receiver_recv(r, msgpack_unpacker_buffer(unpacker),
+                             request_size);
+    msgpack_unpacker_buffer_consumed(unpacker, recv_len);
+    return recv_len;
+}
+
+#define EACH_RECV_SIZE 4
+
+void unpack(receiver* r) {
+    /* buf is allocated by unpacker. */
+    msgpack_unpacker* unp = msgpack_unpacker_new(100);
+    msgpack_unpacked result;
+    msgpack_unpack_return ret;
+    size_t recv_len;
+    int recv_count = 0;
+    int i = 0;
+
+    msgpack_unpacked_init(&result);
+    while (true) {
+        recv_len = receiver_to_unpacker(r, EACH_RECV_SIZE, unp);
+        if (recv_len == 0) break; // (reached end of input)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+        printf("receive count: %d %Id bytes received.\n", recv_count++, recv_len);
+#else // defined(_MSC_VER) || defined(__MINGW32__)
+        printf("receive count: %d %zd bytes received.\n", recv_count++, recv_len);
+#endif // defined(_MSC_VER) || defined(__MINGW32__)
+        ret = msgpack_unpacker_next(unp, &result);
+        while (ret == MSGPACK_UNPACK_SUCCESS) {
+            msgpack_object obj = result.data;
+
+            /* Use obj. */
+            printf("Object no %d:\n", ++i);
+            msgpack_object_print(stdout, obj);
+            printf("\n");
+            /* If you want to allocate something on the zone, you can use zone. */
+            /* msgpack_zone* zone = result.zone; */
+            /* The lifetime of the obj and the zone,  */
+
+            ret = msgpack_unpacker_next(unp, &result);
+        }
+        if (ret == MSGPACK_UNPACK_PARSE_ERROR) {
+            printf("The data in the buf is invalid format.\n");
+            msgpack_unpacked_destroy(&result);
+            return;
+        }
+    }
+    msgpack_unpacked_destroy(&result);
+    msgpack_unpacker_free(unp);
+}
+
+int main(void) {
+    receiver r;
+    receiver_init(&r);
+
+    unpack(&r);
+
+    return 0;
+}
+
+/* Output */
+
+/*
+receive count: 0 4 bytes received.
+receive count: 1 4 bytes received.
+receive count: 2 4 bytes received.
+Object no 1:
+[1, true, "example"]
+receive count: 3 4 bytes received.
+receive count: 4 4 bytes received.
+Object no 2:
+"second"
+receive count: 5 1 bytes received.
+Object no 3:
+[42, false]
+*/

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, uint32_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;
-	}
-}
-

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;
-}
-

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;
-}
-

example/simple_c.c

@@ -0,0 +1,47 @@
+#include <msgpack.h>
+#include <stdio.h>
+
+void print(char const* buf,size_t len)
+{
+    size_t i = 0;
+    for(; i < len ; ++i)
+        printf("%02x ", 0xff & buf[i]);
+    printf("\n");
+}
+
+int main(void)
+{
+    msgpack_sbuffer sbuf;
+    msgpack_packer pk;
+    msgpack_zone mempool;
+    msgpack_object deserialized;
+
+    /* msgpack::sbuffer is a simple buffer implementation. */
+    msgpack_sbuffer_init(&sbuf);
+
+    /* serialize values into the buffer using msgpack_sbuffer_write callback function. */
+    msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
+
+    msgpack_pack_array(&pk, 3);
+    msgpack_pack_int(&pk, 1);
+    msgpack_pack_true(&pk);
+    msgpack_pack_str(&pk, 7);
+    msgpack_pack_str_body(&pk, "example", 7);
+
+    print(sbuf.data, sbuf.size);
+
+    /* deserialize the buffer into msgpack_object instance. */
+    /* deserialized object is valid during the msgpack_zone instance alive. */
+    msgpack_zone_init(&mempool, 2048);
+
+    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;
+}

example/speed_test_uint32_array.c

@@ -1,34 +1,35 @@
 #include <msgpack.h>
-#include <assert.h>
 
 void test()
 {
     size_t size = 10000000;
     msgpack_sbuffer buf;
+    msgpack_packer * pk;
+    size_t upk_pos = 0;
+    msgpack_unpacked msg;
+
     msgpack_sbuffer_init(&buf);
 
-	msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
+    pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
 
     msgpack_pack_array(pk, size);
     {
-		int idx = 0;
+        size_t idx = 0;
         for (; idx < size; ++idx)
             msgpack_pack_uint32(pk, 1);
     }
     msgpack_packer_free(pk);
 
-
-	size_t upk_pos = 0;
-	msgpack_unpacked msg;
     msgpack_unpacked_init(&msg);
 
-	while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
+    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos) == MSGPACK_UNPACK_SUCCESS) {
     }
 
+    msgpack_unpacked_destroy(&msg);
     msgpack_sbuffer_destroy(&buf);
 }
 
-int main(int argc, char **argv)
+int main(void)
 {
     int i = 0;
     for (; i < 10; ++i) test();

example/speed_test_uint64_array.c

@@ -1,35 +1,35 @@
 #include <msgpack.h>
-#include <assert.h>
 
 void test()
 {
     uint64_t test_u64 = 0xFFF0000000000001LL;
     size_t size = 10000000;
     msgpack_sbuffer buf;
+    msgpack_packer * pk;
+    size_t upk_pos = 0;
+    msgpack_unpacked msg;
+
     msgpack_sbuffer_init(&buf);
 
-	msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
+    pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
 
     msgpack_pack_array(pk, size);
     {
-		int idx = 0;
+        size_t idx = 0;
         for (; idx < size; ++idx)
             msgpack_pack_uint64(pk, test_u64);
     }
     msgpack_packer_free(pk);
 
-
-	size_t upk_pos = 0;
-	msgpack_unpacked msg;
     msgpack_unpacked_init(&msg);
 
-	while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
+    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos) == MSGPACK_UNPACK_SUCCESS) {
     }
-
+    msgpack_unpacked_destroy(&msg);
     msgpack_sbuffer_destroy(&buf);
 }
 
-int main(int argc, char **argv)
+int main(void)
 {
     int i = 0;
     for (; i < 10; ++i) test();

example/stream.cc

@@ -1,133 +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(count == 0) {
-				throw std::runtime_error("connection closed");
-			}
-			if(errno == EAGAIN || errno == EINTR) {
-				return;
-			}
-			throw std::runtime_error(strerror(errno));
-		}
-
-		m_pac.buffer_consumed(count);
-
-		msgpack::unpacked result;
-		while (m_pac.next(&result)) {
-			msgpack::object msg = result.get();
-			auto_zone& life = result.zone();
-			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);
-}
-

example/user_buffer_unpack.c

@@ -0,0 +1,81 @@
+#include <msgpack.h>
+#include <stdio.h>
+#include <assert.h>
+
+#define UNPACKED_BUFFER_SIZE 2048
+
+void prepare(msgpack_sbuffer* sbuf) {
+    msgpack_packer pk;
+
+    msgpack_packer_init(&pk, sbuf, msgpack_sbuffer_write);
+    /* 1st object */
+    msgpack_pack_array(&pk, 3);
+    msgpack_pack_int(&pk, 1);
+    msgpack_pack_true(&pk);
+    msgpack_pack_str(&pk, 7);
+    msgpack_pack_str_body(&pk, "example", 7);
+    /* 2nd object */
+    msgpack_pack_str(&pk, 6);
+    msgpack_pack_str_body(&pk, "second", 6);
+    /* 3rd object */
+    msgpack_pack_array(&pk, 2);
+    msgpack_pack_int(&pk, 42);
+    msgpack_pack_false(&pk);
+}
+
+void unpack(char const* buf, size_t len) {
+    /* buf is allocated by client. */
+    msgpack_unpacked result;
+    size_t off = 0;
+    msgpack_unpack_return ret;
+    int i = 0;
+    char unpacked_buffer[UNPACKED_BUFFER_SIZE];
+    msgpack_unpacked_init(&result);
+    ret = msgpack_unpack_next(&result, buf, len, &off);
+    while (ret == MSGPACK_UNPACK_SUCCESS) {
+        msgpack_object obj = result.data;
+
+        /* Use obj. */
+        printf("Object no %d:\n", ++i);
+        msgpack_object_print(stdout, obj);
+        printf("\n");
+        msgpack_object_print_buffer(unpacked_buffer, UNPACKED_BUFFER_SIZE, obj);
+        printf("%s\n", unpacked_buffer);
+        /* If you want to allocate something on the zone, you can use zone. */
+        /* msgpack_zone* zone = result.zone; */
+        /* The lifetime of the obj and the zone,  */
+
+        ret = msgpack_unpack_next(&result, buf, len, &off);
+    }
+    msgpack_unpacked_destroy(&result);
+
+    if (ret == MSGPACK_UNPACK_CONTINUE) {
+        printf("All msgpack_object in the buffer is consumed.\n");
+    }
+    else if (ret == MSGPACK_UNPACK_PARSE_ERROR) {
+        printf("The data in the buf is invalid format.\n");
+    }
+}
+
+int main(void) {
+    msgpack_sbuffer sbuf;
+    msgpack_sbuffer_init(&sbuf);
+
+    prepare(&sbuf);
+    unpack(sbuf.data, sbuf.size);
+
+    msgpack_sbuffer_destroy(&sbuf);
+    return 0;
+}
+
+/* Output */
+
+/*
+Object no 1:
+[1, true, "example"]
+Object no 2:
+"second"
+Object no 3:
+[42, false]
+All msgpack_object in the buffer is consumed.
+*/

include/msgpack.h

@@ -0,0 +1,24 @@
+/*
+ * MessagePack for C
+ *
+ * Copyright (C) 2008-2009 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)
+ */
+/**
+ * @defgroup msgpack MessagePack C
+ * @{
+ * @}
+ */
+
+#include "msgpack/util.h"
+#include "msgpack/object.h"
+#include "msgpack/zone.h"
+#include "msgpack/pack.h"
+#include "msgpack/unpack.h"
+#include "msgpack/sbuffer.h"
+#include "msgpack/vrefbuffer.h"
+#include "msgpack/version.h"
+

include/msgpack/fbuffer.h

@@ -0,0 +1,42 @@
+/*
+ * MessagePack for C FILE* buffer adaptor
+ *
+ * Copyright (C) 2013 Vladimir Volodko
+ *
+ *    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)
+ */
+#ifndef MSGPACK_FBUFFER_H
+#define MSGPACK_FBUFFER_H
+
+#include <stdio.h>
+#include <assert.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup msgpack_fbuffer FILE* buffer
+ * @ingroup msgpack_buffer
+ * @{
+ */
+
+static inline int msgpack_fbuffer_write(void* data, const char* buf, size_t len)
+{
+    assert(buf || len == 0);
+    if(!buf) return 0;
+
+    return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
+}
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/fbuffer.h */

include/msgpack/gcc_atomic.h

@@ -0,0 +1,25 @@
+/*
+ *    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)
+ */
+
+#ifndef MSGPACK_GCC_ATOMIC_H
+#define MSGPACK_GCC_ATOMIC_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+typedef int _msgpack_atomic_counter_t;
+
+int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr);
+int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr);
+
+
+#if defined(__cplusplus)
+}
+#endif
+
+
+#endif // MSGPACK_GCC_ATOMIC_H

include/msgpack/object.h

@@ -0,0 +1,118 @@
+/*
+ * MessagePack for C dynamic typing routine
+ *
+ * Copyright (C) 2008-2009 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)
+ */
+#ifndef MSGPACK_OBJECT_H
+#define MSGPACK_OBJECT_H
+
+#include "zone.h"
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup msgpack_object Dynamically typed object
+ * @ingroup msgpack
+ * @{
+ */
+
+typedef enum {
+    MSGPACK_OBJECT_NIL                  = 0x00,
+    MSGPACK_OBJECT_BOOLEAN              = 0x01,
+    MSGPACK_OBJECT_POSITIVE_INTEGER     = 0x02,
+    MSGPACK_OBJECT_NEGATIVE_INTEGER     = 0x03,
+    MSGPACK_OBJECT_FLOAT32              = 0x0a,
+    MSGPACK_OBJECT_FLOAT64              = 0x04,
+    MSGPACK_OBJECT_FLOAT                = 0x04,
+#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+    MSGPACK_OBJECT_DOUBLE               = MSGPACK_OBJECT_FLOAT, /* obsolete */
+#endif /* MSGPACK_USE_LEGACY_NAME_AS_FLOAT */
+    MSGPACK_OBJECT_STR                  = 0x05,
+    MSGPACK_OBJECT_ARRAY                = 0x06,
+    MSGPACK_OBJECT_MAP                  = 0x07,
+    MSGPACK_OBJECT_BIN                  = 0x08,
+    MSGPACK_OBJECT_EXT                  = 0x09
+} 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_str;
+
+typedef struct {
+    uint32_t size;
+    const char* ptr;
+} msgpack_object_bin;
+
+typedef struct {
+    int8_t type;
+    uint32_t size;
+    const char* ptr;
+} msgpack_object_ext;
+
+typedef union {
+    bool boolean;
+    uint64_t u64;
+    int64_t  i64;
+#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
+    double   dec; /* obsolete*/
+#endif /* MSGPACK_USE_LEGACY_NAME_AS_FLOAT */
+    double   f64;
+    msgpack_object_array array;
+    msgpack_object_map map;
+    msgpack_object_str str;
+    msgpack_object_bin bin;
+    msgpack_object_ext ext;
+} msgpack_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;
+
+#if !defined(_KERNEL_MODE)
+MSGPACK_DLLEXPORT
+void msgpack_object_print(FILE* out, msgpack_object o);
+#endif
+
+MSGPACK_DLLEXPORT
+int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o);
+
+MSGPACK_DLLEXPORT
+bool msgpack_object_equal(const msgpack_object x, const msgpack_object y);
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/object.h */

include/msgpack/pack.h

@@ -3,23 +3,16 @@
  *
  * Copyright (C) 2008-2009 FURUHASHI Sadayuki
  *
- *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    Distributed under the Boost Software License, Version 1.0.
- *    you may not use this file except in compliance with the License.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
- *    You may obtain a copy of the License at
+ *    http://www.boost.org/LICENSE_1_0.txt)
- *
- *        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__
+#ifndef MSGPACK_PACK_H
-#define MSGPACK_PACK_H__
+#define MSGPACK_PACK_H
 
 #include "pack_define.h"
 #include "object.h"
+#include "timestamp.h"
 #include <stdlib.h>
 
 #ifdef __cplusplus
@@ -94,9 +87,24 @@ static int msgpack_pack_array(msgpack_packer* pk, size_t n);
 
 static int msgpack_pack_map(msgpack_packer* pk, size_t n);
 
-static int msgpack_pack_raw(msgpack_packer* pk, size_t l);
+static int msgpack_pack_str(msgpack_packer* pk, size_t l);
-static int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l);
+static int msgpack_pack_str_body(msgpack_packer* pk, const void* b, size_t l);
+static int msgpack_pack_str_with_body(msgpack_packer* pk, const void* b, size_t l);
 
+static int msgpack_pack_v4raw(msgpack_packer* pk, size_t l);
+static int msgpack_pack_v4raw_body(msgpack_packer* pk, const void* b, size_t l);
+
+static int msgpack_pack_bin(msgpack_packer* pk, size_t l);
+static int msgpack_pack_bin_body(msgpack_packer* pk, const void* b, size_t l);
+static int msgpack_pack_bin_with_body(msgpack_packer* pk, const void* b, size_t l);
+
+static int msgpack_pack_ext(msgpack_packer* pk, size_t l, int8_t type);
+static int msgpack_pack_ext_body(msgpack_packer* pk, const void* b, size_t l);
+static int msgpack_pack_ext_with_body(msgpack_packer* pk, const void* b, size_t l, int8_t type);
+
+static int msgpack_pack_timestamp(msgpack_packer* pk, const msgpack_timestamp* d);
+
+MSGPACK_DLLEXPORT
 int msgpack_pack_object(msgpack_packer* pk, msgpack_object d);
 
 
@@ -138,10 +146,29 @@ inline void msgpack_packer_free(msgpack_packer* pk)
     free(pk);
 }
 
+inline int msgpack_pack_str_with_body(msgpack_packer* pk, const void* b, size_t l)
+ {
+     int ret = msgpack_pack_str(pk, l);
+     if (ret != 0) { return ret; }
+     return msgpack_pack_str_body(pk, b, l);
+ }
+
+ inline int msgpack_pack_bin_with_body(msgpack_packer* pk, const void* b, size_t l)
+ {
+     int ret = msgpack_pack_bin(pk, l);
+     if (ret != 0) { return ret; }
+     return msgpack_pack_bin_body(pk, b, l);
+ }
+
+ inline int msgpack_pack_ext_with_body(msgpack_packer* pk, const void* b, size_t l, int8_t type)
+ {
+     int ret = msgpack_pack_ext(pk, l, type);
+     if (ret != 0) { return ret; }
+     return msgpack_pack_ext_body(pk, b, l);
+ }
  
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* msgpack/pack.h */
-

include/msgpack/pack_define.h

@@ -0,0 +1,18 @@
+/*
+ * MessagePack unpacking routine template
+ *
+ * Copyright (C) 2008-2010 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)
+ */
+#ifndef MSGPACK_PACK_DEFINE_H
+#define MSGPACK_PACK_DEFINE_H
+
+#include "msgpack/sysdep.h"
+#include <limits.h>
+#include <string.h>
+
+#endif /* msgpack/pack_define.h */
+

include/msgpack/sbuffer.h

@@ -0,0 +1,115 @@
+/*
+ * MessagePack for C simple buffer implementation
+ *
+ * Copyright (C) 2008-2009 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)
+ */
+#ifndef MSGPACK_SBUFFER_H
+#define MSGPACK_SBUFFER_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup msgpack_sbuffer Simple buffer
+ * @ingroup msgpack_buffer
+ * @{
+ */
+
+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 msgpack_sbuffer* msgpack_sbuffer_new(void)
+{
+    return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer));
+}
+
+static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf)
+{
+    if(sbuf == NULL) { return; }
+    msgpack_sbuffer_destroy(sbuf);
+    free(sbuf);
+}
+
+#ifndef MSGPACK_SBUFFER_INIT_SIZE
+#define MSGPACK_SBUFFER_INIT_SIZE 8192
+#endif
+
+static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len)
+{
+    msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data;
+
+    assert(buf || len == 0);
+    if(!buf) return 0;
+
+    if(sbuf->alloc - sbuf->size < len) {
+        void* tmp;
+        size_t nsize = (sbuf->alloc) ?
+                sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
+
+        while(nsize < sbuf->size + len) {
+            size_t tmp_nsize = nsize * 2;
+            if (tmp_nsize <= nsize) {
+                nsize = sbuf->size + len;
+                break;
+            }
+            nsize = tmp_nsize;
+        }
+
+        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;
+}
+
+static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf)
+{
+    sbuf->size = 0;
+}
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/sbuffer.h */

include/msgpack/timestamp.h

@@ -0,0 +1,58 @@
+/*
+ * MessagePack for C TimeStamp
+ *
+ * Copyright (C) 2018 KONDO Takatoshi
+ *
+ *    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)
+ */
+#ifndef MSGPACK_TIMESTAMP_H
+#define MSGPACK_TIMESTAMP_H
+
+#include <msgpack/object.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct msgpack_timestamp {
+    int64_t tv_sec;
+    uint32_t tv_nsec;
+} msgpack_timestamp;
+
+static inline bool msgpack_object_to_timestamp(const msgpack_object* obj, msgpack_timestamp* ts) {
+    if (obj->type != MSGPACK_OBJECT_EXT) return false;
+    if (obj->via.ext.type != -1) return false;
+    switch (obj->via.ext.size) {
+    case 4:
+        ts->tv_nsec = 0;
+        {
+            uint32_t v;
+            _msgpack_load32(uint32_t, obj->via.ext.ptr, &v);
+            ts->tv_sec = v;
+        }
+        return true;
+    case 8: {
+        uint64_t value;
+        _msgpack_load64(uint64_t, obj->via.ext.ptr, &value);
+        ts->tv_nsec = (uint32_t)(value >> 34);
+        ts->tv_sec = value & 0x00000003ffffffffLL;
+        return true;
+    }
+    case 12:
+        _msgpack_load32(uint32_t, obj->via.ext.ptr, &ts->tv_nsec);
+        _msgpack_load64(int64_t, obj->via.ext.ptr + 4, &ts->tv_sec);
+        return true;
+    default:
+        return false;
+    }
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/timestamp.h */

include/msgpack/unpack.h

@@ -3,20 +3,12 @@
  *
  * Copyright (C) 2008-2009 FURUHASHI Sadayuki
  *
- *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    Distributed under the Boost Software License, Version 1.0.
- *    you may not use this file except in compliance with the License.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
- *    You may obtain a copy of the License at
+ *    http://www.boost.org/LICENSE_1_0.txt)
- *
- *        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__
+#ifndef MSGPACK_UNPACKER_H
-#define MSGPACK_UNPACKER_H__
+#define MSGPACK_UNPACKER_H
 
 #include "zone.h"
 #include "object.h"
@@ -38,7 +30,18 @@ typedef struct msgpack_unpacked {
     msgpack_object data;
 } msgpack_unpacked;
 
-bool msgpack_unpack_next(msgpack_unpacked* result,
+typedef enum {
+    MSGPACK_UNPACK_SUCCESS              =  2,
+    MSGPACK_UNPACK_EXTRA_BYTES          =  1,
+    MSGPACK_UNPACK_CONTINUE             =  0,
+    MSGPACK_UNPACK_PARSE_ERROR          = -1,
+    MSGPACK_UNPACK_NOMEM_ERROR          = -2
+} msgpack_unpack_return;
+
+
+MSGPACK_DLLEXPORT
+msgpack_unpack_return
+msgpack_unpack_next(msgpack_unpacked* result,
         const char* data, size_t len, size_t* off);
 
 /** @} */
@@ -70,11 +73,13 @@ typedef struct msgpack_unpacker {
  * Initializes a streaming deserializer.
  * The initialized deserializer must be destroyed by msgpack_unpacker_destroy(msgpack_unpacker*).
  */
+MSGPACK_DLLEXPORT
 bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size);
 
 /**
  * Destroys a streaming deserializer initialized by msgpack_unpacker_init(msgpack_unpacker*, size_t).
  */
+MSGPACK_DLLEXPORT
 void msgpack_unpacker_destroy(msgpack_unpacker* mpac);
 
 
@@ -82,11 +87,13 @@ void msgpack_unpacker_destroy(msgpack_unpacker* mpac);
  * Creates a streaming deserializer.
  * The created deserializer must be destroyed by msgpack_unpacker_free(msgpack_unpacker*).
  */
+MSGPACK_DLLEXPORT
 msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size);
 
 /**
  * Frees a streaming deserializer created by msgpack_unpacker_new(size_t).
  */
+MSGPACK_DLLEXPORT
 void msgpack_unpacker_free(msgpack_unpacker* mpac);
 
 
@@ -136,7 +143,20 @@ static inline void   msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, si
  * Returns true if it successes. Otherwise false is returned.
  * @param pac  pointer to an initialized msgpack_unpacked object.
  */
-bool msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac);
+MSGPACK_DLLEXPORT
+msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac);
+
+/**
+ * Deserializes one object and set the number of parsed bytes involved.
+ * Returns true if it successes. Otherwise false is returned.
+ * @param mpac    pointer to an initialized msgpack_unpacker object.
+ * @param result  pointer to an initialized msgpack_unpacked object.
+ * @param p_bytes pointer to variable that will be set with the number of parsed bytes.
+ */
+MSGPACK_DLLEXPORT
+msgpack_unpack_return msgpack_unpacker_next_with_size(msgpack_unpacker* mpac,
+                                                      msgpack_unpacked* result,
+                                                      size_t *p_bytes);
 
 /**
  * Initializes a msgpack_unpacked object.
@@ -158,14 +178,19 @@ static inline void msgpack_unpacked_destroy(msgpack_unpacked* result);
 static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result);
 
 
+MSGPACK_DLLEXPORT
 int msgpack_unpacker_execute(msgpack_unpacker* mpac);
 
+MSGPACK_DLLEXPORT
 msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac);
 
+MSGPACK_DLLEXPORT
 msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac);
 
+MSGPACK_DLLEXPORT
 void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac);
 
+MSGPACK_DLLEXPORT
 void msgpack_unpacker_reset(msgpack_unpacker* mpac);
 
 static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac);
@@ -175,23 +200,20 @@ static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac)
 
 
 // obsolete
-typedef enum {
+MSGPACK_DLLEXPORT
-	MSGPACK_UNPACK_SUCCESS				=  2,
-	MSGPACK_UNPACK_EXTRA_BYTES			=  1,
-	MSGPACK_UNPACK_CONTINUE				=  0,
-	MSGPACK_UNPACK_PARSE_ERROR			= -1,
-} msgpack_unpack_return;
-
-// obsolete
 msgpack_unpack_return
 msgpack_unpack(const char* data, size_t len, size_t* off,
         msgpack_zone* result_zone, msgpack_object* result);
 
 
+
+
 static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac);
 
+MSGPACK_DLLEXPORT
 bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac);
 
+MSGPACK_DLLEXPORT
 bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size);
 
 static inline bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size)
@@ -257,4 +279,3 @@ static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* resu
 #endif
 
 #endif /* msgpack/unpack.h */
-

include/msgpack/unpack_define.h

@@ -0,0 +1,89 @@
+/*
+ * MessagePack unpacking routine template
+ *
+ * Copyright (C) 2008-2010 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)
+ */
+#ifndef MSGPACK_UNPACK_DEFINE_H
+#define MSGPACK_UNPACK_DEFINE_H
+
+#include "msgpack/sysdep.h"
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef MSGPACK_EMBED_STACK_SIZE
+#define MSGPACK_EMBED_STACK_SIZE 32
+#endif
+
+
+typedef enum {
+    MSGPACK_CS_HEADER            = 0x00,  // nil
+
+    //MSGPACK_CS_                = 0x01,
+    //MSGPACK_CS_                = 0x02,  // false
+    //MSGPACK_CS_                = 0x03,  // true
+
+    MSGPACK_CS_BIN_8             = 0x04,
+    MSGPACK_CS_BIN_16            = 0x05,
+    MSGPACK_CS_BIN_32            = 0x06,
+
+    MSGPACK_CS_EXT_8             = 0x07,
+    MSGPACK_CS_EXT_16            = 0x08,
+    MSGPACK_CS_EXT_32            = 0x09,
+
+    MSGPACK_CS_FLOAT             = 0x0a,
+    MSGPACK_CS_DOUBLE            = 0x0b,
+    MSGPACK_CS_UINT_8            = 0x0c,
+    MSGPACK_CS_UINT_16           = 0x0d,
+    MSGPACK_CS_UINT_32           = 0x0e,
+    MSGPACK_CS_UINT_64           = 0x0f,
+    MSGPACK_CS_INT_8             = 0x10,
+    MSGPACK_CS_INT_16            = 0x11,
+    MSGPACK_CS_INT_32            = 0x12,
+    MSGPACK_CS_INT_64            = 0x13,
+
+    MSGPACK_CS_FIXEXT_1          = 0x14,
+    MSGPACK_CS_FIXEXT_2          = 0x15,
+    MSGPACK_CS_FIXEXT_4          = 0x16,
+    MSGPACK_CS_FIXEXT_8          = 0x17,
+    MSGPACK_CS_FIXEXT_16         = 0x18,
+
+    MSGPACK_CS_STR_8             = 0x19, // str8
+    MSGPACK_CS_STR_16            = 0x1a, // str16
+    MSGPACK_CS_STR_32            = 0x1b, // str32
+    MSGPACK_CS_ARRAY_16          = 0x1c,
+    MSGPACK_CS_ARRAY_32          = 0x1d,
+    MSGPACK_CS_MAP_16            = 0x1e,
+    MSGPACK_CS_MAP_32            = 0x1f,
+
+    //MSGPACK_ACS_BIG_INT_VALUE,
+    //MSGPACK_ACS_BIG_FLOAT_VALUE,
+    MSGPACK_ACS_STR_VALUE,
+    MSGPACK_ACS_BIN_VALUE,
+    MSGPACK_ACS_EXT_VALUE
+} msgpack_unpack_state;
+
+
+typedef enum {
+    MSGPACK_CT_ARRAY_ITEM,
+    MSGPACK_CT_MAP_KEY,
+    MSGPACK_CT_MAP_VALUE
+} msgpack_container_type;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/unpack_define.h */
+

include/msgpack/unpack_template.h

@@ -0,0 +1,471 @@
+/*
+ * MessagePack unpacking routine template
+ *
+ * Copyright (C) 2008-2010 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)
+ */
+
+#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
+
+#ifndef USE_CASE_RANGE
+#if !defined(_MSC_VER)
+#define USE_CASE_RANGE
+#endif
+#endif
+
+#if defined(_KERNEL_MODE)
+#undef  assert
+#define assert NT_ASSERT
+#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;
+    unsigned int stack_size;
+    msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE];
+    */
+    msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE];
+};
+
+
+msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx)
+{
+    ctx->cs = MSGPACK_CS_HEADER;
+    ctx->trail = 0;
+    ctx->top = 0;
+    /*
+    ctx->stack = ctx->embed_stack;
+    ctx->stack_size = MSGPACK_EMBED_STACK_SIZE;
+    */
+    ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user);
+}
+
+/*
+msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx)
+{
+    if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) {
+        free(ctx->stack);
+    }
+}
+*/
+
+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;
+        /*
+        unsigned int stack_size = ctx->stack_size;
+        */
+        msgpack_unpack_user* user = &ctx->user;
+
+        msgpack_unpack_object obj;
+        msgpack_unpack_struct(_stack)* c = NULL;
+
+        int ret;
+
+#define push_simple_value(func) \
+        ret = msgpack_unpack_callback(func)(user, &obj); \
+        if(ret < 0) { goto _failed; } \
+        goto _push
+#define push_fixed_value(func, arg) \
+        ret = msgpack_unpack_callback(func)(user, arg, &obj); \
+        if(ret < 0) { goto _failed; } \
+        goto _push
+#define push_variable_value(func, base, pos, len) \
+        ret = msgpack_unpack_callback(func)(user, \
+            (const char*)base, (const char*)pos, len, &obj); \
+        if(ret < 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(top >= MSGPACK_EMBED_STACK_SIZE) { \
+            ret = MSGPACK_UNPACK_NOMEM_ERROR; \
+            goto _failed; \
+        } /* FIXME */ \
+        ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \
+        if(ret < 0) { goto _failed; } \
+        if((count_) == 0) { obj = stack[top].obj; goto _push; } \
+        stack[top].ct = ct_; \
+        stack[top].count = count_; \
+        ++top; \
+        goto _header_again
+
+#define NEXT_CS(p) \
+        ((unsigned int)*p & 0x1f)
+
+#ifdef USE_CASE_RANGE
+#define SWITCH_RANGE_BEGIN     switch(*p) {
+#define SWITCH_RANGE(FROM, TO) case FROM ... TO:
+#define SWITCH_RANGE_DEFAULT   default:
+#define SWITCH_RANGE_END       }
+#else
+#define SWITCH_RANGE_BEGIN     { if(0) {
+#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) {
+#define SWITCH_RANGE_DEFAULT   } else {
+#define SWITCH_RANGE_END       } }
+#endif
+
+        if(p == pe) { goto _out; }
+        do {
+            switch(cs) {
+            case MSGPACK_CS_HEADER:
+                SWITCH_RANGE_BEGIN
+                SWITCH_RANGE(0x00, 0x7f)  // Positive Fixnum
+                    push_fixed_value(_uint8, *(uint8_t*)p);
+                SWITCH_RANGE(0xe0, 0xff)  // Negative Fixnum
+                    push_fixed_value(_int8, *(int8_t*)p);
+                SWITCH_RANGE(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: // bin 8
+                    case 0xc5: // bin 16
+                    case 0xc6: // bin 32
+                        again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03));
+                    case 0xc7: // ext 8
+                    case 0xc8: // ext 16
+                    case 0xc9: // ext 32
+                        again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03));
+                    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:  // fixext 1
+                    case 0xd5:  // fixext 2
+                    case 0xd6:  // fixext 4
+                    case 0xd7:  // fixext 8
+                        again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE,
+                            (1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero);
+                    case 0xd8:  // fixext 16
+                        again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero);
+
+                    case 0xd9:  // str 8
+                    case 0xda:  // str 16
+                    case 0xdb:  // str 32
+                        again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1));
+                    case 0xdc:  // array 16
+                    case 0xdd:  // array 32
+                    case 0xde:  // map 16
+                    case 0xdf:  // map 32
+                        again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01));
+                    default:
+                        ret = MSGPACK_UNPACK_PARSE_ERROR;
+                        goto _failed;
+                    }
+                SWITCH_RANGE(0xa0, 0xbf)  // FixStr
+                    again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero);
+                SWITCH_RANGE(0x90, 0x9f)  // FixArray
+                    start_container(_array, ((unsigned int)*p) & 0x0f, MSGPACK_CT_ARRAY_ITEM);
+                SWITCH_RANGE(0x80, 0x8f)  // FixMap
+                    start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY);
+
+                SWITCH_RANGE_DEFAULT
+                    ret = MSGPACK_UNPACK_PARSE_ERROR;
+                    goto _failed;
+                SWITCH_RANGE_END
+                // end MSGPACK_CS_HEADER
+
+
+            _fixed_trail_again:
+                ++p;
+                // fallthrough
+
+            default:
+                if((size_t)(pe - p) < trail) { goto _out; }
+                n = p;  p += trail - 1;
+                switch(cs) {
+                //case MSGPACK_CS_
+                //case MSGPACK_CS_
+                case MSGPACK_CS_FLOAT: {
+                        union { uint32_t i; float f; } mem;
+                        _msgpack_load32(uint32_t, n, &mem.i);
+                        push_fixed_value(_float, mem.f); }
+                case MSGPACK_CS_DOUBLE: {
+                        union { uint64_t i; double f; } mem;
+                        _msgpack_load64(uint64_t, n, &mem.i);
+#if defined(TARGET_OS_IPHONE)
+                    // ok
+#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
+                        // https://github.com/msgpack/msgpack-perl/pull/1
+                        mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
+#endif
+                        push_fixed_value(_double, mem.f); }
+                case MSGPACK_CS_UINT_8:
+                    push_fixed_value(_uint8, *(uint8_t*)n);
+                case MSGPACK_CS_UINT_16:{
+                    uint16_t tmp;
+                    _msgpack_load16(uint16_t,n,&tmp);
+                    push_fixed_value(_uint16, tmp);
+                }
+                case MSGPACK_CS_UINT_32:{
+                    uint32_t tmp;
+                    _msgpack_load32(uint32_t,n,&tmp);
+                    push_fixed_value(_uint32, tmp);
+                }
+                case MSGPACK_CS_UINT_64:{
+                    uint64_t tmp;
+                    _msgpack_load64(uint64_t,n,&tmp);
+                    push_fixed_value(_uint64, tmp);
+                }
+                case MSGPACK_CS_INT_8:
+                    push_fixed_value(_int8, *(int8_t*)n);
+                case MSGPACK_CS_INT_16:{
+                    int16_t tmp;
+                    _msgpack_load16(int16_t,n,&tmp);
+                    push_fixed_value(_int16, tmp);
+                }
+                case MSGPACK_CS_INT_32:{
+                    int32_t tmp;
+                    _msgpack_load32(int32_t,n,&tmp);
+                    push_fixed_value(_int32, tmp);
+                }
+                case MSGPACK_CS_INT_64:{
+                    int64_t tmp;
+                    _msgpack_load64(int64_t,n,&tmp);
+                    push_fixed_value(_int64, tmp);
+                }
+                case MSGPACK_CS_FIXEXT_1:
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 1+1, _ext_zero);
+                case MSGPACK_CS_FIXEXT_2:
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 2+1, _ext_zero);
+                case MSGPACK_CS_FIXEXT_4:
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 4+1, _ext_zero);
+                case MSGPACK_CS_FIXEXT_8:
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 8+1, _ext_zero);
+                case MSGPACK_CS_FIXEXT_16:
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero);
+                case MSGPACK_CS_STR_8:
+                    again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, *(uint8_t*)n, _str_zero);
+                case MSGPACK_CS_BIN_8:
+                    again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero);
+                case MSGPACK_CS_EXT_8:
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero);
+                case MSGPACK_CS_STR_16:{
+                    uint16_t tmp;
+                    _msgpack_load16(uint16_t,n,&tmp);
+                    again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero);
+                }
+                case MSGPACK_CS_BIN_16:{
+                    uint16_t tmp;
+                    _msgpack_load16(uint16_t,n,&tmp);
+                    again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero);
+                }
+                case MSGPACK_CS_EXT_16:{
+                    uint16_t tmp;
+                    _msgpack_load16(uint16_t,n,&tmp);
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero);
+                }
+                case MSGPACK_CS_STR_32:{
+                    uint32_t tmp;
+                    _msgpack_load32(uint32_t,n,&tmp);
+                    again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero);
+                }
+                case MSGPACK_CS_BIN_32:{
+                    uint32_t tmp;
+                    _msgpack_load32(uint32_t,n,&tmp);
+                    again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero);
+                }
+                case MSGPACK_CS_EXT_32:{
+                    uint32_t tmp;
+                    _msgpack_load32(uint32_t,n,&tmp);
+                    again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero);
+                }
+                case MSGPACK_ACS_STR_VALUE:
+                _str_zero:
+                    push_variable_value(_str, data, n, trail);
+                case MSGPACK_ACS_BIN_VALUE:
+                _bin_zero:
+                    push_variable_value(_bin, data, n, trail);
+                case MSGPACK_ACS_EXT_VALUE:
+                _ext_zero:
+                    push_variable_value(_ext, data, n, trail);
+
+                case MSGPACK_CS_ARRAY_16:{
+                    uint16_t tmp;
+                    _msgpack_load16(uint16_t,n,&tmp);
+                    start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM);
+                }
+                case MSGPACK_CS_ARRAY_32:{
+                    /* FIXME security guard */
+                    uint32_t tmp;
+                    _msgpack_load32(uint32_t,n,&tmp);
+                    start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM);
+                }
+
+                case MSGPACK_CS_MAP_16:{
+                    uint16_t tmp;
+                    _msgpack_load16(uint16_t,n,&tmp);
+                    start_container(_map, tmp, MSGPACK_CT_MAP_KEY);
+                }
+                case MSGPACK_CS_MAP_32:{
+                    /* FIXME security guard */
+                    uint32_t tmp;
+                    _msgpack_load32(uint32_t,n,&tmp);
+                    start_container(_map, tmp, MSGPACK_CT_MAP_KEY);
+                }
+
+                default:
+                    ret = MSGPACK_UNPACK_PARSE_ERROR;
+                    goto _failed;
+                }
+            }
+
+    _push:
+        if(top == 0) { goto _finish; }
+        c = &stack[top-1];
+        switch(c->ct) {
+        case MSGPACK_CT_ARRAY_ITEM:
+            ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \
+            if(ret < 0) { goto _failed; }
+            if(--c->count == 0) {
+                obj = c->obj;
+                --top;
+                /*printf("stack pop %d\n", top);*/
+                goto _push;
+            }
+            goto _header_again;
+        case MSGPACK_CT_MAP_KEY:
+            c->map_key = obj;
+            c->ct = MSGPACK_CT_MAP_VALUE;
+            goto _header_again;
+        case MSGPACK_CT_MAP_VALUE:
+            ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \
+            if(ret < 0) { goto _failed; }
+            if(--c->count == 0) {
+                obj = c->obj;
+                --top;
+                /*printf("stack pop %d\n", top);*/
+                goto _push;
+            }
+            c->ct = MSGPACK_CT_MAP_KEY;
+            goto _header_again;
+
+        default:
+            ret = MSGPACK_UNPACK_PARSE_ERROR;
+            goto _failed;
+        }
+
+    _header_again:
+            cs = MSGPACK_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"); */
+        goto _end;
+
+    _out:
+        ret = 0;
+        goto _end;
+
+    _end:
+        ctx->cs = cs;
+        ctx->trail = trail;
+        ctx->top = top;
+        *off = (size_t)(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 SWITCH_RANGE_BEGIN
+#undef SWITCH_RANGE
+#undef SWITCH_RANGE_DEFAULT
+#undef SWITCH_RANGE_END

include/msgpack/util.h

@@ -0,0 +1,15 @@
+/*
+ * MessagePack for C utilities
+ *
+ * Copyright (C) 2014 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)
+ */
+#ifndef MSGPACK_UTIL_H
+#define MSGPACK_UTIL_H
+
+#define MSGPACK_UNUSED(a) (void)(a)
+
+#endif /* MSGPACK_UTIL_H */

include/msgpack/version.h

@@ -0,0 +1,38 @@
+/*
+ * MessagePack for C version information
+ *
+ * Copyright (C) 2008-2009 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)
+ */
+#ifndef MSGPACK_VERSION_H
+#define MSGPACK_VERSION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+MSGPACK_DLLEXPORT
+const char* msgpack_version(void);
+MSGPACK_DLLEXPORT
+int msgpack_version_major(void);
+MSGPACK_DLLEXPORT
+int msgpack_version_minor(void);
+MSGPACK_DLLEXPORT
+int msgpack_version_revision(void);
+
+#include "version_master.h"
+
+#define MSGPACK_STR(v) #v
+#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev)
+
+#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/version.h */
+

include/msgpack/version_master.h

@@ -0,0 +1,3 @@
+#define MSGPACK_VERSION_MAJOR    6
+#define MSGPACK_VERSION_MINOR    0
+#define MSGPACK_VERSION_REVISION 0

include/msgpack/vrefbuffer.h

@@ -0,0 +1,146 @@
+/*
+ * MessagePack for C zero-copy buffer implementation
+ *
+ * Copyright (C) 2008-2009 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)
+ */
+#ifndef MSGPACK_VREFBUFFER_H
+#define MSGPACK_VREFBUFFER_H
+
+#include "zone.h"
+#include <stdlib.h>
+#include <assert.h>
+
+#if defined(unix) || defined(__unix) || defined(__linux__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) || defined(__QNXTO__) || defined(__HAIKU__)
+#include <sys/uio.h>
+typedef struct iovec msgpack_iovec;
+#else
+struct msgpack_iovec {
+    void  *iov_base;
+    size_t iov_len;
+};
+typedef struct msgpack_iovec msgpack_iovec;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup msgpack_vrefbuffer Vectored Referencing buffer
+ * @ingroup msgpack_buffer
+ * @{
+ */
+
+struct msgpack_vrefbuffer_chunk;
+typedef struct msgpack_vrefbuffer_chunk msgpack_vrefbuffer_chunk;
+
+typedef struct msgpack_vrefbuffer_inner_buffer {
+    size_t free;
+    char*  ptr;
+    msgpack_vrefbuffer_chunk* head;
+} msgpack_vrefbuffer_inner_buffer;
+
+typedef struct msgpack_vrefbuffer {
+    msgpack_iovec* tail;
+    msgpack_iovec* end;
+    msgpack_iovec* array;
+
+    size_t chunk_size;
+    size_t ref_size;
+
+    msgpack_vrefbuffer_inner_buffer inner_buffer;
+} msgpack_vrefbuffer;
+
+
+#ifndef MSGPACK_VREFBUFFER_REF_SIZE
+#define MSGPACK_VREFBUFFER_REF_SIZE 32
+#endif
+
+#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE
+#define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192
+#endif
+
+MSGPACK_DLLEXPORT
+bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf,
+        size_t ref_size, size_t chunk_size);
+MSGPACK_DLLEXPORT
+void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf);
+
+static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size);
+static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf);
+
+static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len);
+
+static inline const msgpack_iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref);
+static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref);
+
+MSGPACK_DLLEXPORT
+int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf,
+        const char* buf, size_t len);
+
+MSGPACK_DLLEXPORT
+int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf,
+        const char* buf, size_t len);
+
+MSGPACK_DLLEXPORT
+int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to);
+
+MSGPACK_DLLEXPORT
+void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vref);
+
+/** @} */
+
+
+static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size)
+{
+    msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)malloc(sizeof(msgpack_vrefbuffer));
+    if (vbuf == NULL) return NULL;
+    if(!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) {
+        free(vbuf);
+        return NULL;
+    }
+    return vbuf;
+}
+
+static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf)
+{
+    if(vbuf == NULL) { return; }
+    msgpack_vrefbuffer_destroy(vbuf);
+    free(vbuf);
+}
+
+static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len)
+{
+    msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data;
+    assert(buf || len == 0);
+
+    if(!buf) return 0;
+
+    if(len < vbuf->ref_size) {
+        return msgpack_vrefbuffer_append_copy(vbuf, buf, len);
+    } else {
+        return msgpack_vrefbuffer_append_ref(vbuf, buf, len);
+    }
+}
+
+static inline const msgpack_iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref)
+{
+    return vref->array;
+}
+
+static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref)
+{
+    return (size_t)(vref->tail - vref->array);
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/vrefbuffer.h */

include/msgpack/zbuffer.h

@@ -0,0 +1,205 @@
+/*
+ * MessagePack for C deflate buffer implementation
+ *
+ * Copyright (C) 2010 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)
+ */
+#ifndef MSGPACK_ZBUFFER_H
+#define MSGPACK_ZBUFFER_H
+
+#include "sysdep.h"
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <zlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup msgpack_zbuffer Compressed buffer
+ * @ingroup msgpack_buffer
+ * @{
+ */
+
+typedef struct msgpack_zbuffer {
+    z_stream stream;
+    char* data;
+    size_t init_size;
+} msgpack_zbuffer;
+
+#ifndef MSGPACK_ZBUFFER_INIT_SIZE
+#define MSGPACK_ZBUFFER_INIT_SIZE 8192
+#endif
+
+static inline bool msgpack_zbuffer_init(
+    msgpack_zbuffer* zbuf, int level, size_t init_size);
+static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf);
+
+static inline msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size);
+static inline void msgpack_zbuffer_free(msgpack_zbuffer* zbuf);
+
+static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf);
+
+static inline const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf);
+static inline size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf);
+
+static inline bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf);
+static inline void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf);
+static inline char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf);
+
+
+#ifndef MSGPACK_ZBUFFER_RESERVE_SIZE
+#define MSGPACK_ZBUFFER_RESERVE_SIZE 512
+#endif
+
+static inline int msgpack_zbuffer_write(void* data, const char* buf, size_t len);
+
+static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf);
+
+
+static inline bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf,
+        int level, size_t init_size)
+{
+    memset(zbuf, 0, sizeof(msgpack_zbuffer));
+    zbuf->init_size = init_size;
+    if(deflateInit(&zbuf->stream, level) != Z_OK) {
+        free(zbuf->data);
+        return false;
+    }
+    return true;
+}
+
+static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf)
+{
+    deflateEnd(&zbuf->stream);
+    free(zbuf->data);
+}
+
+static inline msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size)
+{
+    msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer));
+    if (zbuf == NULL) return NULL;
+    if(!msgpack_zbuffer_init(zbuf, level, init_size)) {
+        free(zbuf);
+        return NULL;
+    }
+    return zbuf;
+}
+
+static inline void msgpack_zbuffer_free(msgpack_zbuffer* zbuf)
+{
+    if(zbuf == NULL) { return; }
+    msgpack_zbuffer_destroy(zbuf);
+    free(zbuf);
+}
+
+static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf)
+{
+    size_t used = (size_t)((char *)(zbuf->stream.next_out) - zbuf->data);
+    size_t csize = used + zbuf->stream.avail_out;
+
+    size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2;
+
+    char* tmp = (char*)realloc(zbuf->data, nsize);
+    if(tmp == NULL) {
+        return false;
+    }
+
+    zbuf->data = tmp;
+    zbuf->stream.next_out  = (Bytef*)(tmp + used);
+    zbuf->stream.avail_out = (uInt)(nsize - used);
+
+    return true;
+}
+
+static inline int msgpack_zbuffer_write(void* data, const char* buf, size_t len)
+{
+    msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data;
+
+    assert(buf || len == 0);
+    if(!buf) return 0;
+
+    zbuf->stream.next_in = (Bytef*)buf;
+    zbuf->stream.avail_in = (uInt)len;
+
+    while(zbuf->stream.avail_in > 0) {
+        if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
+            if(!msgpack_zbuffer_expand(zbuf)) {
+                return -1;
+            }
+        }
+
+        if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf)
+{
+    while(true) {
+        switch(deflate(&zbuf->stream, Z_FINISH)) {
+        case Z_STREAM_END:
+            return zbuf->data;
+        case Z_OK:
+        case Z_BUF_ERROR:
+            if(!msgpack_zbuffer_expand(zbuf)) {
+                return NULL;
+            }
+            break;
+        default:
+            return NULL;
+        }
+    }
+}
+
+static inline const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf)
+{
+    return zbuf->data;
+}
+
+static inline size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf)
+{
+    return (size_t)((char *)(zbuf->stream.next_out) - zbuf->data);
+}
+
+static inline void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf)
+{
+    zbuf->stream.avail_out += (uInt)((char*)zbuf->stream.next_out - zbuf->data);
+    zbuf->stream.next_out = (Bytef*)zbuf->data;
+}
+
+static inline bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf)
+{
+    if(deflateReset(&zbuf->stream) != Z_OK) {
+        return false;
+    }
+    msgpack_zbuffer_reset_buffer(zbuf);
+    return true;
+}
+
+static inline char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf)
+{
+    char* tmp = zbuf->data;
+    zbuf->data = NULL;
+    zbuf->stream.next_out = NULL;
+    zbuf->stream.avail_out = 0;
+    return tmp;
+}
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/zbuffer.h */

include/msgpack/zone.h

@@ -0,0 +1,163 @@
+/*
+ * MessagePack for C memory pool implementation
+ *
+ * Copyright (C) 2008-2010 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)
+ */
+#ifndef MSGPACK_ZONE_H
+#define MSGPACK_ZONE_H
+
+#include "sysdep.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup msgpack_zone Memory zone
+ * @ingroup msgpack
+ * @{
+ */
+
+typedef struct msgpack_zone_finalizer {
+    void (*func)(void* data);
+    void* data;
+} msgpack_zone_finalizer;
+
+typedef struct msgpack_zone_finalizer_array {
+    msgpack_zone_finalizer* tail;
+    msgpack_zone_finalizer* end;
+    msgpack_zone_finalizer* array;
+} msgpack_zone_finalizer_array;
+
+struct msgpack_zone_chunk;
+typedef struct msgpack_zone_chunk msgpack_zone_chunk;
+
+typedef struct msgpack_zone_chunk_list {
+    size_t free;
+    char* ptr;
+    msgpack_zone_chunk* head;
+} msgpack_zone_chunk_list;
+
+typedef struct msgpack_zone {
+    msgpack_zone_chunk_list chunk_list;
+    msgpack_zone_finalizer_array finalizer_array;
+    size_t chunk_size;
+} msgpack_zone;
+
+#ifndef MSGPACK_ZONE_CHUNK_SIZE
+#define MSGPACK_ZONE_CHUNK_SIZE 8192
+#endif
+
+MSGPACK_DLLEXPORT
+bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size);
+MSGPACK_DLLEXPORT
+void msgpack_zone_destroy(msgpack_zone* zone);
+
+MSGPACK_DLLEXPORT
+msgpack_zone* msgpack_zone_new(size_t chunk_size);
+MSGPACK_DLLEXPORT
+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);
+
+static inline void msgpack_zone_swap(msgpack_zone* a, msgpack_zone* b);
+
+MSGPACK_DLLEXPORT
+bool msgpack_zone_is_empty(msgpack_zone* zone);
+
+MSGPACK_DLLEXPORT
+void msgpack_zone_clear(msgpack_zone* zone);
+
+/** @} */
+
+
+#ifndef MSGPACK_ZONE_ALIGN
+#define MSGPACK_ZONE_ALIGN sizeof(void*)
+#endif
+
+MSGPACK_DLLEXPORT
+void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size);
+
+static inline void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size)
+{
+    char* ptr;
+    msgpack_zone_chunk_list* cl = &zone->chunk_list;
+
+    if(zone->chunk_list.free < size) {
+        return msgpack_zone_malloc_expand(zone, size);
+    }
+
+    ptr = cl->ptr;
+    cl->free -= size;
+    cl->ptr  += size;
+
+    return ptr;
+}
+
+static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size)
+{
+    char* aligned =
+        (char*)(
+            (uintptr_t)(
+                zone->chunk_list.ptr + (MSGPACK_ZONE_ALIGN - 1)
+            ) & ~(uintptr_t)(MSGPACK_ZONE_ALIGN - 1)
+        );
+    size_t adjusted_size = size + (size_t)(aligned - zone->chunk_list.ptr);
+    if(zone->chunk_list.free >= adjusted_size) {
+        zone->chunk_list.free -= adjusted_size;
+        zone->chunk_list.ptr  += adjusted_size;
+        return aligned;
+    }
+    {
+        void* ptr = msgpack_zone_malloc_expand(zone, size + (MSGPACK_ZONE_ALIGN - 1));
+        if (ptr) {
+            return (char*)((uintptr_t)(ptr) & ~(uintptr_t)(MSGPACK_ZONE_ALIGN - 1));
+        }
+    }
+    return NULL;
+}
+
+
+bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone,
+        void (*func)(void* data), void* data);
+
+static inline 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;
+}
+
+static inline void msgpack_zone_swap(msgpack_zone* a, msgpack_zone* b)
+{
+    msgpack_zone tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* msgpack/zone.h */

makedist.sh

@@ -0,0 +1,39 @@
+#!/bin/sh
+
+ver=`cat include/msgpack/version_master.h | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR[[:space:]]*\([[:alnum:]]*\)/\1./g' -e 's/#define MSGPACK_VERSION_REVISION[[:space:]]*\([[:alnum:]]*\)/\1/g'`
+
+prefix=msgpack-c-$ver
+filename=$prefix.tar
+
+ln -s . $prefix
+
+test -f AUTHORS   || touch AUTHORS
+test -f COPYING   || touch COPYING
+test -f ChangeLog || cp -f CHANGELOG.md ChangeLog
+test -f NEWS      || touch NEWS
+test -f NOTICE    || touch NOTICE
+test -f README    || cp -f README.md README
+
+tar cf $filename $prefix/example
+tar --append --file=$filename $prefix/test
+tar --append --file=$filename $prefix/include
+tar --append --file=$filename $prefix/src
+tar --append --file=$filename $prefix/cmake
+
+tar --append --file=$filename $prefix/CMakeLists.txt
+tar --append --file=$filename $prefix/Files.cmake
+tar --append --file=$filename $prefix/NOTICE
+tar --append --file=$filename $prefix/Doxyfile
+tar --append --file=$filename $prefix/msgpack-c.pc.in
+tar --append --file=$filename $prefix/AUTHORS
+tar --append --file=$filename $prefix/README.md
+tar --append --file=$filename $prefix/LICENSE_1_0.txt
+tar --append --file=$filename $prefix/ChangeLog
+tar --append --file=$filename $prefix/NEWS
+tar --append --file=$filename $prefix/COPYING
+tar --append --file=$filename $prefix/README
+tar --append --file=$filename $prefix/msgpack-c-config.cmake.in
+
+rm -f $prefix
+
+gzip -f $filename

msgpack-c-config.cmake.in

@@ -0,0 +1,19 @@
+#.rst:
+# msgpack
+# -------
+#
+# The following import targets are created
+#
+# ::
+#
+#   msgpack-c
+#   msgpack-c-static (optional)
+#
+
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+if(NOT TARGET msgpack-c AND NOT TARGET msgpack-c-static)
+  include("${CMAKE_CURRENT_LIST_DIR}/msgpack-c-targets.cmake")
+endif()

msgpack-c.pc.in

@@ -6,5 +6,5 @@ includedir=@includedir@
 Name: MessagePack
 Description: Binary-based efficient object serialization library
 Version: @VERSION@
-Libs: -L${libdir} -lmsgpack
+Libs: -L${libdir} -lmsgpack-c
 Cflags: -I${includedir}

msgpack_vc.postbuild.bat

@@ -1,47 +0,0 @@
-IF NOT EXIST include                  MKDIR include
-IF NOT EXIST include\msgpack          MKDIR include\msgpack
-IF NOT EXIST include\msgpack\type     MKDIR include\msgpack\type
-IF NOT EXIST include\msgpack\type\tr1 MKDIR include\msgpack\type\tr1
-copy src\msgpack\pack_define.h      include\msgpack\
-copy src\msgpack\pack_template.h    include\msgpack\
-copy src\msgpack\unpack_define.h    include\msgpack\
-copy src\msgpack\unpack_template.h  include\msgpack\
-copy src\msgpack\sysdep.h           include\msgpack\
-copy src\msgpack.h                     include\
-copy src\msgpack\sbuffer.h             include\msgpack\
-copy src\msgpack\version.h             include\msgpack\
-copy src\msgpack\vrefbuffer.h          include\msgpack\
-copy src\msgpack\zbuffer.h             include\msgpack\
-copy src\msgpack\fbuffer.h             include\msgpack\
-copy src\msgpack\pack.h                include\msgpack\
-copy src\msgpack\unpack.h              include\msgpack\
-copy src\msgpack\object.h              include\msgpack\
-copy src\msgpack\zone.h                include\msgpack\
-copy src\msgpack.hpp                   include\
-copy src\msgpack\sbuffer.hpp           include\msgpack\
-copy src\msgpack\vrefbuffer.hpp        include\msgpack\
-copy src\msgpack\zbuffer.hpp           include\msgpack\
-copy src\msgpack\fbuffer.hpp           include\msgpack\
-copy src\msgpack\pack.hpp              include\msgpack\
-copy src\msgpack\unpack.hpp            include\msgpack\
-copy src\msgpack\object.hpp            include\msgpack\
-copy src\msgpack\zone.hpp              include\msgpack\
-copy src\msgpack\type.hpp              include\msgpack\
-copy src\msgpack\type\bool.hpp         include\msgpack\type\
-copy src\msgpack\type\deque.hpp        include\msgpack\type\
-copy src\msgpack\type\fixint.hpp       include\msgpack\type\
-copy src\msgpack\type\float.hpp        include\msgpack\type\
-copy src\msgpack\type\int.hpp          include\msgpack\type\
-copy src\msgpack\type\list.hpp         include\msgpack\type\
-copy src\msgpack\type\map.hpp          include\msgpack\type\
-copy src\msgpack\type\nil.hpp          include\msgpack\type\
-copy src\msgpack\type\pair.hpp         include\msgpack\type\
-copy src\msgpack\type\raw.hpp          include\msgpack\type\
-copy src\msgpack\type\set.hpp          include\msgpack\type\
-copy src\msgpack\type\string.hpp       include\msgpack\type\
-copy src\msgpack\type\vector.hpp       include\msgpack\type\
-copy src\msgpack\type\tuple.hpp        include\msgpack\type\
-copy src\msgpack\type\define.hpp       include\msgpack\type\
-copy src\msgpack\type\tr1\unordered_map.hpp  include\msgpack\type\tr1\
-copy src\msgpack\type\tr1\unordered_set.hpp  include\msgpack\type\tr1\
-

msgpack_vc8.sln

@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 9.00
-# Visual C++ Express 2008
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MessagePack", "msgpack_vc8.vcproj", "{122A2EA4-B283-4241-9655-786DE78283B2}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|Win32.ActiveCfg = Debug|Win32
-		{122A2EA4-B283-4241-9655-786DE78283B2}.Debug|Win32.Build.0 = Debug|Win32
-		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|Win32.ActiveCfg = Release|Win32
-		{122A2EA4-B283-4241-9655-786DE78283B2}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

msgpack_vc8.vcproj

@@ -1,219 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="MessagePack"
-	ProjectGUID="{122A2EA4-B283-4241-9655-786DE78283B2}"
-	RootNamespace="MessagePack"
-	Keyword="Win32Proj"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="4"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-				Description="Gathering header files"
-				CommandLine="msgpack_vc.postbuild.bat"
-				Outputs="include"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="."
-				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="1"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="lib\msgpackd.lib"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="4"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-				Description="Gathering header files"
-				CommandLine="msgpack_vc.postbuild.bat"
-				Outputs="include"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				AdditionalIncludeDirectories="."
-				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
-				RuntimeLibrary="2"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				Detect64BitPortabilityProblems="true"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="lib\msgpack.lib"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath=".\src\objectc.c"
-				>
-			</File>
-			<File
-				RelativePath=".\src\unpack.c"
-				>
-			</File>
-			<File
-				RelativePath=".\src\version.c"
-				>
-			</File>
-			<File
-				RelativePath=".\src\vrefbuffer.c"
-				>
-			</File>
-			<File
-				RelativePath=".\src\zone.c"
-				>
-			</File>
-			<File
-				RelativePath=".\src\object.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-			<File
-				RelativePath=".\src\msgpack\pack_define.h"
-				>
-			</File>
-			<File
-				RelativePath=".\src\msgpack\pack_template.h"
-				>
-			</File>
-			<File
-				RelativePath=".\src\msgpack\sysdep.h"
-				>
-			</File>
-			<File
-				RelativePath=".\src\msgpack\unpack_define.h"
-				>
-			</File>
-			<File
-				RelativePath=".\src\msgpack\unpack_template.h"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

preprocess

@@ -1,17 +0,0 @@
-#!/bin/sh
-
-preprocess() {
-	ruby -r erb -e 'puts ERB.new(ARGF.read).result' $1.erb > $1.tmp
-	if [ "$?" != 0 ]; then
-		echo ""
-		echo "** preprocess failed **"
-		echo ""
-		exit 1
-	else
-		mv $1.tmp $1
-	fi
-}
-
-preprocess src/msgpack/type/tuple.hpp
-preprocess src/msgpack/type/define.hpp
-preprocess src/msgpack/zone.hpp

src/Makefile.am

@@ -1,108 +0,0 @@
-lib_LTLIBRARIES = libmsgpack.la
-
-libmsgpack_la_SOURCES = \
-		unpack.c \
-		objectc.c \
-		version.c \
-		vrefbuffer.c \
-		zone.c
-
-if ENABLE_CXX
-libmsgpack_la_SOURCES += \
-		object.cpp
-endif
-
-if ENABLE_GCC_CXX_ATOMIC
-libmsgpack_la_SOURCES += \
-		gcc_atomic.cpp
-endif
-
-
-# -version-info CURRENT:REVISION:AGE
-libmsgpack_la_LDFLAGS = -version-info 3:0:0 -no-undefined
-
-
-# backward compatibility
-lib_LTLIBRARIES += libmsgpackc.la
-
-libmsgpackc_la_SOURCES = \
-		unpack.c \
-		objectc.c \
-		version.c \
-		vrefbuffer.c \
-		zone.c
-
-libmsgpackc_la_LDFLAGS = -version-info 2:0:0 -no-undefined
-
-
-nobase_include_HEADERS = \
-		msgpack/pack_define.h \
-		msgpack/pack_template.h \
-		msgpack/unpack_define.h \
-		msgpack/unpack_template.h \
-		msgpack/sysdep.h \
-		gcc_atomic.h \
-		msgpack.h \
-		msgpack/sbuffer.h \
-		msgpack/version.h \
-		msgpack/vrefbuffer.h \
-		msgpack/zbuffer.h \
-		msgpack/fbuffer.h \
-		msgpack/pack.h \
-		msgpack/unpack.h \
-		msgpack/object.h \
-		msgpack/zone.h
-
-if ENABLE_CXX
-nobase_include_HEADERS += \
-		msgpack.hpp \
-		msgpack/sbuffer.hpp \
-		msgpack/vrefbuffer.hpp \
-		msgpack/zbuffer.hpp \
-		msgpack/fbuffer.hpp \
-		msgpack/pack.hpp \
-		msgpack/unpack.hpp \
-		msgpack/object.hpp \
-		msgpack/zone.hpp \
-		msgpack/type.hpp \
-		msgpack/type/bool.hpp \
-		msgpack/type/deque.hpp \
-		msgpack/type/float.hpp \
-		msgpack/type/fixint.hpp \
-		msgpack/type/int.hpp \
-		msgpack/type/list.hpp \
-		msgpack/type/map.hpp \
-		msgpack/type/nil.hpp \
-		msgpack/type/pair.hpp \
-		msgpack/type/raw.hpp \
-		msgpack/type/set.hpp \
-		msgpack/type/string.hpp \
-		msgpack/type/vector.hpp \
-		msgpack/type/tuple.hpp \
-		msgpack/type/define.hpp \
-		msgpack/type/tr1/unordered_map.hpp \
-		msgpack/type/tr1/unordered_set.hpp
-endif
-
-EXTRA_DIST = \
-		msgpack/version.h.in \
-		msgpack/zone.hpp.erb \
-		msgpack/type/define.hpp.erb \
-		msgpack/type/tuple.hpp.erb
-
-
-doxygen_c:
-	cat ../Doxyfile > Doxyfile_c
-	echo "FILE_PATTERNS      = *.h" >> Doxyfile_c
-	echo "OUTPUT_DIRECTORY   = doc_c" >> Doxyfile_c
-	echo "PROJECT_NAME       = \"MessagePack for C\"" >> Doxyfile_c
-	doxygen Doxyfile_c
-
-doxygen_cpp:
-	cat ../Doxyfile > Doxyfile_cpp
-	echo "FILE_PATTERNS      = *.hpp" >> Doxyfile_cpp
-	echo "OUTPUT_DIRECTORY   = doc_cpp" >> Doxyfile_cpp
-	echo "PROJECT_NAME       = \"MessagePack for C++\"" >> Doxyfile_cpp
-	doxygen Doxyfile_cpp
-
-doxygen: doxygen_c doxygen_cpp

src/gcc_atomic.cpp

@@ -1,35 +0,0 @@
-//
-// MessagePack for C++ atomic operations
-//
-// Copyright (C) 2008-2013 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(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
-
-#include "gcc_atomic.h"
-#include <bits/atomicity.h>
-
-int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr)
-{
-	return  __gnu_cxx::__exchange_and_add(ptr, -1) - 1;
-}
-
-int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr)
-{
-	return  __gnu_cxx::__exchange_and_add(ptr, 1) + 1;
-}
-
-
-#endif // old gcc workaround

src/gcc_atomic.h

@@ -1,33 +0,0 @@
-/*
- *    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_GCC_ATOMIC_H__
-#define MSGPACK_GCC_ATOMIC_H__
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-typedef int _msgpack_atomic_counter_t;
-
-int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr);
-int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr);
-
-
-#if defined(__cplusplus)
-}
-#endif
-
-
-#endif // MSGPACK_GCC_ATOMIC_H__

src/msgpack.h

@@ -1,31 +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.
- */
-/**
- * @defgroup msgpack MessagePack C
- * @{
- * @}
- */
-
-#include "msgpack/object.h"
-#include "msgpack/zone.h"
-#include "msgpack/pack.h"
-#include "msgpack/unpack.h"
-#include "msgpack/sbuffer.h"
-#include "msgpack/vrefbuffer.h"
-#include "msgpack/version.h"
-

src/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"

src/msgpack/fbuffer.h

@@ -1,47 +0,0 @@
-/*
- * MessagePack for C FILE* buffer adaptor
- *
- * Copyright (C) 2013 Vladimir Volodko
- *
- *    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_FBUFFER_H__
-#define MSGPACK_FBUFFER_H__
-
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**
- * @defgroup msgpack_fbuffer FILE* buffer
- * @ingroup msgpack_buffer
- * @{
- */
-
-static inline int msgpack_fbuffer_write(void* data, const char* buf, unsigned int len)
-{
-	return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
-}
-
-/** @} */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/fbuffer.h */
-

src/msgpack/fbuffer.hpp

@@ -1,56 +0,0 @@
-//
-// MessagePack for C++ FILE* buffer adaptor
-//
-// Copyright (C) 2013 Vladimir Volodko
-//
-//    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_FBUFFER_HPP__
-#define MSGPACK_FBUFFER_HPP__
-
-#include <cstdio>
-#include <stdexcept>
-
-namespace msgpack {
-
-
-class fbuffer {
-public:
-	explicit fbuffer(FILE* file) : m_file(file) { }
-
-public:
-	void write(const char* buf, unsigned int len)
-	{
-		if (1 != fwrite(buf, len, 1, m_file)) {
-			throw std::runtime_error("fwrite() failed");
-		}
-	}
-
-	FILE* file() const
-	{
-		return m_file;
-	}
-
-private:
-	fbuffer(const fbuffer&);
-	fbuffer& operator= (const fbuffer&);
-
-private:
-	FILE* m_file;
-};
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/fbuffer.hpp */
-

src/msgpack/object.h

@@ -1,98 +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 "zone.h"
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**
- * @defgroup msgpack_object Dynamically typed object
- * @ingroup msgpack
- * @{
- */
-
-typedef enum {
-	MSGPACK_OBJECT_NIL					= 0x00,
-	MSGPACK_OBJECT_BOOLEAN				= 0x01,
-	MSGPACK_OBJECT_POSITIVE_INTEGER		= 0x02,
-	MSGPACK_OBJECT_NEGATIVE_INTEGER		= 0x03,
-	MSGPACK_OBJECT_DOUBLE				= 0x04,
-	MSGPACK_OBJECT_RAW					= 0x05,
-	MSGPACK_OBJECT_ARRAY				= 0x06,
-	MSGPACK_OBJECT_MAP					= 0x07,
-} 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);
-
-bool msgpack_object_equal(const msgpack_object x, const msgpack_object y);
-
-/** @} */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/object.h */
-

src/msgpack/object.hpp

@@ -1,480 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2008-2010 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 "object.h"
-#include "pack.hpp"
-#include "zone.hpp"
-#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					= MSGPACK_OBJECT_NIL,
-		BOOLEAN				= MSGPACK_OBJECT_BOOLEAN,
-		POSITIVE_INTEGER	= MSGPACK_OBJECT_POSITIVE_INTEGER,
-		NEGATIVE_INTEGER	= MSGPACK_OBJECT_NEGATIVE_INTEGER,
-		DOUBLE				= MSGPACK_OBJECT_DOUBLE,
-		RAW					= MSGPACK_OBJECT_RAW,
-		ARRAY				= MSGPACK_OBJECT_ARRAY,
-		MAP					= MSGPACK_OBJECT_MAP,
-	};
-}
-
-
-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 o);
-
-	template <typename T>
-	explicit object(const T& v);
-
-	template <typename T>
-	object(const T& v, zone* z);
-
-	template <typename T>
-	object& operator=(const T& v);
-
-	operator msgpack_object() const;
-
-	struct with_zone;
-
-private:
-	struct implicit_type;
-
-public:
-	implicit_type convert() const;
-};
-
-struct object_kv {
-	object key;
-	object val;
-};
-
-struct object::with_zone : object {
-	with_zone(msgpack::zone* zone) : zone(zone) { }
-	msgpack::zone* zone;
-private:
-	with_zone();
-};
-
-
-bool operator==(const object x, const object y);
-bool operator!=(const object x, const object y);
-
-template <typename T>
-bool operator==(const object x, const T& y);
-
-template <typename T>
-bool operator==(const T& y, const object x);
-
-template <typename T>
-bool operator!=(const object x, const T& y);
-
-template <typename T>
-bool operator!=(const T& y, const object x);
-
-std::ostream& operator<< (std::ostream& s, const object o);
-
-
-// serialize operator
-template <typename Stream, typename T>
-packer<Stream>& operator<< (packer<Stream>& o, const T& v);
-
-// convert operator
-template <typename T>
-T& operator>> (object o, T& v);
-
-// deconvert operator
-template <typename T>
-void operator<< (object::with_zone& o, const 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;
-};
-
-
-// obsolete
-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;
-}
-
-namespace detail {
-template <typename Stream, typename T>
-struct packer_serializer {
-	static packer<Stream>& pack(packer<Stream>& o, const T& v) {
-		v.msgpack_pack(o);
-		return o;
-	}
-};
-}
-
-template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const T& v)
-{
-	return detail::packer_serializer<Stream, T>::pack(o, v);
-}
-
-template <typename T>
-void operator<< (object::with_zone& o, const T& v)
-{
-	v.msgpack_object(static_cast<object*>(&o), o.zone);
-}
-
-template <>
-inline void operator<< (object::with_zone& o, const object& v)
-{
-	o.type = v.type;
-
-	switch(v.type) {
-	case type::NIL:
-	case type::BOOLEAN:
-	case type::POSITIVE_INTEGER:
-	case type::NEGATIVE_INTEGER:
-	case type::DOUBLE:
-		::memcpy(&o.via, &v.via, sizeof(v.via));
-		return;
-
-	case type::RAW:
-		o.via.raw.ptr = static_cast<const char*>(o.zone->malloc(v.via.raw.size));
-		o.via.raw.size = v.via.raw.size;
-		::memcpy(const_cast<char*>(o.via.raw.ptr), v.via.raw.ptr, v.via.raw.size);
-		return;
-
-	case type::ARRAY:
-		o.via.array.ptr = static_cast<object*>(o.zone->malloc(sizeof(object) * v.via.array.size));
-		o.via.array.size = v.via.array.size;
-		for(object* po(o.via.array.ptr), * pv(v.via.array.ptr),
-				* const pvend(v.via.array.ptr + v.via.array.size);
-				pv < pvend; ++po, ++pv) {
-			new (po) object(*pv, o.zone);
-		}
-		return;
-
-	case type::MAP:
-		o.via.map.ptr = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv) * v.via.map.size));
-		o.via.map.size = v.via.map.size;
-		for(object_kv* po(o.via.map.ptr), * pv(v.via.map.ptr),
-				* const pvend(v.via.map.ptr + v.via.map.size);
-				pv < pvend; ++po, ++pv) {
-			object_kv* kv = new (po) object_kv;
-			new (&kv->key) object(pv->key, o.zone);
-			new (&kv->val) object(pv->val, o.zone);
-		}
-		return;
-
-	default:
-		throw type_error();
-	}
-}
-
-template <>
-inline void operator<< (object::with_zone& o, const object::with_zone& v)
-{
-	return o << static_cast<object>(v);
-}
-
-
-inline bool operator==(const object x, const object y)
-{
-	return msgpack_object_equal(x, y);
-}
-
-template <typename T>
-inline bool operator==(const object x, const T& y)
-try {
-	return x == object(y);
-} catch (msgpack::type_error&) {
-	return false;
-}
-
-inline bool operator!=(const object x, const object y)
-{ return !(x == y); }
-
-template <typename T>
-inline bool operator==(const T& y, const object x)
-{ return x == y; }
-
-template <typename T>
-inline bool operator!=(const object x, const T& y)
-{ return !(x == y); }
-
-template <typename T>
-inline bool operator!=(const T& y, const object x)
-{ return x != y; }
-
-
-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;
-}
-
-
-inline object::object()
-{
-	type = type::NIL;
-}
-
-template <typename T>
-inline object::object(const T& v)
-{
-	*this << v;
-}
-
-template <typename T>
-inline object& object::operator=(const T& v)
-{
-	*this = object(v);
-	return *this;
-}
-
-template <typename T>
-object::object(const T& v, zone* z)
-{
-	with_zone oz(z);
-	oz << v;
-	type = oz.type;
-	via = oz.via;
-}
-
-
-inline object::object(msgpack_object o)
-{
-	// FIXME beter way?
-	::memcpy(this, &o, sizeof(o));
-}
-
-inline void operator<< (object& o, msgpack_object v)
-{
-	// FIXME beter way?
-	::memcpy(&o, &v, sizeof(v));
-}
-
-inline object::operator msgpack_object() const
-{
-	// FIXME beter way?
-	msgpack_object obj;
-	::memcpy(&obj, this, sizeof(obj));
-	return obj;
-}
-
-
-// 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:
-		o.pack_uint64(v.via.u64);
-		return o;
-
-	case type::NEGATIVE_INTEGER:
-		o.pack_int64(v.via.i64);
-		return o;
-
-	case type::DOUBLE:
-		o.pack_double(v.via.dec);
-		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();
-	}
-}
-
-template <typename Stream>
-packer<Stream>& operator<< (packer<Stream>& o, const object::with_zone& v)
-{
-	return o << static_cast<object>(v);
-}
-
-
-}  // namespace msgpack
-
-#include "msgpack/type.hpp"
-
-#endif /* msgpack/object.hpp */
-

src/msgpack/pack.hpp

@@ -1,337 +0,0 @@
-//
-// MessagePack for C++ serializing routine
-//
-// Copyright (C) 2008-2010 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 "pack_define.h"
-#include <stdexcept>
-#include <limits.h>
-
-namespace msgpack {
-
-
-template <typename Stream>
-class packer {
-public:
-	packer(Stream* s);
-	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(int8_t d);
-	packer<Stream>& pack_int16(int16_t d);
-	packer<Stream>& pack_int32(int32_t d);
-	packer<Stream>& pack_int64(int64_t d);
-
-	packer<Stream>& pack_fix_uint8(uint8_t d);
-	packer<Stream>& pack_fix_uint16(uint16_t d);
-	packer<Stream>& pack_fix_uint32(uint32_t d);
-	packer<Stream>& pack_fix_uint64(uint64_t d);
-	packer<Stream>& pack_fix_int8(int8_t d);
-	packer<Stream>& pack_fix_int16(int16_t d);
-	packer<Stream>& pack_fix_int32(int32_t d);
-	packer<Stream>& pack_fix_int64(int64_t d);
-
-	packer<Stream>& pack_char(char d);
-	packer<Stream>& pack_signed_char(signed char d);
-	packer<Stream>& pack_short(short d);
-	packer<Stream>& pack_int(int d);
-	packer<Stream>& pack_long(long d);
-	packer<Stream>& pack_long_long(long long d);
-	packer<Stream>& pack_unsigned_char(unsigned char d);
-	packer<Stream>& pack_unsigned_short(unsigned short d);
-	packer<Stream>& pack_unsigned_int(unsigned int d);
-	packer<Stream>& pack_unsigned_long(unsigned long d);
-	packer<Stream>& pack_unsigned_long_long(unsigned long long d);
-
-	packer<Stream>& pack_float(float d);
-	packer<Stream>& pack_double(double d);
-
-	packer<Stream>& pack_nil();
-	packer<Stream>& pack_true();
-	packer<Stream>& pack_false();
-
-	packer<Stream>& pack_array(size_t n);
-
-	packer<Stream>& pack_map(size_t n);
-
-	packer<Stream>& pack_raw(size_t l);
-	packer<Stream>& pack_raw_body(const char* b, size_t l);
-
-private:
-	static void _pack_uint8(Stream& x, uint8_t d);
-	static void _pack_uint16(Stream& x, uint16_t d);
-	static void _pack_uint32(Stream& x, uint32_t d);
-	static void _pack_uint64(Stream& x, uint64_t d);
-	static void _pack_int8(Stream& x, int8_t d);
-	static void _pack_int16(Stream& x, int16_t d);
-	static void _pack_int32(Stream& x, int32_t d);
-	static void _pack_int64(Stream& x, int64_t d);
-
-	static void _pack_fix_uint8(Stream& x, uint8_t d);
-	static void _pack_fix_uint16(Stream& x, uint16_t d);
-	static void _pack_fix_uint32(Stream& x, uint32_t d);
-	static void _pack_fix_uint64(Stream& x, uint64_t d);
-	static void _pack_fix_int8(Stream& x, int8_t d);
-	static void _pack_fix_int16(Stream& x, int16_t d);
-	static void _pack_fix_int32(Stream& x, int32_t d);
-	static void _pack_fix_int64(Stream& x, int64_t d);
-
-	static void _pack_char(Stream& x, char d);
-
-	static void _pack_signed_char(Stream& x, signed char d);
-	static void _pack_short(Stream& x, short d);
-	static void _pack_int(Stream& x, int d);
-	static void _pack_long(Stream& x, long d);
-	static void _pack_long_long(Stream& x, long long d);
-	static void _pack_unsigned_char(Stream& x, unsigned char d);
-	static void _pack_unsigned_short(Stream& x, unsigned short d);
-	static void _pack_unsigned_int(Stream& x, unsigned int d);
-	static void _pack_unsigned_long(Stream& x, unsigned long d);
-	static void _pack_unsigned_long_long(Stream& x, unsigned long long d);
-
-	static void _pack_float(Stream& x, float d);
-	static void _pack_double(Stream& x, double d);
-
-	static void _pack_nil(Stream& x);
-	static void _pack_true(Stream& x);
-	static void _pack_false(Stream& x);
-
-	static void _pack_array(Stream& x, size_t n);
-
-	static void _pack_map(Stream& x, size_t n);
-
-	static void _pack_raw(Stream& x, size_t l);
-	static void _pack_raw_body(Stream& x, const void* b, size_t l);
-
-	static void append_buffer(Stream& x, const unsigned char* buf, size_t len)
-		{ x.write((const char*)buf, len); }
-
-private:
-	Stream& m_stream;
-
-private:
-	packer();
-};
-
-
-template <typename Stream, typename T>
-inline void pack(Stream* s, const T& v)
-{
-	packer<Stream>(s).pack(v);
-}
-
-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_inline_func_fixint(name) \
-	template <typename Stream> \
-	inline void packer<Stream>::_pack_fix ## name
-
-#define msgpack_pack_user Stream&
-
-#define msgpack_pack_append_buffer append_buffer
-
-#include "pack_template.h"
-
-
-template <typename Stream>
-packer<Stream>::packer(Stream* s) : m_stream(*s) { }
-
-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(int8_t d)
-{ _pack_int8(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_int16(int16_t d)
-{ _pack_int16(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_int32(int32_t d)
-{ _pack_int32(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_int64(int64_t d)
-{ _pack_int64(m_stream, d); return *this;}
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_fix_uint8(uint8_t d)
-{ _pack_fix_uint8(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_fix_uint16(uint16_t d)
-{ _pack_fix_uint16(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_fix_uint32(uint32_t d)
-{ _pack_fix_uint32(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_fix_uint64(uint64_t d)
-{ _pack_fix_uint64(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_fix_int8(int8_t d)
-{ _pack_fix_int8(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_fix_int16(int16_t d)
-{ _pack_fix_int16(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_fix_int32(int32_t d)
-{ _pack_fix_int32(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_fix_int64(int64_t d)
-{ _pack_fix_int64(m_stream, d); return *this;}
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_char(char d)
-{ _pack_char(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_signed_char(signed char d)
-{ _pack_signed_char(m_stream, d); return *this; }
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_short(short 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_char(unsigned char d)
-{ _pack_unsigned_char(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(size_t n)
-{ _pack_array(m_stream, n); return *this; }
-
-
-template <typename Stream>
-inline packer<Stream>& packer<Stream>::pack_map(size_t 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 */
-

src/msgpack/pack_define.h

@@ -1,26 +0,0 @@
-/*
- * MessagePack unpacking routine template
- *
- * Copyright (C) 2008-2010 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 "msgpack/sysdep.h"
-#include <limits.h>
-#include <string.h>
-
-#endif /* msgpack/pack_define.h */
-

src/msgpack/pack_template.h

@@ -1,793 +0,0 @@
-/*
- * MessagePack packing routine template
- *
- * Copyright (C) 2008-2010 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__)
-#define TAKE8_8(d)  ((uint8_t*)&d)[0]
-#define TAKE8_16(d) ((uint8_t*)&d)[0]
-#define TAKE8_32(d) ((uint8_t*)&d)[0]
-#define TAKE8_64(d) ((uint8_t*)&d)[0]
-#elif defined(__BIG_ENDIAN__)
-#define TAKE8_8(d)  ((uint8_t*)&d)[0]
-#define TAKE8_16(d) ((uint8_t*)&d)[1]
-#define TAKE8_32(d) ((uint8_t*)&d)[3]
-#define TAKE8_64(d) ((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, &TAKE8_8(d), 1); \
-	} else { \
-		/* unsigned 8 */ \
-		unsigned char buf[2] = {0xcc, TAKE8_8(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, &TAKE8_16(d), 1); \
-	} else if(d < (1<<8)) { \
-		/* unsigned 8 */ \
-		unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
-		msgpack_pack_append_buffer(x, buf, 2); \
-	} else { \
-		/* unsigned 16 */ \
-		unsigned char buf[3]; \
-		buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)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, &TAKE8_32(d), 1); \
-		} else { \
-			/* unsigned 8 */ \
-			unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else { \
-		if(d < (1<<16)) { \
-			/* unsigned 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* unsigned 32 */ \
-			unsigned char buf[5]; \
-			buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} \
-	} \
-} while(0)
-
-#define msgpack_pack_real_uint64(x, d) \
-do { \
-	if(d < (1ULL<<8)) { \
-		if(d < (1ULL<<7)) { \
-			/* fixnum */ \
-			msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
-		} else { \
-			/* unsigned 8 */ \
-			unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else { \
-		if(d < (1ULL<<16)) { \
-			/* unsigned 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else if(d < (1ULL<<32)) { \
-			/* unsigned 32 */ \
-			unsigned char buf[5]; \
-			buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} else { \
-			/* unsigned 64 */ \
-			unsigned char buf[9]; \
-			buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
-			msgpack_pack_append_buffer(x, buf, 9); \
-		} \
-	} \
-} while(0)
-
-#define msgpack_pack_real_int8(x, d) \
-do { \
-	if(d < -(1<<5)) { \
-		/* signed 8 */ \
-		unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \
-		msgpack_pack_append_buffer(x, buf, 2); \
-	} else { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
-	} \
-} while(0)
-
-#define msgpack_pack_real_int16(x, d) \
-do { \
-	if(d < -(1<<5)) { \
-		if(d < -(1<<7)) { \
-			/* signed 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* signed 8 */ \
-			unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
-	} else { \
-		if(d < (1<<8)) { \
-			/* unsigned 8 */ \
-			unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} else { \
-			/* unsigned 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)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 */ \
-			unsigned char buf[5]; \
-			buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
-			msgpack_pack_append_buffer(x, buf, 5); \
-		} else if(d < -(1<<7)) { \
-			/* signed 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* signed 8 */ \
-			unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} \
-	} else if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
-	} else { \
-		if(d < (1<<8)) { \
-			/* unsigned 8 */ \
-			unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
-			msgpack_pack_append_buffer(x, buf, 2); \
-		} else if(d < (1<<16)) { \
-			/* unsigned 16 */ \
-			unsigned char buf[3]; \
-			buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-			msgpack_pack_append_buffer(x, buf, 3); \
-		} else { \
-			/* unsigned 32 */ \
-			unsigned char buf[5]; \
-			buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)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 */ \
-				unsigned char buf[9]; \
-				buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \
-				msgpack_pack_append_buffer(x, buf, 9); \
-			} else { \
-				/* signed 32 */ \
-				unsigned char buf[5]; \
-				buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
-				msgpack_pack_append_buffer(x, buf, 5); \
-			} \
-		} else { \
-			if(d < -(1<<7)) { \
-				/* signed 16 */ \
-				unsigned char buf[3]; \
-				buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
-				msgpack_pack_append_buffer(x, buf, 3); \
-			} else { \
-				/* signed 8 */ \
-				unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \
-				msgpack_pack_append_buffer(x, buf, 2); \
-			} \
-		} \
-	} else if(d < (1<<7)) { \
-		/* fixnum */ \
-		msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
-	} else { \
-		if(d < (1LL<<16)) { \
-			if(d < (1<<8)) { \
-				/* unsigned 8 */ \
-				unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
-				msgpack_pack_append_buffer(x, buf, 2); \
-			} else { \
-				/* unsigned 16 */ \
-				unsigned char buf[3]; \
-				buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
-				msgpack_pack_append_buffer(x, buf, 3); \
-			} \
-		} else { \
-			if(d < (1LL<<32)) { \
-				/* unsigned 32 */ \
-				unsigned char buf[5]; \
-				buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
-				msgpack_pack_append_buffer(x, buf, 5); \
-			} else { \
-				/* unsigned 64 */ \
-				unsigned char buf[9]; \
-				buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
-				msgpack_pack_append_buffer(x, buf, 9); \
-			} \
-		} \
-	} \
-} while(0)
-
-
-#ifdef msgpack_pack_inline_func_fixint
-
-msgpack_pack_inline_func_fixint(_uint8)(msgpack_pack_user x, uint8_t d)
-{
-	unsigned char buf[2] = {0xcc, TAKE8_8(d)};
-	msgpack_pack_append_buffer(x, buf, 2);
-}
-
-msgpack_pack_inline_func_fixint(_uint16)(msgpack_pack_user x, uint16_t d)
-{
-	unsigned char buf[3];
-	buf[0] = 0xcd; _msgpack_store16(&buf[1], d);
-	msgpack_pack_append_buffer(x, buf, 3);
-}
-
-msgpack_pack_inline_func_fixint(_uint32)(msgpack_pack_user x, uint32_t d)
-{
-	unsigned char buf[5];
-	buf[0] = 0xce; _msgpack_store32(&buf[1], d);
-	msgpack_pack_append_buffer(x, buf, 5);
-}
-
-msgpack_pack_inline_func_fixint(_uint64)(msgpack_pack_user x, uint64_t d)
-{
-	unsigned char buf[9];
-	buf[0] = 0xcf; _msgpack_store64(&buf[1], d);
-	msgpack_pack_append_buffer(x, buf, 9);
-}
-
-msgpack_pack_inline_func_fixint(_int8)(msgpack_pack_user x, int8_t d)
-{
-	unsigned char buf[2] = {0xd0, TAKE8_8(d)};
-	msgpack_pack_append_buffer(x, buf, 2);
-}
-
-msgpack_pack_inline_func_fixint(_int16)(msgpack_pack_user x, int16_t d)
-{
-	unsigned char buf[3];
-	buf[0] = 0xd1; _msgpack_store16(&buf[1], d);
-	msgpack_pack_append_buffer(x, buf, 3);
-}
-
-msgpack_pack_inline_func_fixint(_int32)(msgpack_pack_user x, int32_t d)
-{
-	unsigned char buf[5];
-	buf[0] = 0xd2; _msgpack_store32(&buf[1], d);
-	msgpack_pack_append_buffer(x, buf, 5);
-}
-
-msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d)
-{
-	unsigned char buf[9];
-	buf[0] = 0xd3; _msgpack_store64(&buf[1], d);
-	msgpack_pack_append_buffer(x, buf, 9);
-}
-
-#undef msgpack_pack_inline_func_fixint
-#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);
-}
-
-msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d)
-{
-#if defined(CHAR_MIN)
-#if CHAR_MIN < 0
-		msgpack_pack_real_int8(x, d);
-#else
-		msgpack_pack_real_uint8(x, d);
-#endif
-#else
-#error CHAR_MIN is not defined
-#endif
-}
-
-msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d)
-{
-	msgpack_pack_real_int8(x, d);
-}
-
-msgpack_pack_inline_func(_unsigned_char)(msgpack_pack_user x, unsigned char d)
-{
-	msgpack_pack_real_uint8(x, d);
-}
-
-#ifdef msgpack_pack_inline_func_cint
-
-msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d)
-{
-#if defined(SIZEOF_SHORT)
-#if SIZEOF_SHORT == 2
-	msgpack_pack_real_int16(x, d);
-#elif SIZEOF_SHORT == 4
-	msgpack_pack_real_int32(x, d);
-#else
-	msgpack_pack_real_int64(x, d);
-#endif
-
-#elif defined(SHRT_MAX)
-#if SHRT_MAX == 0x7fff
-	msgpack_pack_real_int16(x, d);
-#elif 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)
-#if SIZEOF_INT == 2
-	msgpack_pack_real_int16(x, d);
-#elif SIZEOF_INT == 4
-	msgpack_pack_real_int32(x, d);
-#else
-	msgpack_pack_real_int64(x, d);
-#endif
-
-#elif defined(INT_MAX)
-#if INT_MAX == 0x7fff
-	msgpack_pack_real_int16(x, d);
-#elif 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)
-#if SIZEOF_LONG == 2
-	msgpack_pack_real_int16(x, d);
-#elif SIZEOF_LONG == 4
-	msgpack_pack_real_int32(x, d);
-#else
-	msgpack_pack_real_int64(x, d);
-#endif
-
-#elif defined(LONG_MAX)
-#if LONG_MAX == 0x7fffL
-	msgpack_pack_real_int16(x, d);
-#elif 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)
-#if SIZEOF_LONG_LONG == 2
-	msgpack_pack_real_int16(x, d);
-#elif SIZEOF_LONG_LONG == 4
-	msgpack_pack_real_int32(x, d);
-#else
-	msgpack_pack_real_int64(x, d);
-#endif
-
-#elif defined(LLONG_MAX)
-#if LLONG_MAX == 0x7fffL
-	msgpack_pack_real_int16(x, d);
-#elif 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)
-#if SIZEOF_SHORT == 2
-	msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_SHORT == 4
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-
-#elif defined(USHRT_MAX)
-#if USHRT_MAX == 0xffffU
-	msgpack_pack_real_uint16(x, d);
-#elif 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)
-#if SIZEOF_INT == 2
-	msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_INT == 4
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-
-#elif defined(UINT_MAX)
-#if UINT_MAX == 0xffffU
-	msgpack_pack_real_uint16(x, d);
-#elif 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)
-#if SIZEOF_LONG == 2
-	msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_LONG == 4
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-
-#elif defined(ULONG_MAX)
-#if ULONG_MAX == 0xffffUL
-	msgpack_pack_real_uint16(x, d);
-#elif ULONG_MAX == 0xffffffffUL
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-
-#else
-if(sizeof(unsigned long) == 2) {
-	msgpack_pack_real_uint16(x, d);
-} else if(sizeof(unsigned long) == 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)
-#if SIZEOF_LONG_LONG == 2
-	msgpack_pack_real_uint16(x, d);
-#elif SIZEOF_LONG_LONG == 4
-	msgpack_pack_real_uint32(x, d);
-#else
-	msgpack_pack_real_uint64(x, d);
-#endif
-
-#elif defined(ULLONG_MAX)
-#if ULLONG_MAX == 0xffffUL
-	msgpack_pack_real_uint16(x, d);
-#elif 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)
-{
-	unsigned char buf[5];
-	union { float f; uint32_t i; } mem;
-	mem.f = d;
-	buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i);
-	msgpack_pack_append_buffer(x, buf, 5);
-}
-
-msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d)
-{
-	unsigned char buf[9];
-	union { double f; uint64_t i; } mem;
-	mem.f = d;
-	buf[0] = 0xcb;
-#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
-    // https://github.com/msgpack/msgpack-perl/pull/1
-    mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
-#endif
-    _msgpack_store64(&buf[1], mem.i);
-	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, size_t n)
-{
-	if(n < 16) {
-		unsigned char d = 0x90 | (uint8_t)n;
-		msgpack_pack_append_buffer(x, &d, 1);
-	} else if(n < 65536) {
-		unsigned char buf[3];
-		buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n);
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		unsigned char buf[5];
-		buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n);
-		msgpack_pack_append_buffer(x, buf, 5);
-	}
-}
-
-
-/*
- * Map
- */
-
-msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n)
-{
-	if(n < 16) {
-		unsigned char d = 0x80 | (uint8_t)n;
-		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
-	} else if(n < 65536) {
-		unsigned char buf[3];
-		buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n);
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		unsigned char buf[5];
-		buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n);
-		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 | (uint8_t)l;
-		msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
-	} else if(l < 65536) {
-		unsigned char buf[3];
-		buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
-		msgpack_pack_append_buffer(x, buf, 3);
-	} else {
-		unsigned char buf[5];
-		buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l);
-		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 TAKE8_8
-#undef TAKE8_16
-#undef TAKE8_32
-#undef TAKE8_64
-
-#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
-

src/msgpack/sbuffer.h

@@ -1,112 +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>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**
- * @defgroup msgpack_sbuffer Simple buffer
- * @ingroup msgpack_buffer
- * @{
- */
-
-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 msgpack_sbuffer* msgpack_sbuffer_new(void)
-{
-	return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer));
-}
-
-static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf)
-{
-	if(sbuf == NULL) { return; }
-	msgpack_sbuffer_destroy(sbuf);
-	free(sbuf);
-}
-
-#ifndef MSGPACK_SBUFFER_INIT_SIZE
-#define MSGPACK_SBUFFER_INIT_SIZE 8192
-#endif
-
-static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len)
-{
-	msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data;
-
-	if(sbuf->alloc - sbuf->size < len) {
-		void* tmp;
-		size_t nsize = (sbuf->alloc) ?
-				sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
-
-		while(nsize < sbuf->size + len) { nsize *= 2; }
-
-		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;
-}
-
-static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf)
-{
-	sbuf->size = 0;
-}
-
-/** @} */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/sbuffer.h */
-

src/msgpack/sbuffer.hpp

@@ -1,112 +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 "sbuffer.h"
-#include <stdexcept>
-
-namespace msgpack {
-
-
-class sbuffer : public msgpack_sbuffer {
-public:
-	sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE)
-	{
-		if(initsz == 0) {
-			base::data = NULL;
-		} else {
-			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, size_t 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);
-	}
-
-	void clear()
-	{
-		msgpack_sbuffer_clear(this);
-	}
-
-private:
-	void expand_buffer(size_t len)
-	{
-		size_t nsize = (base::alloc > 0) ?
-				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 */
-

src/msgpack/sysdep.h

@@ -1,208 +0,0 @@
-/*
- * MessagePack system dependencies
- *
- * Copyright (C) 2008-2010 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_SYSDEP_H__
-#define MSGPACK_SYSDEP_H__
-
-#include <stdlib.h>
-#include <stddef.h>
-#if defined(_MSC_VER) && _MSC_VER < 1600
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#elif defined(_MSC_VER)  // && _MSC_VER >= 1600
-#include <stdint.h>
-#else
-#include <stdint.h>
-#include <stdbool.h>
-#endif
-
-#ifdef _WIN32
-#define _msgpack_atomic_counter_header <windows.h>
-typedef long _msgpack_atomic_counter_t;
-#define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
-#define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
-#elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
-#define _msgpack_atomic_counter_header "gcc_atomic.h"
-#else
-typedef unsigned int _msgpack_atomic_counter_t;
-#define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1)
-#define _msgpack_sync_incr_and_fetch(ptr) __sync_add_and_fetch(ptr, 1)
-#endif
-
-#ifdef _WIN32
-
-#ifdef __cplusplus
-/* numeric_limits<T>::min,max */
-#ifdef max
-#undef max
-#endif
-#ifdef min
-#undef min
-#endif
-#endif
-
-#else
-#include <arpa/inet.h>  /* __BYTE_ORDER */
-#endif
-
-#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __LITTLE_ENDIAN__
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define __BIG_ENDIAN__
-#elif _WIN32
-#define __LITTLE_ENDIAN__
-#endif
-#endif
-
-
-#ifdef __LITTLE_ENDIAN__
-
-#ifdef _WIN32
-#  if defined(ntohs)
-#    define _msgpack_be16(x) ntohs(x)
-#  elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400)
-#    define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x))
-#  else
-#    define _msgpack_be16(x) ( \
-        ((((uint16_t)x) <<  8) ) | \
-        ((((uint16_t)x) >>  8) ) )
-#  endif
-#else
-#  define _msgpack_be16(x) ntohs(x)
-#endif
-
-#ifdef _WIN32
-#  if defined(ntohl)
-#    define _msgpack_be32(x) ntohl(x)
-#  elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400)
-#    define _msgpack_be32(x) ((uint32_t)_byteswap_ulong((unsigned long)x))
-#  else
-#    define _msgpack_be32(x) \
-        ( ((((uint32_t)x) << 24)               ) | \
-          ((((uint32_t)x) <<  8) & 0x00ff0000U ) | \
-          ((((uint32_t)x) >>  8) & 0x0000ff00U ) | \
-          ((((uint32_t)x) >> 24)               ) )
-#  endif
-#else
-#  define _msgpack_be32(x) ntohl(x)
-#endif
-
-#if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400)
-#  define _msgpack_be64(x) (_byteswap_uint64(x))
-#elif defined(bswap_64)
-#  define _msgpack_be64(x) bswap_64(x)
-#elif defined(__DARWIN_OSSwapInt64)
-#  define _msgpack_be64(x) __DARWIN_OSSwapInt64(x)
-#else
-#define _msgpack_be64(x) \
-    ( ((((uint64_t)x) << 56)                         ) | \
-      ((((uint64_t)x) << 40) & 0x00ff000000000000ULL ) | \
-      ((((uint64_t)x) << 24) & 0x0000ff0000000000ULL ) | \
-      ((((uint64_t)x) <<  8) & 0x000000ff00000000ULL ) | \
-      ((((uint64_t)x) >>  8) & 0x00000000ff000000ULL ) | \
-      ((((uint64_t)x) >> 24) & 0x0000000000ff0000ULL ) | \
-      ((((uint64_t)x) >> 40) & 0x000000000000ff00ULL ) | \
-      ((((uint64_t)x) >> 56)                         ) )
-#endif
-
-#define _msgpack_load16(cast, from) ((cast)( \
-        (((uint16_t)((uint8_t*)(from))[0]) << 8) | \
-        (((uint16_t)((uint8_t*)(from))[1])     ) ))
-
-#define _msgpack_load32(cast, from) ((cast)( \
-        (((uint32_t)((uint8_t*)(from))[0]) << 24) | \
-        (((uint32_t)((uint8_t*)(from))[1]) << 16) | \
-        (((uint32_t)((uint8_t*)(from))[2]) <<  8) | \
-        (((uint32_t)((uint8_t*)(from))[3])      ) ))
-
-#define _msgpack_load64(cast, from) ((cast)( \
-        (((uint64_t)((uint8_t*)(from))[0]) << 56) | \
-        (((uint64_t)((uint8_t*)(from))[1]) << 48) | \
-        (((uint64_t)((uint8_t*)(from))[2]) << 40) | \
-        (((uint64_t)((uint8_t*)(from))[3]) << 32) | \
-        (((uint64_t)((uint8_t*)(from))[4]) << 24) | \
-        (((uint64_t)((uint8_t*)(from))[5]) << 16) | \
-        (((uint64_t)((uint8_t*)(from))[6]) << 8)  | \
-        (((uint64_t)((uint8_t*)(from))[7])     )  ))
-
-#else
-
-#define _msgpack_be16(x) (x)
-#define _msgpack_be32(x) (x)
-#define _msgpack_be64(x) (x)
-
-#define _msgpack_load16(cast, from) ((cast)( \
-        (((uint16_t)((uint8_t*)from)[0]) << 8) | \
-        (((uint16_t)((uint8_t*)from)[1])     ) ))
-
-#define _msgpack_load32(cast, from) ((cast)( \
-        (((uint32_t)((uint8_t*)from)[0]) << 24) | \
-        (((uint32_t)((uint8_t*)from)[1]) << 16) | \
-        (((uint32_t)((uint8_t*)from)[2]) <<  8) | \
-        (((uint32_t)((uint8_t*)from)[3])      ) ))
-
-#define _msgpack_load64(cast, from) ((cast)( \
-        (((uint64_t)((uint8_t*)from)[0]) << 56) | \
-        (((uint64_t)((uint8_t*)from)[1]) << 48) | \
-        (((uint64_t)((uint8_t*)from)[2]) << 40) | \
-        (((uint64_t)((uint8_t*)from)[3]) << 32) | \
-        (((uint64_t)((uint8_t*)from)[4]) << 24) | \
-        (((uint64_t)((uint8_t*)from)[5]) << 16) | \
-        (((uint64_t)((uint8_t*)from)[6]) << 8)  | \
-        (((uint64_t)((uint8_t*)from)[7])     )  ))
-#endif
-
-
-#define _msgpack_store16(to, num) \
-    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
-#define _msgpack_store32(to, num) \
-    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
-#define _msgpack_store64(to, num) \
-    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
-
-/*
-#define _msgpack_load16(cast, from) \
-    ({ cast val; memcpy(&val, (char*)from, 2); _msgpack_be16(val); })
-#define _msgpack_load32(cast, from) \
-    ({ cast val; memcpy(&val, (char*)from, 4); _msgpack_be32(val); })
-#define _msgpack_load64(cast, from) \
-    ({ cast val; memcpy(&val, (char*)from, 8); _msgpack_be64(val); })
-*/
-
-
-#if !defined(__cplusplus) && defined(_MSC_VER)
-#if !defined(FALSE)
-#define FALSE (0)
-#endif
-#if !defined(TRUE)
-#define TRUE (!FALSE)
-#endif
-#define bool int
-#define true TRUE
-#define false FALSE
-#define inline __inline
-#endif
-
-#endif /* msgpack/sysdep.h */
-

src/msgpack/type.hpp

@@ -1,17 +0,0 @@
-#include "type/bool.hpp"
-#include "type/deque.hpp"
-#include "type/fixint.hpp"
-#include "type/float.hpp"
-#include "type/int.hpp"
-#include "type/list.hpp"
-#include "type/map.hpp"
-#include "type/nil.hpp"
-#include "type/pair.hpp"
-#include "type/raw.hpp"
-#include "type/set.hpp"
-#include "type/string.hpp"
-#include "type/vector.hpp"
-#include "type/tuple.hpp"
-#include "type/define.hpp"
-#include "type/tr1/unordered_map.hpp"
-#include "type/tr1/unordered_set.hpp"

src/msgpack/type/bool.hpp

@@ -1,55 +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_BOOL_HPP__
-#define MSGPACK_TYPE_BOOL_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;
-}
-
-inline void operator<< (object& o, bool v)
-{
-	o.type = type::BOOLEAN;
-	o.via.boolean = v;
-}
-
-inline void operator<< (object::with_zone& o, bool v)
-	{ static_cast<object&>(o) << v; }
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/bool.hpp */
-

src/msgpack/type/define.hpp.erb

@@ -1,148 +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_DEFINE_HPP__
-#define MSGPACK_TYPE_DEFINE_HPP__
-
-#define MSGPACK_DEFINE(...) \
-	template <typename Packer> \
-	void msgpack_pack(Packer& pk) const \
-	{ \
-		msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \
-	} \
-	void msgpack_unpack(msgpack::object o) \
-	{ \
-		msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \
-	}\
-	template <typename MSGPACK_OBJECT> \
-	void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \
-	{ \
-		msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \
-	}
-
-// MSGPACK_ADD_ENUM must be used in the global namespace.
-#define MSGPACK_ADD_ENUM(enum) \
-  namespace msgpack { \
-    template <> \
-    inline enum& operator>> (object o, enum& v) \
-    { \
-      int tmp; \
-      o >> tmp; \
-      v = static_cast<enum>(tmp); \
-      return v; \
-    } \
-    template <> \
-    inline void operator<< (object::with_zone& o, const enum& v) \
-    { \
-      o << static_cast<int>(v); \
-    } \
-    namespace detail { \
-      template <typename Stream> \
-      struct packer_serializer<Stream, enum> { \
-        static packer<Stream>& pack(packer<Stream>& o, const enum& v) { \
-          return o << static_cast<int>(v); \
-        } \
-      }; \
-    } \
-  }
-
-namespace msgpack {
-namespace type {
-
-
-<% GENERATION_LIMIT = 31 %>
-template <typename A0 = void<%1.upto(GENERATION_LIMIT+1) {|i|%>, typename A<%=i%> = void<%}%>>
-struct define;
-
-
-template <>
-struct define<> {
-	typedef define<> value_type;
-	typedef tuple<> tuple_type;
-	template <typename Packer>
-	void msgpack_pack(Packer& pk) const
-	{
-		pk.pack_array(0);
-	}
-	void msgpack_unpack(msgpack::object o)
-	{
-		if(o.type != type::ARRAY) { throw type_error(); }
-	}
-	void msgpack_object(msgpack::object* o, msgpack::zone* z) const
-	{
-		o->type = type::ARRAY;
-		o->via.array.ptr = NULL;
-		o->via.array.size = 0;
-	}
-};
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
-	typedef define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
-	typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> tuple_type;
-	define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) :
-		a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
-	template <typename Packer>
-	void msgpack_pack(Packer& pk) const
-	{
-		pk.pack_array(<%=i+1%>);
-		<%0.upto(i) {|j|%>
-		pk.pack(a<%=j%>);<%}%>
-	}
-	void msgpack_unpack(msgpack::object o)
-	{
-		if(o.type != type::ARRAY) { throw type_error(); }
-		const size_t size = o.via.array.size;
-		if(size > 0) {
-			msgpack::object *ptr = o.via.array.ptr;
-			switch(size) {
-			default:<%(i).downto(0) {|j|%>
-			case <%=j+1%>: ptr[<%=j%>].convert(&a<%=j%>);<%}%>
-			}
-		}
-	}
-	void msgpack_object(msgpack::object* o, msgpack::zone* z) const
-	{
-		o->type = type::ARRAY;
-		o->via.array.ptr = (object*)z->malloc(sizeof(object)*<%=i+1%>);
-		o->via.array.size = <%=i+1%>;
-		<%0.upto(i) {|j|%>
-		o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%>
-	}
-	<%0.upto(i) {|j|%>
-	A<%=j%>& a<%=j%>;<%}%>
-};
-<%}%>
-
-inline define<> make_define()
-{
-	return define<>();
-}
-<%0.upto(GENERATION_LIMIT) {|i|%>
-template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>)
-{
-	return define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
-}
-<%}%>
-
-}  // namespace type
-}  // namespace msgpack
-
-
-#endif /* msgpack/type/define.hpp */
-

src/msgpack/type/deque.hpp

@@ -1,77 +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_DEQUE_HPP__
-#define MSGPACK_TYPE_DEQUE_HPP__
-
-#include "msgpack/object.hpp"
-#include <deque>
-
-namespace msgpack {
-
-
-template <typename T>
-inline std::deque<T>& operator>> (object o, std::deque<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;
-	typename std::deque<T>::iterator it = v.begin();
-	for(; p < pend; ++p, ++it) {
-		p->convert(&*it);
-	}
-	return v;
-}
-
-template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::deque<T>& v)
-{
-	o.pack_array(v.size());
-	for(typename std::deque<T>::const_iterator it(v.begin()), it_end(v.end());
-			it != it_end; ++it) {
-		o.pack(*it);
-	}
-	return o;
-}
-
-template <typename T>
-inline void operator<< (object::with_zone& o, const std::deque<T>& v)
-{
-	o.type = type::ARRAY;
-	if(v.empty()) {
-		o.via.array.ptr = NULL;
-		o.via.array.size = 0;
-	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
-		object* const pend = p + v.size();
-		o.via.array.ptr = p;
-		o.via.array.size = v.size();
-		typename std::deque<T>::const_iterator it(v.begin());
-		do {
-			*p = object(*it, o.zone);
-			++p;
-			++it;
-		} while(p < pend);
-	}
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/deque.hpp */
-

src/msgpack/type/fixint.hpp

@@ -1,217 +0,0 @@
-//
-// MessagePack for C++ static resolution routine
-//
-// Copyright (C) 2020 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_FIXINT_HPP__
-#define MSGPACK_TYPE_FIXINT_HPP__
-
-#include "msgpack/object.hpp"
-#include "msgpack/type/int.hpp"
-
-namespace msgpack {
-
-namespace type {
-
-
-template <typename T>
-struct fix_int {
-	fix_int() : value(0) { }
-	fix_int(T value) : value(value) { }
-
-	operator T() const { return value; }
-
-	T get() const { return value; }
-
-private:
-	T value;
-};
-
-
-typedef fix_int<uint8_t>  fix_uint8;
-typedef fix_int<uint16_t> fix_uint16;
-typedef fix_int<uint32_t> fix_uint32;
-typedef fix_int<uint64_t> fix_uint64;
-
-typedef fix_int<int8_t>  fix_int8;
-typedef fix_int<int16_t> fix_int16;
-typedef fix_int<int32_t> fix_int32;
-typedef fix_int<int64_t> fix_int64;
-
-
-}  // namespace type
-
-
-inline type::fix_int8& operator>> (object o, type::fix_int8& v)
-	{ v = type::detail::convert_integer<int8_t>(o); return v; }
-
-inline type::fix_int16& operator>> (object o, type::fix_int16& v)
-	{ v = type::detail::convert_integer<int16_t>(o); return v; }
-
-inline type::fix_int32& operator>> (object o, type::fix_int32& v)
-	{ v = type::detail::convert_integer<int32_t>(o); return v; }
-
-inline type::fix_int64& operator>> (object o, type::fix_int64& v)
-	{ v = type::detail::convert_integer<int64_t>(o); return v; }
-
-
-inline type::fix_uint8& operator>> (object o, type::fix_uint8& v)
-	{ v = type::detail::convert_integer<uint8_t>(o); return v; }
-
-inline type::fix_uint16& operator>> (object o, type::fix_uint16& v)
-	{ v = type::detail::convert_integer<uint16_t>(o); return v; }
-
-inline type::fix_uint32& operator>> (object o, type::fix_uint32& v)
-	{ v = type::detail::convert_integer<uint32_t>(o); return v; }
-
-inline type::fix_uint64& operator>> (object o, type::fix_uint64& v)
-	{ v = type::detail::convert_integer<uint64_t>(o); return v; }
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::fix_int8& v)
-	{ o.pack_fix_int8(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::fix_int16& v)
-	{ o.pack_fix_int16(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::fix_int32& v)
-	{ o.pack_fix_int32(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::fix_int64& v)
-	{ o.pack_fix_int64(v); return o; }
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::fix_uint8& v)
-	{ o.pack_fix_uint8(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::fix_uint16& v)
-	{ o.pack_fix_uint16(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::fix_uint32& v)
-	{ o.pack_fix_uint32(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const type::fix_uint64& v)
-	{ o.pack_fix_uint64(v); return o; }
-
-
-inline void operator<< (object& o, type::fix_int8 v)
-	{ 
-	    if ( v.get() < 0 ) 
-	    {
-		o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v.get() ;
-	    }
-	    else
-	    {
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v.get() ; 
-	    }
-	}
-
-inline void operator<< (object& o, type::fix_int16 v)
-	{
-	    if ( v.get() < 0 )
-	    {
-		o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v.get() ;
-	    }
-            else
-	    { 
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v.get() ;
-	    }
-	}
-
-inline void operator<< (object& o, type::fix_int32 v)
-	{
-	    if ( v.get() < 0 )
-	    {
-	        o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v.get() ;
-	    }
-	    else
-	    {
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v.get() ;
-	    }
-	}
-
-inline void operator<< (object& o, type::fix_int64 v)
-	{
-	    if( v.get() < 0 )
-	    {
-		o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v.get() ;
-	    }
-	    else
-	    {
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v.get() ;
-	    }
-	}
-
-
-
-inline void operator<< (object& o, type::fix_uint8 v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-
-inline void operator<< (object& o, type::fix_uint16 v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-
-inline void operator<< (object& o, type::fix_uint32 v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-
-inline void operator<< (object& o, type::fix_uint64 v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); }
-
-
-inline void operator<< (object::with_zone& o, type::fix_int8 v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, type::fix_int16 v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, type::fix_int32 v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, type::fix_int64 v)
-	{ static_cast<object&>(o) << v; }
-
-
-inline void operator<< (object::with_zone& o, type::fix_uint8 v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, type::fix_uint16 v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, type::fix_uint32 v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, type::fix_uint64 v)
-	{ static_cast<object&>(o) << v; }
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/fixint.hpp */
-

src/msgpack/type/float.hpp

@@ -1,102 +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) {
-		v = (float)o.via.dec;
-	}
-	else if (o.type == type::POSITIVE_INTEGER) {
-		v = (float)o.via.u64;
-	}
-	else if (o.type == type::NEGATIVE_INTEGER) {
-		v = (float)o.via.i64;
-	}
-	else {
-		throw type_error();
-	}
-	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) {
-		v = o.via.dec;
-	}
-	else if (o.type == type::POSITIVE_INTEGER) {
-		v = (double)o.via.u64;
-	}
-	else if (o.type == type::NEGATIVE_INTEGER) {
-		v = (double)o.via.i64;
-	}
-	else {
-		throw type_error();
-	}
-	return v;
-}
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, const double& v)
-{
-	o.pack_double(v);
-	return o;
-}
-
-
-inline void operator<< (object& o, float v)
-{
-	o.type = type::DOUBLE;
-	o.via.dec = (double)v;
-}
-
-inline void operator<< (object& o, double v)
-{
-	o.type = type::DOUBLE;
-	o.via.dec = v;
-}
-
-inline void operator<< (object::with_zone& o, float v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, double v)
-	{ static_cast<object&>(o) << v; }
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/float.hpp */
-

src/msgpack/type/int.hpp

@@ -1,339 +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_INT_HPP__
-#define MSGPACK_TYPE_INT_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 (T)o.via.u64;
-			} else if(o.type == type::NEGATIVE_INTEGER) {
-				if(o.via.i64 < (int64_t)std::numeric_limits<T>::min())
-					{ throw type_error(); }
-				return (T)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 (T)o.via.u64;
-			}
-			throw type_error();
-		}
-	};
-
-	template <typename T>
-	struct is_signed {
-		static const bool value = std::numeric_limits<T>::is_signed;
-	};
-
-	template <typename T>
-	static inline T convert_integer(object o)
-	{
-		return detail::convert_integer_sign<T, is_signed<T>::value>::convert(o);
-	}
-
-	template <bool Signed>
-	struct pack_char_sign;
-
-	template <>
-	struct pack_char_sign<true> {
-		template <typename Stream>
-		static inline packer<Stream>& pack(packer<Stream>& o, char v) {
-			o.pack_int8(v); return o;
-		}
-	};
-
-	template <>
-	struct pack_char_sign<false> {
-		template <typename Stream>
-		static inline packer<Stream>& pack(packer<Stream>& o, char v) {
-			o.pack_uint8(v); return o;
-		}
-	};
-
-	template <typename Stream>
-	static inline packer<Stream>& pack_char(packer<Stream>& o, char v) {
-		return pack_char_sign<is_signed<char>::value>::pack(o, v);
-	}
-
-	template <bool Signed>
-	struct object_char_sign;
-
-	template <>
-	struct object_char_sign<true> {
-		static inline void make(object& o, char v) {
-			if( v < 0 )
-			{
-			    o.type = type::NEGATIVE_INTEGER ;
-			    o.via.i64 = v ;
-			}
-			else
-			{
-			    o.type = type::POSITIVE_INTEGER ;
-			    o.via.u64 = v ;
-			}
-		}
-	};
-
-	template <>
-	struct object_char_sign<false> {
-		static inline void make(object& o, char v) {
-			o.type = type::POSITIVE_INTEGER, o.via.u64 = v;
-		}
-	};
-
-	static inline void object_char(object& o, char v) {
-		return object_char_sign<is_signed<char>::value>::make(o, v);
-	}
-
-}  // namespace detail
-}  // namespace type
-
-inline char& operator>> (object const& o, char& v)
-	{ v = type::detail::convert_integer<char>(o); return v; }
-
-
-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, char v)
-	{ return type::detail::pack_char(o, v); }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, signed char v)
-	{ o.pack_int8(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, signed short v)
-	{ o.pack_short(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, signed int v)
-	{ o.pack_int(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, signed long v)
-	{ o.pack_long(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, signed long long v)
-	{ o.pack_long_long(v); return o; }
-
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, unsigned char v)
-	{ o.pack_uint8(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, unsigned short v)
-	{ o.pack_unsigned_short(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, unsigned int v)
-	{ o.pack_unsigned_int(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, unsigned long v)
-	{ o.pack_unsigned_long(v); return o; }
-
-template <typename Stream>
-inline packer<Stream>& operator<< (packer<Stream>& o, unsigned long long v)
-	{ o.pack_unsigned_long_long(v); return o; }
-
-
-inline void operator<< (object& o, char v)
-	{ type::detail::object_char(o, v); }
-
-
-inline void operator<< (object& o, signed char v)
-	{
-	    if( v < 0 )
-	    {
-		o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v;
-	    }
-            else
-            {
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v ;
-	    }
-	}
-
-inline void operator<< (object& o, signed short v)
-	{
-	    if(v < 0 )
-	    {
-	        o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v ;
-	    }
-            else
-            {
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v;
-	    }
-	}
-
-inline void operator<< (object& o, signed int v)
-	{
-	    if( v < 0 )	
-	    {
-		o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v ;
-	    }
-	    else
-	    {
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v ;
-	    }
-	}
-
-inline void operator<< (object& o, signed long v)
-	{
-	    if( v < 0 )
-	    {
-		o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v ;
-	    }
-	    else
-	    {
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v ;
-	    }
-	}
-
-inline void operator<< (object& o, signed long long v)
-	{
-	    if( v < 0 )
-	    {
-		o.type = type::NEGATIVE_INTEGER ;
-		o.via.i64 = v ;
-	    }
-	    else
-	    {
-		o.type = type::POSITIVE_INTEGER ;
-		o.via.u64 = v ;
-	    }
-	}
-
-
-inline void operator<< (object& o, unsigned char v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-inline void operator<< (object& o, unsigned short v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-inline void operator<< (object& o, unsigned int v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-inline void operator<< (object& o, unsigned long v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-inline void operator<< (object& o, unsigned long long v)
-	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
-
-
-inline void operator<< (object::with_zone& o, char v)
-	{ static_cast<object&>(o) << v; }
-
-
-inline void operator<< (object::with_zone& o, signed char v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, signed short v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, signed int v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, signed long v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, const signed long long& v)
-	{ static_cast<object&>(o) << v; }
-
-
-inline void operator<< (object::with_zone& o, unsigned char v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, unsigned short v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, unsigned int v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, unsigned long v)
-	{ static_cast<object&>(o) << v; }
-
-inline void operator<< (object::with_zone& o, const unsigned long long& v)
-	{ static_cast<object&>(o) << v; }
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/int.hpp */
-

src/msgpack/type/list.hpp

@@ -1,77 +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_LIST_HPP__
-#define MSGPACK_TYPE_LIST_HPP__
-
-#include "msgpack/object.hpp"
-#include <list>
-
-namespace msgpack {
-
-
-template <typename T>
-inline std::list<T>& operator>> (object o, std::list<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;
-	typename std::list<T>::iterator it = v.begin();
-	for(; p < pend; ++p, ++it) {
-		p->convert(&*it);
-	}
-	return v;
-}
-
-template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::list<T>& v)
-{
-	o.pack_array(v.size());
-	for(typename std::list<T>::const_iterator it(v.begin()), it_end(v.end());
-			it != it_end; ++it) {
-		o.pack(*it);
-	}
-	return o;
-}
-
-template <typename T>
-inline void operator<< (object::with_zone& o, const std::list<T>& v)
-{
-	o.type = type::ARRAY;
-	if(v.empty()) {
-		o.via.array.ptr = NULL;
-		o.via.array.size = 0;
-	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
-		object* const pend = p + v.size();
-		o.via.array.ptr = p;
-		o.via.array.size = v.size();
-		typename std::list<T>::const_iterator it(v.begin());
-		do {
-			*p = object(*it, o.zone);
-			++p;
-			++it;
-		} while(p < pend);
-	}
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/list.hpp */
-

src/msgpack/type/map.hpp

@@ -1,205 +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 void operator<< (object::with_zone& o, const type::assoc_vector<K,V>& v)
-{
-	o.type = type::MAP;
-	if(v.empty()) {
-		o.via.map.ptr  = NULL;
-		o.via.map.size = 0;
-	} else {
-		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
-		object_kv* const pend = p + v.size();
-		o.via.map.ptr  = p;
-		o.via.map.size = v.size();
-		typename type::assoc_vector<K,V>::const_iterator it(v.begin());
-		do {
-			p->key = object(it->first, o.zone);
-			p->val = object(it->second, o.zone);
-			++p;
-			++it;
-		} while(p < pend);
-	}
-}
-
-
-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 void operator<< (object::with_zone& o, const std::map<K,V>& v)
-{
-	o.type = type::MAP;
-	if(v.empty()) {
-		o.via.map.ptr  = NULL;
-		o.via.map.size = 0;
-	} else {
-		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
-		object_kv* const pend = p + v.size();
-		o.via.map.ptr  = p;
-		o.via.map.size = v.size();
-		typename std::map<K,V>::const_iterator it(v.begin());
-		do {
-			p->key = object(it->first, o.zone);
-			p->val = object(it->second, o.zone);
-			++p;
-			++it;
-		} while(p < pend);
-	}
-}
-
-
-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;
-}
-
-template <typename K, typename V>
-inline void operator<< (object::with_zone& o, const std::multimap<K,V>& v)
-{
-	o.type = type::MAP;
-	if(v.empty()) {
-		o.via.map.ptr  = NULL;
-		o.via.map.size = 0;
-	} else {
-		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
-		object_kv* const pend = p + v.size();
-		o.via.map.ptr  = p;
-		o.via.map.size = v.size();
-		typename std::multimap<K,V>::const_iterator it(v.begin());
-		do {
-			p->key = object(it->first, o.zone);
-			p->val = object(it->second, o.zone);
-			++p;
-			++it;
-		} while(p < pend);
-	}
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/map.hpp */
-

src/msgpack/type/nil.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_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;
-}
-
-inline void operator<< (object& o, type::nil v)
-{
-	o.type = type::NIL;
-}
-
-inline void operator<< (object::with_zone& o, type::nil v)
-	{ static_cast<object&>(o) << v; }
-
-
-template <>
-inline void object::as<void>() const
-{
-	msgpack::type::nil v;
-	convert(&v);
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/nil.hpp */
-

src/msgpack/type/pair.hpp

@@ -1,61 +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_PAIR_HPP__
-#define MSGPACK_TYPE_PAIR_HPP__
-
-#include "msgpack/object.hpp"
-#include <utility>
-
-namespace msgpack {
-
-
-template <typename T1, typename T2>
-inline std::pair<T1, T2>& operator>> (object o, std::pair<T1, T2>& v)
-{
-	if(o.type != type::ARRAY) { throw type_error(); }
-	if(o.via.array.size != 2) { throw type_error(); }
-	o.via.array.ptr[0].convert(&v.first);
-	o.via.array.ptr[1].convert(&v.second);
-	return v;
-}
-
-template <typename Stream, typename T1, typename T2>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::pair<T1, T2>& v)
-{
-	o.pack_array(2);
-	o.pack(v.first);
-	o.pack(v.second);
-	return o;
-}
-
-template <typename T1, typename T2>
-inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
-{
-	o.type = type::ARRAY;
-	object* p = (object*)o.zone->malloc(sizeof(object)*2);
-	o.via.array.ptr = p;
-	o.via.array.size = 2;
-	p[0] = object(v.first, o.zone);
-	p[1] = object(v.second, o.zone);
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/pair.hpp */
-

src/msgpack/type/raw.hpp

@@ -1,94 +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() const { return std::string(ptr, size); }
-
-	bool operator== (const raw_ref& x) const
-	{
-		return size == x.size && memcmp(ptr, x.ptr, size) == 0;
-	}
-
-	bool operator!= (const raw_ref& x) const
-	{
-		return !(*this != x);
-	}
-
-	bool operator< (const raw_ref& x) const
-	{
-		if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; }
-		else { return size < x.size; }
-	}
-
-	bool operator> (const raw_ref& x) const
-	{
-		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;
-}
-
-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;
-}
-
-inline void operator<< (object& o, const type::raw_ref& v)
-{
-	o.type = type::RAW;
-	o.via.raw.ptr = v.ptr;
-	o.via.raw.size = v.size;
-}
-
-inline void operator<< (object::with_zone& o, const type::raw_ref& v)
-	{ static_cast<object&>(o) << v; }
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/raw.hpp */
-

src/msgpack/type/set.hpp

@@ -1,122 +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_SET_HPP__
-#define MSGPACK_TYPE_SET_HPP__
-
-#include "msgpack/object.hpp"
-#include <set>
-
-namespace msgpack {
-
-
-template <typename T>
-inline std::set<T>& operator>> (object o, std::set<T>& v)
-{
-	if(o.type != type::ARRAY) { throw type_error(); }
-	object* p = o.via.array.ptr + o.via.array.size;
-	object* const pbegin = o.via.array.ptr;
-	while(p > pbegin) {
-		--p;
-		v.insert(p->as<T>());
-	}
-	return v;
-}
-
-template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::set<T>& v)
-{
-	o.pack_array(v.size());
-	for(typename std::set<T>::const_iterator it(v.begin()), it_end(v.end());
-			it != it_end; ++it) {
-		o.pack(*it);
-	}
-	return o;
-}
-
-template <typename T>
-inline void operator<< (object::with_zone& o, const std::set<T>& v)
-{
-	o.type = type::ARRAY;
-	if(v.empty()) {
-		o.via.array.ptr = NULL;
-		o.via.array.size = 0;
-	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
-		object* const pend = p + v.size();
-		o.via.array.ptr = p;
-		o.via.array.size = v.size();
-		typename std::set<T>::const_iterator it(v.begin());
-		do {
-			*p = object(*it, o.zone);
-			++p;
-			++it;
-		} while(p < pend);
-	}
-}
-
-
-template <typename T>
-inline std::multiset<T>& operator>> (object o, std::multiset<T>& v)
-{
-	if(o.type != type::ARRAY) { throw type_error(); }
-	object* p = o.via.array.ptr + o.via.array.size;
-	object* const pbegin = o.via.array.ptr;
-	while(p > pbegin) {
-		--p;
-		v.insert(p->as<T>());
-	}
-	return v;
-}
-
-template <typename Stream, typename T>
-inline packer<Stream>& operator<< (packer<Stream>& o, const std::multiset<T>& v)
-{
-	o.pack_array(v.size());
-	for(typename std::multiset<T>::const_iterator it(v.begin()), it_end(v.end());
-			it != it_end; ++it) {
-		o.pack(*it);
-	}
-	return o;
-}
-
-template <typename T>
-inline void operator<< (object::with_zone& o, const std::multiset<T>& v)
-{
-	o.type = type::ARRAY;
-	if(v.empty()) {
-		o.via.array.ptr = NULL;
-		o.via.array.size = 0;
-	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
-		object* const pend = p + v.size();
-		o.via.array.ptr = p;
-		o.via.array.size = v.size();
-		typename std::multiset<T>::const_iterator it(v.begin());
-		do {
-			*p = object(*it, o.zone);
-			++p;
-			++it;
-		} while(p < pend);
-	}
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/set.hpp */
-

src/msgpack/type/string.hpp

@@ -1,62 +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_STRING_HPP__
-#define MSGPACK_TYPE_STRING_HPP__
-
-#include "msgpack/object.hpp"
-#include <string>
-
-namespace msgpack {
-
-
-inline std::string& operator>> (object o, std::string& v)
-{
-	if(o.type != type::RAW) { throw type_error(); }
-	v.assign(o.via.raw.ptr, o.via.raw.size);
-	return v;
-}
-
-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;
-}
-
-inline void operator<< (object::with_zone& o, const std::string& v)
-{
-	o.type = type::RAW;
-	char* ptr = (char*)o.zone->malloc(v.size());
-	o.via.raw.ptr = ptr;
-	o.via.raw.size = (uint32_t)v.size();
-	memcpy(ptr, v.data(), v.size());
-}
-
-inline void operator<< (object& o, const std::string& v)
-{
-	o.type = type::RAW;
-	o.via.raw.ptr = v.data();
-	o.via.raw.size = (uint32_t)v.size();
-}
-
-
-}  // namespace msgpack
-
-#endif /* msgpack/type/string.hpp */
-