Update contrib/restricted/boost/system to 1.85.0

25daa0134171d84aaf01d93e2dd746a748160acd

22 files changed, 151 insertions, 411 deletions

diff --git a/contrib/restricted/boost/system/include/boost/system/detail/config.hpp b/contrib/restricted/boost/system/include/boost/system/detail/config.hpp
index 1231291414..c231f0de91 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/config.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/config.hpp
@@ -8,26 +8,19 @@
 //
 // See http://www.boost.org/libs/system for documentation.
 
-#include <boost/system/detail/requires_cxx11.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 
-// BOOST_SYSTEM_HAS_SYSTEM_ERROR
-//
 // 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
 
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC) && ( !defined(BOOST_NO_CXX11_HDR_MUTEX) || defined(BOOST_SYSTEM_DISABLE_THREADS) )
-# define BOOST_SYSTEM_HAS_SYSTEM_ERROR
-#endif
-
 // BOOST_SYSTEM_NOEXCEPT
 // Retained for backward compatibility
 
-#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
+#define BOOST_SYSTEM_NOEXCEPT noexcept
 
 // BOOST_SYSTEM_HAS_CONSTEXPR
 
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/enable_if.hpp b/contrib/restricted/boost/system/include/boost/system/detail/enable_if.hpp
index 7f3d70bae3..5e78c4887c 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/enable_if.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/enable_if.hpp
@@ -5,28 +5,19 @@
 // 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
 {
 
-template<bool C, class T = void> struct enable_if
-{
-    typedef T type;
-};
-
-template<class T> struct enable_if<false, T>
-{
-};
+using std::enable_if;
 
 } // namespace detail
-
 } // namespace system
-
 } // namespace boost
 
 #endif // #ifndef BOOST_SYSTEM_DETAIL_ENABLE_IF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/error_category.hpp b/contrib/restricted/boost/system/include/boost/system/detail/error_category.hpp
index acc349435d..e704221399 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/error_category.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/error_category.hpp
@@ -17,11 +17,8 @@
 #include <string>
 #include <functional>
 #include <cstddef>
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-# include <system_error>
-# include <atomic>
-#endif
+#include <system_error>
+#include <atomic>
 
 namespace boost
 {
@@ -64,20 +61,11 @@ private:
     friend class error_code;
     friend class error_condition;
 
-#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
 public:
 
     error_category( error_category const & ) = delete;
     error_category& operator=( error_category const & ) = delete;
 
-#else
-private:
-
-    error_category( error_category const & );
-    error_category& operator=( error_category const & );
-
-#endif
-
 private:
 
     boost::ulong_long_type id_;
@@ -90,75 +78,47 @@ private:
         void const* stdcat_align_;
     };
 
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
     mutable std::atomic< unsigned > sc_init_;
 
-#else
-
-    unsigned sc_init_;
-
-#endif
-
 protected:
 
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
-
     ~error_category() = default;
 
-#else
-
-    // We'd like to make the destructor protected, to make code that deletes
-    // an error_category* not compile; unfortunately, doing the below makes
-    // the destructor user-provided and hence breaks use after main, as the
-    // categories may get destroyed before code that uses them
-
-    // ~error_category() {}
-
-#endif
-
-#if !BOOST_WORKAROUND(BOOST_GCC, < 40800)
-    BOOST_CONSTEXPR
-#endif
-    error_category() BOOST_NOEXCEPT: id_( 0 ), stdcat_(), sc_init_()
+    constexpr error_category() noexcept: id_( 0 ), stdcat_(), sc_init_()
     {
     }
 
-    explicit
-#if !BOOST_WORKAROUND(BOOST_GCC, < 40800)
-    BOOST_CONSTEXPR
-#endif
-    error_category( boost::ulong_long_type id ) BOOST_NOEXCEPT: id_( id ), stdcat_(), sc_init_()
+    explicit constexpr error_category( boost::ulong_long_type id ) noexcept: id_( id ), stdcat_(), sc_init_()
     {
     }
 
 public:
 
-    virtual const char * name() const BOOST_NOEXCEPT = 0;
+    virtual const char * name() const noexcept = 0;
 
-    virtual error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT;
-    virtual bool equivalent( int code, const error_condition & condition ) const BOOST_NOEXCEPT;
-    virtual bool equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT;
+    virtual 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 BOOST_NOEXCEPT;
+    virtual char const * message( int ev, char * buffer, std::size_t len ) const noexcept;
 
