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

Files changed (1) hide show

tmp/tmp8igky024/{from.md → to.md} +29 -17

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

@@ -1,10 +1,12 @@
 ## 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.
@@ -36,11 +38,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
@@ -55,28 +57,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*:
@@ -98,29 +103,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
@@ -216,11 +221,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.
@@ -314,13 +319,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

 ## 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

Diff to HTML by rtfpessoa