merged from trunk

[SVN r49607]
merged from trunk
2025-06-26 04:21:38 +02:00 · 2008-11-06 00:15:47 +00:00 · 2008-10-22 20:32:22 +00:00 · 2008-10-05 01:47:33 +00:00 · 2008-09-08 21:00:49 +00:00 · 2008-08-05 05:39:57 +00:00
71 changed files with 1684 additions and 3735 deletions
--- a/.drone.jsonnet
+++ b/.drone.jsonnet
@ -1,422 +0,0 @@
-# Copyright 2022 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-local library = "function";
-
-local triggers =
-{
-    branch: [ "master", "develop", "feature/*" ]
-};
-
-local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
-local asan = { ASAN: '1' };
-
-local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
-{
-    name: name,
-    kind: "pipeline",
-    type: "docker",
-    trigger: triggers,
-    platform:
-    {
-        os: "linux",
-        arch: arch
-    },
-    steps:
-    [
-        {
-            name: "everything",
-            image: image,
-            environment: environment,
-            commands:
-            [
-                'set -e',
-                'uname -a',
-                'echo $DRONE_STAGE_MACHINE',
-                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
-            ] +
-            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
-            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
-            [
-                'export LIBRARY=' + library,
-                './.drone/drone.sh',
-            ]
-        }
-    ]
-};
-
-local macos_pipeline(name, environment, xcode_version = "12.2", osx_version = "catalina", arch = "amd64") =
-{
-    name: name,
-    kind: "pipeline",
-    type: "exec",
-    trigger: triggers,
-    platform: {
-        "os": "darwin",
-        "arch": arch
-    },
-    node: {
-        "os": osx_version
-    },
-    steps: [
-        {
-            name: "everything",
-            environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
-            commands:
-            [
-                'export LIBRARY=' + library,
-                './.drone/drone.sh',
-            ]
-        }
-    ]
-};
-
-local windows_pipeline(name, image, environment, arch = "amd64") =
-{
-    name: name,
-    kind: "pipeline",
-    type: "docker",
-    trigger: triggers,
-    platform:
-    {
-        os: "windows",
-        arch: arch
-    },
-    "steps":
-    [
-        {
-            name: "everything",
-            image: image,
-            environment: environment,
-            commands:
-            [
-                'cmd /C .drone\\\\drone.bat ' + library,
-            ]
-        }
-    ]
-};
-
-[
-    linux_pipeline(
-        "Linux 16.04 GCC 4.7 32/64",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '0x', ADDRMD: '32,64' },
-        "g++-4.7-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 GCC 4.8 32/64",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.8', CXXSTD: '11', ADDRMD: '32,64' },
-        "g++-4.8-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 GCC 4.9 32/64",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '11', ADDRMD: '32,64' },
-        "g++-4.9-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 GCC 5* 32/64",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14', ADDRMD: '32,64' },
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 GCC 6 32/64",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '11,14', ADDRMD: '32,64' },
-        "g++-6-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 GCC 7* 32/64",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17', ADDRMD: '32,64' },
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 GCC 8 32/64",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '11,14,17', ADDRMD: '32,64' },
-        "g++-8-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* 32/64",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32,64' },
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* ARM64 UBSAN",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' } + ubsan,
-        arch="arm64",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* ARM64 ASAN",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' } + asan,
-        arch="arm64",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* S390x UBSAN",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' } + ubsan,
-        arch="s390x",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 10 32/64",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '32,64' },
-        "g++-10-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 GCC 11* 32/64",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32,64' },
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 GCC 12 32/64",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' },
-        "g++-12-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 GCC 13 32/64",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' },
-        "g++-13-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 GCC 14 32/64 UBSAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' } + ubsan,
-        "g++-14-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 GCC 14 32/64 ASAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' } + asan,
-        "g++-14-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 Clang 3.5",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '11' },
-        "clang-3.5",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 Clang 3.6",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '11,14' },
-        "clang-3.6",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 Clang 3.7",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '11,14' },
-        "clang-3.7",
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 Clang 3.8",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '11,14' },
-        "clang-3.8",
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 Clang 3.9",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '11,14' },
-        "clang-3.9",
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 Clang 4.0",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '11,14' },
-        "clang-4.0",
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 Clang 5.0",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '11,14,1z' },
-        "clang-5.0",
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 Clang 6.0",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '11,14,17' },
-        "clang-6.0",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 7",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '11,14,17' },
-        "clang-7",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 8",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '11,14,17' },
-        "clang-8",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 9",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '11,14,17,2a' },
-        "clang-9",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 10",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '11,14,17,2a' },
-        "clang-10",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 11",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '11,14,17,2a' },
-        "clang-11",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 12",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '11,14,17,2a' },
-        "clang-12",
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 Clang 13",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '11,14,17,20' },
-        "clang-13",
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 Clang 14",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '11,14,17,20,2b' },
-        "clang-14",
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 Clang 15",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '11,14,17,20,2b' },
-        "clang-15",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 16",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '11,14,17,20,2b' },
-        "clang-16",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 17 UBSAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + ubsan,
-        "clang-17",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 17 ASAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + asan,
-        "clang-17",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 18 UBSAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + ubsan,
-        "clang-18",
-    ),
-
-    linux_pipeline(
-        "Linux 24.04 Clang 18 ASAN",
-        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + asan,
-        "clang-18",
-    ),
-
-    linux_pipeline(
-        "Linux 24.10 Clang 19",
-        "cppalliance/droneubuntu2410:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '11,14,17,20,2b' },
-        "clang-19",
-    ),
-
-    macos_pipeline(
-        "MacOS 10.15 Xcode 12.2 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,2a' } + ubsan,
-    ),
-
-    macos_pipeline(
-        "MacOS 10.15 Xcode 12.2 ASAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,2a' } + asan,
-    ),
-
-    macos_pipeline(
-        "MacOS 12.4 Xcode 13.4.1 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '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: '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', B2_DONT_EMBED_MANIFEST: '1' },
-    ),
-
-    windows_pipeline(
-        "Windows VS2017 msvc-14.1",
-        "cppalliance/dronevs2017",
-        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
-    ),
-
-    windows_pipeline(
-        "Windows VS2019 msvc-14.2",
-        "cppalliance/dronevs2019",
-        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
-    ),
-
-    windows_pipeline(
-        "Windows VS2022 msvc-14.3",
-        "cppalliance/dronevs2022:1",
-        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
-    ),
-]
--- a/.drone/drone.bat
+++ b/.drone/drone.bat
@ -1,23 +0,0 @@
-@REM Copyright 2022 Peter Dimov
-@REM Distributed under the Boost Software License, Version 1.0.
-@REM https://www.boost.org/LICENSE_1_0.txt
-
-@ECHO ON
-
-set LIBRARY=%1
-set DRONE_BUILD_DIR=%CD%
-
-set BOOST_BRANCH=develop
-if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
-cd ..
-git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-cd boost-root
-git submodule update --init tools/boostdep
-xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
-python tools/boostdep/depinst/depinst.py -I example %LIBRARY%
-cmd /c bootstrap
-b2 -d0 headers
-
-if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
--- a/.drone/drone.sh
+++ b/.drone/drone.sh
@ -1,25 +0,0 @@
-#!/bin/bash
-
-# Copyright 2022 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-set -ex
-export PATH=~/.local/bin:/usr/local/bin:$PATH
-
-DRONE_BUILD_DIR=$(pwd)
-
-BOOST_BRANCH=develop
-if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
-
-cd ..
-git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-cd boost-root
-git submodule update --init tools/boostdep
-cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
-python tools/boostdep/depinst/depinst.py -I example $LIBRARY
-./bootstrap.sh
-./b2 -d0 headers
-
-echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,663 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - develop
-      - feature/**
-
-env:
-  UBSAN_OPTIONS: print_stacktrace=1
-
-jobs:
-  posix:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: gcc-4.7
-            cxxstd: "11"
-            container: ubuntu:16.04
-            os: ubuntu-latest
-            install: g++-4.7-multilib
-            address-model: 32,64
-          - toolset: gcc-4.8
-            cxxstd: "11"
-            container: ubuntu:16.04
-            os: ubuntu-latest
-            install: g++-4.8-multilib
-            address-model: 32,64
-          - toolset: gcc-4.9
-            cxxstd: "11"
-            container: ubuntu:16.04
-            os: ubuntu-latest
-            install: g++-4.9-multilib
-            address-model: 32,64
-          - toolset: gcc-5
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: g++-5-multilib
-            address-model: 32,64
-          - toolset: gcc-6
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: g++-6-multilib
-            address-model: 32,64
-          - toolset: gcc-7
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: g++-7-multilib
-            address-model: 32,64
-          - toolset: gcc-8
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-8-multilib
-            address-model: 32,64
-          - toolset: gcc-9
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-9-multilib
-            address-model: 32,64
-          - toolset: gcc-10
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-10-multilib
-            address-model: 32,64
-          - toolset: gcc-11
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-22.04
-            install: g++-11-multilib
-            address-model: 32,64
-          - toolset: gcc-12
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-22.04
-            install: g++-12-multilib
-            address-model: 32,64
-          - toolset: gcc-13
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:24.04
-            os: ubuntu-latest
-            install: g++-13-multilib
-            address-model: 32,64
-          - toolset: gcc-14
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:24.04
-            os: ubuntu-latest
-            install: g++-14-multilib
-            address-model: 32,64
-          - toolset: clang
-            compiler: clang++-3.9
-            cxxstd: "11,14"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: clang-3.9
-          - toolset: clang
-            compiler: clang++-4.0
-            cxxstd: "11,14"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: clang-4.0
-          - toolset: clang
-            compiler: clang++-5.0
-            cxxstd: "11,14,1z"
-            container: ubuntu:18.04
-            os: ubuntu-latest
-            install: clang-5.0
-          - toolset: clang
-            compiler: clang++-6.0
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-6.0
-          - toolset: clang
-            compiler: clang++-7
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-7
-          - toolset: clang
-            compiler: clang++-8
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-8
-          - toolset: clang
-            compiler: clang++-9
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-9
-          - toolset: clang
-            compiler: clang++-10
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-          - toolset: clang
-            compiler: clang++-11
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-          - toolset: clang
-            compiler: clang++-12
-            cxxstd: "11,14,17,20"
-            os: ubuntu-20.04
-          - toolset: clang
-            compiler: clang++-13
-            cxxstd: "11,14,17,20"
-            container: ubuntu:22.04
-            os: ubuntu-latest
-            install: clang-13
-          - toolset: clang
-            compiler: clang++-14
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:22.04
-            os: ubuntu-latest
-            install: clang-14
-          - toolset: clang
-            compiler: clang++-15
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:22.04
-            os: ubuntu-latest
-            install: clang-15
-          - toolset: clang
-            compiler: clang++-16
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:24.04
-            os: ubuntu-latest
-            install: clang-16
-          - toolset: clang
-            compiler: clang++-17
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:24.04
-            os: ubuntu-latest
-            install: clang-17
-          - toolset: clang
-            compiler: clang++-18
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:24.04
-            os: ubuntu-latest
-            install: clang-18
-          - toolset: clang
-            compiler: clang++-19
-            cxxstd: "11,14,17,20,2b"
-            container: ubuntu:24.10
-            os: ubuntu-latest
-            install: clang-19
-          - toolset: clang
-            cxxstd: "11,14,17,20,2b"
-            os: macos-13
-          - toolset: clang
-            cxxstd: "11,14,17,20,2b"
-            os: macos-14
-          - toolset: clang
-            cxxstd: "11,14,17,20,2b"
-            os: macos-15
-
-    runs-on: ${{matrix.os}}
-
-    container:
-      image: ${{matrix.container}}
-      volumes:
-        - /node20217:/node20217:rw,rshared
-        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
-
-    defaults:
-      run:
-        shell: bash
-
-    steps:
-      - name: Setup container environment
-        if: matrix.container
-        run: |
-          apt-get update
-          apt-get -y install sudo python3 git g++ curl xz-utils
-
-      - name: Install nodejs20glibc2.17
-        if: ${{ startsWith( matrix.container, 'ubuntu:1' ) }}
-        run: |
-          curl -LO https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz
-          tar -xf node-v20.9.0-linux-x64-glibc-217.tar.xz --strip-components 1 -C /node20217
-          ldd /__e/node20/bin/node
-
-      - uses: actions/checkout@v4
-
-      - name: Install packages
-        if: matrix.install
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install ${{matrix.install}}
-
-      - name: Setup Boost
-        run: |
-          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
-          LIBRARY=${GITHUB_REPOSITORY#*/}
-          echo LIBRARY: $LIBRARY
-          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
-          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
-          echo GITHUB_REF: $GITHUB_REF
-          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
-          REF=${REF#refs/heads/}
-          echo REF: $REF
-          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
-          echo BOOST_BRANCH: $BOOST_BRANCH
-          cd ..
-          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-          cd boost-root
-          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
-          git submodule update --init tools/boostdep
-          python3 tools/boostdep/depinst/depinst.py $LIBRARY
-          ./bootstrap.sh
-          ./b2 -d0 headers
-
-      - name: Create user-config.jam
-        if: matrix.compiler
-        run: |
-          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
-
-      - name: Run tests
-        run: |
-          cd ../boost-root
-          export ADDRMD=${{matrix.address-model}}
-          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
-
-  windows:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: msvc-14.0
-            cxxstd: 14,latest
-            addrmd: 32,64
-            os: windows-2019
-          - toolset: msvc-14.2
-            cxxstd: "14,17,20,latest"
-            addrmd: 32,64
-            os: windows-2019
-          - toolset: msvc-14.3
-            cxxstd: "14,17,20,latest"
-            addrmd: 32,64
-            os: windows-2022
-          - toolset: clang-win
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2022
-          - toolset: gcc
-            cxxstd: "11,14,17,2a"
-            addrmd: 64
-            os: windows-2019
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - 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%
-          cmd /c bootstrap
-          b2 -d0 headers
-
-      - name: Run tests
-        shell: cmd
-        run: |
-          cd ../boost-root
-          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
-
-  posix-cmake-subdir:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-20.04
-          - os: ubuntu-22.04
-          - os: ubuntu-24.04
-          - os: macos-13
-          - os: macos-14
-          - os: macos-15
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install packages
-        if: matrix.install
-        run: sudo apt-get -y install ${{matrix.install}}
-
-      - name: Setup Boost
-        run: |
-          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
-          LIBRARY=${GITHUB_REPOSITORY#*/}
-          echo LIBRARY: $LIBRARY
-          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
-          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
-          echo GITHUB_REF: $GITHUB_REF
-          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
-          REF=${REF#refs/heads/}
-          echo REF: $REF
-          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
-          echo BOOST_BRANCH: $BOOST_BRANCH
-          cd ..
-          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-          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
-
-      - name: Use library with add_subdirectory
-        run: |
-          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
-          mkdir __build__ && cd __build__
-          cmake ..
-          cmake --build .
-          ctest --output-on-failure --no-tests=error
-
-  posix-cmake-install:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-20.04
-          - os: ubuntu-22.04
-          - os: ubuntu-24.04
-          - os: macos-13
-          - os: macos-14
-          - os: macos-15
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install packages
-        if: matrix.install
-        run: sudo apt-get -y install ${{matrix.install}}
-
-      - name: Setup Boost
-        run: |
-          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
-          LIBRARY=${GITHUB_REPOSITORY#*/}
-          echo LIBRARY: $LIBRARY
-          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
-          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
-          echo GITHUB_REF: $GITHUB_REF
-          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
-          REF=${REF#refs/heads/}
-          echo REF: $REF
-          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
-          echo BOOST_BRANCH: $BOOST_BRANCH
-          cd ..
-          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-          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
-
-      - name: Configure
-        run: |
-          cd ../boost-root
-          mkdir __build__ && cd __build__
-          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
-
-      - name: Install
-        run: |
-          cd ../boost-root/__build__
-          cmake --build . --target install
-
-      - name: Use the installed library
-        run: |
-          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
-          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
-          cmake --build .
-          ctest --output-on-failure --no-tests=error
-
-  posix-cmake-test:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-20.04
-          - os: ubuntu-22.04
-          - os: ubuntu-24.04
-          - os: macos-13
-          - os: macos-14
-          - os: macos-15
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install packages
-        if: matrix.install
-        run: sudo apt-get -y install ${{matrix.install}}
-
-      - name: Setup Boost
-        run: |
-          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
-          LIBRARY=${GITHUB_REPOSITORY#*/}
-          echo LIBRARY: $LIBRARY
-          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
-          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
-          echo GITHUB_REF: $GITHUB_REF
-          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
-          REF=${REF#refs/heads/}
-          echo REF: $REF
-          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
-          echo BOOST_BRANCH: $BOOST_BRANCH
-          cd ..
-          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-          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
-
-      - name: Configure
-        run: |
-          cd ../boost-root
-          mkdir __build__ && cd __build__
-          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
-
-      - name: Build tests
-        run: |
-          cd ../boost-root/__build__
-          cmake --build . --target tests
-
-      - name: Run tests
-        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@v4
-
-      - 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@v4
-
-      - 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@v4
-
-      - 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/.travis.yml
+++ b/.travis.yml
@ -1,362 +0,0 @@
-# Copyright 2016-2019 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-dist: xenial
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-9
-      env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: bionic
-      compiler: g++-10
-      env: UBSAN=1 TOOLSET=gcc CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
-      addons:
-        apt:
-          packages:
-            - g++-10
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.3
-
-    - os: linux
-      dist: trusty
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.4
-
-    - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-7
-      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-xenial-7
-
-    - os: linux
-      compiler: clang++-8
-      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-xenial-8
-
-    - os: linux
-      dist: bionic
-      compiler: clang++-9
-      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-9
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      dist: bionic
-      compiler: clang++-10
-      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-10
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      dist: bionic
-      compiler: clang++-11
-      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-11
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-11 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      dist: bionic
-      compiler: clang++-12
-      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-12
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      dist: trusty
-      compiler: clang++-libc++
-      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: linux
-      dist: bionic
-      compiler: clang++-libc++
-      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: osx
-      compiler: clang++
-      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-
-    - os: linux
-      env: CMAKE_TEST=1
-      script:
-        - mkdir __build__ && cd __build__
-        - cmake -DBOOST_ENABLE_CMAKE=1 -DBUILD_TESTING=ON -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=function ..
-        - ctest --output-on-failure -R boost_function
-
-    - os: linux
-      env: CMAKE_SUBDIR_TEST=1
-      script:
-      - cd libs/function/test/cmake_subdir_test && mkdir __build__ && cd __build__
-      - cmake ..
-      - cmake --build .
-      - cmake --build . --target check
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/boostdep
-  - cp -r $TRAVIS_BUILD_DIR/* libs/function
-  - python tools/boostdep/depinst/depinst.py function
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
-  - ./b2 -j3 libs/function/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-
-notifications:
-  email:
-    on_success: always
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,30 +1,22 @@
-# Generated by `boostdep --cmake function`
-# Copyright 2020, 2021 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-cmake_minimum_required(VERSION 3.8...3.20)
-
-project(boost_function VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
-
-add_library(boost_function INTERFACE)
-add_library(Boost::function ALIAS boost_function)
-
-target_include_directories(boost_function INTERFACE include)
-
-target_link_libraries(boost_function
-  INTERFACE
-    Boost::assert
-    Boost::bind
-    Boost::config
-    Boost::core
-    Boost::throw_exception
+#----------------------------------------------------------------------------
+# This file was automatically generated from the original CMakeLists.txt file
+# Add a variable to hold the headers for the library
+set (lib_headers
+    function.hpp
+    function
 )

-target_compile_features(boost_function INTERFACE cxx_std_11)
+# Add a library target to the build system
+boost_library_project(
+  function
+  #  SRCDIRS 
+  TESTDIRS  test 
+  HEADERS ${lib_headers}
+  DOCDIRS  doc
+  #  DESCRIPTION 
+  MODULARIZED 
+  #  AUTHORS 
+  #  MAINTAINERS 
+)

-if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")

-  add_subdirectory(test)
-
-endif()
--- a/README.md
+++ b/README.md
@ -1,18 +0,0 @@
-# Boost.Function, a polymorphic function wrapper
-
-[Boost.Function](http://boost.org/libs/function), part of the
-[Boost C++ Libraries](http://boost.org), is the original implementation of the
-polymorphic function wrapper `boost::function`, which was eventually accepted
-into the C++11 standard as [`std::function`](https://en.cppreference.com/w/cpp/utility/functional/function).
-
-## Currently supported compilers
-
-* g++ 4.7 or later
-* clang++ 3.9 or later
-* Visual Studio 2013-2022
-
-Tested on [Github Actions](https://github.com/boostorg/function/actions) and [Appveyor](https://ci.appveyor.com/project/pdimov/function/).
-
-## License
-
-Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
--- a/appveyor.yml
+++ b/appveyor.yml
@ -1,67 +0,0 @@
-# Copyright 2016-2019 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-12.0,msvc-14.0
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 14,17
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: clang-win
-      CXXSTD: 14,17,latest
-      ADDRMD: 64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      TOOLSET: clang-win
-      CXXSTD: 14,17,latest
-      ADDRMD: 64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-      CXXSTD: 11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin64\bin;
-      TOOLSET: gcc
-      CXXSTD: 11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw\bin;
-      TOOLSET: gcc
-      CXXSTD: 11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-      CXXSTD: 11,14,1z
-
-install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - cd ..
-  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\function\
-  - python tools/boostdep/depinst/depinst.py function
-  - cmd /c bootstrap
-  - b2 -d0 headers
-
-build: off
-
-test_script:
-  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j3 libs/function/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
--- a/build.jam
+++ b/build.jam
@ -1,24 +0,0 @@
-# Copyright 2023-2024 René Ferdinand Rivera Morell
-# Copyright 2024 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-require-b2 5.2 ;
-
-constant boost_dependencies :
-    /boost/assert//boost_assert
-    /boost/bind//boost_bind
-    /boost/config//boost_config
-    /boost/core//boost_core
-    /boost/throw_exception//boost_throw_exception
-    ;
-
-project /boost/function ;
-
-explicit
-    [ alias boost_function : : : : <include>include <library>$(boost_dependencies) ]
-    [ alias all : boost_function example test ]
-    ;
-
-call-if : boost-library function
-    ;
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@ -0,0 +1,2 @@
+boost_add_documentation(function.xml
+  faq.xml history.xml misc.xml reference.xml tests.xml tutorial.xml)
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -3,23 +3,8 @@
 #   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)
-project function/doc ;
+project boost/doc ;
 import boostbook : boostbook ;

-boostbook function-doc 
-    : 
-    function.xml 
-    :
-        <xsl:param>boost.root=../../../..
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-    ;
+boostbook function-doc : function.xml ;

-###############################################################################
-alias boostdoc
-    : function.xml
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;
--- a/doc/history.xml
+++ b/doc/history.xml
@ -13,15 +13,6 @@

 <itemizedlist spacing="compact">

-  <listitem><para><bold>Version 1.52.0</bold>: </para>
-    <itemizedlist spacing="compact">
-      <listitem><para>Move constructors and move assignment 
-      operators added (only for compilers with C++11 rvalue 
-      references support). Original patch
-      contributed by Antony Polukhin.</para></listitem>
-    </itemizedlist>
-  </listitem>
-
  <listitem><para><bold>Version 1.37.0</bold>: </para>
    <itemizedlist spacing="compact">
      <listitem><para>Improved the performance of Boost.Function's
--- a/doc/reference.xml
+++ b/doc/reference.xml
@ -58,7 +58,7 @@
      <para>A function object <code>f</code> of
      type <code>F</code> is
      <emphasis>stateless</emphasis> if it is a function pointer or if
-      <code><classname>boost::is_stateless</classname>&lt;F&gt;</code>
+      <code><classname>boost::is_stateless</classname>&lt;T&gt;</code>
      is true. The construction of or copy to a Boost.Function object
      from a stateless function object will not cause exceptions to be
      thrown and will not allocate any storage.
@ -128,7 +128,7 @@

      <method name="target_type" cv="const">
        <type>const std::type_info&amp;</type>
-        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Works even with RTTI off.</simpara></returns>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
        <throws><simpara>Will not throw.</simpara></throws>
      </method>
    </method-group>
@ -203,15 +203,6 @@
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>

-    <constructor>
-      <parameter name="f">
-        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </constructor>
-    
    <constructor>
      <template>
        <template-type-parameter name="F"/>
@ -245,15 +236,6 @@
      </parameter>
      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
    </copy-assignment>
-    
-    <copy-assignment>
-      <parameter name="f">
-        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </copy-assignment>

    <method-group name="modifiers">
      <method name="swap">
@ -625,16 +607,7 @@
      <postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
-        
-    <constructor>
-      <parameter name="f">
-        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </constructor>
-    
+
    <constructor>
      <parameter name="f">
        <paramtype>const <classname>function</classname>&amp;</paramtype>
@ -643,15 +616,6 @@
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>

-    <constructor>
-      <parameter name="f">
-        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </constructor>
-    
    <constructor>
      <template>
        <template-type-parameter name="F"/>
@ -681,19 +645,10 @@

    <copy-assignment>
      <parameter name="f">
-        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+        <paramtype>const <classname>function</classname>&amp;</paramtype>
      </parameter>
      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
    </copy-assignment>
-    
-    <copy-assignment>
-      <parameter name="f">
-        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </copy-assignment>

    <copy-assignment>
      <parameter name="f">
@ -702,15 +657,6 @@
      <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
    </copy-assignment>
-    
-    <copy-assignment>
-      <parameter name="f">
-        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </copy-assignment>

    <method-group name="modifiers">
      <method name="swap">
--- a/doc/tutorial.xml
+++ b/doc/tutorial.xml
@ -35,12 +35,12 @@ form to use for your compiler.
        <row>
          <entry>
            <itemizedlist spacing="compact">
-              <listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
+              <listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
              <listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
              <listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
              <listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
              <listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
-	      <listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
+	      <listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
            </itemizedlist>
          </entry>
          <entry>
--- a/example/Jamfile
+++ b/example/Jamfile
@ -1,18 +0,0 @@
-# Boost.Function Library example Jamfile
-#
-# Copyright (c) 2008 James E. King III
-#
-# 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
-
-require-b2 5.0.1 ;
-import-search /boost/config/checks ;
-import config : requires ;
-import testing ;
-
-project : requirements <library>/boost/function//boost_function ;
-
-run bind1st.cpp : : : [ requires cxx98_binders ] ;
-run int_div.cpp ;
-run sum_avg.cpp ;
--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -1,6 +1,3 @@
-#ifndef BOOST_FUNCTION_HPP_INCLUDED
-#define BOOST_FUNCTION_HPP_INCLUDED
-
 // Boost.Function library

 //  Copyright Douglas Gregor 2001-2003. Use, modification and
@ -13,6 +10,57 @@
 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
 // design of this library.

-#include <boost/function/function_template.hpp>
+#include <functional> // unary_function, binary_function

-#endif // #ifndef BOOST_FUNCTION_HPP_INCLUDED
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/detail/workaround.hpp>
+
+#ifndef BOOST_FUNCTION_MAX_ARGS
+#  define BOOST_FUNCTION_MAX_ARGS 10
+#endif // BOOST_FUNCTION_MAX_ARGS
+
+// Include the prologue here so that the use of file-level iteration
+// in anything that may be included by function_template.hpp doesn't break
+#include <boost/function/detail/prologue.hpp>
+
+// Visual Age C++ doesn't handle the file iteration well
+#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
+#  if BOOST_FUNCTION_MAX_ARGS >= 0
+#    include <boost/function/function0.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 1
+#    include <boost/function/function1.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 2
+#    include <boost/function/function2.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 3
+#    include <boost/function/function3.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 4
+#    include <boost/function/function4.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 5
+#    include <boost/function/function5.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 6
+#    include <boost/function/function6.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 7
+#    include <boost/function/function7.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 8
+#    include <boost/function/function8.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 9
+#    include <boost/function/function9.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 10
+#    include <boost/function/function10.hpp>
+#  endif
+#else
+// What is the '3' for?
+#  define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,<boost/function/detail/function_iterate.hpp>))
+#  include BOOST_PP_ITERATE()
+#  undef BOOST_PP_ITERATION_PARAMS_1
+#endif
--- a/include/boost/function/detail/function_iterate.hpp
+++ b/include/boost/function/detail/function_iterate.hpp
@ -0,0 +1,16 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+#if !defined(BOOST_PP_IS_ITERATING)
+# error Boost.Function - do not include this file!
+#endif
+
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
+
--- a/include/boost/function/detail/gen_maybe_include.pl
+++ b/include/boost/function/detail/gen_maybe_include.pl
@ -0,0 +1,37 @@
+#!/usr/bin/perl -w
+#
+# Boost.Function library
+#
+# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu)
+#
+# Permission to copy, use, sell and distribute this software is granted
+# provided this copyright notice appears in all copies.
+# Permission to modify the code and to distribute modified code is granted
+# provided this copyright notice appears in all copies, and a notice
+# that the code was modified is included with the copyright notice.
+#
+# This software is provided "as is" without express or implied warranty,
+# and with no claim as to its suitability for any purpose.
+#
+# For more information, see http://www.boost.org
+use English;
+
+$max_args = $ARGV[0];
+
+open (OUT, ">maybe_include.hpp") or die("Cannot write to maybe_include.hpp");
+for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) {
+    if ($on_arg == 0) {
+	print OUT "#if";
+    }
+    else {
+	print OUT "#elif";
+    }
+    print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n";
+    print OUT "#  ifndef BOOST_FUNCTION_$on_arg\n";
+    print OUT "#    define BOOST_FUNCTION_$on_arg\n";
+    print OUT "#    include <boost/function/function_template.hpp>\n";
+    print OUT "#  endif\n";
+}
+print OUT "#else\n";
+print OUT "#  error Cannot handle Boost.Function objects that accept more than $max_args arguments!\n";
+print OUT "#endif\n";
--- a/include/boost/function/detail/maybe_include.hpp
+++ b/include/boost/function/detail/maybe_include.hpp
@ -0,0 +1,267 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#if BOOST_FUNCTION_NUM_ARGS == 0
+#  ifndef BOOST_FUNCTION_0
+#    define BOOST_FUNCTION_0
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 1
+#  ifndef BOOST_FUNCTION_1
+#    define BOOST_FUNCTION_1
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 2
+#  ifndef BOOST_FUNCTION_2
+#    define BOOST_FUNCTION_2
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 3
+#  ifndef BOOST_FUNCTION_3
+#    define BOOST_FUNCTION_3
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 4
+#  ifndef BOOST_FUNCTION_4
+#    define BOOST_FUNCTION_4
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 5
+#  ifndef BOOST_FUNCTION_5
+#    define BOOST_FUNCTION_5
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 6
+#  ifndef BOOST_FUNCTION_6
+#    define BOOST_FUNCTION_6
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 7
+#  ifndef BOOST_FUNCTION_7
+#    define BOOST_FUNCTION_7
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 8
+#  ifndef BOOST_FUNCTION_8
+#    define BOOST_FUNCTION_8
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 9
+#  ifndef BOOST_FUNCTION_9
+#    define BOOST_FUNCTION_9
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 10
+#  ifndef BOOST_FUNCTION_10
+#    define BOOST_FUNCTION_10
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 11
+#  ifndef BOOST_FUNCTION_11
+#    define BOOST_FUNCTION_11
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 12
+#  ifndef BOOST_FUNCTION_12
+#    define BOOST_FUNCTION_12
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 13
+#  ifndef BOOST_FUNCTION_13
+#    define BOOST_FUNCTION_13
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 14
+#  ifndef BOOST_FUNCTION_14
+#    define BOOST_FUNCTION_14
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 15
+#  ifndef BOOST_FUNCTION_15
+#    define BOOST_FUNCTION_15
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 16
+#  ifndef BOOST_FUNCTION_16
+#    define BOOST_FUNCTION_16
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 17
+#  ifndef BOOST_FUNCTION_17
+#    define BOOST_FUNCTION_17
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 18
+#  ifndef BOOST_FUNCTION_18
+#    define BOOST_FUNCTION_18
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 19
+#  ifndef BOOST_FUNCTION_19
+#    define BOOST_FUNCTION_19
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 20
+#  ifndef BOOST_FUNCTION_20
+#    define BOOST_FUNCTION_20
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 21
+#  ifndef BOOST_FUNCTION_21
+#    define BOOST_FUNCTION_21
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 22
+#  ifndef BOOST_FUNCTION_22
+#    define BOOST_FUNCTION_22
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 23
+#  ifndef BOOST_FUNCTION_23
+#    define BOOST_FUNCTION_23
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 24
+#  ifndef BOOST_FUNCTION_24
+#    define BOOST_FUNCTION_24
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 25
+#  ifndef BOOST_FUNCTION_25
+#    define BOOST_FUNCTION_25
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 26
+#  ifndef BOOST_FUNCTION_26
+#    define BOOST_FUNCTION_26
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 27
+#  ifndef BOOST_FUNCTION_27
+#    define BOOST_FUNCTION_27
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 28
+#  ifndef BOOST_FUNCTION_28
+#    define BOOST_FUNCTION_28
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 29
+#  ifndef BOOST_FUNCTION_29
+#    define BOOST_FUNCTION_29
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 30
+#  ifndef BOOST_FUNCTION_30
+#    define BOOST_FUNCTION_30
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 31
+#  ifndef BOOST_FUNCTION_31
+#    define BOOST_FUNCTION_31
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 32
+#  ifndef BOOST_FUNCTION_32
+#    define BOOST_FUNCTION_32
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 33
+#  ifndef BOOST_FUNCTION_33
+#    define BOOST_FUNCTION_33
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 34
+#  ifndef BOOST_FUNCTION_34
+#    define BOOST_FUNCTION_34
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 35
+#  ifndef BOOST_FUNCTION_35
+#    define BOOST_FUNCTION_35
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 36
+#  ifndef BOOST_FUNCTION_36
+#    define BOOST_FUNCTION_36
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 37
+#  ifndef BOOST_FUNCTION_37
+#    define BOOST_FUNCTION_37
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 38
+#  ifndef BOOST_FUNCTION_38
+#    define BOOST_FUNCTION_38
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 39
+#  ifndef BOOST_FUNCTION_39
+#    define BOOST_FUNCTION_39
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 40
+#  ifndef BOOST_FUNCTION_40
+#    define BOOST_FUNCTION_40
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 41
+#  ifndef BOOST_FUNCTION_41
+#    define BOOST_FUNCTION_41
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 42
+#  ifndef BOOST_FUNCTION_42
+#    define BOOST_FUNCTION_42
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 43
+#  ifndef BOOST_FUNCTION_43
+#    define BOOST_FUNCTION_43
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 44
+#  ifndef BOOST_FUNCTION_44
+#    define BOOST_FUNCTION_44
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 45
+#  ifndef BOOST_FUNCTION_45
+#    define BOOST_FUNCTION_45
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 46
+#  ifndef BOOST_FUNCTION_46
+#    define BOOST_FUNCTION_46
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 47
+#  ifndef BOOST_FUNCTION_47
+#    define BOOST_FUNCTION_47
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 48
+#  ifndef BOOST_FUNCTION_48
+#    define BOOST_FUNCTION_48
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 49
+#  ifndef BOOST_FUNCTION_49
+#    define BOOST_FUNCTION_49
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 50
+#  ifndef BOOST_FUNCTION_50
+#    define BOOST_FUNCTION_50
+#    include <boost/function/function_template.hpp>
+#  endif
+#else
+#  error Cannot handle Boost.Function objects that accept more than 50 arguments!
+#endif
--- a/include/boost/function/detail/prologue.hpp
+++ b/include/boost/function/detail/prologue.hpp
@ -0,0 +1,26 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_FUNCTION_PROLOGUE_HPP
+#define BOOST_FUNCTION_PROLOGUE_HPP
+#  include <cassert>
+#  include <algorithm>
+#  include <boost/config/no_tr1/functional.hpp> // unary_function, binary_function
+#  include <boost/throw_exception.hpp>
+#  include <boost/config.hpp>
+#  include <boost/function/function_base.hpp>
+#  include <boost/mem_fn.hpp>
+#  include <boost/type_traits/is_integral.hpp>
+#  include <boost/preprocessor/enum.hpp>
+#  include <boost/preprocessor/enum_params.hpp>
+#  include <boost/preprocessor/cat.hpp>
+#  include <boost/preprocessor/repeat.hpp>
+#  include <boost/preprocessor/inc.hpp>
+#  include <boost/type_traits/is_void.hpp>
+#endif // BOOST_FUNCTION_PROLOGUE_HPP
--- a/include/boost/function/function0.hpp
+++ b/include/boost/function/function0.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 0
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function1.hpp
+++ b/include/boost/function/function1.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 1
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function10.hpp
+++ b/include/boost/function/function10.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 10
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function2.hpp
+++ b/include/boost/function/function2.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 2
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function3.hpp
+++ b/include/boost/function/function3.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 3
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function4.hpp
+++ b/include/boost/function/function4.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 4
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function5.hpp
+++ b/include/boost/function/function5.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 5
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function6.hpp
+++ b/include/boost/function/function6.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 6
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function7.hpp
+++ b/include/boost/function/function7.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 7
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function8.hpp
+++ b/include/boost/function/function8.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 8
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function9.hpp
+++ b/include/boost/function/function9.hpp
@ -7,4 +7,6 @@

 // For more information, see http://www.boost.org

-#include <boost/function/function_template.hpp>
+#define BOOST_FUNCTION_NUM_ARGS 9
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -11,30 +11,75 @@
 #ifndef BOOST_FUNCTION_BASE_HEADER
 #define BOOST_FUNCTION_BASE_HEADER

-#include <boost/function/function_fwd.hpp>
-#include <boost/function_equal.hpp>
-#include <boost/core/typeinfo.hpp>
-#include <boost/core/ref.hpp>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 #include <stdexcept>
 #include <string>
 #include <memory>
 #include <new>
-#include <type_traits>
+#include <typeinfo>
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/composite_traits.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/ref.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#ifndef BOOST_NO_SFINAE
+#  include "boost/utility/enable_if.hpp"
+#else
+#  include "boost/mpl/bool.hpp"
+#endif
+#include <boost/function_equal.hpp>
+#include <boost/function/function_fwd.hpp>

 #if defined(BOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4793 ) // complaint about native code generation
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
+#endif       
+
+// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
+#ifdef BOOST_NO_STD_TYPEINFO
+// Embedded VC++ does not have type_info in namespace std
+#  define BOOST_FUNCTION_STD_NS
+#else
+#  define BOOST_FUNCTION_STD_NS std
 #endif

-// retained because used in a test
-#define BOOST_FUNCTION_TARGET_FIX(x)
+// Borrowed from Boost.Python library: determines the cases where we
+// need to use std::type_info::name to compare instead of operator==.
+# if (defined(__GNUC__) && __GNUC__ >= 3) \
+ || defined(_AIX) \
+ || (   defined(__sgi) && defined(__host_mips))
+#  include <cstring>
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
+     (std::strcmp((X).name(),(Y).name()) == 0)
+# else
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#endif

-#define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
-  typename std::enable_if< !std::is_integral<Functor>::value, Type>::type
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
+#  define BOOST_FUNCTION_TARGET_FIX(x) x
+#else
+#  define BOOST_FUNCTION_TARGET_FIX(x)
+#endif // not MSVC
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
+      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+                            (::boost::is_integral<Functor>::value)>::value), \
+                           Type>::type
+#else
+// BCC doesn't recognize this depends on a template argument and complains
+// about the use of 'typename'
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
+      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+                   (::boost::is_integral<Functor>::value)>::value), \
+                       Type>::type
+#endif

 namespace boost {
  namespace detail {
@ -47,16 +92,15 @@ namespace boost {
       * object pointers, and a structure that resembles a bound
       * member function pointer.
       */
-      union function_buffer_members
+      union function_buffer
      {
        // For pointers to function objects
-        typedef void* obj_ptr_t;
-        mutable obj_ptr_t obj_ptr;
+        mutable void* obj_ptr;

        // For pointers to std::type_info objects
        struct type_t {
          // (get_functor_type_tag, check_functor_type_tag).
-          const boost::core::typeinfo* type;
+          const BOOST_FUNCTION_STD_NS::type_info* type;

          // Whether the type is const-qualified.
          bool const_qualified;
@ -65,13 +109,7 @@ namespace boost {
        } type;

        // For function pointers of all kinds
-        typedef void (*func_ptr_t)();
-        mutable func_ptr_t func_ptr;
-
-#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
-# pragma warning(push)
-# pragma warning(disable: 5243)
-#endif
+        mutable void (*func_ptr)();

        // For bound member pointers
        struct bound_memfunc_ptr_t {
@ -79,10 +117,6 @@ namespace boost {
          void* obj_ptr;
        } bound_memfunc_ptr;

-#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
-# pragma warning(pop)
-#endif
-
        // For references to function objects. We explicitly keep
        // track of the cv-qualifiers on the object referenced.
        struct obj_ref_t {
@ -90,15 +124,33 @@ namespace boost {
          bool is_const_qualified;
          bool is_volatile_qualified;
        } obj_ref;
-      };
-
-      union BOOST_SYMBOL_VISIBLE function_buffer
-      {
-        // Type-specific union members
-        mutable function_buffer_members members;

        // To relax aliasing constraints
-        mutable char data[sizeof(function_buffer_members)];
+        mutable char data;
+      };
+
+      /**
+       * The unusable class is a placeholder for unused function arguments
+       * It is also completely unusable except that it constructable from
+       * anything. This helps compilers without partial specialization to
+       * handle Boost.Function objects returning void.
+       */
+      struct unusable
+      {
+        unusable() {}
+        template<typename T> unusable(const T&) {}
+      };
+
+      /* Determine the return type. This supports compilers that do not support
+       * void returns or partial specialization by silently changing the return
+       * type to "unusable".
+       */
+      template<typename T> struct function_return_type { typedef T type; };
+
+      template<>
+      struct function_return_type<void>
+      {
+        typedef unusable type;
      };

      // The operation type to perform on the given functor/function pointer
@ -119,15 +171,15 @@ namespace boost {
      template<typename F>
      class get_function_tag
      {
-        typedef typename std::conditional<std::is_pointer<F>::value,
+        typedef typename mpl::if_c<(is_pointer<F>::value),
                                   function_ptr_tag,
                                   function_obj_tag>::type ptr_or_obj_tag;

-        typedef typename std::conditional<std::is_member_pointer<F>::value,
+        typedef typename mpl::if_c<(is_member_pointer<F>::value),
                                   member_ptr_tag,
                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;

-        typedef typename std::conditional<is_reference_wrapper<F>::value,
+        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
                                   function_obj_ref_tag,
                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;

@ -141,42 +193,45 @@ namespace boost {
      struct reference_manager
      {
        static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
               functor_manager_operation_type op)
        {
          switch (op) {
-          case clone_functor_tag:
-            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+          case clone_functor_tag: 
+            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
            return;

          case move_functor_tag:
-            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
-            in_buffer.members.obj_ref.obj_ptr = 0;
+            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+            in_buffer.obj_ref.obj_ptr = 0;
            return;

          case destroy_functor_tag:
-            out_buffer.members.obj_ref.obj_ptr = 0;
+            out_buffer.obj_ref.obj_ptr = 0;
            return;

          case check_functor_type_tag:
            {
+              const BOOST_FUNCTION_STD_NS::type_info& check_type 
+                = *out_buffer.type.type;
+
              // Check whether we have the same type. We can add
              // cv-qualifiers, but we can't take them away.
-              if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(F)
-                  && (!in_buffer.members.obj_ref.is_const_qualified
-                      || out_buffer.members.type.const_qualified)
-                  && (!in_buffer.members.obj_ref.is_volatile_qualified
-                      || out_buffer.members.type.volatile_qualified))
-                out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
+              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F))
+                  && (!in_buffer.obj_ref.is_const_qualified 
+                      || out_buffer.type.const_qualified)
+                  && (!in_buffer.obj_ref.is_volatile_qualified
+                      || out_buffer.type.volatile_qualified))
+                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
              else
-                out_buffer.members.obj_ptr = 0;
+                out_buffer.obj_ptr = 0;
            }
            return;

          case get_functor_type_tag:
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(F);
-            out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
-            out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
+            out_buffer.type.type = &typeid(F);
+            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
+            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
            return;
          }
        }
@ -190,10 +245,10 @@ namespace boost {
      struct function_allows_small_object_optimization
      {
        BOOST_STATIC_CONSTANT
-          (bool,
+          (bool, 
           value = ((sizeof(F) <= sizeof(function_buffer) &&
-                     (std::alignment_of<function_buffer>::value
-                      % std::alignment_of<F>::value == 0))));
+                     (alignment_of<function_buffer>::value 
+                      % alignment_of<F>::value == 0))));
      };

      template <typename F,typename A>
@ -204,12 +259,6 @@ namespace boost {
          A(a)
        {
        }
-
-        functor_wrapper(const functor_wrapper& f) :
-          F(static_cast<const F&>(f)),
-          A(static_cast<const A&>(f))
-        {
-        }
      };

      /**
@ -223,56 +272,57 @@ namespace boost {

        // Function pointers
        static inline void
-        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag)
-            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+            out_buffer.func_ptr = in_buffer.func_ptr;
          else if (op == move_functor_tag) {
-            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
-            in_buffer.members.func_ptr = 0;
+            out_buffer.func_ptr = in_buffer.func_ptr;
+            in_buffer.func_ptr = 0;
          } else if (op == destroy_functor_tag)
-            out_buffer.members.func_ptr = 0;
+            out_buffer.func_ptr = 0;
          else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
-              out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = &in_buffer.func_ptr;
            else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }

        // Function objects that fit in the small-object buffer.
        static inline void
-        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op)
        {
-          if (op == clone_functor_tag) {
-            const functor_type* in_functor =
-              reinterpret_cast<const functor_type*>(in_buffer.data);
-            new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
+          if (op == clone_functor_tag || op == move_functor_tag) {
+            const functor_type* in_functor = 
+              reinterpret_cast<const functor_type*>(&in_buffer.data);
+            new ((void*)&out_buffer.data) functor_type(*in_functor);

-          } else if (op == move_functor_tag) {
-              functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
-              new (reinterpret_cast<void*>(out_buffer.data)) functor_type(std::move(*f));
-              f->~Functor();
+            if (op == move_functor_tag) {
+              reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
+            }
          } else if (op == destroy_functor_tag) {
            // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
-             functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
-             (void)f; // suppress warning about the value of f not being used (MSVC)
-             f->~Functor();
+            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
          } else if (op == check_functor_type_tag) {
-             if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
-              out_buffer.members.obj_ptr = in_buffer.data;
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = &in_buffer.data;
            else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;            
          }
        }
      };
@ -285,7 +335,7 @@ namespace boost {

        // Function pointers
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
@ -293,45 +343,45 @@ namespace boost {

        // Function objects that fit in the small-object buffer.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, std::true_type)
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }
-
+        
        // Function objects that require heap allocation
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, std::false_type)
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::false_)
        {
          if (op == clone_functor_tag) {
            // Clone the functor
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
-            // jewillco: Changing this to static_cast because GCC 2.95.3 is
-            // obsolete.
            const functor_type* f =
-              static_cast<const functor_type*>(in_buffer.members.obj_ptr);
+              (const functor_type*)(in_buffer.obj_ptr);
            functor_type* new_f = new functor_type(*f);
-            out_buffer.members.obj_ptr = new_f;
+            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
-            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
-            in_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor pointer type */
            functor_type* f =
-              static_cast<functor_type*>(out_buffer.members.obj_ptr);
+              static_cast<functor_type*>(out_buffer.obj_ptr);
            delete f;
-            out_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
-              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            const BOOST_FUNCTION_STD_NS::type_info& check_type
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }

@ -339,35 +389,39 @@ namespace boost {
        // object can use the small-object optimization buffer or
        // whether we need to allocate it on the heap.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
-                  std::integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }

        // For member pointers, we use the small-object optimization buffer.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, member_ptr_tag)
        {
-          manager(in_buffer, out_buffer, op, std::true_type());
+          manager(in_buffer, out_buffer, op, mpl::true_());
        }

      public:
        /* Dispatch to an appropriate manager based on whether we have a
           function pointer or a function object pointer. */
        static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
-          if (op == get_functor_type_tag) {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type);
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
-          } else {
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+            return;
+
+          default:
            manager(in_buffer, out_buffer, op, tag_type());
+            return;
          }
        }
      };
@ -380,7 +434,7 @@ namespace boost {

        // Function pointers
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
@ -388,55 +442,57 @@ namespace boost {

        // Function objects that fit in the small-object buffer.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, std::true_type)
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }
-
+        
        // Function objects that require heap allocation
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, std::false_type)
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::false_)
        {
          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
-
-          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
-          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;

          if (op == clone_functor_tag) {
            // Clone the functor
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
            const functor_wrapper_type* f =
-              static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
+              (const functor_wrapper_type*)(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
-            std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f);
+            wrapper_allocator.construct(copy, *f);

            // Get back to the original pointer type
            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
-            out_buffer.members.obj_ptr = new_f;
+            out_buffer.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
-            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
-            in_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor_wrapper_type */
            functor_wrapper_type* victim =
-              static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
+              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
-            std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim);
+            wrapper_allocator.destroy(victim);
            wrapper_allocator.deallocate(victim,1);
-            out_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
-              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }

@ -444,27 +500,31 @@ namespace boost {
        // object can use the small-object optimization buffer or
        // whether we need to allocate it on the heap.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
-                  std::integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }

      public:
        /* Dispatch to an appropriate manager based on whether we have a
           function pointer or a function object pointer. */
        static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
-          if (op == get_functor_type_tag) {
-            out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type);
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
-          } else {
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+            return;
+
+          default:
            manager(in_buffer, out_buffer, op, tag_type());
+            return;
          }
        }
      };
