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 const cpp_token *new_string_token PARAMS ((cpp_reader *, U_CHAR *,
69 static const cpp_token *new_number_token PARAMS ((cpp_reader *, unsigned int));
70 static const cpp_token *stringify_arg PARAMS ((cpp_reader *, macro_arg *));
71 static void paste_all_tokens PARAMS ((cpp_reader *, const cpp_token *));
72 static bool paste_tokens PARAMS ((cpp_reader *, const cpp_token **,
74 static void replace_args PARAMS ((cpp_reader *, cpp_hashnode *, macro_arg *));
75 static _cpp_buff *funlike_invocation_p PARAMS ((cpp_reader *, cpp_hashnode *));
77 /* #define directive parsing and handling. */
79 static cpp_token *alloc_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
80 static cpp_token *lex_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
81 static int warn_of_redefinition PARAMS ((const cpp_hashnode *,
83 static int save_parameter PARAMS ((cpp_reader *, cpp_macro *, cpp_hashnode *));
84 static int parse_params PARAMS ((cpp_reader *, cpp_macro *));
85 static void check_trad_stringification PARAMS ((cpp_reader *,
89 /* Allocates and returns a CPP_STRING token, containing TEXT of length
90 LEN, after null-terminating it. TEXT must be in permanent storage. */
91 static const cpp_token *
92 new_string_token (pfile, text, len)
97 cpp_token *token = _cpp_temp_token (pfile);
100 token->type = CPP_STRING;
101 token->val.str.len = len;
102 token->val.str.text = text;
107 /* Allocates and returns a CPP_NUMBER token evaluating to NUMBER. */
108 static const cpp_token *
109 new_number_token (pfile, number)
113 cpp_token *token = _cpp_temp_token (pfile);
114 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
115 unsigned char *buf = _cpp_unaligned_alloc (pfile, 21);
117 sprintf ((char *) buf, "%u", number);
118 token->type = CPP_NUMBER;
119 token->val.str.text = buf;
120 token->val.str.len = ustrlen (buf);
125 static const char * const monthnames[] =
127 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
128 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
131 /* Handle builtin macros like __FILE__, and push the resulting token
132 on the context stack. Also handles _Pragma, for which no new token
133 is created. Returns 1 if it generates a new token context, 0 to
134 return the token to the caller. */
136 builtin_macro (pfile, node)
140 const cpp_token *result;
142 switch (node->value.builtin)
145 cpp_ice (pfile, "invalid built-in macro \"%s\"", NODE_NAME (node));
154 const struct line_map *map = pfile->map;
156 if (node->value.builtin == BT_BASE_FILE)
157 while (! MAIN_FILE_P (map))
158 map = INCLUDED_FROM (&pfile->line_maps, map);
162 buf = _cpp_unaligned_alloc (pfile, len * 4 + 1);
163 len = cpp_quote_string (buf, (const unsigned char *) name, len) - buf;
165 result = new_string_token (pfile, buf, len);
169 case BT_INCLUDE_LEVEL:
170 /* The line map depth counts the primary source as level 1, but
171 historically __INCLUDE_DEPTH__ has called the primary source
173 result = new_number_token (pfile, pfile->line_maps.depth - 1);
177 /* If __LINE__ is embedded in a macro, it must expand to the
178 line of the macro's invocation, not its definition.
179 Otherwise things like assert() will not work properly. */
180 result = new_number_token (pfile,
181 SOURCE_LINE (pfile->map,
182 pfile->cur_token[-1].line));
187 int stdc = (!CPP_IN_SYSTEM_HEADER (pfile)
188 || pfile->spec_nodes.n__STRICT_ANSI__->type != NT_VOID);
189 result = new_number_token (pfile, stdc);
195 if (pfile->date.type == CPP_EOF)
197 /* Allocate __DATE__ and __TIME__ strings from permanent
198 storage. We only do this once, and don't generate them
199 at init time, because time() and localtime() are very
200 slow on some systems. */
201 time_t tt = time (NULL);
202 struct tm *tb = localtime (&tt);
204 pfile->date.val.str.text =
205 _cpp_unaligned_alloc (pfile, sizeof ("Oct 11 1347"));
206 pfile->date.val.str.len = sizeof ("Oct 11 1347") - 1;
207 pfile->date.type = CPP_STRING;
208 pfile->date.flags = 0;
209 sprintf ((char *) pfile->date.val.str.text, "%s %2d %4d",
210 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
212 pfile->time.val.str.text =
213 _cpp_unaligned_alloc (pfile, sizeof ("12:34:56"));
214 pfile->time.val.str.len = sizeof ("12:34:56") - 1;
215 pfile->time.type = CPP_STRING;
216 pfile->time.flags = 0;
217 sprintf ((char *) pfile->time.val.str.text, "%02d:%02d:%02d",
218 tb->tm_hour, tb->tm_min, tb->tm_sec);
221 if (node->value.builtin == BT_DATE)
222 result = &pfile->date;
224 result = &pfile->time;
228 /* Don't interpret _Pragma within directives. The standard is
229 not clear on this, but to me this makes most sense. */
230 if (pfile->state.in_directive)
233 _cpp_do__Pragma (pfile);
237 push_token_context (pfile, NULL, result, 1);
241 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
242 backslashes and double quotes. Non-printable characters are
243 converted to octal. DEST must be of sufficient size. Returns
244 a pointer to the end of the string. */
246 cpp_quote_string (dest, src, len)
255 if (c == '\\' || c == '"')
266 sprintf ((char *) dest, "\\%03o", c);
275 /* Convert a token sequence ARG to a single string token according to
276 the rules of the ISO C #-operator. */
277 static const cpp_token *
278 stringify_arg (pfile, arg)
282 unsigned char *dest = BUFF_FRONT (pfile->u_buff);
283 unsigned int i, escape_it, backslash_count = 0;
284 const cpp_token *source = NULL;
287 /* Loop, reading in the argument's tokens. */
288 for (i = 0; i < arg->count; i++)
290 const cpp_token *token = arg->first[i];
292 if (token->type == CPP_PADDING)
295 source = token->val.source;
299 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
300 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
302 /* Room for each char being written in octal, initial space and
304 len = cpp_token_len (token);
309 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
311 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
312 _cpp_extend_buff (pfile, &pfile->u_buff, len);
313 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
316 /* Leading white space? */
317 if (dest != BUFF_FRONT (pfile->u_buff))
321 if (source->flags & PREV_WHITE)
328 _cpp_buff *buff = _cpp_get_buff (pfile, len);
329 unsigned char *buf = BUFF_FRONT (buff);
330 len = cpp_spell_token (pfile, token, buf) - buf;
331 dest = cpp_quote_string (dest, buf, len);
332 _cpp_release_buff (pfile, buff);
335 dest = cpp_spell_token (pfile, token, dest);
337 if (token->type == CPP_OTHER && token->val.c == '\\')
343 /* Ignore the final \ of invalid string literals. */
344 if (backslash_count & 1)
346 cpp_warning (pfile, "invalid string literal, ignoring final '\\'");
350 /* Commit the memory, including NUL, and return the token. */
351 len = dest - BUFF_FRONT (pfile->u_buff);
352 BUFF_FRONT (pfile->u_buff) = dest + 1;
353 return new_string_token (pfile, dest - len, len);
356 /* Try to paste two tokens. On success, return non-zero. In any
357 case, PLHS is updated to point to the pasted token, which is
358 guaranteed to not have the PASTE_LEFT flag set. */
360 paste_tokens (pfile, plhs, rhs)
362 const cpp_token **plhs, *rhs;
364 unsigned char *buf, *end;
365 const cpp_token *lhs;
370 len = cpp_token_len (lhs) + cpp_token_len (rhs) + 1;
371 buf = (unsigned char *) alloca (len);
372 end = cpp_spell_token (pfile, lhs, buf);
374 /* Avoid comment headers, since they are still processed in stage 3.
375 It is simpler to insert a space here, rather than modifying the
376 lexer to ignore comments in some circumstances. Simply returning
377 false doesn't work, since we want to clear the PASTE_LEFT flag. */
378 if (lhs->type == CPP_DIV
379 && (rhs->type == CPP_MULT || rhs->type == CPP_DIV))
381 end = cpp_spell_token (pfile, rhs, end);
384 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true, 1);
386 /* Tweak the column number the lexer will report. */
387 pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
389 /* We don't want a leading # to be interpreted as a directive. */
390 pfile->buffer->saved_flags = 0;
392 /* Set pfile->cur_token as required by _cpp_lex_direct. */
393 pfile->cur_token = _cpp_temp_token (pfile);
394 *plhs = _cpp_lex_direct (pfile);
395 valid = pfile->buffer->cur == pfile->buffer->rlimit;
396 _cpp_pop_buffer (pfile);
401 /* Handles an arbitrarily long sequence of ## operators, with initial
402 operand LHS. This implementation is left-associative,
403 non-recursive, and finishes a paste before handling succeeding
404 ones. If a paste fails, we back up to the RHS of the failing ##
405 operator before pushing the context containing the result of prior
406 successful pastes, with the effect that the RHS appears in the
407 output stream after the pasted LHS normally. */
409 paste_all_tokens (pfile, lhs)
411 const cpp_token *lhs;
413 const cpp_token *rhs;
414 cpp_context *context = pfile->context;
418 /* Take the token directly from the current context. We can do
419 this, because we are in the replacement list of either an
420 object-like macro, or a function-like macro with arguments
421 inserted. In either case, the constraints to #define
422 guarantee we have at least one more token. */
423 if (context->direct_p)
424 rhs = context->first.token++;
426 rhs = *context->first.ptoken++;
428 if (rhs->type == CPP_PADDING)
431 if (!paste_tokens (pfile, &lhs, rhs))
433 _cpp_backup_tokens (pfile, 1);
435 /* Mandatory warning for all apart from assembler. */
436 if (CPP_OPTION (pfile, lang) != CLK_ASM)
438 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
439 cpp_token_as_text (pfile, lhs),
440 cpp_token_as_text (pfile, rhs));
444 while (rhs->flags & PASTE_LEFT);
446 /* Put the resulting token in its own context. */
447 push_token_context (pfile, NULL, lhs, 1);
450 /* Reads and returns the arguments to a function-like macro
451 invocation. Assumes the opening parenthesis has been processed.
452 If there is an error, emits an appropriate diagnostic and returns
453 NULL. Each argument is terminated by a CPP_EOF token, for the
454 future benefit of expand_arg(). */
456 collect_args (pfile, node)
458 const cpp_hashnode *node;
460 _cpp_buff *buff, *base_buff;
462 macro_arg *args, *arg;
463 const cpp_token *token;
467 macro = node->value.macro;
469 argc = macro->paramc;
472 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
473 + sizeof (macro_arg)));
475 args = (macro_arg *) buff->base;
476 memset (args, 0, argc * sizeof (macro_arg));
477 buff->cur = (unsigned char *) &args[argc];
478 arg = args, argc = 0;
480 /* Collect the tokens making up each argument. We don't yet know
481 how many arguments have been supplied, whether too many or too
482 few. Hence the slightly bizarre usage of "argc" and "arg". */
485 unsigned int paren_depth = 0;
486 unsigned int ntokens = 0;
489 arg->first = (const cpp_token **) buff->cur;
493 /* Require space for 2 new tokens (including a CPP_EOF). */
494 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
496 buff = _cpp_append_extend_buff (pfile, buff,
497 1000 * sizeof (cpp_token *));
498 arg->first = (const cpp_token **) buff->cur;
501 token = cpp_get_token (pfile);
503 if (token->type == CPP_PADDING)
505 /* Drop leading padding. */
509 else if (token->type == CPP_OPEN_PAREN)
511 else if (token->type == CPP_CLOSE_PAREN)
513 if (paren_depth-- == 0)
516 else if (token->type == CPP_COMMA)
518 /* A comma does not terminate an argument within
519 parentheses or as part of a variable argument. */
521 && ! (macro->variadic && argc == macro->paramc))
524 else if (token->type == CPP_EOF
525 || (token->type == CPP_HASH && token->flags & BOL))
528 arg->first[ntokens++] = token;
531 /* Drop trailing padding. */
532 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
535 arg->count = ntokens;
536 arg->first[ntokens] = &pfile->eof;
538 /* Terminate the argument. Excess arguments loop back and
539 overwrite the final legitimate argument, before failing. */
540 if (argc <= macro->paramc)
542 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
543 if (argc != macro->paramc)
547 while (token->type != CPP_CLOSE_PAREN
548 && token->type != CPP_EOF
549 && token->type != CPP_HASH);
551 if (token->type == CPP_EOF || token->type == CPP_HASH)
553 bool step_back = false;
555 /* 6.10.3 paragraph 11: If there are sequences of preprocessing
556 tokens within the list of arguments that would otherwise act
557 as preprocessing directives, the behavior is undefined.
559 This implementation will report a hard error, terminate the
560 macro invocation, and proceed to process the directive. */
561 if (token->type == CPP_HASH)
564 "directives may not be used inside a macro argument");
568 step_back = (pfile->context->prev || pfile->state.in_directive);
570 /* We still need the CPP_EOF to end directives, and to end
571 pre-expansion of a macro argument. Step back is not
572 unconditional, since we don't want to return a CPP_EOF to our
573 callers at the end of an -include-d file. */
575 _cpp_backup_tokens (pfile, 1);
576 cpp_error (pfile, "unterminated argument list invoking macro \"%s\"",
580 else if (argc < macro->paramc)
582 /* As an extension, a rest argument is allowed to not appear in
583 the invocation at all.
584 e.g. #define debug(format, args...) something
587 This is exactly the same as if there had been an empty rest
588 argument - debug("string", ). */
590 if (argc + 1 == macro->paramc && macro->variadic)
592 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
593 cpp_pedwarn (pfile, "ISO C99 requires rest arguments to be used");
598 "macro \"%s\" requires %u arguments, but only %u given",
599 NODE_NAME (node), macro->paramc, argc);
603 else if (argc > macro->paramc)
605 /* Empty argument to a macro taking no arguments is OK. */
606 if (argc != 1 || arg->count)
609 "macro \"%s\" passed %u arguments, but takes just %u",
610 NODE_NAME (node), argc, macro->paramc);
618 _cpp_release_buff (pfile, base_buff);
622 /* Search for an opening parenthesis to the macro of NODE, in such a
623 way that, if none is found, we don't lose the information in any
624 intervening padding tokens. If we find the parenthesis, collect
625 the arguments and return the buffer containing them. */
627 funlike_invocation_p (pfile, node)
631 const cpp_token *token, *padding = NULL;
635 token = cpp_get_token (pfile);
636 if (token->type != CPP_PADDING)
639 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
643 if (token->type == CPP_OPEN_PAREN)
645 pfile->state.parsing_args = 2;
646 return collect_args (pfile, node);
649 /* CPP_EOF can be the end of macro arguments, or the end of the
650 file. We mustn't back up over the latter. Ugh. */
651 if (token->type != CPP_EOF || token == &pfile->eof)
653 /* Back up. We may have skipped padding, in which case backing
654 up more than one token when expanding macros is in general
655 too difficult. We re-insert it in its own context. */
656 _cpp_backup_tokens (pfile, 1);
658 push_token_context (pfile, NULL, padding, 1);
664 /* Push the context of a macro with hash entry NODE onto the context
665 stack. If we can successfully expand the macro, we push a context
666 containing its yet-to-be-rescanned replacement list and return one.
667 Otherwise, we don't push a context and return zero. */
669 enter_macro_context (pfile, node)
673 /* The presence of a macro invalidates a file's controlling macro. */
674 pfile->mi_valid = false;
676 /* Handle standard macros. */
677 if (! (node->flags & NODE_BUILTIN))
679 cpp_macro *macro = node->value.macro;
685 pfile->state.prevent_expansion++;
686 pfile->keep_tokens++;
687 pfile->state.parsing_args = 1;
688 buff = funlike_invocation_p (pfile, node);
689 pfile->state.parsing_args = 0;
690 pfile->keep_tokens--;
691 pfile->state.prevent_expansion--;
695 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
697 "function-like macro \"%s\" must be used with arguments in traditional C",
703 if (node->value.macro->paramc > 0)
704 replace_args (pfile, node, (macro_arg *) buff->base);
705 _cpp_release_buff (pfile, buff);
708 /* Disable the macro within its expansion. */
709 node->flags |= NODE_DISABLED;
711 if (macro->paramc == 0)
712 push_token_context (pfile, node, macro->expansion, macro->count);
717 /* Handle built-in macros and the _Pragma operator. */
718 return builtin_macro (pfile, node);
721 /* Replace the parameters in a function-like macro of NODE with the
722 actual ARGS, and place the result in a newly pushed token context.
723 Expand each argument before replacing, unless it is operated upon
724 by the # or ## operators. */
726 replace_args (pfile, node, args)
731 unsigned int i, total;
732 const cpp_token *src, *limit;
733 const cpp_token **dest, **first;
738 /* First, fully macro-expand arguments, calculating the number of
739 tokens in the final expansion as we go. The ordering of the if
740 statements below is subtle; we must handle stringification before
742 macro = node->value.macro;
743 total = macro->count;
744 limit = macro->expansion + macro->count;
746 for (src = macro->expansion; src < limit; src++)
747 if (src->type == CPP_MACRO_ARG)
749 /* Leading and trailing padding tokens. */
752 /* We have an argument. If it is not being stringified or
753 pasted it is macro-replaced before insertion. */
754 arg = &args[src->val.arg_no - 1];
756 if (src->flags & STRINGIFY_ARG)
758 if (!arg->stringified)
759 arg->stringified = stringify_arg (pfile, arg);
761 else if ((src->flags & PASTE_LEFT)
762 || (src > macro->expansion && (src[-1].flags & PASTE_LEFT)))
763 total += arg->count - 1;
767 expand_arg (pfile, arg);
768 total += arg->expanded_count - 1;
772 /* Now allocate space for the expansion, copy the tokens and replace
774 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
775 first = (const cpp_token **) buff->base;
778 for (src = macro->expansion; src < limit; src++)
781 const cpp_token **from, **paste_flag;
783 if (src->type != CPP_MACRO_ARG)
790 arg = &args[src->val.arg_no - 1];
791 if (src->flags & STRINGIFY_ARG)
792 count = 1, from = &arg->stringified;
793 else if (src->flags & PASTE_LEFT)
794 count = arg->count, from = arg->first;
795 else if (src != macro->expansion && (src[-1].flags & PASTE_LEFT))
797 count = arg->count, from = arg->first;
800 /* GCC has special semantics for , ## b where b is a
801 varargs parameter: the comma disappears if b was
802 given no actual arguments (not merely if b is an
803 empty argument); otherwise the paste flag is removed. */
804 if (dest[-1]->type == CPP_COMMA
806 && src->val.arg_no == macro->paramc)
811 paste_flag = dest - 1;
813 /* Remove the paste flag if the RHS is a placemarker. */
815 paste_flag = dest - 1;
819 count = arg->expanded_count, from = arg->expanded;
821 /* Padding on the left of an argument (unless RHS of ##). */
822 if (!pfile->state.in_directive
823 && src != macro->expansion && !(src[-1].flags & PASTE_LEFT))
824 *dest++ = padding_token (pfile, src);
828 memcpy (dest, from, count * sizeof (cpp_token *));
831 /* With a non-empty argument on the LHS of ##, the last
832 token should be flagged PASTE_LEFT. */
833 if (src->flags & PASTE_LEFT)
834 paste_flag = dest - 1;
837 /* Avoid paste on RHS (even case count == 0). */
838 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
839 *dest++ = &pfile->avoid_paste;
841 /* Add a new paste flag, or remove an unwanted one. */
844 cpp_token *token = _cpp_temp_token (pfile);
845 token->type = (*paste_flag)->type;
846 token->val.str = (*paste_flag)->val.str;
847 if (src->flags & PASTE_LEFT)
848 token->flags = (*paste_flag)->flags | PASTE_LEFT;
850 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
855 /* Free the expanded arguments. */
856 for (i = 0; i < macro->paramc; i++)
857 if (args[i].expanded)
858 free (args[i].expanded);
860 push_ptoken_context (pfile, node, buff, first, dest - first);
863 /* Return a special padding token, with padding inherited from SOURCE. */
864 static const cpp_token *
865 padding_token (pfile, source)
867 const cpp_token *source;
869 cpp_token *result = _cpp_temp_token (pfile);
871 result->type = CPP_PADDING;
872 result->val.source = source;
877 /* Get a new uninitialized context. Create a new one if we cannot
878 re-use an old one. */
883 cpp_context *result = pfile->context->next;
887 result = xnew (cpp_context);
888 result->prev = pfile->context;
890 pfile->context->next = result;
893 pfile->context = result;
897 /* Push a list of pointers to tokens. */
899 push_ptoken_context (pfile, macro, buff, first, count)
903 const cpp_token **first;
906 cpp_context *context = next_context (pfile);
908 context->direct_p = false;
909 context->macro = macro;
910 context->buff = buff;
911 context->first.ptoken = first;
912 context->last.ptoken = first + count;
915 /* Push a list of tokens. */
917 push_token_context (pfile, macro, first, count)
920 const cpp_token *first;
923 cpp_context *context = next_context (pfile);
925 context->direct_p = true;
926 context->macro = macro;
927 context->buff = NULL;
928 context->first.token = first;
929 context->last.token = first + count;
932 /* Expand an argument ARG before replacing parameters in a
933 function-like macro. This works by pushing a context with the
934 argument's tokens, and then expanding that into a temporary buffer
935 as if it were a normal part of the token stream. collect_args()
936 has terminated the argument's tokens with a CPP_EOF so that we know
937 when we have fully expanded the argument. */
939 expand_arg (pfile, arg)
943 unsigned int capacity;
948 /* Loop, reading in the arguments. */
950 arg->expanded = (const cpp_token **)
951 xmalloc (capacity * sizeof (cpp_token *));
953 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
956 const cpp_token *token;
958 if (arg->expanded_count + 1 >= capacity)
961 arg->expanded = (const cpp_token **)
962 xrealloc (arg->expanded, capacity * sizeof (cpp_token *));
965 token = cpp_get_token (pfile);
967 if (token->type == CPP_EOF)
970 arg->expanded[arg->expanded_count++] = token;
973 _cpp_pop_context (pfile);
976 /* Pop the current context off the stack, re-enabling the macro if the
977 context represented a macro's replacement list. The context
978 structure is not freed so that we can re-use it later. */
980 _cpp_pop_context (pfile)
983 cpp_context *context = pfile->context;
986 context->macro->flags &= ~NODE_DISABLED;
989 _cpp_release_buff (pfile, context->buff);
991 pfile->context = context->prev;
994 /* Eternal routine to get a token. Also used nearly everywhere
995 internally, except for places where we know we can safely call
996 the lexer directly, such as lexing a directive name.
998 Macro expansions and directives are transparently handled,
999 including entering included files. Thus tokens are post-macro
1000 expansion, and after any intervening directives. External callers
1001 see CPP_EOF only at EOF. Internal callers also see it when meeting
1002 a directive inside a macro call, when at the end of a directive and
1003 state.in_directive is still 1, and at the end of argument
1006 cpp_get_token (pfile)
1009 const cpp_token *result;
1014 cpp_context *context = pfile->context;
1016 /* Context->prev == 0 <=> base context. */
1018 result = _cpp_lex_token (pfile);
1019 else if (context->first.token != context->last.token)
1021 if (context->direct_p)
1022 result = context->first.token++;
1024 result = *context->first.ptoken++;
1026 if (result->flags & PASTE_LEFT)
1028 paste_all_tokens (pfile, result);
1029 if (pfile->state.in_directive)
1031 return padding_token (pfile, result);
1036 _cpp_pop_context (pfile);
1037 if (pfile->state.in_directive)
1039 return &pfile->avoid_paste;
1042 if (result->type != CPP_NAME)
1045 node = result->val.node;
1047 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1050 if (!(node->flags & NODE_DISABLED))
1052 if (!pfile->state.prevent_expansion
1053 && enter_macro_context (pfile, node))
1055 if (pfile->state.in_directive)
1057 return padding_token (pfile, result);
1062 /* Flag this token as always unexpandable. FIXME: move this
1063 to collect_args()?. */
1064 cpp_token *t = _cpp_temp_token (pfile);
1065 t->type = result->type;
1066 t->flags = result->flags | NO_EXPAND;
1067 t->val.str = result->val.str;
1077 /* Returns true if we're expanding an object-like macro that was
1078 defined in a system header. Just checks the macro at the top of
1079 the stack. Used for diagnostic suppression. */
1081 cpp_sys_macro_p (pfile)
1084 cpp_hashnode *node = pfile->context->macro;
1086 return node && node->value.macro && node->value.macro->syshdr;
1089 /* Read each token in, until EOF. Directives are transparently
1092 cpp_scan_nooutput (pfile)
1095 while (cpp_get_token (pfile)->type != CPP_EOF)
1099 /* Step back one (or more) tokens. Can only step mack more than 1 if
1100 they are from the lexer, and not from macro expansion. */
1102 _cpp_backup_tokens (pfile, count)
1106 if (pfile->context->prev == NULL)
1108 pfile->lookaheads += count;
1112 if (pfile->cur_token == pfile->cur_run->base
1113 /* Possible with -fpreprocessed and no leading #line. */
1114 && pfile->cur_run->prev != NULL)
1116 pfile->cur_run = pfile->cur_run->prev;
1117 pfile->cur_token = pfile->cur_run->limit;
1125 if (pfile->context->direct_p)
1126 pfile->context->first.token--;
1128 pfile->context->first.ptoken--;
1132 /* #define directive parsing and handling. */
1134 /* Returns non-zero if a macro redefinition warning is required. */
1136 warn_of_redefinition (node, macro2)
1137 const cpp_hashnode *node;
1138 const cpp_macro *macro2;
1140 const cpp_macro *macro1;
1143 /* Some redefinitions need to be warned about regardless. */
1144 if (node->flags & NODE_WARN)
1147 /* Redefinition of a macro is allowed if and only if the old and new
1148 definitions are the same. (6.10.3 paragraph 2). */
1149 macro1 = node->value.macro;
1151 /* The quick failures. */
1152 if (macro1->count != macro2->count
1153 || macro1->paramc != macro2->paramc
1154 || macro1->fun_like != macro2->fun_like
1155 || macro1->variadic != macro2->variadic)
1158 /* Check each token. */
1159 for (i = 0; i < macro1->count; i++)
1160 if (! _cpp_equiv_tokens (¯o1->expansion[i], ¯o2->expansion[i]))
1163 /* Check parameter spellings. */
1164 for (i = 0; i < macro1->paramc; i++)
1165 if (macro1->params[i] != macro2->params[i])
1171 /* Free the definition of hashnode H. */
1173 _cpp_free_definition (h)
1176 /* Macros and assertions no longer have anything to free. */
1178 /* Clear builtin flag in case of redefinition. */
1179 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1182 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1183 zero on success, non-zero if the parameter is a duplicate. */
1185 save_parameter (pfile, macro, node)
1190 /* Constraint 6.10.3.6 - duplicate parameter names. */
1191 if (node->arg_index)
1193 cpp_error (pfile, "duplicate macro parameter \"%s\"", NODE_NAME (node));
1197 if (BUFF_ROOM (pfile->a_buff)
1198 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1199 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1201 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1202 node->arg_index = macro->paramc;
1206 /* Check the syntax of the parameters in a MACRO definition. */
1208 parse_params (pfile, macro)
1212 unsigned int prev_ident = 0;
1216 const cpp_token *token = _cpp_lex_token (pfile);
1218 switch (token->type)
1221 cpp_error (pfile, "\"%s\" may not appear in macro parameter list",
1222 cpp_token_as_text (pfile, token));
1228 cpp_error (pfile, "macro parameters must be comma-separated");
1233 if (save_parameter (pfile, macro, token->val.node))
1237 case CPP_CLOSE_PAREN:
1238 if (prev_ident || macro->paramc == 0)
1241 /* Fall through to pick up the error. */
1245 cpp_error (pfile, "parameter name missing");
1252 macro->variadic = 1;
1255 save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1256 pfile->state.va_args_ok = 1;
1257 if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1259 "anonymous variadic macros were introduced in C99");
1261 else if (CPP_OPTION (pfile, pedantic))
1262 cpp_pedwarn (pfile, "ISO C does not permit named variadic macros");
1264 /* We're at the end, and just expect a closing parenthesis. */
1265 token = _cpp_lex_token (pfile);
1266 if (token->type == CPP_CLOSE_PAREN)
1271 cpp_error (pfile, "missing ')' in macro parameter list");
1277 /* Allocate room for a token from a macro's replacement list. */
1279 alloc_expansion_token (pfile, macro)
1283 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1284 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1286 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1289 /* Lex a token from the expansion of MACRO, but mark parameters as we
1290 find them and warn of traditional stringification. */
1292 lex_expansion_token (pfile, macro)
1298 pfile->cur_token = alloc_expansion_token (pfile, macro);
1299 token = _cpp_lex_direct (pfile);
1301 /* Is this a parameter? */
1302 if (token->type == CPP_NAME && token->val.node->arg_index)
1304 token->type = CPP_MACRO_ARG;
1305 token->val.arg_no = token->val.node->arg_index;
1307 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1308 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1309 check_trad_stringification (pfile, macro, &token->val.str);
1314 /* Parse a macro and save its expansion. Returns non-zero on success. */
1316 _cpp_create_definition (pfile, node)
1321 cpp_token *token, *saved_cur_token;
1322 const cpp_token *ctoken;
1323 unsigned int i, ok = 1;
1325 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1326 macro->line = pfile->directive_line;
1329 macro->variadic = 0;
1331 macro->fun_like = 0;
1333 /* Get the first token of the expansion (or the '(' of a
1334 function-like macro). */
1335 ctoken = _cpp_lex_token (pfile);
1337 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1339 ok = parse_params (pfile, macro);
1340 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1344 /* Success. Commit the parameter array. */
1345 BUFF_FRONT (pfile->a_buff) = (U_CHAR *) ¯o->params[macro->paramc];
1346 macro->fun_like = 1;
1348 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1349 cpp_pedwarn (pfile, "ISO C requires whitespace after the macro name");
1351 saved_cur_token = pfile->cur_token;
1353 if (macro->fun_like)
1354 token = lex_expansion_token (pfile, macro);
1357 token = alloc_expansion_token (pfile, macro);
1363 /* Check the stringifying # constraint 6.10.3.2.1 of
1364 function-like macros when lexing the subsequent token. */
1365 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1367 if (token->type == CPP_MACRO_ARG)
1369 token->flags &= ~PREV_WHITE;
1370 token->flags |= STRINGIFY_ARG;
1371 token->flags |= token[-1].flags & PREV_WHITE;
1372 token[-1] = token[0];
1375 /* Let assembler get away with murder. */
1376 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1379 cpp_error (pfile, "'#' is not followed by a macro parameter");
1384 if (token->type == CPP_EOF)
1387 /* Paste operator constraint 6.10.3.3.1. */
1388 if (token->type == CPP_PASTE)
1390 /* Token-paste ##, can appear in both object-like and
1391 function-like macros, but not at the ends. */
1392 if (--macro->count > 0)
1393 token = lex_expansion_token (pfile, macro);
1395 if (macro->count == 0 || token->type == CPP_EOF)
1399 "'##' cannot appear at either end of a macro expansion");
1403 token[-1].flags |= PASTE_LEFT;
1406 token = lex_expansion_token (pfile, macro);
1409 macro->expansion = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1411 /* Don't count the CPP_EOF. */
1414 /* Clear whitespace on first token for warn_of_redefinition(). */
1416 macro->expansion[0].flags &= ~PREV_WHITE;
1418 /* Commit the memory. */
1419 BUFF_FRONT (pfile->a_buff) = (U_CHAR *) ¯o->expansion[macro->count];
1421 /* Implement the macro-defined-to-itself optimisation. */
1422 if (macro->count == 1 && !macro->fun_like
1423 && macro->expansion[0].type == CPP_NAME
1424 && macro->expansion[0].val.node == node)
1425 node->flags |= NODE_DISABLED;
1427 /* To suppress some diagnostics. */
1428 macro->syshdr = pfile->map->sysp != 0;
1430 if (node->type != NT_VOID)
1432 if (warn_of_redefinition (node, macro))
1434 cpp_pedwarn_with_line (pfile, pfile->directive_line, 0,
1435 "\"%s\" redefined", NODE_NAME (node));
1437 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1438 cpp_pedwarn_with_line (pfile, node->value.macro->line, 0,
1439 "this is the location of the previous definition");
1441 _cpp_free_definition (node);
1444 /* Enter definition in hash table. */
1445 node->type = NT_MACRO;
1446 node->value.macro = macro;
1447 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1448 node->flags |= NODE_WARN;
1452 /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position. */
1453 saved_cur_token[-1].type = pfile->cur_token[-1].type;
1454 pfile->cur_token = saved_cur_token;
1458 /* Stop the lexer accepting __VA_ARGS__. */
1459 pfile->state.va_args_ok = 0;
1461 /* Clear the fast argument lookup indices. */
1462 for (i = macro->paramc; i-- > 0; )
1463 macro->params[i]->arg_index = 0;
1468 /* Warn if a token in STRING matches one of a function-like MACRO's
1471 check_trad_stringification (pfile, macro, string)
1473 const cpp_macro *macro;
1474 const cpp_string *string;
1476 unsigned int i, len;
1477 const U_CHAR *p, *q, *limit = string->text + string->len;
1479 /* Loop over the string. */
1480 for (p = string->text; p < limit; p = q)
1482 /* Find the start of an identifier. */
1483 while (p < limit && !is_idstart (*p))
1486 /* Find the end of the identifier. */
1488 while (q < limit && is_idchar (*q))
1493 /* Loop over the function macro arguments to see if the
1494 identifier inside the string matches one of them. */
1495 for (i = 0; i < macro->paramc; i++)
1497 const cpp_hashnode *node = macro->params[i];
1499 if (NODE_LEN (node) == len
1500 && !memcmp (p, NODE_NAME (node), len))
1503 "macro argument \"%s\" would be stringified with -traditional",
1511 /* Returns the name, arguments and expansion of a macro, in a format
1512 suitable to be read back in again, and therefore also for DWARF 2
1513 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1514 Caller is expected to generate the "#define" bit if needed. The
1515 returned text is temporary, and automatically freed later. */
1516 const unsigned char *
1517 cpp_macro_definition (pfile, node)
1519 const cpp_hashnode *node;
1521 unsigned int i, len;
1522 const cpp_macro *macro = node->value.macro;
1523 unsigned char *buffer;
1525 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1527 cpp_ice (pfile, "invalid hash type %d in cpp_macro_definition", node->type);
1531 /* Calculate length. */
1532 len = NODE_LEN (node) + 1; /* ' ' */
1533 if (macro->fun_like)
1535 len += 4; /* "()" plus possible final ".." of named
1536 varargs (we have + 1 below). */
1537 for (i = 0; i < macro->paramc; i++)
1538 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1541 for (i = 0; i < macro->count; i++)
1543 cpp_token *token = ¯o->expansion[i];
1545 if (token->type == CPP_MACRO_ARG)
1546 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1548 len += cpp_token_len (token); /* Includes room for ' '. */
1549 if (token->flags & STRINGIFY_ARG)
1551 if (token->flags & PASTE_LEFT)
1552 len += 3; /* " ##" */
1555 if (len > pfile->macro_buffer_len)
1557 pfile->macro_buffer = (U_CHAR *) xrealloc (pfile->macro_buffer, len);
1558 pfile->macro_buffer_len = len;
1561 /* Fill in the buffer. Start with the macro name. */
1562 buffer = pfile->macro_buffer;
1563 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1564 buffer += NODE_LEN (node);
1566 /* Parameter names. */
1567 if (macro->fun_like)
1570 for (i = 0; i < macro->paramc; i++)
1572 cpp_hashnode *param = macro->params[i];
1574 if (param != pfile->spec_nodes.n__VA_ARGS__)
1576 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1577 buffer += NODE_LEN (param);
1580 if (i + 1 < macro->paramc)
1581 /* Don't emit a space after the comma here; we're trying
1582 to emit a Dwarf-friendly definition, and the Dwarf spec
1583 forbids spaces in the argument list. */
1585 else if (macro->variadic)
1586 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1591 /* The Dwarf spec requires a space after the macro name, even if the
1592 definition is the empty string. */
1595 /* Expansion tokens. */
1598 for (i = 0; i < macro->count; i++)
1600 cpp_token *token = ¯o->expansion[i];
1602 if (token->flags & PREV_WHITE)
1604 if (token->flags & STRINGIFY_ARG)
1607 if (token->type == CPP_MACRO_ARG)
1609 len = NODE_LEN (macro->params[token->val.arg_no - 1]);
1611 NODE_NAME (macro->params[token->val.arg_no - 1]), len);
1615 buffer = cpp_spell_token (pfile, token, buffer);
1617 if (token->flags & PASTE_LEFT)
1622 /* Next has PREV_WHITE; see _cpp_create_definition. */
1628 return pfile->macro_buffer;