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

Files changed (1) hide show

tmp/tmpn375wp97/{from.md → to.md} +233 -95

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

@@ -22,14 +22,14 @@ group:
     group group-part
 ```
 ``` bnf
 group-part:
-    if-section
     control-line
     text-line
-    '#' non-directive
 ```
 ``` bnf
 if-section:
     if-group elif-groupsₒₚₜ else-groupₒₚₜ endif-line
@@ -45,11 +45,11 @@ elif-groups:
 text-line:
     pp-tokensₒₚₜ new-line
 ```
 ``` bnf
-non-directive:
     pp-tokens new-line
 ```
 ``` bnf
 lparen:
@@ -77,12 +77,14 @@ pp-tokens:
 new-line:
     the new-line character
 ```
 A text line shall not begin with a `#` preprocessing token. A
-non-directive shall not begin with any of the directive names appearing
-in the syntax.
 When in a group that is skipped ([[cpp.cond]]), the directive syntax is
 relaxed to allow any sequence of preprocessing tokens to occur between
 the directive name and the following new-line character.
@@ -99,43 +101,82 @@ capabilities are called *preprocessing*, because conceptually they occur
 before translation of the resulting translation unit.
 The preprocessing tokens within a preprocessing directive are not
 subject to macro expansion unless otherwise stated.
 In:
 ``` cpp
 #define EMPTY
 EMPTY   #   include <file.h>
 ```
 the sequence of preprocessing tokens on the second line is *not* a
-preprocessing directive, because it does not begin with a \# at the
 start of translation phase 4, even though it will do so after the macro
 `EMPTY` has been replaced.
 ## 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]]).
@@ -148,29 +189,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*
@@ -180,14 +252,36 @@ 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]
 ## Source file inclusion <a id="cpp.include">[[cpp.include]]</a>
 A `#include` directive shall identify a header or source file that can
 be processed by the implementation.
@@ -232,11 +326,11 @@ A preprocessing directive of the form
 (that does not match one of the two previous forms) is permitted. The
 preprocessing tokens after `include` in the directive are processed just
 as in normal text (i.e., each identifier currently defined as a macro
 name is replaced by its replacement list of preprocessing tokens). If
 the directive resulting after all replacements does not match one of the
-two previous forms, the behavior is undefined.[^7] The method by which a
 sequence of preprocessing tokens between a `<` and a `>` preprocessing
 token pair or a pair of `"` characters is combined into a single header
 name preprocessing token is *implementation-defined*.
 The implementation shall provide unique mappings for sequences
@@ -247,10 +341,12 @@ alphabetical case.
 A `#include` preprocessing directive may appear in a source file that
 has been read because of a `#include` directive in another file, up to
 an *implementation-defined* nesting limit.
 Although an implementation may provide a mechanism for making arbitrary
 source files available to the `< >` search, in general programmers
 should use the `< >` form for headers provided with the implementation,
 and the `" "` form for sources outside the control of the
 implementation. For instance:
@@ -260,10 +356,14 @@ implementation. For instance:
 #include <unistd.h>
 #include "usefullib.h"
 #include "myprog.h"
 ```
 This illustrates macro-replaced `#include` directives:
 ``` cpp
 #if VERSION == 1
     #define INCFILE  "vers1.h"
@@ -273,39 +373,42 @@ This illustrates macro-replaced `#include` directives:
     #define INCFILE  "versN.h"
 #endif
 #include INCFILE
 ```
 ## Macro replacement <a id="cpp.replace">[[cpp.replace]]</a>
 Two replacement lists are identical if and only if the preprocessing
 tokens in both have the same number, ordering, spelling, and white-space
 separation, where all white-space separations are considered identical.
-An identifier currently defined as an *object-like* macro may be
-redefined by another `#define` preprocessing directive provided that the
-second definition is an object-like macro definition and the two
-replacement lists are identical, otherwise the program is ill-formed.
-Likewise, an identifier currently defined as a *function-like* macro may
 be redefined by another `#define` preprocessing directive provided that
-the second definition is a function-like macro definition that has the
-same number and spelling of parameters, and the two replacement lists
-are identical, otherwise the program is ill-formed.
 There shall be white-space between the identifier and the replacement
 list in the definition of an object-like macro.