-    virtual bool failed( int ev ) const BOOST_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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    friend BOOST_SYSTEM_CONSTEXPR bool operator<( error_category const & lhs, error_category const & rhs ) noexcept
     {
         if( lhs.id_ < rhs.id_ )
         {
@@ -178,8 +138,6 @@ public:
         return std::less<error_category const *>()( &lhs, &rhs );
     }
 
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
     void init_stdcat() const;
 
 # if defined(__SUNPRO_CC) // trailing __global is not supported
@@ -187,8 +145,6 @@ public:
 # else
     operator std::error_category const & () const BOOST_SYMBOL_VISIBLE;
 # endif
-
-#endif
 };
 
 #if defined(BOOST_MSVC) && BOOST_MSVC < 1900
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/error_category_impl.hpp b/contrib/restricted/boost/system/include/boost/system/detail/error_category_impl.hpp
index 2005397a46..7d69f71dbb 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/error_category_impl.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/error_category_impl.hpp
@@ -26,22 +26,22 @@ namespace system
 
 // error_category default implementation
 
-inline error_condition error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
+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 BOOST_NOEXCEPT
+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 BOOST_NOEXCEPT
+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 BOOST_NOEXCEPT
+inline char const * error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
 {
     if( len == 0 )
     {
@@ -58,27 +58,7 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
     try
 #endif
     {
-        std::string m = this->message( ev );
-
-# if defined( BOOST_MSVC )
-#  pragma warning( push )
-#  pragma warning( disable: 4996 )
-# elif defined(__clang__) && defined(__has_warning)
-#  pragma clang diagnostic push
-#  if __has_warning("-Wdeprecated-declarations")
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#  endif
-# endif
-
-        std::strncpy( buffer, m.c_str(), len - 1 );
-        buffer[ len-1 ] = 0;
-
-# if defined( BOOST_MSVC )
-#  pragma warning( pop )
-# elif defined(__clang__) && defined(__has_warning)
-#  pragma clang diagnostic pop
-# endif
-
+        detail::snprintf( buffer, len, "%s", this->message( ev ).c_str() );
         return buffer;
     }
 #if !defined(BOOST_NO_EXCEPTIONS)
@@ -95,8 +75,6 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
 
 // interoperability with std::error_code, std::error_condition
 
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
 #include <boost/system/detail/std_category_impl.hpp>
 #include <boost/system/detail/mutex.hpp>
 #include <new>
@@ -185,6 +163,4 @@ inline BOOST_NOINLINE error_category::operator std::error_category const & () co
 } // namespace system
 } // namespace boost
 
-#endif // #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
 #endif // #ifndef BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_IMPL_HPP_INCLUDED
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/error_code.hpp b/contrib/restricted/boost/system/include/boost/system/detail/error_code.hpp
index 2b387fb60a..a395c8181d 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/error_code.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/error_code.hpp
@@ -21,11 +21,7 @@
 #include <boost/system/detail/append_int.hpp>
 #include <boost/system/detail/snprintf.hpp>
 #include <boost/system/detail/config.hpp>
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-# include <boost/system/detail/std_category.hpp>
-#endif
-
+#include <boost/system/detail/std_category.hpp>
 #include <boost/assert/source_location.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/config.hpp>
@@ -33,10 +29,7 @@
 #include <ostream>
 #include <new>
 #include <cstdio>
-
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-# include <system_error>
-#endif
+#include <system_error>
 
 #if defined(BOOST_GCC) && BOOST_GCC >= 40600 && BOOST_GCC < 70000
 # pragma GCC diagnostic push
@@ -58,14 +51,14 @@ namespace system
 //  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 ) BOOST_NOEXCEPT;
+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 ) BOOST_NOEXCEPT;
+    friend bool operator==( const error_code & code, const error_condition & condition ) noexcept;
     friend std::size_t hash_value( error_code const & ec );
 
 private:
@@ -79,9 +72,7 @@ private:
     union
     {
         data d1_;
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
         unsigned char d2_[ sizeof(std::error_code) ];
-#endif
     };
 
     // 0: default constructed, d1_ value initialized
@@ -93,7 +84,7 @@ private:
 
 private:
 