@ -472,14 +532,73 @@ namespace boost {
      // A type that is only used for comparisons against zero
      struct useless_clear_type {};

+#ifdef BOOST_NO_SFINAE
+      // These routines perform comparisons between a Boost.Function
+      // object and an arbitrary function object (when the last
+      // parameter is mpl::bool_<false>) or against zero (when the
+      // last parameter is mpl::bool_<true>). They are only necessary
+      // for compilers that don't support SFINAE.
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
+        { return f.empty(); }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f, const Functor&, int,
+                          mpl::bool_<true>)
+        { return !f.empty(); }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const Functor& g, long,
+                      mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return function_equal(*fp, g);
+          else return false;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const reference_wrapper<Functor>& g,
+                      int, mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return fp == g.get_pointer();
+          else return false;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f, const Functor& g, long,
+                          mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return !function_equal(*fp, g);
+          else return true;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f,
+                          const reference_wrapper<Functor>& g, int,
+                          mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return fp != g.get_pointer();
+          else return true;
+        }
+#endif // BOOST_NO_SFINAE
+
      /**
       * Stores the "manager" portion of the vtable for a
       * boost::function object.
       */
      struct vtable_base
      {
-        void (*manager)(const function_buffer& in_buffer,
-                        function_buffer& out_buffer,
+        void (*manager)(const function_buffer& in_buffer, 
+                        function_buffer& out_buffer, 
                        functor_manager_operation_type op);
      };
    } // end namespace function
