Avoid pedantic warning for trailing comma in enum

More fixes for implicit int conversions
Fix implicit conversion to int errors
2021-12-10 00:29:17 +02:00 · 2021-12-10 00:22:25 +02:00 · 2021-12-09 22:26:18 +02:00 · 2021-12-09 22:17:47 +02:00
43 changed files with 403 additions and 2057 deletions
@@ -1,253 +0,0 @@
-# Copyright 2022 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-local library = "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',
-                '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 14.04 GCC 4.4",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
-        "g++-4.4",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.6",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x' },
-        "g++-4.6",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.7",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x' },
-        "g++-4.7",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.8*",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11' },
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.9",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11' },
-        "g++-4.9",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 16.04 GCC 5*",
-        "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14' },
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 GCC 6",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14' },
-        "g++-6",
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 GCC 7* 32/64",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
-    ),
-
-    linux_pipeline(
-        "Linux 18.04 GCC 8",
-        "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17' },
-        "g++-8",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* 32",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32' },
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* 64",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '64' },
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9 ARM64 32/64",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
-        arch="arm64",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 10 32 ASAN",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32' } + asan,
-        "g++-10-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 10 64 ASAN",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '64' } + asan,
-        "g++-10-multilib",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 13",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
-        "clang-13",
-        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main"],
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 14 UBSAN",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20' } + ubsan,
-        "clang-14",
-        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main"],
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 Clang 14 ASAN",
-        "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20' } + asan,
-        "clang-14",
-        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main"],
-    ),
-
-    macos_pipeline(
-        "MacOS 10.15 Xcode 12.2 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
-    ),
-
-    macos_pipeline(
-        "MacOS 10.15 Xcode 12.2 ASAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
-    ),
-
-    windows_pipeline(
-        "Windows VS2015 msvc-14.0",
-        "cppalliance/dronevs2015",
-        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest' },
-    ),
-
-    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' },
-    ),
-]
@@ -1,23 +0,0 @@
-@REM Copyright 2022 Peter Dimov
-@REM Distributed under the Boost Software License, Version 1.0.
-@REM https://www.boost.org/LICENSE_1_0.txt
-
-@ECHO ON
-
-set LIBRARY=%1
-set DRONE_BUILD_DIR=%CD%
-
-set BOOST_BRANCH=develop
-if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
-cd ..
-git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-cd boost-root
-git submodule update --init tools/boostdep
-xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
-python tools/boostdep/depinst/depinst.py %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
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-# Copyright 2022 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-set -ex
-
-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}
@@ -47,10 +47,6 @@ jobs:
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
            install: g++-11
-          - toolset: gcc-12
-            cxxstd: "03,11,14,17,20"
-            os: ubuntu-22.04
-            install: g++-12
          - toolset: clang
            compiler: clang++-3.9
            cxxstd: "03,11,14"
@@ -96,18 +92,8 @@ jobs:
            os: ubuntu-20.04
          - toolset: clang
            compiler: clang++-12
-            cxxstd: "03,11,14,17,20"
+            cxxstd: "03,11,14,17,2a"
            os: ubuntu-20.04
-          - toolset: clang
-            compiler: clang++-13
-            cxxstd: "03,11,14,17,20"
-            os: ubuntu-22.04
-            install: clang-13
-          - toolset: clang
-            compiler: clang++-14
-            cxxstd: "03,11,14,17,20"
-            os: ubuntu-22.04
-            install: clang-14
          - toolset: clang
            cxxstd: "03,11,14,17,2a"
            os: macos-10.15
@@ -158,19 +144,15 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: msvc-14.0
-            cxxstd: "14"
+          - toolset: msvc-14.1
+            cxxstd: "14,17,latest"
            addrmd: 32,64
-            os: windows-2019
+            os: windows-2016
          - toolset: msvc-14.2
-            cxxstd: "14,17,20,latest"
+            cxxstd: "14,17,latest"
            addrmd: 32,64
            os: windows-2019
          - toolset: msvc-14.3
-            cxxstd: "14,17,20,latest"
-            addrmd: 32,64
-            os: windows-2022
-          - toolset: clang-win
            cxxstd: "14,17,latest"
            addrmd: 32,64
            os: windows-2022
@@ -210,7 +192,7 @@ jobs:
        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
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release

  posix-cmake-subdir:
    strategy:
@@ -219,7 +201,6 @@ jobs:
        include:
          - os: ubuntu-18.04
          - os: ubuntu-20.04
-          - os: ubuntu-22.04
          - os: macos-10.15

    runs-on: ${{matrix.os}}
@@ -266,7 +247,6 @@ jobs:
        include:
          - os: ubuntu-18.04
          - os: ubuntu-20.04
-          - os: ubuntu-22.04
          - os: macos-10.15

    runs-on: ${{matrix.os}}
@@ -323,7 +303,6 @@ jobs:
        include:
          - os: ubuntu-18.04
          - os: ubuntu-20.04
-          - os: ubuntu-22.04
          - os: macos-10.15

    runs-on: ${{matrix.os}}
@@ -1,25 +0,0 @@
-# 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).
@@ -22,8 +22,20 @@ environment:
      ADDRMD: 32,64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: msvc-14.1
+      CXXSTD: 14,17
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      CXXSTD: 14,17
+      ADDRMD: 64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: msvc-14.2
      CXXSTD: 14,17,latest
      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: clang-win
+      CXXSTD: 14,17,latest
+      ADDRMD: 64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\cygwin\bin;
      TOOLSET: gcc
@@ -1,5 +1,5 @@
 ////
-Copyright 2018-2022 Peter Dimov
+Copyright 2018-2021 Peter Dimov
 Distributed under the Boost Software License, Version 1.0.
 https://www.boost.org/LICENSE_1_0.txt
 ////
@@ -8,25 +8,6 @@ https://www.boost.org/LICENSE_1_0.txt
 # Revision History
 :idprefix:

-## 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`.
@@ -14,6 +14,6 @@ http://www.boost.org/LICENSE_1_0.txt
 This documentation is

 * Copyright 2003-2017 Beman Dawes
-* Copyright 2018-2022 Peter Dimov
+* Copyright 2018-2021 Peter Dimov

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

 Distributed under the Boost Software License, Version 1.0.

@@ -185,12 +185,8 @@ namespace errc {
 template<> struct is_error_condition_enum<errc::errc_t>
  { static const bool value = true; };

-constexpr error_condition make_error_condition( errc::errc_t e ) noexcept;
-
 constexpr error_code make_error_code( errc::errc_t e ) noexcept;
-
-error_code make_error_code( errc::errc_t e,
-  boost::source_location const * loc ) noexcept;
+constexpr error_condition make_error_condition( errc::errc_t e ) noexcept;

 } // namespace system
 } // namespace boost
@@ -260,38 +256,6 @@ void my_api_function( boost::system::error_code& ec )
 }
 ```

-```
-constexpr error_code make_error_code( errc::errc_t e,
-  boost::source_location const * loc ) noexcept;
-```
-[none]
-* {blank}
-+
-Returns: :: `error_code( e, generic_category(), loc )`.
-
-Same as the above overload, but takes a source location.
-* {blank}
-+
-```
-void my_api_function( boost::system::error_code& ec )
-{
-    void* p = std::malloc( 16 );
-
-    if( p == 0 )
-    {
-        // return ENOMEM
-
-        BOOST_STATIC_CONSTEXPR boost::source_location loc =
-          BOOST_CURRENT_LOCATION;
-
-        ec = make_error_code( boost::system::errc::out_of_memory, &loc );
-        return;
-    }
-
-    // use p
-}
-```
-
 ## <boost/system/{zwsp}error_category.hpp>

 ### error_category
@@ -610,8 +574,9 @@ public:
    template<class ErrorCodeEnum>
      constexpr error_code( ErrorCodeEnum e ) noexcept;

-    error_code( error_code const& ec,
-      boost::source_location const * loc ) noexcept;
+    template<class ErrorCodeEnum>
+      error_code( ErrorCodeEnum e, boost::source_location const * loc )
+        noexcept;

    error_code( std::error_code const& ec ) noexcept;

@@ -625,8 +590,9 @@ public:
    template<class ErrorCodeEnum>
      constexpr error_code & operator=( ErrorCodeEnum e ) noexcept;

-    void assign( error_code const& ec,
-      boost::source_location const * loc ) noexcept;
+    template<class ErrorCodeEnum>
+      void assign( ErrorCodeEnum e,
+        boost::source_location const * loc ) noexcept;

    constexpr void clear() noexcept;

@@ -755,17 +721,17 @@ Ensures: :: `*this == make_error_code( e )`.
 Remarks: :: This constructor is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.

 ```
