Merge pull request #1008 from redboltz/upd_411

Update version to 4.1.1.

.github/depends/boost.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+
+usage()
+{
+  cat <<EOL
+  -b   - 32-bit or 64-bit library, maybe 32, 64 or both
+  -t   - the toolset, maybe gcc, clang or both
+  -p   - installation prefix
+EOL
+}
+
+build_boost()
+{
+  ./b2 \
+      --toolset=$1 \
+      --prefix=$3/$2 \
+      --with-test \
+      --with-headers \
+      --with-chrono \
+      --with-context \
+      --with-filesystem \
+      --with-system \
+      --with-timer \
+      address-model=$2 \
+      install || exit 1
+}
+
+bit="64"
+toolset="gcc"
+prefix="$HOME/boost-prefix"
+
+while getopts "b:t:p:" c; do
+  case "$c" in
+    b)
+      bit="$OPTARG"
+      [ "$bit" != "32" ] && [ "$bit" != "64" ] && [ "$bit" != "both" ] && usage && exit 1
+      ;;
+    t)
+      toolset="$OPTARG"
+      [ "$toolset" != "gcc" ] && [ "$toolset" != "clang" ] && [ "$toolset" != "both" ] && usage && exit 1
+      ;;
+    p)
+      prefix="$OPTARG"
+      ;;
+    ?*)
+      echo "invalid arguments." && exit 1
+      ;;
+  esac
+done
+
+mkdir $prefix || exit 1
+wget https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.tar.bz2 || exit 1
+tar xf boost_1_76_0.tar.bz2 || exit 1
+cd boost_1_76_0
+./bootstrap.sh || exit 1
+
+build()
+{
+  if [ "$bit" = "both" ]; then
+    build_boost $1 32 $prefix
+    build_boost $1 64 $prefix
+  else
+    build_boost $1 $bit $prefix
+  fi
+}
+
+if [ "$toolset" = "both" ]; then
+  build gcc
+  build clang
+else
+  build $toolset
+fi

.github/depends/zlib.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+usage()
+{
+  cat <<EOL
+  -b   - 32-bit or 64-bit library, maybe 32 or 64
+  -p   - installation prefix
+EOL
+}
+
+bit="64"
+prefix="$HOME/zlib-prefix"
+
+while getopts "b:t:p:" c; do
+  case "$c" in
+    b)
+      bit="$OPTARG"
+      [ "$bit" != "32" ] && [ "$bit" != "64" ] && [ "$bit" != "both" ] && usage && exit 1
+      ;;
+    p)
+      prefix="$OPTARG"
+      ;;
+    ?*)
+      echo "invalid arguments." && exit 1
+      ;;
+  esac
+done
+
+mkdir $prefix || exit 1
+wget https://zlib.net/zlib-1.2.11.tar.gz || exit 1
+tar -xf zlib-1.2.11.tar.gz || exit 1
+cd zlib-1.2.11
+
+build()
+{
+  cmake \
+    -D CMAKE_BUILD_TYPE=Release \
+    -D CMAKE_INSTALL_PREFIX=$2/$1 \
+    -D CMAKE_C_FLAGS="-m$1" \
+    -D CMAKE_SHARED_LINKER_FLAGS="-m$1" \
+    -B build$1 \
+    -S .
+  cmake --build build$1 --target install
+}
+
+if [ "$bit" = "both" ]; then
+  build 32 $prefix
+  build 64 $prefix
+else
+  build $bit $prefix
+fi

.github/workflows/coverage.yml

@@ -0,0 +1,73 @@
+name: coverage
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+    - cpp_master
+    tags:
+    - '*'
+
+jobs:
+  codecov:
+    timeout-minutes: 30
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Install build dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-10 cmake lcov -y
+        ./ci/set_gcc_10.sh
+
+    - name: Cache boost
+      id: cache-boost
+      uses: actions/cache@v1
+      with:
+        path: ~/boost-prefix/
+        key: ${{ runner.os }}-boost-64-1-76-0-2021-08-09
+
+    - name: Build boost
+      if: steps.cache-boost.outputs.cache-hit != 'true'
+      run: ./.github/depends/boost.sh -b 64 -t gcc -p $HOME/boost-prefix
+
+    - name: Cache zlib
+      id: cache-zlib
+      uses: actions/cache@v1
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-64-1-2-11-2021-08-09
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b 64 -p $HOME/zlib-prefix
+
+    - name: Compile tests
+      run: |
+        mkdir build
+        cmake \
+            -D MSGPACK_CXX20=ON \
+            -D MSGPACK_32BIT=OFF \
+            -D MSGPACK_CHAR_SIGN=signed \
+            -D MSGPACK_USE_X3_PARSE=ON \
+            -D MSGPACK_BUILD_EXAMPLES=ON \
+            -D MSGPACK_BUILD_TESTS=ON \
+            -D CMAKE_BUILD_TYPE=Debug \
+            -D MSGPACK_GEN_COVERAGE=ON \
+            -D CMAKE_PREFIX_PATH="$HOME/zlib-prefix/64;$HOME/boost-prefix/64" \
+            -B build \
+            -S . || exit 1
+        cmake --build build --target all || exit 1
+        ctest --test-dir build || exit 1
+
+    - 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,237 @@
+name: CI
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+  push:
+    branches:
+    - cpp_master
+    tags:
+    - '*'
+
+jobs:
+  macos:
+    name: ${{ format('macOS (pattern {0})', matrix.pattern) }}
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3, 4]
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Cache boost
+      id: cache-boost
+      uses: actions/cache@v2
+      with:
+        path: ~/boost-prefix/
+        key: ${{ runner.os }}-boost-1-76-0-2021-08-09
+
+    - name: Build boost
+      if: steps.cache-boost.outputs.cache-hit != 'true'
+      run: ./.github/depends/boost.sh -b 64 -t clang -p $HOME/boost-prefix
+
+    - name: Cache zlib
+      id: cache-zlib
+      uses: actions/cache@v2
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-1-2-11-2021-08-09
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b 64 -p $HOME/zlib-prefix
+
+    - name: Build and test
+      shell: bash
+      run: |
+        # default configuration - overwrite its params later depending on matrix.pattern
+        export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
+        export ARCH=64
+        export API_VERSION=3
+        export CHAR_SIGN="signed"
+        export X3_PARSE="OFF"
+        export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
+
+        case ${{ matrix.pattern }} in
+          0)
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX11=OFF"
+            ;;
+          1)
+            export API_VERSION=1
+            ;;
+          2)
+            export API_VERSION=2
+            ;;
+          3)
+            export X3_PARSE="ON"
+            ;;
+          4)
+            export CHAR_SIGN="unsigned"
+            ;;
+        esac
+
+        # build and test
+        export CXX="clang++"
+        CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE}" ci/build_cmake.sh || exit 1
+
+        cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1  && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2
+
+  linux:
+    name: ${{ format('Linux (pattern {0})', matrix.pattern) }}
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        pattern: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install build dependencies
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get install g++-10 cmake valgrind -y
+        sudo apt-get install g++-10-multilib -y  # for 32-bit compile
+        ./ci/set_gcc_10.sh
+
+    - name: Cache boost
+      id: cache-boost
+      uses: actions/cache@v2
+      with:
+        path: ~/boost-prefix/
+        key: ${{ runner.os }}-boost-1-76-0-2021-08-09
+
+    - name: Build boost
+      if: steps.cache-boost.outputs.cache-hit != 'true'
+      run: ./.github/depends/boost.sh -b both -t gcc -p $HOME/boost-prefix
+
+    - name: Cache zlib
+      id: cache-zlib
+      uses: actions/cache@v2
+      with:
+        path: ~/zlib-prefix/
+        key: ${{ runner.os }}-zlib-1-2-11-2021-08-09
+
+    - name: Build zlib
+      if: steps.cache-zlib.outputs.cache-hit != 'true'
+      run: ./.github/depends/zlib.sh -b both -p $HOME/zlib-prefix
+
+    - name: Build and test
+      shell: bash
+      run: |
+        # default configuration - overwrite its params later depending on matrix.pattern
+        export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
+        export ARCH=64
+        export API_VERSION=3
+        export CHAR_SIGN="signed"
+        export X3_PARSE="OFF"
+        export SANITIZE="-fsanitize=undefined -fno-sanitize-recover=all"
+        export ACTION="ci/build_cmake.sh"
+
+        case ${{ matrix.pattern }} in
+          0)
+            export CXX="clang++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX11=OFF"
+            ;;
+          1)
+            export CXX="g++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX11=ON"
+            ;;
+          2)
+            export CXX="clang++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX14=ON"
+            ;;
+          3)
+            export CXX="g++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX17=ON"
+            ;;
+          4)
+            export CXX="clang++-10"
+            export MSGPACK_CXX_VERSION="MSGPACK_CXX20=ON"
+            export NO_BOOST="-DMSGPACK_NO_BOOST"
+            ;;
+          5)
+            export CXX="g++-10"
+            export ARCH=32
+            ;;
+          6)
+            export CXX="clang++-10"
+            export API_VERSION=2
+            ;;
+          7)
+            export CXX="g++-10"
+            export API_VERSION=1
+            ;;
+          8)
+            export CXX="clang++-10"
+            export CHAR_SIGN="unsigned"
+            ;;
+          9)
+            export CXX="g++-10"
+            export X3_PARSE="ON"
+            ;;
+          10)
+            export CXX="clang++-10"
+            export ACTION="ci/build_regression.sh"
+            ;;
+          11)
+            export CXX="g++-10"
+            export ARCH=32
+            export CHAR_SIGN="unsigned"
+            export X3_PARSE="ON"
+            ;;
+        esac
+
+        # build and test
+        CMAKE_CXX_COMPILER="$CXX" CXXFLAGS="-Werror -g ${SANITIZE} ${NO_BOOST}" ci/build_cmake.sh || exit 1
+        cat Files.cmake| grep ".*\.[h|hpp]" | perl -pe 's/ //g' | sort > tmp1  && find include -name "*.h" -o -name "*.hpp" | sort > tmp2 && diff tmp1 tmp2
+
+  windows:
+    name: ${{ format('Windows cxx{0}', matrix.cxx) }}
+    runs-on: windows-2019
+    strategy:
+      fail-fast: false
+      matrix:
+        # MSVC2019 only supports /std:c++14, /std:c++17 and /std:c++latest
+        cxx: [14, 17, 20]
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Cache vcpkg dependencies
+      id: cache-vcpkg
+      uses: actions/cache@v2
+      with:
+        path: C:/vcpkg/installed/x64-windows
+        key: ${{ runner.os }}-vcpkg-2021-08-09
+
+    - name: Install vcpkg dependencies
+      if: steps.cache-vcpkg.outputs.cache-hit != 'true'
+      shell: powershell
+      run: |
+        vcpkg update
+        vcpkg install zlib:x64-windows
+        vcpkg install boost-assert:x64-windows boost-numeric-conversion:x64-windows boost-variant:x64-windows boost-utility:x64-windows boost-fusion:x64-windows boost-optional:x64-windows boost-predef:x64-windows boost-preprocessor:x64-windows boost-timer:x64-windows boost-test:x64-windows
+
+    - name: Build and test
+      shell: powershell
+      run: |
+        $CPPVER="MSGPACK_CXX${{ matrix.cxx }}=ON"
+
+        md build
+        cmake `
+            -A x64 `
+            -G "Visual Studio 16 2019" `
+            -D CMAKE_TOOLCHAIN_FILE="C:/vcpkg/scripts/buildsystems/vcpkg.cmake" `
+            -D MSGPACK_BUILD_TESTS=ON `
+            -D $CPPVER `
+            -D CMAKE_CXX_FLAGS="/D_VARIADIC_MAX=10 /EHsc /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING /D_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING /D_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING /W3 /WX" `
+            -B build `
+            -S .
+        if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+        cmake --build build --config Release
+        if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+        ctest -VV --test-dir build -C Release
+        if ($LastExitCode -ne 0) { exit $LastExitCode }

.gitmodules

@@ -1,6 +0,0 @@
-[submodule "external/boost/predef"]
-	path = external/boost/predef
-	url = https://github.com/boostorg/predef.git
-[submodule "external/boost/preprocessor"]
-	path = external/boost/preprocessor
-	url = https://github.com/boostorg/preprocessor.git

.travis.yml