-If the identifier-list in the macro definition does not end with an
 ellipsis, the number of arguments (including those arguments consisting
 of no preprocessing tokens) in an invocation of a function-like macro
 shall equal the number of parameters in the macro definition. Otherwise,
 there shall be more arguments in the invocation than there are
 parameters in the macro definition (excluding the `...`). There shall
 exist a `)` preprocessing token that terminates the invocation.
-The identifier `__VA_ARGS__` shall occur only in the replacement-list of
-a function-like macro that uses the ellipsis notation in the parameters.
 A parameter identifier in a function-like macro shall be uniquely
 declared within its scope.
 The identifier immediately following the `define` is called the *macro
@@ -323,12 +426,12 @@ A preprocessing directive of the form
 ``` bnf
 '# define' identifier replacement-list new-line
 ```
 defines an *object-like macro* that causes each subsequent instance of
-the macro name[^8] to be replaced by the replacement list of
-preprocessing tokens that constitute the remainder of the directive.[^9]
 The replacement list is then rescanned for more macro names as specified
 below.
 A preprocessing directive of the form
@@ -356,11 +459,11 @@ The sequence of preprocessing tokens bounded by the outside-most
 matching parentheses forms the list of arguments for the function-like
 macro. The individual arguments within the list are separated by comma
 preprocessing tokens, but comma preprocessing tokens between matching
 inner parentheses do not separate arguments. If there are sequences of
 preprocessing tokens within the list of arguments that would otherwise
-act as preprocessing directives,[^10] the behavior is undefined.
 If there is a `...` immediately preceding the `)` in the function-like
 macro definition, then the trailing arguments, including any separating
 comma preprocessing tokens, are merged to form a single item: the
 *variable arguments*. The number of arguments so combined is such that,
@@ -415,11 +518,11 @@ end of a replacement list for either form of macro definition.
 If, in the replacement list of a function-like macro, a parameter is
 immediately preceded or followed by a `##` preprocessing token, the
 parameter is replaced by the corresponding argument’s preprocessing
 token sequence; however, if an argument consists of no preprocessing
 tokens, the parameter is replaced by a placemarker preprocessing token
-instead.[^11]
 For both object-like and function-like macro invocations, before the
 replacement list is reexamined for more macro names to replace, each
 instance of a `##` preprocessing token in the replacement list (not from
 an argument) is deleted and the preceding preprocessing token is
@@ -430,19 +533,20 @@ concatenation of a placemarker with a non-placemarker preprocessing
 token results in the non-placemarker preprocessing token. If the result
 is not a valid preprocessing token, the behavior is undefined. The
 resulting token is available for further macro replacement. The order of
 evaluation of `##` operators is unspecified.
 In the following fragment:
 ``` cpp
 #define hash_hash # ## #
 #define mkstr(a) # a
 #define in_between(a) mkstr(a)
 #define join(c, d) in_between(c hash_hash d)
-char p[] = join(x, y);          // equivalent to
-                                // char p[] = "x ## y";
 ```
 The expansion produces, at various stages:
 ``` cpp
@@ -455,10 +559,12 @@ mkstr(x ## y)
 In other words, expanding `hash_hash` produces a new token, consisting
 of two adjacent sharp signs, but this new token is not the `##`
 operator.
 ### Rescanning and further replacement <a id="cpp.rescan">[[cpp.rescan]]</a>
 After all parameters in the replacement list have been substituted and
 `#` and `##` processing has taken place, all placemarker preprocessing
 tokens are removed. Then the resulting preprocessing token sequence is
@@ -494,18 +600,24 @@ A preprocessing directive of the form
 causes the specified identifier no longer to be defined as a macro name.
 It is ignored if the specified identifier is not currently defined as a
 macro name.
-The simplest use of this facility is to define a “manifest constant,” as
 in
 ``` cpp
 #define TABSIZE 100
 int table[TABSIZE];
 ```
 The following defines a function-like macro whose value is the maximum
 of its arguments. It has the advantages of working for any compatible
 types of the arguments and of generating in-line code without the
 overhead of function calling. It has the disadvantages of evaluating one
 or the other of its arguments a second time (including side effects) and
@@ -517,10 +629,14 @@ cannot have its address taken, as it has none.
 ```
 The parentheses ensure that the arguments and the resulting expression
 are bound properly.
 To illustrate the rules for redefinition and reexamination, the sequence
 ``` cpp
 #define x       3
 #define f(a)    f(x * (a))
