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

Files changed (1) hide show

tmp/tmp7pmo_9it/{from.md → to.md} +195 -127

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

@@ -46,10 +46,11 @@ control-line:
     '# define ' identifier lparen '... )' replacement-list new-line
     '# define ' identifier lparen identifier-list ', ... )' replacement-list new-line
     '# undef ' identifier new-line
     '# line ' pp-tokens new-line
     '# error ' pp-tokensₒₚₜ new-line
     '# pragma ' pp-tokensₒₚₜ new-line
     '# 'new-line
 ```
 ``` bnf
@@ -71,10 +72,12 @@ elif-groups:
 ```
 ``` bnf
 elif-group:
     '# elif ' constant-expression new-line groupₒₚₜ
 ```
 ``` bnf
 else-group:
     '# else ' new-line groupₒₚₜ
@@ -95,11 +98,11 @@ conditionally-supported-directive:
     pp-tokens new-line
 ```
 ``` bnf
 lparen:
-    a '(' character not immediately preceded by white-space
 ```
 ``` bnf
 identifier-list:
     identifier
@@ -187,16 +190,16 @@ At the start of phase 4 of translation, the *group* of a
 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.
-The only white-space characters that shall appear between preprocessing
 tokens within a preprocessing directive (from just after the
 directive-introducing token through just before the terminating new-line
 character) are space and horizontal-tab (including spaces that have
-replaced comments or possibly other white-space characters in
-translation phase 3).
 The implementation can process and skip sections of source files
 conditionally, include other source files, import macros from header
 units, and replace macros. These capabilities are called
 *preprocessing*, because conceptually they occur before translation of
