Remove BOOST_NO_VOID_RETURNS code path from bind.hpp

Remove unnecessary macros from mem_fn.hpp
Remove BOOST_NO_VOID_RETURNS code path from mem_fn.hpp
2024-01-02 20:09:20 +02:00 · 2024-01-02 19:55:36 +02:00 · 2024-01-02 19:47:55 +02:00 · 2024-01-02 19:04:31 +02:00 · 2024-01-02 18:41:32 +02:00 · 2023-10-18 14:03:41 +03:00
13 changed files with 560 additions and 607 deletions
--- a/.drone.jsonnet
+++ b/.drone.jsonnet
@@ -97,41 +97,40 @@ local windows_pipeline(name, image, environment, arch = "amd64") =

 [
    linux_pipeline(
-        "Linux 14.04 GCC 4.4",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.4",
+        "cppalliance/droneubuntu1604:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
        "g++-4.4",
        [ "ppa:ubuntu-toolchain-r/test" ],
    ),

    linux_pipeline(
-        "Linux 14.04 GCC 4.6",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.6",
+        "cppalliance/droneubuntu1604:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x' },
        "g++-4.6",
        [ "ppa:ubuntu-toolchain-r/test" ],
    ),

    linux_pipeline(
-        "Linux 14.04 GCC 4.7",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.7",
+        "cppalliance/droneubuntu1604:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x' },
        "g++-4.7",
-        [ "ppa:ubuntu-toolchain-r/test" ],
    ),

    linux_pipeline(
-        "Linux 14.04 GCC 4.8*",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11' },
+        "Linux 16.04 GCC 4.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.8', CXXSTD: '03,11' },
+        "g++-4.8",
    ),

    linux_pipeline(
-        "Linux 14.04 GCC 4.9",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.9",
+        "cppalliance/droneubuntu1604:1",
        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11' },
        "g++-4.9",
-        [ "ppa:ubuntu-toolchain-r/test" ],
    ),

    linux_pipeline(
@@ -161,36 +160,64 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
    ),

    linux_pipeline(
-        "Linux 20.04 GCC 9* 32",
+        "Linux 20.04 GCC 9* 32/64",
        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32' },
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* 64",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '64' },
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9 ARM64 32/64",
-        "cppalliance/droneubuntu2004:multiarch",
        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
        arch="arm64",
    ),

    linux_pipeline(
-        "Linux 20.04 GCC 10 32 ASAN",
+        "Linux 20.04 GCC 9* S390x",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="s390x",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32/64",
        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32' } + asan,
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32,64' },
        "g++-10-multilib",
    ),

    linux_pipeline(
-        "Linux 20.04 GCC 10 64 ASAN",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '64' } + asan,
-        "g++-10-multilib",
+        "Linux 22.04 GCC 11* 32/64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 32 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 64 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 32 UBSAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + ubsan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 64 UBSAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + ubsan,
+        "g++-13-multilib",
    ),

    linux_pipeline(
@@ -222,27 +249,45 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
    ),

    linux_pipeline(
-        "Linux 20.04 Clang 13",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
+        "Linux 22.04 Clang 13",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20,2b' },
        "clang-13",
-        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main"],
    ),

    linux_pipeline(
-        "Linux 20.04 Clang 14 UBSAN",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20' } + ubsan,
+        "Linux 22.04 Clang 14",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' },
        "clang-14",
-        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main"],
    ),

    linux_pipeline(
-        "Linux 20.04 Clang 14 ASAN",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20' } + asan,
-        "clang-14",
-        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main"],
+        "Linux 22.04 Clang 15",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-15",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 Clang 16",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '11,14,17,20,2b' },
+        "clang-16",
+    ),
+
+    linux_pipeline(
+        "Linux 23.10 Clang 17 UBSAN",
+        "cppalliance/droneubuntu2310:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "clang-17",
+    ),
+
+    linux_pipeline(
+        "Linux 23.10 Clang 17 ASAN",
+        "cppalliance/droneubuntu2310:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + asan,
+        "clang-17",
    ),

    macos_pipeline(
@@ -255,10 +300,22 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
    ),

