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

Files changed (1) hide show

tmp/tmpm92_nckj/{from.md → to.md} +134 -230

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

@@ -5,14 +5,14 @@
 This Clause describes components that C++ programs may use to detect and
 report error conditions.
 The following subclauses describe components for reporting several kinds
 of exceptional conditions, documenting program assertions, and a global
-variable for error number codes, as summarized in Table
-[[tab:diagnostics.lib.summary]].
-**Table: Diagnostics library summary** <a id="tab:diagnostics.lib.summary">[tab:diagnostics.lib.summary]</a>
 | Subclause          |                      | Header           |
 | ------------------ | -------------------- | ---------------- |
 | [[std.exceptions]] | Exception classes    | `<stdexcept>`    |
 | [[assertions]]     | Assertions           | `<cassert>`      |
@@ -21,12 +21,12 @@ variable for error number codes, as summarized in Table
 ## Exception classes <a id="std.exceptions">[[std.exceptions]]</a>
 The C++ standard library provides classes to be used to report certain
-errors ([[res.on.exception.handling]]) in C++programs. In the error
-model reflected in these classes, errors are divided into two broad
 categories: *logic* errors and *runtime* errors.
 The distinguishing characteristic of logic errors is that they are due
 to errors in the internal logic of the program. In theory, they are
 preventable.
