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, 2008 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 *,
46 static int builtin_macro (cpp_reader *, cpp_hashnode *);
47 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
48 const cpp_token **, unsigned int);
49 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
51 static cpp_context *next_context (cpp_reader *);
52 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
53 static void expand_arg (cpp_reader *, macro_arg *);
54 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
55 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
56 static void paste_all_tokens (cpp_reader *, const cpp_token *);
57 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
58 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
60 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
62 static bool create_iso_definition (cpp_reader *, cpp_macro *);
64 /* #define directive parsing and handling. */
66 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
67 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
68 static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,
70 static bool parse_params (cpp_reader *, cpp_macro *);
71 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
74 /* Emits a warning if NODE is a macro defined in the main file that
77 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
78 void *v ATTRIBUTE_UNUSED)
80 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
82 cpp_macro *macro = node->value.macro;
85 && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
86 cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
87 "macro \"%s\" is not used", NODE_NAME (node));
93 /* Allocates and returns a CPP_STRING token, containing TEXT of length
94 LEN, after null-terminating it. TEXT must be in permanent storage. */
95 static const cpp_token *
96 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
98 cpp_token *token = _cpp_temp_token (pfile);
101 token->type = CPP_STRING;
102 token->val.str.len = len;
103 token->val.str.text = text;
108 static const char * const monthnames[] =
110 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
111 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
114 /* Helper function for builtin_macro. Returns the text generated by
117 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
119 const struct line_map *map;
120 const uchar *result = NULL;
121 unsigned int number = 1;
123 switch (node->value.builtin)
126 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
132 cpp_buffer *pbuffer = cpp_get_buffer (pfile);
133 if (pbuffer->timestamp == NULL)
135 /* Initialize timestamp value of the assotiated file. */
136 struct _cpp_file *file = cpp_get_file (pbuffer);
139 /* Generate __TIMESTAMP__ string, that represents
140 the date and time of the last modification
141 of the current source file. The string constant
142 looks like "Sun Sep 16 01:03:52 1973". */
143 struct tm *tb = NULL;
144 struct stat *st = _cpp_get_file_stat (file);
146 tb = localtime (&st->st_mtime);
149 char *str = asctime (tb);
150 size_t len = strlen (str);
151 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
153 strcpy ((char *) buf + 1, str);
155 pbuffer->timestamp = buf;
159 cpp_errno (pfile, CPP_DL_WARNING,
160 "could not determine file timestamp");
161 pbuffer->timestamp = U"\"??? ??? ?? ??:??:?? ????\"";
165 result = pbuffer->timestamp;
174 map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
176 if (node->value.builtin == BT_BASE_FILE)
177 while (! MAIN_FILE_P (map))
178 map = INCLUDED_FROM (pfile->line_table, map);
182 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
185 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
191 case BT_INCLUDE_LEVEL:
192 /* The line map depth counts the primary source as level 1, but
193 historically __INCLUDE_DEPTH__ has called the primary source
195 number = pfile->line_table->depth - 1;
199 map = &pfile->line_table->maps[pfile->line_table->used-1];
200 /* If __LINE__ is embedded in a macro, it must expand to the
201 line of the macro's invocation, not its definition.
202 Otherwise things like assert() will not work properly. */
203 if (CPP_OPTION (pfile, traditional))
204 number = pfile->line_table->highest_line;
206 number = pfile->cur_token[-1].src_loc;
207 number = SOURCE_LINE (map, number);
210 /* __STDC__ has the value 1 under normal circumstances.
211 However, if (a) we are in a system header, (b) the option
212 stdc_0_in_system_headers is true (set by target config), and
213 (c) we are not in strictly conforming mode, then it has the
214 value 0. (b) and (c) are already checked in cpp_init_builtins. */
216 if (cpp_in_system_header (pfile))
224 if (pfile->date == NULL)
226 /* Allocate __DATE__ and __TIME__ strings from permanent
227 storage. We only do this once, and don't generate them
228 at init time, because time() and localtime() are very
229 slow on some systems. */
231 struct tm *tb = NULL;
233 /* (time_t) -1 is a legitimate value for "number of seconds
234 since the Epoch", so we have to do a little dance to
235 distinguish that from a genuine error. */
238 if (tt != (time_t)-1 || errno == 0)
239 tb = localtime (&tt);
243 pfile->date = _cpp_unaligned_alloc (pfile,
244 sizeof ("\"Oct 11 1347\""));
245 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
246 monthnames[tb->tm_mon], tb->tm_mday,
249 pfile->time = _cpp_unaligned_alloc (pfile,
250 sizeof ("\"12:34:56\""));
251 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
252 tb->tm_hour, tb->tm_min, tb->tm_sec);
256 cpp_errno (pfile, CPP_DL_WARNING,
257 "could not determine date and time");
259 pfile->date = U"\"??? ?? ????\"";
260 pfile->time = U"\"??:??:??\"";
264 if (node->value.builtin == BT_DATE)
265 result = pfile->date;
267 result = pfile->time;
271 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
272 cpp_error (pfile, CPP_DL_ERROR,
273 "__COUNTER__ expanded inside directive with -fdirectives-only");
274 number = pfile->counter++;
280 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
281 result = _cpp_unaligned_alloc (pfile, 21);
282 sprintf ((char *) result, "%u", number);
288 /* Convert builtin macros like __FILE__ to a token and push it on the
289 context stack. Also handles _Pragma, for which a new token may not
290 be created. Returns 1 if it generates a new token context, 0 to
291 return the token to the caller. */
293 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
299 if (node->value.builtin == BT_PRAGMA)
301 /* Don't interpret _Pragma within directives. The standard is
302 not clear on this, but to me this makes most sense. */
303 if (pfile->state.in_directive)
306 return _cpp_do__Pragma (pfile);
309 buf = _cpp_builtin_macro_text (pfile, node);
311 nbuf = (char *) alloca (len + 1);
312 memcpy (nbuf, buf, len);
315 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
316 _cpp_clean_line (pfile);
318 /* Set pfile->cur_token as required by _cpp_lex_direct. */
319 pfile->cur_token = _cpp_temp_token (pfile);
320 _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
321 if (pfile->buffer->cur != pfile->buffer->rlimit)
322 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
324 _cpp_pop_buffer (pfile);
329 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
330 backslashes and double quotes. DEST must be of sufficient size.
331 Returns a pointer to the end of the string. */
333 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
339 if (c == '\\' || c == '"')
351 /* Convert a token sequence ARG to a single string token according to
352 the rules of the ISO C #-operator. */
353 static const cpp_token *
354 stringify_arg (cpp_reader *pfile, macro_arg *arg)
357 unsigned int i, escape_it, backslash_count = 0;
358 const cpp_token *source = NULL;
361 if (BUFF_ROOM (pfile->u_buff) < 3)
362 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
363 dest = BUFF_FRONT (pfile->u_buff);
366 /* Loop, reading in the argument's tokens. */
367 for (i = 0; i < arg->count; i++)
369 const cpp_token *token = arg->first[i];
371 if (token->type == CPP_PADDING)
374 source = token->val.source;
378 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
379 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
381 /* Room for each char being written in octal, initial space and
382 final quote and NUL. */
383 len = cpp_token_len (token);
388 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
390 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
391 _cpp_extend_buff (pfile, &pfile->u_buff, len);
392 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
395 /* Leading white space? */
396 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
400 if (source->flags & PREV_WHITE)
407 _cpp_buff *buff = _cpp_get_buff (pfile, len);
408 unsigned char *buf = BUFF_FRONT (buff);
409 len = cpp_spell_token (pfile, token, buf, true) - buf;
410 dest = cpp_quote_string (dest, buf, len);
411 _cpp_release_buff (pfile, buff);
414 dest = cpp_spell_token (pfile, token, dest, true);
416 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
422 /* Ignore the final \ of invalid string literals. */
423 if (backslash_count & 1)
425 cpp_error (pfile, CPP_DL_WARNING,
426 "invalid string literal, ignoring final '\\'");
430 /* Commit the memory, including NUL, and return the token. */
432 len = dest - BUFF_FRONT (pfile->u_buff);
433 BUFF_FRONT (pfile->u_buff) = dest + 1;
434 return new_string_token (pfile, dest - len, len);
437 /* Try to paste two tokens. On success, return nonzero. In any
438 case, PLHS is updated to point to the pasted token, which is
439 guaranteed to not have the PASTE_LEFT flag set. */
441 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
443 unsigned char *buf, *end, *lhsend;
447 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
448 buf = (unsigned char *) alloca (len);
449 end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
451 /* Avoid comment headers, since they are still processed in stage 3.
452 It is simpler to insert a space here, rather than modifying the
453 lexer to ignore comments in some circumstances. Simply returning
454 false doesn't work, since we want to clear the PASTE_LEFT flag. */
455 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
457 /* In one obscure case we might see padding here. */
458 if (rhs->type != CPP_PADDING)
459 end = cpp_spell_token (pfile, rhs, end, false);
462 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
463 _cpp_clean_line (pfile);
465 /* Set pfile->cur_token as required by _cpp_lex_direct. */
466 pfile->cur_token = _cpp_temp_token (pfile);
467 lhs = _cpp_lex_direct (pfile);
468 if (pfile->buffer->cur != pfile->buffer->rlimit)
470 source_location saved_loc = lhs->src_loc;
472 _cpp_pop_buffer (pfile);
473 _cpp_backup_tokens (pfile, 1);
476 /* We have to remove the PASTE_LEFT flag from the old lhs, but
477 we want to keep the new location. */
480 lhs->src_loc = saved_loc;
481 lhs->flags &= ~PASTE_LEFT;
483 /* Mandatory error for all apart from assembler. */
484 if (CPP_OPTION (pfile, lang) != CLK_ASM)
485 cpp_error (pfile, CPP_DL_ERROR,
486 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
487 buf, cpp_token_as_text (pfile, rhs));
492 _cpp_pop_buffer (pfile);
496 /* Handles an arbitrarily long sequence of ## operators, with initial
497 operand LHS. This implementation is left-associative,
498 non-recursive, and finishes a paste before handling succeeding
499 ones. If a paste fails, we back up to the RHS of the failing ##
500 operator before pushing the context containing the result of prior
501 successful pastes, with the effect that the RHS appears in the
502 output stream after the pasted LHS normally. */
504 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
506 const cpp_token *rhs;
507 cpp_context *context = pfile->context;
511 /* Take the token directly from the current context. We can do
512 this, because we are in the replacement list of either an
513 object-like macro, or a function-like macro with arguments
514 inserted. In either case, the constraints to #define
515 guarantee we have at least one more token. */
516 if (context->direct_p)
517 rhs = FIRST (context).token++;
519 rhs = *FIRST (context).ptoken++;
521 if (rhs->type == CPP_PADDING)
523 if (rhs->flags & PASTE_LEFT)
526 if (!paste_tokens (pfile, &lhs, rhs))
529 while (rhs->flags & PASTE_LEFT);
531 /* Put the resulting token in its own context. */
532 _cpp_push_token_context (pfile, NULL, lhs, 1);
535 /* Returns TRUE if the number of arguments ARGC supplied in an
536 invocation of the MACRO referenced by NODE is valid. An empty
537 invocation to a macro with no parameters should pass ARGC as zero.
539 Note that MACRO cannot necessarily be deduced from NODE, in case
540 NODE was redefined whilst collecting arguments. */
542 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
544 if (argc == macro->paramc)
547 if (argc < macro->paramc)
549 /* As an extension, a rest argument is allowed to not appear in
550 the invocation at all.
551 e.g. #define debug(format, args...) something
554 This is exactly the same as if there had been an empty rest
555 argument - debug("string", ). */
557 if (argc + 1 == macro->paramc && macro->variadic)
559 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
560 cpp_error (pfile, CPP_DL_PEDWARN,
561 "ISO C99 requires rest arguments to be used");
565 cpp_error (pfile, CPP_DL_ERROR,
566 "macro \"%s\" requires %u arguments, but only %u given",
567 NODE_NAME (node), macro->paramc, argc);
570 cpp_error (pfile, CPP_DL_ERROR,
571 "macro \"%s\" passed %u arguments, but takes just %u",
572 NODE_NAME (node), argc, macro->paramc);
577 /* Reads and returns the arguments to a function-like macro
578 invocation. Assumes the opening parenthesis has been processed.
579 If there is an error, emits an appropriate diagnostic and returns
580 NULL. Each argument is terminated by a CPP_EOF token, for the
581 future benefit of expand_arg(). If there are any deferred
582 #pragma directives among macro arguments, store pointers to the
583 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. */
585 collect_args (cpp_reader *pfile, const cpp_hashnode *node,
586 _cpp_buff **pragma_buff)
588 _cpp_buff *buff, *base_buff;
590 macro_arg *args, *arg;
591 const cpp_token *token;
594 macro = node->value.macro;
596 argc = macro->paramc;
599 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
600 + sizeof (macro_arg)));
602 args = (macro_arg *) buff->base;
603 memset (args, 0, argc * sizeof (macro_arg));
604 buff->cur = (unsigned char *) &args[argc];
605 arg = args, argc = 0;
607 /* Collect the tokens making up each argument. We don't yet know
608 how many arguments have been supplied, whether too many or too
609 few. Hence the slightly bizarre usage of "argc" and "arg". */
612 unsigned int paren_depth = 0;
613 unsigned int ntokens = 0;
616 arg->first = (const cpp_token **) buff->cur;
620 /* Require space for 2 new tokens (including a CPP_EOF). */
621 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
623 buff = _cpp_append_extend_buff (pfile, buff,
624 1000 * sizeof (cpp_token *));
625 arg->first = (const cpp_token **) buff->cur;
628 token = cpp_get_token (pfile);
630 if (token->type == CPP_PADDING)
632 /* Drop leading padding. */
636 else if (token->type == CPP_OPEN_PAREN)
638 else if (token->type == CPP_CLOSE_PAREN)
640 if (paren_depth-- == 0)
643 else if (token->type == CPP_COMMA)
645 /* A comma does not terminate an argument within
646 parentheses or as part of a variable argument. */
648 && ! (macro->variadic && argc == macro->paramc))
651 else if (token->type == CPP_EOF
652 || (token->type == CPP_HASH && token->flags & BOL))
654 else if (token->type == CPP_PRAGMA)
656 cpp_token *newtok = _cpp_temp_token (pfile);
658 /* CPP_PRAGMA token lives in directive_result, which will
659 be overwritten on the next directive. */
664 if (*pragma_buff == NULL
665 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
668 if (*pragma_buff == NULL)
670 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
675 = _cpp_get_buff (pfile,
676 (BUFF_FRONT (*pragma_buff)
677 - (*pragma_buff)->base) * 2);
678 (*pragma_buff)->next = next;
681 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
682 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
683 if (token->type == CPP_PRAGMA_EOL)
685 token = cpp_get_token (pfile);
687 while (token->type != CPP_EOF);
689 /* In deferred pragmas parsing_args and prevent_expansion
690 had been changed, reset it. */
691 pfile->state.parsing_args = 2;
692 pfile->state.prevent_expansion = 1;
694 if (token->type == CPP_EOF)
700 arg->first[ntokens++] = token;
703 /* Drop trailing padding. */
704 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
707 arg->count = ntokens;
708 arg->first[ntokens] = &pfile->eof;
710 /* Terminate the argument. Excess arguments loop back and
711 overwrite the final legitimate argument, before failing. */
712 if (argc <= macro->paramc)
714 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
715 if (argc != macro->paramc)
719 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
721 if (token->type == CPP_EOF)
723 /* We still need the CPP_EOF to end directives, and to end
724 pre-expansion of a macro argument. Step back is not
725 unconditional, since we don't want to return a CPP_EOF to our
726 callers at the end of an -include-d file. */
727 if (pfile->context->prev || pfile->state.in_directive)
728 _cpp_backup_tokens (pfile, 1);
729 cpp_error (pfile, CPP_DL_ERROR,
730 "unterminated argument list invoking macro \"%s\"",
735 /* A single empty argument is counted as no argument. */
736 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
738 if (_cpp_arguments_ok (pfile, macro, node, argc))
740 /* GCC has special semantics for , ## b where b is a varargs
741 parameter: we remove the comma if b was omitted entirely.
742 If b was merely an empty argument, the comma is retained.
743 If the macro takes just one (varargs) parameter, then we
744 retain the comma only if we are standards conforming.
746 If FIRST is NULL replace_args () swallows the comma. */
747 if (macro->variadic && (argc < macro->paramc
748 || (argc == 1 && args[0].count == 0
749 && !CPP_OPTION (pfile, std))))
750 args[macro->paramc - 1].first = NULL;
755 /* An error occurred. */
756 _cpp_release_buff (pfile, base_buff);
760 /* Search for an opening parenthesis to the macro of NODE, in such a
761 way that, if none is found, we don't lose the information in any
762 intervening padding tokens. If we find the parenthesis, collect
763 the arguments and return the buffer containing them. PRAGMA_BUFF
764 argument is the same as in collect_args. */
766 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
767 _cpp_buff **pragma_buff)
769 const cpp_token *token, *padding = NULL;
773 token = cpp_get_token (pfile);
774 if (token->type != CPP_PADDING)
777 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
781 if (token->type == CPP_OPEN_PAREN)
783 pfile->state.parsing_args = 2;
784 return collect_args (pfile, node, pragma_buff);
787 /* CPP_EOF can be the end of macro arguments, or the end of the
788 file. We mustn't back up over the latter. Ugh. */
789 if (token->type != CPP_EOF || token == &pfile->eof)
791 /* Back up. We may have skipped padding, in which case backing
792 up more than one token when expanding macros is in general
793 too difficult. We re-insert it in its own context. */
794 _cpp_backup_tokens (pfile, 1);
796 _cpp_push_token_context (pfile, NULL, padding, 1);
802 /* Push the context of a macro with hash entry NODE onto the context
803 stack. If we can successfully expand the macro, we push a context
804 containing its yet-to-be-rescanned replacement list and return one.
805 If there were additionally any unexpanded deferred #pragma directives
806 among macro arguments, push another context containing the
807 pragma tokens before the yet-to-be-rescanned replacement list
808 and return two. Otherwise, we don't push a context and return zero. */
810 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
811 const cpp_token *result)
813 /* The presence of a macro invalidates a file's controlling macro. */
814 pfile->mi_valid = false;
816 pfile->state.angled_headers = false;
818 if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
820 node->flags |= NODE_USED;
821 if (pfile->cb.used_define)
822 pfile->cb.used_define (pfile, pfile->directive_line, node);
825 /* Handle standard macros. */
826 if (! (node->flags & NODE_BUILTIN))
828 cpp_macro *macro = node->value.macro;
829 _cpp_buff *pragma_buff = NULL;
835 pfile->state.prevent_expansion++;
836 pfile->keep_tokens++;
837 pfile->state.parsing_args = 1;
838 buff = funlike_invocation_p (pfile, node, &pragma_buff);
839 pfile->state.parsing_args = 0;
840 pfile->keep_tokens--;
841 pfile->state.prevent_expansion--;
845 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
846 cpp_error (pfile, CPP_DL_WARNING,
847 "function-like macro \"%s\" must be used with arguments in traditional C",
851 _cpp_release_buff (pfile, pragma_buff);
856 if (macro->paramc > 0)
857 replace_args (pfile, node, macro, (macro_arg *) buff->base);
858 _cpp_release_buff (pfile, buff);
861 /* Disable the macro within its expansion. */
862 node->flags |= NODE_DISABLED;
864 if (!(node->flags & NODE_USED))
866 node->flags |= NODE_USED;
867 if (pfile->cb.used_define)
868 pfile->cb.used_define (pfile, pfile->directive_line, node);
873 if (macro->paramc == 0)
874 _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
878 if (!pfile->state.in_directive)
879 _cpp_push_token_context (pfile, NULL,
880 padding_token (pfile, result), 1);
883 _cpp_buff *tail = pragma_buff->next;
884 pragma_buff->next = NULL;
885 push_ptoken_context (pfile, NULL, pragma_buff,
886 (const cpp_token **) pragma_buff->base,
887 ((const cpp_token **) BUFF_FRONT (pragma_buff)
888 - (const cpp_token **) pragma_buff->base));
891 while (pragma_buff != NULL);
898 /* Handle built-in macros and the _Pragma operator. */
899 return builtin_macro (pfile, node);
902 /* Replace the parameters in a function-like macro of NODE with the
903 actual ARGS, and place the result in a newly pushed token context.
904 Expand each argument before replacing, unless it is operated upon
905 by the # or ## operators. */
907 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
909 unsigned int i, total;
910 const cpp_token *src, *limit;
911 const cpp_token **dest, **first;
915 /* First, fully macro-expand arguments, calculating the number of
916 tokens in the final expansion as we go. The ordering of the if
917 statements below is subtle; we must handle stringification before
919 total = macro->count;
920 limit = macro->exp.tokens + macro->count;
922 for (src = macro->exp.tokens; src < limit; src++)
923 if (src->type == CPP_MACRO_ARG)
925 /* Leading and trailing padding tokens. */
928 /* We have an argument. If it is not being stringified or
929 pasted it is macro-replaced before insertion. */
930 arg = &args[src->val.arg_no - 1];
932 if (src->flags & STRINGIFY_ARG)
934 if (!arg->stringified)
935 arg->stringified = stringify_arg (pfile, arg);
937 else if ((src->flags & PASTE_LEFT)
938 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
939 total += arg->count - 1;
943 expand_arg (pfile, arg);
944 total += arg->expanded_count - 1;
948 /* Now allocate space for the expansion, copy the tokens and replace
950 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
951 first = (const cpp_token **) buff->base;
954 for (src = macro->exp.tokens; src < limit; src++)
957 const cpp_token **from, **paste_flag;
959 if (src->type != CPP_MACRO_ARG)
966 arg = &args[src->val.arg_no - 1];
967 if (src->flags & STRINGIFY_ARG)
968 count = 1, from = &arg->stringified;
969 else if (src->flags & PASTE_LEFT)
970 count = arg->count, from = arg->first;
971 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
973 count = arg->count, from = arg->first;
976 if (dest[-1]->type == CPP_COMMA
978 && src->val.arg_no == macro->paramc)
980 /* Swallow a pasted comma if from == NULL, otherwise
981 drop the paste flag. */
985 paste_flag = dest - 1;
987 /* Remove the paste flag if the RHS is a placemarker. */
989 paste_flag = dest - 1;
993 count = arg->expanded_count, from = arg->expanded;
995 /* Padding on the left of an argument (unless RHS of ##). */
996 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
997 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
998 *dest++ = padding_token (pfile, src);
1002 memcpy (dest, from, count * sizeof (cpp_token *));
1005 /* With a non-empty argument on the LHS of ##, the last
1006 token should be flagged PASTE_LEFT. */
1007 if (src->flags & PASTE_LEFT)
1008 paste_flag = dest - 1;
1011 /* Avoid paste on RHS (even case count == 0). */
1012 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1013 *dest++ = &pfile->avoid_paste;
1015 /* Add a new paste flag, or remove an unwanted one. */
1018 cpp_token *token = _cpp_temp_token (pfile);
1019 token->type = (*paste_flag)->type;
1020 token->val = (*paste_flag)->val;
1021 if (src->flags & PASTE_LEFT)
1022 token->flags = (*paste_flag)->flags | PASTE_LEFT;
1024 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1025 *paste_flag = token;
1029 /* Free the expanded arguments. */
1030 for (i = 0; i < macro->paramc; i++)
1031 if (args[i].expanded)
1032 free (args[i].expanded);
1034 push_ptoken_context (pfile, node, buff, first, dest - first);
1037 /* Return a special padding token, with padding inherited from SOURCE. */
1038 static const cpp_token *
1039 padding_token (cpp_reader *pfile, const cpp_token *source)
1041 cpp_token *result = _cpp_temp_token (pfile);
1043 result->type = CPP_PADDING;
1045 /* Data in GCed data structures cannot be made const so far, so we
1046 need a cast here. */
1047 result->val.source = (cpp_token *) source;
1052 /* Get a new uninitialized context. Create a new one if we cannot
1053 re-use an old one. */
1054 static cpp_context *
1055 next_context (cpp_reader *pfile)
1057 cpp_context *result = pfile->context->next;
1061 result = XNEW (cpp_context);
1062 result->prev = pfile->context;
1064 pfile->context->next = result;
1067 pfile->context = result;
1071 /* Push a list of pointers to tokens. */
1073 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1074 const cpp_token **first, unsigned int count)
1076 cpp_context *context = next_context (pfile);
1078 context->direct_p = false;
1079 context->macro = macro;
1080 context->buff = buff;
1081 FIRST (context).ptoken = first;
1082 LAST (context).ptoken = first + count;
1085 /* Push a list of tokens. */
1087 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1088 const cpp_token *first, unsigned int count)
1090 cpp_context *context = next_context (pfile);
1092 context->direct_p = true;
1093 context->macro = macro;
1094 context->buff = NULL;
1095 FIRST (context).token = first;
1096 LAST (context).token = first + count;
1099 /* Push a traditional macro's replacement text. */
1101 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1102 const uchar *start, size_t len)
1104 cpp_context *context = next_context (pfile);
1106 context->direct_p = true;
1107 context->macro = macro;
1108 context->buff = NULL;
1109 CUR (context) = start;
1110 RLIMIT (context) = start + len;
1111 macro->flags |= NODE_DISABLED;
1114 /* Expand an argument ARG before replacing parameters in a
1115 function-like macro. This works by pushing a context with the
1116 argument's tokens, and then expanding that into a temporary buffer
1117 as if it were a normal part of the token stream. collect_args()
1118 has terminated the argument's tokens with a CPP_EOF so that we know
1119 when we have fully expanded the argument. */
1121 expand_arg (cpp_reader *pfile, macro_arg *arg)
1123 unsigned int capacity;
1124 bool saved_warn_trad;
1126 if (arg->count == 0)
1129 /* Don't warn about funlike macros when pre-expanding. */
1130 saved_warn_trad = CPP_WTRADITIONAL (pfile);
1131 CPP_WTRADITIONAL (pfile) = 0;
1133 /* Loop, reading in the arguments. */
1135 arg->expanded = XNEWVEC (const cpp_token *, capacity);
1137 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1140 const cpp_token *token;
1142 if (arg->expanded_count + 1 >= capacity)
1145 arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1149 token = cpp_get_token (pfile);
1151 if (token->type == CPP_EOF)
1154 arg->expanded[arg->expanded_count++] = token;
1157 _cpp_pop_context (pfile);
1159 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1162 /* Pop the current context off the stack, re-enabling the macro if the
1163 context represented a macro's replacement list. The context
1164 structure is not freed so that we can re-use it later. */
1166 _cpp_pop_context (cpp_reader *pfile)
1168 cpp_context *context = pfile->context;
1171 context->macro->flags &= ~NODE_DISABLED;
1174 _cpp_release_buff (pfile, context->buff);
1176 pfile->context = context->prev;
1179 /* External routine to get a token. Also used nearly everywhere
1180 internally, except for places where we know we can safely call
1181 _cpp_lex_token directly, such as lexing a directive name.
1183 Macro expansions and directives are transparently handled,
1184 including entering included files. Thus tokens are post-macro
1185 expansion, and after any intervening directives. External callers
1186 see CPP_EOF only at EOF. Internal callers also see it when meeting
1187 a directive inside a macro call, when at the end of a directive and
1188 state.in_directive is still 1, and at the end of argument
1191 cpp_get_token (cpp_reader *pfile)
1193 const cpp_token *result;
1194 bool can_set = pfile->set_invocation_location;
1195 pfile->set_invocation_location = false;
1200 cpp_context *context = pfile->context;
1202 /* Context->prev == 0 <=> base context. */
1204 result = _cpp_lex_token (pfile);
1205 else if (FIRST (context).token != LAST (context).token)
1207 if (context->direct_p)
1208 result = FIRST (context).token++;
1210 result = *FIRST (context).ptoken++;
1212 if (result->flags & PASTE_LEFT)
1214 paste_all_tokens (pfile, result);
1215 if (pfile->state.in_directive)
1217 return padding_token (pfile, result);
1222 _cpp_pop_context (pfile);
1223 if (pfile->state.in_directive)
1225 return &pfile->avoid_paste;
1228 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1231 if (result->type != CPP_NAME)
1234 node = result->val.node;
1236 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1239 if (!(node->flags & NODE_DISABLED))
1242 /* If not in a macro context, and we're going to start an
1243 expansion, record the location. */
1244 if (can_set && !context->macro)
1245 pfile->invocation_location = result->src_loc;
1246 if (pfile->state.prevent_expansion)
1248 ret = enter_macro_context (pfile, node, result);
1251 if (pfile->state.in_directive || ret == 2)
1253 return padding_token (pfile, result);
1258 /* Flag this token as always unexpandable. FIXME: move this
1259 to collect_args()?. */
1260 cpp_token *t = _cpp_temp_token (pfile);
1261 t->type = result->type;
1262 t->flags = result->flags | NO_EXPAND;
1263 t->val = result->val;
1273 /* Like cpp_get_token, but also returns a location separate from the
1274 one provided by the returned token. LOC is an out parameter; *LOC
1275 is set to the location "as expected by the user". This matters
1276 when a token results from macro expansion -- the token's location
1277 will indicate where the macro is defined, but *LOC will be the
1278 location of the start of the expansion. */
1280 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1282 const cpp_token *result;
1284 pfile->set_invocation_location = true;
1285 result = cpp_get_token (pfile);
1286 if (pfile->context->macro)
1287 *loc = pfile->invocation_location;
1289 *loc = result->src_loc;
1294 /* Returns true if we're expanding an object-like macro that was
1295 defined in a system header. Just checks the macro at the top of
1296 the stack. Used for diagnostic suppression. */
1298 cpp_sys_macro_p (cpp_reader *pfile)
1300 cpp_hashnode *node = pfile->context->macro;
1302 return node && node->value.macro && node->value.macro->syshdr;
1305 /* Read each token in, until end of the current file. Directives are
1306 transparently processed. */
1308 cpp_scan_nooutput (cpp_reader *pfile)
1310 /* Request a CPP_EOF token at the end of this file, rather than
1311 transparently continuing with the including file. */
1312 pfile->buffer->return_at_eof = true;
1314 pfile->state.discarding_output++;
1315 pfile->state.prevent_expansion++;
1317 if (CPP_OPTION (pfile, traditional))
1318 while (_cpp_read_logical_line_trad (pfile))
1321 while (cpp_get_token (pfile)->type != CPP_EOF)
1324 pfile->state.discarding_output--;
1325 pfile->state.prevent_expansion--;
1328 /* Step back one (or more) tokens. Can only step back more than 1 if
1329 they are from the lexer, and not from macro expansion. */
1331 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1333 if (pfile->context->prev == NULL)
1335 pfile->lookaheads += count;
1339 if (pfile->cur_token == pfile->cur_run->base
1340 /* Possible with -fpreprocessed and no leading #line. */
1341 && pfile->cur_run->prev != NULL)
1343 pfile->cur_run = pfile->cur_run->prev;
1344 pfile->cur_token = pfile->cur_run->limit;
1352 if (pfile->context->direct_p)
1353 FIRST (pfile->context).token--;
1355 FIRST (pfile->context).ptoken--;
1359 /* #define directive parsing and handling. */
1361 /* Returns nonzero if a macro redefinition warning is required. */
1363 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1364 const cpp_macro *macro2)
1366 const cpp_macro *macro1;
1369 /* Some redefinitions need to be warned about regardless. */
1370 if (node->flags & NODE_WARN)
1373 /* Redefinition of a macro is allowed if and only if the old and new
1374 definitions are the same. (6.10.3 paragraph 2). */
1375 macro1 = node->value.macro;
1377 /* Don't check count here as it can be different in valid
1378 traditional redefinitions with just whitespace differences. */
1379 if (macro1->paramc != macro2->paramc
1380 || macro1->fun_like != macro2->fun_like
1381 || macro1->variadic != macro2->variadic)
1384 /* Check parameter spellings. */
1385 for (i = 0; i < macro1->paramc; i++)
1386 if (macro1->params[i] != macro2->params[i])
1389 /* Check the replacement text or tokens. */
1390 if (CPP_OPTION (pfile, traditional))
1391 return _cpp_expansions_different_trad (macro1, macro2);
1393 if (macro1->count != macro2->count)
1396 for (i = 0; i < macro1->count; i++)
1397 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
1403 /* Free the definition of hashnode H. */
1405 _cpp_free_definition (cpp_hashnode *h)
1407 /* Macros and assertions no longer have anything to free. */
1409 /* Clear builtin flag in case of redefinition. */
1410 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
1413 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1414 zero on success, nonzero if the parameter is a duplicate. */
1416 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1419 /* Constraint 6.10.3.6 - duplicate parameter names. */
1420 if (node->flags & NODE_MACRO_ARG)
1422 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1427 if (BUFF_ROOM (pfile->a_buff)
1428 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1429 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1431 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1432 node->flags |= NODE_MACRO_ARG;
1433 len = macro->paramc * sizeof (union _cpp_hashnode_value);
1434 if (len > pfile->macro_buffer_len)
1436 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1438 pfile->macro_buffer_len = len;
1440 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1443 node->value.arg_index = macro->paramc;
1447 /* Check the syntax of the parameters in a MACRO definition. Returns
1448 false if an error occurs. */
1450 parse_params (cpp_reader *pfile, cpp_macro *macro)
1452 unsigned int prev_ident = 0;
1456 const cpp_token *token = _cpp_lex_token (pfile);
1458 switch (token->type)
1461 /* Allow/ignore comments in parameter lists if we are
1462 preserving comments in macro expansions. */
1463 if (token->type == CPP_COMMENT
1464 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1467 cpp_error (pfile, CPP_DL_ERROR,
1468 "\"%s\" may not appear in macro parameter list",
1469 cpp_token_as_text (pfile, token));
1475 cpp_error (pfile, CPP_DL_ERROR,
1476 "macro parameters must be comma-separated");
1481 if (_cpp_save_parameter (pfile, macro, token->val.node))
1485 case CPP_CLOSE_PAREN:
1486 if (prev_ident || macro->paramc == 0)
1489 /* Fall through to pick up the error. */
1493 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1500 macro->variadic = 1;
1503 _cpp_save_parameter (pfile, macro,
1504 pfile->spec_nodes.n__VA_ARGS__);
1505 pfile->state.va_args_ok = 1;
1506 if (! CPP_OPTION (pfile, c99)
1507 && CPP_OPTION (pfile, pedantic)
1508 && CPP_OPTION (pfile, warn_variadic_macros))
1509 cpp_error (pfile, CPP_DL_PEDWARN,
1510 "anonymous variadic macros were introduced in C99");
1512 else if (CPP_OPTION (pfile, pedantic)
1513 && CPP_OPTION (pfile, warn_variadic_macros))
1514 cpp_error (pfile, CPP_DL_PEDWARN,
1515 "ISO C does not permit named variadic macros");
1517 /* We're at the end, and just expect a closing parenthesis. */
1518 token = _cpp_lex_token (pfile);
1519 if (token->type == CPP_CLOSE_PAREN)
1524 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1530 /* Allocate room for a token from a macro's replacement list. */
1532 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1534 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1535 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1537 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1540 /* Lex a token from the expansion of MACRO, but mark parameters as we
1541 find them and warn of traditional stringification. */
1543 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1545 cpp_token *token, *saved_cur_token;
1547 saved_cur_token = pfile->cur_token;
1548 pfile->cur_token = alloc_expansion_token (pfile, macro);
1549 token = _cpp_lex_direct (pfile);
1550 pfile->cur_token = saved_cur_token;
1552 /* Is this a parameter? */
1553 if (token->type == CPP_NAME
1554 && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1556 token->type = CPP_MACRO_ARG;
1557 token->val.arg_no = token->val.node->value.arg_index;
1559 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1560 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1561 check_trad_stringification (pfile, macro, &token->val.str);
1567 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1570 const cpp_token *ctoken;
1571 bool following_paste_op = false;
1572 const char *paste_op_error_msg =
1573 N_("'##' cannot appear at either end of a macro expansion");
1575 /* Get the first token of the expansion (or the '(' of a
1576 function-like macro). */
1577 ctoken = _cpp_lex_token (pfile);
1579 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1581 bool ok = parse_params (pfile, macro);
1582 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1586 /* Success. Commit or allocate the parameter array. */
1587 if (pfile->hash_table->alloc_subobject)
1589 cpp_hashnode **params =
1590 (cpp_hashnode **) pfile->hash_table->alloc_subobject
1591 (sizeof (cpp_hashnode *) * macro->paramc);
1592 memcpy (params, macro->params,
1593 sizeof (cpp_hashnode *) * macro->paramc);
1594 macro->params = params;
1597 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
1598 macro->fun_like = 1;
1600 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1602 /* While ISO C99 requires whitespace before replacement text
1603 in a macro definition, ISO C90 with TC1 allows there characters
1604 from the basic source character set. */
1605 if (CPP_OPTION (pfile, c99))
1606 cpp_error (pfile, CPP_DL_PEDWARN,
1607 "ISO C99 requires whitespace after the macro name");
1610 int warntype = CPP_DL_WARNING;
1611 switch (ctoken->type)
1615 case CPP_OBJC_STRING:
1616 /* '@' is not in basic character set. */
1617 warntype = CPP_DL_PEDWARN;
1620 /* Basic character set sans letters, digits and _. */
1621 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1622 ctoken->val.str.text[0]) == NULL)
1623 warntype = CPP_DL_PEDWARN;
1626 /* All other tokens start with a character from basic
1630 cpp_error (pfile, warntype,
1631 "missing whitespace after the macro name");
1635 if (macro->fun_like)
1636 token = lex_expansion_token (pfile, macro);
1639 token = alloc_expansion_token (pfile, macro);
1645 /* Check the stringifying # constraint 6.10.3.2.1 of
1646 function-like macros when lexing the subsequent token. */
1647 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1649 if (token->type == CPP_MACRO_ARG)
1651 token->flags &= ~PREV_WHITE;
1652 token->flags |= STRINGIFY_ARG;
1653 token->flags |= token[-1].flags & PREV_WHITE;
1654 token[-1] = token[0];
1657 /* Let assembler get away with murder. */
1658 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1660 cpp_error (pfile, CPP_DL_ERROR,
1661 "'#' is not followed by a macro parameter");
1666 if (token->type == CPP_EOF)
1668 /* Paste operator constraint 6.10.3.3.1:
1669 Token-paste ##, can appear in both object-like and
1670 function-like macros, but not at the end. */
1671 if (following_paste_op)
1673 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1679 /* Paste operator constraint 6.10.3.3.1. */
1680 if (token->type == CPP_PASTE)
1682 /* Token-paste ##, can appear in both object-like and
1683 function-like macros, but not at the beginning. */
1684 if (macro->count == 1)
1686 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1691 token[-1].flags |= PASTE_LEFT;
1694 following_paste_op = (token->type == CPP_PASTE);
1695 token = lex_expansion_token (pfile, macro);
1698 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1699 macro->traditional = 0;
1701 /* Don't count the CPP_EOF. */
1704 /* Clear whitespace on first token for warn_of_redefinition(). */
1706 macro->exp.tokens[0].flags &= ~PREV_WHITE;
1708 /* Commit or allocate the memory. */
1709 if (pfile->hash_table->alloc_subobject)
1712 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1714 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1715 macro->exp.tokens = tokns;
1718 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
1723 /* Parse a macro and save its expansion. Returns nonzero on success. */
1725 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1731 if (pfile->hash_table->alloc_subobject)
1732 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1733 (sizeof (cpp_macro));
1735 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1736 macro->line = pfile->directive_line;
1739 macro->variadic = 0;
1740 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1742 macro->fun_like = 0;
1743 /* To suppress some diagnostics. */
1744 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1746 if (CPP_OPTION (pfile, traditional))
1747 ok = _cpp_create_trad_definition (pfile, macro);
1750 ok = create_iso_definition (pfile, macro);
1752 /* We set the type for SEEN_EOL() in directives.c.
1754 Longer term we should lex the whole line before coming here,
1755 and just copy the expansion. */
1757 /* Stop the lexer accepting __VA_ARGS__. */
1758 pfile->state.va_args_ok = 0;
1761 /* Clear the fast argument lookup indices. */
1762 for (i = macro->paramc; i-- > 0; )
1764 struct cpp_hashnode *node = macro->params[i];
1765 node->flags &= ~ NODE_MACRO_ARG;
1766 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1772 if (node->type == NT_MACRO)
1774 if (CPP_OPTION (pfile, warn_unused_macros))
1775 _cpp_warn_if_unused_macro (pfile, node, NULL);
1777 if (warn_of_redefinition (pfile, node, macro))
1779 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1780 "\"%s\" redefined", NODE_NAME (node));
1782 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1783 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1784 node->value.macro->line, 0,
1785 "this is the location of the previous definition");
1789 if (node->type != NT_VOID)
1790 _cpp_free_definition (node);
1792 /* Enter definition in hash table. */
1793 node->type = NT_MACRO;
1794 node->value.macro = macro;
1795 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
1796 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1797 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1798 in the C standard, as something that one must use in C++.
1799 However DR#593 indicates that these aren't actually mentioned
1800 in the C++ standard. We special-case them anyway. */
1801 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1802 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
1803 node->flags |= NODE_WARN;
1808 /* Warn if a token in STRING matches one of a function-like MACRO's
1811 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1812 const cpp_string *string)
1814 unsigned int i, len;
1815 const uchar *p, *q, *limit;
1817 /* Loop over the string. */
1818 limit = string->text + string->len - 1;
1819 for (p = string->text + 1; p < limit; p = q)
1821 /* Find the start of an identifier. */
1822 while (p < limit && !is_idstart (*p))
1825 /* Find the end of the identifier. */
1827 while (q < limit && is_idchar (*q))
1832 /* Loop over the function macro arguments to see if the
1833 identifier inside the string matches one of them. */
1834 for (i = 0; i < macro->paramc; i++)
1836 const cpp_hashnode *node = macro->params[i];
1838 if (NODE_LEN (node) == len
1839 && !memcmp (p, NODE_NAME (node), len))
1841 cpp_error (pfile, CPP_DL_WARNING,
1842 "macro argument \"%s\" would be stringified in traditional C",
1850 /* Returns the name, arguments and expansion of a macro, in a format
1851 suitable to be read back in again, and therefore also for DWARF 2
1852 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1853 Caller is expected to generate the "#define" bit if needed. The
1854 returned text is temporary, and automatically freed later. */
1855 const unsigned char *
1856 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1858 unsigned int i, len;
1859 const cpp_macro *macro = node->value.macro;
1860 unsigned char *buffer;
1862 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1864 cpp_error (pfile, CPP_DL_ICE,
1865 "invalid hash type %d in cpp_macro_definition", node->type);
1869 /* Calculate length. */
1870 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
1871 if (macro->fun_like)
1873 len += 4; /* "()" plus possible final ".." of named
1874 varargs (we have + 1 below). */
1875 for (i = 0; i < macro->paramc; i++)
1876 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1879 /* This should match below where we fill in the buffer. */
1880 if (CPP_OPTION (pfile, traditional))
1881 len += _cpp_replacement_text_len (macro);
1884 for (i = 0; i < macro->count; i++)
1886 cpp_token *token = ¯o->exp.tokens[i];
1888 if (token->type == CPP_MACRO_ARG)
1889 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1891 len += cpp_token_len (token);
1893 if (token->flags & STRINGIFY_ARG)
1895 if (token->flags & PASTE_LEFT)
1896 len += 3; /* " ##" */
1897 if (token->flags & PREV_WHITE)
1902 if (len > pfile->macro_buffer_len)
1904 pfile->macro_buffer = XRESIZEVEC (unsigned char,
1905 pfile->macro_buffer, len);
1906 pfile->macro_buffer_len = len;
1909 /* Fill in the buffer. Start with the macro name. */
1910 buffer = pfile->macro_buffer;
1911 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1912 buffer += NODE_LEN (node);
1914 /* Parameter names. */
1915 if (macro->fun_like)
1918 for (i = 0; i < macro->paramc; i++)
1920 cpp_hashnode *param = macro->params[i];
1922 if (param != pfile->spec_nodes.n__VA_ARGS__)
1924 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1925 buffer += NODE_LEN (param);
1928 if (i + 1 < macro->paramc)
1929 /* Don't emit a space after the comma here; we're trying
1930 to emit a Dwarf-friendly definition, and the Dwarf spec
1931 forbids spaces in the argument list. */
1933 else if (macro->variadic)
1934 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1939 /* The Dwarf spec requires a space after the macro name, even if the
1940 definition is the empty string. */
1943 if (CPP_OPTION (pfile, traditional))
1944 buffer = _cpp_copy_replacement_text (macro, buffer);
1945 else if (macro->count)
1946 /* Expansion tokens. */
1948 for (i = 0; i < macro->count; i++)
1950 cpp_token *token = ¯o->exp.tokens[i];
1952 if (token->flags & PREV_WHITE)
1954 if (token->flags & STRINGIFY_ARG)
1957 if (token->type == CPP_MACRO_ARG)
1960 NODE_NAME (macro->params[token->val.arg_no - 1]),
1961 NODE_LEN (macro->params[token->val.arg_no - 1]));
1962 buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1965 buffer = cpp_spell_token (pfile, token, buffer, false);
1967 if (token->flags & PASTE_LEFT)
1972 /* Next has PREV_WHITE; see _cpp_create_definition. */
1978 return pfile->macro_buffer;