@ -499,15 +618,15 @@ public:
  /** Determine if the function is empty (i.e., has no target). */
  bool empty() const { return !vtable; }

-  /** Retrieve the type of the stored function object, or type_id<void>()
+  /** Retrieve the type of the stored function object, or typeid(void)
      if this is empty. */
-  const boost::core::typeinfo& target_type() const
+  const BOOST_FUNCTION_STD_NS::type_info& target_type() const
  {
-    if (!vtable) return BOOST_CORE_TYPEID(void);
+    if (!vtable) return typeid(void);

    detail::function::function_buffer type;
-    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
-    return *type.members.type.type;
+    vtable->manager(functor, type, detail::function::get_functor_type_tag);
+    return *type.type.type;
  }

  template<typename Functor>
@ -516,35 +635,42 @@ public:
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.members.type.type = &BOOST_CORE_TYPEID(Functor);
-      type_result.members.type.const_qualified = std::is_const<Functor>::value;
-      type_result.members.type.volatile_qualified = std::is_volatile<Functor>::value;
-      get_vtable()->manager(functor, type_result,
+      type_result.type.type = &typeid(Functor);
+      type_result.type.const_qualified = is_const<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      vtable->manager(functor, type_result, 
                      detail::function::check_functor_type_tag);
-      return static_cast<Functor*>(type_result.members.obj_ptr);
+      return static_cast<Functor*>(type_result.obj_ptr);
    }

  template<typename Functor>
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    const Functor* target( Functor * = 0 ) const
+#else
    const Functor* target() const