-    char const* category_name() const BOOST_NOEXCEPT
+    char const* category_name() const noexcept
     {
         // return category().name();
 
@@ -117,22 +108,19 @@ public:
 
     // constructors:
 
-#if !BOOST_WORKAROUND(BOOST_GCC, < 40800)
-    BOOST_CONSTEXPR
-#endif
-    error_code() BOOST_NOEXCEPT:
+    constexpr error_code() noexcept:
         d1_(), lc_flags_( 0 )
     {
     }
 
-    BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) BOOST_NOEXCEPT:
+    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 ) BOOST_NOEXCEPT:
+    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;
@@ -142,15 +130,13 @@ public:
     template<class ErrorCodeEnum> BOOST_SYSTEM_CONSTEXPR error_code( ErrorCodeEnum e,
         typename detail::enable_if<
             is_error_code_enum<ErrorCodeEnum>::value
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
             || std::is_error_code_enum<ErrorCodeEnum>::value
-#endif
-        >::type* = 0 ) BOOST_NOEXCEPT: d1_(), lc_flags_( 0 )
+        >::type* = 0 ) noexcept: d1_(), lc_flags_( 0 )
     {
         *this = make_error_code( e );
     }
 
-    error_code( error_code const& ec, source_location const * loc ) BOOST_NOEXCEPT:
+    error_code( error_code const& ec, source_location const * loc ) noexcept:
         d1_(), lc_flags_( 0 )
     {
         *this = ec;
@@ -161,9 +147,7 @@ public:
         }
     }
 
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-    error_code( std::error_code const& ec ) BOOST_NOEXCEPT:
+    error_code( std::error_code const& ec ) noexcept:
         d1_(), lc_flags_( 0 )
     {
 #ifndef BOOST_NO_RTTI
@@ -181,41 +165,39 @@ public:
         }
     }
 
-#endif
-
     // modifiers:
 
-    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+        operator=( ErrorCodeEnum val ) noexcept
     {
         *this = make_error_code( val );
         return *this;
     }
 
-    BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR void clear() noexcept
     {
         *this = error_code();
     }
 
     // observers:
 
-    BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR int value() const noexcept
     {
         if( lc_flags_ != 1 )
         {
@@ -223,22 +205,16 @@ public:
         }
         else
         {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
             std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
 
             unsigned cv = static_cast<unsigned>( ec.value() );
             unsigned ch = static_cast<unsigned>( reinterpret_cast<boost::uintptr_t>( &ec.category() ) % 2097143 ); // 2^21-9, prime
 
             return static_cast<int>( cv + 1000 * ch );
-#else
-
-            return -1;
-#endif
         }
     }
 
-    BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR const error_category & category() const noexcept
     {
         if( lc_flags_ == 0 )
         {
@@ -255,24 +231,19 @@ public:
     }
 
     // deprecated?
-    error_condition default_error_condition() const BOOST_NOEXCEPT
+    error_condition default_error_condition() const noexcept
     {
         return category().default_error_condition( value() );
     }
 
     std::string message() const
     {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
         if( lc_flags_ == 1 )
         {
             std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
             return ec.message();
         }
-
-#endif
-
-        if( lc_flags_ == 0 )
+        else if( lc_flags_ == 0 )
         {
             return detail::system_error_category_message( value() );
         }
@@ -282,9 +253,8 @@ public:
         }
     }
 
-    char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
+    char const * message( char * buffer, std::size_t len ) const noexcept
     {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
         if( lc_flags_ == 1 )
         {
             std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
@@ -304,9 +274,7 @@ public:
             }
 #endif
         }
-#endif
-
-        if( lc_flags_ == 0 )
+        else if( lc_flags_ == 0 )
         {
             return detail::system_error_category_message( value(), buffer, len );
         }
@@ -316,17 +284,16 @@ public:
         }
     }
 
-    BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR bool failed() const noexcept
     {
         if( lc_flags_ & 1 )
         {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
             if( lc_flags_ == 1 )
             {
                 std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
                 return ec.value() != 0;
             }
-#endif
+
             return true;
         }
         else
@@ -335,36 +302,17 @@ public:
         }
     }
 
-#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-
-    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT  // true if error
+    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const noexcept  // true if error
     {
         return failed();
     }
 
