[syserr] - C++17 → C++20

Files changed (1) hide show

tmp/tmpwmzlqgtw/{from.md → to.md} +106 -166

tmp/tmpwmzlqgtw/{from.md → to.md} RENAMED Viewed

@@ -1,18 +1,20 @@
 ## System error support <a id="syserr">[[syserr]]</a>
-This subclause describes components that the standard library and
-C++programs may use to report error conditions originating from the
 operating system or other low-level application program interfaces.
 Components described in this subclause shall not change the value of
-`errno` ([[errno]]). Implementations should leave the error states
 provided by other libraries unchanged.
-### Header `<system_error>` synopsis <a id="system_error.syn">[[system_error.syn]]</a>
 ``` cpp
 namespace std {
   class error_category;
   const error_category& generic_category() noexcept;
   const error_category& system_category() noexcept;
@@ -118,53 +120,48 @@ namespace std {
   // [syserr.errcondition.nonmembers], non-member functions
   error_condition make_error_condition(errc e) noexcept;
   // [syserr.compare], comparison functions
-  bool operator<(const error_code& 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;
- 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;
   // [syserr.hash], hash support
   template<class T> struct hash;
   template<> struct hash<error_code>;
   template<> struct hash<error_condition>;
   // [syserr], system error support
-  template <class T> inline constexpr bool is_error_code_enum_v
-    = is_error_code_enum<T>::value;
-  template <class T> inline constexpr bool is_error_condition_enum_v
-    = is_error_condition_enum<T>::value;
 }
 ```
 The value of each `enum errc` constant shall be the same as the value of
 the `<cerrno>` macro shown in the above synopsis. Whether or not the
 `<system_error>` implementation exposes the `<cerrno>` macros is
 unspecified.
 The `is_error_code_enum` and `is_error_condition_enum` may be
-specialized for user-defined types to indicate that such types are
 eligible for `class error_code` and `class error_condition` automatic
 conversions, respectively.
 ### Class `error_category` <a id="syserr.errcat">[[syserr.errcat]]</a>
-#### Class `error_category` overview <a id="syserr.errcat.overview">[[syserr.errcat.overview]]</a>
 The class `error_category` serves as a base class for types used to
 identify the source and encoding of a particular category of error code.
 Classes may be derived from `error_category` to support categories of
-errors in addition to those defined in this International Standard. Such
-classes shall behave as specified in this subclause.
 [*Note 1*: `error_category` objects are passed by reference, and two
 such objects are equal if they have the same address. This means that
 applications using custom `error_category` types should create a single
 object of each such type. — *end note*]
@@ -182,26 +179,19 @@ namespace std {
     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;
 }
 ```
-#### Class `error_category` virtual members <a id="syserr.errcat.virtuals">[[syserr.errcat.virtuals]]</a>
-``` cpp
-virtual ~error_category();
-```
-*Effects:* Destroys an object of class `error_category`.
 ``` cpp
 virtual const char* name() const noexcept = 0;
 ```
@@ -229,40 +219,28 @@ virtual bool equivalent(const error_code& code, int condition) const noexcept;
 virtual string message(int ev) const = 0;
 ```
 *Returns:* A string that describes the error condition denoted by `ev`.
-#### Class `error_category` non-virtual members <a id="syserr.errcat.nonvirtuals">[[syserr.errcat.nonvirtuals]]</a>
-``` cpp
-constexpr error_category() noexcept;
-```
-*Effects:* Constructs an object of class `error_category`.
 ``` cpp
 bool operator==(const error_category& rhs) const noexcept;
 ```
 *Returns:* `this == &rhs`.
 ``` cpp
-bool operator!=(const error_category& rhs) const noexcept;
 ```
-*Returns:* `!(*this == rhs)`.
-``` cpp
-bool operator<(const error_category& rhs) const noexcept;
-```
-*Returns:* `less<const error_category*>()(this, &rhs)`.
-[*Note 1*: `less` ([[comparisons]]) provides a total ordering for
-pointers. — *end note*]
-#### Program defined classes derived from `error_category` <a id="syserr.errcat.derived">[[syserr.errcat.derived]]</a>
 ``` cpp
 virtual const char* name() const noexcept = 0;
 ```
