Move BOOST_NOINLINE to operator std::error_category

Remove clang-win from appveyor.yml
Update result_error_construct tests to use sys::error_code instead of (erroneously) std::error_code
2025-12-25 16:28:05 +01:00 · 2022-04-22 22:41:26 +03:00 · 2022-04-22 21:16:09 +03:00 · 2022-04-22 19:52:19 +03:00 · 2022-04-22 16:49:03 +03:00 · 2022-04-21 21:06:14 +03:00
53 changed files with 3979 additions and 400 deletions
--- a/.drone.jsonnet
+++ b/.drone.jsonnet
@@ -0,0 +1,253 @@
+# 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' },
+    ),
+]
--- a/.drone/drone.bat
+++ b/.drone/drone.bat
@@ -0,0 +1,23 @@
+@REM Copyright 2022 Peter Dimov
+@REM Distributed under the Boost Software License, Version 1.0.
+@REM https://www.boost.org/LICENSE_1_0.txt
+
+@ECHO ON
+
+set LIBRARY=%1
+set DRONE_BUILD_DIR=%CD%
+
+set BOOST_BRANCH=develop
+if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
+cd ..
+git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
+python tools/boostdep/depinst/depinst.py %LIBRARY%
+cmd /c bootstrap
+b2 -d0 headers
+
+if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
--- a/.drone/drone.sh
+++ b/.drone/drone.sh
@@ -0,0 +1,24 @@
+#!/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}
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -144,14 +144,22 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: msvc-14.1
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2016
-          - toolset: msvc-14.2
-            cxxstd: "14,17,latest"
+          - toolset: msvc-14.0
+            cxxstd: "14"
            addrmd: 32,64
            os: windows-2019
+          - toolset: msvc-14.2
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: clang-win
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2022
          - toolset: gcc
            cxxstd: "03,11,14,17,2a"
            addrmd: 64
@@ -188,7 +196,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
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker

  posix-cmake-subdir:
    strategy:
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -22,20 +22,8 @@ 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
--- a/doc/system.adoc
+++ b/doc/system.adoc
@@ -13,10 +13,13 @@ Beman Dawes, Christopher Kohlhoff, Peter Dimov
 :toclevels: 4
 :idprefix:
 :docinfo: private-footer
+:source-highlighter: rouge
+:source-language: c++

 :leveloffset: +1

 include::system/introduction.adoc[]
+include::system/usage.adoc[]
 include::system/changes.adoc[]
 include::system/rationale.adoc[]
 include::system/reference.adoc[]
--- a/doc/system/changes.adoc
+++ b/doc/system/changes.adoc
@@ -1,5 +1,5 @@
 ////
-Copyright 2018-2021 Peter Dimov
+Copyright 2018-2022 Peter Dimov
 Distributed under the Boost Software License, Version 1.0.
 https://www.boost.org/LICENSE_1_0.txt
 ////
@@ -8,10 +8,19 @@ https://www.boost.org/LICENSE_1_0.txt
 # Revision History
 :idprefix:

+## Changes in Boost 1.79
+
+* Added a `boost::source_location` parameter to `throw_exception_from_error`.
+* Added `throw_exception_from_error` overloads for `errc::errc_t`,
+  `std::error_code`, `std::errc`, `std::exception_ptr`.
+* `result<T>::value` now automatically supplies `BOOST_CURRENT_LOCATION` to
+  `throw_exception_from_error` via a default argument.
+* Added an `errc::make_error_code` overload taking a source location.
+
 ## Changes in Boost 1.78

 * Added support for source locations to `error_code`.
-* Added `error_code::to_string`, `error_condition::to_string`.
+* Added `error_code::to_string`, `error_condition::to_string`, `error_code::what`.
 * `system_error::what()` now contains the source location, if present.
 * Added `result<T, E = error_code>`, a class holding either a value or an
  error, defined in `<boost/system/result.hpp>`.
--- a/doc/system/copyright.adoc
+++ b/doc/system/copyright.adoc
@@ -14,6 +14,6 @@ http://www.boost.org/LICENSE_1_0.txt
 This documentation is

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

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

 Distributed under the Boost Software License, Version 1.0.

@@ -12,39 +12,67 @@ http://www.boost.org/LICENSE_1_0.txt
 # Introduction
 :idprefix: intro_

-Error conditions originating from the operating system or other low-level
-application program interfaces (API's) are typically reported via an integer
-representing an error code. When these low-level API calls are wrapped in
-portable code, such as in a portable library, some users want to deal with the
-error codes in portable ways. Other users need to get at the system specific
-error codes, so they can deal with system specific needs. The Boost System
-library provides simple, light-weight `error_code` objects that encapsulate
-system-specific error code values, yet also provide access to more abstract
-and portable error conditions via `error_condition` objects.
+Errors originating from the operating system or other low-level application
+program interfaces (APIs) are typically reported via an integer representing
+an error code, either by returning the code directly from the function (e.g.
+`pthread_mutex_init`) or by using a side channel such as the `errno`
+pseudo-variable under POSIX or `GetLastError()` under Windows.

-Because `error_code` objects can represent errors from sources other than the
-operating system, including user-defined sources, each `error_code` and
-`error_condition` has an associated `error_category`.
+However, these integer error values can only be interpreted when their source
+is known. The value 5 under Windows means `ERROR_ACCESS_DENIED` when returned
+by `GetLastError()`, but `EIO` when retrieved from `errno`. And conversely,
+the same error condition "access denied" is represented by the value 5 when
+returned by `GetLastError()` and 13 (`EACCES`) when retrieved from `errno`.

-An exception class, `system_error`, is provided. Derived from
-`std::runtime_error`, it captures the underlying `error_code` for the problem
-causing the exception so that this important information is not lost.
+This means that in order for code to be able to handle errors from both
+sources (to retrieve a text message describing the error, or to check whether
+the error means "access denied"), it needs to know where the integer error
+value originated. For this to be possible, the integer error value needs to
+be accompanied by a piece of information identifying the source.

-While exceptions are the preferred {cpp} default error code reporting
-mechanism, users of libraries dependent on low-level API's often need overloads
-reporting error conditions via error code arguments and/or return values rather
-than via throwing exceptions. Otherwise, when errors are not exceptional
-occurrences and must be dealt with as they arise, programs become littered with
-try/catch blocks, unreadable, and inefficient. The Boost System library
-supports both error reporting by exception and by error code.
+Boost.System provides a framework in which this is possible. Errors are
+represented by a class `error_code` which contains both the error value and
+a pointer to their source (called "category"), represented as a class derived
+from `error_category`.

-In addition to portable errors codes and conditions supported by the
-`error_code.hpp` header, system-specific headers support the Cygwin, Linux,
-and Windows platforms. These headers are effectively no-ops if included for
-platforms other than their intended target.
+The category provides member functions such as `message`, which returns a text
+message for a specific error value, and `equivalent`, which can be used to test
+whether a specific error value correspond to an error condition such as "access
+denied". `error_code` uses these category-provided functions in the
+implementation of its `message` and `operator==` member functions.

-Boost.System is part of the {cpp}11 Standard Library.
-A number of changes, particularly to names, were made by the C++ committee
-during standardization. The Boost implementation has been tracking those changes.
-See <<#ref_deprecated_names,Deprecated Names>> for synonyms provided to prevent
-breakage of existing user code.
+Boost.System contains two predefined category classes, the generic category
+(a reference to which is returned by `generic_category()`) and the system
+category (`system_category()`). The generic category represents the error
+values of the portable subset of `errno` values defined by the POSIX standard,
+whereas the system category is OS dependent. Under POSIX, the system category
+represents the `errno` values returned by the OS APIs (a superset of those in
+the generic category), whereas under Windows, the system category represents
+the error values returned by `GetLastError()`.
+
+The framework is extensible. Users can define their own categories by
+deriving a class from `error_category` and implementing a function that
+returns a reference to an instance of it. This capability is useful both for
+describing library-defined error values, and for adapting existing C API
+libraries that return integer error values.
+
+For those who prefer error reporting via exceptions, Boost.System provides
+a standard exception class `system_error` that stores an `error_code`.
+
+Boost.System was standardized in {cpp}11 as `<system_error>`. For a while,
+the two were equivalent, but Boost.System has evolved since then and now
+contains a number of extensions over its standard sibling:
+
+* A non-allocating overload of `message`;
+* Support for nonzero error codes meaning success, via the `failed` member
+  functions;
+* Support for 64 bit category identifiers, as a solution to the problem
+  that sometimes it's not possible to ensure that only one instance of a
+  category exists in the program;
+* Support for attaching source locations (file/line/function) to error codes;
+* A class `result<T>` that can be used to return either a value or an error
+  code from a function;
+* Various other minor improvements.
+
+`boost::system::error_code` can be converted to, and constructed from,
+`std::error_code`.
--- a/doc/system/reference.adoc
+++ b/doc/system/reference.adoc
@@ -1,6 +1,6 @@
 ////
 Copyright 2003-2017 Beman Dawes
-Copyright 2018-2021 Peter Dimov
+Copyright 2018-2022 Peter Dimov

 Distributed under the Boost Software License, Version 1.0.

@@ -175,7 +175,7 @@ namespace errc {
    too_many_files_open_in_system,  //ENFILE
    too_many_files_open,            //EMFILE
    too_many_links,                 //EMLINK
-    too_many_synbolic_link_levels,  //ELOOP
+    too_many_symbolic_link_levels,  //ELOOP
    value_too_large,                //EOVERFLOW
    wrong_protocol_type             //EPROTOTYPE
  };
@@ -185,9 +185,13 @@ namespace errc {
 template<> struct is_error_condition_enum<errc::errc_t>
  { static const bool value = true; };

-constexpr error_code make_error_code( errc::errc_t e ) noexcept;
 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;
+
 } // namespace system
 } // namespace boost
 ```
@@ -256,6 +260,38 @@ 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
@@ -571,9 +607,13 @@ public:
    error_code( int val, const error_category & cat,
      boost::source_location const * loc ) noexcept;

-    template <class ErrorCodeEnum>
+    template<class ErrorCodeEnum>
      constexpr error_code( ErrorCodeEnum e ) noexcept;

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

    // modifiers
@@ -583,9 +623,13 @@ public:
    void assign( int val, const error_category & cat,
      boost::source_location const * loc ) noexcept;

-    template<typename ErrorCodeEnum>
+    template<class ErrorCodeEnum>
      constexpr error_code & operator=( ErrorCodeEnum e ) noexcept;

+    template<class ErrorCodeEnum>
+      void assign( ErrorCodeEnum e,
+        boost::source_location const * loc ) noexcept;
+
    constexpr void clear() noexcept;

    // observers
@@ -657,9 +701,13 @@ public:

    // stream insertion

-    template <class charT, class traits>
+    template<class charT, class traits>
      friend std::basic_ostream<charT, traits>&
        operator<<( basic_ostream<charT, traits>& os, const error_code & ec );
+
+    // what
+
+    std::string what() const;
 };

 // non-member functions
@@ -699,7 +747,7 @@ Requires: :: `loc` points to a valid `boost::source_location` object with static
 Ensures: :: `value() == val`; `category() == cat`; `has_location()`; `&location() == loc`.

 ```