-#else
-
-    typedef void (*unspecified_bool_type)();
-    static void unspecified_bool_true() {}
-
-    BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const  BOOST_NOEXCEPT // true if error
-    {
-        return failed()? unspecified_bool_true: 0;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error
-    {
-        return !failed();
-    }
-
-#endif
-
-    bool has_location() const BOOST_NOEXCEPT
+    bool has_location() const noexcept
     {
         return lc_flags_ >= 4;
     }
 
-    source_location const & location() const BOOST_NOEXCEPT
+    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;
@@ -378,7 +326,7 @@ private:
 
     friend class error_category;
 
-    BOOST_SYSTEM_CONSTEXPR bool equals( int val, error_category const& cat ) const BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR bool equals( int val, error_category const& cat ) const noexcept
     {
         if( lc_flags_ == 0 )
         {
@@ -399,10 +347,8 @@ 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 ) BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_code & lhs, const error_code & rhs ) noexcept
     {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
         bool s1 = lhs.lc_flags_ == 1;
         bool s2 = rhs.lc_flags_ == 1;
 
@@ -416,16 +362,13 @@ public:
             return e1 == e2;
         }
         else
-#endif
         {
             return lhs.value() == rhs.value() && lhs.category() == rhs.category();
         }
     }
 
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_code & lhs, const error_code & rhs ) BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_code & lhs, const error_code & rhs ) noexcept
     {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
         bool s1 = lhs.lc_flags_ == 1;
         bool s2 = rhs.lc_flags_ == 1;
 
@@ -440,35 +383,32 @@ public:
             return e1 < e2;
         }
         else
-#endif
         {
             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 ) BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept
     {
         return !( lhs == rhs );
     }
 
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-    inline friend bool operator==( std::error_code const & lhs, error_code const & rhs ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    inline friend bool operator!=( error_code const & lhs, std::error_code const & rhs ) noexcept
     {
         return !( lhs == rhs );
     }
@@ -476,25 +416,25 @@ public:
     //
 
     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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    inline friend bool operator!=( E lhs, error_code const & rhs ) noexcept
     {
         return !( lhs == rhs );
     }
@@ -502,47 +442,47 @@ public:
     //
 
     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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    inline friend bool operator!=( std::error_condition const & lhs, error_code const & rhs ) noexcept
     {
         return !( lhs == rhs );
     }
@@ -603,12 +543,8 @@ public:
 
 #endif
 
-#endif
-
     std::string to_string() const
     {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
         if( lc_flags_ == 1 )
         {
             std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( d2_ );
@@ -620,7 +556,6 @@ public:
             return r;
         }
         else
-#endif
         {
             std::string r = category_name();
             detail::append_int( r, value() );
@@ -653,49 +588,41 @@ public:
     }
 };
 
-inline bool operator==( const error_code & code, const error_condition & condition ) BOOST_NOEXCEPT
+inline bool operator==( const error_code & code, const error_condition & condition ) noexcept
 {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
     if( code.lc_flags_ == 1 )
     {
         return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
     }
     else
-
-#endif
     {
         return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
     }
 }
 
-inline bool operator==( const error_condition & condition, const error_code & code ) BOOST_NOEXCEPT
+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 ) BOOST_NOEXCEPT
+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 ) BOOST_NOEXCEPT
+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 defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
     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 );
     }
 
-#endif
-
     error_category const & cat = ec.category();
 
     boost::ulong_long_type id_ = cat.id_;
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/error_condition.hpp b/contrib/restricted/boost/system/include/boost/system/detail/error_condition.hpp
index b2da2811bf..6aeb9506a6 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/error_condition.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/error_condition.hpp
@@ -50,7 +50,7 @@ private:
 
 private:
 
-    boost::ulong_long_type cat_id() const BOOST_NOEXCEPT
+    boost::ulong_long_type cat_id() const noexcept
     {
         return cat_? cat_->id_: detail::generic_category_id;
     }
@@ -59,17 +59,17 @@ public:
 
     // constructors:
 
-    BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_NOEXCEPT:
+    BOOST_SYSTEM_CONSTEXPR error_condition() noexcept:
         val_( 0 ), cat_( 0 )
     {
     }
 
-    BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) BOOST_NOEXCEPT:
+    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 ) BOOST_NOEXCEPT:
+    BOOST_SYSTEM_CONSTEXPR explicit error_condition( boost::system::detail::generic_value_tag vt ) noexcept:
         val_( vt.value ), cat_( 0 )
     {
     }
@@ -77,20 +77,20 @@ public:
     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) BOOST_NOEXCEPT
+      >::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) BOOST_NOEXCEPT:
+      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 ) BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) noexcept
     {
         val_ = val;
         cat_ = &cat;
@@ -98,13 +98,13 @@ public:
 
     template<typename ErrorConditionEnum>
         BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
-        operator=( ErrorConditionEnum val ) BOOST_NOEXCEPT
+        operator=( ErrorConditionEnum val ) noexcept
     {
         *this = error_condition( val );
         return *this;
     }
 
-    BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR void clear() noexcept
     {
         val_ = 0;
         cat_ = 0;
@@ -112,12 +112,12 @@ public:
 
     // observers:
 
-    BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR int value() const noexcept
     {
         return val_;
     }
 
-    BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR const error_category & category() const noexcept
     {
         return cat_? *cat_: generic_category();
     }
@@ -134,7 +134,7 @@ public:
         }
     }
 