+#endif
    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.members.type.type = &BOOST_CORE_TYPEID(Functor);
-      type_result.members.type.const_qualified = true;
-      type_result.members.type.volatile_qualified = std::is_volatile<Functor>::value;
-      get_vtable()->manager(functor, type_result,
+      type_result.type.type = &typeid(Functor);
+      type_result.type.const_qualified = true;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      vtable->manager(functor, type_result, 
                      detail::function::check_functor_type_tag);
      // GCC 2.95.3 gets the CV qualifiers wrong here, so we
      // can't do the static_cast that we should do.
-      return static_cast<const Functor*>(type_result.members.obj_ptr);
+      return (const Functor*)(type_result.obj_ptr);
    }

  template<typename F>
-    typename std::enable_if< !std::is_function<F>::value, bool >::type
-    contains(const F& f) const
+    bool contains(const F& f) const
    {
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+      if (const F* fp = this->target( (F*)0 ))
+#else
      if (const F* fp = this->template target<F>())
+#endif
      {
        return function_equal(*fp, f);
      } else {
@ -552,50 +678,45 @@ public:
      }
    }

-  template<typename Fn>
-    typename std::enable_if< std::is_function<Fn>::value, bool >::type
-    contains(Fn& f) const
+#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
+  // GCC 3.3 and newer cannot copy with the global operator==, due to
+  // problems with instantiation of function return types before it
+  // has been verified that the argument types match up.
+  template<typename Functor>
+    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    operator==(Functor g) const
    {
-      typedef Fn* F;
-      if (const F* fp = this->template target<F>())
-      {
-        return function_equal(*fp, &f);
-      } else {
-        return false;
-      }
+      if (const Functor* fp = target<Functor>())
+        return function_equal(*fp, g);
+      else return false;
    }