@@ -257,12 +260,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
@@ -301,10 +305,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` |
@@ -312,15 +317,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]].
@@ -356,53 +361,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’
@@ -501,14 +494,16 @@ 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.[^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
 consisting of one or more *nondigit*s or *digit*s [[lex.name]] followed
 by a period (`.`) and a single *nondigit*. The first character shall not
 be a *digit*. The implementation may ignore distinctions of alphabetical
@@ -527,15 +522,15 @@ directive [[cpp.import]] of the form
 'import' header-name ';' new-line
 ```
 [*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:
 ``` cpp
 #include <stdio.h>
 #include <unistd.h>
 #include "usefullib.h"
@@ -599,74 +594,80 @@ the first token of the *pp-import*) `export` is an identifier defined as
 an object-like macro.
 The preprocessing tokens after the `import` preprocessing token in the
 `import` *control-line* 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). An `import` directive
-matching the first two forms of a *pp-import* instructs the preprocessor
-to import macros from the header unit [[module.import]] denoted by the
-*header-name*. The *point of macro import* for the first two forms of
-*pp-import* is immediately after the *new-line* terminating the
-*pp-import*. The last form of *pp-import* is only considered if the
-first two forms did not match.
 If a *pp-import* is produced by source file inclusion (including by the
 rewrite produced when a `#include` directive names an importable header)
 while processing the *group* of a *module-file*, the program is
 ill-formed.
 In all three forms of *pp-import*, the `import` and `export` (if it
 exists) preprocessing tokens are replaced by the *import-keyword* and
 *export-keyword* preprocessing tokens respectively.
-[*Note 1*: This makes the line no longer a directive so it is not
 removed at the end of phase 4. — *end note*]
 Additionally, in the second form of *pp-import*, a *header-name* token
 is formed as if the *header-name-tokens* were the *pp-tokens* of a
 `#include` directive. The *header-name-tokens* are replaced by the
 *header-name* token.
-[*Note 2*: This ensures that imports are treated consistently by the
 preprocessor and later phases of translation. — *end note*]
 Each `#define` directive encountered when preprocessing each translation
 unit in a program results in a distinct *macro definition*.
-[*Note 3*: A predefined macro name [[cpp.predefined]] is not introduced
 by a `#define` directive. Implementations providing mechanisms to
 predefine additional macros are encouraged to not treat them as being
 introduced by a `#define` directive. — *end note*]
-Importing macros from a header unit makes macro definitions from a
-translation unit visible in other translation units. Each macro
-definition has at most one point of definition in each translation unit
-and at most one point of undefinition, as follows:
 - The *point of definition* of a macro definition within a translation
-  unit is the point at which its `#define` directive occurs (in the
- translation unit containing the `#define` directive), or, if the macro
-  name is not lexically identical to a keyword [[lex.key]] or to the
- *identifier*s `module` or `import`, the first point of macro import of
-  a translation unit containing a point of definition for the macro
-  definition, if any (in any other translation unit).
 - The *point of undefinition* of a macro definition within a translation
   unit is the first point at which a `#undef` directive naming the macro
   occurs after its point of definition, or the first point of macro
-  import of a translation unit containing a point of undefinition for
- the macro definition, whichever (if any) occurs first.
 A macro directive is *active* at a source location if it has a point of
 definition in that translation unit preceding the location, and does not
 have a point of undefinition in that translation unit preceding the
 location.
 If a macro would be replaced or redefined, and multiple macro
 definitions are active for that macro name, the active macro definitions
 shall all be valid redefinitions of the same macro [[cpp.replace]].
-[*Note 4*: The relative order of *pp-import*s has no bearing on whether
 a particular macro definition is active. — *end note*]
 [*Example 1*:
 Importable header \`"a.h"\`
@@ -694,23 +695,47 @@ Importable header \`"c.h"\`
 ```
 Importable header \`"d.h"\`
 ``` cpp
-import "a.h";   // point of definition of #1, #2, and #3, point of undefinition of #1 in "d.h"
 import "c.h";   // point of definition of #4 and #5 in "d.h"
 int a = Y;      // OK, active macro definitions #2 and #4 are valid redefinitions
 int c = Z;      // error: active macro definitions #3 and #5 are not valid redefinitions of Z
 ```
 — *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.
@@ -742,11 +767,11 @@ But the following redefinitions are invalid:
 #define FUNC_LIKE(b) ( b )      // different parameter spelling
 ```
 — *end example*]
-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
@@ -761,28 +786,31 @@ 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
-name*. There is one name space for macro names. Any white-space
 characters preceding or following the replacement list of preprocessing
 tokens are not considered part of the replacement list for either form
 of macro.
 If a `#` preprocessing token, followed by an identifier, occurs
-lexically at the point at which a preprocessing directive could begin,
-the identifier is not subject to macro replacement.
 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[^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.
 [*Example 2*:
@@ -804,29 +832,29 @@ A preprocessing directive of the form
 '# define' identifier lparen identifier-list ', ...' ')' replacement-list new-line
 ```
 defines a *function-like macro* with parameters, whose use is similar
 syntactically to a function call. The parameters are specified by the
-optional list of identifiers, whose scope extends from their declaration
-in the identifier list until the new-line character that terminates the
-`#define` preprocessing directive. Each subsequent instance of the
 function-like macro name followed by a `(` as the next preprocessing
 token introduces the sequence of preprocessing tokens that is replaced
 by the replacement list in the definition (an invocation of the macro).
 The replaced sequence of preprocessing tokens is terminated by the
 matching `)` preprocessing token, skipping intervening matched pairs of
 left and right parenthesis preprocessing tokens. Within the sequence of
 preprocessing tokens making up an invocation of a function-like macro,
-new-line is considered a normal white-space character.
 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,[^7] the behavior is undefined.
 [*Example 3*:
 The following defines a function-like macro whose value is the maximum
 of its arguments. It has the disadvantages of evaluating one or the
@@ -922,11 +950,11 @@ would be ill-formed as the replacement list of the current function-like
 macro, the program is ill-formed. A *va-opt-replacement* is treated as
 if it were a parameter, and the preprocessing token sequence for the
 corresponding argument is defined as follows. If the substitution of
 `__VA_ARGS__` as neither an operand of `#` nor `##` consists of no
 preprocessing tokens, the argument consists of a single placemarker
-preprocessing token ([[cpp.concat]], [[cpp.rescan]]). Otherwise, the
 argument consists of the results of the expansion of the contained
 *pp-tokens* as the replacement list of the current function-like macro
 before removal of placemarker tokens, rescanning, and further
 replacement.
@@ -1020,13 +1048,20 @@ an argument) is deleted and the preceding preprocessing token is
 concatenated with the following preprocessing token. Placemarker
 preprocessing tokens are handled specially: concatenation of two
 placemarkers results in a single placemarker preprocessing token, and
 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.
 [*Example 1*:
 The sequence
@@ -1241,32 +1276,33 @@ in normal text (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; otherwise, the result is
 processed as appropriate.
-## Error directive <a id="cpp.error">[[cpp.error]]</a>
-A preprocessing directive of the form
 ``` bnf
 '# error' pp-tokensₒₚₜ new-line
 ```
-causes the implementation to produce a diagnostic message that includes
-the specified sequence of preprocessing tokens, and renders the program
-ill-formed.
 ## Pragma directive <a id="cpp.pragma">[[cpp.pragma]]</a>
 A preprocessing directive of the form
 ``` bnf
 '# pragma' pp-tokensₒₚₜ new-line
 ```
 causes the implementation to behave in an *implementation-defined*
-manner. The behavior might cause translation to fail or cause the
 translator or the resulting program to behave in a non-conforming
 manner. Any pragma that is not recognized by the implementation is
 ignored.
 ## Null directive <a id="cpp.null">[[cpp.null]]</a>
@@ -1285,13 +1321,20 @@ The following macro names shall be defined by the implementation:
 - **`__cplusplus`**
 The integer literal `202302L`.
-[*Note 1*: It is intended that future versions of this International
-Standard will replace the value of this macro with a greater
-value. — *end note*]
 - **`__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
@@ -1311,89 +1354,121 @@ The presumed line number (within the current source file) of the current
 source line (an integer literal).[^10]
 - **`__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 2*: 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
 *implementation-defined* valid time shall be supplied.
-- **The names listed in [[cpp.predefined.ft]].**
-The macros defined in [[cpp.predefined.ft]] shall be defined to the
-corresponding integer literal.
-[*Note 3*: Future versions of this International Standard might replace
-the values of these macros with greater values. — *end note*]
 **Table: Feature-test macros** <a id="cpp.predefined.ft">[cpp.predefined.ft]</a>
 | Macro name                              | Value     |
 | --------------------------------------- | --------- |
 | `__cpp_aggregate_bases`                 | `201603L` |
 | `__cpp_aggregate_nsdmi`                 | `201304L` |
 | `__cpp_aggregate_paren_init`            | `201902L` |
 | `__cpp_alias_templates`                 | `200704L` |
 | `__cpp_aligned_new`                     | `201606L` |
 | `__cpp_attributes`                      | `200809L` |
 | `__cpp_binary_literals`                 | `201304L` |
 | `__cpp_capture_star_this`               | `201603L` |
-| `__cpp_char8_t`                         | `201811L` |
-| `__cpp_concepts`                        | `201907L` |
 | `__cpp_conditional_explicit`            | `201806L` |
-| `__cpp_constexpr`                       | `201907L` |
 | `__cpp_constexpr_dynamic_alloc`         | `201907L` |
 | `__cpp_constexpr_in_decltype`           | `201711L` |
-| `__cpp_consteval`                       | `201811L` |
 | `__cpp_constinit`                       | `201907L` |
 | `__cpp_decltype`                        | `200707L` |
 | `__cpp_decltype_auto`                   | `201304L` |
 | `__cpp_deduction_guides`                | `201907L` |
 | `__cpp_delegating_constructors`         | `200604L` |
 | `__cpp_designated_initializers`         | `201707L` |
 | `__cpp_enumerator_attributes`           | `201411L` |
 | `__cpp_fold_expressions`                | `201603L` |
 | `__cpp_generic_lambdas`                 | `201707L` |
 | `__cpp_guaranteed_copy_elision`         | `201606L` |
 | `__cpp_hex_float`                       | `201603L` |
 | `__cpp_if_constexpr`                    | `201606L` |
 | `__cpp_impl_coroutine`                  | `201902L` |
 | `__cpp_impl_destroying_delete`          | `201806L` |
 | `__cpp_impl_three_way_comparison`       | `201907L` |
 | `__cpp_inheriting_constructors`         | `201511L` |
 | `__cpp_init_captures`                   | `201803L` |
 | `__cpp_initializer_lists`               | `200806L` |
 | `__cpp_inline_variables`                | `201606L` |
 | `__cpp_lambdas`                         | `200907L` |
 | `__cpp_modules`                         | `201907L` |
 | `__cpp_namespace_attributes`            | `201411L` |
 | `__cpp_noexcept_function_type`          | `201510L` |
 | `__cpp_nontype_template_args`           | `201911L` |
 | `__cpp_nontype_template_parameter_auto` | `201606L` |
 | `__cpp_nsdmi`                           | `200809L` |
-| `__cpp_range_based_for`                 | `201603L` |
 | `__cpp_raw_strings`                     | `200710L` |
 | `__cpp_ref_qualifiers`                  | `200710L` |
 | `__cpp_return_type_deduction`           | `201304L` |
 | `__cpp_rvalue_references`               | `200610L` |
 | `__cpp_sized_deallocation`              | `201309L` |
 | `__cpp_static_assert`                   | `201411L` |
 | `__cpp_structured_bindings`             | `201606L` |
 | `__cpp_template_template_args`          | `201611L` |
 | `__cpp_threadsafe_static_init`          | `200806L` |
 | `__cpp_unicode_characters`              | `200704L` |
 | `__cpp_unicode_literals`                | `200710L` |
@@ -1424,22 +1499,13 @@ character literal.
 Whether \_\_STDC_VERSION\_\_ is predefined and if so, what its value is,
 are *implementation-defined*.
 - **`__STDC_ISO_10646__`**
-An integer literal of the form `yyyymmL` (for example, `199712L`). If
-this symbol is defined, then every character in the Unicode required
-set, when stored in an object of type `wchar_t`, has the same value as
-the code point of that character. The *Unicode required set* consists of
-all the characters that are defined by ISO/IEC 10646, along with all
-amendments and technical corrigenda as of the specified year and month.
-- **`__STDCPP_STRICT_POINTER_SAFETY__`**
-Defined, and has the value integer literal 1, if and only if the
-implementation has strict pointer safety
-[[basic.stc.dynamic.safety]].
 - **`__STDCPP_THREADS__`**
 Defined, and has the value integer literal 1, if and only if a program
 can have more than one thread of execution [[intro.multithread]].
@@ -1493,11 +1559,11 @@ 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.cond.ha]: #cpp.cond.ha
 [cpp.error]: #cpp.error
@@ -1510,25 +1576,27 @@ LISTING( ..\listing.dir )
 [cpp.pragma.op]: #cpp.pragma.op
 [cpp.pre]: #cpp.pre
 [cpp.predefined]: #cpp.predefined
 [cpp.predefined.ft]: #cpp.predefined.ft
 [cpp.replace]: #cpp.replace
 [cpp.rescan]: #cpp.rescan
 [cpp.scope]: #cpp.scope
 [cpp.stringize]: #cpp.stringize
 [cpp.subst]: #cpp.subst
-[cstdint]: support.md#cstdint
 [expr.const]: expr.md#expr.const
 [expr.new]: expr.md#expr.new
 [intro.multithread]: basic.md#intro.multithread
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
 [lex.phases]: lex.md#lex.phases
 [lex.token]: lex.md#lex.token
 [module.import]: module.md#module.import
-[stmt.if]: stmt.md#stmt.if
 [support.limits]: support.md#support.limits
 [^1]: Thus, preprocessing directives are commonly called “lines”. These
     “lines” have no other syntactic significance, as all whitespace is
     equivalent except in certain situations during preprocessing (see
@@ -1537,13 +1605,13 @@ LISTING( ..\listing.dir )
 [^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-literal*s are not concatenated into a
     single *string-literal* (see the translation phases in
     [[lex.phases]]); thus, an expansion that results in two

     '# define ' identifier lparen '... )' replacement-list new-line
     '# define ' identifier lparen identifier-list ', ... )' replacement-list new-line
     '# undef ' identifier new-line
     '# line ' pp-tokens new-line
     '# error ' pp-tokensₒₚₜ new-line
+    '# warning' pp-tokensₒₚₜ new-line
     '# pragma ' pp-tokensₒₚₜ new-line
     '# 'new-line
 ```
 ``` bnf
 ```
 ``` bnf
 elif-group:
     '# elif ' constant-expression new-line groupₒₚₜ
+    '# elifdef ' identifier new-line groupₒₚₜ
+    '# elifndef' identifier new-line groupₒₚₜ
 ```
 ``` bnf
 else-group:
     '# else ' new-line groupₒₚₜ
     pp-tokens new-line
 ```
 ``` bnf
 lparen:
+    a '(' character not immediately preceded by whitespace
 ```
 ``` bnf
 identifier-list:
     identifier
 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.
+The only whitespace characters that shall appear between preprocessing
 tokens within a preprocessing directive (from just after the
 directive-introducing token through just before the terminating new-line
 character) are space and horizontal-tab (including spaces that have
+replaced comments or possibly other whitespace characters in translation
+phase 3).
 The implementation can process and skip sections of source files
 conditionally, include other source files, import macros from header
 units, and replace macros. These capabilities are called
 *preprocessing*, because conceptually they occur before translation of
     '__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’
 (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
 consisting of one or more *nondigit*s or *digit*s [[lex.name]] followed
 by a period (`.`) and a single *nondigit*. The first character shall not
 be a *digit*. The implementation may ignore distinctions of alphabetical
 'import' header-name ';' new-line
 ```
 [*Note 1*:
+An implementation can provide a mechanism for making arbitrary source
+files available to the `< >` search. However, using the `< >` form for
+headers provided with the implementation and the `" "` form for sources
+outside the control of the implementation achieves wider portability.
+For instance:
 ``` cpp
 #include <stdio.h>
 #include <unistd.h>
 #include "usefullib.h"
 an object-like macro.
 The preprocessing tokens after the `import` preprocessing token in the
 `import` *control-line* 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).
+[*Note 1*: An `import` directive matching the first two forms of a
+*pp-import* instructs the preprocessor to import macros from the header
+unit [[module.import]] denoted by the *header-name*, as described
+below. — *end note*]
+The *point of macro import* for the first two forms of *pp-import* is
+immediately after the *new-line* terminating the *pp-import*. The last
+form of *pp-import* is only considered if the first two forms did not
+match, and does not have a point of macro import.
 If a *pp-import* is produced by source file inclusion (including by the
 rewrite produced when a `#include` directive names an importable header)
 while processing the *group* of a *module-file*, the program is
 ill-formed.
 In all three forms of *pp-import*, the `import` and `export` (if it
 exists) preprocessing tokens are replaced by the *import-keyword* and
 *export-keyword* preprocessing tokens respectively.
+[*Note 2*: This makes the line no longer a directive so it is not
 removed at the end of phase 4. — *end note*]
 Additionally, in the second form of *pp-import*, a *header-name* token
 is formed as if the *header-name-tokens* were the *pp-tokens* of a
 `#include` directive. The *header-name-tokens* are replaced by the
 *header-name* token.
+[*Note 3*: This ensures that imports are treated consistently by the
 preprocessor and later phases of translation. — *end note*]
 Each `#define` directive encountered when preprocessing each translation
 unit in a program results in a distinct *macro definition*.
+[*Note 4*: A predefined macro name [[cpp.predefined]] is not introduced
 by a `#define` directive. Implementations providing mechanisms to
 predefine additional macros are encouraged to not treat them as being
 introduced by a `#define` directive. — *end note*]
+Each macro definition has at most one point of definition in each
+translation unit and at most one point of undefinition, as follows:
 - The *point of definition* of a macro definition within a translation
+  unit T is
+ - if the `#define` directive of the macro definition occurs within T,
+    the point at which that directive occurs, or otherwise,
+ - if the macro name is not lexically identical to a keyword
+    [[lex.key]] or to the *identifier*s `module` or `import`, the first
+    point of macro import in T of a header unit containing a point of
+    definition for the macro definition, if any.
+  In the latter case, the macro is said to be *imported* from the header
+  unit.
 - The *point of undefinition* of a macro definition within a translation
   unit is the first point at which a `#undef` directive naming the macro
   occurs after its point of definition, or the first point of macro
+  import of a header unit containing a point of undefinition for the
+  macro definition, whichever (if any) occurs first.
 A macro directive is *active* at a source location if it has a point of
 definition in that translation unit preceding the location, and does not
 have a point of undefinition in that translation unit preceding the
 location.
 If a macro would be replaced or redefined, and multiple macro
 definitions are active for that macro name, the active macro definitions
 shall all be valid redefinitions of the same macro [[cpp.replace]].
+[*Note 5*: The relative order of *pp-import*s has no bearing on whether
 a particular macro definition is active. — *end note*]
 [*Example 1*:
 Importable header \`"a.h"\`
 ```
 Importable header \`"d.h"\`
 ``` cpp
 import "c.h";   // point of definition of #4 and #5 in "d.h"
+```
+Importable header \`"e.h"\`
+``` cpp
+import "a.h";   // point of definition of #1, #2, and #3, point of undefinition of #1 in "e.h"
+import "d.h";   // point of definition of #4 and #5 in "e.h"
 int a = Y;      // OK, active macro definitions #2 and #4 are valid redefinitions
 int c = Z;      // error: active macro definitions #3 and #5 are not valid redefinitions of Z
 ```
+Module unit \`f\`
+``` cpp
+export module f;
+export import "a.h";
+int a = Y;      // OK
+```
+Translation unit \`#1\`
+``` cpp
+import f;
+int x = Y;      // error: Y is neither a defined macro nor a declared name
+```
 — *end example*]
 ## Macro replacement <a id="cpp.replace">[[cpp.replace]]</a>
+### General <a id="cpp.replace.general">[[cpp.replace.general]]</a>
 Two replacement lists are identical if and only if the preprocessing
+tokens in both have the same number, ordering, spelling, and whitespace
+separation, where all whitespace 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.
 #define FUNC_LIKE(b) ( b )      // different parameter spelling
 ```
 — *end example*]
+There shall be whitespace 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
 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
+name*. There is one name space for macro names. Any whitespace
 characters preceding or following the replacement list of preprocessing
 tokens are not considered part of the replacement list for either form
 of macro.
 If a `#` preprocessing token, followed by an identifier, occurs
+lexically at the point at which a preprocessing directive can begin, the
+identifier is not subject to macro replacement.
 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[^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.
 [*Example 2*:
 '# define' identifier lparen identifier-list ', ...' ')' replacement-list new-line
 ```
 defines a *function-like macro* with parameters, whose use is similar
 syntactically to a function call. The parameters are specified by the
+optional list of identifiers. Each subsequent instance of the
 function-like macro name followed by a `(` as the next preprocessing
 token introduces the sequence of preprocessing tokens that is replaced
 by the replacement list in the definition (an invocation of the macro).
 The replaced sequence of preprocessing tokens is terminated by the
 matching `)` preprocessing token, skipping intervening matched pairs of
 left and right parenthesis preprocessing tokens. Within the sequence of
 preprocessing tokens making up an invocation of a function-like macro,
+new-line is considered a normal whitespace character.
 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,[^7]
+the behavior is undefined.
 [*Example 3*:
 The following defines a function-like macro whose value is the maximum
 of its arguments. It has the disadvantages of evaluating one or the
 macro, the program is ill-formed. A *va-opt-replacement* is treated as
 if it were a parameter, and the preprocessing token sequence for the
 corresponding argument is defined as follows. If the substitution of
 `__VA_ARGS__` as neither an operand of `#` nor `##` consists of no
 preprocessing tokens, the argument consists of a single placemarker
+preprocessing token [[cpp.concat]], [[cpp.rescan]]. Otherwise, the
 argument consists of the results of the expansion of the contained
 *pp-tokens* as the replacement list of the current function-like macro
 before removal of placemarker tokens, rescanning, and further
 replacement.
 concatenated with the following preprocessing token. Placemarker
 preprocessing tokens are handled specially: concatenation of two
 placemarkers results in a single placemarker preprocessing token, and
 concatenation of a placemarker with a non-placemarker preprocessing
 token results in the non-placemarker preprocessing token. If the result
+begins with a sequence matching the syntax of
+*universal-character-name*, the behavior is undefined.
+[*Note 1*: This determination does not consider the replacement of
+*universal-character-name*s in translation phase 3
+[[lex.phases]]. — *end note*]
+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*:
 The sequence
 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; otherwise, the result is
 processed as appropriate.
+## Diagnostic directives <a id="cpp.error">[[cpp.error]]</a>
+A preprocessing directive of either of the following forms
 ``` bnf
 '# error' pp-tokensₒₚₜ new-line
+'# warning' pp-tokensₒₚₜ new-line
 ```
+causes the implementation to produce a diagnostic message that should
+include the specified sequence of preprocessing tokens; the `# error`
+directive renders the program ill-formed.
 ## Pragma directive <a id="cpp.pragma">[[cpp.pragma]]</a>
 A preprocessing directive of the form
 ``` bnf
 '# pragma' pp-tokensₒₚₜ new-line
 ```
 causes the implementation to behave in an *implementation-defined*
+manner. The behavior may cause translation to fail or cause the
 translator or the resulting program to behave in a non-conforming
 manner. Any pragma that is not recognized by the implementation is
 ignored.
 ## Null directive <a id="cpp.null">[[cpp.null]]</a>
 - **`__cplusplus`**
 The integer literal `202302L`.
+[*Note 1*: Future revisions of C++ will replace the value of this macro
+with a greater value. — *end note*]
+- **The names listed in [[cpp.predefined.ft]].**
+The macros defined in [[cpp.predefined.ft]] shall be defined to the
+corresponding integer literal.
+[*Note 2*: Future revisions of C++ might replace the values of these
+macros with greater values. — *end note*]
 - **`__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
 source line (an integer literal).[^10]
 - **`__STDC_HOSTED__`**
 The integer literal `1` if the implementation is a hosted implementation
+or the integer literal `0` if it is a freestanding implementation
+[[intro.compliance]].
 - **`__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 3*: Larger alignments will be passed to
 `operator new(std::size_t, std::align_val_t)`, etc.
 [[expr.new]]. — *end note*]
+- **`__STDCPP_FLOAT16_T__`**
+Defined as the integer literal `1` if and only if the implementation
+supports the ISO/IEC/IEEE 60559 floating-point interchange format
+binary16 as an extended floating-point type [[basic.extended.fp]].
+- **`__STDCPP_FLOAT32_T__`**
+Defined as the integer literal `1` if and only if the implementation
+supports the ISO/IEC/IEEE 60559 floating-point interchange format
+binary32 as an extended floating-point type.
+- **`__STDCPP_FLOAT64_T__`**
+Defined as the integer literal `1` if and only if the implementation
+supports the ISO/IEC/IEEE 60559 floating-point interchange format
+binary64 as an extended floating-point type.
+- **`__STDCPP_FLOAT128_T__`**
+Defined as the integer literal `1` if and only if the implementation
+supports the ISO/IEC/IEEE 60559 floating-point interchange format
+binary128 as an extended floating-point type.
+- **`__STDCPP_BFLOAT16_T__`**
+Defined as the integer literal `1` if and only if the implementation
+supports an extended floating-point type with the properties of the
+\*typedef-name\* `std::bfloat16_t` as described in
+[[basic.extended.fp]].
 - **`__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
 *implementation-defined* valid time shall be supplied.
 **Table: Feature-test macros** <a id="cpp.predefined.ft">[cpp.predefined.ft]</a>
 | Macro name                              | Value     |
 | --------------------------------------- | --------- |
 | `__cpp_aggregate_bases`                 | `201603L` |
 | `__cpp_aggregate_nsdmi`                 | `201304L` |
 | `__cpp_aggregate_paren_init`            | `201902L` |
 | `__cpp_alias_templates`                 | `200704L` |
 | `__cpp_aligned_new`                     | `201606L` |
 | `__cpp_attributes`                      | `200809L` |
+| `__cpp_auto_cast`                       | `202110L` |
 | `__cpp_binary_literals`                 | `201304L` |
 | `__cpp_capture_star_this`               | `201603L` |
+| `__cpp_char8_t`                         | `202207L` |
+| `__cpp_concepts`                        | `202002L` |
 | `__cpp_conditional_explicit`            | `201806L` |
+| `__cpp_constexpr`                       | `202211L` |
 | `__cpp_constexpr_dynamic_alloc`         | `201907L` |
 | `__cpp_constexpr_in_decltype`           | `201711L` |
+| `__cpp_consteval`                       | `202211L` |
 | `__cpp_constinit`                       | `201907L` |
 | `__cpp_decltype`                        | `200707L` |
 | `__cpp_decltype_auto`                   | `201304L` |
 | `__cpp_deduction_guides`                | `201907L` |
 | `__cpp_delegating_constructors`         | `200604L` |
 | `__cpp_designated_initializers`         | `201707L` |
 | `__cpp_enumerator_attributes`           | `201411L` |
+| `__cpp_explicit_this_parameter`         | `202110L` |
 | `__cpp_fold_expressions`                | `201603L` |
 | `__cpp_generic_lambdas`                 | `201707L` |
 | `__cpp_guaranteed_copy_elision`         | `201606L` |
 | `__cpp_hex_float`                       | `201603L` |
+| `__cpp_if_consteval`                    | `202106L` |
 | `__cpp_if_constexpr`                    | `201606L` |
 | `__cpp_impl_coroutine`                  | `201902L` |
 | `__cpp_impl_destroying_delete`          | `201806L` |
 | `__cpp_impl_three_way_comparison`       | `201907L` |
+| `__cpp_implicit_move`                   | `202207L` |
 | `__cpp_inheriting_constructors`         | `201511L` |
 | `__cpp_init_captures`                   | `201803L` |
 | `__cpp_initializer_lists`               | `200806L` |
 | `__cpp_inline_variables`                | `201606L` |
 | `__cpp_lambdas`                         | `200907L` |
 | `__cpp_modules`                         | `201907L` |
+| `__cpp_multidimensional_subscript`      | `202211L` |
+| `__cpp_named_character_escapes`         | `202207L` |
 | `__cpp_namespace_attributes`            | `201411L` |
 | `__cpp_noexcept_function_type`          | `201510L` |
 | `__cpp_nontype_template_args`           | `201911L` |
 | `__cpp_nontype_template_parameter_auto` | `201606L` |
 | `__cpp_nsdmi`                           | `200809L` |
+| `__cpp_range_based_for`                 | `202211L` |
 | `__cpp_raw_strings`                     | `200710L` |
 | `__cpp_ref_qualifiers`                  | `200710L` |
 | `__cpp_return_type_deduction`           | `201304L` |
 | `__cpp_rvalue_references`               | `200610L` |
+| `__cpp_size_t_suffix`                   | `202011L` |
 | `__cpp_sized_deallocation`              | `201309L` |
 | `__cpp_static_assert`                   | `201411L` |
+| `__cpp_static_call_operator`            | `202207L` |
 | `__cpp_structured_bindings`             | `201606L` |
 | `__cpp_template_template_args`          | `201611L` |
 | `__cpp_threadsafe_static_init`          | `200806L` |
 | `__cpp_unicode_characters`              | `200704L` |
 | `__cpp_unicode_literals`                | `200710L` |
 Whether \_\_STDC_VERSION\_\_ is predefined and if so, what its value is,
 are *implementation-defined*.
 - **`__STDC_ISO_10646__`**
+An integer literal of the form `yyyymmL` (for example, `199712L`).
+Whether \_\_STDC_ISO_10646\_\_ is predefined and if so, what its value
+is, are *implementation-defined*.
 - **`__STDCPP_THREADS__`**
 Defined, and has the value integer literal 1, if and only if a program
 can have more than one thread of execution [[intro.multithread]].
 ```
 — *end example*]
 <!-- Link reference definitions -->
+[basic.extended.fp]: basic.md#basic.extended.fp
 [cpp]: #cpp
 [cpp.concat]: #cpp.concat
 [cpp.cond]: #cpp.cond
 [cpp.cond.ha]: #cpp.cond.ha
 [cpp.error]: #cpp.error
 [cpp.pragma.op]: #cpp.pragma.op
 [cpp.pre]: #cpp.pre
 [cpp.predefined]: #cpp.predefined
 [cpp.predefined.ft]: #cpp.predefined.ft
 [cpp.replace]: #cpp.replace
+[cpp.replace.general]: #cpp.replace.general
 [cpp.rescan]: #cpp.rescan
 [cpp.scope]: #cpp.scope
 [cpp.stringize]: #cpp.stringize
 [cpp.subst]: #cpp.subst
+[cstdint.syn]: support.md#cstdint.syn
 [expr.const]: expr.md#expr.const
 [expr.new]: expr.md#expr.new
+[intro.compliance]: intro.md#intro.compliance
 [intro.multithread]: basic.md#intro.multithread
+[lex.ccon]: lex.md#lex.ccon
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
 [lex.phases]: lex.md#lex.phases
 [lex.token]: lex.md#lex.token
 [module.import]: module.md#module.import
 [support.limits]: support.md#support.limits
 [^1]: Thus, preprocessing directives are commonly called “lines”. These
     “lines” have no other syntactic significance, as all whitespace is
     equivalent except in certain situations during preprocessing (see
 [^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 cannot follow a
+    `#else` or `#endif` directive before the terminating new-line
+    character. However, comments can appear anywhere in a source file,
     including within a preprocessing directive.
 [^4]: Note that adjacent *string-literal*s are not concatenated into a
     single *string-literal* (see the translation phases in
     [[lex.phases]]); thus, an expansion that results in two

Diff to HTML by rtfpessoa