@@ -327,11 +305,11 @@ unbounded, and some may not correspond to any POSIX `errno` value. Thus
 implementations are given latitude in determining
 correspondence. — *end note*]
 ### Class `error_code` <a id="syserr.errcode">[[syserr.errcode]]</a>
-#### Class `error_code` overview <a id="syserr.errcode.overview">[[syserr.errcode.overview]]</a>
 The class `error_code` describes an object used to hold error code
 values, such as those originating from the operating system or other
 low-level application program interfaces.
@@ -373,71 +351,59 @@ namespace std {
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& os, const error_code& ec);
 }
 ```
-#### Class `error_code` constructors <a id="syserr.errcode.constructors">[[syserr.errcode.constructors]]</a>
 ``` cpp
 error_code() noexcept;
 ```
-*Effects:* Constructs an object of type `error_code`.
-*Postconditions:* `val_ == 0` and `cat_ == &system_category()`.
 ``` cpp
 error_code(int val, const error_category& cat) noexcept;
 ```
-*Effects:* Constructs an object of type `error_code`.
-*Postconditions:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code(ErrorCodeEnum e) noexcept;
 ```
-*Effects:* Constructs an object of type `error_code`.
-*Postconditions:* `*this == make_error_code(e)`.
-*Remarks:*
-This constructor shall not participate in overload resolution unless
-`is_error_code_enum_v<ErrorCodeEnum>` is `true`.
-#### Class `error_code` modifiers <a id="syserr.errcode.modifiers">[[syserr.errcode.modifiers]]</a>
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
-*Postconditions:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code& operator=(ErrorCodeEnum e) noexcept;
 ```
-*Postconditions:* `*this == make_error_code(e)`.
 *Returns:* `*this`.
-*Remarks:*
-This operator shall not participate in overload resolution unless
-`is_error_code_enum_v<ErrorCodeEnum>` is `true`.
 ``` cpp
 void clear() noexcept;
 ```
-*Postconditions:* `value() == 0` and `category() == system_category()`.
-#### Class `error_code` observers <a id="syserr.errcode.observers">[[syserr.errcode.observers]]</a>
 ``` cpp
 int value() const noexcept;
 ```
@@ -465,35 +431,35 @@ string message() const;
 explicit operator bool() const noexcept;
 ```
 *Returns:* `value() != 0`.
-#### Class `error_code` non-member functions <a id="syserr.errcode.nonmembers">[[syserr.errcode.nonmembers]]</a>
 ``` cpp
 error_code make_error_code(errc e) noexcept;
 ```
 *Returns:* `error_code(static_cast<int>(e), generic_category())`.
 ``` cpp
 template<class charT, class traits>
-  basic_ostream<charT, traits>&
-    operator<<(basic_ostream<charT, traits>& os, const error_code& ec);
 ```
-*Effects:* As if by: `os << ec.category().name() << ’:’ << ec.value();`
 ### Class `error_condition` <a id="syserr.errcondition">[[syserr.errcondition]]</a>
-#### Class `error_condition` overview <a id="syserr.errcondition.overview">[[syserr.errcondition.overview]]</a>
 The class `error_condition` describes an object used to hold values
 identifying error conditions.
 [*Note 1*: `error_condition` values are portable abstractions, while
-`error_code` values ([[syserr.errcode]]) are implementation
 specific. — *end note*]
 ``` cpp
 namespace std {
   class error_condition {
@@ -521,71 +487,61 @@ namespace std {
     const error_category* cat_; // exposition only
   };
 }
 ```
-#### Class `error_condition` constructors <a id="syserr.errcondition.constructors">[[syserr.errcondition.constructors]]</a>
 ``` cpp
 error_condition() noexcept;
 ```