@@ -551,17 +667,22 @@ f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
 f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) & f(2 * (0,1))^m(0,1);
 int i[] = { 1, 23, 4, 5, };
 char c[2][6] = { "hello", "" };
 ```
 To illustrate the rules for creating character string literals and
 concatenating tokens, the sequence
 ``` cpp
 #define str(s)      # s
 #define xstr(s)     str(s)
-#define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \               x ## s, x ## t)
 #define INCFILE(n)  vers ## n
 #define glue(a, b)  a ## b
 #define xglue(a, b) glue(a, b)
 #define HIGHLOW     "hello"
 #define LOW         LOW ", world"
@@ -595,10 +716,14 @@ fputs("strncmp(\"abc\\0d\", \"abc\", '\\4') == 0: \@n", s);
 ```
 Space around the `#` and `##` tokens in the macro definition is
 optional.
 To illustrate the rules for placemarker preprocessing tokens, the
 sequence
 ``` cpp
 #define t(x,y,z) x ## y ## z
@@ -611,17 +736,22 @@ results in
 ``` cpp
 int j[] = { 123, 45, 67, 89,
   10, 11, 12, };
 ```
 To demonstrate the redefinition rules, the following sequence is valid.
 ``` cpp
 #define OBJ_LIKE      (1-1)
 #define OBJ_LIKE      /* white space */ (1-1) /* other */
 #define FUNC_LIKE(a)   ( a )
-#define FUNC_LIKE( a )(     /* note the white space */ \                a /* other stuff on this line
                   */ )
 ```
 But the following redefinitions are invalid:
@@ -630,10 +760,14 @@ But the following redefinitions are invalid:
 #define OBJ_LIKE    (1 - 1)     // different white space
 #define FUNC_LIKE(b) ( a )      // different parameter usage
 #define FUNC_LIKE(b) ( b )      // different parameter spelling
 ```
 Finally, to show the variable argument list macro facilities:
 ``` cpp
 #define debug(...) fprintf(stderr, __VA_ARGS__)
 #define showlist(...) puts(#__VA_ARGS__)
@@ -651,10 +785,12 @@ fprintf(stderr, "Flag");
 fprintf(stderr, "X = %d\n", x);
 puts("The first, second, and third items.");
 ((x>y) ? puts("x>y") : printf("x is %d but y is %d", x, y));
 ```
 ## Line control <a id="cpp.line">[[cpp.line]]</a>
 The string literal of a `#line` directive, if present, shall be a
 character string literal.
@@ -736,14 +872,13 @@ has no effect.
 ## Predefined macro names <a id="cpp.predefined">[[cpp.predefined]]</a>
 The following macro names shall be defined by the implementation:
-- **`\texttt{__cplusplus}`**
-The name ` __cplusplus` is defined to the value `202302L` when compiling
-a C++translation unit.[^12]
 - **`__DATE__`**
 The date of translation of the source file: a character string literal
 of the form `"Mmm dd yyyy"`, where the names of the months are the same
@@ -753,24 +888,32 @@ translation is not available, an *implementation-defined* valid date
 shall be supplied.
 - **`__FILE__`**
 The presumed name of the current source file (a character string
-literal).[^13]
 - **`__LINE__`**
 The presumed line number (within the current source file) of the current
-source line (an integer literal).
 - **`__STDC_HOSTED__`**
 The integer literal `1` if the implementation is a hosted implementation
 or the integer literal `0` if it is not.
 - **`__TIME__`**
 The time of translation of the source file: a character string literal
 of the form `"hh:mm:ss"` as in the time generated by the `asctime`
 function. If the time of translation is not available, an
@@ -841,10 +984,12 @@ and replacing each escape sequence `\\` by a single backslash. The
 resulting sequence of characters is processed through translation phase
 3 to produce preprocessing tokens that are executed as if they were the
 *pp-tokens* in a pragma directive. The original four preprocessing
 tokens in the unary operator expression are removed.
 ``` cpp
 #pragma listing on "..\listing.dir"
 ```
 can also be expressed as:
