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! */
33 cpp_hashnode **params; /* Parameters, if any. */
34 cpp_token *expansion; /* First token of replacement list. */
35 unsigned int line; /* Starting line number. */
36 unsigned int count; /* Number of tokens in expansion. */
37 unsigned short paramc; /* Number of parameters. */
38 unsigned int fun_like : 1; /* If a function-like macro. */
39 unsigned int variadic : 1; /* If a variadic macro. */
40 unsigned int syshdr : 1; /* If macro defined in system header. */
43 typedef struct macro_arg macro_arg;
46 const cpp_token **first; /* First token in unexpanded argument. */
47 const cpp_token **expanded; /* Macro-expanded argument. */
48 const cpp_token *stringified; /* Stringified argument. */
49 unsigned int count; /* # of tokens in argument. */
50 unsigned int expanded_count; /* # of tokens in expanded argument. */
53 /* Macro expansion. */
55 static int enter_macro_context PARAMS ((cpp_reader *, cpp_hashnode *));
56 static int builtin_macro PARAMS ((cpp_reader *, cpp_hashnode *));
57 static void push_token_context
58 PARAMS ((cpp_reader *, cpp_hashnode *, const cpp_token *, unsigned int));
59 static void push_ptoken_context
60 PARAMS ((cpp_reader *, cpp_hashnode *, _cpp_buff *,
61 const cpp_token **, unsigned int));
62 static _cpp_buff *collect_args PARAMS ((cpp_reader *, const cpp_hashnode *));
63 static cpp_context *next_context PARAMS ((cpp_reader *));
64 static const cpp_token *padding_token
65 PARAMS ((cpp_reader *, const cpp_token *));
66 static void expand_arg PARAMS ((cpp_reader *, macro_arg *));
67 static unsigned char *quote_string PARAMS ((unsigned char *,
68 const unsigned char *,
70 static const cpp_token *new_string_token PARAMS ((cpp_reader *, U_CHAR *,
72 static const cpp_token *new_number_token PARAMS ((cpp_reader *, unsigned int));
73 static const cpp_token *stringify_arg PARAMS ((cpp_reader *, macro_arg *));
74 static void paste_all_tokens PARAMS ((cpp_reader *, const cpp_token *));
75 static bool paste_tokens PARAMS ((cpp_reader *, const cpp_token **,
77 static void replace_args PARAMS ((cpp_reader *, cpp_hashnode *, cpp_macro *,
79 static _cpp_buff *funlike_invocation_p PARAMS ((cpp_reader *, cpp_hashnode *));
81 /* #define directive parsing and handling. */
83 static cpp_token *alloc_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
84 static cpp_token *lex_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
85 static int warn_of_redefinition PARAMS ((const cpp_hashnode *,
87 static int save_parameter PARAMS ((cpp_reader *, cpp_macro *, cpp_hashnode *));
88 static int parse_params PARAMS ((cpp_reader *, cpp_macro *));
89 static void check_trad_stringification PARAMS ((cpp_reader *,
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 (pfile, text, len)
101 cpp_token *token = _cpp_temp_token (pfile);
104 token->type = CPP_STRING;
105 token->val.str.len = len;
106 token->val.str.text = text;
111 /* Allocates and returns a CPP_NUMBER token evaluating to NUMBER. */
112 static const cpp_token *
113 new_number_token (pfile, number)
117 cpp_token *token = _cpp_temp_token (pfile);
118 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
119 unsigned char *buf = _cpp_unaligned_alloc (pfile, 21);
121 sprintf ((char *) buf, "%u", number);
122 token->type = CPP_NUMBER;
123 token->val.str.text = buf;
124 token->val.str.len = ustrlen (buf);
129 static const char * const monthnames[] =
131 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
132 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
135 /* Handle builtin macros like __FILE__, and push the resulting token
136 on the context stack. Also handles _Pragma, for which no new token
137 is created. Returns 1 if it generates a new token context, 0 to
138 return the token to the caller. */
140 builtin_macro (pfile, node)
144 const cpp_token *result;
146 switch (node->value.builtin)
149 cpp_ice (pfile, "invalid built-in macro \"%s\"", NODE_NAME (node));
158 const struct line_map *map = pfile->map;
160 if (node->value.builtin == BT_BASE_FILE)
161 while (! MAIN_FILE_P (map))
162 map = INCLUDED_FROM (&pfile->line_maps, map);
166 buf = _cpp_unaligned_alloc (pfile, len * 4 + 1);
167 len = quote_string (buf, (const unsigned char *) name, len) - buf;
169 result = new_string_token (pfile, buf, len);
173 case BT_INCLUDE_LEVEL:
174 /* The line map depth counts the primary source as level 1, but
175 historically __INCLUDE_DEPTH__ has called the primary source
177 result = new_number_token (pfile, pfile->line_maps.depth - 1);
181 /* If __LINE__ is embedded in a macro, it must expand to the
182 line of the macro's invocation, not its definition.
183 Otherwise things like assert() will not work properly. */
184 result = new_number_token (pfile,
185 SOURCE_LINE (pfile->map,
186 pfile->cur_token[-1].line));
191 int stdc = (!CPP_IN_SYSTEM_HEADER (pfile)
192 || pfile->spec_nodes.n__STRICT_ANSI__->type != NT_VOID);
193 result = new_number_token (pfile, stdc);
199 if (pfile->date.type == CPP_EOF)
201 /* Allocate __DATE__ and __TIME__ strings from permanent
202 storage. We only do this once, and don't generate them
203 at init time, because time() and localtime() are very
204 slow on some systems. */
205 time_t tt = time (NULL);
206 struct tm *tb = localtime (&tt);
208 pfile->date.val.str.text =
209 _cpp_unaligned_alloc (pfile, sizeof ("Oct 11 1347"));
210 pfile->date.val.str.len = sizeof ("Oct 11 1347") - 1;
211 pfile->date.type = CPP_STRING;
212 pfile->date.flags = 0;
213 sprintf ((char *) pfile->date.val.str.text, "%s %2d %4d",
214 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
216 pfile->time.val.str.text =
217 _cpp_unaligned_alloc (pfile, sizeof ("12:34:56"));
218 pfile->time.val.str.len = sizeof ("12:34:56") - 1;
219 pfile->time.type = CPP_STRING;
220 pfile->time.flags = 0;
221 sprintf ((char *) pfile->time.val.str.text, "%02d:%02d:%02d",
222 tb->tm_hour, tb->tm_min, tb->tm_sec);
225 if (node->value.builtin == BT_DATE)
226 result = &pfile->date;
228 result = &pfile->time;
232 /* Don't interpret _Pragma within directives. The standard is
233 not clear on this, but to me this makes most sense. */
234 if (pfile->state.in_directive)
237 _cpp_do__Pragma (pfile);
241 push_token_context (pfile, NULL, result, 1);
245 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
246 backslashes and double quotes. Non-printable characters are
247 converted to octal. DEST must be of sufficient size. */
249 quote_string (dest, src, len)
258 if (c == '\\' || c == '"')
269 sprintf ((char *) dest, "\\%03o", c);
278 /* Convert a token sequence ARG to a single string token according to
279 the rules of the ISO C #-operator. */
280 static const cpp_token *
281 stringify_arg (pfile, arg)
285 unsigned char *dest = BUFF_FRONT (pfile->u_buff);
286 unsigned int i, escape_it, backslash_count = 0;
287 const cpp_token *source = NULL;
290 /* Loop, reading in the argument's tokens. */
291 for (i = 0; i < arg->count; i++)
293 const cpp_token *token = arg->first[i];
295 if (token->type == CPP_PADDING)
298 source = token->val.source;
302 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
303 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
305 /* Room for each char being written in octal, initial space and
307 len = cpp_token_len (token);
312 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
314 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
315 _cpp_extend_buff (pfile, &pfile->u_buff, len);
316 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
319 /* Leading white space? */
320 if (dest != BUFF_FRONT (pfile->u_buff))
324 if (source->flags & PREV_WHITE)
331 _cpp_buff *buff = _cpp_get_buff (pfile, len);
332 unsigned char *buf = BUFF_FRONT (buff);
333 len = cpp_spell_token (pfile, token, buf) - buf;
334 dest = quote_string (dest, buf, len);
335 _cpp_release_buff (pfile, buff);
338 dest = cpp_spell_token (pfile, token, dest);
340 if (token->type == CPP_OTHER && token->val.c == '\\')
346 /* Ignore the final \ of invalid string literals. */
347 if (backslash_count & 1)
349 cpp_warning (pfile, "invalid string literal, ignoring final '\\'");
353 /* Commit the memory, including NUL, and return the token. */
354 len = dest - BUFF_FRONT (pfile->u_buff);
355 BUFF_FRONT (pfile->u_buff) = dest + 1;
356 return new_string_token (pfile, dest - len, len);
359 /* Try to paste two tokens. On success, return non-zero. In any
360 case, PLHS is updated to point to the pasted token, which is
361 guaranteed to not have the PASTE_LEFT flag set. */
363 paste_tokens (pfile, plhs, rhs)
365 const cpp_token **plhs, *rhs;
367 unsigned char *buf, *end;
368 const cpp_token *lhs;
373 len = cpp_token_len (lhs) + cpp_token_len (rhs) + 1;
374 buf = (unsigned char *) alloca (len);
375 end = cpp_spell_token (pfile, lhs, buf);
377 /* Avoid comment headers, since they are still processed in stage 3.
378 It is simpler to insert a space here, rather than modifying the
379 lexer to ignore comments in some circumstances. Simply returning
380 false doesn't work, since we want to clear the PASTE_LEFT flag. */
381 if (lhs->type == CPP_DIV
382 && (rhs->type == CPP_MULT || rhs->type == CPP_DIV))
384 end = cpp_spell_token (pfile, rhs, end);
387 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true, 1);
389 /* Tweak the column number the lexer will report. */
390 pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
392 /* We don't want a leading # to be interpreted as a directive. */
393 pfile->buffer->saved_flags = 0;
395 /* Set pfile->cur_token as required by _cpp_lex_direct. */
396 pfile->cur_token = _cpp_temp_token (pfile);
397 *plhs = _cpp_lex_direct (pfile);
398 valid = pfile->buffer->cur == pfile->buffer->rlimit;
399 _cpp_pop_buffer (pfile);
404 /* Handles an arbitrarily long sequence of ## operators, with initial
405 operand LHS. This implementation is left-associative,
406 non-recursive, and finishes a paste before handling succeeding
407 ones. If a paste fails, we back up to the RHS of the failing ##
408 operator before pushing the context containing the result of prior
409 successful pastes, with the effect that the RHS appears in the
410 output stream after the pasted LHS normally. */
412 paste_all_tokens (pfile, lhs)
414 const cpp_token *lhs;
416 const cpp_token *rhs;
417 cpp_context *context = pfile->context;
421 /* Take the token directly from the current context. We can do
422 this, because we are in the replacement list of either an
423 object-like macro, or a function-like macro with arguments
424 inserted. In either case, the constraints to #define
425 guarantee we have at least one more token. */
426 if (context->direct_p)
427 rhs = context->first.token++;
429 rhs = *context->first.ptoken++;
431 if (rhs->type == CPP_PADDING)
434 if (!paste_tokens (pfile, &lhs, rhs))
436 _cpp_backup_tokens (pfile, 1);
438 /* Mandatory warning for all apart from assembler. */
439 if (CPP_OPTION (pfile, lang) != CLK_ASM)
441 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
442 cpp_token_as_text (pfile, lhs),
443 cpp_token_as_text (pfile, rhs));
447 while (rhs->flags & PASTE_LEFT);
449 /* Put the resulting token in its own context. */
450 push_token_context (pfile, NULL, lhs, 1);
453 /* Reads and returns the arguments to a function-like macro
454 invocation. Assumes the opening parenthesis has been processed.
455 If there is an error, emits an appropriate diagnostic and returns
456 NULL. Each argument is terminated by a CPP_EOF token, for the
457 future benefit of expand_arg(). */
459 collect_args (pfile, node)
461 const cpp_hashnode *node;
463 _cpp_buff *buff, *base_buff;
465 macro_arg *args, *arg;
466 const cpp_token *token;
470 macro = node->value.macro;
472 argc = macro->paramc;
475 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
476 + sizeof (macro_arg)));
478 args = (macro_arg *) buff->base;
479 memset (args, 0, argc * sizeof (macro_arg));
480 buff->cur = (unsigned char *) &args[argc];
481 arg = args, argc = 0;
483 /* Collect the tokens making up each argument. We don't yet know
484 how many arguments have been supplied, whether too many or too
485 few. Hence the slightly bizarre usage of "argc" and "arg". */
488 unsigned int paren_depth = 0;
489 unsigned int ntokens = 0;
492 arg->first = (const cpp_token **) buff->cur;
496 /* Require space for 2 new tokens (including a CPP_EOF). */
497 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
499 buff = _cpp_append_extend_buff (pfile, buff,
500 1000 * sizeof (cpp_token *));
501 arg->first = (const cpp_token **) buff->cur;
504 token = cpp_get_token (pfile);
506 if (token->type == CPP_PADDING)
508 /* Drop leading padding. */
512 else if (token->type == CPP_OPEN_PAREN)
514 else if (token->type == CPP_CLOSE_PAREN)
516 if (paren_depth-- == 0)
519 else if (token->type == CPP_COMMA)
521 /* A comma does not terminate an argument within
522 parentheses or as part of a variable argument. */
524 && ! (macro->variadic && argc == macro->paramc))
527 else if (token->type == CPP_EOF
528 || (token->type == CPP_HASH && token->flags & BOL))
531 arg->first[ntokens++] = token;
534 /* Drop trailing padding. */
535 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
538 arg->count = ntokens;
539 arg->first[ntokens] = &pfile->eof;
541 /* Terminate the argument. Excess arguments loop back and
542 overwrite the final legitimate argument, before failing. */
543 if (argc <= macro->paramc)
545 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
546 if (argc != macro->paramc)
550 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
552 if (token->type == CPP_EOF)
554 /* We still need the CPP_EOF to end directives, and to end
555 pre-expansion of a macro argument. Step back is not
556 unconditional, since we don't want to return a CPP_EOF to our
557 callers at the end of an -include-d file. */
558 if (pfile->context->prev || pfile->state.in_directive)
559 _cpp_backup_tokens (pfile, 1);
560 cpp_error (pfile, "unterminated argument list invoking macro \"%s\"",
564 else if (argc < macro->paramc)
566 /* As an extension, a rest argument is allowed to not appear in
567 the invocation at all.
568 e.g. #define debug(format, args...) something
571 This is exactly the same as if there had been an empty rest
572 argument - debug("string", ). */
574 if (argc + 1 == macro->paramc && macro->variadic)
576 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
577 cpp_pedwarn (pfile, "ISO C99 requires rest arguments to be used");
582 "macro \"%s\" requires %u arguments, but only %u given",
583 NODE_NAME (node), macro->paramc, argc);
587 else if (argc > macro->paramc)
589 /* Empty argument to a macro taking no arguments is OK. */
590 if (argc != 1 || arg->count)
593 "macro \"%s\" passed %u arguments, but takes just %u",
594 NODE_NAME (node), argc, macro->paramc);
602 _cpp_release_buff (pfile, base_buff);
606 /* Search for an opening parenthesis to the macro of NODE, in such a
607 way that, if none is found, we don't lose the information in any
608 intervening padding tokens. If we find the parenthesis, collect
609 the arguments and return the buffer containing them. */
611 funlike_invocation_p (pfile, node)
615 const cpp_token *token, *padding = NULL;
619 token = cpp_get_token (pfile);
620 if (token->type != CPP_PADDING)
623 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
627 if (token->type == CPP_OPEN_PAREN)
629 pfile->state.parsing_args = 2;
630 return collect_args (pfile, node);
633 /* Back up. We may have skipped padding, in which case backing up
634 more than one token when expanding macros is in general too
635 difficult. We re-insert it in its own context. */
636 _cpp_backup_tokens (pfile, 1);
638 push_token_context (pfile, NULL, padding, 1);
643 /* Push the context of a macro with hash entry NODE onto the context
644 stack. If we can successfully expand the macro, we push a context
645 containing its yet-to-be-rescanned replacement list and return one.
646 Otherwise, we don't push a context and return zero. */
648 enter_macro_context (pfile, node)
652 /* The presence of a macro invalidates a file's controlling macro. */
653 pfile->mi_valid = false;
655 /* Handle standard macros. */
656 if (! (node->flags & NODE_BUILTIN))
658 cpp_macro *macro = node->value.macro;
664 pfile->state.prevent_expansion++;
665 pfile->keep_tokens++;
666 pfile->state.parsing_args = 1;
667 buff = funlike_invocation_p (pfile, node);
668 pfile->state.parsing_args = 0;
669 pfile->keep_tokens--;
670 pfile->state.prevent_expansion--;
674 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
676 "function-like macro \"%s\" must be used with arguments in traditional C",
682 if (macro->paramc > 0)
683 replace_args (pfile, node, macro, (macro_arg *) buff->base);
684 _cpp_release_buff (pfile, buff);
687 /* Disable the macro within its expansion. */
688 node->flags |= NODE_DISABLED;
690 if (macro->paramc == 0)
691 push_token_context (pfile, node, macro->expansion, macro->count);
696 /* Handle built-in macros and the _Pragma operator. */
697 return builtin_macro (pfile, node);
700 /* Replace the parameters in a function-like macro of NODE with the
701 actual ARGS, and place the result in a newly pushed token context.
702 Expand each argument before replacing, unless it is operated upon
703 by the # or ## operators. */
705 replace_args (pfile, node, macro, args)
711 unsigned int i, total;
712 const cpp_token *src, *limit;
713 const cpp_token **dest, **first;
717 /* First, fully macro-expand arguments, calculating the number of
718 tokens in the final expansion as we go. The ordering of the if
719 statements below is subtle; we must handle stringification before
721 total = macro->count;
722 limit = macro->expansion + macro->count;
724 for (src = macro->expansion; src < limit; src++)
725 if (src->type == CPP_MACRO_ARG)
727 /* Leading and trailing padding tokens. */
730 /* We have an argument. If it is not being stringified or
731 pasted it is macro-replaced before insertion. */
732 arg = &args[src->val.arg_no - 1];
734 if (src->flags & STRINGIFY_ARG)
736 if (!arg->stringified)
737 arg->stringified = stringify_arg (pfile, arg);
739 else if ((src->flags & PASTE_LEFT)
740 || (src > macro->expansion && (src[-1].flags & PASTE_LEFT)))
741 total += arg->count - 1;
745 expand_arg (pfile, arg);
746 total += arg->expanded_count - 1;
750 /* Now allocate space for the expansion, copy the tokens and replace
752 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
753 first = (const cpp_token **) buff->base;
756 for (src = macro->expansion; src < limit; src++)
759 const cpp_token **from, **paste_flag;
761 if (src->type != CPP_MACRO_ARG)
768 arg = &args[src->val.arg_no - 1];
769 if (src->flags & STRINGIFY_ARG)
770 count = 1, from = &arg->stringified;
771 else if (src->flags & PASTE_LEFT)
772 count = arg->count, from = arg->first;
773 else if (src != macro->expansion && (src[-1].flags & PASTE_LEFT))
775 count = arg->count, from = arg->first;
778 /* GCC has special semantics for , ## b where b is a
779 varargs parameter: the comma disappears if b was
780 given no actual arguments (not merely if b is an
781 empty argument); otherwise the paste flag is removed. */
782 if (dest[-1]->type == CPP_COMMA
784 && src->val.arg_no == macro->paramc)
789 paste_flag = dest - 1;
791 /* Remove the paste flag if the RHS is a placemarker. */
793 paste_flag = dest - 1;
797 count = arg->expanded_count, from = arg->expanded;
799 /* Padding on the left of an argument (unless RHS of ##). */
800 if (!pfile->state.in_directive
801 && src != macro->expansion && !(src[-1].flags & PASTE_LEFT))
802 *dest++ = padding_token (pfile, src);
806 memcpy (dest, from, count * sizeof (cpp_token *));
809 /* With a non-empty argument on the LHS of ##, the last
810 token should be flagged PASTE_LEFT. */
811 if (src->flags & PASTE_LEFT)
812 paste_flag = dest - 1;
815 /* Avoid paste on RHS (even case count == 0). */
816 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
817 *dest++ = &pfile->avoid_paste;
819 /* Add a new paste flag, or remove an unwanted one. */
822 cpp_token *token = _cpp_temp_token (pfile);
823 token->type = (*paste_flag)->type;
824 token->val.str = (*paste_flag)->val.str;
825 if (src->flags & PASTE_LEFT)
826 token->flags = (*paste_flag)->flags | PASTE_LEFT;
828 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
833 /* Free the expanded arguments. */
834 for (i = 0; i < macro->paramc; i++)
835 if (args[i].expanded)
836 free (args[i].expanded);
838 push_ptoken_context (pfile, node, buff, first, dest - first);
841 /* Return a special padding token, with padding inherited from SOURCE. */
842 static const cpp_token *
843 padding_token (pfile, source)
845 const cpp_token *source;
847 cpp_token *result = _cpp_temp_token (pfile);
849 result->type = CPP_PADDING;
850 result->val.source = source;
855 /* Get a new uninitialized context. Create a new one if we cannot
856 re-use an old one. */
861 cpp_context *result = pfile->context->next;
865 result = xnew (cpp_context);
866 result->prev = pfile->context;
868 pfile->context->next = result;
871 pfile->context = result;
875 /* Push a list of pointers to tokens. */
877 push_ptoken_context (pfile, macro, buff, first, count)
881 const cpp_token **first;
884 cpp_context *context = next_context (pfile);
886 context->direct_p = false;
887 context->macro = macro;
888 context->buff = buff;
889 context->first.ptoken = first;
890 context->last.ptoken = first + count;
893 /* Push a list of tokens. */
895 push_token_context (pfile, macro, first, count)
898 const cpp_token *first;
901 cpp_context *context = next_context (pfile);
903 context->direct_p = true;
904 context->macro = macro;
905 context->buff = NULL;
906 context->first.token = first;
907 context->last.token = first + count;
910 /* Expand an argument ARG before replacing parameters in a
911 function-like macro. This works by pushing a context with the
912 argument's tokens, and then expanding that into a temporary buffer
913 as if it were a normal part of the token stream. collect_args()
914 has terminated the argument's tokens with a CPP_EOF so that we know
915 when we have fully expanded the argument. */
917 expand_arg (pfile, arg)
921 unsigned int capacity;
926 /* Loop, reading in the arguments. */
928 arg->expanded = (const cpp_token **)
929 xmalloc (capacity * sizeof (cpp_token *));
931 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
934 const cpp_token *token;
936 if (arg->expanded_count + 1 >= capacity)
939 arg->expanded = (const cpp_token **)
940 xrealloc (arg->expanded, capacity * sizeof (cpp_token *));
943 token = cpp_get_token (pfile);
945 if (token->type == CPP_EOF)
948 arg->expanded[arg->expanded_count++] = token;
951 _cpp_pop_context (pfile);
954 /* Pop the current context off the stack, re-enabling the macro if the
955 context represented a macro's replacement list. The context
956 structure is not freed so that we can re-use it later. */
958 _cpp_pop_context (pfile)
961 cpp_context *context = pfile->context;
964 context->macro->flags &= ~NODE_DISABLED;
967 _cpp_release_buff (pfile, context->buff);
969 pfile->context = context->prev;
972 /* Eternal routine to get a token. Also used nearly everywhere
973 internally, except for places where we know we can safely call
974 the lexer directly, such as lexing a directive name.
976 Macro expansions and directives are transparently handled,
977 including entering included files. Thus tokens are post-macro
978 expansion, and after any intervening directives. External callers
979 see CPP_EOF only at EOF. Internal callers also see it when meeting
980 a directive inside a macro call, when at the end of a directive and
981 state.in_directive is still 1, and at the end of argument
984 cpp_get_token (pfile)
987 const cpp_token *result;
992 cpp_context *context = pfile->context;
994 /* Context->prev == 0 <=> base context. */
996 result = _cpp_lex_token (pfile);
997 else if (context->first.token != context->last.token)
999 if (context->direct_p)
1000 result = context->first.token++;
1002 result = *context->first.ptoken++;
1004 if (result->flags & PASTE_LEFT)
1006 paste_all_tokens (pfile, result);
1007 if (pfile->state.in_directive)
1009 return padding_token (pfile, result);
1014 _cpp_pop_context (pfile);
1015 if (pfile->state.in_directive)
1017 return &pfile->avoid_paste;
1020 if (result->type != CPP_NAME)
1023 node = result->val.node;
1025 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1028 if (!(node->flags & NODE_DISABLED))
1030 if (!pfile->state.prevent_expansion
1031 && enter_macro_context (pfile, node))
1033 if (pfile->state.in_directive)
1035 return padding_token (pfile, result);
1040 /* Flag this token as always unexpandable. FIXME: move this
1041 to collect_args()?. */
1042 cpp_token *t = _cpp_temp_token (pfile);
1043 t->type = result->type;
1044 t->flags = result->flags | NO_EXPAND;
1045 t->val.str = result->val.str;
1055 /* Returns true if we're expanding an object-like macro that was
1056 defined in a system header. Just checks the macro at the top of
1057 the stack. Used for diagnostic suppression. */
1059 cpp_sys_macro_p (pfile)
1062 cpp_hashnode *node = pfile->context->macro;
1064 return node && node->value.macro && node->value.macro->syshdr;
1067 /* Read each token in, until EOF. Directives are transparently
1070 cpp_scan_nooutput (pfile)
1073 while (cpp_get_token (pfile)->type != CPP_EOF)
1077 /* Step back one (or more) tokens. Can only step mack more than 1 if
1078 they are from the lexer, and not from macro expansion. */
1080 _cpp_backup_tokens (pfile, count)
1084 if (pfile->context->prev == NULL)
1086 pfile->lookaheads += count;
1090 if (pfile->cur_token == pfile->cur_run->base
1091 /* Possible with -fpreprocessed and no leading #line. */
1092 && pfile->cur_run->prev != NULL)
1094 pfile->cur_run = pfile->cur_run->prev;
1095 pfile->cur_token = pfile->cur_run->limit;
1103 if (pfile->context->direct_p)
1104 pfile->context->first.token--;
1106 pfile->context->first.ptoken--;
1110 /* #define directive parsing and handling. */
1112 /* Returns non-zero if a macro redefinition warning is required. */
1114 warn_of_redefinition (node, macro2)
1115 const cpp_hashnode *node;
1116 const cpp_macro *macro2;
1118 const cpp_macro *macro1;
1121 /* Some redefinitions need to be warned about regardless. */
1122 if (node->flags & NODE_WARN)
1125 /* Redefinition of a macro is allowed if and only if the old and new
1126 definitions are the same. (6.10.3 paragraph 2). */
1127 macro1 = node->value.macro;
1129 /* The quick failures. */
1130 if (macro1->count != macro2->count
1131 || macro1->paramc != macro2->paramc
1132 || macro1->fun_like != macro2->fun_like
1133 || macro1->variadic != macro2->variadic)
1136 /* Check each token. */
1137 for (i = 0; i < macro1->count; i++)
1138 if (! _cpp_equiv_tokens (¯o1->expansion[i], ¯o2->expansion[i]))
1141 /* Check parameter spellings. */
1142 for (i = 0; i < macro1->paramc; i++)
1143 if (macro1->params[i] != macro2->params[i])
1149 /* Free the definition of hashnode H. */
1151 _cpp_free_definition (h)
1154 /* Macros and assertions no longer have anything to free. */
1156 /* Clear builtin flag in case of redefinition. */
1157 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1160 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1161 zero on success, non-zero if the parameter is a duplicate. */
1163 save_parameter (pfile, macro, node)
1168 /* Constraint 6.10.3.6 - duplicate parameter names. */
1169 if (node->arg_index)
1171 cpp_error (pfile, "duplicate macro parameter \"%s\"", NODE_NAME (node));
1175 if (BUFF_ROOM (pfile->a_buff)
1176 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1177 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1179 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1180 node->arg_index = macro->paramc;
1184 /* Check the syntax of the parameters in a MACRO definition. */
1186 parse_params (pfile, macro)
1190 unsigned int prev_ident = 0;
1194 const cpp_token *token = _cpp_lex_token (pfile);
1196 switch (token->type)
1199 cpp_error (pfile, "\"%s\" may not appear in macro parameter list",
1200 cpp_token_as_text (pfile, token));
1206 cpp_error (pfile, "macro parameters must be comma-separated");
1211 if (save_parameter (pfile, macro, token->val.node))
1215 case CPP_CLOSE_PAREN:
1216 if (prev_ident || macro->paramc == 0)
1219 /* Fall through to pick up the error. */
1223 cpp_error (pfile, "parameter name missing");
1230 macro->variadic = 1;
1233 save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1234 pfile->state.va_args_ok = 1;
1235 if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1237 "anonymous variadic macros were introduced in C99");
1239 else if (CPP_OPTION (pfile, pedantic))
1240 cpp_pedwarn (pfile, "ISO C does not permit named variadic macros");
1242 /* We're at the end, and just expect a closing parenthesis. */
1243 token = _cpp_lex_token (pfile);
1244 if (token->type == CPP_CLOSE_PAREN)
1249 cpp_error (pfile, "missing ')' in macro parameter list");
1255 /* Allocate room for a token from a macro's replacement list. */
1257 alloc_expansion_token (pfile, macro)
1261 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1262 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1264 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1267 /* Lex a token from the expansion of MACRO, but mark parameters as we
1268 find them and warn of traditional stringification. */
1270 lex_expansion_token (pfile, macro)
1276 pfile->cur_token = alloc_expansion_token (pfile, macro);
1277 token = _cpp_lex_direct (pfile);
1279 /* Is this a parameter? */
1280 if (token->type == CPP_NAME && token->val.node->arg_index)
1282 token->type = CPP_MACRO_ARG;
1283 token->val.arg_no = token->val.node->arg_index;
1285 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1286 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1287 check_trad_stringification (pfile, macro, &token->val.str);
1292 /* Parse a macro and save its expansion. Returns non-zero on success. */
1294 _cpp_create_definition (pfile, node)
1299 cpp_token *token, *saved_cur_token;
1300 const cpp_token *ctoken;
1301 unsigned int i, ok = 1;
1303 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1304 macro->line = pfile->directive_line;
1307 macro->variadic = 0;
1309 macro->fun_like = 0;
1311 /* Get the first token of the expansion (or the '(' of a
1312 function-like macro). */
1313 ctoken = _cpp_lex_token (pfile);
1315 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1317 ok = parse_params (pfile, macro);
1318 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1322 /* Success. Commit the parameter array. */
1323 BUFF_FRONT (pfile->a_buff) = (U_CHAR *) ¯o->params[macro->paramc];
1324 macro->fun_like = 1;
1326 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1327 cpp_pedwarn (pfile, "ISO C requires whitespace after the macro name");
1329 saved_cur_token = pfile->cur_token;
1331 if (macro->fun_like)
1332 token = lex_expansion_token (pfile, macro);
1335 token = alloc_expansion_token (pfile, macro);
1341 /* Check the stringifying # constraint 6.10.3.2.1 of
1342 function-like macros when lexing the subsequent token. */
1343 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1345 if (token->type == CPP_MACRO_ARG)
1347 token->flags &= ~PREV_WHITE;
1348 token->flags |= STRINGIFY_ARG;
1349 token->flags |= token[-1].flags & PREV_WHITE;
1350 token[-1] = token[0];
1353 /* Let assembler get away with murder. */
1354 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1357 cpp_error (pfile, "'#' is not followed by a macro parameter");
1362 if (token->type == CPP_EOF)
1365 /* Paste operator constraint 6.10.3.3.1. */
1366 if (token->type == CPP_PASTE)
1368 /* Token-paste ##, can appear in both object-like and
1369 function-like macros, but not at the ends. */
1370 if (--macro->count > 0)
1371 token = lex_expansion_token (pfile, macro);
1373 if (macro->count == 0 || token->type == CPP_EOF)
1377 "'##' cannot appear at either end of a macro expansion");
1381 token[-1].flags |= PASTE_LEFT;
1384 token = lex_expansion_token (pfile, macro);
1387 macro->expansion = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1389 /* Don't count the CPP_EOF. */
1392 /* Clear whitespace on first token for warn_of_redefinition(). */
1394 macro->expansion[0].flags &= ~PREV_WHITE;
1396 /* Commit the memory. */
1397 BUFF_FRONT (pfile->a_buff) = (U_CHAR *) ¯o->expansion[macro->count];
1399 /* Implement the macro-defined-to-itself optimisation. */
1400 if (macro->count == 1 && !macro->fun_like
1401 && macro->expansion[0].type == CPP_NAME
1402 && macro->expansion[0].val.node == node)
1403 node->flags |= NODE_DISABLED;
1405 /* To suppress some diagnostics. */
1406 macro->syshdr = pfile->map->sysp != 0;
1408 if (node->type != NT_VOID)
1410 if (warn_of_redefinition (node, macro))
1412 cpp_pedwarn_with_line (pfile, pfile->directive_line, 0,
1413 "\"%s\" redefined", NODE_NAME (node));
1415 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1416 cpp_pedwarn_with_line (pfile, node->value.macro->line, 0,
1417 "this is the location of the previous definition");
1419 _cpp_free_definition (node);
1422 /* Enter definition in hash table. */
1423 node->type = NT_MACRO;
1424 node->value.macro = macro;
1425 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1426 node->flags |= NODE_WARN;
1430 /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position. */
1431 saved_cur_token[-1].type = pfile->cur_token[-1].type;
1432 pfile->cur_token = saved_cur_token;
1436 /* Stop the lexer accepting __VA_ARGS__. */
1437 pfile->state.va_args_ok = 0;
1439 /* Clear the fast argument lookup indices. */
1440 for (i = macro->paramc; i-- > 0; )
1441 macro->params[i]->arg_index = 0;
1446 /* Warn if a token in STRING matches one of a function-like MACRO's
1449 check_trad_stringification (pfile, macro, string)
1451 const cpp_macro *macro;
1452 const cpp_string *string;
1454 unsigned int i, len;
1455 const U_CHAR *p, *q, *limit = string->text + string->len;
1457 /* Loop over the string. */
1458 for (p = string->text; p < limit; p = q)
1460 /* Find the start of an identifier. */
1461 while (p < limit && !is_idstart (*p))
1464 /* Find the end of the identifier. */
1466 while (q < limit && is_idchar (*q))
1471 /* Loop over the function macro arguments to see if the
1472 identifier inside the string matches one of them. */
1473 for (i = 0; i < macro->paramc; i++)
1475 const cpp_hashnode *node = macro->params[i];
1477 if (NODE_LEN (node) == len
1478 && !memcmp (p, NODE_NAME (node), len))
1481 "macro argument \"%s\" would be stringified in traditional C",
1489 /* Returns the name, arguments and expansion of a macro, in a format
1490 suitable to be read back in again, and therefore also for DWARF 2
1491 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1492 Caller is expected to generate the "#define" bit if needed. The
1493 returned text is temporary, and automatically freed later. */
1494 const unsigned char *
1495 cpp_macro_definition (pfile, node)
1497 const cpp_hashnode *node;
1499 unsigned int i, len;
1500 const cpp_macro *macro = node->value.macro;
1501 unsigned char *buffer;
1503 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1505 cpp_ice (pfile, "invalid hash type %d in cpp_macro_definition", node->type);
1509 /* Calculate length. */
1510 len = NODE_LEN (node) + 1; /* ' ' */
1511 if (macro->fun_like)
1513 len += 3; /* "()" plus possible final "." of named
1514 varargs (we have + 2 below). */
1515 for (i = 0; i < macro->paramc; i++)
1516 len += NODE_LEN (macro->params[i]) + 2; /* ", " */
1519 for (i = 0; i < macro->count; i++)
1521 cpp_token *token = ¯o->expansion[i];
1523 if (token->type == CPP_MACRO_ARG)
1524 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1526 len += cpp_token_len (token); /* Includes room for ' '. */
1527 if (token->flags & STRINGIFY_ARG)
1529 if (token->flags & PASTE_LEFT)
1530 len += 3; /* " ##" */
1533 if (len > pfile->macro_buffer_len)
1535 pfile->macro_buffer = (U_CHAR *) xrealloc (pfile->macro_buffer, len);
1536 pfile->macro_buffer_len = len;
1539 /* Fill in the buffer. Start with the macro name. */
1540 buffer = pfile->macro_buffer;
1541 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1542 buffer += NODE_LEN (node);
1544 /* Parameter names. */
1545 if (macro->fun_like)
1548 for (i = 0; i < macro->paramc; i++)
1550 cpp_hashnode *param = macro->params[i];
1552 if (param != pfile->spec_nodes.n__VA_ARGS__)
1554 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1555 buffer += NODE_LEN (param);
1558 if (i + 1 < macro->paramc)
1559 *buffer++ = ',', *buffer++ = ' ';
1560 else if (macro->variadic)
1561 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1566 /* Expansion tokens. */
1570 for (i = 0; i < macro->count; i++)
1572 cpp_token *token = ¯o->expansion[i];
1574 if (token->flags & PREV_WHITE)
1576 if (token->flags & STRINGIFY_ARG)
1579 if (token->type == CPP_MACRO_ARG)
1581 len = NODE_LEN (macro->params[token->val.arg_no - 1]);
1583 NODE_NAME (macro->params[token->val.arg_no - 1]), len);
1587 buffer = cpp_spell_token (pfile, token, buffer);
1589 if (token->flags & PASTE_LEFT)
1594 /* Next has PREV_WHITE; see _cpp_create_definition. */
1600 return pfile->macro_buffer;