整理

include/boost/system/api_config.hpp

@@ -0,0 +1,42 @@
+//  boost/system/api_config.hpp  -------------------------------------------------------//
+
+//  Copyright Beman Dawes 2003, 2006, 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/system for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+//  Boost.System calls operating system API functions to implement system error category
+//  functions. Usually there is no question as to which API is to be used.
+//
+//  In the case of MinGW or Cygwin/MinGW, however, both POSIX and Windows API's are
+//  available. Chaos ensues if other code thinks one is in use when Boost.System was
+//  actually built with the other. This header centralizes the API choice and prevents
+//  user definition of API macros, thus elminating the possibility of mismatches and the
+//  need to test configurations with little or no practical value.
+//
+
+//--------------------------------------------------------------------------------------//
+
+#ifndef BOOST_SYSTEM_API_CONFIG_HPP                  
+#define BOOST_SYSTEM_API_CONFIG_HPP
+
+# if defined(BOOST_POSIX_API) || defined(BOOST_WINDOWS_API)
+#   error user defined BOOST_POSIX_API or BOOST_WINDOWS_API not supported
+# endif
+
+//  BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use
+//    Cygwin/MinGW does not predefine _WIN32.
+//    Standalone MinGW and all other known Windows compilers do predefine _WIN32
+//    Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too.
+
+# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin
+#   define BOOST_WINDOWS_API
+# else
+#   define BOOST_POSIX_API 
+# endif
+                                     
+#endif  // BOOST_SYSTEM_API_CONFIG_HPP 

include/boost/system/config.hpp

@@ -0,0 +1,50 @@
+//  boost/system/config.hpp  -----------------------------------------------------------//
+
+//  Copyright Beman Dawes 2003, 2006
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/system for documentation.
+
+#ifndef BOOST_SYSTEM_CONFIG_HPP
+#define BOOST_SYSTEM_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/system/api_config.hpp>  // for BOOST_POSIX_API or BOOST_WINDOWS_API
+
+// This header implemented separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+//
+// It's only retained for compatibility now that the library is header-only.
+
+//  normalize macros  ------------------------------------------------------------------//
+
+#if !defined(BOOST_SYSTEM_DYN_LINK) && !defined(BOOST_SYSTEM_STATIC_LINK) \
+  && !defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_ALL_STATIC_LINK)
+# define BOOST_SYSTEM_STATIC_LINK
+#endif
+
+#if defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_SYSTEM_DYN_LINK)
+# define BOOST_SYSTEM_DYN_LINK 
+#elif defined(BOOST_ALL_STATIC_LINK) && !defined(BOOST_SYSTEM_STATIC_LINK)
+# define BOOST_SYSTEM_STATIC_LINK 
+#endif
+
+#if defined(BOOST_SYSTEM_DYN_LINK) && defined(BOOST_SYSTEM_STATIC_LINK)
+# error Must not define both BOOST_SYSTEM_DYN_LINK and BOOST_SYSTEM_STATIC_LINK
+#endif
+
+//  enable dynamic or static linking as requested --------------------------------------//
+
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
+# if defined(BOOST_SYSTEM_SOURCE)
+#   define BOOST_SYSTEM_DECL BOOST_SYMBOL_EXPORT
+# else 
+#   define BOOST_SYSTEM_DECL BOOST_SYMBOL_IMPORT
+# endif
+#else
+# define BOOST_SYSTEM_DECL
+#endif
+
+#endif // BOOST_SYSTEM_CONFIG_HPP

include/boost/system/detail/append_int.hpp

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

include/boost/system/detail/cerrno.hpp

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

include/boost/system/detail/config.hpp

