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, 2003, 2004, 2005,
4 2006, 2007 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23 In other words, you are welcome to use, share and improve this program.
24 You are forbidden to forbid anyone else to use, share and improve
25 what you give them. Help stamp out software-hoarding! */
32 typedef struct macro_arg macro_arg;
35 const cpp_token **first; /* First token in unexpanded argument. */
36 const cpp_token **expanded; /* Macro-expanded argument. */
37 const cpp_token *stringified; /* Stringified argument. */
38 unsigned int count; /* # of tokens in argument. */
39 unsigned int expanded_count; /* # of tokens in expanded argument. */
42 /* Macro expansion. */
44 static int enter_macro_context (cpp_reader *, cpp_hashnode *);
45 static int builtin_macro (cpp_reader *, cpp_hashnode *);
46 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
47 const cpp_token **, unsigned int);
48 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *);
49 static cpp_context *next_context (cpp_reader *);
50 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
51 static void expand_arg (cpp_reader *, macro_arg *);
52 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
53 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
54 static void paste_all_tokens (cpp_reader *, const cpp_token *);
55 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
56 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
58 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *);
59 static bool create_iso_definition (cpp_reader *, cpp_macro *);
61 /* #define directive parsing and handling. */
63 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
64 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
65 static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,
67 static bool parse_params (cpp_reader *, cpp_macro *);
68 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
71 /* Emits a warning if NODE is a macro defined in the main file that
74 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
75 void *v ATTRIBUTE_UNUSED)
77 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
79 cpp_macro *macro = node->value.macro;
82 && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
83 cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
84 "macro \"%s\" is not used", NODE_NAME (node));
90 /* Allocates and returns a CPP_STRING token, containing TEXT of length
91 LEN, after null-terminating it. TEXT must be in permanent storage. */
92 static const cpp_token *
93 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
95 cpp_token *token = _cpp_temp_token (pfile);
98 token->type = CPP_STRING;
99 token->val.str.len = len;
100 token->val.str.text = text;
105 static const char * const monthnames[] =
107 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
108 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
111 /* Helper function for builtin_macro. Returns the text generated by
114 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
116 const struct line_map *map;
117 const uchar *result = NULL;
118 unsigned int number = 1;
120 switch (node->value.builtin)
123 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
129 cpp_buffer *pbuffer = cpp_get_buffer (pfile);
130 if (pbuffer->timestamp == NULL)
132 /* Initialize timestamp value of the assotiated file. */
133 struct _cpp_file *file = cpp_get_file (pbuffer);
136 /* Generate __TIMESTAMP__ string, that represents
137 the date and time of the last modification
138 of the current source file. The string constant
139 looks like "Sun Sep 16 01:03:52 1973". */
140 struct tm *tb = NULL;
141 struct stat *st = _cpp_get_file_stat (file);
143 tb = localtime (&st->st_mtime);
146 char *str = asctime (tb);
147 size_t len = strlen (str);
148 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
150 strcpy ((char *) buf + 1, str);
152 pbuffer->timestamp = buf;
156 cpp_errno (pfile, CPP_DL_WARNING,
157 "could not determine file timestamp");
158 pbuffer->timestamp = U"\"??? ??? ?? ??:??:?? ????\"";
162 result = pbuffer->timestamp;
171 map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
173 if (node->value.builtin == BT_BASE_FILE)
174 while (! MAIN_FILE_P (map))
175 map = INCLUDED_FROM (pfile->line_table, map);
179 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
182 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
188 case BT_INCLUDE_LEVEL:
189 /* The line map depth counts the primary source as level 1, but
190 historically __INCLUDE_DEPTH__ has called the primary source
192 number = pfile->line_table->depth - 1;
196 map = &pfile->line_table->maps[pfile->line_table->used-1];
197 /* If __LINE__ is embedded in a macro, it must expand to the
198 line of the macro's invocation, not its definition.
199 Otherwise things like assert() will not work properly. */
200 if (CPP_OPTION (pfile, traditional))
201 number = pfile->line_table->highest_line;
203 number = pfile->cur_token[-1].src_loc;
204 number = SOURCE_LINE (map, number);
207 /* __STDC__ has the value 1 under normal circumstances.
208 However, if (a) we are in a system header, (b) the option
209 stdc_0_in_system_headers is true (set by target config), and
210 (c) we are not in strictly conforming mode, then it has the
211 value 0. (b) and (c) are already checked in cpp_init_builtins. */
213 if (cpp_in_system_header (pfile))
221 if (pfile->date == NULL)
223 /* Allocate __DATE__ and __TIME__ strings from permanent
224 storage. We only do this once, and don't generate them
225 at init time, because time() and localtime() are very
226 slow on some systems. */
228 struct tm *tb = NULL;
230 /* (time_t) -1 is a legitimate value for "number of seconds
231 since the Epoch", so we have to do a little dance to
232 distinguish that from a genuine error. */
235 if (tt != (time_t)-1 || errno == 0)
236 tb = localtime (&tt);
240 pfile->date = _cpp_unaligned_alloc (pfile,
241 sizeof ("\"Oct 11 1347\""));
242 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
243 monthnames[tb->tm_mon], tb->tm_mday,
246 pfile->time = _cpp_unaligned_alloc (pfile,
247 sizeof ("\"12:34:56\""));
248 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
249 tb->tm_hour, tb->tm_min, tb->tm_sec);
253 cpp_errno (pfile, CPP_DL_WARNING,
254 "could not determine date and time");
256 pfile->date = U"\"??? ?? ????\"";
257 pfile->time = U"\"??:??:??\"";
261 if (node->value.builtin == BT_DATE)
262 result = pfile->date;
264 result = pfile->time;
268 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
269 cpp_error (pfile, CPP_DL_ERROR,
270 "__COUNTER__ expanded inside directive with -fdirectives-only");
271 number = pfile->counter++;
277 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
278 result = _cpp_unaligned_alloc (pfile, 21);
279 sprintf ((char *) result, "%u", number);
285 /* Convert builtin macros like __FILE__ to a token and push it on the
286 context stack. Also handles _Pragma, for which a new token may not
287 be created. Returns 1 if it generates a new token context, 0 to
288 return the token to the caller. */
290 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
296 if (node->value.builtin == BT_PRAGMA)
298 /* Don't interpret _Pragma within directives. The standard is
299 not clear on this, but to me this makes most sense. */
300 if (pfile->state.in_directive)
303 return _cpp_do__Pragma (pfile);
306 buf = _cpp_builtin_macro_text (pfile, node);
308 nbuf = (char *) alloca (len + 1);
309 memcpy (nbuf, buf, len);
312 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
313 _cpp_clean_line (pfile);
315 /* Set pfile->cur_token as required by _cpp_lex_direct. */
316 pfile->cur_token = _cpp_temp_token (pfile);
317 _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
318 if (pfile->buffer->cur != pfile->buffer->rlimit)
319 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
321 _cpp_pop_buffer (pfile);
326 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
327 backslashes and double quotes. DEST must be of sufficient size.
328 Returns a pointer to the end of the string. */
330 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
336 if (c == '\\' || c == '"')
348 /* Convert a token sequence ARG to a single string token according to
349 the rules of the ISO C #-operator. */
350 static const cpp_token *
351 stringify_arg (cpp_reader *pfile, macro_arg *arg)
354 unsigned int i, escape_it, backslash_count = 0;
355 const cpp_token *source = NULL;
358 if (BUFF_ROOM (pfile->u_buff) < 3)
359 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
360 dest = BUFF_FRONT (pfile->u_buff);
363 /* Loop, reading in the argument's tokens. */
364 for (i = 0; i < arg->count; i++)
366 const cpp_token *token = arg->first[i];
368 if (token->type == CPP_PADDING)
371 source = token->val.source;
375 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
376 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
378 /* Room for each char being written in octal, initial space and
379 final quote and NUL. */
380 len = cpp_token_len (token);
385 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
387 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
388 _cpp_extend_buff (pfile, &pfile->u_buff, len);
389 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
392 /* Leading white space? */
393 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
397 if (source->flags & PREV_WHITE)
404 _cpp_buff *buff = _cpp_get_buff (pfile, len);
405 unsigned char *buf = BUFF_FRONT (buff);
406 len = cpp_spell_token (pfile, token, buf, true) - buf;
407 dest = cpp_quote_string (dest, buf, len);
408 _cpp_release_buff (pfile, buff);
411 dest = cpp_spell_token (pfile, token, dest, true);
413 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
419 /* Ignore the final \ of invalid string literals. */
420 if (backslash_count & 1)
422 cpp_error (pfile, CPP_DL_WARNING,
423 "invalid string literal, ignoring final '\\'");
427 /* Commit the memory, including NUL, and return the token. */
429 len = dest - BUFF_FRONT (pfile->u_buff);
430 BUFF_FRONT (pfile->u_buff) = dest + 1;
431 return new_string_token (pfile, dest - len, len);
434 /* Try to paste two tokens. On success, return nonzero. In any
435 case, PLHS is updated to point to the pasted token, which is
436 guaranteed to not have the PASTE_LEFT flag set. */
438 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
440 unsigned char *buf, *end, *lhsend;
444 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
445 buf = (unsigned char *) alloca (len);
446 end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
448 /* Avoid comment headers, since they are still processed in stage 3.
449 It is simpler to insert a space here, rather than modifying the
450 lexer to ignore comments in some circumstances. Simply returning
451 false doesn't work, since we want to clear the PASTE_LEFT flag. */
452 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
454 /* In one obscure case we might see padding here. */
455 if (rhs->type != CPP_PADDING)
456 end = cpp_spell_token (pfile, rhs, end, false);
459 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
460 _cpp_clean_line (pfile);
462 /* Set pfile->cur_token as required by _cpp_lex_direct. */
463 pfile->cur_token = _cpp_temp_token (pfile);
464 lhs = _cpp_lex_direct (pfile);
465 if (pfile->buffer->cur != pfile->buffer->rlimit)
467 source_location saved_loc = lhs->src_loc;
469 _cpp_pop_buffer (pfile);
470 _cpp_backup_tokens (pfile, 1);
473 /* We have to remove the PASTE_LEFT flag from the old lhs, but
474 we want to keep the new location. */
477 lhs->src_loc = saved_loc;
478 lhs->flags &= ~PASTE_LEFT;
480 /* Mandatory error for all apart from assembler. */
481 if (CPP_OPTION (pfile, lang) != CLK_ASM)
482 cpp_error (pfile, CPP_DL_ERROR,
483 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
484 buf, cpp_token_as_text (pfile, rhs));
489 _cpp_pop_buffer (pfile);
493 /* Handles an arbitrarily long sequence of ## operators, with initial
494 operand LHS. This implementation is left-associative,
495 non-recursive, and finishes a paste before handling succeeding
496 ones. If a paste fails, we back up to the RHS of the failing ##
497 operator before pushing the context containing the result of prior
498 successful pastes, with the effect that the RHS appears in the
499 output stream after the pasted LHS normally. */
501 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
503 const cpp_token *rhs;
504 cpp_context *context = pfile->context;
508 /* Take the token directly from the current context. We can do
509 this, because we are in the replacement list of either an
510 object-like macro, or a function-like macro with arguments
511 inserted. In either case, the constraints to #define
512 guarantee we have at least one more token. */
513 if (context->direct_p)
514 rhs = FIRST (context).token++;
516 rhs = *FIRST (context).ptoken++;
518 if (rhs->type == CPP_PADDING)
520 if (rhs->flags & PASTE_LEFT)
523 if (!paste_tokens (pfile, &lhs, rhs))
526 while (rhs->flags & PASTE_LEFT);
528 /* Put the resulting token in its own context. */
529 _cpp_push_token_context (pfile, NULL, lhs, 1);
532 /* Returns TRUE if the number of arguments ARGC supplied in an
533 invocation of the MACRO referenced by NODE is valid. An empty
534 invocation to a macro with no parameters should pass ARGC as zero.
536 Note that MACRO cannot necessarily be deduced from NODE, in case
537 NODE was redefined whilst collecting arguments. */
539 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
541 if (argc == macro->paramc)
544 if (argc < macro->paramc)
546 /* As an extension, a rest argument is allowed to not appear in
547 the invocation at all.
548 e.g. #define debug(format, args...) something
551 This is exactly the same as if there had been an empty rest
552 argument - debug("string", ). */
554 if (argc + 1 == macro->paramc && macro->variadic)
556 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
557 cpp_error (pfile, CPP_DL_PEDWARN,
558 "ISO C99 requires rest arguments to be used");
562 cpp_error (pfile, CPP_DL_ERROR,
563 "macro \"%s\" requires %u arguments, but only %u given",
564 NODE_NAME (node), macro->paramc, argc);
567 cpp_error (pfile, CPP_DL_ERROR,
568 "macro \"%s\" passed %u arguments, but takes just %u",
569 NODE_NAME (node), argc, macro->paramc);
574 /* Reads and returns the arguments to a function-like macro
575 invocation. Assumes the opening parenthesis has been processed.
576 If there is an error, emits an appropriate diagnostic and returns
577 NULL. Each argument is terminated by a CPP_EOF token, for the
578 future benefit of expand_arg(). */
580 collect_args (cpp_reader *pfile, const cpp_hashnode *node)
582 _cpp_buff *buff, *base_buff;
584 macro_arg *args, *arg;
585 const cpp_token *token;
588 macro = node->value.macro;
590 argc = macro->paramc;
593 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
594 + sizeof (macro_arg)));
596 args = (macro_arg *) buff->base;
597 memset (args, 0, argc * sizeof (macro_arg));
598 buff->cur = (unsigned char *) &args[argc];
599 arg = args, argc = 0;
601 /* Collect the tokens making up each argument. We don't yet know
602 how many arguments have been supplied, whether too many or too
603 few. Hence the slightly bizarre usage of "argc" and "arg". */
606 unsigned int paren_depth = 0;
607 unsigned int ntokens = 0;
610 arg->first = (const cpp_token **) buff->cur;
614 /* Require space for 2 new tokens (including a CPP_EOF). */
615 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
617 buff = _cpp_append_extend_buff (pfile, buff,
618 1000 * sizeof (cpp_token *));
619 arg->first = (const cpp_token **) buff->cur;
622 token = cpp_get_token (pfile);
624 if (token->type == CPP_PADDING)
626 /* Drop leading padding. */
630 else if (token->type == CPP_OPEN_PAREN)
632 else if (token->type == CPP_CLOSE_PAREN)
634 if (paren_depth-- == 0)
637 else if (token->type == CPP_COMMA)
639 /* A comma does not terminate an argument within
640 parentheses or as part of a variable argument. */
642 && ! (macro->variadic && argc == macro->paramc))
645 else if (token->type == CPP_EOF
646 || (token->type == CPP_HASH && token->flags & BOL))
649 arg->first[ntokens++] = token;
652 /* Drop trailing padding. */
653 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
656 arg->count = ntokens;
657 arg->first[ntokens] = &pfile->eof;
659 /* Terminate the argument. Excess arguments loop back and
660 overwrite the final legitimate argument, before failing. */
661 if (argc <= macro->paramc)
663 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
664 if (argc != macro->paramc)
668 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
670 if (token->type == CPP_EOF)
672 /* We still need the CPP_EOF to end directives, and to end
673 pre-expansion of a macro argument. Step back is not
674 unconditional, since we don't want to return a CPP_EOF to our
675 callers at the end of an -include-d file. */
676 if (pfile->context->prev || pfile->state.in_directive)
677 _cpp_backup_tokens (pfile, 1);
678 cpp_error (pfile, CPP_DL_ERROR,
679 "unterminated argument list invoking macro \"%s\"",
684 /* A single empty argument is counted as no argument. */
685 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
687 if (_cpp_arguments_ok (pfile, macro, node, argc))
689 /* GCC has special semantics for , ## b where b is a varargs
690 parameter: we remove the comma if b was omitted entirely.
691 If b was merely an empty argument, the comma is retained.
692 If the macro takes just one (varargs) parameter, then we
693 retain the comma only if we are standards conforming.
695 If FIRST is NULL replace_args () swallows the comma. */
696 if (macro->variadic && (argc < macro->paramc
697 || (argc == 1 && args[0].count == 0
698 && !CPP_OPTION (pfile, std))))
699 args[macro->paramc - 1].first = NULL;
704 /* An error occurred. */
705 _cpp_release_buff (pfile, base_buff);
709 /* Search for an opening parenthesis to the macro of NODE, in such a
710 way that, if none is found, we don't lose the information in any
711 intervening padding tokens. If we find the parenthesis, collect
712 the arguments and return the buffer containing them. */
714 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node)
716 const cpp_token *token, *padding = NULL;
720 token = cpp_get_token (pfile);
721 if (token->type != CPP_PADDING)
724 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
728 if (token->type == CPP_OPEN_PAREN)
730 pfile->state.parsing_args = 2;
731 return collect_args (pfile, node);
734 /* CPP_EOF can be the end of macro arguments, or the end of the
735 file. We mustn't back up over the latter. Ugh. */
736 if (token->type != CPP_EOF || token == &pfile->eof)
738 /* Back up. We may have skipped padding, in which case backing
739 up more than one token when expanding macros is in general
740 too difficult. We re-insert it in its own context. */
741 _cpp_backup_tokens (pfile, 1);
743 _cpp_push_token_context (pfile, NULL, padding, 1);
749 /* Push the context of a macro with hash entry NODE onto the context
750 stack. If we can successfully expand the macro, we push a context
751 containing its yet-to-be-rescanned replacement list and return one.
752 Otherwise, we don't push a context and return zero. */
754 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node)
756 /* The presence of a macro invalidates a file's controlling macro. */
757 pfile->mi_valid = false;
759 pfile->state.angled_headers = false;
761 /* Handle standard macros. */
762 if (! (node->flags & NODE_BUILTIN))
764 cpp_macro *macro = node->value.macro;
770 pfile->state.prevent_expansion++;
771 pfile->keep_tokens++;
772 pfile->state.parsing_args = 1;
773 buff = funlike_invocation_p (pfile, node);
774 pfile->state.parsing_args = 0;
775 pfile->keep_tokens--;
776 pfile->state.prevent_expansion--;
780 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
781 cpp_error (pfile, CPP_DL_WARNING,
782 "function-like macro \"%s\" must be used with arguments in traditional C",
788 if (macro->paramc > 0)
789 replace_args (pfile, node, macro, (macro_arg *) buff->base);
790 _cpp_release_buff (pfile, buff);
793 /* Disable the macro within its expansion. */
794 node->flags |= NODE_DISABLED;
798 if (macro->paramc == 0)
799 _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
804 /* Handle built-in macros and the _Pragma operator. */
805 return builtin_macro (pfile, node);
808 /* Replace the parameters in a function-like macro of NODE with the
809 actual ARGS, and place the result in a newly pushed token context.
810 Expand each argument before replacing, unless it is operated upon
811 by the # or ## operators. */
813 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
815 unsigned int i, total;
816 const cpp_token *src, *limit;
817 const cpp_token **dest, **first;
821 /* First, fully macro-expand arguments, calculating the number of
822 tokens in the final expansion as we go. The ordering of the if
823 statements below is subtle; we must handle stringification before
825 total = macro->count;
826 limit = macro->exp.tokens + macro->count;
828 for (src = macro->exp.tokens; src < limit; src++)
829 if (src->type == CPP_MACRO_ARG)
831 /* Leading and trailing padding tokens. */
834 /* We have an argument. If it is not being stringified or
835 pasted it is macro-replaced before insertion. */
836 arg = &args[src->val.arg_no - 1];
838 if (src->flags & STRINGIFY_ARG)
840 if (!arg->stringified)
841 arg->stringified = stringify_arg (pfile, arg);
843 else if ((src->flags & PASTE_LEFT)
844 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
845 total += arg->count - 1;
849 expand_arg (pfile, arg);
850 total += arg->expanded_count - 1;
854 /* Now allocate space for the expansion, copy the tokens and replace
856 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
857 first = (const cpp_token **) buff->base;
860 for (src = macro->exp.tokens; src < limit; src++)
863 const cpp_token **from, **paste_flag;
865 if (src->type != CPP_MACRO_ARG)
872 arg = &args[src->val.arg_no - 1];
873 if (src->flags & STRINGIFY_ARG)
874 count = 1, from = &arg->stringified;
875 else if (src->flags & PASTE_LEFT)
876 count = arg->count, from = arg->first;
877 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
879 count = arg->count, from = arg->first;
882 if (dest[-1]->type == CPP_COMMA
884 && src->val.arg_no == macro->paramc)
886 /* Swallow a pasted comma if from == NULL, otherwise
887 drop the paste flag. */
891 paste_flag = dest - 1;
893 /* Remove the paste flag if the RHS is a placemarker. */
895 paste_flag = dest - 1;
899 count = arg->expanded_count, from = arg->expanded;
901 /* Padding on the left of an argument (unless RHS of ##). */
902 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
903 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
904 *dest++ = padding_token (pfile, src);
908 memcpy (dest, from, count * sizeof (cpp_token *));
911 /* With a non-empty argument on the LHS of ##, the last
912 token should be flagged PASTE_LEFT. */
913 if (src->flags & PASTE_LEFT)
914 paste_flag = dest - 1;
917 /* Avoid paste on RHS (even case count == 0). */
918 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
919 *dest++ = &pfile->avoid_paste;
921 /* Add a new paste flag, or remove an unwanted one. */
924 cpp_token *token = _cpp_temp_token (pfile);
925 token->type = (*paste_flag)->type;
926 token->val = (*paste_flag)->val;
927 if (src->flags & PASTE_LEFT)
928 token->flags = (*paste_flag)->flags | PASTE_LEFT;
930 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
935 /* Free the expanded arguments. */
936 for (i = 0; i < macro->paramc; i++)
937 if (args[i].expanded)
938 free (args[i].expanded);
940 push_ptoken_context (pfile, node, buff, first, dest - first);
943 /* Return a special padding token, with padding inherited from SOURCE. */
944 static const cpp_token *
945 padding_token (cpp_reader *pfile, const cpp_token *source)
947 cpp_token *result = _cpp_temp_token (pfile);
949 result->type = CPP_PADDING;
951 /* Data in GCed data structures cannot be made const so far, so we
953 result->val.source = (cpp_token *) source;
958 /* Get a new uninitialized context. Create a new one if we cannot
959 re-use an old one. */
961 next_context (cpp_reader *pfile)
963 cpp_context *result = pfile->context->next;
967 result = XNEW (cpp_context);
968 result->prev = pfile->context;
970 pfile->context->next = result;
973 pfile->context = result;
977 /* Push a list of pointers to tokens. */
979 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
980 const cpp_token **first, unsigned int count)
982 cpp_context *context = next_context (pfile);
984 context->direct_p = false;
985 context->macro = macro;
986 context->buff = buff;
987 FIRST (context).ptoken = first;
988 LAST (context).ptoken = first + count;
991 /* Push a list of tokens. */
993 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
994 const cpp_token *first, unsigned int count)
996 cpp_context *context = next_context (pfile);
998 context->direct_p = true;
999 context->macro = macro;
1000 context->buff = NULL;
1001 FIRST (context).token = first;
1002 LAST (context).token = first + count;
1005 /* Push a traditional macro's replacement text. */
1007 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1008 const uchar *start, size_t len)
1010 cpp_context *context = next_context (pfile);
1012 context->direct_p = true;
1013 context->macro = macro;
1014 context->buff = NULL;
1015 CUR (context) = start;
1016 RLIMIT (context) = start + len;
1017 macro->flags |= NODE_DISABLED;
1020 /* Expand an argument ARG before replacing parameters in a
1021 function-like macro. This works by pushing a context with the
1022 argument's tokens, and then expanding that into a temporary buffer
1023 as if it were a normal part of the token stream. collect_args()
1024 has terminated the argument's tokens with a CPP_EOF so that we know
1025 when we have fully expanded the argument. */
1027 expand_arg (cpp_reader *pfile, macro_arg *arg)
1029 unsigned int capacity;
1030 bool saved_warn_trad;
1032 if (arg->count == 0)
1035 /* Don't warn about funlike macros when pre-expanding. */
1036 saved_warn_trad = CPP_WTRADITIONAL (pfile);
1037 CPP_WTRADITIONAL (pfile) = 0;
1039 /* Loop, reading in the arguments. */
1041 arg->expanded = XNEWVEC (const cpp_token *, capacity);
1043 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1046 const cpp_token *token;
1048 if (arg->expanded_count + 1 >= capacity)
1051 arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1055 token = cpp_get_token (pfile);
1057 if (token->type == CPP_EOF)
1060 arg->expanded[arg->expanded_count++] = token;
1063 _cpp_pop_context (pfile);
1065 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1068 /* Pop the current context off the stack, re-enabling the macro if the
1069 context represented a macro's replacement list. The context
1070 structure is not freed so that we can re-use it later. */
1072 _cpp_pop_context (cpp_reader *pfile)
1074 cpp_context *context = pfile->context;
1077 context->macro->flags &= ~NODE_DISABLED;
1080 _cpp_release_buff (pfile, context->buff);
1082 pfile->context = context->prev;
1085 /* External routine to get a token. Also used nearly everywhere
1086 internally, except for places where we know we can safely call
1087 _cpp_lex_token directly, such as lexing a directive name.
1089 Macro expansions and directives are transparently handled,
1090 including entering included files. Thus tokens are post-macro
1091 expansion, and after any intervening directives. External callers
1092 see CPP_EOF only at EOF. Internal callers also see it when meeting
1093 a directive inside a macro call, when at the end of a directive and
1094 state.in_directive is still 1, and at the end of argument
1097 cpp_get_token (cpp_reader *pfile)
1099 const cpp_token *result;
1100 bool can_set = pfile->set_invocation_location;
1101 pfile->set_invocation_location = false;
1106 cpp_context *context = pfile->context;
1108 /* Context->prev == 0 <=> base context. */
1110 result = _cpp_lex_token (pfile);
1111 else if (FIRST (context).token != LAST (context).token)
1113 if (context->direct_p)
1114 result = FIRST (context).token++;
1116 result = *FIRST (context).ptoken++;
1118 if (result->flags & PASTE_LEFT)
1120 paste_all_tokens (pfile, result);
1121 if (pfile->state.in_directive)
1123 return padding_token (pfile, result);
1128 _cpp_pop_context (pfile);
1129 if (pfile->state.in_directive)
1131 return &pfile->avoid_paste;
1134 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1137 if (result->type != CPP_NAME)
1140 node = result->val.node;
1142 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1145 if (!(node->flags & NODE_DISABLED))
1147 /* If not in a macro context, and we're going to start an
1148 expansion, record the location. */
1149 if (can_set && !context->macro)
1150 pfile->invocation_location = result->src_loc;
1151 if (!pfile->state.prevent_expansion
1152 && enter_macro_context (pfile, node))
1154 if (pfile->state.in_directive)
1156 return padding_token (pfile, result);
1161 /* Flag this token as always unexpandable. FIXME: move this
1162 to collect_args()?. */
1163 cpp_token *t = _cpp_temp_token (pfile);
1164 t->type = result->type;
1165 t->flags = result->flags | NO_EXPAND;
1166 t->val = result->val;
1176 /* Like cpp_get_token, but also returns a location separate from the
1177 one provided by the returned token. LOC is an out parameter; *LOC
1178 is set to the location "as expected by the user". This matters
1179 when a token results from macro expansion -- the token's location
1180 will indicate where the macro is defined, but *LOC will be the
1181 location of the start of the expansion. */
1183 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1185 const cpp_token *result;
1187 pfile->set_invocation_location = true;
1188 result = cpp_get_token (pfile);
1189 if (pfile->context->macro)
1190 *loc = pfile->invocation_location;
1192 *loc = result->src_loc;
1197 /* Returns true if we're expanding an object-like macro that was
1198 defined in a system header. Just checks the macro at the top of
1199 the stack. Used for diagnostic suppression. */
1201 cpp_sys_macro_p (cpp_reader *pfile)
1203 cpp_hashnode *node = pfile->context->macro;
1205 return node && node->value.macro && node->value.macro->syshdr;
1208 /* Read each token in, until end of the current file. Directives are
1209 transparently processed. */
1211 cpp_scan_nooutput (cpp_reader *pfile)
1213 /* Request a CPP_EOF token at the end of this file, rather than
1214 transparently continuing with the including file. */
1215 pfile->buffer->return_at_eof = true;
1217 pfile->state.discarding_output++;
1218 pfile->state.prevent_expansion++;
1220 if (CPP_OPTION (pfile, traditional))
1221 while (_cpp_read_logical_line_trad (pfile))
1224 while (cpp_get_token (pfile)->type != CPP_EOF)
1227 pfile->state.discarding_output--;
1228 pfile->state.prevent_expansion--;
1231 /* Step back one (or more) tokens. Can only step back more than 1 if
1232 they are from the lexer, and not from macro expansion. */
1234 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1236 if (pfile->context->prev == NULL)
1238 pfile->lookaheads += count;
1242 if (pfile->cur_token == pfile->cur_run->base
1243 /* Possible with -fpreprocessed and no leading #line. */
1244 && pfile->cur_run->prev != NULL)
1246 pfile->cur_run = pfile->cur_run->prev;
1247 pfile->cur_token = pfile->cur_run->limit;
1255 if (pfile->context->direct_p)
1256 FIRST (pfile->context).token--;
1258 FIRST (pfile->context).ptoken--;
1262 /* #define directive parsing and handling. */
1264 /* Returns nonzero if a macro redefinition warning is required. */
1266 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1267 const cpp_macro *macro2)
1269 const cpp_macro *macro1;
1272 /* Some redefinitions need to be warned about regardless. */
1273 if (node->flags & NODE_WARN)
1276 /* Redefinition of a macro is allowed if and only if the old and new
1277 definitions are the same. (6.10.3 paragraph 2). */
1278 macro1 = node->value.macro;
1280 /* Don't check count here as it can be different in valid
1281 traditional redefinitions with just whitespace differences. */
1282 if (macro1->paramc != macro2->paramc
1283 || macro1->fun_like != macro2->fun_like
1284 || macro1->variadic != macro2->variadic)
1287 /* Check parameter spellings. */
1288 for (i = 0; i < macro1->paramc; i++)
1289 if (macro1->params[i] != macro2->params[i])
1292 /* Check the replacement text or tokens. */
1293 if (CPP_OPTION (pfile, traditional))
1294 return _cpp_expansions_different_trad (macro1, macro2);
1296 if (macro1->count != macro2->count)
1299 for (i = 0; i < macro1->count; i++)
1300 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
1306 /* Free the definition of hashnode H. */
1308 _cpp_free_definition (cpp_hashnode *h)
1310 /* Macros and assertions no longer have anything to free. */
1312 /* Clear builtin flag in case of redefinition. */
1313 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1316 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1317 zero on success, nonzero if the parameter is a duplicate. */
1319 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1322 /* Constraint 6.10.3.6 - duplicate parameter names. */
1323 if (node->flags & NODE_MACRO_ARG)
1325 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1330 if (BUFF_ROOM (pfile->a_buff)
1331 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1332 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1334 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1335 node->flags |= NODE_MACRO_ARG;
1336 len = macro->paramc * sizeof (union _cpp_hashnode_value);
1337 if (len > pfile->macro_buffer_len)
1339 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1341 pfile->macro_buffer_len = len;
1343 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1346 node->value.arg_index = macro->paramc;
1350 /* Check the syntax of the parameters in a MACRO definition. Returns
1351 false if an error occurs. */
1353 parse_params (cpp_reader *pfile, cpp_macro *macro)
1355 unsigned int prev_ident = 0;
1359 const cpp_token *token = _cpp_lex_token (pfile);
1361 switch (token->type)
1364 /* Allow/ignore comments in parameter lists if we are
1365 preserving comments in macro expansions. */
1366 if (token->type == CPP_COMMENT
1367 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1370 cpp_error (pfile, CPP_DL_ERROR,
1371 "\"%s\" may not appear in macro parameter list",
1372 cpp_token_as_text (pfile, token));
1378 cpp_error (pfile, CPP_DL_ERROR,
1379 "macro parameters must be comma-separated");
1384 if (_cpp_save_parameter (pfile, macro, token->val.node))
1388 case CPP_CLOSE_PAREN:
1389 if (prev_ident || macro->paramc == 0)
1392 /* Fall through to pick up the error. */
1396 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1403 macro->variadic = 1;
1406 _cpp_save_parameter (pfile, macro,
1407 pfile->spec_nodes.n__VA_ARGS__);
1408 pfile->state.va_args_ok = 1;
1409 if (! CPP_OPTION (pfile, c99)
1410 && CPP_OPTION (pfile, pedantic)
1411 && CPP_OPTION (pfile, warn_variadic_macros))
1412 cpp_error (pfile, CPP_DL_PEDWARN,
1413 "anonymous variadic macros were introduced in C99");
1415 else if (CPP_OPTION (pfile, pedantic)
1416 && CPP_OPTION (pfile, warn_variadic_macros))
1417 cpp_error (pfile, CPP_DL_PEDWARN,
1418 "ISO C does not permit named variadic macros");
1420 /* We're at the end, and just expect a closing parenthesis. */
1421 token = _cpp_lex_token (pfile);
1422 if (token->type == CPP_CLOSE_PAREN)
1427 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1433 /* Allocate room for a token from a macro's replacement list. */
1435 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1437 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1438 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1440 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1443 /* Lex a token from the expansion of MACRO, but mark parameters as we
1444 find them and warn of traditional stringification. */
1446 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1448 cpp_token *token, *saved_cur_token;
1450 saved_cur_token = pfile->cur_token;
1451 pfile->cur_token = alloc_expansion_token (pfile, macro);
1452 token = _cpp_lex_direct (pfile);
1453 pfile->cur_token = saved_cur_token;
1455 /* Is this a parameter? */
1456 if (token->type == CPP_NAME
1457 && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1459 token->type = CPP_MACRO_ARG;
1460 token->val.arg_no = token->val.node->value.arg_index;
1462 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1463 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1464 check_trad_stringification (pfile, macro, &token->val.str);
1470 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1473 const cpp_token *ctoken;
1474 bool following_paste_op = false;
1475 const char *paste_op_error_msg =
1476 N_("'##' cannot appear at either end of a macro expansion");
1478 /* Get the first token of the expansion (or the '(' of a
1479 function-like macro). */
1480 ctoken = _cpp_lex_token (pfile);
1482 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1484 bool ok = parse_params (pfile, macro);
1485 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1489 /* Success. Commit or allocate the parameter array. */
1490 if (pfile->hash_table->alloc_subobject)
1492 cpp_hashnode **params =
1493 (cpp_hashnode **) pfile->hash_table->alloc_subobject
1494 (sizeof (cpp_hashnode *) * macro->paramc);
1495 memcpy (params, macro->params,
1496 sizeof (cpp_hashnode *) * macro->paramc);
1497 macro->params = params;
1500 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
1501 macro->fun_like = 1;
1503 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1505 /* While ISO C99 requires whitespace before replacement text
1506 in a macro definition, ISO C90 with TC1 allows there characters
1507 from the basic source character set. */
1508 if (CPP_OPTION (pfile, c99))
1509 cpp_error (pfile, CPP_DL_PEDWARN,
1510 "ISO C99 requires whitespace after the macro name");
1513 int warntype = CPP_DL_WARNING;
1514 switch (ctoken->type)
1518 case CPP_OBJC_STRING:
1519 /* '@' is not in basic character set. */
1520 warntype = CPP_DL_PEDWARN;
1523 /* Basic character set sans letters, digits and _. */
1524 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1525 ctoken->val.str.text[0]) == NULL)
1526 warntype = CPP_DL_PEDWARN;
1529 /* All other tokens start with a character from basic
1533 cpp_error (pfile, warntype,
1534 "missing whitespace after the macro name");
1538 if (macro->fun_like)
1539 token = lex_expansion_token (pfile, macro);
1542 token = alloc_expansion_token (pfile, macro);
1548 /* Check the stringifying # constraint 6.10.3.2.1 of
1549 function-like macros when lexing the subsequent token. */
1550 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1552 if (token->type == CPP_MACRO_ARG)
1554 token->flags &= ~PREV_WHITE;
1555 token->flags |= STRINGIFY_ARG;
1556 token->flags |= token[-1].flags & PREV_WHITE;
1557 token[-1] = token[0];
1560 /* Let assembler get away with murder. */
1561 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1563 cpp_error (pfile, CPP_DL_ERROR,
1564 "'#' is not followed by a macro parameter");
1569 if (token->type == CPP_EOF)
1571 /* Paste operator constraint 6.10.3.3.1:
1572 Token-paste ##, can appear in both object-like and
1573 function-like macros, but not at the end. */
1574 if (following_paste_op)
1576 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1582 /* Paste operator constraint 6.10.3.3.1. */
1583 if (token->type == CPP_PASTE)
1585 /* Token-paste ##, can appear in both object-like and
1586 function-like macros, but not at the beginning. */
1587 if (macro->count == 1)
1589 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1594 token[-1].flags |= PASTE_LEFT;
1597 following_paste_op = (token->type == CPP_PASTE);
1598 token = lex_expansion_token (pfile, macro);
1601 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1602 macro->traditional = 0;
1604 /* Don't count the CPP_EOF. */
1607 /* Clear whitespace on first token for warn_of_redefinition(). */
1609 macro->exp.tokens[0].flags &= ~PREV_WHITE;
1611 /* Commit or allocate the memory. */
1612 if (pfile->hash_table->alloc_subobject)
1615 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1617 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1618 macro->exp.tokens = tokns;
1621 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
1626 /* Parse a macro and save its expansion. Returns nonzero on success. */
1628 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1634 if (pfile->hash_table->alloc_subobject)
1635 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1636 (sizeof (cpp_macro));
1638 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1639 macro->line = pfile->directive_line;
1642 macro->variadic = 0;
1643 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1645 macro->fun_like = 0;
1646 /* To suppress some diagnostics. */
1647 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1649 if (CPP_OPTION (pfile, traditional))
1650 ok = _cpp_create_trad_definition (pfile, macro);
1653 ok = create_iso_definition (pfile, macro);
1655 /* We set the type for SEEN_EOL() in directives.c.
1657 Longer term we should lex the whole line before coming here,
1658 and just copy the expansion. */
1660 /* Stop the lexer accepting __VA_ARGS__. */
1661 pfile->state.va_args_ok = 0;
1664 /* Clear the fast argument lookup indices. */
1665 for (i = macro->paramc; i-- > 0; )
1667 struct cpp_hashnode *node = macro->params[i];
1668 node->flags &= ~ NODE_MACRO_ARG;
1669 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1675 if (node->type == NT_MACRO)
1677 if (CPP_OPTION (pfile, warn_unused_macros))
1678 _cpp_warn_if_unused_macro (pfile, node, NULL);
1680 if (warn_of_redefinition (pfile, node, macro))
1682 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1683 "\"%s\" redefined", NODE_NAME (node));
1685 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1686 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1687 node->value.macro->line, 0,
1688 "this is the location of the previous definition");
1692 if (node->type != NT_VOID)
1693 _cpp_free_definition (node);
1695 /* Enter definition in hash table. */
1696 node->type = NT_MACRO;
1697 node->value.macro = macro;
1698 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1699 node->flags |= NODE_WARN;
1704 /* Warn if a token in STRING matches one of a function-like MACRO's
1707 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1708 const cpp_string *string)
1710 unsigned int i, len;
1711 const uchar *p, *q, *limit;
1713 /* Loop over the string. */
1714 limit = string->text + string->len - 1;
1715 for (p = string->text + 1; p < limit; p = q)
1717 /* Find the start of an identifier. */
1718 while (p < limit && !is_idstart (*p))
1721 /* Find the end of the identifier. */
1723 while (q < limit && is_idchar (*q))
1728 /* Loop over the function macro arguments to see if the
1729 identifier inside the string matches one of them. */
1730 for (i = 0; i < macro->paramc; i++)
1732 const cpp_hashnode *node = macro->params[i];
1734 if (NODE_LEN (node) == len
1735 && !memcmp (p, NODE_NAME (node), len))
1737 cpp_error (pfile, CPP_DL_WARNING,
1738 "macro argument \"%s\" would be stringified in traditional C",
1746 /* Returns the name, arguments and expansion of a macro, in a format
1747 suitable to be read back in again, and therefore also for DWARF 2
1748 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1749 Caller is expected to generate the "#define" bit if needed. The
1750 returned text is temporary, and automatically freed later. */
1751 const unsigned char *
1752 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1754 unsigned int i, len;
1755 const cpp_macro *macro = node->value.macro;
1756 unsigned char *buffer;
1758 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1760 cpp_error (pfile, CPP_DL_ICE,
1761 "invalid hash type %d in cpp_macro_definition", node->type);
1765 /* Calculate length. */
1766 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
1767 if (macro->fun_like)
1769 len += 4; /* "()" plus possible final ".." of named
1770 varargs (we have + 1 below). */
1771 for (i = 0; i < macro->paramc; i++)
1772 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1775 /* This should match below where we fill in the buffer. */
1776 if (CPP_OPTION (pfile, traditional))
1777 len += _cpp_replacement_text_len (macro);
1780 for (i = 0; i < macro->count; i++)
1782 cpp_token *token = ¯o->exp.tokens[i];
1784 if (token->type == CPP_MACRO_ARG)
1785 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1787 len += cpp_token_len (token);
1789 if (token->flags & STRINGIFY_ARG)
1791 if (token->flags & PASTE_LEFT)
1792 len += 3; /* " ##" */
1793 if (token->flags & PREV_WHITE)
1798 if (len > pfile->macro_buffer_len)
1800 pfile->macro_buffer = XRESIZEVEC (unsigned char,
1801 pfile->macro_buffer, len);
1802 pfile->macro_buffer_len = len;
1805 /* Fill in the buffer. Start with the macro name. */
1806 buffer = pfile->macro_buffer;
1807 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1808 buffer += NODE_LEN (node);
1810 /* Parameter names. */
1811 if (macro->fun_like)
1814 for (i = 0; i < macro->paramc; i++)
1816 cpp_hashnode *param = macro->params[i];
1818 if (param != pfile->spec_nodes.n__VA_ARGS__)
1820 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1821 buffer += NODE_LEN (param);
1824 if (i + 1 < macro->paramc)
1825 /* Don't emit a space after the comma here; we're trying
1826 to emit a Dwarf-friendly definition, and the Dwarf spec
1827 forbids spaces in the argument list. */
1829 else if (macro->variadic)
1830 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1835 /* The Dwarf spec requires a space after the macro name, even if the
1836 definition is the empty string. */
1839 if (CPP_OPTION (pfile, traditional))
1840 buffer = _cpp_copy_replacement_text (macro, buffer);
1841 else if (macro->count)
1842 /* Expansion tokens. */
1844 for (i = 0; i < macro->count; i++)
1846 cpp_token *token = ¯o->exp.tokens[i];
1848 if (token->flags & PREV_WHITE)
1850 if (token->flags & STRINGIFY_ARG)
1853 if (token->type == CPP_MACRO_ARG)
1856 NODE_NAME (macro->params[token->val.arg_no - 1]),
1857 NODE_LEN (macro->params[token->val.arg_no - 1]));
1858 buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1861 buffer = cpp_spell_token (pfile, token, buffer, false);
1863 if (token->flags & PASTE_LEFT)
1868 /* Next has PREV_WHITE; see _cpp_create_definition. */
1874 return pfile->macro_buffer;