@@ -1,206 +0,0 @@
-language: cpp
-sudo: false
-
-install:
- - export BASE=`pwd`
- - mkdir ${BASE}/usr
- - if [ "$TRAVIS_OS_NAME" == "linux" ]; then wget --no-check-certificate https://cmake.org/files/v3.7/cmake-3.7.1-Linux-x86_64.sh -O cmake-3.7.1-Linux-x86_64.sh; fi
- - if [ "$TRAVIS_OS_NAME" == "linux" ]; then chmod a+x cmake-3.7.1-Linux-x86_64.sh; fi
- - if [ "$TRAVIS_OS_NAME" == "linux" ]; then ./cmake-3.7.1-Linux-x86_64.sh --prefix=${BASE}/usr --skip-license; fi
- - if [ "$TRAVIS_OS_NAME" == "linux" ]; then export PATH="${BASE}/usr/bin:$PATH"; fi
- - if [ "$TRAVIS_OS_NAME" == "linux" ]; then export LD_LIBRARY_PATH="${BASE}/usr/lib:$LD_LIBRARY_PATH"; fi
- - if [ "$CXX" = "g++" ]; then export CXX="g++-6" CC="gcc-6"; fi
- - if [ "$CXX" = "clang++" ] && [ "$TRAVIS_OS_NAME" == "linux" ]; then export CXX="clang++-3.7" CC="clang-3.7"; fi
-#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 ..
-# valgrind
- - if [ "$TRAVIS_OS_NAME" == "linux" ]; then wget http://valgrind.org/downloads/valgrind-3.12.0.tar.bz2 && tar xjf valgrind-3.12.0.tar.bz2 && cd valgrind-3.12.0 && ./configure --prefix=${BASE}/usr > /dev/null && make -j3 > /dev/null && make install > /dev/null && cd ..; fi
-# boost
- - if [ "$BOOST" == "ON" ]; then wget http://sourceforge.net/projects/boost/files/boost/1.63.0/boost_1_63_0.zip && unzip -q boost_1_63_0.zip && cd boost_1_63_0 && ./bootstrap.sh && ./b2 -j3 --prefix=${BASE}/usr --with-timer --with-chrono address-model=${ARCH} install > /dev/null && cd ..; fi
-
-matrix:
-  include:
-    - os: osx
-      compiler: clang
-      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="1"
-    - os: osx
-      compiler: clang
-      env:  ACTION="ci/build_cmake.sh" CXX11="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2" X3_PARSE="ON"
-    - os: osx
-      compiler: clang
-      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
-    - os: osx
-      compiler: clang
-      env: ACTION="ci/build_cmake.sh"             ARCH="64"              SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="2"
-    - os: linux
-      compiler: clang
-      env: ACTION="ci/build_cmake.sh"             ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="1"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-            - llvm-toolchain-precise
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-5-multilib
-            - g++-5-multilib
-            - bzip2
-            - clang-3.7
-            - libc6-dbg
-    - os: linux
-      compiler: clang
-      env: ACTION="ci/build_cmake.sh"             ARCH="32"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-            - llvm-toolchain-precise
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-5-multilib
-            - g++-5-multilib
-            - lib32stdc++6-6-dbg
-            - lib32gcc1
-            - libc6-i386
-            - lib32z1-dev
-            - bzip2
-            - clang-3.7
-            - libc6-dbg
-    - os: linux
-      compiler: clang
-      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"   BOOST="ON" SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2" X3_PARSE="ON"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-            - llvm-toolchain-precise
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-5-multilib
-            - g++-5-multilib
-            - bzip2
-            - clang-3.7
-            - libc6-dbg
-    - os: linux
-      compiler: clang
-      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="32"              SHARED="OFF" CHAR_SIGN="unsigned" API_VERSION="2"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-            - llvm-toolchain-precise
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-5-multilib
-            - g++-5-multilib
-            - lib32stdc++6-6-dbg
-            - lib32gcc1
-            - libc6-i386
-            - lib32z1-dev
-            - bzip2
-            - clang-3.7
-            - libc6-dbg
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="64"              SHARED="ON"  CHAR_SIGN="signed"   API_VERSION="2"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-6-multilib
-            - g++-6-multilib
-            - bzip2
-            - libc6-dbg
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"  CXX11="ON" ARCH="32"   BOOST="ON" SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="2" X3_PARSE="ON"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-6-multilib
-            - g++-6-multilib
-            - lib32stdc++6-6-dbg
-            - lib32gcc1
-            - libc6-i386
-            - lib32z1-dev
-            - bzip2
-            - libc6-dbg
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"             ARCH="64"              SHARED="ON"  CHAR_SIGN="unsigned" API_VERSION="2"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-6-multilib
-            - g++-6-multilib
-            - bzip2
-            - libc6-dbg
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"             ARCH="32"   BOOST="ON" SHARED="OFF" CHAR_SIGN="signed"   API_VERSION="1"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-6-multilib
-            - g++-6-multilib
-            - lib32stdc++6-6-dbg
-            - lib32gcc1
-            - libc6-i386
-            - lib32z1-dev
-            - bzip2
-            - libc6-dbg
-    - os: linux
-      compiler: gcc
-      env: ACTION="ci/build_cmake.sh"             ARCH="32"   BOOST="ON" SHARED="OFF" CHAR_SIGN="signed"   API_VERSION="2"
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-multilib
-            - gcc-multilib
-            - gcc-6-multilib
-            - g++-6-multilib
-            - lib32stdc++6-6-dbg
-            - lib32gcc1
-            - libc6-i386
-            - lib32z1-dev
-            - bzip2
-            - libc6-dbg
-
-script:
-  - CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" CMAKE_LIBRARY_PATH="${BASE}/usr/lib:${BASE}/build" GTEST_ROOT="${BASE}/usr" BOOST_ROOT="${BASE}/usr" ${ACTION}

CHANGELOG.md