@@ -0,0 +1,83 @@
+#ifndef BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
+
+// 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 http://www.boost.org/libs/system for documentation.
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+// The macro BOOST_SYSTEM_DISABLE_THREADS can be defined on configurations
+// that provide <system_error> and <atomic>, but not <mutex>, such as the
+// single-threaded libstdc++.
+//
+// https://github.com/boostorg/system/issues/92
+
+// BOOST_SYSTEM_NOEXCEPT
+// Retained for backward compatibility
+
+#define BOOST_SYSTEM_NOEXCEPT noexcept
+
+// BOOST_SYSTEM_HAS_CONSTEXPR
+
+#if !defined(BOOST_NO_CXX14_CONSTEXPR)
+# define BOOST_SYSTEM_HAS_CONSTEXPR
+#endif
+
+#if BOOST_WORKAROUND(BOOST_GCC, < 60000)
+# undef BOOST_SYSTEM_HAS_CONSTEXPR
+#endif
+
+#if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+# define BOOST_SYSTEM_CONSTEXPR constexpr
+#else
+# define BOOST_SYSTEM_CONSTEXPR
+#endif
+
+// BOOST_SYSTEM_DEPRECATED
+
+#if defined(__clang__)
+# define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#elif defined(__GNUC__)
+# if __GNUC__ * 100 + __GNUC_MINOR__ >= 405
+#  define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated(msg)))
+# else
+#  define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated))
+# endif
+#elif defined(_MSC_VER)
+#  define BOOST_SYSTEM_DEPRECATED(msg) __declspec(deprecated(msg))
+#elif defined(__sun)
+#  define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#else
+# define BOOST_SYSTEM_DEPRECATED(msg)
+#endif
+
+// BOOST_SYSTEM_CLANG_6
+
+// Android NDK r18b has Clang 7.0.2 that still needs the workaround
+// https://github.com/boostorg/system/issues/100
+#if defined(__clang__) && (__clang_major__ < 7 || (defined(__APPLE__) && __clang_major__ < 11) || (defined(__ANDROID__) && __clang_major__ == 7))
+# define BOOST_SYSTEM_CLANG_6
+#endif
+
+//
+
+#if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 50000
+# define BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY
+#endif
+
+#if defined(__CYGWIN__) || defined(__MINGW32__) || (defined(_MSC_VER) && _MSC_VER == 1800) || (defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 90000)
+
+// Under Cygwin (and MinGW!), std::system_category() is POSIX
+// Under VS2013, std::system_category() isn't quite right
+// Under libstdc++ before 7.4, before 8.3, before 9.1, default_error_condition
+// for the system category returns a condition from the system category
+
+# define BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY
+#endif
+
+#endif // BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED

include/boost/system/detail/enable_if.hpp

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

include/boost/system/detail/errc.hpp

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

include/boost/system/detail/error_category.hpp

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

include/boost/system/detail/error_category_impl.hpp

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

include/boost/system/detail/error_code.hpp

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

include/boost/system/detail/error_condition.hpp

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

include/boost/system/detail/generic_category.hpp

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

include/boost/system/detail/generic_category_message.hpp

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

include/boost/system/detail/interop_category.hpp

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

include/boost/system/detail/is_same.hpp

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

include/boost/system/detail/mutex.hpp

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

include/boost/system/detail/snprintf.hpp

@@ -0,0 +1,28 @@
+#ifndef BOOST_SYSTEM_DETAIL_SNPRINTF_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SNPRINTF_HPP_INCLUDED
+
+// Copyright 2018, 2020, 2021 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <cstdio>
+
+//
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+using std::snprintf;
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_SNPRINTF_HPP_INCLUDED

include/boost/system/detail/std_category.hpp

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

include/boost/system/detail/std_category_impl.hpp

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

include/boost/system/detail/system_category.hpp

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

include/boost/system/detail/system_category_condition_win32.hpp

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

include/boost/system/detail/system_category_impl.hpp

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

include/boost/system/detail/system_category_message.hpp

@@ -0,0 +1,71 @@
+#ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_HPP_INCLUDED
+
+// Implementation of system_error_category_message
+//
+// Copyright 2018, 2022 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/api_config.hpp>
+
+#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API)
+#  error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
+#endif
+
+#if defined(BOOST_WINDOWS_API)
+
+#include <boost/system/detail/system_category_message_win32.hpp>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+inline std::string system_error_category_message( int ev )
+{
+    return system_category_message_win32( ev );
+}
+
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+{
+    return system_category_message_win32( ev, buffer, len );
+}
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#else // #if defined(BOOST_WINDOWS_API)
+
+#include <boost/system/detail/generic_category_message.hpp>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+inline std::string system_error_category_message( int ev )
+{
+    return generic_error_category_message( ev );
+}
+
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
+{
+    return generic_error_category_message( ev, buffer, len );
+}
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #if defined(BOOST_WINDOWS_API)
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_SYSTEM_CATEGORY_MESSAGE_HPP_INCLUDED