-*Effects:* Constructs an object of type `error_condition`.
-*Postconditions:* `val_ == 0` and `cat_ == &generic_category()`.
 ``` cpp
 error_condition(int val, const error_category& cat) noexcept;
 ```
-*Effects:* Constructs an object of type `error_condition`.
-*Postconditions:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition(ErrorConditionEnum e) noexcept;
 ```
-*Effects:* Constructs an object of type `error_condition`.
-*Postconditions:* `*this == make_error_condition(e)`.
-*Remarks:*
-This constructor shall not participate in overload resolution unless
-`is_error_condition_enum_v<ErrorConditionEnum>` is `true`.
-#### Class `error_condition` modifiers <a id="syserr.errcondition.modifiers">[[syserr.errcondition.modifiers]]</a>
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
-*Postconditions:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition& operator=(ErrorConditionEnum e) noexcept;
 ```
-*Postconditions:* `*this == make_error_condition(e)`.
 *Returns:* `*this`.
-*Remarks:*
-This operator shall not participate in overload resolution unless
-`is_error_condition_enum_v<ErrorConditionEnum>` is `true`.
 ``` cpp
 void clear() noexcept;
 ```
-*Postconditions:* `value() == 0` and `category() == generic_category()`.
-#### Class `error_condition` observers <a id="syserr.errcondition.observers">[[syserr.errcondition.observers]]</a>
 ``` cpp
 int value() const noexcept;
 ```
@@ -607,97 +563,93 @@ string message() const;
 explicit operator bool() const noexcept;
 ```
 *Returns:* `value() != 0`.
-#### Class `error_condition` non-member functions <a id="syserr.errcondition.nonmembers">[[syserr.errcondition.nonmembers]]</a>
 ``` cpp
 error_condition make_error_condition(errc e) noexcept;
 ```
 *Returns:* `error_condition(static_cast<int>(e), generic_category())`.
 ### Comparison functions <a id="syserr.compare">[[syserr.compare]]</a>
-``` cpp
-bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
-```
-*Returns:*
-``` cpp
-lhs.category() < rhs.category() ||
-(lhs.category() == rhs.category() && lhs.value() < rhs.value());
-```
-``` cpp
-bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
-```
-*Returns:*
-`lhs.category() < rhs.category() || lhs.category() == rhs.category() &&`
-`lhs.value() < rhs.value()`.
 ``` cpp
 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
 ```
 *Returns:*
-`lhs.category() == rhs.category() && lhs.value() == rhs.value()`.
 ``` cpp
 bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
 ```
 *Returns:*
-`lhs.category().equivalent(lhs.value(), rhs) || rhs.category().equivalent(lhs, rhs.value())`.
 ``` cpp
-bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
 ```
-*Returns:*
-`rhs.category().equivalent(rhs.value(), lhs) || lhs.category().equivalent(rhs, lhs.value())`.
 ``` cpp
 bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
 ```
 *Returns:*
-`lhs.category() == rhs.category() && lhs.value() == rhs.value()`.
 ``` cpp