+    macos_pipeline(
+        "MacOS 12.4 Xcode 13.4.1 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
+    ),
+
+    macos_pipeline(
+        "MacOS 12.4 Xcode 13.4.1 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
+    ),
+
    windows_pipeline(
        "Windows VS2015 msvc-14.0",
        "cppalliance/dronevs2015",
-        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest' },
+        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest', B2_DONT_EMBED_MANIFEST: '1' },
    ),

    windows_pipeline(
--- a/.drone/drone.sh
+++ b/.drone/drone.sh
@@ -5,6 +5,7 @@
 # https://www.boost.org/LICENSE_1_0.txt

 set -ex
+export PATH=~/.local/bin:/usr/local/bin:$PATH

 DRONE_BUILD_DIR=$(pwd)

--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -19,22 +19,26 @@ jobs:
        include:
          - toolset: gcc-4.8
            cxxstd: "03,11"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: g++-4.8
          - toolset: gcc-5
            cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: g++-5
          - toolset: gcc-6
            cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: g++-6
          - toolset: gcc-7
            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
+            install: g++-7
          - toolset: gcc-8
            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
            install: g++-8
          - toolset: gcc-9
            cxxstd: "03,11,14,17,2a"
@@ -51,30 +55,38 @@ jobs:
            cxxstd: "03,11,14,17,20,2b"
            os: ubuntu-22.04
            install: g++-12
+          - toolset: gcc-13
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:23.04
+            os: ubuntu-latest
+            install: g++-13
          - toolset: clang
            compiler: clang++-3.9
            cxxstd: "03,11,14"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: clang-3.9
          - toolset: clang
            compiler: clang++-4.0
            cxxstd: "03,11,14"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: clang-4.0
          - toolset: clang
            compiler: clang++-5.0
            cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
+            container: ubuntu:18.04
+            os: ubuntu-latest
            install: clang-5.0
          - toolset: clang
            compiler: clang++-6.0
            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
            install: clang-6.0
          - toolset: clang
            compiler: clang++-7
            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
            install: clang-7
          - toolset: clang
            compiler: clang++-8
@@ -104,25 +116,64 @@ jobs:
          - toolset: clang
            compiler: clang++-13
            cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-22.04
+            container: ubuntu:22.04
+            os: ubuntu-latest
            install: clang-13
          - toolset: clang
            compiler: clang++-14
            cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-22.04
+            container: ubuntu:22.04
+            os: ubuntu-latest
            install: clang-14
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-15
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:23.04
+            os: ubuntu-latest
+            install: clang-16
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:23.10
+            os: ubuntu-latest
+            install: clang-17
          - toolset: clang
            cxxstd: "03,11,14,17,2a"
            os: macos-11
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-12
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-13

    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    defaults:
+      run:
+        shell: bash

    steps:
      - uses: actions/checkout@v3

+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++
+
      - name: Install packages
        if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -142,7 +193,7 @@ jobs:
          cd boost-root
          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
          git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
          ./bootstrap.sh
          ./b2 -d0 headers

@@ -174,7 +225,7 @@ jobs:
            addrmd: 32,64
            os: windows-2022
          - toolset: clang-win
-            cxxstd: "14,17,latest"
+            cxxstd: "14,17,20,latest"
            addrmd: 32,64
            os: windows-2022
          - toolset: gcc
@@ -224,6 +275,7 @@ jobs:
          - os: ubuntu-22.04
          - os: macos-11
          - os: macos-12
+          - os: macos-13

    runs-on: ${{matrix.os}}

@@ -232,7 +284,7 @@ jobs:

      - name: Install packages
        if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: sudo apt-get -y install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -271,6 +323,7 @@ jobs:
          - os: ubuntu-22.04
          - os: macos-11
          - os: macos-12
+          - os: macos-13

    runs-on: ${{matrix.os}}

@@ -279,7 +332,7 @@ jobs:

      - name: Install packages
        if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: sudo apt-get -y install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -328,6 +381,7 @@ jobs:
          - os: ubuntu-22.04
          - os: macos-11
          - os: macos-12
+          - os: macos-13

    runs-on: ${{matrix.os}}

@@ -336,7 +390,7 @@ jobs:

      - name: Install packages
        if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: sudo apt-get -y install ${{matrix.install}}

      - name: Setup Boost
        run: |
@@ -373,3 +427,183 @@ jobs:
        run: |
          cd ../boost-root/__build__
          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
+
+      - name: Build tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Debug
+
+      - name: Run tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Build tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Release
+
+      - name: Run tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Release
--- a/include/boost/bind/apply.hpp
+++ b/include/boost/bind/apply.hpp
@@ -11,6 +11,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>

 namespace boost
--- a/include/boost/bind/bind.hpp
+++ b/include/boost/bind/bind.hpp
@@ -21,6 +21,7 @@
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>
 #include <boost/bind/mem_fn.hpp>
 #include <boost/type.hpp>
@@ -28,7 +29,7 @@
 #include <boost/bind/arg.hpp>
 #include <boost/bind/detail/result_traits.hpp>
 #include <boost/bind/std_placeholders.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/visit_each.hpp>
 #include <boost/core/ref.hpp>
 #include <boost/core/enable_if.hpp>
@@ -1415,7 +1416,7 @@ public:
    }
 };