-template <class ErrorCodeEnum>
+template<class ErrorCodeEnum>
  constexpr error_code( ErrorCodeEnum e ) noexcept;
 ```
 [none]
@@ -708,6 +756,19 @@ template <class ErrorCodeEnum>
 Ensures: :: `*this == make_error_code( e )`.
 Remarks: :: This constructor is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.

+```
+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.
+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;
 ```
@@ -737,7 +798,7 @@ void assign( int val, const error_category & cat,
 Effects: :: `*this = error_code( val, cat, loc )`.

 ```
-template<typename ErrorCodeEnum>
+template<class ErrorCodeEnum>
  constexpr error_code & operator=( ErrorCodeEnum e ) noexcept;
 ```
 [none]
@@ -746,6 +807,18 @@ template<typename ErrorCodeEnum>
 Ensures: :: `*this == make_error_code( e )`.
 Remarks: :: This operator is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.

+```
+template<class ErrorCodeEnum>
+  void assign( ErrorCodeEnum e,
+    boost::source_location const * loc ) noexcept;
+```
+[none]
+* {blank}
+
+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;
 ```
@@ -1021,6 +1094,18 @@ template <class charT, class traits>
 Effects: :: `os << to_string()`.
 Returns: :: `os`.

+#### what
+
+```
+std::string what() const;
+```
+[none]
+* {blank}
+
+Returns: :: A string representation of `*this`, suitable for logging and
+  diagnostic output. Typically incorporates `message()`, `to_string()`, and
+  `location().to_string()` (if available.)
+
 #### Nonmembers

 ```
@@ -1405,7 +1490,20 @@ namespace system {

 // throw_exception_from_error

-BOOST_NORETURN inline void throw_exception_from_error( error_code const & 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( 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 );

 // in_place_*

@@ -1437,13 +1535,57 @@ 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_NORETURN inline void throw_exception_from_error( error_code const & e,
+  boost::source_location const & loc );
 ```
 [none]
 * {blank}
 +
 Effects: ::
-  `boost::throw_exception( system_error( e ) )`.
+  `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 )`.

 ### result<T, E>

@@ -1479,10 +1621,17 @@ public:

    // checked value access

-    constexpr T& value() & ;
-    constexpr T const& value() const& ;
-    constexpr T&& value() && ;
-    constexpr T const&& value() 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( boost::source_location const & loc =
+      BOOST_CURRENT_LOCATION ) && ;
+
+    constexpr T const&& value( boost::source_location const & loc =
+      BOOST_CURRENT_LOCATION ) const&& ;

    // unchecked value access

@@ -1604,10 +1753,17 @@ Returns: ::
 #### Checked Value Access

 ```
-constexpr T& value() & ;
-constexpr T const& value() const& ;
-constexpr T&& value() && ;
-constexpr T const&& value() 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(
+  boost::source_location const & loc = BOOST_CURRENT_LOCATION ) && ;
+
+constexpr T const&& value(
+  boost::source_location const & loc = BOOST_CURRENT_LOCATION ) const&& ;
 ```
 [none]
 * {blank}
@@ -1615,7 +1771,7 @@ constexpr T const&& value() const&& ;
 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.
+  the held error, and `loc`.

 #### Unchecked Value Access

@@ -1750,7 +1906,8 @@ public:

    // checked value access

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

    // unchecked value access

@@ -1863,14 +2020,15 @@ Returns: ::
 #### Checked Value Access

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

 #### Unchecked Value Access

--- a/doc/system/usage.adoc
+++ b/doc/system/usage.adoc
--- a/include/boost/system.hpp
+++ b/include/boost/system.hpp
@@ -9,8 +9,9 @@

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

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

--- a/include/boost/system/detail/config.hpp
+++ b/include/boost/system/detail/config.hpp
@@ -1,7 +1,7 @@
 #ifndef BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
 #define BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED

-// Copyright 2018 Peter Dimov
+// Copyright 2018-2022 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -13,7 +13,7 @@

 // BOOST_SYSTEM_HAS_SYSTEM_ERROR

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

@@ -62,4 +62,20 @@
 # 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
--- a/include/boost/system/detail/error_category.hpp
+++ b/include/boost/system/detail/error_category.hpp
@@ -48,6 +48,11 @@ 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:
@@ -76,13 +81,21 @@ 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< boost::system::detail::std_category* > ps_;
+    mutable std::atomic< unsigned > sc_init_;

 #else

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

 #endif

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

 #endif

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

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

@@ -158,14 +171,22 @@ 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
--- a/include/boost/system/detail/error_category_impl.hpp
+++ b/include/boost/system/detail/error_category_impl.hpp
@@ -14,13 +14,13 @@
 #include <boost/system/detail/error_condition.hpp>
 #include <boost/system/detail/error_code.hpp>
 #include <boost/system/detail/snprintf.hpp>
+#include <boost/system/detail/config.hpp>
 #include <boost/config.hpp>
 #include <string>
 #include <cstring>

 namespace boost
 {
-
 namespace system
 {

@@ -91,49 +91,106 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
 }

 } // namespace system
-
 } // namespace boost

 // interoperability with std::error_code, std::error_condition

 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

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

-inline boost::system::error_category::operator std::error_category const & () const
+namespace boost
+{
+namespace system
 {
-    if( id_ == boost::system::detail::system_category_id )
-    {
-        static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
-        return system_instance;
-    }

-    if( id_ == boost::system::detail::generic_category_id )
-    {
-        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
-        return generic_instance;
-    }
+namespace detail
+{

-    boost::system::detail::std_category* p = ps_.load( std::memory_order_acquire );
+template<class = void> struct stdcat_mx_holder
+{
+    static std::mutex mx_;
+};

-    if( p != 0 )
-    {
-        return *p;
-    }
+template<class T> std::mutex stdcat_mx_holder<T>::mx_;

-    boost::system::detail::std_category* q = new detail::std_category( this, 0 );
+} // namespace detail

-    if( ps_.compare_exchange_strong( p, q, std::memory_order_release, std::memory_order_acquire ) )
+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 )
    {
-        return *q;
-    }
-    else
-    {
-        delete q;
-        return *p;
+        ::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
+{
+    if( id_ == detail::generic_category_id )
+    {
+// This condition must be the same as the one in error_condition.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY)
+
+        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
+        return generic_instance;
+
+#else
+
+        return std::generic_category();
+
+#endif
+    }
+
+    if( id_ == detail::system_category_id )
+    {
+// This condition must be the same as the one in error_code.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY)
+
+        static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
+        return system_instance;
+
+#else
+
+        return std::system_category();
+
+#endif
+    }
+
+    if( sc_init_.load( std::memory_order_acquire ) == 0 )
+    {
+        init_stdcat();
+    }
+
+    return *static_cast<boost::system::detail::std_category const*>( static_cast<void const*>( stdcat_ ) );
+}
+
+#if defined( BOOST_GCC ) && BOOST_GCC >= 40800 && BOOST_GCC < 70000
+#pragma GCC diagnostic pop
+#endif
+
+} // namespace system
+} // namespace boost
+
 #endif // #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

 #endif // #ifndef BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_IMPL_HPP_INCLUDED