-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;
 ```
-*Returns:* `!(lhs == rhs)`.
 ### System error hash support <a id="syserr.hash">[[syserr.hash]]</a>
 ``` cpp
 template<> struct hash<error_code>;
 template<> struct hash<error_condition>;
 ```
-The specializations are enabled ([[unord.hash]]).
 ### Class `system_error` <a id="syserr.syserr">[[syserr.syserr]]</a>
-#### Class `system_error` overview <a id="syserr.syserr.overview">[[syserr.syserr.overview]]</a>
 The class `system_error` describes an exception object used to report
 error conditions that have an associated error code. Such error
 conditions typically originate from the operating system or other
 low-level application program interfaces.
 [*Note 1*: If an error represents an out-of-memory condition,
 implementations are encouraged to throw an exception object of type
-`bad_alloc` ([[bad.alloc]]) rather than `system_error`. — *end note*]
 ``` cpp
 namespace std {
   class system_error : public runtime_error {
   public:
@@ -711,67 +663,55 @@ namespace std {
     const char* what() const noexcept override;
   };
 }
 ```
-#### Class `system_error` members <a id="syserr.syserr.members">[[syserr.syserr.members]]</a>
 ``` cpp
 system_error(error_code ec, const string& what_arg);
 ```
-*Effects:* Constructs an object of class `system_error`.
-*Postconditions:* `code() == ec`.
-`string(what()).find(what_arg) != string::npos`.
 ``` cpp
 system_error(error_code ec, const char* what_arg);
 ```
-*Effects:* Constructs an object of class `system_error`.
-*Postconditions:* `code() == ec`.
-`string(what()).find(what_arg) != string::npos`.
 ``` cpp
 system_error(error_code ec);
 ```
-*Effects:* Constructs an object of class `system_error`.
-*Postconditions:* `code() == ec`.
 ``` cpp
 system_error(int ev, const error_category& ecat, const string& what_arg);
 ```
-*Effects:* Constructs an object of class `system_error`.
-*Postconditions:* `code() == error_code(ev, ecat)`.
-`string(what()).find(what_arg) != string::npos`.
 ``` cpp
 system_error(int ev, const error_category& ecat, const char* what_arg);
 ```
-*Effects:* Constructs an object of class `system_error`.
-*Postconditions:* `code() == error_code(ev, ecat)`.
-`string(what()).find(what_arg) != string::npos`.
 ``` cpp
 system_error(int ev, const error_category& ecat);
 ```
-*Effects:* Constructs an object of class `system_error`.
-*Postconditions:* `code() == error_code(ev, ecat)`.
 ``` cpp
 const error_code& code() const noexcept;
 ```
@@ -789,18 +729,19 @@ constructor.
 `what_arg + ": " + code.message()`. — *end note*]
 <!-- Link reference definitions -->
 [assertions]: #assertions
 [assertions.assert]: #assertions.assert
-[bad.alloc]: language.md#bad.alloc
 [cassert.syn]: #cassert.syn
 [cerrno.syn]: #cerrno.syn
-[comparisons]: utilities.md#comparisons
-[conv]: conv.md#conv
 [defns.const.subexpr]: library.md#defns.const.subexpr
 [diagnostics]: #diagnostics
 [diagnostics.general]: #diagnostics.general
 [domain.error]: #domain.error
 [errno]: #errno
 [invalid.argument]: #invalid.argument
 [length.error]: #length.error
 [logic.error]: #logic.error
@@ -833,9 +774,8 @@ constructor.
 [syserr.errcondition.overview]: #syserr.errcondition.overview
 [syserr.hash]: #syserr.hash
 [syserr.syserr]: #syserr.syserr
 [syserr.syserr.members]: #syserr.syserr.members
 [syserr.syserr.overview]: #syserr.syserr.overview
-[system_error.syn]: #system_error.syn
-[tab:diagnostics.lib.summary]: #tab:diagnostics.lib.summary
 [underflow.error]: #underflow.error
 [unord.hash]: utilities.md#unord.hash

 ## System error support <a id="syserr">[[syserr]]</a>
+This subclause describes components that the standard library and C++
+programs may use to report error conditions originating from the
 operating system or other low-level application program interfaces.
 Components described in this subclause shall not change the value of
+`errno` [[errno]]. Implementations should leave the error states
 provided by other libraries unchanged.
+### Header `<system_error>` synopsis <a id="system.error.syn">[[system.error.syn]]</a>
 ``` cpp
+#include <compare>              // see [compare.syn]
 namespace std {
   class error_category;
   const error_category& generic_category() noexcept;
   const error_category& system_category() noexcept;
   // [syserr.errcondition.nonmembers], non-member functions
   error_condition make_error_condition(errc e) noexcept;
   // [syserr.compare], comparison functions
   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_condition& rhs) noexcept;
+ strong_ordering operator<=>(const error_code& lhs, const error_code& rhs) noexcept;
+ strong_ordering operator<=>(const error_condition& lhs, const error_condition& rhs) noexcept;
   // [syserr.hash], hash support
   template<class T> struct hash;
   template<> struct hash<error_code>;
   template<> struct hash<error_condition>;
   // [syserr], system error support
+  template<class T>
+ inline constexpr bool is_error_code_enum_v = is_error_code_enum<T>::value;
+  template<class T>
+ inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<T>::value;
 }
 ```
 The value of each `enum errc` constant shall be the same as the value of
 the `<cerrno>` macro shown in the above synopsis. Whether or not the
 `<system_error>` implementation exposes the `<cerrno>` macros is
 unspecified.
 The `is_error_code_enum` and `is_error_condition_enum` may be
+specialized for program-defined types to indicate that such types are
 eligible for `class error_code` and `class error_condition` automatic
 conversions, respectively.
 ### Class `error_category` <a id="syserr.errcat">[[syserr.errcat]]</a>
+#### Overview <a id="syserr.errcat.overview">[[syserr.errcat.overview]]</a>
 The class `error_category` serves as a base class for types used to
 identify the source and encoding of a particular category of error code.
 Classes may be derived from `error_category` to support categories of
+errors in addition to those defined in this document. Such classes shall
+behave as specified in subclause  [[syserr.errcat]].
 [*Note 1*: `error_category` objects are passed by reference, and two
 such objects are equal if they have the same address. This means that
 applications using custom `error_category` types should create a single
 object of each such type. — *end note*]
     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;
+ strong_ordering operator<=>(const error_category& rhs) const noexcept;
   };
   const error_category& generic_category() noexcept;
   const error_category& system_category() noexcept;
 }
 ```