@@ -71,21 +71,17 @@ as violations of logical preconditions or class invariants.
 ``` cpp
 logic_error(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `logic_error`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 logic_error(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `logic_error`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ### Class `domain_error` <a id="domain.error">[[domain.error]]</a>
 ``` cpp
 namespace std {
@@ -102,21 +98,17 @@ exceptions by the implementation to report domain errors.
 ``` cpp
 domain_error(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `domain_error`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 domain_error(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `domain_error`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ### Class `invalid_argument` <a id="invalid.argument">[[invalid.argument]]</a>
 ``` cpp
 namespace std {
@@ -133,21 +125,17 @@ exceptions to report an invalid argument.
 ``` cpp
 invalid_argument(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `invalid_argument`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 invalid_argument(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `invalid_argument`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ### Class `length_error` <a id="length.error">[[length.error]]</a>
 ``` cpp
 namespace std {
@@ -165,21 +153,17 @@ exceeds its maximum allowable size.
 ``` cpp
 length_error(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `length_error`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 length_error(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `length_error`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ### Class `out_of_range` <a id="out.of.range">[[out.of.range]]</a>
 ``` cpp
 namespace std {
@@ -196,21 +180,17 @@ exceptions to report an argument value not in its expected range.
 ``` cpp
 out_of_range(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `out_of_range`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 out_of_range(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `out_of_range`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ### Class `runtime_error` <a id="runtime.error">[[runtime.error]]</a>
 ``` cpp
 namespace std {
@@ -228,21 +208,17 @@ executes.
 ``` cpp
 runtime_error(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `runtime_error`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 runtime_error(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `runtime_error`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ### Class `range_error` <a id="range.error">[[range.error]]</a>
 ``` cpp
 namespace std {
@@ -259,21 +235,17 @@ to report range errors in internal computations.
 ``` cpp
 range_error(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `range_error`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 range_error(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `range_error`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ### Class `overflow_error` <a id="overflow.error">[[overflow.error]]</a>
 ``` cpp
 namespace std {
@@ -290,21 +262,17 @@ exceptions to report an arithmetic overflow error.
 ``` cpp
 overflow_error(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `overflow_error`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 overflow_error(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `overflow_error`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ### Class `underflow_error` <a id="underflow.error">[[underflow.error]]</a>
 ``` cpp
 namespace std {
@@ -321,21 +289,17 @@ exceptions to report an arithmetic underflow error.
 ``` cpp
 underflow_error(const string& what_arg);
 ```
-*Effects:* Constructs an object of class `underflow_error`.
-*Postconditions:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 underflow_error(const char* what_arg);
 ```
-*Effects:* Constructs an object of class `underflow_error`.
-*Postconditions:* `strcmp(what(), what_arg) == 0`.
 ## Assertions <a id="assertions">[[assertions]]</a>
 The header `<cassert>` provides a macro for documenting C++ program
 assertions and a mechanism for disabling the assertion checks.
@@ -347,20 +311,20 @@ assertions and a mechanism for disabling the assertion checks.
 ```
 The contents are the same as the C standard library header `<assert.h>`,
 except that a macro named `static_assert` is not defined.
-ISO C 7.2.
 ### The `assert` macro <a id="assertions.assert">[[assertions.assert]]</a>
-An expression `assert(E)` is a constant subexpression (
-[[defns.const.subexpr]]), if
 - `NDEBUG` is defined at the point where `assert` is last defined or
   redefined, or
-- `E` contextually converted to `bool` (Clause  [[conv]]) is a constant
   subexpression that evaluates to the value `true`.
 ## Error numbers <a id="errno">[[errno]]</a>
 The contents of the header `<cerrno>` are the same as the POSIX header
@@ -457,25 +421,27 @@ A separate `errno` value shall be provided for each thread.
 ```
 The meaning of the macros in this header is defined by the POSIX
 standard.
-ISO C 7.5.
 ## 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;
@@ -581,53 +547,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*]
@@ -645,26 +606,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;
 ```
@@ -692,40 +646,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;
 ```
@@ -790,11 +732,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.
@@ -836,71 +778,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;
 ```
@@ -928,35 +858,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 {
@@ -984,71 +914,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;
 ```
@@ -1070,97 +990,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:
@@ -1174,67 +1090,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;
 ```
@@ -1252,18 +1156,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
@@ -1296,9 +1201,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

 This Clause describes components that C++ programs may use to detect and
 report error conditions.
 The following subclauses describe components for reporting several kinds
 of exceptional conditions, documenting program assertions, and a global
+variable for error number codes, as summarized in
+[[diagnostics.summary]].
+**Table: Diagnostics library summary** <a id="diagnostics.summary">[diagnostics.summary]</a>
 | Subclause          |                      | Header           |
 | ------------------ | -------------------- | ---------------- |
 | [[std.exceptions]] | Exception classes    | `<stdexcept>`    |
 | [[assertions]]     | Assertions           | `<cassert>`      |
 ## Exception classes <a id="std.exceptions">[[std.exceptions]]</a>
 The C++ standard library provides classes to be used to report certain
+errors [[res.on.exception.handling]] in C++ programs. In the error model
+reflected in these classes, errors are divided into two broad
 categories: *logic* errors and *runtime* errors.
 The distinguishing characteristic of logic errors is that they are due
 to errors in the internal logic of the program. In theory, they are
 preventable.
 ``` cpp
 logic_error(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 logic_error(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `domain_error` <a id="domain.error">[[domain.error]]</a>
 ``` cpp
 namespace std {
 ``` cpp
 domain_error(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 domain_error(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `invalid_argument` <a id="invalid.argument">[[invalid.argument]]</a>
 ``` cpp
 namespace std {
 ``` cpp
 invalid_argument(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 invalid_argument(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `length_error` <a id="length.error">[[length.error]]</a>
 ``` cpp
 namespace std {
 ``` cpp
 length_error(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 length_error(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `out_of_range` <a id="out.of.range">[[out.of.range]]</a>
 ``` cpp
 namespace std {
 ``` cpp
 out_of_range(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 out_of_range(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `runtime_error` <a id="runtime.error">[[runtime.error]]</a>
 ``` cpp
 namespace std {
 ``` cpp
 runtime_error(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 runtime_error(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `range_error` <a id="range.error">[[range.error]]</a>
 ``` cpp
 namespace std {
 ``` cpp
 range_error(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 range_error(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `overflow_error` <a id="overflow.error">[[overflow.error]]</a>
 ``` cpp
 namespace std {
 ``` cpp
 overflow_error(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 overflow_error(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `underflow_error` <a id="underflow.error">[[underflow.error]]</a>
 ``` cpp
 namespace std {
 ``` cpp
 underflow_error(const string& what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 underflow_error(const char* what_arg);
 ```
+*Ensures:* `strcmp(what(), what_arg) == 0`.
 ## Assertions <a id="assertions">[[assertions]]</a>
 The header `<cassert>` provides a macro for documenting C++ program
 assertions and a mechanism for disabling the assertion checks.
 ```
 The contents are the same as the C standard library header `<assert.h>`,
 except that a macro named `static_assert` is not defined.
+See also: ISO C 7.2
 ### The `assert` macro <a id="assertions.assert">[[assertions.assert]]</a>
+An expression `assert(E)` is a constant subexpression
+[[defns.const.subexpr]], if
 - `NDEBUG` is defined at the point where `assert` is last defined or
   redefined, or
+- `E` contextually converted to `bool` [[conv]] is a constant
   subexpression that evaluates to the value `true`.
 ## Error numbers <a id="errno">[[errno]]</a>
 The contents of the header `<cerrno>` are the same as the POSIX header
 ```
 The meaning of the macros in this header is defined by the POSIX
 standard.
+See also: ISO C 7.5
 ## 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