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 end = cpp_spell_token (pfile, rhs, end, false);
457 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
458 _cpp_clean_line (pfile);
460 /* Set pfile->cur_token as required by _cpp_lex_direct. */
461 pfile->cur_token = _cpp_temp_token (pfile);
462 lhs = _cpp_lex_direct (pfile);
463 if (pfile->buffer->cur != pfile->buffer->rlimit)
465 source_location saved_loc = lhs->src_loc;
467 _cpp_pop_buffer (pfile);
468 _cpp_backup_tokens (pfile, 1);
471 /* We have to remove the PASTE_LEFT flag from the old lhs, but
472 we want to keep the new location. */
475 lhs->src_loc = saved_loc;
476 lhs->flags &= ~PASTE_LEFT;
478 /* Mandatory error for all apart from assembler. */
479 if (CPP_OPTION (pfile, lang) != CLK_ASM)
480 cpp_error (pfile, CPP_DL_ERROR,
481 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
482 buf, cpp_token_as_text (pfile, rhs));
487 _cpp_pop_buffer (pfile);
491 /* Handles an arbitrarily long sequence of ## operators, with initial
492 operand LHS. This implementation is left-associative,
493 non-recursive, and finishes a paste before handling succeeding
494 ones. If a paste fails, we back up to the RHS of the failing ##
495 operator before pushing the context containing the result of prior
496 successful pastes, with the effect that the RHS appears in the
497 output stream after the pasted LHS normally. */
499 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
501 const cpp_token *rhs;
502 cpp_context *context = pfile->context;
506 /* Take the token directly from the current context. We can do
507 this, because we are in the replacement list of either an
508 object-like macro, or a function-like macro with arguments
509 inserted. In either case, the constraints to #define
510 guarantee we have at least one more token. */
511 if (context->direct_p)
512 rhs = FIRST (context).token++;
514 rhs = *FIRST (context).ptoken++;
516 if (rhs->type == CPP_PADDING)
519 if (!paste_tokens (pfile, &lhs, rhs))
522 while (rhs->flags & PASTE_LEFT);
524 /* Put the resulting token in its own context. */
525 _cpp_push_token_context (pfile, NULL, lhs, 1);
528 /* Returns TRUE if the number of arguments ARGC supplied in an
529 invocation of the MACRO referenced by NODE is valid. An empty
530 invocation to a macro with no parameters should pass ARGC as zero.
532 Note that MACRO cannot necessarily be deduced from NODE, in case
533 NODE was redefined whilst collecting arguments. */
535 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
537 if (argc == macro->paramc)
540 if (argc < macro->paramc)
542 /* As an extension, a rest argument is allowed to not appear in
543 the invocation at all.
544 e.g. #define debug(format, args...) something
547 This is exactly the same as if there had been an empty rest
548 argument - debug("string", ). */
550 if (argc + 1 == macro->paramc && macro->variadic)
552 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
553 cpp_error (pfile, CPP_DL_PEDWARN,
554 "ISO C99 requires rest arguments to be used");
558 cpp_error (pfile, CPP_DL_ERROR,
559 "macro \"%s\" requires %u arguments, but only %u given",
560 NODE_NAME (node), macro->paramc, argc);
563 cpp_error (pfile, CPP_DL_ERROR,
564 "macro \"%s\" passed %u arguments, but takes just %u",
565 NODE_NAME (node), argc, macro->paramc);
570 /* Reads and returns the arguments to a function-like macro
571 invocation. Assumes the opening parenthesis has been processed.
572 If there is an error, emits an appropriate diagnostic and returns
573 NULL. Each argument is terminated by a CPP_EOF token, for the
574 future benefit of expand_arg(). */
576 collect_args (cpp_reader *pfile, const cpp_hashnode *node)
578 _cpp_buff *buff, *base_buff;
580 macro_arg *args, *arg;
581 const cpp_token *token;
584 macro = node->value.macro;
586 argc = macro->paramc;
589 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
590 + sizeof (macro_arg)));
592 args = (macro_arg *) buff->base;
593 memset (args, 0, argc * sizeof (macro_arg));
594 buff->cur = (unsigned char *) &args[argc];
595 arg = args, argc = 0;
597 /* Collect the tokens making up each argument. We don't yet know
598 how many arguments have been supplied, whether too many or too
599 few. Hence the slightly bizarre usage of "argc" and "arg". */
602 unsigned int paren_depth = 0;
603 unsigned int ntokens = 0;
606 arg->first = (const cpp_token **) buff->cur;
610 /* Require space for 2 new tokens (including a CPP_EOF). */
611 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
613 buff = _cpp_append_extend_buff (pfile, buff,
614 1000 * sizeof (cpp_token *));
615 arg->first = (const cpp_token **) buff->cur;
618 token = cpp_get_token (pfile);
620 if (token->type == CPP_PADDING)
622 /* Drop leading padding. */
626 else if (token->type == CPP_OPEN_PAREN)
628 else if (token->type == CPP_CLOSE_PAREN)
630 if (paren_depth-- == 0)
633 else if (token->type == CPP_COMMA)
635 /* A comma does not terminate an argument within
636 parentheses or as part of a variable argument. */
638 && ! (macro->variadic && argc == macro->paramc))
641 else if (token->type == CPP_EOF
642 || (token->type == CPP_HASH && token->flags & BOL))
645 arg->first[ntokens++] = token;
648 /* Drop trailing padding. */
649 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
652 arg->count = ntokens;
653 arg->first[ntokens] = &pfile->eof;
655 /* Terminate the argument. Excess arguments loop back and
656 overwrite the final legitimate argument, before failing. */
657 if (argc <= macro->paramc)
659 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
660 if (argc != macro->paramc)
664 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
666 if (token->type == CPP_EOF)
668 /* We still need the CPP_EOF to end directives, and to end
669 pre-expansion of a macro argument. Step back is not
670 unconditional, since we don't want to return a CPP_EOF to our
671 callers at the end of an -include-d file. */
672 if (pfile->context->prev || pfile->state.in_directive)
673 _cpp_backup_tokens (pfile, 1);
674 cpp_error (pfile, CPP_DL_ERROR,
675 "unterminated argument list invoking macro \"%s\"",
680 /* A single empty argument is counted as no argument. */
681 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
683 if (_cpp_arguments_ok (pfile, macro, node, argc))
685 /* GCC has special semantics for , ## b where b is a varargs
686 parameter: we remove the comma if b was omitted entirely.
687 If b was merely an empty argument, the comma is retained.
688 If the macro takes just one (varargs) parameter, then we
689 retain the comma only if we are standards conforming.
691 If FIRST is NULL replace_args () swallows the comma. */
692 if (macro->variadic && (argc < macro->paramc
693 || (argc == 1 && args[0].count == 0
694 && !CPP_OPTION (pfile, std))))
695 args[macro->paramc - 1].first = NULL;
700 /* An error occurred. */
701 _cpp_release_buff (pfile, base_buff);
705 /* Search for an opening parenthesis to the macro of NODE, in such a
706 way that, if none is found, we don't lose the information in any
707 intervening padding tokens. If we find the parenthesis, collect
708 the arguments and return the buffer containing them. */
710 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node)
712 const cpp_token *token, *padding = NULL;
716 token = cpp_get_token (pfile);
717 if (token->type != CPP_PADDING)
720 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
724 if (token->type == CPP_OPEN_PAREN)
726 pfile->state.parsing_args = 2;
727 return collect_args (pfile, node);
730 /* CPP_EOF can be the end of macro arguments, or the end of the
731 file. We mustn't back up over the latter. Ugh. */
732 if (token->type != CPP_EOF || token == &pfile->eof)
734 /* Back up. We may have skipped padding, in which case backing
735 up more than one token when expanding macros is in general
736 too difficult. We re-insert it in its own context. */
737 _cpp_backup_tokens (pfile, 1);
739 _cpp_push_token_context (pfile, NULL, padding, 1);
745 /* Push the context of a macro with hash entry NODE onto the context
746 stack. If we can successfully expand the macro, we push a context
747 containing its yet-to-be-rescanned replacement list and return one.
748 Otherwise, we don't push a context and return zero. */
750 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node)
752 /* The presence of a macro invalidates a file's controlling macro. */
753 pfile->mi_valid = false;
755 pfile->state.angled_headers = false;
757 /* Handle standard macros. */
758 if (! (node->flags & NODE_BUILTIN))
760 cpp_macro *macro = node->value.macro;
766 pfile->state.prevent_expansion++;
767 pfile->keep_tokens++;
768 pfile->state.parsing_args = 1;
769 buff = funlike_invocation_p (pfile, node);
770 pfile->state.parsing_args = 0;
771 pfile->keep_tokens--;
772 pfile->state.prevent_expansion--;
776 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
777 cpp_error (pfile, CPP_DL_WARNING,
778 "function-like macro \"%s\" must be used with arguments in traditional C",
784 if (macro->paramc > 0)
785 replace_args (pfile, node, macro, (macro_arg *) buff->base);
786 _cpp_release_buff (pfile, buff);
789 /* Disable the macro within its expansion. */
790 node->flags |= NODE_DISABLED;
794 if (macro->paramc == 0)
795 _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
800 /* Handle built-in macros and the _Pragma operator. */
801 return builtin_macro (pfile, node);
804 /* Replace the parameters in a function-like macro of NODE with the
805 actual ARGS, and place the result in a newly pushed token context.
806 Expand each argument before replacing, unless it is operated upon
807 by the # or ## operators. */
809 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
811 unsigned int i, total;
812 const cpp_token *src, *limit;
813 const cpp_token **dest, **first;
817 /* First, fully macro-expand arguments, calculating the number of
818 tokens in the final expansion as we go. The ordering of the if
819 statements below is subtle; we must handle stringification before
821 total = macro->count;
822 limit = macro->exp.tokens + macro->count;
824 for (src = macro->exp.tokens; src < limit; src++)
825 if (src->type == CPP_MACRO_ARG)
827 /* Leading and trailing padding tokens. */
830 /* We have an argument. If it is not being stringified or
831 pasted it is macro-replaced before insertion. */
832 arg = &args[src->val.arg_no - 1];
834 if (src->flags & STRINGIFY_ARG)
836 if (!arg->stringified)
837 arg->stringified = stringify_arg (pfile, arg);
839 else if ((src->flags & PASTE_LEFT)
840 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
841 total += arg->count - 1;
845 expand_arg (pfile, arg);
846 total += arg->expanded_count - 1;
850 /* Now allocate space for the expansion, copy the tokens and replace
852 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
853 first = (const cpp_token **) buff->base;
856 for (src = macro->exp.tokens; src < limit; src++)
859 const cpp_token **from, **paste_flag;
861 if (src->type != CPP_MACRO_ARG)
868 arg = &args[src->val.arg_no - 1];
869 if (src->flags & STRINGIFY_ARG)
870 count = 1, from = &arg->stringified;
871 else if (src->flags & PASTE_LEFT)
872 count = arg->count, from = arg->first;
873 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
875 count = arg->count, from = arg->first;
878 if (dest[-1]->type == CPP_COMMA
880 && src->val.arg_no == macro->paramc)
882 /* Swallow a pasted comma if from == NULL, otherwise
883 drop the paste flag. */
887 paste_flag = dest - 1;
889 /* Remove the paste flag if the RHS is a placemarker. */
891 paste_flag = dest - 1;
895 count = arg->expanded_count, from = arg->expanded;
897 /* Padding on the left of an argument (unless RHS of ##). */
898 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
899 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
900 *dest++ = padding_token (pfile, src);
904 memcpy (dest, from, count * sizeof (cpp_token *));
907 /* With a non-empty argument on the LHS of ##, the last
908 token should be flagged PASTE_LEFT. */
909 if (src->flags & PASTE_LEFT)
910 paste_flag = dest - 1;
913 /* Avoid paste on RHS (even case count == 0). */
914 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
915 *dest++ = &pfile->avoid_paste;
917 /* Add a new paste flag, or remove an unwanted one. */
920 cpp_token *token = _cpp_temp_token (pfile);
921 token->type = (*paste_flag)->type;
922 token->val = (*paste_flag)->val;
923 if (src->flags & PASTE_LEFT)
924 token->flags = (*paste_flag)->flags | PASTE_LEFT;
926 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
931 /* Free the expanded arguments. */
932 for (i = 0; i < macro->paramc; i++)
933 if (args[i].expanded)
934 free (args[i].expanded);
936 push_ptoken_context (pfile, node, buff, first, dest - first);
939 /* Return a special padding token, with padding inherited from SOURCE. */
940 static const cpp_token *
941 padding_token (cpp_reader *pfile, const cpp_token *source)
943 cpp_token *result = _cpp_temp_token (pfile);
945 result->type = CPP_PADDING;
947 /* Data in GCed data structures cannot be made const so far, so we
949 result->val.source = (cpp_token *) source;
954 /* Get a new uninitialized context. Create a new one if we cannot
955 re-use an old one. */
957 next_context (cpp_reader *pfile)
959 cpp_context *result = pfile->context->next;
963 result = XNEW (cpp_context);
964 result->prev = pfile->context;
966 pfile->context->next = result;
969 pfile->context = result;
973 /* Push a list of pointers to tokens. */
975 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
976 const cpp_token **first, unsigned int count)
978 cpp_context *context = next_context (pfile);
980 context->direct_p = false;
981 context->macro = macro;
982 context->buff = buff;
983 FIRST (context).ptoken = first;
984 LAST (context).ptoken = first + count;
987 /* Push a list of tokens. */
989 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
990 const cpp_token *first, unsigned int count)
992 cpp_context *context = next_context (pfile);
994 context->direct_p = true;
995 context->macro = macro;
996 context->buff = NULL;
997 FIRST (context).token = first;
998 LAST (context).token = first + count;
1001 /* Push a traditional macro's replacement text. */
1003 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1004 const uchar *start, size_t len)
1006 cpp_context *context = next_context (pfile);
1008 context->direct_p = true;
1009 context->macro = macro;
1010 context->buff = NULL;
1011 CUR (context) = start;
1012 RLIMIT (context) = start + len;
1013 macro->flags |= NODE_DISABLED;
1016 /* Expand an argument ARG before replacing parameters in a
1017 function-like macro. This works by pushing a context with the
1018 argument's tokens, and then expanding that into a temporary buffer
1019 as if it were a normal part of the token stream. collect_args()
1020 has terminated the argument's tokens with a CPP_EOF so that we know
1021 when we have fully expanded the argument. */
1023 expand_arg (cpp_reader *pfile, macro_arg *arg)
1025 unsigned int capacity;
1026 bool saved_warn_trad;
1028 if (arg->count == 0)
1031 /* Don't warn about funlike macros when pre-expanding. */
1032 saved_warn_trad = CPP_WTRADITIONAL (pfile);
1033 CPP_WTRADITIONAL (pfile) = 0;
1035 /* Loop, reading in the arguments. */
1037 arg->expanded = XNEWVEC (const cpp_token *, capacity);
1039 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1042 const cpp_token *token;
1044 if (arg->expanded_count + 1 >= capacity)
1047 arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1051 token = cpp_get_token (pfile);
1053 if (token->type == CPP_EOF)
1056 arg->expanded[arg->expanded_count++] = token;
1059 _cpp_pop_context (pfile);
1061 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1064 /* Pop the current context off the stack, re-enabling the macro if the
1065 context represented a macro's replacement list. The context
1066 structure is not freed so that we can re-use it later. */
1068 _cpp_pop_context (cpp_reader *pfile)
1070 cpp_context *context = pfile->context;
1073 context->macro->flags &= ~NODE_DISABLED;
1076 _cpp_release_buff (pfile, context->buff);
1078 pfile->context = context->prev;
1081 /* External routine to get a token. Also used nearly everywhere
1082 internally, except for places where we know we can safely call
1083 _cpp_lex_token directly, such as lexing a directive name.
1085 Macro expansions and directives are transparently handled,
1086 including entering included files. Thus tokens are post-macro
1087 expansion, and after any intervening directives. External callers
1088 see CPP_EOF only at EOF. Internal callers also see it when meeting
1089 a directive inside a macro call, when at the end of a directive and
1090 state.in_directive is still 1, and at the end of argument
1093 cpp_get_token (cpp_reader *pfile)
1095 const cpp_token *result;
1096 bool can_set = pfile->set_invocation_location;
1097 pfile->set_invocation_location = false;
1102 cpp_context *context = pfile->context;
1104 /* Context->prev == 0 <=> base context. */
1106 result = _cpp_lex_token (pfile);
1107 else if (FIRST (context).token != LAST (context).token)
1109 if (context->direct_p)
1110 result = FIRST (context).token++;
1112 result = *FIRST (context).ptoken++;
1114 if (result->flags & PASTE_LEFT)
1116 paste_all_tokens (pfile, result);
1117 if (pfile->state.in_directive)
1119 return padding_token (pfile, result);
1124 _cpp_pop_context (pfile);
1125 if (pfile->state.in_directive)
1127 return &pfile->avoid_paste;
1130 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1133 if (result->type != CPP_NAME)
1136 node = result->val.node;
1138 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1141 if (!(node->flags & NODE_DISABLED))
1143 /* If not in a macro context, and we're going to start an
1144 expansion, record the location. */
1145 if (can_set && !context->macro)
1146 pfile->invocation_location = result->src_loc;
1147 if (!pfile->state.prevent_expansion
1148 && enter_macro_context (pfile, node))
1150 if (pfile->state.in_directive)
1152 return padding_token (pfile, result);
1157 /* Flag this token as always unexpandable. FIXME: move this
1158 to collect_args()?. */
1159 cpp_token *t = _cpp_temp_token (pfile);
1160 t->type = result->type;
1161 t->flags = result->flags | NO_EXPAND;
1162 t->val = result->val;
1172 /* Like cpp_get_token, but also returns a location separate from the
1173 one provided by the returned token. LOC is an out parameter; *LOC
1174 is set to the location "as expected by the user". This matters
1175 when a token results from macro expansion -- the token's location
1176 will indicate where the macro is defined, but *LOC will be the
1177 location of the start of the expansion. */
1179 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1181 const cpp_token *result;
1183 pfile->set_invocation_location = true;
1184 result = cpp_get_token (pfile);
1185 if (pfile->context->macro)
1186 *loc = pfile->invocation_location;
1188 *loc = result->src_loc;
1193 /* Returns true if we're expanding an object-like macro that was
1194 defined in a system header. Just checks the macro at the top of
1195 the stack. Used for diagnostic suppression. */
1197 cpp_sys_macro_p (cpp_reader *pfile)
1199 cpp_hashnode *node = pfile->context->macro;
1201 return node && node->value.macro && node->value.macro->syshdr;
1204 /* Read each token in, until end of the current file. Directives are
1205 transparently processed. */
1207 cpp_scan_nooutput (cpp_reader *pfile)
1209 /* Request a CPP_EOF token at the end of this file, rather than
1210 transparently continuing with the including file. */
1211 pfile->buffer->return_at_eof = true;
1213 pfile->state.discarding_output++;
1214 pfile->state.prevent_expansion++;
1216 if (CPP_OPTION (pfile, traditional))
1217 while (_cpp_read_logical_line_trad (pfile))
1220 while (cpp_get_token (pfile)->type != CPP_EOF)
1223 pfile->state.discarding_output--;
1224 pfile->state.prevent_expansion--;
1227 /* Step back one (or more) tokens. Can only step back more than 1 if
1228 they are from the lexer, and not from macro expansion. */
1230 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1232 if (pfile->context->prev == NULL)
1234 pfile->lookaheads += count;
1238 if (pfile->cur_token == pfile->cur_run->base
1239 /* Possible with -fpreprocessed and no leading #line. */
1240 && pfile->cur_run->prev != NULL)
1242 pfile->cur_run = pfile->cur_run->prev;
1243 pfile->cur_token = pfile->cur_run->limit;
1251 if (pfile->context->direct_p)
1252 FIRST (pfile->context).token--;
1254 FIRST (pfile->context).ptoken--;
1258 /* #define directive parsing and handling. */
1260 /* Returns nonzero if a macro redefinition warning is required. */
1262 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1263 const cpp_macro *macro2)
1265 const cpp_macro *macro1;
1268 /* Some redefinitions need to be warned about regardless. */
1269 if (node->flags & NODE_WARN)
1272 /* Redefinition of a macro is allowed if and only if the old and new
1273 definitions are the same. (6.10.3 paragraph 2). */
1274 macro1 = node->value.macro;
1276 /* Don't check count here as it can be different in valid
1277 traditional redefinitions with just whitespace differences. */
1278 if (macro1->paramc != macro2->paramc
1279 || macro1->fun_like != macro2->fun_like
1280 || macro1->variadic != macro2->variadic)
1283 /* Check parameter spellings. */
1284 for (i = 0; i < macro1->paramc; i++)
1285 if (macro1->params[i] != macro2->params[i])
1288 /* Check the replacement text or tokens. */
1289 if (CPP_OPTION (pfile, traditional))
1290 return _cpp_expansions_different_trad (macro1, macro2);
1292 if (macro1->count != macro2->count)
1295 for (i = 0; i < macro1->count; i++)
1296 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
1302 /* Free the definition of hashnode H. */
1304 _cpp_free_definition (cpp_hashnode *h)
1306 /* Macros and assertions no longer have anything to free. */
1308 /* Clear builtin flag in case of redefinition. */
1309 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1312 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1313 zero on success, nonzero if the parameter is a duplicate. */
1315 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1318 /* Constraint 6.10.3.6 - duplicate parameter names. */
1319 if (node->flags & NODE_MACRO_ARG)
1321 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1326 if (BUFF_ROOM (pfile->a_buff)
1327 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1328 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1330 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1331 node->flags |= NODE_MACRO_ARG;
1332 len = macro->paramc * sizeof (union _cpp_hashnode_value);
1333 if (len > pfile->macro_buffer_len)
1335 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1337 pfile->macro_buffer_len = len;
1339 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1342 node->value.arg_index = macro->paramc;
1346 /* Check the syntax of the parameters in a MACRO definition. Returns
1347 false if an error occurs. */
1349 parse_params (cpp_reader *pfile, cpp_macro *macro)
1351 unsigned int prev_ident = 0;
1355 const cpp_token *token = _cpp_lex_token (pfile);
1357 switch (token->type)
1360 /* Allow/ignore comments in parameter lists if we are
1361 preserving comments in macro expansions. */
1362 if (token->type == CPP_COMMENT
1363 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1366 cpp_error (pfile, CPP_DL_ERROR,
1367 "\"%s\" may not appear in macro parameter list",
1368 cpp_token_as_text (pfile, token));
1374 cpp_error (pfile, CPP_DL_ERROR,
1375 "macro parameters must be comma-separated");
1380 if (_cpp_save_parameter (pfile, macro, token->val.node))
1384 case CPP_CLOSE_PAREN:
1385 if (prev_ident || macro->paramc == 0)
1388 /* Fall through to pick up the error. */
1392 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1399 macro->variadic = 1;
1402 _cpp_save_parameter (pfile, macro,
1403 pfile->spec_nodes.n__VA_ARGS__);
1404 pfile->state.va_args_ok = 1;
1405 if (! CPP_OPTION (pfile, c99)
1406 && CPP_OPTION (pfile, pedantic)
1407 && CPP_OPTION (pfile, warn_variadic_macros))
1408 cpp_error (pfile, CPP_DL_PEDWARN,
1409 "anonymous variadic macros were introduced in C99");
1411 else if (CPP_OPTION (pfile, pedantic)
1412 && CPP_OPTION (pfile, warn_variadic_macros))
1413 cpp_error (pfile, CPP_DL_PEDWARN,
1414 "ISO C does not permit named variadic macros");
1416 /* We're at the end, and just expect a closing parenthesis. */
1417 token = _cpp_lex_token (pfile);
1418 if (token->type == CPP_CLOSE_PAREN)
1423 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1429 /* Allocate room for a token from a macro's replacement list. */
1431 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1433 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1434 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1436 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1439 /* Lex a token from the expansion of MACRO, but mark parameters as we
1440 find them and warn of traditional stringification. */
1442 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1444 cpp_token *token, *saved_cur_token;
1446 saved_cur_token = pfile->cur_token;
1447 pfile->cur_token = alloc_expansion_token (pfile, macro);
1448 token = _cpp_lex_direct (pfile);
1449 pfile->cur_token = saved_cur_token;
1451 /* Is this a parameter? */
1452 if (token->type == CPP_NAME
1453 && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1455 token->type = CPP_MACRO_ARG;
1456 token->val.arg_no = token->val.node->value.arg_index;
1458 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1459 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1460 check_trad_stringification (pfile, macro, &token->val.str);
1466 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1469 const cpp_token *ctoken;
1470 bool following_paste_op = false;
1471 const char *paste_op_error_msg =
1472 N_("'##' cannot appear at either end of a macro expansion");
1474 /* Get the first token of the expansion (or the '(' of a
1475 function-like macro). */
1476 ctoken = _cpp_lex_token (pfile);
1478 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1480 bool ok = parse_params (pfile, macro);
1481 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1485 /* Success. Commit or allocate the parameter array. */
1486 if (pfile->hash_table->alloc_subobject)
1488 cpp_hashnode **params =
1489 (cpp_hashnode **) pfile->hash_table->alloc_subobject
1490 (sizeof (cpp_hashnode *) * macro->paramc);
1491 memcpy (params, macro->params,
1492 sizeof (cpp_hashnode *) * macro->paramc);
1493 macro->params = params;
1496 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
1497 macro->fun_like = 1;
1499 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1501 /* While ISO C99 requires whitespace before replacement text
1502 in a macro definition, ISO C90 with TC1 allows there characters
1503 from the basic source character set. */
1504 if (CPP_OPTION (pfile, c99))
1505 cpp_error (pfile, CPP_DL_PEDWARN,
1506 "ISO C99 requires whitespace after the macro name");
1509 int warntype = CPP_DL_WARNING;
1510 switch (ctoken->type)
1514 case CPP_OBJC_STRING:
1515 /* '@' is not in basic character set. */
1516 warntype = CPP_DL_PEDWARN;
1519 /* Basic character set sans letters, digits and _. */
1520 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1521 ctoken->val.str.text[0]) == NULL)
1522 warntype = CPP_DL_PEDWARN;
1525 /* All other tokens start with a character from basic
1529 cpp_error (pfile, warntype,
1530 "missing whitespace after the macro name");
1534 if (macro->fun_like)
1535 token = lex_expansion_token (pfile, macro);
1538 token = alloc_expansion_token (pfile, macro);
1544 /* Check the stringifying # constraint 6.10.3.2.1 of
1545 function-like macros when lexing the subsequent token. */
1546 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1548 if (token->type == CPP_MACRO_ARG)
1550 token->flags &= ~PREV_WHITE;
1551 token->flags |= STRINGIFY_ARG;
1552 token->flags |= token[-1].flags & PREV_WHITE;
1553 token[-1] = token[0];
1556 /* Let assembler get away with murder. */
1557 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1559 cpp_error (pfile, CPP_DL_ERROR,
1560 "'#' is not followed by a macro parameter");
1565 if (token->type == CPP_EOF)
1567 /* Paste operator constraint 6.10.3.3.1:
1568 Token-paste ##, can appear in both object-like and
1569 function-like macros, but not at the end. */
1570 if (following_paste_op)
1572 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1578 /* Paste operator constraint 6.10.3.3.1. */
1579 if (token->type == CPP_PASTE)
1581 /* Token-paste ##, can appear in both object-like and
1582 function-like macros, but not at the beginning. */
1583 if (macro->count == 1)
1585 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1590 token[-1].flags |= PASTE_LEFT;
1593 following_paste_op = (token->type == CPP_PASTE);
1594 token = lex_expansion_token (pfile, macro);
1597 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1598 macro->traditional = 0;
1600 /* Don't count the CPP_EOF. */
1603 /* Clear whitespace on first token for warn_of_redefinition(). */
1605 macro->exp.tokens[0].flags &= ~PREV_WHITE;
1607 /* Commit or allocate the memory. */
1608 if (pfile->hash_table->alloc_subobject)
1611 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1613 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1614 macro->exp.tokens = tokns;
1617 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
1622 /* Parse a macro and save its expansion. Returns nonzero on success. */
1624 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1630 if (pfile->hash_table->alloc_subobject)
1631 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1632 (sizeof (cpp_macro));
1634 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1635 macro->line = pfile->directive_line;
1638 macro->variadic = 0;
1639 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1641 macro->fun_like = 0;
1642 /* To suppress some diagnostics. */
1643 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1645 if (CPP_OPTION (pfile, traditional))
1646 ok = _cpp_create_trad_definition (pfile, macro);
1649 ok = create_iso_definition (pfile, macro);
1651 /* We set the type for SEEN_EOL() in directives.c.
1653 Longer term we should lex the whole line before coming here,
1654 and just copy the expansion. */
1656 /* Stop the lexer accepting __VA_ARGS__. */
1657 pfile->state.va_args_ok = 0;
1660 /* Clear the fast argument lookup indices. */
1661 for (i = macro->paramc; i-- > 0; )
1663 struct cpp_hashnode *node = macro->params[i];
1664 node->flags &= ~ NODE_MACRO_ARG;
1665 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1671 if (node->type == NT_MACRO)
1673 if (CPP_OPTION (pfile, warn_unused_macros))
1674 _cpp_warn_if_unused_macro (pfile, node, NULL);
1676 if (warn_of_redefinition (pfile, node, macro))
1678 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1679 "\"%s\" redefined", NODE_NAME (node));
1681 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1682 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1683 node->value.macro->line, 0,
1684 "this is the location of the previous definition");
1688 if (node->type != NT_VOID)
1689 _cpp_free_definition (node);
1691 /* Enter definition in hash table. */
1692 node->type = NT_MACRO;
1693 node->value.macro = macro;
1694 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1695 node->flags |= NODE_WARN;
1700 /* Warn if a token in STRING matches one of a function-like MACRO's
1703 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1704 const cpp_string *string)
1706 unsigned int i, len;
1707 const uchar *p, *q, *limit;
1709 /* Loop over the string. */
1710 limit = string->text + string->len - 1;
1711 for (p = string->text + 1; p < limit; p = q)
1713 /* Find the start of an identifier. */
1714 while (p < limit && !is_idstart (*p))
1717 /* Find the end of the identifier. */
1719 while (q < limit && is_idchar (*q))
1724 /* Loop over the function macro arguments to see if the
1725 identifier inside the string matches one of them. */
1726 for (i = 0; i < macro->paramc; i++)
1728 const cpp_hashnode *node = macro->params[i];
1730 if (NODE_LEN (node) == len
1731 && !memcmp (p, NODE_NAME (node), len))
1733 cpp_error (pfile, CPP_DL_WARNING,
1734 "macro argument \"%s\" would be stringified in traditional C",
1742 /* Returns the name, arguments and expansion of a macro, in a format
1743 suitable to be read back in again, and therefore also for DWARF 2
1744 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1745 Caller is expected to generate the "#define" bit if needed. The
1746 returned text is temporary, and automatically freed later. */
1747 const unsigned char *
1748 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1750 unsigned int i, len;
1751 const cpp_macro *macro = node->value.macro;
1752 unsigned char *buffer;
1754 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1756 cpp_error (pfile, CPP_DL_ICE,
1757 "invalid hash type %d in cpp_macro_definition", node->type);
1761 /* Calculate length. */
1762 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
1763 if (macro->fun_like)
1765 len += 4; /* "()" plus possible final ".." of named
1766 varargs (we have + 1 below). */
1767 for (i = 0; i < macro->paramc; i++)
1768 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1771 /* This should match below where we fill in the buffer. */
1772 if (CPP_OPTION (pfile, traditional))
1773 len += _cpp_replacement_text_len (macro);
1776 for (i = 0; i < macro->count; i++)
1778 cpp_token *token = ¯o->exp.tokens[i];
1780 if (token->type == CPP_MACRO_ARG)
1781 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1783 len += cpp_token_len (token);
1785 if (token->flags & STRINGIFY_ARG)
1787 if (token->flags & PASTE_LEFT)
1788 len += 3; /* " ##" */
1789 if (token->flags & PREV_WHITE)
1794 if (len > pfile->macro_buffer_len)
1796 pfile->macro_buffer = XRESIZEVEC (unsigned char,
1797 pfile->macro_buffer, len);
1798 pfile->macro_buffer_len = len;
1801 /* Fill in the buffer. Start with the macro name. */
1802 buffer = pfile->macro_buffer;
1803 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1804 buffer += NODE_LEN (node);
1806 /* Parameter names. */
1807 if (macro->fun_like)
1810 for (i = 0; i < macro->paramc; i++)
1812 cpp_hashnode *param = macro->params[i];
1814 if (param != pfile->spec_nodes.n__VA_ARGS__)
1816 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1817 buffer += NODE_LEN (param);
1820 if (i + 1 < macro->paramc)
1821 /* Don't emit a space after the comma here; we're trying
1822 to emit a Dwarf-friendly definition, and the Dwarf spec
1823 forbids spaces in the argument list. */
1825 else if (macro->variadic)
1826 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1831 /* The Dwarf spec requires a space after the macro name, even if the
1832 definition is the empty string. */
1835 if (CPP_OPTION (pfile, traditional))
1836 buffer = _cpp_copy_replacement_text (macro, buffer);
1837 else if (macro->count)
1838 /* Expansion tokens. */
1840 for (i = 0; i < macro->count; i++)
1842 cpp_token *token = ¯o->exp.tokens[i];
1844 if (token->flags & PREV_WHITE)
1846 if (token->flags & STRINGIFY_ARG)
1849 if (token->type == CPP_MACRO_ARG)
1852 NODE_NAME (macro->params[token->val.arg_no - 1]),
1853 NODE_LEN (macro->params[token->val.arg_no - 1]));
1854 buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1857 buffer = cpp_spell_token (pfile, token, buffer, false);
1859 if (token->flags & PASTE_LEFT)
1864 /* Next has PREV_WHITE; see _cpp_create_definition. */
1870 return pfile->macro_buffer;