+  template<typename Functor>
+    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    operator!=(Functor g) const
+    {
+      if (const Functor* fp = target<Functor>())
+        return !function_equal(*fp, g);
+      else return true;
+    }
+#endif
+
 public: // should be protected, but GCC 2.95.3 will fail to allow access
-  detail::function::vtable_base* get_vtable() const {
-    return reinterpret_cast<detail::function::vtable_base*>(
-             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
-  }
-
-  bool has_trivial_copy_and_destroy() const {
-    return reinterpret_cast<std::size_t>(vtable) & 0x01;
-  }
-
  detail::function::vtable_base* vtable;
  mutable detail::function::function_buffer functor;
 };

-#if defined(BOOST_CLANG)
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
 /**
 * The bad_function_call exception class is thrown when a boost::function
 * object is invoked
 */
-class BOOST_SYMBOL_VISIBLE bad_function_call : public std::runtime_error
+class bad_function_call : public std::runtime_error
 {
 public:
  bad_function_call() : std::runtime_error("call to empty boost::function") {}
 };
-#if defined(BOOST_CLANG)
-#   pragma clang diagnostic pop
-#endif

+#ifndef BOOST_NO_SFINAE
 inline bool operator==(const function_base& f,
                       detail::function::useless_clear_type*)
 {
@ -619,10 +740,43 @@ inline bool operator!=(detail::function::useless_clear_type*,
 {
  return !f.empty();
 }
+#endif

+#ifdef BOOST_NO_SFINAE
+// Comparisons between boost::function objects and arbitrary function objects
+template<typename Functor>
+  inline bool operator==(const function_base& f, Functor g)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator==(Functor g, const function_base& f)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator!=(const function_base& f, Functor g)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_not_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator!=(Functor g, const function_base& f)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_not_equal(f, g, 0, integral());
+  }
+#else
+
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
 // Comparisons between boost::function objects and arbitrary function
-// objects.
-
+// objects. GCC 3.3 and before has an obnoxious bug that prevents this
+// from working.
 template<typename Functor>
  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
  operator==(const function_base& f, Functor g)
@ -658,6 +812,7 @@ template<typename Functor>
      return !function_equal(g, *fp);
    else return true;
  }
+#  endif

 template<typename Functor>
  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
@ -695,6 +850,8 @@ template<typename Functor>
    else return true;
  }

+#endif // Compiler supporting SFINAE
+
 namespace detail {
  namespace function {
    inline bool has_empty_target(const function_base* f)
@ -718,9 +875,6 @@ namespace detail {
 } // end namespace boost

 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
-
-#if defined(BOOST_MSVC)
-#   pragma warning( pop )
-#endif
+#undef BOOST_FUNCTION_COMPARE_TYPE_ID

 #endif // BOOST_FUNCTION_BASE_HEADER
--- a/include/boost/function/function_fwd.hpp
+++ b/include/boost/function/function_fwd.hpp
@ -10,9 +10,25 @@
 #define BOOST_FUNCTION_FWD_HPP
 #include <boost/config.hpp>

+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+// Work around a compiler bug.
+// boost::python::objects::function has to be seen by the compiler before the
+// boost::function class template.
+namespace boost { namespace python { namespace objects {
+  class function;
+}}}
+#endif
+
+#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
+ || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+ || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+#endif
+
 namespace boost {
  class bad_function_call;

+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
  // Preferred syntax
  template<typename Signature> class function;

@ -21,44 +37,34 @@ namespace boost {
  {
    f1.swap(f2);
  }
+#endif // have partial specialization

  // Portable syntax
-  template<typename R, typename... T> class function_n;
-
-  template<typename R, typename... T> using function0 = function_n<R, T...>;
-  template<typename R, typename... T> using function1 = function_n<R, T...>;
-  template<typename R, typename... T> using function2 = function_n<R, T...>;
-  template<typename R, typename... T> using function3 = function_n<R, T...>;
-  template<typename R, typename... T> using function4 = function_n<R, T...>;
-  template<typename R, typename... T> using function5 = function_n<R, T...>;
-  template<typename R, typename... T> using function6 = function_n<R, T...>;
-  template<typename R, typename... T> using function7 = function_n<R, T...>;
-  template<typename R, typename... T> using function8 = function_n<R, T...>;
-  template<typename R, typename... T> using function9 = function_n<R, T...>;
-
-  template<typename R, typename... T> using function10 = function_n<R, T...>;
-  template<typename R, typename... T> using function11 = function_n<R, T...>;
-  template<typename R, typename... T> using function12 = function_n<R, T...>;
-  template<typename R, typename... T> using function13 = function_n<R, T...>;
-  template<typename R, typename... T> using function14 = function_n<R, T...>;
-  template<typename R, typename... T> using function15 = function_n<R, T...>;
-  template<typename R, typename... T> using function16 = function_n<R, T...>;
-  template<typename R, typename... T> using function17 = function_n<R, T...>;
-  template<typename R, typename... T> using function18 = function_n<R, T...>;
-  template<typename R, typename... T> using function19 = function_n<R, T...>;
-
-  template<typename R, typename... T> using function20 = function_n<R, T...>;
-  template<typename R, typename... T> using function21 = function_n<R, T...>;
-  template<typename R, typename... T> using function22 = function_n<R, T...>;
-  template<typename R, typename... T> using function23 = function_n<R, T...>;
-  template<typename R, typename... T> using function24 = function_n<R, T...>;
-  template<typename R, typename... T> using function25 = function_n<R, T...>;
-  template<typename R, typename... T> using function26 = function_n<R, T...>;
-  template<typename R, typename... T> using function27 = function_n<R, T...>;
-  template<typename R, typename... T> using function28 = function_n<R, T...>;
-  template<typename R, typename... T> using function29 = function_n<R, T...>;
-
-  template<typename R, typename... T> using function30 = function_n<R, T...>;
+  template<typename R> class function0;
+  template<typename R, typename T1> class function1;
+  template<typename R, typename T1, typename T2> class function2;
+  template<typename R, typename T1, typename T2, typename T3> class function3;
+  template<typename R, typename T1, typename T2, typename T3, typename T4> 
+    class function4;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5> 
+    class function5;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6> 
+    class function6;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7> 
+    class function7;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8> 
+    class function8;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9> 
+    class function9;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9,
+           typename T10> 
+    class function10;
 }

 #endif
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
--- a/include/boost/function/function_typeof.hpp
+++ b/include/boost/function/function_typeof.hpp
@ -9,7 +9,37 @@
 #ifndef BOOST_FUNCTION_TYPEOF_HPP
 #define BOOST_FUNCTION_TYPEOF_HPP
 #include <boost/function/function_fwd.hpp>
+#include <boost/typeof/typeof.hpp>

-// This header is no longer necessary and is only retained for compatibility
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()

+BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
+#endif
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3, 
+  (typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4, 
+  (typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5, 
+  (typename)(typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename)(typename)(typename))
 #endif
--- a/include/boost/function/gen_function_N.pl
+++ b/include/boost/function/gen_function_N.pl
@ -0,0 +1,26 @@
+#!/usr/bin/perl -w
+#
+# Boost.Function library
+#
+# Copyright Douglas Gregor 2001-2003. Use, modification and
+# distribution is subject to the Boost Software License, Version
+# 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+# For more information, see http://www.boost.org
+use English;
+
+if ($#ARGV < 0) {
+  print "Usage: perl gen_function_N <number of arguments>\n";
+  exit;
+}
+
+
+$totalNumArgs = $ARGV[0];
+for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) {
+  open OUT, ">function$numArgs.hpp";
+  print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n";
+  print OUT "#include <boost/function/detail/maybe_include.hpp>\n";
+  print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n";
+  close OUT;
+}
--- a/meta/libraries.json
+++ b/meta/libraries.json
@ -1,19 +0,0 @@
-{
-    "key": "function",
-    "name": "Function",
-    "authors": [
-        "Doug Gregor"
-    ],
-    "description": "Function object wrappers for deferred calls or callbacks.",
-    "std": [
-        "tr1"
-    ],
-    "category": [
-        "Function-objects",
-        "Programming"
-    ],
-    "maintainers": [
-        "Peter Dimov <pdimov -at- gmail.com>"
-    ],
-    "cxxstd": "11"
-}
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -1,11 +1,20 @@
-# Copyright 2018, 2019 Peter Dimov
-# 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(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
-
-if(HAVE_BOOST_TEST)
-
-boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::function Boost::core Boost::lambda Boost::move)
-
-endif()
+boost_test_run(lib_function_test function_test.cpp)
+boost_test_run(function_n_test)
+boost_test_run(allocator_test)
+boost_test_run(stateless_test)
+boost_test_run(lambda_test)
+boost_test_compile_fail(function_test_fail1)
+boost_test_compile_fail(function_test_fail2)
+boost_test_compile(function_30)
+boost_test_run(function_arith_cxx98)
+boost_test_run(function_arith_portable)
+boost_test_run(sum_avg_cxx98)
+boost_test_run(sum_avg_portable)
+boost_test_run(mem_fun_cxx98)
+boost_test_run(mem_fun_portable)
+boost_test_run(std_bind_cxx98)
+boost_test_run(std_bind_portable)
+boost_test_run(function_ref_cxx98)
+boost_test_run(function_ref_portable)
+boost_test_run(contains_test)
+boost_test_run(contains2_test)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -7,91 +7,60 @@

 # For more information, see http://www.boost.org/

+project
+    : source-location $(BOOST_ROOT)
+    ;
+
+# bring in rules for testing
 import testing ;

-project
-  : default-build
-    <warnings>extra
-  : requirements
-    <toolset>msvc:<warnings-as-errors>on
-    <toolset>gcc:<warnings-as-errors>on
-    <toolset>clang:<warnings-as-errors>on
-    <library>/boost/function//boost_function
-    <library>/boost/typeof//boost_typeof
-  ;
+{

-run function_test.cpp ;
-# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
-run function_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : function_test_no_rtti ;
-run function_n_test.cpp ;
-run allocator_test.cpp ;
-run stateless_test.cpp ;
-run lambda_test.cpp
-  : : : <library>/boost/lambda//boost_lambda ;
-compile-fail function_test_fail1.cpp ;
-compile-fail function_test_fail2.cpp ;
-compile function_30.cpp ;
-compile function_30_repeat.cpp ;
-run function_arith_cxx98.cpp ;
-run function_arith_portable.cpp ;
-run sum_avg_cxx98.cpp ;
-run sum_avg_portable.cpp ;
-run mem_fun_cxx98.cpp ;
-run mem_fun_portable.cpp ;
-run std_bind_cxx98.cpp ;
-run std_bind_portable.cpp ;
-run function_ref_cxx98.cpp ;
-run function_ref_portable.cpp ;
-run contains_test.cpp ;
-run contains2_test.cpp ;
-run nothrow_swap.cpp ;
-run rvalues_test.cpp
-  : : : <library>/boost/move//boost_move ;
-compile function_typeof_test.cpp
-  : <cxxstd>03:<build>no <cxxstd>98:<build>no <cxxstd>0x:<build>no ;
-run result_arg_types_test.cpp ;
-run result_arg_n_types_test.cpp ;
+  test-suite function
+    : 
+  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]

-lib throw_bad_function_call : throw_bad_function_call.cpp : <link>shared:<define>THROW_BAD_FUNCTION_CALL_DYN_LINK=1 ;
+  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]

-run test_bad_function_call.cpp throw_bad_function_call : : : <link>shared : test_bad_function_call_shared ;
-run test_bad_function_call.cpp throw_bad_function_call : : : <link>static : test_bad_function_call_static ;
+  [ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]

-lib mixed_cxxstd : mixed_cxxstd.cpp : <link>shared:<define>MIXED_CXXSTD_DYN_LINK=1 ;
+  [ run libs/function/test/stateless_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]

-run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>shared : mixed_cxxstd_shared ;
-run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>static : mixed_cxxstd_static ;
+  [ run libs/function/test/lambda_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]

-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>shared : mixed_cxxstd_shared_0x ;
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>static : mixed_cxxstd_static_0x ;
+  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]