--- a/include/boost/system/detail/error_code.hpp
+++ b/include/boost/system/detail/error_code.hpp
@@ -21,6 +21,11 @@
 #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>
@@ -83,6 +88,28 @@ 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:
@@ -107,18 +134,50 @@ public:
    }

    template<class ErrorCodeEnum> BOOST_SYSTEM_CONSTEXPR error_code( ErrorCodeEnum e,
+        typename detail::enable_if<
+            is_error_code_enum<ErrorCodeEnum>::value
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+            || std::is_error_code_enum<ErrorCodeEnum>::value
+#endif
+        >::type* = 0 ) BOOST_NOEXCEPT: d1_(), lc_flags_( 0 )
+    {
+        *this = make_error_code( e );
+    }
+
+    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 = make_error_code( e );
+        error_code e2 = make_error_code( e );
+
+        if( e2.lc_flags_ == 0 || e2.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:
-        lc_flags_( 1 )
+        d1_(), lc_flags_( 0 )
    {
-        ::new( d2_ ) std::error_code( ec );
+#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;
+        }
    }

 #endif
@@ -143,6 +202,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();
@@ -161,7 +227,11 @@ public:
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

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

            return -1;
@@ -203,7 +273,14 @@ public:

 #endif

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

    char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
@@ -211,23 +288,33 @@ 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

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

    BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
@@ -504,8 +591,16 @@ public:
        }
        else if( lc_flags_ == 0 )
        {
-            //return std::error_code();
+// This condition must be the same as the one in error_category_impl.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY)
+
            return std::error_code( 0, boost::system::system_category() );
+
+#else
+
+            return std::error_code();
+
+#endif
        }
        else
        {
@@ -559,7 +654,7 @@ public:
        else
 #endif
        {
-            std::string r = category().name();
+            std::string r = category_name();
            detail::append_int( r, value() );
            return r;
        }
@@ -569,7 +664,24 @@ public:
        inline friend std::basic_ostream<Ch, Tr>&
        operator<< (std::basic_ostream<Ch, Tr>& os, error_code const & ec)
    {
-        return os << ec.to_string();
+        return os << ec.to_string().c_str();
+    }
+
+    std::string what() const
+    {
+        std::string r = message();
+
+        r += " [";
+        r += to_string();
+
+        if( has_location() )
+        {
+            r += " at ";
+            r += location().to_string();
+        }
+
+        r += "]";
+        return r;
    }
 };

--- a/include/boost/system/detail/error_condition.hpp
+++ b/include/boost/system/detail/error_condition.hpp
@@ -222,7 +222,23 @@ 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)
+
        return std::error_condition( value(), category() );
+
+#else
+
+        if( cat_ )
+        {
+            return std::error_condition( val_, *cat_ );
+        }
+        else
+        {
+            return std::error_condition( val_, std::generic_category() );
+        }
+
+#endif
    }

    inline friend bool operator==( std::error_code const & lhs, error_condition const & rhs ) BOOST_NOEXCEPT
--- a/include/boost/system/detail/snprintf.hpp
+++ b/include/boost/system/detail/snprintf.hpp
@@ -49,6 +49,9 @@ inline void snprintf( char * buffer, std::size_t len, char const * format, ... )

 #else

+#if defined(__GNUC__) && __GNUC__ >= 3
+__attribute__((__format__ (__printf__, 3, 4)))
+#endif
 inline void snprintf( char * buffer, std::size_t len, char const * format, ... )
 {
    va_list args;
--- a/include/boost/system/detail/std_category.hpp
+++ b/include/boost/system/detail/std_category.hpp
@@ -11,9 +11,6 @@
 // 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>

 //
@@ -33,6 +30,13 @@ 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 )
@@ -66,72 +70,10 @@ public:
        return pc_->default_error_condition( ev );
    }

-    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 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;
 };

-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
--- a/include/boost/system/detail/std_category_impl.hpp
+++ b/include/boost/system/detail/std_category_impl.hpp
@@ -0,0 +1,97 @@
+#ifndef BOOST_SYSTEM_DETAIL_STD_CATEGORY_IMPL_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_STD_CATEGORY_IMPL_HPP_INCLUDED
+
+// Support for interoperability between Boost.System and <system_error>
+//
+// Copyright 2018, 2021 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/std_category.hpp>
+#include <boost/system/detail/error_condition.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/detail/generic_category.hpp>
+
+//
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+inline bool std_category::equivalent( int code, const std::error_condition & condition ) const 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
--- a/include/boost/system/detail/system_category_impl.hpp
+++ b/include/boost/system/detail/system_category_impl.hpp
@@ -11,6 +11,7 @@
 //  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>

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

 #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,35 +39,23 @@ 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 generic_error_category_message( ev );
+    return system_error_category_message( ev );
 }

 inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
 {
-    return generic_error_category_message( ev, buffer, len );
+    return system_error_category_message( ev, buffer, len );
 }

-#endif // #if defined(BOOST_WINDOWS_API)
-
 #endif // #ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_IMPL_HPP_INCLUDED
--- a/include/boost/system/detail/system_category_message.hpp
+++ b/include/boost/system/detail/system_category_message.hpp
@@ -0,0 +1,71 @@
+#ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_HPP_INCLUDED
+
+// Implementation of system_error_category_message
+//
+// Copyright 2018, 2022 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/api_config.hpp>
+
+#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API)
+#  error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
+#endif
+
+#if defined(BOOST_WINDOWS_API)
+
+#include <boost/system/detail/system_category_message_win32.hpp>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+inline std::string system_error_category_message( int ev )
+{
+    return system_category_message_win32( ev );
+}
+
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) 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
--- a/include/boost/system/errc.hpp
+++ b/include/boost/system/errc.hpp
@@ -16,6 +16,7 @@
 #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
@@ -35,6 +36,12 @@ BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) BOOST_NOEXC
    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 );
+}
+
 // implicit conversion:
 BOOST_SYSTEM_CONSTEXPR inline error_condition make_error_condition( errc_t e ) BOOST_NOEXCEPT
 {
--- a/include/boost/system/linux_error.hpp
+++ b/include/boost/system/linux_error.hpp
@@ -10,13 +10,6 @@
 #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.

--- a/include/boost/system/result.hpp
+++ b/include/boost/system/result.hpp
@@ -1,7 +1,7 @@
 #ifndef BOOST_SYSTEM_RESULT_HPP_INCLUDED
 #define BOOST_SYSTEM_RESULT_HPP_INCLUDED

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

@@ -11,11 +11,14 @@
 #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>

 //

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

 // throw_exception_from_error

-BOOST_NORETURN inline void throw_exception_from_error( error_code const & e )
+#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::throw_exception( system_error( e ) );
+    boost::throw_with_location( system_error( e ), loc );
 }

+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>;
@@ -39,6 +78,15 @@ 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
@@ -62,35 +110,11 @@ public:
    {
    }

-    // explicit, value
-    template<class A, class En = typename std::enable_if<
-        std::is_constructible<T, A>::value &&
-        !std::is_convertible<A, T>::value &&
-        !std::is_constructible<E, A>::value
-        >::type>
-    explicit constexpr result( A&& a )
-        noexcept( std::is_nothrow_constructible<T, A>::value )
-        : v_( in_place_value, std::forward<A>(a) )
-    {
-    }
-
-    // explicit, error
-    template<class A, class En2 = void, class En = typename std::enable_if<
-        std::is_constructible<E, A>::value &&
-        !std::is_convertible<A, E>::value &&
-        !std::is_constructible<T, A>::value
-        >::type>
-    explicit constexpr result( A&& a )
-        noexcept( std::is_nothrow_constructible<E, A>::value )
-        : v_( in_place_error, std::forward<A>(a) )
-    {
-    }
-
    // implicit, value
-    template<class A, class En2 = void, class En3 = void, class En = typename std::enable_if<
+    template<class A = T, typename std::enable_if<
        std::is_convertible<A, T>::value &&
-        !std::is_constructible<E, A>::value
-        >::type>
+        !(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 )
        : v_( in_place_value, std::forward<A>(a) )
@@ -98,35 +122,33 @@ public:
    }

    // implicit, error
-    template<class A, class En2 = void, class En3 = void, class En4 = void, class En = typename std::enable_if<
+    template<class A = E, class = void, typename std::enable_if<
        std::is_convertible<A, E>::value &&
-        !std::is_constructible<T, A>::value
-        >::type>
+        !std::is_constructible<T, A>::value, int>::type = 0>
    constexpr result( A&& a )
        noexcept( std::is_nothrow_constructible<E, A>::value )
        : v_( in_place_error, std::forward<A>(a) )
    {
    }

-    // more than one arg, value
+    // explicit, value
    template<class... A, class En = typename std::enable_if<
        std::is_constructible<T, A...>::value &&