@@ -861,10 +1006,12 @@ literally as shown, or results from macro replacement, as in:
 #define PRAGMA(x) _Pragma(#x)
 LISTING( ..\listing.dir )
 ```
 <!-- Link reference definitions -->
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [cpp]: #cpp
 [cpp.concat]: #cpp.concat
 [cpp.cond]: #cpp.cond
@@ -880,69 +1027,60 @@ LISTING( ..\listing.dir )
 [cpp.scope]: #cpp.scope
 [cpp.stringize]: #cpp.stringize
 [cpp.subst]: #cpp.subst
 [cstdint]: language.md#cstdint
 [expr.const]: expr.md#expr.const
 [intro.multithread]: intro.md#intro.multithread
 [lex.digraph]: lex.md#lex.digraph
 [lex.name]: lex.md#lex.name
 [lex.phases]: lex.md#lex.phases
 [lex.token]: lex.md#lex.token
 [support.limits]: language.md#support.limits
-[^1]: Thus, preprocessing directives are commonly called “lines.” These
     “lines” have no other syntactic significance, as all white space is
     equivalent except in certain situations during preprocessing (see
     the `#` character string literal creation operator in
     [[cpp.stringize]], for example).
 [^2]: Because the controlling constant expression is evaluated during
     translation phase 4, all identifiers either are or are not macro
     names — there simply are no keywords, enumeration constants, etc.
-[^3]: 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.
-[^4]: 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]]).
-[^5]: 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.
-[^6]: As indicated by the syntax, a preprocessing token shall not follow
     a `#else` or `#endif` directive before the terminating new-line
     character. However, comments may appear anywhere in a source file,
     including within a preprocessing directive.
-[^7]: Note that adjacent string literals are not concatenated into a
     single string literal (see the translation phases in
     [[lex.phases]]); thus, an expansion that results in two string
     literals is an invalid directive.
-[^8]: Since, by macro-replacement time, all character literals and
     string literals are preprocessing tokens, not sequences possibly
     containing identifier-like subsequences (see [[lex.phases]],
     translation phases), they are never scanned for macro names or
     parameters.
-[^9]: An alternative token ([[lex.digraph]]) is not an identifier, even
     when its spelling consists entirely of letters and underscores.
     Therefore it is not possible to define a macro whose name is the
     same as that of an alternative token.
-[^10]: Despite the name, a non-directive is a preprocessing directive.
-[^11]: Placemarker preprocessing tokens do not appear in the syntax
     because they are temporary entities that exist only within
     translation phase 4.
-[^12]: It is intended that future versions of this standard will replace
-    the value of this macro with a greater value. Non-conforming
-    compilers should use a value with at most five decimal digits.
-[^13]: The presumed source file name and line number can be changed by
- the `#line` directive.

     group group-part
 ```
 ``` bnf
 group-part:
     control-line
+    if-section
     text-line
+    '#' conditionally-supported-directive
 ```
 ``` bnf
 if-section:
     if-group elif-groupsₒₚₜ else-groupₒₚₜ endif-line
 text-line:
     pp-tokensₒₚₜ new-line
 ```
 ``` bnf
+conditionally-supported-directive:
     pp-tokens new-line
 ```
 ``` bnf
 lparen:
 new-line:
     the new-line character
 ```
 A text line shall not begin with a `#` preprocessing token. A
+*conditionally-supported-directive* shall not begin with any of the
+directive names appearing in the syntax. A
+*conditionally-supported-directive* is conditionally-supported with
+*implementation-defined* semantics.
 When in a group that is skipped ([[cpp.cond]]), the directive syntax is
 relaxed to allow any sequence of preprocessing tokens to occur between
 the directive name and the following new-line character.
 before translation of the resulting translation unit.
 The preprocessing tokens within a preprocessing directive are not
 subject to macro expansion unless otherwise stated.
+[*Example 1*:
 In:
 ``` cpp
 #define EMPTY
 EMPTY   #   include <file.h>
 ```
 the sequence of preprocessing tokens on the second line is *not* a
+preprocessing directive, because it does not begin with a `#` at the
 start of translation phase 4, even though it will do so after the macro
 `EMPTY` has been replaced.
+— *end example*]
 ## 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*]
 ## Source file inclusion <a id="cpp.include">[[cpp.include]]</a>
 A `#include` directive shall identify a header or source file that can
 be processed by the implementation.
 (that does not match one of the two previous forms) is permitted. The
 preprocessing tokens after `include` in the directive are processed just
 as in normal text (i.e., each identifier currently defined as a macro
 name is replaced by its replacement list of preprocessing tokens). If
 the directive resulting after all replacements does not match one of the