include/boost/system/detail/system_category_message_win32.hpp

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

include/boost/system/detail/throws.hpp

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

include/boost/system/errc.hpp

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

include/boost/system/error_category.hpp

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

include/boost/system/error_code.hpp

@@ -0,0 +1,21 @@
+#ifndef BOOST_SYSTEM_ERROR_CODE_HPP_INCLUDED
+#define BOOST_SYSTEM_ERROR_CODE_HPP_INCLUDED
+
+//  Copyright Beman Dawes 2006, 2007
+//  Copyright Christoper Kohlhoff 2007
+//  Copyright Peter Dimov 2017, 2018
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/detail/error_code.hpp>
+#include <boost/system/error_category.hpp>
+#include <boost/system/error_condition.hpp>
+#include <boost/system/errc.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/system/detail/throws.hpp>
+
+#endif // BOOST_SYSTEM_ERROR_CODE_HPP_INCLUDED

include/boost/system/error_condition.hpp

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

include/boost/system/generic_category.hpp

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

include/boost/system/is_error_code_enum.hpp

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

include/boost/system/is_error_condition_enum.hpp

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

include/boost/system/linux_error.hpp

@@ -0,0 +1,110 @@
+//  boost/system/linux_error.hpp  -------------------------------------------//
+
+//  Copyright Beman Dawes 2007
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/system
+
+#ifndef BOOST_SYSTEM_LINUX_ERROR_HPP
+#define BOOST_SYSTEM_LINUX_ERROR_HPP
+
+//  This header is effectively empty for compiles on operating systems where
+//  it is not applicable.
+
+#if defined(linux) || defined(__linux) || defined(__linux__)
+
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+  namespace system
+  {
+    //  To construct an error_code after a API error:
+    //
+    //      error_code( errno, system_category() )
+
+    //  User code should use the portable "posix" enums for POSIX errors; this
+    //  allows such code to be portable to non-POSIX systems. For the non-POSIX
+    //  errno values that POSIX-based systems typically provide in addition to 
+    //  POSIX values, use the system specific enums below.
+
+    namespace linux_error
+    {
+      enum linux_errno
+      {
+        advertise_error = EADV,
+        bad_exchange = EBADE,
+        bad_file_number = EBADFD,
+        bad_font_format = EBFONT,
+        bad_request_code = EBADRQC,
+        bad_request_descriptor = EBADR,
+        bad_slot = EBADSLT,
+        channel_range = ECHRNG,
+        communication_error = ECOMM,
+        dot_dot_error = EDOTDOT,
+        exchange_full = EXFULL,
+        host_down = EHOSTDOWN,
+        is_named_file_type= EISNAM,
+        key_expired = EKEYEXPIRED,
+        key_rejected = EKEYREJECTED,
+        key_revoked = EKEYREVOKED,
+        level2_halt= EL2HLT,
+        level2_no_syncronized= EL2NSYNC,
+        level3_halt = EL3HLT,
+        level3_reset = EL3RST,
+        link_range = ELNRNG,
+        medium_type = EMEDIUMTYPE,
+        no_anode= ENOANO,
+        no_block_device = ENOTBLK,
+        no_csi = ENOCSI,
+        no_key = ENOKEY,
+        no_medium = ENOMEDIUM,
+        no_network = ENONET,
+        no_package = ENOPKG,
+        not_avail = ENAVAIL,
+        not_named_file_type= ENOTNAM,
+        not_recoverable = ENOTRECOVERABLE,
+        not_unique = ENOTUNIQ,
+        owner_dead = EOWNERDEAD,
+        protocol_no_supported = EPFNOSUPPORT,
+        remote_address_changed = EREMCHG,
+        remote_io_error = EREMOTEIO,
+        remote_object = EREMOTE,
+        restart_needed = ERESTART,
+        shared_library_access = ELIBACC,
+        shared_library_bad = ELIBBAD,
+        shared_library_execute = ELIBEXEC,
+        shared_library_max_ = ELIBMAX,
+        shared_library_section= ELIBSCN,
+        shutdown = ESHUTDOWN,
+        socket_type_not_supported = ESOCKTNOSUPPORT,
+        srmount_error = ESRMNT,
+        stream_pipe_error = ESTRPIPE,
+        too_many_references = ETOOMANYREFS,
+        too_many_users = EUSERS,
+        unattached = EUNATCH,
+        unclean = EUCLEAN
+      };
+    }  // namespace linux_error
+
+# ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
+    namespace Linux = linux_error;
+# endif
+
+    template<> struct is_error_code_enum<linux_error::linux_errno>
+      { static const bool value = true; };
+
+    namespace linux_error
+    {
+      inline error_code make_error_code( linux_errno e )
+        { return error_code( e, system_category() ); }
+    }
+
+  }  // namespace system
+}  // namespace boost 
+
+#endif  // Linux
+
+#endif  // BOOST_SYSTEM_LINUX_ERROR_HPP

