[intro.execution] - C++20 → C++23

Files changed (1) hide show

tmp/tmp084ofjv0/{from.md → to.md} +26 -16

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

@@ -7,10 +7,12 @@ the block and while the block is suspended (by a call of a function,
 suspension of a coroutine [[expr.await]], or receipt of a signal).
 A *constituent expression* is defined as follows:
 - The constituent expression of an expression is that expression.
 - The constituent expressions of a *braced-init-list* or of a (possibly
   parenthesized) *expression-list* are the constituent expressions of
   the elements of the respective list.
 - The constituent expressions of a *brace-or-equal-initializer* of the
   form `=` *initializer-clause* are the constituent expressions of the
@@ -48,13 +50,20 @@ or a subexpression of an immediate subexpression of E.
 [*Note 1*: Expressions appearing in the *compound-statement* of a
 *lambda-expression* are not subexpressions of the
 *lambda-expression*. — *end note*]
 A *full-expression* is
-- an unevaluated operand [[expr.prop]],
 - a *constant-expression* [[expr.const]],
 - an immediate invocation [[expr.const]],
 - an *init-declarator* [[dcl.decl]] or a *mem-initializer*
   [[class.base.init]], including the constituent expressions of the
   initializer,
@@ -138,20 +147,20 @@ overlap. — *end note*]
 Evaluations *A* and *B* are *indeterminately sequenced* when either *A*
 is sequenced before *B* or *B* is sequenced before *A*, but it is
 unspecified which.
 [*Note 4*: Indeterminately sequenced evaluations cannot overlap, but
-either could be executed first. — *end note*]
 An expression *X* is said to be sequenced before an expression *Y* if
 every value computation and every side effect associated with the
 expression *X* is sequenced before every value computation and every
 side effect associated with the expression *Y*.
 Every value computation and side effect associated with a
 full-expression is sequenced before every value computation and side
-effect associated with the next full-expression to be evaluated.[^26]
 Except where noted, evaluations of operands of individual operators and
 of subexpressions of individual expressions are unsequenced.
 [*Note 5*: In an expression that is evaluated more than once during the
@@ -182,22 +191,23 @@ void g(int i) {
 }
 ```
 — *end example*]
-When calling a function (whether or not the function is inline), every
-value computation and side effect associated with any argument
-expression, or with the postfix expression designating the called
-function, is sequenced before execution of every expression or statement
-in the body of the called function. For each function invocation *F*,
-for every evaluation *A* that occurs within *F* and every evaluation *B*
-that does not occur within *F* but is evaluated on the same thread and
-as part of the same signal handler (if any), either *A* is sequenced
-before *B* or *B* is sequenced before *A*.[^27]
-[*Note 7*: If *A* and *B* would not otherwise be sequenced then they
-are indeterminately sequenced. — *end note*]
 Several contexts in C++ cause evaluation of a function call, even though
 no corresponding function call syntax appears in the translation unit.
 [*Example 4*: Evaluation of a *new-expression* invokes one or more
@@ -206,15 +216,15 @@ example, invocation of a conversion function [[class.conv.fct]] can
 arise in contexts in which no function call syntax
 appears. — *end example*]
 The sequencing constraints on the execution of the called function (as
 described above) are features of the function calls as evaluated,
-whatever the syntax of the expression that calls the function might be.
 If a signal handler is executed as a result of a call to the
 `std::raise` function, then the execution of the handler is sequenced
 after the invocation of the `std::raise` function and before its return.
-[*Note 8*: When a signal is received for another reason, the execution
 of the signal handler is usually unsequenced with respect to the rest of
 the program. — *end note*]

 suspension of a coroutine [[expr.await]], or receipt of a signal).
 A *constituent expression* is defined as follows:
 - The constituent expression of an expression is that expression.
+- The constituent expression of a conversion is the corresponding
+  implicit function call, if any, or the converted expression otherwise.
 - The constituent expressions of a *braced-init-list* or of a (possibly
   parenthesized) *expression-list* are the constituent expressions of
   the elements of the respective list.
 - The constituent expressions of a *brace-or-equal-initializer* of the
   form `=` *initializer-clause* are the constituent expressions of the
 [*Note 1*: Expressions appearing in the *compound-statement* of a
 *lambda-expression* are not subexpressions of the
 *lambda-expression*. — *end note*]
+The *potentially-evaluated subexpressions* of an expression, conversion,
+or *initializer* E are
+- the constituent expressions of E and
+- the subexpressions thereof that are not subexpressions of a nested
+  unevaluated operand [[term.unevaluated.operand]].
 A *full-expression* is
+- an unevaluated operand [[expr.context]],
 - a *constant-expression* [[expr.const]],
 - an immediate invocation [[expr.const]],
 - an *init-declarator* [[dcl.decl]] or a *mem-initializer*
   [[class.base.init]], including the constituent expressions of the
   initializer,
 Evaluations *A* and *B* are *indeterminately sequenced* when either *A*
 is sequenced before *B* or *B* is sequenced before *A*, but it is
 unspecified which.
 [*Note 4*: Indeterminately sequenced evaluations cannot overlap, but
+either can be executed first. — *end note*]
 An expression *X* is said to be sequenced before an expression *Y* if
 every value computation and every side effect associated with the
 expression *X* is sequenced before every value computation and every
 side effect associated with the expression *Y*.
 Every value computation and side effect associated with a
 full-expression is sequenced before every value computation and side
+effect associated with the next full-expression to be evaluated.[^22]
 Except where noted, evaluations of operands of individual operators and
 of subexpressions of individual expressions are unsequenced.
 [*Note 5*: In an expression that is evaluated more than once during the
 }
 ```
 — *end example*]
+When invoking a function (whether or not the function is inline), every
+argument expression and the postfix expression designating the called
+function are sequenced before every expression or statement in the body
+of the called function. For each function invocation or evaluation of an
+*await-expression* *F*, each evaluation that does not occur within *F*
+but is evaluated on the same thread and as part of the same signal
+handler (if any) is either sequenced before all evaluations that occur
+within *F* or sequenced after all evaluations that occur within
+*F*;[^23]
+if *F* invokes or resumes a coroutine [[expr.await]], only evaluations
+subsequent to the previous suspension (if any) and prior to the next
+suspension (if any) are considered to occur within *F*.
 Several contexts in C++ cause evaluation of a function call, even though
 no corresponding function call syntax appears in the translation unit.
 [*Example 4*: Evaluation of a *new-expression* invokes one or more
 arise in contexts in which no function call syntax
 appears. — *end example*]
 The sequencing constraints on the execution of the called function (as
 described above) are features of the function calls as evaluated,
+regardless of the syntax of the expression that calls the function.
 If a signal handler is executed as a result of a call to the
 `std::raise` function, then the execution of the handler is sequenced
 after the invocation of the `std::raise` function and before its return.
+[*Note 7*: When a signal is received for another reason, the execution
 of the signal handler is usually unsequenced with respect to the rest of
 the program. — *end note*]

Diff to HTML by rtfpessoa