-        !std::is_constructible<E, A...>::value &&
-        sizeof...(A) >= 2
+        !(detail::is_errc_t<A...>::value && std::is_arithmetic<T>::value) &&
+        !std::is_constructible<E, A...>::value
        >::type>
-    constexpr result( A&&... a )
+    explicit constexpr result( A&&... a )
        noexcept( std::is_nothrow_constructible<T, A...>::value )
        : v_( in_place_value, std::forward<A>(a)... )
    {
    }

-    // more than one arg, error
+    // explicit, error
    template<class... A, class En2 = void, class En = typename std::enable_if<
        !std::is_constructible<T, A...>::value &&
-        std::is_constructible<E, A...>::value &&
-        sizeof...(A) >= 2
+        std::is_constructible<E, A...>::value
        >::type>
-    constexpr result( A&&... a )
+    explicit constexpr result( A&&... a )
        noexcept( std::is_nothrow_constructible<E, A...>::value )
        : v_( in_place_error, std::forward<A>(a)... )
    {
@@ -172,7 +194,7 @@ public:
    // checked value access
 #if defined( BOOST_NO_CXX11_REF_QUALIFIERS )

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

 #else

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

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

-    BOOST_CXX14_CONSTEXPR T&& 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 ) &&
    {
-        return std::move( value() );
+        return std::move( value( loc ) );
    }

-    BOOST_CXX14_CONSTEXPR T const&& value() const&&
+    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 ) &&
    {
-        return std::move( value() );
+        return std::move( value( loc ) );
+    }
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
+        value() const && = delete;
+
+    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 &&
+    {
+        return std::move( value( loc ) );
    }

 #endif
@@ -274,12 +315,31 @@ public:
        return *p;
    }

-    BOOST_CXX14_CONSTEXPR T&& operator*() && noexcept
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
+        operator*() && noexcept(std::is_nothrow_move_constructible<T>::value)
    {
        return std::move(**this);
    }

-    BOOST_CXX14_CONSTEXPR T const&& operator*() const && noexcept
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<!std::is_move_constructible<U>::value, T&&>::type
+        operator*() && noexcept
+    {
+        return std::move(**this);
+    }
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<std::is_move_constructible<U>::value, T>::type
+        operator*() const && noexcept = delete;
+
+    template<class U = T>
+        BOOST_CXX14_CONSTEXPR
+        typename std::enable_if<!std::is_move_constructible<U>::value, T const&&>::type
+        operator*() const && noexcept
    {
        return std::move(**this);
    }
@@ -422,14 +482,14 @@ public:

    // checked value access

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

--- a/include/boost/system/system_error.hpp
+++ b/include/boost/system/system_error.hpp
@@ -6,9 +6,8 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt

+#include <boost/system/errc.hpp>
 #include <boost/system/detail/error_code.hpp>
-#include <boost/system/detail/error_category_impl.hpp>
-#include <boost/system/detail/snprintf.hpp>
 #include <string>
 #include <stdexcept>
 #include <cassert>
@@ -24,79 +23,25 @@ private:

    error_code code_;

-private:
-
-    static std::string to_string( int v )
-    {
-        char buffer[ 32 ];
-        detail::snprintf( buffer, sizeof( buffer ), "%d", v );
-
-        return buffer;
-    }
-
-    static std::string build_message( char const * prefix, error_code const & ec )
-    {
-        std::string r;
-
-        if( prefix )
-        {
-            r += prefix;
-            r += ": ";
-        }
-
-        r += ec.message();
-
-        if( ec.has_location() )
-        {
-            r += " [";
-            r += ec.to_string();
-            r += " at ";
-
-            boost::source_location loc = ec.location();
-
-            r += loc.file_name();
-
-            r += ':';
-            r += to_string( loc.line() );
-
-            if( loc.column() != 0 )
-            {
-                r += ':';
-                r += to_string( loc.column() );
-            }
-
-            r += " in function '";
-            r += loc.function_name();
-            r += "\']";
-        }
-
-        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( build_message( 0, ec ) ), code_( ec ) {}
+    explicit system_error( error_code const & ec ):
+        std::runtime_error( ec.what() ), code_( ec ) {}

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

-    system_error( int ev, error_category const & ecat )
-      : std::runtime_error( build_message( 0, ev, ecat ) ), code_( ev, ecat ) {}
+    system_error( int ev, error_category const & ecat ):
+        std::runtime_error( error_code( ev, ecat ).what() ), code_( ev, ecat ) {}

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

    error_code code() const BOOST_NOEXCEPT
    {
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -4,9 +4,14 @@
    "authors": [
        "Beman Dawes"
    ],
-    "description": "Operating system support, including the diagnostics support that will be part of the C++0x standard library.",
+    "maintainers": [
+        "Peter Dimov <pdimov -at- gmail.com>"
+    ],
+    "description": "Extensible error reporting.",
    "category": [
-        "System"
+        "System",
+        "Error-handling",
+        "Programming"
    ],
    "cxxstd": "03"
 }
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -103,6 +103,23 @@ boost_test(TYPE run SOURCES ec_location_test.cpp)

 boost_test(TYPE run SOURCES error_condition_test3.cpp)
 boost_test(TYPE run SOURCES error_code_test2.cpp)
+boost_test(TYPE run SOURCES system_error_test2.cpp)
+boost_test(TYPE run SOURCES std_interop_test10.cpp)
+
+boost_test(TYPE run SOURCES ec_location_test2.cpp)
+boost_test(TYPE run SOURCES ec_what_test.cpp)
+boost_test(TYPE run SOURCES system_error_test3.cpp)
+
+boost_test(TYPE run SOURCES std_interop_test11.cpp)
+
+boost_test(TYPE run SOURCES ec_wstream_test.cpp)
+
+boost_test(TYPE run SOURCES std_interop_test12.cpp)
+
+boost_test(TYPE run SOURCES errc_test4.cpp)
+
+boost_test(TYPE run SOURCES std_interop_test13.cpp)
+boost_test(TYPE run SOURCES std_interop_test14.cpp)

 # result

@@ -119,3 +136,6 @@ boost_test(TYPE run SOURCES result_value_access.cpp)
 boost_test(TYPE run SOURCES result_error_access.cpp)
 boost_test(TYPE run SOURCES result_swap.cpp)
 boost_test(TYPE run SOURCES result_eq.cpp)
+boost_test(TYPE run SOURCES result_range_for.cpp)
+boost_test(TYPE run SOURCES result_value_construct2.cpp)
+boost_test(TYPE run SOURCES result_error_construct2.cpp)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -20,6 +20,8 @@ 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 + )
@@ -73,8 +75,8 @@ system-run failed_constexpr_test.cpp ;
 # Quick (CI) test
 run quick.cpp ;

-compile warnings_test.cpp
-  : <warnings>pedantic
+run warnings_test.cpp
+  : : : <warnings>pedantic
    <toolset>msvc:<warnings-as-errors>on
    <toolset>gcc:<warnings-as-errors>on
    <toolset>clang:<warnings-as-errors>on ;
@@ -125,12 +127,29 @@ run ec_location_test.cpp ;

 run error_condition_test3.cpp ;
 run error_code_test2.cpp ;
+run system_error_test2.cpp ;
+run std_interop_test10.cpp ;
+
+run ec_location_test2.cpp ;
+run ec_what_test.cpp ;
+run system_error_test3.cpp ;
+
+run std_interop_test11.cpp ;
+
+run ec_wstream_test.cpp ;
+
+run std_interop_test12.cpp ;
+
+run errc_test4.cpp ;
+
+run std_interop_test13.cpp ;
+run std_interop_test14.cpp ;

 # result

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

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

 run result_default_construct.cpp : : : $(CPP11) ;
 run result_value_construct.cpp : : : $(CPP11) ;
@@ -143,3 +162,7 @@ run result_value_access.cpp : : : $(CPP11) ;
 run result_error_access.cpp : : : $(CPP11) ;
 run result_swap.cpp : : : $(CPP11) <toolset>gcc-10:<cxxflags>"-Wno-maybe-uninitialized" ;
 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) ;
--- a/test/cmake_install_test/main.cpp
+++ b/test/cmake_install_test/main.cpp
@@ -40,5 +40,5 @@ int main()
    boost::system::system_error x( bc, "prefix" );

    BOOST_TEST_EQ( x.code(), bc );
-    BOOST_TEST_EQ( std::string( x.what() ), "prefix: " + bc.message() );
+    BOOST_TEST_EQ( std::string( x.what() ), "prefix: " + bc.what() );
 }
--- a/test/cmake_subdir_test/CMakeLists.txt
+++ b/test/cmake_subdir_test/CMakeLists.txt
@@ -12,6 +12,7 @@ add_subdirectory(../../../config boostorg/config)
 add_subdirectory(../../../core boostorg/core)
 add_subdirectory(../../../mp11 boostorg/mp11)
 add_subdirectory(../../../predef boostorg/predef)
+add_subdirectory(../../../static_assert boostorg/static_assert)
 add_subdirectory(../../../throw_exception boostorg/throw_exception)
 add_subdirectory(../../../variant2 boostorg/variant2)
 add_subdirectory(../../../winapi boostorg/winapi)
