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

Files changed (1) hide show

tmp/tmps1khthk7/{from.md → to.md} +121 -88

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

@@ -9,26 +9,26 @@ handler will be invoked only by throwing an exception in code executed
 in the handler’s try block or in functions called from the handler’s try
 block.
 ``` bnf
 try-block:
- 'try' compound-statement handler-seq
 ```
 ``` bnf
 function-try-block:
- 'try' ctor-initializerₒₚₜ compound-statement handler-seq
 ```
 ``` bnf
 handler-seq:
     handler handler-seqₒₚₜ
 ```
 ``` bnf
 handler:
- 'catch' '(' exception-declaration ')' compound-statement
 ```
 ``` bnf
 exception-declaration:
     attribute-specifier-seqₒₚₜ type-specifier-seq declarator
@@ -42,12 +42,12 @@ appertains to the parameter of the catch clause [[except.handle]].
 A *try-block* is a *statement* [[stmt.pre]].
 [*Note 1*: Within this Clause “try block” is taken to mean both
 *try-block* and *function-try-block*. — *end note*]
-A `goto` or `switch` statement shall not be used to transfer control
-into a try block or into a handler.
 [*Example 1*:
 ``` cpp
 void f() {
@@ -183,14 +183,12 @@ When an exception is thrown, control is transferred to the nearest
 handler with a matching type [[except.handle]]; “nearest” means the
 handler for which the *compound-statement* or *ctor-initializer*
 following the `try` keyword was most recently entered by the thread of
 control and not yet exited.
-Throwing an exception copy-initializes ([[dcl.init]],
-[[class.copy.ctor]]) a temporary object, called the *exception object*.
-An lvalue denoting the temporary is used to initialize the variable
-declared in the matching *handler* [[except.handle]]. If the type of the
 exception object would be an incomplete type, an abstract class type
 [[class.abstract]], or a pointer to an incomplete type other than
 cv `void` the program is ill-formed.
 The memory for the exception object is allocated in an unspecified way,
@@ -233,11 +231,12 @@ becomes active [[except.handle]].
 [*Note 4*: An exception can have active handlers and still be
 considered uncaught if it is rethrown. — *end note*]
 If the exception handling mechanism handling an uncaught exception
 [[except.uncaught]] directly invokes a function that exits via an
-exception, the function `std::terminate` is called [[except.terminate]].
 [*Example 2*:
 ``` cpp
 struct C {
@@ -257,22 +256,18 @@ int main() {
 }
 ```
 — *end example*]
-[*Note 5*:
-Consequently, destructors should generally catch exceptions and not let
-them propagate.
-— *end note*]
 ## Constructors and destructors <a id="except.ctor">[[except.ctor]]</a>
 As control passes from the point where an exception is thrown to a
-handler, objects with automatic storage duration are destroyed by a
-process, specified in this subclause, called *stack unwinding*.
 Each object with automatic storage duration is destroyed if it has been
 constructed, but not yet destroyed, since the try block was entered. If
 an exception is thrown during the destruction of temporaries or local
 variables for a `return` statement [[stmt.return]], the destructor for
@@ -304,23 +299,47 @@ destroyed, causing stack unwinding, resulting in the destruction of the
 returned object, followed by the destruction of the local variable `a`.
 Finally, the returned object is constructed again at \#2.
 — *end example*]
-If the initialization or destruction of an object other than by
-delegating constructor is terminated by an exception, the destructor is
-invoked for each of the object’s direct subobjects and, for a complete
-object, virtual base class subobjects, whose initialization has
-completed [[dcl.init]] and whose destructor has not yet begun execution,
-except that in the case of destruction, the variant members of a
-union-like class are not destroyed.
 [*Note 1*: If such an object has a reference member that extends the
 lifetime of a temporary object, this ends the lifetime of the reference
 member, so the lifetime of the temporary object is effectively not
 extended. — *end note*]
 The subobjects are destroyed in the reverse order of the completion of
 their construction. Such destruction is sequenced before entering a
 handler of the *function-try-block* of the constructor or destructor, if
 any.
@@ -328,11 +347,11 @@ If the *compound-statement* of the *function-body* of a delegating
 constructor for an object exits via an exception, the object’s
 destructor is invoked. Such destruction is sequenced before entering a
 handler of the *function-try-block* of a delegating constructor for that
 object, if any.
-[*Note 2*: If the object was allocated by a *new-expression*
 [[expr.new]], the matching deallocation function
 [[basic.stc.dynamic.deallocation]], if any, is called to free the
 storage occupied by the object. — *end note*]
 ## Handling an exception <a id="except.handle">[[except.handle]]</a>