-error_code( error_code const& ec,
-  boost::source_location const * loc ) noexcept;
+template<class ErrorCodeEnum>
+  error_code( ErrorCodeEnum e, boost::source_location const * loc ) noexcept;
 ```
 [none]
 * {blank}
 +
-Requires: :: `loc` points to a valid `boost::source_location` object with static storage duration, or is `nullptr`.
-Ensures: :: `*this == ec`.
-Remarks: :: When `ec` is a default-constructed `error_code` or wraps a `std::error_code`,
-  or when `loc` is `nullptr`, `*this` stores no location (`has_location()` is `false`).
-  Otherwise, `*this` stores `loc` (`has_location()` is `true` and `&location()` is `loc`.)
+Requires: :: `loc` points to a valid `boost::source_location` object with static storage duration.
+Ensures: :: `*this == make_error_code( e )`.
+Remarks: :: This constructor is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
+  When `make_error_code( e )` is not a default-constructed `error_code` and doesn't wrap a
+  `std::error_code`, `has_location()` is `true` and `&location()` is `loc`.

 ```
 error_code( std::error_code const & ec ) noexcept;
@@ -806,13 +772,16 @@ Ensures: :: `*this == make_error_code( e )`.
 Remarks: :: This operator is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.

 ```
-void assign( error_code const& ec,
-  boost::source_location const * loc ) noexcept;
+template<class ErrorCodeEnum>
+  void assign( ErrorCodeEnum e,
+    boost::source_location const * loc ) noexcept;
 ```
 [none]
 * {blank}
 +
-Effects: :: `*this = error_code( ec, loc )`.
+Requires: :: `loc` points to a valid `boost::source_location` object with static storage duration.
+Effects: :: `*this = error_code( e, loc )`.
+Remarks: :: This function is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.

 ```
 constexpr void clear() noexcept;
@@ -1485,20 +1454,7 @@ namespace system {

 // throw_exception_from_error

-BOOST_NORETURN inline void throw_exception_from_error( error_code const & e,
-  boost::source_location const & loc );
-
-BOOST_NORETURN inline void throw_exception_from_error( std::error_code const & e,
-  boost::source_location const & loc );
-
-BOOST_NORETURN inline void throw_exception_from_error( errc::errc_t const & e,
-  boost::source_location const & loc );
-
-BOOST_NORETURN inline void throw_exception_from_error( std::errc const & e,
-  boost::source_location const & loc );
-
-BOOST_NORETURN inline void throw_exception_from_error( std::exception_ptr & e,
-  boost::source_location const & loc );
+BOOST_NORETURN inline void throw_exception_from_error( error_code const & e );

 // in_place_*

@@ -1530,57 +1486,13 @@ If `result<T, E>` is used with other error types, the user is expected to provid
 an appropriate overload of `throw_exception_from_error` in the namespace of `E`.

 ```
-BOOST_NORETURN inline void throw_exception_from_error( error_code const & e,
-  boost::source_location const & loc );
+BOOST_NORETURN inline void throw_exception_from_error( error_code const & e );
 ```
 [none]
 * {blank}
 +
 Effects: ::
-  `boost::throw_with_location( system_error( e ), loc )`.
-
-```
-BOOST_NORETURN inline void throw_exception_from_error( std::error_code const & e,
-  boost::source_location const & loc );
-```
-[none]
-* {blank}
-+
-Effects: ::
-  `boost::throw_with_location( std::system_error( e ), loc )`.
-
-```
-BOOST_NORETURN inline void throw_exception_from_error( errc::errc_t const & e,
-  boost::source_location const & loc );
-```
-[none]
-* {blank}
-+
-Effects: ::
-  `boost::throw_with_location( system_error( make_error_code( e ) ), loc )`.
-
-```
-BOOST_NORETURN inline void throw_exception_from_error( std::errc const & e,
-  boost::source_location const & loc );
-```
-[none]
-* {blank}
-+
-Effects: ::
-  `boost::throw_with_location( std::system_error( make_error_code( e ) ), loc )`.
-
-```
-BOOST_NORETURN inline void throw_exception_from_error( std::exception_ptr & e,
-  boost::source_location const & loc );
-```
-[none]
-* {blank}
-+
-Effects: ::
-+
-[disc]
-** If `e` isn't null, `std::rethrow_exception( e )`.
-** Otherwise, `boost::throw_with_location( std::bad_exception(), loc )`.
+  `boost::throw_exception( system_error( e ) )`.

 ### result<T, E>

@@ -1608,12 +1520,6 @@ public:
    template<class... A>
      constexpr result( in_place_error_t, A&&... a );

-    template<class T2, class E2>
-      constexpr result( result<T2, E2> const& r2 );
-
-    template<class T2, class E2>
-      constexpr result( result<T2, E2>&& r2 );
-
    // queries

    constexpr bool has_value() const noexcept;
@@ -1622,17 +1528,10 @@ public:

    // checked value access

-    constexpr T& value( boost::source_location const & loc =
-      BOOST_CURRENT_LOCATION ) & ;
-
-    constexpr T const& value( boost::source_location const & loc =
-      BOOST_CURRENT_LOCATION ) const& ;
-
-    constexpr T&& value( boost::source_location const & loc =
-      BOOST_CURRENT_LOCATION ) && ;
-
-    constexpr T const&& value( boost::source_location const & loc =
-      BOOST_CURRENT_LOCATION ) const&& ;
+    constexpr T& value() & ;
+    constexpr T const& value() const& ;
+    constexpr T&& value() && ;
+    constexpr T const&& value() const&& ;

    // unchecked value access

@@ -1722,30 +1621,6 @@ Ensures: ::
 Remarks: ::
  This constructor is only enabled when `std::is_constructible<E, A...>::value` is `true`.

-```
-template<class T2, class E2>
-  constexpr result( result<T2, E2> const& r2 );
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  If `r2.has_value()` is `true`, `*this` holds the value `T( *r2 )`, otherwise `*this` holds the value `E( r2.error() )`.
-Remarks: ::
-  This constructor is only enabled when `std::is_convertible<T2, T>::value && std::is_convertible<E2, E>::value` is `true`.
-
-```
-template<class T2, class E2>
-  constexpr result( result<T2, E2>&& r2 );
-```
-[none]
-* {blank}
-+
-Ensures: ::
-  If `r2.has_value()` is `true`, `*this` holds the value `T( std::move( *r2 ) )`, otherwise `*this` holds the value `E( r2.error() )`.
-Remarks: ::
-  This constructor is only enabled when `std::is_convertible<T2, T>::value && std::is_convertible<E2, E>::value` is `true`.
-
 #### Queries

 ```
@@ -1778,17 +1653,10 @@ Returns: ::
 #### Checked Value Access

 ```
-constexpr T& value(
-  boost::source_location const & loc = BOOST_CURRENT_LOCATION ) & ;
-
-constexpr T const& value(
-  boost::source_location const & loc = BOOST_CURRENT_LOCATION ) const& ;
-
-constexpr T&& value(
-  boost::source_location const & loc = BOOST_CURRENT_LOCATION ) && ;
-
-constexpr T const&& value(
-  boost::source_location const & loc = BOOST_CURRENT_LOCATION ) const&& ;
+constexpr T& value() & ;
+constexpr T const& value() const& ;
+constexpr T&& value() && ;
+constexpr T const&& value() const&& ;
 ```
 [none]
 * {blank}
@@ -1796,7 +1664,7 @@ constexpr T const&& value(
 Effects: ::
  If `*this` holds a value, returns a reference to it. Otherwise,
  calls `throw_exception_from_error`, passing it a reference to
-  the held error, and `loc`.
+  the held error.

 #### Unchecked Value Access

@@ -1931,8 +1799,7 @@ public:

    // checked value access

-    constexpr void value( boost::source_location const & loc =
-      BOOST_CURRENT_LOCATION ) const;
+    constexpr void value() const;

    // unchecked value access

@@ -2045,15 +1912,14 @@ Returns: ::
 #### Checked Value Access

 ```
