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

Files changed (1) hide show

tmp/tmplwrjse7o/{from.md → to.md} +39 -31

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

@@ -62,10 +62,16 @@ 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
@@ -73,17 +79,17 @@ 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*:
 The simplest use of this facility is to define a “manifest constant”, as
 in
@@ -119,13 +125,13 @@ 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
@@ -159,22 +165,22 @@ va-opt-replacement:
 After the arguments for the invocation of a function-like macro have
 been identified, argument substitution takes place. For each parameter
 in the replacement list that is neither preceded by a `#` or `##`
 preprocessing token nor followed by a `##` preprocessing token, the
-preprocessing tokens naming the parameter are replaced by a token
-sequence determined as follows:
 - If the parameter is of the form *va-opt-replacement*, the replacement
   preprocessing tokens are the preprocessing token sequence for the
   corresponding argument, as specified below.
 - Otherwise, the replacement preprocessing tokens are the preprocessing
   tokens of corresponding argument after all macros contained therein
   have been expanded. The argument’s preprocessing tokens are completely
   macro replaced before being substituted as if they formed the rest of
-  the preprocessing file with no other preprocessing tokens being
-  available.
 [*Example 1*:
 ``` cpp
 #define LPAREN() (
@@ -290,17 +296,21 @@ argument’s preprocessing tokens becomes a single space character in the
 character string literal. Whitespace before the first preprocessing
 token and after the last preprocessing token comprising the stringizing
 argument is deleted. Otherwise, the original spelling of each
 preprocessing token in the stringizing argument is retained in the
 character string literal, except for special handling for producing the
-spelling of *string-literal*s and *character-literal*s: a `\` character
-is inserted before each `"` and `\` character of a *character-literal*
-or *string-literal* (including the delimiting `"` characters). If the
-replacement that results is not a valid character string literal, the
-behavior is undefined. The character string literal corresponding to an
-empty stringizing argument is `""`. The order of evaluation of `#` and
-`##` operators is unspecified.
 ### The `##` operator <a id="cpp.concat">[[cpp.concat]]</a>
 A `##` preprocessing token shall not occur at the beginning or at the
 end of a replacement list for either form of macro definition.
@@ -308,31 +318,29 @@ 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.[^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
 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
@@ -373,12 +381,12 @@ fputs("strncmp(\"abc\\0d\", \"abc\", '\\4') == 0: \@n", s);
 #include "vers2.h"      (after macro replacement, before file access)
 "hello";
 "hello, world"
 ```
-Space around the `#` and `##` tokens in the macro definition is
-optional.
 — *end example*]
 [*Example 2*:
@@ -400,13 +408,13 @@ in_between(x hash_hash y)
 in_between(x ## y)
 mkstr(x ## y)
 "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.
 — *end example*]
 [*Example 3*:

 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.
+A translation unit shall not `#define` or `#undef` macro names lexically
+identical to keywords, to the identifiers listed in
+[[lex.name.special]], or to the *attribute-token*s described in
+[[dcl.attr]], except that the macro names `likely` and `unlikely` may be
+defined as function-like macros.
 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[^4]
 to be replaced by the replacement list of preprocessing tokens that
+constitute the remainder of the directive.[^5]
 The replacement list is then rescanned for more macro names as specified
+in [[cpp.rescan]].
 [*Example 2*:
 The simplest use of this facility is to define a “manifest constant”, as
 in
 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,[^6]
+the program is ill-formed.
 [*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
 After the arguments for the invocation of a function-like macro have
 been identified, argument substitution takes place. For each parameter
 in the replacement list that is neither preceded by a `#` or `##`
 preprocessing token nor followed by a `##` preprocessing token, the
+preprocessing tokens naming the parameter are replaced by a
+preprocessing token sequence determined as follows:
 - If the parameter is of the form *va-opt-replacement*, the replacement
   preprocessing tokens are the preprocessing token sequence for the
   corresponding argument, as specified below.
 - Otherwise, the replacement preprocessing tokens are the preprocessing
   tokens of corresponding argument after all macros contained therein
   have been expanded. The argument’s preprocessing tokens are completely
   macro replaced before being substituted as if they formed the rest of
+  the preprocessing translation unit with no other preprocessing tokens
+ being available.
 [*Example 1*:
 ``` cpp
 #define LPAREN() (
 character string literal. Whitespace before the first preprocessing
 token and after the last preprocessing token comprising the stringizing
 argument is deleted. Otherwise, the original spelling of each
 preprocessing token in the stringizing argument is retained in the
 character string literal, except for special handling for producing the
+spelling of *header-name*s, *character-literal*s, and *string-literal*s
+(including the delimiting U+0022 (quotation mark) (`"`)) contained
+within the preprocessing token: a U+005c (reverse solidus) character
+(`\`) is inserted before each U+0022 (quotation mark) and
+U+005c (reverse solidus) character of a *header-name*,
+*character-literal*, or *string-literal*, and each new-line character is
+replaced by the two-character sequence `\n`. If the replacement that
+results is not a valid character string literal, the program is
+ill-formed. The character string literal corresponding to an empty
+stringizing argument is `""`. The order of evaluation of `#` and `##`
+operators is unspecified.
 ### The `##` operator <a id="cpp.concat">[[cpp.concat]]</a>
 A `##` preprocessing token shall not occur at the beginning or at the
 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.[^7]
 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
 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.
+[*Note 1*: Concatenation can form a *universal-character-name*
+[[lex.charset]]. — *end note*]
+If the result is not a valid preprocessing token, the program is
+ill-formed. The resulting preprocessing token is available for further
+macro replacement. The order of evaluation of `##` operators is
+unspecified.
 [*Example 1*:
 The sequence
 #include "vers2.h"      (after macro replacement, before file access)
 "hello";
 "hello, world"
 ```
+Space around the `#` and `##` preprocessing tokens in the macro
+definition is optional.
 — *end example*]
 [*Example 2*:
 in_between(x ## y)
 mkstr(x ## y)
 "x ## y"
 ```
+In other words, expanding `hash_hash` produces a new preprocessing
+token, consisting of two adjacent sharp signs, but this new
+preprocessing token is not the `##` operator.
 — *end example*]
 [*Example 3*:

Diff to HTML by rtfpessoa