@@ -1,3 +1,161 @@
+# 2022-03-09 version 4.1.1 for C++
+  * Remove chrono support on `MSGPACK_NO_BOOST` to fix  compile error.
+  * Improve build system (#1003)
+
+# 2022-02-12 version 4.1.0 for C++
+  * Add experimental support for no boost dependency (#1001)
+    * For cmake, add `-DMSGPACK_USE_BOOST=OFF`. For C++ compiler add `-DMSGPACK_NO_BOOST`.
+  * Improve BIN console output (#995)
+  * Fix include notation (#991)
+
+# 2021-10-23 version 4.0.3 for C++
+  * Remove Enabler2 template parameter from object adaptor (#987)
+  * Add MSGPACK_BUILD_DOCS cmake option (#983, #984)
+
+# 2021-08-31 version 4.0.2 for C++
+  * Fix fuzzer interface function name (#972)
+  * Fix boost test link error and support both dynamin(default) and static link boost (#971)
+
+# 2021-08-30 version 4.0.1 for C++
+  * Fix release tarball and its generation script (#967)
+
+# 2021-08-29 version 4.0.0 for C++
+  * Improve zone alignment logic (#965)
+  * Fix v1 unpack logic for STR and BIN (#957, #951)
+  * Fix UB on memcmp with size 0 (#954)
+  * Fix `iovec` name conflict (#952)
+  * Add `std::array<std::byte>` `std::span<char>` `std::span<unsigned char>` `std::span<std::byte>` adaptors (#951)
+  * Improve documents (#918, #919, #951)
+  * Improve tests (#916)
+  * Introduce BOOST_ASSERT (#898)
+  * Improve build system (#897, #905, #924, #951)
+  * Improve Boost.Fusion support (#894)
+  * Check nullptr before call memcpy (#891)
+  * Refine and bugfix `std::chrono::time_point` adaptor (#888, #893)
+  * Improve CI (#884, #892, #895, #951, #955)
+## << breaking changes >>
+  * Separate C++ part of the msgpack-c  from C/C++ mixed msgpack-c (#876, #878)
+  * Require boost libraries. See README.md Dependency(#912)
+
+# 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 >>

CMakeLists.txt

@@ -1,13 +1,10 @@
-CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6)
+CMAKE_MINIMUM_REQUIRED (VERSION 3.1 FATAL_ERROR)
 
-IF ((CMAKE_VERSION VERSION_GREATER 3.1) OR
+CMAKE_POLICY (SET CMP0054 NEW)
-    (CMAKE_VERSION VERSION_EQUAL 3.1))
-    CMAKE_POLICY(SET CMP0054 NEW)
-ENDIF ()
 
-PROJECT (msgpack)
+PROJECT (msgpack LANGUAGES CXX)
 
-FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.h contents)
+FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/version_master.hpp 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})
@@ -16,142 +13,87 @@ STRING (REGEX MATCH "#define MSGPACK_VERSION_REVISION *([0-9a-zA-Z_]*)" NULL_OUT
 SET (VERSION_REVISION ${CMAKE_MATCH_1})
 SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION})
 
-SET (prefix ${CMAKE_INSTALL_PREFIX})
+LIST (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
-SET (exec_prefix "\${prefix}")
-SET (libdir "\${exec_prefix}/lib")
-SET (includedir "\${prefix}/include")
 SET (GNUCXX_STD_SUPPORT_VERSION "4.3")
 
 OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF)
-OPTION (MSGPACK_32BIT "32bit compile" OFF)
+OPTION (MSGPACK_CXX14 "Using c++14 compiler" OFF)
-OPTION (MSGPACK_BOOST "Using boost libraries" OFF)
+OPTION (MSGPACK_CXX17 "Using c++17 compiler" OFF)
+OPTION (MSGPACK_CXX20 "Using c++20 compiler" OFF)
 
-IF (APPLE)
+OPTION (MSGPACK_32BIT            "32bit compile"                        OFF)
-    SET(CMAKE_MACOSX_RPATH ON)
+OPTION (MSGPACK_USE_BOOST        "Use Boost libraried"                  ON)
-    SET(CMAKE_SKIP_BUILD_RPATH FALSE)
+OPTION (MSGPACK_USE_X3_PARSE     "Use Boost X3 parse"                   OFF)
-    SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
+OPTION (MSGPACK_BUILD_TESTS      "Build tests"                          OFF)
-    SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+OPTION (MSGPACK_BUILD_DOCS       "Build Doxygen documentation"          ON)
-    SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+OPTION (MSGPACK_FUZZ_REGRESSION  "Enable regression testing"            OFF)
-    LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
+OPTION (MSGPACK_BUILD_EXAMPLES   "Build msgpack examples"               OFF)
-    IF ("${isSystemDir}" STREQUAL "-1")
+OPTION (MSGPACK_GEN_COVERAGE     "Generate coverage report"             OFF)
-        SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+OPTION (MSGPACK_USE_STATIC_BOOST "Statically link with boost libraries" OFF)
-    ENDIF ()
+OPTION (MSGPACK_CHAR_SIGN        "Char sign to use (signed or unsigned)")
-ENDIF ()
+
+SET (CMAKE_CXX_STANDARD_REQUIRED ON)
 
 IF (MSGPACK_USE_X3_PARSE)
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    IF (NOT (MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20))
-      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
+        MESSAGE (FATAL_ERROR "MSGPACK_USE_X3_PARSE requires MSGPACK_CXX14 or newer")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    ENDIF ()
-      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE -std=c++14 ${CMAKE_CXX_FLAGS}")
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+ENDIF ()
-      SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_X3_PARSE ${CMAKE_CXX_FLAGS}")
+
-      IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
+IF (MSGPACK_CXX20)
-          MESSAGE ( FATAL_ERROR "MSVC doesn't support C++14.")
+    SET (CMAKE_CXX_STANDARD 20)
-      ENDIF ()
+ELSEIF (MSGPACK_CXX17)
-   ENDIF ()
+    SET (CMAKE_CXX_STANDARD 17)
+ELSEIF (MSGPACK_CXX14)
+    SET (CMAKE_CXX_STANDARD 14)
+ELSEIF (MSGPACK_CXX11)
+    SET (CMAKE_CXX_STANDARD 11)
 ELSE ()
-   IF (MSGPACK_CXX11)
+    SET (CMAKE_CXX_STANDARD 98)
-      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-         SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-         SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-         IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19)
-             MESSAGE ( FATAL_ERROR "MSVC doesn't support C++11.")
-         ENDIF ()
-      ENDIF ()
-   ELSE ()
-      IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-         IF ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER ${GNUCXX_STD_SUPPORT_VERSION}) OR
-             (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL   ${GNUCXX_STD_SUPPORT_VERSION}))
-             SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
-         ENDIF ()
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-         SET (CMAKE_CXX_FLAGS "-std=c++98 ${CMAKE_CXX_FLAGS}")
-      ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-         IF (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 18)
-             SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_CPP03 ${CMAKE_CXX_FLAGS}")
-         ENDIF ()
-      ENDIF ()
-   ENDIF ()
 ENDIF ()
 
 IF (MSGPACK_32BIT)
-   IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
+        SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
-      SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
+        SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
-      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
+    ELSEIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-   ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
-      SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}")
+        SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
-      SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}")
+    ENDIF ()
-      SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}")
-   ENDIF ()
 ENDIF ()
 
-OPTION (MSGPACK_BUILD_EXAMPLES "Build msgpack examples." ON)
+IF (MSGPACK_USE_BOOST)
+    SET (Boost_USE_MULTITHREADED ON)
 
-IF (MSGPACK_BOOST)
+    IF (MSGPACK_USE_STATIC_BOOST)
-   SET (CMAKE_CXX_FLAGS "-DMSGPACK_USE_BOOST ${CMAKE_CXX_FLAGS}")
+        MESSAGE (STATUS "Staticly linking with Boost")
-ENDIF ()
+        SET (Boost_USE_STATIC_LIBS TRUE)
+    ELSE ()
+        MESSAGE (STATUS "Dynamically linking with Boost")
+        SET (Boost_USE_STATIC_LIBS FALSE)
+    ENDIF ()
 
-SET (Boost_USE_STATIC_LIBS        ON) # only find static libs
+    FIND_PACKAGE (Boost REQUIRED)
-SET (Boost_USE_MULTITHREADED      ON)
+ELSE ()
-SET (Boost_USE_STATIC_RUNTIME    OFF)
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_NO_BOOST ${CMAKE_CXX_FLAGS}")
-FIND_PACKAGE (Boost COMPONENTS chrono context timer system)
-IF (Boost_INCLUDE_DIRS)
-    INCLUDE_DIRECTORIES (
-        ${Boost_INCLUDE_DIRS}
-    )
-ENDIF ()
-IF (MSGPACK_BOOST_DIR)
-    INCLUDE_DIRECTORIES (
-        ${MSGPACK_BOOST_DIR}
-    )
 ENDIF ()
 
 IF (MSGPACK_CHAR_SIGN)
-   SET (CMAKE_C_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_C_FLAGS}")
+    SET (CMAKE_CXX_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_CXX_FLAGS}")
-   SET (CMAKE_CXX_FLAGS "-f${MSGPACK_CHAR_SIGN}-char ${CMAKE_CXX_FLAGS}")
 ENDIF ()
 
 IF (MSGPACK_DEFAULT_API_VERSION)
-   SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION} ${CMAKE_CXX_FLAGS}")
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=${MSGPACK_DEFAULT_API_VERSION} ${CMAKE_CXX_FLAGS}")
 ELSE ()
-   SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=2 ${CMAKE_CXX_FLAGS}")
+    SET (MSGPACK_DEFAULT_API_VERSION 3)
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_DEFAULT_API_VERSION=3 ${CMAKE_CXX_FLAGS}")
 ENDIF ()
 
-FILE (GLOB_RECURSE PREDEF_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/*.h)
+IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-FOREACH (F ${PREDEF_FILES})
+    IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.1)
-   SET(M "Converting ${F}")
+        INCLUDE (CheckCXXSourceCompiles)
-   MESSAGE(STATUS ${M})
+        CHECK_CXX_SOURCE_COMPILES ("
-   FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/predef/include/boost/${F} CONTENT)
-   STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT})
-   STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT})
-   FILE (WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} ${CONTENT})
-ENDFOREACH ()
-
-FILE (GLOB_RECURSE PREPROCESSOR_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/*.hpp)
-FOREACH (F ${PREPROCESSOR_FILES})
-   SET(M "Converting ${F}")
-   MESSAGE(STATUS ${M})
-   FILE (READ ${CMAKE_CURRENT_SOURCE_DIR}/external/boost/preprocessor/include/boost/${F} CONTENT)
-   STRING(REPLACE "BOOST_" "MSGPACK_" CONTENT ${CONTENT})
-   STRING(REPLACE "boost/" "msgpack/" CONTENT ${CONTENT})
-   FILE (WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/msgpack/${F} ${CONTENT})
-ENDFOREACH ()
-
-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)
-ENDIF ()
-
-OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON)
-OPTION (MSGPACK_ENABLE_SHARED "Build shared libaries in addition to static libraries." ON)
-
-INCLUDE (CheckCXXSourceCompiles)
-CHECK_CXX_SOURCE_COMPILES ("
 #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; }
@@ -160,152 +102,146 @@ int main(int argc, char * argv[])
     atomic_sub(1);
     atomic_add(1);
 }
-" MSGPACK_ENABLE_GCC_CXX_ATOMIC)
+"
+        MSGPACK_ENABLE_GCC_CXX_ATOMIC)
+    ENDIF ()
+ENDIF ()
+
 
 INCLUDE (Files.cmake)
 
-EXECUTE_PROCESS (
+ADD_LIBRARY (msgpackc-cxx INTERFACE)
-    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack
+
+TARGET_INCLUDE_DIRECTORIES (msgpackc-cxx
+    INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+        $<INSTALL_INTERFACE:include>
 )
 
-CONFIGURE_FILE (
+IF (MSGPACK_USE_BOOST)
-    msgpack.pc.in
+    TARGET_LINK_LIBRARIES (msgpackc-cxx INTERFACE Boost::boost)
-    msgpack.pc
-    @ONLY
-)
-
-INCLUDE_DIRECTORIES (
-    ./
-    include/
-    ${CMAKE_CURRENT_BINARY_DIR}/include/
-)
-
-IF (MSGPACK_ENABLE_SHARED)
-    ADD_LIBRARY (msgpackc SHARED
-        ${msgpackc_SOURCES}
-        ${msgpackc_HEADERS}
-    )
 ENDIF ()
 
-ADD_LIBRARY (msgpackc-static STATIC
+IF (MSGPACK_GEN_COVERAGE)
-    ${msgpackc_SOURCES}
+    IF (NOT MSGPACK_BUILD_TESTS)
-    ${msgpackc_HEADERS}
+        MESSAGE(FATAL_ERROR "Coverage requires -DMSGPACK_BUILD_TESTS=ON")
-)
-
-SET_TARGET_PROPERTIES (msgpackc-static PROPERTIES OUTPUT_NAME "msgpackc")
-IF (MSGPACK_ENABLE_SHARED)
-    IF (MSVC)
-        SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX "_import.lib")
-    ELSEIF (MINGW)
-        SET_TARGET_PROPERTIES (msgpackc PROPERTIES IMPORT_SUFFIX ".dll.a")
     ENDIF ()
-    SET_TARGET_PROPERTIES (msgpackc PROPERTIES SOVERSION 2 VERSION 2.0.0)
+    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_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_FLAGS}")
+
+    SETUP_TARGET_FOR_COVERAGE(coverage make coverage test)
 ENDIF ()
 
 IF (MSGPACK_BUILD_TESTS)
+    IF (NOT MSGPACK_USE_BOOST)
+        MESSAGE(FATAL_ERROR "Test requires -DMSGPACK_USE_BOOST=ON")
+    ENDIF ()
     ENABLE_TESTING ()
     # 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)
+    FIND_PROGRAM (CTEST_MEMORYCHECK_COMMAND NAMES valgrind)
-    INCLUDE(Dart)
+    INCLUDE (Dart)
     ADD_SUBDIRECTORY (test)
 ENDIF ()
 
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+# enable regression testing
-    IF (MSGPACK_ENABLE_SHARED)
+IF (MSGPACK_FUZZ_REGRESSION)
-        SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3 -DPIC")
+    ENABLE_TESTING ()
-    ENDIF ()
+    ADD_SUBDIRECTORY (fuzz)
-    SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3" )
 ENDIF ()
 
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+IF ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "sparc")
-    IF (MSGPACK_ENABLE_SHARED)
+    SET (CMAKE_CXX_FLAGS "-DMSGPACK_ZONE_ALIGN=8 ${CMAKE_CXX_FLAGS}")
-        SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-    ENDIF ()
-    SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-ENDIF ()
-
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-    IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-        STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-    ELSE ()
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-    ENDIF ()
-ENDIF ()
-
-IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC90" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC10")
-    SET_SOURCE_FILES_PROPERTIES(${msgpackc_SOURCES} PROPERTIES LANGUAGE CXX)
-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 ()
 
 IF (MSGPACK_BUILD_EXAMPLES)
     ADD_SUBDIRECTORY (example)
 ENDIF ()
 
-IF (MSGPACK_ENABLE_SHARED)
-    SET (MSGPACK_INSTALLTARGETS msgpackc msgpackc-static)
-ELSE()
-    SET (MSGPACK_INSTALLTARGETS msgpackc-static)
-ENDIF ()
-
-INSTALL (TARGETS ${MSGPACK_INSTALLTARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-                                           LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                                           ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX})
-IF (NOT MSVC)
-    INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-ENDIF ()
-
 # Doxygen
-FIND_PACKAGE (Doxygen)
+IF (MSGPACK_BUILD_DOCS)
-IF (DOXYGEN_FOUND)
+    FIND_PACKAGE (Doxygen)
-    LIST (APPEND Doxyfile_c_CONTENT
+    IF (DOXYGEN_FOUND)
-        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
-    )
-    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_c
-        ${Doxyfile_c_CONTENT}
-        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c
-        VERBATIM
-    )
-    LIST (APPEND Doxyfile_cpp_CONTENT
-        COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-        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
-        COMMAND ${CMAKE_COMMAND} -E echo "INPUT              = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-        COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL        = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
-    )
-    IF (DOXYGEN_DOT_FOUND)
         LIST (APPEND Doxyfile_cpp_CONTENT
-            COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT       = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+            COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+            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
+            COMMAND ${CMAKE_COMMAND} -E echo "INPUT              = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+            COMMAND ${CMAKE_COMMAND} -E echo "EXTRACT_ALL        = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+            COMMAND ${CMAKE_COMMAND} -E echo "STRIP_FROM_PATH    = ${CMAKE_CURRENT_SOURCE_DIR}/include" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+        )
+        IF (DOXYGEN_DOT_FOUND)
+            LIST (APPEND Doxyfile_cpp_CONTENT
+                COMMAND ${CMAKE_COMMAND} -E echo "HAVE_DOT       = YES" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp
+            )
+        ENDIF ()
+        ADD_CUSTOM_TARGET (
+            doxygen
+            ${Doxyfile_cpp_CONTENT}
+            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
+            VERBATIM
         )
     ENDIF ()
-    ADD_CUSTOM_TARGET (
-        doxygen_cpp
-        ${Doxyfile_cpp_CONTENT}
-        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
-        VERBATIM
-    )
-    ADD_CUSTOM_TARGET (
-        doxygen
-        DEPENDS doxygen_c doxygen_cpp
-    )
 ENDIF ()
+
+include (GNUInstallDirs)
+
+# Install library.
+INSTALL (TARGETS msgpackc-cxx
+         EXPORT msgpackc-cxx-targets
+         COMPONENT msgpackc-cxx
+         # This provides include directory in exported target
+         # relative to prefix in single directory we've put everything in.
+         INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+# Install headers from source tree.
+INSTALL (DIRECTORY include/
+         DESTINATION include
+         COMPONENT msgpackc-cxx
+)
+
+INCLUDE (CMakePackageConfigHelpers)
+
+IF (NOT (CMAKE_VERSION VERSION_LESS 3.14))
+    SET (extra_version_file_args ARCH_INDEPENDENT)
+ENDIF ()
+SET (cmake_config_path "${CMAKE_INSTALL_LIBDIR}/cmake/msgpackc-cxx")
+
+# Configure the main package file from source tree.
+CONFIGURE_PACKAGE_CONFIG_FILE (
+    msgpack-config.cmake.in
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
+    INSTALL_DESTINATION "${cmake_config_path}"
+)
+
+# Write package version file.
+WRITE_BASIC_PACKAGE_VERSION_FILE (
+    msgpack-config-version.cmake
+    VERSION ${VERSION}
+    COMPATIBILITY SameMajorVersion
+    ${extra_version_file_args}
+)
+
+# Install the generated package version file and the main package file.
+INSTALL (FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/msgpack-config-version.cmake"
+    DESTINATION "${cmake_config_path}"
+    COMPONENT msgpackc-cxx
+)
+
+# This installs package in install tree for using installed targets.
+INSTALL (
+    EXPORT msgpackc-cxx-targets
+    FILE msgpackc-cxx-targets.cmake
+    DESTINATION "${cmake_config_path}"
+    COMPONENT msgpackc-cxx
+)

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

QUICKSTART-C.md

@@ -1,194 +0,0 @@
-# Implementation Status
-
-The serialization library is production-ready.
-
-Currently, RPC implementation is not available.
-
-# Install
-
-
-## 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
-```
-
-## 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.
-
-## Gentoo Linux with Portage
-
-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
-
-On the other UNIX-like platforms, download source package from [Releases|http://msgpack.org/releases/cpp/] and run `./configure && make && make install`.
-
-```
-$ wget http://msgpack.org/releases/cpp/msgpack-1.3.0.tar.gz
-$ tar zxvf msgpack-1.3.0.tar.gz
-$ cd msgpack-1.3.0
-$ ./configure
-$ make
-$ sudo make install
-```
-
-## Windows
-
-On Windows, download source package from [here|https://sourceforge.net/projects/msgpack/files/] and extract it.
-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
-> dir lib       % DLL files are here
-> dir include   % header files are here
-```
-
-## Install from git repository
-
-You need to install gcc (4.1.0 or higher), autotools.
-
-```
-$ git clone git@github.com:msgpack/msgpack.git
-$ cd msgpack/cpp
-$ ./bootstrap
-$ ./configure
-$ make
-$ sudo make install
-```
-
-# Serialization QuickStart for C
-
-## First program
-
-Include `msgpack.h` header and link `msgpack` library to use MessagePack on your program.
-
-```c
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void) {
-
-        /* creates buffer and serializer instance. */
-        msgpack_sbuffer* buffer = msgpack_sbuffer_new();
-        msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
-
-        /* serializes ["Hello", "MessagePack"]. */
-        msgpack_pack_array(pk, 2);
-        msgpack_pack_bin(pk, 5);
-        msgpack_pack_bin_body(pk, "Hello", 5);
-        msgpack_pack_bin(pk, 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);
-
-        /* prints the deserialized object. */
-        msgpack_object obj = msg.data;
-        msgpack_object_print(stdout, obj);  /*=> ["Hello", "MessagePack"] */
-
-        /* cleaning */
-        msgpack_sbuffer_free(buffer);
-        msgpack_packer_free(pk);
-}
-```
-
-## Simple program with a loop
-
-```c
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void) {
-
-        /* creates buffer and serializer instance. */
-        msgpack_sbuffer* buffer = msgpack_sbuffer_new();
-        msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
-
-        int j;
-
-        for(j = 0; j<23; j++) {
-           /* NB: the buffer needs to be cleared on each iteration */
-           msgpack_sbuffer_clear(buffer);
-
-           /* serializes ["Hello", "MessagePack"]. */
-           msgpack_pack_array(pk, 3);
-           msgpack_pack_bin(pk, 5);
-           msgpack_pack_bin_body(pk, "Hello", 5);
-           msgpack_pack_bin(pk, 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);
-
-           /* prints the deserialized object. */
-           msgpack_object obj = msg.data;
-           msgpack_object_print(stdout, obj);  /*=> ["Hello", "MessagePack"] */
-           puts("");
-        }
-
-        /* cleaning */
-        msgpack_sbuffer_free(buffer);
-        msgpack_packer_free(pk);
-}
-```
-
-## Streaming feature
-
-```c
-#include <msgpack.h>
-#include <stdio.h>
-
-int main(void) {
-        /* serializes multiple objects using msgpack_packer. */
-        msgpack_sbuffer* buffer = msgpack_sbuffer_new();
-        msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write);
-        msgpack_pack_int(pk, 1);
-        msgpack_pack_int(pk, 2);
-        msgpack_pack_int(pk, 3);
-
-        /* deserializes these objects using msgpack_unpacker. */
-        msgpack_unpacker pac;
-        msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE);
-
-        /* feeds the buffer. */
-        msgpack_unpacker_reserve_buffer(&pac, buffer->size);
-        memcpy(msgpack_unpacker_buffer(&pac), buffer->data, buffer->size);
-        msgpack_unpacker_buffer_consumed(&pac, buffer->size);
-
-        /* now starts streaming deserialization. */
-        msgpack_unpacked result;
-        msgpack_unpacked_init(&result);
-
-        while(msgpack_unpacker_next(&pac, &result)) {
-            msgpack_object_print(stdout, result.data);
-            puts("");
-        }
-
-        /* results:
-         * $ gcc stream.cc -lmsgpackc -o stream
-         * $ ./stream
-         * 1
-         * 2
-         * 3
-         */
-}
-```

QUICKSTART-CPP.md

@@ -59,7 +59,7 @@ $ ./hello
 #include <iostream>
 #include <string>
 
-int main(void) {
+int main() {
         // serializes multiple objects using msgpack::packer.
         msgpack::sbuffer buffer;
 
@@ -78,7 +78,7 @@ int main(void) {
 
         // now starts streaming deserialization.
         msgpack::object_handle oh;
-        while(pac.next(&oh)) {
+        while(pac.next(oh)) {
             std::cout << oh.get() << std::endl;
         }
 
@@ -98,7 +98,7 @@ int main(void) {
 #include <iostream>
 #include <string>
 
-int main(void) {
+int main() {
         // serializes multiple objects into one message containing an array using msgpack::packer.
         msgpack::sbuffer buffer;
 
@@ -139,7 +139,7 @@ public:
     MSGPACK_DEFINE(m_str, m_vec);
 };
 
-int main(void) {
+int main() {
         std::vector<myclass> vec;
         // add some elements into vec...
 

README.md

@@ -1,9 +1,10 @@
-`msgpack` for C/C++
+`msgpack` for C++
 ===================
 
-Version 2.1.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
+Version 4.1.1 [![Build Status](https://github.com/msgpack/msgpack-c/workflows/CI/badge.svg?branch=cpp_master)](https://github.com/msgpack/msgpack-c/actions) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/cpp_master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/cpp_master)
+[![codecov](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master/graph/badge.svg)](https://codecov.io/gh/msgpack/msgpack-c/branch/cpp_master)
 
-It's like JSON but small and fast.
+It's like JSON but smaller and faster.
 
 Overview
 --------
@@ -11,64 +12,19 @@ Overview
 [MessagePack](http://msgpack.org/) is an efficient binary serialization
 format, which lets you exchange data among multiple languages like JSON,
 except that it's faster and smaller. Small integers are encoded into a
-single byte while typical short strings require only one extra byte in
+single byte and short strings require only one extra byte in
 addition to the strings themselves.
 
 Example
 -------
 
-In C:
-
-```c
-#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_str(&pk, 7);
-    msgpack_pack_str_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;
-}
-```
-
-See [`QUICKSTART-C.md`](./QUICKSTART-C.md) for more details.
-
-In C++:
-
 ```c++
 #include <msgpack.hpp>
 #include <string>
 #include <iostream>
 #include <sstream>
 
-int main(void)
+int main()
 {
     msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
 
@@ -97,80 +53,157 @@ int main(void)
     msgpack::type::tuple<int, bool, std::string> dst;
     deserialized.convert(dst);
 
+    // or create the new instance
+    msgpack::type::tuple<int, bool, std::string> dst2 =
+        deserialized.as<msgpack::type::tuple<int, bool, std::string> >();
+
     return 0;
 }
 ```
 
 See [`QUICKSTART-CPP.md`](./QUICKSTART-CPP.md) for more details.
 
+Dependency
+----------
+
+msgpack-c requires [boost library](https://www.boost.org/).
+C++ version of msgpack-c itself is a header-only library and depends only on
+boost headers. Tests depend on boost unit test framework and are linked with
+it, so if you want to build them, you need to have this dependency installed.
+
+Experimental support for removing boost dependency
+
+For cmake:
+
+```
+cmake -DMSGPACK_USE_BOOST=OFF ..
+```
+
+NOTE: `-DMSGPACK_BUILD_TESTS=ON` doesn't work with `-DMSGPACK_USE_BOOST=OFF`.
+
+For C++ compiler
+
+```
+clang++ -DMSGPACK_NO_BOOST your_code.cpp
+```
+
+
 Usage
 -----
 
-### C++ Header Only Library
+- If you build your project with cmake, you can find msgpack-c with a
+  canonical cmake-way:
 
-When you use msgpack on C++03 and C++11, you can just add
+  ```cmake
-msgpack-c/include to your include path:
+  # ...
+  find_package(msgpack REQUIRED)
+  # ...
+  target_link_libraries(your_target_name <PRIVATE/PUBLIC/INTERFACE> msgpackc-cxx)
+  # ...
+  ```
 
-    g++ -I msgpack-c/include your_source_file.cpp
+  This will search for `msgpack` cmake package in a system prefix and in
+  prefixes from `CMAKE_PREFIX_PATH`. Note that msgpack-c depends on boost
+  headers, and `msgpack` cmake package depends on `Boost` cmake package. The
+  library is header-only and `target_link_libraries` command just adds path
+  to msgpack-c headers to your compiler's include path.
 
-If you want to use C version of msgpack, you need to build it. You can
+  A usage example can be found at [test-install](test-install) directory.
-also install the C and C++ versions of msgpack.
 
-### Building and Installing
+- If you do not use cmake, you can just add path yo msgpack-c and boost
+  headers to your include path:
 
-#### Install from git repository
+  ```bash
+  g++ -I msgpack-c/include -I path_to_boost your_source_file.cpp
+  ```
 
-##### Using the Terminal (CLI)
+Building and Installing
+-----------------------
+
+### Install from git repository
+
+#### Using the Terminal (CLI)
 
 You will need:
 
- - `gcc >= 4.1.0`
+- `gcc >= 4.1.0`
- - `cmake >= 2.8.0`
+- `cmake >= 3.1.0`
 
-C and C++03:
+C++03:
 
-    $ git clone https://github.com/msgpack/msgpack-c.git
+```bash
-    $ cd msgpack-c
+git clone https://github.com/msgpack/msgpack-c.git
-    $ cmake .
+cd msgpack-c
-    $ make
+git checkout cpp_master
-    $ sudo make install
+cmake .
+sudo cmake --build . --target install
+```
 
-If you want to setup C++11 version of msgpack instead,
+If you want to build tests with different C++ version, you can use
-execute the following commands:
+`MSGPACK_CXX11`, `MSGPACK_CXX14`, `MSGPACK_CXX17`, `MSGPACK_CXX20` options.
+Just replace the line
 
-    $ git clone https://github.com/msgpack/msgpack-c.git
+```bash
-    $ cd msgpack-c
+cmake .
-    $ cmake -DMSGPACK_CXX11=ON .
+```
-    $ sudo make install
+
+with a line like that:
+
+```bash
+cmake -DMSGPACK_CXX20=ON .
+```
+
+Note that these flags do not affect installation. They just switch test cases.
+All files are installed in every settings.
+
+If you don't have superuser permissions or don't want to install the library
+to a system-wide prefix, you can use `CMAKE_INSTALL_PREFIX` option like that:
+
+```bash
+cmake -DCMAKE_INSTALL_PREFIX=/your/custom/prefix .
+```
+
+Other useful options:
+
+- `MSGPACK_BUILD_TESTS` (default `OFF`): build tests
+- `MSGPACK_BUILD_EXAMPLES` (default `OFF`): build examples
+- `MSGPACK_32BIT` (default `OFF`): 32bit compile
+- `MSGPACK_USE_X3_PARSE` (default `OFF`): use Boost X3 parse
+  (note that it requires C++14 or newer)
+- `MSGPACK_CHAR_SIGN` (not set explicitly by default): char sign to use (signed or unsigned)
+- `MSGPACK_USE_STATIC_BOOST` (default `OFF`): statically link with boost libraries
 
 #### GUI on Windows
 
-Clone msgpack-c git repository.
+Clone msgpack-c git repository with the command:
 
-    $ git clone https://github.com/msgpack/msgpack-c.git
+```
+git clone https://github.com/msgpack/msgpack-c.git
+```
 
-or using GUI git client.
+or using GUI git client (e.g. [tortoise git](https://code.google.com/p/tortoisegit/)).
 
-e.g.) tortoise git https://code.google.com/p/tortoisegit/
+1. Checkout to `cpp_master` branch
 
-1. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
+2. Launch [cmake GUI client](http://www.cmake.org/cmake/resources/software.html).
 
-2. Set 'Where is the source code:' text box and 'Where to build
+3. Set 'Where is the source code:' text box and
-the binaries:' text box.
+   'Where to build the binaries:' text box.
 
-3. Click 'Configure' button.
+4. Click 'Configure' button.
 
-4. Choose your Visual Studio version.
+5. Choose your Visual Studio version.
 
-5. Click 'Generate' button.
+6. Click 'Generate' button.
 
-6. Open the created msgpack.sln on Visual Studio.
+7. Open the created msgpack.sln on Visual Studio.
 
-7. Build all.
+8. Build all.
 
-### Documentation
+Documentation
+-------------
 
-You can get addtional information on the
+You can get additional information including the tutorial on the
 [wiki](https://github.com/msgpack/msgpack-c/wiki).
 
 Contributing

appveyor.yml

@@ -1,54 +1,66 @@
-version: 2.1.0.{build}
+version: 4.1.1.{build}
+
+branches:
+  only:
+  - cpp_master
 
 environment:
   matrix:
-    - cpp11: -DMSGPACK_CXX11=OFF
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      boost: -DMSGPACK_BOOST=ON
+      cpp11: -DMSGPACK_CXX11=OFF
-      msvc: '"Visual Studio 10 2010"'
-    - cpp11: -DMSGPACK_CXX11=OFF
-      boost: -DMSGPACK_BOOST=ON
-      msvc: '"Visual Studio 11 2012"'
-    - cpp11: -DMSGPACK_CXX11=OFF
-      boost: -DMSGPACK_BOOST=ON
       msvc: '"Visual Studio 12 2013"'
-    - cpp11: -DMSGPACK_CXX11=ON
+      boost_prefix: C:\Libraries\boost_1_58_0
-      boost: -DMSGPACK_BOOST=ON
+      boost_subdir: lib32-msvc-12.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      cpp11: -DMSGPACK_CXX11=OFF
       msvc: '"Visual Studio 14 2015"'
-    - cpp11: -DMSGPACK_CXX11=OFF
+      boost_prefix: C:\Libraries\boost_1_69_0
-      boost: -DMSGPACK_BOOST=ON
+      boost_subdir: lib32-msvc-14.0
-      msvc: '"Visual Studio 14 2015"'
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-    - cpp11: -DMSGPACK_CXX11=ON
+      cpp11: -DMSGPACK_CXX11=ON
-      boost: -DMSGPACK_BOOST=OFF
-      msvc: '"Visual Studio 14 2015"'
-    - cpp11: -DMSGPACK_CXX11=OFF
-      boost: -DMSGPACK_BOOST=OFF
       msvc: '"Visual Studio 14 2015"'
+      boost_prefix: C:\Libraries\boost_1_69_0
+      boost_subdir: lib32-msvc-14.0
 build_script:
-- appveyor DownloadFile https://github.com/google/googletest/archive/release-1.7.0.zip -FileName googletest-release-1.7.0.zip
+  - ps: |
-- 7z x googletest-release-1.7.0.zip > NUL
+      appveyor DownloadFile http://zlib.net/zlib-1.2.11.tar.gz -FileName zlib-1.2.11.tar.gz
-- cd googletest-release-1.7.0
+      7z x zlib-1.2.11.tar.gz 2> $null
-- md build
+      7z x zlib-1.2.11.tar 2> $null
-- cd build
+      cd zlib-1.2.11
-- cmake -G %msvc% -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_FLAGS=/D_VARIADIC_MAX=10 ..
+
-- cmake --build . --config Release
+      md build
-- cd ..
+      md prefix
-- cd ..
+      cd build
-- appveyor DownloadFile http://zlib.net/zlib-1.2.10.tar.gz -FileName zlib-1.2.10.tar.gz
+
-- 7z x zlib-1.2.10.tar.gz > NUL
+      cmake `
-- 7z x zlib-1.2.10.tar > NUL
+          -G $env:msvc `
-- cd zlib-1.2.10
+          -D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\zlib-1.2.11\prefix" `
-- md build
+          ..
-- cd build
+      if ($LastExitCode -ne 0) { exit $LastExitCode }
-- cmake -G %msvc% ..
+
-- cmake --build . --config Release
+      cmake --build . --target install --config Release
-- copy zconf.h ..
+      if ($LastExitCode -ne 0) { exit $LastExitCode }
-- cd ..
+      cd ..\..
-- cd ..
+
-- md build
+      md build
-- cd build
+      md prefix
-- cmake -G %msvc% %cpp11% %boost% %x3_parse%  -DMSGPACK_BOOST_DIR=C:\Libraries\\boost_1_60_0 -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.10\build\Release\zlib.lib -DZLIB_INCLUDE_DIR=%APPVEYOR_BUILD_FOLDER%\zlib-1.2.10 -DCMAKE_CXX_FLAGS='"/D_VARIADIC_MAX=10 /EHsc"' ..
+      cd build
-- cmake --build . --config Release
+
+      cmake `
+          -G $env:msvc `
+          $env:cpp11 `
+          -D MSGPACK_BUILD_EXAMPLES=ON `
+          -D MSGPACK_BUILD_TESTS=ON `
+          -D CMAKE_EXE_LINKER_FLAGS=/LIBPATH:"$env:boost_prefix\$env:boost_subdir" `
+          -D CMAKE_PREFIX_PATH="$env:boost_prefix;$env:APPVEYOR_BUILD_FOLDER\zlib-1.2.11\prefix" `
+          -D CMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER\prefix" `
+          -D CMAKE_CXX_FLAGS="/D_VARIADIC_MAX=10 /EHsc /DBOOST_ALL_DYN_LINK" `
+          ..
+      if ($LastExitCode -ne 0) { exit $LastExitCode }
+
+      cmake --build . --config Release
+      if ($LastExitCode -ne 0) { exit $LastExitCode }
 
 test_script:
-- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\googletest-release-1.7.0\build\Release;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.10\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release
+- set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\zlib-1.2.11\build\Release;%APPVEYOR_BUILD_FOLDER%\build\release;%boost_prefix%\%boost_subdir%
-- ctest -V
+- ctest -VV -C Release

ci/build_cmake.sh

@@ -1,63 +1,37 @@
 #!/bin/bash
 
-mkdir build
+build_dir="$CXX-build"
+prefix_dir="`pwd`/$CXX-prefix"
+mkdir $build_dir  || exit 1
+mkdir $prefix_dir || exit 1
 
-ret=$?
+if [ "${ARCH}" == "32" ]; then
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-cd build
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-if [ "${ARCH}" == "32" ]
-then
     export BIT32="ON"
+    export ARCH_FLAG="-m32"
 else
     export BIT32="OFF"
+    export ARCH_FLAG="-m64"
 fi
 
-cmake -DMSGPACK_CXX11=${CXX11} -DMSGPACK_32BIT=${BIT32} -DMSGPACK_BOOST=${BOOST} -DMSGPACK_ENABLE_SHARED=${SHARED} -DMSGPACK_CHAR_SIGN=${CHAR_SIGN} -DMSGPACK_DEFAULT_API_VERSION=${API_VERSION} -DMSGPACK_USE_X3_PARSE=${X3_PARSE} ..
+cmake \
+    -D CMAKE_PREFIX_PATH="${HOME}/boost-prefix/${ARCH};${HOME}/zlib-prefix/${ARCH}" \
+    -D MSGPACK_BUILD_TESTS=ON \
+    -D ${MSGPACK_CXX_VERSION} \
+    -D MSGPACK_32BIT=${BIT32} \
+    -D MSGPACK_CHAR_SIGN=${CHAR_SIGN} \
+    -D MSGPACK_DEFAULT_API_VERSION=${API_VERSION} \
+    -D MSGPACK_USE_X3_PARSE=${X3_PARSE} \
+    -D CMAKE_CXX_FLAGS="${CXXFLAGS} ${ARCH_FLAG}" \
+    -D CMAKE_INSTALL_PREFIX=$prefix_dir \
+    -B $build_dir \
+    -S . || exit 1
 
-ret=$?
+cmake --build $build_dir --target install || exit 1
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
 
-make
+ctest -VV --test-dir $build_dir || exit 1
 
-ret=$?
+if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]; then
-if [ $ret -ne 0 ]
+    ctest -T memcheck --test-dir $build_dir | tee memcheck.log
-then
-    exit $ret
-fi
-
-make test
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-make install DESTDIR=`pwd`/install
-
-ret=$?
-if [ $ret -ne 0 ]
-then
-    exit $ret
-fi
-
-if [ "${ARCH}" != "32" ] && [ `uname` = "Linux" ]
-then
-    ctest -T memcheck | tee memcheck.log
 
     ret=${PIPESTATUS[0]}
     if [ $ret -ne 0 ]
@@ -72,4 +46,15 @@ then
     fi
 fi
 
-exit 0
+if [ "${ARCH}" != "32" ]; then
+    cd test-install || exit 1
+
+    mkdir $build_dir
+    cmake \
+        -D CMAKE_PREFIX_PATH="$prefix_dir;${HOME}/boost-prefix/${ARCH}" \
+        -B $build_dir \
+        -S . || exit 1
+    cmake --build $build_dir --target all || exit 1
+
+    $build_dir/test-install || exit 1
+fi

ci/build_regression.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+build_dir="$CXX-build"
+mkdir $build_dir || exit 1
+
+if [ "${ARCH}" == "32" ]
+then
+    echo "64 bit support required for regressions"
+    exit 1
+fi
+
+cmake \
+    -D CMAKE_PREFIX_PATH="${HOME}/boost-prefix/${ARCH};${HOME}/zlib-prefix/${ARCH}" \
+    -D MSGPACK_FUZZ_REGRESSION="ON" \
+    -D ${MSGPACK_CXX_VERSION} \
+    -D MSGPACK_CHAR_SIGN=${CHAR_SIGN} \
+    -D MSGPACK_DEFAULT_API_VERSION=${API_VERSION} \
+    -D MSGPACK_USE_X3_PARSE=${X3_PARSE} \
+    -D CMAKE_CXX_FLAGS="${CXXFLAGS}" \
+    -B $build_dir \
+    -S . || exit 1
+
+cmake --build $build_dir --target all || exit 1
+
+ctest -VV --test-dir $build_dir || exit 1

ci/set_gcc_10.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+version=10
+priority=100
+
+sudo update-alternatives --install /usr/bin/gcc         gcc         /usr/bin/gcc-${version}         ${priority}
+sudo update-alternatives --install /usr/bin/gcc-ar      gcc-ar      /usr/bin/gcc-ar-${version}      ${priority}
+sudo update-alternatives --install /usr/bin/gcc-nm      gcc-nm      /usr/bin/gcc-nm-${version}      ${priority}
+sudo update-alternatives --install /usr/bin/gcc-ranlib  gcc-ranlib  /usr/bin/gcc-ranlib-${version}  ${priority}
+sudo update-alternatives --install /usr/bin/gcov        gcov        /usr/bin/gcov-${version}        ${priority}
+sudo update-alternatives --install /usr/bin/gcov-dump   gcov-dump   /usr/bin/gcov-dump-${version}   ${priority}
+sudo update-alternatives --install /usr/bin/gcov-tool   gcov-tool   /usr/bin/gcov-tool-${version}   ${priority}
+sudo update-alternatives --install /usr/bin/lto-dump    lto-dump    /usr/bin/lto-dump-${version}    ${priority}
+sudo update-alternatives --install /usr/bin/g++         g++         /usr/bin/g++-${version}         ${priority}
+
+sudo update-alternatives --install /usr/bin/cc   cc   /usr/bin/gcc-${version} ${priority}
+sudo update-alternatives --install /usr/bin/c++  c++  /usr/bin/g++-${version} ${priority}

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()

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"

erb/v1/cpp03_define_array.hpp.erb

@@ -66,14 +66,16 @@ struct define_array<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
             msgpack::object *ptr = o.via.array.ptr;
             switch(size) {
             default:<%(i).downto(0) {|j|%>
-            case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%>
+            case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);
+            // fallthrough
+<%}%>
             }
         }
     }
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::ARRAY;
-        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
+        o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*<%=i+1%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o->via.array.size = <%=i+1%>;
         <%0.upto(i) {|j|%>
         o->via.array.ptr[<%=j%>] = msgpack::object(a<%=j%>, z);<%}%>

erb/v1/cpp03_define_map.hpp.erb

@@ -61,6 +61,7 @@ struct define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
         if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
         std::map<std::string, msgpack::object const*> kvmap;
         for (uint32_t i = 0; i < o.via.map.size; ++i) {
+            if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
             kvmap.insert(
                 std::map<std::string, msgpack::object const*>::value_type(
                     std::string(
@@ -82,7 +83,7 @@ struct define_map<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
     void msgpack_object(msgpack::object* o, msgpack::zone& z) const
     {
         o->type = msgpack::type::MAP;
-        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*<%=(i+1)/2%>));
+        o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*<%=(i+1)/2%>, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         o->via.map.size = <%=(i+1)/2%>;
         <%0.step(i,2) {|j|%>
         o->via.map.ptr[<%=j/2%>].key = msgpack::object(a<%=j%>, z);

erb/v1/cpp03_msgpack_tuple.hpp.erb

@@ -121,7 +121,7 @@ inline tuple<> make_tuple()
 /// @cond
 <%0.upto(GENERATION_LIMIT) {|i|%>
 template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-inline tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
+tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& a<%=j%><%}%>)
 {
     return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
 }
@@ -207,7 +207,7 @@ struct object_with_zone<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> > {
         msgpack::object::with_zone& o,
         const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) const {
         o.type = msgpack::type::ARRAY;
-        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>));
+        o.via.array.ptr = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*<%=i+1%>, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.size = <%=i+1%>;
         <%0.upto(i) {|j|%>
         o.via.array.ptr[<%=j%>] = msgpack::object(v.template get<<%=j%>>(), o.zone);<%}%>

erb/v1/cpp03_msgpack_tuple_decl.hpp.erb

@@ -54,7 +54,7 @@ tuple<> make_tuple();
 /// @cond
 <%0.upto(GENERATION_LIMIT) {|i|%>
 template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
-tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>);
+tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(A0 const& a0<%1.upto(i) {|j|%>, A<%=j%> const& a<%=j%><%}%>);
 <%}%>
 /// @endcond
 

erb/v1/cpp03_zone.hpp.erb

@@ -10,7 +10,15 @@
 #ifndef MSGPACK_V1_CPP03_ZONE_HPP
 #define MSGPACK_V1_CPP03_ZONE_HPP
 
+#include "msgpack/versioning.hpp"
+#include "msgpack/cpp_config.hpp"
 #include "msgpack/zone_decl.hpp"
+#include "msgpack/assert.hpp"
+
+#include <stdint.h>
+#include <cstdlib>
+#include <memory>
+#include <vector>
 
 <% GENERATION_LIMIT = 15 %>
 namespace msgpack {
@@ -55,7 +63,7 @@ class zone {
             ++m_tail;
         }
         void push_expand(void (*func)(void*), void* data) {
-            const size_t nused = m_end - m_array;
+            const size_t nused = static_cast<size_t>(m_end - m_array);
             size_t nnext;
             if(nused == 0) {
                 nnext = (sizeof(finalizer) < 72/2) ?
@@ -178,7 +186,9 @@ private:
     template <typename T>
     static void object_delete(void* obj);
 
-    void* allocate_expand(size_t size);
+    static char* get_aligned(char* ptr, size_t align);
+
+    char* allocate_expand(size_t size);
 private:
     zone(const zone&);
     zone& operator=(const zone&);
@@ -188,37 +198,43 @@ inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_
 {
 }
 
+inline char* zone::get_aligned(char* ptr, size_t align)
+{
+    MSGPACK_ASSERT(align != 0 && (align & (align - 1)) == 0); // align must be 2^n (n >= 0)
+    return
+        reinterpret_cast<char*>(
+            reinterpret_cast<uintptr_t>(ptr + (align - 1)) & ~static_cast<uintptr_t>(align - 1)
+        );
+}
+
 inline void* zone::allocate_align(size_t size, size_t align)
 {
-    char* aligned =
+    char* aligned = get_aligned(m_chunk_list.m_ptr, align);
-        reinterpret_cast<char*>(
+    size_t adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
-            reinterpret_cast<size_t>(
+    if (m_chunk_list.m_free < adjusted_size) {
-                (m_chunk_list.m_ptr + (align - 1))) / align * align);
+        size_t enough_size = size + align - 1;
-    size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr);
+        char* ptr = allocate_expand(enough_size);
-    if(m_chunk_list.m_free >= adjusted_size) {
+        aligned = get_aligned(ptr, align);
-        m_chunk_list.m_free -= adjusted_size;
+        adjusted_size = size + static_cast<size_t>(aligned - m_chunk_list.m_ptr);
-        m_chunk_list.m_ptr  += adjusted_size;
-        return aligned;
     }
-    return reinterpret_cast<char*>(
+    m_chunk_list.m_free -= adjusted_size;
-        reinterpret_cast<size_t>(
+    m_chunk_list.m_ptr  += adjusted_size;
-            allocate_expand(size + (align - 1))) / align * align);
+    return aligned;
 }
 
 inline void* zone::allocate_no_align(size_t size)
 {
-    if(m_chunk_list.m_free < size) {
-        return allocate_expand(size);
-    }
-
     char* ptr = m_chunk_list.m_ptr;
+    if(m_chunk_list.m_free < size) {
+        ptr = allocate_expand(size);
+    }
     m_chunk_list.m_free -= size;
     m_chunk_list.m_ptr  += size;
 
     return ptr;
 }
 
-inline void* zone::allocate_expand(size_t size)
+inline char* zone::allocate_expand(size_t size)
 {
     chunk_list* const cl = &m_chunk_list;
 
@@ -240,8 +256,8 @@ inline void* zone::allocate_expand(size_t size)
 
     c->m_next  = cl->m_head;
     cl->m_head = c;
-    cl->m_free = sz - size;
+    cl->m_free = sz;
-    cl->m_ptr  = ptr + size;
+    cl->m_ptr  = ptr;
 
     return ptr;
 }
@@ -300,7 +316,7 @@ inline std::size_t aligned_size(
 template <typename T<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
 T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
 {
-    void* x = allocate_align(sizeof(T));
+    void* x = allocate_align(sizeof(T), MSGPACK_ZONE_ALIGNOF(T));
     try {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {

erb/v1/cpp03_zone_decl.hpp.erb

@@ -24,6 +24,14 @@
 #define MSGPACK_ZONE_ALIGN sizeof(void*)
 #endif
 
+#if defined(_MSC_VER)
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof(type)
+#else
+#define MSGPACK_ZONE_ALIGNOF(type) __alignof__(type)
+#endif
+// For a compiler that doesn't support __alignof__:
+// #define MSGPACK_ZONE_ALIGNOF(type) MSGPACK_ZONE_ALIGN
+
 <% GENERATION_LIMIT = 15 %>
 namespace msgpack {
 

example/CMakeLists.txt

@@ -1,5 +1,9 @@
-ADD_SUBDIRECTORY (c)
 ADD_SUBDIRECTORY (cpp03)
 ADD_SUBDIRECTORY (cpp11)
-ADD_SUBDIRECTORY (boost)
+
-ADD_SUBDIRECTORY (x3)
+IF (MSGPACK_USE_BOOST)
+    ADD_SUBDIRECTORY (boost)
+    IF (MSGPACK_USE_X3_PARSE)
+        ADD_SUBDIRECTORY (x3)
+    ENDIF ()
+ENDIF ()

example/boost/CMakeLists.txt

@@ -1,8 +1,17 @@
-IF (MSGPACK_BOOST)
+FIND_PACKAGE (Boost REQUIRED COMPONENTS system)
-    LIST (APPEND exec_PROGRAMS
+FIND_PACKAGE (Threads REQUIRED)
-        msgpack_variant_capitalize.cpp
+FIND_PACKAGE (ZLIB REQUIRED)
-        msgpack_variant_mapbased.cpp
+
-    )
+LIST (APPEND exec_PROGRAMS
+    msgpack_variant_capitalize.cpp
+    msgpack_variant_mapbased.cpp
+)
+
+IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17 OR MSGPACK_CXX20)
+    LIST (APPEND exec_PROGRAMS asio_send_recv.cpp)
+    IF (ZLIB_FOUND)
+        LIST (APPEND exec_PROGRAMS asio_send_recv_zlib.cpp)
+    ENDIF ()
 ENDIF ()
 
 FOREACH (source_file ${exec_PROGRAMS})
@@ -11,11 +20,19 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
+        msgpackc-cxx
+        Boost::system
+        Threads::Threads
+    )
+    IF (ZLIB_FOUND)
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE ZLIB::ZLIB)
+    ENDIF ()
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
     ENDIF ()
 
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
 

example/boost/asio_send_recv.cpp

@@ -0,0 +1,104 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2017 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)
+//
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+#include <boost/asio.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include <msgpack.hpp>
+
+int main() {
+    boost::asio::io_service ios;
+    std::uint16_t const port = 12345;
+
+    // Server
+    std::size_t const window_size = 10;
+    boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
+    boost::asio::ip::tcp::socket ss(ios);
+    std::function<void()> do_accept;
+    std::function<void()> do_async_read_some;
+
+    msgpack::unpacker unp;
+
+    do_accept = [&] {
+        ac.async_accept(
+            ss,
+            [&]
+            (boost::system::error_code const& e) {
+                if (e) {
+                    std::cout << __LINE__ << ":" << e.message() << std::endl;
+                    return;
+                }
+                do_async_read_some = [&] {
+                    unp.reserve_buffer(window_size);
+                    ss.async_read_some(
+                        boost::asio::buffer(unp.buffer(), window_size),
+                        [&](boost::system::error_code const& e, std::size_t bytes_transferred) {
+                            if (e) {
+                                std::cout << __LINE__ << ":" << e.message() << std::endl;
+                                return;
+                            }
+                            std::cout << bytes_transferred << " bytes read." << std::endl;
+                            unp.buffer_consumed(bytes_transferred);
+                            msgpack::object_handle oh;
+                            while (unp.next(oh)) {
+                                std::cout << oh.get() << std::endl;
+                                // In order to finish the program,
+                                // return if one complete msgpack is processed.
+                                // In actual server, don't return here.
+                                return;
+                            }
+                            do_async_read_some();
+                        }
+                    );
+                };
+                do_async_read_some();
+            }
+        );
+    };
+    do_accept();
+
+    // Client
+    auto host = "localhost";
+    boost::asio::ip::tcp::resolver r(ios);
+
+#if BOOST_VERSION < 106600
+    boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port));
+    auto it = r.resolve(q);
+    boost::asio::ip::tcp::resolver::iterator end;
+#else  // BOOST_VERSION < 106600
+    auto eps = r.resolve(host, boost::lexical_cast<std::string>(port));
+    auto it = eps.begin();
+    auto end = eps.end();
+#endif // BOOST_VERSION < 106600
+
+    boost::asio::ip::tcp::socket cs(ios);
+    boost::asio::async_connect(
+        cs,
+        it,
+        end,
+        [&]
+        (boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) {
+            if (e) {
+                std::cout << __LINE__ << ":" << e.message() << std::endl;
+                return;
+            }
+            std::cout << __LINE__ << ":client connected" << std::endl;
+            msgpack::sbuffer sb;
+            msgpack::pack(sb, std::make_tuple(42, false, "hello world", 12.3456));
+            write(cs, boost::asio::buffer(sb.data(), sb.size()));
+        }
+    );
+
+    // Start
+    ios.run();
+}

example/boost/asio_send_recv_zlib.cpp

@@ -0,0 +1,176 @@
+// MessagePack for C++ example
+//
+// Copyright (C) 2017 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)
+//
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+#include <boost/asio.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include <msgpack.hpp>
+#include <msgpack/zbuffer.hpp>
+
+#include <zlib.h>
+
+void print(std::string const& buf) {
+    for (std::string::const_iterator it = buf.begin(), end = buf.end();
+         it != end;
+         ++it) {
+        std::cout
+            << std::setw(2)
+            << std::hex
+            << std::setfill('0')
+            << (static_cast<int>(*it) & 0xff)
+            << ' ';
+    }
+    std::cout << std::dec << std::endl;
+}
+
+int main() {
+    boost::asio::io_service ios;
+    std::uint16_t const port = 12345;
+
+    int num_of_zlib_data = 2;
+    int idx_zlib_data = 0;
+
+    // Server
+    std::size_t const window_size = 11;
+    boost::asio::ip::tcp::acceptor ac(ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
+    boost::asio::ip::tcp::socket ss(ios);
+    std::function<void()> do_accept;
+    std::function<void()> do_async_read_some;
+
+    // zlib for decompress
+    z_stream strm;
+    auto zlib_init = [&] {
+        strm.zalloc = Z_NULL;
+        strm.zfree = Z_NULL;
+        strm.opaque = Z_NULL;
+        strm.next_in = Z_NULL;
+        {
+            int zret = inflateInit(&strm);
+            if (zret != Z_OK) {
+                std::cout << "Zlib inflateInit() error = " << zret << std::endl;
+            }
+        }
+    };
+    zlib_init();
+    std::vector<char> buf(4); // buf size
+
+    msgpack::unpacker unp;
+
+    do_accept = [&] {
+        ac.async_accept(
+            ss,
+            [&]
+            (boost::system::error_code const& e) {
+                if (e) {
+                    std::cout << __LINE__ << ":" << e.message() << std::endl;
+                    return;
+                }
+                do_async_read_some = [&] {
+                    ss.async_read_some(
+                        boost::asio::buffer(buf),
+                        [&](boost::system::error_code const& e, std::size_t bytes_transferred) {
+                            if (e) {
+                                std::cout << __LINE__ << ":" << e.message() << std::endl;
+                                return;
+                            }
+                            std::cout << bytes_transferred << " bytes read." << std::endl;
+                            print(std::string(std::string(&buf[0], buf.size())));
+                            strm.avail_in = static_cast<uInt>(bytes_transferred);
+                            do {
+                                strm.next_in = reinterpret_cast<unsigned char*>(&buf[0]) + (bytes_transferred - strm.avail_in);
+                                int zret;
+                                unp.reserve_buffer(window_size);
+                                strm.avail_out = static_cast<uInt>(window_size);
+                                strm.next_out = reinterpret_cast<unsigned char*>(unp.buffer());
+                                do {
+                                    zret = inflate(&strm, Z_NO_FLUSH);
+                                    assert(zret != Z_STREAM_ERROR);
+                                    switch (zret) {
+                                    case Z_NEED_DICT:
+                                        zret = Z_DATA_ERROR;
+                                        // fall through
+                                    case Z_DATA_ERROR:
+                                    case Z_MEM_ERROR:
+                                        inflateEnd(&strm);
+                                        std::cout << "Zlib inflate() error = " << zret << std::endl;
+                                        std::exit(-1);
+                                    }
+                                    std::size_t decompressed_size = window_size - strm.avail_out;
+                                    std::cout << decompressed_size << " bytes decompressed." << std::endl;
+                                    unp.buffer_consumed(decompressed_size);
+                                    msgpack::object_handle oh;
+                                    while (unp.next(oh)) {
+                                        std::cout << oh.get() << std::endl;
+                                    }
+                                } while (strm.avail_out == 0);
+                                if (zret == Z_STREAM_END) {
+                                    inflateEnd(&strm);
+                                    std::cout << "Zlib decompress finished." << std::endl;
+                                    ++idx_zlib_data;
+                                    if (idx_zlib_data == num_of_zlib_data) {
+                                        std::cout << "All zlib decompress finished." << std::endl;
+                                        return;
+                                    }
+                                    zlib_init();
+                                }
+                            } while (strm.avail_in != 0);
+                            do_async_read_some();
+                        }
+                    );
+                };
+                do_async_read_some();
+            }
+        );
+    };
+    do_accept();
+
+    // Client
+    auto host = "localhost";
+
+    boost::asio::ip::tcp::resolver r(ios);
+
+#if BOOST_VERSION < 106600
+    boost::asio::ip::tcp::resolver::query q(host, boost::lexical_cast<std::string>(port));
+    auto it = r.resolve(q);
+    boost::asio::ip::tcp::resolver::iterator end;
+#else  // BOOST_VERSION < 106600
+    auto eps = r.resolve(host, boost::lexical_cast<std::string>(port));
+    auto it = eps.begin();
+    auto end = eps.end();
+#endif // BOOST_VERSION < 106600
+
+    boost::asio::ip::tcp::socket cs(ios);
+    boost::asio::async_connect(
+        cs,
+        it,
+        end,
+        [&]
+        (boost::system::error_code const& e, boost::asio::ip::tcp::resolver::iterator) {
+            if (e) {
+                std::cout << __LINE__ << ":" << e.message() << std::endl;
+                return;
+            }
+            std::cout << __LINE__ << ":client connected" << std::endl;
+            for (int i = 0; i != num_of_zlib_data; ++i) {
+                msgpack::zbuffer zb;
+                msgpack::pack(zb, std::make_tuple(i, false, "hello world", 12.3456));
+                zb.flush(); // finalize zbuffer (don't forget it)
+                print(std::string(zb.data(), zb.size()));
+                write(cs, boost::asio::buffer(zb.data(), zb.size()));
+            }
+        }
+    );
+
+    // Start
+    ios.run();
+}

example/boost/msgpack_variant_mapbased.cpp

@@ -83,7 +83,8 @@ int main() {
     u.address = "Tokyo";
     msgpack::pack(ss, u);
 
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     msgpack::object const& obj = oh.get();
     std::cout << "Unpacked msgpack object." << std::endl;
     std::cout << obj << std::endl;

example/c/CMakeLists.txt

@@ -1,40 +0,0 @@
-IF (MSGPACK_ENABLE_SHARED)
-    SET (MSGPACK_LIB msgpackc)
-ELSE ()
-    SET (MSGPACK_LIB msgpackc-static)
-ENDIF ()
-
-
-LIST (APPEND exec_PROGRAMS
-    lib_buffer_unpack.c
-    simple_c.c
-    speed_test_uint32_array.c
-    speed_test_uint64_array.c
-    user_buffer_unpack.c
-)
-
-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_LIB}
-    )
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
-    ENDIF ()
-
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-            STRING(REGEX REPLACE "/W[0-4]" "/W3 /WX" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        ELSE ()
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3 /WX")
-        ENDIF ()
-    ENDIF ()
-ENDFOREACH ()

example/c/lib_buffer_unpack.c

@@ -1,127 +0,0 @@
-#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/c/simple_c.c

@@ -1,47 +0,0 @@
-#include <msgpack.h>
-#include <stdio.h>
-
-void print(char const* buf, unsigned int 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/c/speed_test_uint32_array.c

@@ -1,36 +0,0 @@
-#include <msgpack.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);
-
-    pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
-
-    msgpack_pack_array(pk, size);
-    {
-        size_t idx = 0;
-        for (; idx < size; ++idx)
-            msgpack_pack_uint32(pk, 1);
-    }
-    msgpack_packer_free(pk);
-
-    msgpack_unpacked_init(&msg);
-
-    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
-    }
-
-    msgpack_sbuffer_destroy(&buf);
-}
-
-int main(void)
-{
-    int i = 0;
-    for (; i < 10; ++i) test();
-    return 0;
-}

example/c/speed_test_uint64_array.c

@@ -1,37 +0,0 @@
-#include <msgpack.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);
-
-    pk = msgpack_packer_new(&buf, msgpack_sbuffer_write);
-
-    msgpack_pack_array(pk, size);
-    {
-        size_t idx = 0;
-        for (; idx < size; ++idx)
-            msgpack_pack_uint64(pk, test_u64);
-    }
-    msgpack_packer_free(pk);
-
-    msgpack_unpacked_init(&msg);
-
-    while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) {
-    }
-
-    msgpack_sbuffer_destroy(&buf);
-}
-
-int main(void)
-{
-    int i = 0;
-    for (; i < 10; ++i) test();
-    return 0;
-}

example/c/user_buffer_unpack.c

@@ -1,81 +0,0 @@
-#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.
-*/

example/cpp03/CMakeLists.txt

@@ -1,3 +1,7 @@
+FIND_PACKAGE (Threads REQUIRED)
+
+FIND_PACKAGE (Boost COMPONENTS timer)
+
 LIST (APPEND exec_PROGRAMS
     class_intrusive.cpp
     class_intrusive_map.cpp
@@ -22,11 +26,14 @@ IF (NOT MSVC)
     )
 ENDIF ()
 
-IF (Boost_TIMER_LIBRARY AND Boost_CHRONO_LIBRARY AND Boost_SYSTEM_LIBRARY)
+
-    LIST (APPEND with_boost_lib_PROGRAMS
+IF (MSGPACK_USE_BOOST)
-        speed_test.cpp
+    IF (Boost_TIMER_LIBRARY)
-        speed_test_nested_array.cpp
+        LIST (APPEND with_boost_lib_PROGRAMS
-    )
+            speed_test.cpp
+            speed_test_nested_array.cpp
+        )
+    ENDIF ()
 ENDIF ()
 
 FOREACH (source_file ${exec_PROGRAMS})
@@ -35,8 +42,11 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
+        msgpackc-cxx
+    )
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
     ENDIF ()
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
         IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
@@ -53,11 +63,12 @@ FOREACH (source_file ${with_pthread_PROGRAMS})
         ${source_file_we}
         ${source_file}
     )
-    TARGET_LINK_LIBRARIES (${source_file_we}
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-        ${CMAKE_THREAD_LIBS_INIT}
+        msgpackc-cxx
+        Threads::Threads
     )
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3")
+        SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
     ENDIF ()
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
         IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
@@ -69,32 +80,26 @@ FOREACH (source_file ${with_pthread_PROGRAMS})
 ENDFOREACH ()
 
 FOREACH (source_file ${with_boost_lib_PROGRAMS})
-    INCLUDE_DIRECTORIES (
-        ../include
-        ${Boost_INCLUDE_DIRS}
-    )
     GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
     ADD_EXECUTABLE (
         ${source_file_we}
         ${source_file}
     )
-    LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
+    TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-    TARGET_LINK_LIBRARIES (${source_file_we}
+        msgpackc-cxx
-        ${Boost_TIMER_LIBRARY}
+        Boost::timer
-        ${Boost_CHRONO_LIBRARY}
-        ${Boost_SYSTEM_LIBRARY}
     )
     IF (NOT MSVC AND NOT APPLE)
-        TARGET_LINK_LIBRARIES (${source_file_we}
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
             rt
         )
     ENDIF ()
 
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -O3")
     ENDIF ()
 
-    IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
 

example/cpp03/class_intrusive.cpp

@@ -82,10 +82,11 @@ int main() {
         std::stringstream ss;
         msgpack::pack(ss, my);
 
-        print(ss.str());
+        std::string const& str = ss.str();
+        print(str);
 
         msgpack::object_handle oh =
-            msgpack::unpack(ss.str().data(), ss.str().size());
+            msgpack::unpack(str.data(), str.size());
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);

example/cpp03/class_intrusive_map.cpp

@@ -59,8 +59,9 @@ int main() {
 
         print(ss.str());
 
+        std::string const& str = ss.str();
         msgpack::object_handle oh =
-            msgpack::unpack(ss.str().data(), ss.str().size());
+            msgpack::unpack(str.data(), str.size());
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);

example/cpp03/class_non_intrusive.cpp

@@ -69,7 +69,7 @@ struct object_with_zone<my_class> {
         o.type = type::ARRAY;
         o.via.array.size = 2;
         o.via.array.ptr = static_cast<msgpack::object*>(
-            o.zone.allocate_align(sizeof(msgpack::object) * o.via.array.size));
+            o.zone.allocate_align(sizeof(msgpack::object) * o.via.array.size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         o.via.array.ptr[0] = msgpack::object(v.get_name(), o.zone);
         o.via.array.ptr[1] = msgpack::object(v.get_age(), o.zone);
     }
@@ -100,10 +100,11 @@ int main() {
         std::stringstream ss;
         msgpack::pack(ss, my);
 
-        print(ss.str());
+        std::string const& str = ss.str();
+        print(str);
 
         msgpack::object_handle oh =
-            msgpack::unpack(ss.str().data(), ss.str().size());
+            msgpack::unpack(str.data(), str.size());
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);

example/cpp03/map_based_versionup.cpp

@@ -71,7 +71,8 @@ int main() {
 
         print(ss.str());
 
-        msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+        std::string const& str = ss.str();
+        msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;

example/cpp03/reuse_zone.cpp

@@ -31,12 +31,13 @@ int main() {
     std::size_t offset = 0;
 
     // msgpack array is constructed on z.
-    msgpack::object obj = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset);
+    std::string const& ps = ss.str();
+    msgpack::object obj = msgpack::unpack(z, ps.data(), ps.size(), offset);
     std::cout << obj << std::endl;
     assert(obj.as<std::vector<int> >() == v);
 
     // msgpack str is constructed on z.
-    std::string const& str = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset).as<std::string>();
+    std::string const& str = msgpack::unpack(z, ps.data(), ps.size(), offset).as<std::string>();
     std::cout << str << std::endl;
     assert(str == s);
 }

example/cpp11/CMakeLists.txt

@@ -1,8 +1,4 @@
-IF (MSGPACK_CXX11)
+IF (MSGPACK_CXX11 OR MSGPACK_CXX14 OR MSGPACK_CXX17)
-    INCLUDE_DIRECTORIES (
-        ../include
-    )
-
     LIST (APPEND exec_PROGRAMS
         container.cpp
         non_def_con_class.cpp
@@ -20,11 +16,14 @@ IF (MSGPACK_CXX11)
             ${source_file_we}
             ${source_file}
         )
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g -O3 ")
+            msgpackc-cxx
+        )
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
         ENDIF ()
 
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
             SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
         ENDIF ()
 

example/cpp11/container.cpp

@@ -25,8 +25,9 @@ void array() {
     std::stringstream ss;
     msgpack::pack(ss, a);
 
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
-    msgpack::object obj = oh.get();
+    auto oh = msgpack::unpack(str.data(), str.size());
+    auto obj = oh.get();
 
     std::cout << obj << std::endl;
     assert((obj.as<std::array<int, 5>>()) == a);
@@ -37,7 +38,8 @@ void tuple() {
     std::stringstream ss;
     msgpack::pack(ss, t);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -49,7 +51,8 @@ void unordered_map() {
     std::stringstream ss;
     msgpack::pack(ss, m);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     msgpack::object obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -61,7 +64,8 @@ void unordered_set() {
     std::stringstream ss;
     msgpack::pack(ss, s);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -74,7 +78,8 @@ void forward_list() {
     std::stringstream ss;
     msgpack::pack(ss, f);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -98,7 +103,8 @@ void combi() {
     std::size_t offset = 0;
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -106,7 +112,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -114,7 +121,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -122,7 +130,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -130,7 +139,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;

example/x3/CMakeLists.txt

@@ -1,28 +1,27 @@
-IF (MSGPACK_USE_X3_PARSE)
+IF (MSGPACK_USE_X3_PARSE AND MSGPACK_DEFAULT_API_VERSION VERSION_GREATER 1)
-    INCLUDE_DIRECTORIES (
+    FIND_PACKAGE (Boost REQUIRED COMPONENTS context system)
-        ../include
+    FIND_PACKAGE (Threads REQUIRED)
-    )
 
     LIST (APPEND exec_PROGRAMS
         unpack.cpp
         parse.cpp
     )
-    IF (Boost_CONTEXT_LIBRARY AND Boost_SYSTEM_LIBRARY AND CMAKE_THREAD_LIBS_INIT)
+    LIST (APPEND with_boost_PROGRAMS
-        LIST (APPEND with_boost_PROGRAMS
+        stream_unpack.cpp
-            stream_unpack.cpp
+    )
-        )
-    ENDIF ()
     FOREACH (source_file ${exec_PROGRAMS})
         GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
         ADD_EXECUTABLE (
             ${source_file_we}
             ${source_file}
         )
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE msgpackc-cxx)
-            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g ")
+
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
         ENDIF ()
 
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
             SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
         ENDIF ()
 
@@ -40,16 +39,17 @@ IF (MSGPACK_USE_X3_PARSE)
             ${source_file_we}
             ${source_file}
         )
-        TARGET_LINK_LIBRARIES (${source_file_we}
+        TARGET_LINK_LIBRARIES (${source_file_we} PRIVATE
-            ${Boost_CONTEXT_LIBRARY}
+            msgpackc-cxx
-            ${Boost_SYSTEM_LIBRARY}
+            Boost::context
-            ${CMAKE_THREAD_LIBS_INIT}
+            Boost::system
+            Threads::Threads
         )
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Werror -g ")
+            SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")
         ENDIF ()
 
-        IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
             SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
         ENDIF ()
 

example/x3/parse.cpp

@@ -40,7 +40,13 @@ struct json_like_visitor : msgpack::v2::null_visitor {
         m_s += ss.str();
         return true;
     }
-    bool visit_float(double v) {
+    bool visit_float32(float v) {
+        std::stringstream ss;
+        ss << v;
+        m_s += ss.str();
+        return true;
+    }
+    bool visit_float64(double v) {
         std::stringstream ss;
         ss << v;
         m_s += ss.str();

example/x3/stream_unpack.cpp

@@ -21,8 +21,17 @@
 
 #include <boost/asio.hpp>
 #include <boost/coroutine2/all.hpp>
+
+#if defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif // defined(__clang__)
+
 #include <boost/spirit/home/support/multi_pass.hpp>
 
+#if defined(__clang__)
+#pragma GCC diagnostic pop
+#endif // defined(__clang__)
 
 namespace as = boost::asio;
 namespace x3 = boost::spirit::x3;

fuzz/CMakeLists.txt

@@ -0,0 +1,38 @@
+FIND_PACKAGE (Threads REQUIRED)
+FIND_PACKAGE (Boost REQUIRED COMPONENTS system filesystem unit_test_framework)
+
+LIST (APPEND check_PROGRAMS
+    regression_runner.cpp
+)
+
+FOREACH (source_file ${check_PROGRAMS})
+    GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE)
+    ADD_EXECUTABLE (
+        ${source_file_we}
+        ${source_file}
+    )
+
+    TARGET_COMPILE_DEFINITIONS (${source_file_we} PRIVATE
+        $<IF:$<BOOL:${MSGPACK_USE_STATIC_BOOST}>,,BOOST_TEST_DYN_LINK>)
+
+    TARGET_LINK_LIBRARIES (${source_file_we}
+        msgpackc-cxx
+        Threads::Threads
+        Boost::filesystem
+        Boost::system
+        Boost::unit_test_framework
+    )
+
+    ADD_TEST (${source_file_we} ${source_file_we})
+
+    IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+      SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -Wextra -Wno-mismatched-tags -g")
+        IF ("${MSGPACK_SAN}" STREQUAL "ASAN")
+            SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
+            SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
+        ELSEIF ("${MSGPACK_SAN}" STREQUAL "UBSAN")
+            SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined")
+            SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined")
+        ENDIF()
+    ENDIF()
+ENDFOREACH ()

fuzz/regression_runner.cpp

@@ -0,0 +1,49 @@
+#include <boost/filesystem.hpp>
+
+// Use parameterized tests instead of modern data-driven test cases
+// because BOOST_DATA_TEST_CASE requires C++11 or newer. See:
+// - https://www.boost.org/doc/libs/1_76_0/libs/test/doc/html/boost_test/tests_organization/test_cases/param_test.html
+// - https://www.boost.org/doc/libs/1_76_0/libs/test/doc/html/boost_test/tests_organization/test_cases/test_case_generation.html
+#include <boost/test/included/unit_test.hpp>
+#include <boost/test/parameterized_test.hpp>
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "unpack_pack_fuzzer.cpp"
+
+std::vector<std::string> ListDirectory(const std::string& path) {
+  std::vector<std::string> v;
+
+  boost::filesystem::path p(path);
+  boost::filesystem::directory_iterator f(p);
+
+  if (boost::filesystem::is_directory(p)) {
+    while (f != boost::filesystem::directory_iterator()) {
+      v.push_back((*f++).path().string());
+    }
+  }
+  return v;
+}
+
+void UnpackPackFuzzerRegressionTest(const std::string& fpath) {
+  std::ifstream in(fpath.c_str(), std::ios_base::binary);
+  if (!in) {
+    BOOST_FAIL(fpath + " not found");
+  }
+  in.seekg(0, in.end);
+  size_t length = in.tellg();
+  in.seekg(0, in.beg);
+  std::vector<char> bytes(length);
+  in.read(bytes.data(), bytes.size());
+  BOOST_REQUIRE(in);
+  BOOST_REQUIRE_EQUAL(0, LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t *>(bytes.data()), bytes.size()));
+}
+
+boost::unit_test::test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[])
+{
+  std::vector<std::string> files = ListDirectory("../../fuzz/unpack_pack_fuzzer_regressions");
+  boost::unit_test::framework::master_test_suite().add(BOOST_PARAM_TEST_CASE(&UnpackPackFuzzerRegressionTest, files.begin(), files.end()));
+  return 0;
+}

fuzz/unpack_pack_fuzzer.cpp

@@ -0,0 +1,27 @@
+#include <msgpack.hpp>
+
+// The function's signature must NOT be changed since other projects rely on it:
+// - libFuzzer
+// - AFL++
+// - Google's oss-fuzz (uses the previous two ones)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  try {
+    // NOTE(derwolfe): by default the limits are set at 2^32-1 length. I'm
+    // setting these at far smaller values to avoid OOMs
+    const int test_limit = 1000;
+    msgpack::object_handle unpacked = msgpack::unpack(reinterpret_cast<const char *>(data),
+                                                      size,
+                                                      MSGPACK_NULLPTR,
+                                                      MSGPACK_NULLPTR,
+                                                      msgpack::unpack_limit(test_limit,
+                                                                            test_limit,
+                                                                            test_limit,
+                                                                            test_limit,
+                                                                            test_limit,
+                                                                            test_limit));
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, unpacked.get());
+  } catch (...) {
+  }
+  return 0;
+}

fuzz/unpack_pack_fuzzer_seed_corpus/EmptyArray

@@ -0,0 +1 @@
+<EFBFBD>

fuzz/unpack_pack_fuzzer_seed_corpus/EmptyObject

@@ -0,0 +1 @@
+<EFBFBD>

fuzz/unpack_pack_fuzzer_seed_corpus/ExcessiveNesting

@@ -0,0 +1,2 @@
+<EFBFBD>
<01><02><03><04><05><06><07><08>	<09>
+<EFBFBD><0B><0C>

include/msgpack.h

@@ -1,24 +0,0 @@
-/*
- * 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.hpp

@@ -11,7 +11,11 @@
 #include "msgpack/iterator.hpp"
 #include "msgpack/zone.hpp"
 #include "msgpack/pack.hpp"
+#include "msgpack/null_visitor.hpp"
+#include "msgpack/parse.hpp"
 #include "msgpack/unpack.hpp"
+#include "msgpack/x3_parse.hpp"
+#include "msgpack/x3_unpack.hpp"
 #include "msgpack/sbuffer.hpp"
 #include "msgpack/vrefbuffer.hpp"
 #include "msgpack/version.hpp"

include/msgpack/adaptor/adaptor_base.hpp

@@ -14,5 +14,6 @@
 
 #include "msgpack/v1/adaptor/adaptor_base.hpp"
 #include "msgpack/v2/adaptor/adaptor_base.hpp"
+#include "msgpack/v3/adaptor/adaptor_base.hpp"
 
 #endif // MSGPACK_ADAPTOR_BASE_HPP

include/msgpack/adaptor/adaptor_base_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/adaptor_base_decl.hpp"
 #include "msgpack/v2/adaptor/adaptor_base_decl.hpp"
+#include "msgpack/v3/adaptor/adaptor_base_decl.hpp"
 
 #endif // MSGPACK_ADAPTOR_BASE_DECL_HPP

include/msgpack/adaptor/array_ref_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/array_ref_decl.hpp"
 #include "msgpack/v2/adaptor/array_ref_decl.hpp"
+#include "msgpack/v3/adaptor/array_ref_decl.hpp"
 
 #endif // MSGPACK_TYPE_ARRAY_REF_DECL_HPP

include/msgpack/adaptor/boost/msgpack_variant_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp"
 #include "msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp"
+#include "msgpack/v3/adaptor/boost/msgpack_variant_decl.hpp"
 
 #endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP

include/msgpack/adaptor/boost/string_view.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2017 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_TYPE_BOOST_STRING_VIEW_HPP
+#define MSGPACK_TYPE_BOOST_STRING_VIEW_HPP
+
+#include "msgpack/v1/adaptor/boost/string_view.hpp"
+
+#endif // MSGPACK_TYPE_BOOST_STRING_VIEW_HPP

include/msgpack/adaptor/check_container_size_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/check_container_size_decl.hpp"
 #include "msgpack/v2/adaptor/check_container_size_decl.hpp"
+#include "msgpack/v3/adaptor/check_container_size_decl.hpp"
 
 #endif // MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP

include/msgpack/adaptor/complex.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2020 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_TYPE_COMPLEX_HPP
+#define MSGPACK_TYPE_COMPLEX_HPP
+
+#include "msgpack/v1/adaptor/complex.hpp"
+
+#endif // MSGPACK_TYPE_COMPLEX_HPP

include/msgpack/adaptor/cpp11/chrono.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2017 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_TYPE_CPP11_CHRONO_HPP
+#define MSGPACK_TYPE_CPP11_CHRONO_HPP
+
+#include "msgpack/v1/adaptor/cpp11/chrono.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_CHRONO_HPP

include/msgpack/adaptor/cpp11/timespec.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2019 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_TYPE_CPP11_TIMESPEC_HPP
+#define MSGPACK_TYPE_CPP11_TIMESPEC_HPP
+
+#include "msgpack/v1/adaptor/cpp11/timespec.hpp"
+
+#endif // MSGPACK_TYPE_CPP11_TIMESPEC_HPP

include/msgpack/adaptor/cpp17/array_byte.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2021 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_TYPE_CPP17_ARRAY_BYTE_HPP
+#define MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP
+
+#include "msgpack/v1/adaptor/cpp17/array_byte.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_ARRAY_BYTE_HPP

include/msgpack/adaptor/cpp17/byte.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// 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_TYPE_CPP17_BYTE_HPP
+#define MSGPACK_TYPE_CPP17_BYTE_HPP
+
+#include "msgpack/v1/adaptor/cpp17/byte.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_BYTE_HPP

include/msgpack/adaptor/cpp17/carray_byte.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// 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_TYPE_CPP17_CARRAY_BYTE_HPP
+#define MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP
+
+#include "msgpack/v1/adaptor/cpp17/carray_byte.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_CARRAY_BYTE_HPP

include/msgpack/adaptor/cpp17/optional.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2017 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_TYPE_CPP17_OPTIONAL_HPP
+#define MSGPACK_TYPE_CPP17_OPTIONAL_HPP
+
+#include "msgpack/v1/adaptor/cpp17/optional.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_OPTIONAL_HPP

include/msgpack/adaptor/cpp17/string_view.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2017 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_TYPE_CPP17_STRING_VIEW_HPP
+#define MSGPACK_TYPE_CPP17_STRING_VIEW_HPP
+
+#include "msgpack/v1/adaptor/cpp17/string_view.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_STRING_VIEW_HPP

include/msgpack/adaptor/cpp17/vector_byte.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// 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_TYPE_CPP17_VECTOR_BYTE_HPP
+#define MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP
+
+#include "msgpack/v1/adaptor/cpp17/vector_byte.hpp"
+
+#endif // MSGPACK_TYPE_CPP17_VECTOR_BYTE_HPP

include/msgpack/adaptor/cpp20/span.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2021 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_TYPE_CPP20_SPAN_HPP
+#define MSGPACK_TYPE_CPP20_SPAN_HPP
+
+#include "msgpack/v1/adaptor/cpp20/span.hpp"
+
+#endif // MSGPACK_TYPE_CPP20_SPAN_HPP

include/msgpack/adaptor/define_decl.hpp

@@ -10,37 +10,18 @@
 #ifndef MSGPACK_DEFINE_DECL_HPP
 #define MSGPACK_DEFINE_DECL_HPP
 
-// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
+#if defined(MSGPACK_NO_BOOST)
+
+// MSGPACK_PP_VARIADICS is defined in msgpack/preprocessor/config/config.hpp
 // http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
 // However, supporting compiler detection is not complete. msgpack-c requires
-// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
+// variadic macro arguments support. So MSGPACK_PP_VARIADICS is defined here explicitly.
 #if !defined(MSGPACK_PP_VARIADICS)
 #define MSGPACK_PP_VARIADICS
 #endif
 
 #include <msgpack/preprocessor.hpp>
 
-#include "msgpack/versioning.hpp"
-
-// for MSGPACK_ADD_ENUM
-#include "msgpack/adaptor/int.hpp"
-
-#define MSGPACK_DEFINE_ARRAY(...) \
-    template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \
-    } \
-    void msgpack_unpack(msgpack::object const& o) \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \
-    }\
-    template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
-    { \
-        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \
-    }
-
 #define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
 #define MSGPACK_NVP(name, value) (name) (value)
 
@@ -62,29 +43,108 @@
 
 #define MSGPACK_DEFINE_MAP(...) \
     template <typename Packer> \
-    void msgpack_pack(Packer& pk) const \
+    void msgpack_pack(Packer& msgpack_pk) const \
     { \
         msgpack::type::make_define_map \
             MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_pack(pk); \
+            .msgpack_pack(msgpack_pk); \
     } \
-    void msgpack_unpack(msgpack::object const& o) \
+    void msgpack_unpack(msgpack::object const& msgpack_o) \
     { \
         msgpack::type::make_define_map \
             MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_unpack(o); \
+            .msgpack_unpack(msgpack_o); \
     }\
     template <typename MSGPACK_OBJECT> \
-    void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \
+    void msgpack_object(MSGPACK_OBJECT* msgpack_o, msgpack::zone& msgpack_z) const \
     { \
         msgpack::type::make_define_map \
             MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
-            .msgpack_object(o, z); \
+            .msgpack_object(msgpack_o, msgpack_z); \
     }
 
 #define MSGPACK_BASE_MAP(base) \
     (MSGPACK_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
 
+#else  // defined(MSGPACK_NO_BOOST)
+
+// BOOST_PP_VARIADICS is defined in boost/preprocessor/config/config.hpp
+// http://www.boost.org/libs/preprocessor/doc/ref/variadics.html
+// However, supporting compiler detection is not complete. msgpack-c requires
+// variadic macro arguments support. So BOOST_PP_VARIADICS is defined here explicitly.
+#if !defined(BOOST_PP_VARIADICS)
+#define BOOST_PP_VARIADICS
+#endif
+
+#include <boost/preprocessor.hpp>
+
+#define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this)))
+#define MSGPACK_NVP(name, value) (name) (value)
+
+#define MSGPACK_DEFINE_MAP_EACH_PROC(r, data, elem) \
+    BOOST_PP_IF( \
+        BOOST_PP_IS_BEGIN_PARENS(elem), \
+        elem, \
+        (BOOST_PP_STRINGIZE(elem))(elem) \
+    )
+
+#define MSGPACK_DEFINE_MAP_IMPL(...) \
+    BOOST_PP_SEQ_TO_TUPLE( \
+        BOOST_PP_SEQ_FOR_EACH( \
+            MSGPACK_DEFINE_MAP_EACH_PROC, \
+            0, \
+            BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__) \
+        ) \
+    )
+
+#define MSGPACK_DEFINE_MAP(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& msgpack_pk) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_pack(msgpack_pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& msgpack_o) \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_unpack(msgpack_o); \
+    }\
+    template <typename MSGPACK_OBJECT> \
+    void msgpack_object(MSGPACK_OBJECT* msgpack_o, msgpack::zone& msgpack_z) const \
+    { \
+        msgpack::type::make_define_map \
+            MSGPACK_DEFINE_MAP_IMPL(__VA_ARGS__) \
+            .msgpack_object(msgpack_o, msgpack_z); \
+    }
+
+#define MSGPACK_BASE_MAP(base) \
+    (BOOST_PP_STRINGIZE(base))(*const_cast<base *>(static_cast<base const*>(this)))
+
+#endif // defined(MSGPACK_NO_BOOST)
+
+#include "msgpack/versioning.hpp"
+
+// for MSGPACK_ADD_ENUM
+#include "msgpack/adaptor/int.hpp"
+
+#define MSGPACK_DEFINE_ARRAY(...) \
+    template <typename Packer> \
+    void msgpack_pack(Packer& msgpack_pk) const \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(msgpack_pk); \
+    } \
+    void msgpack_unpack(msgpack::object const& msgpack_o) \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(msgpack_o); \
+    }\
+    template <typename MSGPACK_OBJECT> \
+    void msgpack_object(MSGPACK_OBJECT* msgpack_o, msgpack::zone& msgpack_z) const \
+    { \
+        msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(msgpack_o, msgpack_z); \
+    }
+
 // MSGPACK_ADD_ENUM must be used in the global namespace.
 #define MSGPACK_ADD_ENUM(enum_name) \
   namespace msgpack { \
@@ -94,32 +154,32 @@
   namespace adaptor { \
     template<> \
     struct convert<enum_name> { \
-      msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const { \
+      msgpack::object const& operator()(msgpack::object const& msgpack_o, enum_name& msgpack_v) const { \
         msgpack::underlying_type<enum_name>::type tmp; \
-        msgpack::operator>>(o, tmp);                   \
+        msgpack::operator>>(msgpack_o, tmp);                   \
-        v = static_cast<enum_name>(tmp);   \
+        msgpack_v = static_cast<enum_name>(tmp);   \
-        return o; \
+        return msgpack_o; \
       } \
     }; \
     template<> \
     struct object<enum_name> { \
-      void operator()(msgpack::object& o, const enum_name& v) const { \
+      void operator()(msgpack::object& msgpack_o, const enum_name& msgpack_v) const { \
-        msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(v); \
+        msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(msgpack_v); \
-        msgpack::operator<<(o, tmp);                                    \
+        msgpack::operator<<(msgpack_o, tmp);                                    \
       } \
     }; \
     template<> \
     struct object_with_zone<enum_name> { \
-      void operator()(msgpack::object::with_zone& o, const enum_name& v) const {  \
+      void operator()(msgpack::object::with_zone& msgpack_o, const enum_name& msgpack_v) const {  \
-        msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(v); \
+        msgpack::underlying_type<enum_name>::type tmp = static_cast<msgpack::underlying_type<enum_name>::type>(msgpack_v); \
-        msgpack::operator<<(o, tmp);                                    \
+        msgpack::operator<<(msgpack_o, tmp);                                    \
       } \
     }; \
     template <> \
     struct pack<enum_name> { \
       template <typename Stream> \
-      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \
+      msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& msgpack_o, const enum_name& msgpack_v) const { \
-          return msgpack::operator<<(o, static_cast<msgpack::underlying_type<enum_name>::type>(v)); \
+          return msgpack::operator<<(msgpack_o, static_cast<msgpack::underlying_type<enum_name>::type>(msgpack_v)); \
       } \
     }; \
   } \
@@ -139,5 +199,6 @@
 
 #include "msgpack/v1/adaptor/define_decl.hpp"
 #include "msgpack/v2/adaptor/define_decl.hpp"
+#include "msgpack/v3/adaptor/define_decl.hpp"
 
 #endif // MSGPACK_DEFINE_DECL_HPP

include/msgpack/adaptor/ext_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/ext_decl.hpp"
 #include "msgpack/v2/adaptor/ext_decl.hpp"
+#include "msgpack/v3/adaptor/ext_decl.hpp"
 
 #endif // MSGPACK_TYPE_EXT_DECL_HPP

include/msgpack/adaptor/fixint_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/fixint_decl.hpp"
 #include "msgpack/v2/adaptor/fixint_decl.hpp"
+#include "msgpack/v3/adaptor/fixint_decl.hpp"
 
 #endif // MSGPACK_TYPE_FIXINT_DECL_HPP

include/msgpack/adaptor/int_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/int_decl.hpp"
 #include "msgpack/v2/adaptor/int_decl.hpp"
+#include "msgpack/v3/adaptor/int_decl.hpp"
 
 #endif // MSGPACK_TYPE_INT_DECL_HPP

include/msgpack/adaptor/map_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/map_decl.hpp"
 #include "msgpack/v2/adaptor/map_decl.hpp"
+#include "msgpack/v3/adaptor/map_decl.hpp"
 
 #endif // MSGPACK_TYPE_MAP_DECL_HPP

include/msgpack/adaptor/msgpack_tuple_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/msgpack_tuple_decl.hpp"
 #include "msgpack/v2/adaptor/msgpack_tuple_decl.hpp"
+#include "msgpack/v3/adaptor/msgpack_tuple_decl.hpp"
 
 #endif // MSGPACK_MSGPACK_TUPLE_DECL_HPP

include/msgpack/adaptor/nil_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/nil_decl.hpp"
 #include "msgpack/v2/adaptor/nil_decl.hpp"
+#include "msgpack/v3/adaptor/nil_decl.hpp"
 
 #endif // MSGPACK_TYPE_NIL_DECL_HPP

include/msgpack/adaptor/raw_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/raw_decl.hpp"
 #include "msgpack/v2/adaptor/raw_decl.hpp"
+#include "msgpack/v3/adaptor/raw_decl.hpp"
 
 #endif // MSGPACK_TYPE_RAW_DECL_HPP

include/msgpack/adaptor/size_equal_only_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/size_equal_only_decl.hpp"
 #include "msgpack/v2/adaptor/size_equal_only_decl.hpp"
+#include "msgpack/v3/adaptor/size_equal_only_decl.hpp"
 
 #endif // MSGPACK_TYPE_SIZE_EQUAL_ONLY_DECL_HPP

include/msgpack/adaptor/tr1/unordered_map.hpp

@@ -84,7 +84,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_map<K, V, Hash, Pred, Alloc>
             o.via.map.size = 0;
         } else {
             uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
+            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;
@@ -141,7 +141,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multimap<K, V, Hash, Pred, Al
             o.via.map.size = 0;
         } else {
             uint32_t size = checked_get_container_size(v.size());
-            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size));
+            msgpack::object_kv* p = static_cast<msgpack::object_kv*>(o.zone.allocate_align(sizeof(msgpack::object_kv)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
             msgpack::object_kv* const pend = p + size;
             o.via.map.ptr  = p;
             o.via.map.size = size;

include/msgpack/adaptor/tr1/unordered_set.hpp

@@ -82,7 +82,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_set<T, Hash, Compare, Alloc>
             o.via.array.size = 0;
         } else {
             uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
+            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;
@@ -136,7 +136,7 @@ struct object_with_zone<MSGPACK_STD_TR1::unordered_multiset<T, Hash, Compare, Al
             o.via.array.size = 0;
         } else {
             uint32_t size = checked_get_container_size(v.size());
-            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
+            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
             msgpack::object* const pend = p + size;
             o.via.array.ptr = p;
             o.via.array.size = size;

include/msgpack/adaptor/v4raw_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/adaptor/v4raw_decl.hpp"
 #include "msgpack/v2/adaptor/v4raw_decl.hpp"
+#include "msgpack/v3/adaptor/v4raw_decl.hpp"
 
 #endif // MSGPACK_TYPE_V4RAW_DECL_HPP

include/msgpack/adaptor/wstring.hpp

@@ -0,0 +1,15 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// 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_TYPE_WSTRING_HPP
+#define MSGPACK_TYPE_WSTRING_HPP
+
+#include "msgpack/v1/adaptor/wstring.hpp"
+
+#endif // MSGPACK_TYPE_WSTRING_HPP

include/msgpack/assert.hpp

@@ -0,0 +1,26 @@
+//
+// MessagePack for C++ static resolution routine
+//
+// Copyright (C) 2022 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_ASSERT_HPP
+#define MSGPACK_ASSERT_HPP
+
+#if defined(MSGPACK_NO_BOOST)
+
+#include <cassert>
+#define MSGPACK_ASSERT assert
+
+#else  // defined(MSGPACK_NO_BOOST)
+
+#include <boost/assert.hpp>
+#define MSGPACK_ASSERT BOOST_ASSERT
+
+#endif // defined(MSGPACK_NO_BOOST)
+
+#endif // MSGPACK_ASSERT_HPP

include/msgpack/cpp_config_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/cpp_config_decl.hpp"
 #include "msgpack/v2/cpp_config_decl.hpp"
+#include "msgpack/v3/cpp_config_decl.hpp"
 
 #endif // MSGPACK_CPP_CONFIG_DECL_HPP

include/msgpack/cpp_version.hpp

@@ -0,0 +1,18 @@
+#ifndef MSGPACK_CPP_VERSION_HPP
+#define MSGPACK_CPP_VERSION_HPP
+
+#if defined(_MSC_VER)
+#  if _MSC_VER < 1900
+#    define MSGPACK_USE_CPP03
+#  endif
+#elif (__cplusplus < 201103L)
+#  define MSGPACK_USE_CPP03
+#endif
+
+#if defined(_MSVC_LANG)
+#  define MSGPACK_CPP_VERSION _MSVC_LANG
+#else
+#  define MSGPACK_CPP_VERSION __cplusplus
+#endif
+
+#endif // MSGPACK_CPP_VERSION_HPP

include/msgpack/create_object_visitor.hpp

@@ -0,0 +1,17 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// 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_CREATE_OBJECT_VISITOR_HPP
+#define MSGPACK_CREATE_OBJECT_VISITOR_HPP
+
+#include "msgpack/create_object_visitor_decl.hpp"
+
+#include "msgpack/v2/create_object_visitor.hpp"
+
+#endif // MSGPACK_CREATE_OBJECT_VISITOR_HPP

include/msgpack/create_object_visitor_decl.hpp

@@ -0,0 +1,16 @@
+//
+// MessagePack for C++ deserializing routine
+//
+// 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_CREATE_OBJECT_VISITOR_DECL_HPP
+#define MSGPACK_CREATE_OBJECT_VISITOR_DECL_HPP
+
+#include "msgpack/v2/create_object_visitor_decl.hpp"
+#include "msgpack/v3/create_object_visitor_decl.hpp"
+
+#endif // MSGPACK_CREATE_OBJECT_VISITOR_DECL_HPP

include/msgpack/fbuffer.h

@@ -1,38 +0,0 @@
-/*
- * 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>
-
-#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)
-{
-    return (len == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
-}
-
-/** @} */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* msgpack/fbuffer.h */

include/msgpack/fbuffer_decl.hpp

@@ -12,5 +12,6 @@
 
 #include "msgpack/v1/fbuffer_decl.hpp"
 #include "msgpack/v2/fbuffer_decl.hpp"
+#include "msgpack/v3/fbuffer_decl.hpp"
 
 #endif // MSGPACK_FBUFFER_DECL_HPP

include/msgpack/gcc_atomic.h

@@ -1,25 +0,0 @@
-/*
- *    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/gcc_atomic.hpp

@@ -13,7 +13,6 @@
 
 #if defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
 
-#include "msgpack/gcc_atomic.h"
 #include <bits/atomicity.h>
 
 int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr)

include/msgpack/iterator.hpp

@@ -11,8 +11,8 @@
 #ifndef MSGPACK_ITERATOR_HPP
 #define MSGPACK_ITERATOR_HPP
 
-#include <msgpack/iterator_decl.hpp>
+#include "msgpack/iterator_decl.hpp"
 
-#include <msgpack/v1/iterator.hpp>
+#include "msgpack/v1/iterator.hpp"
 
 #endif // MSGPACK_ITERATOR_HPP