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, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 (cpp_reader *, cpp_hashnode *);
44 static int builtin_macro (cpp_reader *, cpp_hashnode *);
45 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
46 const cpp_token **, unsigned int);
47 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *);
48 static cpp_context *next_context (cpp_reader *);
49 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
50 static void expand_arg (cpp_reader *, macro_arg *);
51 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
52 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
53 static void paste_all_tokens (cpp_reader *, const cpp_token *);
54 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
55 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
57 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *);
58 static bool create_iso_definition (cpp_reader *, cpp_macro *);
60 /* #define directive parsing and handling. */
62 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
63 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
64 static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,
66 static bool parse_params (cpp_reader *, cpp_macro *);
67 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
70 /* Emits a warning if NODE is a macro defined in the main file that
73 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
74 void *v ATTRIBUTE_UNUSED)
76 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
78 cpp_macro *macro = node->value.macro;
81 && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
82 cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
83 "macro \"%s\" is not used", NODE_NAME (node));
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 (cpp_reader *pfile, unsigned char *text, unsigned int len)
94 cpp_token *token = _cpp_temp_token (pfile);
97 token->type = CPP_STRING;
98 token->val.str.len = len;
99 token->val.str.text = text;
104 static const char * const monthnames[] =
106 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
107 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
110 /* Helper function for builtin_macro. Returns the text generated by
113 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
115 const struct line_map *map;
116 const uchar *result = NULL;
117 unsigned int number = 1;
119 switch (node->value.builtin)
122 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
128 cpp_buffer *pbuffer = cpp_get_buffer (pfile);
129 if (pbuffer->timestamp == NULL)
131 /* Initialize timestamp value of the assotiated file. */
132 struct _cpp_file *file = cpp_get_file (pbuffer);
135 /* Generate __TIMESTAMP__ string, that represents
136 the date and time of the last modification
137 of the current source file. The string constant
138 looks like "Sun Sep 16 01:03:52 1973". */
139 struct tm *tb = NULL;
140 struct stat *st = _cpp_get_file_stat (file);
142 tb = localtime (&st->st_mtime);
145 char *str = asctime (tb);
146 size_t len = strlen (str);
147 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
149 strcpy ((char *) buf + 1, str);
151 pbuffer->timestamp = buf;
155 cpp_errno (pfile, CPP_DL_WARNING,
156 "could not determine file timestamp");
157 pbuffer->timestamp = U"\"??? ??? ?? ??:??:?? ????\"";
161 result = pbuffer->timestamp;
170 map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
172 if (node->value.builtin == BT_BASE_FILE)
173 while (! MAIN_FILE_P (map))
174 map = INCLUDED_FROM (pfile->line_table, map);
178 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
181 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
187 case BT_INCLUDE_LEVEL:
188 /* The line map depth counts the primary source as level 1, but
189 historically __INCLUDE_DEPTH__ has called the primary source
191 number = pfile->line_table->depth - 1;
195 map = &pfile->line_table->maps[pfile->line_table->used-1];
196 /* If __LINE__ is embedded in a macro, it must expand to the
197 line of the macro's invocation, not its definition.
198 Otherwise things like assert() will not work properly. */
199 if (CPP_OPTION (pfile, traditional))
200 number = pfile->line_table->highest_line;
202 number = pfile->cur_token[-1].src_loc;
203 number = SOURCE_LINE (map, number);
206 /* __STDC__ has the value 1 under normal circumstances.
207 However, if (a) we are in a system header, (b) the option
208 stdc_0_in_system_headers is true (set by target config), and
209 (c) we are not in strictly conforming mode, then it has the
210 value 0. (b) and (c) are already checked in cpp_init_builtins. */
212 if (cpp_in_system_header (pfile))
220 if (pfile->date == NULL)
222 /* Allocate __DATE__ and __TIME__ strings from permanent
223 storage. We only do this once, and don't generate them
224 at init time, because time() and localtime() are very
225 slow on some systems. */
227 struct tm *tb = NULL;
229 /* (time_t) -1 is a legitimate value for "number of seconds
230 since the Epoch", so we have to do a little dance to
231 distinguish that from a genuine error. */
234 if (tt != (time_t)-1 || errno == 0)
235 tb = localtime (&tt);
239 pfile->date = _cpp_unaligned_alloc (pfile,
240 sizeof ("\"Oct 11 1347\""));
241 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
242 monthnames[tb->tm_mon], tb->tm_mday,
245 pfile->time = _cpp_unaligned_alloc (pfile,
246 sizeof ("\"12:34:56\""));
247 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
248 tb->tm_hour, tb->tm_min, tb->tm_sec);
252 cpp_errno (pfile, CPP_DL_WARNING,
253 "could not determine date and time");
255 pfile->date = U"\"??? ?? ????\"";
256 pfile->time = U"\"??:??:??\"";
260 if (node->value.builtin == BT_DATE)
261 result = pfile->date;
263 result = pfile->time;
267 number = pfile->nextcounter++;
273 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
274 result = _cpp_unaligned_alloc (pfile, 21);
275 sprintf ((char *) result, "%u", number);
281 /* Convert builtin macros like __FILE__ to a token and push it on the
282 context stack. Also handles _Pragma, for which a new token may not
283 be created. Returns 1 if it generates a new token context, 0 to
284 return the token to the caller. */
286 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
292 if (node->value.builtin == BT_PRAGMA)
294 /* Don't interpret _Pragma within directives. The standard is
295 not clear on this, but to me this makes most sense. */
296 if (pfile->state.in_directive)
299 _cpp_do__Pragma (pfile);
303 buf = _cpp_builtin_macro_text (pfile, node);
305 nbuf = (char *) alloca (len + 1);
306 memcpy (nbuf, buf, len);
309 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
310 _cpp_clean_line (pfile);
312 /* Set pfile->cur_token as required by _cpp_lex_direct. */
313 pfile->cur_token = _cpp_temp_token (pfile);
314 _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
315 if (pfile->buffer->cur != pfile->buffer->rlimit)
316 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
318 _cpp_pop_buffer (pfile);
323 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
324 backslashes and double quotes. DEST must be of sufficient size.
325 Returns a pointer to the end of the string. */
327 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
333 if (c == '\\' || c == '"')
345 /* Convert a token sequence ARG to a single string token according to
346 the rules of the ISO C #-operator. */
347 static const cpp_token *
348 stringify_arg (cpp_reader *pfile, macro_arg *arg)
351 unsigned int i, escape_it, backslash_count = 0;
352 const cpp_token *source = NULL;
355 if (BUFF_ROOM (pfile->u_buff) < 3)
356 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
357 dest = BUFF_FRONT (pfile->u_buff);
360 /* Loop, reading in the argument's tokens. */
361 for (i = 0; i < arg->count; i++)
363 const cpp_token *token = arg->first[i];
365 if (token->type == CPP_PADDING)
368 source = token->val.source;
372 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
373 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
375 /* Room for each char being written in octal, initial space and
376 final quote and NUL. */
377 len = cpp_token_len (token);
382 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
384 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
385 _cpp_extend_buff (pfile, &pfile->u_buff, len);
386 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
389 /* Leading white space? */
390 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
394 if (source->flags & PREV_WHITE)
401 _cpp_buff *buff = _cpp_get_buff (pfile, len);
402 unsigned char *buf = BUFF_FRONT (buff);
403 len = cpp_spell_token (pfile, token, buf, true) - buf;
404 dest = cpp_quote_string (dest, buf, len);
405 _cpp_release_buff (pfile, buff);
408 dest = cpp_spell_token (pfile, token, dest, true);
410 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
416 /* Ignore the final \ of invalid string literals. */
417 if (backslash_count & 1)
419 cpp_error (pfile, CPP_DL_WARNING,
420 "invalid string literal, ignoring final '\\'");
424 /* Commit the memory, including NUL, and return the token. */
426 len = dest - BUFF_FRONT (pfile->u_buff);
427 BUFF_FRONT (pfile->u_buff) = dest + 1;
428 return new_string_token (pfile, dest - len, len);
431 /* Try to paste two tokens. On success, return nonzero. In any
432 case, PLHS is updated to point to the pasted token, which is
433 guaranteed to not have the PASTE_LEFT flag set. */
435 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
437 unsigned char *buf, *end, *lhsend;
438 const cpp_token *lhs;
442 len = cpp_token_len (lhs) + cpp_token_len (rhs) + 1;
443 buf = (unsigned char *) alloca (len);
444 end = lhsend = cpp_spell_token (pfile, lhs, buf, false);
446 /* Avoid comment headers, since they are still processed in stage 3.
447 It is simpler to insert a space here, rather than modifying the
448 lexer to ignore comments in some circumstances. Simply returning
449 false doesn't work, since we want to clear the PASTE_LEFT flag. */
450 if (lhs->type == CPP_DIV && rhs->type != CPP_EQ)
452 end = cpp_spell_token (pfile, rhs, end, false);
455 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
456 _cpp_clean_line (pfile);
458 /* Set pfile->cur_token as required by _cpp_lex_direct. */
459 pfile->cur_token = _cpp_temp_token (pfile);
460 *plhs = _cpp_lex_direct (pfile);
461 if (pfile->buffer->cur != pfile->buffer->rlimit)
463 _cpp_pop_buffer (pfile);
464 _cpp_backup_tokens (pfile, 1);
467 /* Mandatory error for all apart from assembler. */
468 if (CPP_OPTION (pfile, lang) != CLK_ASM)
469 cpp_error (pfile, CPP_DL_ERROR,
470 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
471 buf, cpp_token_as_text (pfile, rhs));
475 _cpp_pop_buffer (pfile);
479 /* Handles an arbitrarily long sequence of ## operators, with initial
480 operand LHS. This implementation is left-associative,
481 non-recursive, and finishes a paste before handling succeeding
482 ones. If a paste fails, we back up to the RHS of the failing ##
483 operator before pushing the context containing the result of prior
484 successful pastes, with the effect that the RHS appears in the
485 output stream after the pasted LHS normally. */
487 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
489 const cpp_token *rhs;
490 cpp_context *context = pfile->context;
494 /* Take the token directly from the current context. We can do
495 this, because we are in the replacement list of either an
496 object-like macro, or a function-like macro with arguments
497 inserted. In either case, the constraints to #define
498 guarantee we have at least one more token. */
499 if (context->direct_p)
500 rhs = FIRST (context).token++;
502 rhs = *FIRST (context).ptoken++;
504 if (rhs->type == CPP_PADDING)
507 if (!paste_tokens (pfile, &lhs, rhs))
510 while (rhs->flags & PASTE_LEFT);
512 /* Put the resulting token in its own context. */
513 _cpp_push_token_context (pfile, NULL, lhs, 1);
516 /* Returns TRUE if the number of arguments ARGC supplied in an
517 invocation of the MACRO referenced by NODE is valid. An empty
518 invocation to a macro with no parameters should pass ARGC as zero.
520 Note that MACRO cannot necessarily be deduced from NODE, in case
521 NODE was redefined whilst collecting arguments. */
523 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
525 if (argc == macro->paramc)
528 if (argc < macro->paramc)
530 /* As an extension, a rest argument is allowed to not appear in
531 the invocation at all.
532 e.g. #define debug(format, args...) something
535 This is exactly the same as if there had been an empty rest
536 argument - debug("string", ). */
538 if (argc + 1 == macro->paramc && macro->variadic)
540 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
541 cpp_error (pfile, CPP_DL_PEDWARN,
542 "ISO C99 requires rest arguments to be used");
546 cpp_error (pfile, CPP_DL_ERROR,
547 "macro \"%s\" requires %u arguments, but only %u given",
548 NODE_NAME (node), macro->paramc, argc);
551 cpp_error (pfile, CPP_DL_ERROR,
552 "macro \"%s\" passed %u arguments, but takes just %u",
553 NODE_NAME (node), argc, macro->paramc);
558 /* Reads and returns the arguments to a function-like macro
559 invocation. Assumes the opening parenthesis has been processed.
560 If there is an error, emits an appropriate diagnostic and returns
561 NULL. Each argument is terminated by a CPP_EOF token, for the
562 future benefit of expand_arg(). */
564 collect_args (cpp_reader *pfile, const cpp_hashnode *node)
566 _cpp_buff *buff, *base_buff;
568 macro_arg *args, *arg;
569 const cpp_token *token;
572 macro = node->value.macro;
574 argc = macro->paramc;
577 buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
578 + sizeof (macro_arg)));
580 args = (macro_arg *) buff->base;
581 memset (args, 0, argc * sizeof (macro_arg));
582 buff->cur = (unsigned char *) &args[argc];
583 arg = args, argc = 0;
585 /* Collect the tokens making up each argument. We don't yet know
586 how many arguments have been supplied, whether too many or too
587 few. Hence the slightly bizarre usage of "argc" and "arg". */
590 unsigned int paren_depth = 0;
591 unsigned int ntokens = 0;
594 arg->first = (const cpp_token **) buff->cur;
598 /* Require space for 2 new tokens (including a CPP_EOF). */
599 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
601 buff = _cpp_append_extend_buff (pfile, buff,
602 1000 * sizeof (cpp_token *));
603 arg->first = (const cpp_token **) buff->cur;
606 token = cpp_get_token (pfile);
608 if (token->type == CPP_PADDING)
610 /* Drop leading padding. */
614 else if (token->type == CPP_OPEN_PAREN)
616 else if (token->type == CPP_CLOSE_PAREN)
618 if (paren_depth-- == 0)
621 else if (token->type == CPP_COMMA)
623 /* A comma does not terminate an argument within
624 parentheses or as part of a variable argument. */
626 && ! (macro->variadic && argc == macro->paramc))
629 else if (token->type == CPP_EOF
630 || (token->type == CPP_HASH && token->flags & BOL))
633 arg->first[ntokens++] = token;
636 /* Drop trailing padding. */
637 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
640 arg->count = ntokens;
641 arg->first[ntokens] = &pfile->eof;
643 /* Terminate the argument. Excess arguments loop back and
644 overwrite the final legitimate argument, before failing. */
645 if (argc <= macro->paramc)
647 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
648 if (argc != macro->paramc)
652 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
654 if (token->type == CPP_EOF)
656 /* We still need the CPP_EOF to end directives, and to end
657 pre-expansion of a macro argument. Step back is not
658 unconditional, since we don't want to return a CPP_EOF to our
659 callers at the end of an -include-d file. */
660 if (pfile->context->prev || pfile->state.in_directive)
661 _cpp_backup_tokens (pfile, 1);
662 cpp_error (pfile, CPP_DL_ERROR,
663 "unterminated argument list invoking macro \"%s\"",
668 /* A single empty argument is counted as no argument. */
669 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
671 if (_cpp_arguments_ok (pfile, macro, node, argc))
673 /* GCC has special semantics for , ## b where b is a varargs
674 parameter: we remove the comma if b was omitted entirely.
675 If b was merely an empty argument, the comma is retained.
676 If the macro takes just one (varargs) parameter, then we
677 retain the comma only if we are standards conforming.
679 If FIRST is NULL replace_args () swallows the comma. */
680 if (macro->variadic && (argc < macro->paramc
681 || (argc == 1 && args[0].count == 0
682 && !CPP_OPTION (pfile, std))))
683 args[macro->paramc - 1].first = NULL;
688 /* An error occurred. */
689 _cpp_release_buff (pfile, base_buff);
693 /* Search for an opening parenthesis to the macro of NODE, in such a
694 way that, if none is found, we don't lose the information in any
695 intervening padding tokens. If we find the parenthesis, collect
696 the arguments and return the buffer containing them. */
698 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node)
700 const cpp_token *token, *padding = NULL;
704 token = cpp_get_token (pfile);
705 if (token->type != CPP_PADDING)
708 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
712 if (token->type == CPP_OPEN_PAREN)
714 pfile->state.parsing_args = 2;
715 return collect_args (pfile, node);
718 /* CPP_EOF can be the end of macro arguments, or the end of the
719 file. We mustn't back up over the latter. Ugh. */
720 if (token->type != CPP_EOF || token == &pfile->eof)
722 /* Back up. We may have skipped padding, in which case backing
723 up more than one token when expanding macros is in general
724 too difficult. We re-insert it in its own context. */
725 _cpp_backup_tokens (pfile, 1);
727 _cpp_push_token_context (pfile, NULL, padding, 1);
733 /* Push the context of a macro with hash entry NODE onto the context
734 stack. If we can successfully expand the macro, we push a context
735 containing its yet-to-be-rescanned replacement list and return one.
736 Otherwise, we don't push a context and return zero. */
738 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node)
740 /* The presence of a macro invalidates a file's controlling macro. */
741 pfile->mi_valid = false;
743 pfile->state.angled_headers = false;
745 /* Handle standard macros. */
746 if (! (node->flags & NODE_BUILTIN))
748 cpp_macro *macro = node->value.macro;
754 pfile->state.prevent_expansion++;
755 pfile->keep_tokens++;
756 pfile->state.parsing_args = 1;
757 buff = funlike_invocation_p (pfile, node);
758 pfile->state.parsing_args = 0;
759 pfile->keep_tokens--;
760 pfile->state.prevent_expansion--;
764 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
765 cpp_error (pfile, CPP_DL_WARNING,
766 "function-like macro \"%s\" must be used with arguments in traditional C",
772 if (macro->paramc > 0)
773 replace_args (pfile, node, macro, (macro_arg *) buff->base);
774 _cpp_release_buff (pfile, buff);
777 /* Disable the macro within its expansion. */
778 node->flags |= NODE_DISABLED;
782 if (macro->paramc == 0)
783 _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
788 /* Handle built-in macros and the _Pragma operator. */
789 return builtin_macro (pfile, node);
792 /* Replace the parameters in a function-like macro of NODE with the
793 actual ARGS, and place the result in a newly pushed token context.
794 Expand each argument before replacing, unless it is operated upon
795 by the # or ## operators. */
797 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
799 unsigned int i, total;
800 const cpp_token *src, *limit;
801 const cpp_token **dest, **first;
805 /* First, fully macro-expand arguments, calculating the number of
806 tokens in the final expansion as we go. The ordering of the if
807 statements below is subtle; we must handle stringification before
809 total = macro->count;
810 limit = macro->exp.tokens + macro->count;
812 for (src = macro->exp.tokens; src < limit; src++)
813 if (src->type == CPP_MACRO_ARG)
815 /* Leading and trailing padding tokens. */
818 /* We have an argument. If it is not being stringified or
819 pasted it is macro-replaced before insertion. */
820 arg = &args[src->val.arg_no - 1];
822 if (src->flags & STRINGIFY_ARG)
824 if (!arg->stringified)
825 arg->stringified = stringify_arg (pfile, arg);
827 else if ((src->flags & PASTE_LEFT)
828 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
829 total += arg->count - 1;
833 expand_arg (pfile, arg);
834 total += arg->expanded_count - 1;
838 /* Now allocate space for the expansion, copy the tokens and replace
840 buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
841 first = (const cpp_token **) buff->base;
844 for (src = macro->exp.tokens; src < limit; src++)
847 const cpp_token **from, **paste_flag;
849 if (src->type != CPP_MACRO_ARG)
856 arg = &args[src->val.arg_no - 1];
857 if (src->flags & STRINGIFY_ARG)
858 count = 1, from = &arg->stringified;
859 else if (src->flags & PASTE_LEFT)
860 count = arg->count, from = arg->first;
861 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
863 count = arg->count, from = arg->first;
866 if (dest[-1]->type == CPP_COMMA
868 && src->val.arg_no == macro->paramc)
870 /* Swallow a pasted comma if from == NULL, otherwise
871 drop the paste flag. */
875 paste_flag = dest - 1;
877 /* Remove the paste flag if the RHS is a placemarker. */
879 paste_flag = dest - 1;
883 count = arg->expanded_count, from = arg->expanded;
885 /* Padding on the left of an argument (unless RHS of ##). */
886 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
887 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
888 *dest++ = padding_token (pfile, src);
892 memcpy (dest, from, count * sizeof (cpp_token *));
895 /* With a non-empty argument on the LHS of ##, the last
896 token should be flagged PASTE_LEFT. */
897 if (src->flags & PASTE_LEFT)
898 paste_flag = dest - 1;
901 /* Avoid paste on RHS (even case count == 0). */
902 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
903 *dest++ = &pfile->avoid_paste;
905 /* Add a new paste flag, or remove an unwanted one. */
908 cpp_token *token = _cpp_temp_token (pfile);
909 token->type = (*paste_flag)->type;
910 token->val = (*paste_flag)->val;
911 if (src->flags & PASTE_LEFT)
912 token->flags = (*paste_flag)->flags | PASTE_LEFT;
914 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
919 /* Free the expanded arguments. */
920 for (i = 0; i < macro->paramc; i++)
921 if (args[i].expanded)
922 free (args[i].expanded);
924 push_ptoken_context (pfile, node, buff, first, dest - first);
927 /* Return a special padding token, with padding inherited from SOURCE. */
928 static const cpp_token *
929 padding_token (cpp_reader *pfile, const cpp_token *source)
931 cpp_token *result = _cpp_temp_token (pfile);
933 result->type = CPP_PADDING;
935 /* Data in GCed data structures cannot be made const so far, so we
937 result->val.source = (cpp_token *) source;
942 /* Get a new uninitialized context. Create a new one if we cannot
943 re-use an old one. */
945 next_context (cpp_reader *pfile)
947 cpp_context *result = pfile->context->next;
951 result = XNEW (cpp_context);
952 result->prev = pfile->context;
954 pfile->context->next = result;
957 pfile->context = result;
961 /* Push a list of pointers to tokens. */
963 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
964 const cpp_token **first, unsigned int count)
966 cpp_context *context = next_context (pfile);
968 context->direct_p = false;
969 context->macro = macro;
970 context->buff = buff;
971 FIRST (context).ptoken = first;
972 LAST (context).ptoken = first + count;
975 /* Push a list of tokens. */
977 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
978 const cpp_token *first, unsigned int count)
980 cpp_context *context = next_context (pfile);
982 context->direct_p = true;
983 context->macro = macro;
984 context->buff = NULL;
985 FIRST (context).token = first;
986 LAST (context).token = first + count;
989 /* Push a traditional macro's replacement text. */
991 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
992 const uchar *start, size_t len)
994 cpp_context *context = next_context (pfile);
996 context->direct_p = true;
997 context->macro = macro;
998 context->buff = NULL;
999 CUR (context) = start;
1000 RLIMIT (context) = start + len;
1001 macro->flags |= NODE_DISABLED;
1004 /* Expand an argument ARG before replacing parameters in a
1005 function-like macro. This works by pushing a context with the
1006 argument's tokens, and then expanding that into a temporary buffer
1007 as if it were a normal part of the token stream. collect_args()
1008 has terminated the argument's tokens with a CPP_EOF so that we know
1009 when we have fully expanded the argument. */
1011 expand_arg (cpp_reader *pfile, macro_arg *arg)
1013 unsigned int capacity;
1014 bool saved_warn_trad;
1016 if (arg->count == 0)
1019 /* Don't warn about funlike macros when pre-expanding. */
1020 saved_warn_trad = CPP_WTRADITIONAL (pfile);
1021 CPP_WTRADITIONAL (pfile) = 0;
1023 /* Loop, reading in the arguments. */
1025 arg->expanded = XNEWVEC (const cpp_token *, capacity);
1027 push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1030 const cpp_token *token;
1032 if (arg->expanded_count + 1 >= capacity)
1035 arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1039 token = cpp_get_token (pfile);
1041 if (token->type == CPP_EOF)
1044 arg->expanded[arg->expanded_count++] = token;
1047 _cpp_pop_context (pfile);
1049 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1052 /* Pop the current context off the stack, re-enabling the macro if the
1053 context represented a macro's replacement list. The context
1054 structure is not freed so that we can re-use it later. */
1056 _cpp_pop_context (cpp_reader *pfile)
1058 cpp_context *context = pfile->context;
1061 context->macro->flags &= ~NODE_DISABLED;
1064 _cpp_release_buff (pfile, context->buff);
1066 pfile->context = context->prev;
1069 /* External routine to get a token. Also used nearly everywhere
1070 internally, except for places where we know we can safely call
1071 _cpp_lex_token directly, such as lexing a directive name.
1073 Macro expansions and directives are transparently handled,
1074 including entering included files. Thus tokens are post-macro
1075 expansion, and after any intervening directives. External callers
1076 see CPP_EOF only at EOF. Internal callers also see it when meeting
1077 a directive inside a macro call, when at the end of a directive and
1078 state.in_directive is still 1, and at the end of argument
1081 cpp_get_token (cpp_reader *pfile)
1083 const cpp_token *result;
1088 cpp_context *context = pfile->context;
1090 /* Context->prev == 0 <=> base context. */
1092 result = _cpp_lex_token (pfile);
1093 else if (FIRST (context).token != LAST (context).token)
1095 if (context->direct_p)
1096 result = FIRST (context).token++;
1098 result = *FIRST (context).ptoken++;
1100 if (result->flags & PASTE_LEFT)
1102 paste_all_tokens (pfile, result);
1103 if (pfile->state.in_directive)
1105 return padding_token (pfile, result);
1110 _cpp_pop_context (pfile);
1111 if (pfile->state.in_directive)
1113 return &pfile->avoid_paste;
1116 if (pfile->state.in_directive && result->type == CPP_COMMENT)
1119 if (result->type != CPP_NAME)
1122 node = result->val.node;
1124 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1127 if (!(node->flags & NODE_DISABLED))
1129 if (!pfile->state.prevent_expansion
1130 && enter_macro_context (pfile, node))
1132 if (pfile->state.in_directive)
1134 return padding_token (pfile, result);
1139 /* Flag this token as always unexpandable. FIXME: move this
1140 to collect_args()?. */
1141 cpp_token *t = _cpp_temp_token (pfile);
1142 t->type = result->type;
1143 t->flags = result->flags | NO_EXPAND;
1144 t->val = result->val;
1154 /* Returns true if we're expanding an object-like macro that was
1155 defined in a system header. Just checks the macro at the top of
1156 the stack. Used for diagnostic suppression. */
1158 cpp_sys_macro_p (cpp_reader *pfile)
1160 cpp_hashnode *node = pfile->context->macro;
1162 return node && node->value.macro && node->value.macro->syshdr;
1165 /* Read each token in, until end of the current file. Directives are
1166 transparently processed. */
1168 cpp_scan_nooutput (cpp_reader *pfile)
1170 /* Request a CPP_EOF token at the end of this file, rather than
1171 transparently continuing with the including file. */
1172 pfile->buffer->return_at_eof = true;
1174 pfile->state.discarding_output++;
1175 pfile->state.prevent_expansion++;
1177 if (CPP_OPTION (pfile, traditional))
1178 while (_cpp_read_logical_line_trad (pfile))
1181 while (cpp_get_token (pfile)->type != CPP_EOF)
1184 pfile->state.discarding_output--;
1185 pfile->state.prevent_expansion--;
1188 /* Step back one (or more) tokens. Can only step back more than 1 if
1189 they are from the lexer, and not from macro expansion. */
1191 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1193 if (pfile->context->prev == NULL)
1195 pfile->lookaheads += count;
1199 if (pfile->cur_token == pfile->cur_run->base
1200 /* Possible with -fpreprocessed and no leading #line. */
1201 && pfile->cur_run->prev != NULL)
1203 pfile->cur_run = pfile->cur_run->prev;
1204 pfile->cur_token = pfile->cur_run->limit;
1212 if (pfile->context->direct_p)
1213 FIRST (pfile->context).token--;
1215 FIRST (pfile->context).ptoken--;
1219 /* #define directive parsing and handling. */
1221 /* Returns nonzero if a macro redefinition warning is required. */
1223 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1224 const cpp_macro *macro2)
1226 const cpp_macro *macro1;
1229 /* Some redefinitions need to be warned about regardless. */
1230 if (node->flags & NODE_WARN)
1233 /* Redefinition of a macro is allowed if and only if the old and new
1234 definitions are the same. (6.10.3 paragraph 2). */
1235 macro1 = node->value.macro;
1237 /* Don't check count here as it can be different in valid
1238 traditional redefinitions with just whitespace differences. */
1239 if (macro1->paramc != macro2->paramc
1240 || macro1->fun_like != macro2->fun_like
1241 || macro1->variadic != macro2->variadic)
1244 /* Check parameter spellings. */
1245 for (i = 0; i < macro1->paramc; i++)
1246 if (macro1->params[i] != macro2->params[i])
1249 /* Check the replacement text or tokens. */
1250 if (CPP_OPTION (pfile, traditional))
1251 return _cpp_expansions_different_trad (macro1, macro2);
1253 if (macro1->count != macro2->count)
1256 for (i = 0; i < macro1->count; i++)
1257 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
1263 /* Free the definition of hashnode H. */
1265 _cpp_free_definition (cpp_hashnode *h)
1267 /* Macros and assertions no longer have anything to free. */
1269 /* Clear builtin flag in case of redefinition. */
1270 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1273 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1274 zero on success, nonzero if the parameter is a duplicate. */
1276 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1279 /* Constraint 6.10.3.6 - duplicate parameter names. */
1280 if (node->flags & NODE_MACRO_ARG)
1282 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1287 if (BUFF_ROOM (pfile->a_buff)
1288 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1289 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1291 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1292 node->flags |= NODE_MACRO_ARG;
1293 len = macro->paramc * sizeof (union _cpp_hashnode_value);
1294 if (len > pfile->macro_buffer_len)
1296 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1298 pfile->macro_buffer_len = len;
1300 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1303 node->value.arg_index = macro->paramc;
1307 /* Check the syntax of the parameters in a MACRO definition. Returns
1308 false if an error occurs. */
1310 parse_params (cpp_reader *pfile, cpp_macro *macro)
1312 unsigned int prev_ident = 0;
1316 const cpp_token *token = _cpp_lex_token (pfile);
1318 switch (token->type)
1321 /* Allow/ignore comments in parameter lists if we are
1322 preserving comments in macro expansions. */
1323 if (token->type == CPP_COMMENT
1324 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1327 cpp_error (pfile, CPP_DL_ERROR,
1328 "\"%s\" may not appear in macro parameter list",
1329 cpp_token_as_text (pfile, token));
1335 cpp_error (pfile, CPP_DL_ERROR,
1336 "macro parameters must be comma-separated");
1341 if (_cpp_save_parameter (pfile, macro, token->val.node))
1345 case CPP_CLOSE_PAREN:
1346 if (prev_ident || macro->paramc == 0)
1349 /* Fall through to pick up the error. */
1353 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1360 macro->variadic = 1;
1363 _cpp_save_parameter (pfile, macro,
1364 pfile->spec_nodes.n__VA_ARGS__);
1365 pfile->state.va_args_ok = 1;
1366 if (! CPP_OPTION (pfile, c99)
1367 && CPP_OPTION (pfile, pedantic)
1368 && CPP_OPTION (pfile, warn_variadic_macros))
1369 cpp_error (pfile, CPP_DL_PEDWARN,
1370 "anonymous variadic macros were introduced in C99");
1372 else if (CPP_OPTION (pfile, pedantic)
1373 && CPP_OPTION (pfile, warn_variadic_macros))
1374 cpp_error (pfile, CPP_DL_PEDWARN,
1375 "ISO C does not permit named variadic macros");
1377 /* We're at the end, and just expect a closing parenthesis. */
1378 token = _cpp_lex_token (pfile);
1379 if (token->type == CPP_CLOSE_PAREN)
1384 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1390 /* Allocate room for a token from a macro's replacement list. */
1392 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1394 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1395 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1397 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1400 /* Lex a token from the expansion of MACRO, but mark parameters as we
1401 find them and warn of traditional stringification. */
1403 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1407 pfile->cur_token = alloc_expansion_token (pfile, macro);
1408 token = _cpp_lex_direct (pfile);
1410 /* Is this a parameter? */
1411 if (token->type == CPP_NAME
1412 && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1414 token->type = CPP_MACRO_ARG;
1415 token->val.arg_no = token->val.node->value.arg_index;
1417 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1418 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1419 check_trad_stringification (pfile, macro, &token->val.str);
1425 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1428 const cpp_token *ctoken;
1430 /* Get the first token of the expansion (or the '(' of a
1431 function-like macro). */
1432 ctoken = _cpp_lex_token (pfile);
1434 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1436 bool ok = parse_params (pfile, macro);
1437 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1441 /* Success. Commit or allocate the parameter array. */
1442 if (pfile->hash_table->alloc_subobject)
1444 cpp_hashnode **params =
1445 (cpp_hashnode **) pfile->hash_table->alloc_subobject
1446 (sizeof (cpp_hashnode *) * macro->paramc);
1447 memcpy (params, macro->params,
1448 sizeof (cpp_hashnode *) * macro->paramc);
1449 macro->params = params;
1452 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
1453 macro->fun_like = 1;
1455 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1457 /* While ISO C99 requires whitespace before replacement text
1458 in a macro definition, ISO C90 with TC1 allows there characters
1459 from the basic source character set. */
1460 if (CPP_OPTION (pfile, c99))
1461 cpp_error (pfile, CPP_DL_PEDWARN,
1462 "ISO C99 requires whitespace after the macro name");
1465 int warntype = CPP_DL_WARNING;
1466 switch (ctoken->type)
1470 case CPP_OBJC_STRING:
1471 /* '@' is not in basic character set. */
1472 warntype = CPP_DL_PEDWARN;
1475 /* Basic character set sans letters, digits and _. */
1476 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1477 ctoken->val.str.text[0]) == NULL)
1478 warntype = CPP_DL_PEDWARN;
1481 /* All other tokens start with a character from basic
1485 cpp_error (pfile, warntype,
1486 "missing whitespace after the macro name");
1490 if (macro->fun_like)
1491 token = lex_expansion_token (pfile, macro);
1494 token = alloc_expansion_token (pfile, macro);
1500 /* Check the stringifying # constraint 6.10.3.2.1 of
1501 function-like macros when lexing the subsequent token. */
1502 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1504 if (token->type == CPP_MACRO_ARG)
1506 token->flags &= ~PREV_WHITE;
1507 token->flags |= STRINGIFY_ARG;
1508 token->flags |= token[-1].flags & PREV_WHITE;
1509 token[-1] = token[0];
1512 /* Let assembler get away with murder. */
1513 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1515 cpp_error (pfile, CPP_DL_ERROR,
1516 "'#' is not followed by a macro parameter");
1521 if (token->type == CPP_EOF)
1524 /* Paste operator constraint 6.10.3.3.1. */
1525 if (token->type == CPP_PASTE)
1527 /* Token-paste ##, can appear in both object-like and
1528 function-like macros, but not at the ends. */
1529 if (--macro->count > 0)
1530 token = lex_expansion_token (pfile, macro);
1532 if (macro->count == 0 || token->type == CPP_EOF)
1534 cpp_error (pfile, CPP_DL_ERROR,
1535 "'##' cannot appear at either end of a macro expansion");
1539 token[-1].flags |= PASTE_LEFT;
1542 token = lex_expansion_token (pfile, macro);
1545 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1546 macro->traditional = 0;
1548 /* Don't count the CPP_EOF. */
1551 /* Clear whitespace on first token for warn_of_redefinition(). */
1553 macro->exp.tokens[0].flags &= ~PREV_WHITE;
1555 /* Commit or allocate the memory. */
1556 if (pfile->hash_table->alloc_subobject)
1559 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1561 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1562 macro->exp.tokens = tokns;
1565 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
1570 /* Parse a macro and save its expansion. Returns nonzero on success. */
1572 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1578 if (pfile->hash_table->alloc_subobject)
1579 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1580 (sizeof (cpp_macro));
1582 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1583 macro->line = pfile->directive_line;
1586 macro->variadic = 0;
1587 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1589 macro->fun_like = 0;
1590 /* To suppress some diagnostics. */
1591 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1593 if (CPP_OPTION (pfile, traditional))
1594 ok = _cpp_create_trad_definition (pfile, macro);
1597 cpp_token *saved_cur_token = pfile->cur_token;
1599 ok = create_iso_definition (pfile, macro);
1601 /* Restore lexer position because of games lex_expansion_token()
1602 plays lexing the macro. We set the type for SEEN_EOL() in
1605 Longer term we should lex the whole line before coming here,
1606 and just copy the expansion. */
1607 saved_cur_token[-1].type = pfile->cur_token[-1].type;
1608 pfile->cur_token = saved_cur_token;
1610 /* Stop the lexer accepting __VA_ARGS__. */
1611 pfile->state.va_args_ok = 0;
1614 /* Clear the fast argument lookup indices. */
1615 for (i = macro->paramc; i-- > 0; )
1617 struct cpp_hashnode *node = macro->params[i];
1618 node->flags &= ~ NODE_MACRO_ARG;
1619 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1625 if (node->type == NT_MACRO)
1627 if (CPP_OPTION (pfile, warn_unused_macros))
1628 _cpp_warn_if_unused_macro (pfile, node, NULL);
1630 if (warn_of_redefinition (pfile, node, macro))
1632 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1633 "\"%s\" redefined", NODE_NAME (node));
1635 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1636 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1637 node->value.macro->line, 0,
1638 "this is the location of the previous definition");
1642 if (node->type != NT_VOID)
1643 _cpp_free_definition (node);
1645 /* Enter definition in hash table. */
1646 node->type = NT_MACRO;
1647 node->value.macro = macro;
1648 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1649 node->flags |= NODE_WARN;
1654 /* Warn if a token in STRING matches one of a function-like MACRO's
1657 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1658 const cpp_string *string)
1660 unsigned int i, len;
1661 const uchar *p, *q, *limit;
1663 /* Loop over the string. */
1664 limit = string->text + string->len - 1;
1665 for (p = string->text + 1; p < limit; p = q)
1667 /* Find the start of an identifier. */
1668 while (p < limit && !is_idstart (*p))
1671 /* Find the end of the identifier. */
1673 while (q < limit && is_idchar (*q))
1678 /* Loop over the function macro arguments to see if the
1679 identifier inside the string matches one of them. */
1680 for (i = 0; i < macro->paramc; i++)
1682 const cpp_hashnode *node = macro->params[i];
1684 if (NODE_LEN (node) == len
1685 && !memcmp (p, NODE_NAME (node), len))
1687 cpp_error (pfile, CPP_DL_WARNING,
1688 "macro argument \"%s\" would be stringified in traditional C",
1696 /* Returns the name, arguments and expansion of a macro, in a format
1697 suitable to be read back in again, and therefore also for DWARF 2
1698 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1699 Caller is expected to generate the "#define" bit if needed. The
1700 returned text is temporary, and automatically freed later. */
1701 const unsigned char *
1702 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1704 unsigned int i, len;
1705 const cpp_macro *macro = node->value.macro;
1706 unsigned char *buffer;
1708 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1710 cpp_error (pfile, CPP_DL_ICE,
1711 "invalid hash type %d in cpp_macro_definition", node->type);
1715 /* Calculate length. */
1716 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
1717 if (macro->fun_like)
1719 len += 4; /* "()" plus possible final ".." of named
1720 varargs (we have + 1 below). */
1721 for (i = 0; i < macro->paramc; i++)
1722 len += NODE_LEN (macro->params[i]) + 1; /* "," */
1725 /* This should match below where we fill in the buffer. */
1726 if (CPP_OPTION (pfile, traditional))
1727 len += _cpp_replacement_text_len (macro);
1730 for (i = 0; i < macro->count; i++)
1732 cpp_token *token = ¯o->exp.tokens[i];
1734 if (token->type == CPP_MACRO_ARG)
1735 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1737 len += cpp_token_len (token);
1739 if (token->flags & STRINGIFY_ARG)
1741 if (token->flags & PASTE_LEFT)
1742 len += 3; /* " ##" */
1743 if (token->flags & PREV_WHITE)
1748 if (len > pfile->macro_buffer_len)
1750 pfile->macro_buffer = XRESIZEVEC (unsigned char,
1751 pfile->macro_buffer, len);
1752 pfile->macro_buffer_len = len;
1755 /* Fill in the buffer. Start with the macro name. */
1756 buffer = pfile->macro_buffer;
1757 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1758 buffer += NODE_LEN (node);
1760 /* Parameter names. */
1761 if (macro->fun_like)
1764 for (i = 0; i < macro->paramc; i++)
1766 cpp_hashnode *param = macro->params[i];
1768 if (param != pfile->spec_nodes.n__VA_ARGS__)
1770 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1771 buffer += NODE_LEN (param);
1774 if (i + 1 < macro->paramc)
1775 /* Don't emit a space after the comma here; we're trying
1776 to emit a Dwarf-friendly definition, and the Dwarf spec
1777 forbids spaces in the argument list. */
1779 else if (macro->variadic)
1780 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1785 /* The Dwarf spec requires a space after the macro name, even if the
1786 definition is the empty string. */
1789 if (CPP_OPTION (pfile, traditional))
1790 buffer = _cpp_copy_replacement_text (macro, buffer);
1791 else if (macro->count)
1792 /* Expansion tokens. */
1794 for (i = 0; i < macro->count; i++)
1796 cpp_token *token = ¯o->exp.tokens[i];
1798 if (token->flags & PREV_WHITE)
1800 if (token->flags & STRINGIFY_ARG)
1803 if (token->type == CPP_MACRO_ARG)
1806 NODE_NAME (macro->params[token->val.arg_no - 1]),
1807 NODE_LEN (macro->params[token->val.arg_no - 1]));
1808 buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1811 buffer = cpp_spell_token (pfile, token, buffer, false);
1813 if (token->flags & PASTE_LEFT)
1818 /* Next has PREV_WHITE; see _cpp_create_definition. */
1824 return pfile->macro_buffer;