-    char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
+    char const * message( char * buffer, std::size_t len ) const noexcept
     {
         if( cat_ )
         {
@@ -146,7 +146,7 @@ public:
         }
     }
 
-    BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR bool failed() const noexcept
     {
         if( cat_ )
         {
@@ -158,35 +158,16 @@ public:
         }
     }
 
-#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-
-    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT  // true if error
+    BOOST_SYSTEM_CONSTEXPR explicit operator bool() const noexcept  // true if error
     {
         return failed();
     }
 
-#else
-
-    typedef void (*unspecified_bool_type)();
-    static void unspecified_bool_true() {}
-
-    BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const BOOST_NOEXCEPT  // true if error
-    {
-        return failed()? unspecified_bool_true: 0;
-    }
-
-    BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT  // true if no error
-    {
-        return !failed();
-    }
-
-#endif
-
     // relationals:
     //  the more symmetrical non-member syntax allows enum
     //  conversions work for both rhs and lhs.
 
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept
     {
         if( lhs.val_ != rhs.val_ )
         {
@@ -206,20 +187,18 @@ public:
         }
     }
 
-    BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept
     {
         return !( lhs == rhs );
     }
 
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
     operator std::error_condition () const
     {
 // This condition must be the same as the one in error_category_impl.hpp
@@ -241,22 +220,22 @@ public:
 #endif
     }
 
-    inline friend bool operator==( std::error_code const & lhs, error_condition const & rhs ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    inline friend bool operator!=( error_condition const & lhs, std::error_code const & rhs ) noexcept
     {
         return !( lhs == rhs );
     }
@@ -264,25 +243,25 @@ public:
     //
 
     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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( E lhs, error_condition const & rhs ) noexcept
     {
         return !( lhs == rhs );
     }
@@ -290,31 +269,29 @@ public:
     //
 
     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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    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 ) BOOST_NOEXCEPT
+    inline friend bool operator!=( E lhs, error_condition const & rhs ) noexcept
     {
         return !( lhs == rhs );
     }
 
-#endif
-
     std::string to_string() const
     {
         std::string r( "cond:" );
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/generic_category.hpp b/contrib/restricted/boost/system/include/boost/system/detail/generic_category.hpp
index 0a41b67773..6a1a058169 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/generic_category.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/generic_category.hpp
@@ -35,18 +35,18 @@ class BOOST_SYMBOL_VISIBLE generic_error_category: public error_category
 {
 public:
 
-    BOOST_SYSTEM_CONSTEXPR generic_error_category() BOOST_NOEXCEPT:
+    BOOST_SYSTEM_CONSTEXPR generic_error_category() noexcept:
         error_category( detail::generic_category_id )
     {
     }
 
-    const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE
+    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 BOOST_NOEXCEPT 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 )
@@ -55,7 +55,7 @@ public:
 
 // generic_error_category::message
 
-inline char const * generic_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
+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 );
 }
@@ -86,7 +86,7 @@ template<class T> constexpr generic_error_category generic_cat_holder<T>::instan
 
 } // namespace detail
 
-constexpr error_category const & generic_category() BOOST_NOEXCEPT
+constexpr error_category const & generic_category() noexcept
 {
     return detail::generic_cat_holder<void>::instance;
 }
@@ -94,10 +94,10 @@ constexpr error_category const & generic_category() BOOST_NOEXCEPT
 #else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
 
 #if !defined(__SUNPRO_CC) // trailing __global is not supported
-inline error_category const & generic_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
+inline error_category const & generic_category() noexcept BOOST_SYMBOL_VISIBLE;
 #endif
 
-inline error_category const & generic_category() BOOST_NOEXCEPT
+inline error_category const & generic_category() noexcept
 {
     static const detail::generic_error_category instance;
     return instance;
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/generic_category_message.hpp b/contrib/restricted/boost/system/include/boost/system/detail/generic_category_message.hpp
index fbdb41a3c3..ded2db6331 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/generic_category_message.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/generic_category_message.hpp
@@ -27,17 +27,17 @@ namespace detail
 
 // glibc has two incompatible strerror_r definitions
 
-inline char const * strerror_r_helper( char const * r, char const * ) BOOST_NOEXCEPT
+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 ) BOOST_NOEXCEPT
+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 ) BOOST_NOEXCEPT
+inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
 {
     return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
 }
