Change assertions in operator* to match documentation; improves codegen slightly in the result<U&> case

Update system_category_message_win32.hpp

.drone.jsonnet

@@ -0,0 +1,371 @@
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+local library = "system";
+
+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.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.8', CXXSTD: '11' },
+        "g++-4.8",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 4.9",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '11' },
+        "g++-4.9",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 5*",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 6",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '11,14' },
+        "g++-6",
+    ),
+
+    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",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '11,14,17' },
+        "g++-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 32",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' },
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* S390x",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' },
+        arch="s390x",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '32' },
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '64' },
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 32",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 32",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' },
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' },
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 13 32 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + ubsan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 13 64 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' } + ubsan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 13 32 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "g++-14-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b' } + 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 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' },
+        "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",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' },
+        "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,1z' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,1z' } + 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' },
+    ),
+]

.drone/drone.bat

@@ -0,0 +1,23 @@
+@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 %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

.drone/drone.sh

@@ -0,0 +1,25 @@
+#!/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 $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}

.github/workflows/ci.yml

@@ -0,0 +1,637 @@
+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.8
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-4.8
+          - toolset: gcc-5
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-5
+          - toolset: gcc-6
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-6
+          - toolset: gcc-7
+            cxxstd: "11,14,17"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+          - toolset: gcc-8
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-8
+          - toolset: gcc-9
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: gcc-10
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-10
+          - toolset: gcc-11
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-22.04
+          - toolset: gcc-12
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-12
+          - toolset: gcc-13
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:24.04
+            install: g++-13
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:24.04
+            install: g++-14
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            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,2b"
+            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 --git_args "--jobs 3" $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
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.0
+            cxxstd: "14"
+            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,20,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

.travis.yml

@@ -4,9 +4,7 @@
 
 language: cpp
 
-sudo: false
-
-dist: trusty
+dist: xenial
 
 branches:
   only:
@@ -26,7 +24,26 @@ matrix:
   include:
     - os: linux
       compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11,14 ADDRMD=32,64
+      addons:
+        apt:
+          packages:
+            - g++-multilib
+
+    - os: linux
+      arch: arm64
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11,14 ADDRMD=32,64
+
+    - os: linux
+      arch: ppc64le
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11,14
+
+    - os: linux
+      arch: s390x
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11,14 ADDRMD=32,64
 
     - os: linux
       compiler: g++-4.4
@@ -49,99 +66,23 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      dist: trusty
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      dist: bionic
+      compiler: g++-11
+      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-11 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
       addons:
         apt:
           packages:
-            - g++-4.7
+            - g++-11
           sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-9
-      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
 
     - os: linux
+      dist: trusty
       compiler: /usr/bin/clang++
       env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
       addons:
@@ -150,6 +91,7 @@ matrix:
             - clang-3.3
 
     - os: linux
+      dist: trusty
       compiler: /usr/bin/clang++
       env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
       addons:
@@ -158,229 +100,103 @@ matrix:
             - clang-3.4
 
     - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
+      compiler: clang++-12
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-12 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1
       addons:
         apt:
           packages:
-            - clang-3.5
-            - libstdc++-4.9-dev
+            - clang-12
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.5
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-
-    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.9
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.9
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-7
-      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-7
-
-    - os: linux
-      compiler: clang++-8
-      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-8
-
-    - os: linux
-      compiler: clang++-6.0
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
+            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-12 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
 
     - os: linux
+      dist: bionic
       compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
       addons:
         apt:
           packages:
             - libc++-dev
 
-    - os: linux
-      compiler: clang++-libc++
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - libc++-dev
+    - os: freebsd
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,17,2a
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z ADDRMD=32,64
+      osx_image: xcode7.3
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z ADDRMD=32,64
+      osx_image: xcode8.3
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z ADDRMD=32,64
+      osx_image: xcode9.4
 
     - os: osx
       compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+      osx_image: xcode10.1
+
+    - os: osx
+      osx_image: xcode11.3
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+    - os: osx
+      osx_image: xcode12.2
+      compiler: clang++
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
 
     - os: linux
-      compiler: g++
-      env: CMAKE_SUBDIR_TEST=1
+      env: CMAKE=1
       script:
-      - cd libs/system/test/cmake_subdir_test && mkdir __build__ && cd __build__
+        - mkdir __build__ && cd __build__
+        - cmake -DBOOST_INCLUDE_LIBRARIES=system -DBUILD_TESTING=ON ..
+        - cmake --build . --target tests
+        - ctest --output-on-failure --no-tests=error
+
+    - os: linux
+      env: CMAKE=1 BUILD_SHARED_LIBS=ON
+      script:
+        - mkdir __build__ && cd __build__
+        - cmake -DBUILD_SHARED_LIBS=ON -DBOOST_INCLUDE_LIBRARIES=system -DBUILD_TESTING=ON ..
+        - cmake --build . --target tests
+        - ctest --output-on-failure --no-tests=error
+
+    - os: linux
+      env: CMAKE_SUBDIR_TEST=1
+      install:
+        - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+        - git clone -b $BOOST_BRANCH https://github.com/boostorg/assert.git ../assert
+        - git clone -b $BOOST_BRANCH https://github.com/boostorg/config.git ../config
+        - git clone -b $BOOST_BRANCH https://github.com/boostorg/core.git ../core
+        - git clone -b $BOOST_BRANCH https://github.com/boostorg/predef.git ../predef
+        - git clone -b $BOOST_BRANCH https://github.com/boostorg/winapi.git ../winapi
+      script:
+      - cd test/cmake_subdir_test && mkdir __build__ && cd __build__
       - cmake ..
       - cmake --build .
       - cmake --build . --target check
 
+    - os: linux
+      env: CMAKE_INSTALL=1
+      script:
+        - pip install --user cmake
+        - mkdir __build__ && cd __build__
+        - cmake -DBOOST_INCLUDE_LIBRARIES=system -DCMAKE_INSTALL_PREFIX=~/.local ..
+        - cmake --build . --target install
+        - cd ../libs/system/test/cmake_install_test && mkdir __build__ && cd __build__
+        - cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+        - cmake --build .
+        - cmake --build . --target check
+
 install:
   - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
   - cd ..
@@ -395,7 +211,7 @@ install:
 script:
   - |-
     echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 -j3 libs/system/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
+  - ./b2 -j3 libs/system/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
 
 notifications:
   email:

CMakeLists.txt

@@ -1,12 +1,10 @@
-# Copyright 2018 Mike Dev
+# Copyright 2018-2021 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
+# https://www.boost.org/LICENSE_1_0.txt
 
-# Partial (add_subdirectory only) and experimental CMake support
-# Subject to change; please do not rely on the contents of this file yet
+cmake_minimum_required(VERSION 3.8...3.20)
 