--- a/test/ec_location_test2.cpp
+++ b/test/ec_location_test2.cpp
@@ -0,0 +1,287 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+namespace sys = boost::system;
+
+enum E
+{
+    none = 0,
+    einval = EINVAL
+};
+
+namespace boost
+{
+namespace system
+{
+
+template<> struct is_error_code_enum< ::E >
+{
+    static const bool value = true;
+};
+
+} // namespace system
+} // namespace boost
+
+sys::error_code make_error_code( E e )
+{
+    return e == 0? sys::error_code(): sys::error_code( e, sys::generic_category() );
+}
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+enum E2
+{
+    e2inval = EINVAL
+};
+
+namespace boost
+{
+namespace system
+{
+
+template<> struct is_error_code_enum< ::E2 >
+{
+    static const bool value = true;
+};
+
+} // namespace system
+} // namespace boost
+
+std::error_code make_error_code( E2 e )
+{
+    return std::error_code( e, std::generic_category() );
+}
+
+#endif
+
+int main()
+{
+    {
+        sys::error_code ec( einval );
+
+        BOOST_TEST_EQ( ec.value(), EINVAL );
+        BOOST_TEST_EQ( &ec.category(), &sys::generic_category() );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( einval, &loc );
+
+        BOOST_TEST_EQ( ec.value(), EINVAL );
+        BOOST_TEST_EQ( &ec.category(), &sys::generic_category() );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 77 );
+    }
+
+    {
+        sys::error_code ec( none );
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( none, &loc );
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec = sys::error_code( einval, &loc );
+
+        BOOST_TEST_EQ( ec.value(), EINVAL );
+        BOOST_TEST_EQ( &ec.category(), &sys::generic_category() );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 127 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec = sys::error_code( none, &loc );
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( einval, &loc );
+
+        BOOST_TEST_EQ( ec.value(), EINVAL );
+        BOOST_TEST_EQ( &ec.category(), &sys::generic_category() );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 175 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( none, &loc );
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    {
+        sys::error_code ec( e2inval );
+
+        BOOST_TEST_EQ( ec, std::error_code( EINVAL, std::generic_category() ) );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( e2inval, &loc );
+
+        BOOST_TEST_EQ( ec, std::error_code( EINVAL, std::generic_category() ) );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec = sys::error_code( e2inval, &loc );
+
+        BOOST_TEST_EQ( ec, std::error_code( EINVAL, std::generic_category() ) );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST_EQ( &ec.category(), &sys::system_category() );
+
+        BOOST_TEST( !ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        ec.assign( e2inval, &loc );
+
+        BOOST_TEST_EQ( ec, std::error_code( EINVAL, std::generic_category() ) );
+
+        BOOST_TEST( ec.failed() );
+
+        BOOST_TEST( !ec.has_location() );
+        BOOST_TEST_EQ( ec.location().line(), 0 );
+    }
+
+#endif
+
+    return boost::report_errors();
+}
--- a/test/ec_what_test.cpp
+++ b/test/ec_what_test.cpp
@@ -0,0 +1,91 @@
+// Copyright 2020, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [system:0]" );
+    }
+
+    {
+        sys::error_code ec( 5, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec.value(), 5 );
+        BOOST_TEST( ec.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [generic:5]" );
+    }
+
+    {
+        sys::error_code ec( 5, sys::system_category() );
+
+        BOOST_TEST_EQ( ec.value(), 5 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [system:5]" );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( 5, sys::generic_category(), &loc );
+
+        BOOST_TEST_EQ( ec.value(), 5 );
+        BOOST_TEST( ec.category() == sys::generic_category() );
+        BOOST_TEST_EQ( &ec.location(), &loc );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [generic:5 at " + loc.to_string() + "]" );
+    }
+
+    {
+        BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+        sys::error_code ec( 5, sys::system_category(), &loc );
+
+        BOOST_TEST_EQ( ec.value(), 5 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+        BOOST_TEST_EQ( &ec.location(), &loc );
+
+        BOOST_TEST_EQ( ec.what(), ec.message() + " [system:5 at " + loc.to_string() + "]" );
+    }
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    {
+        std::error_code ec;
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.what(), ec2.message() + " [std:system:0]" );
+    }
+
+    {
+        std::error_code ec( 5, std::generic_category() );
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.what(), ec2.message() + " [std:generic:5]" );
+    }
+
+    {
+        std::error_code ec( 5, std::system_category() );
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.what(), ec2.message() + " [std:system:5]" );
+    }
+
+#endif
+
+    return boost::report_errors();
+}
--- a/test/ec_wstream_test.cpp
+++ b/test/ec_wstream_test.cpp
@@ -0,0 +1,21 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <sstream>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        std::wostringstream os;
+        os << sys::error_code();
+
+        BOOST_TEST( os.str() == L"system:0" );
+    }
+
+    return boost::report_errors();
+}
--- a/test/errc_test4.cpp
+++ b/test/errc_test4.cpp
@@ -0,0 +1,17 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+#include <boost/assert/source_location.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+    BOOST_TEST( make_error_code( boost::system::errc::no_such_file_or_directory, &loc ).has_location() );
+    BOOST_TEST_EQ( make_error_code( boost::system::errc::no_such_file_or_directory, &loc ).location().to_string(), loc.to_string() );
+
+    return boost::report_errors();
+}
--- a/test/quick.cpp
+++ b/test/quick.cpp
@@ -37,7 +37,7 @@ int main()
    boost::system::system_error x( bc, "prefix" );

    BOOST_TEST_EQ( x.code(), bc );
-    BOOST_TEST_EQ( std::string( x.what() ), "prefix: " + bc.message() );
+    BOOST_TEST_EQ( std::string( x.what() ), "prefix: " + bc.what() );

    return boost::report_errors();
 }
--- a/test/result_errc_construct.cpp
+++ b/test/result_errc_construct.cpp
@@ -0,0 +1,23 @@
+// 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();
+}
--- a/test/result_error_construct.cpp
+++ b/test/result_error_construct.cpp
@@ -62,13 +62,13 @@ int main()
        BOOST_TEST( !r.has_value() );
        BOOST_TEST( r.has_error() );

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

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

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

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

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

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

-        BOOST_TEST_EQ( r.error(), std::error_code( EINVAL, generic_category() ) );
+        BOOST_TEST_EQ( r.error(), 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>, std::error_code>));
-        BOOST_TEST_TRAIT_TRUE((std::is_convertible<std::error_code, result<int>>));
+        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<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(), std::error_code( EINVAL, generic_category() ) );
+        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
    }

    return boost::report_errors();
--- a/test/result_error_construct2.cpp
+++ b/test/result_error_construct2.cpp
@@ -0,0 +1,57 @@
+// 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.hpp>
+#include <string>
+
+using namespace boost::system;
+
+struct X
+{
+    int a, b;
+};
+
+result<X> fx1()
+{
+    return {{ EINVAL, generic_category() }};
+}
+
+struct Y
+{
+    std::string v;
+};
+
+struct E
+{
+    int v;
+};
+
+result<Y, E> fy1()
+{
+    return {{ 42 }};
+}
+
+int main()
+{
+    {
+        result<X> r = fx1();
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+    }
+
+    {
+        result<Y, E> r = fy1();
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v, 42 );
+    }
+
+    return boost::report_errors();
+}
--- a/test/result_range_for.cpp
+++ b/test/result_range_for.cpp
@@ -0,0 +1,30 @@
+// 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.hpp>
+#include <vector>
+
+using namespace boost::system;
+
+result<std::vector<int>> f()
+{
+    return std::vector<int>{ 1, 2, 3 };
+}
+
+int main()
+{
+    {
+        int s = 0;
+
+        for( int x: f().value() )
+        {
+            s += x;
+        }
+
+        BOOST_TEST_EQ( s, 6 );
+    }
+
+    return boost::report_errors();
+}
--- a/test/result_value_access.cpp
+++ b/test/result_value_access.cpp
@@ -1,10 +1,11 @@
-// Copyright 2017, 2021 Peter Dimov.
+// 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>
+#include <system_error>

 using namespace boost::system;

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

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

+struct E2
+{
+};
+
 int main()
 {
    {
@@ -165,6 +170,78 @@ 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 );

@@ -341,5 +418,77 @@ 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();
 }
