Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 2 of 2.

1 files changed, 475 insertions, 475 deletions

diff --git a/contrib/libs/cxxsupp/libcxx/include/system_error b/contrib/libs/cxxsupp/libcxx/include/system_error
index ac8397764a..7e6d3c1cc5 100644
--- a/contrib/libs/cxxsupp/libcxx/include/system_error
+++ b/contrib/libs/cxxsupp/libcxx/include/system_error
@@ -1,455 +1,455 @@
-// -*- C++ -*- 
-//===---------------------------- system_error ----------------------------===// 
-// 
+// -*- C++ -*-
+//===---------------------------- system_error ----------------------------===//
+//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef _LIBCPP_SYSTEM_ERROR 
-#define _LIBCPP_SYSTEM_ERROR 
- 
-/* 
-    system_error synopsis 
- 
-namespace std 
-{ 
- 
-class error_category 
-{ 
-public: 
-    virtual ~error_category() noexcept; 
- 
-    constexpr error_category(); 
-    error_category(const error_category&) = delete; 
-    error_category& operator=(const error_category&) = delete; 
- 
-    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 string message(int ev) const = 0; 
- 
-    bool operator==(const error_category& rhs) const noexcept; 
-    bool operator!=(const error_category& rhs) const noexcept; 
-    bool operator<(const error_category& rhs) const noexcept; 
-}; 
- 
-const error_category& generic_category() noexcept; 
-const error_category& system_category() noexcept; 
- 
-template <class T> struct is_error_code_enum 
-    : public false_type {}; 
- 
-template <class T> struct is_error_condition_enum 
-    : public false_type {}; 
- 
-template <class _Tp> 
-inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17 
- 
-template <class _Tp> 
-inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17 
- 
-class error_code 
-{ 
-public: 
-    // constructors: 
-    error_code() noexcept; 
-    error_code(int val, const error_category& cat) noexcept; 
-    template <class ErrorCodeEnum> 
-        error_code(ErrorCodeEnum e) noexcept; 
- 
-    // modifiers: 
-    void assign(int val, const error_category& cat) noexcept; 
-    template <class ErrorCodeEnum> 
-        error_code& operator=(ErrorCodeEnum e) noexcept; 
-    void clear() noexcept; 
- 
-    // observers: 
-    int value() const noexcept; 
-    const error_category& category() const noexcept; 
-    error_condition default_error_condition() const noexcept; 
-    string message() const; 
-    explicit operator bool() const noexcept; 
-}; 
- 
-// non-member functions: 
-bool operator<(const error_code& lhs, const error_code& rhs) noexcept; 
-template <class charT, class traits> 
-    basic_ostream<charT,traits>& 
-    operator<<(basic_ostream<charT,traits>& os, const error_code& ec); 
- 
-class error_condition 
-{ 
-public: 
-    // constructors: 
-    error_condition() noexcept; 
-    error_condition(int val, const error_category& cat) noexcept; 
-    template <class ErrorConditionEnum> 
-        error_condition(ErrorConditionEnum e) noexcept; 
- 
-    // modifiers: 
-    void assign(int val, const error_category& cat) noexcept; 
-    template <class ErrorConditionEnum> 
-        error_condition& operator=(ErrorConditionEnum e) noexcept; 
-    void clear() noexcept; 
- 
-    // observers: 
-    int value() const noexcept; 
-    const error_category& category() const noexcept; 
-    string message() const noexcept; 
-    explicit operator bool() const noexcept; 
-}; 
- 
-bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept; 
- 
-class system_error 
-    : public runtime_error 
-{ 
-public: 
-    system_error(error_code ec, const string& what_arg); 
-    system_error(error_code ec, const char* what_arg); 
-    system_error(error_code ec); 
-    system_error(int ev, const error_category& ecat, const string& what_arg); 
-    system_error(int ev, const error_category& ecat, const char* what_arg); 
-    system_error(int ev, const error_category& ecat); 
- 
-    const error_code& code() const noexcept; 
-    const char* what() const noexcept; 
-}; 
- 
-template <> struct is_error_condition_enum<errc> 
-    : true_type { } 
- 
-error_code make_error_code(errc e) noexcept; 
-error_condition make_error_condition(errc e) noexcept; 
- 
-// Comparison operators: 
-bool operator==(const error_code& lhs, const error_code& rhs) noexcept; 
-bool operator==(const error_code& lhs, const error_condition& rhs) noexcept; 
-bool operator==(const error_condition& lhs, const error_code& rhs) noexcept; 
-bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept; 
-bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; 
-bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; 
-bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; 
-bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept; 
- 
-template <> struct hash<std::error_code>; 
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SYSTEM_ERROR
+#define _LIBCPP_SYSTEM_ERROR
+
+/*
+    system_error synopsis
+
+namespace std
+{
+
+class error_category
+{
+public:
+    virtual ~error_category() noexcept;
+
+    constexpr error_category();
+    error_category(const error_category&) = delete;
+    error_category& operator=(const error_category&) = delete;
+
+    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 string message(int ev) const = 0;
+
+    bool operator==(const error_category& rhs) const noexcept;
+    bool operator!=(const error_category& rhs) const noexcept;
+    bool operator<(const error_category& rhs) const noexcept;
+};
+
+const error_category& generic_category() noexcept;
+const error_category& system_category() noexcept;
+
+template <class T> struct is_error_code_enum
+    : public false_type {};
+
+template <class T> struct is_error_condition_enum
+    : public false_type {};
+
+template <class _Tp>
+inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17
+
+template <class _Tp>
+inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17
+
+class error_code
+{
+public:
+    // constructors:
+    error_code() noexcept;
+    error_code(int val, const error_category& cat) noexcept;
+    template <class ErrorCodeEnum>
+        error_code(ErrorCodeEnum e) noexcept;
+
+    // modifiers:
+    void assign(int val, const error_category& cat) noexcept;
+    template <class ErrorCodeEnum>
+        error_code& operator=(ErrorCodeEnum e) noexcept;
+    void clear() noexcept;
+
+    // observers:
+    int value() const noexcept;
+    const error_category& category() const noexcept;
+    error_condition default_error_condition() const noexcept;
+    string message() const;
+    explicit operator bool() const noexcept;
+};
+
+// non-member functions:
+bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
+template <class charT, class traits>
+    basic_ostream<charT,traits>&
+    operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
+
+class error_condition
+{
+public:
+    // constructors:
+    error_condition() noexcept;
+    error_condition(int val, const error_category& cat) noexcept;
+    template <class ErrorConditionEnum>
+        error_condition(ErrorConditionEnum e) noexcept;
+
+    // modifiers:
+    void assign(int val, const error_category& cat) noexcept;
+    template <class ErrorConditionEnum>
+        error_condition& operator=(ErrorConditionEnum e) noexcept;
+    void clear() noexcept;
+
+    // observers:
+    int value() const noexcept;
+    const error_category& category() const noexcept;
+    string message() const noexcept;
+    explicit operator bool() const noexcept;
+};
+
+bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
+
+class system_error
+    : public runtime_error
+{
+public:
+    system_error(error_code ec, const string& what_arg);
+    system_error(error_code ec, const char* what_arg);
+    system_error(error_code ec);
+    system_error(int ev, const error_category& ecat, const string& what_arg);
+    system_error(int ev, const error_category& ecat, const char* what_arg);
+    system_error(int ev, const error_category& ecat);
+
+    const error_code& code() const noexcept;
+    const char* what() const noexcept;
+};
+
+template <> struct is_error_condition_enum<errc>
+    : true_type { }
+
+error_code make_error_code(errc e) noexcept;
+error_condition make_error_condition(errc e) noexcept;
+
+// Comparison operators:
+bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
+bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
+bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
+bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
+bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
+bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
+bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
+bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
+
+template <> struct hash<std::error_code>;
 template <> struct hash<std::error_condition>;
- 
-}  // std 
- 
-*/ 
- 
-#include <__config> 
-#include <__errc> 
-#include <__functional/unary_function.h> 
-#include <__functional_base> 
-#include <compare> 
-#include <stdexcept> 
-#include <string> 
-#include <type_traits> 
- 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
-#pragma GCC system_header 
-#endif 
- 
-_LIBCPP_BEGIN_NAMESPACE_STD 
- 
-// is_error_code_enum 
- 
-template <class _Tp> 
-struct _LIBCPP_TEMPLATE_VIS is_error_code_enum 
-    : public false_type {}; 
- 
-#if _LIBCPP_STD_VER > 14 
-template <class _Tp> 
-inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; 
-#endif 
- 
-// is_error_condition_enum 
- 
-template <class _Tp> 
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum 
-    : public false_type {}; 
- 
-#if _LIBCPP_STD_VER > 14 
-template <class _Tp> 
-inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; 
-#endif 
- 
-template <> 
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc> 
-    : true_type { }; 
- 
-#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS 
-template <> 
-struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx> 
-    : true_type { }; 
-#endif 
- 
-class _LIBCPP_TYPE_VIS error_condition; 
-class _LIBCPP_TYPE_VIS error_code; 
- 
-// class error_category 
- 
-class _LIBCPP_HIDDEN __do_message; 
- 
-class _LIBCPP_TYPE_VIS error_category 
-{ 
-public: 
-    virtual ~error_category() _NOEXCEPT; 
- 
-// ODR violation is used for binary compatibility with older versions of libc++. 
-// We don't have old libc++ versions for MSVC, so we don't need it. 
+
+}  // std
+
+*/
+
+#include <__config>
+#include <__errc>
+#include <__functional/unary_function.h>
+#include <__functional_base>
+#include <compare>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// is_error_code_enum
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
+    : public false_type {};
+
+#if _LIBCPP_STD_VER > 14
+template <class _Tp>
+inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value;
+#endif
+
+// is_error_condition_enum
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
+    : public false_type {};
+
+#if _LIBCPP_STD_VER > 14
+template <class _Tp>
+inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
+#endif
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
+    : true_type { };
+
+#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
+template <>
+struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
+    : true_type { };
+#endif
+
+class _LIBCPP_TYPE_VIS error_condition;
+class _LIBCPP_TYPE_VIS error_code;
+
+// class error_category
+
+class _LIBCPP_HIDDEN __do_message;
+
+class _LIBCPP_TYPE_VIS error_category
+{
+public:
+    virtual ~error_category() _NOEXCEPT;
+
+// ODR violation is used for binary compatibility with older versions of libc++.
+// We don't have old libc++ versions for MSVC, so we don't need it.
 #if defined(_LIBCPP_BUILDING_LIBRARY) && \
-    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) 
-    error_category() _NOEXCEPT; 
-#else 
-    _LIBCPP_INLINE_VISIBILITY 
-    _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT 
-#endif 
-private: 
-    error_category(const error_category&);// = delete; 
-    error_category& operator=(const error_category&);// = delete; 
- 
-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 string message(int __ev) const = 0; 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;} 
- 
-    friend class _LIBCPP_HIDDEN __do_message; 
-}; 
- 
-class _LIBCPP_HIDDEN __do_message 
-    : public error_category 
-{ 
-public: 
-    virtual string message(int ev) const; 
-}; 
- 
-_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT; 
-_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT; 
- 
-class _LIBCPP_TYPE_VIS error_condition 
-{ 
-    int __val_; 
-    const error_category* __cat_; 
-public: 
-    _LIBCPP_INLINE_VISIBILITY 
-    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    error_condition(int __val, const error_category& __cat) _NOEXCEPT 
-        : __val_(__val), __cat_(&__cat) {} 
- 
-    template <class _Ep> 
-        _LIBCPP_INLINE_VISIBILITY 
-        error_condition(_Ep __e, 
-              typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr 
-                                                                     ) _NOEXCEPT 
-            {*this = make_error_condition(__e);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    void assign(int __val, const error_category& __cat) _NOEXCEPT 
-    { 
-        __val_ = __val; 
-        __cat_ = &__cat; 
-    } 
- 
-    template <class _Ep> 
-        _LIBCPP_INLINE_VISIBILITY 
-        typename enable_if 
-        < 
-            is_error_condition_enum<_Ep>::value, 
-            error_condition& 
-        >::type 
-        operator=(_Ep __e) _NOEXCEPT 
-            {*this = make_error_condition(__e); return *this;} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    void clear() _NOEXCEPT 
-    { 
-        __val_ = 0; 
-        __cat_ = &generic_category(); 
-    } 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    int value() const _NOEXCEPT {return __val_;} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    const error_category& category() const _NOEXCEPT {return *__cat_;} 
-    string message() const; 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    explicit operator bool() const _NOEXCEPT {return __val_ != 0;} 
-}; 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-error_condition 
-make_error_condition(errc __e) _NOEXCEPT 
-{ 
-    return error_condition(static_cast<int>(__e), generic_category()); 
-} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT 
-{ 
-    return __x.category() < __y.category() 
-        || (__x.category() == __y.category() && __x.value() < __y.value()); 
-} 
- 
-// error_code 
- 
-class _LIBCPP_TYPE_VIS error_code 
-{ 
-    int __val_; 
-    const error_category* __cat_; 
-public: 
-    _LIBCPP_INLINE_VISIBILITY 
-    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    error_code(int __val, const error_category& __cat) _NOEXCEPT 
-        : __val_(__val), __cat_(&__cat) {} 
- 
-    template <class _Ep> 
-        _LIBCPP_INLINE_VISIBILITY 
-        error_code(_Ep __e, 
-                   typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr 
-                                                                     ) _NOEXCEPT 
-            {*this = make_error_code(__e);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    void assign(int __val, const error_category& __cat) _NOEXCEPT 
-    { 
-        __val_ = __val; 
-        __cat_ = &__cat; 
-    } 
- 
-    template <class _Ep> 
-        _LIBCPP_INLINE_VISIBILITY 
-        typename enable_if 
-        < 
-            is_error_code_enum<_Ep>::value, 
-            error_code& 
-        >::type 
-        operator=(_Ep __e) _NOEXCEPT 
-            {*this = make_error_code(__e); return *this;} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    void clear() _NOEXCEPT 
-    { 
-        __val_ = 0; 
-        __cat_ = &system_category(); 
-    } 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    int value() const _NOEXCEPT {return __val_;} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    const error_category& category() const _NOEXCEPT {return *__cat_;} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    error_condition default_error_condition() const _NOEXCEPT 
-        {return __cat_->default_error_condition(__val_);} 
- 
-    string message() const; 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    explicit operator bool() const _NOEXCEPT {return __val_ != 0;} 
-}; 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-error_code 
-make_error_code(errc __e) _NOEXCEPT 
-{ 
-    return error_code(static_cast<int>(__e), generic_category()); 
-} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator<(const error_code& __x, const error_code& __y) _NOEXCEPT 
-{ 
-    return __x.category() < __y.category() 
-        || (__x.category() == __y.category() && __x.value() < __y.value()); 
-} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator==(const error_code& __x, const error_code& __y) _NOEXCEPT 
-{ 
-    return __x.category() == __y.category() && __x.value() == __y.value(); 
-} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT 
-{ 
-    return __x.category().equivalent(__x.value(), __y) 
-        || __y.category().equivalent(__x, __y.value()); 
-} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT 
-{ 
-    return __y == __x; 
-} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT 
-{ 
-    return __x.category() == __y.category() && __x.value() == __y.value(); 
-} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT 
-{return !(__x == __y);} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT 
-{return !(__x == __y);} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT 
-{return !(__x == __y);} 
- 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT 
-{return !(__x == __y);} 
- 
-template <> 
-struct _LIBCPP_TEMPLATE_VIS hash<error_code> 
-    : public unary_function<error_code, size_t> 
-{ 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_t operator()(const error_code& __ec) const _NOEXCEPT 
-    { 
-        return static_cast<size_t>(__ec.value()); 
-    } 
-}; 
- 
+    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
+    error_category() _NOEXCEPT;
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT
+#endif
+private:
+    error_category(const error_category&);// = delete;
+    error_category& operator=(const error_category&);// = delete;
+
+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 string message(int __ev) const = 0;
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
+
+    friend class _LIBCPP_HIDDEN __do_message;
+};
+
+class _LIBCPP_HIDDEN __do_message
+    : public error_category
+{
+public:
+    virtual string message(int ev) const;
+};
+
+_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
+_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
+
+class _LIBCPP_TYPE_VIS error_condition
+{
+    int __val_;
+    const error_category* __cat_;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    error_condition(int __val, const error_category& __cat) _NOEXCEPT
+        : __val_(__val), __cat_(&__cat) {}
+
+    template <class _Ep>
+        _LIBCPP_INLINE_VISIBILITY
+        error_condition(_Ep __e,
+              typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr
+                                                                     ) _NOEXCEPT
+            {*this = make_error_condition(__e);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void assign(int __val, const error_category& __cat) _NOEXCEPT
+    {
+        __val_ = __val;
+        __cat_ = &__cat;
+    }
+
+    template <class _Ep>
+        _LIBCPP_INLINE_VISIBILITY
+        typename enable_if
+        <
+            is_error_condition_enum<_Ep>::value,
+            error_condition&
+        >::type
+        operator=(_Ep __e) _NOEXCEPT
+            {*this = make_error_condition(__e); return *this;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void clear() _NOEXCEPT
+    {
+        __val_ = 0;
+        __cat_ = &generic_category();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int value() const _NOEXCEPT {return __val_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    const error_category& category() const _NOEXCEPT {return *__cat_;}
+    string message() const;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+error_condition
+make_error_condition(errc __e) _NOEXCEPT
+{
+    return error_condition(static_cast<int>(__e), generic_category());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{
+    return __x.category() < __y.category()
+        || (__x.category() == __y.category() && __x.value() < __y.value());
+}
+
+// error_code
+
+class _LIBCPP_TYPE_VIS error_code
+{
+    int __val_;
+    const error_category* __cat_;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    error_code(int __val, const error_category& __cat) _NOEXCEPT
+        : __val_(__val), __cat_(&__cat) {}
+
+    template <class _Ep>
+        _LIBCPP_INLINE_VISIBILITY
+        error_code(_Ep __e,
+                   typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr
+                                                                     ) _NOEXCEPT
+            {*this = make_error_code(__e);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void assign(int __val, const error_category& __cat) _NOEXCEPT
+    {
+        __val_ = __val;
+        __cat_ = &__cat;
+    }
+
+    template <class _Ep>
+        _LIBCPP_INLINE_VISIBILITY
+        typename enable_if
+        <
+            is_error_code_enum<_Ep>::value,
+            error_code&
+        >::type
+        operator=(_Ep __e) _NOEXCEPT
+            {*this = make_error_code(__e); return *this;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void clear() _NOEXCEPT
+    {
+        __val_ = 0;
+        __cat_ = &system_category();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int value() const _NOEXCEPT {return __val_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    const error_category& category() const _NOEXCEPT {return *__cat_;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    error_condition default_error_condition() const _NOEXCEPT
+        {return __cat_->default_error_condition(__val_);}
+
+    string message() const;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+error_code
+make_error_code(errc __e) _NOEXCEPT
+{
+    return error_code(static_cast<int>(__e), generic_category());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
+{
+    return __x.category() < __y.category()
+        || (__x.category() == __y.category() && __x.value() < __y.value());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
+{
+    return __x.category() == __y.category() && __x.value() == __y.value();
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
+{
+    return __x.category().equivalent(__x.value(), __y)
+        || __y.category().equivalent(__x, __y.value());
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
+{
+    return __y == __x;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{
+    return __x.category() == __y.category() && __x.value() == __y.value();
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+{return !(__x == __y);}
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<error_code>
+    : public unary_function<error_code, size_t>
+{
+    _LIBCPP_INLINE_VISIBILITY
+    size_t operator()(const error_code& __ec) const _NOEXCEPT
+    {
+        return static_cast<size_t>(__ec.value());
+    }
+};
+
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<error_condition> 
+struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
     : public unary_function<error_condition, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
@@ -459,32 +459,32 @@ struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
     }
 };
 
-// system_error 
- 
-class _LIBCPP_TYPE_VIS system_error 
-    : public runtime_error 
-{ 
-    error_code __ec_; 
-public: 
-    system_error(error_code __ec, const string& __what_arg); 
-    system_error(error_code __ec, const char* __what_arg); 
-    system_error(error_code __ec); 
-    system_error(int __ev, const error_category& __ecat, const string& __what_arg); 
-    system_error(int __ev, const error_category& __ecat, const char* __what_arg); 
-    system_error(int __ev, const error_category& __ecat); 
-    system_error(const system_error&) _NOEXCEPT = default; 
-    ~system_error() _NOEXCEPT; 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    const error_code& code() const _NOEXCEPT {return __ec_;} 
- 
-private: 
-    static string __init(const error_code&, string); 
-}; 
- 
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS 
-void __throw_system_error(int ev, const char* what_arg); 
- 
-_LIBCPP_END_NAMESPACE_STD 
- 
-#endif // _LIBCPP_SYSTEM_ERROR 
+// system_error
+
+class _LIBCPP_TYPE_VIS system_error
+    : public runtime_error
+{
+    error_code __ec_;
+public:
+    system_error(error_code __ec, const string& __what_arg);
+    system_error(error_code __ec, const char* __what_arg);
+    system_error(error_code __ec);
+    system_error(int __ev, const error_category& __ecat, const string& __what_arg);
+    system_error(int __ev, const error_category& __ecat, const char* __what_arg);
+    system_error(int __ev, const error_category& __ecat);
+    system_error(const system_error&) _NOEXCEPT = default;
+    ~system_error() _NOEXCEPT;
+
+    _LIBCPP_INLINE_VISIBILITY
+    const error_code& code() const _NOEXCEPT {return __ec_;}
+
+private:
+    static string __init(const error_code&, string);
+};
+
+_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
+void __throw_system_error(int ev, const char* what_arg);
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SYSTEM_ERROR