[intro.execution] - C++11 → C++14

Files changed (1) hide show

tmp/tmp2wl2_m81/{from.md → to.md} +22 -20

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

@@ -16,11 +16,12 @@ characteristics and behavior in these respects.[^6] Such documentation
 shall define the instance of the abstract machine that corresponds to
 that implementation (referred to as the “corresponding instance” below).
 Certain other aspects and operations of the abstract machine are
 described in this International Standard as unspecified (for example,
-order of evaluation of arguments to a function). Where possible, this
 International Standard defines a set of allowable behaviors. These
 define the nondeterministic aspects of the abstract machine. An instance
 of the abstract machine can thus have more than one possible execution
 for a given program and a given input.
@@ -35,19 +36,15 @@ of the corresponding instance of the abstract machine with the same
 program and the same input. However, if any such execution contains an
 undefined operation, this International Standard places no requirement
 on the implementation executing that program with that input (not even
 with regard to operations preceding the first undefined operation).
-When the processing of the abstract machine is interrupted by receipt of
-a signal, the values of objects which are neither
-- of type `volatile std::sig_atomic_t` nor
-- lock-free atomic objects ([[atomics.lockfree]])
-are unspecified during the execution of the signal handler, and the
-value of any object not in either of these two categories that is
-modified by the handler becomes undefined.
 An instance of each object with automatic storage duration (
 [[basic.stc.auto]]) is associated with each entry into its block. Such
 an object exists and retains its last-stored value during the execution
 of the block and while the block is suspended (by a call of a function
@@ -115,18 +112,20 @@ or -17 and 12. However on a machine in which overflows do not produce an
 exception and in which the results of overflows are reversible, the
 above expression statement can be rewritten by the implementation in any
 of the above ways because the same result will occur.
 A *full-expression* is an expression that is not a subexpression of
-another expression. If a language construct is defined to produce an
-implicit call of a function, a use of the language construct is
-considered to be an expression for the purposes of this definition. A
-call to a destructor generated at the end of the lifetime of an object
-other than a temporary object is an implicit full-expression.
-Conversions applied to the result of an expression in order to satisfy
-the requirements of the language construct in which the expression
-appears are also considered to be part of the full-expression.
 ``` cpp
 struct S {
   S(int i): I(i) { }
   int& v() { return I; }
@@ -177,22 +176,25 @@ sequenced* when either *A* is sequenced before *B* or *B* is sequenced
 before *A*, but it is unspecified which. Indeterminately sequenced
 evaluations cannot overlap, but either could be executed first.
 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.[^8].
 Except where noted, evaluations of operands of individual operators and
 of subexpressions of individual expressions are unsequenced. In an
 expression that is evaluated more than once during the execution of a
 program, unsequenced and indeterminately sequenced evaluations of its
 subexpressions need not be performed consistently in different
 evaluations. The value computations of the operands of an operator are
 sequenced before the value computation of the result of the operator. If
 a side effect on a scalar object is unsequenced relative to either
 another side effect on the same scalar object or a value computation
-using the value of the same scalar object, the behavior is undefined.
 ``` cpp
 void f(int, int);
 void g(int i, int* v) {
   i = v[i++];         // the behavior is undefined

 shall define the instance of the abstract machine that corresponds to
 that implementation (referred to as the “corresponding instance” below).
 Certain other aspects and operations of the abstract machine are
 described in this International Standard as unspecified (for example,
+evaluation of expressions in a *new-initializer* if the allocation
+function fails to allocate memory ([[expr.new]])). Where possible, this
 International Standard defines a set of allowable behaviors. These
 define the nondeterministic aspects of the abstract machine. An instance
 of the abstract machine can thus have more than one possible execution
 for a given program and a given input.
 program and the same input. However, if any such execution contains an
 undefined operation, this International Standard places no requirement
 on the implementation executing that program with that input (not even
 with regard to operations preceding the first undefined operation).
+If a signal handler is executed as a result of a call to the `raise`
+function, then the execution of the handler is sequenced after the
+invocation of the `raise` function and before its return. 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.
 An instance of each object with automatic storage duration (
 [[basic.stc.auto]]) is associated with each entry into its block. Such
 an object exists and retains its last-stored value during the execution
 of the block and while the block is suspended (by a call of a function
 exception and in which the results of overflows are reversible, the
 above expression statement can be rewritten by the implementation in any
 of the above ways because the same result will occur.
 A *full-expression* is an expression that is not a subexpression of
+another expression. in some contexts, such as unevaluated operands, a
+syntactic subexpression is considered a full-expression (Clause
+[[expr]]). If a language construct is defined to produce an implicit
+call of a function, a use of the language construct is considered to be
+an expression for the purposes of this definition. A call to a
+destructor generated at the end of the lifetime of an object other than
+a temporary object is an implicit full-expression. Conversions applied
+to the result of an expression in order to satisfy the requirements of
+the language construct in which the expression appears are also
+considered to be part of the full-expression.
 ``` cpp
 struct S {
   S(int i): I(i) { }
   int& v() { return I; }
 before *A*, but it is unspecified which. Indeterminately sequenced
 evaluations cannot overlap, but either could be executed first.
 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.[^8]
 Except where noted, evaluations of operands of individual operators and
 of subexpressions of individual expressions are unsequenced. In an
 expression that is evaluated more than once during the execution of a
 program, unsequenced and indeterminately sequenced evaluations of its
 subexpressions need not be performed consistently in different
 evaluations. The value computations of the operands of an operator are
 sequenced before the value computation of the result of the operator. If
 a side effect on a scalar object is unsequenced relative to either
 another side effect on the same scalar object or a value computation
+using the value of the same scalar object, and they are not potentially
+concurrent ([[intro.multithread]]), the behavior is undefined. The next
+section imposes similar, but more complex restrictions on potentially
+concurrent computations.
 ``` cpp
 void f(int, int);
 void g(int i, int* v) {
   i = v[i++];         // the behavior is undefined

Diff to HTML by rtfpessoa