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,
4 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>.
23 In other words, you are welcome to use, share and improve this program.
24 You are forbidden to forbid anyone else to use, share and improve
25 what you give them. Help stamp out software-hoarding! */
32 typedef struct macro_arg macro_arg;
33 /* This structure represents the tokens of a macro argument. These
34 tokens can be macro themselves, in which case they can be either
35 expanded or unexpanded. When they are expanded, this data
36 structure keeps both the expanded and unexpanded forms. */
39 const cpp_token **first; /* First token in unexpanded argument. */
40 const cpp_token **expanded; /* Macro-expanded argument. */
41 const cpp_token *stringified; /* Stringified argument. */
42 unsigned int count; /* # of tokens in argument. */
43 unsigned int expanded_count; /* # of tokens in expanded argument. */
44 source_location *virt_locs; /* Where virtual locations for
45 unexpanded tokens are stored. */
46 source_location *expanded_virt_locs; /* Where virtual locations for
51 /* The kind of macro tokens which the instance of
52 macro_arg_token_iter is supposed to iterate over. */
53 enum macro_arg_token_kind {
54 MACRO_ARG_TOKEN_NORMAL,
55 /* This is a macro argument token that got transformed into a string
56 litteral, e.g. #foo. */
57 MACRO_ARG_TOKEN_STRINGIFIED,
58 /* This is a token resulting from the expansion of a macro
59 argument that was itself a macro. */
60 MACRO_ARG_TOKEN_EXPANDED
63 /* An iterator over tokens coming from a function-like macro
65 typedef struct macro_arg_token_iter macro_arg_token_iter;
66 struct macro_arg_token_iter
68 /* Whether or not -ftrack-macro-expansion is used. */
69 bool track_macro_exp_p;
70 /* The kind of token over which we are supposed to iterate. */
71 enum macro_arg_token_kind kind;
72 /* A pointer to the current token pointed to by the iterator. */
73 const cpp_token **token_ptr;
74 /* A pointer to the "full" location of the current token. If
75 -ftrack-macro-expansion is used this location tracks loci accross
77 const source_location *location_ptr;
78 #ifdef ENABLE_CHECKING
79 /* The number of times the iterator went forward. This useful only
80 when checking is enabled. */
85 /* Macro expansion. */
87 static int enter_macro_context (cpp_reader *, cpp_hashnode *,
88 const cpp_token *, source_location);
89 static int builtin_macro (cpp_reader *, cpp_hashnode *);
90 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
91 const cpp_token **, unsigned int);
92 static void push_extended_tokens_context (cpp_reader *, cpp_hashnode *,
93 _cpp_buff *, source_location *,
94 const cpp_token **, unsigned int);
95 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
96 _cpp_buff **, unsigned *);
97 static cpp_context *next_context (cpp_reader *);
98 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
99 static void expand_arg (cpp_reader *, macro_arg *);
100 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
101 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
102 static void paste_all_tokens (cpp_reader *, const cpp_token *);
103 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
104 static void alloc_expanded_arg_mem (cpp_reader *, macro_arg *, size_t);
105 static void ensure_expanded_arg_room (cpp_reader *, macro_arg *, size_t, size_t *);
106 static void delete_macro_args (_cpp_buff*, unsigned num_args);
107 static void set_arg_token (macro_arg *, const cpp_token *,
108 source_location, size_t,
109 enum macro_arg_token_kind,
111 static const source_location *get_arg_token_location (const macro_arg *,
112 enum macro_arg_token_kind);
113 static const cpp_token **arg_token_ptr_at (const macro_arg *,
115 enum macro_arg_token_kind,
116 source_location **virt_location);
118 static void macro_arg_token_iter_init (macro_arg_token_iter *, bool,
119 enum macro_arg_token_kind,
122 static const cpp_token *macro_arg_token_iter_get_token
123 (const macro_arg_token_iter *it);
124 static source_location macro_arg_token_iter_get_location
125 (const macro_arg_token_iter *);
126 static void macro_arg_token_iter_forward (macro_arg_token_iter *);
127 static _cpp_buff *tokens_buff_new (cpp_reader *, size_t,
129 static size_t tokens_buff_count (_cpp_buff *);
130 static const cpp_token **tokens_buff_last_token_ptr (_cpp_buff *);
131 static const cpp_token **tokens_buff_put_token_to (const cpp_token **,
136 const struct line_map *,
139 static const cpp_token **tokens_buff_add_token (_cpp_buff *,
144 const struct line_map *,
146 static void tokens_buff_remove_last_token (_cpp_buff *);
147 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
148 macro_arg *, source_location);
149 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
150 _cpp_buff **, unsigned *);
151 static bool create_iso_definition (cpp_reader *, cpp_macro *);
153 /* #define directive parsing and handling. */
155 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
156 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
157 static bool warn_of_redefinition (cpp_reader *, cpp_hashnode *,
159 static bool parse_params (cpp_reader *, cpp_macro *);
160 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
162 static bool reached_end_of_context (cpp_context *);
163 static void consume_next_token_from_context (cpp_reader *pfile,
166 static const cpp_token* cpp_get_token_1 (cpp_reader *, source_location *);
168 /* Statistical counter tracking the number of macros that got
170 unsigned num_expanded_macros_counter = 0;
171 /* Statistical counter tracking the total number tokens resulting
172 from macro expansion. */
173 unsigned num_macro_tokens_counter = 0;
175 /* Emits a warning if NODE is a macro defined in the main file that
176 has not been used. */
178 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
179 void *v ATTRIBUTE_UNUSED)
181 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
183 cpp_macro *macro = node->value.macro;
186 && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
187 cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, macro->line, 0,
188 "macro \"%s\" is not used", NODE_NAME (node));
194 /* Allocates and returns a CPP_STRING token, containing TEXT of length
195 LEN, after null-terminating it. TEXT must be in permanent storage. */
196 static const cpp_token *
197 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
199 cpp_token *token = _cpp_temp_token (pfile);
202 token->type = CPP_STRING;
203 token->val.str.len = len;
204 token->val.str.text = text;
209 static const char * const monthnames[] =
211 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
212 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
215 /* Helper function for builtin_macro. Returns the text generated by
218 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
220 const struct line_map *map;
221 const uchar *result = NULL;
222 linenum_type number = 1;
224 switch (node->value.builtin)
227 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
233 cpp_buffer *pbuffer = cpp_get_buffer (pfile);
234 if (pbuffer->timestamp == NULL)
236 /* Initialize timestamp value of the assotiated file. */
237 struct _cpp_file *file = cpp_get_file (pbuffer);
240 /* Generate __TIMESTAMP__ string, that represents
241 the date and time of the last modification
242 of the current source file. The string constant
243 looks like "Sun Sep 16 01:03:52 1973". */
244 struct tm *tb = NULL;
245 struct stat *st = _cpp_get_file_stat (file);
247 tb = localtime (&st->st_mtime);
250 char *str = asctime (tb);
251 size_t len = strlen (str);
252 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
254 strcpy ((char *) buf + 1, str);
256 pbuffer->timestamp = buf;
260 cpp_errno (pfile, CPP_DL_WARNING,
261 "could not determine file timestamp");
262 pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
266 result = pbuffer->timestamp;
276 if (node->value.builtin == BT_FILE)
277 name = linemap_get_expansion_filename (pfile->line_table,
278 pfile->line_table->highest_line);
281 map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
282 while (! MAIN_FILE_P (map))
283 map = INCLUDED_FROM (pfile->line_table, map);
284 name = ORDINARY_MAP_FILE_NAME (map);
287 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
290 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
296 case BT_INCLUDE_LEVEL:
297 /* The line map depth counts the primary source as level 1, but
298 historically __INCLUDE_DEPTH__ has called the primary source
300 number = pfile->line_table->depth - 1;
304 map = LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table);
305 /* If __LINE__ is embedded in a macro, it must expand to the
306 line of the macro's invocation, not its definition.
307 Otherwise things like assert() will not work properly. */
308 number = linemap_get_expansion_line (pfile->line_table,
309 CPP_OPTION (pfile, traditional)
310 ? pfile->line_table->highest_line
311 : pfile->cur_token[-1].src_loc);
314 /* __STDC__ has the value 1 under normal circumstances.
315 However, if (a) we are in a system header, (b) the option
316 stdc_0_in_system_headers is true (set by target config), and
317 (c) we are not in strictly conforming mode, then it has the
318 value 0. (b) and (c) are already checked in cpp_init_builtins. */
320 if (cpp_in_system_header (pfile))
328 if (pfile->date == NULL)
330 /* Allocate __DATE__ and __TIME__ strings from permanent
331 storage. We only do this once, and don't generate them
332 at init time, because time() and localtime() are very
333 slow on some systems. */
335 struct tm *tb = NULL;
337 /* (time_t) -1 is a legitimate value for "number of seconds
338 since the Epoch", so we have to do a little dance to
339 distinguish that from a genuine error. */
342 if (tt != (time_t)-1 || errno == 0)
343 tb = localtime (&tt);
347 pfile->date = _cpp_unaligned_alloc (pfile,
348 sizeof ("\"Oct 11 1347\""));
349 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
350 monthnames[tb->tm_mon], tb->tm_mday,
353 pfile->time = _cpp_unaligned_alloc (pfile,
354 sizeof ("\"12:34:56\""));
355 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
356 tb->tm_hour, tb->tm_min, tb->tm_sec);
360 cpp_errno (pfile, CPP_DL_WARNING,
361 "could not determine date and time");
363 pfile->date = UC"\"??? ?? ????\"";
364 pfile->time = UC"\"??:??:??\"";
368 if (node->value.builtin == BT_DATE)
369 result = pfile->date;
371 result = pfile->time;
375 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
376 cpp_error (pfile, CPP_DL_ERROR,
377 "__COUNTER__ expanded inside directive with -fdirectives-only");
378 number = pfile->counter++;
384 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
385 result = _cpp_unaligned_alloc (pfile, 21);
386 sprintf ((char *) result, "%u", number);
392 /* Convert builtin macros like __FILE__ to a token and push it on the
393 context stack. Also handles _Pragma, for which a new token may not
394 be created. Returns 1 if it generates a new token context, 0 to
395 return the token to the caller. */
397 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
403 if (node->value.builtin == BT_PRAGMA)
405 /* Don't interpret _Pragma within directives. The standard is
406 not clear on this, but to me this makes most sense. */
407 if (pfile->state.in_directive)
410 return _cpp_do__Pragma (pfile);
413 buf = _cpp_builtin_macro_text (pfile, node);
415 nbuf = (char *) alloca (len + 1);
416 memcpy (nbuf, buf, len);
419 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
420 _cpp_clean_line (pfile);
422 /* Set pfile->cur_token as required by _cpp_lex_direct. */
423 pfile->cur_token = _cpp_temp_token (pfile);
424 _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
425 if (pfile->buffer->cur != pfile->buffer->rlimit)
426 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
428 _cpp_pop_buffer (pfile);
433 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
434 backslashes and double quotes. DEST must be of sufficient size.
435 Returns a pointer to the end of the string. */
437 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
443 if (c == '\\' || c == '"')
455 /* Convert a token sequence ARG to a single string token according to
456 the rules of the ISO C #-operator. */
457 static const cpp_token *
458 stringify_arg (cpp_reader *pfile, macro_arg *arg)
461 unsigned int i, escape_it, backslash_count = 0;
462 const cpp_token *source = NULL;
465 if (BUFF_ROOM (pfile->u_buff) < 3)
466 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
467 dest = BUFF_FRONT (pfile->u_buff);
470 /* Loop, reading in the argument's tokens. */
471 for (i = 0; i < arg->count; i++)
473 const cpp_token *token = arg->first[i];
475 if (token->type == CPP_PADDING)
478 || (!(source->flags & PREV_WHITE)
479 && token->val.source == NULL))
480 source = token->val.source;
484 escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
485 || token->type == CPP_WSTRING || token->type == CPP_WCHAR
486 || token->type == CPP_STRING32 || token->type == CPP_CHAR32
487 || token->type == CPP_STRING16 || token->type == CPP_CHAR16
488 || token->type == CPP_UTF8STRING);
490 /* Room for each char being written in octal, initial space and
491 final quote and NUL. */
492 len = cpp_token_len (token);
497 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
499 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
500 _cpp_extend_buff (pfile, &pfile->u_buff, len);
501 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
504 /* Leading white space? */
505 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
509 if (source->flags & PREV_WHITE)
516 _cpp_buff *buff = _cpp_get_buff (pfile, len);
517 unsigned char *buf = BUFF_FRONT (buff);
518 len = cpp_spell_token (pfile, token, buf, true) - buf;
519 dest = cpp_quote_string (dest, buf, len);
520 _cpp_release_buff (pfile, buff);
523 dest = cpp_spell_token (pfile, token, dest, true);
525 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
531 /* Ignore the final \ of invalid string literals. */
532 if (backslash_count & 1)
534 cpp_error (pfile, CPP_DL_WARNING,
535 "invalid string literal, ignoring final '\\'");
539 /* Commit the memory, including NUL, and return the token. */
541 len = dest - BUFF_FRONT (pfile->u_buff);
542 BUFF_FRONT (pfile->u_buff) = dest + 1;
543 return new_string_token (pfile, dest - len, len);
546 /* Try to paste two tokens. On success, return nonzero. In any
547 case, PLHS is updated to point to the pasted token, which is
548 guaranteed to not have the PASTE_LEFT flag set. */
550 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
552 unsigned char *buf, *end, *lhsend;
556 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
557 buf = (unsigned char *) alloca (len);
558 end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
560 /* Avoid comment headers, since they are still processed in stage 3.
561 It is simpler to insert a space here, rather than modifying the
562 lexer to ignore comments in some circumstances. Simply returning
563 false doesn't work, since we want to clear the PASTE_LEFT flag. */
564 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
566 /* In one obscure case we might see padding here. */
567 if (rhs->type != CPP_PADDING)
568 end = cpp_spell_token (pfile, rhs, end, false);
571 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
572 _cpp_clean_line (pfile);
574 /* Set pfile->cur_token as required by _cpp_lex_direct. */
575 pfile->cur_token = _cpp_temp_token (pfile);
576 lhs = _cpp_lex_direct (pfile);
577 if (pfile->buffer->cur != pfile->buffer->rlimit)
579 source_location saved_loc = lhs->src_loc;
581 _cpp_pop_buffer (pfile);
582 _cpp_backup_tokens (pfile, 1);
585 /* We have to remove the PASTE_LEFT flag from the old lhs, but
586 we want to keep the new location. */
589 lhs->src_loc = saved_loc;
590 lhs->flags &= ~PASTE_LEFT;
592 /* Mandatory error for all apart from assembler. */
593 if (CPP_OPTION (pfile, lang) != CLK_ASM)
594 cpp_error (pfile, CPP_DL_ERROR,
595 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
596 buf, cpp_token_as_text (pfile, rhs));
601 _cpp_pop_buffer (pfile);
605 /* Handles an arbitrarily long sequence of ## operators, with initial
606 operand LHS. This implementation is left-associative,
607 non-recursive, and finishes a paste before handling succeeding
608 ones. If a paste fails, we back up to the RHS of the failing ##
609 operator before pushing the context containing the result of prior
610 successful pastes, with the effect that the RHS appears in the
611 output stream after the pasted LHS normally. */
613 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
615 const cpp_token *rhs = NULL;
616 cpp_context *context = pfile->context;
620 /* Take the token directly from the current context. We can do
621 this, because we are in the replacement list of either an
622 object-like macro, or a function-like macro with arguments
623 inserted. In either case, the constraints to #define
624 guarantee we have at least one more token. */
625 if (context->tokens_kind == TOKENS_KIND_DIRECT)
626 rhs = FIRST (context).token++;
627 else if (context->tokens_kind == TOKENS_KIND_INDIRECT)
628 rhs = *FIRST (context).ptoken++;
629 else if (context->tokens_kind == TOKENS_KIND_EXTENDED)
631 /* So we are in presence of an extended token context, which
632 means that each token in this context has a virtual
633 location attached to it. So let's not forget to update
634 the pointer to the current virtual location of the
635 current token when we update the pointer to the current
638 rhs = *FIRST (context).ptoken++;
639 /* context->c.mc must be non-null, as if we were not in a
640 macro context, context->tokens_kind could not be equal to
641 TOKENS_KIND_EXTENDED. */
642 context->c.mc->cur_virt_loc++;
645 if (rhs->type == CPP_PADDING)
647 if (rhs->flags & PASTE_LEFT)
650 if (!paste_tokens (pfile, &lhs, rhs))
653 while (rhs->flags & PASTE_LEFT);
655 /* Put the resulting token in its own context. */
656 _cpp_push_token_context (pfile, NULL, lhs, 1);
659 /* Returns TRUE if the number of arguments ARGC supplied in an
660 invocation of the MACRO referenced by NODE is valid. An empty
661 invocation to a macro with no parameters should pass ARGC as zero.
663 Note that MACRO cannot necessarily be deduced from NODE, in case
664 NODE was redefined whilst collecting arguments. */
666 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
668 if (argc == macro->paramc)
671 if (argc < macro->paramc)
673 /* As an extension, a rest argument is allowed to not appear in
674 the invocation at all.
675 e.g. #define debug(format, args...) something
678 This is exactly the same as if there had been an empty rest
679 argument - debug("string", ). */
681 if (argc + 1 == macro->paramc && macro->variadic)
683 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
684 cpp_error (pfile, CPP_DL_PEDWARN,
685 "ISO C99 requires rest arguments to be used");
689 cpp_error (pfile, CPP_DL_ERROR,
690 "macro \"%s\" requires %u arguments, but only %u given",
691 NODE_NAME (node), macro->paramc, argc);
694 cpp_error (pfile, CPP_DL_ERROR,
695 "macro \"%s\" passed %u arguments, but takes just %u",
696 NODE_NAME (node), argc, macro->paramc);
701 /* Reads and returns the arguments to a function-like macro
702 invocation. Assumes the opening parenthesis has been processed.
703 If there is an error, emits an appropriate diagnostic and returns
704 NULL. Each argument is terminated by a CPP_EOF token, for the
705 future benefit of expand_arg(). If there are any deferred
706 #pragma directives among macro arguments, store pointers to the
707 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
709 What is returned is the buffer that contains the memory allocated
710 to hold the macro arguments. NODE is the name of the macro this
711 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
712 set to the actual number of macro arguments allocated in the
715 collect_args (cpp_reader *pfile, const cpp_hashnode *node,
716 _cpp_buff **pragma_buff, unsigned *num_args)
718 _cpp_buff *buff, *base_buff;
720 macro_arg *args, *arg;
721 const cpp_token *token;
723 source_location virt_loc;
724 bool track_macro_expansion_p = CPP_OPTION (pfile, track_macro_expansion);
725 unsigned num_args_alloced = 0;
727 macro = node->value.macro;
729 argc = macro->paramc;
733 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
734 #define ARG_TOKENS_EXTENT 1000
736 buff = _cpp_get_buff (pfile, argc * (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
737 * sizeof (cpp_token *)
738 + sizeof (macro_arg)));
740 args = (macro_arg *) buff->base;
741 memset (args, 0, argc * sizeof (macro_arg));
742 buff->cur = (unsigned char *) &args[argc];
743 arg = args, argc = 0;
745 /* Collect the tokens making up each argument. We don't yet know
746 how many arguments have been supplied, whether too many or too
747 few. Hence the slightly bizarre usage of "argc" and "arg". */
750 unsigned int paren_depth = 0;
751 unsigned int ntokens = 0;
752 unsigned virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
756 arg->first = (const cpp_token **) buff->cur;
757 if (track_macro_expansion_p)
759 virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
760 arg->virt_locs = XNEWVEC (source_location,
766 /* Require space for 2 new tokens (including a CPP_EOF). */
767 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
769 buff = _cpp_append_extend_buff (pfile, buff,
771 * sizeof (cpp_token *));
772 arg->first = (const cpp_token **) buff->cur;
774 if (track_macro_expansion_p
775 && (ntokens + 2 > virt_locs_capacity))
777 virt_locs_capacity += ARG_TOKENS_EXTENT;
778 arg->virt_locs = XRESIZEVEC (source_location,
783 token = cpp_get_token_1 (pfile, &virt_loc);
785 if (token->type == CPP_PADDING)
787 /* Drop leading padding. */
791 else if (token->type == CPP_OPEN_PAREN)
793 else if (token->type == CPP_CLOSE_PAREN)
795 if (paren_depth-- == 0)
798 else if (token->type == CPP_COMMA)
800 /* A comma does not terminate an argument within
801 parentheses or as part of a variable argument. */
803 && ! (macro->variadic && argc == macro->paramc))
806 else if (token->type == CPP_EOF
807 || (token->type == CPP_HASH && token->flags & BOL))
809 else if (token->type == CPP_PRAGMA)
811 cpp_token *newtok = _cpp_temp_token (pfile);
813 /* CPP_PRAGMA token lives in directive_result, which will
814 be overwritten on the next directive. */
819 if (*pragma_buff == NULL
820 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
823 if (*pragma_buff == NULL)
825 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
830 = _cpp_get_buff (pfile,
831 (BUFF_FRONT (*pragma_buff)
832 - (*pragma_buff)->base) * 2);
833 (*pragma_buff)->next = next;
836 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
837 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
838 if (token->type == CPP_PRAGMA_EOL)
840 token = cpp_get_token_1 (pfile, &virt_loc);
842 while (token->type != CPP_EOF);
844 /* In deferred pragmas parsing_args and prevent_expansion
845 had been changed, reset it. */
846 pfile->state.parsing_args = 2;
847 pfile->state.prevent_expansion = 1;
849 if (token->type == CPP_EOF)
854 set_arg_token (arg, token, virt_loc,
855 ntokens, MACRO_ARG_TOKEN_NORMAL,
856 CPP_OPTION (pfile, track_macro_expansion));
860 /* Drop trailing padding. */
861 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
864 arg->count = ntokens;
865 set_arg_token (arg, &pfile->eof, pfile->eof.src_loc,
866 ntokens, MACRO_ARG_TOKEN_NORMAL,
867 CPP_OPTION (pfile, track_macro_expansion));
869 /* Terminate the argument. Excess arguments loop back and
870 overwrite the final legitimate argument, before failing. */
871 if (argc <= macro->paramc)
873 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
874 if (argc != macro->paramc)
878 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
880 if (token->type == CPP_EOF)
882 /* We still need the CPP_EOF to end directives, and to end
883 pre-expansion of a macro argument. Step back is not
884 unconditional, since we don't want to return a CPP_EOF to our
885 callers at the end of an -include-d file. */
886 if (pfile->context->prev || pfile->state.in_directive)
887 _cpp_backup_tokens (pfile, 1);
888 cpp_error (pfile, CPP_DL_ERROR,
889 "unterminated argument list invoking macro \"%s\"",
894 /* A single empty argument is counted as no argument. */
895 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
897 if (_cpp_arguments_ok (pfile, macro, node, argc))
899 /* GCC has special semantics for , ## b where b is a varargs
900 parameter: we remove the comma if b was omitted entirely.
901 If b was merely an empty argument, the comma is retained.
902 If the macro takes just one (varargs) parameter, then we
903 retain the comma only if we are standards conforming.
905 If FIRST is NULL replace_args () swallows the comma. */
906 if (macro->variadic && (argc < macro->paramc
907 || (argc == 1 && args[0].count == 0
908 && !CPP_OPTION (pfile, std))))
909 args[macro->paramc - 1].first = NULL;
911 *num_args = num_args_alloced;
916 /* An error occurred. */
917 _cpp_release_buff (pfile, base_buff);
921 /* Search for an opening parenthesis to the macro of NODE, in such a
922 way that, if none is found, we don't lose the information in any
923 intervening padding tokens. If we find the parenthesis, collect
924 the arguments and return the buffer containing them. PRAGMA_BUFF
925 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
926 *NUM_ARGS is set to the number of arguments contained in the
929 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
930 _cpp_buff **pragma_buff, unsigned *num_args)
932 const cpp_token *token, *padding = NULL;
936 token = cpp_get_token (pfile);
937 if (token->type != CPP_PADDING)
940 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
944 if (token->type == CPP_OPEN_PAREN)
946 pfile->state.parsing_args = 2;
947 return collect_args (pfile, node, pragma_buff, num_args);
950 /* CPP_EOF can be the end of macro arguments, or the end of the
951 file. We mustn't back up over the latter. Ugh. */
952 if (token->type != CPP_EOF || token == &pfile->eof)
954 /* Back up. We may have skipped padding, in which case backing
955 up more than one token when expanding macros is in general
956 too difficult. We re-insert it in its own context. */
957 _cpp_backup_tokens (pfile, 1);
959 _cpp_push_token_context (pfile, NULL, padding, 1);
965 /* Return the real number of tokens in the expansion of MACRO. */
966 static inline unsigned int
967 macro_real_token_count (const cpp_macro *macro)
970 if (__builtin_expect (!macro->extra_tokens, true))
972 for (i = 0; i < macro->count; i++)
973 if (macro->exp.tokens[i].type == CPP_PASTE)
978 /* Push the context of a macro with hash entry NODE onto the context
979 stack. If we can successfully expand the macro, we push a context
980 containing its yet-to-be-rescanned replacement list and return one.
981 If there were additionally any unexpanded deferred #pragma
982 directives among macro arguments, push another context containing
983 the pragma tokens before the yet-to-be-rescanned replacement list
984 and return two. Otherwise, we don't push a context and return
985 zero. LOCATION is the location of the expansion point of the
988 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
989 const cpp_token *result, source_location location)
991 /* The presence of a macro invalidates a file's controlling macro. */
992 pfile->mi_valid = false;
994 pfile->state.angled_headers = false;
996 if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
998 node->flags |= NODE_USED;
999 if ((!pfile->cb.user_builtin_macro
1000 || !pfile->cb.user_builtin_macro (pfile, node))
1001 && pfile->cb.used_define)
1002 pfile->cb.used_define (pfile, pfile->directive_line, node);
1005 /* Handle standard macros. */
1006 if (! (node->flags & NODE_BUILTIN))
1008 cpp_macro *macro = node->value.macro;
1009 _cpp_buff *pragma_buff = NULL;
1011 if (macro->fun_like)
1014 unsigned num_args = 0;
1016 pfile->state.prevent_expansion++;
1017 pfile->keep_tokens++;
1018 pfile->state.parsing_args = 1;
1019 buff = funlike_invocation_p (pfile, node, &pragma_buff,
1021 pfile->state.parsing_args = 0;
1022 pfile->keep_tokens--;
1023 pfile->state.prevent_expansion--;
1027 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
1028 cpp_warning (pfile, CPP_W_TRADITIONAL,
1029 "function-like macro \"%s\" must be used with arguments in traditional C",
1033 _cpp_release_buff (pfile, pragma_buff);
1038 if (macro->paramc > 0)
1039 replace_args (pfile, node, macro,
1040 (macro_arg *) buff->base,
1042 /* Free the memory used by the arguments of this
1043 function-like macro. This memory has been allocated by
1044 funlike_invocation_p and by replace_args. */
1045 delete_macro_args (buff, num_args);
1048 /* Disable the macro within its expansion. */
1049 node->flags |= NODE_DISABLED;
1051 if (!(node->flags & NODE_USED))
1053 node->flags |= NODE_USED;
1054 if (pfile->cb.used_define)
1055 pfile->cb.used_define (pfile, pfile->directive_line, node);
1059 pfile->cb.used (pfile, location, node);
1063 if (macro->paramc == 0)
1065 if (CPP_OPTION (pfile, track_macro_expansion))
1067 unsigned int i, count = macro->count;
1068 const cpp_token *src = macro->exp.tokens;
1069 const struct line_map *map;
1070 source_location *virt_locs = NULL;
1071 _cpp_buff *macro_tokens =
1072 tokens_buff_new (pfile, count, &virt_locs);
1074 /* Create a macro map to record the locations of the
1075 tokens that are involved in the expansion. LOCATION
1076 is the location of the macro expansion point. */
1077 map = linemap_enter_macro (pfile->line_table,
1078 node, location, count);
1079 for (i = 0; i < count; ++i)
1081 tokens_buff_add_token (macro_tokens, virt_locs,
1083 src->src_loc, map, i);
1086 push_extended_tokens_context (pfile, node,
1089 (const cpp_token **)
1092 num_macro_tokens_counter += count;
1096 unsigned tokens_count = macro_real_token_count (macro);
1097 _cpp_push_token_context (pfile, node, macro->exp.tokens,
1099 num_macro_tokens_counter += tokens_count;
1105 if (!pfile->state.in_directive)
1106 _cpp_push_token_context (pfile, NULL,
1107 padding_token (pfile, result), 1);
1110 unsigned tokens_count;
1111 _cpp_buff *tail = pragma_buff->next;
1112 pragma_buff->next = NULL;
1113 tokens_count = ((const cpp_token **) BUFF_FRONT (pragma_buff)
1114 - (const cpp_token **) pragma_buff->base);
1115 push_ptoken_context (pfile, NULL, pragma_buff,
1116 (const cpp_token **) pragma_buff->base,
1119 if (!CPP_OPTION (pfile, track_macro_expansion))
1120 num_macro_tokens_counter += tokens_count;
1123 while (pragma_buff != NULL);
1130 /* Handle built-in macros and the _Pragma operator. */
1131 return builtin_macro (pfile, node);
1134 /* De-allocate the memory used by BUFF which is an array of instances
1135 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1138 delete_macro_args (_cpp_buff *buff, unsigned num_args)
1140 macro_arg *macro_args;
1146 macro_args = (macro_arg *) buff->base;
1148 /* Walk instances of macro_arg to free their expanded tokens as well
1149 as their macro_arg::virt_locs members. */
1150 for (i = 0; i < num_args; ++i)
1152 if (macro_args[i].expanded)
1154 free (macro_args[i].expanded);
1155 macro_args[i].expanded = NULL;
1157 if (macro_args[i].virt_locs)
1159 free (macro_args[i].virt_locs);
1160 macro_args[i].virt_locs = NULL;
1162 if (macro_args[i].expanded_virt_locs)
1164 free (macro_args[i].expanded_virt_locs);
1165 macro_args[i].expanded_virt_locs = NULL;
1168 _cpp_free_buff (buff);
1171 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1172 to set, LOCATION is its virtual location. "Virtual" location means
1173 the location that encodes loci accross macro expansion. Otherwise
1174 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1175 argument ARG is supposed to contain. Note that ARG must be
1176 tailored so that it has enough room to contain INDEX + 1 numbers of
1177 tokens, at least. */
1179 set_arg_token (macro_arg *arg, const cpp_token *token,
1180 source_location location, size_t index,
1181 enum macro_arg_token_kind kind,
1182 bool track_macro_exp_p)
1184 const cpp_token **token_ptr;
1185 source_location *loc = NULL;
1188 arg_token_ptr_at (arg, index, kind,
1189 track_macro_exp_p ? &loc : NULL);
1194 #ifdef ENABLE_CHECKING
1195 if (kind == MACRO_ARG_TOKEN_STRINGIFIED
1196 || !track_macro_exp_p)
1197 /* We can't set the location of a stringified argument
1198 token and we can't set any location if we aren't tracking
1199 macro expansion locations. */
1206 /* Get the pointer to the location of the argument token of the
1207 function-like macro argument ARG. This function must be called
1208 only when we -ftrack-macro-expansion is on. */
1209 static const source_location *
1210 get_arg_token_location (const macro_arg *arg,
1211 enum macro_arg_token_kind kind)
1213 const source_location *loc = NULL;
1214 const cpp_token **token_ptr =
1215 arg_token_ptr_at (arg, 0, kind, (source_location **) &loc);
1217 if (token_ptr == NULL)
1223 /* Return the pointer to the INDEXth token of the macro argument ARG.
1224 KIND specifies the kind of token the macro argument ARG contains.
1225 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1226 of the virtual location of the returned token if the
1227 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1228 spelling location of the returned token. */
1229 static const cpp_token **
1230 arg_token_ptr_at (const macro_arg *arg, size_t index,
1231 enum macro_arg_token_kind kind,
1232 source_location **virt_location)
1234 const cpp_token **tokens_ptr = NULL;
1238 case MACRO_ARG_TOKEN_NORMAL:
1239 tokens_ptr = arg->first;
1241 case MACRO_ARG_TOKEN_STRINGIFIED:
1242 tokens_ptr = (const cpp_token **) &arg->stringified;
1244 case MACRO_ARG_TOKEN_EXPANDED:
1245 tokens_ptr = arg->expanded;
1249 if (tokens_ptr == NULL)
1250 /* This can happen for e.g, an empty token argument to a
1251 funtion-like macro. */
1256 if (kind == MACRO_ARG_TOKEN_NORMAL)
1257 *virt_location = &arg->virt_locs[index];
1258 else if (kind == MACRO_ARG_TOKEN_EXPANDED)
1259 *virt_location = &arg->expanded_virt_locs[index];
1260 else if (kind == MACRO_ARG_TOKEN_STRINGIFIED)
1262 (source_location *) &tokens_ptr[index]->src_loc;
1264 return &tokens_ptr[index];
1267 /* Initialize an iterator so that it iterates over the tokens of a
1268 function-like macro argument. KIND is the kind of tokens we want
1269 ITER to iterate over. TOKEN_PTR points the first token ITER will
1272 macro_arg_token_iter_init (macro_arg_token_iter *iter,
1273 bool track_macro_exp_p,
1274 enum macro_arg_token_kind kind,
1275 const macro_arg *arg,
1276 const cpp_token **token_ptr)
1278 iter->track_macro_exp_p = track_macro_exp_p;
1280 iter->token_ptr = token_ptr;
1281 if (track_macro_exp_p)
1282 iter->location_ptr = get_arg_token_location (arg, kind);
1283 #ifdef ENABLE_CHECKING
1284 iter->num_forwards = 0;
1285 if (track_macro_exp_p
1286 && token_ptr != NULL
1287 && iter->location_ptr == NULL)
1292 /* Move the iterator one token forward. Note that if IT was
1293 initialized on an argument that has a stringified token, moving it
1294 foward doesn't make sense as a stringified token is essentially one
1297 macro_arg_token_iter_forward (macro_arg_token_iter *it)
1301 case MACRO_ARG_TOKEN_NORMAL:
1302 case MACRO_ARG_TOKEN_EXPANDED:
1304 if (it->track_macro_exp_p)
1307 case MACRO_ARG_TOKEN_STRINGIFIED:
1308 #ifdef ENABLE_CHECKING
1309 if (it->num_forwards > 0)
1315 #ifdef ENABLE_CHECKING
1320 /* Return the token pointed to by the iterator. */
1321 static const cpp_token *
1322 macro_arg_token_iter_get_token (const macro_arg_token_iter *it)
1324 #ifdef ENABLE_CHECKING
1325 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1326 && it->num_forwards > 0)
1329 if (it->token_ptr == NULL)
1331 return *it->token_ptr;
1334 /* Return the location of the token pointed to by the iterator.*/
1335 static source_location
1336 macro_arg_token_iter_get_location (const macro_arg_token_iter *it)
1338 #ifdef ENABLE_CHECKING
1339 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1340 && it->num_forwards > 0)
1343 if (it->track_macro_exp_p)
1344 return *it->location_ptr;
1346 return (*it->token_ptr)->src_loc;
1349 /* Return the index of a token [resulting from macro expansion] inside
1350 the total list of tokens resulting from a given macro
1351 expansion. The index can be different depending on whether if we
1352 want each tokens resulting from function-like macro arguments
1353 expansion to have a different location or not.
1355 E.g, consider this function-like macro:
1359 Then consider us "calling" it (and thus expanding it) like:
1363 It will be expanded into:
1367 Let's consider the case of the token '4'.
1369 Its index can be 2 (it's the third token of the set of tokens
1370 resulting from the expansion) or it can be 0 if we consider that
1371 all tokens resulting from the expansion of the argument "1+2" have
1372 the same index, which is 0. In this later case, the index of token
1373 '-' would then be 1 and the index of token '3' would be 2.
1375 The later case is useful to use less memory e.g, for the case of
1376 the user using the option -ftrack-macro-expansion=1.
1378 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1379 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1380 parameter (inside the macro replacement list) that corresponds to
1381 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1384 If we refer to the example above, for the '4' argument token,
1385 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1386 would be set to the token 'x', in the replacement list "x - 3" of
1389 This is a subroutine of replace_args. */
1390 inline static unsigned
1391 expanded_token_index (cpp_reader *pfile, cpp_macro *macro,
1392 const cpp_token *cur_replacement_token,
1393 unsigned absolute_token_index)
1395 if (CPP_OPTION (pfile, track_macro_expansion) > 1)
1396 return absolute_token_index;
1397 return cur_replacement_token - macro->exp.tokens;
1400 /* Replace the parameters in a function-like macro of NODE with the
1401 actual ARGS, and place the result in a newly pushed token context.
1402 Expand each argument before replacing, unless it is operated upon
1403 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1404 the expansion point of the macro. E.g, the location of the
1405 function-like macro invocation. */
1407 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro,
1408 macro_arg *args, source_location expansion_point_loc)
1410 unsigned int i, total;
1411 const cpp_token *src, *limit;
1412 const cpp_token **first = NULL;
1414 _cpp_buff *buff = NULL;
1415 source_location *virt_locs = NULL;
1416 unsigned int exp_count;
1417 const struct line_map *map = NULL;
1418 int track_macro_exp;
1420 /* First, fully macro-expand arguments, calculating the number of
1421 tokens in the final expansion as we go. The ordering of the if
1422 statements below is subtle; we must handle stringification before
1425 /* EXP_COUNT is the number of tokens in the macro replacement
1426 list. TOTAL is the number of tokens /after/ macro parameters
1427 have been replaced by their arguments. */
1428 exp_count = macro_real_token_count (macro);
1430 limit = macro->exp.tokens + exp_count;
1432 for (src = macro->exp.tokens; src < limit; src++)
1433 if (src->type == CPP_MACRO_ARG)
1435 /* Leading and trailing padding tokens. */
1437 /* Account for leading and padding tokens in exp_count too.
1438 This is going to be important later down this function,
1439 when we want to handle the case of (track_macro_exp <
1443 /* We have an argument. If it is not being stringified or
1444 pasted it is macro-replaced before insertion. */
1445 arg = &args[src->val.macro_arg.arg_no - 1];
1447 if (src->flags & STRINGIFY_ARG)
1449 if (!arg->stringified)
1450 arg->stringified = stringify_arg (pfile, arg);
1452 else if ((src->flags & PASTE_LEFT)
1453 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
1454 total += arg->count - 1;
1458 expand_arg (pfile, arg);
1459 total += arg->expanded_count - 1;
1463 /* When the compiler is called with the -ftrack-macro-expansion
1464 flag, we need to keep track of the location of each token that
1465 results from macro expansion.
1467 A token resulting from macro expansion is not a new token. It is
1468 simply the same token as the token coming from the macro
1469 definition. The new things that are allocated are the buffer
1470 that holds the tokens resulting from macro expansion and a new
1471 location that records many things like the locus of the expansion
1472 point as well as the original locus inside the definition of the
1473 macro. This location is called a virtual location.
1475 So the buffer BUFF holds a set of cpp_token*, and the buffer
1476 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1478 Both of these two buffers are going to be hung off of the macro
1479 context, when the latter is pushed. The memory allocated to
1480 store the tokens and their locations is going to be freed once
1481 the context of macro expansion is popped.
1483 As far as tokens are concerned, the memory overhead of
1484 -ftrack-macro-expansion is proportional to the number of
1485 macros that get expanded multiplied by sizeof (source_location).
1486 The good news is that extra memory gets freed when the macro
1487 context is freed, i.e shortly after the macro got expanded. */
1489 /* Is the -ftrack-macro-expansion flag in effect? */
1490 track_macro_exp = CPP_OPTION (pfile, track_macro_expansion);
1492 /* Now allocate memory space for tokens and locations resulting from
1493 the macro expansion, copy the tokens and replace the arguments.
1494 This memory must be freed when the context of the macro MACRO is
1496 buff = tokens_buff_new (pfile, total, track_macro_exp ? &virt_locs : NULL);
1498 first = (const cpp_token **) buff->base;
1500 /* Create a macro map to record the locations of the tokens that are
1501 involved in the expansion. Note that the expansion point is set
1502 to the location of the closing parenthesis. Otherwise, the
1503 subsequent map created for the first token that comes after the
1504 macro map might have a wrong line number. That would lead to
1505 tokens with wrong line numbers after the macro expansion. This
1506 adds up to the memory overhead of the -ftrack-macro-expansion
1507 flag; for every macro that is expanded, a "macro map" is
1509 if (track_macro_exp)
1511 int num_macro_tokens = total;
1512 if (track_macro_exp < 2)
1513 /* Then the number of macro tokens won't take in account the
1514 fact that function-like macro arguments can expand to
1515 multiple tokens. This is to save memory at the expense of
1518 Suppose we have #define SQARE(A) A * A
1520 And then we do SQARE(2+3)
1522 Then the tokens 2, +, 3, will have the same location,
1523 saying they come from the expansion of the argument A. */
1524 num_macro_tokens = exp_count;
1525 map = linemap_enter_macro (pfile->line_table, node,
1526 expansion_point_loc,
1530 for (src = macro->exp.tokens; src < limit; src++)
1532 unsigned int arg_tokens_count;
1533 macro_arg_token_iter from;
1534 const cpp_token **paste_flag = NULL;
1535 const cpp_token **tmp_token_ptr;
1537 if (src->type != CPP_MACRO_ARG)
1539 /* Allocate a virtual location for token SRC, and add that
1540 token and its virtual location into the buffers BUFF and
1542 unsigned index = expanded_token_index (pfile, macro, src, i);
1543 tokens_buff_add_token (buff, virt_locs, src,
1544 src->src_loc, src->src_loc,
1551 arg = &args[src->val.macro_arg.arg_no - 1];
1552 /* SRC is a macro parameter that we need to replace with its
1553 corresponding argument. So at some point we'll need to
1554 iterate over the tokens of the macro argument and copy them
1555 into the "place" now holding the correspondig macro
1556 parameter. We are going to use the iterator type
1557 macro_argo_token_iter to handle that iterating. The 'if'
1558 below is to initialize the iterator depending on the type of
1559 tokens the macro argument has. It also does some adjustment
1560 related to padding tokens and some pasting corner cases. */
1561 if (src->flags & STRINGIFY_ARG)
1563 arg_tokens_count = 1;
1564 macro_arg_token_iter_init (&from,
1566 track_macro_expansion),
1567 MACRO_ARG_TOKEN_STRINGIFIED,
1568 arg, &arg->stringified);
1570 else if (src->flags & PASTE_LEFT)
1572 arg_tokens_count = arg->count;
1573 macro_arg_token_iter_init (&from,
1575 track_macro_expansion),
1576 MACRO_ARG_TOKEN_NORMAL,
1579 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
1582 arg_tokens_count = arg->count;
1583 macro_arg_token_iter_init (&from,
1585 track_macro_expansion),
1586 MACRO_ARG_TOKEN_NORMAL,
1589 num_toks = tokens_buff_count (buff);
1593 /* So the current parameter token is pasted to the previous
1594 token in the replacement list. Let's look at what
1595 we have as previous and current arguments. */
1597 /* This is the previous argument's token ... */
1598 tmp_token_ptr = tokens_buff_last_token_ptr (buff);
1600 if ((*tmp_token_ptr)->type == CPP_COMMA
1602 && src->val.macro_arg.arg_no == macro->paramc)
1604 /* ... which is a comma; and the current parameter
1605 is the last parameter of a variadic function-like
1606 macro. If the argument to the current last
1607 parameter is NULL, then swallow the comma,
1608 otherwise drop the paste flag. */
1609 if (macro_arg_token_iter_get_token (&from) == NULL)
1610 tokens_buff_remove_last_token (buff);
1612 paste_flag = tmp_token_ptr;
1614 /* Remove the paste flag if the RHS is a placemarker. */
1615 else if (arg_tokens_count == 0)
1616 paste_flag = tmp_token_ptr;
1621 arg_tokens_count = arg->expanded_count;
1622 macro_arg_token_iter_init (&from,
1624 track_macro_expansion),
1625 MACRO_ARG_TOKEN_EXPANDED,
1626 arg, arg->expanded);
1629 /* Padding on the left of an argument (unless RHS of ##). */
1630 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
1631 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
1633 const cpp_token *t = padding_token (pfile, src);
1634 unsigned index = expanded_token_index (pfile, macro, src, i);
1635 /* Allocate a virtual location for the padding token and
1636 append the token and its location to BUFF and
1638 tokens_buff_add_token (buff, virt_locs, t,
1639 t->src_loc, t->src_loc,
1643 if (arg_tokens_count)
1645 /* So now we've got the number of tokens that make up the
1646 argument that is going to replace the current parameter
1647 in the macro's replacement list. */
1649 for (j = 0; j < arg_tokens_count; ++j)
1651 /* So if track_macro_exp is < 2, the user wants to
1652 save extra memory while tracking macro expansion
1653 locations. So in that case here is what we do:
1655 Suppose we have #define SQARE(A) A * A
1657 And then we do SQARE(2+3)
1659 Then the tokens 2, +, 3, will have the same location,
1660 saying they come from the expansion of the argument
1663 So that means we are going to ignore the COUNT tokens
1664 resulting from the expansion of the current macro
1665 arugment. In other words all the ARG_TOKENS_COUNT tokens
1666 resulting from the expansion of the macro argument will
1667 have the index I. Normally, each of those token should
1669 unsigned token_index = i;
1671 if (track_macro_exp > 1)
1674 index = expanded_token_index (pfile, macro, src, token_index);
1675 tokens_buff_add_token (buff, virt_locs,
1676 macro_arg_token_iter_get_token (&from),
1677 macro_arg_token_iter_get_location (&from),
1678 src->src_loc, map, index);
1679 macro_arg_token_iter_forward (&from);
1682 /* With a non-empty argument on the LHS of ##, the last
1683 token should be flagged PASTE_LEFT. */
1684 if (src->flags & PASTE_LEFT)
1686 (const cpp_token **) tokens_buff_last_token_ptr (buff);
1688 else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1689 && ! CPP_OPTION (pfile, c99)
1690 && ! cpp_in_system_header (pfile))
1692 cpp_error (pfile, CPP_DL_PEDWARN,
1693 "invoking macro %s argument %d: "
1694 "empty macro arguments are undefined"
1695 " in ISO C90 and ISO C++98",
1697 src->val.macro_arg.arg_no);
1700 /* Avoid paste on RHS (even case count == 0). */
1701 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1703 const cpp_token *t = &pfile->avoid_paste;
1704 tokens_buff_add_token (buff, virt_locs,
1705 t, t->src_loc, t->src_loc,
1709 /* Add a new paste flag, or remove an unwanted one. */
1712 cpp_token *token = _cpp_temp_token (pfile);
1713 token->type = (*paste_flag)->type;
1714 token->val = (*paste_flag)->val;
1715 if (src->flags & PASTE_LEFT)
1716 token->flags = (*paste_flag)->flags | PASTE_LEFT;
1718 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1719 *paste_flag = token;
1722 i += arg_tokens_count;
1725 if (track_macro_exp)
1726 push_extended_tokens_context (pfile, node, buff, virt_locs, first,
1727 tokens_buff_count (buff));
1729 push_ptoken_context (pfile, node, buff, first,
1730 tokens_buff_count (buff));
1732 num_macro_tokens_counter += tokens_buff_count (buff);
1735 /* Return a special padding token, with padding inherited from SOURCE. */
1736 static const cpp_token *
1737 padding_token (cpp_reader *pfile, const cpp_token *source)
1739 cpp_token *result = _cpp_temp_token (pfile);
1741 result->type = CPP_PADDING;
1743 /* Data in GCed data structures cannot be made const so far, so we
1744 need a cast here. */
1745 result->val.source = (cpp_token *) source;
1750 /* Get a new uninitialized context. Create a new one if we cannot
1751 re-use an old one. */
1752 static cpp_context *
1753 next_context (cpp_reader *pfile)
1755 cpp_context *result = pfile->context->next;
1759 result = XNEW (cpp_context);
1760 memset (result, 0, sizeof (cpp_context));
1761 result->prev = pfile->context;
1763 pfile->context->next = result;
1766 pfile->context = result;
1770 /* Push a list of pointers to tokens. */
1772 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1773 const cpp_token **first, unsigned int count)
1775 cpp_context *context = next_context (pfile);
1777 context->tokens_kind = TOKENS_KIND_INDIRECT;
1778 context->c.macro = macro;
1779 context->buff = buff;
1780 FIRST (context).ptoken = first;
1781 LAST (context).ptoken = first + count;
1784 /* Push a list of tokens. */
1786 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1787 const cpp_token *first, unsigned int count)
1789 cpp_context *context = next_context (pfile);
1791 context->tokens_kind = TOKENS_KIND_DIRECT;
1792 context->c.macro = macro;
1793 context->buff = NULL;
1794 FIRST (context).token = first;
1795 LAST (context).token = first + count;
1798 /* Build a context containing a list of tokens as well as their
1799 virtual locations and push it. TOKENS_BUFF is the buffer that
1800 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
1801 non-NULL, it means that the context owns it, meaning that
1802 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
1803 contains the virtual locations. */
1805 push_extended_tokens_context (cpp_reader *pfile,
1806 cpp_hashnode *macro,
1807 _cpp_buff *token_buff,
1808 source_location *virt_locs,
1809 const cpp_token **first,
1812 cpp_context *context = next_context (pfile);
1815 context->tokens_kind = TOKENS_KIND_EXTENDED;
1816 context->buff = token_buff;
1818 m = XNEW (macro_context);
1819 m->macro_node = macro;
1820 m->virt_locs = virt_locs;
1821 m->cur_virt_loc = virt_locs;
1823 FIRST (context).ptoken = first;
1824 LAST (context).ptoken = first + count;
1827 /* Push a traditional macro's replacement text. */
1829 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1830 const uchar *start, size_t len)
1832 cpp_context *context = next_context (pfile);
1834 context->tokens_kind = TOKENS_KIND_DIRECT;
1835 context->c.macro = macro;
1836 context->buff = NULL;
1837 CUR (context) = start;
1838 RLIMIT (context) = start + len;
1839 macro->flags |= NODE_DISABLED;
1842 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
1843 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
1844 non-null (which means that -ftrack-macro-expansion is on),
1845 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
1846 hold the virtual locations of the tokens resulting from macro
1849 tokens_buff_new (cpp_reader *pfile, size_t len,
1850 source_location **virt_locs)
1852 size_t tokens_size = len * sizeof (cpp_token *);
1853 size_t locs_size = len * sizeof (source_location);
1855 if (virt_locs != NULL)
1856 *virt_locs = XNEWVEC (source_location, locs_size);
1857 return _cpp_get_buff (pfile, tokens_size);
1860 /* Returns the number of tokens contained in a token buffer. The
1861 buffer holds a set of cpp_token*. */
1863 tokens_buff_count (_cpp_buff *buff)
1865 return (BUFF_FRONT (buff) - buff->base) / sizeof (cpp_token *);
1868 /* Return a pointer to the last token contained in the token buffer
1870 static const cpp_token **
1871 tokens_buff_last_token_ptr (_cpp_buff *buff)
1873 return &((const cpp_token **) BUFF_FRONT (buff))[-1];
1876 /* Remove the last token contained in the token buffer TOKENS_BUFF.
1877 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
1878 containing the virtual locations of the tokens in TOKENS_BUFF; in
1879 which case the function updates that buffer as well. */
1881 tokens_buff_remove_last_token (_cpp_buff *tokens_buff)
1884 if (BUFF_FRONT (tokens_buff) > tokens_buff->base)
1885 BUFF_FRONT (tokens_buff) =
1886 (unsigned char *) &((cpp_token **) BUFF_FRONT (tokens_buff))[-1];
1889 /* Insert a token into the token buffer at the position pointed to by
1890 DEST. Note that the buffer is not enlarged so the previous token
1891 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
1892 means -ftrack-macro-expansion is effect; it then points to where to
1893 insert the virtual location of TOKEN. TOKEN is the token to
1894 insert. VIRT_LOC is the virtual location of the token, i.e, the
1895 location possibly encoding its locus accross macro expansion. If
1896 TOKEN is an argument of a function-like macro (inside a macro
1897 replacement list), PARM_DEF_LOC is the spelling location of the
1898 macro parameter that TOKEN is replacing, in the replacement list of
1899 the macro. If TOKEN is not an argument of a function-like macro or
1900 if it doesn't come from a macro expansion, then VIRT_LOC can just
1901 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
1902 means TOKEN comes from a macro expansion and MAP is the macro map
1903 associated to the macro. MACRO_TOKEN_INDEX points to the index of
1904 the token in the macro map; it is not considered if MAP is NULL.
1906 Upon successful completion this function returns the a pointer to
1907 the position of the token coming right after the insertion
1909 static inline const cpp_token **
1910 tokens_buff_put_token_to (const cpp_token **dest,
1911 source_location *virt_loc_dest,
1912 const cpp_token *token,
1913 source_location virt_loc,
1914 source_location parm_def_loc,
1915 const struct line_map *map,
1916 unsigned int macro_token_index)
1918 source_location macro_loc = virt_loc;
1919 const cpp_token **result;
1923 /* -ftrack-macro-expansion is on. */
1925 macro_loc = linemap_add_macro_token (map, macro_token_index,
1926 virt_loc, parm_def_loc);
1927 *virt_loc_dest = macro_loc;
1935 /* Adds a token at the end of the tokens contained in BUFFER. Note
1936 that this function doesn't enlarge BUFFER when the number of tokens
1937 reaches BUFFER's size; it aborts in that situation.
1939 TOKEN is the token to append. VIRT_LOC is the virtual location of
1940 the token, i.e, the location possibly encoding its locus accross
1941 macro expansion. If TOKEN is an argument of a function-like macro
1942 (inside a macro replacement list), PARM_DEF_LOC is the location of
1943 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
1944 from a macro expansion, then VIRT_LOC can just be set to the same
1945 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
1946 from a macro expansion and MAP is the macro map associated to the
1947 macro. MACRO_TOKEN_INDEX points to the index of the token in the
1948 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
1949 non-null, it means -ftrack-macro-expansion is on; in which case
1950 this function adds the virtual location DEF_LOC to the VIRT_LOCS
1951 array, at the same index as the one of TOKEN in BUFFER. Upon
1952 successful completion this function returns the a pointer to the
1953 position of the token coming right after the insertion point. */
1954 static const cpp_token **
1955 tokens_buff_add_token (_cpp_buff *buffer,
1956 source_location *virt_locs,
1957 const cpp_token *token,
1958 source_location virt_loc,
1959 source_location parm_def_loc,
1960 const struct line_map *map,
1961 unsigned int macro_token_index)
1963 const cpp_token **result;
1964 source_location *virt_loc_dest = NULL;
1965 unsigned token_index =
1966 (BUFF_FRONT (buffer) - buffer->base) / sizeof (cpp_token *);
1968 /* Abort if we pass the end the buffer. */
1969 if (BUFF_FRONT (buffer) > BUFF_LIMIT (buffer))
1972 if (virt_locs != NULL)
1973 virt_loc_dest = &virt_locs[token_index];
1976 tokens_buff_put_token_to ((const cpp_token **) BUFF_FRONT (buffer),
1977 virt_loc_dest, token, virt_loc, parm_def_loc,
1978 map, macro_token_index);
1980 BUFF_FRONT (buffer) = (unsigned char *) result;
1984 /* Allocate space for the function-like macro argument ARG to store
1985 the tokens resulting from the macro-expansion of the tokens that
1986 make up ARG itself. That space is allocated in ARG->expanded and
1987 needs to be freed using free. */
1989 alloc_expanded_arg_mem (cpp_reader *pfile, macro_arg *arg, size_t capacity)
1991 #ifdef ENABLE_CHECKING
1992 if (arg->expanded != NULL
1993 || arg->expanded_virt_locs != NULL)
1996 arg->expanded = XNEWVEC (const cpp_token *, capacity);
1997 if (CPP_OPTION (pfile, track_macro_expansion))
1998 arg->expanded_virt_locs = XNEWVEC (source_location, capacity);
2002 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2005 ensure_expanded_arg_room (cpp_reader *pfile, macro_arg *arg,
2006 size_t size, size_t *expanded_capacity)
2008 if (size <= *expanded_capacity)
2014 XRESIZEVEC (const cpp_token *, arg->expanded, size);
2015 *expanded_capacity = size;
2017 if (CPP_OPTION (pfile, track_macro_expansion))
2019 if (arg->expanded_virt_locs == NULL)
2020 arg->expanded_virt_locs = XNEWVEC (source_location, size);
2022 arg->expanded_virt_locs = XRESIZEVEC (source_location,
2023 arg->expanded_virt_locs,
2028 /* Expand an argument ARG before replacing parameters in a
2029 function-like macro. This works by pushing a context with the
2030 argument's tokens, and then expanding that into a temporary buffer
2031 as if it were a normal part of the token stream. collect_args()
2032 has terminated the argument's tokens with a CPP_EOF so that we know
2033 when we have fully expanded the argument. */
2035 expand_arg (cpp_reader *pfile, macro_arg *arg)
2038 bool saved_warn_trad;
2039 bool track_macro_exp_p = CPP_OPTION (pfile, track_macro_expansion);
2042 || arg->expanded != NULL)
2045 /* Don't warn about funlike macros when pre-expanding. */
2046 saved_warn_trad = CPP_WTRADITIONAL (pfile);
2047 CPP_WTRADITIONAL (pfile) = 0;
2049 /* Loop, reading in the tokens of the argument. */
2051 alloc_expanded_arg_mem (pfile, arg, capacity);
2053 if (track_macro_exp_p)
2054 push_extended_tokens_context (pfile, NULL, NULL,
2059 push_ptoken_context (pfile, NULL, NULL,
2060 arg->first, arg->count + 1);
2064 const cpp_token *token;
2065 source_location location;
2067 ensure_expanded_arg_room (pfile, arg, arg->expanded_count + 1,
2070 token = cpp_get_token_1 (pfile, &location);
2072 if (token->type == CPP_EOF)
2075 set_arg_token (arg, token, location,
2076 arg->expanded_count, MACRO_ARG_TOKEN_EXPANDED,
2077 CPP_OPTION (pfile, track_macro_expansion));
2078 arg->expanded_count++;
2081 _cpp_pop_context (pfile);
2083 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
2086 /* Pop the current context off the stack, re-enabling the macro if the
2087 context represented a macro's replacement list. Initially the
2088 context structure was not freed so that we can re-use it later, but
2089 now we do free it to reduce peak memory consumption. */
2091 _cpp_pop_context (cpp_reader *pfile)
2093 cpp_context *context = pfile->context;
2095 if (context->c.macro)
2097 cpp_hashnode *macro;
2098 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
2100 macro_context *mc = context->c.mc;
2101 macro = mc->macro_node;
2102 /* If context->buff is set, it means the life time of tokens
2103 is bound to the life time of this context; so we must
2104 free the tokens; that means we must free the virtual
2105 locations of these tokens too. */
2106 if (context->buff && mc->virt_locs)
2108 free (mc->virt_locs);
2109 mc->virt_locs = NULL;
2112 context->c.mc = NULL;
2115 macro = context->c.macro;
2117 /* Beware that MACRO can be NULL in cases like when we are
2118 called from expand_arg. In those cases, a dummy context with
2119 tokens is pushed just for the purpose of walking them using
2120 cpp_get_token_1. In that case, no 'macro' field is set into
2121 the dummy context. */
2123 macro->flags &= ~NODE_DISABLED;
2128 /* Decrease memory peak consumption by freeing the memory used
2130 _cpp_free_buff (context->buff);
2133 pfile->context = context->prev;
2134 /* decrease peak memory consumption by feeing the context. */
2135 pfile->context->next = NULL;
2139 /* Return TRUE if we reached the end of the set of tokens stored in
2140 CONTEXT, FALSE otherwise. */
2142 reached_end_of_context (cpp_context *context)
2144 if (context->tokens_kind == TOKENS_KIND_DIRECT)
2145 return FIRST (context).token == LAST (context).token;
2146 else if (context->tokens_kind == TOKENS_KIND_INDIRECT
2147 || context->tokens_kind == TOKENS_KIND_EXTENDED)
2148 return FIRST (context).ptoken == LAST (context).ptoken;
2153 /* Consume the next token contained in the current context of PFILE,
2154 and return it in *TOKEN. It's "full location" is returned in
2155 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2156 means the location encoding the locus of the token accross macro
2157 expansion; otherwise it's just is the "normal" location of the
2158 token which (*TOKEN)->src_loc. */
2160 consume_next_token_from_context (cpp_reader *pfile,
2161 const cpp_token ** token,
2162 source_location *location)
2164 cpp_context *c = pfile->context;
2166 if ((c)->tokens_kind == TOKENS_KIND_DIRECT)
2168 *token = FIRST (c).token;
2169 *location = (*token)->src_loc;
2172 else if ((c)->tokens_kind == TOKENS_KIND_INDIRECT)
2174 *token = *FIRST (c).ptoken;
2175 *location = (*token)->src_loc;
2178 else if ((c)->tokens_kind == TOKENS_KIND_EXTENDED)
2180 macro_context *m = c->c.mc;
2181 *token = *FIRST (c).ptoken;
2184 *location = *m->cur_virt_loc;
2188 *location = (*token)->src_loc;
2195 /* In the traditional mode of the preprocessor, if we are currently in
2196 a directive, the location of a token must be the location of the
2197 start of the directive line. This function returns the proper
2198 location if we are in the traditional mode, and just returns
2199 LOCATION otherwise. */
2201 static inline source_location
2202 maybe_adjust_loc_for_trad_cpp (cpp_reader *pfile, source_location location)
2204 if (CPP_OPTION (pfile, traditional))
2206 if (pfile->state.in_directive)
2207 return pfile->directive_line;
2212 /* Routine to get a token as well as its location.
2214 Macro expansions and directives are transparently handled,
2215 including entering included files. Thus tokens are post-macro
2216 expansion, and after any intervening directives. External callers
2217 see CPP_EOF only at EOF. Internal callers also see it when meeting
2218 a directive inside a macro call, when at the end of a directive and
2219 state.in_directive is still 1, and at the end of argument
2222 LOC is an out parameter; *LOC is set to the location "as expected
2223 by the user". Please read the comment of
2224 cpp_get_token_with_location to learn more about the meaning of this
2226 static const cpp_token*
2227 cpp_get_token_1 (cpp_reader *pfile, source_location *location)
2229 const cpp_token *result;
2230 bool can_set = pfile->set_invocation_location;
2231 /* This token is a virtual token that either encodes a location
2232 related to macro expansion or a spelling location. */
2233 source_location virt_loc = 0;
2234 pfile->set_invocation_location = false;
2239 cpp_context *context = pfile->context;
2241 /* Context->prev == 0 <=> base context. */
2244 result = _cpp_lex_token (pfile);
2245 virt_loc = result->src_loc;
2247 else if (!reached_end_of_context (context))
2249 consume_next_token_from_context (pfile, &result,
2251 if (result->flags & PASTE_LEFT)
2253 paste_all_tokens (pfile, result);
2254 if (pfile->state.in_directive)
2256 result = padding_token (pfile, result);
2262 if (pfile->context->c.macro)
2263 ++num_expanded_macros_counter;
2264 _cpp_pop_context (pfile);
2265 if (pfile->state.in_directive)
2267 result = &pfile->avoid_paste;
2271 if (pfile->state.in_directive && result->type == CPP_COMMENT)
2274 if (result->type != CPP_NAME)
2277 node = result->val.node.node;
2279 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
2282 if (!(node->flags & NODE_DISABLED))
2285 /* If not in a macro context, and we're going to start an
2286 expansion, record the location. */
2287 if (can_set && !context->c.macro)
2288 pfile->invocation_location = result->src_loc;
2289 if (pfile->state.prevent_expansion)
2292 /* Conditional macros require that a predicate be evaluated
2294 if ((node->flags & NODE_CONDITIONAL) != 0)
2296 if (pfile->cb.macro_to_expand)
2298 bool whitespace_after;
2299 const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
2301 whitespace_after = (peek_tok->type == CPP_PADDING
2302 || (peek_tok->flags & PREV_WHITE));
2303 node = pfile->cb.macro_to_expand (pfile, result);
2305 ret = enter_macro_context (pfile, node, result,
2307 else if (whitespace_after)
2309 /* If macro_to_expand hook returned NULL and it
2310 ate some tokens, see if we don't need to add
2311 a padding token in between this and the
2313 peek_tok = cpp_peek_token (pfile, 0);
2314 if (peek_tok->type != CPP_PADDING
2315 && (peek_tok->flags & PREV_WHITE) == 0)
2316 _cpp_push_token_context (pfile, NULL,
2317 padding_token (pfile,
2323 ret = enter_macro_context (pfile, node, result,
2327 if (pfile->state.in_directive || ret == 2)
2329 result = padding_token (pfile, result);
2335 /* Flag this token as always unexpandable. FIXME: move this
2336 to collect_args()?. */
2337 cpp_token *t = _cpp_temp_token (pfile);
2338 t->type = result->type;
2339 t->flags = result->flags | NO_EXPAND;
2340 t->val = result->val;
2348 if (location != NULL)
2351 virt_loc = result->src_loc;
2352 *location = virt_loc;
2354 if (!CPP_OPTION (pfile, track_macro_expansion)
2356 && pfile->context->c.macro != NULL)
2357 /* We are in a macro expansion context, are not tracking
2358 virtual location, but were asked to report the location
2359 of the expansion point of the macro being expanded. */
2360 *location = pfile->invocation_location;
2362 *location = maybe_adjust_loc_for_trad_cpp (pfile, *location);
2367 /* External routine to get a token. Also used nearly everywhere
2368 internally, except for places where we know we can safely call
2369 _cpp_lex_token directly, such as lexing a directive name.
2371 Macro expansions and directives are transparently handled,
2372 including entering included files. Thus tokens are post-macro
2373 expansion, and after any intervening directives. External callers
2374 see CPP_EOF only at EOF. Internal callers also see it when meeting
2375 a directive inside a macro call, when at the end of a directive and
2376 state.in_directive is still 1, and at the end of argument
2379 cpp_get_token (cpp_reader *pfile)
2381 return cpp_get_token_1 (pfile, NULL);
2384 /* Like cpp_get_token, but also returns a virtual token location
2385 separate from the spelling location carried by the returned token.
2387 LOC is an out parameter; *LOC is set to the location "as expected
2388 by the user". This matters when a token results from macro
2389 expansion; in that case the token's spelling location indicates the
2390 locus of the token in the definition of the macro but *LOC
2391 virtually encodes all the other meaningful locuses associated to
2394 What? virtual location? Yes, virtual location.
2396 If the token results from macro expansion and if macro expansion
2397 location tracking is enabled its virtual location encodes (at the
2400 - the spelling location of the token
2402 - the locus of the macro expansion point
2404 - the locus of the point where the token got instantiated as part
2405 of the macro expansion process.
2407 You have to use the linemap API to get the locus you are interested
2408 in from a given virtual location.
2410 Note however that virtual locations are not necessarily ordered for
2411 relations '<' and '>'. One must use the function
2412 linemap_location_before_p instead of using the relational operator
2415 If macro expansion tracking is off and if the token results from
2416 macro expansion the virtual location is the expansion point of the
2417 macro that got expanded.
2419 When the token doesn't result from macro expansion, the virtual
2420 location is just the same thing as its spelling location. */
2423 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
2425 const cpp_token *result;
2427 pfile->set_invocation_location = true;
2428 result = cpp_get_token_1 (pfile, loc);
2432 /* Returns true if we're expanding an object-like macro that was
2433 defined in a system header. Just checks the macro at the top of
2434 the stack. Used for diagnostic suppression. */
2436 cpp_sys_macro_p (cpp_reader *pfile)
2438 cpp_hashnode *node = pfile->context->c.macro;
2440 return node && node->value.macro && node->value.macro->syshdr;
2443 /* Read each token in, until end of the current file. Directives are
2444 transparently processed. */
2446 cpp_scan_nooutput (cpp_reader *pfile)
2448 /* Request a CPP_EOF token at the end of this file, rather than
2449 transparently continuing with the including file. */
2450 pfile->buffer->return_at_eof = true;
2452 pfile->state.discarding_output++;
2453 pfile->state.prevent_expansion++;
2455 if (CPP_OPTION (pfile, traditional))
2456 while (_cpp_read_logical_line_trad (pfile))
2459 while (cpp_get_token (pfile)->type != CPP_EOF)
2462 pfile->state.discarding_output--;
2463 pfile->state.prevent_expansion--;
2466 /* Step back one or more tokens obtained from the lexer. */
2468 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
2470 pfile->lookaheads += count;
2474 if (pfile->cur_token == pfile->cur_run->base
2475 /* Possible with -fpreprocessed and no leading #line. */
2476 && pfile->cur_run->prev != NULL)
2478 pfile->cur_run = pfile->cur_run->prev;
2479 pfile->cur_token = pfile->cur_run->limit;
2484 /* Step back one (or more) tokens. Can only step back more than 1 if
2485 they are from the lexer, and not from macro expansion. */
2487 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
2489 if (pfile->context->prev == NULL)
2490 _cpp_backup_tokens_direct (pfile, count);
2495 if (pfile->context->tokens_kind == TOKENS_KIND_DIRECT)
2496 FIRST (pfile->context).token--;
2497 else if (pfile->context->tokens_kind == TOKENS_KIND_INDIRECT)
2498 FIRST (pfile->context).ptoken--;
2499 else if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
2501 FIRST (pfile->context).ptoken--;
2502 if (pfile->context->c.macro)
2504 macro_context *m = pfile->context->c.mc;
2506 #ifdef ENABLE_CHECKING
2507 if (m->cur_virt_loc < m->virt_locs)
2519 /* #define directive parsing and handling. */
2521 /* Returns nonzero if a macro redefinition warning is required. */
2523 warn_of_redefinition (cpp_reader *pfile, cpp_hashnode *node,
2524 const cpp_macro *macro2)
2526 const cpp_macro *macro1;
2529 /* Some redefinitions need to be warned about regardless. */
2530 if (node->flags & NODE_WARN)
2533 /* Suppress warnings for builtins that lack the NODE_WARN flag. */
2534 if (node->flags & NODE_BUILTIN)
2536 if (!pfile->cb.user_builtin_macro
2537 || !pfile->cb.user_builtin_macro (pfile, node))
2541 /* Redefinitions of conditional (context-sensitive) macros, on
2542 the other hand, must be allowed silently. */
2543 if (node->flags & NODE_CONDITIONAL)
2546 /* Redefinition of a macro is allowed if and only if the old and new
2547 definitions are the same. (6.10.3 paragraph 2). */
2548 macro1 = node->value.macro;
2550 /* Don't check count here as it can be different in valid
2551 traditional redefinitions with just whitespace differences. */
2552 if (macro1->paramc != macro2->paramc
2553 || macro1->fun_like != macro2->fun_like
2554 || macro1->variadic != macro2->variadic)
2557 /* Check parameter spellings. */
2558 for (i = 0; i < macro1->paramc; i++)
2559 if (macro1->params[i] != macro2->params[i])
2562 /* Check the replacement text or tokens. */
2563 if (CPP_OPTION (pfile, traditional))
2564 return _cpp_expansions_different_trad (macro1, macro2);
2566 if (macro1->count != macro2->count)
2569 for (i = 0; i < macro1->count; i++)
2570 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
2576 /* Free the definition of hashnode H. */
2578 _cpp_free_definition (cpp_hashnode *h)
2580 /* Macros and assertions no longer have anything to free. */
2582 /* Clear builtin flag in case of redefinition. */
2583 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
2586 /* Save parameter NODE to the parameter list of macro MACRO. Returns
2587 zero on success, nonzero if the parameter is a duplicate. */
2589 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
2592 /* Constraint 6.10.3.6 - duplicate parameter names. */
2593 if (node->flags & NODE_MACRO_ARG)
2595 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
2600 if (BUFF_ROOM (pfile->a_buff)
2601 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
2602 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
2604 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
2605 node->flags |= NODE_MACRO_ARG;
2606 len = macro->paramc * sizeof (union _cpp_hashnode_value);
2607 if (len > pfile->macro_buffer_len)
2609 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
2611 pfile->macro_buffer_len = len;
2613 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
2616 node->value.arg_index = macro->paramc;
2620 /* Check the syntax of the parameters in a MACRO definition. Returns
2621 false if an error occurs. */
2623 parse_params (cpp_reader *pfile, cpp_macro *macro)
2625 unsigned int prev_ident = 0;
2629 const cpp_token *token = _cpp_lex_token (pfile);
2631 switch (token->type)
2634 /* Allow/ignore comments in parameter lists if we are
2635 preserving comments in macro expansions. */
2636 if (token->type == CPP_COMMENT
2637 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
2640 cpp_error (pfile, CPP_DL_ERROR,
2641 "\"%s\" may not appear in macro parameter list",
2642 cpp_token_as_text (pfile, token));
2648 cpp_error (pfile, CPP_DL_ERROR,
2649 "macro parameters must be comma-separated");
2654 if (_cpp_save_parameter (pfile, macro, token->val.node.node))
2658 case CPP_CLOSE_PAREN:
2659 if (prev_ident || macro->paramc == 0)
2662 /* Fall through to pick up the error. */
2666 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
2673 macro->variadic = 1;
2676 _cpp_save_parameter (pfile, macro,
2677 pfile->spec_nodes.n__VA_ARGS__);
2678 pfile->state.va_args_ok = 1;
2679 if (! CPP_OPTION (pfile, c99)
2680 && CPP_OPTION (pfile, cpp_pedantic)
2681 && CPP_OPTION (pfile, warn_variadic_macros))
2683 (pfile, CPP_W_VARIADIC_MACROS,
2684 "anonymous variadic macros were introduced in C99");
2686 else if (CPP_OPTION (pfile, cpp_pedantic)
2687 && CPP_OPTION (pfile, warn_variadic_macros))
2688 cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
2689 "ISO C does not permit named variadic macros");
2691 /* We're at the end, and just expect a closing parenthesis. */
2692 token = _cpp_lex_token (pfile);
2693 if (token->type == CPP_CLOSE_PAREN)
2698 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
2704 /* Allocate room for a token from a macro's replacement list. */
2706 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
2708 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
2709 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
2711 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
2714 /* Lex a token from the expansion of MACRO, but mark parameters as we
2715 find them and warn of traditional stringification. */
2717 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
2719 cpp_token *token, *saved_cur_token;
2721 saved_cur_token = pfile->cur_token;
2722 pfile->cur_token = alloc_expansion_token (pfile, macro);
2723 token = _cpp_lex_direct (pfile);
2724 pfile->cur_token = saved_cur_token;
2726 /* Is this a parameter? */
2727 if (token->type == CPP_NAME
2728 && (token->val.node.node->flags & NODE_MACRO_ARG) != 0)
2730 token->type = CPP_MACRO_ARG;
2731 token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
2733 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
2734 && (token->type == CPP_STRING || token->type == CPP_CHAR))
2735 check_trad_stringification (pfile, macro, &token->val.str);
2741 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
2744 const cpp_token *ctoken;
2745 bool following_paste_op = false;
2746 const char *paste_op_error_msg =
2747 N_("'##' cannot appear at either end of a macro expansion");
2748 unsigned int num_extra_tokens = 0;
2750 /* Get the first token of the expansion (or the '(' of a
2751 function-like macro). */
2752 ctoken = _cpp_lex_token (pfile);
2754 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
2756 bool ok = parse_params (pfile, macro);
2757 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
2761 /* Success. Commit or allocate the parameter array. */
2762 if (pfile->hash_table->alloc_subobject)
2764 cpp_hashnode **params =
2765 (cpp_hashnode **) pfile->hash_table->alloc_subobject
2766 (sizeof (cpp_hashnode *) * macro->paramc);
2767 memcpy (params, macro->params,
2768 sizeof (cpp_hashnode *) * macro->paramc);
2769 macro->params = params;
2772 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
2773 macro->fun_like = 1;
2775 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
2777 /* While ISO C99 requires whitespace before replacement text
2778 in a macro definition, ISO C90 with TC1 allows there characters
2779 from the basic source character set. */
2780 if (CPP_OPTION (pfile, c99))
2781 cpp_error (pfile, CPP_DL_PEDWARN,
2782 "ISO C99 requires whitespace after the macro name");
2785 int warntype = CPP_DL_WARNING;
2786 switch (ctoken->type)
2790 case CPP_OBJC_STRING:
2791 /* '@' is not in basic character set. */
2792 warntype = CPP_DL_PEDWARN;
2795 /* Basic character set sans letters, digits and _. */
2796 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
2797 ctoken->val.str.text[0]) == NULL)
2798 warntype = CPP_DL_PEDWARN;
2801 /* All other tokens start with a character from basic
2805 cpp_error (pfile, warntype,
2806 "missing whitespace after the macro name");
2810 if (macro->fun_like)
2811 token = lex_expansion_token (pfile, macro);
2814 token = alloc_expansion_token (pfile, macro);
2820 /* Check the stringifying # constraint 6.10.3.2.1 of
2821 function-like macros when lexing the subsequent token. */
2822 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
2824 if (token->type == CPP_MACRO_ARG)
2826 if (token->flags & PREV_WHITE)
2827 token->flags |= SP_PREV_WHITE;
2828 if (token[-1].flags & DIGRAPH)
2829 token->flags |= SP_DIGRAPH;
2830 token->flags &= ~PREV_WHITE;
2831 token->flags |= STRINGIFY_ARG;
2832 token->flags |= token[-1].flags & PREV_WHITE;
2833 token[-1] = token[0];
2836 /* Let assembler get away with murder. */
2837 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
2839 cpp_error (pfile, CPP_DL_ERROR,
2840 "'#' is not followed by a macro parameter");
2845 if (token->type == CPP_EOF)
2847 /* Paste operator constraint 6.10.3.3.1:
2848 Token-paste ##, can appear in both object-like and
2849 function-like macros, but not at the end. */
2850 if (following_paste_op)
2852 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
2858 /* Paste operator constraint 6.10.3.3.1. */
2859 if (token->type == CPP_PASTE)
2861 /* Token-paste ##, can appear in both object-like and
2862 function-like macros, but not at the beginning. */
2863 if (macro->count == 1)
2865 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
2869 if (token[-1].flags & PASTE_LEFT)
2871 macro->extra_tokens = 1;
2873 token->val.token_no = macro->count - 1;
2878 token[-1].flags |= PASTE_LEFT;
2879 if (token->flags & DIGRAPH)
2880 token[-1].flags |= SP_DIGRAPH;
2881 if (token->flags & PREV_WHITE)
2882 token[-1].flags |= SP_PREV_WHITE;
2886 following_paste_op = (token->type == CPP_PASTE);
2887 token = lex_expansion_token (pfile, macro);
2890 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
2891 macro->traditional = 0;
2893 /* Don't count the CPP_EOF. */
2896 /* Clear whitespace on first token for warn_of_redefinition(). */
2898 macro->exp.tokens[0].flags &= ~PREV_WHITE;
2900 /* Commit or allocate the memory. */
2901 if (pfile->hash_table->alloc_subobject)
2904 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
2906 if (num_extra_tokens)
2908 /* Place second and subsequent ## or %:%: tokens in
2909 sequences of consecutive such tokens at the end of the
2910 list to preserve information about where they appear, how
2911 they are spelt and whether they are preceded by
2912 whitespace without otherwise interfering with macro
2914 cpp_token *normal_dest = tokns;
2915 cpp_token *extra_dest = tokns + macro->count - num_extra_tokens;
2917 for (i = 0; i < macro->count; i++)
2919 if (macro->exp.tokens[i].type == CPP_PASTE)
2920 *extra_dest++ = macro->exp.tokens[i];
2922 *normal_dest++ = macro->exp.tokens[i];
2926 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
2927 macro->exp.tokens = tokns;
2930 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
2935 /* Parse a macro and save its expansion. Returns nonzero on success. */
2937 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
2943 if (pfile->hash_table->alloc_subobject)
2944 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
2945 (sizeof (cpp_macro));
2947 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
2948 macro->line = pfile->directive_line;
2951 macro->variadic = 0;
2952 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
2954 macro->fun_like = 0;
2955 macro->extra_tokens = 0;
2956 /* To suppress some diagnostics. */
2957 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
2959 if (CPP_OPTION (pfile, traditional))
2960 ok = _cpp_create_trad_definition (pfile, macro);
2963 ok = create_iso_definition (pfile, macro);
2965 /* We set the type for SEEN_EOL() in directives.c.
2967 Longer term we should lex the whole line before coming here,
2968 and just copy the expansion. */
2970 /* Stop the lexer accepting __VA_ARGS__. */
2971 pfile->state.va_args_ok = 0;
2974 /* Clear the fast argument lookup indices. */
2975 for (i = macro->paramc; i-- > 0; )
2977 struct cpp_hashnode *node = macro->params[i];
2978 node->flags &= ~ NODE_MACRO_ARG;
2979 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
2985 if (node->type == NT_MACRO)
2987 if (CPP_OPTION (pfile, warn_unused_macros))
2988 _cpp_warn_if_unused_macro (pfile, node, NULL);
2990 if (warn_of_redefinition (pfile, node, macro))
2992 const int reason = (node->flags & NODE_BUILTIN)
2993 ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
2996 warned = cpp_pedwarning_with_line (pfile, reason,
2997 pfile->directive_line, 0,
3001 if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
3002 cpp_error_with_line (pfile, CPP_DL_NOTE,
3003 node->value.macro->line, 0,
3004 "this is the location of the previous definition");
3008 if (node->type != NT_VOID)
3009 _cpp_free_definition (node);
3011 /* Enter definition in hash table. */
3012 node->type = NT_MACRO;
3013 node->value.macro = macro;
3014 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
3015 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
3016 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3017 in the C standard, as something that one must use in C++.
3018 However DR#593 indicates that these aren't actually mentioned
3019 in the C++ standard. We special-case them anyway. */
3020 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
3021 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
3022 node->flags |= NODE_WARN;
3024 /* If user defines one of the conditional macros, remove the
3026 node->flags &= ~NODE_CONDITIONAL;
3031 /* Warn if a token in STRING matches one of a function-like MACRO's
3034 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
3035 const cpp_string *string)
3037 unsigned int i, len;
3038 const uchar *p, *q, *limit;
3040 /* Loop over the string. */
3041 limit = string->text + string->len - 1;
3042 for (p = string->text + 1; p < limit; p = q)
3044 /* Find the start of an identifier. */
3045 while (p < limit && !is_idstart (*p))
3048 /* Find the end of the identifier. */
3050 while (q < limit && is_idchar (*q))
3055 /* Loop over the function macro arguments to see if the
3056 identifier inside the string matches one of them. */
3057 for (i = 0; i < macro->paramc; i++)
3059 const cpp_hashnode *node = macro->params[i];
3061 if (NODE_LEN (node) == len
3062 && !memcmp (p, NODE_NAME (node), len))
3064 cpp_error (pfile, CPP_DL_WARNING,
3065 "macro argument \"%s\" would be stringified in traditional C",
3073 /* Returns the name, arguments and expansion of a macro, in a format
3074 suitable to be read back in again, and therefore also for DWARF 2
3075 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3076 Caller is expected to generate the "#define" bit if needed. The
3077 returned text is temporary, and automatically freed later. */
3078 const unsigned char *
3079 cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node)
3081 unsigned int i, len;
3082 const cpp_macro *macro;
3083 unsigned char *buffer;
3085 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
3087 if (node->type != NT_MACRO
3088 || !pfile->cb.user_builtin_macro
3089 || !pfile->cb.user_builtin_macro (pfile, node))
3091 cpp_error (pfile, CPP_DL_ICE,
3092 "invalid hash type %d in cpp_macro_definition",
3098 macro = node->value.macro;
3099 /* Calculate length. */
3100 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
3101 if (macro->fun_like)
3103 len += 4; /* "()" plus possible final ".." of named
3104 varargs (we have + 1 below). */
3105 for (i = 0; i < macro->paramc; i++)
3106 len += NODE_LEN (macro->params[i]) + 1; /* "," */
3109 /* This should match below where we fill in the buffer. */
3110 if (CPP_OPTION (pfile, traditional))
3111 len += _cpp_replacement_text_len (macro);
3114 unsigned int count = macro_real_token_count (macro);
3115 for (i = 0; i < count; i++)
3117 cpp_token *token = ¯o->exp.tokens[i];
3119 if (token->type == CPP_MACRO_ARG)
3120 len += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
3122 len += cpp_token_len (token);
3124 if (token->flags & STRINGIFY_ARG)
3126 if (token->flags & PASTE_LEFT)
3127 len += 3; /* " ##" */
3128 if (token->flags & PREV_WHITE)
3133 if (len > pfile->macro_buffer_len)
3135 pfile->macro_buffer = XRESIZEVEC (unsigned char,
3136 pfile->macro_buffer, len);
3137 pfile->macro_buffer_len = len;
3140 /* Fill in the buffer. Start with the macro name. */
3141 buffer = pfile->macro_buffer;
3142 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
3143 buffer += NODE_LEN (node);
3145 /* Parameter names. */
3146 if (macro->fun_like)
3149 for (i = 0; i < macro->paramc; i++)
3151 cpp_hashnode *param = macro->params[i];
3153 if (param != pfile->spec_nodes.n__VA_ARGS__)
3155 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
3156 buffer += NODE_LEN (param);
3159 if (i + 1 < macro->paramc)
3160 /* Don't emit a space after the comma here; we're trying
3161 to emit a Dwarf-friendly definition, and the Dwarf spec
3162 forbids spaces in the argument list. */
3164 else if (macro->variadic)
3165 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
3170 /* The Dwarf spec requires a space after the macro name, even if the
3171 definition is the empty string. */
3174 if (CPP_OPTION (pfile, traditional))
3175 buffer = _cpp_copy_replacement_text (macro, buffer);
3176 else if (macro->count)
3177 /* Expansion tokens. */
3179 unsigned int count = macro_real_token_count (macro);
3180 for (i = 0; i < count; i++)
3182 cpp_token *token = ¯o->exp.tokens[i];
3184 if (token->flags & PREV_WHITE)
3186 if (token->flags & STRINGIFY_ARG)
3189 if (token->type == CPP_MACRO_ARG)
3192 NODE_NAME (macro->params[token->val.macro_arg.arg_no - 1]),
3193 NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]));
3194 buffer += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
3197 buffer = cpp_spell_token (pfile, token, buffer, false);
3199 if (token->flags & PASTE_LEFT)
3204 /* Next has PREV_WHITE; see _cpp_create_definition. */
3210 return pfile->macro_buffer;