include/boost/system/system_category.hpp

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

include/boost/system/system_error.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_SYSTEM_SYSTEM_ERROR_HPP
+#define BOOST_SYSTEM_SYSTEM_ERROR_HPP
+
+// Copyright Beman Dawes 2006
+// Copyright Peter Dimov 2021
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+#include <boost/system/detail/error_code.hpp>
+#include <string>
+#include <stdexcept>
+#include <cassert>
+
+namespace boost
+{
+namespace system
+{
+
+class BOOST_SYMBOL_VISIBLE system_error: public std::runtime_error
+{
+private:
+
+    error_code code_;
+
+public:
+
+    explicit system_error( error_code const & ec ):
+        std::runtime_error( ec.what() ), code_( ec ) {}
+
+    system_error( error_code const & ec, std::string const & prefix ):
+        std::runtime_error( prefix + ": " + ec.what() ), code_( ec ) {}
+
+    system_error( error_code const & ec, char const * prefix ):
+        std::runtime_error( std::string( prefix ) + ": " + ec.what() ), code_( ec ) {}
+
+    system_error( int ev, error_category const & ecat ):
+        std::runtime_error( error_code( ev, ecat ).what() ), code_( ev, ecat ) {}
+
+    system_error( int ev, error_category const & ecat, std::string const & prefix ):
+        std::runtime_error( prefix + ": " + error_code( ev, ecat ).what() ), code_( ev, ecat ) {}
+
+    system_error( int ev, error_category const & ecat, char const * prefix ):
+        std::runtime_error( std::string( prefix ) + ": " + error_code( ev, ecat ).what() ), code_( ev, ecat ) {}
+
+    error_code code() const noexcept
+    {
+        return code_;
+    }
+};
+
+} // namespace system
+} // namespace boost
+
+#endif // BOOST_SYSTEM_SYSTEM_ERROR_HPP

include/boost/system/windows_error.hpp