+two previous forms, the behavior is undefined.[^4] The method by which a
 sequence of preprocessing tokens between a `<` and a `>` preprocessing
 token pair or a pair of `"` characters is combined into a single header
 name preprocessing token is *implementation-defined*.
 The implementation shall provide unique mappings for sequences
 A `#include` preprocessing directive may appear in a source file that
 has been read because of a `#include` directive in another file, up to
 an *implementation-defined* nesting limit.
+[*Note 1*:
 Although an implementation may provide a mechanism for making arbitrary
 source files available to the `< >` search, in general programmers
 should use the `< >` form for headers provided with the implementation,
 and the `" "` form for sources outside the control of the
 implementation. For instance:
 #include <unistd.h>
 #include "usefullib.h"
 #include "myprog.h"
 ```
+— *end note*]
+[*Example 1*:
 This illustrates macro-replaced `#include` directives:
 ``` cpp
 #if VERSION == 1
     #define INCFILE  "vers1.h"
     #define INCFILE  "versN.h"
 #endif
 #include INCFILE
 ```
+— *end example*]
 ## Macro replacement <a id="cpp.replace">[[cpp.replace]]</a>
 Two replacement lists are identical if and only if the preprocessing
 tokens in both have the same number, ordering, spelling, and white-space
 separation, where all white-space separations are considered identical.
+An identifier currently defined as an object-like macro (see below) may
 be redefined by another `#define` preprocessing directive provided that
+the second definition is an object-like macro definition and the two
+replacement lists are identical, otherwise the program is ill-formed.
+Likewise, an identifier currently defined as a function-like macro (see
+below) may be redefined by another `#define` preprocessing directive
+provided that the second definition is a function-like macro definition
+that has the same number and spelling of parameters, and the two
+replacement lists are identical, otherwise the program is ill-formed.
 There shall be white-space between the identifier and the replacement
 list in the definition of an object-like macro.
+If the *identifier-list* in the macro definition does not end with an
 ellipsis, the number of arguments (including those arguments consisting
 of no preprocessing tokens) in an invocation of a function-like macro
 shall equal the number of parameters in the macro definition. Otherwise,
 there shall be more arguments in the invocation than there are
 parameters in the macro definition (excluding the `...`). There shall
 exist a `)` preprocessing token that terminates the invocation.
+The identifier `__VA_ARGS__` shall occur only in the *replacement-list*
+of a function-like macro that uses the ellipsis notation in the
+parameters.
 A parameter identifier in a function-like macro shall be uniquely
 declared within its scope.
 The identifier immediately following the `define` is called the *macro
 ``` bnf
 '# define' identifier replacement-list new-line
 ```
 defines an *object-like macro* that causes each subsequent instance of
+the macro name[^5] to be replaced by the replacement list of
+preprocessing tokens that constitute the remainder of the directive.[^6]
 The replacement list is then rescanned for more macro names as specified
 below.
 A preprocessing directive of the form
 matching parentheses forms the list of arguments for the function-like
 macro. The individual arguments within the list are separated by comma
 preprocessing tokens, but comma preprocessing tokens between matching
 inner parentheses do not separate arguments. If there are sequences of
 preprocessing tokens within the list of arguments that would otherwise
+act as preprocessing directives,[^7] the behavior is undefined.
 If there is a `...` immediately preceding the `)` in the function-like
 macro definition, then the trailing arguments, including any separating
 comma preprocessing tokens, are merged to form a single item: the
 *variable arguments*. The number of arguments so combined is such that,
 If, in the replacement list of a function-like macro, a parameter is
 immediately preceded or followed by a `##` preprocessing token, the
 parameter is replaced by the corresponding argument’s preprocessing
 token sequence; however, if an argument consists of no preprocessing
 tokens, the parameter is replaced by a placemarker preprocessing token
+instead.[^8]
 For both object-like and function-like macro invocations, before the
 replacement list is reexamined for more macro names to replace, each
 instance of a `##` preprocessing token in the replacement list (not from
 an argument) is deleted and the preceding preprocessing token is
 token results in the non-placemarker preprocessing token. If the result
 is not a valid preprocessing token, the behavior is undefined. The
 resulting token is available for further macro replacement. The order of
 evaluation of `##` operators is unspecified.