@@ -68,7 +68,7 @@ inline std::string generic_error_category_message( int ev )
     return m? m: "Unknown error";
 }
 
-inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
+inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
 {
     if( len == 0 )
     {
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/interop_category.hpp b/contrib/restricted/boost/system/include/boost/system/detail/interop_category.hpp
index 9755ad5a59..418c69183d 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/interop_category.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/interop_category.hpp
@@ -35,25 +35,25 @@ class BOOST_SYMBOL_VISIBLE interop_error_category: public error_category
 {
 public:
 
-    BOOST_SYSTEM_CONSTEXPR interop_error_category() BOOST_NOEXCEPT:
+    BOOST_SYSTEM_CONSTEXPR interop_error_category() noexcept:
         error_category( detail::interop_category_id )
     {
     }
 
-    const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE
+    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 BOOST_NOEXCEPT 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 BOOST_NOEXCEPT
+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;
@@ -79,7 +79,7 @@ template<class T> struct BOOST_SYMBOL_VISIBLE interop_cat_holder
 template<class T> constexpr interop_error_category interop_cat_holder<T>::instance;
 #endif
 
-constexpr error_category const & interop_category() BOOST_NOEXCEPT
+constexpr error_category const & interop_category() noexcept
 {
     return interop_cat_holder<void>::instance;
 }
@@ -87,10 +87,10 @@ constexpr error_category const & interop_category() BOOST_NOEXCEPT
 #else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
 
 #if !defined(__SUNPRO_CC) // trailing __global is not supported
-inline error_category const & interop_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
+inline error_category const & interop_category() noexcept BOOST_SYMBOL_VISIBLE;
 #endif
 
-inline error_category const & interop_category() BOOST_NOEXCEPT
+inline error_category const & interop_category() noexcept
 {
     static const detail::interop_error_category instance;
     return instance;
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/is_same.hpp b/contrib/restricted/boost/system/include/boost/system/detail/is_same.hpp
index dc466f8ee3..12c1e585a4 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/is_same.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/is_same.hpp
@@ -5,29 +5,19 @@
 // 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
 {
 
-template<class T1, class T2> struct is_same
-{
-    enum _vt { value = 0 };
-};
-
-template<class T> struct is_same<T, T>
-{
-    enum _vt { value = 1 };
-};
+using std::is_same;
 
 } // namespace detail
-
 } // namespace system
-
 } // namespace boost
 
 #endif // #ifndef BOOST_SYSTEM_DETAIL_IS_SAME_HPP_INCLUDED
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/requires_cxx11.hpp b/contrib/restricted/boost/system/include/boost/system/detail/requires_cxx11.hpp
deleted file mode 100644
index 016791c086..0000000000
--- a/contrib/restricted/boost/system/include/boost/system/detail/requires_cxx11.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef BOOST_SYSTEM_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
-#define BOOST_SYSTEM_DETAIL_REQUIRES_CXX11_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>
-#include <boost/config/pragma_message.hpp>
-
-#if defined(BOOST_NO_CXX11_CONSTEXPR) || \
-    defined(BOOST_NO_CXX11_NOEXCEPT) || \
-    defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) || \
-    defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || \
-    defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-
-BOOST_PRAGMA_MESSAGE("C++03 support was deprecated in Boost.System 1.82 and will be removed in Boost.System 1.85.")
-
-#endif
-
-#endif // #ifndef BOOST_SYSTEM_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/snprintf.hpp b/contrib/restricted/boost/system/include/boost/system/detail/snprintf.hpp
index f54a3514ff..b999dd9c99 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/snprintf.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/snprintf.hpp
@@ -8,66 +8,21 @@
 //
 // See library home page at http://www.boost.org/libs/system
 
-#include <boost/config.hpp>
 #include <cstdio>
-#include <cstdarg>
 
 //
 
 namespace boost
 {
-
 namespace system
 {
-
 namespace detail
 {
 
-#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) )
-
-inline void snprintf( char * buffer, std::size_t len, char const * format, ... )
-{
-# if defined( BOOST_MSVC )
-#  pragma warning( push )
-#  pragma warning( disable: 4996 )
-# endif
-
-    if( len == 0 ) return;
-
-    va_list args;
-    va_start( args, format );
-
-    _vsnprintf( buffer, len - 1, format, args );
-    buffer[ len - 1 ] = 0;
-
-    va_end( args );
-
-# if defined( BOOST_MSVC )
-#  pragma warning( pop )
-# endif
-}
-
-#else
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-__attribute__((__format__ (__printf__, 3, 4)))
-#endif
-inline void snprintf( char * buffer, std::size_t len, char const * format, ... )
-{
-    va_list args;
-    va_start( args, format );
-
-    std::vsnprintf( buffer, len, format, args );
-
-    va_end( args );
-}
-
-#endif
+using std::snprintf;
 
 } // namespace detail
-
 } // namespace system
-
 } // namespace boost
 
 #endif // #ifndef BOOST_SYSTEM_DETAIL_SNPRINTF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/std_category.hpp b/contrib/restricted/boost/system/include/boost/system/detail/std_category.hpp
index 68073c1b92..6aabc28149 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/std_category.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/std_category.hpp
@@ -35,7 +35,7 @@ private:
 
 public:
 
-    boost::system::error_category const & original_category() const BOOST_NOEXCEPT
+    boost::system::error_category const & original_category() const noexcept
     {
         return *pc_;
     }
@@ -51,16 +51,12 @@ public:
         // here when Id != 0, but this should never happen now because this code
         // path is no longer used
 
-#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
-
         static_assert( Id == 0, "This constructor should only be called with Id == 0 under MS STL 14.0+" );
 
 #endif
-
-#endif
     }
 