+#### Virtual members <a id="syserr.errcat.virtuals">[[syserr.errcat.virtuals]]</a>
 ``` cpp
 virtual const char* name() const noexcept = 0;
 ```
 virtual string message(int ev) const = 0;
 ```
 *Returns:* A string that describes the error condition denoted by `ev`.
+#### Non-virtual members <a id="syserr.errcat.nonvirtuals">[[syserr.errcat.nonvirtuals]]</a>
 ``` cpp
 bool operator==(const error_category& rhs) const noexcept;
 ```
 *Returns:* `this == &rhs`.
 ``` cpp
+strong_ordering operator<=>(const error_category& rhs) const noexcept;
 ```
+*Returns:* `compare_three_way()(this, &rhs)`.
+[*Note 1*: `compare_three_way` [[comparisons.three.way]] provides a
+total ordering for pointers. — *end note*]
+#### Program-defined classes derived from `error_category` <a id="syserr.errcat.derived">[[syserr.errcat.derived]]</a>
 ``` cpp
 virtual const char* name() const noexcept = 0;
 ```
 implementations are given latitude in determining
 correspondence. — *end note*]
 ### Class `error_code` <a id="syserr.errcode">[[syserr.errcode]]</a>
+#### Overview <a id="syserr.errcode.overview">[[syserr.errcode.overview]]</a>
 The class `error_code` describes an object used to hold error code
 values, such as those originating from the operating system or other
 low-level application program interfaces.
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& os, const error_code& ec);
 }
 ```
+#### Constructors <a id="syserr.errcode.constructors">[[syserr.errcode.constructors]]</a>
 ``` cpp
 error_code() noexcept;
 ```
+*Ensures:* `val_ == 0` and `cat_ == &system_category()`.
 ``` cpp
 error_code(int val, const error_category& cat) noexcept;
 ```
+*Ensures:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code(ErrorCodeEnum e) noexcept;
 ```
+*Constraints:* `is_error_code_enum_v<ErrorCodeEnum>` is `true`.
+*Ensures:* `*this == make_error_code(e)`.
+#### Modifiers <a id="syserr.errcode.modifiers">[[syserr.errcode.modifiers]]</a>
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
+*Ensures:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code& operator=(ErrorCodeEnum e) noexcept;
 ```