@@ -340,12 +359,11 @@ storage occupied by the object. — *end note*]
 The *exception-declaration* in a *handler* describes the type(s) of
 exceptions that can cause that *handler* to be entered. The
 *exception-declaration* shall not denote an incomplete type, an abstract
 class type, or an rvalue reference type. The *exception-declaration*
 shall not denote a pointer or reference to an incomplete type, other
-than `void*`, `const` `void*`, `volatile` `void*`, or `const` `volatile`
-`void*`.
 A handler of type “array of `T`” or function type `T` is adjusted to be
 of type “pointer to `T`”.
 A *handler* is a match for an exception object of type `E` if
@@ -423,27 +441,24 @@ considered active when the catch clause exits.
 The exception with the most recently activated handler that is still
 active is called the *currently handled exception*.
 If no matching handler is found, the function `std::terminate` is
-called; whether or not the stack is unwound before this call to
 `std::terminate` is *implementation-defined* [[except.terminate]].
 Referring to any non-static member or base class of an object in the
 handler for a *function-try-block* of a constructor or destructor for
 that object results in undefined behavior.
-The scope and lifetime of the parameters of a function or constructor
-extend into the handlers of a *function-try-block*.
 Exceptions thrown in destructors of objects with static storage duration
-or in constructors of namespace-scope objects with static storage
-duration are not caught by a *function-try-block* on the `main` function
-[[basic.start.main]]. Exceptions thrown in destructors of objects with
-thread storage duration or in constructors of namespace-scope objects
-with thread storage duration are not caught by a *function-try-block* on
-the initial function of the thread.
 If a `return` statement [[stmt.return]] appears in a handler of the
 *function-try-block* of a constructor, the program is ill-formed.
 The currently handled exception is rethrown if control reaches the end
@@ -455,14 +470,14 @@ of the *compound-statement* of that function (see [[stmt.return]]).
 The variable declared by the *exception-declaration*, of type cv `T` or
 cv `T&`, is initialized from the exception object, of type `E`, as
 follows:
 - if `T` is a base class of `E`, the variable is copy-initialized
-  [[dcl.init]] from the corresponding base class subobject of the
-  exception object;
-- otherwise, the variable is copy-initialized [[dcl.init]] from the
-  exception object.
 The lifetime of the variable ends when the handler exits, after the
 destruction of any objects with automatic storage duration initialized
 within the handler.
@@ -481,12 +496,12 @@ specification*. The exception specification is either defined
 implicitly, or defined explicitly by using a *noexcept-specifier* as a
 suffix of a function declarator [[dcl.fct]].
 ``` bnf
 noexcept-specifier:
- 'noexcept' '(' constant-expression ')'
- 'noexcept'
 ```
 In a *noexcept-specifier*, the *constant-expression*, if supplied, shall
 be a contextually converted constant expression of type `bool`
 [[expr.const]]; that constant expression is the exception specification
@@ -494,30 +509,39 @@ of the function type in which the *noexcept-specifier* appears. A `(`
 token that follows `noexcept` is part of the *noexcept-specifier* and
 does not commence an initializer [[dcl.init]]. The *noexcept-specifier*
 `noexcept` without a *constant-expression* is equivalent to the
 *noexcept-specifier* `noexcept(true)`.
 If a declaration of a function does not have a *noexcept-specifier*, the
 declaration has a potentially throwing exception specification unless it
 is a destructor or a deallocation function or is defaulted on its first
 declaration, in which cases the exception specification is as specified
 below and no other declaration for that function shall have a
 *noexcept-specifier*. In an explicit instantiation [[temp.explicit]] a
 *noexcept-specifier* may be specified, but is not required. If a
-*noexcept-specifier* is specified in an explicit instantiation
-directive, the exception specification shall be the same as the
-exception specification of all other declarations of that function. A
-diagnostic is required only if the exception specifications are not the
-same within a single translation unit.
 If a virtual function has a non-throwing exception specification, all
 declarations, including the definition, of any function that overrides
 that virtual function in any derived class shall have a non-throwing
 exception specification, unless the overriding function is defined as
 deleted.
