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 = UC"\"??? ??? ?? ??:??:?? ????\"";
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 = UC"\"??? ?? ????\"";
260 pfile->time = UC"\"??:??:??\"";
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_CHAR
379 || token->type == CPP_WSTRING || token->type == CPP_STRING
380 || token->type == CPP_STRING32 || token->type == CPP_CHAR32
381 || token->type == CPP_STRING16 || token->type == CPP_CHAR16);
383 /* Room for each char being written in octal, initial space and
384 final quote and NUL. */
385 len = cpp_token_len (token);
390 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
392 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
393 _cpp_extend_buff (pfile, &pfile->u_buff, len);
394 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
397 /* Leading white space? */
398 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
402 if (source->flags & PREV_WHITE)
409 _cpp_buff *buff = _cpp_get_buff (pfile, len);
410 unsigned char *buf = BUFF_FRONT (buff);
411 len = cpp_spell_token (pfile, token, buf, true) - buf;
412 dest = cpp_quote_string (dest, buf, len);
413 _cpp_release_buff (pfile, buff);
416 dest = cpp_spell_token (pfile, token, dest, true);
418 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
424 /* Ignore the final \ of invalid string literals. */
425 if (backslash_count & 1)
427 cpp_error (pfile, CPP_DL_WARNING,
428 "invalid string literal, ignoring final '\\'");
432 /* Commit the memory, including NUL, and return the token. */
434 len = dest - BUFF_FRONT (pfile->u_buff);
435 BUFF_FRONT (pfile->u_buff) = dest + 1;
436 return new_string_token (pfile, dest - len, len);
439 /* Try to paste two tokens. On success, return nonzero. In any
440 case, PLHS is updated to point to the pasted token, which is
441 guaranteed to not have the PASTE_LEFT flag set. */
443 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
445 unsigned char *buf, *end, *lhsend;
449 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
450 buf = (unsigned char *) alloca (len);
451 end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
453 /* Avoid comment headers, since they are still processed in stage 3.
454 It is simpler to insert a space here, rather than modifying the
455 lexer to ignore comments in some circumstances. Simply returning
456 false doesn't work, since we want to clear the PASTE_LEFT flag. */
457 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
459 /* In one obscure case we might see padding here. */
460 if (rhs->type != CPP_PADDING)
461 end = cpp_spell_token (pfile, rhs, end, false);
464 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
465 _cpp_clean_line (pfile);
467 /* Set pfile->cur_token as required by _cpp_lex_direct. */
468 pfile->cur_token = _cpp_temp_token (pfile);
469 lhs = _cpp_lex_direct (pfile);
470 if (pfile->buffer->cur != pfile->buffer->rlimit)
472 source_location saved_loc = lhs->src_loc;
474 _cpp_pop_buffer (pfile);
475 _cpp_backup_tokens (pfile, 1);
478 /* We have to remove the PASTE_LEFT flag from the old lhs, but
479 we want to keep the new location. */
482 lhs->src_loc = saved_loc;
483 lhs->flags &= ~PASTE_LEFT;
485 /* Mandatory error for all apart from assembler. */
486 if (CPP_OPTION (pfile, lang) != CLK_ASM)
487 cpp_error (pfile, CPP_DL_ERROR,
488 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
489 buf, cpp_token_as_text (pfile, rhs));
494 _cpp_pop_buffer (pfile);
498 /* Handles an arbitrarily long sequence of ## operators, with initial
499 operand LHS. This implementation is left-associative,
500 non-recursive, and finishes a paste before handling succeeding
501 ones. If a paste fails, we back up to the RHS of the failing ##
502 operator before pushing the context containing the result of prior
503 successful pastes, with the effect that the RHS appears in the
504 output stream after the pasted LHS normally. */
506 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
508 const cpp_token *rhs;
509 cpp_context *context = pfile->context;
513 /* Take the token directly from the current context. We can do
514 this, because we are in the replacement list of either an
515 object-like macro, or a function-like macro with arguments
516 inserted. In either case, the constraints to #define
517 guarantee we have at least one more token. */
518 if (context->direct_p)
519 rhs = FIRST (context).token++;
521 rhs = *FIRST (context).ptoken++;
523 if (rhs->type == CPP_PADDING)
525 if (rhs->flags & PASTE_LEFT)
528 if (!paste_tokens (pfile, &lhs, rhs))
531 while (rhs->flags & PASTE_LEFT);
533 /* Put the resulting token in its own context. */
534 _cpp_push_token_context (pfile, NULL, lhs, 1);
537 /* Returns TRUE if the number of arguments ARGC supplied in an
538 invocation of the MACRO referenced by NODE is valid. An empty
539 invocation to a macro with no parameters should pass ARGC as zero.
541 Note that MACRO cannot necessarily be deduced from NODE, in case
542 NODE was redefined whilst collecting arguments. */
544 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
546 if (argc == macro->paramc)
549 if (argc < macro->paramc)
551 /* As an extension, a rest argument is allowed to not appear in
552 the invocation at all.
553 e.g. #define debug(format, args...) something
556 This is exactly the same as if there had been an empty rest
557 argument - debug("string", ). */
559 if (argc + 1 == macro->paramc && macro->variadic)
561 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
562 cpp_error (pfile, CPP_DL_PEDWARN,
563 "ISO C99 requires rest arguments to be used");
567 cpp_error (pfile, CPP_DL_ERROR,
568 "macro \"%s\" requires %u arguments, but only %u given",
569 NODE_NAME (node), macro->paramc, argc);
572 cpp_error (pfile, CPP_DL_ERROR,
573 "macro \"%s\" passed %u arguments, but takes just %u",
574 NODE_NAME (node), argc, macro->paramc);
579 /* Reads and returns the arguments to a function-like macro
580 invocation. Assumes the opening parenthesis has been processed.
581 If there is an error, emits an appropriate diagnostic and returns
582 NULL. Each argument is terminated by a CPP_EOF token, for the
583 future benefit of expand_arg(). If there are any deferred
584 #pragma directives among macro arguments, store pointers to the
585 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. */
587 collect_args (cpp_reader *pfile, const cpp_hashnode *node,
588 _cpp_buff **pragma_buff)
590 _cpp_buff *buff, *base_buff;
592 macro_arg *args, *arg;
593 const cpp_token *token;
596 macro = node->value.macro;
598 argc = macro->paramc;
601 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
602 + sizeof (macro_arg)));
604 args = (macro_arg *) buff->base;
605 memset (args, 0, argc * sizeof (macro_arg));
606 buff->cur = (unsigned char *) &args[argc];
607 arg = args, argc = 0;
609 /* Collect the tokens making up each argument. We don't yet know
610 how many arguments have been supplied, whether too many or too
611 few. Hence the slightly bizarre usage of "argc" and "arg". */
614 unsigned int paren_depth = 0;
615 unsigned int ntokens = 0;
618 arg->first = (const cpp_token **) buff->cur;
622 /* Require space for 2 new tokens (including a CPP_EOF). */
623 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
625 buff = _cpp_append_extend_buff (pfile, buff,
626 1000 * sizeof (cpp_token *));
627 arg->first = (const cpp_token **) buff->cur;
630 token = cpp_get_token (pfile);
632 if (token->type == CPP_PADDING)
634 /* Drop leading padding. */
638 else if (token->type == CPP_OPEN_PAREN)
640 else if (token->type == CPP_CLOSE_PAREN)
642 if (paren_depth-- == 0)
645 else if (token->type == CPP_COMMA)
647 /* A comma does not terminate an argument within
648 parentheses or as part of a variable argument. */
650 && ! (macro->variadic && argc == macro->paramc))
653 else if (token->type == CPP_EOF
654 || (token->type == CPP_HASH && token->flags & BOL))
656 else if (token->type == CPP_PRAGMA)
658 cpp_token *newtok = _cpp_temp_token (pfile);
660 /* CPP_PRAGMA token lives in directive_result, which will
661 be overwritten on the next directive. */
666 if (*pragma_buff == NULL
667 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
670 if (*pragma_buff == NULL)
672 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
677 = _cpp_get_buff (pfile,
678 (BUFF_FRONT (*pragma_buff)
679 - (*pragma_buff)->base) * 2);
680 (*pragma_buff)->next = next;
683 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
684 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
685 if (token->type == CPP_PRAGMA_EOL)
687 token = cpp_get_token (pfile);
689 while (token->type != CPP_EOF);
691 /* In deferred pragmas parsing_args and prevent_expansion
692 had been changed, reset it. */
693 pfile->state.parsing_args = 2;
694 pfile->state.prevent_expansion = 1;
696 if (token->type == CPP_EOF)
702 arg->first[ntokens++] = token;
705 /* Drop trailing padding. */
706 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
709 arg->count = ntokens;
710 arg->first[ntokens] = &pfile->eof;
712 /* Terminate the argument. Excess arguments loop back and
713 overwrite the final legitimate argument, before failing. */
714 if (argc <= macro->paramc)
716 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
717 if (argc != macro->paramc)
721 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
723 if (token->type == CPP_EOF)
725 /* We still need the CPP_EOF to end directives, and to end
726 pre-expansion of a macro argument. Step back is not
727 unconditional, since we don't want to return a CPP_EOF to our
728 callers at the end of an -include-d file. */
729 if (pfile->context->prev || pfile->state.in_directive)
730 _cpp_backup_tokens (pfile, 1);
731 cpp_error (pfile, CPP_DL_ERROR,
732 "unterminated argument list invoking macro \"%s\"",
737 /* A single empty argument is counted as no argument. */
738 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
740 if (_cpp_arguments_ok (pfile, macro, node, argc))
742 /* GCC has special semantics for , ## b where b is a varargs
743 parameter: we remove the comma if b was omitted entirely.
744 If b was merely an empty argument, the comma is retained.
745 If the macro takes just one (varargs) parameter, then we
746 retain the comma only if we are standards conforming.
748 If FIRST is NULL replace_args () swallows the comma. */
749 if (macro->variadic && (argc < macro->paramc
750 || (argc == 1 && args[0].count == 0
751 && !CPP_OPTION (pfile, std))))
752 args[macro->paramc - 1].first = NULL;
757 /* An error occurred. */
758 _cpp_release_buff (pfile, base_buff);
762 /* Search for an opening parenthesis to the macro of NODE, in such a
763 way that, if none is found, we don't lose the information in any
764 intervening padding tokens. If we find the parenthesis, collect
765 the arguments and return the buffer containing them. PRAGMA_BUFF
766 argument is the same as in collect_args. */
768 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
769 _cpp_buff **pragma_buff)
771 const cpp_token *token, *padding = NULL;
775 token = cpp_get_token (pfile);
776 if (token->type != CPP_PADDING)
779 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
783 if (token->type == CPP_OPEN_PAREN)
785 pfile->state.parsing_args = 2;
786 return collect_args (pfile, node, pragma_buff);
789 /* CPP_EOF can be the end of macro arguments, or the end of the
790 file. We mustn't back up over the latter. Ugh. */
791 if (token->type != CPP_EOF || token == &pfile->eof)
793 /* Back up. We may have skipped padding, in which case backing
794 up more than one token when expanding macros is in general
795 too difficult. We re-insert it in its own context. */
796 _cpp_backup_tokens (pfile, 1);
798 _cpp_push_token_context (pfile, NULL, padding, 1);
804 /* Push the context of a macro with hash entry NODE onto the context
805 stack. If we can successfully expand the macro, we push a context
806 containing its yet-to-be-rescanned replacement list and return one.
807 If there were additionally any unexpanded deferred #pragma directives
808 among macro arguments, push another context containing the
809 pragma tokens before the yet-to-be-rescanned replacement list
810 and return two. Otherwise, we don't push a context and return zero. */
812 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
813 const cpp_token *result)
815 /* The presence of a macro invalidates a file's controlling macro. */
816 pfile->mi_valid = false;
818 pfile->state.angled_headers = false;
820 if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
822 node->flags |= NODE_USED;
823 if (pfile->cb.used_define)
824 pfile->cb.used_define (pfile, pfile->directive_line, node);
827 /* Handle standard macros. */
828 if (! (node->flags & NODE_BUILTIN))
830 cpp_macro *macro = node->value.macro;
831 _cpp_buff *pragma_buff = NULL;
837 pfile->state.prevent_expansion++;
838 pfile->keep_tokens++;
839 pfile->state.parsing_args = 1;
840 buff = funlike_invocation_p (pfile, node, &pragma_buff);
841 pfile->state.parsing_args = 0;
842 pfile->keep_tokens--;
843 pfile->state.prevent_expansion--;
847 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
848 cpp_error (pfile, CPP_DL_WARNING,
849 "function-like macro \"%s\" must be used with arguments in traditional C",
853 _cpp_release_buff (pfile, pragma_buff);
858 if (macro->paramc > 0)
859 replace_args (pfile, node, macro, (macro_arg *) buff->base);
860 _cpp_release_buff (pfile, buff);
863 /* Disable the macro within its expansion. */
864 node->flags |= NODE_DISABLED;
866 if (!(node->flags & NODE_USED))
868 node->flags |= NODE_USED;
869 if (pfile->cb.used_define)
870 pfile->cb.used_define (pfile, pfile->directive_line, node);
875 if (macro->paramc == 0)
876 _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
880 if (!pfile->state.in_directive)
881 _cpp_push_token_context (pfile, NULL,
882 padding_token (pfile, result), 1);
885 _cpp_buff *tail = pragma_buff->next;
886 pragma_buff->next = NULL;
887 push_ptoken_context (pfile, NULL, pragma_buff,
888 (const cpp_token **) pragma_buff->base,
889 ((const cpp_token **) BUFF_FRONT (pragma_buff)
890 - (const cpp_token **) pragma_buff->base));
893 while (pragma_buff != NULL);
900 /* Handle built-in macros and the _Pragma operator. */
901 return builtin_macro (pfile, node);
904 /* Replace the parameters in a function-like macro of NODE with the
905 actual ARGS, and place the result in a newly pushed token context.
906 Expand each argument before replacing, unless it is operated upon
907 by the # or ## operators. */
909 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
911 unsigned int i, total;
912 const cpp_token *src, *limit;
913 const cpp_token **dest, **first;
917 /* First, fully macro-expand arguments, calculating the number of
918 tokens in the final expansion as we go. The ordering of the if
919 statements below is subtle; we must handle stringification before
921 total = macro->count;
922 limit = macro->exp.tokens + macro->count;
924 for (src = macro->exp.tokens; src < limit; src++)
925 if (src->type == CPP_MACRO_ARG)
927 /* Leading and trailing padding tokens. */
930 /* We have an argument. If it is not being stringified or
931 pasted it is macro-replaced before insertion. */
932 arg = &args[src->val.arg_no - 1];
934 if (src->flags & STRINGIFY_ARG)
936 if (!arg->stringified)
937 arg->stringified = stringify_arg (pfile, arg);
939 else if ((src->flags & PASTE_LEFT)
940 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
941 total += arg->count - 1;
945 expand_arg (pfile, arg);
946 total += arg->expanded_count - 1;
950 /* Now allocate space for the expansion, copy the tokens and replace
952 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
953 first = (const cpp_token **) buff->base;
956 for (src = macro->exp.tokens; src < limit; src++)
959 const cpp_token **from, **paste_flag;
961 if (src->type != CPP_MACRO_ARG)
968 arg = &args[src->val.arg_no - 1];
969 if (src->flags & STRINGIFY_ARG)
970 count = 1, from = &arg->stringified;
971 else if (src->flags & PASTE_LEFT)
972 count = arg->count, from = arg->first;
973 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
975 count = arg->count, from = arg->first;
978 if (dest[-1]->type == CPP_COMMA
980 && src->val.arg_no == macro->paramc)
982 /* Swallow a pasted comma if from == NULL, otherwise
983 drop the paste flag. */
987 paste_flag = dest - 1;
989 /* Remove the paste flag if the RHS is a placemarker. */
991 paste_flag = dest - 1;
995 count = arg->expanded_count, from = arg->expanded;
997 /* Padding on the left of an argument (unless RHS of ##). */
998 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
999 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
1000 *dest++ = padding_token (pfile, src);
1004 memcpy (dest, from, count * sizeof (cpp_token *));
1007 /* With a non-empty argument on the LHS of ##, the last
1008 token should be flagged PASTE_LEFT. */
1009 if (src->flags & PASTE_LEFT)
1010 paste_flag = dest - 1;
1012 else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1013 && ! CPP_OPTION (pfile, c99)
1014 && ! cpp_in_system_header (pfile))
1016 cpp_error (pfile, CPP_DL_PEDWARN,
1017 "invoking macro %s argument %d: "
1018 "empty macro arguments are undefined"
1019 " in ISO C90 and ISO C++98",
1024 /* Avoid paste on RHS (even case count == 0). */
1025 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1026 *dest++ = &pfile->avoid_paste;
1028 /* Add a new paste flag, or remove an unwanted one. */
1031 cpp_token *token = _cpp_temp_token (pfile);
1032 token->type = (*paste_flag)->type;
1033 token->val = (*paste_flag)->val;
1034 if (src->flags & PASTE_LEFT)
1035 token->flags = (*paste_flag)->flags | PASTE_LEFT;
1037 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1038 *paste_flag = token;
1042 /* Free the expanded arguments. */
1043 for (i = 0; i < macro->paramc; i++)
1044 if (args[i].expanded)
1045 free (args[i].expanded);
1047 push_ptoken_context (pfile, node, buff, first, dest - first);
1050 /* Return a special padding token, with padding inherited from SOURCE. */
1051 static const cpp_token *
1052 padding_token (cpp_reader *pfile, const cpp_token *source)
1054 cpp_token *result = _cpp_temp_token (pfile);
1056 result->type = CPP_PADDING;
1058 /* Data in GCed data structures cannot be made const so far, so we
1059 need a cast here. */
1060 result->val.source = (cpp_token *) source;
1065 /* Get a new uninitialized context. Create a new one if we cannot
1066 re-use an old one. */
1067 static cpp_context *
1068 next_context (cpp_reader *pfile)
1070 cpp_context *result = pfile->context->next;
1074 result = XNEW (cpp_context);
1075 result->prev = pfile->context;
1077 pfile->context->next = result;
1080 pfile->context = result;
1084 /* Push a list of pointers to tokens. */
1086 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1087 const cpp_token **first, unsigned int count)
1089 cpp_context *context = next_context (pfile);
1091 context->direct_p = false;
1092 context->macro = macro;
1093 context->buff = buff;
1094 FIRST (context).ptoken = first;
1095 LAST (context).ptoken = first + count;
1098 /* Push a list of tokens. */
1100 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1101 const cpp_token *first, unsigned int count)
1103 cpp_context *context = next_context (pfile);
1105 context->direct_p = true;
1106 context->macro = macro;
1107 context->buff = NULL;
1108 FIRST (context).token = first;
1109 LAST (context).token = first + count;
1112 /* Push a traditional macro's replacement text. */
1114 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1115 const uchar *start, size_t len)
1117 cpp_context *context = next_context (pfile);
1119 context->direct_p = true;
1120 context->macro = macro;
1121 context->buff = NULL;
1122 CUR (context) = start;
1123 RLIMIT (context) = start + len;
1124 macro->flags |= NODE_DISABLED;
1127 /* Expand an argument ARG before replacing parameters in a
1128 function-like macro. This works by pushing a context with the
1129 argument's tokens, and then expanding that into a temporary buffer
1130 as if it were a normal part of the token stream. collect_args()
1131 has terminated the argument's tokens with a CPP_EOF so that we know
1132 when we have fully expanded the argument. */
1134 expand_arg (cpp_reader *pfile, macro_arg *arg)
1136 unsigned int capacity;
1137 bool saved_warn_trad;
1139 if (arg->count == 0)
1142 /* Don't warn about funlike macros when pre-expanding. */
1143 saved_warn_trad = CPP_WTRADITIONAL (pfile);
1144 CPP_WTRADITIONAL (pfile) = 0;
1146 /* Loop, reading in the arguments. */
1148 arg->expanded = XNEWVEC (const cpp_token *, capacity);
1150 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1153 const cpp_token *token;
1155 if (arg->expanded_count + 1 >= capacity)
1158 arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1162 token = cpp_get_token (pfile);
1164 if (token->type == CPP_EOF)
1167 arg->expanded[arg->expanded_count++] = token;
1170 _cpp_pop_context (pfile);
1172 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1175 /* Pop the current context off the stack, re-enabling the macro if the
1176 context represented a macro's replacement list. The context
1177 structure is not freed so that we can re-use it later. */
1179 _cpp_pop_context (cpp_reader *pfile)
1181 cpp_context *context = pfile->context;
1184 context->macro->flags &= ~NODE_DISABLED;
1187 _cpp_release_buff (pfile, context->buff);
1189 pfile->context = context->prev;
1192 /* External routine to get a token. Also used nearly everywhere
1193 internally, except for places where we know we can safely call
1194 _cpp_lex_token directly, such as lexing a directive name.
1196 Macro expansions and directives are transparently handled,
1197 including entering included files. Thus tokens are post-macro
1198 expansion, and after any intervening directives. External callers
1199 see CPP_EOF only at EOF. Internal callers also see it when meeting
1200 a directive inside a macro call, when at the end of a directive and
1201 state.in_directive is still 1, and at the end of argument
1204 cpp_get_token (cpp_reader *pfile)
1206 const cpp_token *result;
1207 bool can_set = pfile->set_invocation_location;
1208 pfile->set_invocation_location = false;
1213 cpp_context *context = pfile->context;
1215 /* Context->prev == 0 <=> base context. */
1217 result = _cpp_lex_token (pfile);
1218 else if (FIRST (context).token != LAST (context).token)
1220 if (context->direct_p)
1221 result = FIRST (context).token++;
1223 result = *FIRST (context).ptoken++;
1225 if (result->flags & PASTE_LEFT)
1227 paste_all_tokens (pfile, result);
1228 if (pfile->state.in_directive)
1230 return padding_token (pfile, result);
1235 _cpp_pop_context (pfile);
1236 if (pfile->state.in_directive)
1238 return &pfile->avoid_paste;
1241 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1244 if (result->type != CPP_NAME)
1247 node = result->val.node;
1249 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1252 if (!(node->flags & NODE_DISABLED))
1255 /* If not in a macro context, and we're going to start an
1256 expansion, record the location. */
1257 if (can_set && !context->macro)
1258 pfile->invocation_location = result->src_loc;
1259 if (pfile->state.prevent_expansion)
1262 /* Conditional macros require that a predicate be evaluated
1264 if (((!(node->flags & NODE_CONDITIONAL))
1265 || (pfile->cb.macro_to_expand
1266 && (node = pfile->cb.macro_to_expand (pfile, result))))
1267 && (ret = enter_macro_context (pfile, node, result)))
1269 if (pfile->state.in_directive || ret == 2)
1271 return padding_token (pfile, result);
1276 /* Flag this token as always unexpandable. FIXME: move this
1277 to collect_args()?. */
1278 cpp_token *t = _cpp_temp_token (pfile);
1279 t->type = result->type;
1280 t->flags = result->flags | NO_EXPAND;
1281 t->val = result->val;
1291 /* Like cpp_get_token, but also returns a location separate from the
1292 one provided by the returned token. LOC is an out parameter; *LOC
1293 is set to the location "as expected by the user". This matters
1294 when a token results from macro expansion -- the token's location
1295 will indicate where the macro is defined, but *LOC will be the
1296 location of the start of the expansion. */
1298 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1300 const cpp_token *result;
1302 pfile->set_invocation_location = true;
1303 result = cpp_get_token (pfile);
1304 if (pfile->context->macro)
1305 *loc = pfile->invocation_location;
1307 *loc = result->src_loc;
1312 /* Returns true if we're expanding an object-like macro that was
1313 defined in a system header. Just checks the macro at the top of
1314 the stack. Used for diagnostic suppression. */
1316 cpp_sys_macro_p (cpp_reader *pfile)
1318 cpp_hashnode *node = pfile->context->macro;
1320 return node && node->value.macro && node->value.macro->syshdr;
1323 /* Read each token in, until end of the current file. Directives are
1324 transparently processed. */
1326 cpp_scan_nooutput (cpp_reader *pfile)
1328 /* Request a CPP_EOF token at the end of this file, rather than
1329 transparently continuing with the including file. */
1330 pfile->buffer->return_at_eof = true;
1332 pfile->state.discarding_output++;
1333 pfile->state.prevent_expansion++;
1335 if (CPP_OPTION (pfile, traditional))
1336 while (_cpp_read_logical_line_trad (pfile))
1339 while (cpp_get_token (pfile)->type != CPP_EOF)
1342 pfile->state.discarding_output--;
1343 pfile->state.prevent_expansion--;
1346 /* Step back one or more tokens obtained from the lexer. */
1348 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
1350 pfile->lookaheads += count;
1354 if (pfile->cur_token == pfile->cur_run->base
1355 /* Possible with -fpreprocessed and no leading #line. */
1356 && pfile->cur_run->prev != NULL)
1358 pfile->cur_run = pfile->cur_run->prev;
1359 pfile->cur_token = pfile->cur_run->limit;
1364 /* Step back one (or more) tokens. Can only step back more than 1 if
1365 they are from the lexer, and not from macro expansion. */
1367 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1369 if (pfile->context->prev == NULL)
1370 _cpp_backup_tokens_direct (pfile, count);
1375 if (pfile->context->direct_p)
1376 FIRST (pfile->context).token--;
1378 FIRST (pfile->context).ptoken--;
1382 /* #define directive parsing and handling. */
1384 /* Returns nonzero if a macro redefinition warning is required. */
1386 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1387 const cpp_macro *macro2)
1389 const cpp_macro *macro1;
1392 /* Some redefinitions need to be warned about regardless. */
1393 if (node->flags & NODE_WARN)
1396 /* Redefinitions of conditional (context-sensitive) macros, on
1397 the other hand, must be allowed silently. */
1398 if (node->flags & NODE_CONDITIONAL)
1401 /* Redefinition of a macro is allowed if and only if the old and new
1402 definitions are the same. (6.10.3 paragraph 2). */
1403 macro1 = node->value.macro;
1405 /* Don't check count here as it can be different in valid
1406 traditional redefinitions with just whitespace differences. */
1407 if (macro1->paramc != macro2->paramc
1408 || macro1->fun_like != macro2->fun_like
1409 || macro1->variadic != macro2->variadic)
1412 /* Check parameter spellings. */
1413 for (i = 0; i < macro1->paramc; i++)
1414 if (macro1->params[i] != macro2->params[i])
1417 /* Check the replacement text or tokens. */
1418 if (CPP_OPTION (pfile, traditional))
1419 return _cpp_expansions_different_trad (macro1, macro2);
1421 if (macro1->count != macro2->count)
1424 for (i = 0; i < macro1->count; i++)
1425 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
1431 /* Free the definition of hashnode H. */
1433 _cpp_free_definition (cpp_hashnode *h)
1435 /* Macros and assertions no longer have anything to free. */
1437 /* Clear builtin flag in case of redefinition. */
1438 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
1441 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1442 zero on success, nonzero if the parameter is a duplicate. */
1444 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1447 /* Constraint 6.10.3.6 - duplicate parameter names. */
1448 if (node->flags & NODE_MACRO_ARG)
1450 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1455 if (BUFF_ROOM (pfile->a_buff)
1456 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1457 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1459 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1460 node->flags |= NODE_MACRO_ARG;
1461 len = macro->paramc * sizeof (union _cpp_hashnode_value);
1462 if (len > pfile->macro_buffer_len)
1464 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1466 pfile->macro_buffer_len = len;
1468 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1471 node->value.arg_index = macro->paramc;
1475 /* Check the syntax of the parameters in a MACRO definition. Returns
1476 false if an error occurs. */
1478 parse_params (cpp_reader *pfile, cpp_macro *macro)
1480 unsigned int prev_ident = 0;
1484 const cpp_token *token = _cpp_lex_token (pfile);
1486 switch (token->type)
1489 /* Allow/ignore comments in parameter lists if we are
1490 preserving comments in macro expansions. */
1491 if (token->type == CPP_COMMENT
1492 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1495 cpp_error (pfile, CPP_DL_ERROR,
1496 "\"%s\" may not appear in macro parameter list",
1497 cpp_token_as_text (pfile, token));
1503 cpp_error (pfile, CPP_DL_ERROR,
1504 "macro parameters must be comma-separated");
1509 if (_cpp_save_parameter (pfile, macro, token->val.node))
1513 case CPP_CLOSE_PAREN:
1514 if (prev_ident || macro->paramc == 0)
1517 /* Fall through to pick up the error. */
1521 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1528 macro->variadic = 1;
1531 _cpp_save_parameter (pfile, macro,
1532 pfile->spec_nodes.n__VA_ARGS__);
1533 pfile->state.va_args_ok = 1;
1534 if (! CPP_OPTION (pfile, c99)
1535 && CPP_OPTION (pfile, pedantic)
1536 && CPP_OPTION (pfile, warn_variadic_macros))
1537 cpp_error (pfile, CPP_DL_PEDWARN,
1538 "anonymous variadic macros were introduced in C99");
1540 else if (CPP_OPTION (pfile, pedantic)
1541 && CPP_OPTION (pfile, warn_variadic_macros))
1542 cpp_error (pfile, CPP_DL_PEDWARN,
1543 "ISO C does not permit named variadic macros");
1545 /* We're at the end, and just expect a closing parenthesis. */
1546 token = _cpp_lex_token (pfile);
1547 if (token->type == CPP_CLOSE_PAREN)
1552 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1558 /* Allocate room for a token from a macro's replacement list. */
1560 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1562 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1563 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1565 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1568 /* Lex a token from the expansion of MACRO, but mark parameters as we
1569 find them and warn of traditional stringification. */
1571 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1573 cpp_token *token, *saved_cur_token;
1575 saved_cur_token = pfile->cur_token;
1576 pfile->cur_token = alloc_expansion_token (pfile, macro);
1577 token = _cpp_lex_direct (pfile);
1578 pfile->cur_token = saved_cur_token;
1580 /* Is this a parameter? */
1581 if (token->type == CPP_NAME
1582 && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1584 token->type = CPP_MACRO_ARG;
1585 token->val.arg_no = token->val.node->value.arg_index;
1587 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1588 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1589 check_trad_stringification (pfile, macro, &token->val.str);
1595 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1598 const cpp_token *ctoken;
1599 bool following_paste_op = false;
1600 const char *paste_op_error_msg =
1601 N_("'##' cannot appear at either end of a macro expansion");
1603 /* Get the first token of the expansion (or the '(' of a
1604 function-like macro). */
1605 ctoken = _cpp_lex_token (pfile);
1607 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1609 bool ok = parse_params (pfile, macro);
1610 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1614 /* Success. Commit or allocate the parameter array. */
1615 if (pfile->hash_table->alloc_subobject)
1617 cpp_hashnode **params =
1618 (cpp_hashnode **) pfile->hash_table->alloc_subobject
1619 (sizeof (cpp_hashnode *) * macro->paramc);
1620 memcpy (params, macro->params,
1621 sizeof (cpp_hashnode *) * macro->paramc);
1622 macro->params = params;
1625 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
1626 macro->fun_like = 1;
1628 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1630 /* While ISO C99 requires whitespace before replacement text
1631 in a macro definition, ISO C90 with TC1 allows there characters
1632 from the basic source character set. */
1633 if (CPP_OPTION (pfile, c99))
1634 cpp_error (pfile, CPP_DL_PEDWARN,
1635 "ISO C99 requires whitespace after the macro name");
1638 int warntype = CPP_DL_WARNING;
1639 switch (ctoken->type)
1643 case CPP_OBJC_STRING:
1644 /* '@' is not in basic character set. */
1645 warntype = CPP_DL_PEDWARN;
1648 /* Basic character set sans letters, digits and _. */
1649 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1650 ctoken->val.str.text[0]) == NULL)
1651 warntype = CPP_DL_PEDWARN;
1654 /* All other tokens start with a character from basic
1658 cpp_error (pfile, warntype,
1659 "missing whitespace after the macro name");
1663 if (macro->fun_like)
1664 token = lex_expansion_token (pfile, macro);
1667 token = alloc_expansion_token (pfile, macro);
1673 /* Check the stringifying # constraint 6.10.3.2.1 of
1674 function-like macros when lexing the subsequent token. */
1675 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1677 if (token->type == CPP_MACRO_ARG)
1679 token->flags &= ~PREV_WHITE;
1680 token->flags |= STRINGIFY_ARG;
1681 token->flags |= token[-1].flags & PREV_WHITE;
1682 token[-1] = token[0];
1685 /* Let assembler get away with murder. */
1686 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1688 cpp_error (pfile, CPP_DL_ERROR,
1689 "'#' is not followed by a macro parameter");
1694 if (token->type == CPP_EOF)
1696 /* Paste operator constraint 6.10.3.3.1:
1697 Token-paste ##, can appear in both object-like and
1698 function-like macros, but not at the end. */
1699 if (following_paste_op)
1701 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1707 /* Paste operator constraint 6.10.3.3.1. */
1708 if (token->type == CPP_PASTE)
1710 /* Token-paste ##, can appear in both object-like and
1711 function-like macros, but not at the beginning. */
1712 if (macro->count == 1)
1714 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1719 token[-1].flags |= PASTE_LEFT;
1722 following_paste_op = (token->type == CPP_PASTE);
1723 token = lex_expansion_token (pfile, macro);
1726 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1727 macro->traditional = 0;
1729 /* Don't count the CPP_EOF. */
1732 /* Clear whitespace on first token for warn_of_redefinition(). */
1734 macro->exp.tokens[0].flags &= ~PREV_WHITE;
1736 /* Commit or allocate the memory. */
1737 if (pfile->hash_table->alloc_subobject)
1740 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1742 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1743 macro->exp.tokens = tokns;
1746 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
1751 /* Parse a macro and save its expansion. Returns nonzero on success. */
1753 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1759 if (pfile->hash_table->alloc_subobject)
1760 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1761 (sizeof (cpp_macro));
1763 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1764 macro->line = pfile->directive_line;
1767 macro->variadic = 0;
1768 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1770 macro->fun_like = 0;
1771 /* To suppress some diagnostics. */
1772 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1774 if (CPP_OPTION (pfile, traditional))
1775 ok = _cpp_create_trad_definition (pfile, macro);
1778 ok = create_iso_definition (pfile, macro);
1780 /* We set the type for SEEN_EOL() in directives.c.
1782 Longer term we should lex the whole line before coming here,
1783 and just copy the expansion. */
1785 /* Stop the lexer accepting __VA_ARGS__. */
1786 pfile->state.va_args_ok = 0;
1789 /* Clear the fast argument lookup indices. */
1790 for (i = macro->paramc; i-- > 0; )
1792 struct cpp_hashnode *node = macro->params[i];
1793 node->flags &= ~ NODE_MACRO_ARG;
1794 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1800 if (node->type == NT_MACRO)
1802 if (CPP_OPTION (pfile, warn_unused_macros))
1803 _cpp_warn_if_unused_macro (pfile, node, NULL);
1805 if (warn_of_redefinition (pfile, node, macro))
1807 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1808 "\"%s\" redefined", NODE_NAME (node));
1810 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1811 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1812 node->value.macro->line, 0,
1813 "this is the location of the previous definition");
1817 if (node->type != NT_VOID)
1818 _cpp_free_definition (node);
1820 /* Enter definition in hash table. */
1821 node->type = NT_MACRO;
1822 node->value.macro = macro;
1823 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
1824 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1825 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1826 in the C standard, as something that one must use in C++.
1827 However DR#593 indicates that these aren't actually mentioned
1828 in the C++ standard. We special-case them anyway. */
1829 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1830 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
1831 node->flags |= NODE_WARN;
1833 /* If user defines one of the conditional macros, remove the
1835 node->flags &= ~NODE_CONDITIONAL;
1840 /* Warn if a token in STRING matches one of a function-like MACRO's
1843 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1844 const cpp_string *string)
1846 unsigned int i, len;
1847 const uchar *p, *q, *limit;
1849 /* Loop over the string. */
1850 limit = string->text + string->len - 1;
1851 for (p = string->text + 1; p < limit; p = q)
1853 /* Find the start of an identifier. */
1854 while (p < limit && !is_idstart (*p))
1857 /* Find the end of the identifier. */
1859 while (q < limit && is_idchar (*q))
1864 /* Loop over the function macro arguments to see if the
1865 identifier inside the string matches one of them. */
1866 for (i = 0; i < macro->paramc; i++)
1868 const cpp_hashnode *node = macro->params[i];
1870 if (NODE_LEN (node) == len
1871 && !memcmp (p, NODE_NAME (node), len))
1873 cpp_error (pfile, CPP_DL_WARNING,
1874 "macro argument \"%s\" would be stringified in traditional C",
1882 /* Returns the name, arguments and expansion of a macro, in a format
1883 suitable to be read back in again, and therefore also for DWARF 2
1884 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1885 Caller is expected to generate the "#define" bit if needed. The
1886 returned text is temporary, and automatically freed later. */
1887 const unsigned char *
1888 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1890 unsigned int i, len;
1891 const cpp_macro *macro = node->value.macro;
1892 unsigned char *buffer;
1894 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1896 cpp_error (pfile, CPP_DL_ICE,
1897 "invalid hash type %d in cpp_macro_definition", node->type);
1901 /* Calculate length. */
1902 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
1903 if (macro->fun_like)
1905 len += 4; /* "()" plus possible final ".." of named
1906 varargs (we have + 1 below). */
1907 for (i = 0; i < macro->paramc; i++)
1908 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1911 /* This should match below where we fill in the buffer. */
1912 if (CPP_OPTION (pfile, traditional))
1913 len += _cpp_replacement_text_len (macro);
1916 for (i = 0; i < macro->count; i++)
1918 cpp_token *token = ¯o->exp.tokens[i];
1920 if (token->type == CPP_MACRO_ARG)
1921 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1923 len += cpp_token_len (token);
1925 if (token->flags & STRINGIFY_ARG)
1927 if (token->flags & PASTE_LEFT)
1928 len += 3; /* " ##" */
1929 if (token->flags & PREV_WHITE)
1934 if (len > pfile->macro_buffer_len)
1936 pfile->macro_buffer = XRESIZEVEC (unsigned char,
1937 pfile->macro_buffer, len);
1938 pfile->macro_buffer_len = len;
1941 /* Fill in the buffer. Start with the macro name. */
1942 buffer = pfile->macro_buffer;
1943 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1944 buffer += NODE_LEN (node);
1946 /* Parameter names. */
1947 if (macro->fun_like)
1950 for (i = 0; i < macro->paramc; i++)
1952 cpp_hashnode *param = macro->params[i];
1954 if (param != pfile->spec_nodes.n__VA_ARGS__)
1956 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1957 buffer += NODE_LEN (param);
1960 if (i + 1 < macro->paramc)
1961 /* Don't emit a space after the comma here; we're trying
1962 to emit a Dwarf-friendly definition, and the Dwarf spec
1963 forbids spaces in the argument list. */
1965 else if (macro->variadic)
1966 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1971 /* The Dwarf spec requires a space after the macro name, even if the
1972 definition is the empty string. */
1975 if (CPP_OPTION (pfile, traditional))
1976 buffer = _cpp_copy_replacement_text (macro, buffer);
1977 else if (macro->count)
1978 /* Expansion tokens. */
1980 for (i = 0; i < macro->count; i++)
1982 cpp_token *token = ¯o->exp.tokens[i];
1984 if (token->flags & PREV_WHITE)
1986 if (token->flags & STRINGIFY_ARG)
1989 if (token->type == CPP_MACRO_ARG)
1992 NODE_NAME (macro->params[token->val.arg_no - 1]),
1993 NODE_LEN (macro->params[token->val.arg_no - 1]));
1994 buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1997 buffer = cpp_spell_token (pfile, token, buffer, false);
1999 if (token->flags & PASTE_LEFT)
2004 /* Next has PREV_WHITE; see _cpp_create_definition. */
2010 return pfile->macro_buffer;