--- a/test/result_value_construct2.cpp
+++ b/test/result_value_construct2.cpp
@@ -0,0 +1,152 @@
+// 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.hpp>
+#include <vector>
+#include <string>
+
+using namespace boost::system;
+
+struct X
+{
+    int a;
+};
+
+struct Y
+{
+    int a, b;
+};
+
+struct E
+{
+    std::string v;
+};
+
+result<X> fx0()
+{
+    return {};
+}
+
+result<X> fx1()
+{
+    return {{ 1 }};
+}
+
+result<Y> fy0()
+{
+    return {};
+}
+
+result<Y> fy2()
+{
+    return {{ 1, 2 }};
+}
+
+result<X, E> fxe0()
+{
+    return {};
+}
+
+result<X, E> fxe1()
+{
+    return {{ 1 }};
+}
+
+result<std::vector<int>> fv0()
+{
+    return {};
+}
+
+result<std::vector<int>> fv1()
+{
+    return {{ 1 }};
+}
+
+result<std::vector<int>> fv2()
+{
+    return {{ 1, 2 }};
+}
+
+int main()
+{
+    {
+        result<X> r = fx0();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->a, 0 );
+    }
+
+    {
+        result<X> r = fx1();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->a, 1 );
+    }
+
+    {
+        result<Y> r = fy0();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->a, 0 );
+        BOOST_TEST_EQ( r->b, 0 );
+    }
+
+    {
+        result<Y> r = fy2();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->a, 1 );
+        BOOST_TEST_EQ( r->b, 2 );
+    }
+
+    {
+        result<X, E> r = fxe0();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->a, 0 );
+    }
+
+    {
+        result<X, E> r = fxe1();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->a, 1 );
+    }
+
+    {
+        result<std::vector<int>> r = fv0();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->size(), 0 );
+    }
+
+    {
+        result<std::vector<int>> r = fv1();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->size(), 1 );
+        BOOST_TEST_EQ( r->at(0), 1 );
+    }
+
+    {
+        result<std::vector<int>> r = fv2();
+
+        BOOST_TEST( r.has_value() );
+
+        BOOST_TEST_EQ( r->size(), 2 );
+        BOOST_TEST_EQ( r->at(0), 1 );
+        BOOST_TEST_EQ( r->at(1), 2 );
+    }
+
+    return boost::report_errors();
+}
--- a/test/std_interop_test.cpp
+++ b/test/std_interop_test.cpp
@@ -44,7 +44,8 @@ static void test_generic_category()

    int ev = ENOENT;

-    BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+    // Under MSVC, it's "no such file or directory" instead of "No such file or directory"
+    BOOST_TEST_EQ( bt.message( ev ).substr( 1 ), st.message( ev ).substr( 1 ) );

    {
        boost::system::error_code bc( ev, bt );
@@ -82,34 +83,13 @@ static void test_system_category()

    BOOST_TEST_CSTR_EQ( bt.name(), st.name() );

+    for( int ev = 1; ev < 6; ++ev )
    {
-        int ev = 5;
-        BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+        std::string bm = bt.message( ev );
+        std::string sm = st.message( ev );

-        {
-            boost::system::error_code bc( ev, bt );
-
-            BOOST_TEST_EQ( bc.value(), ev );
-            BOOST_TEST_EQ( &bc.category(), &bt );
-
-            std::error_code sc( bc );
-
-            BOOST_TEST_EQ( sc.value(), ev );
-            BOOST_TEST_EQ( &sc.category(), &st );
-        }
-
-        {
-            boost::system::error_condition bn = bt.default_error_condition( ev );
-            BOOST_TEST( bt.equivalent( ev, bn ) );
-
-            std::error_condition sn( bn );
-            BOOST_TEST( st.equivalent( ev, sn ) );
-        }
-    }
-
-    {
-        int ev = 4;
-        BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+        // We strip whitespace and the trailing dot, MSVC not so much
+        BOOST_TEST_EQ( bm, sm.substr( 0, bm.size() ) );

        {
            boost::system::error_code bc( ev, bt );
--- a/test/std_interop_test10.cpp
+++ b/test/std_interop_test10.cpp
@@ -0,0 +1,66 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config/pragma_message.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>
+
+int main()
+{
+    {
+        boost::system::error_code e1;
+        boost::system::error_code e2( 0, boost::system::system_category() );
+
+        BOOST_TEST_EQ( e1, e2 );
+
+        std::error_code e3( e1 );
+        std::error_code e4( e2 );
+
+        BOOST_TEST_EQ( e3, e4 );
+    }
+
+    {
+        boost::system::error_code e1;
+
+        std::error_code e2( e1 );
+        std::error_code e3( e1.value(), e1.category() );
+
+        BOOST_TEST_EQ( e2, e3 );
+    }
+
+    {
+        boost::system::error_condition e1;
+        boost::system::error_condition e2( 0, boost::system::generic_category() );
+
+        BOOST_TEST_EQ( e1, e2 );
+
+        std::error_condition e3( e1 );
+        std::error_condition e4( e2 );
+
+        BOOST_TEST( e3 == e4 );
+    }
+
+    {
+        boost::system::error_condition e1;
+
+        std::error_condition e2( e1 );
+        std::error_condition e3( e1.value(), e1.category() );
+
+        BOOST_TEST( e2 == e3 );
+    }
+
+    return boost::report_errors();
+}
+
+#endif
--- a/test/std_interop_test11.cpp
+++ b/test/std_interop_test11.cpp
@@ -0,0 +1,47 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/config.hpp>
+#include <ios>
+
+#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test, BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined" )
+int main() {}
+
+#elif defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 50000
+
+BOOST_PRAGMA_MESSAGE( "Skipping test, BOOST_LIBSTDCXX_VERSION < 50000" )
+int main() {}
+
+#else
+
+#include <system_error>
+
+int main()
+{
+    {
+        boost::system::error_code ec = std::io_errc::stream;
+
+        BOOST_TEST( ec == std::io_errc::stream );
+        BOOST_TEST_NOT( ec != std::io_errc::stream );
+
+        ec.clear();
+
+        BOOST_TEST_NOT( ec == std::io_errc::stream );
+        BOOST_TEST( ec != std::io_errc::stream );
+
+        ec = std::io_errc::stream;
+
+        BOOST_TEST( ec == std::io_errc::stream );
+        BOOST_TEST_NOT( ec != std::io_errc::stream );
+    }
+
+    return boost::report_errors();
+}
+
+#endif
--- a/test/std_interop_test12.cpp
+++ b/test/std_interop_test12.cpp
@@ -0,0 +1,127 @@
+// 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
--- a/test/std_interop_test13.cpp
+++ b/test/std_interop_test13.cpp
@@ -0,0 +1,77 @@
+// 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
--- a/test/std_interop_test14.cpp
+++ b/test/std_interop_test14.cpp
@@ -0,0 +1,57 @@
+// 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
--- a/test/std_interop_test6.cpp
+++ b/test/std_interop_test6.cpp
@@ -30,13 +30,20 @@ int main()
        BOOST_TEST_EQ( e2, e1 );
        BOOST_TEST_NOT( e2 != e1 );

-        BOOST_TEST( e2 == en );
+#if defined(_LIBCPP_VERSION)
+
+        // Under MS STL and libstdc++, std::error_code() does not compare
+        // equal to std::error_condition(). Go figure.
+
+        BOOST_TEST_EQ( e2, en );
        BOOST_TEST_NOT( e2 != en );

        boost::system::error_code e3( e2 );

        BOOST_TEST_EQ( e3, en );
        BOOST_TEST_NOT( e3 != en );
+
+#endif
    }

    {
@@ -51,13 +58,17 @@ int main()
        BOOST_TEST_EQ( e2, e1 );
        BOOST_TEST_NOT( e2 != e1 );

-        BOOST_TEST( e2 == en );
+#if defined(_LIBCPP_VERSION)
+
+        BOOST_TEST_EQ( e2, en );
        BOOST_TEST_NOT( e2 != en );

        boost::system::error_code e3( e2 );

        BOOST_TEST_EQ( e3, en );
        BOOST_TEST_NOT( e3 != en );
+
+#endif
    }

    {
@@ -72,7 +83,7 @@ int main()
        BOOST_TEST_EQ( e2, e1 );
        BOOST_TEST_NOT( e2 != e1 );

-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
        BOOST_TEST_NOT( e2 != en );

        boost::system::error_code e3( e2 );
@@ -93,7 +104,7 @@ int main()
        BOOST_TEST_EQ( e2, e1 );
        BOOST_TEST_NOT( e2 != e1 );

-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
        BOOST_TEST_NOT( e2 != en );

        boost::system::error_code e3( e2 );
@@ -114,7 +125,7 @@ int main()
        BOOST_TEST_EQ( e2, e1 );
        BOOST_TEST_NOT( e2 != e1 );

-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
        BOOST_TEST_NOT( e2 != en );

        boost::system::error_code e3( e2 );
--- a/test/system_error_test.cpp
+++ b/test/system_error_test.cpp
@@ -81,27 +81,25 @@ int main( int, char *[] )
  system_error c6_0( 0, system_category(), "c6_0" ); 
  system_error c6_1( 1, system_category(), "c6_1" );

-  TEST( c1_0, 0, "The operation completed successfully" );
-  TEST( c1_1, 1, "Incorrect function" );
-  TEST( c1_2u, 2, "The system cannot find the file specified" );
+  TEST( c1_0, 0, "The operation completed successfully [system:0]" );
+  TEST( c1_1, 1, "Incorrect function [system:1]" );
+  TEST( c1_2u, 2, "The system cannot find the file specified [system:2]" );

-  TEST( c2_0, 0, "c2_0: The operation completed successfully" );
-  TEST( c2_1, 1, "c2_1: Incorrect function" );
+  TEST( c2_0, 0, "c2_0: The operation completed successfully [system:0]" );
+  TEST( c2_1, 1, "c2_1: Incorrect function [system:1]" );

-  TEST( c3_0, 0, "c3_0: The operation completed successfully" );
-  TEST( c3_1, 1, "c3_1: Incorrect function" );
+  TEST( c3_0, 0, "c3_0: The operation completed successfully [system:0]" );
+  TEST( c3_1, 1, "c3_1: Incorrect function [system:1]" );

-  TEST( c4_0, 0, "The operation completed successfully" );
-  TEST( c4_1, 1, "Incorrect function" );
-  TEST( c4_2u, 2, "The system cannot find the file specified" );
+  TEST( c4_0, 0, "The operation completed successfully [system:0]" );
+  TEST( c4_1, 1, "Incorrect function [system:1]" );
+  TEST( c4_2u, 2, "The system cannot find the file specified [system:2]" );

-  TEST( c5_0, 0, "c5_0: The operation completed successfully" );
-  TEST( c5_1, 1, "c5_1: Incorrect function" );
+  TEST( c5_0, 0, "c5_0: The operation completed successfully [system:0]" );
+  TEST( c5_1, 1, "c5_1: Incorrect function [system:1]" );

-  TEST( c6_0, 0, "c6_0: The operation completed successfully" );
-  TEST( c6_1, 1, "c6_1: Incorrect function" );
+  TEST( c6_0, 0, "c6_0: The operation completed successfully [system:0]" );
+  TEST( c6_1, 1, "c6_1: Incorrect function [system:1]" );

  return ::boost::report_errors();
 }
-
-
--- a/test/system_error_test2.cpp
+++ b/test/system_error_test2.cpp
@@ -0,0 +1,41 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/system_error.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        sys::error_code ec( 5, sys::generic_category() );
+        sys::system_error x1( ec );
+        (void)x1;
+    }
+
+    {
+        sys::error_code ec( 5, sys::system_category() );
+        sys::system_error x1( ec );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( make_error_code( sys::errc::invalid_argument ) );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( 5, sys::generic_category() );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( 5, sys::system_category() );
+        (void)x1;
+    }
+
+    return boost::report_errors();
+}
--- a/test/system_error_test3.cpp
+++ b/test/system_error_test3.cpp
@@ -0,0 +1,62 @@
+// 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/system_error.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        sys::error_code ec( 5, sys::generic_category() );
+        sys::system_error x1( ec );
+
+        BOOST_TEST_EQ( std::string( x1.what() ), ec.what() );
+    }
+
+    {
+        sys::error_code ec( 5, sys::generic_category() );
+        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" ) );
+
+        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() );
+    }
+
+    {
+        sys::system_error x1( 5, sys::system_category(), "prefix" );
+
+        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();
+}
--- a/test/warnings_test.cpp
+++ b/test/warnings_test.cpp
@@ -46,7 +46,7 @@ int main()
    boost::system::system_error x( bc, "prefix" );

    BOOST_TEST_EQ( x.code(), bc );