-#elif !defined( BOOST_NO_VOID_RETURNS )
+#else

 template<class R, class F, class L> class bind_t
 {
@@ -1425,61 +1426,7 @@ public:

    bind_t(F f, L const & l): f_(f), l_(l) {}

-#define BOOST_BIND_RETURN return
 #include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-#else // no void returns
-
-template<class R> struct bind_t_generator
-{
-
-template<class F, class L> class implementation
-{
-public:
-
-    typedef implementation this_type;
-
-    implementation(F f, L const & l): f_(f), l_(l) {}
-
-#define BOOST_BIND_RETURN return
-#include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-};
-
-template<> struct bind_t_generator<void>
-{
-
-template<class F, class L> class implementation
-{
-private:
-
-    typedef void R;
-
-public:
-
-    typedef implementation this_type;
-
-    implementation(F f, L const & l): f_(f), l_(l) {}
-
-#define BOOST_BIND_RETURN
-#include <boost/bind/bind_template.hpp>
-#undef BOOST_BIND_RETURN
-
-};
-
-};
-
-template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>
-{
-public:
-
-    bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}

 };

--- a/include/boost/bind/bind_template.hpp
+++ b/include/boost/bind/bind_template.hpp
@@ -17,25 +17,25 @@
    result_type operator()()
    {
        list0 a;
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    result_type operator()() const
    {
        list0 a;
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1)
    {
        list1<A1 &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1) const
    {
        list1<A1 &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -44,13 +44,13 @@
    template<class A1> result_type operator()(A1 const & a1)
    {
        list1<A1 const &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 const & a1) const
    {
        list1<A1 const &> a(a1);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -58,13 +58,13 @@
    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
    {
        list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
    {
        list2<A1 &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -73,39 +73,39 @@
    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
    {
        list2<A1 const &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
    {
        list2<A1 const &, A2 &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
    {
        list2<A1 &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
    {
        list2<A1 &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
    {
        list2<A1 const &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
    {
        list2<A1 const &, A2 const &> a(a1, a2);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -113,13 +113,13 @@
    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -128,13 +128,13 @@
    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -142,13 +142,13 @@
    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -157,13 +157,13 @@
    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -171,13 +171,13 @@
    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -186,13 +186,13 @@
    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -200,13 +200,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -215,13 +215,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -229,13 +229,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -244,13 +244,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -258,13 +258,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -273,13 +273,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif
@@ -287,13 +287,13 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
@@ -302,25 +302,25 @@
    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

 #endif

    template<class A> result_type eval(A & a)
    {
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A> result_type eval(A & a) const
    {
-        BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+        return l_(type<result_type>(), f_, a, 0);
    }

    template<class V> void accept(V & v) const
--- a/include/boost/bind/detail/requires_cxx11.hpp
+++ b/include/boost/bind/detail/requires_cxx11.hpp
@@ -0,0 +1,22 @@
+#ifndef BOOST_BIND_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
+#define BOOST_BIND_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
+    defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
+    defined(BOOST_NO_CXX11_DECLTYPE) || \
+    defined(BOOST_NO_CXX11_CONSTEXPR) || \
+    defined(BOOST_NO_CXX11_NOEXCEPT) || \
+    defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+BOOST_PRAGMA_MESSAGE("C++03 support was deprecated in Boost.Bind 1.82 and will be removed in Boost.Bind 1.85.")
+
+#endif
+
+#endif // #ifndef BOOST_BIND_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
--- a/include/boost/bind/mem_fn.hpp
+++ b/include/boost/bind/mem_fn.hpp
@@ -21,194 +21,17 @@
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //

-#include <boost/config.hpp>
+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/get_pointer.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>

 namespace boost
 {

-#if defined(BOOST_NO_VOID_RETURNS)
-
-#define BOOST_MEM_FN_CLASS_F , class F
-#define BOOST_MEM_FN_TYPEDEF(X)
-
-namespace _mfi // mem_fun_impl
-{
-
-template<class V> struct mf
-{
-
-#define BOOST_MEM_FN_RETURN return
-
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#if defined(BOOST_MEM_FN_ENABLE_STDCALL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#if defined(BOOST_MEM_FN_ENABLE_FASTCALL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<V>
-
-template<> struct mf<void>
-{
-
-#define BOOST_MEM_FN_RETURN
-
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<void>
-
-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF_F
-
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_NAME2(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#if defined(BOOST_MEM_FN_ENABLE_CDECL) && !defined(_M_X64)
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-} // namespace _mfi
-
-#else // #ifdef BOOST_NO_VOID_RETURNS
-
-#define BOOST_MEM_FN_CLASS_F
-#define BOOST_MEM_FN_TYPEDEF(X) typedef X;
-
 namespace _mfi
 {

-#define BOOST_MEM_FN_RETURN return
-
 #define BOOST_MEM_FN_NAME(X) X
 #define BOOST_MEM_FN_CC

@@ -253,14 +76,9 @@ namespace _mfi

 #endif

-#undef BOOST_MEM_FN_RETURN
-
 } // namespace _mfi

-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF
-
-#endif // #ifdef BOOST_NO_VOID_RETURNS
+//

 #define BOOST_MEM_FN_NAME(X) X
 #define BOOST_MEM_FN_CC
--- a/include/boost/bind/mem_fn_template.hpp
+++ b/include/boost/bind/mem_fn_template.hpp
@@ -18,7 +18,7 @@

 // mf0

-template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf0)
+template<class R, class T> class BOOST_MEM_FN_NAME(mf0)
 {
 public:

@@ -27,17 +27,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) ())
+    typedef R (BOOST_MEM_FN_CC T::*F) ();
    F f_;

    template<class U> R call(U & u, T const *) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)();
+        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+        return (get_pointer(u)->*f_)();
    }

 public:
@@ -46,13 +46,13 @@ public:

    R operator()(T * p) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)();
+        return (p->*f_)();
    }

    template<class U> R operator()(U & u) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        return call(u, p);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -60,14 +60,14 @@ public:
    template<class U> R operator()(U const & u) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        return call(u, p);
    }

 #endif

    R operator()(T & t) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)();
+        return (t.*f_)();
    }

    bool operator==(BOOST_MEM_FN_NAME(mf0) const & rhs) const
@@ -83,7 +83,7 @@ public:

 // cmf0

-template<class R, class T BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf0)
+template<class R, class T> class BOOST_MEM_FN_NAME(cmf0)
 {
 public:

@@ -92,17 +92,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) () const)
+    typedef R (BOOST_MEM_FN_CC T::*F) () const;
    F f_;

    template<class U> R call(U & u, T const *) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)();
+        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+        return (get_pointer(u)->*f_)();
    }

 public:
@@ -112,12 +112,12 @@ public:
    template<class U> R operator()(U const & u) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        return call(u, p);
    }

    R operator()(T const & t) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)();
+        return (t.*f_)();
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf0) const & rhs) const
@@ -133,7 +133,7 @@ public:

 // mf1

-template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf1)
+template<class R, class T, class A1> class BOOST_MEM_FN_NAME(mf1)
 {
 public:

@@ -143,17 +143,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1);
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1);
+        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
+        return (get_pointer(u)->*f_)(b1);
    }

 public:
@@ -162,13 +162,13 @@ public:

    R operator()(T * p, A1 a1) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1);
+        return (p->*f_)(a1);
    }

    template<class U> R operator()(U & u, A1 a1) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        return call(u, p, a1);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -176,14 +176,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        return call(u, p, a1);
    }

 #endif

    R operator()(T & t, A1 a1) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1);
+        return (t.*f_)(a1);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf1) const & rhs) const
@@ -199,7 +199,7 @@ public:

 // cmf1

-template<class R, class T, class A1 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf1)
+template<class R, class T, class A1> class BOOST_MEM_FN_NAME(cmf1)
 {
 public:

@@ -209,17 +209,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1) const;
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1);
+        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1);
+        return (get_pointer(u)->*f_)(b1);
    }

 public:
@@ -229,12 +229,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        return call(u, p, a1);
    }

    R operator()(T const & t, A1 a1) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1);
+        return (t.*f_)(a1);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf1) const & rhs) const
@@ -250,7 +250,7 @@ public:

 // mf2

-template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf2)
+template<class R, class T, class A1, class A2> class BOOST_MEM_FN_NAME(mf2)
 {
 public:

@@ -258,17 +258,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2);
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
+        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
+        return (get_pointer(u)->*f_)(b1, b2);
    }

 public:
