[support.exception] - C++20 → C++23

Files changed (1) hide show

tmp/tmp8tseoaw9/{from.md → to.md} +25 -14

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

@@ -1,13 +1,16 @@
 ## Exception handling <a id="support.exception">[[support.exception]]</a>
 The header `<exception>` defines several types and functions related to
 the handling of exceptions in a C++ program.
 ### Header `<exception>` synopsis <a id="exception.syn">[[exception.syn]]</a>
 ``` cpp
 namespace std {
   class exception;
   class bad_exception;
   class nested_exception;
@@ -83,11 +86,11 @@ virtual const char* what() const noexcept;
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
 string [[multibyte.strings]], suitable for conversion and display as a
-`wstring` ([[string.classes]], [[locale.codecvt]]). The return value
 remains valid until the exception object from which it is obtained is
 destroyed or a non-`const` member function of the exception object is
 called.
 ### Class `bad_exception` <a id="bad.exception">[[bad.exception]]</a>
@@ -119,11 +122,11 @@ const char* what() const noexcept override;
 ``` cpp
 using terminate_handler = void (*)();
 ```
-The type of a *handler function* to be called by `std::terminate()` when
 terminating exception processing.
 *Required behavior:* A `terminate_handler` shall terminate execution of
 the program without returning to the caller.
@@ -137,43 +140,43 @@ terminate_handler set_terminate(terminate_handler f) noexcept;
 ```
 *Effects:* Establishes the function designated by `f` as the current
 handler function for terminating exception processing.
 *Remarks:* It is unspecified whether a null pointer value designates the
 default `terminate_handler`.
-*Returns:* The previous `terminate_handler`.
 #### `get_terminate` <a id="get.terminate">[[get.terminate]]</a>
 ``` cpp
 terminate_handler get_terminate() noexcept;
 ```
 *Returns:* The current `terminate_handler`.
-[*Note 1*: This may be a null pointer value. — *end note*]
 #### `terminate` <a id="terminate">[[terminate]]</a>
 ``` cpp
 [[noreturn]] void terminate() noexcept;
 ```
-*Remarks:* Called by the implementation when exception handling must be
-abandoned for any of several reasons [[except.terminate]]. May also be
-called directly by the program.
 *Effects:* Calls a `terminate_handler` function. It is unspecified which
 `terminate_handler` function will be called if an exception is active
 during a call to `set_terminate`. Otherwise calls the current
 `terminate_handler` function.
 [*Note 1*: A default `terminate_handler` is always considered a
 callable handler in this context. — *end note*]
 ### `uncaught_exceptions` <a id="uncaught.exceptions">[[uncaught.exceptions]]</a>
 ``` cpp
 int uncaught_exceptions() noexcept;
 ```
@@ -201,22 +204,22 @@ The default constructor of `exception_ptr` produces the null value of
 the type.
 `exception_ptr` shall not be implicitly convertible to any arithmetic,
 enumeration, or pointer type.
-[*Note 1*: An implementation might use a reference-counted smart
-pointer as `exception_ptr`. — *end note*]
 For purposes of determining the presence of a data race, operations on
 `exception_ptr` objects shall access and modify only the `exception_ptr`
 objects themselves and not the exceptions they refer to. Use of
 `rethrow_exception` on `exception_ptr` objects that refer to the same
 exception object shall not introduce a data race.
 [*Note 2*: If `rethrow_exception` rethrows the same exception object
 (rather than a copy), concurrent access to that rethrown exception
-object may introduce a data race. Changes in the number of
 `exception_ptr` objects that refer to a particular exception do not
 introduce a data race. — *end note*]
 ``` cpp
 exception_ptr current_exception() noexcept;
@@ -238,21 +241,29 @@ creates a new copy each time it is called. — *end note*]
 If the attempt to copy the current exception object throws an exception,
 the function returns an `exception_ptr` object that refers to the thrown
 exception or, if this is not possible, to an instance of
 `bad_exception`.
-[*Note 4*: The copy constructor of the thrown exception may also fail,
 so the implementation is allowed to substitute a `bad_exception` object
 to avoid infinite recursion. — *end note*]
 ``` cpp
 [[noreturn]] void rethrow_exception(exception_ptr p);
 ```
 *Preconditions:* `p` is not a null pointer.
-*Throws:* The exception object to which `p` refers.
 ``` cpp
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 ```

 ## Exception handling <a id="support.exception">[[support.exception]]</a>
+### General <a id="support.exception.general">[[support.exception.general]]</a>
 The header `<exception>` defines several types and functions related to
 the handling of exceptions in a C++ program.
 ### Header `<exception>` synopsis <a id="exception.syn">[[exception.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   class exception;
   class bad_exception;
   class nested_exception;
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
 string [[multibyte.strings]], suitable for conversion and display as a
+`wstring` [[string.classes]], [[locale.codecvt]]. The return value
 remains valid until the exception object from which it is obtained is
 destroyed or a non-`const` member function of the exception object is
 called.
 ### Class `bad_exception` <a id="bad.exception">[[bad.exception]]</a>
 ``` cpp
 using terminate_handler = void (*)();
 ```
+The type of a *handler function* to be invoked by `terminate` when
 terminating exception processing.
 *Required behavior:* A `terminate_handler` shall terminate execution of
 the program without returning to the caller.
 ```
 *Effects:* Establishes the function designated by `f` as the current
 handler function for terminating exception processing.
