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

Files changed (1) hide show

tmp/tmp8c20fo4f/{from.md → to.md} +57 -84

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

@@ -1,13 +1,17 @@
 ## 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
@@ -67,22 +71,19 @@ namespace std {
     network_unreachable,                // ENETUNREACH
     no_buffer_space,                    // ENOBUFS
     no_child_process,                   // ECHILD
     no_link,                            // ENOLINK
     no_lock_available,                  // ENOLCK
-    no_message_available,               // ENODATA
     no_message,                         // ENOMSG
     no_protocol_option,                 // ENOPROTOOPT
     no_space_on_device,                 // ENOSPC
-    no_stream_resources,                // ENOSR
     no_such_device_or_address,          // ENXIO
     no_such_device,                     // ENODEV
     no_such_file_or_directory,          // ENOENT
     no_such_process,                    // ESRCH
     not_a_directory,                    // ENOTDIR
     not_a_socket,                       // ENOTSOCK
-    not_a_stream,                       // ENOSTR
     not_connected,                      // ENOTCONN
     not_enough_memory,                  // ENOMEM
     not_supported,                      // ENOTSUP
     operation_canceled,                 // ECANCELED
     operation_in_progress,              // EINPROGRESS
@@ -96,11 +97,10 @@ namespace std {
     read_only_file_system,              // EROFS
     resource_deadlock_would_occur,      // EDEADLK
     resource_unavailable_try_again,     // EAGAIN
     result_out_of_range,                // ERANGE
     state_not_recoverable,              // ENOTRECOVERABLE
-    stream_timeout,                     // ETIME
     text_file_busy,                     // ETXTBSY
     timed_out,                          // ETIMEDOUT
     too_many_files_open_in_system,      // ENFILE
     too_many_files_open,                // EMFILE
     too_many_links,                     // EMLINK
@@ -119,11 +119,11 @@ namespace std {
       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_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;
@@ -133,24 +133,24 @@ namespace std {
   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>
@@ -160,13 +160,14 @@ 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*]
 ``` cpp
 namespace std {
   class error_category {
   public:
@@ -292,19 +293,20 @@ the same object.
 *Remarks:* The object’s `equivalent` virtual functions shall behave as
 specified for class `error_category`. The object’s `name` virtual
 function shall return a pointer to the string `"system"`. The object’s
 `default_error_condition` virtual function shall behave as follows:
-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>
 #### Overview <a id="syserr.errcode.overview">[[syserr.errcode.overview]]</a>
@@ -357,26 +359,32 @@ namespace std {
 ``` 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;
@@ -389,11 +397,16 @@ 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;
@@ -493,27 +506,33 @@ namespace std {
 ``` 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;
@@ -527,11 +546,16 @@ template<class ErrorConditionEnum>
 ```
 *Constraints:* `is_error_condition_enum_v<ErrorConditionEnum>` is
 `true`.
-*Ensures:* `*this == make_error_condition(e)`.
 *Returns:* `*this`.
 ``` cpp
 void clear() noexcept;
@@ -571,11 +595,11 @@ explicit operator bool() const 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;
 ```
@@ -726,56 +750,5 @@ const char* what() const noexcept override;
 constructor.
 [*Note 1*: The returned NTBS might be the contents of
 `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
-[out.of.range]: #out.of.range
-[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.errcat.objects]: #syserr.errcat.objects
-[syserr.errcat.overview]: #syserr.errcat.overview
-[syserr.errcat.virtuals]: #syserr.errcat.virtuals
-[syserr.errcode]: #syserr.errcode
-[syserr.errcode.constructors]: #syserr.errcode.constructors
-[syserr.errcode.modifiers]: #syserr.errcode.modifiers
-[syserr.errcode.nonmembers]: #syserr.errcode.nonmembers
-[syserr.errcode.observers]: #syserr.errcode.observers
-[syserr.errcode.overview]: #syserr.errcode.overview
-[syserr.errcondition]: #syserr.errcondition
-[syserr.errcondition.constructors]: #syserr.errcondition.constructors
-[syserr.errcondition.modifiers]: #syserr.errcondition.modifiers
-[syserr.errcondition.nonmembers]: #syserr.errcondition.nonmembers
-[syserr.errcondition.observers]: #syserr.errcondition.observers
-[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

 ## System error support <a id="syserr">[[syserr]]</a>
+### General <a id="syserr.general">[[syserr.general]]</a>
+Subclause [[syserr]] 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 [[syserr]] do not change the value of `errno`
+[[errno]].
+*Recommended practice:* 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
     network_unreachable,                // ENETUNREACH
     no_buffer_space,                    // ENOBUFS
     no_child_process,                   // ECHILD
     no_link,                            // ENOLINK
     no_lock_available,                  // ENOLCK
     no_message,                         // ENOMSG
     no_protocol_option,                 // ENOPROTOOPT
     no_space_on_device,                 // ENOSPC
     no_such_device_or_address,          // ENXIO
     no_such_device,                     // ENODEV
     no_such_file_or_directory,          // ENOENT
     no_such_process,                    // ESRCH
     not_a_directory,                    // ENOTDIR
     not_a_socket,                       // ENOTSOCK
     not_connected,                      // ENOTCONN
     not_enough_memory,                  // ENOMEM
     not_supported,                      // ENOTSUP
     operation_canceled,                 // ECANCELED
     operation_in_progress,              // EINPROGRESS
     read_only_file_system,              // EROFS
     resource_deadlock_would_occur,      // EDEADLK
     resource_unavailable_try_again,     // EAGAIN
     result_out_of_range,                // ERANGE
     state_not_recoverable,              // ENOTRECOVERABLE
     text_file_busy,                     // ETXTBSY
     timed_out,                          // ETIMEDOUT
     too_many_files_open_in_system,      // ENFILE
     too_many_files_open,                // EMFILE
     too_many_links,                     // EMLINK
       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 operator 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;
   template<> struct hash<error_code>;
   template<> struct hash<error_condition>;
   // [syserr], system error support
   template<class T>
+    constexpr bool is_error_code_enum_v = is_error_code_enum<T>::value;
   template<class T>
+    constexpr bool is_error_condition_enum_v = is_error_condition_enum<T>::value;
 }
 ```
+The value of each `enum errc` enumerator is 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` templates may be
 specialized for program-defined types to indicate that such types are
+eligible for `class error_code` and `class error_condition` implicit
 conversions, respectively.
 ### Class `error_category` <a id="syserr.errcat">[[syserr.errcat]]</a>
 #### Overview <a id="syserr.errcat.overview">[[syserr.errcat.overview]]</a>
 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. If there is more
+than a single object of a custom `error_category` type, such equality
+comparisons can evaluate to `false` even for objects holding the same
+value. — *end note*]
 ``` cpp
 namespace std {
   class error_category {
   public:
 *Remarks:* The object’s `equivalent` virtual functions shall behave as
 specified for class `error_category`. The object’s `name` virtual
 function shall return a pointer to the string `"system"`. The object’s
 `default_error_condition` virtual function shall behave as follows:
+If the argument `ev` is equal to 0, the function returns
+`error_condition(0, generic_category())`. Otherwise, if `ev` corresponds
+to a POSIX `errno` value `pxv`, the function returns
+`error_condition(pxv, generic_category())`. Otherwise, the function
+returns `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 might 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>
 #### Overview <a id="syserr.errcode.overview">[[syserr.errcode.overview]]</a>
 ``` cpp
 error_code() noexcept;
 ```
+*Effects:* Initializes `val_` with `0` and `cat_` with
+`&system_category()`.
 ``` cpp
 error_code(int val, const error_category& cat) noexcept;
 ```
+*Effects:* Initializes `val_` with `val` and `cat_` with `&cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code(ErrorCodeEnum e) noexcept;
 ```
 *Constraints:* `is_error_code_enum_v<ErrorCodeEnum>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+error_code ec = make_error_code(e);
+assign(ec.value(), ec.category());
+```
 #### Modifiers <a id="syserr.errcode.modifiers">[[syserr.errcode.modifiers]]</a>
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
   error_code& operator=(ErrorCodeEnum e) noexcept;
 ```
 *Constraints:* `is_error_code_enum_v<ErrorCodeEnum>` is `true`.
+*Effects:* Equivalent to:
+``` cpp
+error_code ec = make_error_code(e);
+assign(ec.value(), ec.category());
+```
 *Returns:* `*this`.
 ``` cpp
 void clear() noexcept;
 ``` cpp
 error_condition() noexcept;
 ```
+*Effects:* Initializes `val_` with `0` and `cat_` with
+`&generic_category()`.
 ``` cpp
 error_condition(int val, const error_category& cat) noexcept;
 ```
+*Effects:* Initializes `val_` with `val` and `cat_` with `&cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition(ErrorConditionEnum e) noexcept;
 ```
 *Constraints:* `is_error_condition_enum_v<ErrorConditionEnum>` is
 `true`.
+*Effects:* Equivalent to:
+``` cpp
+error_condition ec = make_error_condition(e);
+assign(ec.value(), ec.category());
+```
 #### Modifiers <a id="syserr.errcondition.modifiers">[[syserr.errcondition.modifiers]]</a>
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
 *Constraints:* `is_error_condition_enum_v<ErrorConditionEnum>` is
 `true`.
+*Effects:* Equivalent to:
+``` cpp
+error_condition ec = make_error_condition(e);
+assign(ec.value(), ec.category());
+```
 *Returns:* `*this`.
 ``` cpp
 void clear() noexcept;
 error_condition make_error_condition(errc e) noexcept;
 ```
 *Returns:* `error_condition(static_cast<int>(e), generic_category())`.
+### Comparison operator functions <a id="syserr.compare">[[syserr.compare]]</a>
 ``` cpp
 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
 ```
 constructor.
 [*Note 1*: The returned NTBS might be the contents of
 `what_arg + ": " + code.message()`. — *end note*]

Diff to HTML by rtfpessoa