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

Files changed (1) hide show

tmp/tmp2dbgg5wc/{from.md → to.md} +247 -104

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

@@ -20,11 +20,11 @@ variable for error number codes, as summarized in Table
 | [[syserr]]         | System error support | `<system_error>` |
 ## Exception classes <a id="std.exceptions">[[std.exceptions]]</a>
-The Standard C++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
@@ -35,10 +35,12 @@ By contrast, runtime errors are due to events beyond the scope of the
 program. They cannot be easily predicted in advance. The header
 `<stdexcept>` defines several types of predefined exceptions for
 reporting errors in a C++program. These exceptions are related by
 inheritance.
 ``` cpp
 namespace std {
   class logic_error;
     class domain_error;
     class invalid_argument;
@@ -71,19 +73,19 @@ as violations of logical preconditions or class invariants.
 logic_error(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `logic_error`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 logic_error(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `logic_error`.
-`strcmp(what(), what_arg) == 0`.
 ### Class `domain_error` <a id="domain.error">[[domain.error]]</a>
 ``` cpp
 namespace std {
@@ -102,19 +104,19 @@ exceptions by the implementation to report domain errors.
 domain_error(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `domain_error`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 domain_error(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `domain_error`.
-`strcmp(what(), what_arg) == 0`.
 ### Class `invalid_argument` <a id="invalid.argument">[[invalid.argument]]</a>
 ``` cpp
 namespace std {
@@ -133,19 +135,19 @@ exceptions to report an invalid argument.
 invalid_argument(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `invalid_argument`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 invalid_argument(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `invalid_argument`.
-`strcmp(what(), what_arg) == 0`.
 ### Class `length_error` <a id="length.error">[[length.error]]</a>
 ``` cpp
 namespace std {
@@ -165,19 +167,19 @@ exceeds its maximum allowable size.
 length_error(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `length_error`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 length_error(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `length_error`.
-`strcmp(what(), what_arg) == 0`.
 ### Class `out_of_range` <a id="out.of.range">[[out.of.range]]</a>
 ``` cpp
 namespace std {
@@ -196,19 +198,19 @@ exceptions to report an argument value not in its expected range.
 out_of_range(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `out_of_range`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 out_of_range(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `out_of_range`.
-`strcmp(what(), what_arg) == 0`.
 ### Class `runtime_error` <a id="runtime.error">[[runtime.error]]</a>
 ``` cpp
 namespace std {
@@ -228,19 +230,19 @@ executes.
 runtime_error(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `runtime_error`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 runtime_error(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `runtime_error`.
-`strcmp(what(), what_arg) == 0`.
 ### Class `range_error` <a id="range.error">[[range.error]]</a>
 ``` cpp
 namespace std {
@@ -259,19 +261,19 @@ to report range errors in internal computations.
 range_error(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `range_error`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 range_error(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `range_error`.
-`strcmp(what(), what_arg) == 0`.
 ### Class `overflow_error` <a id="overflow.error">[[overflow.error]]</a>
 ``` cpp
 namespace std {
@@ -290,19 +292,19 @@ exceptions to report an arithmetic overflow error.
 overflow_error(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `overflow_error`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 overflow_error(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `overflow_error`.
-`strcmp(what(), what_arg) == 0`.
 ### Class `underflow_error` <a id="underflow.error">[[underflow.error]]</a>
 ``` cpp
 namespace std {
@@ -321,38 +323,145 @@ exceptions to report an arithmetic underflow error.
 underflow_error(const string& what_arg);
 ```
 *Effects:* Constructs an object of class `underflow_error`.
-`strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
 underflow_error(const char* what_arg);
 ```
 *Effects:* Constructs an object of class `underflow_error`.
-`strcmp(what(), what_arg) == 0`.
 ## Assertions <a id="assertions">[[assertions]]</a>
-The header `<cassert>`, described in (Table
-[[tab:diagnostics.hdr.cassert]]), provides a macro for documenting
-C++program assertions and a mechanism for disabling the assertion
-checks.
-The contents are the same as the Standard C library header `<assert.h>`.
-ISO C 7.2.
 ## Error numbers <a id="errno">[[errno]]</a>
-The header `<cerrno>` is described in Table
-[[tab:diagnostics.hdr.cerrno]]. Its contents are the same as the POSIX
-header `<errno.h>`, except that `errno` shall be defined as a macro. The
-intent is to remain in close alignment with the POSIX standard. A
-separate `errno` value shall be provided for each thread.
 ## 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
@@ -360,10 +469,12 @@ 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.
 ``` cpp
 namespace std {
   class error_category;
   const error_category& generic_category() noexcept;
   const error_category& system_category() noexcept;
@@ -457,29 +568,45 @@ namespace std {
     too_many_symbolic_link_levels,      // ELOOP
     value_too_large,                    // EOVERFLOW
     wrong_protocol_type,                // EPROTOTYPE
   };
-  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;
-  // [syserr.compare] 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;
-  // [syserr.hash] Hash support
   template <class T> struct hash;
   template <> struct hash<error_code>;
-} // namespace std
 ```
 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
@@ -496,14 +623,16 @@ conversions, respectively.
 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. `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.
 ``` cpp
 namespace std {
   class error_category {
   public:
@@ -522,12 +651,11 @@ namespace std {
     bool operator<(const error_category& rhs) const noexcept;
   };
   const error_category& generic_category() noexcept;
   const error_category& system_category() noexcept;
-}   // namespace std
 ```
 #### Class `error_category` virtual members <a id="syserr.errcat.virtuals">[[syserr.errcat.virtuals]]</a>
 ``` cpp
@@ -590,11 +718,12 @@ bool operator!=(const error_category& rhs) const noexcept;
 bool operator<(const error_category& rhs) const noexcept;
 ```
 *Returns:* `less<const error_category*>()(this, &rhs)`.
-`less` ([[comparisons]]) provides a total ordering for pointers.
 #### Program defined classes derived from `error_category` <a id="syserr.errcat.derived">[[syserr.errcat.derived]]</a>
 ``` cpp
 virtual const char* name() const noexcept = 0;
@@ -652,41 +781,45 @@ function shall return a pointer to the string `"system"`. The object’s
 If the argument `ev` corresponds to a POSIX `errno` value `posv`, the
 function shall return `error_condition(posv, generic_category())`.
 Otherwise, the function shall return
 `error_condition(ev, system_category())`. What constitutes
-correspondence for any given operating system is unspecified. The number
-of potential system error codes is large and unbounded, and some may not
-correspond to any POSIX `errno` value. Thus implementations are given
-latitude in determining correspondence.
 ### 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. Class `error_code` is an
-adjunct to error reporting by exception.
 ``` cpp
 namespace std {
   class error_code {
   public:
-    // [syserr.errcode.constructors] constructors:
     error_code() noexcept;
     error_code(int val, const error_category& cat) noexcept;
     template <class ErrorCodeEnum>
       error_code(ErrorCodeEnum e) noexcept;
-    // [syserr.errcode.modifiers] modifiers:
     void assign(int val, const error_category& cat) noexcept;
     template <class ErrorCodeEnum>
       error_code& operator=(ErrorCodeEnum e) noexcept;
     void clear() noexcept;
-    // [syserr.errcode.observers] 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;
@@ -694,18 +827,17 @@ namespace std {
   private:
     int val_;                   // exposition only
     const error_category* cat_; // exposition only
   };
-  // [syserr.errcode.nonmembers] non-member functions:
   error_code make_error_code(errc e) noexcept;
-  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);
-}   // namespace std
 ```
 #### Class `error_code` constructors <a id="syserr.errcode.constructors">[[syserr.errcode.constructors]]</a>
 ``` cpp
@@ -731,12 +863,14 @@ template <class ErrorCodeEnum>
 *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<ErrorCodeEnum>::value` 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;
@@ -751,12 +885,14 @@ template <class ErrorCodeEnum>
 *Postconditions:* `*this == make_error_code(e)`.
 *Returns:* `*this`.
-*Remarks:* This operator shall not participate in overload resolution
-unless `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
 ``` cpp
 void clear() noexcept;
 ```
@@ -800,65 +936,56 @@ explicit operator bool() const noexcept;
 error_code make_error_code(errc e) noexcept;
 ```
 *Returns:* `error_code(static_cast<int>(e), generic_category())`.
-``` cpp
-bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
-```
-*Returns:*
-`lhs.category() < rhs.category() || lhs.category() == rhs.category() && lhs.value() < rhs.value()`.
 ``` cpp
 template <class charT, class traits>
   basic_ostream<charT, traits>&
     operator<<(basic_ostream<charT, traits>& os, const error_code& ec);
 ```
-*Effects:*
-`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. `error_condition` values are portable
-abstractions, while `error_code` values ([[syserr.errcode]]) are
-implementation specific.
 ``` cpp
 namespace std {
   class error_condition {
   public:
-    // [syserr.errcondition.constructors] constructors:
     error_condition() noexcept;
     error_condition(int val, const error_category& cat) noexcept;
     template <class ErrorConditionEnum>
       error_condition(ErrorConditionEnum e) noexcept;
-    // [syserr.errcondition.modifiers] modifiers:
     void assign(int val, const error_category& cat) noexcept;
     template <class ErrorConditionEnum>
       error_condition& operator=(ErrorConditionEnum e) noexcept;
     void clear() noexcept;
-    // [syserr.errcondition.observers] observers:
     int value() const noexcept;
     const error_category& category() const noexcept;
     string message() const;
     explicit operator bool() const noexcept;
   private:
     int val_;                   // exposition only
     const error_category* cat_; // exposition only
   };
-  // [syserr.errcondition.nonmembers] non-member functions:
-  bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
-} // namespace std
 ```
 #### Class `error_condition` constructors <a id="syserr.errcondition.constructors">[[syserr.errcondition.constructors]]</a>
 ``` cpp
@@ -882,14 +1009,16 @@ template <class ErrorConditionEnum>
   error_condition(ErrorConditionEnum e) noexcept;
 ```
 *Effects:* Constructs an object of type `error_condition`.
-`*this == make_error_condition(e)`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_error_condition_enum<ErrorConditionEnum>::value` 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;
@@ -900,16 +1029,18 @@ void assign(int val, const error_category& cat) noexcept;
 ``` cpp
 template <class ErrorConditionEnum>
     error_condition& operator=(ErrorConditionEnum e) noexcept;
 ```
-`*this == make_error_condition(e)`.
 *Returns:* `*this`.
-*Remarks:* This operator shall not participate in overload resolution
-unless `is_error_condition_enum<ErrorConditionEnum>::value` is `true`.
 ``` cpp
 void clear() noexcept;
 ```
@@ -947,20 +1078,31 @@ explicit operator bool() const noexcept;
 error_condition make_error_condition(errc e) noexcept;
 ```
 *Returns:* `error_condition(static_cast<int>(e), generic_category())`.
 ``` 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()`.
-### Comparison operators <a id="syserr.compare">[[syserr.compare]]</a>
 ``` cpp
 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
 ```
 *Returns:*
@@ -998,44 +1140,42 @@ bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept
 ### System error hash support <a id="syserr.hash">[[syserr.hash]]</a>
 ``` cpp
 template <> struct hash<error_code>;
 ```
-The template specialization shall meet the requirements of class
-template `hash` ([[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.
-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`.
 ``` cpp
 namespace std {
   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;
   };
-}   // namespace std
 ```
 #### Class `system_error` members <a id="syserr.syserr.members">[[syserr.syserr.members]]</a>
 ``` cpp
@@ -1065,23 +1205,21 @@ 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)`.
@@ -1102,23 +1240,28 @@ const error_code& code() const noexcept;
 *Returns:* `ec` or `error_code(ev, ecat)`, from the constructor, as
 appropriate.
 ``` cpp
-const char* what() const noexcept;
 ```
 *Returns:* An NTBSincorporating the arguments supplied in the
 constructor.
-The returned NTBS might be the contents of
-`what_arg + ": " + code.message()`.
 <!-- Link reference definitions -->
 [assertions]: #assertions
 [bad.alloc]: language.md#bad.alloc
 [comparisons]: utilities.md#comparisons
 [diagnostics]: #diagnostics
 [diagnostics.general]: #diagnostics.general
 [domain.error]: #domain.error
 [errno]: #errno
 [invalid.argument]: #invalid.argument
@@ -1128,10 +1271,11 @@ The returned NTBS might be the contents of
 [overflow.error]: #overflow.error
 [range.error]: #range.error
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [runtime.error]: #runtime.error
 [std.exceptions]: #std.exceptions
 [syserr]: #syserr
 [syserr.compare]: #syserr.compare
 [syserr.errcat]: #syserr.errcat
 [syserr.errcat.derived]: #syserr.errcat.derived
 [syserr.errcat.nonvirtuals]: #syserr.errcat.nonvirtuals
@@ -1152,10 +1296,9 @@ The returned NTBS might be the contents of
 [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
-[tab:diagnostics.hdr.cassert]: #tab:diagnostics.hdr.cassert
-[tab:diagnostics.hdr.cerrno]: #tab:diagnostics.hdr.cerrno
 [tab:diagnostics.lib.summary]: #tab:diagnostics.lib.summary
 [underflow.error]: #underflow.error
 [unord.hash]: utilities.md#unord.hash

 | [[syserr]]         | System error support | `<system_error>` |
 ## 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
 program. They cannot be easily predicted in advance. The header
 `<stdexcept>` defines several types of predefined exceptions for
 reporting errors in a C++program. These exceptions are related by
 inheritance.
+### Header `<stdexcept>` synopsis <a id="stdexcept.syn">[[stdexcept.syn]]</a>
 ``` cpp
 namespace std {
   class logic_error;
     class domain_error;
     class invalid_argument;
 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 {
 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 {
 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 {
 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 {
 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 {
 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 {
 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 {
 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 {
 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.
+### Header `<cassert>` synopsis <a id="cassert.syn">[[cassert.syn]]</a>
+``` cpp
+#define assert(E) see below
+```
+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
+`<errno.h>`, except that `errno` shall be defined as a macro.
+[*Note 1*: The intent is to remain in close alignment with the POSIX
+standard. — *end note*]
+A separate `errno` value shall be provided for each thread.
+### Header `<cerrno>` synopsis <a id="cerrno.syn">[[cerrno.syn]]</a>
+``` cpp
+#define errno see below
+#define E2BIG see below
+#define EACCES see below
+#define EADDRINUSE see below
+#define EADDRNOTAVAIL see below
+#define EAFNOSUPPORT see below
+#define EAGAIN see below
+#define EALREADY see below
+#define EBADF see below
+#define EBADMSG see below
+#define EBUSY see below
+#define ECANCELED see below
+#define ECHILD see below
+#define ECONNABORTED see below
+#define ECONNREFUSED see below
+#define ECONNRESET see below
+#define EDEADLK see below
+#define EDESTADDRREQ see below
+#define EDOM see below
+#define EEXIST see below
+#define EFAULT see below
+#define EFBIG see below
+#define EHOSTUNREACH see below
+#define EIDRM see below
+#define EILSEQ see below
+#define EINPROGRESS see below
+#define EINTR see below
+#define EINVAL see below
+#define EIO see below
+#define EISCONN see below
+#define EISDIR see below
+#define ELOOP see below
+#define EMFILE see below
+#define EMLINK see below
+#define EMSGSIZE see below
+#define ENAMETOOLONG see below
+#define ENETDOWN see below
+#define ENETRESET see below
+#define ENETUNREACH see below
+#define ENFILE see below
+#define ENOBUFS see below
+#define ENODATA see below
+#define ENODEV see below
+#define ENOENT see below
+#define ENOEXEC see below
+#define ENOLCK see below
+#define ENOLINK see below
+#define ENOMEM see below
+#define ENOMSG see below
+#define ENOPROTOOPT see below
+#define ENOSPC see below
+#define ENOSR see below
+#define ENOSTR see below
+#define ENOSYS see below
+#define ENOTCONN see below
+#define ENOTDIR see below
+#define ENOTEMPTY see below
+#define ENOTRECOVERABLE see below
+#define ENOTSOCK see below
+#define ENOTSUP see below
+#define ENOTTY see below
+#define ENXIO see below
+#define EOPNOTSUPP see below
+#define EOVERFLOW see below
+#define EOWNERDEAD see below
+#define EPERM see below
+#define EPIPE see below
+#define EPROTO see below
+#define EPROTONOSUPPORT see below
+#define EPROTOTYPE see below
+#define ERANGE see below
+#define EROFS see below
+#define ESPIPE see below
+#define ESRCH see below
+#define ETIME see below
+#define ETIMEDOUT see below
+#define ETXTBSY see below
+#define EWOULDBLOCK see below
+#define EXDEV see below
+```
+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
 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;
     too_many_symbolic_link_levels,      // ELOOP
     value_too_large,                    // EOVERFLOW
     wrong_protocol_type,                // EPROTOTYPE
   };
+  template <> struct is_error_condition_enum<errc> : true_type {};
+  // [syserr.errcode.nonmembers], non-member functions
   error_code make_error_code(errc e) noexcept;
+  template <class charT, class traits>
+    basic_ostream<charT, traits>&
+      operator<<(basic_ostream<charT, traits>& os, const error_code& ec);
+  // [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
 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*]
 ``` cpp
 namespace std {
   class error_category {
   public:
     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
 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;
 If the argument `ev` corresponds to a POSIX `errno` value `posv`, the
 function shall return `error_condition(posv, generic_category())`.
 Otherwise, the function shall return
 `error_condition(ev, system_category())`. What constitutes
+correspondence for any given operating system is unspecified.
+[*Note 1*: The number of potential system error codes is large and
+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.
+[*Note 1*: Class `error_code` is an adjunct to error reporting by
+exception. — *end note*]
 ``` cpp
 namespace std {
   class error_code {
   public:
+    // [syserr.errcode.constructors], constructors
     error_code() noexcept;
     error_code(int val, const error_category& cat) noexcept;
     template <class ErrorCodeEnum>
       error_code(ErrorCodeEnum e) noexcept;
+    // [syserr.errcode.modifiers], modifiers
     void assign(int val, const error_category& cat) noexcept;
     template <class ErrorCodeEnum>
       error_code& operator=(ErrorCodeEnum e) noexcept;
     void clear() noexcept;
+    // [syserr.errcode.observers], 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;
   private:
     int val_;                   // exposition only
     const error_category* cat_; // exposition only
   };
+  // [syserr.errcode.nonmembers], non-member functions
   error_code make_error_code(errc e) noexcept;
   template <class charT, class traits>
     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
 *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:* `*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;
 ```
 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 {
   public:
+    // [syserr.errcondition.constructors], constructors
     error_condition() noexcept;
     error_condition(int val, const error_category& cat) noexcept;
     template <class ErrorConditionEnum>
       error_condition(ErrorConditionEnum e) noexcept;
+    // [syserr.errcondition.modifiers], modifiers
     void assign(int val, const error_category& cat) noexcept;
     template <class ErrorConditionEnum>
       error_condition& operator=(ErrorConditionEnum e) noexcept;
     void clear() noexcept;
+    // [syserr.errcondition.observers], observers
     int value() const noexcept;
     const error_category& category() const noexcept;
     string message() const;
     explicit operator bool() const noexcept;
   private:
     int val_;                   // exposition only
     const error_category* cat_; // exposition only
   };
+}
 ```
 #### Class `error_condition` constructors <a id="syserr.errcondition.constructors">[[syserr.errcondition.constructors]]</a>
 ``` cpp
   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;
 ``` 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;
 ```
 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:*
 ### 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:
     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 override;
   };
+}
 ```
 #### Class `system_error` members <a id="syserr.syserr.members">[[syserr.syserr.members]]</a>
 ``` cpp
 *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)`.
 *Returns:* `ec` or `error_code(ev, ecat)`, from the constructor, as
 appropriate.
 ``` cpp
+const char* what() const noexcept override;
 ```
 *Returns:* An NTBSincorporating the arguments supplied in the
 constructor.
+[*Note 1*: The returned NTBSmight be the contents of
+`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
 [overflow.error]: #overflow.error
 [range.error]: #range.error
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [runtime.error]: #runtime.error
 [std.exceptions]: #std.exceptions
+[stdexcept.syn]: #stdexcept.syn
 [syserr]: #syserr
 [syserr.compare]: #syserr.compare
 [syserr.errcat]: #syserr.errcat
 [syserr.errcat.derived]: #syserr.errcat.derived
 [syserr.errcat.nonvirtuals]: #syserr.errcat.nonvirtuals
 [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

Diff to HTML by rtfpessoa