-cmake_minimum_required(VERSION 3.5)
-project(BoostSystem LANGUAGES CXX)
+project(boost_system VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
 add_library(boost_system INTERFACE)
 add_library(Boost::system ALIAS boost_system)
@@ -14,7 +12,27 @@ add_library(Boost::system ALIAS boost_system)
 target_include_directories(boost_system INTERFACE include)
 
 target_link_libraries(boost_system
-    INTERFACE
-        Boost::config
-        Boost::winapi
+  INTERFACE
+    Boost::assert
+    Boost::config
+    Boost::throw_exception
+    Boost::variant2
+    Boost::winapi
 )
+
+target_compile_features(boost_system INTERFACE cxx_std_11)
+
+if(CMAKE_VERSION VERSION_GREATER 3.18 AND CMAKE_GENERATOR MATCHES "Visual Studio")
+
+  file(GLOB_RECURSE boost_system_IDEFILES CONFIGURE_DEPENDS include/*.hpp)
+  source_group(TREE ${PROJECT_SOURCE_DIR}/include FILES ${boost_system_IDEFILES} PREFIX "Header Files")
+  list(APPEND boost_system_IDEFILES extra/boost_system.natvis)
+  target_sources(boost_system PRIVATE ${boost_system_IDEFILES})
+
+endif()
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()

README.md

@@ -0,0 +1,25 @@
+# Boost.System
+
+The Boost.System library, part of [Boost C++ Libraries](https://boost.org),
+implements an extensible framework for error reporting in the form of an
+`error_code` class and supporting facilities.
+
+It has been proposed for the C++11 standard, has been accepted, and
+is now available as part of the standard library in the `<system_error>`
+header. However, the Boost implementation has continued to evolve and
+gain enhancements and additional functionality, such as support for
+attaching [source locations](https://www.boost.org/doc/libs/release/libs/assert/doc/html/assert.html#source_location_support)
+to `error_code`, and a `result<T>` class that can carry either a value
+or an error code.
+
+See [the documentation of System](http://boost.org/libs/system) for more
+information.
+
+Since `<system_error>` is a relatively undocumented portion of the C++
+standard library, the documentation of Boost.System may be useful to you
+even if you use the standard components.
+
+## License
+
+Distributed under the
+[Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).

appveyor.yml

@@ -14,31 +14,27 @@ branches:
 
 environment:
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
-    - 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,clang-win
-      CXXSTD: 14,17
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.1
+      CXXSTD: 14,17,latest
+      ADDRMD: 32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: 14,17,latest
+      ADDRMD: 64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       ADDPATH: C:\cygwin64\bin;
       TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw\bin;
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      ADDPATH: C:\mingw-w64\i686-8.1.0-posix-dwarf-rt_v6-rev0\mingw32\bin;
       TOOLSET: gcc
-      CXXSTD: 03,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;
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      ADDPATH: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;
       TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE_SUBDIR: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE_INSTALL: 1
 
 install:
   - set BOOST_BRANCH=develop
@@ -58,4 +54,27 @@ test_script:
   - PATH=%ADDPATH%%PATH%
   - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
   - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j3 libs/system/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release
+  - if "%CMAKE%%CMAKE_SUBDIR%%CMAKE_INSTALL%" == ""  b2 -j3 libs/system/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
+
+  - if not "%CMAKE%" == ""  mkdir __build__ && cd __build__
+  - if not "%CMAKE%" == ""  cmake -DBUILD_TESTING=ON -DBOOST_INCLUDE_LIBRARIES=system -DBoost_VERBOSE=ON ..
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Debug & ctest --output-on-failure --no-tests=error -j 3 -C Debug
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Release & ctest --output-on-failure --no-tests=error -j 3 -C Release
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config MinSizeRel & ctest --output-on-failure --no-tests=error -j 3 -C MinSizeRel
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config RelWithDebInfo & ctest --output-on-failure --no-tests=error -j 3 -C RelWithDebInfo
+
+  - if not "%CMAKE_SUBDIR%" == ""  cd libs/system/test/cmake_subdir_test && mkdir __build__ && cd __build__
+  - if not "%CMAKE_SUBDIR%" == ""  cmake ..
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config MinSizeRel && cmake --build . --target check --config MinSizeRel
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config RelWithDebInfo && cmake --build . --target check --config RelWithDebInfo
+
+  - if not "%CMAKE_INSTALL%" == ""  mkdir __build__ && cd __build__
+  - if not "%CMAKE_INSTALL%" == ""  cmake -DBOOST_INCLUDE_LIBRARIES=system -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Debug
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Release
+  - if not "%CMAKE_INSTALL%" == ""  cd ../libs/system/test/cmake_install_test && mkdir __build__ && cd __build__
+  - if not "%CMAKE_INSTALL%" == ""  cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release

build.jam

@@ -0,0 +1,25 @@
+# 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/config//boost_config
+    /boost/throw_exception//boost_throw_exception
+    /boost/variant2//boost_variant2
+    /boost/winapi//boost_winapi
+    ;
+
+project /boost/system ;
+
+explicit
+    [ alias boost_system : build//boost_system ]
+    [ alias all : boost_system test ]
+    ;
+
+call-if : boost-library system
+    : install boost_system
+    ;

build/Jamfile.v2

@@ -1,25 +1,20 @@
 # Boost System Library Build Jamfile
-
-# (C) Copyright Beman Dawes 2002, 2006
-
+# Copyright 2002, 2006 Beman Dawes
+# Copyright 2024 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or www.boost.org/LICENSE_1_0.txt)
+# https://www.boost.org/LICENSE_1_0.txt
 
-# See library home page at http://www.boost.org/libs/system
+# See library home page at https://www.boost.org/libs/system
 
-project boost/system
-    : source-location ../src
-    : usage-requirements  # pass these requirement to dependents (i.e. users)
+project
+    : common-requirements
+      <include>../include
+      <library>$(boost_dependencies)
       <link>shared:<define>BOOST_SYSTEM_DYN_LINK=1
       <link>static:<define>BOOST_SYSTEM_STATIC_LINK=1
+      <define>BOOST_SYSTEM_NO_LIB=1
     ;
 
 SOURCES = error_code ;
 
-lib boost_system
-   : $(SOURCES).cpp
-   : <link>shared:<define>BOOST_SYSTEM_DYN_LINK=1
-     <link>static:<define>BOOST_SYSTEM_STATIC_LINK=1
-   ;
-
-boost-install boost_system ;
+lib boost_system : ../src/$(SOURCES).cpp ;

doc/system-docinfo-footer.html

@@ -1,5 +1,6 @@
 <style>
 
 *:not(pre)>code { background: none; color: #600000; }
+:not(pre):not([class^=L])>code { background: none; color: #600000; }
 
 </style>

doc/system.adoc

@@ -4,19 +4,22 @@ Copyright 2018 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
+https://www.boost.org/LICENSE_1_0.txt
 ////
 
 # Boost.System: Extensible Error Reporting
 Beman Dawes, Christopher Kohlhoff, Peter Dimov
 :toc: left
-:toclevels: 3
+:toclevels: 4
 :idprefix:
 :docinfo: private-footer
+:source-highlighter: rouge
+:source-language: c++
 
 :leveloffset: +1
 
 include::system/introduction.adoc[]
+include::system/usage.adoc[]
 include::system/changes.adoc[]
 include::system/rationale.adoc[]
 include::system/reference.adoc[]

doc/system/changes.adoc

@@ -1,16 +1,115 @@
 ////
-Copyright 2018 Peter Dimov
-
+Copyright 2018-2022 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
+https://www.boost.org/LICENSE_1_0.txt
 ////
 
 [#changes]
-# Release History
+# Revision History
 :idprefix:
 
+## Changes in Boost 1.86
+
+* Support `result<T> & fv`, where `fv` returns `void`.
+* Support `result<void> &= fv;`, where `fv` returns `void`.
+
+## Changes in Boost 1.85
+
+* {cpp}03 is no longer supported; a {cpp}11 compiler is required. (This includes GCC 4.8 or later, and MSVC 14.0 (VS 2015) or later.)
+* The deprecated header `boost/system/cygwin_error.hpp` has been removed.
+* The original and obsolete (32 bit) MinGW is no longer supported. MinGW-w64 (both 64 and 32 bit) is still supported.
+* `operator&` now works for `result<void>` (by way of taking a nullary function.)
+* Added `operator|=` for `result`.
+
+## Changes in Boost 1.84
+
+* Added support for `result<U&, E>`.
+* Added `operator|` for `result`.
+* Added `operator&` for `result`.
+* Added `operator&=` for `result`.
+
+## Changes in Boost 1.81
+
+* The macro `BOOST_SYSTEM_DISABLE_THREADS` can now be defined to disable
+  the use of `<mutex>` (e.g. on single-threaded libstdc++).
+* Added `value_type`, `error_type`, `in_place_value`, `in_place_error`
+  to `result<>`.
+* Added `emplace` to `result<>`.
+
+## Changes in Boost 1.80
+
+* When an `error_code` is converted to `std::error_code` and then back
+  to `error_code`, the original is now restored, if possible.
+* Reworked the conversion from `error_category` to `std::error_category`
+  to avoid the one-time allocation that shows up on leak checkers.
+* Added a constructor that allows replacing the source location of an
+  `error_code`, and a corresponding `assign`.
+* Added a converting constructor to `result`.
+
+## Changes in Boost 1.79
+
+* Added a `boost::source_location` parameter to `throw_exception_from_error`.
+* Added `throw_exception_from_error` overloads for `errc::errc_t`,
+  `std::error_code`, `std::errc`, `std::exception_ptr`.
+* `result<T>::value` now automatically supplies `BOOST_CURRENT_LOCATION` to
+  `throw_exception_from_error` via a default argument.
+* Added an `errc::make_error_code` overload taking a source location.
+
+## Changes in Boost 1.78
+
+* Added support for source locations to `error_code`.
+* Added `error_code::to_string`, `error_condition::to_string`, `error_code::what`.
+* `system_error::what()` now contains the source location, if present.
+* Added `result<T, E = error_code>`, a class holding either a value or an
+  error, defined in `<boost/system/result.hpp>`.
+
+## Changes in Boost 1.77
+
+* The conversion operator from `error_category` to `std::error_category`
+  has been improved and no longer requires `<map>` or `<mutex>`.
+* The comparison operators of `error_category` are now inline friends
+  instead of member functions (a side effect of the previous change.)
+* `error_condition` now defers calling `generic_category()` to avoid
+  instantiating the object until it's actually needed.
+* `error_condition::failed` and `error_condition::message` have been
+  undeprecated, and `operator bool()` now once again returns `failed()`.
+* The system category now doesn't call `generic_category()`, to avoid
+  instantiating the object.
+* The return value of `default_error_condition` changes in some cases into
+  an `error_condition` from the generic category, instead of from the system
+  category. This happens on POSIX when the input `error_code` is from
+  the system category and does not correspond to any `errc_t` value.
+* The interoperability of `error_code` and `std::error_code` has been
+  improved substantially. It is now possible to construct
+  `boost::system::error_code` from `std::error_code`, and it's possible
+  to pass `boost::system::error_code` to functions taking `std::error_code&`.
+* A stream insertion operator for `error_condition` has been added.
+
+## Changes in Boost 1.76
+
+* `windows_error.hpp` is no longer deprecated.
+
+## Changes in Boost 1.75
+
+* The platform-specific headers `windows_error.hpp`, `linux_error.hpp`,
+  and `cygwin_error.hpp` emit deprecation messages and are slated for
+  removal.
+* The old names for `generic_category()` and `system_category()` emit
+  deprecation messages and are slated for removal.
+* `error_condition::failed` is deprecated and is slated for removal.
+  `operator bool()` for `error_condition` has been reverted to its old
+  meaning of `value() != 0`. This is done for compatibility with
+  `std::error_condition` as the next release is expected to improve
+  interoperability with `<system_error>` even further. _Note that this
+  does not affect_ `error_code::failed`, which is still alive and well.
+* The overload of `error_condition::message` that takes a buffer is
+  deprecated and is slated for removal, for the same reasons. _Note that
+  this does not affect_ `error_code::message`.
+
+## Changes in Boost 1.74
+
+* `operator bool()` now returns `failed()` instead of `value() != 0`.
+
 ## Changes in Boost 1.69
 
 * Boost.System is now header-only. A stub library is still built for

doc/system/copyright.adoc

@@ -1,5 +1,5 @@
 ////
-Copyright 2018 Peter Dimov
+Copyright 2018-2021 Peter Dimov
 
 Distributed under the Boost Software License, Version 1.0.
 
@@ -14,6 +14,6 @@ http://www.boost.org/LICENSE_1_0.txt
 This documentation is
 
 * Copyright 2003-2017 Beman Dawes
-* Copyright 2018 Peter Dimov
+* Copyright 2018-2022 Peter Dimov
 
 and is distributed under the http://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].

doc/system/introduction.adoc

@@ -1,6 +1,6 @@
 ////
 Copyright 2003-2017 Beman Dawes
-Copyright 2018 Peter Dimov
+Copyright 2018, 2021 Peter Dimov
 
 Distributed under the Boost Software License, Version 1.0.
 
@@ -12,39 +12,67 @@ http://www.boost.org/LICENSE_1_0.txt
 # Introduction
 :idprefix: intro_
 
-Error conditions originating from the operating system or other low-level
-application program interfaces (API's) are typically reported via an integer
-representing an error code. When these low-level API calls are wrapped in
-portable code, such as in a portable library, some users want to deal with the
-error codes in portable ways. Other users need to get at the system specific
-error codes, so they can deal with system specific needs. The Boost System
-library provides simple, light-weight `error_code` objects that encapsulate
-system-specific error code values, yet also provide access to more abstract
-and portable error conditions via `error_condition` objects.
+Errors originating from the operating system or other low-level application
+program interfaces (APIs) are typically reported via an integer representing
+an error code, either by returning the code directly from the function (e.g.
+`pthread_mutex_init`) or by using a side channel such as the `errno`
+pseudo-variable under POSIX or `GetLastError()` under Windows.
 
-Because `error_code` objects can represent errors from sources other than the
-operating system, including user-defined sources, each `error_code` and
-`error_condition` has an associated `error_category`.
+However, these integer error values can only be interpreted when their source
+is known. The value 5 under Windows means `ERROR_ACCESS_DENIED` when returned
+by `GetLastError()`, but `EIO` when retrieved from `errno`. And conversely,
+the same error condition "access denied" is represented by the value 5 when
+returned by `GetLastError()` and 13 (`EACCES`) when retrieved from `errno`.
 
-An exception class, `system_error`, is provided. Derived from
-`std::runtime_error`, it captures the underlying `error_code` for the problem
-causing the exception so that this important information is not lost.
+This means that in order for code to be able to handle errors from both
+sources (to retrieve a text message describing the error, or to check whether
+the error means "access denied"), it needs to know where the integer error
+value originated. For this to be possible, the integer error value needs to
+be accompanied by a piece of information identifying the source.
 
-While exceptions are the preferred {cpp} default error code reporting
-mechanism, users of libraries dependent on low-level API's often need overloads
-reporting error conditions via error code arguments and/or return values rather
-than via throwing exceptions. Otherwise, when errors are not exceptional
-occurrences and must be dealt with as they arise, programs become littered with
-try/catch blocks, unreadable, and inefficient. The Boost System library
-supports both error reporting by exception and by error code.
+Boost.System provides a framework in which this is possible. Errors are
+represented by a class `error_code` which contains both the error value and
+a pointer to their source (called "category"), represented as a class derived
+from `error_category`.
 
-In addition to portable errors codes and conditions supported by the
-`error_code.hpp` header, system-specific headers support the Cygwin, Linux,
-and Windows platforms. These headers are effectively no-ops if included for
-platforms other than their intended target.
+The category provides member functions such as `message`, which returns a text
+message for a specific error value, and `equivalent`, which can be used to test
+whether a specific error value correspond to an error condition such as "access
+denied". `error_code` uses these category-provided functions in the
+implementation of its `message` and `operator==` member functions.
 
-Boost.System is part of the {cpp}11 Standard Library.
-A number of changes, particularly to names, were made by the C++ committee
-during standardization. The Boost implementation has been tracking those changes.
-See <<#ref_deprecated_names,Deprecated Names>> for synonyms provided to prevent
-breakage of existing user code.
+Boost.System contains two predefined category classes, the generic category
+(a reference to which is returned by `generic_category()`) and the system
+category (`system_category()`). The generic category represents the error
+values of the portable subset of `errno` values defined by the POSIX standard,
+whereas the system category is OS dependent. Under POSIX, the system category
+represents the `errno` values returned by the OS APIs (a superset of those in
+the generic category), whereas under Windows, the system category represents
+the error values returned by `GetLastError()`.
+
+The framework is extensible. Users can define their own categories by
+deriving a class from `error_category` and implementing a function that
+returns a reference to an instance of it. This capability is useful both for
+describing library-defined error values, and for adapting existing C API
+libraries that return integer error values.
+
+For those who prefer error reporting via exceptions, Boost.System provides
+a standard exception class `system_error` that stores an `error_code`.
+
+Boost.System was standardized in {cpp}11 as `<system_error>`. For a while,
+the two were equivalent, but Boost.System has evolved since then and now
+contains a number of extensions over its standard sibling:
+
+* A non-allocating overload of `message`;
+* Support for nonzero error codes meaning success, via the `failed` member
+  functions;
+* Support for 64 bit category identifiers, as a solution to the problem
+  that sometimes it's not possible to ensure that only one instance of a
+  category exists in the program;
+* Support for attaching source locations (file/line/function) to error codes;
+* A class `result<T>` that can be used to return either a value or an error
+  code from a function;
+* Various other minor improvements.
+
+`boost::system::error_code` can be converted to, and constructed from,
+`std::error_code`.

extra/boost_system.natvis

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+
+    <Type Name="boost::system::error_category">
+        <DisplayString Condition="id_ == 0xb2ab117a257edfd0">[generic]</DisplayString>
+        <DisplayString Condition="id_ == 0xb2ab117a257edfd1">[system]</DisplayString>
+        <DisplayString Condition="id_ == 0xb2ab117a257edfd2">[interop]</DisplayString>
+        <DisplayString Condition="id_ != 0">[{id_,x}]</DisplayString>
+        <DisplayString>@{((uintptr_t)this),x}</DisplayString>
+    </Type>
+
+    <Type Name="boost::system::error_code">
+        <DisplayString Condition="lc_flags_ == 0">{d1_.val_} [system] ✓</DisplayString>
+
+        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr==1">{((std::error_code*)d2_)->_Myval} [std:future]</DisplayString>
+        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr==3">{((std::error_code*)d2_)->_Myval} [std:generic]</DisplayString>
+        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr==5">{((std::error_code*)d2_)->_Myval} [std:iostream]</DisplayString>
+        <DisplayString Condition="lc_flags_ == 1 &amp;&amp; ((std::error_code*)d2_)->_Mycat->_Addr==7">{((std::error_code*)d2_)->_Myval} [std:system]</DisplayString>
+        <DisplayString Condition="lc_flags_ == 1">{((std::error_code*)d2_)->_Myval} std@{((uintptr_t)((std::error_code*)d2_)->_Mycat),x}</DisplayString>
+
+        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd0 &amp;&amp;
+            (lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 )))">{d1_.val_} [generic] ✓</DisplayString>
+        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd1 &amp;&amp;
+            (lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 )))">{d1_.val_} [system] ✓</DisplayString>
+        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd2 &amp;&amp;
+            (lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 )))">{d1_.val_} [interop] ✓</DisplayString>
+        <DisplayString Condition="d1_.cat_->id_ != 0 &amp;&amp;
+            (lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 )))">{d1_.val_} [{d1_.cat_->id_,x}] ✓</DisplayString>
+        <DisplayString Condition=
+            "lc_flags_ == 2 || (lc_flags_ &gt; 3 &amp;&amp; ( lc_flags_ % 2 == 0 ))">{d1_.val_} @{((uintptr_t)d1_.cat_),x} ✓</DisplayString>
+
+        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd0 &amp;&amp;
+            (lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 ))">{d1_.val_} [generic]</DisplayString>
+        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd1 &amp;&amp;
+            (lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 ))">{d1_.val_} [system]</DisplayString>
+        <DisplayString Condition="d1_.cat_->id_ == 0xb2ab117a257edfd2 &amp;&amp;
+            (lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 ))">{d1_.val_} [interop]</DisplayString>
+        <DisplayString Condition="d1_.cat_->id_ != 0 &amp;&amp;
+            (lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 ))">{d1_.val_} [{d1_.cat_->id_,x}]</DisplayString>
+        <DisplayString Condition=
+            "lc_flags_ &gt;= 3 &amp;&amp; ( lc_flags_ % 2 == 1 )">{d1_.val_} @{((uintptr_t)d1_.cat_),x}</DisplayString>
+
+        <Expand>
+            <Item Name="std::error_code" Condition="lc_flags_ == 1">(std::error_code*)d2_</Item>
+            <Item Name="[location]" Condition="lc_flags_ &gt; 3">*((boost::source_location*)(lc_flags_ &amp; ~1))</Item>
+        </Expand>
+    </Type>
+
+    <Type Name="boost::system::result&lt;*,*&gt;">
+        <DisplayString>{v_}</DisplayString>
+    </Type>
+
+</AutoVisualizer>

include/boost/cerrno.hpp

@@ -7,325 +7,9 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_SYSTEM_CERRNO_HPP
-#define BOOST_SYSTEM_CERRNO_HPP
+#ifndef BOOST_CERRNO_HPP_INCLUDED
+#define BOOST_CERRNO_HPP_INCLUDED
 
-#include <cerrno>
+#include <boost/system/detail/cerrno.hpp>
 
-//  supply errno values likely to be missing, particularly on Windows
-
-#ifndef EAFNOSUPPORT
-#define EAFNOSUPPORT 9901
-#endif
-
-#ifndef EADDRINUSE
-#define EADDRINUSE 9902
-#endif
-
-#ifndef EADDRNOTAVAIL
-#define EADDRNOTAVAIL 9903
-#endif
-
-#ifndef EISCONN
-#define EISCONN 9904
-#endif
-
-#ifndef EBADMSG
-#define EBADMSG 9905
-#endif
-
-#ifndef ECONNABORTED
-#define ECONNABORTED 9906
-#endif
-
-#ifndef EALREADY
-#define EALREADY 9907
-#endif
-
-#ifndef ECONNREFUSED
-#define ECONNREFUSED 9908
-#endif
-
-#ifndef ECONNRESET
-#define ECONNRESET 9909
-#endif
-
-#ifndef EDESTADDRREQ
-#define EDESTADDRREQ 9910
-#endif
-
-#ifndef EHOSTUNREACH
-#define EHOSTUNREACH 9911
-#endif
-
-#ifndef EIDRM
-#define EIDRM 9912
-#endif
-
-#ifndef EMSGSIZE
-#define EMSGSIZE 9913
-#endif
-
-#ifndef ENETDOWN
-#define ENETDOWN 9914
-#endif
-
-#ifndef ENETRESET
-#define ENETRESET 9915
-#endif
-
-#ifndef ENETUNREACH
-#define ENETUNREACH 9916
-#endif
-
-#ifndef ENOBUFS
-#define ENOBUFS 9917
-#endif
-
-#ifndef ENOLINK
-#define ENOLINK 9918
-#endif
-
-#ifndef ENODATA
-#define ENODATA 9919
-#endif
-
-#ifndef ENOMSG
-#define ENOMSG 9920
-#endif
-
-#ifndef ENOPROTOOPT
-#define ENOPROTOOPT 9921
-#endif
-
-#ifndef ENOSR
-#define ENOSR 9922
-#endif
-
-#ifndef ENOTSOCK
-#define ENOTSOCK 9923
-#endif
-
-#ifndef ENOSTR
-#define ENOSTR 9924
-#endif
-
-#ifndef ENOTCONN
-#define ENOTCONN 9925
-#endif
-
-#ifndef ENOTSUP
-#define ENOTSUP 9926
-#endif
-
-#ifndef ECANCELED
-#define ECANCELED 9927
-#endif
-
-#ifndef EINPROGRESS
-#define EINPROGRESS 9928
-#endif
-
-#ifndef EOPNOTSUPP
-#define EOPNOTSUPP 9929
-#endif
-
-#ifndef EWOULDBLOCK
-#define EWOULDBLOCK 9930
-#endif
-
-#ifndef EOWNERDEAD
-#define EOWNERDEAD  9931
-#endif
-
-#ifndef EPROTO
-#define EPROTO 9932
-#endif
-
-#ifndef EPROTONOSUPPORT
-#define EPROTONOSUPPORT 9933
-#endif
-
-#ifndef ENOTRECOVERABLE
-#define ENOTRECOVERABLE 9934
-#endif
-
-#ifndef ETIME
-#define ETIME 9935
-#endif
-
-#ifndef ETXTBSY
-#define ETXTBSY 9936
-#endif
-
-#ifndef ETIMEDOUT
-#define ETIMEDOUT 9938
-#endif
-
-#ifndef ELOOP
-#define ELOOP 9939
-#endif
-
-#ifndef EOVERFLOW
-#define EOVERFLOW 9940
-#endif
-
-#ifndef EPROTOTYPE
-#define EPROTOTYPE 9941
-#endif
-
-#ifndef ENOSYS
-#define ENOSYS 9942
-#endif
-
-#ifndef EINVAL
-#define EINVAL 9943
-#endif
-
-#ifndef ERANGE
-#define ERANGE 9944
-#endif
-
-#ifndef EILSEQ
-#define EILSEQ 9945
-#endif
-
-//  Windows Mobile doesn't appear to define these:
-
-#ifndef E2BIG
-#define E2BIG 9946
-#endif
-
-#ifndef EDOM
-#define EDOM 9947
-#endif
-
-#ifndef EFAULT
-#define EFAULT 9948
-#endif
-
-#ifndef EBADF
-#define EBADF 9949
-#endif
-
-#ifndef EPIPE
-#define EPIPE 9950
-#endif
-
-#ifndef EXDEV
-#define EXDEV 9951
-#endif
-
-#ifndef EBUSY
-#define EBUSY 9952
-#endif
-
-#ifndef ENOTEMPTY
-#define ENOTEMPTY 9953
-#endif
-
-#ifndef ENOEXEC
-#define ENOEXEC 9954
-#endif
-
-#ifndef EEXIST
-#define EEXIST 9955
-#endif
-
-#ifndef EFBIG
-#define EFBIG 9956
-#endif
-
-#ifndef ENAMETOOLONG
-#define ENAMETOOLONG 9957
-#endif
-
-#ifndef ENOTTY
-#define ENOTTY 9958
-#endif
-
-#ifndef EINTR
-#define EINTR 9959
-#endif
-
-#ifndef ESPIPE
-#define ESPIPE 9960
-#endif
-
-#ifndef EIO
-#define EIO 9961
-#endif
-
-#ifndef EISDIR
-#define EISDIR 9962
-#endif
-
-#ifndef ECHILD
-#define ECHILD 9963
-#endif
-
-#ifndef ENOLCK
-#define ENOLCK 9964
-#endif
-
-#ifndef ENOSPC
-#define ENOSPC 9965
-#endif
-
-#ifndef ENXIO
-#define ENXIO 9966
-#endif
-
-#ifndef ENODEV
-#define ENODEV 9967
-#endif
-
-#ifndef ENOENT
-#define ENOENT 9968
-#endif
-
-#ifndef ESRCH
-#define ESRCH 9969
-#endif
-
-#ifndef ENOTDIR
-#define ENOTDIR 9970
-#endif
-
-#ifndef ENOMEM
-#define ENOMEM 9971
-#endif
-
-#ifndef EPERM
-#define EPERM 9972
-#endif
-
-#ifndef EACCES
-#define EACCES 9973
-#endif
-
-#ifndef EROFS
-#define EROFS 9974
-#endif
-
-#ifndef EDEADLK
-#define EDEADLK 9975
-#endif
-
-#ifndef EAGAIN
-#define EAGAIN 9976
-#endif
-
-#ifndef ENFILE
-#define ENFILE 9977
-#endif
-
-#ifndef EMFILE
-#define EMFILE 9978
-#endif
-
-#ifndef EMLINK
-#define EMLINK 9979
-#endif
-
-#endif // include guard
+#endif // #ifndef BOOST_CERRNO_HPP_INCLUDED

include/boost/system.hpp

@@ -0,0 +1,14 @@
+#ifndef BOOST_SYSTEM_HPP_INCLUDED
+#define BOOST_SYSTEM_HPP_INCLUDED
+
+// Copyright 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/system
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/system_error.hpp>
+#include <boost/system/result.hpp>
+
+#endif // #ifndef BOOST_SYSTEM_HPP_INCLUDED

include/boost/system/cygwin_error.hpp

@@ -1,56 +0,0 @@
-//  boost/system/cygwin_error.hpp  -------------------------------------------//
-
-//  Copyright Beman Dawes 2007
-
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See library home page at http://www.boost.org/libs/system
-
-#ifndef BOOST_SYSTEM_CYGWIN_ERROR_HPP
-#define BOOST_SYSTEM_CYGWIN_ERROR_HPP
-
-//  This header is effectively empty for compiles on operating systems where
-//  it is not applicable.
-
-# ifdef __CYGWIN__
-
-#include <boost/system/error_code.hpp>
-
-namespace boost
-{
-  namespace system
-  {
-    //  To construct an error_code after a API error:
-    //
-    //      error_code( errno, system_category() )
-
-    //  User code should use the portable "posix" enums for POSIX errors; this
-    //  allows such code to be portable to non-POSIX systems. For the non-POSIX
-    //  errno values that POSIX-based systems typically provide in addition to 
-    //  POSIX values, use the system specific enums below.
-
-   namespace cygwin_error
-    {
-      enum cygwin_errno
-      {
-        no_net = ENONET,
-        no_package = ENOPKG,
-        no_share = ENOSHARE
-      };
-    }  // namespace cygwin_error
-
-    template<> struct is_error_code_enum<cygwin_error::cygwin_errno>
-      { static const bool value = true; };
-
-    namespace cygwin_error
-    {
-      inline error_code make_error_code( cygwin_errno e )
-        { return error_code( e, system_category() ); }
-    }
-  }
-}
-
-#endif  // __CYGWIN__
-
-#endif  // BOOST_SYSTEM_CYGWIN_ERROR_HPP

include/boost/system/detail/append_int.hpp

@@ -0,0 +1,32 @@
+#ifndef BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED
+
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/system/detail/snprintf.hpp>
+#include <string>
+
+//
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+inline void append_int( std::string& s, int v )
+{
+    char buffer[ 32 ];
+    detail::snprintf( buffer, sizeof( buffer ), ":%d", v );
+
+    s += buffer;
+}
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED

include/boost/system/detail/cerrno.hpp

@@ -0,0 +1,329 @@
+//  Copyright Beman Dawes 2005.
+//  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)
+
+//  See library home page at http://www.boost.org/libs/system
+
+#ifndef BOOST_SYSTEM_DETAIL_CERRNO_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_CERRNO_HPP_INCLUDED
+
+#include <cerrno>
+
+//  supply errno values likely to be missing, particularly on Windows
+
+#ifndef EAFNOSUPPORT
+#define EAFNOSUPPORT 9901
+#endif
+
+#ifndef EADDRINUSE
+#define EADDRINUSE 9902
+#endif
+
+#ifndef EADDRNOTAVAIL
+#define EADDRNOTAVAIL 9903
+#endif
+
+#ifndef EISCONN
+#define EISCONN 9904
+#endif
+
+#ifndef EBADMSG
+#define EBADMSG 9905
+#endif
+
+#ifndef ECONNABORTED
+#define ECONNABORTED 9906
+#endif
+
+#ifndef EALREADY
+#define EALREADY 9907
+#endif
+
+#ifndef ECONNREFUSED
+#define ECONNREFUSED 9908
+#endif
+
+#ifndef ECONNRESET
+#define ECONNRESET 9909
+#endif
+
+#ifndef EDESTADDRREQ
+#define EDESTADDRREQ 9910
+#endif
+
+#ifndef EHOSTUNREACH
+#define EHOSTUNREACH 9911
+#endif
+
+#ifndef EIDRM
+#define EIDRM 9912
+#endif
+
+#ifndef EMSGSIZE
+#define EMSGSIZE 9913
+#endif
+
+#ifndef ENETDOWN
+#define ENETDOWN 9914
+#endif
+
+#ifndef ENETRESET
+#define ENETRESET 9915
+#endif
+
+#ifndef ENETUNREACH
+#define ENETUNREACH 9916
+#endif
+
+#ifndef ENOBUFS
+#define ENOBUFS 9917
+#endif
+
+#ifndef ENOLINK
+#define ENOLINK 9918
+#endif
+
+#ifndef ENODATA
+#define ENODATA 9919
+#endif
+
+#ifndef ENOMSG
+#define ENOMSG 9920
+#endif
+
+#ifndef ENOPROTOOPT
+#define ENOPROTOOPT 9921
+#endif
+
+#ifndef ENOSR
+#define ENOSR 9922
+#endif
+
+#ifndef ENOTSOCK
+#define ENOTSOCK 9923
+#endif
+
+#ifndef ENOSTR
+#define ENOSTR 9924
+#endif
+
+#ifndef ENOTCONN
+#define ENOTCONN 9925
+#endif
+
+#ifndef ENOTSUP
+#define ENOTSUP 9926
+#endif
+
+#ifndef ECANCELED
+#define ECANCELED 9927
+#endif
+
+#ifndef EINPROGRESS
+#define EINPROGRESS 9928
+#endif
+
+#ifndef EOPNOTSUPP
+#define EOPNOTSUPP 9929
+#endif
+
+#ifndef EWOULDBLOCK
+#define EWOULDBLOCK 9930
+#endif
+
+#ifndef EOWNERDEAD
+#define EOWNERDEAD  9931
+#endif
+
+#ifndef EPROTO
+#define EPROTO 9932
+#endif
+
+#ifndef EPROTONOSUPPORT
+#define EPROTONOSUPPORT 9933
+#endif
+
+#ifndef ENOTRECOVERABLE
+#define ENOTRECOVERABLE 9934
+#endif
+
+#ifndef ETIME
+#define ETIME 9935
+#endif
+
+#ifndef ETXTBSY
+#define ETXTBSY 9936
+#endif
+
+#ifndef ETIMEDOUT
+#define ETIMEDOUT 9938
+#endif
+
+#ifndef ELOOP
+#define ELOOP 9939
+#endif
+
+#ifndef EOVERFLOW
+#define EOVERFLOW 9940
+#endif
+
+#ifndef EPROTOTYPE
+#define EPROTOTYPE 9941
+#endif
+
+#ifndef ENOSYS
+#define ENOSYS 9942
+#endif
+
+#ifndef EINVAL
+#define EINVAL 9943
+#endif
+
+#ifndef ERANGE
+#define ERANGE 9944
+#endif
+
+#ifndef EILSEQ
+#define EILSEQ 9945
+#endif
+
+//  Windows Mobile doesn't appear to define these:
+
+#ifndef E2BIG
+#define E2BIG 9946
+#endif
+
+#ifndef EDOM
+#define EDOM 9947
+#endif
+
+#ifndef EFAULT
+#define EFAULT 9948
+#endif
+
+#ifndef EBADF
+#define EBADF 9949
+#endif
+
+#ifndef EPIPE
+#define EPIPE 9950
+#endif
+
+#ifndef EXDEV
+#define EXDEV 9951
+#endif
+
+#ifndef EBUSY
+#define EBUSY 9952
+#endif
+
+#ifndef ENOTEMPTY
+#define ENOTEMPTY 9953
+#endif
+
+#ifndef ENOEXEC
+#define ENOEXEC 9954
+#endif
+
+#ifndef EEXIST
+#define EEXIST 9955
+#endif
+
+#ifndef EFBIG
+#define EFBIG 9956
+#endif
+
+#ifndef ENAMETOOLONG
+#define ENAMETOOLONG 9957
+#endif
+
+#ifndef ENOTTY
+#define ENOTTY 9958
+#endif
+
+#ifndef EINTR
+#define EINTR 9959
+#endif
+
+#ifndef ESPIPE
+#define ESPIPE 9960
+#endif
+
+#ifndef EIO
+#define EIO 9961
+#endif
+
+#ifndef EISDIR
+#define EISDIR 9962
+#endif
+
+#ifndef ECHILD
+#define ECHILD 9963
+#endif
+
+#ifndef ENOLCK
+#define ENOLCK 9964
+#endif
+
+#ifndef ENOSPC
+#define ENOSPC 9965
+#endif
+
+#ifndef ENXIO
+#define ENXIO 9966
+#endif
+
+#ifndef ENODEV
+#define ENODEV 9967
+#endif
+
+#ifndef ENOENT
+#define ENOENT 9968
+#endif
+
+#ifndef ESRCH
+#define ESRCH 9969
+#endif
+
+#ifndef ENOTDIR
+#define ENOTDIR 9970
+#endif
+
+#ifndef ENOMEM
+#define ENOMEM 9971
+#endif
+
+#ifndef EPERM
+#define EPERM 9972
+#endif
+
+#ifndef EACCES
+#define EACCES 9973
+#endif
+
+#ifndef EROFS
+#define EROFS 9974
+#endif
+
+#ifndef EDEADLK
+#define EDEADLK 9975
+#endif
+
+#ifndef EAGAIN
+#define EAGAIN 9976
+#endif
+
+#ifndef ENFILE
+#define ENFILE 9977
+#endif
+
+#ifndef EMFILE
+#define EMFILE 9978
+#endif
+
+#ifndef EMLINK
+#define EMLINK 9979
+#endif
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_CERRNO_HPP_INCLUDED

include/boost/system/detail/config.hpp

@@ -1,7 +1,7 @@
 #ifndef BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
 #define BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
 
-// Copyright 2018 Peter Dimov
+// Copyright 2018-2022 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)
@@ -11,26 +11,16 @@
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 
-// BOOST_SYSTEM_HAS_SYSTEM_ERROR
-
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-# define BOOST_SYSTEM_HAS_SYSTEM_ERROR
-#endif
-
-#if BOOST_WORKAROUND(BOOST_GCC, < 40600)
-// g++ 4.4's <map> is not good enough
-# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR
-#endif
-
-#if defined(BOOST_NO_CXX11_HDR_MUTEX)
-// Required for thread-safe map manipulation
-# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR
-#endif
+// The macro BOOST_SYSTEM_DISABLE_THREADS can be defined on configurations
+// that provide <system_error> and <atomic>, but not <mutex>, such as the
+// single-threaded libstdc++.
+//
+// https://github.com/boostorg/system/issues/92
 
 // BOOST_SYSTEM_NOEXCEPT
 // Retained for backward compatibility
 
-#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
+#define BOOST_SYSTEM_NOEXCEPT noexcept
 
 // BOOST_SYSTEM_HAS_CONSTEXPR
 
@@ -48,4 +38,46 @@
 # define BOOST_SYSTEM_CONSTEXPR
 #endif
 
+// BOOST_SYSTEM_DEPRECATED
+
+#if defined(__clang__)
+# define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#elif defined(__GNUC__)
+# if __GNUC__ * 100 + __GNUC_MINOR__ >= 405
+#  define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated(msg)))
+# else
+#  define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated))
+# endif
+#elif defined(_MSC_VER)
+#  define BOOST_SYSTEM_DEPRECATED(msg) __declspec(deprecated(msg))
+#elif defined(__sun)
+#  define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#else
+# define BOOST_SYSTEM_DEPRECATED(msg)
+#endif
+
+// BOOST_SYSTEM_CLANG_6
+
+// Android NDK r18b has Clang 7.0.2 that still needs the workaround
+// https://github.com/boostorg/system/issues/100
+#if defined(__clang__) && (__clang_major__ < 7 || (defined(__APPLE__) && __clang_major__ < 11) || (defined(__ANDROID__) && __clang_major__ == 7))
+# define BOOST_SYSTEM_CLANG_6
+#endif
+
+//
+
+#if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 50000
+# define BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY
+#endif
+
+#if defined(__CYGWIN__) || defined(__MINGW32__) || (defined(_MSC_VER) && _MSC_VER == 1800) || (defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 90000)
+
+// Under Cygwin (and MinGW!), std::system_category() is POSIX
+// Under VS2013, std::system_category() isn't quite right
+// Under libstdc++ before 7.4, before 8.3, before 9.1, default_error_condition
+// for the system category returns a condition from the system category
+
+# define BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY
+#endif
+
 #endif // BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED

include/boost/system/detail/enable_if.hpp

@@ -0,0 +1,23 @@
+#ifndef BOOST_SYSTEM_DETAIL_ENABLE_IF_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_ENABLE_IF_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <type_traits>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+using std::enable_if;
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_ENABLE_IF_HPP_INCLUDED

include/boost/system/detail/errc.hpp

@@ -0,0 +1,126 @@
+#ifndef BOOST_SYSTEM_DETAIL_ERRC_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_ERRC_HPP_INCLUDED
+
+// Copyright Beman Dawes 2006, 2007
+// Copyright Christoper Kohlhoff 2007
+// Copyright Peter Dimov 2017, 2018, 2020
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/is_error_condition_enum.hpp>
+#include <boost/system/detail/cerrno.hpp>
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace errc
+{
+
+enum errc_t
+{
+    success = 0,
+    address_family_not_supported = EAFNOSUPPORT,
+    address_in_use = EADDRINUSE,
+    address_not_available = EADDRNOTAVAIL,
+    already_connected = EISCONN,
+    argument_list_too_long = E2BIG,
+    argument_out_of_domain = EDOM,
+    bad_address = EFAULT,
+    bad_file_descriptor = EBADF,
+    bad_message = EBADMSG,
+    broken_pipe = EPIPE,
+    connection_aborted = ECONNABORTED,
+    connection_already_in_progress = EALREADY,
+    connection_refused = ECONNREFUSED,
+    connection_reset = ECONNRESET,
+    cross_device_link = EXDEV,
+    destination_address_required = EDESTADDRREQ,
+    device_or_resource_busy = EBUSY,
+    directory_not_empty = ENOTEMPTY,
+    executable_format_error = ENOEXEC,
+    file_exists = EEXIST,
+    file_too_large = EFBIG,
+    filename_too_long = ENAMETOOLONG,
+    function_not_supported = ENOSYS,
+    host_unreachable = EHOSTUNREACH,
+    identifier_removed = EIDRM,
+    illegal_byte_sequence = EILSEQ,
+    inappropriate_io_control_operation = ENOTTY,
+    interrupted = EINTR,
+    invalid_argument = EINVAL,
+    invalid_seek = ESPIPE,
+    io_error = EIO,
+    is_a_directory = EISDIR,
+    message_size = EMSGSIZE,
+    network_down = ENETDOWN,
+    network_reset = ENETRESET,
+    network_unreachable = ENETUNREACH,
+    no_buffer_space = ENOBUFS,
+    no_child_process = ECHILD,
+    no_link = ENOLINK,
+    no_lock_available = ENOLCK,
+    no_message_available = ENODATA,
+    no_message = ENOMSG,
+    no_protocol_option = ENOPROTOOPT,
+    no_space_on_device = ENOSPC,
+    no_stream_resources = ENOSR,
+    no_such_device_or_address = ENXIO,
+    no_such_device = ENODEV,
+    no_such_file_or_directory = ENOENT,
+    no_such_process = ESRCH,
+    not_a_directory = ENOTDIR,
+    not_a_socket = ENOTSOCK,
+    not_a_stream = ENOSTR,
+    not_connected = ENOTCONN,
+    not_enough_memory = ENOMEM,
+    not_supported = ENOTSUP,
+    operation_canceled = ECANCELED,
+    operation_in_progress = EINPROGRESS,
+    operation_not_permitted = EPERM,
+    operation_not_supported = EOPNOTSUPP,
+    operation_would_block = EWOULDBLOCK,
+    owner_dead = EOWNERDEAD,
+    permission_denied = EACCES,
+    protocol_error = EPROTO,
+    protocol_not_supported = EPROTONOSUPPORT,
+    read_only_file_system = EROFS,
+    resource_deadlock_would_occur = EDEADLK,
+    resource_unavailable_try_again = EAGAIN,
+    result_out_of_range = ERANGE,
+    state_not_recoverable = ENOTRECOVERABLE,
+    stream_timeout = ETIME,
+    text_file_busy = ETXTBSY,
+    timed_out = ETIMEDOUT,
+    too_many_files_open_in_system = ENFILE,
+    too_many_files_open = EMFILE,
+    too_many_links = EMLINK,
+    too_many_symbolic_link_levels = ELOOP,
+    value_too_large = EOVERFLOW,
+    wrong_protocol_type = EPROTOTYPE
+};
+
+} // namespace errc
+
+#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
+
+namespace posix = errc;
+namespace posix_error = errc;
+
+#endif
+
+template<> struct is_error_condition_enum<errc::errc_t>
+{
+    static const bool value = true;
+};
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_ERRC_HPP_INCLUDED

include/boost/system/detail/error_category.hpp

@@ -0,0 +1,183 @@
+#ifndef BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <string>
+#include <functional>
+#include <cstddef>
+#include <system_error>
+#include <atomic>
+
+namespace boost
+{
+
+namespace system
+{
+
+class error_category;
+class error_code;
+class error_condition;
+
+std::size_t hash_value( error_code const & ec );
+
+namespace detail
+{
+
+BOOST_SYSTEM_CONSTEXPR bool failed_impl( int ev, error_category const & cat );
+
+class std_category;
+
+} // namespace detail
+
+#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
+#pragma warning(push)
+#pragma warning(disable: 4351) //  new behavior: elements of array will be default initialized
+#endif
+
+class BOOST_SYMBOL_VISIBLE error_category
+{
+private:
+
+    friend std::size_t hash_value( error_code const & ec );
+    friend BOOST_SYSTEM_CONSTEXPR bool detail::failed_impl( int ev, error_category const & cat );
+
+    friend class error_code;
+    friend class error_condition;
+
+public:
+
+    error_category( error_category const & ) = delete;
+    error_category& operator=( error_category const & ) = delete;
+
+private:
+
+    boost::ulong_long_type id_;
+
+    static std::size_t const stdcat_size_ = 4 * sizeof( void const* );
+
+    union
+    {
+        mutable unsigned char stdcat_[ stdcat_size_ ];
+        void const* stdcat_align_;
+    };
+
+    mutable std::atomic< unsigned > sc_init_;
+
+protected:
+
+    ~error_category() = default;
+
+    constexpr error_category() noexcept: id_( 0 ), stdcat_(), sc_init_()
+    {
+    }
+
+    explicit constexpr error_category( boost::ulong_long_type id ) noexcept: id_( id ), stdcat_(), sc_init_()
+    {
+    }
+
+public:
+
+    virtual const char * name() const noexcept = 0;
+
+    virtual error_condition default_error_condition( int ev ) const noexcept;
+    virtual bool equivalent( int code, const error_condition & condition ) const noexcept;
+    virtual bool equivalent( const error_code & code, int condition ) const noexcept;
+
+    virtual std::string message( int ev ) const = 0;
+    virtual char const * message( int ev, char * buffer, std::size_t len ) const noexcept;
+
+    virtual bool failed( int ev ) const noexcept
+    {
+        return ev != 0;
+    }
+
+    friend BOOST_SYSTEM_CONSTEXPR bool operator==( error_category const & lhs, error_category const & rhs ) noexcept
+    {
+        return rhs.id_ == 0? &lhs == &rhs: lhs.id_ == rhs.id_;
+    }
+
+    friend BOOST_SYSTEM_CONSTEXPR bool operator!=( error_category const & lhs, error_category const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    friend BOOST_SYSTEM_CONSTEXPR bool operator<( error_category const & lhs, error_category const & rhs ) noexcept
+    {
+        if( lhs.id_ < rhs.id_ )
+        {
+            return true;
+        }
+
+        if( lhs.id_ > rhs.id_ )
+        {
+            return false;
+        }
+
+        if( rhs.id_ != 0 )
+        {
+            return false; // equal
+        }
+
+        return std::less<error_category const *>()( &lhs, &rhs );
+    }
+
+    void init_stdcat() const;
+
+# if defined(__SUNPRO_CC) // trailing __global is not supported
+    operator std::error_category const & () const;
+# else
+    operator std::error_category const & () const BOOST_SYMBOL_VISIBLE;
+# endif
+};
+
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
+#pragma warning(pop)
+#endif
+
+#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
+#pragma GCC diagnostic pop
+#endif
+
+namespace detail
+{
+
+static const boost::ulong_long_type generic_category_id = ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDFD0;
+static const boost::ulong_long_type system_category_id = generic_category_id + 1;
+static const boost::ulong_long_type interop_category_id = generic_category_id + 2;
+
+BOOST_SYSTEM_CONSTEXPR inline bool failed_impl( int ev, error_category const & cat )
+{
+    if( cat.id_ == system_category_id || cat.id_ == generic_category_id )
+    {
+        return ev != 0;
+    }
+    else
+    {
+        return cat.failed( ev );
+    }
+}
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_HPP_INCLUDED

include/boost/system/detail/error_category_impl.hpp

@@ -0,0 +1,166 @@
+#ifndef BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_IMPL_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_IMPL_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_category.hpp>
+#include <boost/system/detail/error_condition.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/detail/snprintf.hpp>
+#include <boost/system/detail/config.hpp>
+#include <boost/config.hpp>
+#include <string>
+#include <cstring>
+
+namespace boost
+{
+namespace system
+{
+
+// error_category default implementation
+
+inline error_condition error_category::default_error_condition( int ev ) const noexcept
+{
+    return error_condition( ev, *this );
+}
+
+inline bool error_category::equivalent( int code, const error_condition & condition ) const noexcept
+{
+    return default_error_condition( code ) == condition;
+}
+
+inline bool error_category::equivalent( const error_code & code, int condition ) const noexcept
+{
+    return code.equals( condition, *this );
+}
+
+inline char const * error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
+{
+    if( len == 0 )
+    {
+        return buffer;
+    }
+
+    if( len == 1 )
+    {
+        buffer[0] = 0;
+        return buffer;
+    }
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+    try
+#endif
+    {
+        detail::snprintf( buffer, len, "%s", this->message( ev ).c_str() );
+        return buffer;
+    }
+#if !defined(BOOST_NO_EXCEPTIONS)
+    catch( ... )
+    {
+        detail::snprintf( buffer, len, "No message text available for error %d", ev );
+        return buffer;
+    }
+#endif
+}
+
+} // namespace system
+} // namespace boost
+
+// interoperability with std::error_code, std::error_condition
+
+#include <boost/system/detail/std_category_impl.hpp>
+#include <boost/system/detail/mutex.hpp>
+#include <new>
+
+namespace boost
+{
+namespace system
+{
+
+inline void error_category::init_stdcat() const
+{
+    static_assert( sizeof( stdcat_ ) >= sizeof( boost::system::detail::std_category ), "sizeof(stdcat_) is not enough for std_category" );
+
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
+    // no alignof
+#else
+
+    static_assert( alignof( decltype(stdcat_align_) ) >= alignof( boost::system::detail::std_category ), "alignof(stdcat_) is not enough for std_category" );
+
+#endif
+
+    // detail::mutex has a constexpr default constructor,
+    // and therefore guarantees static initialization, on
+    // everything except VS 2013 (msvc-12.0)
+
+    static system::detail::mutex mx_;
+
+    system::detail::lock_guard<system::detail::mutex> lk( mx_ );
+
+    if( sc_init_.load( std::memory_order_acquire ) == 0 )
+    {
+        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, system::detail::id_wrapper<0>() );
+        sc_init_.store( 1, std::memory_order_release );
+    }
+}
+
+#if defined( BOOST_GCC ) && BOOST_GCC >= 40800 && BOOST_GCC < 70000
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+inline BOOST_NOINLINE error_category::operator std::error_category const & () const
+{
+    if( id_ == detail::generic_category_id )
+    {
+// This condition must be the same as the one in error_condition.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY)
+
+        static const boost::system::detail::std_category generic_instance( this, system::detail::id_wrapper<0x1F4D3>() );
+        return generic_instance;
+
+#else
+
+        return std::generic_category();
+
+#endif
+    }
+
+    if( id_ == detail::system_category_id )
+    {
+// This condition must be the same as the one in error_code.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY)
+
+        static const boost::system::detail::std_category system_instance( this, system::detail::id_wrapper<0x1F4D7>() );
+        return system_instance;
+
+#else
+
+        return std::system_category();
+
+#endif
+    }
+
+    if( sc_init_.load( std::memory_order_acquire ) == 0 )
+    {
+        init_stdcat();
+    }
+
+    return *static_cast<boost::system::detail::std_category const*>( static_cast<void const*>( stdcat_ ) );
+}
+
+#if defined( BOOST_GCC ) && BOOST_GCC >= 40800 && BOOST_GCC < 70000
+#pragma GCC diagnostic pop
+#endif
+
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_IMPL_HPP_INCLUDED

include/boost/system/detail/error_code.hpp

@@ -0,0 +1,659 @@
+#ifndef BOOST_SYSTEM_DETAIL_ERROR_CODE_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_ERROR_CODE_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017-2021
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/is_error_code_enum.hpp>
+#include <boost/system/detail/error_category.hpp>
+#include <boost/system/detail/error_condition.hpp>
+#include <boost/system/detail/system_category.hpp>
+#include <boost/system/detail/system_category_impl.hpp>
+#include <boost/system/detail/interop_category.hpp>
+#include <boost/system/detail/enable_if.hpp>
+#include <boost/system/detail/is_same.hpp>
+#include <boost/system/detail/append_int.hpp>
+#include <boost/system/detail/snprintf.hpp>
+#include <boost/system/detail/config.hpp>
+#include <boost/system/detail/std_category.hpp>
+#include <boost/assert/source_location.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <ostream>
+#include <new>
+#include <cstdio>
+#include <system_error>
+
+#if defined(BOOST_GCC) && BOOST_GCC >= 40600 && BOOST_GCC < 70000
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+namespace boost
+{
+
+namespace system
+{
+
+//  class error_code
+
+//  We want error_code to be a value type that can be copied without slicing
+//  and without requiring heap allocation, but we also want it to have
+//  polymorphic behavior based on the error category. This is achieved by
+//  abstract base class error_category supplying the polymorphic behavior,
+//  and error_code containing a pointer to an object of a type derived
+//  from error_category.
+
+bool operator==( const error_code & code, const error_condition & condition ) noexcept;
+std::size_t hash_value( error_code const & ec );
+
+class error_code
+{
+private:
+
+    friend bool operator==( const error_code & code, const error_condition & condition ) noexcept;
+    friend std::size_t hash_value( error_code const & ec );
+
+private:
+
+    struct data
+    {
+        int val_;
+        const error_category * cat_;
+    };
+
+    union
+    {
+        data d1_;
+        unsigned char d2_[ sizeof(std::error_code) ];
+    };
+
+    // 0: default constructed, d1_ value initialized
+    // 1: holds std::error_code in d2_
+    // 2: holds error code in d1_, failed == false
+    // 3: holds error code in d1_, failed == true
+    // >3: pointer to source_location, failed_ in lsb
+    boost::uintptr_t lc_flags_;
+
+private:
+
+    char const* category_name() const noexcept
+    {
+        // return category().name();
+
+        if( lc_flags_ == 0 )
+        {
+            // must match detail::system_error_category::name()
+            return "system";
+        }
+        else if( lc_flags_ == 1 )
+        {
+            // must match detail::interop_error_category::name()
+            return "std:unknown";
+        }
+        else
+        {
+            return d1_.cat_->name();
+        }
+    }
+
+public:
+
+    // constructors:
+
+    constexpr error_code() noexcept:
+        d1_(), lc_flags_( 0 )
+    {
+    }
+
+    BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) noexcept:
+        d1_(), lc_flags_( 2 + detail::failed_impl( val, cat ) )
+    {
+        d1_.val_ = val;
+        d1_.cat_ = &cat;
+    }
+
+    error_code( int val, const error_category & cat, source_location const * loc ) noexcept:
+        d1_(), lc_flags_( ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | +detail::failed_impl( val, cat ) )
+    {
+        d1_.val_ = val;
+        d1_.cat_ = &cat;
+    }
+
+    template<class ErrorCodeEnum> BOOST_SYSTEM_CONSTEXPR error_code( ErrorCodeEnum e,
+        typename detail::enable_if<
+            is_error_code_enum<ErrorCodeEnum>::value
+            || std::is_error_code_enum<ErrorCodeEnum>::value
+        >::type* = 0 ) noexcept: d1_(), lc_flags_( 0 )
+    {
+        *this = make_error_code( e );
+    }
+
+    error_code( error_code const& ec, source_location const * loc ) noexcept:
+        d1_(), lc_flags_( 0 )
+    {
+        *this = ec;
+
+        if( ec.lc_flags_ != 0 && ec.lc_flags_ != 1 )
+        {
+            lc_flags_ = ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | ( ec.lc_flags_ & 1 );
+        }
+    }
+
+    error_code( std::error_code const& ec ) noexcept:
+        d1_(), lc_flags_( 0 )
+    {
+#ifndef BOOST_NO_RTTI
+
+        if( detail::std_category const* pc2 = dynamic_cast< detail::std_category const* >( &ec.category() ) )
+        {
+            *this = boost::system::error_code( ec.value(), pc2->original_category() );
+        }
+        else
+
+#endif
+        {
+            ::new( d2_ ) std::error_code( ec );
+            lc_flags_ = 1;
+        }
+    }
+
+    // modifiers:
+
+    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) noexcept
+    {
+        *this = error_code( val, cat );
+    }
+
+    void assign( int val, const error_category & cat, source_location const * loc ) noexcept
+    {
+        *this = error_code( val, cat, loc );
+    }
+
+    void assign( error_code const& ec, source_location const * loc ) noexcept
+    {
+        *this = error_code( ec, loc );
+    }
+
+    template<typename ErrorCodeEnum>
+        BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
+        operator=( ErrorCodeEnum val ) noexcept
+    {
+        *this = make_error_code( val );
+        return *this;
+    }
+
+    BOOST_SYSTEM_CONSTEXPR void clear() noexcept
+    {
+        *this = error_code();
+    }
+
+    // observers:
+
+    BOOST_SYSTEM_CONSTEXPR int value() const noexcept
+    {
+        if( lc_flags_ != 1 )
+        {
+            return d1_.val_;
+        }
+        else
+        {
+            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
+
+            unsigned cv = static_cast<unsigned>( ec.value() );
+            unsigned ch = static_cast<unsigned>( reinterpret_cast<boost::uintptr_t>( &ec.category() ) % 2097143 ); // 2^21-9, prime
+
+            return static_cast<int>( cv + 1000 * ch );
+        }
+    }
+
+    BOOST_SYSTEM_CONSTEXPR const error_category & category() const noexcept
+    {
+        if( lc_flags_ == 0 )
+        {
+            return system_category();
+        }
+        else if( lc_flags_ == 1 )
+        {
+            return detail::interop_category();
+        }
+        else
+        {
+            return *d1_.cat_;
+        }
+    }
+
+    // deprecated?
+    error_condition default_error_condition() const noexcept
+    {
+        return category().default_error_condition( value() );
+    }
+
+    std::string message() const
+    {
+        if( lc_flags_ == 1 )
+        {
+            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
+            return ec.message();
+        }
+        else if( lc_flags_ == 0 )
+        {
+            return detail::system_error_category_message( value() );
+        }
+        else
+        {
+            return category().message( value() );
+        }
+    }
+
+    char const * message( char * buffer, std::size_t len ) const noexcept
+    {
+        if( lc_flags_ == 1 )
+        {
+            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+            try
+#endif
+            {
+                detail::snprintf( buffer, len, "%s", ec.message().c_str() );
+                return buffer;
+            }
+#if !defined(BOOST_NO_EXCEPTIONS)
+            catch( ... )
+            {
+                detail::snprintf( buffer, len, "No message text available for error std:%s:%d", ec.category().name(), ec.value() );
+                return buffer;
+            }
+#endif
+        }
+        else if( lc_flags_ == 0 )
+        {
+            return detail::system_error_category_message( value(), buffer, len );
+        }
+        else
+        {
+            return category().message( value(), buffer, len );
+        }
+    }
+
+    BOOST_SYSTEM_CONSTEXPR bool failed() const noexcept
+    {
+        if( lc_flags_ & 1 )
+        {
+            if( lc_flags_ == 1 )
+            {
+                std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
+                return ec.value() != 0;
+            }
+
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const noexcept  // true if error
+    {
+        return failed();
+    }
+
+    bool has_location() const noexcept
+    {
+        return lc_flags_ >= 4;
+    }
+
+    source_location const & location() const noexcept
+    {
+        BOOST_STATIC_CONSTEXPR source_location loc;
+        return lc_flags_ >= 4? *reinterpret_cast<source_location const*>( lc_flags_ &~ static_cast<boost::uintptr_t>( 1 ) ): loc;
+    }
+
+    // relationals:
+
+private:
+
+    // private equality for use in error_category::equivalent
+
+    friend class error_category;
+
+    BOOST_SYSTEM_CONSTEXPR bool equals( int val, error_category const& cat ) const noexcept
+    {
+        if( lc_flags_ == 0 )
+        {
+            return val == 0 && cat.id_ == detail::system_category_id;
+        }
+        else if( lc_flags_ == 1 )
+        {
+            return cat.id_ == detail::interop_category_id && val == value();
+        }
+        else
+        {
+            return val == d1_.val_ && cat == *d1_.cat_;
+        }
+    }
+
+public:
+
+    //  the more symmetrical non-member syntax allows enum
+    //  conversions work for both rhs and lhs.
+
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_code & lhs, const error_code & rhs ) noexcept
+    {
+        bool s1 = lhs.lc_flags_ == 1;
+        bool s2 = rhs.lc_flags_ == 1;
+
+        if( s1 != s2 ) return false;
+
+        if( s1 && s2 )
+        {
+            std::error_code const& e1 = *reinterpret_cast<std::error_code const*>( lhs.d2_ );
+            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( rhs.d2_ );
+
+            return e1 == e2;
+        }
+        else
+        {
+            return lhs.value() == rhs.value() && lhs.category() == rhs.category();
+        }
+    }
+
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_code & lhs, const error_code & rhs ) noexcept
+    {
+        bool s1 = lhs.lc_flags_ == 1;
+        bool s2 = rhs.lc_flags_ == 1;
+
+        if( s1 < s2 ) return true;
+        if( s2 < s1 ) return false;
+
+        if( s1 && s2 )
+        {
+            std::error_code const& e1 = *reinterpret_cast<std::error_code const*>( lhs.d2_ );
+            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( rhs.d2_ );
+
+            return e1 < e2;
+        }
+        else
+        {
+            return lhs.category() < rhs.category() || (lhs.category() == rhs.category() && lhs.value() < rhs.value());
+        }
+    }
+
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    inline friend bool operator==( std::error_code const & lhs, error_code const & rhs ) noexcept
+    {
+        return lhs == static_cast< std::error_code >( rhs );
+    }
+
+    inline friend bool operator==( error_code const & lhs, std::error_code const & rhs ) noexcept
+    {
+        return static_cast< std::error_code >( lhs ) == rhs;
+    }
+
+    inline friend bool operator!=( std::error_code const & lhs, error_code const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    inline friend bool operator!=( error_code const & lhs, std::error_code const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    //
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    inline friend bool operator==( error_code const & lhs, E rhs ) noexcept
+    {
+        return lhs == make_error_condition( rhs );
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    inline friend bool operator==( E lhs, error_code const & rhs ) noexcept
+    {
+        return make_error_condition( lhs ) == rhs;
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    inline friend bool operator!=( error_code const & lhs, E rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    inline friend bool operator!=( E lhs, error_code const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    //
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( error_code const & lhs, E rhs ) noexcept
+    {
+        return lhs == make_error_code( rhs );
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( E lhs, error_code const & rhs ) noexcept
+    {
+        return make_error_code( lhs ) == rhs;
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( error_code const & lhs, E rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( E lhs, error_code const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+#if defined(BOOST_SYSTEM_CLANG_6)
+
+    inline friend bool operator==( error_code const & lhs, std::error_condition const & rhs ) noexcept
+    {
+        return static_cast< std::error_code >( lhs ) == rhs;
+    }
+
+    inline friend bool operator==( std::error_condition const & lhs, error_code const & rhs ) noexcept
+    {
+        return lhs == static_cast< std::error_code >( rhs );
+    }
+
+    inline friend bool operator!=( error_code const & lhs, std::error_condition const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    inline friend bool operator!=( std::error_condition const & lhs, error_code const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+#endif
+
+    // conversions
+
+    operator std::error_code () const
+    {
+        if( lc_flags_ == 1 )
+        {
+            return *reinterpret_cast<std::error_code const*>( d2_ );
+        }
+        else if( lc_flags_ == 0 )
+        {
+// This condition must be the same as the one in error_category_impl.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY)
+
+            return std::error_code( 0, boost::system::system_category() );
+
+#else
+
+            return std::error_code();
+
+#endif
+        }
+        else
+        {
+            return std::error_code( d1_.val_, *d1_.cat_ );
+        }
+    }
+
+    operator std::error_code ()
+    {
+        return const_cast<error_code const&>( *this );
+    }
+
+    template<class T,
+      class E = typename detail::enable_if<detail::is_same<T, std::error_code>::value>::type>
+      operator T& ()
+    {
+        if( lc_flags_ != 1 )
+        {
+            std::error_code e2( *this );
+            ::new( d2_ ) std::error_code( e2 );
+            lc_flags_ = 1;
+        }
+
+        return *reinterpret_cast<std::error_code*>( d2_ );
+    }
+
+#if defined(BOOST_SYSTEM_CLANG_6)
+
+    template<class T,
+      class E = typename std::enable_if<std::is_same<T, std::error_code>::value>::type>
+      operator T const& () = delete;
+
+#endif
+
+    std::string to_string() const
+    {
+        if( lc_flags_ == 1 )
+        {
+            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( d2_ );
+
+            std::string r( "std:" );
+            r += e2.category().name();
+            detail::append_int( r, e2.value() );
+
+            return r;
+        }
+        else
+        {
+            std::string r = category_name();
+            detail::append_int( r, value() );
+            return r;
+        }
+    }
+
+    template<class Ch, class Tr>
+        inline friend std::basic_ostream<Ch, Tr>&
+        operator<< (std::basic_ostream<Ch, Tr>& os, error_code const & ec)
+    {
+        return os << ec.to_string().c_str();
+    }
+
+    std::string what() const
+    {
+        std::string r = message();
+
+        r += " [";
+        r += to_string();
+
+        if( has_location() )
+        {
+            r += " at ";
+            r += location().to_string();
+        }
+
+        r += "]";
+        return r;
+    }
+};
+
+inline bool operator==( const error_code & code, const error_condition & condition ) noexcept
+{
+    if( code.lc_flags_ == 1 )
+    {
+        return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
+    }
+    else
+    {
+        return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
+    }
+}
+
+inline bool operator==( const error_condition & condition, const error_code & code ) noexcept
+{
+    return code == condition;
+}
+
+inline bool operator!=( const error_code & lhs, const error_condition & rhs ) noexcept
+{
+    return !( lhs == rhs );
+}
+
+inline bool operator!=( const error_condition & lhs, const error_code & rhs ) noexcept
+{
+    return !( lhs == rhs );
+}
+
+inline std::size_t hash_value( error_code const & ec )
+{
+    if( ec.lc_flags_ == 1 )
+    {
+        std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( ec.d2_ );
+        return std::hash<std::error_code>()( e2 );
+    }
+
+    error_category const & cat = ec.category();
+
+    boost::ulong_long_type id_ = cat.id_;
+
+    if( id_ == 0 )
+    {
+        id_ = reinterpret_cast<boost::uintptr_t>( &cat );
+    }
+
+    boost::ulong_long_type hv = ( boost::ulong_long_type( 0xCBF29CE4 ) << 32 ) + 0x84222325;
+    boost::ulong_long_type const prime = ( boost::ulong_long_type( 0x00000100 ) << 32 ) + 0x000001B3;
+
+    // id
+
+    hv ^= id_;
+    hv *= prime;
+
+    // value
+
+    hv ^= static_cast<unsigned>( ec.value() );
+    hv *= prime;
+
+    return static_cast<std::size_t>( hv );
+}
+
+} // namespace system
+
+} // namespace boost
+
+#if defined(BOOST_GCC) && BOOST_GCC >= 40600 && BOOST_GCC < 70000
+# pragma GCC diagnostic pop
+#endif
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_ERROR_CODE_HPP_INCLUDED

include/boost/system/detail/error_condition.hpp

@@ -0,0 +1,326 @@
+#ifndef BOOST_SYSTEM_DETAIL_ERROR_CONDITION_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_ERROR_CONDITION_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017-2021
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_category.hpp>
+#include <boost/system/detail/generic_category.hpp>
+#include <boost/system/detail/enable_if.hpp>
+#include <boost/system/detail/is_same.hpp>
+#include <boost/system/detail/errc.hpp>
+#include <boost/system/detail/append_int.hpp>
+#include <boost/system/is_error_condition_enum.hpp>
+#include <boost/system/detail/config.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+namespace system
+{
+
+// class error_condition
+
+// error_conditions are portable, error_codes are system or library specific
+
+namespace detail
+{
+
+struct generic_value_tag
+{
+    int value;
+    BOOST_SYSTEM_CONSTEXPR explicit generic_value_tag( int v ): value( v ) {}
+};
+
+} // namespace detail
+
+class error_condition
+{
+private:
+
+    int val_;
+    error_category const * cat_;
+
+private:
+
+    boost::ulong_long_type cat_id() const noexcept
+    {
+        return cat_? cat_->id_: detail::generic_category_id;
+    }
+
+public:
+
+    // constructors:
+
+    BOOST_SYSTEM_CONSTEXPR error_condition() noexcept:
+        val_( 0 ), cat_( 0 )
+    {
+    }
+
+    BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) noexcept:
+        val_( val ), cat_( &cat )
+    {
+    }
+
+    BOOST_SYSTEM_CONSTEXPR explicit error_condition( boost::system::detail::generic_value_tag vt ) noexcept:
+        val_( vt.value ), cat_( 0 )
+    {
+    }
+
+    template<class ErrorConditionEnum> BOOST_SYSTEM_CONSTEXPR error_condition( ErrorConditionEnum e,
+      typename detail::enable_if<
+        is_error_condition_enum<ErrorConditionEnum>::value && !boost::system::detail::is_same<ErrorConditionEnum, errc::errc_t>::value
+      >::type* = 0) noexcept
+    {
+        *this = make_error_condition( e );
+    }
+
+    template<class ErrorConditionEnum> BOOST_SYSTEM_CONSTEXPR error_condition( ErrorConditionEnum e,
+      typename detail::enable_if<boost::system::detail::is_same<ErrorConditionEnum, errc::errc_t>::value>::type* = 0) noexcept:
+        val_( e ), cat_( 0 )
+    {
+    }
+
+    // modifiers:
+
+    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) noexcept
+    {
+        val_ = val;
+        cat_ = &cat;
+    }
+
+    template<typename ErrorConditionEnum>
+        BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
+        operator=( ErrorConditionEnum val ) noexcept
+    {
+        *this = error_condition( val );
+        return *this;
+    }
+
+    BOOST_SYSTEM_CONSTEXPR void clear() noexcept
+    {
+        val_ = 0;
+        cat_ = 0;
+    }
+
+    // observers:
+
+    BOOST_SYSTEM_CONSTEXPR int value() const noexcept
+    {
+        return val_;
+    }
+
+    BOOST_SYSTEM_CONSTEXPR const error_category & category() const noexcept
+    {
+        return cat_? *cat_: generic_category();
+    }
+
+    std::string message() const
+    {
+        if( cat_ )
+        {
+            return cat_->message( value() );
+        }
+        else
+        {
+            return detail::generic_error_category_message( value() );
+        }
+    }
+
+    char const * message( char * buffer, std::size_t len ) const noexcept
+    {
+        if( cat_ )
+        {
+            return cat_->message( value(), buffer, len );
+        }
+        else
+        {
+            return detail::generic_error_category_message( value(), buffer, len );
+        }
+    }
+
+    BOOST_SYSTEM_CONSTEXPR bool failed() const noexcept
+    {
+        if( cat_ )
+        {
+            return detail::failed_impl( val_, *cat_ );
+        }
+        else
+        {
+            return val_ != 0;
+        }
+    }
+
+    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const noexcept  // true if error
+    {
+        return failed();
+    }
+
+    // relationals:
+    //  the more symmetrical non-member syntax allows enum
+    //  conversions work for both rhs and lhs.
+
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept
+    {
+        if( lhs.val_ != rhs.val_ )
+        {
+            return false;
+        }
+        else if( lhs.cat_ == 0 )
+        {
+            return rhs.cat_id() == detail::generic_category_id;
+        }
+        else if( rhs.cat_ == 0 )
+        {
+            return lhs.cat_id() == detail::generic_category_id;
+        }
+        else
+        {
+            return *lhs.cat_ == *rhs.cat_;
+        }
+    }
+
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) noexcept
+    {
+        error_category const& lcat = lhs.category();
+        error_category const& rcat = rhs.category();
+        return lcat < rcat || ( lcat == rcat && lhs.val_ < rhs.val_ );
+    }
+
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    operator std::error_condition () const
+    {
+// This condition must be the same as the one in error_category_impl.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY)
+
+        return std::error_condition( value(), category() );
+
+#else
+
+        if( cat_ )
+        {
+            return std::error_condition( val_, *cat_ );
+        }
+        else
+        {
+            return std::error_condition( val_, std::generic_category() );
+        }
+
+#endif
+    }
+
+    inline friend bool operator==( std::error_code const & lhs, error_condition const & rhs ) noexcept
+    {
+        return lhs == static_cast< std::error_condition >( rhs );
+    }
+
+    inline friend bool operator==( error_condition const & lhs, std::error_code const & rhs ) noexcept
+    {
+        return static_cast< std::error_condition >( lhs ) == rhs;
+    }
+
+    inline friend bool operator!=( std::error_code const & lhs, error_condition const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    inline friend bool operator!=( error_condition const & lhs, std::error_code const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    //
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( error_condition const & lhs, E rhs ) noexcept
+    {
+        return lhs == make_error_condition( rhs );
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( E lhs, error_condition const & rhs ) noexcept
+    {
+        return make_error_condition( lhs ) == rhs;
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( error_condition const & lhs, E rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( E lhs, error_condition const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    //
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    inline friend bool operator==( error_condition const & lhs, E rhs ) noexcept
+    {
+        return lhs == make_error_code( rhs );
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    inline friend bool operator==( E lhs, error_condition const & rhs ) noexcept
+    {
+        return make_error_code( lhs ) == rhs;
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    inline friend bool operator!=( error_condition const & lhs, E rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    inline friend bool operator!=( E lhs, error_condition const & rhs ) noexcept
+    {
+        return !( lhs == rhs );
+    }
+
+    std::string to_string() const
+    {
+        std::string r( "cond:" );
+
+        if( cat_ )
+        {
+            r += cat_->name();
+        }
+        else
+        {
+            r += "generic";
+        }
+
+        detail::append_int( r, value() );
+
+        return r;
+    }
+
+    template<class Ch, class Tr>
+        inline friend std::basic_ostream<Ch, Tr>&
+        operator<< (std::basic_ostream<Ch, Tr>& os, error_condition const & en)
+    {
+        os << en.to_string();
+        return os;
+    }
+};
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_ERROR_CONDITION_HPP_INCLUDED

include/boost/system/detail/generic_category.hpp

@@ -1,13 +1,19 @@
-// Implementation details of generic_error_category
-//
-// Copyright 2018 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)
-//
-// See library home page at http://www.boost.org/libs/system
+#ifndef BOOST_SYSTEM_DETAIL_GENERIC_CATEGORY_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_GENERIC_CATEGORY_HPP_INCLUDED
 
-#include <cstring>
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_category.hpp>
+#include <boost/system/detail/generic_category_message.hpp>
+#include <boost/system/detail/config.hpp>
+#include <boost/config.hpp>
 
 namespace boost
 {
@@ -18,84 +24,100 @@ namespace system
 namespace detail
 {
 
-#if defined(__GLIBC__)
+// generic_error_category
 
-// glibc has two incompatible strerror_r definitions
+#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
 
-inline char const * strerror_r_helper( char const * r, char const * ) BOOST_NOEXCEPT
+class BOOST_SYMBOL_VISIBLE generic_error_category: public error_category
 {
-    return r;
-}
+public:
 
-inline char const * strerror_r_helper( int r, char const * buffer ) BOOST_NOEXCEPT
-{
-    return r == 0? buffer: "Unknown error";
-}
-
-inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
-{
-    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
-}
-
-inline std::string generic_error_category_message( int ev )
-{
-    char buffer[ 128 ];
-    return generic_error_category_message( ev, buffer, sizeof( buffer ) );
-}
-
-#else
-
-// std::strerror is thread-safe on everything else, incl. Windows
-
-# if defined( BOOST_MSVC )
-#  pragma warning( push )
-#  pragma warning( disable: 4996 )
-# elif defined(__clang__) && defined(__has_warning)
-#  pragma clang diagnostic push
-#  if __has_warning("-Wdeprecated-declarations")
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#  endif
-# endif
-
-inline std::string generic_error_category_message( int ev )
-{
-    char const * m = std::strerror( ev );
-    return m? m: "Unknown error";
-}
-
-inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
-{
-    if( len == 0 )
+    BOOST_SYSTEM_CONSTEXPR generic_error_category() noexcept:
+        error_category( detail::generic_category_id )
     {
-        return buffer;
     }
 
-    if( len == 1 )
+    const char * name() const noexcept BOOST_OVERRIDE
     {
-        buffer[0] = 0;
-        return buffer;
+        return "generic";
     }
 
-    char const * m = std::strerror( ev );
+    std::string message( int ev ) const BOOST_OVERRIDE;
+    char const * message( int ev, char * buffer, std::size_t len ) const noexcept BOOST_OVERRIDE;
+};
 
-    if( m == 0 ) return "Unknown error";
+#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
+#pragma GCC diagnostic pop
+#endif
 
-    std::strncpy( buffer, m, len - 1 );
-    buffer[ len-1 ] = 0;
+// generic_error_category::message
 
-    return buffer;
+inline char const * generic_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
+{
+    return generic_error_category_message( ev, buffer, len );
 }
 
-# if defined( BOOST_MSVC )
-#  pragma warning( pop )
-# elif defined(__clang__) && defined(__has_warning)
-#  pragma clang diagnostic pop
-# endif
+inline std::string generic_error_category::message( int ev ) const
+{
+    return generic_error_category_message( ev );
+}
 
+} // namespace detail
+
+// generic_category()
+
+#if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+namespace detail
+{
+
+template<class T> struct BOOST_SYMBOL_VISIBLE generic_cat_holder
+{
+    static constexpr generic_error_category instance{};
+};
+
+// Before C++17 it was mandatory to redeclare all static constexpr
+#if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
+template<class T> constexpr generic_error_category generic_cat_holder<T>::instance;
 #endif
 
 } // namespace detail
 
+constexpr error_category const & generic_category() noexcept
+{
+    return detail::generic_cat_holder<void>::instance;
+}
+
+#else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+#if !defined(__SUNPRO_CC) // trailing __global is not supported
+inline error_category const & generic_category() noexcept BOOST_SYMBOL_VISIBLE;
+#endif
+
+inline error_category const & generic_category() noexcept
+{
+    static const detail::generic_error_category instance;
+    return instance;
+}
+
+#endif // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+// deprecated synonyms
+
+#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
+
+BOOST_SYSTEM_DEPRECATED("please use generic_category()") inline const error_category & get_generic_category() { return generic_category(); }
+BOOST_SYSTEM_DEPRECATED("please use generic_category()") inline const error_category & get_posix_category() { return generic_category(); }
+BOOST_SYSTEM_DEPRECATED("please use generic_category()") static const error_category & posix_category BOOST_ATTRIBUTE_UNUSED = generic_category();
+BOOST_SYSTEM_DEPRECATED("please use generic_category()") static const error_category & errno_ecat BOOST_ATTRIBUTE_UNUSED = generic_category();
+
+#endif
+
 } // namespace system
 
 } // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_GENERIC_CATEGORY_HPP_INCLUDED

include/boost/system/detail/generic_category_message.hpp

@@ -0,0 +1,120 @@
+#ifndef BOOST_SYSTEM_DETAIL_GENERIC_CATEGORY_MESSAGE_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_GENERIC_CATEGORY_MESSAGE_HPP_INCLUDED
+
+// Implementation of generic_error_category_message
+//
+// Copyright 2018 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/config.hpp>
+#include <string>
+#include <cstring>
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+#if defined(__GLIBC__)
+
+// glibc has two incompatible strerror_r definitions
+
+inline char const * strerror_r_helper( char const * r, char const * ) noexcept
+{
+    return r;
+}
+
+inline char const * strerror_r_helper( int r, char const * buffer ) noexcept
+{
+    return r == 0? buffer: "Unknown error";
+}
+
+inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+{
+    if( buffer != nullptr )
+    {
+        return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    }
+    else
+    {
+        // strerror_r requires non-null buffer pointer
+
+        char tmp[ 1 ] = {};
+        char const* r = strerror_r_helper( strerror_r( ev, tmp, 0 ), buffer );
+
+        return r == tmp? nullptr: r;
+    }
+}
+
+inline std::string generic_error_category_message( int ev )
+{
+    char buffer[ 128 ];
+    return generic_error_category_message( ev, buffer, sizeof( buffer ) );
+}
+
+#else // #if defined(__GLIBC__)
+
+// std::strerror is thread-safe on everything else, incl. Windows
+
+# if defined( BOOST_MSVC )
+#  pragma warning( push )
+#  pragma warning( disable: 4996 )
+# elif defined(__clang__) && defined(__has_warning)
+#  pragma clang diagnostic push
+#  if __has_warning("-Wdeprecated-declarations")
+#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#  endif
+# endif
+
+inline std::string generic_error_category_message( int ev )
+{
+    char const * m = std::strerror( ev );
+    return m? m: "Unknown error";
+}
+
+inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+{
+    if( len == 0 )
+    {
+        return buffer;
+    }
+
+    if( len == 1 )
+    {
+        buffer[0] = 0;
+        return buffer;
+    }
+
+    char const * m = std::strerror( ev );
+
+    if( m == 0 ) return "Unknown error";
+
+    std::strncpy( buffer, m, len - 1 );
+    buffer[ len-1 ] = 0;
+
+    return buffer;
+}
+
+# if defined( BOOST_MSVC )
+#  pragma warning( pop )
+# elif defined(__clang__) && defined(__has_warning)
+#  pragma clang diagnostic pop
+# endif
+
+#endif // #if defined(__GLIBC__)
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_GENERIC_CATEGORY_MESSAGE_HPP_INCLUDED

include/boost/system/detail/interop_category.hpp

@@ -0,0 +1,107 @@
+#ifndef BOOST_SYSTEM_DETAIL_INTEROP_CATEGORY_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_INTEROP_CATEGORY_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018, 2021
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_category.hpp>
+#include <boost/system/detail/snprintf.hpp>
+#include <boost/system/detail/config.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+// interop_error_category, used for std::error_code
+
+#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+class BOOST_SYMBOL_VISIBLE interop_error_category: public error_category
+{
+public:
+
+    BOOST_SYSTEM_CONSTEXPR interop_error_category() noexcept:
+        error_category( detail::interop_category_id )
+    {
+    }
+
+    const char * name() const noexcept BOOST_OVERRIDE
+    {
+        return "std:unknown";
+    }
+
+    std::string message( int ev ) const BOOST_OVERRIDE;
+    char const * message( int ev, char * buffer, std::size_t len ) const noexcept BOOST_OVERRIDE;
+};
+
+#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
+#pragma GCC diagnostic pop
+#endif
+
+inline char const * interop_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
+{
+    detail::snprintf( buffer, len, "Unknown interop error %d", ev );
+    return buffer;
+}
+
+inline std::string interop_error_category::message( int ev ) const
+{
+    char buffer[ 48 ];
+    return message( ev, buffer, sizeof( buffer ) );
+}
+
+// interop_category()
+
+#if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+template<class T> struct BOOST_SYMBOL_VISIBLE interop_cat_holder
+{
+    static constexpr interop_error_category instance{};
+};
+
+// Before C++17 it was mandatory to redeclare all static constexpr
+#if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
+template<class T> constexpr interop_error_category interop_cat_holder<T>::instance;
+#endif
+
+constexpr error_category const & interop_category() noexcept
+{
+    return interop_cat_holder<void>::instance;
+}
+
+#else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+#if !defined(__SUNPRO_CC) // trailing __global is not supported
+inline error_category const & interop_category() noexcept BOOST_SYMBOL_VISIBLE;
+#endif
+
+inline error_category const & interop_category() noexcept
+{
+    static const detail::interop_error_category instance;
+    return instance;
+}
+
+#endif // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_INTEROP_CATEGORY_HPP_INCLUDED

include/boost/system/detail/is_same.hpp

@@ -0,0 +1,23 @@
+#ifndef BOOST_SYSTEM_DETAIL_IS_SAME_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_IS_SAME_HPP_INCLUDED
+
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <type_traits>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+using std::is_same;
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_IS_SAME_HPP_INCLUDED

include/boost/system/detail/mutex.hpp

@@ -0,0 +1,128 @@
+#ifndef BOOST_SYSTEM_DETAIL_MUTEX_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_MUTEX_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_SYSTEM_DISABLE_THREADS)
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+struct mutex
+{
+    void lock()
+    {
+    }
+
+    void unlock()
+    {
+    }
+};
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#else // defined(BOOST_SYSTEM_DISABLE_THREADS)
+
+#if defined(BOOST_MSSTL_VERSION) && BOOST_MSSTL_VERSION >= 140
+
+// Under the MS STL, std::mutex::mutex() is not constexpr, as is
+// required by the standard, which leads to initialization order
+// issues. However, shared_mutex is based on SRWLock and its
+// default constructor is constexpr, so we use that instead.
+
+#include <boost/winapi/config.hpp>
+
+// SRWLOCK is not available when targeting Windows XP
+#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+#include <shared_mutex>
+
+#if BOOST_MSSTL_VERSION >= 142 || _HAS_SHARED_MUTEX
+# define BOOST_SYSTEM_HAS_MSSTL_SHARED_MUTEX
+#endif
+
+#endif // BOOST_MSSTL_VERSION >= 142 || _HAS_SHARED_MUTEX
+
+#endif // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+#if defined(BOOST_SYSTEM_HAS_MSSTL_SHARED_MUTEX)
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+typedef std::shared_mutex mutex;
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#else // defined(BOOST_SYSTEM_HAS_MSSTL_SHARED_MUTEX)
+
+#include <mutex>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+using std::mutex;
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // defined(BOOST_SYSTEM_HAS_MSSTL_SHARED_MUTEX)
+#endif // defined(BOOST_SYSTEM_DISABLE_THREADS)
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+template<class Mtx> class lock_guard
+{
+private:
+
+    Mtx& mtx_;
+
+private:
+
+    lock_guard( lock_guard const& );
+    lock_guard& operator=( lock_guard const& );
+
+public:
+
+    explicit lock_guard( Mtx& mtx ): mtx_( mtx )
+    {
+        mtx_.lock();
+    }
+
+    ~lock_guard()
+    {
+        mtx_.unlock();
+    }
+};
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_MUTEX_HPP_INCLUDED

include/boost/system/detail/snprintf.hpp

@@ -0,0 +1,28 @@
+#ifndef BOOST_SYSTEM_DETAIL_SNPRINTF_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SNPRINTF_HPP_INCLUDED
+
+// Copyright 2018, 2020, 2021 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <cstdio>
+
+//
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+using std::snprintf;
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_SNPRINTF_HPP_INCLUDED

include/boost/system/detail/std_category.hpp

@@ -0,0 +1,84 @@
+#ifndef BOOST_SYSTEM_DETAIL_STD_CATEGORY_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_STD_CATEGORY_HPP_INCLUDED
+
+// Support for interoperability between Boost.System and <system_error>
+//
+// Copyright 2018, 2021 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_category.hpp>
+#include <boost/config.hpp>
+#include <system_error>
+
+//
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+template<unsigned Id> struct id_wrapper {};
+
+class BOOST_SYMBOL_VISIBLE std_category: public std::error_category
+{
+private:
+
+    boost::system::error_category const * pc_;
+
+public:
+
+    boost::system::error_category const & original_category() const noexcept
+    {
+        return *pc_;
+    }
+
+public:
+
+    template<unsigned Id>
+    explicit std_category( boost::system::error_category const * pc, id_wrapper<Id> ): pc_( pc )
+    {
+#if defined(_MSC_VER) && defined(_CPPLIB_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
+
+        // We used to assign to the protected _Addr member of std::error_category
+        // here when Id != 0, but this should never happen now because this code
+        // path is no longer used
+
+        static_assert( Id == 0, "This constructor should only be called with Id == 0 under MS STL 14.0+" );
+
+#endif
+    }
+
+    const char * name() const noexcept BOOST_OVERRIDE
+    {
+        return pc_->name();
+    }
+
+    std::string message( int ev ) const BOOST_OVERRIDE
+    {
+        return pc_->message( ev );
+    }
+
+    std::error_condition default_error_condition( int ev ) const noexcept BOOST_OVERRIDE
+    {
+        return pc_->default_error_condition( ev );
+    }
+
+    inline bool equivalent( int code, const std::error_condition & condition ) const noexcept BOOST_OVERRIDE;
+    inline bool equivalent( const std::error_code & code, int condition ) const noexcept BOOST_OVERRIDE;
+};
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_STD_CATEGORY_HPP_INCLUDED

include/boost/system/detail/std_category_impl.hpp

@@ -0,0 +1,97 @@
+#ifndef BOOST_SYSTEM_DETAIL_STD_CATEGORY_IMPL_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_STD_CATEGORY_IMPL_HPP_INCLUDED
+
+// Support for interoperability between Boost.System and <system_error>
+//
+// Copyright 2018, 2021 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/std_category.hpp>
+#include <boost/system/detail/error_condition.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/detail/generic_category.hpp>
+
+//
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+inline bool std_category::equivalent( int code, const std::error_condition & condition ) const noexcept
+{
+    if( condition.category() == *this )
+    {
+        boost::system::error_condition bn( condition.value(), *pc_ );
+        return pc_->equivalent( code, bn );
+    }
+    else if( condition.category() == std::generic_category() || condition.category() == boost::system::generic_category() )
+    {
+        boost::system::error_condition bn( condition.value(), boost::system::generic_category() );
+        return pc_->equivalent( code, bn );
+    }
+
+#ifndef BOOST_NO_RTTI
+
+    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &condition.category() ) )
+    {
+        boost::system::error_condition bn( condition.value(), *pc2->pc_ );
+        return pc_->equivalent( code, bn );
+    }
+
+#endif
+
+    else
+    {
+        return default_error_condition( code ) == condition;
+    }
+}
+
+inline bool std_category::equivalent( const std::error_code & code, int condition ) const noexcept
+{
+    if( code.category() == *this )
+    {
+        boost::system::error_code bc( code.value(), *pc_ );
+        return pc_->equivalent( bc, condition );
+    }
+    else if( code.category() == std::generic_category() || code.category() == boost::system::generic_category() )
+    {
+        boost::system::error_code bc( code.value(), boost::system::generic_category() );
+        return pc_->equivalent( bc, condition );
+    }
+
+#ifndef BOOST_NO_RTTI
+
+    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &code.category() ) )
+    {
+        boost::system::error_code bc( code.value(), *pc2->pc_ );
+        return pc_->equivalent( bc, condition );
+    }
+
+#endif
+
+    else if( *pc_ == boost::system::generic_category() )
+    {
+        return std::generic_category().equivalent( code, condition );
+    }
+    else
+    {
+        return false;
+    }
+}
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_STD_CATEGORY_IMPL_HPP_INCLUDED

include/boost/system/detail/std_interoperability.hpp

@@ -1,180 +0,0 @@
-// Support for interoperability between Boost.System and <system_error>
-//
-// Copyright 2018 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)
-//
-// See library home page at http://www.boost.org/libs/system
-
-#include <system_error>
-#include <map>
-#include <memory>
-#include <mutex>
-
-//
-
-namespace boost
-{
-
-namespace system
-{
-
-namespace detail
-{
-
-class BOOST_SYMBOL_VISIBLE std_category: public std::error_category
-{
-private:
-
-    boost::system::error_category const * pc_;
-
-public:
-
-    explicit std_category( boost::system::error_category const * pc, unsigned id ): pc_( pc )
-    {
-        if( id != 0 )
-        {
-#if defined(_MSC_VER) && defined(_CPPLIB_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
-
-            // Poking into the protected _Addr member of std::error_category
-            // is not a particularly good programming practice, but what can
-            // you do
-
-            _Addr = id;
-
-#endif
-        }
-    }
-
-    virtual const char * name() const BOOST_NOEXCEPT
-    {
-        return pc_->name();
-    }
-
-    virtual std::string message( int ev ) const
-    {
-        return pc_->message( ev );
-    }
-
-    virtual std::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
-    {
-        return pc_->default_error_condition( ev );
-    }
-
-    virtual bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT;
-    virtual bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT;
-};
-
-inline std::error_category const & to_std_category( boost::system::error_category const & cat ) BOOST_SYMBOL_VISIBLE;
-
-struct cat_ptr_less
-{
-    bool operator()( boost::system::error_category const * p1, boost::system::error_category const * p2 ) const BOOST_NOEXCEPT
-    {
-        return *p1 < *p2;
-    }
-};
-
-inline std::error_category const & to_std_category( boost::system::error_category const & cat )
-{
-    if( cat == boost::system::system_category() )
-    {
-        static const std_category system_instance( &cat, 0x1F4D7 );
-        return system_instance;
-    }
-    else if( cat == boost::system::generic_category() )
-    {
-        static const std_category generic_instance( &cat, 0x1F4D3 );
-        return generic_instance;
-    }
-    else
-    {
-        typedef std::map< boost::system::error_category const *, std::unique_ptr<std_category>, cat_ptr_less > map_type;
-
-        static map_type map_;
-        static std::mutex map_mx_;
-
-        std::lock_guard<std::mutex> guard( map_mx_ );
-
-        map_type::iterator i = map_.find( &cat );
-
-        if( i == map_.end() )
-        {
-            std::unique_ptr<std_category> p( new std_category( &cat, 0 ) );
-
-            std::pair<map_type::iterator, bool> r = map_.insert( map_type::value_type( &cat, std::move( p ) ) );
-
-            i = r.first;
-        }
-
-        return *i->second;
-    }
-}
-
-inline bool std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT
-{
-    if( condition.category() == *this )
-    {
-        boost::system::error_condition bn( condition.value(), *pc_ );
-        return pc_->equivalent( code, bn );
-    }
-    else if( condition.category() == std::generic_category() || condition.category() == boost::system::generic_category() )
-    {
-        boost::system::error_condition bn( condition.value(), boost::system::generic_category() );
-        return pc_->equivalent( code, bn );
-    }
-
-#ifndef BOOST_NO_RTTI
-
-    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &condition.category() ) )
-    {
-        boost::system::error_condition bn( condition.value(), *pc2->pc_ );
-        return pc_->equivalent( code, bn );
-    }
-
-#endif
-
-    else
-    {
-        return default_error_condition( code ) == condition;
-    }
-}
-
-inline bool std_category::equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT
-{
-    if( code.category() == *this )
-    {
-        boost::system::error_code bc( code.value(), *pc_ );
-        return pc_->equivalent( bc, condition );
-    }
-    else if( code.category() == std::generic_category() || code.category() == boost::system::generic_category() )
-    {
-        boost::system::error_code bc( code.value(), boost::system::generic_category() );
-        return pc_->equivalent( bc, condition );
-    }
-
-#ifndef BOOST_NO_RTTI
-
-    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &code.category() ) )
-    {
-        boost::system::error_code bc( code.value(), *pc2->pc_ );
-        return pc_->equivalent( bc, condition );
-    }
-#endif
-
-    else if( *pc_ == boost::system::generic_category() )
-    {
-        return std::generic_category().equivalent( code, condition );
-    }
-    else
-    {
-        return false;
-    }
-}
-
-} // namespace detail
-
-} // namespace system
-
-} // namespace boost

include/boost/system/detail/system_category.hpp

@@ -0,0 +1,110 @@
+#ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_category.hpp>
+#include <boost/system/detail/config.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+// system_error_category
+
+#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+class BOOST_SYMBOL_VISIBLE system_error_category: public error_category
+{
+public:
+
+    BOOST_SYSTEM_CONSTEXPR system_error_category() noexcept:
+        error_category( detail::system_category_id )
+    {
+    }
+
+    const char * name() const noexcept BOOST_OVERRIDE
+    {
+        return "system";
+    }
+
+    error_condition default_error_condition( int ev ) const noexcept BOOST_OVERRIDE;
+
+    std::string message( int ev ) const BOOST_OVERRIDE;
+    char const * message( int ev, char * buffer, std::size_t len ) const noexcept BOOST_OVERRIDE;
+};
+
+#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
+#pragma GCC diagnostic pop
+#endif
+
+} // namespace detail
+
+// system_category()
+
+#if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+namespace detail
+{
+
+template<class T> struct BOOST_SYMBOL_VISIBLE system_cat_holder
+{
+    static constexpr system_error_category instance{};
+};
+
+// Before C++17 it was mandatory to redeclare all static constexpr
+#if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
+template<class T> constexpr system_error_category system_cat_holder<T>::instance;
+#endif
+
+} // namespace detail
+
+constexpr error_category const & system_category() noexcept
+{
+    return detail::system_cat_holder<void>::instance;
+}
+
+#else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+#if !defined(__SUNPRO_CC) // trailing __global is not supported
+inline error_category const & system_category() noexcept BOOST_SYMBOL_VISIBLE;
+#endif
+
+inline error_category const & system_category() noexcept
+{
+    static const detail::system_error_category instance;
+    return instance;
+}
+
+#endif // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+
+// deprecated synonyms
+
+#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
+
+BOOST_SYSTEM_DEPRECATED("please use system_category()") inline const error_category & get_system_category() { return system_category(); }
+BOOST_SYSTEM_DEPRECATED("please use system_category()") static const error_category & native_ecat BOOST_ATTRIBUTE_UNUSED = system_category();
+
+#endif
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_HPP_INCLUDED

include/boost/system/detail/system_category_condition_win32.hpp

@@ -0,0 +1,157 @@
+#ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_CONDITION_WIN32_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_CONDITION_WIN32_HPP_INCLUDED
+
+// Copyright Beman Dawes 2002, 2006
+// Copyright (c) Microsoft Corporation 2014
+// Copyright 2018 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/errc.hpp>
+#include <boost/winapi/error_codes.hpp>
+#include <boost/config.hpp>
+
+//
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+inline int system_category_condition_win32( int ev ) noexcept
+{
+    // When using the Windows Runtime, most system errors are reported as HRESULTs.
+    // We want to map the common Win32 errors to their equivalent error condition,
+    // whether or not they are reported via an HRESULT.
+
+#define BOOST_SYSTEM_FAILED(hr)           ((hr) < 0)
+#define BOOST_SYSTEM_HRESULT_FACILITY(hr) (((hr) >> 16) & 0x1fff)
+#define BOOST_SYSTEM_HRESULT_CODE(hr)     ((hr) & 0xFFFF)
+#define BOOST_SYSTEM_FACILITY_WIN32       7
+
+    if( BOOST_SYSTEM_FAILED( ev ) && BOOST_SYSTEM_HRESULT_FACILITY( ev ) == BOOST_SYSTEM_FACILITY_WIN32 )
+    {
+        ev = BOOST_SYSTEM_HRESULT_CODE( ev );
+    }
+
+#undef BOOST_SYSTEM_FAILED
+#undef BOOST_SYSTEM_HRESULT_FACILITY
+#undef BOOST_SYSTEM_HRESULT_CODE
+#undef BOOST_SYSTEM_FACILITY_WIN32
+
+    using namespace boost::winapi;
+    using namespace errc;
+
+    // Windows system -> posix_errno decode table
+    // see WinError.h comments for descriptions of errors
+
+    switch ( ev )
+    {
+    case 0: return success;
+
+    case ERROR_ACCESS_DENIED_: return permission_denied;
+    case ERROR_ALREADY_EXISTS_: return file_exists;
+    case ERROR_BAD_NETPATH_: return no_such_file_or_directory;
+    case ERROR_BAD_NET_NAME_: return no_such_file_or_directory;
+    case ERROR_BAD_UNIT_: return no_such_device;
+    case ERROR_BROKEN_PIPE_: return broken_pipe;
+    case ERROR_BUFFER_OVERFLOW_: return filename_too_long;
+    case ERROR_BUSY_: return device_or_resource_busy;
+    case ERROR_BUSY_DRIVE_: return device_or_resource_busy;
+    case ERROR_CANNOT_MAKE_: return permission_denied;
+    case ERROR_CANTOPEN_: return io_error;
+    case ERROR_CANTREAD_: return io_error;
+    case ERROR_CANTWRITE_: return io_error;
+    case ERROR_CONNECTION_ABORTED_: return connection_aborted;
+    case ERROR_CURRENT_DIRECTORY_: return permission_denied;
+    case ERROR_DEV_NOT_EXIST_: return no_such_device;
+    case ERROR_DEVICE_IN_USE_: return device_or_resource_busy;
+    case ERROR_DIR_NOT_EMPTY_: return directory_not_empty;
+    case ERROR_DIRECTORY_: return invalid_argument; // WinError.h: "The directory name is invalid"
+    case ERROR_DISK_FULL_: return no_space_on_device;
+    case ERROR_FILENAME_EXCED_RANGE_: return filename_too_long;
+    case ERROR_FILE_EXISTS_: return file_exists;
+    case ERROR_FILE_NOT_FOUND_: return no_such_file_or_directory;
+    case ERROR_HANDLE_DISK_FULL_: return no_space_on_device;
+    case ERROR_INVALID_ACCESS_: return permission_denied;
+    case ERROR_INVALID_DRIVE_: return no_such_device;
+    case ERROR_INVALID_FUNCTION_: return function_not_supported;
+    case ERROR_INVALID_HANDLE_: return invalid_argument;
+    case ERROR_INVALID_NAME_: return no_such_file_or_directory;
+    case ERROR_INVALID_PARAMETER_: return invalid_argument;
+    case ERROR_LOCK_VIOLATION_: return no_lock_available;
+    case ERROR_LOCKED_: return no_lock_available;
+    case ERROR_NEGATIVE_SEEK_: return invalid_argument;
+    case ERROR_NOACCESS_: return permission_denied;
+    case ERROR_NOT_ENOUGH_MEMORY_: return not_enough_memory;
+    case ERROR_NOT_READY_: return resource_unavailable_try_again;
+    case ERROR_NOT_SAME_DEVICE_: return cross_device_link;
+    case ERROR_OPEN_FAILED_: return io_error;
+    case ERROR_OPEN_FILES_: return device_or_resource_busy;
+    case ERROR_OPERATION_ABORTED_: return operation_canceled;
+    case ERROR_OUTOFMEMORY_: return not_enough_memory;
+    case ERROR_PATH_NOT_FOUND_: return no_such_file_or_directory;
+    case ERROR_READ_FAULT_: return io_error;
+    case ERROR_REPARSE_TAG_INVALID_: return invalid_argument;
+    case ERROR_RETRY_: return resource_unavailable_try_again;
+    case ERROR_SEEK_: return io_error;
+    case ERROR_SEM_TIMEOUT_: return timed_out;
+    case ERROR_SHARING_VIOLATION_: return permission_denied;
+    case ERROR_NOT_SUPPORTED_: return not_supported; // WinError.h: "The request is not supported."
+    case ERROR_TIMEOUT_: return timed_out;
+    case ERROR_TOO_MANY_OPEN_FILES_: return too_many_files_open;
+    case ERROR_WRITE_FAULT_: return io_error;
+    case ERROR_WRITE_PROTECT_: return permission_denied;
+
+    case 258: return timed_out; // WAIT_TIMEOUT
+
+    case WSAEACCES_: return permission_denied;
+    case WSAEADDRINUSE_: return address_in_use;
+    case WSAEADDRNOTAVAIL_: return address_not_available;
+    case WSAEAFNOSUPPORT_: return address_family_not_supported;
+    case WSAEALREADY_: return connection_already_in_progress;
+    case WSAEBADF_: return bad_file_descriptor;
+    case WSAECONNABORTED_: return connection_aborted;
+    case WSAECONNREFUSED_: return connection_refused;
+    case WSAECONNRESET_: return connection_reset;
+    case WSAEDESTADDRREQ_: return destination_address_required;
+    case WSAEFAULT_: return bad_address;
+    case WSAEHOSTUNREACH_: return host_unreachable;
+    case WSAEINPROGRESS_: return operation_in_progress;
+    case WSAEINTR_: return interrupted;
+    case WSAEINVAL_: return invalid_argument;
+    case WSAEISCONN_: return already_connected;
+    case WSAEMFILE_: return too_many_files_open;
+    case WSAEMSGSIZE_: return message_size;
+    case WSAENAMETOOLONG_: return filename_too_long;
+    case WSAENETDOWN_: return network_down;
+    case WSAENETRESET_: return network_reset;
+    case WSAENETUNREACH_: return network_unreachable;
+    case WSAENOBUFS_: return no_buffer_space;
+    case WSAENOPROTOOPT_: return no_protocol_option;
+    case WSAENOTCONN_: return not_connected;
+    case WSAENOTSOCK_: return not_a_socket;
+    case WSAEOPNOTSUPP_: return operation_not_supported;
+    case WSAEPROTONOSUPPORT_: return protocol_not_supported;
+    case WSAEPROTOTYPE_: return wrong_protocol_type;
+    case WSAETIMEDOUT_: return timed_out;
+    case WSAEWOULDBLOCK_: return operation_would_block;
+
+    default: return -1;
+    }
+}
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_CONDITION_WIN32_HPP_INCLUDED

include/boost/system/detail/system_category_impl.hpp

@@ -0,0 +1,61 @@
+#ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_IMPL_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_IMPL_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018, 2020
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/system_category.hpp>
+#include <boost/system/detail/system_category_message.hpp>
+#include <boost/system/detail/error_condition.hpp>
+#include <boost/system/api_config.hpp>
+
+#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API)
+#  error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
+#endif
+
+// system_error_category implementation
+
+#if defined(BOOST_WINDOWS_API)
+
+#include <boost/system/detail/system_category_condition_win32.hpp>
+
+inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const noexcept
+{
+    int e2 = system_category_condition_win32( ev );
+
+    if( e2 == -1 )
+    {
+        return error_condition( ev, *this );
+    }
+    else
+    {
+        return error_condition( boost::system::detail::generic_value_tag( e2 ) );
+    }
+}
+
+#else // #if defined(BOOST_WINDOWS_API)
+
+inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const noexcept
+{
+    return error_condition( boost::system::detail::generic_value_tag( ev ) );
+}
+
+#endif // #if defined(BOOST_WINDOWS_API)
+
+inline std::string boost::system::detail::system_error_category::message( int ev ) const
+{
+    return system_error_category_message( ev );
+}
+
+inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
+{
+    return system_error_category_message( ev, buffer, len );
+}
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_IMPL_HPP_INCLUDED

include/boost/system/detail/system_category_message.hpp

@@ -0,0 +1,71 @@
+#ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_HPP_INCLUDED
+
+// Implementation of system_error_category_message
+//
+// Copyright 2018, 2022 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/api_config.hpp>
+
+#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API)
+#  error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
+#endif
+
+#if defined(BOOST_WINDOWS_API)
+
+#include <boost/system/detail/system_category_message_win32.hpp>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+inline std::string system_error_category_message( int ev )
+{
+    return system_category_message_win32( ev );
+}
+
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+{
+    return system_category_message_win32( ev, buffer, len );
+}
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#else // #if defined(BOOST_WINDOWS_API)
+
+#include <boost/system/detail/generic_category_message.hpp>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+inline std::string system_error_category_message( int ev )
+{
+    return generic_error_category_message( ev );
+}
+
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+{
+    return generic_error_category_message( ev, buffer, len );
+}
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #if defined(BOOST_WINDOWS_API)
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_HPP_INCLUDED

include/boost/system/detail/system_category_message_win32.hpp

@@ -0,0 +1,211 @@
+#ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_WIN32_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_WIN32_HPP_INCLUDED
+
+// Copyright Beman Dawes 2002, 2006
+// Copyright (c) Microsoft Corporation 2014
+// Copyright 2018, 2020 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/snprintf.hpp>
+#include <boost/winapi/error_handling.hpp>
+#include <boost/winapi/character_code_conversion.hpp>
+#include <boost/winapi/local_memory.hpp>
+#include <boost/config.hpp>
+#include <cstdio>
+
+//
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len )
+{
+    detail::snprintf( buffer, len, "Unknown error (%d)", ev );
+    return buffer;
+}
+
+inline boost::winapi::UINT_ message_cp_win32()
+{
+#if defined(BOOST_SYSTEM_USE_UTF8)
+
+    return boost::winapi::CP_UTF8_;
+
+#else
+
+    return boost::winapi::CP_ACP_;
+
+#endif
+}
+
+inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) noexcept
+{
+    if( len == 0 )
+    {
+        return buffer;
+    }
+
+    if( len == 1 )
+    {
+        buffer[0] = 0;
+        return buffer;
+    }
+
+    boost::winapi::UINT_ const code_page = message_cp_win32();
+
+    int r = 0;
+
+#if !defined(BOOST_NO_ANSI_APIS)
+
+    if( code_page == boost::winapi::CP_ACP_ )
+    {
+        using namespace boost::winapi;
+
+        DWORD_ retval = boost::winapi::FormatMessageA(
+            FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
+            NULL,
+            static_cast<DWORD_>(ev),
+            MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
+            buffer,
+            static_cast<DWORD_>( len ),
+            NULL
+        );
+
+        r = static_cast<int>( retval );
+    }
+    else
+
+#endif
+
+    {
+        using namespace boost::winapi;
+
+        wchar_t * lpMsgBuf = 0;
+
+        DWORD_ retval = boost::winapi::FormatMessageW(
+            FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
+            NULL,
+            static_cast<DWORD_>(ev),
+            MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
+            (LPWSTR_) &lpMsgBuf,
+            0,
+            NULL
+        );
+
+        if( retval != 0 )
+        {
+            r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, buffer, static_cast<int>( len ), NULL, NULL );
+            boost::winapi::LocalFree( lpMsgBuf );
+            if ( r != 0 ) --r; // exclude null terminator
+        }
+    }
+
+    if( r == 0 )
+    {
+        return unknown_message_win32( ev, buffer, len );
+    }
+
+    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
+    {
+        buffer[ --r ] = 0;
+    }
+
+    if( r > 0 && buffer[ r-1 ] == '.' )
+    {
+        buffer[ --r ] = 0;
+    }
+
+    return buffer;
+}
+
+struct local_free
+{
+    void * p_;
+
+    ~local_free()
+    {
+        boost::winapi::LocalFree( p_ );
+    }
+};
+
+inline std::string unknown_message_win32( int ev )
+{
+    char buffer[ 38 ];
+    return unknown_message_win32( ev, buffer, sizeof( buffer ) );
+}
+
+inline std::string system_category_message_win32( int ev )
+{
+    using namespace boost::winapi;
+
+    wchar_t * lpMsgBuf = 0;
+
+    DWORD_ retval = boost::winapi::FormatMessageW(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
+        NULL,
+        static_cast<DWORD_>(ev),
+        MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
+        (LPWSTR_) &lpMsgBuf,
+        0,
+        NULL
+    );
+
+    if( retval == 0 )
+    {
+        return unknown_message_win32( ev );
+    }
+
+    local_free lf_ = { lpMsgBuf };
+    (void)lf_;
+
+    UINT_ const code_page = message_cp_win32();
+
+    int r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, 0, 0, NULL, NULL );
+
+    if( r == 0 )
+    {
+        return unknown_message_win32( ev );
+    }
+
+    std::string buffer( static_cast<std::size_t>(r), char() );
+
+    r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, &buffer[0], r, NULL, NULL );
+
+    if( r == 0 )
+    {
+        return unknown_message_win32( ev );
+    }
+
+    --r; // exclude null terminator
+
+    while( r > 0 && ( buffer[ static_cast<std::size_t>(r)-1 ] == '\n' || buffer[ static_cast<std::size_t>(r)-1 ] == '\r' ) )
+    {
+        --r;
+    }
+
+    if( r > 0 && buffer[ static_cast<std::size_t>(r)-1 ] == '.' )
+    {
+        --r;
+    }
+
+    buffer.resize( r );
+
+    return buffer;
+}
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_WIN32_HPP_INCLUDED

include/boost/system/detail/system_category_posix.hpp

@@ -1,132 +0,0 @@
-// POSIX-specific implementation details of system_error_category
-//
-// Copyright 2018 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)
-//
-// See library home page at http://www.boost.org/libs/system
-
-namespace boost
-{
-
-namespace system
-{
-
-namespace detail
-{
-
-inline bool is_generic_value( int ev ) BOOST_NOEXCEPT
-{
-    using namespace errc;
-
-    static int const gen[] =
-    {
-        success,
-        address_family_not_supported,
-        address_in_use,
-        address_not_available,
-        already_connected,
-        argument_list_too_long,
-        argument_out_of_domain,
-        bad_address,
-        bad_file_descriptor,
-        bad_message,
-        broken_pipe,
-        connection_aborted,
-        connection_already_in_progress,
-        connection_refused,
-        connection_reset,
-        cross_device_link,
-        destination_address_required,
-        device_or_resource_busy,
-        directory_not_empty,
-        executable_format_error,
-        file_exists,
-        file_too_large,
-        filename_too_long,
-        function_not_supported,
-        host_unreachable,
-        identifier_removed,
-        illegal_byte_sequence,
-        inappropriate_io_control_operation,
-        interrupted,
-        invalid_argument,
-        invalid_seek,
-        io_error,
-        is_a_directory,
-        message_size,
-        network_down,
-        network_reset,
-        network_unreachable,
-        no_buffer_space,
-        no_child_process,
-        no_link,
-        no_lock_available,
-        no_message_available,
-        no_message,
-        no_protocol_option,
-        no_space_on_device,
-        no_stream_resources,
-        no_such_device_or_address,
-        no_such_device,
-        no_such_file_or_directory,
-        no_such_process,
-        not_a_directory,
-        not_a_socket,
-        not_a_stream,
-        not_connected,
-        not_enough_memory,
-        not_supported,
-        operation_canceled,
-        operation_in_progress,
-        operation_not_permitted,
-        operation_not_supported,
-        operation_would_block,
-        owner_dead,
-        permission_denied,
-        protocol_error,
-        protocol_not_supported,
-        read_only_file_system,
-        resource_deadlock_would_occur,
-        resource_unavailable_try_again,
-        result_out_of_range,
-        state_not_recoverable,
-        stream_timeout,
-        text_file_busy,
-        timed_out,
-        too_many_files_open_in_system,
-        too_many_files_open,
-        too_many_links,
-        too_many_symbolic_link_levels,
-        value_too_large,
-        wrong_protocol_type
-    };
-
-    int const n = sizeof( gen ) / sizeof( gen[0] );
-
-    for( int i = 0; i < n; ++i )
-    {
-        if( ev == gen[ i ] ) return true;
-    }
-
-    return false;
-}
-
-inline error_condition system_category_default_error_condition_posix( int ev ) BOOST_NOEXCEPT
-{
-    if( is_generic_value( ev ) )
-    {
-        return error_condition( ev, generic_category() );
-    }
-    else
-    {
-        return error_condition( ev, system_category() );
-    }
-}
-
-} // namespace detail
-
-} // namespace system
-
-} // namespace boost

include/boost/system/detail/system_category_win32.hpp

@@ -1,341 +0,0 @@
-// Windows implementation of system_error_category
-//
-// Copyright Beman Dawes 2002, 2006
-// Copyright (c) Microsoft Corporation 2014
-// Copyright 2018 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)
-//
-// See library home page at http://www.boost.org/libs/system
-
-#include <boost/winapi/error_codes.hpp>
-#include <boost/winapi/error_handling.hpp>
-#include <boost/winapi/character_code_conversion.hpp>
-#include <boost/winapi/local_memory.hpp>
-#include <cstdio>
-
-//
-
-namespace boost
-{
-
-namespace system
-{
-
-namespace detail
-{
-
-#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) )
-
-inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len )
-{
-# if defined( BOOST_MSVC )
-#  pragma warning( push )
-#  pragma warning( disable: 4996 )
-# endif
-
-    _snprintf( buffer, len - 1, "Unknown error (%d)", ev );
-
-    buffer[ len - 1 ] = 0;
-    return buffer;
-
-# if defined( BOOST_MSVC )
-#  pragma warning( pop )
-# endif
-}
-
-#else
-
-inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len )
-{
-    std::snprintf( buffer, len, "Unknown error (%d)", ev );
-    return buffer;
-}
-
-#endif
-
-inline boost::winapi::UINT_ message_cp_win32()
-{
-#if defined(BOOST_SYSTEM_USE_UTF8)
-
-    return boost::winapi::CP_UTF8_;
-
-#else
-
-    return boost::winapi::CP_ACP_;
-
-#endif
-}
-
-inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
-{
-    if( len == 0 )
-    {
-        return buffer;
-    }
-
-    if( len == 1 )
-    {
-        buffer[0] = 0;
-        return buffer;
-    }
-
-    boost::winapi::UINT_ const code_page = message_cp_win32();
-
-    int r = 0;
-
-#if !defined(BOOST_NO_ANSI_APIS)
-
-    if( code_page == boost::winapi::CP_ACP_ )
-    {
-        using namespace boost::winapi;
-
-        DWORD_ retval = boost::winapi::FormatMessageA(
-            FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
-            NULL,
-            ev,
-            MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
-            buffer,
-            static_cast<DWORD_>( len ),
-            NULL
-        );
-
-        r = static_cast<int>( retval );
-    }
-    else
-
-#endif
-
-    {
-        using namespace boost::winapi;
-
-        wchar_t * lpMsgBuf = 0;
-
-        DWORD_ retval = boost::winapi::FormatMessageW(
-            FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
-            NULL,
-            ev,
-            MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
-            (LPWSTR_) &lpMsgBuf,
-            0,
-            NULL
-        );
-
-        if( retval != 0 )
-        {
-            r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, buffer, static_cast<int>( len ), NULL, NULL );
-            boost::winapi::LocalFree( lpMsgBuf );
-            if ( r != 0 ) --r; // exclude null terminator
-        }
-    }
-
-    if( r == 0 )
-    {
-        return unknown_message_win32( ev, buffer, len );
-    }
-
-    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
-    {
-        buffer[ --r ] = 0;
-    }
-
-    if( r > 0 && buffer[ r-1 ] == '.' )
-    {
-        buffer[ --r ] = 0;
-    }
-
-    return buffer;
-}
-
-struct local_free
-{
-    void * p_;
-
-    ~local_free()
-    {
-        boost::winapi::LocalFree( p_ );
-    }
-};
-
-inline std::string unknown_message_win32( int ev )
-{
-    char buffer[ 38 ];
-    return unknown_message_win32( ev, buffer, sizeof( buffer ) );
-}
-
-inline std::string system_category_message_win32( int ev )
-{
-    using namespace boost::winapi;
-
-    wchar_t * lpMsgBuf = 0;
-
-    DWORD_ retval = boost::winapi::FormatMessageW(
-        FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
-        NULL,
-        ev,
-        MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
-        (LPWSTR_) &lpMsgBuf,
-        0,
-        NULL
-    );
-
-    if( retval == 0 )
-    {
-        return unknown_message_win32( ev );
-    }
-
-    local_free lf_ = { lpMsgBuf };
-    (void)lf_;
-
-    UINT_ const code_page = message_cp_win32();
-
-    int r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, 0, 0, NULL, NULL );
-
-    if( r == 0 )
-    {
-        return unknown_message_win32( ev );
-    }
-
-    std::string buffer( r, char() );
-
-    r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, &buffer[0], r, NULL, NULL );
-
-    if( r == 0 )
-    {
-        return unknown_message_win32( ev );
-    }
-
-    --r; // exclude null terminator
-
-    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
-    {
-        --r;
-    }
-
-    if( r > 0 && buffer[ r-1 ] == '.' )
-    {
-        --r;
-    }
-
-    buffer.resize( r );
-
-    return buffer;
-}
-
-inline error_condition system_category_default_error_condition_win32( int ev ) BOOST_NOEXCEPT
-{
-    // When using the Windows Runtime, most system errors are reported as HRESULTs.
-    // We want to map the common Win32 errors to their equivalent error condition,
-    // whether or not they are reported via an HRESULT.
-
-#define BOOST_SYSTEM_FAILED(hr)           ((hr) < 0)
-#define BOOST_SYSTEM_HRESULT_FACILITY(hr) (((hr) >> 16) & 0x1fff)
-#define BOOST_SYSTEM_HRESULT_CODE(hr)     ((hr) & 0xFFFF)
-#define BOOST_SYSTEM_FACILITY_WIN32       7
-
-    if( BOOST_SYSTEM_FAILED( ev ) && BOOST_SYSTEM_HRESULT_FACILITY( ev ) == BOOST_SYSTEM_FACILITY_WIN32 )
-    {
-        ev = BOOST_SYSTEM_HRESULT_CODE( ev );
-    }
-
-#undef BOOST_SYSTEM_FAILED
-#undef BOOST_SYSTEM_HRESULT_FACILITY
-#undef BOOST_SYSTEM_HRESULT_CODE
-#undef BOOST_SYSTEM_FACILITY_WIN32
-
-    using namespace boost::winapi;
-    using namespace errc;
-
-    // Windows system -> posix_errno decode table
-    // see WinError.h comments for descriptions of errors
-
-    switch ( ev )
-    {
-    case 0: return make_error_condition( success );
-
-    case ERROR_ACCESS_DENIED_: return make_error_condition( permission_denied );
-    case ERROR_ALREADY_EXISTS_: return make_error_condition( file_exists );
-    case ERROR_BAD_UNIT_: return make_error_condition( no_such_device );
-    case ERROR_BUFFER_OVERFLOW_: return make_error_condition( filename_too_long );
-    case ERROR_BUSY_: return make_error_condition( device_or_resource_busy );
-    case ERROR_BUSY_DRIVE_: return make_error_condition( device_or_resource_busy );
-    case ERROR_CANNOT_MAKE_: return make_error_condition( permission_denied );
-    case ERROR_CANTOPEN_: return make_error_condition( io_error );
-    case ERROR_CANTREAD_: return make_error_condition( io_error );
-    case ERROR_CANTWRITE_: return make_error_condition( io_error );
-    case ERROR_CONNECTION_ABORTED_: return make_error_condition( connection_aborted );
-    case ERROR_CURRENT_DIRECTORY_: return make_error_condition( permission_denied );
-    case ERROR_DEV_NOT_EXIST_: return make_error_condition( no_such_device );
-    case ERROR_DEVICE_IN_USE_: return make_error_condition( device_or_resource_busy );
-    case ERROR_DIR_NOT_EMPTY_: return make_error_condition( directory_not_empty );
-    case ERROR_DIRECTORY_: return make_error_condition( invalid_argument ); // WinError.h: "The directory name is invalid"
-    case ERROR_DISK_FULL_: return make_error_condition( no_space_on_device );
-    case ERROR_FILE_EXISTS_: return make_error_condition( file_exists );
-    case ERROR_FILE_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
-    case ERROR_HANDLE_DISK_FULL_: return make_error_condition( no_space_on_device );
-    case ERROR_INVALID_ACCESS_: return make_error_condition( permission_denied );
-    case ERROR_INVALID_DRIVE_: return make_error_condition( no_such_device );
-    case ERROR_INVALID_FUNCTION_: return make_error_condition( function_not_supported );
-    case ERROR_INVALID_HANDLE_: return make_error_condition( invalid_argument );
-    case ERROR_INVALID_NAME_: return make_error_condition( invalid_argument );
-    case ERROR_LOCK_VIOLATION_: return make_error_condition( no_lock_available );
-    case ERROR_LOCKED_: return make_error_condition( no_lock_available );
-    case ERROR_NEGATIVE_SEEK_: return make_error_condition( invalid_argument );
-    case ERROR_NOACCESS_: return make_error_condition( permission_denied );
-    case ERROR_NOT_ENOUGH_MEMORY_: return make_error_condition( not_enough_memory );
-    case ERROR_NOT_READY_: return make_error_condition( resource_unavailable_try_again );
-    case ERROR_NOT_SAME_DEVICE_: return make_error_condition( cross_device_link );
-    case ERROR_OPEN_FAILED_: return make_error_condition( io_error );
-    case ERROR_OPEN_FILES_: return make_error_condition( device_or_resource_busy );
-    case ERROR_OPERATION_ABORTED_: return make_error_condition( operation_canceled );
-    case ERROR_OUTOFMEMORY_: return make_error_condition( not_enough_memory );
-    case ERROR_PATH_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
-    case ERROR_READ_FAULT_: return make_error_condition( io_error );
-    case ERROR_RETRY_: return make_error_condition( resource_unavailable_try_again );
-    case ERROR_SEEK_: return make_error_condition( io_error );
-    case ERROR_SHARING_VIOLATION_: return make_error_condition( permission_denied );
-    case ERROR_TOO_MANY_OPEN_FILES_: return make_error_condition( too_many_files_open );
-    case ERROR_WRITE_FAULT_: return make_error_condition( io_error );
-    case ERROR_WRITE_PROTECT_: return make_error_condition( permission_denied );
-    case WSAEACCES_: return make_error_condition( permission_denied );
-    case WSAEADDRINUSE_: return make_error_condition( address_in_use );
-    case WSAEADDRNOTAVAIL_: return make_error_condition( address_not_available );
-    case WSAEAFNOSUPPORT_: return make_error_condition( address_family_not_supported );
-    case WSAEALREADY_: return make_error_condition( connection_already_in_progress );
-    case WSAEBADF_: return make_error_condition( bad_file_descriptor );
-    case WSAECONNABORTED_: return make_error_condition( connection_aborted );
-    case WSAECONNREFUSED_: return make_error_condition( connection_refused );
-    case WSAECONNRESET_: return make_error_condition( connection_reset );
-    case WSAEDESTADDRREQ_: return make_error_condition( destination_address_required );
-    case WSAEFAULT_: return make_error_condition( bad_address );
-    case WSAEHOSTUNREACH_: return make_error_condition( host_unreachable );
-    case WSAEINPROGRESS_: return make_error_condition( operation_in_progress );
-    case WSAEINTR_: return make_error_condition( interrupted );
-    case WSAEINVAL_: return make_error_condition( invalid_argument );
-    case WSAEISCONN_: return make_error_condition( already_connected );
-    case WSAEMFILE_: return make_error_condition( too_many_files_open );
-    case WSAEMSGSIZE_: return make_error_condition( message_size );
-    case WSAENAMETOOLONG_: return make_error_condition( filename_too_long );
-    case WSAENETDOWN_: return make_error_condition( network_down );
-    case WSAENETRESET_: return make_error_condition( network_reset );
-    case WSAENETUNREACH_: return make_error_condition( network_unreachable );
-    case WSAENOBUFS_: return make_error_condition( no_buffer_space );
-    case WSAENOPROTOOPT_: return make_error_condition( no_protocol_option );
-    case WSAENOTCONN_: return make_error_condition( not_connected );
-    case WSAENOTSOCK_: return make_error_condition( not_a_socket );
-    case WSAEOPNOTSUPP_: return make_error_condition( operation_not_supported );
-    case WSAEPROTONOSUPPORT_: return make_error_condition( protocol_not_supported );
-    case WSAEPROTOTYPE_: return make_error_condition( wrong_protocol_type );
-    case WSAETIMEDOUT_: return make_error_condition( timed_out );
-    case WSAEWOULDBLOCK_: return make_error_condition( operation_would_block );
-
-    default: return error_condition( ev, system_category() );
-    }
-}
-
-} // namespace detail
-
-} // namespace system
-
-} // namespace boost

include/boost/system/detail/throws.hpp

@@ -0,0 +1,59 @@
+#ifndef BOOST_SYSTEM_DETAIL_THROWS_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_THROWS_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+namespace boost
+{
+
+namespace system
+{
+
+class error_code;
+
+} // namespace system
+
+// boost::throws()
+
+namespace detail
+{
+
+//  Misuse of the error_code object is turned into a noisy failure by
+//  poisoning the reference. This particular implementation doesn't
+//  produce warnings or errors from popular compilers, is very efficient
+//  (as determined by inspecting generated code), and does not suffer
+//  from order of initialization problems. In practice, it also seems
+//  cause user function error handling implementation errors to be detected
+//  very early in the development cycle.
+
+inline system::error_code* throws()
+{
+    // See github.com/boostorg/system/pull/12 by visigoth for why the return
+    // is poisoned with nonzero rather than (0). A test, test_throws_usage(),
+    // has been added to error_code_test.cpp, and as visigoth mentioned it
+    // fails on clang for release builds with a return of 0 but works fine
+    // with (1).
+    // Since the undefined behavior sanitizer (-fsanitize=undefined) does not
+    // allow a reference to be formed to the unaligned address of (1), we use
+    // (8) instead.
+
+    return reinterpret_cast<system::error_code*>(8);
+}
+
+} // namespace detail
+
+inline system::error_code& throws()
+{
+    return *detail::throws();
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_THROWS_HPP_INCLUDED

include/boost/system/errc.hpp

@@ -0,0 +1,57 @@
+#ifndef BOOST_SYSTEM_ERRC_HPP_INCLUDED
+#define BOOST_SYSTEM_ERRC_HPP_INCLUDED
+
+// Copyright Beman Dawes 2006, 2007
+// Copyright Christoper Kohlhoff 2007
+// Copyright Peter Dimov 2017, 2018, 2020
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/errc.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/detail/error_condition.hpp>
+#include <boost/system/detail/generic_category.hpp>
+#include <boost/system/detail/error_category_impl.hpp>
+#include <boost/system/detail/config.hpp>
+#include <boost/assert/source_location.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+namespace system
+{
+
+// make_* functions for errc::errc_t
+
+namespace errc
+{
+
+// explicit conversion:
+BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) noexcept
+{
+    return error_code( e, generic_category() );
+}
+
+// explicit conversion:
+inline error_code make_error_code( errc_t e, boost::source_location const * loc ) noexcept
+{
+    return error_code( e, generic_category(), loc );
+}
+
+// implicit conversion:
+BOOST_SYSTEM_CONSTEXPR inline error_condition make_error_condition( errc_t e ) noexcept
+{
+    return error_condition( e, generic_category() );
+}
+
+} // namespace errc
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_ERRC_HPP_INCLUDED

include/boost/system/error_category.hpp

@@ -0,0 +1,13 @@
+#ifndef BOOST_SYSTEM_ERROR_CATEGORY_HPP_INCLUDED
+#define BOOST_SYSTEM_ERROR_CATEGORY_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_category.hpp>
+#include <boost/system/detail/error_category_impl.hpp>
+
+#endif // #ifndef BOOST_SYSTEM_ERROR_CATEGORY_HPP_INCLUDED

include/boost/system/error_code.hpp

@@ -10,959 +10,12 @@
 //
 //  See library home page at http://www.boost.org/libs/system
 
-#include <boost/system/api_config.hpp>
-#include <boost/system/detail/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/config.hpp>
-#include <ostream>
-#include <string>
-#include <functional>
-#include <cstring>
-
-// TODO: undef these macros if not already defined
-#include <boost/cerrno.hpp>
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-# include <system_error>
-#endif
-
-#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API)
-#  error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
-#endif
-
-namespace boost
-{
-
-namespace system
-{
-
-class error_code;         // values defined by the operating system
-class error_condition;    // portable generic values defined below, but ultimately
-                          // based on the POSIX standard
-
-// "Concept" helpers
-
-template<class T> struct is_error_code_enum
-{
-    static const bool value = false;
-};
-
-template<class T> struct is_error_condition_enum
-{
-    static const bool value = false;
-};
-
-// Generic error_conditions
-
-namespace errc
-{
-
-enum errc_t
-{
-    success = 0,
-    address_family_not_supported = EAFNOSUPPORT,
-    address_in_use = EADDRINUSE,
-    address_not_available = EADDRNOTAVAIL,
-    already_connected = EISCONN,
-    argument_list_too_long = E2BIG,
-    argument_out_of_domain = EDOM,
-    bad_address = EFAULT,
-    bad_file_descriptor = EBADF,
-    bad_message = EBADMSG,
-    broken_pipe = EPIPE,
-    connection_aborted = ECONNABORTED,
-    connection_already_in_progress = EALREADY,
-    connection_refused = ECONNREFUSED,
-    connection_reset = ECONNRESET,
-    cross_device_link = EXDEV,
-    destination_address_required = EDESTADDRREQ,
-    device_or_resource_busy = EBUSY,
-    directory_not_empty = ENOTEMPTY,
-    executable_format_error = ENOEXEC,
-    file_exists = EEXIST,
-    file_too_large = EFBIG,
-    filename_too_long = ENAMETOOLONG,
-    function_not_supported = ENOSYS,
-    host_unreachable = EHOSTUNREACH,
-    identifier_removed = EIDRM,
-    illegal_byte_sequence = EILSEQ,
-    inappropriate_io_control_operation = ENOTTY,
-    interrupted = EINTR,
-    invalid_argument = EINVAL,
-    invalid_seek = ESPIPE,
-    io_error = EIO,
-    is_a_directory = EISDIR,
-    message_size = EMSGSIZE,
-    network_down = ENETDOWN,
-    network_reset = ENETRESET,
-    network_unreachable = ENETUNREACH,
-    no_buffer_space = ENOBUFS,
-    no_child_process = ECHILD,
-    no_link = ENOLINK,
-    no_lock_available = ENOLCK,
-    no_message_available = ENODATA,
-    no_message = ENOMSG,
-    no_protocol_option = ENOPROTOOPT,
-    no_space_on_device = ENOSPC,
-    no_stream_resources = ENOSR,
-    no_such_device_or_address = ENXIO,
-    no_such_device = ENODEV,
-    no_such_file_or_directory = ENOENT,
-    no_such_process = ESRCH,
-    not_a_directory = ENOTDIR,
-    not_a_socket = ENOTSOCK,
-    not_a_stream = ENOSTR,
-    not_connected = ENOTCONN,
-    not_enough_memory = ENOMEM,
-    not_supported = ENOTSUP,
-    operation_canceled = ECANCELED,
-    operation_in_progress = EINPROGRESS,
-    operation_not_permitted = EPERM,
-    operation_not_supported = EOPNOTSUPP,
-    operation_would_block = EWOULDBLOCK,
-    owner_dead = EOWNERDEAD,
-    permission_denied = EACCES,
-    protocol_error = EPROTO,
-    protocol_not_supported = EPROTONOSUPPORT,
-    read_only_file_system = EROFS,
-    resource_deadlock_would_occur = EDEADLK,
-    resource_unavailable_try_again = EAGAIN,
-    result_out_of_range = ERANGE,
-    state_not_recoverable = ENOTRECOVERABLE,
-    stream_timeout = ETIME,
-    text_file_busy = ETXTBSY,
-    timed_out = ETIMEDOUT,
-    too_many_files_open_in_system = ENFILE,
-    too_many_files_open = EMFILE,
-    too_many_links = EMLINK,
-    too_many_symbolic_link_levels = ELOOP,
-    value_too_large = EOVERFLOW,
-    wrong_protocol_type = EPROTOTYPE
-};
-
-} // namespace errc
-
-#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
-
-namespace posix = errc;
-namespace posix_error = errc;
-
-#endif
-
-template<> struct is_error_condition_enum<errc::errc_t>
-{
-    static const bool value = true;
-};
-
-// class error_category
-#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-#endif
-
-#ifdef BOOST_MSVC
-#pragma warning( push )
-// 'this' : used in base member initializer list
-#pragma warning( disable: 4355 )
-#endif
-
-std::size_t hash_value( error_code const & ec );
-
-class BOOST_SYMBOL_VISIBLE error_category
-{
-private:
-
-    friend std::size_t hash_value( error_code const & ec );
-
-#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
-public:
-
-    error_category( error_category const & ) = delete;
-    error_category& operator=( error_category const & ) = delete;
-
-#else
-private:
-
-    error_category( error_category const & );
-    error_category& operator=( error_category const & );
-
-#endif
-
-private:
-
-    boost::ulong_long_type id_;
-
-protected:
-
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
-
-    ~error_category() = default;
-
-#else
-
-    // We'd like to make the destructor protected, to make code that deletes
-    // an error_category* not compile; unfortunately, doing the below makes
-    // the destructor user-provided and hence breaks use after main, as the
-    // categories may get destroyed before code that uses them
-
-    // ~error_category() {}
-
-#endif
-
-    BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 )
-    {
-    }
-
-    explicit BOOST_SYSTEM_CONSTEXPR error_category( boost::ulong_long_type id ) BOOST_NOEXCEPT: id_( id )
-    {
-    }
-
-public:
-
-    virtual const char * name() const BOOST_NOEXCEPT = 0;
-
-    virtual error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT;
-    virtual bool equivalent( int code, const error_condition & condition ) const BOOST_NOEXCEPT;
-    virtual bool equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT;
-
-    virtual std::string message( int ev ) const = 0;
-    virtual char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT;
-
-    virtual bool failed( int ev ) const BOOST_NOEXCEPT;
-
-    BOOST_SYSTEM_CONSTEXPR bool operator==( const error_category & rhs ) const BOOST_NOEXCEPT
-    {
-        return rhs.id_ == 0? this == &rhs: id_ == rhs.id_;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR bool operator!=( const error_category & rhs ) const BOOST_NOEXCEPT
-    {
-        return !( *this == rhs );
-    }
-
-    BOOST_SYSTEM_CONSTEXPR bool operator<( const error_category & rhs ) const BOOST_NOEXCEPT
-    {
-        if( id_ < rhs.id_ )
-        {
-            return true;
-        }
-
-        if( id_ > rhs.id_ )
-        {
-            return false;
-        }
-
-        if( rhs.id_ != 0 )
-        {
-            return false; // equal
-        }
-
-        return std::less<error_category const *>()( this, &rhs );
-    }
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-    operator std::error_category const & () const;
-
-#endif
-};
-
-#ifdef BOOST_MSVC
-#pragma warning( pop )
-#endif
-
-// predefined error categories
-
-namespace detail
-{
-
-class BOOST_SYMBOL_VISIBLE generic_error_category: public error_category
-{
-public:
-
-    // clang++ 3.8 and below: initialization of const object
-    // requires a user-provided default constructor
-    BOOST_SYSTEM_CONSTEXPR generic_error_category() BOOST_NOEXCEPT:
-        error_category( ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDF0D )
-    {
-    }
-
-    const char * name() const BOOST_NOEXCEPT
-    {
-        return "generic";
-    }
-
-    std::string message( int ev ) const;
-    char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT;
-};
-
-class BOOST_SYMBOL_VISIBLE system_error_category: public error_category
-{
-public:
-
-    BOOST_SYSTEM_CONSTEXPR system_error_category() BOOST_NOEXCEPT:
-        error_category( ( boost::ulong_long_type( 0x8FAFD21E ) << 32 ) + 0x25C5E09B )
-    {
-    }
-
-    const char * name() const BOOST_NOEXCEPT
-    {
-        return "system";
-    }
-
-    error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT;
-
-    std::string message( int ev ) const;
-    char const * message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT;
-};
-
-} // namespace detail
-
-#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
-#pragma GCC diagnostic pop
-#endif
-
-// generic_category(), system_category()
-
-#if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
-
-namespace detail
-{
-
-template<class T> struct BOOST_SYMBOL_VISIBLE cat_holder
-{
-    static constexpr system_error_category system_category_instance{};
-    static constexpr generic_error_category generic_category_instance{};
-};
-
-template<class T> constexpr system_error_category cat_holder<T>::system_category_instance;
-template<class T> constexpr generic_error_category cat_holder<T>::generic_category_instance;
-
-} // namespace detail
-
-constexpr error_category const & system_category() BOOST_NOEXCEPT
-{
-    return detail::cat_holder<void>::system_category_instance;
-}
-
-constexpr error_category const & generic_category() BOOST_NOEXCEPT
-{
-    return detail::cat_holder<void>::generic_category_instance;
-}
-
-#else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
-
-inline error_category const & system_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
-
-inline error_category const & system_category() BOOST_NOEXCEPT
-{
-    static const detail::system_error_category system_category_instance;
-    return system_category_instance;
-}
-
-inline error_category const & generic_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
-
-inline error_category const & generic_category() BOOST_NOEXCEPT
-{
-    static const detail::generic_error_category generic_category_instance;
-    return generic_category_instance;
-}
-
-#endif // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
-
-// deprecated synonyms
-
-#ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
-
-inline const error_category & get_system_category() { return system_category(); }
-inline const error_category & get_generic_category() { return generic_category(); }
-inline const error_category & get_posix_category() { return generic_category(); }
-static const error_category & posix_category BOOST_ATTRIBUTE_UNUSED = generic_category();
-static const error_category & errno_ecat BOOST_ATTRIBUTE_UNUSED = generic_category();
-static const error_category & native_ecat BOOST_ATTRIBUTE_UNUSED = system_category();
-
-#endif
-
-// enable_if
-
-namespace detail
-{
-
-template<bool C, class T = void> struct enable_if
-{
-    typedef T type;
-};
-
-template<class T> struct enable_if<false, T>
-{
-};
-
-// failed_impl
-
-#if !defined(BOOST_SYSTEM_HAS_CONSTEXPR)
-
-inline bool failed_impl( int ev, error_category const & cat )
-{
-    return cat.failed( ev );
-}
-
-#else
-
-BOOST_SYSTEM_CONSTEXPR inline bool failed_impl( int ev, error_category const & cat )
-{
-    if( cat == system_category() || cat == generic_category() )
-    {
-        return ev != 0;
-    }
-    else
-    {
-        return cat.failed( ev );
-    }
-}
-
-#endif
-
-} // namespace detail
-
-// class error_condition
-
-// error_conditions are portable, error_codes are system or library specific
-
-class error_condition
-{
-private:
-
-    int val_;
-    bool failed_;
-    error_category const * cat_;
-
-public:
-
-    // constructors:
-
-    BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_NOEXCEPT:
-        val_( 0 ), failed_( false ), cat_( &generic_category() )
-    {
-    }
-
-    BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) BOOST_NOEXCEPT:
-        val_( val ), failed_( detail::failed_impl( val, cat ) ), cat_( &cat )
-    {
-    }
-
-    template<class ErrorConditionEnum> BOOST_SYSTEM_CONSTEXPR error_condition( ErrorConditionEnum e,
-        typename detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type* = 0) BOOST_NOEXCEPT
-    {
-        *this = make_error_condition( e );
-    }
-
-    // modifiers:
-
-    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT
-    {
-        val_ = val;
-        failed_ = detail::failed_impl( val, cat );
-        cat_ = &cat;
-    }
-
-    template<typename ErrorConditionEnum>
-        BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
-        operator=( ErrorConditionEnum val ) BOOST_NOEXCEPT
-    {
-        *this = make_error_condition( val );
-        return *this;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
-    {
-        val_ = 0;
-        failed_ = false;
-        cat_ = &generic_category();
-    }
-
-    // observers:
-
-    BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT
-    {
-        return val_;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT
-    {
-        return *cat_;
-    }
-
-    std::string message() const
-    {
-        return cat_->message( value() );
-    }
-
-    char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
-    {
-        return cat_->message( value(), buffer, len );
-    }
-
-    BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
-    {
-        return failed_;
-    }
-
-#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-
-    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT  // true if error
-    {
-        return val_ != 0;
-    }
-
-#else
-
-    typedef void (*unspecified_bool_type)();
-    static void unspecified_bool_true() {}
-
-    BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const BOOST_NOEXCEPT  // true if error
-    {
-        return val_ != 0? unspecified_bool_true: 0;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT  // true if no error
-    {
-        return val_ == 0;
-    }
-
-#endif
-
-    // relationals:
-    //  the more symmetrical non-member syntax allows enum
-    //  conversions work for both rhs and lhs.
-
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
-    {
-        return lhs.val_ == rhs.val_ && *lhs.cat_ == *rhs.cat_;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
-    {
-        return *lhs.cat_ < *rhs.cat_ || ( *lhs.cat_ == *rhs.cat_ && lhs.val_ < rhs.val_ );
-    }
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-    operator std::error_condition () const
-    {
-        return std::error_condition( value(), category() );
-    }
-
-#endif
-};
-
-//  class error_code
-
-//  We want error_code to be a value type that can be copied without slicing
-//  and without requiring heap allocation, but we also want it to have
-//  polymorphic behavior based on the error category. This is achieved by
-//  abstract base class error_category supplying the polymorphic behavior,
-//  and error_code containing a pointer to an object of a type derived
-//  from error_category.
-
-class error_code
-{
-private:
-
-    int val_;
-    bool failed_;
-    const error_category * cat_;
-
-public:
-
-    // constructors:
-
-    BOOST_SYSTEM_CONSTEXPR error_code() BOOST_NOEXCEPT:
-        val_( 0 ), failed_( false ), cat_( &system_category() )
-    {
-    }
-
-    BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) BOOST_NOEXCEPT:
-        val_( val ), failed_( detail::failed_impl( val, cat ) ), cat_( &cat )
-    {
-    }
-
-    template<class ErrorCodeEnum> BOOST_SYSTEM_CONSTEXPR error_code( ErrorCodeEnum e,
-        typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type* = 0 ) BOOST_NOEXCEPT
-    {
-        *this = make_error_code( e );
-    }
-
-    // modifiers:
-
-    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT
-    {
-        val_ = val;
-        failed_ = detail::failed_impl( val, cat );
-        cat_ = &cat;
-    }
-
-    template<typename ErrorCodeEnum>
-        BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
-        operator=( ErrorCodeEnum val ) BOOST_NOEXCEPT
-    {
-        *this = make_error_code( val );
-        return *this;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
-    {
-        val_ = 0;
-        failed_ = false;
-        cat_ = &system_category();
-    }
-
-    // observers:
-
-    BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT
-    {
-        return val_;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT
-    {
-        return *cat_;
-    }
-
-    error_condition default_error_condition() const BOOST_NOEXCEPT
-    {
-        return cat_->default_error_condition( value() );
-    }
-
-    std::string message() const
-    {
-        return cat_->message( value() );
-    }
-
-    char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
-    {
-        return cat_->message( value(), buffer, len );
-    }
-
-    BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
-    {
-        return failed_;
-    }
-
-#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-
-    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT  // true if error
-    {
-        return val_ != 0;
-    }
-
-#else
-
-    typedef void (*unspecified_bool_type)();
-    static void unspecified_bool_true() {}
-
-    BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const  BOOST_NOEXCEPT // true if error
-    {
-        return val_ != 0? unspecified_bool_true: 0;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error
-    {
-        return val_ == 0;
-    }
-
-#endif
-
-    // relationals:
-
-    //  the more symmetrical non-member syntax allows enum
-    //  conversions work for both rhs and lhs.
-
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT
-    {
-        return lhs.val_ == rhs.val_ && *lhs.cat_ == *rhs.cat_;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT
-    {
-        return *lhs.cat_ < *rhs.cat_ || ( *lhs.cat_ == *rhs.cat_ && lhs.val_ < rhs.val_ );
-    }
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-    operator std::error_code () const
-    {
-        return std::error_code( value(), category() );
-    }
-
-#endif
-};
-
-}  // namespace system
-
-// boost::throws()
-
-namespace detail
-{
-
-//  Misuse of the error_code object is turned into a noisy failure by
-//  poisoning the reference. This particular implementation doesn't
-//  produce warnings or errors from popular compilers, is very efficient
-//  (as determined by inspecting generated code), and does not suffer
-//  from order of initialization problems. In practice, it also seems
-//  cause user function error handling implementation errors to be detected
-//  very early in the development cycle.
-
-inline system::error_code* throws()
-{
-    // See github.com/boostorg/system/pull/12 by visigoth for why the return
-    // is poisoned with nonzero rather than (0). A test, test_throws_usage(),
-    // has been added to error_code_test.cpp, and as visigoth mentioned it
-    // fails on clang for release builds with a return of 0 but works fine
-    // with (1).
-    // Since the undefined behavior sanitizer (-fsanitize=undefined) does not
-    // allow a reference to be formed to the unaligned address of (1), we use
-    // (8) instead.
-
-    return reinterpret_cast<system::error_code*>(8);
-}
-
-} // namespace detail
-
-inline system::error_code& throws()
-{
-    return *detail::throws();
-}
-
-// non-member functions of error_code and error_condition
-
-namespace system
-{
-
-BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT
-{
-    return !( lhs == rhs );
-}
-
-BOOST_SYSTEM_CONSTEXPR inline bool operator!=( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
-{
-    return !( lhs == rhs );
-}
-
-inline bool operator==( const error_code & code, const error_condition & condition ) BOOST_NOEXCEPT
-{
-    return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
-}
-
-inline bool operator!=( const error_code & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
-{
-    return !( lhs == rhs );
-}
-
-inline bool operator==( const error_condition & condition, const error_code & code ) BOOST_NOEXCEPT
-{
-    return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
-}
-
-inline bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_NOEXCEPT
-{
-    return !( lhs == rhs );
-}
-
-template <class charT, class traits>
-    inline std::basic_ostream<charT,traits>&
-    operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
-{
-    os << ec.category().name() << ':' << ec.value();
-    return os;
-}
-
-inline std::size_t hash_value( error_code const & ec )
-{
-    error_category const & cat = ec.category();
-
-    boost::ulong_long_type id = cat.id_;
-
-    if( id == 0 )
-    {
-        id = reinterpret_cast<boost::uintptr_t>( &cat );
-    }
-
-    boost::ulong_long_type hv = ( boost::ulong_long_type( 0xCBF29CE4 ) << 32 ) + 0x84222325;
-    boost::ulong_long_type const prime = ( boost::ulong_long_type( 0x00000100 ) << 32 ) + 0x000001B3;
-
-    // id
-
-    hv ^= id;
-    hv *= prime;
-
-    // value
-
-    hv ^= static_cast<unsigned>( ec.value() );
-    hv *= prime;
-
-    return static_cast<std::size_t>( hv );
-}
-
-// make_* functions for errc::errc_t
-
-namespace errc
-{
-
-// explicit conversion:
-BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) BOOST_NOEXCEPT
-{
-    return error_code( e, generic_category() );
-}
-
-// implicit conversion:
-BOOST_SYSTEM_CONSTEXPR inline error_condition make_error_condition( errc_t e ) BOOST_NOEXCEPT
-{
-    return error_condition( e, generic_category() );
-}
-
-} // namespace errc
-
-// error_category default implementation
-
-inline error_condition error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
-{
-    return error_condition( ev, *this );
-}
-
-inline bool error_category::equivalent( int code, const error_condition & condition ) const BOOST_NOEXCEPT
-{
-    return default_error_condition( code ) == condition;
-}
-
-inline bool error_category::equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT
-{
-    return *this == code.category() && code.value() == condition;
-}
-
-inline char const * error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
-{
-    if( len == 0 )
-    {
-        return buffer;
-    }
-
-    if( len == 1 )
-    {
-        buffer[0] = 0;
-        return buffer;
-    }
-
-#if !defined(BOOST_NO_EXCEPTIONS)
-    try
-#endif
-    {
-        std::string m = this->message( ev );
-
-# if defined( BOOST_MSVC )
-#  pragma warning( push )
-#  pragma warning( disable: 4996 )
-# elif defined(__clang__) && defined(__has_warning)
-#  pragma clang diagnostic push
-#  if __has_warning("-Wdeprecated-declarations")
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#  endif
-# endif
-
-        std::strncpy( buffer, m.c_str(), len - 1 );
-        buffer[ len-1 ] = 0;
-
-# if defined( BOOST_MSVC )
-#  pragma warning( pop )
-# elif defined(__clang__) && defined(__has_warning)
-#  pragma clang diagnostic pop
-# endif
-
-        return buffer;
-    }
-#if !defined(BOOST_NO_EXCEPTIONS)
-    catch( ... )
-    {
-        return "Message text unavailable";
-    }
-#endif
-}
-
-inline bool error_category::failed( int ev ) const BOOST_NOEXCEPT
-{
-    return ev != 0;
-}
-
-} // namespace system
-
-} // namespace boost
-
-// generic_error_category implementation
-
-#include <boost/system/detail/generic_category.hpp>
-
-inline std::string boost::system::detail::generic_error_category::message( int ev ) const
-{
-    return generic_error_category_message( ev );
-}
-
-inline char const * boost::system::detail::generic_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
-{
-    return generic_error_category_message( ev, buffer, len );
-}
-
-// system_error_category implementation
-
-#if defined(BOOST_WINDOWS_API)
-
-#include <boost/system/detail/system_category_win32.hpp>
-
-inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
-{
-    return system_category_default_error_condition_win32( ev );
-}
-
-inline std::string boost::system::detail::system_error_category::message( int ev ) const
-{
-    return system_category_message_win32( ev );
-}
-
-inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
-{
-    return system_category_message_win32( ev, buffer, len );
-}
-
-#else // #if defined(BOOST_WINDOWS_API)
-
-#include <boost/system/detail/system_category_posix.hpp>
-
-inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
-{
-    return system_category_default_error_condition_posix( ev );
-}
-
-inline std::string boost::system::detail::system_error_category::message( int ev ) const
-{
-    return generic_error_category_message( ev );
-}
-
-inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
-{
-    return generic_error_category_message( ev, buffer, len );
-}
-
-#endif // #if defined(BOOST_WINDOWS_API)
-
-// interoperability with std::error_code, std::error_condition
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-#include <boost/system/detail/std_interoperability.hpp>
-
-inline boost::system::error_category::operator std::error_category const & () const
-{
-    return boost::system::detail::to_std_category( *this );
-}
-
-#endif // #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/error_category.hpp>
+#include <boost/system/error_condition.hpp>
+#include <boost/system/errc.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/system/detail/throws.hpp>
 
 #endif // BOOST_SYSTEM_ERROR_CODE_HPP_INCLUDED

include/boost/system/error_condition.hpp

@@ -0,0 +1,13 @@
+#ifndef BOOST_SYSTEM_ERROR_CONDITION_HPP_INCLUDED
+#define BOOST_SYSTEM_ERROR_CONDITION_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_condition.hpp>
+#include <boost/system/detail/error_category_impl.hpp>
+
+#endif // #ifndef BOOST_SYSTEM_ERROR_CONDITION_HPP_INCLUDED

include/boost/system/generic_category.hpp

@@ -0,0 +1,13 @@
+#ifndef BOOST_SYSTEM_GENERIC_CATEGORY_HPP_INCLUDED
+#define BOOST_SYSTEM_GENERIC_CATEGORY_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/generic_category.hpp>
+#include <boost/system/detail/error_category_impl.hpp>
+
+#endif // #ifndef BOOST_SYSTEM_GENERIC_CATEGORY_HPP_INCLUDED

include/boost/system/is_error_code_enum.hpp

@@ -0,0 +1,30 @@
+#ifndef BOOST_SYSTEM_IS_ERROR_CODE_ENUM_HPP_INCLUDED
+#define BOOST_SYSTEM_IS_ERROR_CODE_ENUM_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+namespace boost
+{
+
+namespace system
+{
+
+class error_code;
+
+template<class T> struct is_error_code_enum
+{
+    static const bool value = false;
+};
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_IS_ERROR_CODE_ENUM_HPP_INCLUDED

include/boost/system/is_error_condition_enum.hpp

@@ -0,0 +1,30 @@
+#ifndef BOOST_SYSTEM_IS_ERROR_CONDITION_ENUM_HPP_INCLUDED
+#define BOOST_SYSTEM_IS_ERROR_CONDITION_ENUM_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+namespace boost
+{
+
+namespace system
+{
+
+class error_condition;
+
+template<class T> struct is_error_condition_enum
+{
+    static const bool value = false;
+};
+
+} // namespace system
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_IS_ERROR_CONDITION_ENUM_HPP_INCLUDED

include/boost/system/system_category.hpp

@@ -0,0 +1,14 @@
+#ifndef BOOST_SYSTEM_SYSTEM_CATEGORY_HPP_INCLUDED
+#define BOOST_SYSTEM_SYSTEM_CATEGORY_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/system_category.hpp>
+#include <boost/system/detail/system_category_impl.hpp>
+#include <boost/system/detail/error_category_impl.hpp>
+
+#endif // #ifndef BOOST_SYSTEM_SYSTEM_CATEGORY_HPP_INCLUDED

include/boost/system/system_error.hpp

@@ -1,84 +1,55 @@
-//  Boost system_error.hpp  --------------------------------------------------//
-
-//  Copyright Beman Dawes 2006
-
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
 #ifndef BOOST_SYSTEM_SYSTEM_ERROR_HPP
 #define BOOST_SYSTEM_SYSTEM_ERROR_HPP
 
-#include <boost/system/error_code.hpp>
+// Copyright Beman Dawes 2006
+// Copyright Peter Dimov 2021
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+#include <boost/system/detail/error_code.hpp>
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 namespace boost
 {
-  namespace system
-  {
-    //  class system_error  ------------------------------------------------------------//
+namespace system
+{
 
-    class BOOST_SYMBOL_VISIBLE system_error : public std::runtime_error
-    // BOOST_SYMBOL_VISIBLE is needed by GCC to ensure system_error thrown from a shared
-    // library can be caught. See svn.boost.org/trac/boost/ticket/3697
+class BOOST_SYMBOL_VISIBLE system_error: public std::runtime_error
+{
+private:
+
+    error_code code_;
+
+public:
+
+    explicit system_error( error_code const & ec ):
+        std::runtime_error( ec.what() ), code_( ec ) {}
+
+    system_error( error_code const & ec, std::string const & prefix ):
+        std::runtime_error( prefix + ": " + ec.what() ), code_( ec ) {}
+
+    system_error( error_code const & ec, char const * prefix ):
+        std::runtime_error( std::string( prefix ) + ": " + ec.what() ), code_( ec ) {}
+
+    system_error( int ev, error_category const & ecat ):
+        std::runtime_error( error_code( ev, ecat ).what() ), code_( ev, ecat ) {}
+
+    system_error( int ev, error_category const & ecat, std::string const & prefix ):
+        std::runtime_error( prefix + ": " + error_code( ev, ecat ).what() ), code_( ev, ecat ) {}
+
+    system_error( int ev, error_category const & ecat, char const * prefix ):
+        std::runtime_error( std::string( prefix ) + ": " + error_code( ev, ecat ).what() ), code_( ev, ecat ) {}
+
+    error_code code() const noexcept
     {
-    public:
-      explicit system_error( error_code ec )
-          : std::runtime_error(""), m_error_code(ec) {}
-
-      system_error( error_code ec, const std::string & what_arg )
-          : std::runtime_error(what_arg), m_error_code(ec) {}
-
-      system_error( error_code ec, const char* what_arg )
-          : std::runtime_error(what_arg), m_error_code(ec) {}
-
-      system_error( int ev, const error_category & ecat )
-          : std::runtime_error(""), m_error_code(ev,ecat) {}
-
-      system_error( int ev, const error_category & ecat,
-        const std::string & what_arg )
-          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
-
-      system_error( int ev, const error_category & ecat,
-        const char * what_arg )
-          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
-
-      virtual ~system_error() BOOST_NOEXCEPT_OR_NOTHROW {}
-
-      error_code code() const BOOST_NOEXCEPT { return m_error_code; }
-      const char * what() const BOOST_NOEXCEPT_OR_NOTHROW;
-
-    private:
-      error_code           m_error_code;
-      mutable std::string  m_what;
-    };
-
-    //  implementation  ------------------------------------------------------//
-
-    inline const char * system_error::what() const BOOST_NOEXCEPT_OR_NOTHROW
-    // see http://www.boost.org/more/error_handling.html for lazy build rationale
-    {
-      if ( m_what.empty() )
-      {
-#ifndef BOOST_NO_EXCEPTIONS
-        try
-#endif
-        {
-          m_what = this->std::runtime_error::what();
-          if ( !m_what.empty() ) m_what += ": ";
-          m_what += m_error_code.message();
-        }
-#ifndef BOOST_NO_EXCEPTIONS
-        catch (...) { return std::runtime_error::what(); }
-#endif
-      }
-      return m_what.c_str();
+        return code_;
     }
+};
 
-  } // namespace system
+} // namespace system
 } // namespace boost
 
 #endif // BOOST_SYSTEM_SYSTEM_ERROR_HPP
-
-

include/boost/system/windows_error.hpp

@@ -18,16 +18,6 @@
 #ifdef BOOST_WINDOWS_API
 
 #include <boost/system/error_code.hpp>
-
-//// Neither MinGW or Cygwin versions of winerror.h work if used alone, so on
-//// either of those platforms include the full windows.h
-//
-//#if defined(__MINGW32__) || defined(__CYGWIN__)
-//#include <windows.h>
-//#else
-//#include <winerror.h>
-//#endif
-
 #include <boost/winapi/error_codes.hpp>
 
 namespace boost
@@ -82,7 +72,8 @@ namespace boost
         wrong_disk = boost::winapi::ERROR_WRONG_DISK_,
         sharing_buffer_exceeded = boost::winapi::ERROR_SHARING_BUFFER_EXCEEDED_,
         handle_eof = boost::winapi::ERROR_HANDLE_EOF_,
-        handle_disk_full= boost::winapi::ERROR_HANDLE_DISK_FULL_,
+        handle_disk_full = boost::winapi::ERROR_HANDLE_DISK_FULL_,
+        not_supported = boost::winapi::ERROR_NOT_SUPPORTED_,
         rem_not_list = boost::winapi::ERROR_REM_NOT_LIST_,
         dup_name = boost::winapi::ERROR_DUP_NAME_,
         bad_net_path = boost::winapi::ERROR_BAD_NETPATH_,
@@ -94,7 +85,7 @@ namespace boost
         broken_pipe = boost::winapi::ERROR_BROKEN_PIPE_,
         open_failed = boost::winapi::ERROR_OPEN_FAILED_,
         buffer_overflow = boost::winapi::ERROR_BUFFER_OVERFLOW_,
-        disk_full= boost::winapi::ERROR_DISK_FULL_,
+        disk_full = boost::winapi::ERROR_DISK_FULL_,
         // ...
         lock_failed = boost::winapi::ERROR_LOCK_FAILED_,
         busy = boost::winapi::ERROR_BUSY_,

index.html

@@ -8,8 +8,8 @@ Automatic redirection failed, please go to
 </body>
 </html>
 <!--
-	<EFBFBD> Copyright Beman Dawes, 2001
+	© Copyright Beman Dawes, 2001
 	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
+	https://www.boost.org/LICENSE_1_0.txt
 -->

meta/libraries.json

@@ -4,8 +4,14 @@
     "authors": [
         "Beman Dawes"
     ],
-    "description": "Operating system support, including the diagnostics support that will be part of the C++0x standard library.",
+    "maintainers": [
+        "Peter Dimov <pdimov -at- gmail.com>"
+    ],
+    "description": "Extensible error reporting.",
     "category": [
-        "System"
-    ]
+        "System",
+        "Error-handling",
+        "Programming"
+    ],
+    "cxxstd": "11"
 }

test/CMakeLists.txt

@@ -0,0 +1,179 @@
+# Copyright 2018-2020 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(BoostTest OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
+
+if(NOT HAVE_BOOST_TEST)
+  return()
+endif()
+
+macro(system_run s1)
+
+  string(MAKE_C_IDENTIFIER ${s1} n1)
+
+  boost_test(SOURCES ${s1} ${ARGN})
+  boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_NO_ANSI_APIS NAME ${n1}_no_ansi)
+  boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_SYSTEM_USE_UTF8 NAME ${n1}_utf8)
+  boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_SYSTEM_DISABLE_THREADS NAME ${n1}_nthr)
+
+endmacro()
+
+macro(lib name macro)
+
+  add_library(${name} EXCLUDE_FROM_ALL ${ARGN})
+  target_compile_definitions(${name} PRIVATE $<$<BOOL:BUILD_SHARED_LIBS>:${macro}=1>)
+  target_link_libraries(${name} PRIVATE Boost::system Boost::config)
+
+endmacro()
+
+set(BOOST_TEST_LINK_LIBRARIES Boost::system Boost::core Boost::static_assert)
+
+boost_test(SOURCES quick.cpp)
+
+system_run(error_code_test.cpp)
+system_run(error_code_user_test.cpp)
+system_run(system_error_test.cpp)
+
+lib(boost_system_throw_test THROW_DYN_LINK throw_test.cpp)
+boost_test(SOURCES dynamic_link_test.cpp LINK_LIBRARIES boost_system_throw_test)
+
+system_run(initialization_test.cpp)
+system_run(header_only_test.cpp)
+
+boost_test(SOURCES config_test.cpp)
+
+system_run(std_interop_test.cpp)
+system_run(std_mismatch_test.cpp)
+
+lib(boost_system_single_instance_lib1 SINGLE_INSTANCE_DYN_LINK single_instance_1.cpp)
+lib(boost_system_single_instance_lib2 SINGLE_INSTANCE_DYN_LINK single_instance_2.cpp)
+
+system_run(single_instance_test.cpp single_instance_1.cpp single_instance_2.cpp)
+boost_test(SOURCES single_instance_test.cpp NAME single_instance_test_lib LINK_LIBRARIES boost_system_single_instance_lib1 boost_system_single_instance_lib2)
+
+system_run(before_main_test.cpp)
+system_run(constexpr_test.cpp)
+system_run(win32_hresult_test.cpp)
+
+system_run(error_category_test.cpp)
+system_run(generic_category_test.cpp)
+system_run(system_category_test.cpp)
+system_run(after_main_test.cpp)
+system_run(failed_test.cpp)
+system_run(failed_constexpr_test.cpp)
+
+boost_test(SOURCES warnings_test.cpp COMPILE_OPTIONS -Wall -Werror)
+
+lib(boost_system_std_single_instance_lib1 STD_SINGLE_INSTANCE_DYN_LINK std_single_instance_1.cpp)
+lib(boost_system_std_single_instance_lib2 STD_SINGLE_INSTANCE_DYN_LINK std_single_instance_2.cpp)
+
+system_run(std_single_instance_test.cpp std_single_instance_1.cpp std_single_instance_2.cpp)
+boost_test(SOURCES std_single_instance_test.cpp NAME std_single_instance_test_lib LINK_LIBRARIES boost_system_std_single_instance_lib1 boost_system_std_single_instance_lib2)
+
+boost_test(TYPE run SOURCES is_error_code_enum_test.cpp)
+boost_test(TYPE run SOURCES is_error_condition_enum_test.cpp)
+boost_test(TYPE run SOURCES errc_test.cpp)
+boost_test(TYPE run SOURCES errc_test2.cpp)
+boost_test(TYPE run SOURCES error_category_test2.cpp)
+boost_test(TYPE run SOURCES error_condition_test.cpp)
+boost_test(TYPE run SOURCES error_condition_test2.cpp)
+boost_test(TYPE run SOURCES generic_category_test2.cpp)
+boost_test(TYPE run SOURCES generic_category_test3.cpp)
+boost_test(TYPE run SOURCES system_category_test2.cpp)
+boost_test(TYPE run SOURCES system_category_test3.cpp)
+
+boost_test(TYPE run SOURCES windows_error_test.cpp)
+boost_test(TYPE run SOURCES linux_error_test.cpp)
+
+boost_test(TYPE link SOURCES errc_test3.cpp)
+
+boost_test(TYPE run SOURCES snprintf_test.cpp)
+
+boost_test(TYPE run SOURCES std_interop_test2.cpp)
+boost_test(TYPE run SOURCES std_interop_test3.cpp)
+boost_test(TYPE run SOURCES std_interop_test4.cpp)
+boost_test(TYPE run SOURCES std_interop_test5.cpp)
+boost_test(TYPE run SOURCES std_interop_test6.cpp)
+boost_test(TYPE run SOURCES std_interop_test7.cpp)
+boost_test(TYPE run SOURCES std_interop_test8.cpp)
+boost_test(TYPE run SOURCES std_interop_test9.cpp)
+
+boost_test(TYPE run SOURCES ec_location_test.cpp)
+
+boost_test(TYPE run SOURCES error_condition_test3.cpp)
+boost_test(TYPE run SOURCES error_code_test2.cpp)
+boost_test(TYPE run SOURCES system_error_test2.cpp)
+boost_test(TYPE run SOURCES std_interop_test10.cpp)
+
+boost_test(TYPE run SOURCES ec_location_test2.cpp)
+boost_test(TYPE run SOURCES ec_what_test.cpp)
+boost_test(TYPE run SOURCES system_error_test3.cpp)
+
+boost_test(TYPE run SOURCES std_interop_test11.cpp)
+
+boost_test(TYPE run SOURCES ec_wstream_test.cpp)
+
+boost_test(TYPE run SOURCES std_interop_test12.cpp)
+
+boost_test(TYPE run SOURCES errc_test4.cpp)
+
+boost_test(TYPE run SOURCES std_interop_test13.cpp)
+boost_test(TYPE run SOURCES std_interop_test14.cpp)
+
+boost_test(TYPE run SOURCES ec_location_test3.cpp)
+boost_test(TYPE run SOURCES ec_location_test4.cpp)
+
+boost_test(TYPE compile SOURCES constexpr_test2.cpp)
+
+boost_test(TYPE run SOURCES error_code_test3.cpp)
+boost_test(TYPE run SOURCES std_interop_test15.cpp)
+
+boost_test(TYPE run SOURCES win32_generic_test.cpp)
+
+boost_test(TYPE run SOURCES ec_hash_value_test.cpp)
+
+boost_test(TYPE run SOURCES std_interop_test16.cpp)
+
+# result
+
+boost_test(TYPE run SOURCES result_default_construct.cpp)
+boost_test(TYPE run SOURCES result_value_construct.cpp)
+boost_test(TYPE run SOURCES result_error_construct.cpp)
+boost_test(TYPE run SOURCES result_copy_construct.cpp)
+boost_test(TYPE run SOURCES result_move_construct.cpp)
+boost_test(TYPE run SOURCES result_copy_assign.cpp)
+boost_test(TYPE run SOURCES result_move_assign.cpp)
+boost_test(TYPE run SOURCES result_value_access.cpp)
+boost_test(TYPE run SOURCES result_error_access.cpp)
+boost_test(TYPE run SOURCES result_swap.cpp)
+boost_test(TYPE run SOURCES result_eq.cpp)
+boost_test(TYPE run SOURCES result_range_for.cpp)
+boost_test(TYPE run SOURCES result_value_construct2.cpp)
+boost_test(TYPE run SOURCES result_error_construct2.cpp)
+boost_test(TYPE run SOURCES result_errc_construct.cpp)
+boost_test(TYPE run SOURCES result_convert_construct.cpp)
+boost_test(TYPE run SOURCES result_typedefs.cpp)
+boost_test(TYPE run SOURCES result_value_construct3.cpp)
+boost_test(TYPE run SOURCES result_error_construct3.cpp)
+boost_test(TYPE run SOURCES result_emplace.cpp)
+boost_test(TYPE run SOURCES result_error_construct4.cpp)
+boost_test(TYPE run SOURCES result_value_construct4.cpp)
+boost_test(TYPE run SOURCES result_value_construct5.cpp)
+boost_test(TYPE run SOURCES result_error_move.cpp)
+boost_test(TYPE run SOURCES result_value_construct6.cpp)
+boost_test(TYPE run SOURCES result_value_construct7.cpp)
+boost_test(TYPE run SOURCES result_error_construct5.cpp)
+boost_test(TYPE run SOURCES result_or_value.cpp)
+boost_test(TYPE compile-fail SOURCES result_or_value_fail.cpp)
+boost_test(TYPE compile-fail SOURCES result_or_value_fail2.cpp)
+boost_test(TYPE run SOURCES result_or_fn0v.cpp)
+boost_test(TYPE run SOURCES result_or_fn0r.cpp)
+boost_test(TYPE run SOURCES result_and_fn1v.cpp)
+boost_test(TYPE run SOURCES result_and_fn1r.cpp)
+boost_test(TYPE run SOURCES result_and_eq_fn1v.cpp)
+boost_test(TYPE run SOURCES result_and_eq_fn1r.cpp)
+boost_test(TYPE run SOURCES result_in_place_use.cpp)
+boost_test(TYPE run SOURCES result_or_eq_value.cpp)
+boost_test(TYPE run SOURCES result_or_eq_fn0v.cpp)
+boost_test(TYPE run SOURCES result_or_eq_fn0r.cpp)

test/Jamfile.v2

@@ -1,7 +1,7 @@
 # Boost System Library test Jamfile
 
 # Copyright Beman Dawes 2003, 2006
-# Copyright 2017-2019 Peter Dimov
+# Copyright 2017-2021 Peter Dimov
 
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt
@@ -10,6 +10,23 @@
 
 import testing ;
 
+project
+  : default-build
+
+    <warnings>extra
+
+  : requirements
+
+    <library>/boost/system//boost_system
+    <library>/boost/core//boost_core
+
+    <toolset>msvc:<warnings-as-errors>on
+    <toolset>gcc:<warnings-as-errors>on
+    <toolset>clang:<warnings-as-errors>on
+
+    <toolset>gcc-4.4:<cxxflags>-Wno-sign-compare
+  ;
+
 rule system-run ( sources + )
 {
     local result ;
@@ -19,6 +36,7 @@ rule system-run ( sources + )
     result += [ run $(sources) : : : <library>/boost/system//boost_system <link>shared : $(sources[1]:B)_shared ] ;
     result += [ run $(sources) : : : <define>BOOST_NO_ANSI_APIS : $(sources[1]:B)_no_ansi ] ;
     result += [ run $(sources) : : : <define>BOOST_SYSTEM_USE_UTF8 : $(sources[1]:B)_utf8 ] ;
+    result += [ run $(sources) : : : <define>BOOST_SYSTEM_DISABLE_THREADS : $(sources[1]:B)_nthr ] ;
 
     return $(result) ;
 }
@@ -47,7 +65,11 @@ run single_instance_test.cpp single_instance_lib1 single_instance_lib2 : : : <li
 run single_instance_test.cpp single_instance_lib1 single_instance_lib2 : : : <link>shared : single_instance_lib_shared ;
 
 system-run before_main_test.cpp ;
-run-fail throws_assign_fail.cpp ;
+
+run-fail throws_assign_fail.cpp : : :
+    # GCC 12 catches this at compile time with a warning
+    <toolset>gcc,<variant>release:<build>no ;
+
 system-run constexpr_test.cpp ;
 system-run win32_hresult_test.cpp ;
 
@@ -56,12 +78,18 @@ system-run generic_category_test.cpp ;
 system-run system_category_test.cpp ;
 system-run after_main_test.cpp ;
 system-run failed_test.cpp ;
-system-run failed_constexpr_test.cpp ;
+run failed_constexpr_test.cpp : : :
+    # GCC w/ UBSAN doesn't consider `cat_ != 0` a constant expression
+    <toolset>gcc,<undefined-sanitizer>norecover:<build>no ;
 
 # Quick (CI) test
 run quick.cpp ;
 
-run warnings_test.cpp : : : <warnings>all <warnings-as-errors>on <toolset>gcc:<cxxflags>-Wnon-virtual-dtor <toolset>clang:<cxxflags>-Wnon-virtual-dtor ;
+run warnings_test.cpp
+  : : : <warnings>pedantic
+    <toolset>msvc:<warnings-as-errors>on
+    <toolset>gcc:<warnings-as-errors>on
+    <toolset>clang:<warnings-as-errors>on ;
 
 lib std_single_instance_lib1 : std_single_instance_1.cpp : <link>shared:<define>STD_SINGLE_INSTANCE_DYN_LINK ;
 lib std_single_instance_lib2 : std_single_instance_2.cpp : <link>shared:<define>STD_SINGLE_INSTANCE_DYN_LINK ;
@@ -69,3 +97,116 @@ lib std_single_instance_lib2 : std_single_instance_2.cpp : <link>shared:<define>
 system-run std_single_instance_test.cpp std_single_instance_1.cpp std_single_instance_2.cpp ;
 run std_single_instance_test.cpp std_single_instance_lib1 std_single_instance_lib2 : : : <link>static : std_single_instance_lib_static ;
 run std_single_instance_test.cpp std_single_instance_lib1 std_single_instance_lib2 : : : <link>shared <define>STD_SINGLE_INSTANCE_SHARED : std_single_instance_lib_shared ;
+
+run is_error_code_enum_test.cpp ;
+run is_error_condition_enum_test.cpp ;
+run errc_test.cpp ;
+run errc_test2.cpp ;
+run error_category_test2.cpp ;
+run error_condition_test.cpp ;
+run error_condition_test2.cpp ;
+run generic_category_test2.cpp ;
+run generic_category_test3.cpp ;
+run system_category_test2.cpp ;
+run system_category_test3.cpp ;
+
+run windows_error_test.cpp ;
+run linux_error_test.cpp ;
+
+link errc_test3.cpp ;
+
+run snprintf_test.cpp ;
+
+run std_interop_test2.cpp ;
+run std_interop_test3.cpp ;
+run std_interop_test4.cpp ;
+run std_interop_test5.cpp
+  : : :
+  # crash on xenial, but the real g++ 4.8 on both centos 7 and trusty works
+  <toolset>gcc-4.8:<build>no
+  <toolset>gcc-4.9:<build>no
+  ;
+
+run std_interop_test6.cpp ;
+run std_interop_test7.cpp ;
+run std_interop_test8.cpp ;
+run std_interop_test9.cpp ;
+
+run ec_location_test.cpp ;
+
+run error_condition_test3.cpp ;
+run error_code_test2.cpp ;
+run system_error_test2.cpp ;
+run std_interop_test10.cpp ;
+
+run ec_location_test2.cpp ;
+run ec_what_test.cpp ;
+run system_error_test3.cpp ;
+
+run std_interop_test11.cpp ;
+
+run ec_wstream_test.cpp ;
+
+run std_interop_test12.cpp ;
+
+run errc_test4.cpp ;
+
+run std_interop_test13.cpp ;
+run std_interop_test14.cpp ;
+
+run ec_location_test3.cpp ;
+run ec_location_test4.cpp ;
+
+compile constexpr_test2.cpp ;
+
+run error_code_test3.cpp ;
+run std_interop_test15.cpp ;
+
+run win32_generic_test.cpp ;
+
+run ec_hash_value_test.cpp ;
+
+run std_interop_test16.cpp ;
+
+# result
+
+run result_default_construct.cpp ;
+run result_value_construct.cpp ;
+run result_error_construct.cpp ;
+run result_copy_construct.cpp ;
+run result_move_construct.cpp ;
+run result_copy_assign.cpp ;
+run result_move_assign.cpp ;
+run result_value_access.cpp ;
+run result_error_access.cpp ;
+run result_swap.cpp : : : <toolset>gcc-10:<cxxflags>"-Wno-maybe-uninitialized" ;
+run result_eq.cpp ;
+run result_range_for.cpp ;
+run result_value_construct2.cpp ;
+run result_error_construct2.cpp ;
+run result_errc_construct.cpp ;
+run result_convert_construct.cpp ;
+run result_typedefs.cpp ;
+run result_value_construct3.cpp ;
+run result_error_construct3.cpp ;
+run result_emplace.cpp ;
+run result_error_construct4.cpp ;
+run result_value_construct4.cpp ;
+run result_value_construct5.cpp ;
+run result_error_move.cpp ;
+run result_value_construct6.cpp ;
+run result_value_construct7.cpp ;
+run result_error_construct5.cpp ;
+run result_or_value.cpp ;
+compile-fail result_or_value_fail.cpp ;
+compile-fail result_or_value_fail2.cpp ;
+run result_or_fn0v.cpp ;
+run result_or_fn0r.cpp ;
+run result_and_fn1v.cpp ;
+run result_and_fn1r.cpp ;
+run result_and_eq_fn1v.cpp ;
+run result_and_eq_fn1r.cpp ;
+run result_in_place_use.cpp ;
+run result_or_eq_value.cpp ;
+run result_or_eq_fn0v.cpp ;
+run result_or_eq_fn0r.cpp ;

test/after_main_test.cpp

@@ -5,8 +5,13 @@
 #include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/quick_exit.hpp>
+#include <boost/config.hpp>
 #include <cerrno>
 
+#if defined(BOOST_MSVC)
+# pragma warning(disable: 4722) // Z::~Z never returns
+#endif
+
 using namespace boost::system;
 
 struct Z
@@ -27,4 +32,6 @@ static error_code e2( ENOENT, generic_category() );
 
 int main()
 {
+    (void)e1;
+    (void)e2;
 }

test/cmake_install_test/CMakeLists.txt

@@ -0,0 +1,17 @@
+# 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_system REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::system)
+
+enable_testing()
+add_test(main main)
+
+add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/cmake_install_test/main.cpp

@@ -0,0 +1,44 @@
+// 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/system
+
+#include <boost/system.hpp>
+#include <cassert>
+#include <cerrno>
+
+#define BOOST_TEST(expr) assert(expr)
+#define BOOST_TEST_EQ(x1, x2) assert((x1)==(x2))
+
+int main()
+{
+    boost::system::error_category const & bt = boost::system::generic_category();
+
+    int ev = ENOENT;
+
+    boost::system::error_code bc( ev, bt );
+
+    BOOST_TEST_EQ( bc.value(), ev );
+    BOOST_TEST_EQ( &bc.category(), &bt );
+
+    boost::system::error_condition bn = bt.default_error_condition( ev );
+
+    BOOST_TEST_EQ( bn.value(), ev );
+    BOOST_TEST_EQ( &bn.category(), &bt );
+
+    BOOST_TEST( bt.equivalent( ev, bn ) );
+
+    BOOST_TEST( bc == bn );
+
+    boost::system::error_code bc2 = make_error_code( boost::system::errc::no_such_file_or_directory );
+
+    BOOST_TEST_EQ( bc2, bc );
+    BOOST_TEST_EQ( bc2.value(), ev );
+    BOOST_TEST_EQ( &bc.category(), &bt );
+
+    boost::system::system_error x( bc, "prefix" );
+
+    BOOST_TEST_EQ( x.code(), bc );
+    BOOST_TEST_EQ( std::string( x.what() ), "prefix: " + bc.what() );
+}

test/cmake_subdir_test/CMakeLists.txt

@@ -1,8 +1,8 @@
-# Copyright 2018, 2019 Peter Dimov
+# Copyright 2018-2021 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)
+cmake_minimum_required(VERSION 3.5...3.20)
 
 project(cmake_subdir_test LANGUAGES CXX)
 
@@ -10,7 +10,11 @@ add_subdirectory(../.. boostorg/system)
 add_subdirectory(../../../assert boostorg/assert)
 add_subdirectory(../../../config boostorg/config)
 add_subdirectory(../../../core boostorg/core)
+add_subdirectory(../../../mp11 boostorg/mp11)
 add_subdirectory(../../../predef boostorg/predef)
+add_subdirectory(../../../static_assert boostorg/static_assert)
+add_subdirectory(../../../throw_exception boostorg/throw_exception)
+add_subdirectory(../../../variant2 boostorg/variant2)
 add_subdirectory(../../../winapi boostorg/winapi)
 
 add_executable(quick ../quick.cpp)
@@ -19,4 +23,4 @@ target_link_libraries(quick Boost::system Boost::core)
 enable_testing()
 add_test(quick quick)
 
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
+add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --no-tests=error -C $<CONFIG>)

test/config_test.cpp

@@ -50,16 +50,6 @@ int main()
   std::cout << "BOOST_NO_ANSI_APIS is defined" << std::endl;
 #else
   std::cout << "BOOST_NO_ANSI_APIS is not defined" << std::endl;
-#endif
-#ifdef BOOST_NO_CXX11_NOEXCEPT
-  std::cout << "BOOST_NO_CXX11_NOEXCEPT is defined" << std::endl;
-#else
-  std::cout << "BOOST_NO_CXX11_NOEXCEPT is not defined" << std::endl;
-#endif
-#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-  std::cout << "BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS is defined" << std::endl;
-#else
-  std::cout << "BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS is not defined" << std::endl;
 #endif
   return 0;
 }

test/constexpr_test2.cpp

@@ -0,0 +1,35 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_GCC) && BOOST_GCC >= 40700 && BOOST_GCC < 40800
+
+BOOST_PRAGMA_MESSAGE("Skipping test, BOOST_GCC is 407xx")
+
+#else
+
+struct X
+{
+    boost::system::error_code ec;
+};
+
+X const& f()
+{
+#if defined(BOOST_CLANG_VERSION) && BOOST_CLANG_VERSION < 30900
+
+    BOOST_STATIC_CONSTEXPR X x = {};
+    return x;
+
+#else
+
+    BOOST_STATIC_CONSTEXPR X x;
+    return x;
+
+#endif
+}
+
+#endif

test/ec_hash_value_test.cpp

@@ -0,0 +1,126 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+#include <system_error>
+
+namespace sys = boost::system;
+
+int main()
+{
+    // normal against normal (equal, system)
+    {
+        sys::error_code e2( 0, sys::system_category() );
+        sys::error_code e3( e2.value(), e2.category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal against normal (equal, generic)
+    {
+        sys::error_code e2( EINVAL, sys::generic_category() );
+        sys::error_code e3( e2.value(), e2.category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal against normal (inequal, value, generic)
+    {
+        sys::error_code e2( 0, sys::generic_category() );
+        sys::error_code e3( EINVAL, sys::generic_category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal against normal (inequal, value, system)
+    {
+        sys::error_code e2( 1, sys::system_category() );
+        sys::error_code e3( 2, sys::system_category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal against normal (inequal, category)
+    {
+        sys::error_code e2( 0, sys::system_category() );
+        sys::error_code e3( 0, sys::generic_category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // empty against normal
+    {
+        sys::error_code e2;
+        sys::error_code e3( e2.value(), e2.category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // std:: wrapping against normal
+    {
+        std::error_code e1( EINVAL, std::generic_category() );
+
+        sys::error_code e2( e1 );
+        sys::error_code e3( e2.value(), e2.category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // empty against wrapping std:: empty
+    {
+        std::error_code e1;
+
+        sys::error_code e2( e1 );
+        sys::error_code e3;
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // empty against roundtrip via std
+    {
+        sys::error_code e2;
+
+        std::error_code e1( e2 );
+        sys::error_code e3( e1 );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal/generic against roundtrip via std
+    {
+        sys::error_code e2( EINVAL, boost::system::generic_category() );
+
+        std::error_code e1( e2 );
+        sys::error_code e3( e1 );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal/system against roundtrip via std
+    {
+        sys::error_code e2( 0, boost::system::system_category() );
+
+        std::error_code e1( e2 );
+        sys::error_code e3( e1 );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    return boost::report_errors();
+}

test/ec_location_test.cpp

@@ -0,0 +1,112 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+int main()
+{
+    int const val = ENOENT;
+    boost::system::error_category const & cat = boost::system::generic_category();
+
+    {
+        boost::system::error_code ec( val, cat );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        boost::system::error_code ec( val, cat, &loc );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 27 );
+    }
+
+    {
+        boost::system::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &boost::system::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec = boost::system::error_code( val, cat, &loc );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 51 );
+    }
+
+    {
+        boost::system::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &boost::system::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( val, cat, &loc );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 75 );
+    }
+
+    {
+        std::error_code e2( val, std::generic_category() );
+
+        boost::system::error_code ec( e2 );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( val, cat, &loc );
+
+        BOOST_TEST_EQ( ec.value(), val );
+        BOOST_TEST_EQ( &ec.category(), &cat );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 98 );
+    }
+
+    return boost::report_errors();
+}

test/ec_location_test2.cpp

@@ -0,0 +1,279 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+namespace sys = boost::system;
+
+enum E
+{
+    none = 0,
+    einval = EINVAL
+};
+
+namespace boost
+{
+namespace system
+{
+
+template<> struct is_error_code_enum< ::E >
+{
+    static const bool value = true;
+};
+
+} // namespace system
+} // namespace boost
+
+sys::error_code make_error_code( E e )
+{
+    return e == 0? sys::error_code(): sys::error_code( e, sys::generic_category() );
+}
+
+enum E2
+{
+    e2inval = EINVAL
+};
+
+namespace boost
+{
+namespace system
+{
+
+template<> struct is_error_code_enum< ::E2 >
+{
+    static const bool value = true;
+};
+
+} // namespace system
+} // namespace boost
+
+std::error_code make_error_code( E2 e )
+{
+    return std::error_code( e, std::generic_category() );
+}
+
+int main()
+{
+    {
+        sys::error_code ec( einval );
+
+        BOOST_TEST_EQ( ec.value(), EINVAL );
+        BOOST_TEST_EQ( &ec.category(), &sys::generic_category() );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( einval, &loc );
+
+        BOOST_TEST_EQ( ec.value(), EINVAL );
+        BOOST_TEST_EQ( &ec.category(), &sys::generic_category() );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 73 );
+    }
+
+    {
+        sys::error_code ec( none );
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( none, &loc );
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec = sys::error_code( einval, &loc );
+
+        BOOST_TEST_EQ( ec.value(), EINVAL );
+        BOOST_TEST_EQ( &ec.category(), &sys::generic_category() );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 123 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec = sys::error_code( none, &loc );
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( einval, &loc );
+
+        BOOST_TEST_EQ( ec.value(), EINVAL );
+        BOOST_TEST_EQ( &ec.category(), &sys::generic_category() );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 171 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( none, &loc );
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec( e2inval );
+
+        BOOST_TEST_EQ( ec, std::error_code( EINVAL, std::generic_category() ) );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( e2inval, &loc );
+
+        BOOST_TEST_EQ( ec, std::error_code( EINVAL, std::generic_category() ) );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec = sys::error_code( e2inval, &loc );
+
+        BOOST_TEST_EQ( ec, std::error_code( EINVAL, std::generic_category() ) );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( e2inval, &loc );
+
+        BOOST_TEST_EQ( ec, std::error_code( EINVAL, std::generic_category() ) );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    return boost::report_errors();
+}

test/ec_location_test3.cpp

@@ -0,0 +1,86 @@
+// Copyright 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+int main()
+{
+    int const val = ENOENT;
+    boost::system::error_category const & cat = boost::system::generic_category();
+
+    {
+        boost::system::error_code ec;
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        boost::system::error_code ec2( ec, &loc );
+
+        BOOST_TEST_EQ( ec2, ec );
+
+        BOOST_TEST( !ec2.has_location() );
+        BOOST_TEST_EQ( ec2.location(), boost::source_location() );
+
+        boost::system::error_code ec3( ec2, 0 );
+
+        BOOST_TEST_EQ( ec3, ec2 );
+
+        BOOST_TEST( !ec3.has_location() );
+        BOOST_TEST_EQ( ec3.location(), boost::source_location() );
+    }
+
+    {
+        boost::system::error_code ec( val, cat );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        boost::system::error_code ec2( ec, &loc );
+
+        BOOST_TEST_EQ( ec2, ec );
+
+        BOOST_TEST( ec2.has_location() );
+        BOOST_TEST_EQ( ec2.location(), loc );
+
+        boost::system::error_code ec3( ec2, 0 );
+
+        BOOST_TEST_EQ( ec3, ec2 );
+
+        BOOST_TEST( !ec3.has_location() );
+        BOOST_TEST_EQ( ec3.location(), boost::source_location() );
+    }
+
+    {
+        std::error_code e2( val, std::generic_category() );
+
+        boost::system::error_code ec( e2 );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        boost::system::error_code ec2( ec, &loc );
+
+        BOOST_TEST_EQ( ec2, ec );
+
+        BOOST_TEST( !ec2.has_location() );
+        BOOST_TEST_EQ( ec2.location(), boost::source_location() );
+
+        boost::system::error_code ec3( ec2, 0 );
+
+        BOOST_TEST_EQ( ec3, ec2 );
+
+        BOOST_TEST( !ec3.has_location() );
+        BOOST_TEST_EQ( ec3.location(), boost::source_location() );
+    }
+
+    return boost::report_errors();
+}

test/ec_location_test4.cpp

@@ -0,0 +1,89 @@
+// Copyright 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+int main()
+{
+    int const val = ENOENT;
+    boost::system::error_category const & cat = boost::system::generic_category();
+
+    {
+        boost::system::error_code ec;
+        boost::system::error_code ec2( ec );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( ec, &loc );
+
+        BOOST_TEST_EQ( ec, ec2 );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+
+        ec.assign( ec, 0 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+    }
+
+    {
+        boost::system::error_code ec( val, cat );
+        boost::system::error_code ec2( ec );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( ec, &loc );
+
+        BOOST_TEST_EQ( ec, ec2 );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), loc );
+
+        ec.assign( ec, 0 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+    }
+
+    {
+        std::error_code e2( val, std::generic_category() );
+
+        boost::system::error_code ec( e2 );
+        boost::system::error_code ec2( ec );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( ec, &loc );
+
+        BOOST_TEST_EQ( ec, ec2 );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+
+        ec.assign( ec, 0 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location(), boost::source_location() );
+    }
+
+    return boost::report_errors();
+}

test/ec_what_test.cpp

@@ -0,0 +1,87 @@
+// Copyright 2020, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [system:0]" );
+    }
+
+    {
+        sys::error_code ec( 5, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec.value(), 5 );
+        BOOST_TEST( ec.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [generic:5]" );
+    }
+
+    {
+        sys::error_code ec( 5, sys::system_category() );
+
+        BOOST_TEST_EQ( ec.value(), 5 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [system:5]" );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( 5, sys::generic_category(), &loc );
+
+        BOOST_TEST_EQ( ec.value(), 5 );
+        BOOST_TEST( ec.category() == sys::generic_category() );
+        BOOST_TEST_EQ( &ec.location(), &loc );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [generic:5 at " + loc.to_string() + "]" );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( 5, sys::system_category(), &loc );
+
+        BOOST_TEST_EQ( ec.value(), 5 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+        BOOST_TEST_EQ( &ec.location(), &loc );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [system:5 at " + loc.to_string() + "]" );
+    }
+
+    {
+        std::error_code ec;
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.what(), ec2.message() + " [std:system:0]" );
+    }
+
+    {
+        std::error_code ec( 5, std::generic_category() );
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.what(), ec2.message() + " [std:generic:5]" );
+    }
+
+    {
+        std::error_code ec( 5, std::system_category() );
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.what(), ec2.message() + " [std:system:5]" );
+    }
+
+    return boost::report_errors();
+}

test/ec_wstream_test.cpp

@@ -0,0 +1,21 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        std::wostringstream os;
+        os << sys::error_code();
+
+        BOOST_TEST( os.str() == L"system:0" );
+    }
+
+    return boost::report_errors();
+}

test/errc_test.cpp

@@ -0,0 +1,18 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+#include <boost/system/is_error_condition_enum.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( static_cast<int>( boost::system::errc::success ), 0 );
+    BOOST_TEST_EQ( static_cast<int>( boost::system::errc::no_such_file_or_directory ), ENOENT );
+    BOOST_TEST_EQ( static_cast<int>( boost::system::errc::address_family_not_supported ), EAFNOSUPPORT );
+
+    BOOST_TEST( boost::system::is_error_condition_enum< boost::system::errc::errc_t >::value );
+
+    return boost::report_errors();
+}

test/errc_test2.cpp

@@ -0,0 +1,20 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( make_error_code( boost::system::errc::success ).value(), 0 );
+    BOOST_TEST_EQ( make_error_condition( boost::system::errc::success ).value(), 0 );
+
+    BOOST_TEST_EQ( make_error_code( boost::system::errc::no_such_file_or_directory ).value(), ENOENT );
+    BOOST_TEST_EQ( make_error_condition( boost::system::errc::no_such_file_or_directory ).value(), ENOENT );
+
+    BOOST_TEST_EQ( make_error_code( boost::system::errc::address_family_not_supported ).value(), EAFNOSUPPORT );
+    BOOST_TEST_EQ( make_error_condition( boost::system::errc::address_family_not_supported ).value(), EAFNOSUPPORT );
+
+    return boost::report_errors();
+}

test/errc_test3.cpp

@@ -0,0 +1,34 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+
+int main()
+{
+    make_error_code( boost::system::errc::success ).value();
+    make_error_code( boost::system::errc::success ).category();
+    make_error_code( boost::system::errc::success ).default_error_condition();
+    make_error_code( boost::system::errc::success ).message();
+    make_error_code( boost::system::errc::success ).failed();
+    make_error_code( boost::system::errc::success ).clear();
+
+    make_error_condition( boost::system::errc::success ).value();
+    make_error_condition( boost::system::errc::success ).category();
+    make_error_condition( boost::system::errc::success ).message();
+    make_error_condition( boost::system::errc::success ).failed();
+    make_error_condition( boost::system::errc::success ).clear();
+
+    make_error_code( boost::system::errc::no_such_file_or_directory ).value();
+    make_error_code( boost::system::errc::no_such_file_or_directory ).category();
+    make_error_code( boost::system::errc::no_such_file_or_directory ).default_error_condition();
+    make_error_code( boost::system::errc::no_such_file_or_directory ).message();
+    make_error_code( boost::system::errc::no_such_file_or_directory ).failed();
+    make_error_code( boost::system::errc::no_such_file_or_directory ).clear();
+
+    make_error_condition( boost::system::errc::no_such_file_or_directory ).value();
+    make_error_condition( boost::system::errc::no_such_file_or_directory ).category();
+    make_error_condition( boost::system::errc::no_such_file_or_directory ).message();
+    make_error_condition( boost::system::errc::no_such_file_or_directory ).failed();
+    make_error_condition( boost::system::errc::no_such_file_or_directory ).clear();
+}

test/errc_test4.cpp

@@ -0,0 +1,17 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+#include <boost/assert/source_location.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+    BOOST_TEST( make_error_code( boost::system::errc::no_such_file_or_directory, &loc ).has_location() );
+    BOOST_TEST_EQ( make_error_code( boost::system::errc::no_such_file_or_directory, &loc ).location().to_string(), loc.to_string() );
+
+    return boost::report_errors();
+}

test/error_category_test.cpp

@@ -8,11 +8,9 @@
 
 // See library home page at http://www.boost.org/libs/system
 
-// Avoid spurious VC++ warnings
-# define _CRT_SECURE_NO_WARNINGS
-
 #include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/core/snprintf.hpp>
 #include <cstdio>
 
 //
@@ -23,7 +21,7 @@ class user_category: public sys::error_category
 {
 public:
 
-    virtual const char * name() const BOOST_NOEXCEPT
+    virtual const char * name() const noexcept
     {
         return "user";
     }
@@ -31,7 +29,7 @@ public:
     virtual std::string message( int ev ) const
     {
         char buffer[ 256 ];
-        std::sprintf( buffer, "user message %d", ev );
+        boost::core::snprintf( buffer, sizeof( buffer ), "user message %d", ev );
 
         return buffer;
     }

test/error_category_test2.cpp

@@ -0,0 +1,77 @@
+
+// Copyright 2018, 2020 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
+
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/error_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/snprintf.hpp>
+#include <cstdio>
+
+//
+
+namespace sys = boost::system;
+
+class user_category: public sys::error_category
+{
+public:
+
+    virtual const char * name() const noexcept
+    {
+        return "user";
+    }
+
+    virtual std::string message( int ev ) const
+    {
+        char buffer[ 256 ];
+        boost::core::snprintf( buffer, sizeof( buffer ), "user message %d", ev );
+
+        return buffer;
+    }
+
+    using sys::error_category::message;
+};
+
+static user_category s_cat_1;
+static user_category s_cat_2;
+
+int main()
+{
+    // default_error_condition
+
+    BOOST_TEST( s_cat_1.default_error_condition( 1 ).value() == 1 );
+    BOOST_TEST( s_cat_1.default_error_condition( 1 ).category() == s_cat_1 );
+
+    BOOST_TEST( s_cat_2.default_error_condition( 2 ).value() == 2 );
+    BOOST_TEST( s_cat_2.default_error_condition( 2 ).category() == s_cat_2 );
+
+    // equivalent
+
+    BOOST_TEST( s_cat_1.equivalent( 1, s_cat_1.default_error_condition( 1 ) ) );
+    BOOST_TEST( !s_cat_1.equivalent( 1, s_cat_1.default_error_condition( 2 ) ) );
+    BOOST_TEST( !s_cat_1.equivalent( 1, s_cat_2.default_error_condition( 2 ) ) );
+
+    // message
+
+    {
+        char buffer[ 256 ];
+        BOOST_TEST_CSTR_EQ( s_cat_1.message( 1, buffer, sizeof( buffer ) ), s_cat_1.message( 1 ).c_str() );
+    }
+
+    {
+        char buffer[ 4 ];
+        BOOST_TEST_CSTR_EQ( s_cat_1.message( 1, buffer, sizeof( buffer ) ), "use" );
+    }
+
+    // ==
+
+    BOOST_TEST_NOT( s_cat_1 == s_cat_2 );
+    BOOST_TEST( s_cat_1 != s_cat_2 );
+
+    return boost::report_errors();
+}

test/error_code_test.cpp

@@ -11,11 +11,8 @@
 
 #include <boost/config/warning_disable.hpp>
 
-#include <boost/detail/lightweight_test.hpp>
 #include <boost/system/error_code.hpp>
-#include <boost/system/cygwin_error.hpp>
-#include <boost/system/linux_error.hpp>
-#include <boost/system/windows_error.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <sstream>
 #include <string>
@@ -111,6 +108,7 @@ int main( int, char ** )
 
   std::cout << "Conversion use cases...\n";
   error_condition x1( errc::file_exists );
+  (void)x1;
   //error_code x2( errc::file_exists ); // should fail to compile
   make_error_code(errc::file_exists);
   make_error_condition(errc::file_exists);
@@ -294,29 +292,7 @@ int main( int, char ** )
   BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
   BOOST_TEST( ec.default_error_condition().category() == generic_category() );
 
-# ifdef __CYGWIN__
-
-  std::cout << "Cygwin tests...\n";
-  ec = cygwin_error::no_package;
-  BOOST_TEST( ec == cygwin_error::no_package );
-  BOOST_TEST( ec == error_code( ENOPKG, system_category() ) );
-  BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category() ) );
-  BOOST_TEST( ec.default_error_condition().category() == system_category() );
-
-# elif defined(linux) || defined(__linux) || defined(__linux__)
-
-  std::cout << "Linux tests...\n";
-  ec = linux_error::dot_dot_error;
-  BOOST_TEST( ec == linux_error::dot_dot_error );
-  BOOST_TEST( ec == error_code( EDOTDOT, system_category() ) );
-  BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category() ) );
-  BOOST_TEST( ec.default_error_condition().category() == system_category() );
-
-# endif
-
 #endif
   
   return ::boost::report_errors();
 }
-
-

test/error_code_test2.cpp

@@ -0,0 +1,224 @@
+// Copyright 2020, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    char buffer[ 4096 ], buffer2[ 4096 ];
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec.message(), ec.category().message( ec.value() ) );
+        BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.category().message( ec.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.message().c_str() );
+
+        {
+            char const* msg = ec.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !ec.failed() );
+        BOOST_TEST( !ec );
+
+        BOOST_TEST_EQ( ec.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec;
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.value(), 0 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !ec2.failed() );
+        BOOST_TEST( !ec2 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+        BOOST_TEST_NOT( ec != ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec;
+        sys::error_code ec2( ec.value(), ec.category() );
+
+        BOOST_TEST_EQ( ec2.value(), 0 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !ec2.failed() );
+        BOOST_TEST( !ec2 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+        BOOST_TEST_NOT( ec != ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec2( 5, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.value(), 5 );
+        BOOST_TEST( ec2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:5" ) );
+    }
+
+    {
+        sys::error_code ec2( -4, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.value(), -4 );
+        BOOST_TEST( ec2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:-4" ) );
+    }
+
+    {
+        sys::error_code ec2( 5, sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.value(), 5 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:5" ) );
+    }
+
+    {
+        sys::error_code ec2( -4, sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.value(), -4 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:-4" ) );
+    }
+
+    return boost::report_errors();
+}

test/error_code_test3.cpp

@@ -0,0 +1,69 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/error_condition.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+enum my_errc
+{
+    enomem_c = ENOMEM
+};
+
+enum my_errn
+{
+    enomem_n = ENOMEM
+};
+
+namespace boost {
+namespace system {
+
+template<> struct is_error_code_enum<my_errc>
+{
+    static const bool value = true;
+};
+
+template<> struct is_error_condition_enum<my_errn>
+{
+    static const bool value = true;
+};
+
+} // namespace system
+} // namespace boost
+
+sys::error_code make_error_code( my_errc e )
+{
+    return sys::error_code( e, sys::generic_category() );
+}
+
+sys::error_condition make_error_condition( my_errn e )
+{
+    return sys::error_condition( e, sys::generic_category() );
+}
+
+int main()
+{
+    sys::error_code ec = make_error_code( sys::errc::not_enough_memory );
+    sys::error_condition en( sys::errc::not_enough_memory );
+
+    BOOST_TEST_EQ( ec, en );
+    BOOST_TEST_EQ( en, ec );
+
+    BOOST_TEST_EQ( ec, enomem_c );
+    BOOST_TEST_EQ( enomem_c, ec );
+
+    BOOST_TEST_EQ( ec, enomem_n );
+    BOOST_TEST_EQ( enomem_n, ec );
+
+    BOOST_TEST_EQ( en, enomem_c );
+    BOOST_TEST_EQ( enomem_c, en );
+
+    BOOST_TEST_EQ( en, enomem_n );
+    BOOST_TEST_EQ( enomem_n, en );
+
+    return boost::report_errors();
+}

test/error_condition_test.cpp

@@ -0,0 +1,31 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_condition.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    sys::error_condition en;
+
+    BOOST_TEST_EQ( en.value(), 0 );
+    BOOST_TEST( !en );
+
+    sys::error_condition en2( en );
+
+    BOOST_TEST( en == en2 );
+    BOOST_TEST_NOT( en != en2 );
+
+    en2.assign( 1, en.category() );
+
+    BOOST_TEST_EQ( en2.value(), 1 );
+    BOOST_TEST( en2 );
+
+    BOOST_TEST_NOT( en == en2 );
+    BOOST_TEST( en != en2 );
+
+    return boost::report_errors();
+}

test/error_condition_test2.cpp

@@ -0,0 +1,25 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_condition.hpp>
+#include <boost/system/errc.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    sys::error_condition en( sys::errc::no_such_file_or_directory );
+
+    BOOST_TEST_EQ( en.value(), ENOENT );
+
+    BOOST_TEST( en );
+    BOOST_TEST( !!en );
+
+    BOOST_TEST( en == make_error_condition( sys::errc::no_such_file_or_directory ) );
+
+    BOOST_TEST( en.category() == sys::error_condition().category() );
+
+    return boost::report_errors();
+}

test/error_condition_test3.cpp

@@ -0,0 +1,224 @@
+// Copyright 2020, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_condition.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    char buffer[ 4096 ], buffer2[ 4096 ];
+
+    {
+        sys::error_condition en;
+
+        BOOST_TEST_EQ( en.value(), 0 );
+        BOOST_TEST( en.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en.message(), en.category().message( en.value() ) );
+        BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.category().message( en.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.message().c_str() );
+
+        {
+            char const* msg = en.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !en.failed() );
+        BOOST_TEST( !en );
+
+        BOOST_TEST_EQ( en.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en;
+        sys::error_condition en2( en );
+
+        BOOST_TEST_EQ( en2.value(), 0 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !en2.failed() );
+        BOOST_TEST( !en2 );
+
+        BOOST_TEST_EQ( en, en2 );
+        BOOST_TEST_NOT( en != en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en;
+        sys::error_condition en2( en.value(), en.category() );
+
+        BOOST_TEST_EQ( en2.value(), 0 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !en2.failed() );
+        BOOST_TEST( !en2 );
+
+        BOOST_TEST_EQ( en, en2 );
+        BOOST_TEST_NOT( en != en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en2( 5, sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.value(), 5 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:5" ) );
+    }
+
+    {
+        sys::error_condition en2( -4, sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.value(), -4 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:-4" ) );
+    }
+
+    {
+        sys::error_condition en2( 5, sys::system_category() );
+
+        BOOST_TEST_EQ( en2.value(), 5 );
+        BOOST_TEST( en2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:5" ) );
+    }
+
+    {
+        sys::error_condition en2( -4, sys::system_category() );
+
+        BOOST_TEST_EQ( en2.value(), -4 );
+        BOOST_TEST( en2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:-4" ) );
+    }
+
+    return boost::report_errors();
+}

test/failed_constexpr_test.cpp

@@ -33,6 +33,12 @@ BOOST_STATIC_ASSERT( !ec3.failed() );
 BOOST_STATIC_ASSERT( ec3? false: true );
 BOOST_STATIC_ASSERT( !ec3 );
 
+#if defined(__GNUC__) && __GNUC__ == 7 && __cplusplus == 201703L
+
+// 'cat_' is not a constant expression
+
+#else
+
 constexpr error_condition en1( 1, system_category() );
 
 BOOST_STATIC_ASSERT( en1.failed() );
@@ -51,6 +57,8 @@ BOOST_STATIC_ASSERT( !en3.failed() );
 BOOST_STATIC_ASSERT( en3? false: true );
 BOOST_STATIC_ASSERT( !en3 );
 
+#endif
+
 int main()
 {
 }

test/failed_test.cpp

@@ -2,11 +2,9 @@
 // Copyright 2018 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 
-// Avoid spurious VC++ warnings
-#define _CRT_SECURE_NO_WARNINGS
-
 #include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/core/snprintf.hpp>
 #include <cstdio>
 
 using namespace boost::system;
@@ -15,11 +13,11 @@ struct http_category_impl: public error_category
 {
     // clang++ 3.8 and below: initialization of const object
     // requires a user-provided default constructor
-    BOOST_SYSTEM_CONSTEXPR http_category_impl() BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR http_category_impl() noexcept
     {
     }
 
-    char const * name() const BOOST_NOEXCEPT
+    char const * name() const noexcept
     {
         return "http";
     }
@@ -28,11 +26,11 @@ struct http_category_impl: public error_category
     {
         char buffer[ 32 ];
 
-        std::sprintf( buffer, "HTTP/1.0 %d", ev );
+        boost::core::snprintf( buffer, sizeof( buffer ), "HTTP/1.0 %d", ev );
         return buffer;
     }
 
-    bool failed( int ev ) const BOOST_NOEXCEPT
+    bool failed( int ev ) const noexcept
     {
         return !( ev >= 200 && ev < 300 );
     }
@@ -123,13 +121,13 @@ template<class Ec> void test()
 
     {
         Ec ec( 0, http_category() );
-        BOOST_TEST( ec.failed() );
+        TEST_FAILED( ec );
 
         ec.assign( 200, http_category() );
-        BOOST_TEST( !ec.failed() );
+        TEST_NOT_FAILED( ec );
 
         ec = Ec( 404, http_category() );
-        BOOST_TEST( ec.failed() );
+        TEST_FAILED( ec );
     }
 
 }

test/generic_category_test2.cpp

@@ -0,0 +1,20 @@
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/generic_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+// Tests whether generic_category() is functional when only
+// generic_category.hpp is included
+
+namespace sys = boost::system;
+
+int main()
+{
+    sys::error_category const & cat = sys::generic_category();
+
+    BOOST_TEST_CSTR_EQ( cat.name(), "generic" );
+
+    return boost::report_errors();
+}

test/generic_category_test3.cpp

@@ -0,0 +1,30 @@
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/generic_category.hpp>
+#include <boost/system/error_condition.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+namespace sys = boost::system;
+
+int main()
+{
+    sys::error_category const & cat = sys::generic_category();
+
+    // name
+    BOOST_TEST_CSTR_EQ( cat.name(), "generic" );
+
+    // default_error_condition
+    BOOST_TEST( cat.default_error_condition( 0 ) == sys::error_condition( 0, cat ) );
+    BOOST_TEST( cat.default_error_condition( ENOENT ) == sys::error_condition( ENOENT, cat ) );
+    BOOST_TEST( cat.default_error_condition( -1 ) == sys::error_condition( -1, cat ) );
+
+    // failed
+    BOOST_TEST( !cat.failed( 0 ) );
+    BOOST_TEST( cat.failed( ENOENT ) );
+    BOOST_TEST( cat.failed( -1 ) );
+
+    return boost::report_errors();
+}

test/header_only_test.cpp

@@ -16,8 +16,10 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/system/error_code.hpp>
 
-int main( int, char*[] )
+int main()
 {
-  boost::system::error_code ec( 0, boost::system::system_category() );
-  return ::boost::report_errors();
+    boost::system::error_code ec( 0, boost::system::system_category() );
+    (void)ec;
+
+    return ::boost::report_errors();
 }

test/is_error_code_enum_test.cpp

@@ -0,0 +1,41 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/is_error_code_enum.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+enum error
+{
+    success = 0,
+    e1,
+    e2,
+    e3
+};
+
+namespace boost
+{
+namespace system
+{
+
+template<> struct is_error_code_enum< ::error >
+{
+    static const bool value = true;
+};
+
+}
+}
+
+boost::system::error_code make_error_code( ::error e );
+
+enum not_error
+{
+};
+
+int main()
+{
+    BOOST_TEST( boost::system::is_error_code_enum< ::error >::value );
+    BOOST_TEST( !boost::system::is_error_code_enum< ::not_error >::value );
+
+    return boost::report_errors();
+}

test/is_error_condition_enum_test.cpp

@@ -0,0 +1,40 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/is_error_condition_enum.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+enum condition
+{
+    c1 = 1,
+    c2,
+    c3
+};
+
+namespace boost
+{
+namespace system
+{
+
+template<> struct is_error_condition_enum< ::condition >
+{
+    static const bool value = true;
+};
+
+}
+}
+
+boost::system::error_condition make_error_condition( ::condition e );
+
+enum not_condition
+{
+};
+
+int main()
+{
+    BOOST_TEST( boost::system::is_error_condition_enum< ::condition >::value );
+    BOOST_TEST( !boost::system::is_error_condition_enum< ::not_condition >::value );
+
+    return boost::report_errors();
+}

test/linux_error_test.cpp

@@ -0,0 +1,29 @@
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/linux_error.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if !defined(__linux__)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test, __linux__ is not defined" )
+int main() {}
+
+#else
+
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    namespace sys = boost::system;
+
+    sys::error_code ec = sys::linux_error::dot_dot_error;
+
+    BOOST_TEST_EQ( ec, sys::linux_error::dot_dot_error );
+    BOOST_TEST_EQ( ec, sys::error_code( EDOTDOT, sys::system_category() ) );
+
+    return boost::report_errors();
+}
+
+#endif

test/quick.cpp

@@ -1,14 +1,10 @@
-
-// Copyright 2017 Peter Dimov.
-//
+// Copyright 2017, 2021 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
+// https://www.boost.org/LICENSE_1_0.txt
 
 // See library home page at http://www.boost.org/libs/system
 
-#include <boost/system/error_code.hpp>
+#include <boost/system.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <cerrno>
 
@@ -32,5 +28,16 @@ int main()
 
     BOOST_TEST( bc == bn );
 
+    boost::system::error_code bc2 = make_error_code( boost::system::errc::no_such_file_or_directory );
+
+    BOOST_TEST_EQ( bc2, bc );
+    BOOST_TEST_EQ( bc2.value(), ev );
+    BOOST_TEST_EQ( &bc.category(), &bt );
+
+    boost::system::system_error x( bc, "prefix" );
+
+    BOOST_TEST_EQ( x.code(), bc );
+    BOOST_TEST_EQ( std::string( x.what() ), "prefix: " + bc.what() );
+
     return boost::report_errors();
 }

test/result_and_eq_fn1r.cpp

@@ -0,0 +1,149 @@
+// Copyright 2017, 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+};
+
+struct Y
+{
+    int v_;
+
+    explicit Y( int v ): v_( v ) {}
+    Y( X x ): v_( x.v_) {}
+
+    Y( Y const& ) = delete;
+    Y& operator=( Y const& ) = delete;
+
+    Y( Y&& r ): v_( r.v_ )
+    {
+        r.v_ = 0;
+    }
+
+    Y& operator=( Y&& r )
+    {
+        if( &r != this )
+        {
+            v_ = r.v_;
+            r.v_ = 0;
+        }
+
+        return *this;
+    }
+};
+
+struct E
+{
+};
+
+struct E2
+{
+    E2() {}
+    E2( E ) {}
+};
+
+result<int, E> fi( int x )
+{
+    return 2 * x + 1;
+}
+
+result<int, E2> fi2( int )
+{
+    return E2();
+}
+
+result<X, E> fy( Y y )
+{
+    return X{ 2 * y.v_ + 1 };
+}
+
+result<Y, E2> fy2( Y )
+{
+    return E2();
+}
+
+result<int&, E> fri( int& )
+{
+    static int x = 2;
+    return x;
+}
+
+result<int&, E2> fri2( int& )
+{
+    return E2();
+}
+
+result<void, E2> fv()
+{
+    return {};
+}
+
+result<void, E2> fv2()
+{
+    return E2();
+}
+
+int main()
+{
+    {
+        result<int, E2> r( 1 );
+
+        r &= fi;
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 3 );
+
+        r &= fi2;
+        BOOST_TEST( r.has_error() );
+
+        r &= fi;
+        BOOST_TEST( r.has_error() );
+    }
+
+    {
+        result<Y, E2> r( in_place_value, 1 );
+
+        r &= fy;
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 3 );
+
+        r &= fy2;
+        BOOST_TEST( r.has_error() );
+
+        r &= fy;
+        BOOST_TEST( r.has_error() );
+    }
+
+    {
+        int x1 = 1;
+        result<int&, E2> r( x1 );
+
+        r &= fri;
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &*fri( x1 ) );
+
+        r &= fri2;
+        BOOST_TEST( r.has_error() );
+
+        r &= fri;
+        BOOST_TEST( r.has_error() );
+    }
+
+    {
+        result<void, E2> r;
+
+        r &= fv;
+        BOOST_TEST( r.has_value() );
+
+        r &= fv2;
+        BOOST_TEST( r.has_error() );
+
+        r &= fv;
+        BOOST_TEST( r.has_error() );
+    }
+
+    return boost::report_errors();
+}

test/result_and_eq_fn1v.cpp

@@ -0,0 +1,141 @@
+// Copyright 2017, 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+};
+
+struct Y
+{
+    int v_;
+
+    explicit Y( int v ): v_( v ) {}
+    Y( X x ): v_( x.v_) {}
+
+    Y( Y const& ) = delete;
+    Y& operator=( Y const& ) = delete;
+
+    Y( Y&& r ): v_( r.v_ )
+    {
+        r.v_ = 0;
+    }
+
+    Y& operator=( Y&& r )
+    {
+        if( &r != this )
+        {
+            v_ = r.v_;
+            r.v_ = 0;
+        }
+
+        return *this;
+    }
+};
+
+struct E
+{
+};
+
+int f( int x )
+{
+    return x * 2 + 1;
+}
+
+X g( Y y )
+{
+    return X{ y.v_ * 2 + 1 };
+}
+
+int& h( int& )
+{
+    static int x = 2;
+    return x;
+}
+
+static int fv_called;
+
+void fv()
+{
+    ++fv_called;
+}
+
+int main()
+{
+    {
+        result<int> r( 1 );
+
+        r &= f;
+
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( *r, 3 );
+    }
+
+    {
+        result<int, E> r( in_place_error );
+
+        r &= f;
+
+        BOOST_TEST( r.has_error() );
+    }
+
+    {
+        result<Y> r( in_place_value, 1 );
+
+        r &= g;
+
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( r->v_, 3 );
+    }
+
+    {
+        result<Y, E> r( in_place_error );
+
+        r &= g;
+
+        BOOST_TEST( r.has_error() );
+    }
+
+    {
+        int x1 = 1;
+        result<int&> r( x1 );
+
+        r &= h;
+
+        BOOST_TEST( r.has_value() ) && BOOST_TEST_EQ( &*r, &h( x1 ) );
+    }
+
+    {
+        result<int&, E> r( in_place_error );
+
+        r &= h;
+
+        BOOST_TEST( r.has_error() );
+    }
+
+    {
+        result<void> r;
+        fv_called = 0;
+
+        r &= fv;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( fv_called, 1 );
+    }
+
+    {
+        result<void, E> r( in_place_error );
+        fv_called = 0;
+
+        r &= fv;
+
+        BOOST_TEST( r.has_error() );
+        BOOST_TEST_EQ( fv_called, 0 );
+    }
+
+    return boost::report_errors();
+}

test/result_and_fn1r.cpp

@@ -0,0 +1,503 @@
+// Copyright 2017, 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+};
+
+struct Y
+{
+    int v_;
+
+    explicit Y( int v ): v_( v ) {}
+    Y( X x ): v_( x.v_) {}
+
+    Y( Y const& ) = delete;
+    Y& operator=( Y const& ) = delete;
+
+    Y( Y&& r ): v_( r.v_ )
+    {
+        r.v_ = 0;
+    }
+
+    Y& operator=( Y&& ) = delete;
+};
+
+struct E
+{
+};
+
+struct E2
+{
+    E2() {}
+    E2( E ) {}
+};
+
+result<int, E2> fi( int x )
+{
+    return 2 * x + 1;
+}
+
+result<int, E2> fi2( int )
+{
+    return E2();
+}
+
+result<void, E2> fi3( int )
+{
+    return {};
+}
+
+result<X, E2> fy( Y y )
+{
+    return X{ 2 * y.v_ + 1 };
+}
+
+result<X, E2> fy2( Y )
+{
+    return E2();
+}
+
+result<void, E2> fy3( Y )
+{
+    return {};
+}
+
+result<int, E2> fri( int& x )
+{
+    return x * 2 + 1;
+}
+
+result<int&, E2> fri2( int& )
+{
+    return E2();
+}
+
+result<void, E2> fri3( int& )
+{
+    return {};
+}
+
+result<int, E2> fk()
+{
+    return 7;
+}
+
+result<int, E2> fk2()
+{
+    return E2();
+}
+
+result<void, E2> fk3()
+{
+    return {};
+}
+
+result<void, E2> fk4()
+{
+    return E2();
+}
+
+int main()
+{
+    {
+        result<int, E> r( 1 );
+
+        {
+            result<int, E2> r2 = r & fi;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+        }
+
+        {
+            result<int, E2> r2 = r & fi2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fi3;
+            BOOST_TEST( r2.has_value() );
+        }
+    }
+
+    {
+        result<int, E> const r( 1 );
+
+        {
+            result<int, E2> r2 = r & fi;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+        }
+
+        {
+            result<int, E2> r2 = r & fi2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fi3;
+            BOOST_TEST( r2.has_value() );
+        }
+    }
+
+    {
+        result<int, E2> r2 = result<int, E>( 1 ) & fi;
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+    }
+
+    {
+        result<int, E2> r2 = result<int, E>( 1 ) & fi2;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E2> r2 = result<int, E>( 1 ) & fi3;
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<int, E> r( in_place_error );
+
+        {
+            result<int, E2> r2 = r & fi;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int, E2> r2 = r & fi2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fi3;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<int, E> const r( in_place_error );
+
+        {
+            result<int, E2> r2 = r & fi;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int, E2> r2 = r & fi2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fi3;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<int, E2> r2 = result<int, E>( in_place_error ) & fi;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E2> r2 = result<int, E>( in_place_error ) & fi2;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E2> r2 = result<int, E>( in_place_error ) & fi3;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X, E2> r2 = result<Y, E>( in_place_value, 1 ) & fy;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2->v_, 3 );
+    }
+
+    {
+        result<X, E2> r2 = result<Y, E>( in_place_value, 1 ) & fy2;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E2> r2 = result<Y, E>( in_place_value, 1 ) & fy3;
+
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<X, E2> r2 = result<Y, E>( in_place_error ) & fy;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X, E2> r2 = result<Y, E>( in_place_error ) & fy2;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E2> r2 = result<Y, E>( in_place_error ) & fy3;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        int x1 = 1;
+        result<int&, E> r( x1 );
+
+        {
+            result<int, E2> r2 = r & fri;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+        }
+
+        {
+            result<int&, E2> r2 = r & fri2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fri3;
+            BOOST_TEST( r2.has_value() );
+        }
+    }
+
+    {
+        int x1 = 1;
+        result<int&, E> const r( x1 );
+
+        {
+            result<int, E2> r2 = r & fri;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+        }
+
+        {
+            result<int&, E2> r2 = r & fri2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fri3;
+            BOOST_TEST( r2.has_value() );
+        }
+    }
+
+    {
+        int x1 = 1;
+
+        result<int, E2> r2 = result<int&, E>( x1 ) & fri;
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&, E2> r2 = result<int&, E>( x1 ) & fri2;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        int x1 = 1;
+
+        result<void, E2> r2 = result<int&, E>( x1 ) & fri3;
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<int&, E> r( in_place_error );
+
+        {
+            result<int, E2> r2 = r & fri;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int&, E2> r2 = r & fri2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fri3;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<int&, E> const r( in_place_error );
+
+        {
+            result<int, E2> r2 = r & fri;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int&, E2> r2 = r & fri2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fri3;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<int, E2> r2 = result<int&, E>( in_place_error ) & fri;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int&, E2> r2 = result<int&, E>( in_place_error ) & fri2;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E2> r2 = result<int&, E>( in_place_error ) & fri3;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E> r;
+
+        {
+            result<int, E2> r2 = r & fk;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+        }
+
+        {
+            result<int, E2> r2 = r & fk2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fk3;
+            BOOST_TEST( r2.has_value() );
+        }
+
+        {
+            result<void, E2> r2 = r & fk4;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<void, E> const r;
+
+        {
+            result<int, E2> r2 = r & fk;
+            BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+        }
+
+        {
+            result<int, E2> r2 = r & fk2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fk3;
+            BOOST_TEST( r2.has_value() );
+        }
+
+        {
+            result<void, E2> r2 = r & fk4;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<int, E2> r2 = result<void, E>() & fk;
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+    }
+
+    {
+        result<int, E2> r2 = result<void, E>() & fk2;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E2> r2 = result<void, E>() & fk3;
+        BOOST_TEST( r2.has_value() );
+    }
+
+    {
+        result<void, E2> r2 = result<void, E>() & fk4;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E> r( in_place_error );
+
+        {
+            result<int, E2> r2 = r & fk;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int, E2> r2 = r & fk2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fk3;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fk4;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<void, E> const r( in_place_error );
+
+        {
+            result<int, E2> r2 = r & fk;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<int, E2> r2 = r & fk2;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fk3;
+            BOOST_TEST( r2.has_error() );
+        }
+
+        {
+            result<void, E2> r2 = r & fk4;
+            BOOST_TEST( r2.has_error() );
+        }
+    }
+
+    {
+        result<int, E2> r2 = result<void, E>( in_place_error ) & fk;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E2> r2 = result<void, E>( in_place_error ) & fk2;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E2> r2 = result<void, E>( in_place_error ) & fk3;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E2> r2 = result<void, E>( in_place_error ) & fk4;
+        BOOST_TEST( r2.has_error() );
+    }
+
+    return boost::report_errors();
+}

test/result_and_fn1v.cpp

@@ -0,0 +1,331 @@
+// Copyright 2017, 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    int v_;
+};
+
+struct Y
+{
+    int v_;
+
+    explicit Y( int v ): v_( v ) {}
+    Y( X x ): v_( x.v_) {}
+
+    Y( Y const& ) = delete;
+    Y& operator=( Y const& ) = delete;
+
+    Y( Y&& r ): v_( r.v_ )
+    {
+        r.v_ = 0;
+    }
+
+    Y& operator=( Y&& ) = delete;
+};
+
+struct E
+{
+};
+
+int f( int x )
+{
+    return x * 2 + 1;
+}
+
+X g( Y y )
+{
+    return X{ y.v_ * 2 + 1 };
+}
+
+int& h( int& )
+{
+    static int x = 2;
+    return x;
+}
+
+int k()
+{
+    return 7;
+}
+
+static int fv1_called_with;
+
+void fv1( int x )
+{
+    fv1_called_with = x;
+}
+
+static int fv2_called;
+
+void fv2()
+{
+    ++fv2_called;
+}
+
+int main()
+{
+    {
+        result<int> r( 1 );
+        result<int> r2 = r & f;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+    }
+
+    {
+        result<int> const r( 1 );
+        result<int> r2 = r & f;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+    }
+
+    {
+        result<int> r2 = result<int>( 1 ) & f;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 3 );
+    }
+
+    {
+        result<int, E> r( in_place_error );
+        result<int, E> r2 = r & f;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E> const r( in_place_error );
+        result<int, E> r2 = r & f;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E> r2 = result<int, E>( in_place_error ) & f;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<X> r2 = result<Y>( in_place_value, 1 ) & g;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2->v_, 3 );
+    }
+
+    {
+        result<X, E> r2 = result<Y, E>( in_place_error ) & g;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> r( x1 );
+
+        result<int&> r2 = r & h;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &h( x1 ) );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> const r( x1 );
+
+        result<int&> r2 = r & h;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &h( x1 ) );
+    }
+
+    {
+        int x1 = 1;
+
+        result<int&> r2 = result<int&>( x1 ) & h;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( &*r2, &h( x1 ) );
+    }
+
+    {
+        result<int&, E> r( in_place_error );
+
+        result<int&, E> r2 = r & h;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int&, E> const r( in_place_error );
+
+        result<int&, E> r2 = r & h;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int&, E> r2 = result<int&, E>( in_place_error ) & h;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void> r;
+        result<int> r2 = r & k;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+    }
+
+    {
+        result<void> const r;
+        result<int> r2 = r & k;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+    }
+
+    {
+        result<int> r2 = result<void>() & k;
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( *r2, 7 );
+    }
+
+    {
+        result<void, E> r( in_place_error );
+        result<int, E> r2 = r & k;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<void, E> const r( in_place_error );
+        result<int, E> r2 = r & k;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        result<int, E> r2 = result<void, E>( in_place_error ) & k;
+
+        BOOST_TEST( r2.has_error() );
+    }
+
+    {
+        fv1_called_with = 0;
+
+        result<int> r( 1 );
+        result<void> r2 = r & fv1;
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
+    }
+
+    {
+        result<int> const r( 1 );
+        result<void> r2 = r & fv1;
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
+    }
+
+    {
+        fv1_called_with = 0;
+
+        result<void> r2 = result<int>( 1 ) & fv1;
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
+    }
+
+    {
+        fv1_called_with = 0;
+
+        result<int, E> r( in_place_error );
+        result<void, E> r2 = r & fv1;
+
+        BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
+    }
+
+    {
+        fv1_called_with = 0;
+
+        result<int, E> const r( in_place_error );
+        result<void, E> r2 = r & fv1;
+
+        BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
+    }
+
+    {
+        fv1_called_with = 0;
+
+        result<void, E> r2 = result<int, E>( in_place_error ) & fv1;
+
+        BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
+    }
+
+    {
+        result<void> r;
+        fv2_called = 0;
+
+        result<void> r2 = r & fv2;
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
+    }
+
+    {
+        result<void> const r;
+        fv2_called = 0;
+
+        result<void> r2 = r & fv2;
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
+    }
+
+    {
+        fv2_called = 0;
+
+        result<void> r2 = result<void>() & fv2;
+
+        BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
+    }
+
+    {
+        result<void, E> r( in_place_error );
+        fv2_called = 0;
+
+        result<void, E> r2 = r & fv2;
+
+        BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
+    }
+
+    {
+        result<void, E> const r( in_place_error );
+        fv2_called = 0;
+
+        result<void, E> r2 = r & fv2;
+
+        BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
+    }
+
+    {
+        fv2_called = 0;
+
+        result<void, E> r2 = result<void, E>( in_place_error ) & fv2;
+
+        BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
+    }
+
+    return boost::report_errors();
+}