+*Constraints:* `is_error_code_enum_v<ErrorCodeEnum>` is `true`.
+*Ensures:* `*this == make_error_code(e)`.
 *Returns:* `*this`.
 ``` cpp
 void clear() noexcept;
 ```
+*Ensures:* `value() == 0` and `category() == system_category()`.
+#### Observers <a id="syserr.errcode.observers">[[syserr.errcode.observers]]</a>
 ``` cpp
 int value() const noexcept;
 ```
 explicit operator bool() const noexcept;
 ```
 *Returns:* `value() != 0`.
+#### Non-member functions <a id="syserr.errcode.nonmembers">[[syserr.errcode.nonmembers]]</a>
 ``` cpp
 error_code make_error_code(errc e) noexcept;
 ```
 *Returns:* `error_code(static_cast<int>(e), generic_category())`.
 ``` cpp
 template<class charT, class traits>
+  basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const error_code& ec);
 ```
+*Effects:* Equivalent to:
+`return os << ec.category().name() << ’:’ << ec.value();`
 ### Class `error_condition` <a id="syserr.errcondition">[[syserr.errcondition]]</a>
+#### Overview <a id="syserr.errcondition.overview">[[syserr.errcondition.overview]]</a>
 The class `error_condition` describes an object used to hold values
 identifying error conditions.
 [*Note 1*: `error_condition` values are portable abstractions, while
+`error_code` values [[syserr.errcode]] are implementation
 specific. — *end note*]
 ``` cpp
 namespace std {
   class error_condition {
     const error_category* cat_; // exposition only
   };
 }
 ```
+#### Constructors <a id="syserr.errcondition.constructors">[[syserr.errcondition.constructors]]</a>
 ``` cpp
 error_condition() noexcept;
 ```
+*Ensures:* `val_ == 0` and `cat_ == &generic_category()`.
 ``` cpp
 error_condition(int val, const error_category& cat) noexcept;
 ```
+*Ensures:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition(ErrorConditionEnum e) noexcept;
 ```
+*Constraints:* `is_error_condition_enum_v<ErrorConditionEnum>` is
+`true`.
+*Ensures:* `*this == make_error_condition(e)`.
+#### Modifiers <a id="syserr.errcondition.modifiers">[[syserr.errcondition.modifiers]]</a>
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
+*Ensures:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition& operator=(ErrorConditionEnum e) noexcept;
 ```
+*Constraints:* `is_error_condition_enum_v<ErrorConditionEnum>` is
+`true`.
+*Ensures:* `*this == make_error_condition(e)`.
 *Returns:* `*this`.
 ``` cpp
 void clear() noexcept;
 ```
+*Ensures:* `value() == 0` and `category() == generic_category()`.
+#### Observers <a id="syserr.errcondition.observers">[[syserr.errcondition.observers]]</a>
 ``` cpp
 int value() const noexcept;
 ```
 explicit operator bool() const noexcept;
 ```
 *Returns:* `value() != 0`.
+#### Non-member functions <a id="syserr.errcondition.nonmembers">[[syserr.errcondition.nonmembers]]</a>
 ``` cpp
 error_condition make_error_condition(errc e) noexcept;
 ```
 *Returns:* `error_condition(static_cast<int>(e), generic_category())`.
 ### Comparison functions <a id="syserr.compare">[[syserr.compare]]</a>
 ``` cpp
 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
 ```
 *Returns:*
+``` cpp
+lhs.category() == rhs.category() && lhs.value() == rhs.value()
+```
 ``` cpp
 bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
 ```
 *Returns:*
 ``` cpp
+lhs.category().equivalent(lhs.value(), rhs) || rhs.category().equivalent(lhs, rhs.value())
 ```
 ``` cpp
 bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
 ```
 *Returns:*
 ``` cpp
+lhs.category() == rhs.category() && lhs.value() == rhs.value()
 ```