-[*Example 1*:
 ``` cpp
 struct B {
   virtual void f() noexcept;
   virtual void g();
@@ -538,29 +562,29 @@ non-throwing exception specification.
 — *end example*]
 Whenever an exception is thrown and the search for a handler
 [[except.handle]] encounters the outermost block of a function with a
 non-throwing exception specification, the function `std::terminate` is
-called [[except.terminate]].
 [*Note 1*: An implementation is not permitted to reject an expression
 merely because, when executed, it throws or might throw an exception
 from a function with a non-throwing exception
 specification. — *end note*]
-[*Example 2*:
 ``` cpp
 extern void f();                // potentially-throwing
 void g() noexcept {
   f();                          // valid, even if f throws
   throw 42;                     // valid, effectively a call to std::terminate
 }
 ```
-The call to `f` is well-formed even though, when called, `f` might throw
 an exception.
 — *end example*]
 An expression E is *potentially-throwing* if
@@ -569,11 +593,12 @@ An expression E is *potentially-throwing* if
   function type, or a pointer-to-function type, with a
   potentially-throwing exception specification, or
 - E implicitly invokes a function (such as an overloaded operator, an
   allocation function in a *new-expression*, a constructor for a
   function argument, or a destructor if E is a full-expression
-  [[intro.execution]]) that is potentially-throwing, or
 - E is a *throw-expression* [[expr.throw]], or
 - E is a `dynamic_cast` expression that casts to a reference type and
   requires a runtime check [[expr.dynamic.cast]], or
 - E is a `typeid` expression applied to a (possibly parenthesized)
   built-in unary `*` operator applied to a pointer to a polymorphic
@@ -584,31 +609,31 @@ An expression E is *potentially-throwing* if
 An implicitly-declared constructor for a class `X`, or a constructor
 without a *noexcept-specifier* that is defaulted on its first
 declaration, has a potentially-throwing exception specification if and
 only if any of the following constructs is potentially-throwing:
-- a constructor selected by overload resolution in the implicit
-  definition of the constructor for class `X` to initialize a
   potentially constructed subobject, or
 - a subexpression of such an initialization, such as a default argument
   expression, or,
 - for a default constructor, a default member initializer.
 [*Note 2*: Even though destructors for fully-constructed subobjects are
 invoked when an exception is thrown during the execution of a
 constructor [[except.ctor]], their exception specifications do not
 contribute to the exception specification of the constructor, because an
 exception thrown from such a destructor would call the function
-`std::terminate` rather than escape the constructor ([[except.throw]],
-[[except.terminate]]). — *end note*]
 The exception specification for an implicitly-declared destructor, or a
 destructor without a *noexcept-specifier*, is potentially-throwing if
 and only if any of the destructors for any of its potentially
-constructed subobjects is potentially-throwing or the destructor is
-virtual and the destructor of any virtual base class is
-potentially-throwing.
 The exception specification for an implicitly-declared assignment
 operator, or an assignment-operator without a *noexcept-specifier* that
 is defaulted on its first declaration, is potentially-throwing if and
 only if the invocation of any assignment operator in the implicit
@@ -621,11 +646,11 @@ specification.
 The exception specification for a comparison operator function
 [[over.binary]] without a *noexcept-specifier* that is defaulted on its
 first declaration is potentially-throwing if and only if any expression
 in the implicit definition is potentially-throwing.
-[*Example 3*:
 ``` cpp
 struct A {
   A(int = (A(5), 0)) noexcept;
   A(const A&) noexcept;
@@ -655,14 +680,13 @@ base class function has a non-throwing exception specification.
 — *end example*]
 An exception specification is considered to be *needed* when:
-- in an expression, the function is the unique lookup result or the
- selected member of a set of overloaded functions ([[basic.lookup]],
- [[over.match]], [[over.over]]);
-- the function is odr-used [[basic.def.odr]] or, if it appears in an
   unevaluated operand, would be odr-used if the expression were
   potentially-evaluated;
 - the exception specification is compared to that of another declaration
   (e.g., an explicit specialization or an overriding virtual function);
 - the function is defined; or
@@ -678,21 +702,23 @@ described above only when needed; similarly, the *noexcept-specifier* of
 a specialization of a function template or member function of a class
 template is instantiated only when needed.
 ## Special functions <a id="except.special">[[except.special]]</a>
 The function `std::terminate` [[except.terminate]] is used by the
 exception handling mechanism for coping with errors related to the
 exception handling mechanism itself. The function
 `std::current_exception()` [[propagation]] and the class
 `std::nested_exception` [[except.nested]] can be used by a program to
 capture the currently handled exception.
 ### The `std::terminate` function <a id="except.terminate">[[except.terminate]]</a>
-In some situations exception handling must be abandoned for less subtle
-error handling techniques.
 [*Note 1*:
 These situations are:
@@ -705,11 +731,11 @@ These situations are:
 - when the search for a handler [[except.handle]] encounters the
   outermost block of a function with a non-throwing exception
   specification [[except.spec]], or
 - when the destruction of an object during stack unwinding
   [[except.ctor]] terminates by throwing an exception, or
-- when initialization of a non-local variable with static or thread
   storage duration [[basic.start.dynamic]] exits via an exception, or
 - when destruction of an object with static or thread storage duration
   exits via an exception [[basic.start.term]], or
 - when execution of a function registered with `std::atexit` or
   `std::at_quick_exit` exits via an exception [[support.start.term]], or
@@ -719,78 +745,82 @@ These situations are:
 - when the function `std::nested_exception::rethrow_nested` is called
   for an object that has captured no exception [[except.nested]], or
 - when execution of the initial function of a thread exits via an
   exception [[thread.thread.constr]], or
 - for a parallel algorithm whose `ExecutionPolicy` specifies such
-  behavior ([[execpol.seq]], [[execpol.par]], [[execpol.parunseq]]),
- when execution of an element access function
- [[algorithms.parallel.defns]] of the parallel algorithm exits via an
- exception [[algorithms.parallel.exceptions]], or
 - when the destructor or the move assignment operator is invoked on an
-  object of type `std::thread` that refers to a joinable thread (
-  [[thread.thread.destr]], [[thread.thread.assign]]), or
 - when a call to a `wait()`, `wait_until()`, or `wait_for()` function on
-  a condition variable ([[thread.condition.condvar]],
-  [[thread.condition.condvarany]]) fails to meet a postcondition.
 — *end note*]
-In such cases, the function `std::terminate` is called
 [[exception.terminate]]. In the situation where no matching handler is
 found, it is *implementation-defined* whether or not the stack is
-unwound before `std::terminate` is called. In the situation where the
 search for a handler [[except.handle]] encounters the outermost block of
 a function with a non-throwing exception specification [[except.spec]],
 it is *implementation-defined* whether the stack is unwound, unwound
 partially, or not unwound at all before the function `std::terminate` is
-called. In all other situations, the stack shall not be unwound before
-the function `std::terminate` is called. An implementation is not
 permitted to finish stack unwinding prematurely based on a determination
-that the unwind process will eventually cause a call to the function
-`std::terminate`.
-### The `std::uncaught_exceptions()` function <a id="except.uncaught">[[except.uncaught]]</a>
 An exception is considered uncaught after completing the initialization
 of the exception object [[except.throw]] until completing the activation
 of a handler for the exception [[except.handle]].
 [*Note 1*: As a consequence, an exception is considered uncaught during
 any stack unwinding resulting from it being thrown. — *end note*]
-If an exception is rethrown ([[expr.throw]], [[propagation]]), it is
 considered uncaught from the point of rethrow until the rethrown
-exception is caught. The function `std::uncaught_exceptions()`
 [[uncaught.exceptions]] returns the number of uncaught exceptions in the
 current thread.
 <!-- Link reference definitions -->
 [algorithms.parallel.defns]: algorithms.md#algorithms.parallel.defns
 [algorithms.parallel.exceptions]: algorithms.md#algorithms.parallel.exceptions
-[basic.def.odr]: basic.md#basic.def.odr
-[basic.lookup]: basic.md#basic.lookup
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [class.abstract]: class.md#class.abstract
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.copy.elision]: class.md#class.copy.elision
 [class.dtor]: class.md#class.dtor
 [conv.fctptr]: expr.md#conv.fctptr
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.init]: dcl.md#dcl.init
 [except]: #except
 [except.ctor]: #except.ctor
 [except.handle]: #except.handle
 [except.nested]: support.md#except.nested
 [except.pre]: #except.pre
 [except.spec]: #except.spec
 [except.special]: #except.special
 [except.terminate]: #except.terminate
 [except.throw]: #except.throw
 [except.uncaught]: #except.uncaught
 [exception.terminate]: support.md#exception.terminate
 [execpol.par]: utilities.md#execpol.par
