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

Files changed (1) hide show

tmp/tmphyo7l98a/{from.md → to.md} +54 -20

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

@@ -2,33 +2,34 @@
 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
@@ -46,12 +47,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
@@ -79,11 +80,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,
@@ -138,11 +139,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
@@ -153,19 +154,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
@@ -178,10 +180,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
@@ -217,18 +221,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
@@ -240,10 +250,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))
@@ -274,17 +288,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"
@@ -318,10 +337,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
@@ -334,17 +357,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:
@@ -353,10 +381,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__)
@@ -374,5 +406,7 @@ 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));
 ```

 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*]

Diff to HTML by rtfpessoa