-local check14 = [ check-target-builds mixed_cxxstd/<cxxstd>14 : : <build>no ] ;
+  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]

-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>shared $(check14) : mixed_cxxstd_shared_14 ;
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>static $(check14) : mixed_cxxstd_static_14 ;
+  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 

-lib return_function : return_function.cpp : <link>shared:<define>RETURN_FUNCTION_DYN_LINK=1 ;
+  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]

-run test_return_function.cpp return_function : : : <link>shared : return_function_shared ;
-run test_return_function.cpp return_function : : : <link>static : return_function_static ;
+  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]

-run test_return_function.cpp return_function/<cxxstd>0x : : : <link>shared : return_function_shared_0x ;
-run test_return_function.cpp return_function/<cxxstd>0x : : : <link>static : return_function_static_0x ;
+  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]

-run test_return_function.cpp return_function/<cxxstd>14 : : : <link>shared $(check14) : return_function_shared_14 ;
-run test_return_function.cpp return_function/<cxxstd>14 : : : <link>static $(check14) : return_function_static_14 ;
+  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]

-run quick.cpp ;
+  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]

-compile issue_42.cpp ;
+  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]

-run fn_eq_bind_test.cpp ;
+  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]

-# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
-run contains_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains_test_no_rtti ;
-run contains2_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains2_test_no_rtti ;
+  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]

-run contains3_test.cpp ;
-run contains3_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains3_test_no_rtti ;
+  [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]

-compile issue_53.cpp ;
+  [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
+  
+  [ run libs/function/test/contains_test.cpp : : : : ]
+   
+  [ run libs/function/test/contains2_test.cpp : : : : ]
+   
+  [ run libs/function/test/nothrow_swap.cpp :  :  :  :  ]
+
+  [ compile libs/function/test/function_typeof_test.cpp ]
+ ;
+}
+      
--- a/test/allocator_test.cpp
+++ b/test/allocator_test.cpp
@ -7,10 +7,10 @@

 // For more information, see http://www.boost.org

-#include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/test/minimal.hpp>
 #include <cassert>
 #include <functional>
+#include <boost/function.hpp>

 using namespace std;
 using namespace boost;
@ -74,19 +74,20 @@ struct DoNothing: base

 static void do_nothing() {}

-int main()
+int
+test_main(int, char*[])
 {
  function2<int, int, int> f;
  f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
  f.clear();
-  BOOST_TEST_EQ( alloc_count, 1 );
-  BOOST_TEST_EQ( dealloc_count, 1 );
+  BOOST_CHECK(alloc_count == 1);
+  BOOST_CHECK(dealloc_count == 1);
  alloc_count = 0;
  dealloc_count = 0;
  f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
  f.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
+  BOOST_CHECK(dealloc_count == 0);
  f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
  f.clear();
  f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
@ -96,8 +97,8 @@ int main()
  dealloc_count = 0;
  f.assign( &do_minus, counting_allocator<int>() );
  f.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
+  BOOST_CHECK(dealloc_count == 0);
  f.assign( &do_minus, std::allocator<int>() );
  f.clear();

@ -106,14 +107,14 @@ int main()
  dealloc_count = 0;
  fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
  fv.clear();
-  BOOST_TEST_EQ( alloc_count, 1 );
-  BOOST_TEST_EQ( dealloc_count, 1 );
+  BOOST_CHECK(alloc_count == 1);
+  BOOST_CHECK(dealloc_count == 1);
  alloc_count = 0;
  dealloc_count = 0;
  fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
  fv.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
+  BOOST_CHECK(dealloc_count == 0);
  fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
  fv.clear();
  fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
@ -123,14 +124,10 @@ int main()
  dealloc_count = 0;
  fv.assign( &do_nothing, counting_allocator<int>() );
  fv.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
+  BOOST_CHECK(dealloc_count == 0);
  fv.assign( &do_nothing, std::allocator<int>() );
  fv.clear();
-  
-  function0<void> fv2;
-  fv.assign(&do_nothing, std::allocator<int>() );
-  fv2.assign(fv, std::allocator<int>() );

-  return boost::report_errors();
+  return 0;
 }
--- a/test/cmake_install_test/CMakeLists.txt
+++ b/test/cmake_install_test/CMakeLists.txt
@ -1,17 +0,0 @@
-# Copyright 2018, 2019 Peter Dimov
-# 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
-
-cmake_minimum_required(VERSION 3.5...3.16)
-
-project(cmake_install_test LANGUAGES CXX)
-
-find_package(boost_function REQUIRED)
-
-add_executable(main main.cpp)
-target_link_libraries(main Boost::function)
-
-enable_testing()
-add_test(main main)
-
-add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
--- a/test/cmake_install_test/main.cpp
+++ b/test/cmake_install_test/main.cpp
@ -1,22 +0,0 @@
-// Copyright 2017, 2021 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-// See library home page at http://www.boost.org/libs/function
-
-#include <boost/function.hpp>
-#include <cassert>
-
-#define BOOST_TEST(expr) assert(expr)
-#define BOOST_TEST_EQ(x1, x2) assert((x1)==(x2))
-
-int add( int x, int y )
-{
-    return x + y;
-}
-
-int main()
-{
-    boost::function<int(int, int)> fn( &add );
-    BOOST_TEST_EQ( fn( 1, 2 ), 3 );
-}
--- a/test/cmake_subdir_test/CMakeLists.txt
+++ b/test/cmake_subdir_test/CMakeLists.txt
@ -1,40 +0,0 @@
-# Copyright 2018, 2019 Peter Dimov
-# 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
-
-cmake_minimum_required(VERSION 3.5...3.20)
-
-project(cmake_subdir_test LANGUAGES CXX)
-
-add_subdirectory(../.. boostorg/function)
-
-set(deps
-
-# Primary dependencies
-
-assert
-bind
-config
-core
-throw_exception
-
-# Secondary dependencies
-
-static_assert
-)
-
-foreach(dep IN LISTS deps)
-
-  add_subdirectory(../../../${dep} boostorg/${dep})
-
-endforeach()
-
-# --target check
-
-add_executable(quick ../quick.cpp)
-target_link_libraries(quick Boost::function Boost::core)
-
-enable_testing()
-add_test(quick quick)
-
-add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
--- a/test/contains2_test.cpp
+++ b/test/contains2_test.cpp
@ -9,7 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt)

 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>

 static int forty_two()
 {
--- a/test/contains3_test.cpp
+++ b/test/contains3_test.cpp
@ -1,33 +0,0 @@
-// Copyright 2023 Peter Dimov
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-static int f()
-{
-    return 1;
-}
-
-static int g()
-{
-    return 2;
-}
-
-int main()
-{
-    {
-        boost::function<int()> fn;
-        BOOST_TEST( !fn.contains( f ) );
-        BOOST_TEST( !fn.contains( g ) );
-    }
-
-    {
-        boost::function<int()> fn( f );
-        BOOST_TEST( fn.contains( f ) );
-        BOOST_TEST( !fn.contains( g ) );
-    }
-
-    return boost::report_errors();
-}
--- a/test/contains_test.cpp
+++ b/test/contains_test.cpp
@ -5,12 +5,10 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)

+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <boost/ref.hpp>

-#define BOOST_CHECK BOOST_TEST
-
 static int forty_two() { return 42; }

 struct Seventeen
@ -33,7 +31,7 @@ bool operator==(const ReturnInt& x, const ReturnInt& y)
 bool operator!=(const ReturnInt& x, const ReturnInt& y)
 { return x.value != y.value; }

-namespace contains_test {
+namespace contain_test {

 struct ReturnIntFE
 {
@ -44,10 +42,34 @@ struct ReturnIntFE
  int value;
 };

+}
+
+#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+
+namespace contain_test {
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
 { return x.value == y.value; }
-
-} // namespace contains_test
+# else
+bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
+{ return x.value == y.value; }
+# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+}
+#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+namespace boost {
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+bool 
+function_equal(const contain_test::ReturnIntFE& x, 
+               const contain_test::ReturnIntFE& y)
+{ return x.value == y.value; }
+# else
+bool 
+function_equal_impl(const contain_test::ReturnIntFE& x, 
+                    const contain_test::ReturnIntFE& y, int)
+{ return x.value == y.value; }
+# endif
+}
+#endif

 static void target_test()
 {
@ -84,8 +106,10 @@ static void equal_test()
  f = &forty_two;
  BOOST_CHECK(f == &forty_two);
  BOOST_CHECK(f != ReturnInt(17));
+#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two == f);
  BOOST_CHECK(ReturnInt(17) != f);
+#endif

  BOOST_CHECK(f.contains(&forty_two));

@ -93,37 +117,47 @@ static void equal_test()
  BOOST_CHECK(f != &forty_two);
  BOOST_CHECK(f == ReturnInt(17));
  BOOST_CHECK(f != ReturnInt(16));
+#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two != f);
  BOOST_CHECK(ReturnInt(17) == f);
  BOOST_CHECK(ReturnInt(16) != f);
+#endif

  BOOST_CHECK(f.contains(ReturnInt(17)));

-  f = contains_test::ReturnIntFE(17);
+  f = contain_test::ReturnIntFE(17);
  BOOST_CHECK(f != &forty_two);
-  BOOST_CHECK(f == contains_test::ReturnIntFE(17));
-  BOOST_CHECK(f != contains_test::ReturnIntFE(16));
+  BOOST_CHECK(f == contain_test::ReturnIntFE(17));
+  BOOST_CHECK(f != contain_test::ReturnIntFE(16));
+#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two != f);
-  BOOST_CHECK(contains_test::ReturnIntFE(17) == f);
-  BOOST_CHECK(contains_test::ReturnIntFE(16) != f);
+  BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
+  BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
+#endif

-  BOOST_CHECK(f.contains(contains_test::ReturnIntFE(17)));
+  BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));

+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
  boost::function<int(void)> g;

  g = &forty_two;
  BOOST_CHECK(g == &forty_two);
  BOOST_CHECK(g != ReturnInt(17));
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two == g);
  BOOST_CHECK(ReturnInt(17) != g);
+#  endif

  g = ReturnInt(17);
  BOOST_CHECK(g != &forty_two);
  BOOST_CHECK(g == ReturnInt(17));
  BOOST_CHECK(g != ReturnInt(16));
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
  BOOST_CHECK(&forty_two != g);
  BOOST_CHECK(ReturnInt(17) == g);
  BOOST_CHECK(ReturnInt(16) != g);
+#  endif
+#endif
 }

 static void ref_equal_test()
@ -139,8 +173,10 @@ static void ref_equal_test()
    BOOST_CHECK(!(f != boost::ref(ri)));
    BOOST_CHECK(!(f != ri));
    BOOST_CHECK(!(boost::ref(ri) != f));
+#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
    BOOST_CHECK(ri == f);
    BOOST_CHECK(!(ri != f));
+#endif

    // Values equal, references inequal
    ReturnInt ri2(17);
@ -150,10 +186,13 @@ static void ref_equal_test()
    BOOST_CHECK(!(f != ri2));
    BOOST_CHECK(!(f == boost::ref(ri2)));
    BOOST_CHECK(!(boost::ref(ri2) == f));
+#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
    BOOST_CHECK(ri2 == f);
    BOOST_CHECK(!(ri2 != f));
+#endif 
  }

+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
  {
    ReturnInt ri(17);
    boost::function<int(void)> f = boost::ref(ri);
@ -165,8 +204,10 @@ static void ref_equal_test()
    BOOST_CHECK(!(f != boost::ref(ri)));
    BOOST_CHECK(!(f != ri));
    BOOST_CHECK(!(boost::ref(ri) != f));
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
    BOOST_CHECK(ri == f);
    BOOST_CHECK(!(ri != f));
+#  endif

    // Values equal, references inequal
    ReturnInt ri2(17);
@ -176,16 +217,19 @@ static void ref_equal_test()
    BOOST_CHECK(!(f != ri2));
    BOOST_CHECK(!(f == boost::ref(ri2)));
    BOOST_CHECK(!(boost::ref(ri2) == f));
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
    BOOST_CHECK(ri2 == f);
    BOOST_CHECK(!(ri2 != f));
+#  endif
  }
+#endif
 }

-int main()
+int test_main(int, char*[])
 {
  target_test();
  equal_test();
  ref_equal_test();

-  return boost::report_errors();
+  return 0;
 }