@@ -798,25 +828,28 @@ current thread.
 [execpol.seq]: utilities.md#execpol.seq
 [expr.call]: expr.md#expr.call
 [expr.const]: expr.md#expr.const
 [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 [expr.new]: expr.md#expr.new
 [expr.throw]: expr.md#expr.throw
 [expr.typeid]: expr.md#expr.typeid
 [futures]: thread.md#futures
 [intro.execution]: basic.md#intro.execution
 [intro.races]: basic.md#intro.races
 [over.binary]: over.md#over.binary
 [over.match]: over.md#over.match
 [over.over]: over.md#over.over
 [propagation]: support.md#propagation
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [structure.specifications]: library.md#structure.specifications
 [support.start.term]: support.md#support.start.term
 [temp.explicit]: temp.md#temp.explicit
 [thread.condition.condvar]: thread.md#thread.condition.condvar
 [thread.condition.condvarany]: thread.md#thread.condition.condvarany
 [thread.thread.assign]: thread.md#thread.thread.assign
 [thread.thread.constr]: thread.md#thread.thread.constr
 [thread.thread.destr]: thread.md#thread.thread.destr

 in the handler’s try block or in functions called from the handler’s try
 block.
 ``` bnf
 try-block:
+    try compound-statement handler-seq
 ```
 ``` bnf
 function-try-block:
+    try ctor-initializerₒₚₜ compound-statement handler-seq
 ```
 ``` bnf
 handler-seq:
     handler handler-seqₒₚₜ
 ```
 ``` bnf
 handler:
+    catch '(' exception-declaration ')' compound-statement
 ```
 ``` bnf
 exception-declaration:
     attribute-specifier-seqₒₚₜ type-specifier-seq declarator
 A *try-block* is a *statement* [[stmt.pre]].
 [*Note 1*: Within this Clause “try block” is taken to mean both
 *try-block* and *function-try-block*. — *end note*]
+The *compound-statement* of a try block or of a handler is a
+control-flow-limited statement [[stmt.label]].
 [*Example 1*:
 ``` cpp
 void f() {
 handler with a matching type [[except.handle]]; “nearest” means the
 handler for which the *compound-statement* or *ctor-initializer*
 following the `try` keyword was most recently entered by the thread of
 control and not yet exited.
+Throwing an exception copy-initializes [[dcl.init]], [[class.copy.ctor]]
+a temporary object, called the *exception object*. If the type of the
 exception object would be an incomplete type, an abstract class type
 [[class.abstract]], or a pointer to an incomplete type other than
 cv `void` the program is ill-formed.
 The memory for the exception object is allocated in an unspecified way,
 [*Note 4*: An exception can have active handlers and still be
 considered uncaught if it is rethrown. — *end note*]
 If the exception handling mechanism handling an uncaught exception
 [[except.uncaught]] directly invokes a function that exits via an
+exception, the function `std::terminate` is invoked
+[[except.terminate]].
 [*Example 2*:
 ``` cpp
 struct C {
 }
 ```
 — *end example*]
+[*Note 5*: If a destructor directly invoked by stack unwinding exits
+via an exception, `std::terminate` is invoked. — *end note*]
 ## Constructors and destructors <a id="except.ctor">[[except.ctor]]</a>
 As control passes from the point where an exception is thrown to a
+handler, objects are destroyed by a process, specified in this
+subclause, called *stack unwinding*.
 Each object with automatic storage duration is destroyed if it has been
 constructed, but not yet destroyed, since the try block was entered. If
 an exception is thrown during the destruction of temporaries or local
 variables for a `return` statement [[stmt.return]], the destructor for
 returned object, followed by the destruction of the local variable `a`.
 Finally, the returned object is constructed again at \#2.
 — *end example*]
+If the initialization of an object other than by delegating constructor
+is terminated by an exception, the destructor is invoked for each of the
+object’s subobjects that were known to be initialized by the object’s
+initialization and whose initialization has completed [[dcl.init]].
 [*Note 1*: If such an object has a reference member that extends the
 lifetime of a temporary object, this ends the lifetime of the reference
 member, so the lifetime of the temporary object is effectively not
 extended. — *end note*]
+A subobject is *known to be initialized* if its initialization is
+specified
+- in [[class.base.init]] for initialization by constructor,
+- in [[class.copy.ctor]] for initialization by defaulted copy/move
+  constructor,
+- in [[class.inhctor.init]] for initialization by inherited constructor,
+- in [[dcl.init.aggr]] for aggregate initialization,
+- in [[expr.prim.lambda.capture]] for the initialization of the closure
+  object when evaluating a *lambda-expression*,
+- in [[dcl.init.general]] for default-initialization,
+  value-initialization, or direct-initialization of an array.
+[*Note 2*: This includes virtual base class subobjects if the
+initialization is for a complete object, and can include variant members
+that were nominated explicitly by a *mem-initializer* or
+*designated-initializer-clause* or that have a default member
+initializer. — *end note*]
+If the destructor of an object is terminated by an exception, each
+destructor invocation that would be performed after executing the body
+of the destructor [[class.dtor]] and that has not yet begun execution is
+performed.
+[*Note 3*: This includes virtual base class subobjects if the
+destructor was invoked for a complete object. — *end note*]
 The subobjects are destroyed in the reverse order of the completion of
 their construction. Such destruction is sequenced before entering a
 handler of the *function-try-block* of the constructor or destructor, if
 any.
 constructor for an object exits via an exception, the object’s
 destructor is invoked. Such destruction is sequenced before entering a
 handler of the *function-try-block* of a delegating constructor for that
 object, if any.
+[*Note 4*: If the object was allocated by a *new-expression*
 [[expr.new]], the matching deallocation function
 [[basic.stc.dynamic.deallocation]], if any, is called to free the
 storage occupied by the object. — *end note*]
 ## Handling an exception <a id="except.handle">[[except.handle]]</a>
 The *exception-declaration* in a *handler* describes the type(s) of
 exceptions that can cause that *handler* to be entered. The
 *exception-declaration* shall not denote an incomplete type, an abstract
 class type, or an rvalue reference type. The *exception-declaration*
 shall not denote a pointer or reference to an incomplete type, other
+than “pointer to cv `void`”.
 A handler of type “array of `T`” or function type `T` is adjusted to be
 of type “pointer to `T`”.
 A *handler* is a match for an exception object of type `E` if
 The exception with the most recently activated handler that is still
 active is called the *currently handled exception*.
 If no matching handler is found, the function `std::terminate` is
+invoked; whether or not the stack is unwound before this invocation of
 `std::terminate` is *implementation-defined* [[except.terminate]].
 Referring to any non-static member or base class of an object in the
 handler for a *function-try-block* of a constructor or destructor for
 that object results in undefined behavior.
 Exceptions thrown in destructors of objects with static storage duration
+or in constructors of objects associated with non-block variables with
+static storage duration are not caught by a *function-try-block* on the
+`main` function [[basic.start.main]]. Exceptions thrown in destructors
+of objects with thread storage duration or in constructors of objects
+associated with non-block variables with thread storage duration are not
+caught by a *function-try-block* on the initial function of the thread.
 If a `return` statement [[stmt.return]] appears in a handler of the
 *function-try-block* of a constructor, the program is ill-formed.
 The currently handled exception is rethrown if control reaches the end
 The variable declared by the *exception-declaration*, of type cv `T` or
 cv `T&`, is initialized from the exception object, of type `E`, as
 follows:
 - if `T` is a base class of `E`, the variable is copy-initialized
+  [[dcl.init]] from an lvalue of type `T` designating the corresponding
+ base class subobject of the exception object;
+- otherwise, the variable is copy-initialized [[dcl.init]] from an
+ lvalue of type `E` designating the exception object.
 The lifetime of the variable ends when the handler exits, after the
 destruction of any objects with automatic storage duration initialized
 within the handler.
 implicitly, or defined explicitly by using a *noexcept-specifier* as a
 suffix of a function declarator [[dcl.fct]].
 ``` bnf
 noexcept-specifier:
+    noexcept '(' constant-expression ')'
+    noexcept
 ```
 In a *noexcept-specifier*, the *constant-expression*, if supplied, shall
 be a contextually converted constant expression of type `bool`
 [[expr.const]]; that constant expression is the exception specification
 token that follows `noexcept` is part of the *noexcept-specifier* and
 does not commence an initializer [[dcl.init]]. The *noexcept-specifier*
 `noexcept` without a *constant-expression* is equivalent to the
 *noexcept-specifier* `noexcept(true)`.
+[*Example 1*:
+``` cpp
+void f() noexcept(sizeof(char[2])); // error: narrowing conversion of value 2 to type bool
+void g() noexcept(sizeof(char));    // OK, conversion of value 1 to type bool is non-narrowing
+```
+— *end example*]
 If a declaration of a function does not have a *noexcept-specifier*, the
 declaration has a potentially throwing exception specification unless it
 is a destructor or a deallocation function or is defaulted on its first
 declaration, in which cases the exception specification is as specified
 below and no other declaration for that function shall have a
 *noexcept-specifier*. In an explicit instantiation [[temp.explicit]] a
 *noexcept-specifier* may be specified, but is not required. If a
+*noexcept-specifier* is specified in an explicit instantiation, the
+exception specification shall be the same as the exception specification
+of all other declarations of that function. A diagnostic is required
+only if the exception specifications are not the same within a single
+translation unit.
 If a virtual function has a non-throwing exception specification, all
 declarations, including the definition, of any function that overrides
 that virtual function in any derived class shall have a non-throwing
 exception specification, unless the overriding function is defined as
 deleted.
+[*Example 2*:
 ``` cpp
 struct B {
   virtual void f() noexcept;
   virtual void g();
 — *end example*]
 Whenever an exception is thrown and the search for a handler
 [[except.handle]] encounters the outermost block of a function with a
 non-throwing exception specification, the function `std::terminate` is
+invoked [[except.terminate]].
 [*Note 1*: An implementation is not permitted to reject an expression
 merely because, when executed, it throws or might throw an exception
 from a function with a non-throwing exception
 specification. — *end note*]
+[*Example 3*:
 ``` cpp
 extern void f();                // potentially-throwing
 void g() noexcept {
   f();                          // valid, even if f throws
   throw 42;                     // valid, effectively a call to std::terminate
 }
 ```
+The call to `f` is well-formed despite the possibility for it to throw
 an exception.
 — *end example*]
 An expression E is *potentially-throwing* if
   function type, or a pointer-to-function type, with a
   potentially-throwing exception specification, or
 - E implicitly invokes a function (such as an overloaded operator, an
   allocation function in a *new-expression*, a constructor for a
   function argument, or a destructor if E is a full-expression
+  [[intro.execution]]) that has a potentially-throwing exception
+  specification, or
 - E is a *throw-expression* [[expr.throw]], or
 - E is a `dynamic_cast` expression that casts to a reference type and
   requires a runtime check [[expr.dynamic.cast]], or
 - E is a `typeid` expression applied to a (possibly parenthesized)
   built-in unary `*` operator applied to a pointer to a polymorphic
 An implicitly-declared constructor for a class `X`, or a constructor
 without a *noexcept-specifier* that is defaulted on its first
 declaration, has a potentially-throwing exception specification if and
 only if any of the following constructs is potentially-throwing:
+- the invocation of a constructor selected by overload resolution in the
+ implicit definition of the constructor for class `X` to initialize a
   potentially constructed subobject, or
 - a subexpression of such an initialization, such as a default argument
   expression, or,
 - for a default constructor, a default member initializer.
 [*Note 2*: Even though destructors for fully-constructed subobjects are
 invoked when an exception is thrown during the execution of a
 constructor [[except.ctor]], their exception specifications do not
 contribute to the exception specification of the constructor, because an
 exception thrown from such a destructor would call the function
+`std::terminate` rather than escape the constructor
+[[except.throw]], [[except.terminate]]. — *end note*]
 The exception specification for an implicitly-declared destructor, or a
 destructor without a *noexcept-specifier*, is potentially-throwing if
 and only if any of the destructors for any of its potentially
+constructed subobjects has a potentially-throwing exception
+specification or the destructor is virtual and the destructor of any
+virtual base class has a potentially-throwing exception specification.
 The exception specification for an implicitly-declared assignment
 operator, or an assignment-operator without a *noexcept-specifier* that
 is defaulted on its first declaration, is potentially-throwing if and
 only if the invocation of any assignment operator in the implicit
 The exception specification for a comparison operator function
 [[over.binary]] without a *noexcept-specifier* that is defaulted on its
 first declaration is potentially-throwing if and only if any expression
 in the implicit definition is potentially-throwing.
+[*Example 4*:
 ``` cpp
 struct A {
   A(int = (A(5), 0)) noexcept;
   A(const A&) noexcept;
 — *end example*]
 An exception specification is considered to be *needed* when:
+- in an expression, the function is selected by overload resolution
+  [[over.match]], [[over.over]];
+- the function is odr-used [[term.odr.use]] or, if it appears in an
   unevaluated operand, would be odr-used if the expression were
   potentially-evaluated;
 - the exception specification is compared to that of another declaration
   (e.g., an explicit specialization or an overriding virtual function);
 - the function is defined; or
 a specialization of a function template or member function of a class
 template is instantiated only when needed.
 ## Special functions <a id="except.special">[[except.special]]</a>
+### General <a id="except.special.general">[[except.special.general]]</a>
 The function `std::terminate` [[except.terminate]] is used by the
 exception handling mechanism for coping with errors related to the
 exception handling mechanism itself. The function
 `std::current_exception()` [[propagation]] and the class
 `std::nested_exception` [[except.nested]] can be used by a program to
 capture the currently handled exception.
 ### The `std::terminate` function <a id="except.terminate">[[except.terminate]]</a>
+In some situations exception handling is abandoned for less subtle error
+handling techniques.
 [*Note 1*:
 These situations are:
 - when the search for a handler [[except.handle]] encounters the
   outermost block of a function with a non-throwing exception
   specification [[except.spec]], or
 - when the destruction of an object during stack unwinding
   [[except.ctor]] terminates by throwing an exception, or
+- when initialization of a non-block variable with static or thread
   storage duration [[basic.start.dynamic]] exits via an exception, or
 - when destruction of an object with static or thread storage duration
   exits via an exception [[basic.start.term]], or
 - when execution of a function registered with `std::atexit` or
   `std::at_quick_exit` exits via an exception [[support.start.term]], or
 - when the function `std::nested_exception::rethrow_nested` is called
   for an object that has captured no exception [[except.nested]], or
 - when execution of the initial function of a thread exits via an
   exception [[thread.thread.constr]], or
 - for a parallel algorithm whose `ExecutionPolicy` specifies such
+  behavior [[execpol.seq]], [[execpol.par]], [[execpol.parunseq]], when
+  execution of an element access function [[algorithms.parallel.defns]]
+  of the parallel algorithm exits via an exception
+  [[algorithms.parallel.exceptions]], or
 - when the destructor or the move assignment operator is invoked on an
+  object of type `std::thread` that refers to a joinable thread
+  [[thread.thread.destr]], [[thread.thread.assign]], or
 - when a call to a `wait()`, `wait_until()`, or `wait_for()` function on
+  a condition variable
+  [[thread.condition.condvar]], [[thread.condition.condvarany]] fails to
+  meet a postcondition.
 — *end note*]
+In such cases, the function `std::terminate` is invoked
 [[exception.terminate]]. In the situation where no matching handler is
 found, it is *implementation-defined* whether or not the stack is
+unwound before `std::terminate` is invoked. In the situation where the
 search for a handler [[except.handle]] encounters the outermost block of
 a function with a non-throwing exception specification [[except.spec]],
 it is *implementation-defined* whether the stack is unwound, unwound
 partially, or not unwound at all before the function `std::terminate` is
+invoked. In all other situations, the stack shall not be unwound before
+the function `std::terminate` is invoked. An implementation is not
 permitted to finish stack unwinding prematurely based on a determination
+that the unwind process will eventually cause an invocation of the
+function `std::terminate`.
+### The `std::uncaught_exceptions` function <a id="except.uncaught">[[except.uncaught]]</a>
 An exception is considered uncaught after completing the initialization
 of the exception object [[except.throw]] until completing the activation
 of a handler for the exception [[except.handle]].
 [*Note 1*: As a consequence, an exception is considered uncaught during
 any stack unwinding resulting from it being thrown. — *end note*]
+If an exception is rethrown [[expr.throw]], [[propagation]], it is
 considered uncaught from the point of rethrow until the rethrown
+exception is caught. The function `std::uncaught_exceptions`
 [[uncaught.exceptions]] returns the number of uncaught exceptions in the
 current thread.
 <!-- Link reference definitions -->
 [algorithms.parallel.defns]: algorithms.md#algorithms.parallel.defns
 [algorithms.parallel.exceptions]: algorithms.md#algorithms.parallel.exceptions
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [class.abstract]: class.md#class.abstract
+[class.base.init]: class.md#class.base.init
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.copy.elision]: class.md#class.copy.elision
 [class.dtor]: class.md#class.dtor
+[class.inhctor.init]: class.md#class.inhctor.init
 [conv.fctptr]: expr.md#conv.fctptr
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.init]: dcl.md#dcl.init
+[dcl.init.aggr]: dcl.md#dcl.init.aggr
+[dcl.init.general]: dcl.md#dcl.init.general
 [except]: #except
 [except.ctor]: #except.ctor
 [except.handle]: #except.handle
 [except.nested]: support.md#except.nested
 [except.pre]: #except.pre
 [except.spec]: #except.spec
 [except.special]: #except.special