+[*Example 1*:
 In the following fragment:
 ``` cpp
 #define hash_hash # ## #
 #define mkstr(a) # a
 #define in_between(a) mkstr(a)
 #define join(c, d) in_between(c hash_hash d)
+char p[] = join(x, y);          // equivalent to char p[] = "x ## y";
 ```
 The expansion produces, at various stages:
 ``` cpp
 In other words, expanding `hash_hash` produces a new token, consisting
 of two adjacent sharp signs, but this new token is not the `##`
 operator.
+— *end example*]
 ### Rescanning and further replacement <a id="cpp.rescan">[[cpp.rescan]]</a>
 After all parameters in the replacement list have been substituted and
 `#` and `##` processing has taken place, all placemarker preprocessing
 tokens are removed. Then the resulting preprocessing token sequence is
 causes the specified identifier no longer to be defined as a macro name.
 It is ignored if the specified identifier is not currently defined as a
 macro name.
+[*Example 1*:
+The simplest use of this facility is to define a “manifest constant”, as
 in
 ``` cpp
 #define TABSIZE 100
 int table[TABSIZE];
 ```
+— *end example*]
+[*Example 2*:
 The following defines a function-like macro whose value is the maximum
 of its arguments. It has the advantages of working for any compatible
 types of the arguments and of generating in-line code without the
 overhead of function calling. It has the disadvantages of evaluating one
 or the other of its arguments a second time (including side effects) and
 ```
 The parentheses ensure that the arguments and the resulting expression
 are bound properly.
+— *end example*]
+[*Example 3*:
 To illustrate the rules for redefinition and reexamination, the sequence
 ``` cpp
 #define x       3
 #define f(a)    f(x * (a))
 f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) & f(2 * (0,1))^m(0,1);
 int i[] = { 1, 23, 4, 5, };
 char c[2][6] = { "hello", "" };
 ```
+— *end example*]
+[*Example 4*:
 To illustrate the rules for creating character string literals and
 concatenating tokens, the sequence
 ``` cpp
 #define str(s)      # s
 #define xstr(s)     str(s)
+#define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
+               x ## s, x ## t)
 #define INCFILE(n)  vers ## n
 #define glue(a, b)  a ## b
 #define xglue(a, b) glue(a, b)
 #define HIGHLOW     "hello"
 #define LOW         LOW ", world"
 ```
 Space around the `#` and `##` tokens in the macro definition is
 optional.
+— *end example*]
+[*Example 5*:
 To illustrate the rules for placemarker preprocessing tokens, the
 sequence
 ``` cpp
 #define t(x,y,z) x ## y ## z
 ``` cpp
 int j[] = { 123, 45, 67, 89,
   10, 11, 12, };
 ```
+— *end example*]
+[*Example 6*:
 To demonstrate the redefinition rules, the following sequence is valid.
 ``` cpp
 #define OBJ_LIKE      (1-1)
 #define OBJ_LIKE      /* white space */ (1-1) /* other */
 #define FUNC_LIKE(a)   ( a )
+#define FUNC_LIKE( a )(     /* note the white space */ \
+                a /* other stuff on this line
                   */ )
 ```
 But the following redefinitions are invalid:
 #define OBJ_LIKE    (1 - 1)     // different white space
 #define FUNC_LIKE(b) ( a )      // different parameter usage
 #define FUNC_LIKE(b) ( b )      // different parameter spelling
 ```
+— *end example*]
+[*Example 7*:
 Finally, to show the variable argument list macro facilities:
 ``` cpp
 #define debug(...) fprintf(stderr, __VA_ARGS__)
 #define showlist(...) puts(#__VA_ARGS__)
 fprintf(stderr, "X = %d\n", x);
 puts("The first, second, and third items.");
 ((x>y) ? puts("x>y") : printf("x is %d but y is %d", x, y));
 ```
+— *end example*]
 ## Line control <a id="cpp.line">[[cpp.line]]</a>
 The string literal of a `#line` directive, if present, shall be a
 character string literal.
 ## Predefined macro names <a id="cpp.predefined">[[cpp.predefined]]</a>
 The following macro names shall be defined by the implementation:
