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 *));
65 static bool create_iso_definition PARAMS ((cpp_reader *, cpp_macro *));
67 /* #define directive parsing and handling. */
69 static cpp_token *alloc_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
70 static cpp_token *lex_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
71 static bool warn_of_redefinition PARAMS ((cpp_reader *, const cpp_hashnode *,
73 static int save_parameter PARAMS ((cpp_reader *, cpp_macro *, cpp_hashnode *));
74 static int parse_params PARAMS ((cpp_reader *, cpp_macro *));
75 static void check_trad_stringification PARAMS ((cpp_reader *,
79 /* Allocates and returns a CPP_STRING token, containing TEXT of length
80 LEN, after null-terminating it. TEXT must be in permanent storage. */
81 static const cpp_token *
82 new_string_token (pfile, text, len)
87 cpp_token *token = _cpp_temp_token (pfile);
90 token->type = CPP_STRING;
91 token->val.str.len = len;
92 token->val.str.text = text;
97 /* Allocates and returns a CPP_NUMBER token evaluating to NUMBER. */
98 static const cpp_token *
99 new_number_token (pfile, number)
103 cpp_token *token = _cpp_temp_token (pfile);
104 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
105 unsigned char *buf = _cpp_unaligned_alloc (pfile, 21);
107 sprintf ((char *) buf, "%u", number);
108 token->type = CPP_NUMBER;
109 token->val.str.text = buf;
110 token->val.str.len = ustrlen (buf);
115 static const char * const monthnames[] =
117 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
118 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
121 /* Handle builtin macros like __FILE__, and push the resulting token
122 on the context stack. Also handles _Pragma, for which no new token
123 is created. Returns 1 if it generates a new token context, 0 to
124 return the token to the caller. */
126 builtin_macro (pfile, node)
130 const cpp_token *result;
132 switch (node->value.builtin)
135 cpp_error (pfile, DL_ICE, "invalid built-in macro \"%s\"",
145 const struct line_map *map = pfile->map;
147 if (node->value.builtin == BT_BASE_FILE)
148 while (! MAIN_FILE_P (map))
149 map = INCLUDED_FROM (&pfile->line_maps, map);
153 buf = _cpp_unaligned_alloc (pfile, len * 4 + 1);
154 len = cpp_quote_string (buf, (const unsigned char *) name, len) - buf;
156 result = new_string_token (pfile, buf, len);
160 case BT_INCLUDE_LEVEL:
161 /* The line map depth counts the primary source as level 1, but
162 historically __INCLUDE_DEPTH__ has called the primary source
164 result = new_number_token (pfile, pfile->line_maps.depth - 1);
168 /* If __LINE__ is embedded in a macro, it must expand to the
169 line of the macro's invocation, not its definition.
170 Otherwise things like assert() will not work properly. */
171 result = new_number_token (pfile,
172 SOURCE_LINE (pfile->map,
173 pfile->cur_token[-1].line));
176 /* __STDC__ has the value 1 under normal circumstances.
177 However, if (a) we are in a system header, (b) the option
178 stdc_0_in_system_headers is true (set by target config), and
179 (c) we are not in strictly conforming mode, then it has the
184 enum c_lang lang = CPP_OPTION (pfile, lang);
185 if (CPP_IN_SYSTEM_HEADER (pfile)
186 && CPP_OPTION (pfile, stdc_0_in_system_headers)
187 && !(lang == CLK_STDC89 || lang == CLK_STDC94
188 || lang == CLK_STDC99)) /* || lang == CLK_CXX98 ? */
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. Returns
248 a pointer to the end of the string. */
250 cpp_quote_string (dest, src, len)
259 if (c == '\\' || c == '"')
270 sprintf ((char *) dest, "\\%03o", c);
279 /* Convert a token sequence ARG to a single string token according to
280 the rules of the ISO C #-operator. */
281 static const cpp_token *
282 stringify_arg (pfile, arg)
286 unsigned char *dest = BUFF_FRONT (pfile->u_buff);
287 unsigned int i, escape_it, backslash_count = 0;
288 const cpp_token *source = NULL;
291 /* Loop, reading in the argument's tokens. */
292 for (i = 0; i < arg->count; i++)
294 const cpp_token *token = arg->first[i];
296 if (token->type == CPP_PADDING)
299 source = token->val.source;
303 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
304 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
306 /* Room for each char being written in octal, initial space and
308 len = cpp_token_len (token);
313 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
315 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
316 _cpp_extend_buff (pfile, &pfile->u_buff, len);
317 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
320 /* Leading white space? */
321 if (dest != BUFF_FRONT (pfile->u_buff))
325 if (source->flags & PREV_WHITE)
332 _cpp_buff *buff = _cpp_get_buff (pfile, len);
333 unsigned char *buf = BUFF_FRONT (buff);
334 len = cpp_spell_token (pfile, token, buf) - buf;
335 dest = cpp_quote_string (dest, buf, len);
336 _cpp_release_buff (pfile, buff);
339 dest = cpp_spell_token (pfile, token, dest);
341 if (token->type == CPP_OTHER && token->val.c == '\\')
347 /* Ignore the final \ of invalid string literals. */
348 if (backslash_count & 1)
350 cpp_error (pfile, DL_WARNING,
351 "invalid string literal, ignoring final '\\'");
355 /* Commit the memory, including NUL, and return the token. */
356 len = dest - BUFF_FRONT (pfile->u_buff);
357 BUFF_FRONT (pfile->u_buff) = dest + 1;
358 return new_string_token (pfile, dest - len, len);
361 /* Try to paste two tokens. On success, return non-zero. In any
362 case, PLHS is updated to point to the pasted token, which is
363 guaranteed to not have the PASTE_LEFT flag set. */
365 paste_tokens (pfile, plhs, rhs)
367 const cpp_token **plhs, *rhs;
369 unsigned char *buf, *end;
370 const cpp_token *lhs;
375 len = cpp_token_len (lhs) + cpp_token_len (rhs) + 1;
376 buf = (unsigned char *) alloca (len);
377 end = cpp_spell_token (pfile, lhs, buf);
379 /* Avoid comment headers, since they are still processed in stage 3.
380 It is simpler to insert a space here, rather than modifying the
381 lexer to ignore comments in some circumstances. Simply returning
382 false doesn't work, since we want to clear the PASTE_LEFT flag. */
383 if (lhs->type == CPP_DIV
384 && (rhs->type == CPP_MULT || rhs->type == CPP_DIV))
386 end = cpp_spell_token (pfile, rhs, end);
389 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true, 1);
391 /* Tweak the column number the lexer will report. */
392 pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
394 /* We don't want a leading # to be interpreted as a directive. */
395 pfile->buffer->saved_flags = 0;
397 /* Set pfile->cur_token as required by _cpp_lex_direct. */
398 pfile->cur_token = _cpp_temp_token (pfile);
399 *plhs = _cpp_lex_direct (pfile);
400 valid = pfile->buffer->cur == pfile->buffer->rlimit;
401 _cpp_pop_buffer (pfile);
406 /* Handles an arbitrarily long sequence of ## operators, with initial
407 operand LHS. This implementation is left-associative,
408 non-recursive, and finishes a paste before handling succeeding
409 ones. If a paste fails, we back up to the RHS of the failing ##
410 operator before pushing the context containing the result of prior
411 successful pastes, with the effect that the RHS appears in the
412 output stream after the pasted LHS normally. */
414 paste_all_tokens (pfile, lhs)
416 const cpp_token *lhs;
418 const cpp_token *rhs;
419 cpp_context *context = pfile->context;
423 /* Take the token directly from the current context. We can do
424 this, because we are in the replacement list of either an
425 object-like macro, or a function-like macro with arguments
426 inserted. In either case, the constraints to #define
427 guarantee we have at least one more token. */
428 if (context->direct_p)
429 rhs = FIRST (context).token++;
431 rhs = *FIRST (context).ptoken++;
433 if (rhs->type == CPP_PADDING)
436 if (!paste_tokens (pfile, &lhs, rhs))
438 _cpp_backup_tokens (pfile, 1);
440 /* Mandatory error for all apart from assembler. */
441 if (CPP_OPTION (pfile, lang) != CLK_ASM)
442 cpp_error (pfile, DL_ERROR,
443 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
444 cpp_token_as_text (pfile, lhs),
445 cpp_token_as_text (pfile, rhs));
449 while (rhs->flags & PASTE_LEFT);
451 /* Put the resulting token in its own context. */
452 push_token_context (pfile, NULL, lhs, 1);
455 /* Reads and returns the arguments to a function-like macro
456 invocation. Assumes the opening parenthesis has been processed.
457 If there is an error, emits an appropriate diagnostic and returns
458 NULL. Each argument is terminated by a CPP_EOF token, for the
459 future benefit of expand_arg(). */
461 collect_args (pfile, node)
463 const cpp_hashnode *node;
465 _cpp_buff *buff, *base_buff;
467 macro_arg *args, *arg;
468 const cpp_token *token;
472 macro = node->value.macro;
474 argc = macro->paramc;
477 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
478 + sizeof (macro_arg)));
480 args = (macro_arg *) buff->base;
481 memset (args, 0, argc * sizeof (macro_arg));
482 buff->cur = (unsigned char *) &args[argc];
483 arg = args, argc = 0;
485 /* Collect the tokens making up each argument. We don't yet know
486 how many arguments have been supplied, whether too many or too
487 few. Hence the slightly bizarre usage of "argc" and "arg". */
490 unsigned int paren_depth = 0;
491 unsigned int ntokens = 0;
494 arg->first = (const cpp_token **) buff->cur;
498 /* Require space for 2 new tokens (including a CPP_EOF). */
499 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
501 buff = _cpp_append_extend_buff (pfile, buff,
502 1000 * sizeof (cpp_token *));
503 arg->first = (const cpp_token **) buff->cur;
506 token = cpp_get_token (pfile);
508 if (token->type == CPP_PADDING)
510 /* Drop leading padding. */
514 else if (token->type == CPP_OPEN_PAREN)
516 else if (token->type == CPP_CLOSE_PAREN)
518 if (paren_depth-- == 0)
521 else if (token->type == CPP_COMMA)
523 /* A comma does not terminate an argument within
524 parentheses or as part of a variable argument. */
526 && ! (macro->variadic && argc == macro->paramc))
529 else if (token->type == CPP_EOF
530 || (token->type == CPP_HASH && token->flags & BOL))
533 arg->first[ntokens++] = token;
536 /* Drop trailing padding. */
537 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
540 arg->count = ntokens;
541 arg->first[ntokens] = &pfile->eof;
543 /* Terminate the argument. Excess arguments loop back and
544 overwrite the final legitimate argument, before failing. */
545 if (argc <= macro->paramc)
547 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
548 if (argc != macro->paramc)
552 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
554 if (token->type == CPP_EOF)
556 /* We still need the CPP_EOF to end directives, and to end
557 pre-expansion of a macro argument. Step back is not
558 unconditional, since we don't want to return a CPP_EOF to our
559 callers at the end of an -include-d file. */
560 if (pfile->context->prev || pfile->state.in_directive)
561 _cpp_backup_tokens (pfile, 1);
562 cpp_error (pfile, DL_ERROR,
563 "unterminated argument list invoking macro \"%s\"",
567 else if (argc < macro->paramc)
569 /* As an extension, a rest argument is allowed to not appear in
570 the invocation at all.
571 e.g. #define debug(format, args...) something
574 This is exactly the same as if there had been an empty rest
575 argument - debug("string", ). */
577 if (argc + 1 == macro->paramc && macro->variadic)
579 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
580 cpp_error (pfile, DL_PEDWARN,
581 "ISO C99 requires rest arguments to be used");
585 cpp_error (pfile, DL_ERROR,
586 "macro \"%s\" requires %u arguments, but only %u given",
587 NODE_NAME (node), macro->paramc, argc);
591 else if (argc > macro->paramc)
593 /* Empty argument to a macro taking no arguments is OK. */
594 if (argc != 1 || arg->count)
596 cpp_error (pfile, DL_ERROR,
597 "macro \"%s\" passed %u arguments, but takes just %u",
598 NODE_NAME (node), argc, macro->paramc);
606 _cpp_release_buff (pfile, base_buff);
610 /* Search for an opening parenthesis to the macro of NODE, in such a
611 way that, if none is found, we don't lose the information in any
612 intervening padding tokens. If we find the parenthesis, collect
613 the arguments and return the buffer containing them. */
615 funlike_invocation_p (pfile, node)
619 const cpp_token *token, *padding = NULL;
623 token = cpp_get_token (pfile);
624 if (token->type != CPP_PADDING)
627 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
631 if (token->type == CPP_OPEN_PAREN)
633 pfile->state.parsing_args = 2;
634 return collect_args (pfile, node);
637 /* CPP_EOF can be the end of macro arguments, or the end of the
638 file. We mustn't back up over the latter. Ugh. */
639 if (token->type != CPP_EOF || token == &pfile->eof)
641 /* Back up. We may have skipped padding, in which case backing
642 up more than one token when expanding macros is in general
643 too difficult. We re-insert it in its own context. */
644 _cpp_backup_tokens (pfile, 1);
646 push_token_context (pfile, NULL, padding, 1);
652 /* Push the context of a macro with hash entry NODE onto the context
653 stack. If we can successfully expand the macro, we push a context
654 containing its yet-to-be-rescanned replacement list and return one.
655 Otherwise, we don't push a context and return zero. */
657 enter_macro_context (pfile, node)
661 /* The presence of a macro invalidates a file's controlling macro. */
662 pfile->mi_valid = false;
664 pfile->state.angled_headers = false;
666 /* Handle standard macros. */
667 if (! (node->flags & NODE_BUILTIN))
669 cpp_macro *macro = node->value.macro;
675 pfile->state.prevent_expansion++;
676 pfile->keep_tokens++;
677 pfile->state.parsing_args = 1;
678 buff = funlike_invocation_p (pfile, node);
679 pfile->state.parsing_args = 0;
680 pfile->keep_tokens--;
681 pfile->state.prevent_expansion--;
685 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
686 cpp_error (pfile, DL_WARNING,
687 "function-like macro \"%s\" must be used with arguments in traditional C",
693 if (macro->paramc > 0)
694 replace_args (pfile, node, macro, (macro_arg *) buff->base);
695 _cpp_release_buff (pfile, buff);
698 /* Disable the macro within its expansion. */
699 node->flags |= NODE_DISABLED;
701 if (macro->paramc == 0)
702 push_token_context (pfile, node, macro->exp.tokens, macro->count);
707 /* Handle built-in macros and the _Pragma operator. */
708 return builtin_macro (pfile, node);
711 /* Replace the parameters in a function-like macro of NODE with the
712 actual ARGS, and place the result in a newly pushed token context.
713 Expand each argument before replacing, unless it is operated upon
714 by the # or ## operators. */
716 replace_args (pfile, node, macro, args)
722 unsigned int i, total;
723 const cpp_token *src, *limit;
724 const cpp_token **dest, **first;
728 /* First, fully macro-expand arguments, calculating the number of
729 tokens in the final expansion as we go. The ordering of the if
730 statements below is subtle; we must handle stringification before
732 total = macro->count;
733 limit = macro->exp.tokens + macro->count;
735 for (src = macro->exp.tokens; src < limit; src++)
736 if (src->type == CPP_MACRO_ARG)
738 /* Leading and trailing padding tokens. */
741 /* We have an argument. If it is not being stringified or
742 pasted it is macro-replaced before insertion. */
743 arg = &args[src->val.arg_no - 1];
745 if (src->flags & STRINGIFY_ARG)
747 if (!arg->stringified)
748 arg->stringified = stringify_arg (pfile, arg);
750 else if ((src->flags & PASTE_LEFT)
751 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
752 total += arg->count - 1;
756 expand_arg (pfile, arg);
757 total += arg->expanded_count - 1;
761 /* Now allocate space for the expansion, copy the tokens and replace
763 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
764 first = (const cpp_token **) buff->base;
767 for (src = macro->exp.tokens; src < limit; src++)
770 const cpp_token **from, **paste_flag;
772 if (src->type != CPP_MACRO_ARG)
779 arg = &args[src->val.arg_no - 1];
780 if (src->flags & STRINGIFY_ARG)
781 count = 1, from = &arg->stringified;
782 else if (src->flags & PASTE_LEFT)
783 count = arg->count, from = arg->first;
784 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
786 count = arg->count, from = arg->first;
789 /* GCC has special semantics for , ## b where b is a
790 varargs parameter: the comma disappears if b was
791 given no actual arguments (not merely if b is an
792 empty argument); otherwise the paste flag is removed. */
793 if (dest[-1]->type == CPP_COMMA
795 && src->val.arg_no == macro->paramc)
800 paste_flag = dest - 1;
802 /* Remove the paste flag if the RHS is a placemarker. */
804 paste_flag = dest - 1;
808 count = arg->expanded_count, from = arg->expanded;
810 /* Padding on the left of an argument (unless RHS of ##). */
811 if (!pfile->state.in_directive
812 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
813 *dest++ = padding_token (pfile, src);
817 memcpy (dest, from, count * sizeof (cpp_token *));
820 /* With a non-empty argument on the LHS of ##, the last
821 token should be flagged PASTE_LEFT. */
822 if (src->flags & PASTE_LEFT)
823 paste_flag = dest - 1;
826 /* Avoid paste on RHS (even case count == 0). */
827 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
828 *dest++ = &pfile->avoid_paste;
830 /* Add a new paste flag, or remove an unwanted one. */
833 cpp_token *token = _cpp_temp_token (pfile);
834 token->type = (*paste_flag)->type;
835 token->val.str = (*paste_flag)->val.str;
836 if (src->flags & PASTE_LEFT)
837 token->flags = (*paste_flag)->flags | PASTE_LEFT;
839 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
844 /* Free the expanded arguments. */
845 for (i = 0; i < macro->paramc; i++)
846 if (args[i].expanded)
847 free (args[i].expanded);
849 push_ptoken_context (pfile, node, buff, first, dest - first);
852 /* Return a special padding token, with padding inherited from SOURCE. */
853 static const cpp_token *
854 padding_token (pfile, source)
856 const cpp_token *source;
858 cpp_token *result = _cpp_temp_token (pfile);
860 result->type = CPP_PADDING;
861 result->val.source = source;
866 /* Get a new uninitialized context. Create a new one if we cannot
867 re-use an old one. */
872 cpp_context *result = pfile->context->next;
876 result = xnew (cpp_context);
877 result->prev = pfile->context;
879 pfile->context->next = result;
882 pfile->context = result;
886 /* Push a list of pointers to tokens. */
888 push_ptoken_context (pfile, macro, buff, first, count)
892 const cpp_token **first;
895 cpp_context *context = next_context (pfile);
897 context->direct_p = false;
898 context->macro = macro;
899 context->buff = buff;
900 FIRST (context).ptoken = first;
901 LAST (context).ptoken = first + count;
904 /* Push a list of tokens. */
906 push_token_context (pfile, macro, first, count)
909 const cpp_token *first;
912 cpp_context *context = next_context (pfile);
914 context->direct_p = true;
915 context->macro = macro;
916 context->buff = NULL;
917 FIRST (context).token = first;
918 LAST (context).token = first + count;
921 /* Push a traditional macro's replacement text. */
923 _cpp_push_text_context (pfile, macro, start, end)
926 const uchar *start, *end;
928 cpp_context *context = next_context (pfile);
930 context->direct_p = true;
931 context->macro = macro;
932 context->buff = NULL;
933 CUR (context) = start;
934 RLIMIT (context) = end;
937 /* Expand an argument ARG before replacing parameters in a
938 function-like macro. This works by pushing a context with the
939 argument's tokens, and then expanding that into a temporary buffer
940 as if it were a normal part of the token stream. collect_args()
941 has terminated the argument's tokens with a CPP_EOF so that we know
942 when we have fully expanded the argument. */
944 expand_arg (pfile, arg)
948 unsigned int capacity;
953 /* Loop, reading in the arguments. */
955 arg->expanded = (const cpp_token **)
956 xmalloc (capacity * sizeof (cpp_token *));
958 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
961 const cpp_token *token;
963 if (arg->expanded_count + 1 >= capacity)
966 arg->expanded = (const cpp_token **)
967 xrealloc (arg->expanded, capacity * sizeof (cpp_token *));
970 token = cpp_get_token (pfile);
972 if (token->type == CPP_EOF)
975 arg->expanded[arg->expanded_count++] = token;
978 _cpp_pop_context (pfile);
981 /* Pop the current context off the stack, re-enabling the macro if the
982 context represented a macro's replacement list. The context
983 structure is not freed so that we can re-use it later. */
985 _cpp_pop_context (pfile)
988 cpp_context *context = pfile->context;
991 context->macro->flags &= ~NODE_DISABLED;
994 _cpp_release_buff (pfile, context->buff);
996 pfile->context = context->prev;
999 /* Eternal routine to get a token. Also used nearly everywhere
1000 internally, except for places where we know we can safely call
1001 the lexer directly, such as lexing a directive name.
1003 Macro expansions and directives are transparently handled,
1004 including entering included files. Thus tokens are post-macro
1005 expansion, and after any intervening directives. External callers
1006 see CPP_EOF only at EOF. Internal callers also see it when meeting
1007 a directive inside a macro call, when at the end of a directive and
1008 state.in_directive is still 1, and at the end of argument
1011 cpp_get_token (pfile)
1014 const cpp_token *result;
1019 cpp_context *context = pfile->context;
1021 /* Context->prev == 0 <=> base context. */
1023 result = _cpp_lex_token (pfile);
1024 else if (FIRST (context).token != LAST (context).token)
1026 if (context->direct_p)
1027 result = FIRST (context).token++;
1029 result = *FIRST (context).ptoken++;
1031 if (result->flags & PASTE_LEFT)
1033 paste_all_tokens (pfile, result);
1034 if (pfile->state.in_directive)
1036 return padding_token (pfile, result);
1041 _cpp_pop_context (pfile);
1042 if (pfile->state.in_directive)
1044 return &pfile->avoid_paste;
1047 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1050 if (result->type != CPP_NAME)
1053 node = result->val.node;
1055 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1058 if (!(node->flags & NODE_DISABLED))
1060 if (!pfile->state.prevent_expansion
1061 && enter_macro_context (pfile, node))
1063 if (pfile->state.in_directive)
1065 return padding_token (pfile, result);
1070 /* Flag this token as always unexpandable. FIXME: move this
1071 to collect_args()?. */
1072 cpp_token *t = _cpp_temp_token (pfile);
1073 t->type = result->type;
1074 t->flags = result->flags | NO_EXPAND;
1075 t->val.str = result->val.str;
1085 /* Returns true if we're expanding an object-like macro that was
1086 defined in a system header. Just checks the macro at the top of
1087 the stack. Used for diagnostic suppression. */
1089 cpp_sys_macro_p (pfile)
1092 cpp_hashnode *node = pfile->context->macro;
1094 return node && node->value.macro && node->value.macro->syshdr;
1097 /* Read each token in, until end of the current file. Directives are
1098 transparently processed. */
1100 cpp_scan_nooutput (pfile)
1103 /* Request a CPP_EOF token at the end of this file, rather than
1104 transparently continuing with the including file. */
1105 pfile->buffer->return_at_eof = true;
1107 while (cpp_get_token (pfile)->type != CPP_EOF)
1111 /* Step back one (or more) tokens. Can only step mack more than 1 if
1112 they are from the lexer, and not from macro expansion. */
1114 _cpp_backup_tokens (pfile, count)
1118 if (pfile->context->prev == NULL)
1120 pfile->lookaheads += count;
1124 if (pfile->cur_token == pfile->cur_run->base
1125 /* Possible with -fpreprocessed and no leading #line. */
1126 && pfile->cur_run->prev != NULL)
1128 pfile->cur_run = pfile->cur_run->prev;
1129 pfile->cur_token = pfile->cur_run->limit;
1137 if (pfile->context->direct_p)
1138 FIRST (pfile->context).token--;
1140 FIRST (pfile->context).ptoken--;
1144 /* #define directive parsing and handling. */
1146 /* Returns non-zero if a macro redefinition warning is required. */
1148 warn_of_redefinition (pfile, node, macro2)
1150 const cpp_hashnode *node;
1151 const cpp_macro *macro2;
1153 const cpp_macro *macro1;
1156 /* Some redefinitions need to be warned about regardless. */
1157 if (node->flags & NODE_WARN)
1160 /* Redefinition of a macro is allowed if and only if the old and new
1161 definitions are the same. (6.10.3 paragraph 2). */
1162 macro1 = node->value.macro;
1164 /* The quick failures. */
1165 if (macro1->count != macro2->count
1166 || macro1->paramc != macro2->paramc
1167 || macro1->fun_like != macro2->fun_like
1168 || macro1->variadic != macro2->variadic)
1171 /* Check parameter spellings. */
1172 for (i = 0; i < macro1->paramc; i++)
1173 if (macro1->params[i] != macro2->params[i])
1176 /* Check the replacement text or tokens. */
1177 if (CPP_OPTION (pfile, traditional))
1178 return memcmp (macro1->exp.text, macro2->exp.text, macro1->count);
1180 for (i = 0; i < macro1->count; i++)
1181 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
1187 /* Free the definition of hashnode H. */
1189 _cpp_free_definition (h)
1192 /* Macros and assertions no longer have anything to free. */
1194 /* Clear builtin flag in case of redefinition. */
1195 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1198 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1199 zero on success, non-zero if the parameter is a duplicate. */
1201 save_parameter (pfile, macro, node)
1206 /* Constraint 6.10.3.6 - duplicate parameter names. */
1207 if (node->arg_index)
1209 cpp_error (pfile, DL_ERROR, "duplicate macro parameter \"%s\"",
1214 if (BUFF_ROOM (pfile->a_buff)
1215 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1216 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1218 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1219 node->arg_index = macro->paramc;
1223 /* Check the syntax of the parameters in a MACRO definition. */
1225 parse_params (pfile, macro)
1229 unsigned int prev_ident = 0;
1233 const cpp_token *token = _cpp_lex_token (pfile);
1235 switch (token->type)
1238 /* Allow/ignore comments in parameter lists if we are
1239 preserving comments in macro expansions. */
1240 if (token->type == CPP_COMMENT
1241 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1244 cpp_error (pfile, DL_ERROR,
1245 "\"%s\" may not appear in macro parameter list",
1246 cpp_token_as_text (pfile, token));
1252 cpp_error (pfile, DL_ERROR,
1253 "macro parameters must be comma-separated");
1258 if (save_parameter (pfile, macro, token->val.node))
1262 case CPP_CLOSE_PAREN:
1263 if (prev_ident || macro->paramc == 0)
1266 /* Fall through to pick up the error. */
1270 cpp_error (pfile, DL_ERROR, "parameter name missing");
1277 macro->variadic = 1;
1280 save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1281 pfile->state.va_args_ok = 1;
1282 if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1283 cpp_error (pfile, DL_PEDWARN,
1284 "anonymous variadic macros were introduced in C99");
1286 else if (CPP_OPTION (pfile, pedantic))
1287 cpp_error (pfile, DL_PEDWARN,
1288 "ISO C does not permit named variadic macros");
1290 /* We're at the end, and just expect a closing parenthesis. */
1291 token = _cpp_lex_token (pfile);
1292 if (token->type == CPP_CLOSE_PAREN)
1297 cpp_error (pfile, DL_ERROR, "missing ')' in macro parameter list");
1303 /* Allocate room for a token from a macro's replacement list. */
1305 alloc_expansion_token (pfile, macro)
1309 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1310 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1312 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1315 /* Lex a token from the expansion of MACRO, but mark parameters as we
1316 find them and warn of traditional stringification. */
1318 lex_expansion_token (pfile, macro)
1324 pfile->cur_token = alloc_expansion_token (pfile, macro);
1325 token = _cpp_lex_direct (pfile);
1327 /* Is this a parameter? */
1328 if (token->type == CPP_NAME && token->val.node->arg_index)
1330 token->type = CPP_MACRO_ARG;
1331 token->val.arg_no = token->val.node->arg_index;
1333 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1334 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1335 check_trad_stringification (pfile, macro, &token->val.str);
1341 create_iso_definition (pfile, macro)
1346 const cpp_token *ctoken;
1348 /* Get the first token of the expansion (or the '(' of a
1349 function-like macro). */
1350 ctoken = _cpp_lex_token (pfile);
1352 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1354 bool ok = parse_params (pfile, macro);
1355 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1359 /* Success. Commit the parameter array. */
1360 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
1361 macro->fun_like = 1;
1363 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1364 cpp_error (pfile, DL_PEDWARN,
1365 "ISO C requires whitespace after the macro name");
1367 if (macro->fun_like)
1368 token = lex_expansion_token (pfile, macro);
1371 token = alloc_expansion_token (pfile, macro);
1377 /* Check the stringifying # constraint 6.10.3.2.1 of
1378 function-like macros when lexing the subsequent token. */
1379 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1381 if (token->type == CPP_MACRO_ARG)
1383 token->flags &= ~PREV_WHITE;
1384 token->flags |= STRINGIFY_ARG;
1385 token->flags |= token[-1].flags & PREV_WHITE;
1386 token[-1] = token[0];
1389 /* Let assembler get away with murder. */
1390 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1392 cpp_error (pfile, DL_ERROR,
1393 "'#' is not followed by a macro parameter");
1398 if (token->type == CPP_EOF)
1401 /* Paste operator constraint 6.10.3.3.1. */
1402 if (token->type == CPP_PASTE)
1404 /* Token-paste ##, can appear in both object-like and
1405 function-like macros, but not at the ends. */
1406 if (--macro->count > 0)
1407 token = lex_expansion_token (pfile, macro);
1409 if (macro->count == 0 || token->type == CPP_EOF)
1411 cpp_error (pfile, DL_ERROR,
1412 "'##' cannot appear at either end of a macro expansion");
1416 token[-1].flags |= PASTE_LEFT;
1419 token = lex_expansion_token (pfile, macro);
1422 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1424 /* Don't count the CPP_EOF. */
1427 /* Clear whitespace on first token for warn_of_redefinition(). */
1429 macro->exp.tokens[0].flags &= ~PREV_WHITE;
1431 /* Commit the memory. */
1432 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
1437 /* Parse a macro and save its expansion. Returns non-zero on success. */
1439 _cpp_create_definition (pfile, node)
1447 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1448 macro->line = pfile->directive_line;
1451 macro->variadic = 0;
1453 macro->fun_like = 0;
1454 /* To suppress some diagnostics. */
1455 macro->syshdr = pfile->map->sysp != 0;
1457 if (CPP_OPTION (pfile, traditional))
1458 ok = _cpp_create_trad_definition (pfile, macro);
1461 cpp_token *saved_cur_token = pfile->cur_token;
1463 ok = create_iso_definition (pfile, macro);
1465 /* Restore lexer position because of games lex_expansion_token()
1466 plays lexing the macro. We set the type for SEEN_EOL() in
1469 Longer term we should lex the whole line before coming here,
1470 and just copy the expansion. */
1471 saved_cur_token[-1].type = pfile->cur_token[-1].type;
1472 pfile->cur_token = saved_cur_token;
1474 /* Stop the lexer accepting __VA_ARGS__. */
1475 pfile->state.va_args_ok = 0;
1478 /* Clear the fast argument lookup indices. */
1479 for (i = macro->paramc; i-- > 0; )
1480 macro->params[i]->arg_index = 0;
1485 if (node->type != NT_VOID)
1487 if (warn_of_redefinition (pfile, node, macro))
1489 cpp_error_with_line (pfile, DL_PEDWARN, pfile->directive_line, 0,
1490 "\"%s\" redefined", NODE_NAME (node));
1492 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1493 cpp_error_with_line (pfile, DL_PEDWARN,
1494 node->value.macro->line, 0,
1495 "this is the location of the previous definition");
1497 _cpp_free_definition (node);
1500 /* Enter definition in hash table. */
1501 node->type = NT_MACRO;
1502 node->value.macro = macro;
1503 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1504 node->flags |= NODE_WARN;
1509 /* Warn if a token in STRING matches one of a function-like MACRO's
1512 check_trad_stringification (pfile, macro, string)
1514 const cpp_macro *macro;
1515 const cpp_string *string;
1517 unsigned int i, len;
1518 const uchar *p, *q, *limit = string->text + string->len;
1520 /* Loop over the string. */
1521 for (p = string->text; p < limit; p = q)
1523 /* Find the start of an identifier. */
1524 while (p < limit && !is_idstart (*p))
1527 /* Find the end of the identifier. */
1529 while (q < limit && is_idchar (*q))
1534 /* Loop over the function macro arguments to see if the
1535 identifier inside the string matches one of them. */
1536 for (i = 0; i < macro->paramc; i++)
1538 const cpp_hashnode *node = macro->params[i];
1540 if (NODE_LEN (node) == len
1541 && !memcmp (p, NODE_NAME (node), len))
1543 cpp_error (pfile, DL_WARNING,
1544 "macro argument \"%s\" would be stringified in traditional C",
1552 /* Returns the name, arguments and expansion of a macro, in a format
1553 suitable to be read back in again, and therefore also for DWARF 2
1554 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1555 Caller is expected to generate the "#define" bit if needed. The
1556 returned text is temporary, and automatically freed later. */
1557 const unsigned char *
1558 cpp_macro_definition (pfile, node)
1560 const cpp_hashnode *node;
1562 unsigned int i, len;
1563 const cpp_macro *macro = node->value.macro;
1564 unsigned char *buffer;
1566 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1568 cpp_error (pfile, DL_ICE,
1569 "invalid hash type %d in cpp_macro_definition", node->type);
1573 /* Calculate length. */
1574 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
1575 if (macro->fun_like)
1577 len += 4; /* "()" plus possible final ".." of named
1578 varargs (we have + 1 below). */
1579 for (i = 0; i < macro->paramc; i++)
1580 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1583 for (i = 0; i < macro->count; i++)
1585 cpp_token *token = ¯o->exp.tokens[i];
1587 if (token->type == CPP_MACRO_ARG)
1588 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1590 len += cpp_token_len (token); /* Includes room for ' '. */
1591 if (token->flags & STRINGIFY_ARG)
1593 if (token->flags & PASTE_LEFT)
1594 len += 3; /* " ##" */
1597 if (len > pfile->macro_buffer_len)
1599 pfile->macro_buffer = (uchar *) xrealloc (pfile->macro_buffer, len);
1600 pfile->macro_buffer_len = len;
1603 /* Fill in the buffer. Start with the macro name. */
1604 buffer = pfile->macro_buffer;
1605 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1606 buffer += NODE_LEN (node);
1608 /* Parameter names. */
1609 if (macro->fun_like)
1612 for (i = 0; i < macro->paramc; i++)
1614 cpp_hashnode *param = macro->params[i];
1616 if (param != pfile->spec_nodes.n__VA_ARGS__)
1618 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1619 buffer += NODE_LEN (param);
1622 if (i + 1 < macro->paramc)
1623 /* Don't emit a space after the comma here; we're trying
1624 to emit a Dwarf-friendly definition, and the Dwarf spec
1625 forbids spaces in the argument list. */
1627 else if (macro->variadic)
1628 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1633 /* The Dwarf spec requires a space after the macro name, even if the
1634 definition is the empty string. */
1637 /* Expansion tokens. */
1640 for (i = 0; i < macro->count; i++)
1642 cpp_token *token = ¯o->exp.tokens[i];
1644 if (token->flags & PREV_WHITE)
1646 if (token->flags & STRINGIFY_ARG)
1649 if (token->type == CPP_MACRO_ARG)
1651 len = NODE_LEN (macro->params[token->val.arg_no - 1]);
1653 NODE_NAME (macro->params[token->val.arg_no - 1]), len);
1657 buffer = cpp_spell_token (pfile, token, buffer);
1659 if (token->flags & PASTE_LEFT)
1664 /* Next has PREV_WHITE; see _cpp_create_definition. */
1670 return pfile->macro_buffer;