* gcc.dg/tree-ssa/pr64801.c: Fix scan-tree-dump-not directive.
[official-gcc.git] / libcpp / macro.c
blob95713450c2760586eff9760074539e393eb60b30
1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986-2015 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
10 later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
25 #include "config.h"
26 #include "system.h"
27 #include "cpplib.h"
28 #include "internal.h"
30 typedef struct macro_arg macro_arg;
31 /* This structure represents the tokens of a macro argument. These
32 tokens can be macro themselves, in which case they can be either
33 expanded or unexpanded. When they are expanded, this data
34 structure keeps both the expanded and unexpanded forms. */
35 struct macro_arg
37 const cpp_token **first; /* First token in unexpanded argument. */
38 const cpp_token **expanded; /* Macro-expanded argument. */
39 const cpp_token *stringified; /* Stringified argument. */
40 unsigned int count; /* # of tokens in argument. */
41 unsigned int expanded_count; /* # of tokens in expanded argument. */
42 source_location *virt_locs; /* Where virtual locations for
43 unexpanded tokens are stored. */
44 source_location *expanded_virt_locs; /* Where virtual locations for
45 expanded tokens are
46 stored. */
49 /* The kind of macro tokens which the instance of
50 macro_arg_token_iter is supposed to iterate over. */
51 enum macro_arg_token_kind {
52 MACRO_ARG_TOKEN_NORMAL,
53 /* This is a macro argument token that got transformed into a string
54 litteral, e.g. #foo. */
55 MACRO_ARG_TOKEN_STRINGIFIED,
56 /* This is a token resulting from the expansion of a macro
57 argument that was itself a macro. */
58 MACRO_ARG_TOKEN_EXPANDED
61 /* An iterator over tokens coming from a function-like macro
62 argument. */
63 typedef struct macro_arg_token_iter macro_arg_token_iter;
64 struct macro_arg_token_iter
66 /* Whether or not -ftrack-macro-expansion is used. */
67 bool track_macro_exp_p;
68 /* The kind of token over which we are supposed to iterate. */
69 enum macro_arg_token_kind kind;
70 /* A pointer to the current token pointed to by the iterator. */
71 const cpp_token **token_ptr;
72 /* A pointer to the "full" location of the current token. If
73 -ftrack-macro-expansion is used this location tracks loci across
74 macro expansion. */
75 const source_location *location_ptr;
76 #ifdef ENABLE_CHECKING
77 /* The number of times the iterator went forward. This useful only
78 when checking is enabled. */
79 size_t num_forwards;
80 #endif
83 /* Saved data about an identifier being used as a macro argument
84 name. */
85 struct macro_arg_saved_data {
86 /* The canonical (UTF-8) spelling of this identifier. */
87 cpp_hashnode *canonical_node;
88 /* The previous value of this identifier. */
89 union _cpp_hashnode_value value;
92 /* Macro expansion. */
94 static int enter_macro_context (cpp_reader *, cpp_hashnode *,
95 const cpp_token *, source_location);
96 static int builtin_macro (cpp_reader *, cpp_hashnode *, source_location);
97 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
98 const cpp_token **, unsigned int);
99 static void push_extended_tokens_context (cpp_reader *, cpp_hashnode *,
100 _cpp_buff *, source_location *,
101 const cpp_token **, unsigned int);
102 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
103 _cpp_buff **, unsigned *);
104 static cpp_context *next_context (cpp_reader *);
105 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
106 static void expand_arg (cpp_reader *, macro_arg *);
107 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
108 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
109 static void paste_all_tokens (cpp_reader *, const cpp_token *);
110 static bool paste_tokens (cpp_reader *, source_location,
111 const cpp_token **, const cpp_token *);
112 static void alloc_expanded_arg_mem (cpp_reader *, macro_arg *, size_t);
113 static void ensure_expanded_arg_room (cpp_reader *, macro_arg *, size_t, size_t *);
114 static void delete_macro_args (_cpp_buff*, unsigned num_args);
115 static void set_arg_token (macro_arg *, const cpp_token *,
116 source_location, size_t,
117 enum macro_arg_token_kind,
118 bool);
119 static const source_location *get_arg_token_location (const macro_arg *,
120 enum macro_arg_token_kind);
121 static const cpp_token **arg_token_ptr_at (const macro_arg *,
122 size_t,
123 enum macro_arg_token_kind,
124 source_location **virt_location);
126 static void macro_arg_token_iter_init (macro_arg_token_iter *, bool,
127 enum macro_arg_token_kind,
128 const macro_arg *,
129 const cpp_token **);
130 static const cpp_token *macro_arg_token_iter_get_token
131 (const macro_arg_token_iter *it);
132 static source_location macro_arg_token_iter_get_location
133 (const macro_arg_token_iter *);
134 static void macro_arg_token_iter_forward (macro_arg_token_iter *);
135 static _cpp_buff *tokens_buff_new (cpp_reader *, size_t,
136 source_location **);
137 static size_t tokens_buff_count (_cpp_buff *);
138 static const cpp_token **tokens_buff_last_token_ptr (_cpp_buff *);
139 static inline const cpp_token **tokens_buff_put_token_to (const cpp_token **,
140 source_location *,
141 const cpp_token *,
142 source_location,
143 source_location,
144 const struct line_map *,
145 unsigned int);
147 static const cpp_token **tokens_buff_add_token (_cpp_buff *,
148 source_location *,
149 const cpp_token *,
150 source_location,
151 source_location,
152 const struct line_map *,
153 unsigned int);
154 static inline void tokens_buff_remove_last_token (_cpp_buff *);
155 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
156 macro_arg *, source_location);
157 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
158 _cpp_buff **, unsigned *);
159 static bool create_iso_definition (cpp_reader *, cpp_macro *);
161 /* #define directive parsing and handling. */
163 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
164 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
165 static bool warn_of_redefinition (cpp_reader *, cpp_hashnode *,
166 const cpp_macro *);
167 static bool parse_params (cpp_reader *, cpp_macro *);
168 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
169 const cpp_string *);
170 static bool reached_end_of_context (cpp_context *);
171 static void consume_next_token_from_context (cpp_reader *pfile,
172 const cpp_token **,
173 source_location *);
174 static const cpp_token* cpp_get_token_1 (cpp_reader *, source_location *);
176 static cpp_hashnode* macro_of_context (cpp_context *context);
178 static bool in_macro_expansion_p (cpp_reader *pfile);
180 /* Statistical counter tracking the number of macros that got
181 expanded. */
182 unsigned num_expanded_macros_counter = 0;
183 /* Statistical counter tracking the total number tokens resulting
184 from macro expansion. */
185 unsigned num_macro_tokens_counter = 0;
187 /* Emits a warning if NODE is a macro defined in the main file that
188 has not been used. */
190 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
191 void *v ATTRIBUTE_UNUSED)
193 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
195 cpp_macro *macro = node->value.macro;
197 if (!macro->used
198 && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
199 cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, macro->line, 0,
200 "macro \"%s\" is not used", NODE_NAME (node));
203 return 1;
206 /* Allocates and returns a CPP_STRING token, containing TEXT of length
207 LEN, after null-terminating it. TEXT must be in permanent storage. */
208 static const cpp_token *
209 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
211 cpp_token *token = _cpp_temp_token (pfile);
213 text[len] = '\0';
214 token->type = CPP_STRING;
215 token->val.str.len = len;
216 token->val.str.text = text;
217 token->flags = 0;
218 return token;
221 static const char * const monthnames[] =
223 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
224 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
227 /* Helper function for builtin_macro. Returns the text generated by
228 a builtin macro. */
229 const uchar *
230 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
232 const uchar *result = NULL;
233 linenum_type number = 1;
235 switch (node->value.builtin)
237 default:
238 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
239 NODE_NAME (node));
240 break;
242 case BT_TIMESTAMP:
244 if (CPP_OPTION (pfile, warn_date_time))
245 cpp_warning (pfile, CPP_W_DATE_TIME, "macro \"%s\" might prevent "
246 "reproducible builds", NODE_NAME (node));
248 cpp_buffer *pbuffer = cpp_get_buffer (pfile);
249 if (pbuffer->timestamp == NULL)
251 /* Initialize timestamp value of the assotiated file. */
252 struct _cpp_file *file = cpp_get_file (pbuffer);
253 if (file)
255 /* Generate __TIMESTAMP__ string, that represents
256 the date and time of the last modification
257 of the current source file. The string constant
258 looks like "Sun Sep 16 01:03:52 1973". */
259 struct tm *tb = NULL;
260 struct stat *st = _cpp_get_file_stat (file);
261 if (st)
262 tb = localtime (&st->st_mtime);
263 if (tb)
265 char *str = asctime (tb);
266 size_t len = strlen (str);
267 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
268 buf[0] = '"';
269 strcpy ((char *) buf + 1, str);
270 buf[len] = '"';
271 pbuffer->timestamp = buf;
273 else
275 cpp_errno (pfile, CPP_DL_WARNING,
276 "could not determine file timestamp");
277 pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
281 result = pbuffer->timestamp;
283 break;
284 case BT_FILE:
285 case BT_BASE_FILE:
287 unsigned int len;
288 const char *name;
289 uchar *buf;
291 if (node->value.builtin == BT_FILE)
292 name = linemap_get_expansion_filename (pfile->line_table,
293 pfile->line_table->highest_line);
294 else
296 name = _cpp_get_file_name (pfile->main_file);
297 if (!name)
298 abort ();
300 len = strlen (name);
301 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
302 result = buf;
303 *buf = '"';
304 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
305 *buf++ = '"';
306 *buf = '\0';
308 break;
310 case BT_INCLUDE_LEVEL:
311 /* The line map depth counts the primary source as level 1, but
312 historically __INCLUDE_DEPTH__ has called the primary source
313 level 0. */
314 number = pfile->line_table->depth - 1;
315 break;
317 case BT_SPECLINE:
318 /* If __LINE__ is embedded in a macro, it must expand to the
319 line of the macro's invocation, not its definition.
320 Otherwise things like assert() will not work properly. */
321 number = linemap_get_expansion_line (pfile->line_table,
322 CPP_OPTION (pfile, traditional)
323 ? pfile->line_table->highest_line
324 : pfile->cur_token[-1].src_loc);
325 break;
327 /* __STDC__ has the value 1 under normal circumstances.
328 However, if (a) we are in a system header, (b) the option
329 stdc_0_in_system_headers is true (set by target config), and
330 (c) we are not in strictly conforming mode, then it has the
331 value 0. (b) and (c) are already checked in cpp_init_builtins. */
332 case BT_STDC:
333 if (cpp_in_system_header (pfile))
334 number = 0;
335 else
336 number = 1;
337 break;
339 case BT_DATE:
340 case BT_TIME:
341 if (CPP_OPTION (pfile, warn_date_time))
342 cpp_warning (pfile, CPP_W_DATE_TIME, "macro \"%s\" might prevent "
343 "reproducible builds", NODE_NAME (node));
344 if (pfile->date == NULL)
346 /* Allocate __DATE__ and __TIME__ strings from permanent
347 storage. We only do this once, and don't generate them
348 at init time, because time() and localtime() are very
349 slow on some systems. */
350 time_t tt;
351 struct tm *tb = NULL;
353 /* (time_t) -1 is a legitimate value for "number of seconds
354 since the Epoch", so we have to do a little dance to
355 distinguish that from a genuine error. */
356 errno = 0;
357 tt = time(NULL);
358 if (tt != (time_t)-1 || errno == 0)
359 tb = localtime (&tt);
361 if (tb)
363 pfile->date = _cpp_unaligned_alloc (pfile,
364 sizeof ("\"Oct 11 1347\""));
365 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
366 monthnames[tb->tm_mon], tb->tm_mday,
367 tb->tm_year + 1900);
369 pfile->time = _cpp_unaligned_alloc (pfile,
370 sizeof ("\"12:34:56\""));
371 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
372 tb->tm_hour, tb->tm_min, tb->tm_sec);
374 else
376 cpp_errno (pfile, CPP_DL_WARNING,
377 "could not determine date and time");
379 pfile->date = UC"\"??? ?? ????\"";
380 pfile->time = UC"\"??:??:??\"";
384 if (node->value.builtin == BT_DATE)
385 result = pfile->date;
386 else
387 result = pfile->time;
388 break;
390 case BT_COUNTER:
391 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
392 cpp_error (pfile, CPP_DL_ERROR,
393 "__COUNTER__ expanded inside directive with -fdirectives-only");
394 number = pfile->counter++;
395 break;
397 case BT_HAS_ATTRIBUTE:
398 number = pfile->cb.has_attribute (pfile);
399 break;
402 if (result == NULL)
404 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
405 result = _cpp_unaligned_alloc (pfile, 21);
406 sprintf ((char *) result, "%u", number);
409 return result;
412 /* Convert builtin macros like __FILE__ to a token and push it on the
413 context stack. Also handles _Pragma, for which a new token may not
414 be created. Returns 1 if it generates a new token context, 0 to
415 return the token to the caller. LOC is the location of the expansion
416 point of the macro. */
417 static int
418 builtin_macro (cpp_reader *pfile, cpp_hashnode *node, source_location loc)
420 const uchar *buf;
421 size_t len;
422 char *nbuf;
424 if (node->value.builtin == BT_PRAGMA)
426 /* Don't interpret _Pragma within directives. The standard is
427 not clear on this, but to me this makes most sense. */
428 if (pfile->state.in_directive)
429 return 0;
431 return _cpp_do__Pragma (pfile);
434 buf = _cpp_builtin_macro_text (pfile, node);
435 len = ustrlen (buf);
436 nbuf = (char *) alloca (len + 1);
437 memcpy (nbuf, buf, len);
438 nbuf[len]='\n';
440 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
441 _cpp_clean_line (pfile);
443 /* Set pfile->cur_token as required by _cpp_lex_direct. */
444 pfile->cur_token = _cpp_temp_token (pfile);
445 cpp_token *token = _cpp_lex_direct (pfile);
446 /* We should point to the expansion point of the builtin macro. */
447 token->src_loc = loc;
448 if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
450 /* We are tracking tokens resulting from macro expansion.
451 Create a macro line map and generate a virtual location for
452 the token resulting from the expansion of the built-in
453 macro. */
454 source_location *virt_locs = NULL;
455 _cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs);
456 const line_map * map =
457 linemap_enter_macro (pfile->line_table, node,
458 token->src_loc, 1);
459 tokens_buff_add_token (token_buf, virt_locs, token,
460 pfile->line_table->builtin_location,
461 pfile->line_table->builtin_location,
462 map, /*macro_token_index=*/0);
463 push_extended_tokens_context (pfile, node, token_buf, virt_locs,
464 (const cpp_token **)token_buf->base,
467 else
468 _cpp_push_token_context (pfile, NULL, token, 1);
469 if (pfile->buffer->cur != pfile->buffer->rlimit)
470 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
471 NODE_NAME (node));
472 _cpp_pop_buffer (pfile);
474 return 1;
477 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
478 backslashes and double quotes. DEST must be of sufficient size.
479 Returns a pointer to the end of the string. */
480 uchar *
481 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
483 while (len--)
485 uchar c = *src++;
487 if (c == '\\' || c == '"')
489 *dest++ = '\\';
490 *dest++ = c;
492 else
493 *dest++ = c;
496 return dest;
499 /* Convert a token sequence ARG to a single string token according to
500 the rules of the ISO C #-operator. */
501 static const cpp_token *
502 stringify_arg (cpp_reader *pfile, macro_arg *arg)
504 unsigned char *dest;
505 unsigned int i, escape_it, backslash_count = 0;
506 const cpp_token *source = NULL;
507 size_t len;
509 if (BUFF_ROOM (pfile->u_buff) < 3)
510 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
511 dest = BUFF_FRONT (pfile->u_buff);
512 *dest++ = '"';
514 /* Loop, reading in the argument's tokens. */
515 for (i = 0; i < arg->count; i++)
517 const cpp_token *token = arg->first[i];
519 if (token->type == CPP_PADDING)
521 if (source == NULL
522 || (!(source->flags & PREV_WHITE)
523 && token->val.source == NULL))
524 source = token->val.source;
525 continue;
528 escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
529 || token->type == CPP_WSTRING || token->type == CPP_WCHAR
530 || token->type == CPP_STRING32 || token->type == CPP_CHAR32
531 || token->type == CPP_STRING16 || token->type == CPP_CHAR16
532 || token->type == CPP_UTF8STRING
533 || cpp_userdef_string_p (token->type)
534 || cpp_userdef_char_p (token->type));
536 /* Room for each char being written in octal, initial space and
537 final quote and NUL. */
538 len = cpp_token_len (token);
539 if (escape_it)
540 len *= 4;
541 len += 3;
543 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
545 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
546 _cpp_extend_buff (pfile, &pfile->u_buff, len);
547 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
550 /* Leading white space? */
551 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
553 if (source == NULL)
554 source = token;
555 if (source->flags & PREV_WHITE)
556 *dest++ = ' ';
558 source = NULL;
560 if (escape_it)
562 _cpp_buff *buff = _cpp_get_buff (pfile, len);
563 unsigned char *buf = BUFF_FRONT (buff);
564 len = cpp_spell_token (pfile, token, buf, true) - buf;
565 dest = cpp_quote_string (dest, buf, len);
566 _cpp_release_buff (pfile, buff);
568 else
569 dest = cpp_spell_token (pfile, token, dest, true);
571 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
572 backslash_count++;
573 else
574 backslash_count = 0;
577 /* Ignore the final \ of invalid string literals. */
578 if (backslash_count & 1)
580 cpp_error (pfile, CPP_DL_WARNING,
581 "invalid string literal, ignoring final '\\'");
582 dest--;
585 /* Commit the memory, including NUL, and return the token. */
586 *dest++ = '"';
587 len = dest - BUFF_FRONT (pfile->u_buff);
588 BUFF_FRONT (pfile->u_buff) = dest + 1;
589 return new_string_token (pfile, dest - len, len);
592 /* Try to paste two tokens. On success, return nonzero. In any
593 case, PLHS is updated to point to the pasted token, which is
594 guaranteed to not have the PASTE_LEFT flag set. LOCATION is
595 the virtual location used for error reporting. */
596 static bool
597 paste_tokens (cpp_reader *pfile, source_location location,
598 const cpp_token **plhs, const cpp_token *rhs)
600 unsigned char *buf, *end, *lhsend;
601 cpp_token *lhs;
602 unsigned int len;
604 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
605 buf = (unsigned char *) alloca (len);
606 end = lhsend = cpp_spell_token (pfile, *plhs, buf, true);
608 /* Avoid comment headers, since they are still processed in stage 3.
609 It is simpler to insert a space here, rather than modifying the
610 lexer to ignore comments in some circumstances. Simply returning
611 false doesn't work, since we want to clear the PASTE_LEFT flag. */
612 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
613 *end++ = ' ';
614 /* In one obscure case we might see padding here. */
615 if (rhs->type != CPP_PADDING)
616 end = cpp_spell_token (pfile, rhs, end, true);
617 *end = '\n';
619 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
620 _cpp_clean_line (pfile);
622 /* Set pfile->cur_token as required by _cpp_lex_direct. */
623 pfile->cur_token = _cpp_temp_token (pfile);
624 lhs = _cpp_lex_direct (pfile);
625 if (pfile->buffer->cur != pfile->buffer->rlimit)
627 source_location saved_loc = lhs->src_loc;
629 _cpp_pop_buffer (pfile);
630 _cpp_backup_tokens (pfile, 1);
631 *lhsend = '\0';
633 /* We have to remove the PASTE_LEFT flag from the old lhs, but
634 we want to keep the new location. */
635 *lhs = **plhs;
636 *plhs = lhs;
637 lhs->src_loc = saved_loc;
638 lhs->flags &= ~PASTE_LEFT;
640 /* Mandatory error for all apart from assembler. */
641 if (CPP_OPTION (pfile, lang) != CLK_ASM)
642 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
643 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
644 buf, cpp_token_as_text (pfile, rhs));
645 return false;
648 *plhs = lhs;
649 _cpp_pop_buffer (pfile);
650 return true;
653 /* Handles an arbitrarily long sequence of ## operators, with initial
654 operand LHS. This implementation is left-associative,
655 non-recursive, and finishes a paste before handling succeeding
656 ones. If a paste fails, we back up to the RHS of the failing ##
657 operator before pushing the context containing the result of prior
658 successful pastes, with the effect that the RHS appears in the
659 output stream after the pasted LHS normally. */
660 static void
661 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
663 const cpp_token *rhs = NULL;
664 cpp_context *context = pfile->context;
665 source_location virt_loc = 0;
667 /* We are expanding a macro and we must have been called on a token
668 that appears at the left hand side of a ## operator. */
669 if (macro_of_context (pfile->context) == NULL
670 || (!(lhs->flags & PASTE_LEFT)))
671 abort ();
673 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
674 /* The caller must have called consume_next_token_from_context
675 right before calling us. That has incremented the pointer to
676 the current virtual location. So it now points to the location
677 of the token that comes right after *LHS. We want the
678 resulting pasted token to have the location of the current
679 *LHS, though. */
680 virt_loc = context->c.mc->cur_virt_loc[-1];
681 else
682 /* We are not tracking macro expansion. So the best virtual
683 location we can get here is the expansion point of the macro we
684 are currently expanding. */
685 virt_loc = pfile->invocation_location;
689 /* Take the token directly from the current context. We can do
690 this, because we are in the replacement list of either an
691 object-like macro, or a function-like macro with arguments
692 inserted. In either case, the constraints to #define
693 guarantee we have at least one more token. */
694 if (context->tokens_kind == TOKENS_KIND_DIRECT)
695 rhs = FIRST (context).token++;
696 else if (context->tokens_kind == TOKENS_KIND_INDIRECT)
697 rhs = *FIRST (context).ptoken++;
698 else if (context->tokens_kind == TOKENS_KIND_EXTENDED)
700 /* So we are in presence of an extended token context, which
701 means that each token in this context has a virtual
702 location attached to it. So let's not forget to update
703 the pointer to the current virtual location of the
704 current token when we update the pointer to the current
705 token */
707 rhs = *FIRST (context).ptoken++;
708 /* context->c.mc must be non-null, as if we were not in a
709 macro context, context->tokens_kind could not be equal to
710 TOKENS_KIND_EXTENDED. */
711 context->c.mc->cur_virt_loc++;
714 if (rhs->type == CPP_PADDING)
716 if (rhs->flags & PASTE_LEFT)
717 abort ();
719 if (!paste_tokens (pfile, virt_loc, &lhs, rhs))
720 break;
722 while (rhs->flags & PASTE_LEFT);
724 /* Put the resulting token in its own context. */
725 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
727 source_location *virt_locs = NULL;
728 _cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs);
729 tokens_buff_add_token (token_buf, virt_locs, lhs,
730 virt_loc, 0, NULL, 0);
731 push_extended_tokens_context (pfile, context->c.mc->macro_node,
732 token_buf, virt_locs,
733 (const cpp_token **)token_buf->base, 1);
735 else
736 _cpp_push_token_context (pfile, NULL, lhs, 1);
739 /* Returns TRUE if the number of arguments ARGC supplied in an
740 invocation of the MACRO referenced by NODE is valid. An empty
741 invocation to a macro with no parameters should pass ARGC as zero.
743 Note that MACRO cannot necessarily be deduced from NODE, in case
744 NODE was redefined whilst collecting arguments. */
745 bool
746 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
748 if (argc == macro->paramc)
749 return true;
751 if (argc < macro->paramc)
753 /* As an extension, variadic arguments are allowed to not appear in
754 the invocation at all.
755 e.g. #define debug(format, args...) something
756 debug("string");
758 This is exactly the same as if an empty variadic list had been
759 supplied - debug("string", ). */
761 if (argc + 1 == macro->paramc && macro->variadic)
763 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
765 if (CPP_OPTION (pfile, cplusplus))
766 cpp_error (pfile, CPP_DL_PEDWARN,
767 "ISO C++11 requires at least one argument "
768 "for the \"...\" in a variadic macro");
769 else
770 cpp_error (pfile, CPP_DL_PEDWARN,
771 "ISO C99 requires at least one argument "
772 "for the \"...\" in a variadic macro");
774 return true;
777 cpp_error (pfile, CPP_DL_ERROR,
778 "macro \"%s\" requires %u arguments, but only %u given",
779 NODE_NAME (node), macro->paramc, argc);
781 else
782 cpp_error (pfile, CPP_DL_ERROR,
783 "macro \"%s\" passed %u arguments, but takes just %u",
784 NODE_NAME (node), argc, macro->paramc);
786 return false;
789 /* Reads and returns the arguments to a function-like macro
790 invocation. Assumes the opening parenthesis has been processed.
791 If there is an error, emits an appropriate diagnostic and returns
792 NULL. Each argument is terminated by a CPP_EOF token, for the
793 future benefit of expand_arg(). If there are any deferred
794 #pragma directives among macro arguments, store pointers to the
795 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
797 What is returned is the buffer that contains the memory allocated
798 to hold the macro arguments. NODE is the name of the macro this
799 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
800 set to the actual number of macro arguments allocated in the
801 returned buffer. */
802 static _cpp_buff *
803 collect_args (cpp_reader *pfile, const cpp_hashnode *node,
804 _cpp_buff **pragma_buff, unsigned *num_args)
806 _cpp_buff *buff, *base_buff;
807 cpp_macro *macro;
808 macro_arg *args, *arg;
809 const cpp_token *token;
810 unsigned int argc;
811 source_location virt_loc;
812 bool track_macro_expansion_p = CPP_OPTION (pfile, track_macro_expansion);
813 unsigned num_args_alloced = 0;
815 macro = node->value.macro;
816 if (macro->paramc)
817 argc = macro->paramc;
818 else
819 argc = 1;
821 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
822 #define ARG_TOKENS_EXTENT 1000
824 buff = _cpp_get_buff (pfile, argc * (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
825 * sizeof (cpp_token *)
826 + sizeof (macro_arg)));
827 base_buff = buff;
828 args = (macro_arg *) buff->base;
829 memset (args, 0, argc * sizeof (macro_arg));
830 buff->cur = (unsigned char *) &args[argc];
831 arg = args, argc = 0;
833 /* Collect the tokens making up each argument. We don't yet know
834 how many arguments have been supplied, whether too many or too
835 few. Hence the slightly bizarre usage of "argc" and "arg". */
838 unsigned int paren_depth = 0;
839 unsigned int ntokens = 0;
840 unsigned virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
841 num_args_alloced++;
843 argc++;
844 arg->first = (const cpp_token **) buff->cur;
845 if (track_macro_expansion_p)
847 virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
848 arg->virt_locs = XNEWVEC (source_location,
849 virt_locs_capacity);
852 for (;;)
854 /* Require space for 2 new tokens (including a CPP_EOF). */
855 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
857 buff = _cpp_append_extend_buff (pfile, buff,
858 ARG_TOKENS_EXTENT
859 * sizeof (cpp_token *));
860 arg->first = (const cpp_token **) buff->cur;
862 if (track_macro_expansion_p
863 && (ntokens + 2 > virt_locs_capacity))
865 virt_locs_capacity += ARG_TOKENS_EXTENT;
866 arg->virt_locs = XRESIZEVEC (source_location,
867 arg->virt_locs,
868 virt_locs_capacity);
871 token = cpp_get_token_1 (pfile, &virt_loc);
873 if (token->type == CPP_PADDING)
875 /* Drop leading padding. */
876 if (ntokens == 0)
877 continue;
879 else if (token->type == CPP_OPEN_PAREN)
880 paren_depth++;
881 else if (token->type == CPP_CLOSE_PAREN)
883 if (paren_depth-- == 0)
884 break;
886 else if (token->type == CPP_COMMA)
888 /* A comma does not terminate an argument within
889 parentheses or as part of a variable argument. */
890 if (paren_depth == 0
891 && ! (macro->variadic && argc == macro->paramc))
892 break;
894 else if (token->type == CPP_EOF
895 || (token->type == CPP_HASH && token->flags & BOL))
896 break;
897 else if (token->type == CPP_PRAGMA)
899 cpp_token *newtok = _cpp_temp_token (pfile);
901 /* CPP_PRAGMA token lives in directive_result, which will
902 be overwritten on the next directive. */
903 *newtok = *token;
904 token = newtok;
907 if (*pragma_buff == NULL
908 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
910 _cpp_buff *next;
911 if (*pragma_buff == NULL)
912 *pragma_buff
913 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
914 else
916 next = *pragma_buff;
917 *pragma_buff
918 = _cpp_get_buff (pfile,
919 (BUFF_FRONT (*pragma_buff)
920 - (*pragma_buff)->base) * 2);
921 (*pragma_buff)->next = next;
924 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
925 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
926 if (token->type == CPP_PRAGMA_EOL)
927 break;
928 token = cpp_get_token_1 (pfile, &virt_loc);
930 while (token->type != CPP_EOF);
932 /* In deferred pragmas parsing_args and prevent_expansion
933 had been changed, reset it. */
934 pfile->state.parsing_args = 2;
935 pfile->state.prevent_expansion = 1;
937 if (token->type == CPP_EOF)
938 break;
939 else
940 continue;
942 set_arg_token (arg, token, virt_loc,
943 ntokens, MACRO_ARG_TOKEN_NORMAL,
944 CPP_OPTION (pfile, track_macro_expansion));
945 ntokens++;
948 /* Drop trailing padding. */
949 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
950 ntokens--;
952 arg->count = ntokens;
953 set_arg_token (arg, &pfile->eof, pfile->eof.src_loc,
954 ntokens, MACRO_ARG_TOKEN_NORMAL,
955 CPP_OPTION (pfile, track_macro_expansion));
957 /* Terminate the argument. Excess arguments loop back and
958 overwrite the final legitimate argument, before failing. */
959 if (argc <= macro->paramc)
961 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
962 if (argc != macro->paramc)
963 arg++;
966 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
968 if (token->type == CPP_EOF)
970 /* We still need the CPP_EOF to end directives, and to end
971 pre-expansion of a macro argument. Step back is not
972 unconditional, since we don't want to return a CPP_EOF to our
973 callers at the end of an -include-d file. */
974 if (pfile->context->prev || pfile->state.in_directive)
975 _cpp_backup_tokens (pfile, 1);
976 cpp_error (pfile, CPP_DL_ERROR,
977 "unterminated argument list invoking macro \"%s\"",
978 NODE_NAME (node));
980 else
982 /* A single empty argument is counted as no argument. */
983 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
984 argc = 0;
985 if (_cpp_arguments_ok (pfile, macro, node, argc))
987 /* GCC has special semantics for , ## b where b is a varargs
988 parameter: we remove the comma if b was omitted entirely.
989 If b was merely an empty argument, the comma is retained.
990 If the macro takes just one (varargs) parameter, then we
991 retain the comma only if we are standards conforming.
993 If FIRST is NULL replace_args () swallows the comma. */
994 if (macro->variadic && (argc < macro->paramc
995 || (argc == 1 && args[0].count == 0
996 && !CPP_OPTION (pfile, std))))
997 args[macro->paramc - 1].first = NULL;
998 if (num_args)
999 *num_args = num_args_alloced;
1000 return base_buff;
1004 /* An error occurred. */
1005 _cpp_release_buff (pfile, base_buff);
1006 return NULL;
1009 /* Search for an opening parenthesis to the macro of NODE, in such a
1010 way that, if none is found, we don't lose the information in any
1011 intervening padding tokens. If we find the parenthesis, collect
1012 the arguments and return the buffer containing them. PRAGMA_BUFF
1013 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
1014 *NUM_ARGS is set to the number of arguments contained in the
1015 returned buffer. */
1016 static _cpp_buff *
1017 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
1018 _cpp_buff **pragma_buff, unsigned *num_args)
1020 const cpp_token *token, *padding = NULL;
1022 for (;;)
1024 token = cpp_get_token (pfile);
1025 if (token->type != CPP_PADDING)
1026 break;
1027 if (padding == NULL
1028 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
1029 padding = token;
1032 if (token->type == CPP_OPEN_PAREN)
1034 pfile->state.parsing_args = 2;
1035 return collect_args (pfile, node, pragma_buff, num_args);
1038 /* CPP_EOF can be the end of macro arguments, or the end of the
1039 file. We mustn't back up over the latter. Ugh. */
1040 if (token->type != CPP_EOF || token == &pfile->eof)
1042 /* Back up. We may have skipped padding, in which case backing
1043 up more than one token when expanding macros is in general
1044 too difficult. We re-insert it in its own context. */
1045 _cpp_backup_tokens (pfile, 1);
1046 if (padding)
1047 _cpp_push_token_context (pfile, NULL, padding, 1);
1050 return NULL;
1053 /* Return the real number of tokens in the expansion of MACRO. */
1054 static inline unsigned int
1055 macro_real_token_count (const cpp_macro *macro)
1057 unsigned int i;
1058 if (__builtin_expect (!macro->extra_tokens, true))
1059 return macro->count;
1060 for (i = 0; i < macro->count; i++)
1061 if (macro->exp.tokens[i].type == CPP_PASTE)
1062 return i;
1063 abort ();
1066 /* Push the context of a macro with hash entry NODE onto the context
1067 stack. If we can successfully expand the macro, we push a context
1068 containing its yet-to-be-rescanned replacement list and return one.
1069 If there were additionally any unexpanded deferred #pragma
1070 directives among macro arguments, push another context containing
1071 the pragma tokens before the yet-to-be-rescanned replacement list
1072 and return two. Otherwise, we don't push a context and return
1073 zero. LOCATION is the location of the expansion point of the
1074 macro. */
1075 static int
1076 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
1077 const cpp_token *result, source_location location)
1079 /* The presence of a macro invalidates a file's controlling macro. */
1080 pfile->mi_valid = false;
1082 pfile->state.angled_headers = false;
1084 /* From here to when we push the context for the macro later down
1085 this function, we need to flag the fact that we are about to
1086 expand a macro. This is useful when -ftrack-macro-expansion is
1087 turned off. In that case, we need to record the location of the
1088 expansion point of the top-most macro we are about to to expand,
1089 into pfile->invocation_location. But we must not record any such
1090 location once the process of expanding the macro starts; that is,
1091 we must not do that recording between now and later down this
1092 function where set this flag to FALSE. */
1093 pfile->about_to_expand_macro_p = true;
1095 if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
1097 node->flags |= NODE_USED;
1098 if ((!pfile->cb.user_builtin_macro
1099 || !pfile->cb.user_builtin_macro (pfile, node))
1100 && pfile->cb.used_define)
1101 pfile->cb.used_define (pfile, pfile->directive_line, node);
1104 /* Handle standard macros. */
1105 if (! (node->flags & NODE_BUILTIN))
1107 cpp_macro *macro = node->value.macro;
1108 _cpp_buff *pragma_buff = NULL;
1110 if (macro->fun_like)
1112 _cpp_buff *buff;
1113 unsigned num_args = 0;
1115 pfile->state.prevent_expansion++;
1116 pfile->keep_tokens++;
1117 pfile->state.parsing_args = 1;
1118 buff = funlike_invocation_p (pfile, node, &pragma_buff,
1119 &num_args);
1120 pfile->state.parsing_args = 0;
1121 pfile->keep_tokens--;
1122 pfile->state.prevent_expansion--;
1124 if (buff == NULL)
1126 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
1127 cpp_warning (pfile, CPP_W_TRADITIONAL,
1128 "function-like macro \"%s\" must be used with arguments in traditional C",
1129 NODE_NAME (node));
1131 if (pragma_buff)
1132 _cpp_release_buff (pfile, pragma_buff);
1134 pfile->about_to_expand_macro_p = false;
1135 return 0;
1138 if (macro->paramc > 0)
1139 replace_args (pfile, node, macro,
1140 (macro_arg *) buff->base,
1141 location);
1142 /* Free the memory used by the arguments of this
1143 function-like macro. This memory has been allocated by
1144 funlike_invocation_p and by replace_args. */
1145 delete_macro_args (buff, num_args);
1148 /* Disable the macro within its expansion. */
1149 node->flags |= NODE_DISABLED;
1151 if (!(node->flags & NODE_USED))
1153 node->flags |= NODE_USED;
1154 if (pfile->cb.used_define)
1155 pfile->cb.used_define (pfile, pfile->directive_line, node);
1158 if (pfile->cb.used)
1159 pfile->cb.used (pfile, location, node);
1161 macro->used = 1;
1163 if (macro->paramc == 0)
1165 unsigned tokens_count = macro_real_token_count (macro);
1166 if (CPP_OPTION (pfile, track_macro_expansion))
1168 unsigned int i;
1169 const cpp_token *src = macro->exp.tokens;
1170 const struct line_map *map;
1171 source_location *virt_locs = NULL;
1172 _cpp_buff *macro_tokens
1173 = tokens_buff_new (pfile, tokens_count, &virt_locs);
1175 /* Create a macro map to record the locations of the
1176 tokens that are involved in the expansion. LOCATION
1177 is the location of the macro expansion point. */
1178 map = linemap_enter_macro (pfile->line_table,
1179 node, location, tokens_count);
1180 for (i = 0; i < tokens_count; ++i)
1182 tokens_buff_add_token (macro_tokens, virt_locs,
1183 src, src->src_loc,
1184 src->src_loc, map, i);
1185 ++src;
1187 push_extended_tokens_context (pfile, node,
1188 macro_tokens,
1189 virt_locs,
1190 (const cpp_token **)
1191 macro_tokens->base,
1192 tokens_count);
1194 else
1195 _cpp_push_token_context (pfile, node, macro->exp.tokens,
1196 tokens_count);
1197 num_macro_tokens_counter += tokens_count;
1200 if (pragma_buff)
1202 if (!pfile->state.in_directive)
1203 _cpp_push_token_context (pfile, NULL,
1204 padding_token (pfile, result), 1);
1207 unsigned tokens_count;
1208 _cpp_buff *tail = pragma_buff->next;
1209 pragma_buff->next = NULL;
1210 tokens_count = ((const cpp_token **) BUFF_FRONT (pragma_buff)
1211 - (const cpp_token **) pragma_buff->base);
1212 push_ptoken_context (pfile, NULL, pragma_buff,
1213 (const cpp_token **) pragma_buff->base,
1214 tokens_count);
1215 pragma_buff = tail;
1216 if (!CPP_OPTION (pfile, track_macro_expansion))
1217 num_macro_tokens_counter += tokens_count;
1220 while (pragma_buff != NULL);
1221 pfile->about_to_expand_macro_p = false;
1222 return 2;
1225 pfile->about_to_expand_macro_p = false;
1226 return 1;
1229 pfile->about_to_expand_macro_p = false;
1230 /* Handle built-in macros and the _Pragma operator. */
1231 return builtin_macro (pfile, node, location);
1234 /* De-allocate the memory used by BUFF which is an array of instances
1235 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1236 present in BUFF. */
1237 static void
1238 delete_macro_args (_cpp_buff *buff, unsigned num_args)
1240 macro_arg *macro_args;
1241 unsigned i;
1243 if (buff == NULL)
1244 return;
1246 macro_args = (macro_arg *) buff->base;
1248 /* Walk instances of macro_arg to free their expanded tokens as well
1249 as their macro_arg::virt_locs members. */
1250 for (i = 0; i < num_args; ++i)
1252 if (macro_args[i].expanded)
1254 free (macro_args[i].expanded);
1255 macro_args[i].expanded = NULL;
1257 if (macro_args[i].virt_locs)
1259 free (macro_args[i].virt_locs);
1260 macro_args[i].virt_locs = NULL;
1262 if (macro_args[i].expanded_virt_locs)
1264 free (macro_args[i].expanded_virt_locs);
1265 macro_args[i].expanded_virt_locs = NULL;
1268 _cpp_free_buff (buff);
1271 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1272 to set, LOCATION is its virtual location. "Virtual" location means
1273 the location that encodes loci across macro expansion. Otherwise
1274 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1275 argument ARG is supposed to contain. Note that ARG must be
1276 tailored so that it has enough room to contain INDEX + 1 numbers of
1277 tokens, at least. */
1278 static void
1279 set_arg_token (macro_arg *arg, const cpp_token *token,
1280 source_location location, size_t index,
1281 enum macro_arg_token_kind kind,
1282 bool track_macro_exp_p)
1284 const cpp_token **token_ptr;
1285 source_location *loc = NULL;
1287 token_ptr =
1288 arg_token_ptr_at (arg, index, kind,
1289 track_macro_exp_p ? &loc : NULL);
1290 *token_ptr = token;
1292 if (loc != NULL)
1294 #ifdef ENABLE_CHECKING
1295 if (kind == MACRO_ARG_TOKEN_STRINGIFIED
1296 || !track_macro_exp_p)
1297 /* We can't set the location of a stringified argument
1298 token and we can't set any location if we aren't tracking
1299 macro expansion locations. */
1300 abort ();
1301 #endif
1302 *loc = location;
1306 /* Get the pointer to the location of the argument token of the
1307 function-like macro argument ARG. This function must be called
1308 only when we -ftrack-macro-expansion is on. */
1309 static const source_location *
1310 get_arg_token_location (const macro_arg *arg,
1311 enum macro_arg_token_kind kind)
1313 const source_location *loc = NULL;
1314 const cpp_token **token_ptr =
1315 arg_token_ptr_at (arg, 0, kind, (source_location **) &loc);
1317 if (token_ptr == NULL)
1318 return NULL;
1320 return loc;
1323 /* Return the pointer to the INDEXth token of the macro argument ARG.
1324 KIND specifies the kind of token the macro argument ARG contains.
1325 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1326 of the virtual location of the returned token if the
1327 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1328 spelling location of the returned token. */
1329 static const cpp_token **
1330 arg_token_ptr_at (const macro_arg *arg, size_t index,
1331 enum macro_arg_token_kind kind,
1332 source_location **virt_location)
1334 const cpp_token **tokens_ptr = NULL;
1336 switch (kind)
1338 case MACRO_ARG_TOKEN_NORMAL:
1339 tokens_ptr = arg->first;
1340 break;
1341 case MACRO_ARG_TOKEN_STRINGIFIED:
1342 tokens_ptr = (const cpp_token **) &arg->stringified;
1343 break;
1344 case MACRO_ARG_TOKEN_EXPANDED:
1345 tokens_ptr = arg->expanded;
1346 break;
1349 if (tokens_ptr == NULL)
1350 /* This can happen for e.g, an empty token argument to a
1351 funtion-like macro. */
1352 return tokens_ptr;
1354 if (virt_location)
1356 if (kind == MACRO_ARG_TOKEN_NORMAL)
1357 *virt_location = &arg->virt_locs[index];
1358 else if (kind == MACRO_ARG_TOKEN_EXPANDED)
1359 *virt_location = &arg->expanded_virt_locs[index];
1360 else if (kind == MACRO_ARG_TOKEN_STRINGIFIED)
1361 *virt_location =
1362 (source_location *) &tokens_ptr[index]->src_loc;
1364 return &tokens_ptr[index];
1367 /* Initialize an iterator so that it iterates over the tokens of a
1368 function-like macro argument. KIND is the kind of tokens we want
1369 ITER to iterate over. TOKEN_PTR points the first token ITER will
1370 iterate over. */
1371 static void
1372 macro_arg_token_iter_init (macro_arg_token_iter *iter,
1373 bool track_macro_exp_p,
1374 enum macro_arg_token_kind kind,
1375 const macro_arg *arg,
1376 const cpp_token **token_ptr)
1378 iter->track_macro_exp_p = track_macro_exp_p;
1379 iter->kind = kind;
1380 iter->token_ptr = token_ptr;
1381 /* Unconditionally initialize this so that the compiler doesn't warn
1382 about iter->location_ptr being possibly uninitialized later after
1383 this code has been inlined somewhere. */
1384 iter->location_ptr = NULL;
1385 if (track_macro_exp_p)
1386 iter->location_ptr = get_arg_token_location (arg, kind);
1387 #ifdef ENABLE_CHECKING
1388 iter->num_forwards = 0;
1389 if (track_macro_exp_p
1390 && token_ptr != NULL
1391 && iter->location_ptr == NULL)
1392 abort ();
1393 #endif
1396 /* Move the iterator one token forward. Note that if IT was
1397 initialized on an argument that has a stringified token, moving it
1398 forward doesn't make sense as a stringified token is essentially one
1399 string. */
1400 static void
1401 macro_arg_token_iter_forward (macro_arg_token_iter *it)
1403 switch (it->kind)
1405 case MACRO_ARG_TOKEN_NORMAL:
1406 case MACRO_ARG_TOKEN_EXPANDED:
1407 it->token_ptr++;
1408 if (it->track_macro_exp_p)
1409 it->location_ptr++;
1410 break;
1411 case MACRO_ARG_TOKEN_STRINGIFIED:
1412 #ifdef ENABLE_CHECKING
1413 if (it->num_forwards > 0)
1414 abort ();
1415 #endif
1416 break;
1419 #ifdef ENABLE_CHECKING
1420 it->num_forwards++;
1421 #endif
1424 /* Return the token pointed to by the iterator. */
1425 static const cpp_token *
1426 macro_arg_token_iter_get_token (const macro_arg_token_iter *it)
1428 #ifdef ENABLE_CHECKING
1429 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1430 && it->num_forwards > 0)
1431 abort ();
1432 #endif
1433 if (it->token_ptr == NULL)
1434 return NULL;
1435 return *it->token_ptr;
1438 /* Return the location of the token pointed to by the iterator.*/
1439 static source_location
1440 macro_arg_token_iter_get_location (const macro_arg_token_iter *it)
1442 #ifdef ENABLE_CHECKING
1443 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1444 && it->num_forwards > 0)
1445 abort ();
1446 #endif
1447 if (it->track_macro_exp_p)
1448 return *it->location_ptr;
1449 else
1450 return (*it->token_ptr)->src_loc;
1453 /* Return the index of a token [resulting from macro expansion] inside
1454 the total list of tokens resulting from a given macro
1455 expansion. The index can be different depending on whether if we
1456 want each tokens resulting from function-like macro arguments
1457 expansion to have a different location or not.
1459 E.g, consider this function-like macro:
1461 #define M(x) x - 3
1463 Then consider us "calling" it (and thus expanding it) like:
1465 M(1+4)
1467 It will be expanded into:
1469 1+4-3
1471 Let's consider the case of the token '4'.
1473 Its index can be 2 (it's the third token of the set of tokens
1474 resulting from the expansion) or it can be 0 if we consider that
1475 all tokens resulting from the expansion of the argument "1+2" have
1476 the same index, which is 0. In this later case, the index of token
1477 '-' would then be 1 and the index of token '3' would be 2.
1479 The later case is useful to use less memory e.g, for the case of
1480 the user using the option -ftrack-macro-expansion=1.
1482 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1483 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1484 parameter (inside the macro replacement list) that corresponds to
1485 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1488 If we refer to the example above, for the '4' argument token,
1489 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1490 would be set to the token 'x', in the replacement list "x - 3" of
1491 macro M.
1493 This is a subroutine of replace_args. */
1494 inline static unsigned
1495 expanded_token_index (cpp_reader *pfile, cpp_macro *macro,
1496 const cpp_token *cur_replacement_token,
1497 unsigned absolute_token_index)
1499 if (CPP_OPTION (pfile, track_macro_expansion) > 1)
1500 return absolute_token_index;
1501 return cur_replacement_token - macro->exp.tokens;
1504 /* Replace the parameters in a function-like macro of NODE with the
1505 actual ARGS, and place the result in a newly pushed token context.
1506 Expand each argument before replacing, unless it is operated upon
1507 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1508 the expansion point of the macro. E.g, the location of the
1509 function-like macro invocation. */
1510 static void
1511 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro,
1512 macro_arg *args, source_location expansion_point_loc)
1514 unsigned int i, total;
1515 const cpp_token *src, *limit;
1516 const cpp_token **first = NULL;
1517 macro_arg *arg;
1518 _cpp_buff *buff = NULL;
1519 source_location *virt_locs = NULL;
1520 unsigned int exp_count;
1521 const struct line_map *map = NULL;
1522 int track_macro_exp;
1524 /* First, fully macro-expand arguments, calculating the number of
1525 tokens in the final expansion as we go. The ordering of the if
1526 statements below is subtle; we must handle stringification before
1527 pasting. */
1529 /* EXP_COUNT is the number of tokens in the macro replacement
1530 list. TOTAL is the number of tokens /after/ macro parameters
1531 have been replaced by their arguments. */
1532 exp_count = macro_real_token_count (macro);
1533 total = exp_count;
1534 limit = macro->exp.tokens + exp_count;
1536 for (src = macro->exp.tokens; src < limit; src++)
1537 if (src->type == CPP_MACRO_ARG)
1539 /* Leading and trailing padding tokens. */
1540 total += 2;
1541 /* Account for leading and padding tokens in exp_count too.
1542 This is going to be important later down this function,
1543 when we want to handle the case of (track_macro_exp <
1544 2). */
1545 exp_count += 2;
1547 /* We have an argument. If it is not being stringified or
1548 pasted it is macro-replaced before insertion. */
1549 arg = &args[src->val.macro_arg.arg_no - 1];
1551 if (src->flags & STRINGIFY_ARG)
1553 if (!arg->stringified)
1554 arg->stringified = stringify_arg (pfile, arg);
1556 else if ((src->flags & PASTE_LEFT)
1557 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
1558 total += arg->count - 1;
1559 else
1561 if (!arg->expanded)
1562 expand_arg (pfile, arg);
1563 total += arg->expanded_count - 1;
1567 /* When the compiler is called with the -ftrack-macro-expansion
1568 flag, we need to keep track of the location of each token that
1569 results from macro expansion.
1571 A token resulting from macro expansion is not a new token. It is
1572 simply the same token as the token coming from the macro
1573 definition. The new things that are allocated are the buffer
1574 that holds the tokens resulting from macro expansion and a new
1575 location that records many things like the locus of the expansion
1576 point as well as the original locus inside the definition of the
1577 macro. This location is called a virtual location.
1579 So the buffer BUFF holds a set of cpp_token*, and the buffer
1580 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1582 Both of these two buffers are going to be hung off of the macro
1583 context, when the latter is pushed. The memory allocated to
1584 store the tokens and their locations is going to be freed once
1585 the context of macro expansion is popped.
1587 As far as tokens are concerned, the memory overhead of
1588 -ftrack-macro-expansion is proportional to the number of
1589 macros that get expanded multiplied by sizeof (source_location).
1590 The good news is that extra memory gets freed when the macro
1591 context is freed, i.e shortly after the macro got expanded. */
1593 /* Is the -ftrack-macro-expansion flag in effect? */
1594 track_macro_exp = CPP_OPTION (pfile, track_macro_expansion);
1596 /* Now allocate memory space for tokens and locations resulting from
1597 the macro expansion, copy the tokens and replace the arguments.
1598 This memory must be freed when the context of the macro MACRO is
1599 popped. */
1600 buff = tokens_buff_new (pfile, total, track_macro_exp ? &virt_locs : NULL);
1602 first = (const cpp_token **) buff->base;
1604 /* Create a macro map to record the locations of the tokens that are
1605 involved in the expansion. Note that the expansion point is set
1606 to the location of the closing parenthesis. Otherwise, the
1607 subsequent map created for the first token that comes after the
1608 macro map might have a wrong line number. That would lead to
1609 tokens with wrong line numbers after the macro expansion. This
1610 adds up to the memory overhead of the -ftrack-macro-expansion
1611 flag; for every macro that is expanded, a "macro map" is
1612 created. */
1613 if (track_macro_exp)
1615 int num_macro_tokens = total;
1616 if (track_macro_exp < 2)
1617 /* Then the number of macro tokens won't take in account the
1618 fact that function-like macro arguments can expand to
1619 multiple tokens. This is to save memory at the expense of
1620 accuracy.
1622 Suppose we have #define SQARE(A) A * A
1624 And then we do SQARE(2+3)
1626 Then the tokens 2, +, 3, will have the same location,
1627 saying they come from the expansion of the argument A. */
1628 num_macro_tokens = exp_count;
1629 map = linemap_enter_macro (pfile->line_table, node,
1630 expansion_point_loc,
1631 num_macro_tokens);
1633 i = 0;
1634 for (src = macro->exp.tokens; src < limit; src++)
1636 unsigned int arg_tokens_count;
1637 macro_arg_token_iter from;
1638 const cpp_token **paste_flag = NULL;
1639 const cpp_token **tmp_token_ptr;
1641 if (src->type != CPP_MACRO_ARG)
1643 /* Allocate a virtual location for token SRC, and add that
1644 token and its virtual location into the buffers BUFF and
1645 VIRT_LOCS. */
1646 unsigned index = expanded_token_index (pfile, macro, src, i);
1647 tokens_buff_add_token (buff, virt_locs, src,
1648 src->src_loc, src->src_loc,
1649 map, index);
1650 i += 1;
1651 continue;
1654 paste_flag = 0;
1655 arg = &args[src->val.macro_arg.arg_no - 1];
1656 /* SRC is a macro parameter that we need to replace with its
1657 corresponding argument. So at some point we'll need to
1658 iterate over the tokens of the macro argument and copy them
1659 into the "place" now holding the correspondig macro
1660 parameter. We are going to use the iterator type
1661 macro_argo_token_iter to handle that iterating. The 'if'
1662 below is to initialize the iterator depending on the type of
1663 tokens the macro argument has. It also does some adjustment
1664 related to padding tokens and some pasting corner cases. */
1665 if (src->flags & STRINGIFY_ARG)
1667 arg_tokens_count = 1;
1668 macro_arg_token_iter_init (&from,
1669 CPP_OPTION (pfile,
1670 track_macro_expansion),
1671 MACRO_ARG_TOKEN_STRINGIFIED,
1672 arg, &arg->stringified);
1674 else if (src->flags & PASTE_LEFT)
1676 arg_tokens_count = arg->count;
1677 macro_arg_token_iter_init (&from,
1678 CPP_OPTION (pfile,
1679 track_macro_expansion),
1680 MACRO_ARG_TOKEN_NORMAL,
1681 arg, arg->first);
1683 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
1685 int num_toks;
1686 arg_tokens_count = arg->count;
1687 macro_arg_token_iter_init (&from,
1688 CPP_OPTION (pfile,
1689 track_macro_expansion),
1690 MACRO_ARG_TOKEN_NORMAL,
1691 arg, arg->first);
1693 num_toks = tokens_buff_count (buff);
1695 if (num_toks != 0)
1697 /* So the current parameter token is pasted to the previous
1698 token in the replacement list. Let's look at what
1699 we have as previous and current arguments. */
1701 /* This is the previous argument's token ... */
1702 tmp_token_ptr = tokens_buff_last_token_ptr (buff);
1704 if ((*tmp_token_ptr)->type == CPP_COMMA
1705 && macro->variadic
1706 && src->val.macro_arg.arg_no == macro->paramc)
1708 /* ... which is a comma; and the current parameter
1709 is the last parameter of a variadic function-like
1710 macro. If the argument to the current last
1711 parameter is NULL, then swallow the comma,
1712 otherwise drop the paste flag. */
1713 if (macro_arg_token_iter_get_token (&from) == NULL)
1714 tokens_buff_remove_last_token (buff);
1715 else
1716 paste_flag = tmp_token_ptr;
1718 /* Remove the paste flag if the RHS is a placemarker. */
1719 else if (arg_tokens_count == 0)
1720 paste_flag = tmp_token_ptr;
1723 else
1725 arg_tokens_count = arg->expanded_count;
1726 macro_arg_token_iter_init (&from,
1727 CPP_OPTION (pfile,
1728 track_macro_expansion),
1729 MACRO_ARG_TOKEN_EXPANDED,
1730 arg, arg->expanded);
1733 /* Padding on the left of an argument (unless RHS of ##). */
1734 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
1735 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
1737 const cpp_token *t = padding_token (pfile, src);
1738 unsigned index = expanded_token_index (pfile, macro, src, i);
1739 /* Allocate a virtual location for the padding token and
1740 append the token and its location to BUFF and
1741 VIRT_LOCS. */
1742 tokens_buff_add_token (buff, virt_locs, t,
1743 t->src_loc, t->src_loc,
1744 map, index);
1747 if (arg_tokens_count)
1749 /* So now we've got the number of tokens that make up the
1750 argument that is going to replace the current parameter
1751 in the macro's replacement list. */
1752 unsigned int j;
1753 for (j = 0; j < arg_tokens_count; ++j)
1755 /* So if track_macro_exp is < 2, the user wants to
1756 save extra memory while tracking macro expansion
1757 locations. So in that case here is what we do:
1759 Suppose we have #define SQARE(A) A * A
1761 And then we do SQARE(2+3)
1763 Then the tokens 2, +, 3, will have the same location,
1764 saying they come from the expansion of the argument
1767 So that means we are going to ignore the COUNT tokens
1768 resulting from the expansion of the current macro
1769 arugment. In other words all the ARG_TOKENS_COUNT tokens
1770 resulting from the expansion of the macro argument will
1771 have the index I. Normally, each of those token should
1772 have index I+J. */
1773 unsigned token_index = i;
1774 unsigned index;
1775 if (track_macro_exp > 1)
1776 token_index += j;
1778 index = expanded_token_index (pfile, macro, src, token_index);
1779 tokens_buff_add_token (buff, virt_locs,
1780 macro_arg_token_iter_get_token (&from),
1781 macro_arg_token_iter_get_location (&from),
1782 src->src_loc, map, index);
1783 macro_arg_token_iter_forward (&from);
1786 /* With a non-empty argument on the LHS of ##, the last
1787 token should be flagged PASTE_LEFT. */
1788 if (src->flags & PASTE_LEFT)
1789 paste_flag =
1790 (const cpp_token **) tokens_buff_last_token_ptr (buff);
1792 else if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, c99)
1793 && ! macro->syshdr && ! cpp_in_system_header (pfile))
1795 if (CPP_OPTION (pfile, cplusplus))
1796 cpp_pedwarning (pfile, CPP_W_PEDANTIC,
1797 "invoking macro %s argument %d: "
1798 "empty macro arguments are undefined"
1799 " in ISO C++98",
1800 NODE_NAME (node), src->val.macro_arg.arg_no);
1801 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat))
1802 cpp_pedwarning (pfile,
1803 CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
1804 ? CPP_W_C90_C99_COMPAT : CPP_W_PEDANTIC,
1805 "invoking macro %s argument %d: "
1806 "empty macro arguments are undefined"
1807 " in ISO C90",
1808 NODE_NAME (node), src->val.macro_arg.arg_no);
1810 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
1811 && ! CPP_OPTION (pfile, cplusplus)
1812 && ! macro->syshdr && ! cpp_in_system_header (pfile))
1813 cpp_warning (pfile, CPP_W_C90_C99_COMPAT,
1814 "invoking macro %s argument %d: "
1815 "empty macro arguments are undefined"
1816 " in ISO C90",
1817 NODE_NAME (node), src->val.macro_arg.arg_no);
1819 /* Avoid paste on RHS (even case count == 0). */
1820 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1822 const cpp_token *t = &pfile->avoid_paste;
1823 tokens_buff_add_token (buff, virt_locs,
1824 t, t->src_loc, t->src_loc,
1825 NULL, 0);
1828 /* Add a new paste flag, or remove an unwanted one. */
1829 if (paste_flag)
1831 cpp_token *token = _cpp_temp_token (pfile);
1832 token->type = (*paste_flag)->type;
1833 token->val = (*paste_flag)->val;
1834 if (src->flags & PASTE_LEFT)
1835 token->flags = (*paste_flag)->flags | PASTE_LEFT;
1836 else
1837 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1838 *paste_flag = token;
1841 i += arg_tokens_count;
1844 if (track_macro_exp)
1845 push_extended_tokens_context (pfile, node, buff, virt_locs, first,
1846 tokens_buff_count (buff));
1847 else
1848 push_ptoken_context (pfile, node, buff, first,
1849 tokens_buff_count (buff));
1851 num_macro_tokens_counter += tokens_buff_count (buff);
1854 /* Return a special padding token, with padding inherited from SOURCE. */
1855 static const cpp_token *
1856 padding_token (cpp_reader *pfile, const cpp_token *source)
1858 cpp_token *result = _cpp_temp_token (pfile);
1860 result->type = CPP_PADDING;
1862 /* Data in GCed data structures cannot be made const so far, so we
1863 need a cast here. */
1864 result->val.source = (cpp_token *) source;
1865 result->flags = 0;
1866 return result;
1869 /* Get a new uninitialized context. Create a new one if we cannot
1870 re-use an old one. */
1871 static cpp_context *
1872 next_context (cpp_reader *pfile)
1874 cpp_context *result = pfile->context->next;
1876 if (result == 0)
1878 result = XNEW (cpp_context);
1879 memset (result, 0, sizeof (cpp_context));
1880 result->prev = pfile->context;
1881 result->next = 0;
1882 pfile->context->next = result;
1885 pfile->context = result;
1886 return result;
1889 /* Push a list of pointers to tokens. */
1890 static void
1891 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1892 const cpp_token **first, unsigned int count)
1894 cpp_context *context = next_context (pfile);
1896 context->tokens_kind = TOKENS_KIND_INDIRECT;
1897 context->c.macro = macro;
1898 context->buff = buff;
1899 FIRST (context).ptoken = first;
1900 LAST (context).ptoken = first + count;
1903 /* Push a list of tokens.
1905 A NULL macro means that we should continue the current macro
1906 expansion, in essence. That means that if we are currently in a
1907 macro expansion context, we'll make the new pfile->context refer to
1908 the current macro. */
1909 void
1910 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1911 const cpp_token *first, unsigned int count)
1913 cpp_context *context;
1915 if (macro == NULL)
1916 macro = macro_of_context (pfile->context);
1918 context = next_context (pfile);
1919 context->tokens_kind = TOKENS_KIND_DIRECT;
1920 context->c.macro = macro;
1921 context->buff = NULL;
1922 FIRST (context).token = first;
1923 LAST (context).token = first + count;
1926 /* Build a context containing a list of tokens as well as their
1927 virtual locations and push it. TOKENS_BUFF is the buffer that
1928 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
1929 non-NULL, it means that the context owns it, meaning that
1930 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
1931 contains the virtual locations.
1933 A NULL macro means that we should continue the current macro
1934 expansion, in essence. That means that if we are currently in a
1935 macro expansion context, we'll make the new pfile->context refer to
1936 the current macro. */
1937 static void
1938 push_extended_tokens_context (cpp_reader *pfile,
1939 cpp_hashnode *macro,
1940 _cpp_buff *token_buff,
1941 source_location *virt_locs,
1942 const cpp_token **first,
1943 unsigned int count)
1945 cpp_context *context;
1946 macro_context *m;
1948 if (macro == NULL)
1949 macro = macro_of_context (pfile->context);
1951 context = next_context (pfile);
1952 context->tokens_kind = TOKENS_KIND_EXTENDED;
1953 context->buff = token_buff;
1955 m = XNEW (macro_context);
1956 m->macro_node = macro;
1957 m->virt_locs = virt_locs;
1958 m->cur_virt_loc = virt_locs;
1959 context->c.mc = m;
1960 FIRST (context).ptoken = first;
1961 LAST (context).ptoken = first + count;
1964 /* Push a traditional macro's replacement text. */
1965 void
1966 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1967 const uchar *start, size_t len)
1969 cpp_context *context = next_context (pfile);
1971 context->tokens_kind = TOKENS_KIND_DIRECT;
1972 context->c.macro = macro;
1973 context->buff = NULL;
1974 CUR (context) = start;
1975 RLIMIT (context) = start + len;
1976 macro->flags |= NODE_DISABLED;
1979 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
1980 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
1981 non-null (which means that -ftrack-macro-expansion is on),
1982 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
1983 hold the virtual locations of the tokens resulting from macro
1984 expansion. */
1985 static _cpp_buff*
1986 tokens_buff_new (cpp_reader *pfile, size_t len,
1987 source_location **virt_locs)
1989 size_t tokens_size = len * sizeof (cpp_token *);
1990 size_t locs_size = len * sizeof (source_location);
1992 if (virt_locs != NULL)
1993 *virt_locs = XNEWVEC (source_location, locs_size);
1994 return _cpp_get_buff (pfile, tokens_size);
1997 /* Returns the number of tokens contained in a token buffer. The
1998 buffer holds a set of cpp_token*. */
1999 static size_t
2000 tokens_buff_count (_cpp_buff *buff)
2002 return (BUFF_FRONT (buff) - buff->base) / sizeof (cpp_token *);
2005 /* Return a pointer to the last token contained in the token buffer
2006 BUFF. */
2007 static const cpp_token **
2008 tokens_buff_last_token_ptr (_cpp_buff *buff)
2010 return &((const cpp_token **) BUFF_FRONT (buff))[-1];
2013 /* Remove the last token contained in the token buffer TOKENS_BUFF.
2014 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
2015 containing the virtual locations of the tokens in TOKENS_BUFF; in
2016 which case the function updates that buffer as well. */
2017 static inline void
2018 tokens_buff_remove_last_token (_cpp_buff *tokens_buff)
2021 if (BUFF_FRONT (tokens_buff) > tokens_buff->base)
2022 BUFF_FRONT (tokens_buff) =
2023 (unsigned char *) &((cpp_token **) BUFF_FRONT (tokens_buff))[-1];
2026 /* Insert a token into the token buffer at the position pointed to by
2027 DEST. Note that the buffer is not enlarged so the previous token
2028 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
2029 means -ftrack-macro-expansion is effect; it then points to where to
2030 insert the virtual location of TOKEN. TOKEN is the token to
2031 insert. VIRT_LOC is the virtual location of the token, i.e, the
2032 location possibly encoding its locus across macro expansion. If
2033 TOKEN is an argument of a function-like macro (inside a macro
2034 replacement list), PARM_DEF_LOC is the spelling location of the
2035 macro parameter that TOKEN is replacing, in the replacement list of
2036 the macro. If TOKEN is not an argument of a function-like macro or
2037 if it doesn't come from a macro expansion, then VIRT_LOC can just
2038 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
2039 means TOKEN comes from a macro expansion and MAP is the macro map
2040 associated to the macro. MACRO_TOKEN_INDEX points to the index of
2041 the token in the macro map; it is not considered if MAP is NULL.
2043 Upon successful completion this function returns the a pointer to
2044 the position of the token coming right after the insertion
2045 point. */
2046 static inline const cpp_token **
2047 tokens_buff_put_token_to (const cpp_token **dest,
2048 source_location *virt_loc_dest,
2049 const cpp_token *token,
2050 source_location virt_loc,
2051 source_location parm_def_loc,
2052 const struct line_map *map,
2053 unsigned int macro_token_index)
2055 source_location macro_loc = virt_loc;
2056 const cpp_token **result;
2058 if (virt_loc_dest)
2060 /* -ftrack-macro-expansion is on. */
2061 if (map)
2062 macro_loc = linemap_add_macro_token (map, macro_token_index,
2063 virt_loc, parm_def_loc);
2064 *virt_loc_dest = macro_loc;
2066 *dest = token;
2067 result = &dest[1];
2069 return result;
2072 /* Adds a token at the end of the tokens contained in BUFFER. Note
2073 that this function doesn't enlarge BUFFER when the number of tokens
2074 reaches BUFFER's size; it aborts in that situation.
2076 TOKEN is the token to append. VIRT_LOC is the virtual location of
2077 the token, i.e, the location possibly encoding its locus across
2078 macro expansion. If TOKEN is an argument of a function-like macro
2079 (inside a macro replacement list), PARM_DEF_LOC is the location of
2080 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
2081 from a macro expansion, then VIRT_LOC can just be set to the same
2082 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
2083 from a macro expansion and MAP is the macro map associated to the
2084 macro. MACRO_TOKEN_INDEX points to the index of the token in the
2085 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
2086 non-null, it means -ftrack-macro-expansion is on; in which case
2087 this function adds the virtual location DEF_LOC to the VIRT_LOCS
2088 array, at the same index as the one of TOKEN in BUFFER. Upon
2089 successful completion this function returns the a pointer to the
2090 position of the token coming right after the insertion point. */
2091 static const cpp_token **
2092 tokens_buff_add_token (_cpp_buff *buffer,
2093 source_location *virt_locs,
2094 const cpp_token *token,
2095 source_location virt_loc,
2096 source_location parm_def_loc,
2097 const struct line_map *map,
2098 unsigned int macro_token_index)
2100 const cpp_token **result;
2101 source_location *virt_loc_dest = NULL;
2102 unsigned token_index =
2103 (BUFF_FRONT (buffer) - buffer->base) / sizeof (cpp_token *);
2105 /* Abort if we pass the end the buffer. */
2106 if (BUFF_FRONT (buffer) > BUFF_LIMIT (buffer))
2107 abort ();
2109 if (virt_locs != NULL)
2110 virt_loc_dest = &virt_locs[token_index];
2112 result =
2113 tokens_buff_put_token_to ((const cpp_token **) BUFF_FRONT (buffer),
2114 virt_loc_dest, token, virt_loc, parm_def_loc,
2115 map, macro_token_index);
2117 BUFF_FRONT (buffer) = (unsigned char *) result;
2118 return result;
2121 /* Allocate space for the function-like macro argument ARG to store
2122 the tokens resulting from the macro-expansion of the tokens that
2123 make up ARG itself. That space is allocated in ARG->expanded and
2124 needs to be freed using free. */
2125 static void
2126 alloc_expanded_arg_mem (cpp_reader *pfile, macro_arg *arg, size_t capacity)
2128 #ifdef ENABLE_CHECKING
2129 if (arg->expanded != NULL
2130 || arg->expanded_virt_locs != NULL)
2131 abort ();
2132 #endif
2133 arg->expanded = XNEWVEC (const cpp_token *, capacity);
2134 if (CPP_OPTION (pfile, track_macro_expansion))
2135 arg->expanded_virt_locs = XNEWVEC (source_location, capacity);
2139 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2140 tokens. */
2141 static void
2142 ensure_expanded_arg_room (cpp_reader *pfile, macro_arg *arg,
2143 size_t size, size_t *expanded_capacity)
2145 if (size <= *expanded_capacity)
2146 return;
2148 size *= 2;
2150 arg->expanded =
2151 XRESIZEVEC (const cpp_token *, arg->expanded, size);
2152 *expanded_capacity = size;
2154 if (CPP_OPTION (pfile, track_macro_expansion))
2156 if (arg->expanded_virt_locs == NULL)
2157 arg->expanded_virt_locs = XNEWVEC (source_location, size);
2158 else
2159 arg->expanded_virt_locs = XRESIZEVEC (source_location,
2160 arg->expanded_virt_locs,
2161 size);
2165 /* Expand an argument ARG before replacing parameters in a
2166 function-like macro. This works by pushing a context with the
2167 argument's tokens, and then expanding that into a temporary buffer
2168 as if it were a normal part of the token stream. collect_args()
2169 has terminated the argument's tokens with a CPP_EOF so that we know
2170 when we have fully expanded the argument. */
2171 static void
2172 expand_arg (cpp_reader *pfile, macro_arg *arg)
2174 size_t capacity;
2175 bool saved_warn_trad;
2176 bool track_macro_exp_p = CPP_OPTION (pfile, track_macro_expansion);
2178 if (arg->count == 0
2179 || arg->expanded != NULL)
2180 return;
2182 /* Don't warn about funlike macros when pre-expanding. */
2183 saved_warn_trad = CPP_WTRADITIONAL (pfile);
2184 CPP_WTRADITIONAL (pfile) = 0;
2186 /* Loop, reading in the tokens of the argument. */
2187 capacity = 256;
2188 alloc_expanded_arg_mem (pfile, arg, capacity);
2190 if (track_macro_exp_p)
2191 push_extended_tokens_context (pfile, NULL, NULL,
2192 arg->virt_locs,
2193 arg->first,
2194 arg->count + 1);
2195 else
2196 push_ptoken_context (pfile, NULL, NULL,
2197 arg->first, arg->count + 1);
2199 for (;;)
2201 const cpp_token *token;
2202 source_location location;
2204 ensure_expanded_arg_room (pfile, arg, arg->expanded_count + 1,
2205 &capacity);
2207 token = cpp_get_token_1 (pfile, &location);
2209 if (token->type == CPP_EOF)
2210 break;
2212 set_arg_token (arg, token, location,
2213 arg->expanded_count, MACRO_ARG_TOKEN_EXPANDED,
2214 CPP_OPTION (pfile, track_macro_expansion));
2215 arg->expanded_count++;
2218 _cpp_pop_context (pfile);
2220 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
2223 /* Returns the macro associated to the current context if we are in
2224 the context a macro expansion, NULL otherwise. */
2225 static cpp_hashnode*
2226 macro_of_context (cpp_context *context)
2228 if (context == NULL)
2229 return NULL;
2231 return (context->tokens_kind == TOKENS_KIND_EXTENDED)
2232 ? context->c.mc->macro_node
2233 : context->c.macro;
2236 /* Return TRUE iff we are expanding a macro or are about to start
2237 expanding one. If we are effectively expanding a macro, the
2238 function macro_of_context returns a pointer to the macro being
2239 expanded. */
2240 static bool
2241 in_macro_expansion_p (cpp_reader *pfile)
2243 if (pfile == NULL)
2244 return false;
2246 return (pfile->about_to_expand_macro_p
2247 || macro_of_context (pfile->context));
2250 /* Pop the current context off the stack, re-enabling the macro if the
2251 context represented a macro's replacement list. Initially the
2252 context structure was not freed so that we can re-use it later, but
2253 now we do free it to reduce peak memory consumption. */
2254 void
2255 _cpp_pop_context (cpp_reader *pfile)
2257 cpp_context *context = pfile->context;
2259 /* We should not be popping the base context. */
2260 if (context == &pfile->base_context)
2261 abort ();
2263 if (context->c.macro)
2265 cpp_hashnode *macro;
2266 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
2268 macro_context *mc = context->c.mc;
2269 macro = mc->macro_node;
2270 /* If context->buff is set, it means the life time of tokens
2271 is bound to the life time of this context; so we must
2272 free the tokens; that means we must free the virtual
2273 locations of these tokens too. */
2274 if (context->buff && mc->virt_locs)
2276 free (mc->virt_locs);
2277 mc->virt_locs = NULL;
2279 free (mc);
2280 context->c.mc = NULL;
2282 else
2283 macro = context->c.macro;
2285 /* Beware that MACRO can be NULL in cases like when we are
2286 called from expand_arg. In those cases, a dummy context with
2287 tokens is pushed just for the purpose of walking them using
2288 cpp_get_token_1. In that case, no 'macro' field is set into
2289 the dummy context. */
2290 if (macro != NULL
2291 /* Several contiguous macro expansion contexts can be
2292 associated to the same macro; that means it's the same
2293 macro expansion that spans across all these (sub)
2294 contexts. So we should re-enable an expansion-disabled
2295 macro only when we are sure we are really out of that
2296 macro expansion. */
2297 && macro_of_context (context->prev) != macro)
2298 macro->flags &= ~NODE_DISABLED;
2301 if (context->buff)
2303 /* Decrease memory peak consumption by freeing the memory used
2304 by the context. */
2305 _cpp_free_buff (context->buff);
2308 pfile->context = context->prev;
2309 /* decrease peak memory consumption by feeing the context. */
2310 pfile->context->next = NULL;
2311 free (context);
2314 /* Return TRUE if we reached the end of the set of tokens stored in
2315 CONTEXT, FALSE otherwise. */
2316 static inline bool
2317 reached_end_of_context (cpp_context *context)
2319 if (context->tokens_kind == TOKENS_KIND_DIRECT)
2320 return FIRST (context).token == LAST (context).token;
2321 else if (context->tokens_kind == TOKENS_KIND_INDIRECT
2322 || context->tokens_kind == TOKENS_KIND_EXTENDED)
2323 return FIRST (context).ptoken == LAST (context).ptoken;
2324 else
2325 abort ();
2328 /* Consume the next token contained in the current context of PFILE,
2329 and return it in *TOKEN. It's "full location" is returned in
2330 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2331 means the location encoding the locus of the token across macro
2332 expansion; otherwise it's just is the "normal" location of the
2333 token which (*TOKEN)->src_loc. */
2334 static inline void
2335 consume_next_token_from_context (cpp_reader *pfile,
2336 const cpp_token ** token,
2337 source_location *location)
2339 cpp_context *c = pfile->context;
2341 if ((c)->tokens_kind == TOKENS_KIND_DIRECT)
2343 *token = FIRST (c).token;
2344 *location = (*token)->src_loc;
2345 FIRST (c).token++;
2347 else if ((c)->tokens_kind == TOKENS_KIND_INDIRECT)
2349 *token = *FIRST (c).ptoken;
2350 *location = (*token)->src_loc;
2351 FIRST (c).ptoken++;
2353 else if ((c)->tokens_kind == TOKENS_KIND_EXTENDED)
2355 macro_context *m = c->c.mc;
2356 *token = *FIRST (c).ptoken;
2357 if (m->virt_locs)
2359 *location = *m->cur_virt_loc;
2360 m->cur_virt_loc++;
2362 else
2363 *location = (*token)->src_loc;
2364 FIRST (c).ptoken++;
2366 else
2367 abort ();
2370 /* In the traditional mode of the preprocessor, if we are currently in
2371 a directive, the location of a token must be the location of the
2372 start of the directive line. This function returns the proper
2373 location if we are in the traditional mode, and just returns
2374 LOCATION otherwise. */
2376 static inline source_location
2377 maybe_adjust_loc_for_trad_cpp (cpp_reader *pfile, source_location location)
2379 if (CPP_OPTION (pfile, traditional))
2381 if (pfile->state.in_directive)
2382 return pfile->directive_line;
2384 return location;
2387 /* Routine to get a token as well as its location.
2389 Macro expansions and directives are transparently handled,
2390 including entering included files. Thus tokens are post-macro
2391 expansion, and after any intervening directives. External callers
2392 see CPP_EOF only at EOF. Internal callers also see it when meeting
2393 a directive inside a macro call, when at the end of a directive and
2394 state.in_directive is still 1, and at the end of argument
2395 pre-expansion.
2397 LOC is an out parameter; *LOC is set to the location "as expected
2398 by the user". Please read the comment of
2399 cpp_get_token_with_location to learn more about the meaning of this
2400 location. */
2401 static const cpp_token*
2402 cpp_get_token_1 (cpp_reader *pfile, source_location *location)
2404 const cpp_token *result;
2405 /* This token is a virtual token that either encodes a location
2406 related to macro expansion or a spelling location. */
2407 source_location virt_loc = 0;
2408 /* pfile->about_to_expand_macro_p can be overriden by indirect calls
2409 to functions that push macro contexts. So let's save it so that
2410 we can restore it when we are about to leave this routine. */
2411 bool saved_about_to_expand_macro = pfile->about_to_expand_macro_p;
2413 for (;;)
2415 cpp_hashnode *node;
2416 cpp_context *context = pfile->context;
2418 /* Context->prev == 0 <=> base context. */
2419 if (!context->prev)
2421 result = _cpp_lex_token (pfile);
2422 virt_loc = result->src_loc;
2424 else if (!reached_end_of_context (context))
2426 consume_next_token_from_context (pfile, &result,
2427 &virt_loc);
2428 if (result->flags & PASTE_LEFT)
2430 paste_all_tokens (pfile, result);
2431 if (pfile->state.in_directive)
2432 continue;
2433 result = padding_token (pfile, result);
2434 goto out;
2437 else
2439 if (pfile->context->c.macro)
2440 ++num_expanded_macros_counter;
2441 _cpp_pop_context (pfile);
2442 if (pfile->state.in_directive)
2443 continue;
2444 result = &pfile->avoid_paste;
2445 goto out;
2448 if (pfile->state.in_directive && result->type == CPP_COMMENT)
2449 continue;
2451 if (result->type != CPP_NAME)
2452 break;
2454 node = result->val.node.node;
2456 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
2457 break;
2459 if (!(node->flags & NODE_DISABLED))
2461 int ret = 0;
2462 /* If not in a macro context, and we're going to start an
2463 expansion, record the location. */
2464 if (!in_macro_expansion_p (pfile))
2465 pfile->invocation_location = result->src_loc;
2466 if (pfile->state.prevent_expansion)
2467 break;
2469 /* Conditional macros require that a predicate be evaluated
2470 first. */
2471 if ((node->flags & NODE_CONDITIONAL) != 0)
2473 if (pfile->cb.macro_to_expand)
2475 bool whitespace_after;
2476 const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
2478 whitespace_after = (peek_tok->type == CPP_PADDING
2479 || (peek_tok->flags & PREV_WHITE));
2480 node = pfile->cb.macro_to_expand (pfile, result);
2481 if (node)
2482 ret = enter_macro_context (pfile, node, result,
2483 virt_loc);
2484 else if (whitespace_after)
2486 /* If macro_to_expand hook returned NULL and it
2487 ate some tokens, see if we don't need to add
2488 a padding token in between this and the
2489 next token. */
2490 peek_tok = cpp_peek_token (pfile, 0);
2491 if (peek_tok->type != CPP_PADDING
2492 && (peek_tok->flags & PREV_WHITE) == 0)
2493 _cpp_push_token_context (pfile, NULL,
2494 padding_token (pfile,
2495 peek_tok), 1);
2499 else
2500 ret = enter_macro_context (pfile, node, result,
2501 virt_loc);
2502 if (ret)
2504 if (pfile->state.in_directive || ret == 2)
2505 continue;
2506 result = padding_token (pfile, result);
2507 goto out;
2510 else
2512 /* Flag this token as always unexpandable. FIXME: move this
2513 to collect_args()?. */
2514 cpp_token *t = _cpp_temp_token (pfile);
2515 t->type = result->type;
2516 t->flags = result->flags | NO_EXPAND;
2517 t->val = result->val;
2518 result = t;
2521 break;
2524 out:
2525 if (location != NULL)
2527 if (virt_loc == 0)
2528 virt_loc = result->src_loc;
2529 *location = virt_loc;
2531 if (!CPP_OPTION (pfile, track_macro_expansion)
2532 && macro_of_context (pfile->context) != NULL)
2533 /* We are in a macro expansion context, are not tracking
2534 virtual location, but were asked to report the location
2535 of the expansion point of the macro being expanded. */
2536 *location = pfile->invocation_location;
2538 *location = maybe_adjust_loc_for_trad_cpp (pfile, *location);
2541 pfile->about_to_expand_macro_p = saved_about_to_expand_macro;
2542 return result;
2545 /* External routine to get a token. Also used nearly everywhere
2546 internally, except for places where we know we can safely call
2547 _cpp_lex_token directly, such as lexing a directive name.
2549 Macro expansions and directives are transparently handled,
2550 including entering included files. Thus tokens are post-macro
2551 expansion, and after any intervening directives. External callers
2552 see CPP_EOF only at EOF. Internal callers also see it when meeting
2553 a directive inside a macro call, when at the end of a directive and
2554 state.in_directive is still 1, and at the end of argument
2555 pre-expansion. */
2556 const cpp_token *
2557 cpp_get_token (cpp_reader *pfile)
2559 return cpp_get_token_1 (pfile, NULL);
2562 /* Like cpp_get_token, but also returns a virtual token location
2563 separate from the spelling location carried by the returned token.
2565 LOC is an out parameter; *LOC is set to the location "as expected
2566 by the user". This matters when a token results from macro
2567 expansion; in that case the token's spelling location indicates the
2568 locus of the token in the definition of the macro but *LOC
2569 virtually encodes all the other meaningful locuses associated to
2570 the token.
2572 What? virtual location? Yes, virtual location.
2574 If the token results from macro expansion and if macro expansion
2575 location tracking is enabled its virtual location encodes (at the
2576 same time):
2578 - the spelling location of the token
2580 - the locus of the macro expansion point
2582 - the locus of the point where the token got instantiated as part
2583 of the macro expansion process.
2585 You have to use the linemap API to get the locus you are interested
2586 in from a given virtual location.
2588 Note however that virtual locations are not necessarily ordered for
2589 relations '<' and '>'. One must use the function
2590 linemap_location_before_p instead of using the relational operator
2591 '<'.
2593 If macro expansion tracking is off and if the token results from
2594 macro expansion the virtual location is the expansion point of the
2595 macro that got expanded.
2597 When the token doesn't result from macro expansion, the virtual
2598 location is just the same thing as its spelling location. */
2600 const cpp_token *
2601 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
2603 return cpp_get_token_1 (pfile, loc);
2606 /* Returns true if we're expanding an object-like macro that was
2607 defined in a system header. Just checks the macro at the top of
2608 the stack. Used for diagnostic suppression. */
2610 cpp_sys_macro_p (cpp_reader *pfile)
2612 cpp_hashnode *node = NULL;
2614 if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
2615 node = pfile->context->c.mc->macro_node;
2616 else
2617 node = pfile->context->c.macro;
2619 return node && node->value.macro && node->value.macro->syshdr;
2622 /* Read each token in, until end of the current file. Directives are
2623 transparently processed. */
2624 void
2625 cpp_scan_nooutput (cpp_reader *pfile)
2627 /* Request a CPP_EOF token at the end of this file, rather than
2628 transparently continuing with the including file. */
2629 pfile->buffer->return_at_eof = true;
2631 pfile->state.discarding_output++;
2632 pfile->state.prevent_expansion++;
2634 if (CPP_OPTION (pfile, traditional))
2635 while (_cpp_read_logical_line_trad (pfile))
2637 else
2638 while (cpp_get_token (pfile)->type != CPP_EOF)
2641 pfile->state.discarding_output--;
2642 pfile->state.prevent_expansion--;
2645 /* Step back one or more tokens obtained from the lexer. */
2646 void
2647 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
2649 pfile->lookaheads += count;
2650 while (count--)
2652 pfile->cur_token--;
2653 if (pfile->cur_token == pfile->cur_run->base
2654 /* Possible with -fpreprocessed and no leading #line. */
2655 && pfile->cur_run->prev != NULL)
2657 pfile->cur_run = pfile->cur_run->prev;
2658 pfile->cur_token = pfile->cur_run->limit;
2663 /* Step back one (or more) tokens. Can only step back more than 1 if
2664 they are from the lexer, and not from macro expansion. */
2665 void
2666 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
2668 if (pfile->context->prev == NULL)
2669 _cpp_backup_tokens_direct (pfile, count);
2670 else
2672 if (count != 1)
2673 abort ();
2674 if (pfile->context->tokens_kind == TOKENS_KIND_DIRECT)
2675 FIRST (pfile->context).token--;
2676 else if (pfile->context->tokens_kind == TOKENS_KIND_INDIRECT)
2677 FIRST (pfile->context).ptoken--;
2678 else if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
2680 FIRST (pfile->context).ptoken--;
2681 if (pfile->context->c.macro)
2683 macro_context *m = pfile->context->c.mc;
2684 m->cur_virt_loc--;
2685 #ifdef ENABLE_CHECKING
2686 if (m->cur_virt_loc < m->virt_locs)
2687 abort ();
2688 #endif
2690 else
2691 abort ();
2693 else
2694 abort ();
2698 /* #define directive parsing and handling. */
2700 /* Returns nonzero if a macro redefinition warning is required. */
2701 static bool
2702 warn_of_redefinition (cpp_reader *pfile, cpp_hashnode *node,
2703 const cpp_macro *macro2)
2705 const cpp_macro *macro1;
2706 unsigned int i;
2708 /* Some redefinitions need to be warned about regardless. */
2709 if (node->flags & NODE_WARN)
2710 return true;
2712 /* Suppress warnings for builtins that lack the NODE_WARN flag,
2713 unless Wbuiltin-macro-redefined. */
2714 if (node->flags & NODE_BUILTIN
2715 && (!pfile->cb.user_builtin_macro
2716 || !pfile->cb.user_builtin_macro (pfile, node)))
2717 return CPP_OPTION (pfile, warn_builtin_macro_redefined);
2719 /* Redefinitions of conditional (context-sensitive) macros, on
2720 the other hand, must be allowed silently. */
2721 if (node->flags & NODE_CONDITIONAL)
2722 return false;
2724 /* Redefinition of a macro is allowed if and only if the old and new
2725 definitions are the same. (6.10.3 paragraph 2). */
2726 macro1 = node->value.macro;
2728 /* Don't check count here as it can be different in valid
2729 traditional redefinitions with just whitespace differences. */
2730 if (macro1->paramc != macro2->paramc
2731 || macro1->fun_like != macro2->fun_like
2732 || macro1->variadic != macro2->variadic)
2733 return true;
2735 /* Check parameter spellings. */
2736 for (i = 0; i < macro1->paramc; i++)
2737 if (macro1->params[i] != macro2->params[i])
2738 return true;
2740 /* Check the replacement text or tokens. */
2741 if (CPP_OPTION (pfile, traditional))
2742 return _cpp_expansions_different_trad (macro1, macro2);
2744 if (macro1->count != macro2->count)
2745 return true;
2747 for (i = 0; i < macro1->count; i++)
2748 if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
2749 return true;
2751 return false;
2754 /* Free the definition of hashnode H. */
2755 void
2756 _cpp_free_definition (cpp_hashnode *h)
2758 /* Macros and assertions no longer have anything to free. */
2759 h->type = NT_VOID;
2760 /* Clear builtin flag in case of redefinition. */
2761 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
2764 /* Save parameter NODE (spelling SPELLING) to the parameter list of
2765 macro MACRO. Returns zero on success, nonzero if the parameter is
2766 a duplicate. */
2767 bool
2768 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node,
2769 cpp_hashnode *spelling)
2771 unsigned int len;
2772 /* Constraint 6.10.3.6 - duplicate parameter names. */
2773 if (node->flags & NODE_MACRO_ARG)
2775 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
2776 NODE_NAME (node));
2777 return true;
2780 if (BUFF_ROOM (pfile->a_buff)
2781 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
2782 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
2784 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = spelling;
2785 node->flags |= NODE_MACRO_ARG;
2786 len = macro->paramc * sizeof (struct macro_arg_saved_data);
2787 if (len > pfile->macro_buffer_len)
2789 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
2790 len);
2791 pfile->macro_buffer_len = len;
2793 struct macro_arg_saved_data save;
2794 save.value = node->value;
2795 save.canonical_node = node;
2796 ((struct macro_arg_saved_data *) pfile->macro_buffer)[macro->paramc - 1]
2797 = save;
2799 node->value.arg_index = macro->paramc;
2800 return false;
2803 /* Check the syntax of the parameters in a MACRO definition. Returns
2804 false if an error occurs. */
2805 static bool
2806 parse_params (cpp_reader *pfile, cpp_macro *macro)
2808 unsigned int prev_ident = 0;
2810 for (;;)
2812 const cpp_token *token = _cpp_lex_token (pfile);
2814 switch (token->type)
2816 default:
2817 /* Allow/ignore comments in parameter lists if we are
2818 preserving comments in macro expansions. */
2819 if (token->type == CPP_COMMENT
2820 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
2821 continue;
2823 cpp_error (pfile, CPP_DL_ERROR,
2824 "\"%s\" may not appear in macro parameter list",
2825 cpp_token_as_text (pfile, token));
2826 return false;
2828 case CPP_NAME:
2829 if (prev_ident)
2831 cpp_error (pfile, CPP_DL_ERROR,
2832 "macro parameters must be comma-separated");
2833 return false;
2835 prev_ident = 1;
2837 if (_cpp_save_parameter (pfile, macro, token->val.node.node,
2838 token->val.node.spelling))
2839 return false;
2840 continue;
2842 case CPP_CLOSE_PAREN:
2843 if (prev_ident || macro->paramc == 0)
2844 return true;
2846 /* Fall through to pick up the error. */
2847 case CPP_COMMA:
2848 if (!prev_ident)
2850 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
2851 return false;
2853 prev_ident = 0;
2854 continue;
2856 case CPP_ELLIPSIS:
2857 macro->variadic = 1;
2858 if (!prev_ident)
2860 _cpp_save_parameter (pfile, macro,
2861 pfile->spec_nodes.n__VA_ARGS__,
2862 pfile->spec_nodes.n__VA_ARGS__);
2863 pfile->state.va_args_ok = 1;
2864 if (! CPP_OPTION (pfile, c99)
2865 && CPP_OPTION (pfile, cpp_pedantic)
2866 && CPP_OPTION (pfile, warn_variadic_macros))
2868 if (CPP_OPTION (pfile, cplusplus))
2869 cpp_pedwarning
2870 (pfile, CPP_W_VARIADIC_MACROS,
2871 "anonymous variadic macros were introduced in C++11");
2872 else
2873 cpp_pedwarning
2874 (pfile, CPP_W_VARIADIC_MACROS,
2875 "anonymous variadic macros were introduced in C99");
2877 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
2878 && ! CPP_OPTION (pfile, cplusplus))
2879 cpp_error (pfile, CPP_DL_WARNING,
2880 "anonymous variadic macros were introduced in C99");
2882 else if (CPP_OPTION (pfile, cpp_pedantic)
2883 && CPP_OPTION (pfile, warn_variadic_macros))
2885 if (CPP_OPTION (pfile, cplusplus))
2886 cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
2887 "ISO C++ does not permit named variadic macros");
2888 else
2889 cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
2890 "ISO C does not permit named variadic macros");
2893 /* We're at the end, and just expect a closing parenthesis. */
2894 token = _cpp_lex_token (pfile);
2895 if (token->type == CPP_CLOSE_PAREN)
2896 return true;
2897 /* Fall through. */
2899 case CPP_EOF:
2900 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
2901 return false;
2906 /* Allocate room for a token from a macro's replacement list. */
2907 static cpp_token *
2908 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
2910 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
2911 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
2913 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
2916 /* Lex a token from the expansion of MACRO, but mark parameters as we
2917 find them and warn of traditional stringification. */
2918 static cpp_token *
2919 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
2921 cpp_token *token, *saved_cur_token;
2923 saved_cur_token = pfile->cur_token;
2924 pfile->cur_token = alloc_expansion_token (pfile, macro);
2925 token = _cpp_lex_direct (pfile);
2926 pfile->cur_token = saved_cur_token;
2928 /* Is this a parameter? */
2929 if (token->type == CPP_NAME
2930 && (token->val.node.node->flags & NODE_MACRO_ARG) != 0)
2932 cpp_hashnode *spelling = token->val.node.spelling;
2933 token->type = CPP_MACRO_ARG;
2934 token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
2935 token->val.macro_arg.spelling = spelling;
2937 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
2938 && (token->type == CPP_STRING || token->type == CPP_CHAR))
2939 check_trad_stringification (pfile, macro, &token->val.str);
2941 return token;
2944 static bool
2945 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
2947 cpp_token *token;
2948 const cpp_token *ctoken;
2949 bool following_paste_op = false;
2950 const char *paste_op_error_msg =
2951 N_("'##' cannot appear at either end of a macro expansion");
2952 unsigned int num_extra_tokens = 0;
2954 /* Get the first token of the expansion (or the '(' of a
2955 function-like macro). */
2956 ctoken = _cpp_lex_token (pfile);
2958 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
2960 bool ok = parse_params (pfile, macro);
2961 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
2962 if (!ok)
2963 return false;
2965 /* Success. Commit or allocate the parameter array. */
2966 if (pfile->hash_table->alloc_subobject)
2968 cpp_hashnode **params =
2969 (cpp_hashnode **) pfile->hash_table->alloc_subobject
2970 (sizeof (cpp_hashnode *) * macro->paramc);
2971 memcpy (params, macro->params,
2972 sizeof (cpp_hashnode *) * macro->paramc);
2973 macro->params = params;
2975 else
2976 BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
2977 macro->fun_like = 1;
2979 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
2981 /* While ISO C99 requires whitespace before replacement text
2982 in a macro definition, ISO C90 with TC1 allows characters
2983 from the basic source character set there. */
2984 if (CPP_OPTION (pfile, c99))
2986 if (CPP_OPTION (pfile, cplusplus))
2987 cpp_error (pfile, CPP_DL_PEDWARN,
2988 "ISO C++11 requires whitespace after the macro name");
2989 else
2990 cpp_error (pfile, CPP_DL_PEDWARN,
2991 "ISO C99 requires whitespace after the macro name");
2993 else
2995 int warntype = CPP_DL_WARNING;
2996 switch (ctoken->type)
2998 case CPP_ATSIGN:
2999 case CPP_AT_NAME:
3000 case CPP_OBJC_STRING:
3001 /* '@' is not in basic character set. */
3002 warntype = CPP_DL_PEDWARN;
3003 break;
3004 case CPP_OTHER:
3005 /* Basic character set sans letters, digits and _. */
3006 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
3007 ctoken->val.str.text[0]) == NULL)
3008 warntype = CPP_DL_PEDWARN;
3009 break;
3010 default:
3011 /* All other tokens start with a character from basic
3012 character set. */
3013 break;
3015 cpp_error (pfile, warntype,
3016 "missing whitespace after the macro name");
3020 if (macro->fun_like)
3021 token = lex_expansion_token (pfile, macro);
3022 else
3024 token = alloc_expansion_token (pfile, macro);
3025 *token = *ctoken;
3028 for (;;)
3030 /* Check the stringifying # constraint 6.10.3.2.1 of
3031 function-like macros when lexing the subsequent token. */
3032 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
3034 if (token->type == CPP_MACRO_ARG)
3036 if (token->flags & PREV_WHITE)
3037 token->flags |= SP_PREV_WHITE;
3038 if (token[-1].flags & DIGRAPH)
3039 token->flags |= SP_DIGRAPH;
3040 token->flags &= ~PREV_WHITE;
3041 token->flags |= STRINGIFY_ARG;
3042 token->flags |= token[-1].flags & PREV_WHITE;
3043 token[-1] = token[0];
3044 macro->count--;
3046 /* Let assembler get away with murder. */
3047 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
3049 cpp_error (pfile, CPP_DL_ERROR,
3050 "'#' is not followed by a macro parameter");
3051 return false;
3055 if (token->type == CPP_EOF)
3057 /* Paste operator constraint 6.10.3.3.1:
3058 Token-paste ##, can appear in both object-like and
3059 function-like macros, but not at the end. */
3060 if (following_paste_op)
3062 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
3063 return false;
3065 break;
3068 /* Paste operator constraint 6.10.3.3.1. */
3069 if (token->type == CPP_PASTE)
3071 /* Token-paste ##, can appear in both object-like and
3072 function-like macros, but not at the beginning. */
3073 if (macro->count == 1)
3075 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
3076 return false;
3079 if (token[-1].flags & PASTE_LEFT)
3081 macro->extra_tokens = 1;
3082 num_extra_tokens++;
3083 token->val.token_no = macro->count - 1;
3085 else
3087 --macro->count;
3088 token[-1].flags |= PASTE_LEFT;
3089 if (token->flags & DIGRAPH)
3090 token[-1].flags |= SP_DIGRAPH;
3091 if (token->flags & PREV_WHITE)
3092 token[-1].flags |= SP_PREV_WHITE;
3096 following_paste_op = (token->type == CPP_PASTE);
3097 token = lex_expansion_token (pfile, macro);
3100 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
3101 macro->traditional = 0;
3103 /* Don't count the CPP_EOF. */
3104 macro->count--;
3106 /* Clear whitespace on first token for warn_of_redefinition(). */
3107 if (macro->count)
3108 macro->exp.tokens[0].flags &= ~PREV_WHITE;
3110 /* Commit or allocate the memory. */
3111 if (pfile->hash_table->alloc_subobject)
3113 cpp_token *tokns =
3114 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
3115 * macro->count);
3116 if (num_extra_tokens)
3118 /* Place second and subsequent ## or %:%: tokens in
3119 sequences of consecutive such tokens at the end of the
3120 list to preserve information about where they appear, how
3121 they are spelt and whether they are preceded by
3122 whitespace without otherwise interfering with macro
3123 expansion. */
3124 cpp_token *normal_dest = tokns;
3125 cpp_token *extra_dest = tokns + macro->count - num_extra_tokens;
3126 unsigned int i;
3127 for (i = 0; i < macro->count; i++)
3129 if (macro->exp.tokens[i].type == CPP_PASTE)
3130 *extra_dest++ = macro->exp.tokens[i];
3131 else
3132 *normal_dest++ = macro->exp.tokens[i];
3135 else
3136 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
3137 macro->exp.tokens = tokns;
3139 else
3140 BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
3142 return true;
3145 /* Parse a macro and save its expansion. Returns nonzero on success. */
3146 bool
3147 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
3149 cpp_macro *macro;
3150 unsigned int i;
3151 bool ok;
3153 if (pfile->hash_table->alloc_subobject)
3154 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
3155 (sizeof (cpp_macro));
3156 else
3157 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
3158 macro->line = pfile->directive_line;
3159 macro->params = 0;
3160 macro->paramc = 0;
3161 macro->variadic = 0;
3162 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
3163 macro->count = 0;
3164 macro->fun_like = 0;
3165 macro->extra_tokens = 0;
3166 /* To suppress some diagnostics. */
3167 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
3169 if (CPP_OPTION (pfile, traditional))
3170 ok = _cpp_create_trad_definition (pfile, macro);
3171 else
3173 ok = create_iso_definition (pfile, macro);
3175 /* We set the type for SEEN_EOL() in directives.c.
3177 Longer term we should lex the whole line before coming here,
3178 and just copy the expansion. */
3180 /* Stop the lexer accepting __VA_ARGS__. */
3181 pfile->state.va_args_ok = 0;
3184 /* Clear the fast argument lookup indices. */
3185 for (i = macro->paramc; i-- > 0; )
3187 struct macro_arg_saved_data *save =
3188 &((struct macro_arg_saved_data *) pfile->macro_buffer)[i];
3189 struct cpp_hashnode *node = save->canonical_node;
3190 node->flags &= ~ NODE_MACRO_ARG;
3191 node->value = save->value;
3194 if (!ok)
3195 return ok;
3197 if (node->type == NT_MACRO)
3199 if (CPP_OPTION (pfile, warn_unused_macros))
3200 _cpp_warn_if_unused_macro (pfile, node, NULL);
3202 if (warn_of_redefinition (pfile, node, macro))
3204 const int reason = ((node->flags & NODE_BUILTIN)
3205 && !(node->flags & NODE_WARN))
3206 ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
3208 bool warned =
3209 cpp_pedwarning_with_line (pfile, reason,
3210 pfile->directive_line, 0,
3211 "\"%s\" redefined", NODE_NAME (node));
3213 if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
3214 cpp_error_with_line (pfile, CPP_DL_NOTE,
3215 node->value.macro->line, 0,
3216 "this is the location of the previous definition");
3220 if (node->type != NT_VOID)
3221 _cpp_free_definition (node);
3223 /* Enter definition in hash table. */
3224 node->type = NT_MACRO;
3225 node->value.macro = macro;
3226 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
3227 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
3228 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3229 in the C standard, as something that one must use in C++.
3230 However DR#593 and C++11 indicate that they play no role in C++.
3231 We special-case them anyway. */
3232 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
3233 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
3234 node->flags |= NODE_WARN;
3236 /* If user defines one of the conditional macros, remove the
3237 conditional flag */
3238 node->flags &= ~NODE_CONDITIONAL;
3240 return ok;
3243 /* Warn if a token in STRING matches one of a function-like MACRO's
3244 parameters. */
3245 static void
3246 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
3247 const cpp_string *string)
3249 unsigned int i, len;
3250 const uchar *p, *q, *limit;
3252 /* Loop over the string. */
3253 limit = string->text + string->len - 1;
3254 for (p = string->text + 1; p < limit; p = q)
3256 /* Find the start of an identifier. */
3257 while (p < limit && !is_idstart (*p))
3258 p++;
3260 /* Find the end of the identifier. */
3261 q = p;
3262 while (q < limit && is_idchar (*q))
3263 q++;
3265 len = q - p;
3267 /* Loop over the function macro arguments to see if the
3268 identifier inside the string matches one of them. */
3269 for (i = 0; i < macro->paramc; i++)
3271 const cpp_hashnode *node = macro->params[i];
3273 if (NODE_LEN (node) == len
3274 && !memcmp (p, NODE_NAME (node), len))
3276 cpp_error (pfile, CPP_DL_WARNING,
3277 "macro argument \"%s\" would be stringified in traditional C",
3278 NODE_NAME (node));
3279 break;
3285 /* Returns the name, arguments and expansion of a macro, in a format
3286 suitable to be read back in again, and therefore also for DWARF 2
3287 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3288 Caller is expected to generate the "#define" bit if needed. The
3289 returned text is temporary, and automatically freed later. */
3290 const unsigned char *
3291 cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node)
3293 unsigned int i, len;
3294 const cpp_macro *macro;
3295 unsigned char *buffer;
3297 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
3299 if (node->type != NT_MACRO
3300 || !pfile->cb.user_builtin_macro
3301 || !pfile->cb.user_builtin_macro (pfile, node))
3303 cpp_error (pfile, CPP_DL_ICE,
3304 "invalid hash type %d in cpp_macro_definition",
3305 node->type);
3306 return 0;
3310 macro = node->value.macro;
3311 /* Calculate length. */
3312 len = NODE_LEN (node) * 10 + 2; /* ' ' and NUL. */
3313 if (macro->fun_like)
3315 len += 4; /* "()" plus possible final ".." of named
3316 varargs (we have + 1 below). */
3317 for (i = 0; i < macro->paramc; i++)
3318 len += NODE_LEN (macro->params[i]) + 1; /* "," */
3321 /* This should match below where we fill in the buffer. */
3322 if (CPP_OPTION (pfile, traditional))
3323 len += _cpp_replacement_text_len (macro);
3324 else
3326 unsigned int count = macro_real_token_count (macro);
3327 for (i = 0; i < count; i++)
3329 cpp_token *token = &macro->exp.tokens[i];
3331 if (token->type == CPP_MACRO_ARG)
3332 len += NODE_LEN (token->val.macro_arg.spelling);
3333 else
3334 len += cpp_token_len (token);
3336 if (token->flags & STRINGIFY_ARG)
3337 len++; /* "#" */
3338 if (token->flags & PASTE_LEFT)
3339 len += 3; /* " ##" */
3340 if (token->flags & PREV_WHITE)
3341 len++; /* " " */
3345 if (len > pfile->macro_buffer_len)
3347 pfile->macro_buffer = XRESIZEVEC (unsigned char,
3348 pfile->macro_buffer, len);
3349 pfile->macro_buffer_len = len;
3352 /* Fill in the buffer. Start with the macro name. */
3353 buffer = pfile->macro_buffer;
3354 buffer = _cpp_spell_ident_ucns (buffer, node);
3356 /* Parameter names. */
3357 if (macro->fun_like)
3359 *buffer++ = '(';
3360 for (i = 0; i < macro->paramc; i++)
3362 cpp_hashnode *param = macro->params[i];
3364 if (param != pfile->spec_nodes.n__VA_ARGS__)
3366 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
3367 buffer += NODE_LEN (param);
3370 if (i + 1 < macro->paramc)
3371 /* Don't emit a space after the comma here; we're trying
3372 to emit a Dwarf-friendly definition, and the Dwarf spec
3373 forbids spaces in the argument list. */
3374 *buffer++ = ',';
3375 else if (macro->variadic)
3376 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
3378 *buffer++ = ')';
3381 /* The Dwarf spec requires a space after the macro name, even if the
3382 definition is the empty string. */
3383 *buffer++ = ' ';
3385 if (CPP_OPTION (pfile, traditional))
3386 buffer = _cpp_copy_replacement_text (macro, buffer);
3387 else if (macro->count)
3388 /* Expansion tokens. */
3390 unsigned int count = macro_real_token_count (macro);
3391 for (i = 0; i < count; i++)
3393 cpp_token *token = &macro->exp.tokens[i];
3395 if (token->flags & PREV_WHITE)
3396 *buffer++ = ' ';
3397 if (token->flags & STRINGIFY_ARG)
3398 *buffer++ = '#';
3400 if (token->type == CPP_MACRO_ARG)
3402 memcpy (buffer,
3403 NODE_NAME (token->val.macro_arg.spelling),
3404 NODE_LEN (token->val.macro_arg.spelling));
3405 buffer += NODE_LEN (token->val.macro_arg.spelling);
3407 else
3408 buffer = cpp_spell_token (pfile, token, buffer, true);
3410 if (token->flags & PASTE_LEFT)
3412 *buffer++ = ' ';
3413 *buffer++ = '#';
3414 *buffer++ = '#';
3415 /* Next has PREV_WHITE; see _cpp_create_definition. */
3420 *buffer = '\0';
3421 return pfile->macro_buffer;