+- **`__cplusplus`**
+The integer literal `202302L`.[^9]
 - **`__DATE__`**
 The date of translation of the source file: a character string literal
 of the form `"Mmm dd yyyy"`, where the names of the months are the same
 shall be supplied.
 - **`__FILE__`**
 The presumed name of the current source file (a character string
+literal). [^10]
 - **`__LINE__`**
 The presumed line number (within the current source file) of the current
+source line (an integer literal). [^11]
 - **`__STDC_HOSTED__`**
 The integer literal `1` if the implementation is a hosted implementation
 or the integer literal `0` if it is not.
+- **`__STDCPP_DEFAULT_NEW_ALIGNMENT__`**
+An integer literal of type `std::size_t` whose value is the alignment
+guaranteed by a call to `operator new(std::size_t)` or
+`operator new[](std::size_t)`.
+[*Note 1*: Larger alignments will be passed to
+`operator new(std::size_t, std::align_val_t)`, etc. (
+[[expr.new]]). — *end note*]
 - **`__TIME__`**
 The time of translation of the source file: a character string literal
 of the form `"hh:mm:ss"` as in the time generated by the `asctime`
 function. If the time of translation is not available, an
 resulting sequence of characters is processed through translation phase
 3 to produce preprocessing tokens that are executed as if they were the
 *pp-tokens* in a pragma directive. The original four preprocessing
 tokens in the unary operator expression are removed.
+[*Example 1*:
 ``` cpp
 #pragma listing on "..\listing.dir"
 ```
 can also be expressed as:
 #define PRAGMA(x) _Pragma(#x)
 LISTING( ..\listing.dir )
 ```
+— *end example*]
 <!-- Link reference definitions -->
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [cpp]: #cpp
 [cpp.concat]: #cpp.concat
 [cpp.cond]: #cpp.cond
 [cpp.scope]: #cpp.scope
 [cpp.stringize]: #cpp.stringize
 [cpp.subst]: #cpp.subst
 [cstdint]: language.md#cstdint
 [expr.const]: expr.md#expr.const
+[expr.new]: expr.md#expr.new
 [intro.multithread]: intro.md#intro.multithread
 [lex.digraph]: lex.md#lex.digraph
 [lex.name]: lex.md#lex.name
 [lex.phases]: lex.md#lex.phases
 [lex.token]: lex.md#lex.token
 [support.limits]: language.md#support.limits
+[^1]: Thus, preprocessing directives are commonly called “lines”. These
     “lines” have no other syntactic significance, as all white space is
     equivalent except in certain situations during preprocessing (see
     the `#` character string literal creation operator in
     [[cpp.stringize]], for example).
 [^2]: Because the controlling constant expression is evaluated during
     translation phase 4, all identifiers either are or are not macro
     names — there simply are no keywords, enumeration constants, etc.
+[^3]: As indicated by the syntax, a preprocessing token shall not follow
     a `#else` or `#endif` directive before the terminating new-line
     character. However, comments may appear anywhere in a source file,
     including within a preprocessing directive.
+[^4]: Note that adjacent string literals are not concatenated into a
     single string literal (see the translation phases in
     [[lex.phases]]); thus, an expansion that results in two string
     literals is an invalid directive.
+[^5]: Since, by macro-replacement time, all character literals and
     string literals are preprocessing tokens, not sequences possibly
     containing identifier-like subsequences (see [[lex.phases]],
     translation phases), they are never scanned for macro names or
     parameters.
+[^6]: An alternative token ([[lex.digraph]]) is not an identifier, even
     when its spelling consists entirely of letters and underscores.
     Therefore it is not possible to define a macro whose name is the
     same as that of an alternative token.
+[^7]: A *conditionally-supported-directive* is a preprocessing directive
+    regardless of whether the implementation supports it.
+[^8]: Placemarker preprocessing tokens do not appear in the syntax
     because they are temporary entities that exist only within
     translation phase 4.
+[^9]: It is intended that future versions of this International Standard
+ will replace the value of this macro with a greater value.
+ Non-conforming compilers should use a value with at most five
+    decimal digits.
+[^10]: The presumed source file name can be changed by the `#line`
+    directive.
+[^11]: The presumed line number can be changed by the `#line` directive.

Diff to HTML by rtfpessoa