-    BOOST_TEST_EQ( std::string( x.what() ), "prefix: " + bc.message() );
+    BOOST_TEST_EQ( std::string( x.what() ), "prefix: " + bc.what() );

    return boost::report_errors();
 }
Author	SHA1	Message	Date
Peter Dimov	a97e5a0546	Move BOOST_NOINLINE to operator std::error_category	2022-04-22 22:41:26 +03:00
Peter Dimov	dc17edfa07	Remove clang-win from appveyor.yml	2022-04-22 21:16:09 +03:00
Peter Dimov	65da7dfd56	Update result_error_construct tests to use sys::error_code instead of (erroneously) std::error_code	2022-04-22 19:52:19 +03:00
Peter Dimov	9279001b8c	Check BOOST_NO_CXX11_HDR_MUTEX when enabling <system_error> integration	2022-04-22 16:49:03 +03:00
Peter Dimov	616e652bd7	Suppress strict-aliasing warning for gcc 4.8 to 6	2022-04-21 21:06:14 +03:00
Peter Dimov	98439855bd	Use static_cast instead of reinterpret_cast	2022-04-21 20:52:02 +03:00
Peter Dimov	986efb1420	Rework conversion to std::error_category to not allocate (closes #78 )	2022-04-21 20:32:25 +03:00
Peter Dimov	28a13571b9	Restore the original system::error_code from std::error_code (refs #79 )	2022-03-18 18:24:01 +02:00
Peter Dimov	65ed1eef66	Add std_interop_test14.cpp (refs #79 )	2022-03-18 08:12:05 +02:00
Peter Dimov	6de20eeebc	Add std_interop_test13	2022-03-18 08:12:05 +02:00
Peter Dimov	0a9266ea7e	Add a comment explaining the one-time allocation in error_category_impl.hpp. Fixes #78 .	2022-03-18 08:11:16 +02:00
Peter Dimov	adb9fc54cb	Remove msvc-14.1 from ci.yml	2022-03-18 07:51:38 +02:00
Peter Dimov	e197c5e803	Update documentation	2022-02-18 19:43:08 +02:00
Peter Dimov	6d7a57a970	Add throw_exception_from_error overload for std::exception_ptr	2022-02-18 02:55:34 +02:00
Peter Dimov	00c71cf388	Add throw_exception_from_error overloads for boost::system::errc, std::errc	2022-02-17 21:55:47 +02:00
Peter Dimov	d930cea481	Update documentation	2022-02-14 02:05:44 +02:00
Peter Dimov	4f09f4adde	Use throw_with_location in throw_exception_from_error	2022-02-13 22:50:20 +02:00
Peter Dimov	abd62362ef	Update documentation	2022-02-09 20:52:23 +02:00
Peter Dimov	8d8e6a90de	Add an errc::make_error_code overload taking a source location	2022-02-09 20:41:34 +02:00
Peter Dimov	716c2ed8ef	Disable result tests on GCC 4.7	2022-02-07 21:40:26 +02:00
Peter Dimov	46a5ecd490	Do not include boost/system/result.hpp on GCC 4.7	2022-02-07 21:38:14 +02:00
Peter Dimov	79f4ef0416	Remove .drone.star	2022-02-07 21:34:11 +02:00
Peter Dimov	d0a8f7fbb7	Squash-merge feature/drone-jsonnet into develop	2022-02-07 21:33:48 +02:00
Peter Dimov	bc07ab1e25	Update .drone.star	2022-02-07 05:09:49 +02:00
Peter Dimov	c6bff94709	Update std_interop_test12.cpp	2022-02-07 04:35:44 +02:00
Peter Dimov	ae079810be	Add std_interop_test12.cpp	2022-02-07 04:30:50 +02:00
Peter Dimov	928de55563	Update .drone.star	2022-02-07 03:47:42 +02:00
Peter Dimov	442138de0a	Update .drone.star	2022-02-07 03:41:35 +02:00
Peter Dimov	de610efd53	Move conditions to detail/config.hpp	2022-02-07 03:16:23 +02:00
Peter Dimov	4b143cdacc	Use BOOST_LIBSTDCXX_VERSION instead of BOOST_GCC; update syscat condition	2022-02-07 03:02:57 +02:00
Peter Dimov	a1cb578f52	Update .drone.star	2022-02-07 02:55:54 +02:00
Peter Dimov	96b5073b79	Update .drone.star	2022-02-07 02:03:13 +02:00
Peter Dimov	2bff5c7071	Update .drone.star	2022-02-07 01:27:59 +02:00
Peter Dimov	137128176d	Update .drone.star	2022-02-07 01:14:28 +02:00
Peter Dimov	e0e0f56eae	Update .drone.star	2022-02-07 00:54:07 +02:00
Peter Dimov	58d55a67e5	Update .drone.star	2022-02-07 00:01:53 +02:00
Peter Dimov	34dcb59ee8	Update drone.bat	2022-02-06 23:30:19 +02:00
Peter Dimov	33f6ecba31	Update Drone files	2022-02-06 23:21:40 +02:00
Peter Dimov	23fbfb1ffa	Update .drone.star	2022-02-06 22:55:48 +02:00
Peter Dimov	5366407135	Add Windows jobs to Drone	2022-02-06 22:42:19 +02:00
Peter Dimov	72a79b1dcb	Disable -Wsign-compare for GCC 4.4	2022-02-06 22:29:28 +02:00
Peter Dimov	a5c1ab042e	Update Drone files	2022-02-06 22:25:45 +02:00
Peter Dimov	c2beb75d66	Merge pull request #59 from sdarwin/drone Drone config	2022-02-06 22:08:07 +02:00
Peter Dimov	54d9f4f38a	Update documentation	2022-02-05 19:25:43 +02:00
Peter Dimov	b92be6417a	Add a source_location parameter to throw_exception_from_error	2022-02-05 05:24:29 +02:00
Peter Dimov	245fff8af3	Update ci.yml	2022-02-05 03:11:09 +02:00
Peter Dimov	c359af3141	Update system_error constructors	2022-02-04 21:34:14 +02:00
Peter Dimov	50cad72fac	Update system_error_test3.cpp	2022-02-04 21:22:35 +02:00
Peter Dimov	9554d8bbd3	Suppress incorrect warnings from GCC 7/8	2022-02-03 19:02:19 +02:00
Peter Dimov	cf9d986871	Update documentation	2022-02-03 18:47:53 +02:00
Peter Dimov	a5d68e52e6	Add throw_exception_from_error overload for std::error_code	2022-02-03 18:35:42 +02:00
Peter Dimov	9c6a09f41d	Mark throw_exception_from_error as noinline	2022-02-03 09:37:59 +02:00
Peter Dimov	b9c26b9fa0	Add detail::system_error_category_message, use it in error_code::message	2022-02-03 05:47:43 +02:00
Peter Dimov	2e2430c4fa	Add error_code::category_name helper, use it in to_string	2022-02-03 04:36:58 +02:00
Peter Dimov	4b1caad727	Avoid sign conversion warnings in error_code::value	2022-01-19 17:30:56 +02:00
Peter Dimov	5b96abbaa8	Undeprecate linux_error.hpp (closes #77 )	2021-12-27 02:53:04 +02:00
Peter Dimov	2e1c800d82	Update appveyor.yml	2021-12-21 22:35:10 +02:00
Peter Dimov	04a79d710f	Merge branch 'fix_error_code_wostream' of https://github.com/MarcelRaad/system into feature/pr-76	2021-12-21 19:51:50 +02:00
Peter Dimov	5700936367	Add ec_wstream_test (refs #76 )	2021-12-21 19:51:08 +02:00
Marcel Raad	86b031cab9	Fix error_code's operator<< for arbitrary basic_ostream specializations This fixes a regression from commit `a9b64a888a`. Calling `operator<<` with `std::string` only works for `std::ostream`. Use `c_str()` to restore the previous behavior of using `const char*`, which works for any `basic_ostream` specialization.	2021-12-21 13:17:26 +01:00
Peter Dimov	204e65f725	Add msvc-14.0 to GHA	2021-12-11 03:42:52 +02:00
Peter Dimov	01ce081470	Disable errc_t -> arithmetic conversions when initializing result (closes #74 )	2021-12-11 01:22:08 +02:00
Peter Dimov	8c9ceba775	Add negative test for constructing result<int> from errc_t (refs #74 )	2021-12-09 20:19:05 +02:00
Peter Dimov	91c0dd9a74	Merge pull request #73 from kpushkaryov/patch-1 Fix a typo	2021-11-17 06:24:18 +02:00
Kirill Pushkaryov	189fff42fe	Fix a typo	2021-11-17 10:59:03 +07:00
Peter Dimov	3b4045c149	Minor doc update	2021-11-17 04:11:15 +02:00
Peter Dimov	3d877a1fca	Update meta/libraries.json	2021-11-11 04:51:03 +02:00
Peter Dimov	128bdf9db2	Minor usage section changes	2021-11-11 04:33:06 +02:00
Peter Dimov	0e84860604	Add another usage subsection	2021-11-11 04:09:49 +02:00
Peter Dimov	83a306f3bf	Update introduction	2021-11-10 20:36:57 +02:00
Peter Dimov	7dce2e3f42	Change 'wrapping' to 'adapting'	2021-11-10 18:52:41 +02:00
Peter Dimov	292c6825c6	Add another usage subsection	2021-11-09 22:05:45 +02:00
Peter Dimov	0d90d3d883	Add myimg_category implementation to usage example	2021-11-08 20:50:41 +02:00
Peter Dimov	81fec2b171	Add another usage subsection	2021-11-07 23:45:25 +02:00
Peter Dimov	4e15afe5be	Add error handling and programming categories to libraries.json	2021-11-07 20:32:42 +02:00
Peter Dimov	8d1a866920	Add a usage subsection on wrapping zlib errors	2021-11-05 22:05:23 +02:00
Peter Dimov	09466c85b4	Add another usage subsection	2021-11-05 20:38:03 +02:00
Peter Dimov	baef8e50ea	Rename 'Usage Examples' to 'Usage', add another subsection	2021-11-05 16:48:33 +02:00
Peter Dimov	5034f11a3a	Add usage examples	2021-11-02 03:12:26 +02:00
Peter Dimov	f78b036665	Update #if condition	2021-10-29 21:13:10 +03:00
Ed Catmur	9b0d735040	Add __attribute__((__format__)) to snprintf This attribute will check format string bugs and is required for clean compile if -Wformat-nonliteral is enabled.	2021-10-29 11:59:03 +01:00
Peter Dimov	bfebaf53d7	Add static_assert to cmake_subdir_test	2021-10-28 23:48:03 +03:00
Peter Dimov	8338e80295	Enable syntax hightlighting	2021-10-28 23:17:20 +03:00
Peter Dimov	2b23aaab16	Add msvc-14.3 to ci.yml	2021-10-28 23:16:53 +03:00
Peter Dimov	7933300b6f	Disable test on g++ 4.x because no std::io_errc	2021-10-11 03:30:50 +03:00
Peter Dimov	4ec1e54099	Enable error_code construction from enums specializing std::is_error_code_enum. Fixes #70 .	2021-10-11 02:02:22 +03:00
Peter Dimov	5217e58a7d	Enable implicit construction for aggregates using {{ ... }}	2021-10-02 22:07:05 +03:00
Peter Dimov	ce37e23491	Protect against dangling references in op* and value()	2021-10-02 19:16:04 +03:00
Peter Dimov	420a262733	Fix warnings_test.cpp	2021-10-02 17:25:31 +03:00
Peter Dimov	e15bccc09b	Fix cmake_install_test/main.cpp	2021-10-02 16:57:38 +03:00
Peter Dimov	bb775c071a	Update system_error::what to use error_code::what	2021-10-02 15:00:40 +03:00
Peter Dimov	01676ae42f	Update documentation	2021-10-02 14:47:07 +03:00
Peter Dimov	eefcc5dcf6	Add error_code::what	2021-10-02 14:41:27 +03:00
Peter Dimov	f2d3a0decf	Update documentation	2021-10-02 01:39:06 +03:00
Peter Dimov	0ccf08509b	Add a constructor taking ErrorCodeEnum and a source location	2021-10-01 23:04:04 +03:00
Peter Dimov	7a72aee355	Merge branch 'develop' into feature/std-category-2	2021-09-24 23:54:51 +03:00
Peter Dimov	a8df99e927	Use source_location::to_string in system_error::build_message	2021-09-24 20:40:19 +03:00
Peter Dimov	85c7d92302	Avoid instantiating the system category in error_code::operator std::error_code	2021-09-24 15:24:45 +03:00
Peter Dimov	4c201d26b2	Update std_interop_test10	2021-09-24 04:29:29 +03:00
Peter Dimov	1659dfbeba	Avoid instantiating generic_category in error_condition::operator std::error_condition	2021-09-24 04:27:08 +03:00
Peter Dimov	d2b8b54356	Do not use std::system_category under MinGW and g++ 4.x	2021-09-21 16:35:40 +03:00
Peter Dimov	41f7ea49cb	Do not use std::system_category under VS2013	2021-09-21 16:02:12 +03:00
Peter Dimov	0b22dc595f	Merge branch 'develop' into feature/std-category-2	2021-09-21 15:57:56 +03:00
Peter Dimov	aab58b0d5b	Add std_interop_test10	2021-09-21 15:57:39 +03:00
Peter Dimov	ad66ea43a3	Revert addition of get_generic_std_category, get_system_std_category (they need `this`); do not use std::system_category on Cygwin	2021-09-21 15:45:00 +03:00
Peter Dimov	811564f186	Disable failing comparisons in std_interop_test6; stdlibs are at fault	2021-09-21 15:11:19 +03:00
Peter Dimov	a7e4879e55	Fix message comparisons in std_interop_test	2021-09-21 15:06:28 +03:00
Peter Dimov	9b11d864be	Add helper functions get_generic_std_category, get_system_std_category	2021-09-21 15:01:44 +03:00
Peter Dimov	cc6a61b6c5	Convert system_category to std::system_category	2021-09-21 05:34:05 +03:00
Peter Dimov	9151633c95	Merge branch 'develop' into feature/std-category	2021-09-20 17:41:47 +03:00
Peter Dimov	5e0db22075	Include errc.hpp in system_error.hpp	2021-09-20 17:41:34 +03:00
Peter Dimov	60a20eeeb9	Retain old generic_category conversion behavior on g++ 4.8/4.9	2021-09-19 18:44:45 +03:00
Peter Dimov	1c8128e4cb	Merge branch 'develop' into feature/std-category	2021-09-19 18:12:59 +03:00
Peter Dimov	1879ba6d35	Minor test update	2021-09-19 18:12:46 +03:00
Peter Dimov	b1dec88674	Convert generic_category to std::generic_category	2021-09-19 17:08:46 +03:00
sdarwin	a688d7834a	add drone config [ci skip]	2021-01-21 19:45:47 +00:00