+``` cpp
+strong_ordering operator<=>(const error_code& lhs, const error_code& rhs) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+if (auto c = lhs.category() <=> rhs.category(); c != 0) return c;
+return lhs.value() <=> rhs.value();
+```
+``` cpp
+strong_ordering operator<=>(const error_condition& lhs, const error_condition& rhs) noexcept;
+```
+*Returns:*
+``` cpp
+if (auto c = lhs.category() <=> rhs.category(); c != 0) return c;
+return lhs.value() <=> rhs.value();
+```
 ### System error hash support <a id="syserr.hash">[[syserr.hash]]</a>
 ``` cpp
 template<> struct hash<error_code>;
 template<> struct hash<error_condition>;
 ```
+The specializations are enabled [[unord.hash]].
 ### Class `system_error` <a id="syserr.syserr">[[syserr.syserr]]</a>
+#### Overview <a id="syserr.syserr.overview">[[syserr.syserr.overview]]</a>
 The class `system_error` describes an exception object used to report
 error conditions that have an associated error code. Such error
 conditions typically originate from the operating system or other
 low-level application program interfaces.
 [*Note 1*: If an error represents an out-of-memory condition,
 implementations are encouraged to throw an exception object of type
+`bad_alloc` [[bad.alloc]] rather than `system_error`. — *end note*]
 ``` cpp
 namespace std {
   class system_error : public runtime_error {
   public:
     const char* what() const noexcept override;
   };
 }
 ```
+#### Members <a id="syserr.syserr.members">[[syserr.syserr.members]]</a>
 ``` cpp
 system_error(error_code ec, const string& what_arg);
 ```
+*Ensures:* `code() == ec` and
+`string_view(what()).find(what_arg.c_str()) != string_view::npos`.
 ``` cpp
 system_error(error_code ec, const char* what_arg);
 ```
+*Ensures:* `code() == ec` and
+`string_view(what()).find(what_arg) != string_view::npos`.
 ``` cpp
 system_error(error_code ec);
 ```
+*Ensures:* `code() == ec`.
 ``` cpp
 system_error(int ev, const error_category& ecat, const string& what_arg);
 ```
+*Ensures:*
+`code() == error_code(ev, ecat)` and
+`string_view(what()).find(what_arg.c_str()) != string_view::npos`.
 ``` cpp
 system_error(int ev, const error_category& ecat, const char* what_arg);
 ```
+*Ensures:*
+`code() == error_code(ev, ecat)` and
+`string_view(what()).find(what_arg) != string_view::npos`.
 ``` cpp
 system_error(int ev, const error_category& ecat);
 ```
+*Ensures:* `code() == error_code(ev, ecat)`.
 ``` cpp
 const error_code& code() const noexcept;
 ```
 `what_arg + ": " + code.message()`. — *end note*]
 <!-- Link reference definitions -->
 [assertions]: #assertions
 [assertions.assert]: #assertions.assert
+[bad.alloc]: support.md#bad.alloc
 [cassert.syn]: #cassert.syn
 [cerrno.syn]: #cerrno.syn
+[comparisons.three.way]: utilities.md#comparisons.three.way
+[conv]: expr.md#conv
 [defns.const.subexpr]: library.md#defns.const.subexpr
 [diagnostics]: #diagnostics
 [diagnostics.general]: #diagnostics.general
+[diagnostics.summary]: #diagnostics.summary
 [domain.error]: #domain.error
 [errno]: #errno
 [invalid.argument]: #invalid.argument
 [length.error]: #length.error
 [logic.error]: #logic.error
 [syserr.errcondition.overview]: #syserr.errcondition.overview
 [syserr.hash]: #syserr.hash
 [syserr.syserr]: #syserr.syserr
 [syserr.syserr.members]: #syserr.syserr.members
 [syserr.syserr.overview]: #syserr.syserr.overview
+[system.error.syn]: #system.error.syn
 [underflow.error]: #underflow.error
 [unord.hash]: utilities.md#unord.hash

Diff to HTML by rtfpessoa