--- a/test/fn_eq_bind_test.cpp
+++ b/test/fn_eq_bind_test.cpp
@ -1,87 +0,0 @@
-// Copyright 2023 Peter Dimov
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/function.hpp>
-#include <boost/bind/bind.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost::placeholders;
-
-int f1() { return 1; }
-int f2() { return 2; }
-
-int main()
-{
-    {
-        boost::function<int()> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int, int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int, int, int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int, int, int, int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int, int, int, int, int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int, int, int, int, int, int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int, int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    {
-        boost::function<int(int, int, int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
-
-        BOOST_TEST( fn == boost::bind( f1 ) );
-        BOOST_TEST( fn != boost::bind( f2 ) );
-    }
-
-    return boost::report_errors();
-}
--- a/test/function_30_repeat.cpp
+++ b/test/function_30_repeat.cpp
@ -1,35 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-
-// Make sure we don't try to redefine function2
-#include <boost/function/function2.hpp>
-
-// Define all Boost.Function class templates up to 30 arguments
-#define BOOST_FUNCTION_MAX_ARGS 20
-#include <boost/function.hpp>
-#undef BOOST_FUNCTION_MAX_ARGS
-#define BOOST_FUNCTION_MAX_ARGS 40
-#include <boost/function.hpp>
-#undef BOOST_FUNCTION_MAX_ARGS
-#define BOOST_FUNCTION_MAX_ARGS 25
-#include <boost/function.hpp>
-#undef BOOST_FUNCTION_MAX_ARGS
-#define BOOST_FUNCTION_MAX_ARGS 30
-#include <boost/function.hpp>
-#include <boost/function.hpp>
-
-int main()
-{
-  boost::function0<float> f0;
-
-  boost::function30<float, int, int, int, int, int, int, int, int, int, int,
-                    int, int, int, int, int, int, int, int, int, int,
-                    int, int, int, int, int, int, int, int, int, int> f30;
-  return 0;
-}
--- a/test/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -7,20 +7,12 @@

 // For more information, see http://www.boost.org

-#if defined(__clang__) && defined(__has_warning)
-# if __has_warning( "-Wself-assign-overloaded" )
-#  pragma clang diagnostic ignored "-Wself-assign-overloaded"
-# endif
-#endif
-
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <functional>
 #include <cassert>
 #include <string>

-#define BOOST_CHECK BOOST_TEST
-
 using namespace boost;
 using std::string;
 using std::negate;
@ -639,7 +631,7 @@ test_ref()
    boost::function2<int, int, int> f(ref(atc));
    BOOST_CHECK(f(1, 3) == 4);
  }
-  catch(std::runtime_error const&) {
+  catch(std::runtime_error e) {
    BOOST_ERROR("Nonthrowing constructor threw an exception");
  }
 }
@ -692,7 +684,7 @@ void test_construct_destroy_count()
   BOOST_CHECK(construction_count == destruction_count);
 }

-int main()
+int test_main(int, char* [])
 {
  test_zero_args();
  test_one_arg();
@ -701,5 +693,5 @@ int main()
  test_member_functions();
  test_ref();
  test_construct_destroy_count();
-  return boost::report_errors();
+  return 0;
 }
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@ -7,22 +7,14 @@

 // For more information, see http://www.boost.org

-#if defined(__clang__) && defined(__has_warning)
-# if __has_warning( "-Wself-assign-overloaded" )
-#  pragma clang diagnostic ignored "-Wself-assign-overloaded"
-# endif
-#endif
-
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <functional>
 #include <string>
 #include <utility>

-#define BOOST_CHECK BOOST_TEST
-
-using boost::function;
-using std::string;
+using namespace boost;
+using namespace std;

 int global_int;