-    const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE
+    const char * name() const noexcept BOOST_OVERRIDE
     {
         return pc_->name();
     }
@@ -70,13 +66,13 @@ public:
         return pc_->message( ev );
     }
 
-    std::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT BOOST_OVERRIDE
+    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 BOOST_NOEXCEPT BOOST_OVERRIDE;
-    inline bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
+    inline bool equivalent( int code, const std::error_condition & condition ) const noexcept BOOST_OVERRIDE;
+    inline bool equivalent( const std::error_code & code, int condition ) const noexcept BOOST_OVERRIDE;
 };
 
 } // namespace detail
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/std_category_impl.hpp b/contrib/restricted/boost/system/include/boost/system/detail/std_category_impl.hpp
index 9dee5e7980..3843bd343c 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/std_category_impl.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/std_category_impl.hpp
@@ -26,7 +26,7 @@ namespace system
 namespace detail
 {
 
-inline bool std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT
+inline bool std_category::equivalent( int code, const std::error_condition & condition ) const noexcept
 {
     if( condition.category() == *this )
     {
@@ -55,7 +55,7 @@ inline bool std_category::equivalent( int code, const std::error_condition & con
     }
 }
 
-inline bool std_category::equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT
+inline bool std_category::equivalent( const std::error_code & code, int condition ) const noexcept
 {
     if( code.category() == *this )
     {
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/system_category.hpp b/contrib/restricted/boost/system/include/boost/system/detail/system_category.hpp
index ae8c9530e0..260894d4f3 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/system_category.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/system_category.hpp
@@ -34,20 +34,20 @@ class BOOST_SYMBOL_VISIBLE system_error_category: public error_category
 {
 public:
 
-    BOOST_SYSTEM_CONSTEXPR system_error_category() BOOST_NOEXCEPT:
+    BOOST_SYSTEM_CONSTEXPR system_error_category() noexcept:
         error_category( detail::system_category_id )
     {
     }
 
-    const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE
+    const char * name() const noexcept BOOST_OVERRIDE
     {
         return "system";
     }
 
-    error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT BOOST_OVERRIDE;
+    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 BOOST_NOEXCEPT 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 )
@@ -75,7 +75,7 @@ template<class T> constexpr system_error_category system_cat_holder<T>::instance
 
 } // namespace detail
 
-constexpr error_category const & system_category() BOOST_NOEXCEPT
+constexpr error_category const & system_category() noexcept
 {
     return detail::system_cat_holder<void>::instance;
 }
@@ -83,10 +83,10 @@ constexpr error_category const & system_category() BOOST_NOEXCEPT
 #else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
 
 #if !defined(__SUNPRO_CC) // trailing __global is not supported
-inline error_category const & system_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
+inline error_category const & system_category() noexcept BOOST_SYMBOL_VISIBLE;
 #endif
 
-inline error_category const & system_category() BOOST_NOEXCEPT
+inline error_category const & system_category() noexcept
 {
     static const detail::system_error_category instance;
     return instance;
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/system_category_condition_win32.hpp b/contrib/restricted/boost/system/include/boost/system/detail/system_category_condition_win32.hpp
index 446a351942..a43d676662 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/system_category_condition_win32.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/system_category_condition_win32.hpp
@@ -25,7 +25,7 @@ namespace system
 namespace detail
 {
 
-inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
+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,
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/system_category_impl.hpp b/contrib/restricted/boost/system/include/boost/system/detail/system_category_impl.hpp
index fc3933e2fd..5da83f0b20 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/system_category_impl.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/system_category_impl.hpp
@@ -25,7 +25,7 @@
 
 #include <boost/system/detail/system_category_condition_win32.hpp>
 
-inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
+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 );
 
@@ -41,7 +41,7 @@ inline boost::system::error_condition boost::system::detail::system_error_catego
 
 #else // #if defined(BOOST_WINDOWS_API)
 
-inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const BOOST_NOEXCEPT
+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 ) );
 }
@@ -53,7 +53,7 @@ inline std::string boost::system::detail::system_error_category::message( int ev
     return system_error_category_message( ev );
 }
 
-inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
+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 );
 }
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/system_category_message.hpp b/contrib/restricted/boost/system/include/boost/system/detail/system_category_message.hpp
index 203e75aa9e..cd1437b004 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/system_category_message.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/system_category_message.hpp
@@ -32,7 +32,7 @@ inline std::string system_error_category_message( int ev )
     return system_category_message_win32( ev );
 }
 
-inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
 {
     return system_category_message_win32( ev, buffer, len );
 }
@@ -57,7 +57,7 @@ inline std::string system_error_category_message( int ev )
     return generic_error_category_message( ev );
 }
 
-inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
+inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
 {
     return generic_error_category_message( ev, buffer, len );
 }
diff --git a/contrib/restricted/boost/system/include/boost/system/detail/system_category_message_win32.hpp b/contrib/restricted/boost/system/include/boost/system/detail/system_category_message_win32.hpp
index e5f544ccd9..73ff8947bc 100644
--- a/contrib/restricted/boost/system/include/boost/system/detail/system_category_message_win32.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/detail/system_category_message_win32.hpp
@@ -47,7 +47,7 @@ inline boost::winapi::UINT_ message_cp_win32()
 #endif
 }
 
-inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
+inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) noexcept
 {
     if( len == 0 )
     {
diff --git a/contrib/restricted/boost/system/include/boost/system/errc.hpp b/contrib/restricted/boost/system/include/boost/system/errc.hpp
index 2b642cd764..3e7cfc8d4b 100644
--- a/contrib/restricted/boost/system/include/boost/system/errc.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/errc.hpp
@@ -31,19 +31,19 @@ namespace errc
 {
 
 // explicit conversion:
-BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) BOOST_NOEXCEPT
+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 ) BOOST_NOEXCEPT
+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 ) BOOST_NOEXCEPT
+BOOST_SYSTEM_CONSTEXPR inline error_condition make_error_condition( errc_t e ) noexcept
 {
     return error_condition( e, generic_category() );
 }
diff --git a/contrib/restricted/boost/system/include/boost/system/system_error.hpp b/contrib/restricted/boost/system/include/boost/system/system_error.hpp
index 09d65e2ac6..7d6d8b60b7 100644
--- a/contrib/restricted/boost/system/include/boost/system/system_error.hpp
+++ b/contrib/restricted/boost/system/include/boost/system/system_error.hpp
@@ -43,7 +43,7 @@ public:
     system_error( int ev, error_category const & ecat, char const * prefix ):
         std::runtime_error( std::string( prefix ) + ": " + error_code( ev, ecat ).what() ), code_( ev, ecat ) {}
 
-    error_code code() const BOOST_NOEXCEPT
+    error_code code() const noexcept
     {
         return code_;
     }
diff --git a/contrib/restricted/boost/system/ya.make b/contrib/restricted/boost/system/ya.make
index 483476895f..9582ac8e7d 100644
--- a/contrib/restricted/boost/system/ya.make
+++ b/contrib/restricted/boost/system/ya.make
@@ -6,9 +6,9 @@ LICENSE(BSL-1.0)
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-VERSION(1.84.0)
+VERSION(1.85.0)
 
-ORIGINAL_SOURCE(https://github.com/boostorg/system/archive/boost-1.84.0.tar.gz)
+ORIGINAL_SOURCE(https://github.com/boostorg/system/archive/boost-1.85.0.tar.gz)
 
 PEERDIR(
     contrib/restricted/boost/assert