[cpp.cond] - C++14 → C++17

Files changed (1) hide show

tmp/tmpx91eaxrv/{from.md → to.md} +123 -35

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

@@ -1,26 +1,61 @@
 ## Conditional inclusion <a id="cpp.cond">[[cpp.cond]]</a>
 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 unary operator expressions of the form
-``` bnf
-'defined' identifier
-```
-or
-``` bnf
-'defined (' identifier ')'
-```
-which evaluate to `1` if the identifier is currently defined as a macro
-name (that is, if it is predefined or if it has been the subject of a
-`#define` preprocessing directive without an intervening `#undef`
-directive with the same subject identifier), `0` if it is not.
 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]]).
@@ -33,29 +68,60 @@ Prior to evaluation, macro invocations in the list of preprocessing
 tokens that will become the controlling constant expression are replaced
 (except for those macro names modified by the `defined` unary operator),
 just as in normal text. If the token `defined` is generated as a result
 of this replacement process or use of the `defined` unary operator does
 not match one of the two specified forms prior to macro replacement, the
-behavior is undefined. After all replacements due to macro expansion and
-the `defined` unary operator have been performed, all remaining
-identifiers and keywords[^3], except for `true` and `false`, are
-replaced with the pp-number `0`, and then each preprocessing token is
-converted into a 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]]).[^4] This includes interpreting character literals, which
-may involve converting escape sequences into execution character set
-members. Whether the numeric value for these character literals matches
-the value obtained when an identical character literal occurs in an
-expression (other than within a `#if` or `#elif` directive) is
-*implementation-defined*.[^5] 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
 check whether the identifier is or is not currently defined as a macro
 name. Their conditions are equivalent to `#if` `defined` *identifier*
@@ -65,10 +131,32 @@ 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’
 preprocessing tokens are ignored, as are the other preprocessing tokens
 in the group. Only the first group whose control condition evaluates to
-true (nonzero) is processed. If none of the conditions evaluates to
-true, and there is a `#else` directive, the group controlled by the
-`#else` is processed; lacking a `#else` directive, all the groups until
-the `#endif` are skipped.[^6]

 ## Conditional inclusion <a id="cpp.cond">[[cpp.cond]]</a>
+``` bnf
+defined-macro-expression:
+    'defined' identifier
+    'defined (' identifier ')'
+```
+``` bnf
+h-preprocessing-token:
+    any *preprocessing-token* other than '>'
+```
+``` bnf
+h-pp-tokens:
+    h-preprocessing-token
+    h-pp-tokens h-preprocessing-token
+```
+``` bnf
+has-include-expression:
+    '__has_include ( <' h-char-sequence '> )'
+    '__has_include ( "' q-char-sequence '" )'
+    '__has_include (' string-literal ')'
+    '__has_include ( <' h-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 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
+has been the subject of a `#define` preprocessing directive without an
+intervening `#undef` directive with the same subject identifier), `0` if
+it is not.
+The third and fourth forms of *has-include-expression* are considered
+only if neither of the first or second forms matches, in which case the
+preprocessing tokens are processed just as in normal text.
+The header or source file identified by the parenthesized preprocessing
+token sequence in each contained *has-include-expression* is searched
+for as if that preprocessing token sequence were the *pp-tokens* in a
+`#include` directive, except that no further macro expansion is
+performed. If such a directive would not satisfy the syntactic
+requirements of a `#include` directive, the program is ill-formed. The
+*has-include-expression* evaluates to `1` if the search for the source
+file succeeds, and to `0` if the search fails.
+The `#ifdef` and `#ifndef` directives, and the `defined` conditional
+inclusion operator, shall treat `__has_include` as if it were the name
+of a defined macro. The identifier `__has_include` shall not appear in
+any context not mentioned in this section.
 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]]).
 tokens that will become the controlling constant expression are replaced
 (except for those macro names modified by the `defined` unary operator),
 just as in normal text. If the token `defined` is generated as a result
 of this replacement process or use of the `defined` unary operator does
 not match one of the two specified forms prior to macro replacement, the
+behavior is undefined.
+After all replacements due to macro expansion and evaluations of
+*defined-macro-expression*s and *has-include-expression*s have been
+performed, all remaining identifiers and keywords, except for `true` and
+`false`, are replaced with the *pp-number* `0`, and then each
+preprocessing token is converted into a token.
+[*Note 1*: An alternative token ([[lex.digraph]]) is not an
+identifier, even when its spelling consists entirely of letters and
+underscores. 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 2*: 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 literals, which may involve
+converting escape sequences into execution character set members.
+Whether the numeric value for these character literals 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 3*:
+Thus, the constant expression in the following `#if` directive and `if`
+statement 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
 check whether the identifier is or is not currently defined as a macro
 name. Their conditions are equivalent to `#if` `defined` *identifier*
 (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’
 preprocessing tokens are ignored, as are the other preprocessing tokens
 in the group. Only the first group whose control condition evaluates to
+true (nonzero) is processed; any following groups are skipped and their
+controlling directives are processed as if they were in a group that is
+skipped. If none of the conditions evaluates to true, and there is a
+`#else` directive, the group controlled by the `#else` is processed;
+lacking a `#else` directive, all the groups until the `#endif` are
+skipped.[^3]
+[*Example 1*:
+This demonstrates a way to include a library `optional` facility only if
+it is available:
+``` cpp
+#if __has_include(<optional>)
+#  include <optional>
+#  define have_optional 1
+#elif __has_include(<experimental/optional>)
+#  include <experimental/optional>
+#  define have_optional 1
+#  define experimental_optional 1
+#else
+#  define have_optional 0
+#endif
+```
+— *end example*]

Diff to HTML by rtfpessoa