@ -533,7 +525,7 @@ test_zero_args()
 static void
 test_one_arg()
 {
-  std::negate<int> neg;
+  negate<int> neg;

  function<int (int)> f1(neg);
  BOOST_CHECK(f1(5) == -5);
@ -615,12 +607,12 @@ struct add_with_throw_on_copy {

  add_with_throw_on_copy(const add_with_throw_on_copy&)
  {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
  }

  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
  {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
  }
 };

@ -629,51 +621,14 @@ test_ref()
 {
  add_with_throw_on_copy atc;
  try {
-    boost::function<int (int, int)> f(boost::ref(atc));
+    boost::function<int (int, int)> f(ref(atc));
    BOOST_CHECK(f(1, 3) == 4);
  }
-  catch(std::runtime_error const&) {
+  catch(runtime_error e) {
    BOOST_ERROR("Nonthrowing constructor threw an exception");
  }
 }

-#if BOOST_WORKAROUND(BOOST_GCC, >= 70000 && BOOST_GCC < 80000) && __cplusplus >= 201700
-
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81311
-#pragma message("Skipping test_empty_ref on g++ 7 -std=c++17")
-
-static void test_empty_ref()
-{
-}
-
-#else
-
-static void dummy() {}
-
-static void test_empty_ref()
-{
-  boost::function<void()> f1;
-  boost::function<void()> f2(boost::ref(f1));
-
-  try {
-    f2();
-    BOOST_ERROR("Exception didn't throw for reference to empty function.");
-  }
-  catch(std::runtime_error const&) {}
-
-  f1 = dummy;
-
-  try {
-    f2();
-  }
-  catch(std::runtime_error const&) {
-    BOOST_ERROR("Error calling referenced function.");
-  }
-}
-
-#endif
-
-
 static void test_exception()
 {
  boost::function<int (int, int)> f;
@ -681,7 +636,7 @@ static void test_exception()
    f(5, 4);
    BOOST_CHECK(false);
  }
-  catch(boost::bad_function_call const&) {
+  catch(boost::bad_function_call) {
    // okay
  }
 }
@ -711,93 +666,7 @@ static void test_call()
  test_call_cref(std::plus<int>());
 }

-struct big_aggregating_structure {
-  int disable_small_objects_optimizations[32];
-    
-  big_aggregating_structure()
-  {
-    ++ global_int;
-  }
-    
-  big_aggregating_structure(const big_aggregating_structure&)
-  {
-    ++ global_int;
-  }
-
-  ~big_aggregating_structure()
-  {
-    -- global_int;
-  }
-    
-  void operator()() 
-  {
-    ++ global_int;
-  }
-
-  void operator()(int) 
-  {
-    ++ global_int;
-  }
-};
-
-template <class FunctionT>
-static void test_move_semantics() 
-{
-  typedef FunctionT f1_type;
-
-  big_aggregating_structure obj;
-  
-  f1_type f1 = obj;
-  global_int = 0;
-  f1();
-  
-  BOOST_CHECK(!f1.empty());
-  BOOST_CHECK(global_int == 1);
-  
-  // Testing rvalue constructors
-  f1_type f2(static_cast<f1_type&&>(f1));
-  BOOST_CHECK(f1.empty());
-  BOOST_CHECK(!f2.empty());
-  BOOST_CHECK(global_int == 1);
-  f2();
-  BOOST_CHECK(global_int == 2);
-  
-  f1_type f3(static_cast<f1_type&&>(f2));
-  BOOST_CHECK(f1.empty());
-  BOOST_CHECK(f2.empty());
-  BOOST_CHECK(!f3.empty());
-  BOOST_CHECK(global_int == 2);
-  f3();
-  BOOST_CHECK(global_int == 3);
-    
-  // Testing move assignment
-  f1_type f4;
-  BOOST_CHECK(f4.empty());
-  f4 = static_cast<f1_type&&>(f3);
-  BOOST_CHECK(f1.empty());
-  BOOST_CHECK(f2.empty());
-  BOOST_CHECK(f3.empty());
-  BOOST_CHECK(!f4.empty());
-  BOOST_CHECK(global_int == 3);
-  f4();
-  BOOST_CHECK(global_int == 4);
-  
-  // Testing self move assignment
-  f4 = static_cast<f1_type&&>(f4);
-  BOOST_CHECK(!f4.empty());
-  BOOST_CHECK(global_int == 4);
-
-  // Testing, that no memory leaked when assigning to nonempty function
-  f4 = obj;
-  BOOST_CHECK(!f4.empty());
-  BOOST_CHECK(global_int == 4);
-  f1_type f5 = obj;
-  BOOST_CHECK(global_int == 5);
-  f4 = static_cast<f1_type&&>(f5);
-  BOOST_CHECK(global_int == 4);
-}
-
-int main()
+int test_main(int, char* [])
 {
  test_zero_args();
  test_one_arg();
@ -805,12 +674,9 @@ int main()
  test_emptiness();
  test_member_functions();
  test_ref();
-  test_empty_ref();
  test_exception();
  test_implicit();
  test_call();
-  test_move_semantics<function<void()> >();
-  test_move_semantics<boost::function0<void> >();

-  return boost::report_errors();
+  return 0;
 }
--- a/test/function_test_fail1.cpp
+++ b/test/function_test_fail1.cpp
@ -7,12 +7,22 @@

 // For more information, see http://www.boost.org

+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>

-void test()
-{
-    boost::function0<int> f1;
-    boost::function0<int> f2;
+using namespace std;
+using namespace boost;

-    if( f1 == f2 ) {}
+int
+test_main(int, char*[])
+{
+  function0<int> f1;
+  function0<int> f2;
+
+  if (f1 == f2) {
+  }
+
+  BOOST_ERROR("This should not have compiled.");
+
+  return 0;
 }
--- a/test/function_test_fail2.cpp
+++ b/test/function_test_fail2.cpp
@ -7,12 +7,21 @@

 // For more information, see http://www.boost.org

+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>

+using namespace std;
+using namespace boost;
+
 static int bad_fn(float f) { return static_cast<int>(f); }

-void test()
+int
+test_main(int, char*[])
 {
-    boost::function0<int> f1;
-    f1 = bad_fn;
+  function0<int> f1;
+  f1 = bad_fn;
+
+  BOOST_ERROR("This should not have compiled.");
+
+  return 0;
 }
--- a/test/issue_42.cpp
+++ b/test/issue_42.cpp
@ -1,21 +0,0 @@
-// Copyright 2022 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-//
-// https://github.com/boostorg/function/issues/42
-
-#include <boost/function.hpp>
-
-struct F
-{
-    int operator()( int x ) const { return -x; }
-};
-
-struct X
-{
-    boost::function<int(int)> f_;
-    explicit X( boost::function<int(int)> f ): f_( f ) {}
-};
-
-F f2;
-X x( f2 ); // -Wuninitialized under GCC 12
--- a/test/issue_53.cpp
+++ b/test/issue_53.cpp
@ -1,20 +0,0 @@
-// Copyright 2024 Peter Dimov
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-//
-// https://github.com/boostorg/function/issues/53
-
-#include <boost/bind/apply.hpp>
-#include <boost/bind/bind.hpp>
-#include <boost/function.hpp>
-
-int TestArg( int, double )
-{
-    return 0;
-}
-
-
-void f()
-{
-    boost::function<int(int)> fn = boost::bind( &TestArg, boost::placeholders::_1, 1.0 );
-}
--- a/test/lambda_test.cpp
+++ b/test/lambda_test.cpp
@ -7,34 +7,32 @@

 // For more information, see http://www.boost.org

-#include <boost/function.hpp>
-#include <boost/lambda/lambda.hpp>
-#include <boost/lambda/bind.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <cstdlib>

+#include <boost/test/minimal.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/lambda/bind.hpp>
+#include <boost/function.hpp>
+
+using namespace std;
+using namespace boost;
+using namespace boost::lambda;

 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
 {
-  using namespace std;
  return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }

-int main()
+int test_main(int, char*[])
 {
-  using boost::function;
-  using namespace boost::lambda;
-
  function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
-  BOOST_TEST_EQ( f1(true, 2.0), 30u );
+  function <unsigned(double)>       f2 = bind(f1, false, _1);
+  function <unsigned()>             f3 = bind(f2, 4.0);

-  function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
-  BOOST_TEST_EQ( f2(2.0), 60u );
+  f3();

-  function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
-  BOOST_TEST_EQ( f3(), 120u );
-
-  return boost::report_errors();
+  return 0;
 }
+
--- a/test/mem_fun_cxx98.cpp
+++ b/test/mem_fun_cxx98.cpp
@ -10,36 +10,22 @@

    
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

-struct Y {
-    Y(int y = 0) : y_(y) {}
-    bool operator==(const Y& rhs) const { return y_ == rhs.y_; }
-private:
-    int y_;
-    };
-
 struct X {
  int foo(int);
-  Y& foo2(Y&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }

 int main()
 {
    boost::function<int (X*, int)> f;
-    boost::function<Y& (X*, Y&)> f2;
-	Y y1;
-	
-    f = &X::foo;
-    f2 = &X::foo2;

-    X x;
-    BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+f = &X::foo;
+  
+X x;
+f(&x, 5);

-    return ::boost::report_errors();
+    return 0;
 }
--- a/test/mem_fun_portable.cpp
+++ b/test/mem_fun_portable.cpp
@ -10,36 +10,22 @@

    
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

-struct Y {
-    Y(int y = 0) : y_(y) {}
-    bool operator==(const Y& rhs) const { return y_ == rhs.y_; }
-private:
-    int y_;
-    };
-
 struct X {
  int foo(int);
-  Y& foo2(Y&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }

 int main()
 {
    boost::function2<int, X*, int> f;
-    boost::function2<Y&, X*, Y&> f2;
-    Y y1;
-    
-    f = &X::foo;
-    f2 = &X::foo2;

-    X x;
-    BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+f = &X::foo;
+  
+X x;
+f(&x, 5);

-    return ::boost::report_errors();
+    return 0;
 }
--- a/test/mixed_cxxstd.cpp
+++ b/test/mixed_cxxstd.cpp
@ -1,42 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/config.hpp>
-
-#if defined(MIXED_CXXSTD_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-EXPORT void call_fn_1( boost::function<void()> const & fn )
-{
-    fn();
-}
-
-EXPORT void call_fn_2( boost::function<void(int)> const & fn )
-{
-    fn( 1 );
-}
-
-EXPORT void call_fn_3( boost::function<void(int, int)> const & fn )
-{
-    fn( 1, 2 );
-}
-
-EXPORT void call_fn_4( boost::function0<void> const & fn )
-{
-    fn();
-}
-
-EXPORT void call_fn_5( boost::function1<void, int> const & fn )
-{
-    fn( 1 );
-}
-
-EXPORT void call_fn_6( boost::function2<void, int, int> const & fn )
-{
-    fn( 1, 2 );
-}
--- a/test/nothrow_swap.cpp
+++ b/test/nothrow_swap.cpp
@ -7,10 +7,8 @@

 // For more information, see http://www.boost.org

+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#define BOOST_CHECK BOOST_TEST

 struct tried_to_copy { };

@ -42,7 +40,7 @@ struct MaybeThrowOnCopy {

 bool MaybeThrowOnCopy::throwOnCopy = false;

-int main()
+int test_main(int, char* [])
 {
  boost::function0<int> f;
  boost::function0<int> g;
@ -58,5 +56,5 @@ int main()
  BOOST_CHECK(f() == 2);
  BOOST_CHECK(g() == 1);
  
-  return boost::report_errors();
+  return 0;
 }
--- a/test/quick.cpp
+++ b/test/quick.cpp
@ -1,21 +0,0 @@
-// Copyright 2019 Peter Dimov
-
-// Use, modification and distribution is subject to 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 <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-static int f( int x )
-{
-    return x + 1;
-}
-
-int main()
-{
-    boost::function<int(int)> fn( f );
-
-    BOOST_TEST_EQ( fn( 5 ), 6 );
-
-    return boost::report_errors();
-}
--- a/test/result_arg_n_types_test.cpp
+++ b/test/result_arg_n_types_test.cpp
@ -1,146 +0,0 @@
-// Copyright 2024 Peter Dimov
-// Use, modification and distribution is subject to
-// the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/function.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-struct R {};
-
-struct A1 {};
-struct A2 {};
-struct A3 {};
-struct A4 {};
-struct A5 {};
-struct A6 {};
-struct A7 {};
-struct A8 {};
-struct A9 {};
-struct A10 {};
-
-int main()
-{
-    {
-        typedef boost::function<R()> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-    }
-
-    {
-        typedef boost::function<R(A1)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-    }
-
-    {
-        typedef boost::function<R(A1, A2)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-    }
-
-    {
-        typedef boost::function<R(A1, A2, A3)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
-    }
-
-    {
-        typedef boost::function<R(A1, A2, A3, A4)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
-        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
-    }
-
-    {
-        typedef boost::function<R(A1, A2, A3, A4, A5)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
-        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
-        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
-    }
-
-    {
-        typedef boost::function<R(A1, A2, A3, A4, A5, A6)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
-        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
-        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
-        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
-    }
-
-    {
-        typedef boost::function<R(A1, A2, A3, A4, A5, A6, A7)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
-        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
-        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
-        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
-        BOOST_TEST_TRAIT_SAME(F::arg7_type, A7);
-    }
-
-    {
-        typedef boost::function<R(A1, A2, A3, A4, A5, A6, A7, A8)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
-        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
-        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
-        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
-        BOOST_TEST_TRAIT_SAME(F::arg7_type, A7);
-        BOOST_TEST_TRAIT_SAME(F::arg8_type, A8);
-    }
-
-    {
-        typedef boost::function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
-        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
-        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
-        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
-        BOOST_TEST_TRAIT_SAME(F::arg7_type, A7);
-        BOOST_TEST_TRAIT_SAME(F::arg8_type, A8);
-        BOOST_TEST_TRAIT_SAME(F::arg9_type, A9);
-    }
-
-    {
-        typedef boost::function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> F;
-
-        BOOST_TEST_TRAIT_SAME(F::result_type, R);
-        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
-        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
-        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
-        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
-        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
-        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
-        BOOST_TEST_TRAIT_SAME(F::arg7_type, A7);
-        BOOST_TEST_TRAIT_SAME(F::arg8_type, A8);
-        BOOST_TEST_TRAIT_SAME(F::arg9_type, A9);
-        BOOST_TEST_TRAIT_SAME(F::arg10_type, A10);
-    }
-
-    return boost::report_errors();
-}
--- a/test/result_arg_types_test.cpp
+++ b/test/result_arg_types_test.cpp
@ -1,39 +0,0 @@
-// Boost.Function library
-
-//  Copyright 2016 Peter Dimov
-
-//  Use, modification and distribution is subject to
-//  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 <boost/function.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-struct X
-{
-};
-
-struct Y
-{
-};
-
-struct Z
-{
-};
-
-int main()
-{
-    typedef boost::function<X(Y)> F1;
-
-    BOOST_TEST_TRAIT_SAME(F1::result_type, X);
-    BOOST_TEST_TRAIT_SAME(F1::argument_type, Y);
-
-    typedef boost::function<X(Y, Z)> F2;
-
-    BOOST_TEST_TRAIT_SAME(F2::result_type, X);
-    BOOST_TEST_TRAIT_SAME(F2::first_argument_type, Y);
-    BOOST_TEST_TRAIT_SAME(F2::second_argument_type, Z);
-
-    return boost::report_errors();
-}
--- a/test/return_function.cpp
+++ b/test/return_function.cpp
@ -1,27 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/config.hpp>
-
-#if defined(RETURN_FUNCTION_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-int f( int x, int y )
-{
-    return x + y;
-}
-
-EXPORT boost::function<int(int, int)> get_fn_1()
-{
-    return f;
-}
-
-EXPORT boost::function2<int, int, int> get_fn_2()
-{
-    return f;
-}
--- a/test/rvalues_test.cpp
+++ b/test/rvalues_test.cpp
@ -1,103 +0,0 @@
-// Copyright 2014 Antony Polukhin.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-
-#include <boost/function.hpp>
-#include <boost/move/move.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <iostream>
-#include <cstdlib>
-
-#define BOOST_CHECK BOOST_TEST
-
-class only_movable {
-private:
-    BOOST_MOVABLE_BUT_NOT_COPYABLE(only_movable)
-    int value_;
-    bool moved_;
-
-public:
-    only_movable(BOOST_RV_REF(only_movable) x)
-        : value_(x.value_)
-        , moved_(false)
-    {
-        x.moved_ = true;
-    }
-
-   only_movable& operator=(BOOST_RV_REF(only_movable) x) {
-        value_ = x.value_;
-        x.moved_ = true;
-        moved_ = false;
-        return *this;
-   }
-
-    explicit only_movable(int value = 0) : value_(value), moved_(false) {}
-    int get_value() const {  return value_;  }
-    bool is_moved() const { return moved_; }
-};
-
-
-int one(BOOST_RV_REF(only_movable) v) { return v.get_value(); }
-only_movable two(BOOST_RV_REF(only_movable) t) {
-    only_movable t1 = boost::move(t);
-    return BOOST_MOVE_RET(only_movable, t1);
-}
-
-only_movable two_sum(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) {
-    only_movable ret(t1.get_value() + t2.get_value());
-    return BOOST_MOVE_RET(only_movable, ret);
-}
-
-struct sum_struct {
-    only_movable operator()(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) const {
-        only_movable ret(t1.get_value() + t2.get_value());
-        return BOOST_MOVE_RET(only_movable, ret);
-    }
-};
-
-int three(std::string&&) { return 1; }
-std::string&& four(std::string&& s) { return boost::move(s); }
-
-int main()
-{
-    using boost::function;
-
-    function <int(BOOST_RV_REF(only_movable))>  f1 = one;
-
-    only_movable om1(1);
-    BOOST_CHECK(f1(boost::move(om1)) == 1);
-
-    function <only_movable(BOOST_RV_REF(only_movable))>  f2 = two;
-
-    only_movable om2(2);
-    only_movable om2_2 = f2(boost::move(om2));
-    BOOST_CHECK(om2_2.get_value() == 2);
-    BOOST_CHECK(om2.is_moved());
-
-    {
-        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = two_sum;
-        only_movable om1_sum(1), om2_sum(2);
-        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
-        BOOST_CHECK(om2_sum_2.get_value() == 3);
-    }
-
-    {
-        sum_struct s;
-        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = s;
-        only_movable om1_sum(1), om2_sum(2);
-        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
-        BOOST_CHECK(om2_sum_2.get_value() == 3);
-    }
-
-    function <int(std::string&&)>               f3 = three;
-    function <std::string&& (std::string&& s)>  f4 = four;
-
-    f3(std::string("Hello"));
-    BOOST_CHECK(f4(std::string("world")) == "world");
-
-    return boost::report_errors();
-}
--- a/test/stateless_test.cpp
+++ b/test/stateless_test.cpp
@ -7,18 +7,16 @@

 // For more information, see http://www.boost.org

+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <stdexcept>
-#include <new>

 struct stateless_integer_add {
  int operator()(int x, int y) const { return x+y; }

-  void* operator new(std::size_t n)
+  void* operator new(std::size_t)
  {
-    BOOST_ERROR( "stateless_integer_add incorrectly allocated" );
-    return ::operator new( n );
+    throw std::runtime_error("Cannot allocate a stateless_integer_add");
  }

  void* operator new(std::size_t, void* p)
@ -26,17 +24,15 @@ struct stateless_integer_add {
    return p;
  }

-  void operator delete(void* p) throw()
+  void operator delete(void*) throw()
  {
-    BOOST_ERROR( "stateless_integer_add incorrectly deallocated" );
-    return ::operator delete( p );
  }
 };

-int main()
+int test_main(int, char*[])
 {
  boost::function2<int, int, int> f;
  f = stateless_integer_add();

-  return boost::report_errors();
+  return 0;
 }
--- a/test/std_bind_cxx98.cpp
+++ b/test/std_bind_cxx98.cpp
@ -8,16 +8,7 @@

 // For more information, see http://www.boost.org/

-#if defined(__clang__) && defined(__has_warning)
-# if __has_warning( "-Wdeprecated-declarations" )
-#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
-# endif
-#endif
-
-#if defined(__GNUC__) && __GNUC__ >= 12
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
+    
 #include <boost/function.hpp>
 #include <iostream>
 #include <functional>
@ -29,12 +20,11 @@ int X::foo(int x) { return -x; }

 int main()
 {
-#ifndef BOOST_NO_CXX98_BINDERS
      boost::function<int (int)> f;
  X x;
  f = std::bind1st(
        std::mem_fun(&X::foo), &x);
  f(5); // Call x.foo(5)
-#endif
+
    return 0;
 }
--- a/test/std_bind_portable.cpp
+++ b/test/std_bind_portable.cpp
@ -8,16 +8,7 @@

 // For more information, see http://www.boost.org/

-#if defined(__clang__) && defined(__has_warning)
-# if __has_warning( "-Wdeprecated-declarations" )
-#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
-# endif
-#endif
-
-#if defined(__GNUC__) && __GNUC__ >= 12
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
+    
 #include <boost/function.hpp>
 #include <iostream>
 #include <functional>
@ -29,12 +20,11 @@ int X::foo(int x) { return -x; }

 int main()
 {
-#ifndef BOOST_NO_CXX98_BINDERS
      boost::function1<int, int> f;
  X x;
  f = std::bind1st(
        std::mem_fun(&X::foo), &x);
  f(5); // Call x.foo(5)
-#endif
+
    return 0;
 }
--- a/test/test_bad_function_call.cpp
+++ b/test/test_bad_function_call.cpp
@ -1,14 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-void throw_bad_function_call();
-
-int main()
-{
-    BOOST_TEST_THROWS( throw_bad_function_call(), boost::bad_function_call );
-    return boost::report_errors();
-}
--- a/test/test_mixed_cxxstd.cpp
+++ b/test/test_mixed_cxxstd.cpp
@ -1,48 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-//
-
-void call_fn_1( boost::function<void()> const & fn );
-void call_fn_2( boost::function<void(int)> const & fn );
-void call_fn_3( boost::function<void(int, int)> const & fn );
-
-void call_fn_4( boost::function0<void> const & fn );
-void call_fn_5( boost::function1<void, int> const & fn );
-void call_fn_6( boost::function2<void, int, int> const & fn );
-
-//
-
-static int v;
-
-void f0()
-{
-    v = -1;
-}
-
-void f1( int x )
-{
-    v = x;
-}
-
-void f2( int x, int y )
-{
-    v = x + y;
-}
-
-int main()
-{
-    v = 0; call_fn_1( f0 ); BOOST_TEST_EQ( v, -1 );
-    v = 0; call_fn_2( f1 ); BOOST_TEST_EQ( v, 1 );
-    v = 0; call_fn_3( f2 ); BOOST_TEST_EQ( v, 3 );
-
-    v = 0; call_fn_4( f0 ); BOOST_TEST_EQ( v, -1 );
-    v = 0; call_fn_5( f1 ); BOOST_TEST_EQ( v, 1 );
-    v = 0; call_fn_6( f2 ); BOOST_TEST_EQ( v, 3 );
-
-    return boost::report_errors();
-}
--- a/test/test_return_function.cpp
+++ b/test/test_return_function.cpp
@ -1,21 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-//
-
-boost::function<int(int, int)> get_fn_1();
-boost::function2<int, int, int> get_fn_2();
-
-//
-
-int main()
-{
-    BOOST_TEST_EQ( get_fn_1()( 1, 2 ), 3 );
-    BOOST_TEST_EQ( get_fn_2()( 1, 2 ), 3 );
-
-    return boost::report_errors();
-}
--- a/test/throw_bad_function_call.cpp
+++ b/test/throw_bad_function_call.cpp
@ -1,17 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/config.hpp>
-
-#if defined(THROW_BAD_FUNCTION_CALL_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-EXPORT void throw_bad_function_call()
-{
-    throw boost::bad_function_call();
-}