@@ -277,13 +277,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
+        return (p->*f_)(a1, a2);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        return call(u, p, a1, a2);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -291,14 +291,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        return call(u, p, a1, a2);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
+        return (t.*f_)(a1, a2);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf2) const & rhs) const
@@ -314,7 +314,7 @@ public:

 // cmf2

-template<class R, class T, class A1, class A2 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf2)
+template<class R, class T, class A1, class A2> class BOOST_MEM_FN_NAME(cmf2)
 {
 public:

@@ -322,17 +322,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const;
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2);
+        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2);
+        return (get_pointer(u)->*f_)(b1, b2);
    }

 public:
@@ -342,12 +342,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        return call(u, p, a1, a2);
    }

    R operator()(T const & t, A1 a1, A2 a2) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
+        return (t.*f_)(a1, a2);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf2) const & rhs) const
@@ -363,7 +363,7 @@ public:

 // mf3

-template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf3)
+template<class R, class T, class A1, class A2, class A3> class BOOST_MEM_FN_NAME(mf3)
 {
 public:

@@ -371,17 +371,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
+        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
+        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

 public:
@@ -390,13 +390,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
+        return (p->*f_)(a1, a2, a3);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        return call(u, p, a1, a2, a3);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -404,14 +404,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        return call(u, p, a1, a2, a3);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
+        return (t.*f_)(a1, a2, a3);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf3) const & rhs) const
@@ -427,7 +427,7 @@ public:

 // cmf3

-template<class R, class T, class A1, class A2, class A3 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf3)
+template<class R, class T, class A1, class A2, class A3> class BOOST_MEM_FN_NAME(cmf3)
 {
 public:

@@ -435,17 +435,17 @@ public:

 private:

-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3);
+        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3);
+        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

 public:
@@ -455,12 +455,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        return call(u, p, a1, a2, a3);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
+        return (t.*f_)(a1, a2, a3);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf3) const & rhs) const
@@ -476,7 +476,7 @@ public:

 // mf4

-template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf4)
+template<class R, class T, class A1, class A2, class A3, class A4> class BOOST_MEM_FN_NAME(mf4)
 {
 public:

@@ -484,17 +484,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
+        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

 public:
@@ -503,13 +503,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
+        return (p->*f_)(a1, a2, a3, a4);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        return call(u, p, a1, a2, a3, a4);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -517,14 +517,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        return call(u, p, a1, a2, a3, a4);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
+        return (t.*f_)(a1, a2, a3, a4);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf4) const & rhs) const
@@ -540,7 +540,7 @@ public:

 // cmf4