+*Returns:* The previous `terminate_handler`.
 *Remarks:* It is unspecified whether a null pointer value designates the
 default `terminate_handler`.
 #### `get_terminate` <a id="get.terminate">[[get.terminate]]</a>
 ``` cpp
 terminate_handler get_terminate() noexcept;
 ```
 *Returns:* The current `terminate_handler`.
+[*Note 1*: This can be a null pointer value. — *end note*]
 #### `terminate` <a id="terminate">[[terminate]]</a>
 ``` cpp
 [[noreturn]] void terminate() noexcept;
 ```
 *Effects:* Calls a `terminate_handler` function. It is unspecified which
 `terminate_handler` function will be called if an exception is active
 during a call to `set_terminate`. Otherwise calls the current
 `terminate_handler` function.
 [*Note 1*: A default `terminate_handler` is always considered a
 callable handler in this context. — *end note*]
+*Remarks:* Called by the implementation when exception handling must be
+abandoned for any of several reasons [[except.terminate]]. May also be
+called directly by the program.
 ### `uncaught_exceptions` <a id="uncaught.exceptions">[[uncaught.exceptions]]</a>
 ``` cpp
 int uncaught_exceptions() noexcept;
 ```
 the type.
 `exception_ptr` shall not be implicitly convertible to any arithmetic,
 enumeration, or pointer type.
+[*Note 1*: An implementation can use a reference-counted smart pointer
+as `exception_ptr`. — *end note*]
 For purposes of determining the presence of a data race, operations on
 `exception_ptr` objects shall access and modify only the `exception_ptr`
 objects themselves and not the exceptions they refer to. Use of
 `rethrow_exception` on `exception_ptr` objects that refer to the same
 exception object shall not introduce a data race.
 [*Note 2*: If `rethrow_exception` rethrows the same exception object
 (rather than a copy), concurrent access to that rethrown exception
+object can introduce a data race. Changes in the number of
 `exception_ptr` objects that refer to a particular exception do not
 introduce a data race. — *end note*]
 ``` cpp
 exception_ptr current_exception() noexcept;
 If the attempt to copy the current exception object throws an exception,
 the function returns an `exception_ptr` object that refers to the thrown
 exception or, if this is not possible, to an instance of
 `bad_exception`.
+[*Note 4*: The copy constructor of the thrown exception can also fail,
 so the implementation is allowed to substitute a `bad_exception` object
 to avoid infinite recursion. — *end note*]
 ``` cpp
 [[noreturn]] void rethrow_exception(exception_ptr p);
 ```
 *Preconditions:* `p` is not a null pointer.
+*Effects:* Let u be the exception object to which `p` refers, or a copy
+of that exception object. It is unspecified whether a copy is made, and
+memory for the copy is allocated in an unspecified way.
+- If allocating memory to form u fails, throws an instance of
+  `bad_alloc`;
+- otherwise, if copying the exception to which `p` refers to form u
+  throws an exception, throws that exception;
+- otherwise, throws u.
 ``` cpp
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 ```

Diff to HTML by rtfpessoa