1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
8
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
12 later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>.
22
23 In other words, you are welcome to use, share and improve this program.
24 You are forbidden to forbid anyone else to use, share and improve
25 what you give them. Help stamp out software-hoarding! */
26
27 #include "config.h"
28 #include "system.h"
29 #include "cpplib.h"
30 #include "internal.h"
31
32 typedef struct macro_arg macro_arg;
33 /* This structure represents the tokens of a macro argument. These
34 tokens can be macro themselves, in which case they can be either
35 expanded or unexpanded. When they are expanded, this data
36 structure keeps both the expanded and unexpanded forms. */
37 struct macro_arg
38 {
39 const cpp_token **first; /* First token in unexpanded argument. */
40 const cpp_token **expanded; /* Macro-expanded argument. */
41 const cpp_token *stringified; /* Stringified argument. */
42 unsigned int count; /* # of tokens in argument. */
43 unsigned int expanded_count; /* # of tokens in expanded argument. */
44 source_location *virt_locs; /* Where virtual locations for
45 unexpanded tokens are stored. */
46 source_location *expanded_virt_locs; /* Where virtual locations for
47 expanded tokens are
48 stored. */
49 };
50
51 /* The kind of macro tokens which the instance of
52 macro_arg_token_iter is supposed to iterate over. */
53 enum macro_arg_token_kind {
54 MACRO_ARG_TOKEN_NORMAL,
55 /* This is a macro argument token that got transformed into a string
56 litteral, e.g. #foo. */
57 MACRO_ARG_TOKEN_STRINGIFIED,
58 /* This is a token resulting from the expansion of a macro
59 argument that was itself a macro. */
60 MACRO_ARG_TOKEN_EXPANDED
61 };
62
63 /* An iterator over tokens coming from a function-like macro
64 argument. */
65 typedef struct macro_arg_token_iter macro_arg_token_iter;
66 struct macro_arg_token_iter
67 {
68 /* Whether or not -ftrack-macro-expansion is used. */
69 bool track_macro_exp_p;
70 /* The kind of token over which we are supposed to iterate. */
71 enum macro_arg_token_kind kind;
72 /* A pointer to the current token pointed to by the iterator. */
73 const cpp_token **token_ptr;
74 /* A pointer to the "full" location of the current token. If
75 -ftrack-macro-expansion is used this location tracks loci accross
76 macro expansion. */
77 const source_location *location_ptr;
78 #ifdef ENABLE_CHECKING
79 /* The number of times the iterator went forward. This useful only
80 when checking is enabled. */
81 size_t num_forwards;
82 #endif
83 };
84
85 /* Macro expansion. */
86
87 static int enter_macro_context (cpp_reader *, cpp_hashnode *,
88 const cpp_token *, source_location);
89 static int builtin_macro (cpp_reader *, cpp_hashnode *);
90 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
91 const cpp_token **, unsigned int);
92 static void push_extended_tokens_context (cpp_reader *, cpp_hashnode *,
93 _cpp_buff *, source_location *,
94 const cpp_token **, unsigned int);
95 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
96 _cpp_buff **, unsigned *);
97 static cpp_context *next_context (cpp_reader *);
98 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
99 static void expand_arg (cpp_reader *, macro_arg *);
100 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
101 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
102 static void paste_all_tokens (cpp_reader *, const cpp_token *);
103 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
104 static void alloc_expanded_arg_mem (cpp_reader *, macro_arg *, size_t);
105 static void ensure_expanded_arg_room (cpp_reader *, macro_arg *, size_t, size_t *);
106 static void delete_macro_args (_cpp_buff*, unsigned num_args);
107 static void set_arg_token (macro_arg *, const cpp_token *,
108 source_location, size_t,
109 enum macro_arg_token_kind,
110 bool);
111 static const source_location *get_arg_token_location (const macro_arg *,
112 enum macro_arg_token_kind);
113 static const cpp_token **arg_token_ptr_at (const macro_arg *,
114 size_t,
115 enum macro_arg_token_kind,
116 source_location **virt_location);
117
118 static void macro_arg_token_iter_init (macro_arg_token_iter *, bool,
119 enum macro_arg_token_kind,
120 const macro_arg *,
121 const cpp_token **);
122 static const cpp_token *macro_arg_token_iter_get_token
123 (const macro_arg_token_iter *it);
124 static source_location macro_arg_token_iter_get_location
125 (const macro_arg_token_iter *);
126 static void macro_arg_token_iter_forward (macro_arg_token_iter *);
127 static _cpp_buff *tokens_buff_new (cpp_reader *, size_t,
128 source_location **);
129 static size_t tokens_buff_count (_cpp_buff *);
130 static const cpp_token **tokens_buff_last_token_ptr (_cpp_buff *);
131 static inline const cpp_token **tokens_buff_put_token_to (const cpp_token **,
132 source_location *,
133 const cpp_token *,
134 source_location,
135 source_location,
136 const struct line_map *,
137 unsigned int);
138
139 static const cpp_token **tokens_buff_add_token (_cpp_buff *,
140 source_location *,
141 const cpp_token *,
142 source_location,
143 source_location,
144 const struct line_map *,
145 unsigned int);
146 static inline void tokens_buff_remove_last_token (_cpp_buff *);
147 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
148 macro_arg *, source_location);
149 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
150 _cpp_buff **, unsigned *);
151 static bool create_iso_definition (cpp_reader *, cpp_macro *);
152
153 /* #define directive parsing and handling. */
154
155 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
156 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
157 static bool warn_of_redefinition (cpp_reader *, cpp_hashnode *,
158 const cpp_macro *);
159 static bool parse_params (cpp_reader *, cpp_macro *);
160 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
161 const cpp_string *);
162 static bool reached_end_of_context (cpp_context *);
163 static void consume_next_token_from_context (cpp_reader *pfile,
164 const cpp_token **,
165 source_location *);
166 static const cpp_token* cpp_get_token_1 (cpp_reader *, source_location *);
167
168 /* Statistical counter tracking the number of macros that got
169 expanded. */
170 unsigned num_expanded_macros_counter = 0;
171 /* Statistical counter tracking the total number tokens resulting
172 from macro expansion. */
173 unsigned num_macro_tokens_counter = 0;
174
175 /* Emits a warning if NODE is a macro defined in the main file that
176 has not been used. */
177 int
_cpp_warn_if_unused_macro(cpp_reader * pfile,cpp_hashnode * node,void * v ATTRIBUTE_UNUSED)178 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
179 void *v ATTRIBUTE_UNUSED)
180 {
181 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
182 {
183 cpp_macro *macro = node->value.macro;
184
185 if (!macro->used
186 && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
187 cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, macro->line, 0,
188 "macro \"%s\" is not used", NODE_NAME (node));
189 }
190
191 return 1;
192 }
193
194 /* Allocates and returns a CPP_STRING token, containing TEXT of length
195 LEN, after null-terminating it. TEXT must be in permanent storage. */
196 static const cpp_token *
new_string_token(cpp_reader * pfile,unsigned char * text,unsigned int len)197 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
198 {
199 cpp_token *token = _cpp_temp_token (pfile);
200
201 text[len] = '\0';
202 token->type = CPP_STRING;
203 token->val.str.len = len;
204 token->val.str.text = text;
205 token->flags = 0;
206 return token;
207 }
208
209 static const char * const monthnames[] =
210 {
211 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
212 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
213 };
214
215 /* Helper function for builtin_macro. Returns the text generated by
216 a builtin macro. */
217 const uchar *
_cpp_builtin_macro_text(cpp_reader * pfile,cpp_hashnode * node)218 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
219 {
220 const uchar *result = NULL;
221 linenum_type number = 1;
222
223 switch (node->value.builtin)
224 {
225 default:
226 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
227 NODE_NAME (node));
228 break;
229
230 case BT_TIMESTAMP:
231 {
232 cpp_buffer *pbuffer = cpp_get_buffer (pfile);
233 if (pbuffer->timestamp == NULL)
234 {
235 /* Initialize timestamp value of the assotiated file. */
236 struct _cpp_file *file = cpp_get_file (pbuffer);
237 if (file)
238 {
239 /* Generate __TIMESTAMP__ string, that represents
240 the date and time of the last modification
241 of the current source file. The string constant
242 looks like "Sun Sep 16 01:03:52 1973". */
243 struct tm *tb = NULL;
244 struct stat *st = _cpp_get_file_stat (file);
245 if (st)
246 tb = localtime (&st->st_mtime);
247 if (tb)
248 {
249 char *str = asctime (tb);
250 size_t len = strlen (str);
251 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
252 buf[0] = '"';
253 strcpy ((char *) buf + 1, str);
254 buf[len] = '"';
255 pbuffer->timestamp = buf;
256 }
257 else
258 {
259 cpp_errno (pfile, CPP_DL_WARNING,
260 "could not determine file timestamp");
261 pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
262 }
263 }
264 }
265 result = pbuffer->timestamp;
266 }
267 break;
268 case BT_FILE:
269 case BT_BASE_FILE:
270 {
271 unsigned int len;
272 const char *name;
273 uchar *buf;
274
275 if (node->value.builtin == BT_FILE)
276 name = linemap_get_expansion_filename (pfile->line_table,
277 pfile->line_table->highest_line);
278 else
279 {
280 name = _cpp_get_file_name (pfile->main_file);
281 if (!name)
282 abort ();
283 }
284 len = strlen (name);
285 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
286 result = buf;
287 *buf = '"';
288 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
289 *buf++ = '"';
290 *buf = '\0';
291 }
292 break;
293
294 case BT_INCLUDE_LEVEL:
295 /* The line map depth counts the primary source as level 1, but
296 historically __INCLUDE_DEPTH__ has called the primary source
297 level 0. */
298 number = pfile->line_table->depth - 1;
299 break;
300
301 case BT_SPECLINE:
302 /* If __LINE__ is embedded in a macro, it must expand to the
303 line of the macro's invocation, not its definition.
304 Otherwise things like assert() will not work properly. */
305 number = linemap_get_expansion_line (pfile->line_table,
306 CPP_OPTION (pfile, traditional)
307 ? pfile->line_table->highest_line
308 : pfile->cur_token[-1].src_loc);
309 break;
310
311 /* __STDC__ has the value 1 under normal circumstances.
312 However, if (a) we are in a system header, (b) the option
313 stdc_0_in_system_headers is true (set by target config), and
314 (c) we are not in strictly conforming mode, then it has the
315 value 0. (b) and (c) are already checked in cpp_init_builtins. */
316 case BT_STDC:
317 if (cpp_in_system_header (pfile))
318 number = 0;
319 else
320 number = 1;
321 break;
322
323 case BT_DATE:
324 case BT_TIME:
325 if (pfile->date == NULL)
326 {
327 /* Allocate __DATE__ and __TIME__ strings from permanent
328 storage. We only do this once, and don't generate them
329 at init time, because time() and localtime() are very
330 slow on some systems. */
331 time_t tt;
332 struct tm *tb = NULL;
333
334 /* (time_t) -1 is a legitimate value for "number of seconds
335 since the Epoch", so we have to do a little dance to
336 distinguish that from a genuine error. */
337 errno = 0;
338 tt = time(NULL);
339 if (tt != (time_t)-1 || errno == 0)
340 tb = localtime (&tt);
341
342 if (tb)
343 {
344 pfile->date = _cpp_unaligned_alloc (pfile,
345 sizeof ("\"Oct 11 1347\""));
346 sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
347 monthnames[tb->tm_mon], tb->tm_mday,
348 tb->tm_year + 1900);
349
350 pfile->time = _cpp_unaligned_alloc (pfile,
351 sizeof ("\"12:34:56\""));
352 sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
353 tb->tm_hour, tb->tm_min, tb->tm_sec);
354 }
355 else
356 {
357 cpp_errno (pfile, CPP_DL_WARNING,
358 "could not determine date and time");
359
360 pfile->date = UC"\"??? ?? ????\"";
361 pfile->time = UC"\"??:??:??\"";
362 }
363 }
364
365 if (node->value.builtin == BT_DATE)
366 result = pfile->date;
367 else
368 result = pfile->time;
369 break;
370
371 case BT_COUNTER:
372 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
373 cpp_error (pfile, CPP_DL_ERROR,
374 "__COUNTER__ expanded inside directive with -fdirectives-only");
375 number = pfile->counter++;
376 break;
377 }
378
379 if (result == NULL)
380 {
381 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
382 result = _cpp_unaligned_alloc (pfile, 21);
383 sprintf ((char *) result, "%u", number);
384 }
385
386 return result;
387 }
388
389 /* Convert builtin macros like __FILE__ to a token and push it on the
390 context stack. Also handles _Pragma, for which a new token may not
391 be created. Returns 1 if it generates a new token context, 0 to
392 return the token to the caller. */
393 static int
builtin_macro(cpp_reader * pfile,cpp_hashnode * node)394 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
395 {
396 const uchar *buf;
397 size_t len;
398 char *nbuf;
399
400 if (node->value.builtin == BT_PRAGMA)
401 {
402 /* Don't interpret _Pragma within directives. The standard is
403 not clear on this, but to me this makes most sense. */
404 if (pfile->state.in_directive)
405 return 0;
406
407 return _cpp_do__Pragma (pfile);
408 }
409
410 buf = _cpp_builtin_macro_text (pfile, node);
411 len = ustrlen (buf);
412 nbuf = (char *) alloca (len + 1);
413 memcpy (nbuf, buf, len);
414 nbuf[len]='\n';
415
416 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
417 _cpp_clean_line (pfile);
418
419 /* Set pfile->cur_token as required by _cpp_lex_direct. */
420 pfile->cur_token = _cpp_temp_token (pfile);
421 _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
422 if (pfile->buffer->cur != pfile->buffer->rlimit)
423 cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
424 NODE_NAME (node));
425 _cpp_pop_buffer (pfile);
426
427 return 1;
428 }
429
430 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
431 backslashes and double quotes. DEST must be of sufficient size.
432 Returns a pointer to the end of the string. */
433 uchar *
cpp_quote_string(uchar * dest,const uchar * src,unsigned int len)434 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
435 {
436 while (len--)
437 {
438 uchar c = *src++;
439
440 if (c == '\\' || c == '"')
441 {
442 *dest++ = '\\';
443 *dest++ = c;
444 }
445 else
446 *dest++ = c;
447 }
448
449 return dest;
450 }
451
452 /* Convert a token sequence ARG to a single string token according to
453 the rules of the ISO C #-operator. */
454 static const cpp_token *
stringify_arg(cpp_reader * pfile,macro_arg * arg)455 stringify_arg (cpp_reader *pfile, macro_arg *arg)
456 {
457 unsigned char *dest;
458 unsigned int i, escape_it, backslash_count = 0;
459 const cpp_token *source = NULL;
460 size_t len;
461
462 if (BUFF_ROOM (pfile->u_buff) < 3)
463 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
464 dest = BUFF_FRONT (pfile->u_buff);
465 *dest++ = '"';
466
467 /* Loop, reading in the argument's tokens. */
468 for (i = 0; i < arg->count; i++)
469 {
470 const cpp_token *token = arg->first[i];
471
472 if (token->type == CPP_PADDING)
473 {
474 if (source == NULL
475 || (!(source->flags & PREV_WHITE)
476 && token->val.source == NULL))
477 source = token->val.source;
478 continue;
479 }
480
481 escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
482 || token->type == CPP_WSTRING || token->type == CPP_WCHAR
483 || token->type == CPP_STRING32 || token->type == CPP_CHAR32
484 || token->type == CPP_STRING16 || token->type == CPP_CHAR16
485 || token->type == CPP_UTF8STRING);
486
487 /* Room for each char being written in octal, initial space and
488 final quote and NUL. */
489 len = cpp_token_len (token);
490 if (escape_it)
491 len *= 4;
492 len += 3;
493
494 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
495 {
496 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
497 _cpp_extend_buff (pfile, &pfile->u_buff, len);
498 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
499 }
500
501 /* Leading white space? */
502 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
503 {
504 if (source == NULL)
505 source = token;
506 if (source->flags & PREV_WHITE)
507 *dest++ = ' ';
508 }
509 source = NULL;
510
511 if (escape_it)
512 {
513 _cpp_buff *buff = _cpp_get_buff (pfile, len);
514 unsigned char *buf = BUFF_FRONT (buff);
515 len = cpp_spell_token (pfile, token, buf, true) - buf;
516 dest = cpp_quote_string (dest, buf, len);
517 _cpp_release_buff (pfile, buff);
518 }
519 else
520 dest = cpp_spell_token (pfile, token, dest, true);
521
522 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
523 backslash_count++;
524 else
525 backslash_count = 0;
526 }
527
528 /* Ignore the final \ of invalid string literals. */
529 if (backslash_count & 1)
530 {
531 cpp_error (pfile, CPP_DL_WARNING,
532 "invalid string literal, ignoring final '\\'");
533 dest--;
534 }
535
536 /* Commit the memory, including NUL, and return the token. */
537 *dest++ = '"';
538 len = dest - BUFF_FRONT (pfile->u_buff);
539 BUFF_FRONT (pfile->u_buff) = dest + 1;
540 return new_string_token (pfile, dest - len, len);
541 }
542
543 /* Try to paste two tokens. On success, return nonzero. In any
544 case, PLHS is updated to point to the pasted token, which is
545 guaranteed to not have the PASTE_LEFT flag set. */
546 static bool
paste_tokens(cpp_reader * pfile,const cpp_token ** plhs,const cpp_token * rhs)547 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
548 {
549 unsigned char *buf, *end, *lhsend;
550 cpp_token *lhs;
551 unsigned int len;
552
553 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
554 buf = (unsigned char *) alloca (len);
555 end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
556
557 /* Avoid comment headers, since they are still processed in stage 3.
558 It is simpler to insert a space here, rather than modifying the
559 lexer to ignore comments in some circumstances. Simply returning
560 false doesn't work, since we want to clear the PASTE_LEFT flag. */
561 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
562 *end++ = ' ';
563 /* In one obscure case we might see padding here. */
564 if (rhs->type != CPP_PADDING)
565 end = cpp_spell_token (pfile, rhs, end, false);
566 *end = '\n';
567
568 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
569 _cpp_clean_line (pfile);
570
571 /* Set pfile->cur_token as required by _cpp_lex_direct. */
572 pfile->cur_token = _cpp_temp_token (pfile);
573 lhs = _cpp_lex_direct (pfile);
574 if (pfile->buffer->cur != pfile->buffer->rlimit)
575 {
576 source_location saved_loc = lhs->src_loc;
577
578 _cpp_pop_buffer (pfile);
579 _cpp_backup_tokens (pfile, 1);
580 *lhsend = '\0';
581
582 /* We have to remove the PASTE_LEFT flag from the old lhs, but
583 we want to keep the new location. */
584 *lhs = **plhs;
585 *plhs = lhs;
586 lhs->src_loc = saved_loc;
587 lhs->flags &= ~PASTE_LEFT;
588
589 /* Mandatory error for all apart from assembler. */
590 if (CPP_OPTION (pfile, lang) != CLK_ASM)
591 cpp_error (pfile, CPP_DL_ERROR,
592 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
593 buf, cpp_token_as_text (pfile, rhs));
594 return false;
595 }
596
597 *plhs = lhs;
598 _cpp_pop_buffer (pfile);
599 return true;
600 }
601
602 /* Handles an arbitrarily long sequence of ## operators, with initial
603 operand LHS. This implementation is left-associative,
604 non-recursive, and finishes a paste before handling succeeding
605 ones. If a paste fails, we back up to the RHS of the failing ##
606 operator before pushing the context containing the result of prior
607 successful pastes, with the effect that the RHS appears in the
608 output stream after the pasted LHS normally. */
609 static void
paste_all_tokens(cpp_reader * pfile,const cpp_token * lhs)610 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
611 {
612 const cpp_token *rhs = NULL;
613 cpp_context *context = pfile->context;
614
615 do
616 {
617 /* Take the token directly from the current context. We can do
618 this, because we are in the replacement list of either an
619 object-like macro, or a function-like macro with arguments
620 inserted. In either case, the constraints to #define
621 guarantee we have at least one more token. */
622 if (context->tokens_kind == TOKENS_KIND_DIRECT)
623 rhs = FIRST (context).token++;
624 else if (context->tokens_kind == TOKENS_KIND_INDIRECT)
625 rhs = *FIRST (context).ptoken++;
626 else if (context->tokens_kind == TOKENS_KIND_EXTENDED)
627 {
628 /* So we are in presence of an extended token context, which
629 means that each token in this context has a virtual
630 location attached to it. So let's not forget to update
631 the pointer to the current virtual location of the
632 current token when we update the pointer to the current
633 token */
634
635 rhs = *FIRST (context).ptoken++;
636 /* context->c.mc must be non-null, as if we were not in a
637 macro context, context->tokens_kind could not be equal to
638 TOKENS_KIND_EXTENDED. */
639 context->c.mc->cur_virt_loc++;
640 }
641
642 if (rhs->type == CPP_PADDING)
643 {
644 if (rhs->flags & PASTE_LEFT)
645 abort ();
646 }
647 if (!paste_tokens (pfile, &lhs, rhs))
648 break;
649 }
650 while (rhs->flags & PASTE_LEFT);
651
652 /* Put the resulting token in its own context. */
653 _cpp_push_token_context (pfile, NULL, lhs, 1);
654 }
655
656 /* Returns TRUE if the number of arguments ARGC supplied in an
657 invocation of the MACRO referenced by NODE is valid. An empty
658 invocation to a macro with no parameters should pass ARGC as zero.
659
660 Note that MACRO cannot necessarily be deduced from NODE, in case
661 NODE was redefined whilst collecting arguments. */
662 bool
_cpp_arguments_ok(cpp_reader * pfile,cpp_macro * macro,const cpp_hashnode * node,unsigned int argc)663 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
664 {
665 if (argc == macro->paramc)
666 return true;
667
668 if (argc < macro->paramc)
669 {
670 /* As an extension, a rest argument is allowed to not appear in
671 the invocation at all.
672 e.g. #define debug(format, args...) something
673 debug("string");
674
675 This is exactly the same as if there had been an empty rest
676 argument - debug("string", ). */
677
678 if (argc + 1 == macro->paramc && macro->variadic)
679 {
680 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
681 cpp_error (pfile, CPP_DL_PEDWARN,
682 "ISO C99 requires rest arguments to be used");
683 return true;
684 }
685
686 cpp_error (pfile, CPP_DL_ERROR,
687 "macro \"%s\" requires %u arguments, but only %u given",
688 NODE_NAME (node), macro->paramc, argc);
689 }
690 else
691 cpp_error (pfile, CPP_DL_ERROR,
692 "macro \"%s\" passed %u arguments, but takes just %u",
693 NODE_NAME (node), argc, macro->paramc);
694
695 return false;
696 }
697
698 /* Reads and returns the arguments to a function-like macro
699 invocation. Assumes the opening parenthesis has been processed.
700 If there is an error, emits an appropriate diagnostic and returns
701 NULL. Each argument is terminated by a CPP_EOF token, for the
702 future benefit of expand_arg(). If there are any deferred
703 #pragma directives among macro arguments, store pointers to the
704 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
705
706 What is returned is the buffer that contains the memory allocated
707 to hold the macro arguments. NODE is the name of the macro this
708 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
709 set to the actual number of macro arguments allocated in the
710 returned buffer. */
711 static _cpp_buff *
collect_args(cpp_reader * pfile,const cpp_hashnode * node,_cpp_buff ** pragma_buff,unsigned * num_args)712 collect_args (cpp_reader *pfile, const cpp_hashnode *node,
713 _cpp_buff **pragma_buff, unsigned *num_args)
714 {
715 _cpp_buff *buff, *base_buff;
716 cpp_macro *macro;
717 macro_arg *args, *arg;
718 const cpp_token *token;
719 unsigned int argc;
720 source_location virt_loc;
721 bool track_macro_expansion_p = CPP_OPTION (pfile, track_macro_expansion);
722 unsigned num_args_alloced = 0;
723
724 macro = node->value.macro;
725 if (macro->paramc)
726 argc = macro->paramc;
727 else
728 argc = 1;
729
730 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
731 #define ARG_TOKENS_EXTENT 1000
732
733 buff = _cpp_get_buff (pfile, argc * (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
734 * sizeof (cpp_token *)
735 + sizeof (macro_arg)));
736 base_buff = buff;
737 args = (macro_arg *) buff->base;
738 memset (args, 0, argc * sizeof (macro_arg));
739 buff->cur = (unsigned char *) &args[argc];
740 arg = args, argc = 0;
741
742 /* Collect the tokens making up each argument. We don't yet know
743 how many arguments have been supplied, whether too many or too
744 few. Hence the slightly bizarre usage of "argc" and "arg". */
745 do
746 {
747 unsigned int paren_depth = 0;
748 unsigned int ntokens = 0;
749 unsigned virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
750 num_args_alloced++;
751
752 argc++;
753 arg->first = (const cpp_token **) buff->cur;
754 if (track_macro_expansion_p)
755 {
756 virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
757 arg->virt_locs = XNEWVEC (source_location,
758 virt_locs_capacity);
759 }
760
761 for (;;)
762 {
763 /* Require space for 2 new tokens (including a CPP_EOF). */
764 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
765 {
766 buff = _cpp_append_extend_buff (pfile, buff,
767 ARG_TOKENS_EXTENT
768 * sizeof (cpp_token *));
769 arg->first = (const cpp_token **) buff->cur;
770 }
771 if (track_macro_expansion_p
772 && (ntokens + 2 > virt_locs_capacity))
773 {
774 virt_locs_capacity += ARG_TOKENS_EXTENT;
775 arg->virt_locs = XRESIZEVEC (source_location,
776 arg->virt_locs,
777 virt_locs_capacity);
778 }
779
780 token = cpp_get_token_1 (pfile, &virt_loc);
781
782 if (token->type == CPP_PADDING)
783 {
784 /* Drop leading padding. */
785 if (ntokens == 0)
786 continue;
787 }
788 else if (token->type == CPP_OPEN_PAREN)
789 paren_depth++;
790 else if (token->type == CPP_CLOSE_PAREN)
791 {
792 if (paren_depth-- == 0)
793 break;
794 }
795 else if (token->type == CPP_COMMA)
796 {
797 /* A comma does not terminate an argument within
798 parentheses or as part of a variable argument. */
799 if (paren_depth == 0
800 && ! (macro->variadic && argc == macro->paramc))
801 break;
802 }
803 else if (token->type == CPP_EOF
804 || (token->type == CPP_HASH && token->flags & BOL))
805 break;
806 else if (token->type == CPP_PRAGMA)
807 {
808 cpp_token *newtok = _cpp_temp_token (pfile);
809
810 /* CPP_PRAGMA token lives in directive_result, which will
811 be overwritten on the next directive. */
812 *newtok = *token;
813 token = newtok;
814 do
815 {
816 if (*pragma_buff == NULL
817 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
818 {
819 _cpp_buff *next;
820 if (*pragma_buff == NULL)
821 *pragma_buff
822 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
823 else
824 {
825 next = *pragma_buff;
826 *pragma_buff
827 = _cpp_get_buff (pfile,
828 (BUFF_FRONT (*pragma_buff)
829 - (*pragma_buff)->base) * 2);
830 (*pragma_buff)->next = next;
831 }
832 }
833 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
834 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
835 if (token->type == CPP_PRAGMA_EOL)
836 break;
837 token = cpp_get_token_1 (pfile, &virt_loc);
838 }
839 while (token->type != CPP_EOF);
840
841 /* In deferred pragmas parsing_args and prevent_expansion
842 had been changed, reset it. */
843 pfile->state.parsing_args = 2;
844 pfile->state.prevent_expansion = 1;
845
846 if (token->type == CPP_EOF)
847 break;
848 else
849 continue;
850 }
851 set_arg_token (arg, token, virt_loc,
852 ntokens, MACRO_ARG_TOKEN_NORMAL,
853 CPP_OPTION (pfile, track_macro_expansion));
854 ntokens++;
855 }
856
857 /* Drop trailing padding. */
858 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
859 ntokens--;
860
861 arg->count = ntokens;
862 set_arg_token (arg, &pfile->eof, pfile->eof.src_loc,
863 ntokens, MACRO_ARG_TOKEN_NORMAL,
864 CPP_OPTION (pfile, track_macro_expansion));
865
866 /* Terminate the argument. Excess arguments loop back and
867 overwrite the final legitimate argument, before failing. */
868 if (argc <= macro->paramc)
869 {
870 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
871 if (argc != macro->paramc)
872 arg++;
873 }
874 }
875 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
876
877 if (token->type == CPP_EOF)
878 {
879 /* We still need the CPP_EOF to end directives, and to end
880 pre-expansion of a macro argument. Step back is not
881 unconditional, since we don't want to return a CPP_EOF to our
882 callers at the end of an -include-d file. */
883 if (pfile->context->prev || pfile->state.in_directive)
884 _cpp_backup_tokens (pfile, 1);
885 cpp_error (pfile, CPP_DL_ERROR,
886 "unterminated argument list invoking macro \"%s\"",
887 NODE_NAME (node));
888 }
889 else
890 {
891 /* A single empty argument is counted as no argument. */
892 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
893 argc = 0;
894 if (_cpp_arguments_ok (pfile, macro, node, argc))
895 {
896 /* GCC has special semantics for , ## b where b is a varargs
897 parameter: we remove the comma if b was omitted entirely.
898 If b was merely an empty argument, the comma is retained.
899 If the macro takes just one (varargs) parameter, then we
900 retain the comma only if we are standards conforming.
901
902 If FIRST is NULL replace_args () swallows the comma. */
903 if (macro->variadic && (argc < macro->paramc
904 || (argc == 1 && args[0].count == 0
905 && !CPP_OPTION (pfile, std))))
906 args[macro->paramc - 1].first = NULL;
907 if (num_args)
908 *num_args = num_args_alloced;
909 return base_buff;
910 }
911 }
912
913 /* An error occurred. */
914 _cpp_release_buff (pfile, base_buff);
915 return NULL;
916 }
917
918 /* Search for an opening parenthesis to the macro of NODE, in such a
919 way that, if none is found, we don't lose the information in any
920 intervening padding tokens. If we find the parenthesis, collect
921 the arguments and return the buffer containing them. PRAGMA_BUFF
922 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
923 *NUM_ARGS is set to the number of arguments contained in the
924 returned buffer. */
925 static _cpp_buff *
funlike_invocation_p(cpp_reader * pfile,cpp_hashnode * node,_cpp_buff ** pragma_buff,unsigned * num_args)926 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
927 _cpp_buff **pragma_buff, unsigned *num_args)
928 {
929 const cpp_token *token, *padding = NULL;
930
931 for (;;)
932 {
933 token = cpp_get_token (pfile);
934 if (token->type != CPP_PADDING)
935 break;
936 if (padding == NULL
937 || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
938 padding = token;
939 }
940
941 if (token->type == CPP_OPEN_PAREN)
942 {
943 pfile->state.parsing_args = 2;
944 return collect_args (pfile, node, pragma_buff, num_args);
945 }
946
947 /* CPP_EOF can be the end of macro arguments, or the end of the
948 file. We mustn't back up over the latter. Ugh. */
949 if (token->type != CPP_EOF || token == &pfile->eof)
950 {
951 /* Back up. We may have skipped padding, in which case backing
952 up more than one token when expanding macros is in general
953 too difficult. We re-insert it in its own context. */
954 _cpp_backup_tokens (pfile, 1);
955 if (padding)
956 _cpp_push_token_context (pfile, NULL, padding, 1);
957 }
958
959 return NULL;
960 }
961
962 /* Return the real number of tokens in the expansion of MACRO. */
963 static inline unsigned int
macro_real_token_count(const cpp_macro * macro)964 macro_real_token_count (const cpp_macro *macro)
965 {
966 unsigned int i;
967 if (__builtin_expect (!macro->extra_tokens, true))
968 return macro->count;
969 for (i = 0; i < macro->count; i++)
970 if (macro->exp.tokens[i].type == CPP_PASTE)
971 return i;
972 abort ();
973 }
974
975 /* Push the context of a macro with hash entry NODE onto the context
976 stack. If we can successfully expand the macro, we push a context
977 containing its yet-to-be-rescanned replacement list and return one.
978 If there were additionally any unexpanded deferred #pragma
979 directives among macro arguments, push another context containing
980 the pragma tokens before the yet-to-be-rescanned replacement list
981 and return two. Otherwise, we don't push a context and return
982 zero. LOCATION is the location of the expansion point of the
983 macro. */
984 static int
enter_macro_context(cpp_reader * pfile,cpp_hashnode * node,const cpp_token * result,source_location location)985 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
986 const cpp_token *result, source_location location)
987 {
988 /* The presence of a macro invalidates a file's controlling macro. */
989 pfile->mi_valid = false;
990
991 pfile->state.angled_headers = false;
992
993 if ((node->flags & NODE_BUILTIN) && !(node->flags & NODE_USED))
994 {
995 node->flags |= NODE_USED;
996 if ((!pfile->cb.user_builtin_macro
997 || !pfile->cb.user_builtin_macro (pfile, node))
998 && pfile->cb.used_define)
999 pfile->cb.used_define (pfile, pfile->directive_line, node);
1000 }
1001
1002 /* Handle standard macros. */
1003 if (! (node->flags & NODE_BUILTIN))
1004 {
1005 cpp_macro *macro = node->value.macro;
1006 _cpp_buff *pragma_buff = NULL;
1007
1008 if (macro->fun_like)
1009 {
1010 _cpp_buff *buff;
1011 unsigned num_args = 0;
1012
1013 pfile->state.prevent_expansion++;
1014 pfile->keep_tokens++;
1015 pfile->state.parsing_args = 1;
1016 buff = funlike_invocation_p (pfile, node, &pragma_buff,
1017 &num_args);
1018 pfile->state.parsing_args = 0;
1019 pfile->keep_tokens--;
1020 pfile->state.prevent_expansion--;
1021
1022 if (buff == NULL)
1023 {
1024 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
1025 cpp_warning (pfile, CPP_W_TRADITIONAL,
1026 "function-like macro \"%s\" must be used with arguments in traditional C",
1027 NODE_NAME (node));
1028
1029 if (pragma_buff)
1030 _cpp_release_buff (pfile, pragma_buff);
1031
1032 return 0;
1033 }
1034
1035 if (macro->paramc > 0)
1036 replace_args (pfile, node, macro,
1037 (macro_arg *) buff->base,
1038 location);
1039 /* Free the memory used by the arguments of this
1040 function-like macro. This memory has been allocated by
1041 funlike_invocation_p and by replace_args. */
1042 delete_macro_args (buff, num_args);
1043 }
1044
1045 /* Disable the macro within its expansion. */
1046 node->flags |= NODE_DISABLED;
1047
1048 if (!(node->flags & NODE_USED))
1049 {
1050 node->flags |= NODE_USED;
1051 if (pfile->cb.used_define)
1052 pfile->cb.used_define (pfile, pfile->directive_line, node);
1053 }
1054
1055 if (pfile->cb.used)
1056 pfile->cb.used (pfile, location, node);
1057
1058 macro->used = 1;
1059
1060 if (macro->paramc == 0)
1061 {
1062 if (CPP_OPTION (pfile, track_macro_expansion))
1063 {
1064 unsigned int i, count = macro->count;
1065 const cpp_token *src = macro->exp.tokens;
1066 const struct line_map *map;
1067 source_location *virt_locs = NULL;
1068 _cpp_buff *macro_tokens =
1069 tokens_buff_new (pfile, count, &virt_locs);
1070
1071 /* Create a macro map to record the locations of the
1072 tokens that are involved in the expansion. LOCATION
1073 is the location of the macro expansion point. */
1074 map = linemap_enter_macro (pfile->line_table,
1075 node, location, count);
1076 for (i = 0; i < count; ++i)
1077 {
1078 tokens_buff_add_token (macro_tokens, virt_locs,
1079 src, src->src_loc,
1080 src->src_loc, map, i);
1081 ++src;
1082 }
1083 push_extended_tokens_context (pfile, node,
1084 macro_tokens,
1085 virt_locs,
1086 (const cpp_token **)
1087 macro_tokens->base,
1088 count);
1089 num_macro_tokens_counter += count;
1090 }
1091 else
1092 {
1093 unsigned tokens_count = macro_real_token_count (macro);
1094 _cpp_push_token_context (pfile, node, macro->exp.tokens,
1095 tokens_count);
1096 num_macro_tokens_counter += tokens_count;
1097 }
1098 }
1099
1100 if (pragma_buff)
1101 {
1102 if (!pfile->state.in_directive)
1103 _cpp_push_token_context (pfile, NULL,
1104 padding_token (pfile, result), 1);
1105 do
1106 {
1107 unsigned tokens_count;
1108 _cpp_buff *tail = pragma_buff->next;
1109 pragma_buff->next = NULL;
1110 tokens_count = ((const cpp_token **) BUFF_FRONT (pragma_buff)
1111 - (const cpp_token **) pragma_buff->base);
1112 push_ptoken_context (pfile, NULL, pragma_buff,
1113 (const cpp_token **) pragma_buff->base,
1114 tokens_count);
1115 pragma_buff = tail;
1116 if (!CPP_OPTION (pfile, track_macro_expansion))
1117 num_macro_tokens_counter += tokens_count;
1118
1119 }
1120 while (pragma_buff != NULL);
1121 return 2;
1122 }
1123
1124 return 1;
1125 }
1126
1127 /* Handle built-in macros and the _Pragma operator. */
1128 return builtin_macro (pfile, node);
1129 }
1130
1131 /* De-allocate the memory used by BUFF which is an array of instances
1132 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1133 present in BUFF. */
1134 static void
delete_macro_args(_cpp_buff * buff,unsigned num_args)1135 delete_macro_args (_cpp_buff *buff, unsigned num_args)
1136 {
1137 macro_arg *macro_args;
1138 unsigned i;
1139
1140 if (buff == NULL)
1141 return;
1142
1143 macro_args = (macro_arg *) buff->base;
1144
1145 /* Walk instances of macro_arg to free their expanded tokens as well
1146 as their macro_arg::virt_locs members. */
1147 for (i = 0; i < num_args; ++i)
1148 {
1149 if (macro_args[i].expanded)
1150 {
1151 free (macro_args[i].expanded);
1152 macro_args[i].expanded = NULL;
1153 }
1154 if (macro_args[i].virt_locs)
1155 {
1156 free (macro_args[i].virt_locs);
1157 macro_args[i].virt_locs = NULL;
1158 }
1159 if (macro_args[i].expanded_virt_locs)
1160 {
1161 free (macro_args[i].expanded_virt_locs);
1162 macro_args[i].expanded_virt_locs = NULL;
1163 }
1164 }
1165 _cpp_free_buff (buff);
1166 }
1167
1168 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1169 to set, LOCATION is its virtual location. "Virtual" location means
1170 the location that encodes loci accross macro expansion. Otherwise
1171 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1172 argument ARG is supposed to contain. Note that ARG must be
1173 tailored so that it has enough room to contain INDEX + 1 numbers of
1174 tokens, at least. */
1175 static void
set_arg_token(macro_arg * arg,const cpp_token * token,source_location location,size_t index,enum macro_arg_token_kind kind,bool track_macro_exp_p)1176 set_arg_token (macro_arg *arg, const cpp_token *token,
1177 source_location location, size_t index,
1178 enum macro_arg_token_kind kind,
1179 bool track_macro_exp_p)
1180 {
1181 const cpp_token **token_ptr;
1182 source_location *loc = NULL;
1183
1184 token_ptr =
1185 arg_token_ptr_at (arg, index, kind,
1186 track_macro_exp_p ? &loc : NULL);
1187 *token_ptr = token;
1188
1189 if (loc != NULL)
1190 {
1191 #ifdef ENABLE_CHECKING
1192 if (kind == MACRO_ARG_TOKEN_STRINGIFIED
1193 || !track_macro_exp_p)
1194 /* We can't set the location of a stringified argument
1195 token and we can't set any location if we aren't tracking
1196 macro expansion locations. */
1197 abort ();
1198 #endif
1199 *loc = location;
1200 }
1201 }
1202
1203 /* Get the pointer to the location of the argument token of the
1204 function-like macro argument ARG. This function must be called
1205 only when we -ftrack-macro-expansion is on. */
1206 static const source_location *
get_arg_token_location(const macro_arg * arg,enum macro_arg_token_kind kind)1207 get_arg_token_location (const macro_arg *arg,
1208 enum macro_arg_token_kind kind)
1209 {
1210 const source_location *loc = NULL;
1211 const cpp_token **token_ptr =
1212 arg_token_ptr_at (arg, 0, kind, (source_location **) &loc);
1213
1214 if (token_ptr == NULL)
1215 return NULL;
1216
1217 return loc;
1218 }
1219
1220 /* Return the pointer to the INDEXth token of the macro argument ARG.
1221 KIND specifies the kind of token the macro argument ARG contains.
1222 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1223 of the virtual location of the returned token if the
1224 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1225 spelling location of the returned token. */
1226 static const cpp_token **
arg_token_ptr_at(const macro_arg * arg,size_t index,enum macro_arg_token_kind kind,source_location ** virt_location)1227 arg_token_ptr_at (const macro_arg *arg, size_t index,
1228 enum macro_arg_token_kind kind,
1229 source_location **virt_location)
1230 {
1231 const cpp_token **tokens_ptr = NULL;
1232
1233 switch (kind)
1234 {
1235 case MACRO_ARG_TOKEN_NORMAL:
1236 tokens_ptr = arg->first;
1237 break;
1238 case MACRO_ARG_TOKEN_STRINGIFIED:
1239 tokens_ptr = (const cpp_token **) &arg->stringified;
1240 break;
1241 case MACRO_ARG_TOKEN_EXPANDED:
1242 tokens_ptr = arg->expanded;
1243 break;
1244 }
1245
1246 if (tokens_ptr == NULL)
1247 /* This can happen for e.g, an empty token argument to a
1248 funtion-like macro. */
1249 return tokens_ptr;
1250
1251 if (virt_location)
1252 {
1253 if (kind == MACRO_ARG_TOKEN_NORMAL)
1254 *virt_location = &arg->virt_locs[index];
1255 else if (kind == MACRO_ARG_TOKEN_EXPANDED)
1256 *virt_location = &arg->expanded_virt_locs[index];
1257 else if (kind == MACRO_ARG_TOKEN_STRINGIFIED)
1258 *virt_location =
1259 (source_location *) &tokens_ptr[index]->src_loc;
1260 }
1261 return &tokens_ptr[index];
1262 }
1263
1264 /* Initialize an iterator so that it iterates over the tokens of a
1265 function-like macro argument. KIND is the kind of tokens we want
1266 ITER to iterate over. TOKEN_PTR points the first token ITER will
1267 iterate over. */
1268 static void
macro_arg_token_iter_init(macro_arg_token_iter * iter,bool track_macro_exp_p,enum macro_arg_token_kind kind,const macro_arg * arg,const cpp_token ** token_ptr)1269 macro_arg_token_iter_init (macro_arg_token_iter *iter,
1270 bool track_macro_exp_p,
1271 enum macro_arg_token_kind kind,
1272 const macro_arg *arg,
1273 const cpp_token **token_ptr)
1274 {
1275 iter->track_macro_exp_p = track_macro_exp_p;
1276 iter->kind = kind;
1277 iter->token_ptr = token_ptr;
1278 /* Unconditionally initialize this so that the compiler doesn't warn
1279 about iter->location_ptr being possibly uninitialized later after
1280 this code has been inlined somewhere. */
1281 iter->location_ptr = NULL;
1282 if (track_macro_exp_p)
1283 iter->location_ptr = get_arg_token_location (arg, kind);
1284 #ifdef ENABLE_CHECKING
1285 iter->num_forwards = 0;
1286 if (track_macro_exp_p
1287 && token_ptr != NULL
1288 && iter->location_ptr == NULL)
1289 abort ();
1290 #endif
1291 }
1292
1293 /* Move the iterator one token forward. Note that if IT was
1294 initialized on an argument that has a stringified token, moving it
1295 foward doesn't make sense as a stringified token is essentially one
1296 string. */
1297 static void
macro_arg_token_iter_forward(macro_arg_token_iter * it)1298 macro_arg_token_iter_forward (macro_arg_token_iter *it)
1299 {
1300 switch (it->kind)
1301 {
1302 case MACRO_ARG_TOKEN_NORMAL:
1303 case MACRO_ARG_TOKEN_EXPANDED:
1304 it->token_ptr++;
1305 if (it->track_macro_exp_p)
1306 it->location_ptr++;
1307 break;
1308 case MACRO_ARG_TOKEN_STRINGIFIED:
1309 #ifdef ENABLE_CHECKING
1310 if (it->num_forwards > 0)
1311 abort ();
1312 #endif
1313 break;
1314 }
1315
1316 #ifdef ENABLE_CHECKING
1317 it->num_forwards++;
1318 #endif
1319 }
1320
1321 /* Return the token pointed to by the iterator. */
1322 static const cpp_token *
macro_arg_token_iter_get_token(const macro_arg_token_iter * it)1323 macro_arg_token_iter_get_token (const macro_arg_token_iter *it)
1324 {
1325 #ifdef ENABLE_CHECKING
1326 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1327 && it->num_forwards > 0)
1328 abort ();
1329 #endif
1330 if (it->token_ptr == NULL)
1331 return NULL;
1332 return *it->token_ptr;
1333 }
1334
1335 /* Return the location of the token pointed to by the iterator.*/
1336 static source_location
macro_arg_token_iter_get_location(const macro_arg_token_iter * it)1337 macro_arg_token_iter_get_location (const macro_arg_token_iter *it)
1338 {
1339 #ifdef ENABLE_CHECKING
1340 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1341 && it->num_forwards > 0)
1342 abort ();
1343 #endif
1344 if (it->track_macro_exp_p)
1345 return *it->location_ptr;
1346 else
1347 return (*it->token_ptr)->src_loc;
1348 }
1349
1350 /* Return the index of a token [resulting from macro expansion] inside
1351 the total list of tokens resulting from a given macro
1352 expansion. The index can be different depending on whether if we
1353 want each tokens resulting from function-like macro arguments
1354 expansion to have a different location or not.
1355
1356 E.g, consider this function-like macro:
1357
1358 #define M(x) x - 3
1359
1360 Then consider us "calling" it (and thus expanding it) like:
1361
1362 M(1+4)
1363
1364 It will be expanded into:
1365
1366 1+4-3
1367
1368 Let's consider the case of the token '4'.
1369
1370 Its index can be 2 (it's the third token of the set of tokens
1371 resulting from the expansion) or it can be 0 if we consider that
1372 all tokens resulting from the expansion of the argument "1+2" have
1373 the same index, which is 0. In this later case, the index of token
1374 '-' would then be 1 and the index of token '3' would be 2.
1375
1376 The later case is useful to use less memory e.g, for the case of
1377 the user using the option -ftrack-macro-expansion=1.
1378
1379 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1380 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1381 parameter (inside the macro replacement list) that corresponds to
1382 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1383 of.
1384
1385 If we refer to the example above, for the '4' argument token,
1386 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1387 would be set to the token 'x', in the replacement list "x - 3" of
1388 macro M.
1389
1390 This is a subroutine of replace_args. */
1391 inline static unsigned
expanded_token_index(cpp_reader * pfile,cpp_macro * macro,const cpp_token * cur_replacement_token,unsigned absolute_token_index)1392 expanded_token_index (cpp_reader *pfile, cpp_macro *macro,
1393 const cpp_token *cur_replacement_token,
1394 unsigned absolute_token_index)
1395 {
1396 if (CPP_OPTION (pfile, track_macro_expansion) > 1)
1397 return absolute_token_index;
1398 return cur_replacement_token - macro->exp.tokens;
1399 }
1400
1401 /* Replace the parameters in a function-like macro of NODE with the
1402 actual ARGS, and place the result in a newly pushed token context.
1403 Expand each argument before replacing, unless it is operated upon
1404 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1405 the expansion point of the macro. E.g, the location of the
1406 function-like macro invocation. */
1407 static void
replace_args(cpp_reader * pfile,cpp_hashnode * node,cpp_macro * macro,macro_arg * args,source_location expansion_point_loc)1408 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro,
1409 macro_arg *args, source_location expansion_point_loc)
1410 {
1411 unsigned int i, total;
1412 const cpp_token *src, *limit;
1413 const cpp_token **first = NULL;
1414 macro_arg *arg;
1415 _cpp_buff *buff = NULL;
1416 source_location *virt_locs = NULL;
1417 unsigned int exp_count;
1418 const struct line_map *map = NULL;
1419 int track_macro_exp;
1420
1421 /* First, fully macro-expand arguments, calculating the number of
1422 tokens in the final expansion as we go. The ordering of the if
1423 statements below is subtle; we must handle stringification before
1424 pasting. */
1425
1426 /* EXP_COUNT is the number of tokens in the macro replacement
1427 list. TOTAL is the number of tokens /after/ macro parameters
1428 have been replaced by their arguments. */
1429 exp_count = macro_real_token_count (macro);
1430 total = exp_count;
1431 limit = macro->exp.tokens + exp_count;
1432
1433 for (src = macro->exp.tokens; src < limit; src++)
1434 if (src->type == CPP_MACRO_ARG)
1435 {
1436 /* Leading and trailing padding tokens. */
1437 total += 2;
1438 /* Account for leading and padding tokens in exp_count too.
1439 This is going to be important later down this function,
1440 when we want to handle the case of (track_macro_exp <
1441 2). */
1442 exp_count += 2;
1443
1444 /* We have an argument. If it is not being stringified or
1445 pasted it is macro-replaced before insertion. */
1446 arg = &args[src->val.macro_arg.arg_no - 1];
1447
1448 if (src->flags & STRINGIFY_ARG)
1449 {
1450 if (!arg->stringified)
1451 arg->stringified = stringify_arg (pfile, arg);
1452 }
1453 else if ((src->flags & PASTE_LEFT)
1454 || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
1455 total += arg->count - 1;
1456 else
1457 {
1458 if (!arg->expanded)
1459 expand_arg (pfile, arg);
1460 total += arg->expanded_count - 1;
1461 }
1462 }
1463
1464 /* When the compiler is called with the -ftrack-macro-expansion
1465 flag, we need to keep track of the location of each token that
1466 results from macro expansion.
1467
1468 A token resulting from macro expansion is not a new token. It is
1469 simply the same token as the token coming from the macro
1470 definition. The new things that are allocated are the buffer
1471 that holds the tokens resulting from macro expansion and a new
1472 location that records many things like the locus of the expansion
1473 point as well as the original locus inside the definition of the
1474 macro. This location is called a virtual location.
1475
1476 So the buffer BUFF holds a set of cpp_token*, and the buffer
1477 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1478
1479 Both of these two buffers are going to be hung off of the macro
1480 context, when the latter is pushed. The memory allocated to
1481 store the tokens and their locations is going to be freed once
1482 the context of macro expansion is popped.
1483
1484 As far as tokens are concerned, the memory overhead of
1485 -ftrack-macro-expansion is proportional to the number of
1486 macros that get expanded multiplied by sizeof (source_location).
1487 The good news is that extra memory gets freed when the macro
1488 context is freed, i.e shortly after the macro got expanded. */
1489
1490 /* Is the -ftrack-macro-expansion flag in effect? */
1491 track_macro_exp = CPP_OPTION (pfile, track_macro_expansion);
1492
1493 /* Now allocate memory space for tokens and locations resulting from
1494 the macro expansion, copy the tokens and replace the arguments.
1495 This memory must be freed when the context of the macro MACRO is
1496 popped. */
1497 buff = tokens_buff_new (pfile, total, track_macro_exp ? &virt_locs : NULL);
1498
1499 first = (const cpp_token **) buff->base;
1500
1501 /* Create a macro map to record the locations of the tokens that are
1502 involved in the expansion. Note that the expansion point is set
1503 to the location of the closing parenthesis. Otherwise, the
1504 subsequent map created for the first token that comes after the
1505 macro map might have a wrong line number. That would lead to
1506 tokens with wrong line numbers after the macro expansion. This
1507 adds up to the memory overhead of the -ftrack-macro-expansion
1508 flag; for every macro that is expanded, a "macro map" is
1509 created. */
1510 if (track_macro_exp)
1511 {
1512 int num_macro_tokens = total;
1513 if (track_macro_exp < 2)
1514 /* Then the number of macro tokens won't take in account the
1515 fact that function-like macro arguments can expand to
1516 multiple tokens. This is to save memory at the expense of
1517 accuracy.
1518
1519 Suppose we have #define SQARE(A) A * A
1520
1521 And then we do SQARE(2+3)
1522
1523 Then the tokens 2, +, 3, will have the same location,
1524 saying they come from the expansion of the argument A. */
1525 num_macro_tokens = exp_count;
1526 map = linemap_enter_macro (pfile->line_table, node,
1527 expansion_point_loc,
1528 num_macro_tokens);
1529 }
1530 i = 0;
1531 for (src = macro->exp.tokens; src < limit; src++)
1532 {
1533 unsigned int arg_tokens_count;
1534 macro_arg_token_iter from;
1535 const cpp_token **paste_flag = NULL;
1536 const cpp_token **tmp_token_ptr;
1537
1538 if (src->type != CPP_MACRO_ARG)
1539 {
1540 /* Allocate a virtual location for token SRC, and add that
1541 token and its virtual location into the buffers BUFF and
1542 VIRT_LOCS. */
1543 unsigned index = expanded_token_index (pfile, macro, src, i);
1544 tokens_buff_add_token (buff, virt_locs, src,
1545 src->src_loc, src->src_loc,
1546 map, index);
1547 i += 1;
1548 continue;
1549 }
1550
1551 paste_flag = 0;
1552 arg = &args[src->val.macro_arg.arg_no - 1];
1553 /* SRC is a macro parameter that we need to replace with its
1554 corresponding argument. So at some point we'll need to
1555 iterate over the tokens of the macro argument and copy them
1556 into the "place" now holding the correspondig macro
1557 parameter. We are going to use the iterator type
1558 macro_argo_token_iter to handle that iterating. The 'if'
1559 below is to initialize the iterator depending on the type of
1560 tokens the macro argument has. It also does some adjustment
1561 related to padding tokens and some pasting corner cases. */
1562 if (src->flags & STRINGIFY_ARG)
1563 {
1564 arg_tokens_count = 1;
1565 macro_arg_token_iter_init (&from,
1566 CPP_OPTION (pfile,
1567 track_macro_expansion),
1568 MACRO_ARG_TOKEN_STRINGIFIED,
1569 arg, &arg->stringified);
1570 }
1571 else if (src->flags & PASTE_LEFT)
1572 {
1573 arg_tokens_count = arg->count;
1574 macro_arg_token_iter_init (&from,
1575 CPP_OPTION (pfile,
1576 track_macro_expansion),
1577 MACRO_ARG_TOKEN_NORMAL,
1578 arg, arg->first);
1579 }
1580 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
1581 {
1582 int num_toks;
1583 arg_tokens_count = arg->count;
1584 macro_arg_token_iter_init (&from,
1585 CPP_OPTION (pfile,
1586 track_macro_expansion),
1587 MACRO_ARG_TOKEN_NORMAL,
1588 arg, arg->first);
1589
1590 num_toks = tokens_buff_count (buff);
1591
1592 if (num_toks != 0)
1593 {
1594 /* So the current parameter token is pasted to the previous
1595 token in the replacement list. Let's look at what
1596 we have as previous and current arguments. */
1597
1598 /* This is the previous argument's token ... */
1599 tmp_token_ptr = tokens_buff_last_token_ptr (buff);
1600
1601 if ((*tmp_token_ptr)->type == CPP_COMMA
1602 && macro->variadic
1603 && src->val.macro_arg.arg_no == macro->paramc)
1604 {
1605 /* ... which is a comma; and the current parameter
1606 is the last parameter of a variadic function-like
1607 macro. If the argument to the current last
1608 parameter is NULL, then swallow the comma,
1609 otherwise drop the paste flag. */
1610 if (macro_arg_token_iter_get_token (&from) == NULL)
1611 tokens_buff_remove_last_token (buff);
1612 else
1613 paste_flag = tmp_token_ptr;
1614 }
1615 /* Remove the paste flag if the RHS is a placemarker. */
1616 else if (arg_tokens_count == 0)
1617 paste_flag = tmp_token_ptr;
1618 }
1619 }
1620 else
1621 {
1622 arg_tokens_count = arg->expanded_count;
1623 macro_arg_token_iter_init (&from,
1624 CPP_OPTION (pfile,
1625 track_macro_expansion),
1626 MACRO_ARG_TOKEN_EXPANDED,
1627 arg, arg->expanded);
1628 }
1629
1630 /* Padding on the left of an argument (unless RHS of ##). */
1631 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
1632 && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
1633 {
1634 const cpp_token *t = padding_token (pfile, src);
1635 unsigned index = expanded_token_index (pfile, macro, src, i);
1636 /* Allocate a virtual location for the padding token and
1637 append the token and its location to BUFF and
1638 VIRT_LOCS. */
1639 tokens_buff_add_token (buff, virt_locs, t,
1640 t->src_loc, t->src_loc,
1641 map, index);
1642 }
1643
1644 if (arg_tokens_count)
1645 {
1646 /* So now we've got the number of tokens that make up the
1647 argument that is going to replace the current parameter
1648 in the macro's replacement list. */
1649 unsigned int j;
1650 for (j = 0; j < arg_tokens_count; ++j)
1651 {
1652 /* So if track_macro_exp is < 2, the user wants to
1653 save extra memory while tracking macro expansion
1654 locations. So in that case here is what we do:
1655
1656 Suppose we have #define SQARE(A) A * A
1657
1658 And then we do SQARE(2+3)
1659
1660 Then the tokens 2, +, 3, will have the same location,
1661 saying they come from the expansion of the argument
1662 A.
1663
1664 So that means we are going to ignore the COUNT tokens
1665 resulting from the expansion of the current macro
1666 arugment. In other words all the ARG_TOKENS_COUNT tokens
1667 resulting from the expansion of the macro argument will
1668 have the index I. Normally, each of those token should
1669 have index I+J. */
1670 unsigned token_index = i;
1671 unsigned index;
1672 if (track_macro_exp > 1)
1673 token_index += j;
1674
1675 index = expanded_token_index (pfile, macro, src, token_index);
1676 tokens_buff_add_token (buff, virt_locs,
1677 macro_arg_token_iter_get_token (&from),
1678 macro_arg_token_iter_get_location (&from),
1679 src->src_loc, map, index);
1680 macro_arg_token_iter_forward (&from);
1681 }
1682
1683 /* With a non-empty argument on the LHS of ##, the last
1684 token should be flagged PASTE_LEFT. */
1685 if (src->flags & PASTE_LEFT)
1686 paste_flag =
1687 (const cpp_token **) tokens_buff_last_token_ptr (buff);
1688 }
1689 else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1690 && ! CPP_OPTION (pfile, c99)
1691 && ! cpp_in_system_header (pfile))
1692 {
1693 cpp_error (pfile, CPP_DL_PEDWARN,
1694 "invoking macro %s argument %d: "
1695 "empty macro arguments are undefined"
1696 " in ISO C90 and ISO C++98",
1697 NODE_NAME (node),
1698 src->val.macro_arg.arg_no);
1699 }
1700
1701 /* Avoid paste on RHS (even case count == 0). */
1702 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1703 {
1704 const cpp_token *t = &pfile->avoid_paste;
1705 tokens_buff_add_token (buff, virt_locs,
1706 t, t->src_loc, t->src_loc,
1707 NULL, 0);
1708 }
1709
1710 /* Add a new paste flag, or remove an unwanted one. */
1711 if (paste_flag)
1712 {
1713 cpp_token *token = _cpp_temp_token (pfile);
1714 token->type = (*paste_flag)->type;
1715 token->val = (*paste_flag)->val;
1716 if (src->flags & PASTE_LEFT)
1717 token->flags = (*paste_flag)->flags | PASTE_LEFT;
1718 else
1719 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1720 *paste_flag = token;
1721 }
1722
1723 i += arg_tokens_count;
1724 }
1725
1726 if (track_macro_exp)
1727 push_extended_tokens_context (pfile, node, buff, virt_locs, first,
1728 tokens_buff_count (buff));
1729 else
1730 push_ptoken_context (pfile, node, buff, first,
1731 tokens_buff_count (buff));
1732
1733 num_macro_tokens_counter += tokens_buff_count (buff);
1734 }
1735
1736 /* Return a special padding token, with padding inherited from SOURCE. */
1737 static const cpp_token *
padding_token(cpp_reader * pfile,const cpp_token * source)1738 padding_token (cpp_reader *pfile, const cpp_token *source)
1739 {
1740 cpp_token *result = _cpp_temp_token (pfile);
1741
1742 result->type = CPP_PADDING;
1743
1744 /* Data in GCed data structures cannot be made const so far, so we
1745 need a cast here. */
1746 result->val.source = (cpp_token *) source;
1747 result->flags = 0;
1748 return result;
1749 }
1750
1751 /* Get a new uninitialized context. Create a new one if we cannot
1752 re-use an old one. */
1753 static cpp_context *
next_context(cpp_reader * pfile)1754 next_context (cpp_reader *pfile)
1755 {
1756 cpp_context *result = pfile->context->next;
1757
1758 if (result == 0)
1759 {
1760 result = XNEW (cpp_context);
1761 memset (result, 0, sizeof (cpp_context));
1762 result->prev = pfile->context;
1763 result->next = 0;
1764 pfile->context->next = result;
1765 }
1766
1767 pfile->context = result;
1768 return result;
1769 }
1770
1771 /* Push a list of pointers to tokens. */
1772 static void
push_ptoken_context(cpp_reader * pfile,cpp_hashnode * macro,_cpp_buff * buff,const cpp_token ** first,unsigned int count)1773 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1774 const cpp_token **first, unsigned int count)
1775 {
1776 cpp_context *context = next_context (pfile);
1777
1778 context->tokens_kind = TOKENS_KIND_INDIRECT;
1779 context->c.macro = macro;
1780 context->buff = buff;
1781 FIRST (context).ptoken = first;
1782 LAST (context).ptoken = first + count;
1783 }
1784
1785 /* Push a list of tokens. */
1786 void
_cpp_push_token_context(cpp_reader * pfile,cpp_hashnode * macro,const cpp_token * first,unsigned int count)1787 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1788 const cpp_token *first, unsigned int count)
1789 {
1790 cpp_context *context = next_context (pfile);
1791
1792 context->tokens_kind = TOKENS_KIND_DIRECT;
1793 context->c.macro = macro;
1794 context->buff = NULL;
1795 FIRST (context).token = first;
1796 LAST (context).token = first + count;
1797 }
1798
1799 /* Build a context containing a list of tokens as well as their
1800 virtual locations and push it. TOKENS_BUFF is the buffer that
1801 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
1802 non-NULL, it means that the context owns it, meaning that
1803 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
1804 contains the virtual locations. */
1805 static void
push_extended_tokens_context(cpp_reader * pfile,cpp_hashnode * macro,_cpp_buff * token_buff,source_location * virt_locs,const cpp_token ** first,unsigned int count)1806 push_extended_tokens_context (cpp_reader *pfile,
1807 cpp_hashnode *macro,
1808 _cpp_buff *token_buff,
1809 source_location *virt_locs,
1810 const cpp_token **first,
1811 unsigned int count)
1812 {
1813 cpp_context *context = next_context (pfile);
1814 macro_context *m;
1815
1816 context->tokens_kind = TOKENS_KIND_EXTENDED;
1817 context->buff = token_buff;
1818
1819 m = XNEW (macro_context);
1820 m->macro_node = macro;
1821 m->virt_locs = virt_locs;
1822 m->cur_virt_loc = virt_locs;
1823 context->c.mc = m;
1824 FIRST (context).ptoken = first;
1825 LAST (context).ptoken = first + count;
1826 }
1827
1828 /* Push a traditional macro's replacement text. */
1829 void
_cpp_push_text_context(cpp_reader * pfile,cpp_hashnode * macro,const uchar * start,size_t len)1830 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1831 const uchar *start, size_t len)
1832 {
1833 cpp_context *context = next_context (pfile);
1834
1835 context->tokens_kind = TOKENS_KIND_DIRECT;
1836 context->c.macro = macro;
1837 context->buff = NULL;
1838 CUR (context) = start;
1839 RLIMIT (context) = start + len;
1840 macro->flags |= NODE_DISABLED;
1841 }
1842
1843 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
1844 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
1845 non-null (which means that -ftrack-macro-expansion is on),
1846 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
1847 hold the virtual locations of the tokens resulting from macro
1848 expansion. */
1849 static _cpp_buff*
tokens_buff_new(cpp_reader * pfile,size_t len,source_location ** virt_locs)1850 tokens_buff_new (cpp_reader *pfile, size_t len,
1851 source_location **virt_locs)
1852 {
1853 size_t tokens_size = len * sizeof (cpp_token *);
1854 size_t locs_size = len * sizeof (source_location);
1855
1856 if (virt_locs != NULL)
1857 *virt_locs = XNEWVEC (source_location, locs_size);
1858 return _cpp_get_buff (pfile, tokens_size);
1859 }
1860
1861 /* Returns the number of tokens contained in a token buffer. The
1862 buffer holds a set of cpp_token*. */
1863 static size_t
tokens_buff_count(_cpp_buff * buff)1864 tokens_buff_count (_cpp_buff *buff)
1865 {
1866 return (BUFF_FRONT (buff) - buff->base) / sizeof (cpp_token *);
1867 }
1868
1869 /* Return a pointer to the last token contained in the token buffer
1870 BUFF. */
1871 static const cpp_token **
tokens_buff_last_token_ptr(_cpp_buff * buff)1872 tokens_buff_last_token_ptr (_cpp_buff *buff)
1873 {
1874 return &((const cpp_token **) BUFF_FRONT (buff))[-1];
1875 }
1876
1877 /* Remove the last token contained in the token buffer TOKENS_BUFF.
1878 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
1879 containing the virtual locations of the tokens in TOKENS_BUFF; in
1880 which case the function updates that buffer as well. */
1881 static inline void
tokens_buff_remove_last_token(_cpp_buff * tokens_buff)1882 tokens_buff_remove_last_token (_cpp_buff *tokens_buff)
1883
1884 {
1885 if (BUFF_FRONT (tokens_buff) > tokens_buff->base)
1886 BUFF_FRONT (tokens_buff) =
1887 (unsigned char *) &((cpp_token **) BUFF_FRONT (tokens_buff))[-1];
1888 }
1889
1890 /* Insert a token into the token buffer at the position pointed to by
1891 DEST. Note that the buffer is not enlarged so the previous token
1892 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
1893 means -ftrack-macro-expansion is effect; it then points to where to
1894 insert the virtual location of TOKEN. TOKEN is the token to
1895 insert. VIRT_LOC is the virtual location of the token, i.e, the
1896 location possibly encoding its locus accross macro expansion. If
1897 TOKEN is an argument of a function-like macro (inside a macro
1898 replacement list), PARM_DEF_LOC is the spelling location of the
1899 macro parameter that TOKEN is replacing, in the replacement list of
1900 the macro. If TOKEN is not an argument of a function-like macro or
1901 if it doesn't come from a macro expansion, then VIRT_LOC can just
1902 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
1903 means TOKEN comes from a macro expansion and MAP is the macro map
1904 associated to the macro. MACRO_TOKEN_INDEX points to the index of
1905 the token in the macro map; it is not considered if MAP is NULL.
1906
1907 Upon successful completion this function returns the a pointer to
1908 the position of the token coming right after the insertion
1909 point. */
1910 static inline const cpp_token **
tokens_buff_put_token_to(const cpp_token ** dest,source_location * virt_loc_dest,const cpp_token * token,source_location virt_loc,source_location parm_def_loc,const struct line_map * map,unsigned int macro_token_index)1911 tokens_buff_put_token_to (const cpp_token **dest,
1912 source_location *virt_loc_dest,
1913 const cpp_token *token,
1914 source_location virt_loc,
1915 source_location parm_def_loc,
1916 const struct line_map *map,
1917 unsigned int macro_token_index)
1918 {
1919 source_location macro_loc = virt_loc;
1920 const cpp_token **result;
1921
1922 if (virt_loc_dest)
1923 {
1924 /* -ftrack-macro-expansion is on. */
1925 if (map)
1926 macro_loc = linemap_add_macro_token (map, macro_token_index,
1927 virt_loc, parm_def_loc);
1928 *virt_loc_dest = macro_loc;
1929 }
1930 *dest = token;
1931 result = &dest[1];
1932
1933 return result;
1934 }
1935
1936 /* Adds a token at the end of the tokens contained in BUFFER. Note
1937 that this function doesn't enlarge BUFFER when the number of tokens
1938 reaches BUFFER's size; it aborts in that situation.
1939
1940 TOKEN is the token to append. VIRT_LOC is the virtual location of
1941 the token, i.e, the location possibly encoding its locus accross
1942 macro expansion. If TOKEN is an argument of a function-like macro
1943 (inside a macro replacement list), PARM_DEF_LOC is the location of
1944 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
1945 from a macro expansion, then VIRT_LOC can just be set to the same
1946 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
1947 from a macro expansion and MAP is the macro map associated to the
1948 macro. MACRO_TOKEN_INDEX points to the index of the token in the
1949 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
1950 non-null, it means -ftrack-macro-expansion is on; in which case
1951 this function adds the virtual location DEF_LOC to the VIRT_LOCS
1952 array, at the same index as the one of TOKEN in BUFFER. Upon
1953 successful completion this function returns the a pointer to the
1954 position of the token coming right after the insertion point. */
1955 static const cpp_token **
tokens_buff_add_token(_cpp_buff * buffer,source_location * virt_locs,const cpp_token * token,source_location virt_loc,source_location parm_def_loc,const struct line_map * map,unsigned int macro_token_index)1956 tokens_buff_add_token (_cpp_buff *buffer,
1957 source_location *virt_locs,
1958 const cpp_token *token,
1959 source_location virt_loc,
1960 source_location parm_def_loc,
1961 const struct line_map *map,
1962 unsigned int macro_token_index)
1963 {
1964 const cpp_token **result;
1965 source_location *virt_loc_dest = NULL;
1966 unsigned token_index =
1967 (BUFF_FRONT (buffer) - buffer->base) / sizeof (cpp_token *);
1968
1969 /* Abort if we pass the end the buffer. */
1970 if (BUFF_FRONT (buffer) > BUFF_LIMIT (buffer))
1971 abort ();
1972
1973 if (virt_locs != NULL)
1974 virt_loc_dest = &virt_locs[token_index];
1975
1976 result =
1977 tokens_buff_put_token_to ((const cpp_token **) BUFF_FRONT (buffer),
1978 virt_loc_dest, token, virt_loc, parm_def_loc,
1979 map, macro_token_index);
1980
1981 BUFF_FRONT (buffer) = (unsigned char *) result;
1982 return result;
1983 }
1984
1985 /* Allocate space for the function-like macro argument ARG to store
1986 the tokens resulting from the macro-expansion of the tokens that
1987 make up ARG itself. That space is allocated in ARG->expanded and
1988 needs to be freed using free. */
1989 static void
alloc_expanded_arg_mem(cpp_reader * pfile,macro_arg * arg,size_t capacity)1990 alloc_expanded_arg_mem (cpp_reader *pfile, macro_arg *arg, size_t capacity)
1991 {
1992 #ifdef ENABLE_CHECKING
1993 if (arg->expanded != NULL
1994 || arg->expanded_virt_locs != NULL)
1995 abort ();
1996 #endif
1997 arg->expanded = XNEWVEC (const cpp_token *, capacity);
1998 if (CPP_OPTION (pfile, track_macro_expansion))
1999 arg->expanded_virt_locs = XNEWVEC (source_location, capacity);
2000
2001 }
2002
2003 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2004 tokens. */
2005 static void
ensure_expanded_arg_room(cpp_reader * pfile,macro_arg * arg,size_t size,size_t * expanded_capacity)2006 ensure_expanded_arg_room (cpp_reader *pfile, macro_arg *arg,
2007 size_t size, size_t *expanded_capacity)
2008 {
2009 if (size <= *expanded_capacity)
2010 return;
2011
2012 size *= 2;
2013
2014 arg->expanded =
2015 XRESIZEVEC (const cpp_token *, arg->expanded, size);
2016 *expanded_capacity = size;
2017
2018 if (CPP_OPTION (pfile, track_macro_expansion))
2019 {
2020 if (arg->expanded_virt_locs == NULL)
2021 arg->expanded_virt_locs = XNEWVEC (source_location, size);
2022 else
2023 arg->expanded_virt_locs = XRESIZEVEC (source_location,
2024 arg->expanded_virt_locs,
2025 size);
2026 }
2027 }
2028
2029 /* Expand an argument ARG before replacing parameters in a
2030 function-like macro. This works by pushing a context with the
2031 argument's tokens, and then expanding that into a temporary buffer
2032 as if it were a normal part of the token stream. collect_args()
2033 has terminated the argument's tokens with a CPP_EOF so that we know
2034 when we have fully expanded the argument. */
2035 static void
expand_arg(cpp_reader * pfile,macro_arg * arg)2036 expand_arg (cpp_reader *pfile, macro_arg *arg)
2037 {
2038 size_t capacity;
2039 bool saved_warn_trad;
2040 bool track_macro_exp_p = CPP_OPTION (pfile, track_macro_expansion);
2041
2042 if (arg->count == 0
2043 || arg->expanded != NULL)
2044 return;
2045
2046 /* Don't warn about funlike macros when pre-expanding. */
2047 saved_warn_trad = CPP_WTRADITIONAL (pfile);
2048 CPP_WTRADITIONAL (pfile) = 0;
2049
2050 /* Loop, reading in the tokens of the argument. */
2051 capacity = 256;
2052 alloc_expanded_arg_mem (pfile, arg, capacity);
2053
2054 if (track_macro_exp_p)
2055 push_extended_tokens_context (pfile, NULL, NULL,
2056 arg->virt_locs,
2057 arg->first,
2058 arg->count + 1);
2059 else
2060 push_ptoken_context (pfile, NULL, NULL,
2061 arg->first, arg->count + 1);
2062
2063 for (;;)
2064 {
2065 const cpp_token *token;
2066 source_location location;
2067
2068 ensure_expanded_arg_room (pfile, arg, arg->expanded_count + 1,
2069 &capacity);
2070
2071 token = cpp_get_token_1 (pfile, &location);
2072
2073 if (token->type == CPP_EOF)
2074 break;
2075
2076 set_arg_token (arg, token, location,
2077 arg->expanded_count, MACRO_ARG_TOKEN_EXPANDED,
2078 CPP_OPTION (pfile, track_macro_expansion));
2079 arg->expanded_count++;
2080 }
2081
2082 _cpp_pop_context (pfile);
2083
2084 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
2085 }
2086
2087 /* Pop the current context off the stack, re-enabling the macro if the
2088 context represented a macro's replacement list. Initially the
2089 context structure was not freed so that we can re-use it later, but
2090 now we do free it to reduce peak memory consumption. */
2091 void
_cpp_pop_context(cpp_reader * pfile)2092 _cpp_pop_context (cpp_reader *pfile)
2093 {
2094 cpp_context *context = pfile->context;
2095
2096 if (context->c.macro)
2097 {
2098 cpp_hashnode *macro;
2099 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
2100 {
2101 macro_context *mc = context->c.mc;
2102 macro = mc->macro_node;
2103 /* If context->buff is set, it means the life time of tokens
2104 is bound to the life time of this context; so we must
2105 free the tokens; that means we must free the virtual
2106 locations of these tokens too. */
2107 if (context->buff && mc->virt_locs)
2108 {
2109 free (mc->virt_locs);
2110 mc->virt_locs = NULL;
2111 }
2112 free (mc);
2113 context->c.mc = NULL;
2114 }
2115 else
2116 macro = context->c.macro;
2117
2118 /* Beware that MACRO can be NULL in cases like when we are
2119 called from expand_arg. In those cases, a dummy context with
2120 tokens is pushed just for the purpose of walking them using
2121 cpp_get_token_1. In that case, no 'macro' field is set into
2122 the dummy context. */
2123 if (macro != NULL)
2124 macro->flags &= ~NODE_DISABLED;
2125 }
2126
2127 if (context->buff)
2128 {
2129 /* Decrease memory peak consumption by freeing the memory used
2130 by the context. */
2131 _cpp_free_buff (context->buff);
2132 }
2133
2134 pfile->context = context->prev;
2135 /* decrease peak memory consumption by feeing the context. */
2136 pfile->context->next = NULL;
2137 free (context);
2138 }
2139
2140 /* Return TRUE if we reached the end of the set of tokens stored in
2141 CONTEXT, FALSE otherwise. */
2142 static inline bool
reached_end_of_context(cpp_context * context)2143 reached_end_of_context (cpp_context *context)
2144 {
2145 if (context->tokens_kind == TOKENS_KIND_DIRECT)
2146 return FIRST (context).token == LAST (context).token;
2147 else if (context->tokens_kind == TOKENS_KIND_INDIRECT
2148 || context->tokens_kind == TOKENS_KIND_EXTENDED)
2149 return FIRST (context).ptoken == LAST (context).ptoken;
2150 else
2151 abort ();
2152 }
2153
2154 /* Consume the next token contained in the current context of PFILE,
2155 and return it in *TOKEN. It's "full location" is returned in
2156 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2157 means the location encoding the locus of the token accross macro
2158 expansion; otherwise it's just is the "normal" location of the
2159 token which (*TOKEN)->src_loc. */
2160 static inline void
consume_next_token_from_context(cpp_reader * pfile,const cpp_token ** token,source_location * location)2161 consume_next_token_from_context (cpp_reader *pfile,
2162 const cpp_token ** token,
2163 source_location *location)
2164 {
2165 cpp_context *c = pfile->context;
2166
2167 if ((c)->tokens_kind == TOKENS_KIND_DIRECT)
2168 {
2169 *token = FIRST (c).token;
2170 *location = (*token)->src_loc;
2171 FIRST (c).token++;
2172 }
2173 else if ((c)->tokens_kind == TOKENS_KIND_INDIRECT)
2174 {
2175 *token = *FIRST (c).ptoken;
2176 *location = (*token)->src_loc;
2177 FIRST (c).ptoken++;
2178 }
2179 else if ((c)->tokens_kind == TOKENS_KIND_EXTENDED)
2180 {
2181 macro_context *m = c->c.mc;
2182 *token = *FIRST (c).ptoken;
2183 if (m->virt_locs)
2184 {
2185 *location = *m->cur_virt_loc;
2186 m->cur_virt_loc++;
2187 }
2188 else
2189 *location = (*token)->src_loc;
2190 FIRST (c).ptoken++;
2191 }
2192 else
2193 abort ();
2194 }
2195
2196 /* In the traditional mode of the preprocessor, if we are currently in
2197 a directive, the location of a token must be the location of the
2198 start of the directive line. This function returns the proper
2199 location if we are in the traditional mode, and just returns
2200 LOCATION otherwise. */
2201
2202 static inline source_location
maybe_adjust_loc_for_trad_cpp(cpp_reader * pfile,source_location location)2203 maybe_adjust_loc_for_trad_cpp (cpp_reader *pfile, source_location location)
2204 {
2205 if (CPP_OPTION (pfile, traditional))
2206 {
2207 if (pfile->state.in_directive)
2208 return pfile->directive_line;
2209 }
2210 return location;
2211 }
2212
2213 /* Routine to get a token as well as its location.
2214
2215 Macro expansions and directives are transparently handled,
2216 including entering included files. Thus tokens are post-macro
2217 expansion, and after any intervening directives. External callers
2218 see CPP_EOF only at EOF. Internal callers also see it when meeting
2219 a directive inside a macro call, when at the end of a directive and
2220 state.in_directive is still 1, and at the end of argument
2221 pre-expansion.
2222
2223 LOC is an out parameter; *LOC is set to the location "as expected
2224 by the user". Please read the comment of
2225 cpp_get_token_with_location to learn more about the meaning of this
2226 location. */
2227 static const cpp_token*
cpp_get_token_1(cpp_reader * pfile,source_location * location)2228 cpp_get_token_1 (cpp_reader *pfile, source_location *location)
2229 {
2230 const cpp_token *result;
2231 bool can_set = pfile->set_invocation_location;
2232 /* This token is a virtual token that either encodes a location
2233 related to macro expansion or a spelling location. */
2234 source_location virt_loc = 0;
2235 pfile->set_invocation_location = false;
2236
2237 for (;;)
2238 {
2239 cpp_hashnode *node;
2240 cpp_context *context = pfile->context;
2241
2242 /* Context->prev == 0 <=> base context. */
2243 if (!context->prev)
2244 {
2245 result = _cpp_lex_token (pfile);
2246 virt_loc = result->src_loc;
2247 }
2248 else if (!reached_end_of_context (context))
2249 {
2250 consume_next_token_from_context (pfile, &result,
2251 &virt_loc);
2252 if (result->flags & PASTE_LEFT)
2253 {
2254 paste_all_tokens (pfile, result);
2255 if (pfile->state.in_directive)
2256 continue;
2257 result = padding_token (pfile, result);
2258 goto out;
2259 }
2260 }
2261 else
2262 {
2263 if (pfile->context->c.macro)
2264 ++num_expanded_macros_counter;
2265 _cpp_pop_context (pfile);
2266 if (pfile->state.in_directive)
2267 continue;
2268 result = &pfile->avoid_paste;
2269 goto out;
2270 }
2271
2272 if (pfile->state.in_directive && result->type == CPP_COMMENT)
2273 continue;
2274
2275 if (result->type != CPP_NAME)
2276 break;
2277
2278 node = result->val.node.node;
2279
2280 if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
2281 break;
2282
2283 if (!(node->flags & NODE_DISABLED))
2284 {
2285 int ret = 0;
2286 /* If not in a macro context, and we're going to start an
2287 expansion, record the location. */
2288 if (can_set && !context->c.macro)
2289 pfile->invocation_location = result->src_loc;
2290 if (pfile->state.prevent_expansion)
2291 break;
2292
2293 /* Conditional macros require that a predicate be evaluated
2294 first. */
2295 if ((node->flags & NODE_CONDITIONAL) != 0)
2296 {
2297 if (pfile->cb.macro_to_expand)
2298 {
2299 bool whitespace_after;
2300 const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
2301
2302 whitespace_after = (peek_tok->type == CPP_PADDING
2303 || (peek_tok->flags & PREV_WHITE));
2304 node = pfile->cb.macro_to_expand (pfile, result);
2305 if (node)
2306 ret = enter_macro_context (pfile, node, result,
2307 virt_loc);
2308 else if (whitespace_after)
2309 {
2310 /* If macro_to_expand hook returned NULL and it
2311 ate some tokens, see if we don't need to add
2312 a padding token in between this and the
2313 next token. */
2314 peek_tok = cpp_peek_token (pfile, 0);
2315 if (peek_tok->type != CPP_PADDING
2316 && (peek_tok->flags & PREV_WHITE) == 0)
2317 _cpp_push_token_context (pfile, NULL,
2318 padding_token (pfile,
2319 peek_tok), 1);
2320 }
2321 }
2322 }
2323 else
2324 ret = enter_macro_context (pfile, node, result,
2325 virt_loc);
2326 if (ret)
2327 {
2328 if (pfile->state.in_directive || ret == 2)
2329 continue;
2330 result = padding_token (pfile, result);
2331 goto out;
2332 }
2333 }
2334 else
2335 {
2336 /* Flag this token as always unexpandable. FIXME: move this
2337 to collect_args()?. */
2338 cpp_token *t = _cpp_temp_token (pfile);
2339 t->type = result->type;
2340 t->flags = result->flags | NO_EXPAND;
2341 t->val = result->val;
2342 result = t;
2343 }
2344
2345 break;
2346 }
2347
2348 out:
2349 if (location != NULL)
2350 {
2351 if (virt_loc == 0)
2352 virt_loc = result->src_loc;
2353 *location = virt_loc;
2354
2355 if (!CPP_OPTION (pfile, track_macro_expansion)
2356 && can_set
2357 && pfile->context->c.macro != NULL)
2358 /* We are in a macro expansion context, are not tracking
2359 virtual location, but were asked to report the location
2360 of the expansion point of the macro being expanded. */
2361 *location = pfile->invocation_location;
2362
2363 *location = maybe_adjust_loc_for_trad_cpp (pfile, *location);
2364 }
2365 return result;
2366 }
2367
2368 /* External routine to get a token. Also used nearly everywhere
2369 internally, except for places where we know we can safely call
2370 _cpp_lex_token directly, such as lexing a directive name.
2371
2372 Macro expansions and directives are transparently handled,
2373 including entering included files. Thus tokens are post-macro
2374 expansion, and after any intervening directives. External callers
2375 see CPP_EOF only at EOF. Internal callers also see it when meeting
2376 a directive inside a macro call, when at the end of a directive and
2377 state.in_directive is still 1, and at the end of argument
2378 pre-expansion. */
2379 const cpp_token *
cpp_get_token(cpp_reader * pfile)2380 cpp_get_token (cpp_reader *pfile)
2381 {
2382 return cpp_get_token_1 (pfile, NULL);
2383 }
2384
2385 /* Like cpp_get_token, but also returns a virtual token location
2386 separate from the spelling location carried by the returned token.
2387
2388 LOC is an out parameter; *LOC is set to the location "as expected
2389 by the user". This matters when a token results from macro
2390 expansion; in that case the token's spelling location indicates the
2391 locus of the token in the definition of the macro but *LOC
2392 virtually encodes all the other meaningful locuses associated to
2393 the token.
2394
2395 What? virtual location? Yes, virtual location.
2396
2397 If the token results from macro expansion and if macro expansion
2398 location tracking is enabled its virtual location encodes (at the
2399 same time):
2400
2401 - the spelling location of the token
2402
2403 - the locus of the macro expansion point
2404
2405 - the locus of the point where the token got instantiated as part
2406 of the macro expansion process.
2407
2408 You have to use the linemap API to get the locus you are interested
2409 in from a given virtual location.
2410
2411 Note however that virtual locations are not necessarily ordered for
2412 relations '<' and '>'. One must use the function
2413 linemap_location_before_p instead of using the relational operator
2414 '<'.
2415
2416 If macro expansion tracking is off and if the token results from
2417 macro expansion the virtual location is the expansion point of the
2418 macro that got expanded.
2419
2420 When the token doesn't result from macro expansion, the virtual
2421 location is just the same thing as its spelling location. */
2422
2423 const cpp_token *
cpp_get_token_with_location(cpp_reader * pfile,source_location * loc)2424 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
2425 {
2426 const cpp_token *result;
2427
2428 pfile->set_invocation_location = true;
2429 result = cpp_get_token_1 (pfile, loc);
2430 return result;
2431 }
2432
2433 /* Returns true if we're expanding an object-like macro that was
2434 defined in a system header. Just checks the macro at the top of
2435 the stack. Used for diagnostic suppression. */
2436 int
cpp_sys_macro_p(cpp_reader * pfile)2437 cpp_sys_macro_p (cpp_reader *pfile)
2438 {
2439 cpp_hashnode *node = pfile->context->c.macro;
2440
2441 return node && node->value.macro && node->value.macro->syshdr;
2442 }
2443
2444 /* Read each token in, until end of the current file. Directives are
2445 transparently processed. */
2446 void
cpp_scan_nooutput(cpp_reader * pfile)2447 cpp_scan_nooutput (cpp_reader *pfile)
2448 {
2449 /* Request a CPP_EOF token at the end of this file, rather than
2450 transparently continuing with the including file. */
2451 pfile->buffer->return_at_eof = true;
2452
2453 pfile->state.discarding_output++;
2454 pfile->state.prevent_expansion++;
2455
2456 if (CPP_OPTION (pfile, traditional))
2457 while (_cpp_read_logical_line_trad (pfile))
2458 ;
2459 else
2460 while (cpp_get_token (pfile)->type != CPP_EOF)
2461 ;
2462
2463 pfile->state.discarding_output--;
2464 pfile->state.prevent_expansion--;
2465 }
2466
2467 /* Step back one or more tokens obtained from the lexer. */
2468 void
_cpp_backup_tokens_direct(cpp_reader * pfile,unsigned int count)2469 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
2470 {
2471 pfile->lookaheads += count;
2472 while (count--)
2473 {
2474 pfile->cur_token--;
2475 if (pfile->cur_token == pfile->cur_run->base
2476 /* Possible with -fpreprocessed and no leading #line. */
2477 && pfile->cur_run->prev != NULL)
2478 {
2479 pfile->cur_run = pfile->cur_run->prev;
2480 pfile->cur_token = pfile->cur_run->limit;
2481 }
2482 }
2483 }
2484
2485 /* Step back one (or more) tokens. Can only step back more than 1 if
2486 they are from the lexer, and not from macro expansion. */
2487 void
_cpp_backup_tokens(cpp_reader * pfile,unsigned int count)2488 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
2489 {
2490 if (pfile->context->prev == NULL)
2491 _cpp_backup_tokens_direct (pfile, count);
2492 else
2493 {
2494 if (count != 1)
2495 abort ();
2496 if (pfile->context->tokens_kind == TOKENS_KIND_DIRECT)
2497 FIRST (pfile->context).token--;
2498 else if (pfile->context->tokens_kind == TOKENS_KIND_INDIRECT)
2499 FIRST (pfile->context).ptoken--;
2500 else if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
2501 {
2502 FIRST (pfile->context).ptoken--;
2503 if (pfile->context->c.macro)
2504 {
2505 macro_context *m = pfile->context->c.mc;
2506 m->cur_virt_loc--;
2507 #ifdef ENABLE_CHECKING
2508 if (m->cur_virt_loc < m->virt_locs)
2509 abort ();
2510 #endif
2511 }
2512 else
2513 abort ();
2514 }
2515 else
2516 abort ();
2517 }
2518 }
2519
2520 /* #define directive parsing and handling. */
2521
2522 /* Returns nonzero if a macro redefinition warning is required. */
2523 static bool
warn_of_redefinition(cpp_reader * pfile,cpp_hashnode * node,const cpp_macro * macro2)2524 warn_of_redefinition (cpp_reader *pfile, cpp_hashnode *node,
2525 const cpp_macro *macro2)
2526 {
2527 const cpp_macro *macro1;
2528 unsigned int i;
2529
2530 /* Some redefinitions need to be warned about regardless. */
2531 if (node->flags & NODE_WARN)
2532 return true;
2533
2534 /* Suppress warnings for builtins that lack the NODE_WARN flag. */
2535 if (node->flags & NODE_BUILTIN)
2536 {
2537 if (!pfile->cb.user_builtin_macro
2538 || !pfile->cb.user_builtin_macro (pfile, node))
2539 return false;
2540 }
2541
2542 /* Redefinitions of conditional (context-sensitive) macros, on
2543 the other hand, must be allowed silently. */
2544 if (node->flags & NODE_CONDITIONAL)
2545 return false;
2546
2547 /* Redefinition of a macro is allowed if and only if the old and new
2548 definitions are the same. (6.10.3 paragraph 2). */
2549 macro1 = node->value.macro;
2550
2551 /* Don't check count here as it can be different in valid
2552 traditional redefinitions with just whitespace differences. */
2553 if (macro1->paramc != macro2->paramc
2554 || macro1->fun_like != macro2->fun_like
2555 || macro1->variadic != macro2->variadic)
2556 return true;
2557
2558 /* Check parameter spellings. */
2559 for (i = 0; i < macro1->paramc; i++)
2560 if (macro1->params[i] != macro2->params[i])
2561 return true;
2562
2563 /* Check the replacement text or tokens. */
2564 if (CPP_OPTION (pfile, traditional))
2565 return _cpp_expansions_different_trad (macro1, macro2);
2566
2567 if (macro1->count != macro2->count)
2568 return true;
2569
2570 for (i = 0; i < macro1->count; i++)
2571 if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
2572 return true;
2573
2574 return false;
2575 }
2576
2577 /* Free the definition of hashnode H. */
2578 void
_cpp_free_definition(cpp_hashnode * h)2579 _cpp_free_definition (cpp_hashnode *h)
2580 {
2581 /* Macros and assertions no longer have anything to free. */
2582 h->type = NT_VOID;
2583 /* Clear builtin flag in case of redefinition. */
2584 h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
2585 }
2586
2587 /* Save parameter NODE to the parameter list of macro MACRO. Returns
2588 zero on success, nonzero if the parameter is a duplicate. */
2589 bool
_cpp_save_parameter(cpp_reader * pfile,cpp_macro * macro,cpp_hashnode * node)2590 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
2591 {
2592 unsigned int len;
2593 /* Constraint 6.10.3.6 - duplicate parameter names. */
2594 if (node->flags & NODE_MACRO_ARG)
2595 {
2596 cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
2597 NODE_NAME (node));
2598 return true;
2599 }
2600
2601 if (BUFF_ROOM (pfile->a_buff)
2602 < (macro->paramc + 1) * sizeof (cpp_hashnode *))
2603 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
2604
2605 ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
2606 node->flags |= NODE_MACRO_ARG;
2607 len = macro->paramc * sizeof (union _cpp_hashnode_value);
2608 if (len > pfile->macro_buffer_len)
2609 {
2610 pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
2611 len);
2612 pfile->macro_buffer_len = len;
2613 }
2614 ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
2615 = node->value;
2616
2617 node->value.arg_index = macro->paramc;
2618 return false;
2619 }
2620
2621 /* Check the syntax of the parameters in a MACRO definition. Returns
2622 false if an error occurs. */
2623 static bool
parse_params(cpp_reader * pfile,cpp_macro * macro)2624 parse_params (cpp_reader *pfile, cpp_macro *macro)
2625 {
2626 unsigned int prev_ident = 0;
2627
2628 for (;;)
2629 {
2630 const cpp_token *token = _cpp_lex_token (pfile);
2631
2632 switch (token->type)
2633 {
2634 default:
2635 /* Allow/ignore comments in parameter lists if we are
2636 preserving comments in macro expansions. */
2637 if (token->type == CPP_COMMENT
2638 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
2639 continue;
2640
2641 cpp_error (pfile, CPP_DL_ERROR,
2642 "\"%s\" may not appear in macro parameter list",
2643 cpp_token_as_text (pfile, token));
2644 return false;
2645
2646 case CPP_NAME:
2647 if (prev_ident)
2648 {
2649 cpp_error (pfile, CPP_DL_ERROR,
2650 "macro parameters must be comma-separated");
2651 return false;
2652 }
2653 prev_ident = 1;
2654
2655 if (_cpp_save_parameter (pfile, macro, token->val.node.node))
2656 return false;
2657 continue;
2658
2659 case CPP_CLOSE_PAREN:
2660 if (prev_ident || macro->paramc == 0)
2661 return true;
2662
2663 /* Fall through to pick up the error. */
2664 case CPP_COMMA:
2665 if (!prev_ident)
2666 {
2667 cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
2668 return false;
2669 }
2670 prev_ident = 0;
2671 continue;
2672
2673 case CPP_ELLIPSIS:
2674 macro->variadic = 1;
2675 if (!prev_ident)
2676 {
2677 _cpp_save_parameter (pfile, macro,
2678 pfile->spec_nodes.n__VA_ARGS__);
2679 pfile->state.va_args_ok = 1;
2680 if (! CPP_OPTION (pfile, c99)
2681 && CPP_OPTION (pfile, cpp_pedantic)
2682 && CPP_OPTION (pfile, warn_variadic_macros))
2683 cpp_pedwarning
2684 (pfile, CPP_W_VARIADIC_MACROS,
2685 "anonymous variadic macros were introduced in C99");
2686 }
2687 else if (CPP_OPTION (pfile, cpp_pedantic)
2688 && CPP_OPTION (pfile, warn_variadic_macros))
2689 cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
2690 "ISO C does not permit named variadic macros");
2691
2692 /* We're at the end, and just expect a closing parenthesis. */
2693 token = _cpp_lex_token (pfile);
2694 if (token->type == CPP_CLOSE_PAREN)
2695 return true;
2696 /* Fall through. */
2697
2698 case CPP_EOF:
2699 cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
2700 return false;
2701 }
2702 }
2703 }
2704
2705 /* Allocate room for a token from a macro's replacement list. */
2706 static cpp_token *
alloc_expansion_token(cpp_reader * pfile,cpp_macro * macro)2707 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
2708 {
2709 if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
2710 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
2711
2712 return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
2713 }
2714
2715 /* Lex a token from the expansion of MACRO, but mark parameters as we
2716 find them and warn of traditional stringification. */
2717 static cpp_token *
lex_expansion_token(cpp_reader * pfile,cpp_macro * macro)2718 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
2719 {
2720 cpp_token *token, *saved_cur_token;
2721
2722 saved_cur_token = pfile->cur_token;
2723 pfile->cur_token = alloc_expansion_token (pfile, macro);
2724 token = _cpp_lex_direct (pfile);
2725 pfile->cur_token = saved_cur_token;
2726
2727 /* Is this a parameter? */
2728 if (token->type == CPP_NAME
2729 && (token->val.node.node->flags & NODE_MACRO_ARG) != 0)
2730 {
2731 token->type = CPP_MACRO_ARG;
2732 token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
2733 }
2734 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
2735 && (token->type == CPP_STRING || token->type == CPP_CHAR))
2736 check_trad_stringification (pfile, macro, &token->val.str);
2737
2738 return token;
2739 }
2740
2741 static bool
create_iso_definition(cpp_reader * pfile,cpp_macro * macro)2742 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
2743 {
2744 cpp_token *token;
2745 const cpp_token *ctoken;
2746 bool following_paste_op = false;
2747 const char *paste_op_error_msg =
2748 N_("'##' cannot appear at either end of a macro expansion");
2749 unsigned int num_extra_tokens = 0;
2750
2751 /* Get the first token of the expansion (or the '(' of a
2752 function-like macro). */
2753 ctoken = _cpp_lex_token (pfile);
2754
2755 if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
2756 {
2757 bool ok = parse_params (pfile, macro);
2758 macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
2759 if (!ok)
2760 return false;
2761
2762 /* Success. Commit or allocate the parameter array. */
2763 if (pfile->hash_table->alloc_subobject)
2764 {
2765 cpp_hashnode **params =
2766 (cpp_hashnode **) pfile->hash_table->alloc_subobject
2767 (sizeof (cpp_hashnode *) * macro->paramc);
2768 memcpy (params, macro->params,
2769 sizeof (cpp_hashnode *) * macro->paramc);
2770 macro->params = params;
2771 }
2772 else
2773 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->params[macro->paramc];
2774 macro->fun_like = 1;
2775 }
2776 else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
2777 {
2778 /* While ISO C99 requires whitespace before replacement text
2779 in a macro definition, ISO C90 with TC1 allows there characters
2780 from the basic source character set. */
2781 if (CPP_OPTION (pfile, c99))
2782 cpp_error (pfile, CPP_DL_PEDWARN,
2783 "ISO C99 requires whitespace after the macro name");
2784 else
2785 {
2786 int warntype = CPP_DL_WARNING;
2787 switch (ctoken->type)
2788 {
2789 case CPP_ATSIGN:
2790 case CPP_AT_NAME:
2791 case CPP_OBJC_STRING:
2792 /* '@' is not in basic character set. */
2793 warntype = CPP_DL_PEDWARN;
2794 break;
2795 case CPP_OTHER:
2796 /* Basic character set sans letters, digits and _. */
2797 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
2798 ctoken->val.str.text[0]) == NULL)
2799 warntype = CPP_DL_PEDWARN;
2800 break;
2801 default:
2802 /* All other tokens start with a character from basic
2803 character set. */
2804 break;
2805 }
2806 cpp_error (pfile, warntype,
2807 "missing whitespace after the macro name");
2808 }
2809 }
2810
2811 if (macro->fun_like)
2812 token = lex_expansion_token (pfile, macro);
2813 else
2814 {
2815 token = alloc_expansion_token (pfile, macro);
2816 *token = *ctoken;
2817 }
2818
2819 for (;;)
2820 {
2821 /* Check the stringifying # constraint 6.10.3.2.1 of
2822 function-like macros when lexing the subsequent token. */
2823 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
2824 {
2825 if (token->type == CPP_MACRO_ARG)
2826 {
2827 if (token->flags & PREV_WHITE)
2828 token->flags |= SP_PREV_WHITE;
2829 if (token[-1].flags & DIGRAPH)
2830 token->flags |= SP_DIGRAPH;
2831 token->flags &= ~PREV_WHITE;
2832 token->flags |= STRINGIFY_ARG;
2833 token->flags |= token[-1].flags & PREV_WHITE;
2834 token[-1] = token[0];
2835 macro->count--;
2836 }
2837 /* Let assembler get away with murder. */
2838 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
2839 {
2840 cpp_error (pfile, CPP_DL_ERROR,
2841 "'#' is not followed by a macro parameter");
2842 return false;
2843 }
2844 }
2845
2846 if (token->type == CPP_EOF)
2847 {
2848 /* Paste operator constraint 6.10.3.3.1:
2849 Token-paste ##, can appear in both object-like and
2850 function-like macros, but not at the end. */
2851 if (following_paste_op)
2852 {
2853 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
2854 return false;
2855 }
2856 break;
2857 }
2858
2859 /* Paste operator constraint 6.10.3.3.1. */
2860 if (token->type == CPP_PASTE)
2861 {
2862 /* Token-paste ##, can appear in both object-like and
2863 function-like macros, but not at the beginning. */
2864 if (macro->count == 1)
2865 {
2866 cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
2867 return false;
2868 }
2869
2870 if (token[-1].flags & PASTE_LEFT)
2871 {
2872 macro->extra_tokens = 1;
2873 num_extra_tokens++;
2874 token->val.token_no = macro->count - 1;
2875 }
2876 else
2877 {
2878 --macro->count;
2879 token[-1].flags |= PASTE_LEFT;
2880 if (token->flags & DIGRAPH)
2881 token[-1].flags |= SP_DIGRAPH;
2882 if (token->flags & PREV_WHITE)
2883 token[-1].flags |= SP_PREV_WHITE;
2884 }
2885 }
2886
2887 following_paste_op = (token->type == CPP_PASTE);
2888 token = lex_expansion_token (pfile, macro);
2889 }
2890
2891 macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
2892 macro->traditional = 0;
2893
2894 /* Don't count the CPP_EOF. */
2895 macro->count--;
2896
2897 /* Clear whitespace on first token for warn_of_redefinition(). */
2898 if (macro->count)
2899 macro->exp.tokens[0].flags &= ~PREV_WHITE;
2900
2901 /* Commit or allocate the memory. */
2902 if (pfile->hash_table->alloc_subobject)
2903 {
2904 cpp_token *tokns =
2905 (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
2906 * macro->count);
2907 if (num_extra_tokens)
2908 {
2909 /* Place second and subsequent ## or %:%: tokens in
2910 sequences of consecutive such tokens at the end of the
2911 list to preserve information about where they appear, how
2912 they are spelt and whether they are preceded by
2913 whitespace without otherwise interfering with macro
2914 expansion. */
2915 cpp_token *normal_dest = tokns;
2916 cpp_token *extra_dest = tokns + macro->count - num_extra_tokens;
2917 unsigned int i;
2918 for (i = 0; i < macro->count; i++)
2919 {
2920 if (macro->exp.tokens[i].type == CPP_PASTE)
2921 *extra_dest++ = macro->exp.tokens[i];
2922 else
2923 *normal_dest++ = macro->exp.tokens[i];
2924 }
2925 }
2926 else
2927 memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
2928 macro->exp.tokens = tokns;
2929 }
2930 else
2931 BUFF_FRONT (pfile->a_buff) = (uchar *) ¯o->exp.tokens[macro->count];
2932
2933 return true;
2934 }
2935
2936 /* Parse a macro and save its expansion. Returns nonzero on success. */
2937 bool
_cpp_create_definition(cpp_reader * pfile,cpp_hashnode * node)2938 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
2939 {
2940 cpp_macro *macro;
2941 unsigned int i;
2942 bool ok;
2943
2944 if (pfile->hash_table->alloc_subobject)
2945 macro = (cpp_macro *) pfile->hash_table->alloc_subobject
2946 (sizeof (cpp_macro));
2947 else
2948 macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
2949 macro->line = pfile->directive_line;
2950 macro->params = 0;
2951 macro->paramc = 0;
2952 macro->variadic = 0;
2953 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
2954 macro->count = 0;
2955 macro->fun_like = 0;
2956 macro->extra_tokens = 0;
2957 /* To suppress some diagnostics. */
2958 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
2959
2960 if (CPP_OPTION (pfile, traditional))
2961 ok = _cpp_create_trad_definition (pfile, macro);
2962 else
2963 {
2964 ok = create_iso_definition (pfile, macro);
2965
2966 /* We set the type for SEEN_EOL() in directives.c.
2967
2968 Longer term we should lex the whole line before coming here,
2969 and just copy the expansion. */
2970
2971 /* Stop the lexer accepting __VA_ARGS__. */
2972 pfile->state.va_args_ok = 0;
2973 }
2974
2975 /* Clear the fast argument lookup indices. */
2976 for (i = macro->paramc; i-- > 0; )
2977 {
2978 struct cpp_hashnode *node = macro->params[i];
2979 node->flags &= ~ NODE_MACRO_ARG;
2980 node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
2981 }
2982
2983 if (!ok)
2984 return ok;
2985
2986 if (node->type == NT_MACRO)
2987 {
2988 if (CPP_OPTION (pfile, warn_unused_macros))
2989 _cpp_warn_if_unused_macro (pfile, node, NULL);
2990
2991 if (warn_of_redefinition (pfile, node, macro))
2992 {
2993 const int reason = (node->flags & NODE_BUILTIN)
2994 ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
2995 bool warned;
2996
2997 warned = cpp_pedwarning_with_line (pfile, reason,
2998 pfile->directive_line, 0,
2999 "\"%s\" redefined",
3000 NODE_NAME (node));
3001
3002 if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
3003 cpp_error_with_line (pfile, CPP_DL_NOTE,
3004 node->value.macro->line, 0,
3005 "this is the location of the previous definition");
3006 }
3007 }
3008
3009 if (node->type != NT_VOID)
3010 _cpp_free_definition (node);
3011
3012 /* Enter definition in hash table. */
3013 node->type = NT_MACRO;
3014 node->value.macro = macro;
3015 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
3016 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
3017 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3018 in the C standard, as something that one must use in C++.
3019 However DR#593 indicates that these aren't actually mentioned
3020 in the C++ standard. We special-case them anyway. */
3021 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
3022 && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
3023 node->flags |= NODE_WARN;
3024
3025 /* If user defines one of the conditional macros, remove the
3026 conditional flag */
3027 node->flags &= ~NODE_CONDITIONAL;
3028
3029 return ok;
3030 }
3031
3032 /* Warn if a token in STRING matches one of a function-like MACRO's
3033 parameters. */
3034 static void
check_trad_stringification(cpp_reader * pfile,const cpp_macro * macro,const cpp_string * string)3035 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
3036 const cpp_string *string)
3037 {
3038 unsigned int i, len;
3039 const uchar *p, *q, *limit;
3040
3041 /* Loop over the string. */
3042 limit = string->text + string->len - 1;
3043 for (p = string->text + 1; p < limit; p = q)
3044 {
3045 /* Find the start of an identifier. */
3046 while (p < limit && !is_idstart (*p))
3047 p++;
3048
3049 /* Find the end of the identifier. */
3050 q = p;
3051 while (q < limit && is_idchar (*q))
3052 q++;
3053
3054 len = q - p;
3055
3056 /* Loop over the function macro arguments to see if the
3057 identifier inside the string matches one of them. */
3058 for (i = 0; i < macro->paramc; i++)
3059 {
3060 const cpp_hashnode *node = macro->params[i];
3061
3062 if (NODE_LEN (node) == len
3063 && !memcmp (p, NODE_NAME (node), len))
3064 {
3065 cpp_error (pfile, CPP_DL_WARNING,
3066 "macro argument \"%s\" would be stringified in traditional C",
3067 NODE_NAME (node));
3068 break;
3069 }
3070 }
3071 }
3072 }
3073
3074 /* Returns the name, arguments and expansion of a macro, in a format
3075 suitable to be read back in again, and therefore also for DWARF 2
3076 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3077 Caller is expected to generate the "#define" bit if needed. The
3078 returned text is temporary, and automatically freed later. */
3079 const unsigned char *
cpp_macro_definition(cpp_reader * pfile,cpp_hashnode * node)3080 cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node)
3081 {
3082 unsigned int i, len;
3083 const cpp_macro *macro;
3084 unsigned char *buffer;
3085
3086 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
3087 {
3088 if (node->type != NT_MACRO
3089 || !pfile->cb.user_builtin_macro
3090 || !pfile->cb.user_builtin_macro (pfile, node))
3091 {
3092 cpp_error (pfile, CPP_DL_ICE,
3093 "invalid hash type %d in cpp_macro_definition",
3094 node->type);
3095 return 0;
3096 }
3097 }
3098
3099 macro = node->value.macro;
3100 /* Calculate length. */
3101 len = NODE_LEN (node) + 2; /* ' ' and NUL. */
3102 if (macro->fun_like)
3103 {
3104 len += 4; /* "()" plus possible final ".." of named
3105 varargs (we have + 1 below). */
3106 for (i = 0; i < macro->paramc; i++)
3107 len += NODE_LEN (macro->params[i]) + 1; /* "," */
3108 }
3109
3110 /* This should match below where we fill in the buffer. */
3111 if (CPP_OPTION (pfile, traditional))
3112 len += _cpp_replacement_text_len (macro);
3113 else
3114 {
3115 unsigned int count = macro_real_token_count (macro);
3116 for (i = 0; i < count; i++)
3117 {
3118 cpp_token *token = ¯o->exp.tokens[i];
3119
3120 if (token->type == CPP_MACRO_ARG)
3121 len += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
3122 else
3123 len += cpp_token_len (token);
3124
3125 if (token->flags & STRINGIFY_ARG)
3126 len++; /* "#" */
3127 if (token->flags & PASTE_LEFT)
3128 len += 3; /* " ##" */
3129 if (token->flags & PREV_WHITE)
3130 len++; /* " " */
3131 }
3132 }
3133
3134 if (len > pfile->macro_buffer_len)
3135 {
3136 pfile->macro_buffer = XRESIZEVEC (unsigned char,
3137 pfile->macro_buffer, len);
3138 pfile->macro_buffer_len = len;
3139 }
3140
3141 /* Fill in the buffer. Start with the macro name. */
3142 buffer = pfile->macro_buffer;
3143 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
3144 buffer += NODE_LEN (node);
3145
3146 /* Parameter names. */
3147 if (macro->fun_like)
3148 {
3149 *buffer++ = '(';
3150 for (i = 0; i < macro->paramc; i++)
3151 {
3152 cpp_hashnode *param = macro->params[i];
3153
3154 if (param != pfile->spec_nodes.n__VA_ARGS__)
3155 {
3156 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
3157 buffer += NODE_LEN (param);
3158 }
3159
3160 if (i + 1 < macro->paramc)
3161 /* Don't emit a space after the comma here; we're trying
3162 to emit a Dwarf-friendly definition, and the Dwarf spec
3163 forbids spaces in the argument list. */
3164 *buffer++ = ',';
3165 else if (macro->variadic)
3166 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
3167 }
3168 *buffer++ = ')';
3169 }
3170
3171 /* The Dwarf spec requires a space after the macro name, even if the
3172 definition is the empty string. */
3173 *buffer++ = ' ';
3174
3175 if (CPP_OPTION (pfile, traditional))
3176 buffer = _cpp_copy_replacement_text (macro, buffer);
3177 else if (macro->count)
3178 /* Expansion tokens. */
3179 {
3180 unsigned int count = macro_real_token_count (macro);
3181 for (i = 0; i < count; i++)
3182 {
3183 cpp_token *token = ¯o->exp.tokens[i];
3184
3185 if (token->flags & PREV_WHITE)
3186 *buffer++ = ' ';
3187 if (token->flags & STRINGIFY_ARG)
3188 *buffer++ = '#';
3189
3190 if (token->type == CPP_MACRO_ARG)
3191 {
3192 memcpy (buffer,
3193 NODE_NAME (macro->params[token->val.macro_arg.arg_no - 1]),
3194 NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]));
3195 buffer += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
3196 }
3197 else
3198 buffer = cpp_spell_token (pfile, token, buffer, false);
3199
3200 if (token->flags & PASTE_LEFT)
3201 {
3202 *buffer++ = ' ';
3203 *buffer++ = '#';
3204 *buffer++ = '#';
3205 /* Next has PREV_WHITE; see _cpp_create_definition. */
3206 }
3207 }
3208 }
3209
3210 *buffer = '\0';
3211 return pfile->macro_buffer;
3212 }
3213