1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 In other words, you are welcome to use, share and improve this program.
23 You are forbidden to forbid anyone else to use, share and improve
24 what you give them. Help stamp out software-hoarding! */
31 typedef struct macro_arg macro_arg
;
34 const cpp_token
**first
; /* First token in unexpanded argument. */
35 const cpp_token
**expanded
; /* Macro-expanded argument. */
36 const cpp_token
*stringified
; /* Stringified argument. */
37 unsigned int count
; /* # of tokens in argument. */
38 unsigned int expanded_count
; /* # of tokens in expanded argument. */
41 /* Macro expansion. */
43 static int enter_macro_context
PARAMS ((cpp_reader
*, cpp_hashnode
*));
44 static int builtin_macro
PARAMS ((cpp_reader
*, cpp_hashnode
*));
45 static void push_token_context
46 PARAMS ((cpp_reader
*, cpp_hashnode
*, const cpp_token
*, unsigned int));
47 static void push_ptoken_context
48 PARAMS ((cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
49 const cpp_token
**, unsigned int));
50 static _cpp_buff
*collect_args
PARAMS ((cpp_reader
*, const cpp_hashnode
*));
51 static cpp_context
*next_context
PARAMS ((cpp_reader
*));
52 static const cpp_token
*padding_token
53 PARAMS ((cpp_reader
*, const cpp_token
*));
54 static void expand_arg
PARAMS ((cpp_reader
*, macro_arg
*));
55 static const cpp_token
*new_string_token
PARAMS ((cpp_reader
*, uchar
*,
57 static const cpp_token
*new_number_token
PARAMS ((cpp_reader
*, unsigned int));
58 static const cpp_token
*stringify_arg
PARAMS ((cpp_reader
*, macro_arg
*));
59 static void paste_all_tokens
PARAMS ((cpp_reader
*, const cpp_token
*));
60 static bool paste_tokens
PARAMS ((cpp_reader
*, const cpp_token
**,
62 static void replace_args
PARAMS ((cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
64 static _cpp_buff
*funlike_invocation_p
PARAMS ((cpp_reader
*, cpp_hashnode
*));
65 static bool create_iso_definition
PARAMS ((cpp_reader
*, cpp_macro
*));
67 /* #define directive parsing and handling. */
69 static cpp_token
*alloc_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
70 static cpp_token
*lex_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
71 static bool warn_of_redefinition
PARAMS ((cpp_reader
*, const cpp_hashnode
*,
73 static int parse_params
PARAMS ((cpp_reader
*, cpp_macro
*));
74 static void check_trad_stringification
PARAMS ((cpp_reader
*,
78 /* Allocates and returns a CPP_STRING token, containing TEXT of length
79 LEN, after null-terminating it. TEXT must be in permanent storage. */
80 static const cpp_token
*
81 new_string_token (pfile
, text
, len
)
86 cpp_token
*token
= _cpp_temp_token (pfile
);
89 token
->type
= CPP_STRING
;
90 token
->val
.str
.len
= len
;
91 token
->val
.str
.text
= text
;
96 /* Allocates and returns a CPP_NUMBER token evaluating to NUMBER. */
97 static const cpp_token
*
98 new_number_token (pfile
, number
)
102 cpp_token
*token
= _cpp_temp_token (pfile
);
103 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
104 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, 21);
106 sprintf ((char *) buf
, "%u", number
);
107 token
->type
= CPP_NUMBER
;
108 token
->val
.str
.text
= buf
;
109 token
->val
.str
.len
= ustrlen (buf
);
114 static const char * const monthnames
[] =
116 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
117 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
120 /* Handle builtin macros like __FILE__, and push the resulting token
121 on the context stack. Also handles _Pragma, for which no new token
122 is created. Returns 1 if it generates a new token context, 0 to
123 return the token to the caller. */
125 builtin_macro (pfile
, node
)
129 const cpp_token
*result
;
131 switch (node
->value
.builtin
)
134 cpp_error (pfile
, DL_ICE
, "invalid built-in macro \"%s\"",
144 const struct line_map
*map
= pfile
->map
;
146 if (node
->value
.builtin
== BT_BASE_FILE
)
147 while (! MAIN_FILE_P (map
))
148 map
= INCLUDED_FROM (&pfile
->line_maps
, map
);
152 buf
= _cpp_unaligned_alloc (pfile
, len
* 4 + 1);
153 len
= cpp_quote_string (buf
, (const unsigned char *) name
, len
) - buf
;
155 result
= new_string_token (pfile
, buf
, len
);
159 case BT_INCLUDE_LEVEL
:
160 /* The line map depth counts the primary source as level 1, but
161 historically __INCLUDE_DEPTH__ has called the primary source
163 result
= new_number_token (pfile
, pfile
->line_maps
.depth
- 1);
167 /* If __LINE__ is embedded in a macro, it must expand to the
168 line of the macro's invocation, not its definition.
169 Otherwise things like assert() will not work properly. */
170 result
= new_number_token (pfile
,
171 SOURCE_LINE (pfile
->map
,
172 pfile
->cur_token
[-1].line
));
175 /* __STDC__ has the value 1 under normal circumstances.
176 However, if (a) we are in a system header, (b) the option
177 stdc_0_in_system_headers is true (set by target config), and
178 (c) we are not in strictly conforming mode, then it has the
183 enum c_lang lang
= CPP_OPTION (pfile
, lang
);
184 if (CPP_IN_SYSTEM_HEADER (pfile
)
185 && CPP_OPTION (pfile
, stdc_0_in_system_headers
)
186 && !(lang
== CLK_STDC89
|| lang
== CLK_STDC94
187 || lang
== CLK_STDC99
)) /* || lang == CLK_CXX98 ? */
192 result
= new_number_token (pfile
, stdc
);
198 if (pfile
->date
.type
== CPP_EOF
)
200 /* Allocate __DATE__ and __TIME__ strings from permanent
201 storage. We only do this once, and don't generate them
202 at init time, because time() and localtime() are very
203 slow on some systems. */
204 time_t tt
= time (NULL
);
205 struct tm
*tb
= localtime (&tt
);
207 pfile
->date
.val
.str
.text
=
208 _cpp_unaligned_alloc (pfile
, sizeof ("Oct 11 1347"));
209 pfile
->date
.val
.str
.len
= sizeof ("Oct 11 1347") - 1;
210 pfile
->date
.type
= CPP_STRING
;
211 pfile
->date
.flags
= 0;
212 sprintf ((char *) pfile
->date
.val
.str
.text
, "%s %2d %4d",
213 monthnames
[tb
->tm_mon
], tb
->tm_mday
, tb
->tm_year
+ 1900);
215 pfile
->time
.val
.str
.text
=
216 _cpp_unaligned_alloc (pfile
, sizeof ("12:34:56"));
217 pfile
->time
.val
.str
.len
= sizeof ("12:34:56") - 1;
218 pfile
->time
.type
= CPP_STRING
;
219 pfile
->time
.flags
= 0;
220 sprintf ((char *) pfile
->time
.val
.str
.text
, "%02d:%02d:%02d",
221 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
224 if (node
->value
.builtin
== BT_DATE
)
225 result
= &pfile
->date
;
227 result
= &pfile
->time
;
231 /* Don't interpret _Pragma within directives. The standard is
232 not clear on this, but to me this makes most sense. */
233 if (pfile
->state
.in_directive
)
236 _cpp_do__Pragma (pfile
);
240 push_token_context (pfile
, NULL
, result
, 1);
244 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
245 backslashes and double quotes. Non-printable characters are
246 converted to octal. DEST must be of sufficient size. Returns
247 a pointer to the end of the string. */
249 cpp_quote_string (dest
, src
, len
)
258 if (c
== '\\' || c
== '"')
269 sprintf ((char *) dest
, "\\%03o", c
);
278 /* Convert a token sequence ARG to a single string token according to
279 the rules of the ISO C #-operator. */
280 static const cpp_token
*
281 stringify_arg (pfile
, arg
)
285 unsigned char *dest
= BUFF_FRONT (pfile
->u_buff
);
286 unsigned int i
, escape_it
, backslash_count
= 0;
287 const cpp_token
*source
= NULL
;
290 /* Loop, reading in the argument's tokens. */
291 for (i
= 0; i
< arg
->count
; i
++)
293 const cpp_token
*token
= arg
->first
[i
];
295 if (token
->type
== CPP_PADDING
)
298 source
= token
->val
.source
;
302 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_WSTRING
303 || token
->type
== CPP_CHAR
|| token
->type
== CPP_WCHAR
);
305 /* Room for each char being written in octal, initial space and
307 len
= cpp_token_len (token
);
312 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
314 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
315 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
316 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
319 /* Leading white space? */
320 if (dest
!= BUFF_FRONT (pfile
->u_buff
))
324 if (source
->flags
& PREV_WHITE
)
331 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
332 unsigned char *buf
= BUFF_FRONT (buff
);
333 len
= cpp_spell_token (pfile
, token
, buf
) - buf
;
334 dest
= cpp_quote_string (dest
, buf
, len
);
335 _cpp_release_buff (pfile
, buff
);
338 dest
= cpp_spell_token (pfile
, token
, dest
);
340 if (token
->type
== CPP_OTHER
&& token
->val
.c
== '\\')
346 /* Ignore the final \ of invalid string literals. */
347 if (backslash_count
& 1)
349 cpp_error (pfile
, DL_WARNING
,
350 "invalid string literal, ignoring final '\\'");
354 /* Commit the memory, including NUL, and return the token. */
355 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
356 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
357 return new_string_token (pfile
, dest
- len
, len
);
360 /* Try to paste two tokens. On success, return non-zero. In any
361 case, PLHS is updated to point to the pasted token, which is
362 guaranteed to not have the PASTE_LEFT flag set. */
364 paste_tokens (pfile
, plhs
, rhs
)
366 const cpp_token
**plhs
, *rhs
;
368 unsigned char *buf
, *end
;
369 const cpp_token
*lhs
;
374 len
= cpp_token_len (lhs
) + cpp_token_len (rhs
) + 1;
375 buf
= (unsigned char *) alloca (len
);
376 end
= cpp_spell_token (pfile
, lhs
, buf
);
378 /* Avoid comment headers, since they are still processed in stage 3.
379 It is simpler to insert a space here, rather than modifying the
380 lexer to ignore comments in some circumstances. Simply returning
381 false doesn't work, since we want to clear the PASTE_LEFT flag. */
382 if (lhs
->type
== CPP_DIV
383 && (rhs
->type
== CPP_MULT
|| rhs
->type
== CPP_DIV
))
385 end
= cpp_spell_token (pfile
, rhs
, end
);
388 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true, 1);
390 /* Tweak the column number the lexer will report. */
391 pfile
->buffer
->col_adjust
= pfile
->cur_token
[-1].col
- 1;
393 /* We don't want a leading # to be interpreted as a directive. */
394 pfile
->buffer
->saved_flags
= 0;
396 /* Set pfile->cur_token as required by _cpp_lex_direct. */
397 pfile
->cur_token
= _cpp_temp_token (pfile
);
398 *plhs
= _cpp_lex_direct (pfile
);
399 valid
= pfile
->buffer
->cur
== pfile
->buffer
->rlimit
;
400 _cpp_pop_buffer (pfile
);
405 /* Handles an arbitrarily long sequence of ## operators, with initial
406 operand LHS. This implementation is left-associative,
407 non-recursive, and finishes a paste before handling succeeding
408 ones. If a paste fails, we back up to the RHS of the failing ##
409 operator before pushing the context containing the result of prior
410 successful pastes, with the effect that the RHS appears in the
411 output stream after the pasted LHS normally. */
413 paste_all_tokens (pfile
, lhs
)
415 const cpp_token
*lhs
;
417 const cpp_token
*rhs
;
418 cpp_context
*context
= pfile
->context
;
422 /* Take the token directly from the current context. We can do
423 this, because we are in the replacement list of either an
424 object-like macro, or a function-like macro with arguments
425 inserted. In either case, the constraints to #define
426 guarantee we have at least one more token. */
427 if (context
->direct_p
)
428 rhs
= FIRST (context
).token
++;
430 rhs
= *FIRST (context
).ptoken
++;
432 if (rhs
->type
== CPP_PADDING
)
435 if (!paste_tokens (pfile
, &lhs
, rhs
))
437 _cpp_backup_tokens (pfile
, 1);
439 /* Mandatory error for all apart from assembler. */
440 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
441 cpp_error (pfile
, DL_ERROR
,
442 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
443 cpp_token_as_text (pfile
, lhs
),
444 cpp_token_as_text (pfile
, rhs
));
448 while (rhs
->flags
& PASTE_LEFT
);
450 /* Put the resulting token in its own context. */
451 push_token_context (pfile
, NULL
, lhs
, 1);
454 /* Reads and returns the arguments to a function-like macro
455 invocation. Assumes the opening parenthesis has been processed.
456 If there is an error, emits an appropriate diagnostic and returns
457 NULL. Each argument is terminated by a CPP_EOF token, for the
458 future benefit of expand_arg(). */
460 collect_args (pfile
, node
)
462 const cpp_hashnode
*node
;
464 _cpp_buff
*buff
, *base_buff
;
466 macro_arg
*args
, *arg
;
467 const cpp_token
*token
;
471 macro
= node
->value
.macro
;
473 argc
= macro
->paramc
;
476 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
477 + sizeof (macro_arg
)));
479 args
= (macro_arg
*) buff
->base
;
480 memset (args
, 0, argc
* sizeof (macro_arg
));
481 buff
->cur
= (unsigned char *) &args
[argc
];
482 arg
= args
, argc
= 0;
484 /* Collect the tokens making up each argument. We don't yet know
485 how many arguments have been supplied, whether too many or too
486 few. Hence the slightly bizarre usage of "argc" and "arg". */
489 unsigned int paren_depth
= 0;
490 unsigned int ntokens
= 0;
493 arg
->first
= (const cpp_token
**) buff
->cur
;
497 /* Require space for 2 new tokens (including a CPP_EOF). */
498 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
500 buff
= _cpp_append_extend_buff (pfile
, buff
,
501 1000 * sizeof (cpp_token
*));
502 arg
->first
= (const cpp_token
**) buff
->cur
;
505 token
= cpp_get_token (pfile
);
507 if (token
->type
== CPP_PADDING
)
509 /* Drop leading padding. */
513 else if (token
->type
== CPP_OPEN_PAREN
)
515 else if (token
->type
== CPP_CLOSE_PAREN
)
517 if (paren_depth
-- == 0)
520 else if (token
->type
== CPP_COMMA
)
522 /* A comma does not terminate an argument within
523 parentheses or as part of a variable argument. */
525 && ! (macro
->variadic
&& argc
== macro
->paramc
))
528 else if (token
->type
== CPP_EOF
529 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
532 arg
->first
[ntokens
++] = token
;
535 /* Drop trailing padding. */
536 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
539 arg
->count
= ntokens
;
540 arg
->first
[ntokens
] = &pfile
->eof
;
542 /* Terminate the argument. Excess arguments loop back and
543 overwrite the final legitimate argument, before failing. */
544 if (argc
<= macro
->paramc
)
546 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
547 if (argc
!= macro
->paramc
)
551 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
553 if (token
->type
== CPP_EOF
)
555 /* We still need the CPP_EOF to end directives, and to end
556 pre-expansion of a macro argument. Step back is not
557 unconditional, since we don't want to return a CPP_EOF to our
558 callers at the end of an -include-d file. */
559 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
560 _cpp_backup_tokens (pfile
, 1);
561 cpp_error (pfile
, DL_ERROR
,
562 "unterminated argument list invoking macro \"%s\"",
566 else if (argc
< macro
->paramc
)
568 /* As an extension, a rest argument is allowed to not appear in
569 the invocation at all.
570 e.g. #define debug(format, args...) something
573 This is exactly the same as if there had been an empty rest
574 argument - debug("string", ). */
576 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
578 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
579 cpp_error (pfile
, DL_PEDWARN
,
580 "ISO C99 requires rest arguments to be used");
584 cpp_error (pfile
, DL_ERROR
,
585 "macro \"%s\" requires %u arguments, but only %u given",
586 NODE_NAME (node
), macro
->paramc
, argc
);
590 else if (argc
> macro
->paramc
)
592 /* Empty argument to a macro taking no arguments is OK. */
593 if (argc
!= 1 || arg
->count
)
595 cpp_error (pfile
, DL_ERROR
,
596 "macro \"%s\" passed %u arguments, but takes just %u",
597 NODE_NAME (node
), argc
, macro
->paramc
);
605 _cpp_release_buff (pfile
, base_buff
);
609 /* Search for an opening parenthesis to the macro of NODE, in such a
610 way that, if none is found, we don't lose the information in any
611 intervening padding tokens. If we find the parenthesis, collect
612 the arguments and return the buffer containing them. */
614 funlike_invocation_p (pfile
, node
)
618 const cpp_token
*token
, *padding
= NULL
;
622 token
= cpp_get_token (pfile
);
623 if (token
->type
!= CPP_PADDING
)
626 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
630 if (token
->type
== CPP_OPEN_PAREN
)
632 pfile
->state
.parsing_args
= 2;
633 return collect_args (pfile
, node
);
636 /* CPP_EOF can be the end of macro arguments, or the end of the
637 file. We mustn't back up over the latter. Ugh. */
638 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
640 /* Back up. We may have skipped padding, in which case backing
641 up more than one token when expanding macros is in general
642 too difficult. We re-insert it in its own context. */
643 _cpp_backup_tokens (pfile
, 1);
645 push_token_context (pfile
, NULL
, padding
, 1);
651 /* Push the context of a macro with hash entry NODE onto the context
652 stack. If we can successfully expand the macro, we push a context
653 containing its yet-to-be-rescanned replacement list and return one.
654 Otherwise, we don't push a context and return zero. */
656 enter_macro_context (pfile
, node
)
660 /* The presence of a macro invalidates a file's controlling macro. */
661 pfile
->mi_valid
= false;
663 pfile
->state
.angled_headers
= false;
665 /* Handle standard macros. */
666 if (! (node
->flags
& NODE_BUILTIN
))
668 cpp_macro
*macro
= node
->value
.macro
;
674 pfile
->state
.prevent_expansion
++;
675 pfile
->keep_tokens
++;
676 pfile
->state
.parsing_args
= 1;
677 buff
= funlike_invocation_p (pfile
, node
);
678 pfile
->state
.parsing_args
= 0;
679 pfile
->keep_tokens
--;
680 pfile
->state
.prevent_expansion
--;
684 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
685 cpp_error (pfile
, DL_WARNING
,
686 "function-like macro \"%s\" must be used with arguments in traditional C",
692 if (macro
->paramc
> 0)
693 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
694 _cpp_release_buff (pfile
, buff
);
697 /* Disable the macro within its expansion. */
698 node
->flags
|= NODE_DISABLED
;
700 if (macro
->paramc
== 0)
701 push_token_context (pfile
, node
, macro
->exp
.tokens
, macro
->count
);
706 /* Handle built-in macros and the _Pragma operator. */
707 return builtin_macro (pfile
, node
);
710 /* Replace the parameters in a function-like macro of NODE with the
711 actual ARGS, and place the result in a newly pushed token context.
712 Expand each argument before replacing, unless it is operated upon
713 by the # or ## operators. */
715 replace_args (pfile
, node
, macro
, args
)
721 unsigned int i
, total
;
722 const cpp_token
*src
, *limit
;
723 const cpp_token
**dest
, **first
;
727 /* First, fully macro-expand arguments, calculating the number of
728 tokens in the final expansion as we go. The ordering of the if
729 statements below is subtle; we must handle stringification before
731 total
= macro
->count
;
732 limit
= macro
->exp
.tokens
+ macro
->count
;
734 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
735 if (src
->type
== CPP_MACRO_ARG
)
737 /* Leading and trailing padding tokens. */
740 /* We have an argument. If it is not being stringified or
741 pasted it is macro-replaced before insertion. */
742 arg
= &args
[src
->val
.arg_no
- 1];
744 if (src
->flags
& STRINGIFY_ARG
)
746 if (!arg
->stringified
)
747 arg
->stringified
= stringify_arg (pfile
, arg
);
749 else if ((src
->flags
& PASTE_LEFT
)
750 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
751 total
+= arg
->count
- 1;
755 expand_arg (pfile
, arg
);
756 total
+= arg
->expanded_count
- 1;
760 /* Now allocate space for the expansion, copy the tokens and replace
762 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
763 first
= (const cpp_token
**) buff
->base
;
766 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
769 const cpp_token
**from
, **paste_flag
;
771 if (src
->type
!= CPP_MACRO_ARG
)
778 arg
= &args
[src
->val
.arg_no
- 1];
779 if (src
->flags
& STRINGIFY_ARG
)
780 count
= 1, from
= &arg
->stringified
;
781 else if (src
->flags
& PASTE_LEFT
)
782 count
= arg
->count
, from
= arg
->first
;
783 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
785 count
= arg
->count
, from
= arg
->first
;
788 /* GCC has special semantics for , ## b where b is a
789 varargs parameter: the comma disappears if b was
790 given no actual arguments (not merely if b is an
791 empty argument); otherwise the paste flag is removed. */
792 if (dest
[-1]->type
== CPP_COMMA
794 && src
->val
.arg_no
== macro
->paramc
)
799 paste_flag
= dest
- 1;
801 /* Remove the paste flag if the RHS is a placemarker. */
803 paste_flag
= dest
- 1;
807 count
= arg
->expanded_count
, from
= arg
->expanded
;
809 /* Padding on the left of an argument (unless RHS of ##). */
810 if (!pfile
->state
.in_directive
811 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
812 *dest
++ = padding_token (pfile
, src
);
816 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
819 /* With a non-empty argument on the LHS of ##, the last
820 token should be flagged PASTE_LEFT. */
821 if (src
->flags
& PASTE_LEFT
)
822 paste_flag
= dest
- 1;
825 /* Avoid paste on RHS (even case count == 0). */
826 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
827 *dest
++ = &pfile
->avoid_paste
;
829 /* Add a new paste flag, or remove an unwanted one. */
832 cpp_token
*token
= _cpp_temp_token (pfile
);
833 token
->type
= (*paste_flag
)->type
;
834 token
->val
.str
= (*paste_flag
)->val
.str
;
835 if (src
->flags
& PASTE_LEFT
)
836 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
838 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
843 /* Free the expanded arguments. */
844 for (i
= 0; i
< macro
->paramc
; i
++)
845 if (args
[i
].expanded
)
846 free (args
[i
].expanded
);
848 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
851 /* Return a special padding token, with padding inherited from SOURCE. */
852 static const cpp_token
*
853 padding_token (pfile
, source
)
855 const cpp_token
*source
;
857 cpp_token
*result
= _cpp_temp_token (pfile
);
859 result
->type
= CPP_PADDING
;
860 result
->val
.source
= source
;
865 /* Get a new uninitialized context. Create a new one if we cannot
866 re-use an old one. */
871 cpp_context
*result
= pfile
->context
->next
;
875 result
= xnew (cpp_context
);
876 result
->prev
= pfile
->context
;
878 pfile
->context
->next
= result
;
881 pfile
->context
= result
;
885 /* Push a list of pointers to tokens. */
887 push_ptoken_context (pfile
, macro
, buff
, first
, count
)
891 const cpp_token
**first
;
894 cpp_context
*context
= next_context (pfile
);
896 context
->direct_p
= false;
897 context
->macro
= macro
;
898 context
->buff
= buff
;
899 FIRST (context
).ptoken
= first
;
900 LAST (context
).ptoken
= first
+ count
;
903 /* Push a list of tokens. */
905 push_token_context (pfile
, macro
, first
, count
)
908 const cpp_token
*first
;
911 cpp_context
*context
= next_context (pfile
);
913 context
->direct_p
= true;
914 context
->macro
= macro
;
915 context
->buff
= NULL
;
916 FIRST (context
).token
= first
;
917 LAST (context
).token
= first
+ count
;
920 /* Push a traditional macro's replacement text. */
922 _cpp_push_text_context (pfile
, macro
, start
, end
)
925 const uchar
*start
, *end
;
927 cpp_context
*context
= next_context (pfile
);
929 context
->direct_p
= true;
930 context
->macro
= macro
;
931 context
->buff
= NULL
;
932 CUR (context
) = start
;
933 RLIMIT (context
) = end
;
936 /* Expand an argument ARG before replacing parameters in a
937 function-like macro. This works by pushing a context with the
938 argument's tokens, and then expanding that into a temporary buffer
939 as if it were a normal part of the token stream. collect_args()
940 has terminated the argument's tokens with a CPP_EOF so that we know
941 when we have fully expanded the argument. */
943 expand_arg (pfile
, arg
)
947 unsigned int capacity
;
952 /* Loop, reading in the arguments. */
954 arg
->expanded
= (const cpp_token
**)
955 xmalloc (capacity
* sizeof (cpp_token
*));
957 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
960 const cpp_token
*token
;
962 if (arg
->expanded_count
+ 1 >= capacity
)
965 arg
->expanded
= (const cpp_token
**)
966 xrealloc (arg
->expanded
, capacity
* sizeof (cpp_token
*));
969 token
= cpp_get_token (pfile
);
971 if (token
->type
== CPP_EOF
)
974 arg
->expanded
[arg
->expanded_count
++] = token
;
977 _cpp_pop_context (pfile
);
980 /* Pop the current context off the stack, re-enabling the macro if the
981 context represented a macro's replacement list. The context
982 structure is not freed so that we can re-use it later. */
984 _cpp_pop_context (pfile
)
987 cpp_context
*context
= pfile
->context
;
990 context
->macro
->flags
&= ~NODE_DISABLED
;
993 _cpp_release_buff (pfile
, context
->buff
);
995 pfile
->context
= context
->prev
;
998 /* Eternal routine to get a token. Also used nearly everywhere
999 internally, except for places where we know we can safely call
1000 the lexer directly, such as lexing a directive name.
1002 Macro expansions and directives are transparently handled,
1003 including entering included files. Thus tokens are post-macro
1004 expansion, and after any intervening directives. External callers
1005 see CPP_EOF only at EOF. Internal callers also see it when meeting
1006 a directive inside a macro call, when at the end of a directive and
1007 state.in_directive is still 1, and at the end of argument
1010 cpp_get_token (pfile
)
1013 const cpp_token
*result
;
1018 cpp_context
*context
= pfile
->context
;
1020 /* Context->prev == 0 <=> base context. */
1022 result
= _cpp_lex_token (pfile
);
1023 else if (FIRST (context
).token
!= LAST (context
).token
)
1025 if (context
->direct_p
)
1026 result
= FIRST (context
).token
++;
1028 result
= *FIRST (context
).ptoken
++;
1030 if (result
->flags
& PASTE_LEFT
)
1032 paste_all_tokens (pfile
, result
);
1033 if (pfile
->state
.in_directive
)
1035 return padding_token (pfile
, result
);
1040 _cpp_pop_context (pfile
);
1041 if (pfile
->state
.in_directive
)
1043 return &pfile
->avoid_paste
;
1046 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1049 if (result
->type
!= CPP_NAME
)
1052 node
= result
->val
.node
;
1054 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1057 if (!(node
->flags
& NODE_DISABLED
))
1059 if (!pfile
->state
.prevent_expansion
1060 && enter_macro_context (pfile
, node
))
1062 if (pfile
->state
.in_directive
)
1064 return padding_token (pfile
, result
);
1069 /* Flag this token as always unexpandable. FIXME: move this
1070 to collect_args()?. */
1071 cpp_token
*t
= _cpp_temp_token (pfile
);
1072 t
->type
= result
->type
;
1073 t
->flags
= result
->flags
| NO_EXPAND
;
1074 t
->val
.str
= result
->val
.str
;
1084 /* Returns true if we're expanding an object-like macro that was
1085 defined in a system header. Just checks the macro at the top of
1086 the stack. Used for diagnostic suppression. */
1088 cpp_sys_macro_p (pfile
)
1091 cpp_hashnode
*node
= pfile
->context
->macro
;
1093 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1096 /* Read each token in, until end of the current file. Directives are
1097 transparently processed. */
1099 cpp_scan_nooutput (pfile
)
1102 /* Request a CPP_EOF token at the end of this file, rather than
1103 transparently continuing with the including file. */
1104 pfile
->buffer
->return_at_eof
= true;
1106 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1110 /* Step back one (or more) tokens. Can only step mack more than 1 if
1111 they are from the lexer, and not from macro expansion. */
1113 _cpp_backup_tokens (pfile
, count
)
1117 if (pfile
->context
->prev
== NULL
)
1119 pfile
->lookaheads
+= count
;
1123 if (pfile
->cur_token
== pfile
->cur_run
->base
1124 /* Possible with -fpreprocessed and no leading #line. */
1125 && pfile
->cur_run
->prev
!= NULL
)
1127 pfile
->cur_run
= pfile
->cur_run
->prev
;
1128 pfile
->cur_token
= pfile
->cur_run
->limit
;
1136 if (pfile
->context
->direct_p
)
1137 FIRST (pfile
->context
).token
--;
1139 FIRST (pfile
->context
).ptoken
--;
1143 /* #define directive parsing and handling. */
1145 /* Returns non-zero if a macro redefinition warning is required. */
1147 warn_of_redefinition (pfile
, node
, macro2
)
1149 const cpp_hashnode
*node
;
1150 const cpp_macro
*macro2
;
1152 const cpp_macro
*macro1
;
1155 /* Some redefinitions need to be warned about regardless. */
1156 if (node
->flags
& NODE_WARN
)
1159 /* Redefinition of a macro is allowed if and only if the old and new
1160 definitions are the same. (6.10.3 paragraph 2). */
1161 macro1
= node
->value
.macro
;
1163 /* The quick failures. */
1164 if (macro1
->count
!= macro2
->count
1165 || macro1
->paramc
!= macro2
->paramc
1166 || macro1
->fun_like
!= macro2
->fun_like
1167 || macro1
->variadic
!= macro2
->variadic
)
1170 /* Check parameter spellings. */
1171 for (i
= 0; i
< macro1
->paramc
; i
++)
1172 if (macro1
->params
[i
] != macro2
->params
[i
])
1175 /* Check the replacement text or tokens. */
1176 if (CPP_OPTION (pfile
, traditional
))
1177 return memcmp (macro1
->exp
.text
, macro2
->exp
.text
, macro1
->count
);
1179 for (i
= 0; i
< macro1
->count
; i
++)
1180 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
1186 /* Free the definition of hashnode H. */
1188 _cpp_free_definition (h
)
1191 /* Macros and assertions no longer have anything to free. */
1193 /* Clear builtin flag in case of redefinition. */
1194 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
);
1197 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1198 zero on success, non-zero if the parameter is a duplicate. */
1200 _cpp_save_parameter (pfile
, macro
, node
)
1205 /* Constraint 6.10.3.6 - duplicate parameter names. */
1206 if (node
->arg_index
)
1208 cpp_error (pfile
, DL_ERROR
, "duplicate macro parameter \"%s\"",
1213 if (BUFF_ROOM (pfile
->a_buff
)
1214 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1215 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1217 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1218 node
->arg_index
= macro
->paramc
;
1222 /* Check the syntax of the parameters in a MACRO definition. */
1224 parse_params (pfile
, macro
)
1228 unsigned int prev_ident
= 0;
1232 const cpp_token
*token
= _cpp_lex_token (pfile
);
1234 switch (token
->type
)
1237 /* Allow/ignore comments in parameter lists if we are
1238 preserving comments in macro expansions. */
1239 if (token
->type
== CPP_COMMENT
1240 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1243 cpp_error (pfile
, DL_ERROR
,
1244 "\"%s\" may not appear in macro parameter list",
1245 cpp_token_as_text (pfile
, token
));
1251 cpp_error (pfile
, DL_ERROR
,
1252 "macro parameters must be comma-separated");
1257 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
))
1261 case CPP_CLOSE_PAREN
:
1262 if (prev_ident
|| macro
->paramc
== 0)
1265 /* Fall through to pick up the error. */
1269 cpp_error (pfile
, DL_ERROR
, "parameter name missing");
1276 macro
->variadic
= 1;
1279 _cpp_save_parameter (pfile
, macro
,
1280 pfile
->spec_nodes
.n__VA_ARGS__
);
1281 pfile
->state
.va_args_ok
= 1;
1282 if (! CPP_OPTION (pfile
, c99
) && CPP_OPTION (pfile
, pedantic
))
1283 cpp_error (pfile
, DL_PEDWARN
,
1284 "anonymous variadic macros were introduced in C99");
1286 else if (CPP_OPTION (pfile
, pedantic
))
1287 cpp_error (pfile
, DL_PEDWARN
,
1288 "ISO C does not permit named variadic macros");
1290 /* We're at the end, and just expect a closing parenthesis. */
1291 token
= _cpp_lex_token (pfile
);
1292 if (token
->type
== CPP_CLOSE_PAREN
)
1297 cpp_error (pfile
, DL_ERROR
, "missing ')' in macro parameter list");
1303 /* Allocate room for a token from a macro's replacement list. */
1305 alloc_expansion_token (pfile
, macro
)
1309 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1310 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1312 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1315 /* Lex a token from the expansion of MACRO, but mark parameters as we
1316 find them and warn of traditional stringification. */
1318 lex_expansion_token (pfile
, macro
)
1324 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1325 token
= _cpp_lex_direct (pfile
);
1327 /* Is this a parameter? */
1328 if (token
->type
== CPP_NAME
&& token
->val
.node
->arg_index
)
1330 token
->type
= CPP_MACRO_ARG
;
1331 token
->val
.arg_no
= token
->val
.node
->arg_index
;
1333 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1334 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1335 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1341 create_iso_definition (pfile
, macro
)
1346 const cpp_token
*ctoken
;
1348 /* Get the first token of the expansion (or the '(' of a
1349 function-like macro). */
1350 ctoken
= _cpp_lex_token (pfile
);
1352 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1354 bool ok
= parse_params (pfile
, macro
);
1355 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1359 /* Success. Commit the parameter array. */
1360 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1361 macro
->fun_like
= 1;
1363 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1364 cpp_error (pfile
, DL_PEDWARN
,
1365 "ISO C requires whitespace after the macro name");
1367 if (macro
->fun_like
)
1368 token
= lex_expansion_token (pfile
, macro
);
1371 token
= alloc_expansion_token (pfile
, macro
);
1377 /* Check the stringifying # constraint 6.10.3.2.1 of
1378 function-like macros when lexing the subsequent token. */
1379 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1381 if (token
->type
== CPP_MACRO_ARG
)
1383 token
->flags
&= ~PREV_WHITE
;
1384 token
->flags
|= STRINGIFY_ARG
;
1385 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1386 token
[-1] = token
[0];
1389 /* Let assembler get away with murder. */
1390 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1392 cpp_error (pfile
, DL_ERROR
,
1393 "'#' is not followed by a macro parameter");
1398 if (token
->type
== CPP_EOF
)
1401 /* Paste operator constraint 6.10.3.3.1. */
1402 if (token
->type
== CPP_PASTE
)
1404 /* Token-paste ##, can appear in both object-like and
1405 function-like macros, but not at the ends. */
1406 if (--macro
->count
> 0)
1407 token
= lex_expansion_token (pfile
, macro
);
1409 if (macro
->count
== 0 || token
->type
== CPP_EOF
)
1411 cpp_error (pfile
, DL_ERROR
,
1412 "'##' cannot appear at either end of a macro expansion");
1416 token
[-1].flags
|= PASTE_LEFT
;
1419 token
= lex_expansion_token (pfile
, macro
);
1422 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1424 /* Don't count the CPP_EOF. */
1427 /* Clear whitespace on first token for warn_of_redefinition(). */
1429 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
1431 /* Commit the memory. */
1432 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
1437 /* Parse a macro and save its expansion. Returns non-zero on success. */
1439 _cpp_create_definition (pfile
, node
)
1447 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1448 macro
->line
= pfile
->directive_line
;
1451 macro
->variadic
= 0;
1453 macro
->fun_like
= 0;
1454 /* To suppress some diagnostics. */
1455 macro
->syshdr
= pfile
->map
->sysp
!= 0;
1457 if (CPP_OPTION (pfile
, traditional
))
1458 ok
= _cpp_create_trad_definition (pfile
, macro
);
1461 cpp_token
*saved_cur_token
= pfile
->cur_token
;
1463 ok
= create_iso_definition (pfile
, macro
);
1465 /* Restore lexer position because of games lex_expansion_token()
1466 plays lexing the macro. We set the type for SEEN_EOL() in
1469 Longer term we should lex the whole line before coming here,
1470 and just copy the expansion. */
1471 saved_cur_token
[-1].type
= pfile
->cur_token
[-1].type
;
1472 pfile
->cur_token
= saved_cur_token
;
1474 /* Stop the lexer accepting __VA_ARGS__. */
1475 pfile
->state
.va_args_ok
= 0;
1478 /* Clear the fast argument lookup indices. */
1479 for (i
= macro
->paramc
; i
-- > 0; )
1480 macro
->params
[i
]->arg_index
= 0;
1485 if (node
->type
!= NT_VOID
)
1487 if (warn_of_redefinition (pfile
, node
, macro
))
1489 cpp_error_with_line (pfile
, DL_PEDWARN
, pfile
->directive_line
, 0,
1490 "\"%s\" redefined", NODE_NAME (node
));
1492 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1493 cpp_error_with_line (pfile
, DL_PEDWARN
,
1494 node
->value
.macro
->line
, 0,
1495 "this is the location of the previous definition");
1497 _cpp_free_definition (node
);
1500 /* Enter definition in hash table. */
1501 node
->type
= NT_MACRO
;
1502 node
->value
.macro
= macro
;
1503 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
1504 node
->flags
|= NODE_WARN
;
1509 /* Warn if a token in STRING matches one of a function-like MACRO's
1512 check_trad_stringification (pfile
, macro
, string
)
1514 const cpp_macro
*macro
;
1515 const cpp_string
*string
;
1517 unsigned int i
, len
;
1518 const uchar
*p
, *q
, *limit
= string
->text
+ string
->len
;
1520 /* Loop over the string. */
1521 for (p
= string
->text
; p
< limit
; p
= q
)
1523 /* Find the start of an identifier. */
1524 while (p
< limit
&& !is_idstart (*p
))
1527 /* Find the end of the identifier. */
1529 while (q
< limit
&& is_idchar (*q
))
1534 /* Loop over the function macro arguments to see if the
1535 identifier inside the string matches one of them. */
1536 for (i
= 0; i
< macro
->paramc
; i
++)
1538 const cpp_hashnode
*node
= macro
->params
[i
];
1540 if (NODE_LEN (node
) == len
1541 && !memcmp (p
, NODE_NAME (node
), len
))
1543 cpp_error (pfile
, DL_WARNING
,
1544 "macro argument \"%s\" would be stringified in traditional C",
1552 /* Returns the name, arguments and expansion of a macro, in a format
1553 suitable to be read back in again, and therefore also for DWARF 2
1554 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1555 Caller is expected to generate the "#define" bit if needed. The
1556 returned text is temporary, and automatically freed later. */
1557 const unsigned char *
1558 cpp_macro_definition (pfile
, node
)
1560 const cpp_hashnode
*node
;
1562 unsigned int i
, len
;
1563 const cpp_macro
*macro
= node
->value
.macro
;
1564 unsigned char *buffer
;
1566 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1568 cpp_error (pfile
, DL_ICE
,
1569 "invalid hash type %d in cpp_macro_definition", node
->type
);
1573 /* Calculate length. */
1574 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
1575 if (macro
->fun_like
)
1577 len
+= 4; /* "()" plus possible final ".." of named
1578 varargs (we have + 1 below). */
1579 for (i
= 0; i
< macro
->paramc
; i
++)
1580 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1583 for (i
= 0; i
< macro
->count
; i
++)
1585 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1587 if (token
->type
== CPP_MACRO_ARG
)
1588 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1590 len
+= cpp_token_len (token
); /* Includes room for ' '. */
1591 if (token
->flags
& STRINGIFY_ARG
)
1593 if (token
->flags
& PASTE_LEFT
)
1594 len
+= 3; /* " ##" */
1597 if (len
> pfile
->macro_buffer_len
)
1599 pfile
->macro_buffer
= (uchar
*) xrealloc (pfile
->macro_buffer
, len
);
1600 pfile
->macro_buffer_len
= len
;
1603 /* Fill in the buffer. Start with the macro name. */
1604 buffer
= pfile
->macro_buffer
;
1605 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1606 buffer
+= NODE_LEN (node
);
1608 /* Parameter names. */
1609 if (macro
->fun_like
)
1612 for (i
= 0; i
< macro
->paramc
; i
++)
1614 cpp_hashnode
*param
= macro
->params
[i
];
1616 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1618 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1619 buffer
+= NODE_LEN (param
);
1622 if (i
+ 1 < macro
->paramc
)
1623 /* Don't emit a space after the comma here; we're trying
1624 to emit a Dwarf-friendly definition, and the Dwarf spec
1625 forbids spaces in the argument list. */
1627 else if (macro
->variadic
)
1628 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1633 /* The Dwarf spec requires a space after the macro name, even if the
1634 definition is the empty string. */
1637 /* Expansion tokens. */
1640 for (i
= 0; i
< macro
->count
; i
++)
1642 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1644 if (token
->flags
& PREV_WHITE
)
1646 if (token
->flags
& STRINGIFY_ARG
)
1649 if (token
->type
== CPP_MACRO_ARG
)
1651 len
= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1653 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]), len
);
1657 buffer
= cpp_spell_token (pfile
, token
, buffer
);
1659 if (token
->flags
& PASTE_LEFT
)
1664 /* Next has PREV_WHITE; see _cpp_create_definition. */
1670 return pfile
->macro_buffer
;