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

Files changed (1) hide show

tmp/tmpkvkwef6t/{from.md → to.md} +150 -0

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

	@@ -0,0 +1,150 @@

+### 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.
+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.
+[*Example 1*:
+The following sequence is valid:
+``` cpp
+#define OBJ_LIKE      (1-1)
+#define OBJ_LIKE      /* whitespace */ (1-1) /* other */
+#define FUNC_LIKE(a)   ( a )
+#define FUNC_LIKE( a )(     /* note the whitespace */ \
+                a /* other stuff on this line
+                  */ )
+```
+But the following redefinitions are invalid:
+``` cpp
+#define OBJ_LIKE    (0)         // different token sequence
+#define OBJ_LIKE    (1 - 1)     // different whitespace
+#define FUNC_LIKE(b) ( a )      // different parameter usage
+#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
+shall equal the number of parameters in the macro definition. Otherwise,
+there shall be at least as many arguments in the invocation as there are
+parameters in the macro definition (excluding the `...`). There shall
+exist a `)` preprocessing token that terminates the invocation.
+The identifiers `__VA_ARGS__` and `__VA_OPT__` 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
+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*:
+The simplest use of this facility is to define a “manifest constant”, as
+in
+``` cpp
+#define TABSIZE 100
+int table[TABSIZE];
+```
+— *end example*]
+A preprocessing directive of the form
+``` bnf
+'# define' identifier lparen identifier-listₒₚₜ ')' replacement-list new-line
+'# define' identifier lparen '...' ')' replacement-list new-line
+'# 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
+other of its arguments a second time (including side effects) and
+generating more code than a function if invoked several times. It also
+cannot have its address taken, as it has none.
+``` cpp
+#define max(a, b) ((a) > (b) ? (a) : (b))
+```
+The parentheses ensure that the arguments and the resulting expression
+are bound properly.
+— *end example*]
+If there is a `...` immediately preceding the `)` in the function-like
+macro definition, then the trailing arguments (if any), 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, following merger, the number of arguments is either equal to or
+one more than the number of parameters in the macro definition
+(excluding the `...`).

Diff to HTML by rtfpessoa