1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 In other words, you are welcome to use, share and improve this program.
23 You are forbidden to forbid anyone else to use, share and improve
24 what you give them. Help stamp out software-hoarding! */
31 typedef struct macro_arg macro_arg;
34 const cpp_token **first; /* First token in unexpanded argument. */
35 const cpp_token **expanded; /* Macro-expanded argument. */
36 const cpp_token *stringified; /* Stringified argument. */
37 unsigned int count; /* # of tokens in argument. */
38 unsigned int expanded_count; /* # of tokens in expanded argument. */
41 /* Macro expansion. */
43 static int enter_macro_context PARAMS ((cpp_reader *, cpp_hashnode *));
44 static int builtin_macro PARAMS ((cpp_reader *, cpp_hashnode *));
45 static void push_token_context
46 PARAMS ((cpp_reader *, cpp_hashnode *, const cpp_token *, unsigned int));
47 static void push_ptoken_context
48 PARAMS ((cpp_reader *, cpp_hashnode *, _cpp_buff *,
49 const cpp_token **, unsigned int));
50 static _cpp_buff *collect_args PARAMS ((cpp_reader *, const cpp_hashnode *));
51 static cpp_context *next_context PARAMS ((cpp_reader *));
52 static const cpp_token *padding_token
53 PARAMS ((cpp_reader *, const cpp_token *));
54 static void expand_arg PARAMS ((cpp_reader *, macro_arg *));
55 static const cpp_token *new_string_token PARAMS ((cpp_reader *, uchar *,
57 static const cpp_token *new_number_token PARAMS ((cpp_reader *, unsigned int));
58 static const cpp_token *stringify_arg PARAMS ((cpp_reader *, macro_arg *));
59 static void paste_all_tokens PARAMS ((cpp_reader *, const cpp_token *));
60 static bool paste_tokens PARAMS ((cpp_reader *, const cpp_token **,
62 static void replace_args PARAMS ((cpp_reader *, cpp_hashnode *, cpp_macro *,
64 static _cpp_buff *funlike_invocation_p PARAMS ((cpp_reader *, cpp_hashnode *));
66 /* #define directive parsing and handling. */
68 static cpp_token *alloc_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
69 static cpp_token *lex_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
70 static int warn_of_redefinition PARAMS ((const cpp_hashnode *,
72 static int save_parameter PARAMS ((cpp_reader *, cpp_macro *, cpp_hashnode *));
73 static int parse_params PARAMS ((cpp_reader *, cpp_macro *));
74 static void check_trad_stringification PARAMS ((cpp_reader *,
78 /* Allocates and returns a CPP_STRING token, containing TEXT of length
79 LEN, after null-terminating it. TEXT must be in permanent storage. */
80 static const cpp_token *
81 new_string_token (pfile, text, len)
86 cpp_token *token = _cpp_temp_token (pfile);
89 token->type = CPP_STRING;
90 token->val.str.len = len;
91 token->val.str.text = text;
96 /* Allocates and returns a CPP_NUMBER token evaluating to NUMBER. */
97 static const cpp_token *
98 new_number_token (pfile, number)
102 cpp_token *token = _cpp_temp_token (pfile);
103 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
104 unsigned char *buf = _cpp_unaligned_alloc (pfile, 21);
106 sprintf ((char *) buf, "%u", number);
107 token->type = CPP_NUMBER;
108 token->val.str.text = buf;
109 token->val.str.len = ustrlen (buf);
114 static const char * const monthnames[] =
116 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
117 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
120 /* Handle builtin macros like __FILE__, and push the resulting token
121 on the context stack. Also handles _Pragma, for which no new token
122 is created. Returns 1 if it generates a new token context, 0 to
123 return the token to the caller. */
125 builtin_macro (pfile, node)
129 const cpp_token *result;
131 switch (node->value.builtin)
134 cpp_error (pfile, DL_ICE, "invalid built-in macro \"%s\"",
144 const struct line_map *map = pfile->map;
146 if (node->value.builtin == BT_BASE_FILE)
147 while (! MAIN_FILE_P (map))
148 map = INCLUDED_FROM (&pfile->line_maps, map);
152 buf = _cpp_unaligned_alloc (pfile, len * 4 + 1);
153 len = cpp_quote_string (buf, (const unsigned char *) name, len) - buf;
155 result = new_string_token (pfile, buf, len);
159 case BT_INCLUDE_LEVEL:
160 /* The line map depth counts the primary source as level 1, but
161 historically __INCLUDE_DEPTH__ has called the primary source
163 result = new_number_token (pfile, pfile->line_maps.depth - 1);
167 /* If __LINE__ is embedded in a macro, it must expand to the
168 line of the macro's invocation, not its definition.
169 Otherwise things like assert() will not work properly. */
170 result = new_number_token (pfile,
171 SOURCE_LINE (pfile->map,
172 pfile->cur_token[-1].line));
177 int stdc = (!CPP_IN_SYSTEM_HEADER (pfile)
178 || pfile->spec_nodes.n__STRICT_ANSI__->type != NT_VOID);
179 result = new_number_token (pfile, stdc);
185 if (pfile->date.type == CPP_EOF)
187 /* Allocate __DATE__ and __TIME__ strings from permanent
188 storage. We only do this once, and don't generate them
189 at init time, because time() and localtime() are very
190 slow on some systems. */
191 time_t tt = time (NULL);
192 struct tm *tb = localtime (&tt);
194 pfile->date.val.str.text =
195 _cpp_unaligned_alloc (pfile, sizeof ("Oct 11 1347"));
196 pfile->date.val.str.len = sizeof ("Oct 11 1347") - 1;
197 pfile->date.type = CPP_STRING;
198 pfile->date.flags = 0;
199 sprintf ((char *) pfile->date.val.str.text, "%s %2d %4d",
200 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
202 pfile->time.val.str.text =
203 _cpp_unaligned_alloc (pfile, sizeof ("12:34:56"));
204 pfile->time.val.str.len = sizeof ("12:34:56") - 1;
205 pfile->time.type = CPP_STRING;
206 pfile->time.flags = 0;
207 sprintf ((char *) pfile->time.val.str.text, "%02d:%02d:%02d",
208 tb->tm_hour, tb->tm_min, tb->tm_sec);
211 if (node->value.builtin == BT_DATE)
212 result = &pfile->date;
214 result = &pfile->time;
218 /* Don't interpret _Pragma within directives. The standard is
219 not clear on this, but to me this makes most sense. */
220 if (pfile->state.in_directive)
223 _cpp_do__Pragma (pfile);
227 push_token_context (pfile, NULL, result, 1);
231 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
232 backslashes and double quotes. Non-printable characters are
233 converted to octal. DEST must be of sufficient size. Returns
234 a pointer to the end of the string. */
236 cpp_quote_string (dest, src, len)
245 if (c == '\\' || c == '"')
256 sprintf ((char *) dest, "\\%03o", c);
265 /* Convert a token sequence ARG to a single string token according to
266 the rules of the ISO C #-operator. */
267 static const cpp_token *
268 stringify_arg (pfile, arg)
272 unsigned char *dest = BUFF_FRONT (pfile->u_buff);
273 unsigned int i, escape_it, backslash_count = 0;
274 const cpp_token *source = NULL;
277 /* Loop, reading in the argument's tokens. */
278 for (i = 0; i < arg->count; i++)
280 const cpp_token *token = arg->first[i];
282 if (token->type == CPP_PADDING)
285 source = token->val.source;
289 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
290 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
292 /* Room for each char being written in octal, initial space and
294 len = cpp_token_len (token);
299 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
301 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
302 _cpp_extend_buff (pfile, &pfile->u_buff, len);
303 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
306 /* Leading white space? */
307 if (dest != BUFF_FRONT (pfile->u_buff))
311 if (source->flags & PREV_WHITE)
318 _cpp_buff *buff = _cpp_get_buff (pfile, len);
319 unsigned char *buf = BUFF_FRONT (buff);
320 len = cpp_spell_token (pfile, token, buf) - buf;
321 dest = cpp_quote_string (dest, buf, len);
322 _cpp_release_buff (pfile, buff);
325 dest = cpp_spell_token (pfile, token, dest);
327 if (token->type == CPP_OTHER && token->val.c == '\\')
333 /* Ignore the final \ of invalid string literals. */
334 if (backslash_count & 1)
336 cpp_error (pfile, DL_WARNING,
337 "invalid string literal, ignoring final '\\'");
341 /* Commit the memory, including NUL, and return the token. */
342 len = dest - BUFF_FRONT (pfile->u_buff);
343 BUFF_FRONT (pfile->u_buff) = dest + 1;
344 return new_string_token (pfile, dest - len, len);
347 /* Try to paste two tokens. On success, return non-zero. In any
348 case, PLHS is updated to point to the pasted token, which is
349 guaranteed to not have the PASTE_LEFT flag set. */
351 paste_tokens (pfile, plhs, rhs)
353 const cpp_token **plhs, *rhs;
355 unsigned char *buf, *end;
356 const cpp_token *lhs;
361 len = cpp_token_len (lhs) + cpp_token_len (rhs) + 1;
362 buf = (unsigned char *) alloca (len);
363 end = cpp_spell_token (pfile, lhs, buf);
365 /* Avoid comment headers, since they are still processed in stage 3.
366 It is simpler to insert a space here, rather than modifying the
367 lexer to ignore comments in some circumstances. Simply returning
368 false doesn't work, since we want to clear the PASTE_LEFT flag. */
369 if (lhs->type == CPP_DIV
370 && (rhs->type == CPP_MULT || rhs->type == CPP_DIV))
372 end = cpp_spell_token (pfile, rhs, end);
375 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true, 1);
377 /* Tweak the column number the lexer will report. */
378 pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
380 /* We don't want a leading # to be interpreted as a directive. */
381 pfile->buffer->saved_flags = 0;
383 /* Set pfile->cur_token as required by _cpp_lex_direct. */
384 pfile->cur_token = _cpp_temp_token (pfile);
385 *plhs = _cpp_lex_direct (pfile);
386 valid = pfile->buffer->cur == pfile->buffer->rlimit;
387 _cpp_pop_buffer (pfile);
392 /* Handles an arbitrarily long sequence of ## operators, with initial
393 operand LHS. This implementation is left-associative,
394 non-recursive, and finishes a paste before handling succeeding
395 ones. If a paste fails, we back up to the RHS of the failing ##
396 operator before pushing the context containing the result of prior
397 successful pastes, with the effect that the RHS appears in the
398 output stream after the pasted LHS normally. */
400 paste_all_tokens (pfile, lhs)
402 const cpp_token *lhs;
404 const cpp_token *rhs;
405 cpp_context *context = pfile->context;
409 /* Take the token directly from the current context. We can do
410 this, because we are in the replacement list of either an
411 object-like macro, or a function-like macro with arguments
412 inserted. In either case, the constraints to #define
413 guarantee we have at least one more token. */
414 if (context->direct_p)
415 rhs = context->first.token++;
417 rhs = *context->first.ptoken++;
419 if (rhs->type == CPP_PADDING)
422 if (!paste_tokens (pfile, &lhs, rhs))
424 _cpp_backup_tokens (pfile, 1);
426 /* Mandatory error for all apart from assembler. */
427 if (CPP_OPTION (pfile, lang) != CLK_ASM)
428 cpp_error (pfile, DL_ERROR,
429 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
430 cpp_token_as_text (pfile, lhs),
431 cpp_token_as_text (pfile, rhs));
435 while (rhs->flags & PASTE_LEFT);
437 /* Put the resulting token in its own context. */
438 push_token_context (pfile, NULL, lhs, 1);
441 /* Reads and returns the arguments to a function-like macro
442 invocation. Assumes the opening parenthesis has been processed.
443 If there is an error, emits an appropriate diagnostic and returns
444 NULL. Each argument is terminated by a CPP_EOF token, for the
445 future benefit of expand_arg(). */
447 collect_args (pfile, node)
449 const cpp_hashnode *node;
451 _cpp_buff *buff, *base_buff;
453 macro_arg *args, *arg;
454 const cpp_token *token;
458 macro = node->value.macro;
460 argc = macro->paramc;
463 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
464 + sizeof (macro_arg)));
466 args = (macro_arg *) buff->base;
467 memset (args, 0, argc * sizeof (macro_arg));
468 buff->cur = (unsigned char *) &args[argc];
469 arg = args, argc = 0;
471 /* Collect the tokens making up each argument. We don't yet know
472 how many arguments have been supplied, whether too many or too
473 few. Hence the slightly bizarre usage of "argc" and "arg". */
476 unsigned int paren_depth = 0;
477 unsigned int ntokens = 0;
480 arg->first = (const cpp_token **) buff->cur;
484 /* Require space for 2 new tokens (including a CPP_EOF). */
485 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
487 buff = _cpp_append_extend_buff (pfile, buff,
488 1000 * sizeof (cpp_token *));
489 arg->first = (const cpp_token **) buff->cur;
492 token = cpp_get_token (pfile);
494 if (token->type == CPP_PADDING)
496 /* Drop leading padding. */
500 else if (token->type == CPP_OPEN_PAREN)
502 else if (token->type == CPP_CLOSE_PAREN)
504 if (paren_depth-- == 0)
507 else if (token->type == CPP_COMMA)
509 /* A comma does not terminate an argument within
510 parentheses or as part of a variable argument. */
512 && ! (macro->variadic && argc == macro->paramc))
515 else if (token->type == CPP_EOF
516 || (token->type == CPP_HASH && token->flags & BOL))
519 arg->first[ntokens++] = token;
522 /* Drop trailing padding. */
523 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
526 arg->count = ntokens;
527 arg->first[ntokens] = &pfile->eof;
529 /* Terminate the argument. Excess arguments loop back and
530 overwrite the final legitimate argument, before failing. */
531 if (argc <= macro->paramc)
533 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
534 if (argc != macro->paramc)
538 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
540 if (token->type == CPP_EOF)
542 /* We still need the CPP_EOF to end directives, and to end
543 pre-expansion of a macro argument. Step back is not
544 unconditional, since we don't want to return a CPP_EOF to our
545 callers at the end of an -include-d file. */
546 if (pfile->context->prev || pfile->state.in_directive)
547 _cpp_backup_tokens (pfile, 1);
548 cpp_error (pfile, DL_ERROR,
549 "unterminated argument list invoking macro \"%s\"",
553 else if (argc < macro->paramc)
555 /* As an extension, a rest argument is allowed to not appear in
556 the invocation at all.
557 e.g. #define debug(format, args...) something
560 This is exactly the same as if there had been an empty rest
561 argument - debug("string", ). */
563 if (argc + 1 == macro->paramc && macro->variadic)
565 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
566 cpp_error (pfile, DL_PEDWARN,
567 "ISO C99 requires rest arguments to be used");
571 cpp_error (pfile, DL_ERROR,
572 "macro \"%s\" requires %u arguments, but only %u given",
573 NODE_NAME (node), macro->paramc, argc);
577 else if (argc > macro->paramc)
579 /* Empty argument to a macro taking no arguments is OK. */
580 if (argc != 1 || arg->count)
582 cpp_error (pfile, DL_ERROR,
583 "macro \"%s\" passed %u arguments, but takes just %u",
584 NODE_NAME (node), argc, macro->paramc);
592 _cpp_release_buff (pfile, base_buff);
596 /* Search for an opening parenthesis to the macro of NODE, in such a
597 way that, if none is found, we don't lose the information in any
598 intervening padding tokens. If we find the parenthesis, collect
599 the arguments and return the buffer containing them. */
601 funlike_invocation_p (pfile, node)
605 const cpp_token *token, *padding = NULL;
609 token = cpp_get_token (pfile);
610 if (token->type != CPP_PADDING)
613 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
617 if (token->type == CPP_OPEN_PAREN)
619 pfile->state.parsing_args = 2;
620 return collect_args (pfile, node);
623 /* CPP_EOF can be the end of macro arguments, or the end of the
624 file. We mustn't back up over the latter. Ugh. */
625 if (token->type != CPP_EOF || token == &pfile->eof)
627 /* Back up. We may have skipped padding, in which case backing
628 up more than one token when expanding macros is in general
629 too difficult. We re-insert it in its own context. */
630 _cpp_backup_tokens (pfile, 1);
632 push_token_context (pfile, NULL, padding, 1);
638 /* Push the context of a macro with hash entry NODE onto the context
639 stack. If we can successfully expand the macro, we push a context
640 containing its yet-to-be-rescanned replacement list and return one.
641 Otherwise, we don't push a context and return zero. */
643 enter_macro_context (pfile, node)
647 /* The presence of a macro invalidates a file's controlling macro. */
648 pfile->mi_valid = false;
650 /* Handle standard macros. */
651 if (! (node->flags & NODE_BUILTIN))
653 cpp_macro *macro = node->value.macro;
659 pfile->state.prevent_expansion++;
660 pfile->keep_tokens++;
661 pfile->state.parsing_args = 1;
662 buff = funlike_invocation_p (pfile, node);
663 pfile->state.parsing_args = 0;
664 pfile->keep_tokens--;
665 pfile->state.prevent_expansion--;
669 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
670 cpp_error (pfile, DL_WARNING,
671 "function-like macro \"%s\" must be used with arguments in traditional C",
677 if (macro->paramc > 0)
678 replace_args (pfile, node, macro, (macro_arg *) buff->base);
679 _cpp_release_buff (pfile, buff);
682 /* Disable the macro within its expansion. */
683 node->flags |= NODE_DISABLED;
685 if (macro->paramc == 0)
686 push_token_context (pfile, node, macro->exp.tokens, macro->count);
691 /* Handle built-in macros and the _Pragma operator. */
692 return builtin_macro (pfile, node);
695 /* Replace the parameters in a function-like macro of NODE with the
696 actual ARGS, and place the result in a newly pushed token context.
697 Expand each argument before replacing, unless it is operated upon
698 by the # or ## operators. */
700 replace_args (pfile, node, macro, args)
706 unsigned int i, total;
707 const cpp_token *src, *limit;
708 const cpp_token **dest, **first;
712 /* First, fully macro-expand arguments, calculating the number of
713 tokens in the final expansion as we go. The ordering of the if
714 statements below is subtle; we must handle stringification before
716 total = macro->count;
717 limit = macro->exp.tokens + macro->count;
719 for (src = macro->exp.tokens; src < limit; src++)
720 if (src->type == CPP_MACRO_ARG)
722 /* Leading and trailing padding tokens. */
725 /* We have an argument. If it is not being stringified or
726 pasted it is macro-replaced before insertion. */
727 arg = &args[src->val.arg_no - 1];
729 if (src->flags & STRINGIFY_ARG)
731 if (!arg->stringified)
732 arg->stringified = stringify_arg (pfile, arg);
734 else if ((src->flags & PASTE_LEFT)
735 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
736 total += arg->count - 1;
740 expand_arg (pfile, arg);
741 total += arg->expanded_count - 1;
745 /* Now allocate space for the expansion, copy the tokens and replace
747 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
748 first = (const cpp_token **) buff->base;
751 for (src = macro->exp.tokens; src < limit; src++)
754 const cpp_token **from, **paste_flag;
756 if (src->type != CPP_MACRO_ARG)
763 arg = &args[src->val.arg_no - 1];
764 if (src->flags & STRINGIFY_ARG)
765 count = 1, from = &arg->stringified;
766 else if (src->flags & PASTE_LEFT)
767 count = arg->count, from = arg->first;
768 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
770 count = arg->count, from = arg->first;
773 /* GCC has special semantics for , ## b where b is a
774 varargs parameter: the comma disappears if b was
775 given no actual arguments (not merely if b is an
776 empty argument); otherwise the paste flag is removed. */
777 if (dest[-1]->type == CPP_COMMA
779 && src->val.arg_no == macro->paramc)
784 paste_flag = dest - 1;
786 /* Remove the paste flag if the RHS is a placemarker. */
788 paste_flag = dest - 1;
792 count = arg->expanded_count, from = arg->expanded;
794 /* Padding on the left of an argument (unless RHS of ##). */
795 if (!pfile->state.in_directive
796 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
797 *dest++ = padding_token (pfile, src);
801 memcpy (dest, from, count * sizeof (cpp_token *));
804 /* With a non-empty argument on the LHS of ##, the last
805 token should be flagged PASTE_LEFT. */
806 if (src->flags & PASTE_LEFT)
807 paste_flag = dest - 1;
810 /* Avoid paste on RHS (even case count == 0). */
811 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
812 *dest++ = &pfile->avoid_paste;
814 /* Add a new paste flag, or remove an unwanted one. */
817 cpp_token *token = _cpp_temp_token (pfile);
818 token->type = (*paste_flag)->type;
819 token->val.str = (*paste_flag)->val.str;
820 if (src->flags & PASTE_LEFT)
821 token->flags = (*paste_flag)->flags | PASTE_LEFT;
823 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
828 /* Free the expanded arguments. */
829 for (i = 0; i < macro->paramc; i++)
830 if (args[i].expanded)
831 free (args[i].expanded);
833 push_ptoken_context (pfile, node, buff, first, dest - first);
836 /* Return a special padding token, with padding inherited from SOURCE. */
837 static const cpp_token *
838 padding_token (pfile, source)
840 const cpp_token *source;
842 cpp_token *result = _cpp_temp_token (pfile);
844 result->type = CPP_PADDING;
845 result->val.source = source;
850 /* Get a new uninitialized context. Create a new one if we cannot
851 re-use an old one. */
856 cpp_context *result = pfile->context->next;
860 result = xnew (cpp_context);
861 result->prev = pfile->context;
863 pfile->context->next = result;
866 pfile->context = result;
870 /* Push a list of pointers to tokens. */
872 push_ptoken_context (pfile, macro, buff, first, count)
876 const cpp_token **first;
879 cpp_context *context = next_context (pfile);
881 context->direct_p = false;
882 context->macro = macro;
883 context->buff = buff;
884 context->first.ptoken = first;
885 context->last.ptoken = first + count;
888 /* Push a list of tokens. */
890 push_token_context (pfile, macro, first, count)
893 const cpp_token *first;
896 cpp_context *context = next_context (pfile);
898 context->direct_p = true;
899 context->macro = macro;
900 context->buff = NULL;
901 context->first.token = first;
902 context->last.token = first + count;
905 /* Expand an argument ARG before replacing parameters in a
906 function-like macro. This works by pushing a context with the
907 argument's tokens, and then expanding that into a temporary buffer
908 as if it were a normal part of the token stream. collect_args()
909 has terminated the argument's tokens with a CPP_EOF so that we know
910 when we have fully expanded the argument. */
912 expand_arg (pfile, arg)
916 unsigned int capacity;
921 /* Loop, reading in the arguments. */
923 arg->expanded = (const cpp_token **)
924 xmalloc (capacity * sizeof (cpp_token *));
926 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
929 const cpp_token *token;
931 if (arg->expanded_count + 1 >= capacity)
934 arg->expanded = (const cpp_token **)
935 xrealloc (arg->expanded, capacity * sizeof (cpp_token *));
938 token = cpp_get_token (pfile);
940 if (token->type == CPP_EOF)
943 arg->expanded[arg->expanded_count++] = token;
946 _cpp_pop_context (pfile);
949 /* Pop the current context off the stack, re-enabling the macro if the
950 context represented a macro's replacement list. The context
951 structure is not freed so that we can re-use it later. */
953 _cpp_pop_context (pfile)
956 cpp_context *context = pfile->context;
959 context->macro->flags &= ~NODE_DISABLED;
962 _cpp_release_buff (pfile, context->buff);
964 pfile->context = context->prev;
967 /* Eternal routine to get a token. Also used nearly everywhere
968 internally, except for places where we know we can safely call
969 the lexer directly, such as lexing a directive name.
971 Macro expansions and directives are transparently handled,
972 including entering included files. Thus tokens are post-macro
973 expansion, and after any intervening directives. External callers
974 see CPP_EOF only at EOF. Internal callers also see it when meeting
975 a directive inside a macro call, when at the end of a directive and
976 state.in_directive is still 1, and at the end of argument
979 cpp_get_token (pfile)
982 const cpp_token *result;
987 cpp_context *context = pfile->context;
989 /* Context->prev == 0 <=> base context. */
991 result = _cpp_lex_token (pfile);
992 else if (context->first.token != context->last.token)
994 if (context->direct_p)
995 result = context->first.token++;
997 result = *context->first.ptoken++;
999 if (result->flags & PASTE_LEFT)
1001 paste_all_tokens (pfile, result);
1002 if (pfile->state.in_directive)
1004 return padding_token (pfile, result);
1009 _cpp_pop_context (pfile);
1010 if (pfile->state.in_directive)
1012 return &pfile->avoid_paste;
1015 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1018 if (result->type != CPP_NAME)
1021 node = result->val.node;
1023 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1026 if (!(node->flags & NODE_DISABLED))
1028 if (!pfile->state.prevent_expansion
1029 && enter_macro_context (pfile, node))
1031 if (pfile->state.in_directive)
1033 return padding_token (pfile, result);
1038 /* Flag this token as always unexpandable. FIXME: move this
1039 to collect_args()?. */
1040 cpp_token *t = _cpp_temp_token (pfile);
1041 t->type = result->type;
1042 t->flags = result->flags | NO_EXPAND;
1043 t->val.str = result->val.str;
1053 /* Returns true if we're expanding an object-like macro that was
1054 defined in a system header. Just checks the macro at the top of
1055 the stack. Used for diagnostic suppression. */
1057 cpp_sys_macro_p (pfile)
1060 cpp_hashnode *node = pfile->context->macro;
1062 return node && node->value.macro && node->value.macro->syshdr;
1065 /* Read each token in, until end of the current file. Directives are
1066 transparently processed. */
1068 cpp_scan_nooutput (pfile)
1071 /* Request a CPP_EOF token at the end of this file, rather than
1072 transparently continuing with the including file. */
1073 pfile->buffer->return_at_eof = true;
1075 while (cpp_get_token (pfile)->type != CPP_EOF)
1079 /* Step back one (or more) tokens. Can only step mack more than 1 if
1080 they are from the lexer, and not from macro expansion. */
1082 _cpp_backup_tokens (pfile, count)
1086 if (pfile->context->prev == NULL)
1088 pfile->lookaheads += count;
1092 if (pfile->cur_token == pfile->cur_run->base
1093 /* Possible with -fpreprocessed and no leading #line. */
1094 && pfile->cur_run->prev != NULL)
1096 pfile->cur_run = pfile->cur_run->prev;
1097 pfile->cur_token = pfile->cur_run->limit;
1105 if (pfile->context->direct_p)
1106 pfile->context->first.token--;
1108 pfile->context->first.ptoken--;
1112 /* #define directive parsing and handling. */
1114 /* Returns non-zero if a macro redefinition warning is required. */
1116 warn_of_redefinition (node, macro2)
1117 const cpp_hashnode *node;
1118 const cpp_macro *macro2;
1120 const cpp_macro *macro1;
1123 /* Some redefinitions need to be warned about regardless. */
1124 if (node->flags & NODE_WARN)
1127 /* Redefinition of a macro is allowed if and only if the old and new
1128 definitions are the same. (6.10.3 paragraph 2). */
1129 macro1 = node->value.macro;
1131 /* The quick failures. */
1132 if (macro1->count != macro2->count
1133 || macro1->paramc != macro2->paramc
1134 || macro1->fun_like != macro2->fun_like
1135 || macro1->variadic != macro2->variadic)
1138 /* Check each token. */
1139 for (i = 0; i < macro1->count; i++)
1140 if (! _cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
1143 /* Check parameter spellings. */
1144 for (i = 0; i < macro1->paramc; i++)
1145 if (macro1->params[i] != macro2->params[i])
1151 /* Free the definition of hashnode H. */
1153 _cpp_free_definition (h)
1156 /* Macros and assertions no longer have anything to free. */
1158 /* Clear builtin flag in case of redefinition. */
1159 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1162 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1163 zero on success, non-zero if the parameter is a duplicate. */
1165 save_parameter (pfile, macro, node)
1170 /* Constraint 6.10.3.6 - duplicate parameter names. */
1171 if (node->arg_index)
1173 cpp_error (pfile, DL_ERROR, "duplicate macro parameter \"%s\"",
1178 if (BUFF_ROOM (pfile->a_buff)
1179 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1180 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1182 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1183 node->arg_index = macro->paramc;
1187 /* Check the syntax of the parameters in a MACRO definition. */
1189 parse_params (pfile, macro)
1193 unsigned int prev_ident = 0;
1197 const cpp_token *token = _cpp_lex_token (pfile);
1199 switch (token->type)
1202 /* Allow/ignore comments in parameter lists if we are
1203 preserving comments in macro expansions. */
1204 if (token->type == CPP_COMMENT
1205 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1208 cpp_error (pfile, DL_ERROR,
1209 "\"%s\" may not appear in macro parameter list",
1210 cpp_token_as_text (pfile, token));
1216 cpp_error (pfile, DL_ERROR,
1217 "macro parameters must be comma-separated");
1222 if (save_parameter (pfile, macro, token->val.node))
1226 case CPP_CLOSE_PAREN:
1227 if (prev_ident || macro->paramc == 0)
1230 /* Fall through to pick up the error. */
1234 cpp_error (pfile, DL_ERROR, "parameter name missing");
1241 macro->variadic = 1;
1244 save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1245 pfile->state.va_args_ok = 1;
1246 if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1247 cpp_error (pfile, DL_PEDWARN,
1248 "anonymous variadic macros were introduced in C99");
1250 else if (CPP_OPTION (pfile, pedantic))
1251 cpp_error (pfile, DL_PEDWARN,
1252 "ISO C does not permit named variadic macros");
1254 /* We're at the end, and just expect a closing parenthesis. */
1255 token = _cpp_lex_token (pfile);
1256 if (token->type == CPP_CLOSE_PAREN)
1261 cpp_error (pfile, DL_ERROR, "missing ')' in macro parameter list");
1267 /* Allocate room for a token from a macro's replacement list. */
1269 alloc_expansion_token (pfile, macro)
1273 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1274 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1276 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1279 /* Lex a token from the expansion of MACRO, but mark parameters as we
1280 find them and warn of traditional stringification. */
1282 lex_expansion_token (pfile, macro)
1288 pfile->cur_token = alloc_expansion_token (pfile, macro);
1289 token = _cpp_lex_direct (pfile);
1291 /* Is this a parameter? */
1292 if (token->type == CPP_NAME && token->val.node->arg_index)
1294 token->type = CPP_MACRO_ARG;
1295 token->val.arg_no = token->val.node->arg_index;
1297 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1298 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1299 check_trad_stringification (pfile, macro, &token->val.str);
1304 /* Parse a macro and save its expansion. Returns non-zero on success. */
1306 _cpp_create_definition (pfile, node)
1311 cpp_token *token, *saved_cur_token;
1312 const cpp_token *ctoken;
1313 unsigned int i, ok = 1;
1315 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1316 macro->line = pfile->directive_line;
1319 macro->variadic = 0;
1321 macro->fun_like = 0;
1323 /* Get the first token of the expansion (or the '(' of a
1324 function-like macro). */
1325 ctoken = _cpp_lex_token (pfile);
1327 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1329 ok = parse_params (pfile, macro);
1330 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1334 /* Success. Commit the parameter array. */
1335 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
1336 macro->fun_like = 1;
1338 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1339 cpp_error (pfile, DL_PEDWARN,
1340 "ISO C requires whitespace after the macro name");
1342 saved_cur_token = pfile->cur_token;
1344 if (macro->fun_like)
1345 token = lex_expansion_token (pfile, macro);
1348 token = alloc_expansion_token (pfile, macro);
1354 /* Check the stringifying # constraint 6.10.3.2.1 of
1355 function-like macros when lexing the subsequent token. */
1356 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1358 if (token->type == CPP_MACRO_ARG)
1360 token->flags &= ~PREV_WHITE;
1361 token->flags |= STRINGIFY_ARG;
1362 token->flags |= token[-1].flags & PREV_WHITE;
1363 token[-1] = token[0];
1366 /* Let assembler get away with murder. */
1367 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1370 cpp_error (pfile, DL_ERROR,
1371 "'#' is not followed by a macro parameter");
1376 if (token->type == CPP_EOF)
1379 /* Paste operator constraint 6.10.3.3.1. */
1380 if (token->type == CPP_PASTE)
1382 /* Token-paste ##, can appear in both object-like and
1383 function-like macros, but not at the ends. */
1384 if (--macro->count > 0)
1385 token = lex_expansion_token (pfile, macro);
1387 if (macro->count == 0 || token->type == CPP_EOF)
1390 cpp_error (pfile, DL_ERROR,
1391 "'##' cannot appear at either end of a macro expansion");
1395 token[-1].flags |= PASTE_LEFT;
1398 token = lex_expansion_token (pfile, macro);
1401 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1403 /* Don't count the CPP_EOF. */
1406 /* Clear whitespace on first token for warn_of_redefinition(). */
1408 macro->exp.tokens[0].flags &= ~PREV_WHITE;
1410 /* Commit the memory. */
1411 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
1413 /* Implement the macro-defined-to-itself optimisation. */
1414 if (macro->count == 1 && !macro->fun_like
1415 && macro->exp.tokens[0].type == CPP_NAME
1416 && macro->exp.tokens[0].val.node == node)
1417 node->flags |= NODE_DISABLED;
1419 /* To suppress some diagnostics. */
1420 macro->syshdr = pfile->map->sysp != 0;
1422 if (node->type != NT_VOID)
1424 if (warn_of_redefinition (node, macro))
1426 cpp_error_with_line (pfile, DL_PEDWARN, pfile->directive_line, 0,
1427 "\"%s\" redefined", NODE_NAME (node));
1429 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1430 cpp_error_with_line (pfile, DL_PEDWARN, node->value.macro->line, 0,
1431 "this is the location of the previous definition");
1433 _cpp_free_definition (node);
1436 /* Enter definition in hash table. */
1437 node->type = NT_MACRO;
1438 node->value.macro = macro;
1439 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1440 node->flags |= NODE_WARN;
1444 /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position. */
1445 saved_cur_token[-1].type = pfile->cur_token[-1].type;
1446 pfile->cur_token = saved_cur_token;
1450 /* Stop the lexer accepting __VA_ARGS__. */
1451 pfile->state.va_args_ok = 0;
1453 /* Clear the fast argument lookup indices. */
1454 for (i = macro->paramc; i-- > 0; )
1455 macro->params[i]->arg_index = 0;
1460 /* Warn if a token in STRING matches one of a function-like MACRO's
1463 check_trad_stringification (pfile, macro, string)
1465 const cpp_macro *macro;
1466 const cpp_string *string;
1468 unsigned int i, len;
1469 const uchar *p, *q, *limit = string->text + string->len;
1471 /* Loop over the string. */
1472 for (p = string->text; p < limit; p = q)
1474 /* Find the start of an identifier. */
1475 while (p < limit && !is_idstart (*p))
1478 /* Find the end of the identifier. */
1480 while (q < limit && is_idchar (*q))
1485 /* Loop over the function macro arguments to see if the
1486 identifier inside the string matches one of them. */
1487 for (i = 0; i < macro->paramc; i++)
1489 const cpp_hashnode *node = macro->params[i];
1491 if (NODE_LEN (node) == len
1492 && !memcmp (p, NODE_NAME (node), len))
1494 cpp_error (pfile, DL_WARNING,
1495 "macro argument \"%s\" would be stringified in traditional C",
1503 /* Returns the name, arguments and expansion of a macro, in a format
1504 suitable to be read back in again, and therefore also for DWARF 2
1505 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1506 Caller is expected to generate the "#define" bit if needed. The
1507 returned text is temporary, and automatically freed later. */
1508 const unsigned char *
1509 cpp_macro_definition (pfile, node)
1511 const cpp_hashnode *node;
1513 unsigned int i, len;
1514 const cpp_macro *macro = node->value.macro;
1515 unsigned char *buffer;
1517 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1519 cpp_error (pfile, DL_ICE,
1520 "invalid hash type %d in cpp_macro_definition", node->type);
1524 /* Calculate length. */
1525 len = NODE_LEN (node) + 1; /* ' ' */
1526 if (macro->fun_like)
1528 len += 4; /* "()" plus possible final ".." of named
1529 varargs (we have + 1 below). */
1530 for (i = 0; i < macro->paramc; i++)
1531 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1534 for (i = 0; i < macro->count; i++)
1536 cpp_token *token = ¯o->exp.tokens[i];
1538 if (token->type == CPP_MACRO_ARG)
1539 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1541 len += cpp_token_len (token); /* Includes room for ' '. */
1542 if (token->flags & STRINGIFY_ARG)
1544 if (token->flags & PASTE_LEFT)
1545 len += 3; /* " ##" */
1548 if (len > pfile->macro_buffer_len)
1550 pfile->macro_buffer = (uchar *) xrealloc (pfile->macro_buffer, len);
1551 pfile->macro_buffer_len = len;
1554 /* Fill in the buffer. Start with the macro name. */
1555 buffer = pfile->macro_buffer;
1556 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1557 buffer += NODE_LEN (node);
1559 /* Parameter names. */
1560 if (macro->fun_like)
1563 for (i = 0; i < macro->paramc; i++)
1565 cpp_hashnode *param = macro->params[i];
1567 if (param != pfile->spec_nodes.n__VA_ARGS__)
1569 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1570 buffer += NODE_LEN (param);
1573 if (i + 1 < macro->paramc)
1574 /* Don't emit a space after the comma here; we're trying
1575 to emit a Dwarf-friendly definition, and the Dwarf spec
1576 forbids spaces in the argument list. */
1578 else if (macro->variadic)
1579 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1584 /* The Dwarf spec requires a space after the macro name, even if the
1585 definition is the empty string. */
1588 /* Expansion tokens. */
1591 for (i = 0; i < macro->count; i++)
1593 cpp_token *token = ¯o->exp.tokens[i];
1595 if (token->flags & PREV_WHITE)
1597 if (token->flags & STRINGIFY_ARG)
1600 if (token->type == CPP_MACRO_ARG)
1602 len = NODE_LEN (macro->params[token->val.arg_no - 1]);
1604 NODE_NAME (macro->params[token->val.arg_no - 1]), len);
1608 buffer = cpp_spell_token (pfile, token, buffer);
1610 if (token->flags & PASTE_LEFT)
1615 /* Next has PREV_WHITE; see _cpp_create_definition. */
1621 return pfile->macro_buffer;