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 *stringify_arg PARAMS ((cpp_reader *, macro_arg *));
58 static void paste_all_tokens PARAMS ((cpp_reader *, const cpp_token *));
59 static bool paste_tokens PARAMS ((cpp_reader *, const cpp_token **,
61 static void replace_args PARAMS ((cpp_reader *, cpp_hashnode *, cpp_macro *,
63 static _cpp_buff *funlike_invocation_p PARAMS ((cpp_reader *, cpp_hashnode *));
64 static bool create_iso_definition PARAMS ((cpp_reader *, cpp_macro *));
66 /* #define directive parsing and handling. */
68 static cpp_token *alloc_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
69 static cpp_token *lex_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
70 static bool warn_of_redefinition PARAMS ((cpp_reader *, const cpp_hashnode *,
72 static int parse_params PARAMS ((cpp_reader *, cpp_macro *));
73 static void check_trad_stringification PARAMS ((cpp_reader *,
77 /* Allocates and returns a CPP_STRING token, containing TEXT of length
78 LEN, after null-terminating it. TEXT must be in permanent storage. */
79 static const cpp_token *
80 new_string_token (pfile, text, len)
85 cpp_token *token = _cpp_temp_token (pfile);
88 token->type = CPP_STRING;
89 token->val.str.len = len;
90 token->val.str.text = text;
95 static const char * const monthnames[] =
97 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
98 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
101 /* Handle builtin macros like __FILE__, and push the resulting token
102 on the context stack. Also handles _Pragma, for which no new token
103 is created. Returns 1 if it generates a new token context, 0 to
104 return the token to the caller. */
106 _cpp_builtin_macro_text (pfile, node)
110 const uchar *result = NULL;
111 unsigned int number = 1;
113 switch (node->value.builtin)
116 cpp_error (pfile, DL_ICE, "invalid built-in macro \"%s\"",
126 const struct line_map *map = pfile->map;
128 if (node->value.builtin == BT_BASE_FILE)
129 while (! MAIN_FILE_P (map))
130 map = INCLUDED_FROM (&pfile->line_maps, map);
134 buf = _cpp_unaligned_alloc (pfile, len * 4 + 3);
137 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
143 case BT_INCLUDE_LEVEL:
144 /* The line map depth counts the primary source as level 1, but
145 historically __INCLUDE_DEPTH__ has called the primary source
147 number = pfile->line_maps.depth - 1;
151 /* If __LINE__ is embedded in a macro, it must expand to the
152 line of the macro's invocation, not its definition.
153 Otherwise things like assert() will not work properly. */
154 if (CPP_OPTION (pfile, traditional))
155 number = pfile->line;
157 number = pfile->cur_token[-1].line;
158 number = SOURCE_LINE (pfile->map, number);
161 /* __STDC__ has the value 1 under normal circumstances.
162 However, if (a) we are in a system header, (b) the option
163 stdc_0_in_system_headers is true (set by target config), and
164 (c) we are not in strictly conforming mode, then it has the
168 enum c_lang lang = CPP_OPTION (pfile, lang);
169 if (CPP_IN_SYSTEM_HEADER (pfile)
170 && CPP_OPTION (pfile, stdc_0_in_system_headers)
171 && !(lang == CLK_STDC89 || lang == CLK_STDC94
172 || lang == CLK_STDC99)) /* || lang == CLK_CXX98 ? */
181 if (pfile->date == NULL)
183 /* Allocate __DATE__ and __TIME__ strings from permanent
184 storage. We only do this once, and don't generate them
185 at init time, because time() and localtime() are very
186 slow on some systems. */
187 time_t tt = time (NULL);
188 struct tm *tb = localtime (&tt);
190 pfile->date = _cpp_unaligned_alloc (pfile,
191 sizeof ("\"Oct 11 1347\""));
192 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
193 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
195 pfile->time = _cpp_unaligned_alloc (pfile, sizeof ("\"12:34:56\""));
196 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
197 tb->tm_hour, tb->tm_min, tb->tm_sec);
200 if (node->value.builtin == BT_DATE)
201 result = pfile->date;
203 result = pfile->time;
209 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
210 result = _cpp_unaligned_alloc (pfile, 21);
211 sprintf ((char *) result, "%u", number);
217 /* Convert builtin macros like __FILE__ to a token and push it on the
218 context stack. Also handles _Pragma, for which no new token is
219 created. Returns 1 if it generates a new token context, 0 to
220 return the token to the caller. */
222 builtin_macro (pfile, node)
228 if (node->value.builtin == BT_PRAGMA)
230 /* Don't interpret _Pragma within directives. The standard is
231 not clear on this, but to me this makes most sense. */
232 if (pfile->state.in_directive)
235 _cpp_do__Pragma (pfile);
239 buf = _cpp_builtin_macro_text (pfile, node);
241 cpp_push_buffer (pfile, buf, ustrlen (buf), /* from_stage3 */ true, 1);
243 /* Tweak the column number the lexer will report. */
244 pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
246 /* We don't want a leading # to be interpreted as a directive. */
247 pfile->buffer->saved_flags = 0;
249 /* Set pfile->cur_token as required by _cpp_lex_direct. */
250 pfile->cur_token = _cpp_temp_token (pfile);
251 push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
252 if (pfile->buffer->cur != pfile->buffer->rlimit)
253 cpp_error (pfile, DL_ICE, "invalid built-in macro \"%s\"",
255 _cpp_pop_buffer (pfile);
260 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
261 backslashes and double quotes. Non-printable characters are
262 converted to octal. DEST must be of sufficient size. Returns
263 a pointer to the end of the string. */
265 cpp_quote_string (dest, src, len)
274 if (c == '\\' || c == '"')
285 sprintf ((char *) dest, "\\%03o", c);
294 /* Convert a token sequence ARG to a single string token according to
295 the rules of the ISO C #-operator. */
296 static const cpp_token *
297 stringify_arg (pfile, arg)
301 unsigned char *dest = BUFF_FRONT (pfile->u_buff);
302 unsigned int i, escape_it, backslash_count = 0;
303 const cpp_token *source = NULL;
306 /* Loop, reading in the argument's tokens. */
307 for (i = 0; i < arg->count; i++)
309 const cpp_token *token = arg->first[i];
311 if (token->type == CPP_PADDING)
314 source = token->val.source;
318 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
319 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
321 /* Room for each char being written in octal, initial space and
323 len = cpp_token_len (token);
328 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
330 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
331 _cpp_extend_buff (pfile, &pfile->u_buff, len);
332 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
335 /* Leading white space? */
336 if (dest != BUFF_FRONT (pfile->u_buff))
340 if (source->flags & PREV_WHITE)
347 _cpp_buff *buff = _cpp_get_buff (pfile, len);
348 unsigned char *buf = BUFF_FRONT (buff);
349 len = cpp_spell_token (pfile, token, buf) - buf;
350 dest = cpp_quote_string (dest, buf, len);
351 _cpp_release_buff (pfile, buff);
354 dest = cpp_spell_token (pfile, token, dest);
356 if (token->type == CPP_OTHER && token->val.c == '\\')
362 /* Ignore the final \ of invalid string literals. */
363 if (backslash_count & 1)
365 cpp_error (pfile, DL_WARNING,
366 "invalid string literal, ignoring final '\\'");
370 /* Commit the memory, including NUL, and return the token. */
371 len = dest - BUFF_FRONT (pfile->u_buff);
372 BUFF_FRONT (pfile->u_buff) = dest + 1;
373 return new_string_token (pfile, dest - len, len);
376 /* Try to paste two tokens. On success, return non-zero. In any
377 case, PLHS is updated to point to the pasted token, which is
378 guaranteed to not have the PASTE_LEFT flag set. */
380 paste_tokens (pfile, plhs, rhs)
382 const cpp_token **plhs, *rhs;
384 unsigned char *buf, *end;
385 const cpp_token *lhs;
390 len = cpp_token_len (lhs) + cpp_token_len (rhs) + 1;
391 buf = (unsigned char *) alloca (len);
392 end = cpp_spell_token (pfile, lhs, buf);
394 /* Avoid comment headers, since they are still processed in stage 3.
395 It is simpler to insert a space here, rather than modifying the
396 lexer to ignore comments in some circumstances. Simply returning
397 false doesn't work, since we want to clear the PASTE_LEFT flag. */
398 if (lhs->type == CPP_DIV
399 && (rhs->type == CPP_MULT || rhs->type == CPP_DIV))
401 end = cpp_spell_token (pfile, rhs, end);
404 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true, 1);
406 /* Tweak the column number the lexer will report. */
407 pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
409 /* We don't want a leading # to be interpreted as a directive. */
410 pfile->buffer->saved_flags = 0;
412 /* Set pfile->cur_token as required by _cpp_lex_direct. */
413 pfile->cur_token = _cpp_temp_token (pfile);
414 *plhs = _cpp_lex_direct (pfile);
415 valid = pfile->buffer->cur == pfile->buffer->rlimit;
416 _cpp_pop_buffer (pfile);
421 /* Handles an arbitrarily long sequence of ## operators, with initial
422 operand LHS. This implementation is left-associative,
423 non-recursive, and finishes a paste before handling succeeding
424 ones. If a paste fails, we back up to the RHS of the failing ##
425 operator before pushing the context containing the result of prior
426 successful pastes, with the effect that the RHS appears in the
427 output stream after the pasted LHS normally. */
429 paste_all_tokens (pfile, lhs)
431 const cpp_token *lhs;
433 const cpp_token *rhs;
434 cpp_context *context = pfile->context;
438 /* Take the token directly from the current context. We can do
439 this, because we are in the replacement list of either an
440 object-like macro, or a function-like macro with arguments
441 inserted. In either case, the constraints to #define
442 guarantee we have at least one more token. */
443 if (context->direct_p)
444 rhs = FIRST (context).token++;
446 rhs = *FIRST (context).ptoken++;
448 if (rhs->type == CPP_PADDING)
451 if (!paste_tokens (pfile, &lhs, rhs))
453 _cpp_backup_tokens (pfile, 1);
455 /* Mandatory error for all apart from assembler. */
456 if (CPP_OPTION (pfile, lang) != CLK_ASM)
457 cpp_error (pfile, DL_ERROR,
458 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
459 cpp_token_as_text (pfile, lhs),
460 cpp_token_as_text (pfile, rhs));
464 while (rhs->flags & PASTE_LEFT);
466 /* Put the resulting token in its own context. */
467 push_token_context (pfile, NULL, lhs, 1);
470 /* Returns TRUE if the number of arguments ARGC supplied in an
471 invocation of the MACRO referenced by NODE is valid. An empty
472 invocation to a macro with no parameters should pass ARGC as zero.
474 Note that MACRO cannot necessarily be deduced from NODE, in case
475 NODE was redefined whilst collecting arguments. */
477 _cpp_arguments_ok (pfile, macro, node, argc)
480 const cpp_hashnode *node;
483 if (argc == macro->paramc)
486 if (argc < macro->paramc)
488 /* As an extension, a rest argument is allowed to not appear in
489 the invocation at all.
490 e.g. #define debug(format, args...) something
493 This is exactly the same as if there had been an empty rest
494 argument - debug("string", ). */
496 if (argc + 1 == macro->paramc && macro->variadic)
498 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
499 cpp_error (pfile, DL_PEDWARN,
500 "ISO C99 requires rest arguments to be used");
504 cpp_error (pfile, DL_ERROR,
505 "macro \"%s\" requires %u arguments, but only %u given",
506 NODE_NAME (node), macro->paramc, argc);
509 cpp_error (pfile, DL_ERROR,
510 "macro \"%s\" passed %u arguments, but takes just %u",
511 NODE_NAME (node), argc, macro->paramc);
516 /* Reads and returns the arguments to a function-like macro
517 invocation. Assumes the opening parenthesis has been processed.
518 If there is an error, emits an appropriate diagnostic and returns
519 NULL. Each argument is terminated by a CPP_EOF token, for the
520 future benefit of expand_arg(). */
522 collect_args (pfile, node)
524 const cpp_hashnode *node;
526 _cpp_buff *buff, *base_buff;
528 macro_arg *args, *arg;
529 const cpp_token *token;
532 macro = node->value.macro;
534 argc = macro->paramc;
537 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
538 + sizeof (macro_arg)));
540 args = (macro_arg *) buff->base;
541 memset (args, 0, argc * sizeof (macro_arg));
542 buff->cur = (unsigned char *) &args[argc];
543 arg = args, argc = 0;
545 /* Collect the tokens making up each argument. We don't yet know
546 how many arguments have been supplied, whether too many or too
547 few. Hence the slightly bizarre usage of "argc" and "arg". */
550 unsigned int paren_depth = 0;
551 unsigned int ntokens = 0;
554 arg->first = (const cpp_token **) buff->cur;
558 /* Require space for 2 new tokens (including a CPP_EOF). */
559 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
561 buff = _cpp_append_extend_buff (pfile, buff,
562 1000 * sizeof (cpp_token *));
563 arg->first = (const cpp_token **) buff->cur;
566 token = cpp_get_token (pfile);
568 if (token->type == CPP_PADDING)
570 /* Drop leading padding. */
574 else if (token->type == CPP_OPEN_PAREN)
576 else if (token->type == CPP_CLOSE_PAREN)
578 if (paren_depth-- == 0)
581 else if (token->type == CPP_COMMA)
583 /* A comma does not terminate an argument within
584 parentheses or as part of a variable argument. */
586 && ! (macro->variadic && argc == macro->paramc))
589 else if (token->type == CPP_EOF
590 || (token->type == CPP_HASH && token->flags & BOL))
593 arg->first[ntokens++] = token;
596 /* Drop trailing padding. */
597 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
600 arg->count = ntokens;
601 arg->first[ntokens] = &pfile->eof;
603 /* Terminate the argument. Excess arguments loop back and
604 overwrite the final legitimate argument, before failing. */
605 if (argc <= macro->paramc)
607 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
608 if (argc != macro->paramc)
612 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
614 if (token->type == CPP_EOF)
616 /* We still need the CPP_EOF to end directives, and to end
617 pre-expansion of a macro argument. Step back is not
618 unconditional, since we don't want to return a CPP_EOF to our
619 callers at the end of an -include-d file. */
620 if (pfile->context->prev || pfile->state.in_directive)
621 _cpp_backup_tokens (pfile, 1);
622 cpp_error (pfile, DL_ERROR,
623 "unterminated argument list invoking macro \"%s\"",
628 /* A single empty argument is counted as no argument. */
629 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
631 if (_cpp_arguments_ok (pfile, macro, node, argc))
635 /* An error occurred. */
636 _cpp_release_buff (pfile, base_buff);
640 /* Search for an opening parenthesis to the macro of NODE, in such a
641 way that, if none is found, we don't lose the information in any
642 intervening padding tokens. If we find the parenthesis, collect
643 the arguments and return the buffer containing them. */
645 funlike_invocation_p (pfile, node)
649 const cpp_token *token, *padding = NULL;
653 token = cpp_get_token (pfile);
654 if (token->type != CPP_PADDING)
657 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
661 if (token->type == CPP_OPEN_PAREN)
663 pfile->state.parsing_args = 2;
664 return collect_args (pfile, node);
667 /* CPP_EOF can be the end of macro arguments, or the end of the
668 file. We mustn't back up over the latter. Ugh. */
669 if (token->type != CPP_EOF || token == &pfile->eof)
671 /* Back up. We may have skipped padding, in which case backing
672 up more than one token when expanding macros is in general
673 too difficult. We re-insert it in its own context. */
674 _cpp_backup_tokens (pfile, 1);
676 push_token_context (pfile, NULL, padding, 1);
682 /* Push the context of a macro with hash entry NODE onto the context
683 stack. If we can successfully expand the macro, we push a context
684 containing its yet-to-be-rescanned replacement list and return one.
685 Otherwise, we don't push a context and return zero. */
687 enter_macro_context (pfile, node)
691 /* The presence of a macro invalidates a file's controlling macro. */
692 pfile->mi_valid = false;
694 pfile->state.angled_headers = false;
696 /* Handle standard macros. */
697 if (! (node->flags & NODE_BUILTIN))
699 cpp_macro *macro = node->value.macro;
705 pfile->state.prevent_expansion++;
706 pfile->keep_tokens++;
707 pfile->state.parsing_args = 1;
708 buff = funlike_invocation_p (pfile, node);
709 pfile->state.parsing_args = 0;
710 pfile->keep_tokens--;
711 pfile->state.prevent_expansion--;
715 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
716 cpp_error (pfile, DL_WARNING,
717 "function-like macro \"%s\" must be used with arguments in traditional C",
723 if (macro->paramc > 0)
724 replace_args (pfile, node, macro, (macro_arg *) buff->base);
725 _cpp_release_buff (pfile, buff);
728 /* Disable the macro within its expansion. */
729 node->flags |= NODE_DISABLED;
731 if (macro->paramc == 0)
732 push_token_context (pfile, node, macro->exp.tokens, macro->count);
737 /* Handle built-in macros and the _Pragma operator. */
738 return builtin_macro (pfile, node);
741 /* Replace the parameters in a function-like macro of NODE with the
742 actual ARGS, and place the result in a newly pushed token context.
743 Expand each argument before replacing, unless it is operated upon
744 by the # or ## operators. */
746 replace_args (pfile, node, macro, args)
752 unsigned int i, total;
753 const cpp_token *src, *limit;
754 const cpp_token **dest, **first;
758 /* First, fully macro-expand arguments, calculating the number of
759 tokens in the final expansion as we go. The ordering of the if
760 statements below is subtle; we must handle stringification before
762 total = macro->count;
763 limit = macro->exp.tokens + macro->count;
765 for (src = macro->exp.tokens; src < limit; src++)
766 if (src->type == CPP_MACRO_ARG)
768 /* Leading and trailing padding tokens. */
771 /* We have an argument. If it is not being stringified or
772 pasted it is macro-replaced before insertion. */
773 arg = &args[src->val.arg_no - 1];
775 if (src->flags & STRINGIFY_ARG)
777 if (!arg->stringified)
778 arg->stringified = stringify_arg (pfile, arg);
780 else if ((src->flags & PASTE_LEFT)
781 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
782 total += arg->count - 1;
786 expand_arg (pfile, arg);
787 total += arg->expanded_count - 1;
791 /* Now allocate space for the expansion, copy the tokens and replace
793 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
794 first = (const cpp_token **) buff->base;
797 for (src = macro->exp.tokens; src < limit; src++)
800 const cpp_token **from, **paste_flag;
802 if (src->type != CPP_MACRO_ARG)
809 arg = &args[src->val.arg_no - 1];
810 if (src->flags & STRINGIFY_ARG)
811 count = 1, from = &arg->stringified;
812 else if (src->flags & PASTE_LEFT)
813 count = arg->count, from = arg->first;
814 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
816 count = arg->count, from = arg->first;
819 /* GCC has special semantics for , ## b where b is a
820 varargs parameter: the comma disappears if b was
821 given no actual arguments (not merely if b is an
822 empty argument); otherwise the paste flag is removed. */
823 if (dest[-1]->type == CPP_COMMA
825 && src->val.arg_no == macro->paramc)
830 paste_flag = dest - 1;
832 /* Remove the paste flag if the RHS is a placemarker. */
834 paste_flag = dest - 1;
838 count = arg->expanded_count, from = arg->expanded;
840 /* Padding on the left of an argument (unless RHS of ##). */
841 if (!pfile->state.in_directive
842 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
843 *dest++ = padding_token (pfile, src);
847 memcpy (dest, from, count * sizeof (cpp_token *));
850 /* With a non-empty argument on the LHS of ##, the last
851 token should be flagged PASTE_LEFT. */
852 if (src->flags & PASTE_LEFT)
853 paste_flag = dest - 1;
856 /* Avoid paste on RHS (even case count == 0). */
857 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
858 *dest++ = &pfile->avoid_paste;
860 /* Add a new paste flag, or remove an unwanted one. */
863 cpp_token *token = _cpp_temp_token (pfile);
864 token->type = (*paste_flag)->type;
865 token->val.str = (*paste_flag)->val.str;
866 if (src->flags & PASTE_LEFT)
867 token->flags = (*paste_flag)->flags | PASTE_LEFT;
869 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
874 /* Free the expanded arguments. */
875 for (i = 0; i < macro->paramc; i++)
876 if (args[i].expanded)
877 free (args[i].expanded);
879 push_ptoken_context (pfile, node, buff, first, dest - first);
882 /* Return a special padding token, with padding inherited from SOURCE. */
883 static const cpp_token *
884 padding_token (pfile, source)
886 const cpp_token *source;
888 cpp_token *result = _cpp_temp_token (pfile);
890 result->type = CPP_PADDING;
891 result->val.source = source;
896 /* Get a new uninitialized context. Create a new one if we cannot
897 re-use an old one. */
902 cpp_context *result = pfile->context->next;
906 result = xnew (cpp_context);
907 result->prev = pfile->context;
909 pfile->context->next = result;
912 pfile->context = result;
916 /* Push a list of pointers to tokens. */
918 push_ptoken_context (pfile, macro, buff, first, count)
922 const cpp_token **first;
925 cpp_context *context = next_context (pfile);
927 context->direct_p = false;
928 context->macro = macro;
929 context->buff = buff;
930 FIRST (context).ptoken = first;
931 LAST (context).ptoken = first + count;
934 /* Push a list of tokens. */
936 push_token_context (pfile, macro, first, count)
939 const cpp_token *first;
942 cpp_context *context = next_context (pfile);
944 context->direct_p = true;
945 context->macro = macro;
946 context->buff = NULL;
947 FIRST (context).token = first;
948 LAST (context).token = first + count;
951 /* Push a traditional macro's replacement text. */
953 _cpp_push_text_context (pfile, macro, start, len)
959 cpp_context *context = next_context (pfile);
961 context->direct_p = true;
962 context->macro = macro;
963 context->buff = NULL;
964 CUR (context) = start;
965 RLIMIT (context) = start + len;
966 macro->flags |= NODE_DISABLED;
969 /* Expand an argument ARG before replacing parameters in a
970 function-like macro. This works by pushing a context with the
971 argument's tokens, and then expanding that into a temporary buffer
972 as if it were a normal part of the token stream. collect_args()
973 has terminated the argument's tokens with a CPP_EOF so that we know
974 when we have fully expanded the argument. */
976 expand_arg (pfile, arg)
980 unsigned int capacity;
985 /* Loop, reading in the arguments. */
987 arg->expanded = (const cpp_token **)
988 xmalloc (capacity * sizeof (cpp_token *));
990 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
993 const cpp_token *token;
995 if (arg->expanded_count + 1 >= capacity)
998 arg->expanded = (const cpp_token **)
999 xrealloc (arg->expanded, capacity * sizeof (cpp_token *));
1002 token = cpp_get_token (pfile);
1004 if (token->type == CPP_EOF)
1007 arg->expanded[arg->expanded_count++] = token;
1010 _cpp_pop_context (pfile);
1013 /* Pop the current context off the stack, re-enabling the macro if the
1014 context represented a macro's replacement list. The context
1015 structure is not freed so that we can re-use it later. */
1017 _cpp_pop_context (pfile)
1020 cpp_context *context = pfile->context;
1023 context->macro->flags &= ~NODE_DISABLED;
1026 _cpp_release_buff (pfile, context->buff);
1028 pfile->context = context->prev;
1031 /* Eternal routine to get a token. Also used nearly everywhere
1032 internally, except for places where we know we can safely call
1033 the lexer directly, such as lexing a directive name.
1035 Macro expansions and directives are transparently handled,
1036 including entering included files. Thus tokens are post-macro
1037 expansion, and after any intervening directives. External callers
1038 see CPP_EOF only at EOF. Internal callers also see it when meeting
1039 a directive inside a macro call, when at the end of a directive and
1040 state.in_directive is still 1, and at the end of argument
1043 cpp_get_token (pfile)
1046 const cpp_token *result;
1051 cpp_context *context = pfile->context;
1053 /* Context->prev == 0 <=> base context. */
1055 result = _cpp_lex_token (pfile);
1056 else if (FIRST (context).token != LAST (context).token)
1058 if (context->direct_p)
1059 result = FIRST (context).token++;
1061 result = *FIRST (context).ptoken++;
1063 if (result->flags & PASTE_LEFT)
1065 paste_all_tokens (pfile, result);
1066 if (pfile->state.in_directive)
1068 return padding_token (pfile, result);
1073 _cpp_pop_context (pfile);
1074 if (pfile->state.in_directive)
1076 return &pfile->avoid_paste;
1079 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1082 if (result->type != CPP_NAME)
1085 node = result->val.node;
1087 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1090 if (!(node->flags & NODE_DISABLED))
1092 if (!pfile->state.prevent_expansion
1093 && enter_macro_context (pfile, node))
1095 if (pfile->state.in_directive)
1097 return padding_token (pfile, result);
1102 /* Flag this token as always unexpandable. FIXME: move this
1103 to collect_args()?. */
1104 cpp_token *t = _cpp_temp_token (pfile);
1105 t->type = result->type;
1106 t->flags = result->flags | NO_EXPAND;
1107 t->val.str = result->val.str;
1117 /* Returns true if we're expanding an object-like macro that was
1118 defined in a system header. Just checks the macro at the top of
1119 the stack. Used for diagnostic suppression. */
1121 cpp_sys_macro_p (pfile)
1124 cpp_hashnode *node = pfile->context->macro;
1126 return node && node->value.macro && node->value.macro->syshdr;
1129 /* Read each token in, until end of the current file. Directives are
1130 transparently processed. */
1132 cpp_scan_nooutput (pfile)
1135 /* Request a CPP_EOF token at the end of this file, rather than
1136 transparently continuing with the including file. */
1137 pfile->buffer->return_at_eof = true;
1139 if (CPP_OPTION (pfile, traditional))
1140 while (_cpp_read_logical_line_trad (pfile))
1143 while (cpp_get_token (pfile)->type != CPP_EOF)
1147 /* Step back one (or more) tokens. Can only step mack more than 1 if
1148 they are from the lexer, and not from macro expansion. */
1150 _cpp_backup_tokens (pfile, count)
1154 if (pfile->context->prev == NULL)
1156 pfile->lookaheads += count;
1160 if (pfile->cur_token == pfile->cur_run->base
1161 /* Possible with -fpreprocessed and no leading #line. */
1162 && pfile->cur_run->prev != NULL)
1164 pfile->cur_run = pfile->cur_run->prev;
1165 pfile->cur_token = pfile->cur_run->limit;
1173 if (pfile->context->direct_p)
1174 FIRST (pfile->context).token--;
1176 FIRST (pfile->context).ptoken--;
1180 /* #define directive parsing and handling. */
1182 /* Returns non-zero if a macro redefinition warning is required. */
1184 warn_of_redefinition (pfile, node, macro2)
1186 const cpp_hashnode *node;
1187 const cpp_macro *macro2;
1189 const cpp_macro *macro1;
1192 /* Some redefinitions need to be warned about regardless. */
1193 if (node->flags & NODE_WARN)
1196 /* Redefinition of a macro is allowed if and only if the old and new
1197 definitions are the same. (6.10.3 paragraph 2). */
1198 macro1 = node->value.macro;
1200 /* Don't check count here as it can be different in valid
1201 traditional redefinitions with just whitespace differences. */
1202 if (macro1->paramc != macro2->paramc
1203 || macro1->fun_like != macro2->fun_like
1204 || macro1->variadic != macro2->variadic)
1207 /* Check parameter spellings. */
1208 for (i = 0; i < macro1->paramc; i++)
1209 if (macro1->params[i] != macro2->params[i])
1212 /* Check the replacement text or tokens. */
1213 if (CPP_OPTION (pfile, traditional))
1214 return _cpp_expansions_different_trad (macro1, macro2);
1216 if (macro1->count == macro2->count)
1217 for (i = 0; i < macro1->count; i++)
1218 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
1224 /* Free the definition of hashnode H. */
1226 _cpp_free_definition (h)
1229 /* Macros and assertions no longer have anything to free. */
1231 /* Clear builtin flag in case of redefinition. */
1232 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1235 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1236 zero on success, non-zero if the parameter is a duplicate. */
1238 _cpp_save_parameter (pfile, macro, node)
1243 /* Constraint 6.10.3.6 - duplicate parameter names. */
1244 if (node->arg_index)
1246 cpp_error (pfile, DL_ERROR, "duplicate macro parameter \"%s\"",
1251 if (BUFF_ROOM (pfile->a_buff)
1252 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1253 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1255 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1256 node->arg_index = macro->paramc;
1260 /* Check the syntax of the parameters in a MACRO definition. */
1262 parse_params (pfile, macro)
1266 unsigned int prev_ident = 0;
1270 const cpp_token *token = _cpp_lex_token (pfile);
1272 switch (token->type)
1275 /* Allow/ignore comments in parameter lists if we are
1276 preserving comments in macro expansions. */
1277 if (token->type == CPP_COMMENT
1278 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1281 cpp_error (pfile, DL_ERROR,
1282 "\"%s\" may not appear in macro parameter list",
1283 cpp_token_as_text (pfile, token));
1289 cpp_error (pfile, DL_ERROR,
1290 "macro parameters must be comma-separated");
1295 if (_cpp_save_parameter (pfile, macro, token->val.node))
1299 case CPP_CLOSE_PAREN:
1300 if (prev_ident || macro->paramc == 0)
1303 /* Fall through to pick up the error. */
1307 cpp_error (pfile, DL_ERROR, "parameter name missing");
1314 macro->variadic = 1;
1317 _cpp_save_parameter (pfile, macro,
1318 pfile->spec_nodes.n__VA_ARGS__);
1319 pfile->state.va_args_ok = 1;
1320 if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1321 cpp_error (pfile, DL_PEDWARN,
1322 "anonymous variadic macros were introduced in C99");
1324 else if (CPP_OPTION (pfile, pedantic))
1325 cpp_error (pfile, DL_PEDWARN,
1326 "ISO C does not permit named variadic macros");
1328 /* We're at the end, and just expect a closing parenthesis. */
1329 token = _cpp_lex_token (pfile);
1330 if (token->type == CPP_CLOSE_PAREN)
1335 cpp_error (pfile, DL_ERROR, "missing ')' in macro parameter list");
1341 /* Allocate room for a token from a macro's replacement list. */
1343 alloc_expansion_token (pfile, macro)
1347 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1348 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1350 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1353 /* Lex a token from the expansion of MACRO, but mark parameters as we
1354 find them and warn of traditional stringification. */
1356 lex_expansion_token (pfile, macro)
1362 pfile->cur_token = alloc_expansion_token (pfile, macro);
1363 token = _cpp_lex_direct (pfile);
1365 /* Is this a parameter? */
1366 if (token->type == CPP_NAME && token->val.node->arg_index)
1368 token->type = CPP_MACRO_ARG;
1369 token->val.arg_no = token->val.node->arg_index;
1371 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1372 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1373 check_trad_stringification (pfile, macro, &token->val.str);
1379 create_iso_definition (pfile, macro)
1384 const cpp_token *ctoken;
1386 /* Get the first token of the expansion (or the '(' of a
1387 function-like macro). */
1388 ctoken = _cpp_lex_token (pfile);
1390 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1392 bool ok = parse_params (pfile, macro);
1393 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1397 /* Success. Commit the parameter array. */
1398 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
1399 macro->fun_like = 1;
1401 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1402 cpp_error (pfile, DL_PEDWARN,
1403 "ISO C requires whitespace after the macro name");
1405 if (macro->fun_like)
1406 token = lex_expansion_token (pfile, macro);
1409 token = alloc_expansion_token (pfile, macro);
1415 /* Check the stringifying # constraint 6.10.3.2.1 of
1416 function-like macros when lexing the subsequent token. */
1417 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1419 if (token->type == CPP_MACRO_ARG)
1421 token->flags &= ~PREV_WHITE;
1422 token->flags |= STRINGIFY_ARG;
1423 token->flags |= token[-1].flags & PREV_WHITE;
1424 token[-1] = token[0];
1427 /* Let assembler get away with murder. */
1428 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1430 cpp_error (pfile, DL_ERROR,
1431 "'#' is not followed by a macro parameter");
1436 if (token->type == CPP_EOF)
1439 /* Paste operator constraint 6.10.3.3.1. */
1440 if (token->type == CPP_PASTE)
1442 /* Token-paste ##, can appear in both object-like and
1443 function-like macros, but not at the ends. */
1444 if (--macro->count > 0)
1445 token = lex_expansion_token (pfile, macro);
1447 if (macro->count == 0 || token->type == CPP_EOF)
1449 cpp_error (pfile, DL_ERROR,
1450 "'##' cannot appear at either end of a macro expansion");
1454 token[-1].flags |= PASTE_LEFT;
1457 token = lex_expansion_token (pfile, macro);
1460 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1462 /* Don't count the CPP_EOF. */
1465 /* Clear whitespace on first token for warn_of_redefinition(). */
1467 macro->exp.tokens[0].flags &= ~PREV_WHITE;
1469 /* Commit the memory. */
1470 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
1475 /* Parse a macro and save its expansion. Returns non-zero on success. */
1477 _cpp_create_definition (pfile, node)
1485 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1486 macro->line = pfile->directive_line;
1489 macro->variadic = 0;
1491 macro->fun_like = 0;
1492 /* To suppress some diagnostics. */
1493 macro->syshdr = pfile->map->sysp != 0;
1495 if (CPP_OPTION (pfile, traditional))
1496 ok = _cpp_create_trad_definition (pfile, macro);
1499 cpp_token *saved_cur_token = pfile->cur_token;
1501 ok = create_iso_definition (pfile, macro);
1503 /* Restore lexer position because of games lex_expansion_token()
1504 plays lexing the macro. We set the type for SEEN_EOL() in
1507 Longer term we should lex the whole line before coming here,
1508 and just copy the expansion. */
1509 saved_cur_token[-1].type = pfile->cur_token[-1].type;
1510 pfile->cur_token = saved_cur_token;
1512 /* Stop the lexer accepting __VA_ARGS__. */
1513 pfile->state.va_args_ok = 0;
1516 /* Clear the fast argument lookup indices. */
1517 for (i = macro->paramc; i-- > 0; )
1518 macro->params[i]->arg_index = 0;
1523 if (node->type != NT_VOID)
1525 if (warn_of_redefinition (pfile, node, macro))
1527 cpp_error_with_line (pfile, DL_PEDWARN, pfile->directive_line, 0,
1528 "\"%s\" redefined", NODE_NAME (node));
1530 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1531 cpp_error_with_line (pfile, DL_PEDWARN,
1532 node->value.macro->line, 0,
1533 "this is the location of the previous definition");
1535 _cpp_free_definition (node);
1538 /* Enter definition in hash table. */
1539 node->type = NT_MACRO;
1540 node->value.macro = macro;
1541 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1542 node->flags |= NODE_WARN;
1547 /* Warn if a token in STRING matches one of a function-like MACRO's
1550 check_trad_stringification (pfile, macro, string)
1552 const cpp_macro *macro;
1553 const cpp_string *string;
1555 unsigned int i, len;
1556 const uchar *p, *q, *limit = string->text + string->len;
1558 /* Loop over the string. */
1559 for (p = string->text; p < limit; p = q)
1561 /* Find the start of an identifier. */
1562 while (p < limit && !is_idstart (*p))
1565 /* Find the end of the identifier. */
1567 while (q < limit && is_idchar (*q))
1572 /* Loop over the function macro arguments to see if the
1573 identifier inside the string matches one of them. */
1574 for (i = 0; i < macro->paramc; i++)
1576 const cpp_hashnode *node = macro->params[i];
1578 if (NODE_LEN (node) == len
1579 && !memcmp (p, NODE_NAME (node), len))
1581 cpp_error (pfile, DL_WARNING,
1582 "macro argument \"%s\" would be stringified in traditional C",
1590 /* Returns the name, arguments and expansion of a macro, in a format
1591 suitable to be read back in again, and therefore also for DWARF 2
1592 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1593 Caller is expected to generate the "#define" bit if needed. The
1594 returned text is temporary, and automatically freed later. */
1595 const unsigned char *
1596 cpp_macro_definition (pfile, node)
1598 const cpp_hashnode *node;
1600 unsigned int i, len;
1601 const cpp_macro *macro = node->value.macro;
1602 unsigned char *buffer;
1604 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1606 cpp_error (pfile, DL_ICE,
1607 "invalid hash type %d in cpp_macro_definition", node->type);
1611 /* Calculate length. */
1612 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
1613 if (macro->fun_like)
1615 len += 4; /* "()" plus possible final ".." of named
1616 varargs (we have + 1 below). */
1617 for (i = 0; i < macro->paramc; i++)
1618 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1621 if (CPP_OPTION (pfile, traditional))
1622 len += _cpp_replacement_text_len (macro);
1625 for (i = 0; i < macro->count; i++)
1627 cpp_token *token = ¯o->exp.tokens[i];
1629 if (token->type == CPP_MACRO_ARG)
1630 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1632 len += cpp_token_len (token); /* Includes room for ' '. */
1633 if (token->flags & STRINGIFY_ARG)
1635 if (token->flags & PASTE_LEFT)
1636 len += 3; /* " ##" */
1640 if (len > pfile->macro_buffer_len)
1642 pfile->macro_buffer = (uchar *) xrealloc (pfile->macro_buffer, len);
1643 pfile->macro_buffer_len = len;
1646 /* Fill in the buffer. Start with the macro name. */
1647 buffer = pfile->macro_buffer;
1648 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1649 buffer += NODE_LEN (node);
1651 /* Parameter names. */
1652 if (macro->fun_like)
1655 for (i = 0; i < macro->paramc; i++)
1657 cpp_hashnode *param = macro->params[i];
1659 if (param != pfile->spec_nodes.n__VA_ARGS__)
1661 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1662 buffer += NODE_LEN (param);
1665 if (i + 1 < macro->paramc)
1666 /* Don't emit a space after the comma here; we're trying
1667 to emit a Dwarf-friendly definition, and the Dwarf spec
1668 forbids spaces in the argument list. */
1670 else if (macro->variadic)
1671 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1676 /* The Dwarf spec requires a space after the macro name, even if the
1677 definition is the empty string. */
1680 if (CPP_OPTION (pfile, traditional))
1681 buffer = _cpp_copy_replacement_text (macro, buffer);
1682 else if (macro->count)
1683 /* Expansion tokens. */
1685 for (i = 0; i < macro->count; i++)
1687 cpp_token *token = ¯o->exp.tokens[i];
1689 if (token->flags & PREV_WHITE)
1691 if (token->flags & STRINGIFY_ARG)
1694 if (token->type == CPP_MACRO_ARG)
1696 len = NODE_LEN (macro->params[token->val.arg_no - 1]);
1698 NODE_NAME (macro->params[token->val.arg_no - 1]), len);
1702 buffer = cpp_spell_token (pfile, token, buffer);
1704 if (token->flags & PASTE_LEFT)
1709 /* Next has PREV_WHITE; see _cpp_create_definition. */
1715 return pfile->macro_buffer;