-template<class R, class T, class A1, class A2, class A3, class A4 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf4)
+template<class R, class T, class A1, class A2, class A3, class A4> class BOOST_MEM_FN_NAME(cmf4)
 {
 public:

@@ -548,17 +548,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4);
+        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

 public:
@@ -568,12 +568,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        return call(u, p, a1, a2, a3, a4);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
+        return (t.*f_)(a1, a2, a3, a4);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf4) const & rhs) const
@@ -589,7 +589,7 @@ public:

 // mf5

-template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf5)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> class BOOST_MEM_FN_NAME(mf5)
 {
 public:

@@ -597,17 +597,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
+        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

 public:
@@ -616,13 +616,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
+        return (p->*f_)(a1, a2, a3, a4, a5);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        return call(u, p, a1, a2, a3, a4, a5);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -630,14 +630,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        return call(u, p, a1, a2, a3, a4, a5);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
+        return (t.*f_)(a1, a2, a3, a4, a5);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf5) const & rhs) const
@@ -653,7 +653,7 @@ public:

 // cmf5

-template<class R, class T, class A1, class A2, class A3, class A4, class A5 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf5)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> class BOOST_MEM_FN_NAME(cmf5)
 {
 public:

@@ -661,17 +661,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5);
+        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

 public:
@@ -681,12 +681,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        return call(u, p, a1, a2, a3, a4, a5);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
+        return (t.*f_)(a1, a2, a3, a4, a5);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf5) const & rhs) const
@@ -702,7 +702,7 @@ public:

 // mf6

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf6)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> class BOOST_MEM_FN_NAME(mf6)
 {
 public:

@@ -710,17 +710,17 @@ public:

 private:

-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

 public:
@@ -729,13 +729,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
+        return (p->*f_)(a1, a2, a3, a4, a5, a6);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        return call(u, p, a1, a2, a3, a4, a5, a6);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -743,14 +743,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        return call(u, p, a1, a2, a3, a4, a5, a6);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf6) const & rhs) const
@@ -766,7 +766,7 @@ public:

 // cmf6

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf6)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> class BOOST_MEM_FN_NAME(cmf6)
 {
 public:

@@ -774,17 +774,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

 public:
@@ -794,12 +794,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        return call(u, p, a1, a2, a3, a4, a5, a6);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf6) const & rhs) const
@@ -815,7 +815,7 @@ public:

 // mf7

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf7)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> class BOOST_MEM_FN_NAME(mf7)
 {
 public:

@@ -823,17 +823,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

 public:
@@ -842,13 +842,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -856,14 +856,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf7) const & rhs) const
@@ -879,7 +879,7 @@ public:

 // cmf7

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf7)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> class BOOST_MEM_FN_NAME(cmf7)
 {
 public:

@@ -887,17 +887,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

 public:
@@ -907,12 +907,12 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf7) const & rhs) const
@@ -928,7 +928,7 @@ public:

 // mf8

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(mf8)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class BOOST_MEM_FN_NAME(mf8)
 {
 public:

@@ -936,17 +936,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8))
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

 public:
@@ -955,13 +955,13 @@ public:

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }

 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
@@ -969,14 +969,14 @@ public:
    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }

 #endif

    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(BOOST_MEM_FN_NAME(mf8) const & rhs) const
@@ -992,7 +992,7 @@ public:

 // cmf8

