[cpp.cond] - C++20 → C++23

Files changed (1) hide show

tmp/tmptagp4fp8/{from.md → to.md} +21 -31

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

@@ -34,12 +34,13 @@ has-attribute-expression:
     '__has_cpp_attribute (' pp-tokens ')'
 ```
 The expression that controls conditional inclusion shall be an integral
 constant expression except that identifiers (including those lexically
-identical to keywords) are interpreted as described below[^2] and it may
-contain zero or more *defined-macro-expression*s and/or
 *has-include-expression*s and/or *has-attribute-expression*s as unary
 operator expressions.
 A *defined-macro-expression* evaluates to `1` if the identifier is
 currently defined as a macro name (that is, if it is predefined or if it
@@ -78,10 +79,11 @@ detected by any non-zero result. — *end note*]
 **Table: __has_cpp_attribute values** <a id="cpp.cond.ha">[cpp.cond.ha]</a>
 | Attribute            | Value     |
 | -------------------- | --------- |
 | `carries_dependency` | `200809L` |
 | `deprecated`         | `201309L` |
 | `fallthrough`        | `201603L` |
 | `likely`             | `201803L` |
 | `maybe_unused`       | `201603L` |
@@ -89,15 +91,15 @@ detected by any non-zero result. — *end note*]
 | `nodiscard`          | `201907L` |
 | `noreturn`           | `200809L` |
 | `unlikely`           | `201803L` |
-The `#ifdef` and `#ifndef` directives, and the `defined` conditional
-inclusion operator, shall treat `__has_include` and
-`__has_cpp_attribute` as if they were the names of defined macros. The
-identifiers `__has_include` and `__has_cpp_attribute` shall not appear
-in any context not mentioned in this subclause.
 Each preprocessing token that remains (in the list of preprocessing
 tokens that will become the controlling expression) after all macro
 replacements have occurred shall be in the lexical form of a token
 [[lex.token]].
@@ -133,53 +135,41 @@ Therefore it is not subject to this replacement. — *end note*]
 The resulting tokens comprise the controlling constant expression which
 is evaluated according to the rules of  [[expr.const]] using arithmetic
 that has at least the ranges specified in  [[support.limits]]. For the
 purposes of this token conversion and evaluation all signed and unsigned
 integer types act as if they have the same representation as,
-respectively, `intmax_t` or `uintmax_t` [[cstdint]].
 [*Note 3*: Thus on an implementation where
 `std::numeric_limits<int>::max()` is `0x7FFF` and
 `std::numeric_limits<unsigned int>::max()` is `0xFFFF`, the integer
 literal `0x8000` is signed and positive within a `#if` expression even
 though it is unsigned in translation phase 7
 [[lex.phases]]. — *end note*]
-This includes interpreting *character-literal*s, which may involve
-converting escape sequences into execution character set members.
-Whether the numeric value for these *character-literal*s matches the
-value obtained when an identical *character-literal* occurs in an
-expression (other than within a `#if` or `#elif` directive) is
-*implementation-defined*.
-[*Note 4*:
-Thus, the constant expression in the following `#if` directive and `if`
-statement [[stmt.if]] is not guaranteed to evaluate to the same value in
-these two contexts:
-``` cpp
-#if 'z' - 'a' == 25
-if ('z' - 'a' == 25)
-```
-— *end note*]
-Also, whether a single-character *character-literal* may have a negative
-value is *implementation-defined*. Each subexpression with type `bool`
-is subjected to integral promotion before processing continues.
 Preprocessing directives of the forms
 ``` bnf
 '# ifdef ' identifier new-line groupₒₚₜ
 '# ifndef ' identifier new-line groupₒₚₜ
 ```
 check whether the identifier is or is not currently defined as a macro
-name. Their conditions are equivalent to `#if` `defined` *identifier*
-and `#if` `!defined` *identifier* respectively.
 Each directive’s condition is checked in order. If it evaluates to false
 (zero), the group that it controls is skipped: directives are processed
 only through the name that determines the directive in order to keep
 track of the level of nested conditionals; the rest of the directives’

     '__has_cpp_attribute (' pp-tokens ')'
 ```
 The expression that controls conditional inclusion shall be an integral
 constant expression except that identifiers (including those lexically
+identical to keywords) are interpreted as described below[^2]
+and it may contain zero or more *defined-macro-expression*s and/or
 *has-include-expression*s and/or *has-attribute-expression*s as unary
 operator expressions.
 A *defined-macro-expression* evaluates to `1` if the identifier is
 currently defined as a macro name (that is, if it is predefined or if it
 **Table: __has_cpp_attribute values** <a id="cpp.cond.ha">[cpp.cond.ha]</a>
 | Attribute            | Value     |
 | -------------------- | --------- |
+| `assume`             | `202207L` |
 | `carries_dependency` | `200809L` |
 | `deprecated`         | `201309L` |
 | `fallthrough`        | `201603L` |
 | `likely`             | `201803L` |
 | `maybe_unused`       | `201603L` |
 | `nodiscard`          | `201907L` |
 | `noreturn`           | `200809L` |
 | `unlikely`           | `201803L` |
+The `#ifdef`, `#ifndef`, `#elifdef`, and `#elifndef` directives, and the
+`defined` conditional inclusion operator, shall treat `__has_include`
+and `__has_cpp_attribute` as if they were the names of defined macros.
+The identifiers `__has_include` and `__has_cpp_attribute` shall not
+appear in any context not mentioned in this subclause.
 Each preprocessing token that remains (in the list of preprocessing
 tokens that will become the controlling expression) after all macro
 replacements have occurred shall be in the lexical form of a token
 [[lex.token]].
 The resulting tokens comprise the controlling constant expression which
 is evaluated according to the rules of  [[expr.const]] using arithmetic
 that has at least the ranges specified in  [[support.limits]]. For the
 purposes of this token conversion and evaluation all signed and unsigned
 integer types act as if they have the same representation as,
+respectively, `intmax_t` or `uintmax_t` [[cstdint.syn]].
 [*Note 3*: Thus on an implementation where
 `std::numeric_limits<int>::max()` is `0x7FFF` and
 `std::numeric_limits<unsigned int>::max()` is `0xFFFF`, the integer
 literal `0x8000` is signed and positive within a `#if` expression even
 though it is unsigned in translation phase 7
 [[lex.phases]]. — *end note*]
+This includes interpreting *character-literal*s according to the rules
+in [[lex.ccon]].
+[*Note 4*: The associated character encodings of literals are the same
+in `#if` and `#elif` directives and in any expression. — *end note*]
+Each subexpression with type `bool` is subjected to integral promotion
+before processing continues.
 Preprocessing directives of the forms
 ``` bnf
 '# ifdef ' identifier new-line groupₒₚₜ
 '# ifndef ' identifier new-line groupₒₚₜ
+'# elifdef ' identifier new-line groupₒₚₜ
+'# elifndef' identifier new-line groupₒₚₜ
 ```
 check whether the identifier is or is not currently defined as a macro
+name. Their conditions are equivalent to `#if` `defined` *identifier*,
+`#if` `!defined` *identifier*, `#elif` `defined` *identifier*, and
+`#elif` `!defined` *identifier*, respectively.
 Each directive’s condition is checked in order. If it evaluates to false
 (zero), the group that it controls is skipped: directives are processed
 only through the name that determines the directive in order to keep
 track of the level of nested conditionals; the rest of the directives’

Diff to HTML by rtfpessoa