@@ -0,0 +1,119 @@
+//  boost/system/windows_error.hpp  ------------------------------------------//
+
+//  Copyright Beman Dawes 2007
+
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See library home page at http://www.boost.org/libs/system
+
+#ifndef BOOST_SYSTEM_WINDOWS_ERROR_HPP
+#define BOOST_SYSTEM_WINDOWS_ERROR_HPP
+
+//  This header is effectively empty for compiles on operating systems where
+//  it is not applicable.
+
+#include <boost/system/config.hpp>
+
+#ifdef BOOST_WINDOWS_API
+
+#include <boost/system/error_code.hpp>
+#include <boost/winapi/error_codes.hpp>
+
+namespace boost
+{
+  namespace system
+  {
+
+    //  Microsoft Windows  ---------------------------------------------------//
+
+    //  To construct an error_code after a API error:
+    //
+    //      error_code( ::GetLastError(), system_category() )
+
+    namespace windows_error
+    {
+      enum windows_error_code
+      {
+        success = 0,
+        // These names and values are based on Windows winerror.h
+        invalid_function = boost::winapi::ERROR_INVALID_FUNCTION_,
+        file_not_found = boost::winapi::ERROR_FILE_NOT_FOUND_,
+        path_not_found = boost::winapi::ERROR_PATH_NOT_FOUND_,
+        too_many_open_files = boost::winapi::ERROR_TOO_MANY_OPEN_FILES_,
+        access_denied = boost::winapi::ERROR_ACCESS_DENIED_,
+        invalid_handle = boost::winapi::ERROR_INVALID_HANDLE_,
+        arena_trashed = boost::winapi::ERROR_ARENA_TRASHED_,
+        not_enough_memory = boost::winapi::ERROR_NOT_ENOUGH_MEMORY_,
+        invalid_block = boost::winapi::ERROR_INVALID_BLOCK_,
+        bad_environment = boost::winapi::ERROR_BAD_ENVIRONMENT_,
+        bad_format = boost::winapi::ERROR_BAD_FORMAT_,
+        invalid_access = boost::winapi::ERROR_INVALID_ACCESS_,
+        outofmemory = boost::winapi::ERROR_OUTOFMEMORY_,
+        invalid_drive = boost::winapi::ERROR_INVALID_DRIVE_,
+        current_directory = boost::winapi::ERROR_CURRENT_DIRECTORY_,
+        not_same_device = boost::winapi::ERROR_NOT_SAME_DEVICE_,
+        no_more_files = boost::winapi::ERROR_NO_MORE_FILES_,
+        write_protect = boost::winapi::ERROR_WRITE_PROTECT_,
+        bad_unit = boost::winapi::ERROR_BAD_UNIT_,
+        not_ready = boost::winapi::ERROR_NOT_READY_,
+        bad_command = boost::winapi::ERROR_BAD_COMMAND_,
+        crc = boost::winapi::ERROR_CRC_,
+        bad_length = boost::winapi::ERROR_BAD_LENGTH_,
+        seek = boost::winapi::ERROR_SEEK_,
+        not_dos_disk = boost::winapi::ERROR_NOT_DOS_DISK_,
+        sector_not_found = boost::winapi::ERROR_SECTOR_NOT_FOUND_,
+        out_of_paper = boost::winapi::ERROR_OUT_OF_PAPER_,
+        write_fault = boost::winapi::ERROR_WRITE_FAULT_,
+        read_fault = boost::winapi::ERROR_READ_FAULT_,
+        gen_failure = boost::winapi::ERROR_GEN_FAILURE_,
+        sharing_violation = boost::winapi::ERROR_SHARING_VIOLATION_,
+        lock_violation = boost::winapi::ERROR_LOCK_VIOLATION_,
+        wrong_disk = boost::winapi::ERROR_WRONG_DISK_,
+        sharing_buffer_exceeded = boost::winapi::ERROR_SHARING_BUFFER_EXCEEDED_,
+        handle_eof = boost::winapi::ERROR_HANDLE_EOF_,
+        handle_disk_full = boost::winapi::ERROR_HANDLE_DISK_FULL_,
+        not_supported = boost::winapi::ERROR_NOT_SUPPORTED_,
+        rem_not_list = boost::winapi::ERROR_REM_NOT_LIST_,
+        dup_name = boost::winapi::ERROR_DUP_NAME_,
+        bad_net_path = boost::winapi::ERROR_BAD_NETPATH_,
+        network_busy = boost::winapi::ERROR_NETWORK_BUSY_,
+        // ...
+        file_exists = boost::winapi::ERROR_FILE_EXISTS_,
+        cannot_make = boost::winapi::ERROR_CANNOT_MAKE_,
+        // ...
+        broken_pipe = boost::winapi::ERROR_BROKEN_PIPE_,
+        open_failed = boost::winapi::ERROR_OPEN_FAILED_,
+        buffer_overflow = boost::winapi::ERROR_BUFFER_OVERFLOW_,
+        disk_full = boost::winapi::ERROR_DISK_FULL_,
+        // ...
+        lock_failed = boost::winapi::ERROR_LOCK_FAILED_,
+        busy = boost::winapi::ERROR_BUSY_,
+        cancel_violation = boost::winapi::ERROR_CANCEL_VIOLATION_,
+        already_exists = boost::winapi::ERROR_ALREADY_EXISTS_
+        // ...
+
+        // TODO: add more Windows errors
+      };
+
+    }  // namespace windows
+
+# ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
+    namespace windows = windows_error;
+# endif
+
+    template<> struct is_error_code_enum<windows_error::windows_error_code>
+      { static const bool value = true; };
+
+    namespace windows_error
+    {
+      inline error_code make_error_code( windows_error_code e )
+        { return error_code( e, system_category() ); }
+    }
+
+  }  // namespace system
+}  // namespace boost
+
+#endif  // BOOST_WINDOWS_API
+
+#endif  // BOOST_SYSTEM_WINDOWS_ERROR_HPP