-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 BOOST_MEM_FN_CLASS_F> class BOOST_MEM_FN_NAME(cmf8)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class BOOST_MEM_FN_NAME(cmf8)
 {
 public:

@@ -1000,17 +1000,17 @@ public:

 private:
    
-    BOOST_MEM_FN_TYPEDEF(R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
-        BOOST_MEM_FN_RETURN (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
-        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

 public:
@@ -1019,18 +1019,18 @@ public:

    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
-        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
-        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(BOOST_MEM_FN_NAME(cmf8) const & rhs) const
--- a/include/boost/bind/mem_fn_vw.hpp
+++ b/include/boost/bind/mem_fn_vw.hpp
@@ -1,130 +0,0 @@
-//
-//  bind/mem_fn_vw.hpp - void return helper wrappers
-//
-//  Do not include this header directly
-//
-//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
-//
-// 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)
-//
-//  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
-//
-
-template<class R, class T> struct BOOST_MEM_FN_NAME(mf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T, R (BOOST_MEM_FN_CC T::*) ()>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) ();
-    explicit BOOST_MEM_FN_NAME(mf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T, F>(f) {}
-};
-
-template<class R, class T> struct BOOST_MEM_FN_NAME(cmf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T, R (BOOST_MEM_FN_CC T::*) () const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) () const;
-    explicit BOOST_MEM_FN_NAME(cmf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T, F>(f) {}
-};
-
-
-template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(mf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1);
-    explicit BOOST_MEM_FN_NAME(mf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1, F>(f) {}
-};
-
-template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(cmf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1) const;
-    explicit BOOST_MEM_FN_NAME(cmf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(mf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2);
-    explicit BOOST_MEM_FN_NAME(mf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(cmf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const;
-    explicit BOOST_MEM_FN_NAME(cmf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(mf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
-    explicit BOOST_MEM_FN_NAME(mf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(cmf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
-    explicit BOOST_MEM_FN_NAME(cmf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(mf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
-    explicit BOOST_MEM_FN_NAME(mf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(cmf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
-    explicit BOOST_MEM_FN_NAME(cmf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(mf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
-    explicit BOOST_MEM_FN_NAME(mf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(cmf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
-    explicit BOOST_MEM_FN_NAME(cmf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(mf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
-    explicit BOOST_MEM_FN_NAME(mf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(cmf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
-    explicit BOOST_MEM_FN_NAME(cmf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(mf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
-    explicit BOOST_MEM_FN_NAME(mf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(cmf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
-    explicit BOOST_MEM_FN_NAME(cmf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7, F>(f) {}
-};
-
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(mf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8)>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
-    explicit BOOST_MEM_FN_NAME(mf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
-};
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(cmf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const>
-{
-    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
-    explicit BOOST_MEM_FN_NAME(cmf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8, F>(f) {}
-};
-
--- a/include/boost/bind/protect.hpp
+++ b/include/boost/bind/protect.hpp
@@ -12,6 +12,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 #include <utility>
--- a/include/boost/bind/std_placeholders.hpp
+++ b/include/boost/bind/std_placeholders.hpp
@@ -11,6 +11,7 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/is_placeholder.hpp>
 #include <boost/config.hpp>

--- a/include/boost/bind/storage.hpp
+++ b/include/boost/bind/storage.hpp
@@ -21,6 +21,7 @@
 //  See http://www.boost.org/libs/bind/bind.html for documentation.
 //

+#include <boost/bind/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>
 #include <boost/bind/arg.hpp>
Author	SHA1	Message	Date
Peter Dimov	732bc0787c	Remove BOOST_NO_VOID_RETURNS code path from bind.hpp	2024-01-02 20:09:20 +02:00
Peter Dimov	645d30d455	Remove unnecessary macros from mem_fn.hpp	2024-01-02 19:55:36 +02:00
Peter Dimov	08e5b5831c	Remove BOOST_NO_VOID_RETURNS code path from mem_fn.hpp	2024-01-02 19:47:55 +02:00
Peter Dimov	d9b74619b7	Update ci.yml	2024-01-02 19:04:31 +02:00
Peter Dimov	6892ffa0a3	Update .drone.jsonnet	2024-01-02 18:41:32 +02:00
Peter Dimov	586d4e1fb0	Update ci.yml	2023-10-18 14:03:41 +03:00
Peter Dimov	186b9c66de	Update C++03 deprecation message	2023-10-18 14:00:38 +03:00
Peter Dimov	55d037093b	Update C++03 deprecation message	2023-06-03 02:25:23 +03:00
Peter Dimov	8d945a9733	Update .drone.jsonnet	2023-03-04 20:12:04 +02:00
Peter Dimov	a421c908e3	Add notice for C++03 deprecation	2023-03-04 19:58:19 +02:00
Peter Dimov	41dda10827	Update ci.yml	2023-03-04 17:53:35 +02:00