-constexpr void value(
-  boost::source_location const & loc = BOOST_CURRENT_LOCATION ) const;
+constexpr void value() const;
 ```
 [none]
 * {blank}
 +
 Effects: ::
  If `*this` doesn't hold a value, calls `throw_exception_from_error`,
-  passing it a reference to the held error, and `loc`.
+  passing it a reference to the held error.

 #### Unchecked Value Access

@@ -9,9 +9,8 @@

 #include <boost/system/error_code.hpp>
 #include <boost/system/system_error.hpp>
-#include <boost/config.hpp>

-#if (__cplusplus >= 201103L) && !(defined(BOOST_GCC) && BOOST_GCC < 40800) || (defined(_MSC_VER) && _MSC_VER >= 1900)
+#if (__cplusplus >= 201103L) || (defined(_MSC_VER) && _MSC_VER >= 1900)
 # include <boost/system/result.hpp>
 #endif

@@ -1,7 +1,7 @@
 #ifndef BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
 #define BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED

-// Copyright 2018-2022 Peter Dimov
+// 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)
@@ -13,7 +13,7 @@

 // BOOST_SYSTEM_HAS_SYSTEM_ERROR

-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC) && !defined(BOOST_NO_CXX11_HDR_MUTEX)
+#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC)
 # define BOOST_SYSTEM_HAS_SYSTEM_ERROR
 #endif

@@ -62,20 +62,4 @@
 # 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
@@ -12,101 +12,124 @@

 #include <boost/system/is_error_condition_enum.hpp>
 #include <boost/system/detail/cerrno.hpp>
+#include <boost/config.hpp>

 namespace boost
 {
-
 namespace system
 {

+#define BOOST_SYSTEM_ENUMERATE_ERRC(F, G) \
+    F(success, 0) \
+    F(address_family_not_supported, EAFNOSUPPORT) \
+    F(address_in_use, EADDRINUSE) \
+    F(address_not_available, EADDRNOTAVAIL) \
+    F(already_connected, EISCONN) \
+    F(argument_list_too_long, E2BIG) \
+    F(argument_out_of_domain, EDOM) \
+    F(bad_address, EFAULT) \
+    F(bad_file_descriptor, EBADF) \
+    F(bad_message, EBADMSG) \
+    F(broken_pipe, EPIPE) \
+    F(connection_aborted, ECONNABORTED) \
+    F(connection_already_in_progress, EALREADY) \
+    F(connection_refused, ECONNREFUSED) \
+    F(connection_reset, ECONNRESET) \
+    F(cross_device_link, EXDEV) \
+    F(destination_address_required, EDESTADDRREQ) \
+    F(device_or_resource_busy, EBUSY) \
+    F(directory_not_empty, ENOTEMPTY) \
+    F(executable_format_error, ENOEXEC) \
+    F(file_exists, EEXIST) \
+    F(file_too_large, EFBIG) \
+    F(filename_too_long, ENAMETOOLONG) \
+    F(function_not_supported, ENOSYS) \
+    F(host_unreachable, EHOSTUNREACH) \
+    F(identifier_removed, EIDRM) \
+    F(illegal_byte_sequence, EILSEQ) \
+    F(inappropriate_io_control_operation, ENOTTY) \
+    F(interrupted, EINTR) \
+    F(invalid_argument, EINVAL) \
+    F(invalid_seek, ESPIPE) \
+    F(io_error, EIO) \
+    F(is_a_directory, EISDIR) \
+    F(message_size, EMSGSIZE) \
+    F(network_down, ENETDOWN) \
+    F(network_reset, ENETRESET) \
+    F(network_unreachable, ENETUNREACH) \
+    F(no_buffer_space, ENOBUFS) \
+    F(no_child_process, ECHILD) \
+    F(no_link, ENOLINK) \
+    F(no_lock_available, ENOLCK) \
+    F(no_message_available, ENODATA) \
+    F(no_message, ENOMSG) \
+    F(no_protocol_option, ENOPROTOOPT) \
+    F(no_space_on_device, ENOSPC) \
+    F(no_stream_resources, ENOSR) \
+    F(no_such_device_or_address, ENXIO) \
+    F(no_such_device, ENODEV) \
+    F(no_such_file_or_directory, ENOENT) \
+    F(no_such_process, ESRCH) \
+    F(not_a_directory, ENOTDIR) \
+    F(not_a_socket, ENOTSOCK) \
+    F(not_a_stream, ENOSTR) \
+    F(not_connected, ENOTCONN) \
+    F(not_enough_memory, ENOMEM) \
+    F(not_supported, ENOTSUP) \
+    F(operation_canceled, ECANCELED) \
+    F(operation_in_progress, EINPROGRESS) \
+    F(operation_not_permitted, EPERM) \
+    F(operation_not_supported, EOPNOTSUPP) \
+    F(operation_would_block, EWOULDBLOCK) \
+    F(owner_dead, EOWNERDEAD) \
+    F(permission_denied, EACCES) \
+    F(protocol_error, EPROTO) \
+    F(protocol_not_supported, EPROTONOSUPPORT) \
+    F(read_only_file_system, EROFS) \
+    F(resource_deadlock_would_occur, EDEADLK) \
+    F(resource_unavailable_try_again, EAGAIN) \
+    F(result_out_of_range, ERANGE) \
+    F(state_not_recoverable, ENOTRECOVERABLE) \
+    F(stream_timeout, ETIME) \
+    F(text_file_busy, ETXTBSY) \
+    F(timed_out, ETIMEDOUT) \
+    F(too_many_files_open_in_system, ENFILE) \
+    F(too_many_files_open, EMFILE) \
+    F(too_many_links, EMLINK) \
+    F(too_many_symbolic_link_levels, ELOOP) \
+    F(value_too_large, EOVERFLOW) \
+    G(wrong_protocol_type, EPROTOTYPE)
+
 namespace errc
 {

+#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_SYSTEM_ENABLE_DEPRECATED)
+enum class errc_t
+#else
 enum errc_t
+#endif
 {
-    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
-};
+
+#define BOOST_SYSTEM_DEFINE_ERRC(x, y) x = y,
+#define BOOST_SYSTEM_DEFINE_ERRC2(x, y) x = y
+BOOST_SYSTEM_ENUMERATE_ERRC(BOOST_SYSTEM_DEFINE_ERRC, BOOST_SYSTEM_DEFINE_ERRC2)
+#undef BOOST_SYSTEM_DEFINE_ERRC
+#undef BOOST_SYSTEM_DEFINE_ERRC2
+
+}; // enum errc_t
+
+#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_SYSTEM_ENABLE_DEPRECATED)
+
+#define BOOST_SYSTEM_SURFACE_ERRC(x, y) BOOST_CONSTEXPR_OR_CONST errc_t x = errc_t::x;
+BOOST_SYSTEM_ENUMERATE_ERRC(BOOST_SYSTEM_SURFACE_ERRC, BOOST_SYSTEM_SURFACE_ERRC)
+#undef BOOST_SYSTEM_SURFACE_ERRC
+
+#endif

 } // namespace errc

+#undef BOOST_SYSTEM_ENUMERATE_ERRC
+
 #ifdef BOOST_SYSTEM_ENABLE_DEPRECATED

 namespace posix = errc;
@@ -120,7 +143,6 @@ template<> struct is_error_condition_enum<errc::errc_t>
 };

 } // namespace system
-
 } // namespace boost

 #endif // #ifndef BOOST_SYSTEM_DETAIL_ERRC_HPP_INCLUDED
@@ -48,11 +48,6 @@ class std_category;
 #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #endif

-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable: 4351) //  new behavior: elements of array will be default initialized
-#endif
-
 class BOOST_SYMBOL_VISIBLE error_category
 {
 private:
@@ -81,21 +76,13 @@ 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_;
-    };
-
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

-    mutable std::atomic< unsigned > sc_init_;
+    mutable std::atomic< boost::system::detail::std_category* > ps_;

 #else

-    unsigned sc_init_;
+    boost::system::detail::std_category* ps_;

 #endif

@@ -116,11 +103,11 @@ protected:

 #endif

-    BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 ), stdcat_(), sc_init_()
+    BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 ), ps_()
    {
    }

-    explicit BOOST_SYSTEM_CONSTEXPR error_category( boost::ulong_long_type id ) BOOST_NOEXCEPT: id_( id ), stdcat_(), sc_init_()
+    explicit BOOST_SYSTEM_CONSTEXPR error_category( boost::ulong_long_type id ) BOOST_NOEXCEPT: id_( id ), ps_()
    {
    }

@@ -171,22 +158,14 @@ public:
    }

 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-    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
-
 #endif
 };

-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
 #if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
 #pragma GCC diagnostic pop
 #endif
@@ -14,7 +14,6 @@
 #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>
@@ -97,66 +96,26 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t

 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

-#include <boost/system/detail/std_category_impl.hpp>
-#include <mutex>
-#include <new>
+#include <boost/system/detail/std_category.hpp>

 namespace boost
 {
 namespace system
 {

-namespace detail
-{
-
-template<class = void> struct stdcat_mx_holder
-{
-    static std::mutex mx_;
-};
-
-template<class T> std::mutex stdcat_mx_holder<T>::mx_;
-
-} // namespace detail
-
-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
-
-    std::lock_guard<std::mutex> lk( boost::system::detail::stdcat_mx_holder<>::mx_ );
-
-    if( sc_init_.load( std::memory_order_acquire ) == 0 )
-    {
-        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, 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
+inline 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)
+#if defined(BOOST_GCC) && BOOST_GCC < 50000

-        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
-        return generic_instance;
+    static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
+    return generic_instance;

 #else

-        return std::generic_category();
+    return std::generic_category();

 #endif
    }
@@ -164,29 +123,40 @@ inline BOOST_NOINLINE error_category::operator std::error_category const & () co
    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)
+#if defined(__CYGWIN__) || defined(__MINGW32__) || (defined(_MSC_VER) && _MSC_VER == 1800) || (defined(BOOST_GCC) && BOOST_GCC < 50000)

-        static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
-        return system_instance;
+    // Under Cygwin (and MinGW!), std::system_category() is POSIX
+    // Under VS2013, std::system_category() isn't quite right
+
+    static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
+    return system_instance;

 #else

-        return std::system_category();
+    return std::system_category();

 #endif
    }

-    if( sc_init_.load( std::memory_order_acquire ) == 0 )
+    detail::std_category* p = ps_.load( std::memory_order_acquire );
+
+    if( p != 0 )
    {
-        init_stdcat();
+        return *p;
    }

-    return *static_cast<boost::system::detail::std_category const*>( static_cast<void const*>( stdcat_ ) );
-}
+    detail::std_category* q = new detail::std_category( this, 0 );

-#if defined( BOOST_GCC ) && BOOST_GCC >= 40800 && BOOST_GCC < 70000
-#pragma GCC diagnostic pop
-#endif
+    if( ps_.compare_exchange_strong( p, q, std::memory_order_release, std::memory_order_acquire ) )
+    {
+        return *q;
+    }
+    else
+    {
+        delete q;
+        return *p;
+    }
+}

 } // namespace system
 } // namespace boost
@@ -21,11 +21,6 @@
 #include <boost/system/detail/append_int.hpp>
 #include <boost/system/detail/snprintf.hpp>
 #include <boost/system/detail/config.hpp>
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-# include <boost/system/detail/std_category.hpp>
-#endif
-
 #include <boost/assert/source_location.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/config.hpp>
@@ -88,28 +83,6 @@ private:
    // >3: pointer to source_location, failed_ in lsb
    boost::uintptr_t lc_flags_;

-private:
-
-    char const* category_name() const BOOST_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:
@@ -144,35 +117,28 @@ public:
        *this = make_error_code( e );
    }

-    error_code( error_code const& ec, source_location const * loc ) BOOST_NOEXCEPT:
+    template<class ErrorCodeEnum> error_code( ErrorCodeEnum e, source_location const * loc,
+        typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type* = 0 ) BOOST_NOEXCEPT:
        d1_(), lc_flags_( 0 )
    {
-        *this = ec;
+        error_code e2 = make_error_code( e );

-        if( ec.lc_flags_ != 0 && ec.lc_flags_ != 1 )
+        if( e2.lc_flags_ == 0 || e2.lc_flags_ == 1 )
        {
-            lc_flags_ = ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | ( ec.lc_flags_ & 1 );
+            *this = e2;
+        }
+        else
+        {
+            *this = error_code( e2.d1_.val_, *e2.d1_.cat_, loc );
        }
    }

 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

    error_code( std::error_code const& ec ) BOOST_NOEXCEPT:
-        d1_(), lc_flags_( 0 )
+        lc_flags_( 1 )
    {
-#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;
-        }
+        ::new( d2_ ) std::error_code( ec );
    }

 #endif
@@ -189,11 +155,6 @@ public:
        *this = error_code( val, cat, loc );
    }

-    void assign( error_code const& ec, source_location const * loc ) BOOST_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 ) BOOST_NOEXCEPT
@@ -202,6 +163,13 @@ public:
        return *this;
    }

+    template<typename ErrorCodeEnum>
+        typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, void>::type
+        assign( ErrorCodeEnum val, source_location const * loc ) BOOST_NOEXCEPT
+    {
+        *this = error_code( val, loc );
+    }
+
    BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
    {
        *this = error_code();
@@ -220,11 +188,7 @@ public:
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

            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 );
+            return ec.value() + 1000 * static_cast<unsigned>( reinterpret_cast<boost::uintptr_t>( &ec.category() ) % 2097143 ); // 2^21-9, prime
 #else

            return -1;
@@ -266,14 +230,7 @@ public:

 #endif

-        if( lc_flags_ == 0 )
-        {
-            return detail::system_error_category_message( value() );
-        }
-        else
-        {
-            return category().message( value() );
-        }
+        return category().message( value() );
    }

    char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
@@ -281,33 +238,23 @@ public:
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
        if( lc_flags_ == 1 )
        {
-            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
-
 #if !defined(BOOST_NO_EXCEPTIONS)
            try
 #endif
            {
+                std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
                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
        }
 #endif

-        if( lc_flags_ == 0 )
-        {
-            return detail::system_error_category_message( value(), buffer, len );
-        }
-        else
-        {
-            return category().message( value(), buffer, len );
-        }
+        return category().message( value(), buffer, len );
    }

    BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
@@ -585,7 +532,7 @@ public:
        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)
+#if defined(__CYGWIN__) || defined(__MINGW32__) || (defined(_MSC_VER) && _MSC_VER == 1800) || (defined(BOOST_GCC) && BOOST_GCC < 50000)

            return std::error_code( 0, boost::system::system_category() );

@@ -647,7 +594,7 @@ public:
        else
 #endif
        {
-            std::string r = category_name();
+            std::string r = category().name();
            detail::append_int( r, value() );
            return r;
        }
@@ -657,7 +604,7 @@ public:
        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();
+        return os << ec.to_string();
    }

    std::string what() const
@@ -84,7 +84,7 @@ public:

    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) BOOST_NOEXCEPT:
-        val_( e ), cat_( 0 )
+        val_( static_cast<int>( e ) ), cat_( 0 )
    {
    }

@@ -223,7 +223,7 @@ public:
    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)
+#if defined(BOOST_GCC) && BOOST_GCC < 50000

        return std::error_condition( value(), category() );

@@ -11,6 +11,9 @@
 // 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/generic_category.hpp>
 #include <system_error>

 //
@@ -30,13 +33,6 @@ private:

    boost::system::error_category const * pc_;

-public:
-
-    boost::system::error_category const & original_category() const BOOST_NOEXCEPT
-    {
-        return *pc_;
-    }
-
 public:

    explicit std_category( boost::system::error_category const * pc, unsigned id ): pc_( pc )
@@ -70,10 +66,72 @@ public:
        return pc_->default_error_condition( ev );
    }

-    inline bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
-    inline bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
+    bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
+    bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 };

+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
@@ -1,97 +0,0 @@
-#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 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
-
-#endif // #ifndef BOOST_SYSTEM_DETAIL_STD_CATEGORY_IMPL_HPP_INCLUDED
@@ -25,7 +25,7 @@ namespace system
 namespace detail
 {

-inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
+inline errc::errc_t system_category_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,
@@ -138,10 +138,15 @@ inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
    case WSAETIMEDOUT_: return timed_out;
    case WSAEWOULDBLOCK_: return operation_would_block;

-    default: return -1;
+    default: return static_cast<errc::errc_t>( -1 );
    }
 }

+inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
+{
+    return static_cast<int>( system_category_condition_win32_( ev ) );
+}
+
 } // namespace detail

 } // namespace system
@@ -11,7 +11,6 @@
 //  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>

@@ -23,6 +22,7 @@

 #if defined(BOOST_WINDOWS_API)

+#include <boost/system/detail/system_category_message_win32.hpp>
 #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 BOOST_NOEXCEPT
@@ -39,23 +39,35 @@ inline boost::system::error_condition boost::system::detail::system_error_catego
    }
 }

+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/generic_category_message.hpp>
+
 inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_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 );
+    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 system_error_category_message( ev, buffer, len );
+    return generic_error_category_message( ev, buffer, len );
 }

+#endif // #if defined(BOOST_WINDOWS_API)
+
 #endif // #ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_IMPL_HPP_INCLUDED
@@ -1,71 +0,0 @@
-#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 ) BOOST_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 ) BOOST_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
@@ -16,7 +16,6 @@
 #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
@@ -33,19 +32,13 @@ namespace errc
 // explicit conversion:
 BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) BOOST_NOEXCEPT
 {
-    return error_code( e, generic_category() );
-}
-
-// explicit conversion:
-inline error_code make_error_code( errc_t e, boost::source_location const * loc ) BOOST_NOEXCEPT
-{
-    return error_code( e, generic_category(), loc );
+    return error_code( static_cast<int>( 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() );
+    return error_condition( static_cast<int>( e ), generic_category() );
 }

 } // namespace errc
@@ -10,6 +10,13 @@
 #ifndef BOOST_SYSTEM_LINUX_ERROR_HPP
 #define BOOST_SYSTEM_LINUX_ERROR_HPP

+#include <boost/config/pragma_message.hpp>
+
+#if !defined(BOOST_ALLOW_DEPRECATED_HEADERS)
+  BOOST_PRAGMA_MESSAGE("This header is deprecated and is slated for removal."
+  " If you want it retained, please open an issue in github.com/boostorg/system.")
+#endif
+
 //  This header is effectively empty for compiles on operating systems where
 //  it is not applicable.

@@ -1,7 +1,7 @@
 #ifndef BOOST_SYSTEM_RESULT_HPP_INCLUDED
 #define BOOST_SYSTEM_RESULT_HPP_INCLUDED

-// Copyright 2017, 2021, 2022 Peter Dimov.
+// Copyright 2017, 2021 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt

@@ -11,14 +11,11 @@
 #include <boost/system/detail/error_category_impl.hpp>
 #include <boost/variant2/variant.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/assert/source_location.hpp>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <type_traits>
 #include <utility>
 #include <iosfwd>
-#include <system_error>
-#include <exception>

 //

@@ -29,47 +26,11 @@ namespace system

 // throw_exception_from_error

-#if defined(__GNUC__) && __GNUC__ >= 7 && __GNUC__ <= 8
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wattributes"
-#endif
-
-BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( error_code const & e, boost::source_location const& loc )
+BOOST_NORETURN inline void throw_exception_from_error( error_code const & e )
 {
-    boost::throw_with_location( system_error( e ), loc );
+    boost::throw_exception( system_error( e ) );
 }

-BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( errc::errc_t const & e, boost::source_location const& loc )
-{
-    boost::throw_with_location( system_error( make_error_code( e ) ), loc );
-}
-
-BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( std::error_code const & e, boost::source_location const& loc )
-{
-    boost::throw_with_location( std::system_error( e ), loc );
-}
-
-BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( std::errc const & e, boost::source_location const& loc )
-{
-    boost::throw_with_location( std::system_error( make_error_code( e ) ), loc );
-}
-
-BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( std::exception_ptr const & p, boost::source_location const& loc )
-{
-    if( p )
-    {
-        std::rethrow_exception( p );
-    }
-    else
-    {
-        boost::throw_with_location( std::bad_exception(), loc );
-    }
-}
-
-#if defined(__GNUC__) && __GNUC__ >= 7 && __GNUC__ <= 8
-# pragma GCC diagnostic pop
-#endif
-
 // in_place_*

 using in_place_value_t = variant2::in_place_index_t<0>;
@@ -78,15 +39,6 @@ constexpr in_place_value_t in_place_value{};
 using in_place_error_t = variant2::in_place_index_t<1>;
 constexpr in_place_error_t in_place_error{};

-namespace detail
-{
-
-template<class T> using remove_cvref = typename std::remove_cv< typename std::remove_reference<T>::type >::type;
-
-template<class... T> using is_errc_t = std::is_same<mp11::mp_list<remove_cvref<T>...>, mp11::mp_list<errc::errc_t>>;
-
-} // namespace detail
-
 // result

 template<class T, class E = error_code> class result
@@ -113,7 +65,6 @@ public:
    // implicit, value
    template<class A = T, typename std::enable_if<
        std::is_convertible<A, T>::value &&
-        !(detail::is_errc_t<A>::value && std::is_arithmetic<T>::value) &&
        !std::is_constructible<E, A>::value, int>::type = 0>
    constexpr result( A&& a )
        noexcept( std::is_nothrow_constructible<T, A>::value )
@@ -134,7 +85,6 @@ public:
    // explicit, value
    template<class... A, class En = typename std::enable_if<
        std::is_constructible<T, A...>::value &&
-        !(detail::is_errc_t<A...>::value && std::is_arithmetic<T>::value) &&
        !std::is_constructible<E, A...>::value
        >::type>
    explicit constexpr result( A&&... a )
@@ -174,43 +124,6 @@ public:
    {
    }

-    // converting
-    template<class T2, class E2, class En = typename std::enable_if<
-        std::is_convertible<T2, T>::value &&
-        std::is_convertible<E2, E>::value
-        >::type>
-    BOOST_CXX14_CONSTEXPR result( result<T2, E2> const& r2 )
-        noexcept(
-            std::is_nothrow_constructible<T, T2 const&>::value &&
-            std::is_nothrow_constructible<E, E2>::value &&
-            std::is_nothrow_default_constructible<E2>::value &&
-            std::is_nothrow_copy_constructible<E2>::value )
-        : v_( in_place_error, r2.error() )
-    {
-        if( r2 )
-        {
-            v_.template emplace<0>( *r2 );
-        }
-    }
-
-    template<class T2, class E2, class En = typename std::enable_if<
-        std::is_convertible<T2, T>::value &&
-        std::is_convertible<E2, E>::value
-        >::type>
-    BOOST_CXX14_CONSTEXPR result( result<T2, E2>&& r2 )
-        noexcept(
-            std::is_nothrow_constructible<T, T2&&>::value &&
-            std::is_nothrow_constructible<E, E2>::value &&
-            std::is_nothrow_default_constructible<E2>::value &&
-            std::is_nothrow_copy_constructible<E2>::value )
-        : v_( in_place_error, r2.error() )
-    {
-        if( r2 )
-        {
-            v_.template emplace<0>( std::move( *r2 ) );
-        }
-    }
-
    // queries

    constexpr bool has_value() const noexcept
@@ -231,7 +144,7 @@ public:
    // checked value access
 #if defined( BOOST_NO_CXX11_REF_QUALIFIERS )

-    BOOST_CXX14_CONSTEXPR T value( boost::source_location const& loc = BOOST_CURRENT_LOCATION ) const
+    BOOST_CXX14_CONSTEXPR T value() const
    {
        if( has_value() )
        {
@@ -239,13 +152,13 @@ public:
        }
        else
        {
-            throw_exception_from_error( variant2::unsafe_get<1>( v_ ), loc );
+            throw_exception_from_error( variant2::unsafe_get<1>( v_ ) );
        }
    }

 #else

-    BOOST_CXX14_CONSTEXPR T& value( boost::source_location const& loc = BOOST_CURRENT_LOCATION ) &
+    BOOST_CXX14_CONSTEXPR T& value() &
    {
        if( has_value() )
        {
@@ -253,11 +166,11 @@ public:
        }
        else
        {
-            throw_exception_from_error( variant2::unsafe_get<1>( v_ ), loc );
+            throw_exception_from_error( variant2::unsafe_get<1>( v_ ) );
        }
    }

-    BOOST_CXX14_CONSTEXPR T const& value( boost::source_location const& loc = BOOST_CURRENT_LOCATION ) const&
+    BOOST_CXX14_CONSTEXPR T const& value() const&
    {
        if( has_value() )
        {
@@ -265,24 +178,24 @@ public:
        }
        else
        {
-            throw_exception_from_error( variant2::unsafe_get<1>( v_ ), loc );
+            throw_exception_from_error( variant2::unsafe_get<1>( v_ ) );
        }
    }

    template<class U = T>
        BOOST_CXX14_CONSTEXPR
        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
-        value( boost::source_location const& loc = BOOST_CURRENT_LOCATION ) &&
+        value() &&
    {
-        return std::move( value( loc ) );
+        return std::move( value() );
    }

    template<class U = T>
        BOOST_CXX14_CONSTEXPR
        typename std::enable_if<!std::is_move_constructible<U>::value, T&&>::type
-        value( boost::source_location const& loc = BOOST_CURRENT_LOCATION ) &&
+        value() &&
    {
-        return std::move( value( loc ) );
+        return std::move( value() );
    }

    template<class U = T>
@@ -293,9 +206,9 @@ public:
    template<class U = T>
        BOOST_CXX14_CONSTEXPR
        typename std::enable_if<!std::is_move_constructible<U>::value, T const&&>::type
-        value( boost::source_location const& loc = BOOST_CURRENT_LOCATION ) const &&
+        value() const &&
    {
-        return std::move( value( loc ) );
+        return std::move( value() );
    }

 #endif
@@ -519,14 +432,14 @@ public:

    // checked value access

-    BOOST_CXX14_CONSTEXPR void value( boost::source_location const& loc = BOOST_CURRENT_LOCATION ) const
+    BOOST_CXX14_CONSTEXPR void value() const
    {
        if( has_value() )
        {
        }
        else
        {
-            throw_exception_from_error( variant2::unsafe_get<1>( v_ ), loc );
+            throw_exception_from_error( variant2::unsafe_get<1>( v_ ) );
        }
    }

@@ -23,25 +23,46 @@ private:

    error_code code_;

+private:
+
+    static std::string build_message( char const * prefix, error_code const & ec )
+    {
+        std::string r;
+
+        if( prefix )
+        {
+            r += prefix;
+            r += ": ";
+        }
+
+        r += ec.what();
+        return r;
+    }
+
+    static std::string build_message( char const * prefix, int ev, error_category const & cat )
+    {
+        return build_message( prefix, error_code( ev, cat ) );
+    }
+
 public:

-    explicit system_error( error_code const & ec ):
-        std::runtime_error( ec.what() ), code_( ec ) {}
+    explicit system_error( error_code const & ec )
+      : std::runtime_error( build_message( 0, ec ) ), 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, std::string const & prefix )
+      : std::runtime_error( build_message( prefix.c_str(), ec ) ), code_( ec ) {}

-    system_error( error_code const & ec, char const * prefix ):
-        std::runtime_error( std::string( prefix ) + ": " + ec.what() ), code_( ec ) {}
+    system_error( error_code const & ec, char const * prefix )
+      : std::runtime_error( build_message( prefix, ec ) ), 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::runtime_error( build_message( 0, ev, ecat ) ), 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, std::string const & prefix )
+      : std::runtime_error( build_message( prefix.c_str(), ev, ecat ) ), 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 ) {}
+    system_error( int ev, error_category const & ecat, char const * prefix )
+      : std::runtime_error( build_message( prefix, ev, ecat ) ), code_( ev, ecat ) {}

    error_code code() const BOOST_NOEXCEPT
    {
@@ -112,18 +112,6 @@ 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)
-
 # result

 set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)
@@ -142,4 +130,3 @@ 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_convert_construct.cpp)
@@ -20,8 +20,6 @@ project
    <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 + )
@@ -61,11 +59,7 @@ 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 : : :
-    # GCC 12 catches this at compile time with a warning
-    <toolset>gcc,<variant>release:<build>no ;
-
+run-fail throws_assign_fail.cpp ;
 system-run constexpr_test.cpp ;
 system-run win32_hresult_test.cpp ;

@@ -140,23 +134,11 @@ 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 ;
-
 # result

 import ../../config/checks/config : requires ;

-CPP11 = [ requires cxx11_variadic_templates cxx11_template_aliases cxx11_decltype cxx11_constexpr cxx11_noexcept ] <toolset>gcc-4.7:<build>no ;
+CPP11 = [ requires cxx11_variadic_templates cxx11_template_aliases cxx11_decltype cxx11_constexpr cxx11_noexcept ] ;

 run result_default_construct.cpp : : : $(CPP11) ;
 run result_value_construct.cpp : : : $(CPP11) ;
@@ -172,5 +154,3 @@ run result_eq.cpp : : : $(CPP11) ;
 run result_range_for.cpp : : : $(CPP11) ;
 run result_value_construct2.cpp : : : $(CPP11) ;
 run result_error_construct2.cpp : : : $(CPP11) ;
-run result_errc_construct.cpp : : : $(CPP11) ;
-run result_convert_construct.cpp : : : $(CPP11) ;
@@ -1,90 +0,0 @@
-// 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() );
-    }
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-    {
-        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() );
-    }
-
-#endif
-
-    return boost::report_errors();
-}
@@ -1,93 +0,0 @@
-// 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() );
-    }
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-    {
-        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() );
-    }
-
-#endif
-
-    return boost::report_errors();
-}
@@ -1,21 +0,0 @@
-// 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();
-}
@@ -1,17 +0,0 @@
-// 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();
-}
@@ -165,7 +165,7 @@ int main( int, char ** )
  econd = ec.default_error_condition();
  BOOST_TEST( econd.value() == static_cast<int>(errc::permission_denied) );
  BOOST_TEST( econd.category() == generic_category() );
-  BOOST_TEST( econd == error_condition( errc::permission_denied, generic_category() ) );
+  BOOST_TEST( econd == error_condition( static_cast<int>(errc::permission_denied), generic_category() ) );
  BOOST_TEST( econd == errc::permission_denied );
  BOOST_TEST( errc::permission_denied == econd );
  BOOST_TEST( ec == errc::permission_denied );
@@ -244,35 +244,35 @@ int main( int, char ** )
  ec = error_code( ERROR_ACCESS_DENIED, system_category() );
  BOOST_TEST( ec.value() == ERROR_ACCESS_DENIED );
  BOOST_TEST( ec == errc::permission_denied );
-  BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
+  BOOST_TEST( ec.default_error_condition().value() == static_cast<int>(errc::permission_denied) );
  BOOST_TEST( ec.default_error_condition().category() == generic_category() );

  //   test the second entry in the decoder table:
  ec = error_code( ERROR_ALREADY_EXISTS, system_category() );
  BOOST_TEST( ec.value() == ERROR_ALREADY_EXISTS );
  BOOST_TEST( ec == errc::file_exists );
-  BOOST_TEST( ec.default_error_condition().value() == errc::file_exists );
+  BOOST_TEST( ec.default_error_condition().value() == static_cast<int>(errc::file_exists) );
  BOOST_TEST( ec.default_error_condition().category() == generic_category() );

  //   test the third entry in the decoder table:
  ec = error_code( ERROR_BAD_UNIT, system_category() );
  BOOST_TEST( ec.value() == ERROR_BAD_UNIT );
  BOOST_TEST( ec == errc::no_such_device );
-  BOOST_TEST( ec.default_error_condition().value() == errc::no_such_device );
+  BOOST_TEST( ec.default_error_condition().value() == static_cast<int>(errc::no_such_device) );
  BOOST_TEST( ec.default_error_condition().category() == generic_category() );

  //   test the last non-Winsock entry in the decoder table:
  ec = error_code( ERROR_WRITE_PROTECT, system_category() );
  BOOST_TEST( ec.value() == ERROR_WRITE_PROTECT );
  BOOST_TEST( ec == errc::permission_denied );
-  BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
+  BOOST_TEST( ec.default_error_condition().value() == static_cast<int>(errc::permission_denied) );
  BOOST_TEST( ec.default_error_condition().category() == generic_category() );

  //   test the last Winsock entry in the decoder table:
  ec = error_code( WSAEWOULDBLOCK, system_category() );
  BOOST_TEST( ec.value() == WSAEWOULDBLOCK );
  BOOST_TEST( ec == errc::operation_would_block );
-  BOOST_TEST( ec.default_error_condition().value() == errc::operation_would_block );
+  BOOST_TEST( ec.default_error_condition().value() == static_cast<int>(errc::operation_would_block) );
  BOOST_TEST( ec.default_error_condition().category() == generic_category() );

  //   test not-in-table condition:
@@ -285,11 +285,11 @@ int main( int, char ** )

  std::cout << "POSIX tests...\n";
  ec = error_code( EACCES, system_category() );
-  BOOST_TEST( ec == error_code( errc::permission_denied, system_category() ) );
-  BOOST_TEST( error_code( errc::permission_denied, system_category() ) == ec );
+  BOOST_TEST( ec == error_code( static_cast<int>(errc::permission_denied), system_category() ) );
+  BOOST_TEST( error_code( static_cast<int>(errc::permission_denied), system_category() ) == ec );
  BOOST_TEST( ec == errc::permission_denied );
  BOOST_TEST( errc::permission_denied == ec );
-  BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
+  BOOST_TEST( ec.default_error_condition().value() == static_cast<int>(errc::permission_denied) );
  BOOST_TEST( ec.default_error_condition().category() == generic_category() );

 #endif
@@ -118,7 +118,7 @@ namespace boost
      boost::system::error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
      {
        return ev == boo_boo
-          ? boost::system::error_condition( boost::system::errc::io_error,
+          ? boost::system::error_condition( static_cast<int>( boost::system::errc::io_error ),
              boost::system::generic_category() )
          : boost::system::error_condition( ev,
              boost::lib3::lib3_error_category );
@@ -180,7 +180,7 @@ namespace lib4
    boost::system::error_condition default_error_condition( int ev ) const  BOOST_SYSTEM_NOEXCEPT
    {
      return ev == boo_boo.value()
-        ? boost::system::error_condition( boost::system::errc::io_error,
+        ? boost::system::error_condition( static_cast<int>( boost::system::errc::io_error ),
            boost::system::generic_category() )
        : boost::system::error_condition( ev, lib4::lib4_error_category );
    }
@@ -18,7 +18,7 @@ struct foo
  foo()
  {
    boost::system::error_code ec;
-    BOOST_TEST_NE( ec, boost::system::errc::permission_denied );
+    BOOST_TEST( ec != boost::system::errc::permission_denied );
  }
 } f;

@@ -1,202 +0,0 @@
-// 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>
-#include <boost/core/lightweight_test_trait.hpp>
-
-using namespace boost::system;
-
-struct X
-{
-    static int instances;
-
-    int v_;
-
-    X(): v_() { ++instances; }
-
-    X( int v ): v_( v ) { ++instances; }
-
-    X( X const& r ): v_( r.v_ ) { ++instances; }
-
-    X& operator=( X const& ) = delete;
-
-    ~X() { --instances; }
-};
-
-bool operator==( X const & x1, X const & x2 )
-{
-    return x1.v_ == x2.v_;
-}
-
-std::ostream& operator<<( std::ostream& os, X const & x )
-{
-    os << "X:" << x.v_;
-    return os;
-}
-
-int X::instances = 0;
-
-int main()
-{
-    {
-        result<int> r( 5 );
-        result<long> r2 = r;
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 5 );
-    }
-
-    {
-        result<int> const r( 6 );
-        result<long> r2 = r;
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 6 );
-    }
-
-    {
-        result<long> r2 = result<int>( 7 );
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 7 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<int> r( 5 );
-        result<X> r2 = r;
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 5 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<int> const r( 6 );
-        result<X> r2 = r;
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 6 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<X> r2 = result<int>( 7 );
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 7 );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int> r( ec );
-        result<long> r2 = r;
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), ec );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<int> r( ec );
-        result<long> r2 = r;
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), ec );
-    }
-
-    {
-        auto ec = make_error_code( errc::invalid_argument );
-
-        result<long> r2 = result<int>( ec );
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), ec );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<char const*, int> r( "test" );
-        result<std::string, X> r2 = r;
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
-        BOOST_TEST_EQ( X::instances, 0 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<char const*, int> const r( "test" );
-        result<std::string, X> r2 = r;
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
-        BOOST_TEST_EQ( X::instances, 0 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<std::string, X> r2 = result<char const*, int>( "test" );
-
-        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
-        BOOST_TEST_EQ( X::instances, 0 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<char const*, int> r( 5 );
-        result<std::string, X> r2 = r;
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), X(5) );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        result<char const*, int> const r( 6 );
-        result<std::string, X> r2 = r;
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), X(6) );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    {
-        result<std::string, X> r2 = result<char const*, int>( 7 );
-
-        BOOST_TEST( !r2 );
-        BOOST_TEST_EQ( r2.error(), X(7) );
-        BOOST_TEST_EQ( X::instances, 1 );
-    }
-
-    BOOST_TEST_EQ( X::instances, 0 );
-
-    {
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<long>, result<int>>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<result<int>, result<long>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int>, result<void*>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<void*>, result<int>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int>, result<void>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<void>, result<int>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<void>, result<int>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int>, result<void>>));
-
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, void*>, result<int, int>>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int, int>, result<int, void*>>));
-    }
-
-    return boost::report_errors();
-}
@@ -1,23 +0,0 @@
-// Copyright 2021 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_trait.hpp>
-#include <type_traits>
-
-using namespace boost::system;
-
-int main()
-{
-    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<int>>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int>, errc::errc_t>));
-
-    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<double>>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double>, errc::errc_t>));
-
-    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<bool>>));
-    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, errc::errc_t>));
-
-    return boost::report_errors();
-}
@@ -62,13 +62,13 @@ int main()
        BOOST_TEST( !r.has_value() );
        BOOST_TEST( r.has_error() );

-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+        BOOST_TEST_EQ( r.error(), std::error_code( EINVAL, generic_category() ) );
    }

    {
        auto ec = make_error_code( errc::invalid_argument );

-        result<error_code> r( in_place_error, ec );
+        result<std::error_code> r( in_place_error, ec );

        BOOST_TEST( !r.has_value() );
        BOOST_TEST( r.has_error() );
@@ -77,12 +77,12 @@ int main()
    }

    {
-        result<error_code> r( in_place_error, EINVAL, generic_category() );
+        result<std::error_code> r( in_place_error, EINVAL, generic_category() );

        BOOST_TEST( !r.has_value() );
        BOOST_TEST( r.has_error() );

-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+        BOOST_TEST_EQ( r.error(), std::error_code( EINVAL, generic_category() ) );
    }

    BOOST_TEST_EQ( X::instances, 0 );
@@ -140,8 +140,8 @@ int main()
    BOOST_TEST_EQ( X::instances, 0 );

    {
-        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int>, error_code>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<error_code, result<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<int>, std::error_code>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<std::error_code, result<int>>));

        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<std::string, X>, int>));
        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<std::string, X>>));
@@ -178,7 +178,7 @@ int main()
        BOOST_TEST( !r.has_value() );
        BOOST_TEST( r.has_error() );

-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+        BOOST_TEST_EQ( r.error(), std::error_code( EINVAL, generic_category() ) );
    }

    return boost::report_errors();
@@ -41,7 +41,7 @@ int main()
        BOOST_TEST( !r.has_value() );
        BOOST_TEST( r.has_error() );

-        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+        BOOST_TEST_EQ( r.error(), std::error_code( EINVAL, generic_category() ) );
    }

    {
@@ -1,11 +1,10 @@
-// Copyright 2017, 2021, 2022 Peter Dimov.
+// Copyright 2017, 2021 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>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <system_error>

 using namespace boost::system;

@@ -27,15 +26,11 @@ struct E
 {
 };

-BOOST_NORETURN void throw_exception_from_error( Y const &, boost::source_location const& )
+BOOST_NORETURN void throw_exception_from_error( Y const & )
 {
    throw E();
 }

-struct E2
-{
-};
-
 int main()
 {
    {
@@ -170,78 +165,6 @@ int main()
        BOOST_TEST_EQ( result<int>( ec ).operator->(), static_cast<int*>(0) );
    }

-    {
-        auto ec = make_error_code( std::errc::invalid_argument );
-
-        result<int, std::error_code> const r( ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        result<int, errc::errc_t> const r( in_place_error, errc::invalid_argument );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        result<int, std::errc> const r( std::errc::invalid_argument );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        result<int, std::exception_ptr> const r( std::make_exception_ptr( E2() ) );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), E2 );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
-    {
-        result<int, std::exception_ptr> const r( in_place_error );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::bad_exception );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
-    }
-
    {
        result<X> r( 1 );

@@ -418,77 +341,5 @@ int main()
        BOOST_TEST_EQ( result<void>( ec ).operator->(), static_cast<void*>(0) );
    }

-    {
-        auto ec = make_error_code( std::errc::invalid_argument );
-
-        result<void, std::error_code> const r( ec );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
-    }
-
-    {
-        result<void, errc::errc_t> const r( in_place_error, errc::invalid_argument );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
-    }
-
-    {
-        result<void, std::errc> const r( std::errc::invalid_argument );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::system_error );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
-    }
-
-    {
-        result<void, std::exception_ptr> const r( std::make_exception_ptr( E2() ) );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), E2 );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
-    }
-
-    {
-        result<void, std::exception_ptr> const r( in_place_error );
-
-        BOOST_TEST( !r.has_value() );
-        BOOST_TEST( r.has_error() );
-
-        BOOST_TEST_NOT( r );
-        BOOST_TEST( !r );
-
-        BOOST_TEST_THROWS( r.value(), std::bad_exception );
-
-        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
-    }
-
    return boost::report_errors();
 }
@@ -1,127 +0,0 @@
-// Copyright 2021, 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_category.hpp>
-#include <boost/system/errc.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/config/pragma_message.hpp>
-#include <boost/config.hpp>
-#include <cerrno>
-
-#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
-int main() {}
-
-#else
-
-#include <system_error>
-
-enum my_errc
-{
-    my_enoent = ENOENT
-};
-
-class my_category: public boost::system::error_category
-{
-public:
-
-    char const* name() const BOOST_NOEXCEPT
-    {
-        return "mycat";
-    }
-
-    boost::system::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
-    {
-        switch( ev )
-        {
-        case my_enoent:
-
-            return boost::system::error_condition( ENOENT, boost::system::generic_category() );
-
-        default:
-
-            return boost::system::error_condition( ev, *this );
-        }
-    }
-
-    std::string message( int ev ) const
-    {
-        switch( ev )
-        {
-        case my_enoent:
-
-            return "No such entity";
-
-        default:
-
-            return "Unknown error";
-        }
-    }
-};
-
-#if defined(BOOST_GCC) && BOOST_GCC < 70000
-
-// g++ 6 and earlier do not allow specializations outside the namespace
-
-namespace boost
-{
-namespace system
-{
-
-template<> struct is_error_code_enum<my_errc>: std::true_type {};
-
-} // namespace system
-} // namespace boost
-
-namespace std
-{
-
-template<> struct is_error_code_enum<my_errc>: std::true_type {};
-
-} // namespace std
-
-#else
-
-template<> struct boost::system::is_error_code_enum<my_errc>: std::true_type {};
-template<> struct std::is_error_code_enum<my_errc>: std::true_type {};
-
-#endif
-
-boost::system::error_code make_error_code( my_errc e )
-{
-    // If `cat` is declared constexpr or const, msvc-14.1 and
-    // msvc-14.2 before 19.29 put it in read-only memory,
-    // despite the `ps_` member being mutable. So it crashes.
-
-    static /*BOOST_SYSTEM_CONSTEXPR*/ my_category cat;
-    return boost::system::error_code( e, cat );
-}
-
-int main()
-{
-    {
-        boost::system::error_code e1 = my_enoent;
-
-        BOOST_TEST( e1 == my_enoent );
-        BOOST_TEST_NOT( e1 != my_enoent );
-
-        BOOST_TEST( e1 == boost::system::errc::no_such_file_or_directory );
-        BOOST_TEST( e1 == std::errc::no_such_file_or_directory );
-    }
-
-    {
-        std::error_code e1 = my_enoent;
-
-        BOOST_TEST( e1 == my_enoent );
-        BOOST_TEST_NOT( e1 != my_enoent );
-
-        BOOST_TEST( e1 == std::errc::no_such_file_or_directory );
-    }
-
-    return boost::report_errors();
-}
-
-#endif
@@ -1,77 +0,0 @@
-// Copyright 2021, 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_category.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/config/pragma_message.hpp>
-#include <boost/config.hpp>
-#include <cerrno>
-
-#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
-int main() {}
-
-#else
-
-#include <system_error>
-
-class my_category_impl: public std::error_category
-{
-public:
-
-    char const* name() const BOOST_NOEXCEPT
-    {
-        return "mycat";
-    }
-
-    std::string message( int /*ev*/ ) const
-    {
-        return "Unknown error";
-    }
-};
-
-std::error_category const& my_category()
-{
-    static my_category_impl mycat;
-    return mycat;
-}
-
-int main()
-{
-    {
-        std::error_code e1( 5, boost::system::system_category() );
-        boost::system::error_code e2( e1 );
-        std::error_code e3( e2 );
-
-        BOOST_TEST_EQ( e1, e3 );
-        BOOST_TEST_EQ( e1.value(), e3.value() );
-        BOOST_TEST_EQ( &e1.category(), &e3.category() );
-    }
-
-    {
-        std::error_code e1( 5, boost::system::generic_category() );
-        boost::system::error_code e2( e1 );
-        std::error_code e3( e2 );
-
-        BOOST_TEST_EQ( e1, e3 );
-        BOOST_TEST_EQ( e1.value(), e3.value() );
-        BOOST_TEST_EQ( &e1.category(), &e3.category() );
-    }
-
-    {
-        std::error_code e1( 5, my_category() );
-        boost::system::error_code e2( e1 );
-        std::error_code e3( e2 );
-
-        BOOST_TEST_EQ( e1, e3 );
-        BOOST_TEST_EQ( e1.value(), e3.value() );
-        BOOST_TEST_EQ( &e1.category(), &e3.category() );
-    }
-
-    return boost::report_errors();
-}
-
-#endif
@@ -1,57 +0,0 @@
-// Copyright 2021, 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_category.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/config/pragma_message.hpp>
-#include <boost/config.hpp>
-#include <cerrno>
-
-#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
-int main() {}
-
-#else
-
-#include <system_error>
-
-class my_category_impl: public boost::system::error_category
-{
-public:
-
-    char const* name() const BOOST_NOEXCEPT
-    {
-        return "mycat";
-    }
-
-    std::string message( int /*ev*/ ) const
-    {
-        return "Unknown error";
-    }
-};
-
-boost::system::error_category const& my_category()
-{
-    static my_category_impl mycat;
-    return mycat;
-}
-
-int main()
-{
-    {
-        boost::system::error_code e1( 5, my_category() );
-        std::error_code e2( e1 );
-        boost::system::error_code e3( e2 );
-
-        BOOST_TEST_EQ( e1, e3 );
-        BOOST_TEST_EQ( e1.value(), e3.value() );
-        BOOST_TEST_EQ( &e1.category(), &e3.category() );
-    }
-
-    return boost::report_errors();
-}
-
-#endif
@@ -1,4 +1,4 @@
-// Copyright 2021, 2022 Peter Dimov
+// Copyright 2021 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0
 // https://www.boost.org/LICENSE_1_0.txt

@@ -14,36 +14,22 @@ int main()
        sys::error_code ec( 5, sys::generic_category() );
        sys::system_error x1( ec );

-        BOOST_TEST_EQ( std::string( x1.what() ), ec.what() );
+		BOOST_TEST_EQ( std::string( x1.what() ), ec.what() );
    }

    {
-        sys::error_code ec( 5, sys::generic_category() );
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( 5, sys::system_category(), &loc );
        sys::system_error x1( ec, "prefix" );

        BOOST_TEST_EQ( std::string( x1.what() ), "prefix: " + ec.what() );
    }

    {
-        sys::error_code ec( 5, sys::generic_category() );
-        sys::system_error x1( ec, std::string( "prefix2" ) );
+        sys::system_error x1( 5, sys::generic_category() );

-        BOOST_TEST_EQ( std::string( x1.what() ), "prefix2: " + ec.what() );
-    }
-
-    {
-        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
-
-        sys::error_code ec( 5, sys::generic_category(), &loc );
-        sys::system_error x1( ec, "prefix3" );
-
-        BOOST_TEST_EQ( std::string( x1.what() ), "prefix3: " + ec.what() );
-    }
-
-    {
-        sys::system_error x1( 5, sys::system_category() );
-
-        BOOST_TEST_EQ( std::string( x1.what() ), sys::error_code( 5, sys::system_category() ).what() );
+        BOOST_TEST_EQ( std::string( x1.what() ), sys::error_code( 5, sys::generic_category() ).what() );
    }

    {
@@ -52,11 +38,5 @@ int main()
        BOOST_TEST_EQ( std::string( x1.what() ), "prefix: " + sys::error_code( 5, sys::system_category() ).what() );
    }

-    {
-        sys::system_error x1( 5, sys::system_category(), std::string( "prefix2" ) );
-
-        BOOST_TEST_EQ( std::string( x1.what() ), "prefix2: " + sys::error_code( 5, sys::system_category() ).what() );
-    }
-
    return boost::report_errors();
 }
Author	SHA1	Message	Date
Peter Dimov	ae341976d4	Avoid pedantic warning for trailing comma in enum	2021-12-10 00:29:17 +02:00
Peter Dimov	29b901c5bb	More fixes for implicit int conversions	2021-12-10 00:22:25 +02:00
Peter Dimov	2e1b2dcafb	Fix implicit conversion to int errors	2021-12-09 22:26:18 +02:00
Peter Dimov	d0cf08daed	Make errc::errc_t a scoped enum	2021-12-09 22:17:47 +02:00