+[except.special.general]: #except.special.general
 [except.terminate]: #except.terminate
 [except.throw]: #except.throw
 [except.uncaught]: #except.uncaught
 [exception.terminate]: support.md#exception.terminate
 [execpol.par]: utilities.md#execpol.par
 [execpol.seq]: utilities.md#execpol.seq
 [expr.call]: expr.md#expr.call
 [expr.const]: expr.md#expr.const
 [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 [expr.new]: expr.md#expr.new
+[expr.prim.lambda.capture]: expr.md#expr.prim.lambda.capture
 [expr.throw]: expr.md#expr.throw
 [expr.typeid]: expr.md#expr.typeid
 [futures]: thread.md#futures
 [intro.execution]: basic.md#intro.execution
 [intro.races]: basic.md#intro.races
 [over.binary]: over.md#over.binary
 [over.match]: over.md#over.match
 [over.over]: over.md#over.over
 [propagation]: support.md#propagation
 [stmt.jump]: stmt.md#stmt.jump
+[stmt.label]: stmt.md#stmt.label
 [stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [structure.specifications]: library.md#structure.specifications
 [support.start.term]: support.md#support.start.term
 [temp.explicit]: temp.md#temp.explicit
+[term.odr.use]: basic.md#term.odr.use
 [thread.condition.condvar]: thread.md#thread.condition.condvar
 [thread.condition.condvarany]: thread.md#thread.condition.condvarany
 [thread.thread.assign]: thread.md#thread.thread.assign
 [thread.thread.constr]: thread.md#thread.thread.constr
 [thread.thread.destr]: thread.md#thread.thread.destr

Diff to HTML by rtfpessoa