1/* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986-2023 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6
7This program is free software; you can redistribute it and/or modify it
8under the terms of the GNU General Public License as published by the
9Free Software Foundation; either version 3, or (at your option) any
10later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>.
20
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
24
25#include "config.h"
26#include "system.h"
27#include "cpplib.h"
28#include "internal.h"
29
30typedef struct macro_arg macro_arg;
31/* This structure represents the tokens of a macro argument. These
32 tokens can be macro themselves, in which case they can be either
33 expanded or unexpanded. When they are expanded, this data
34 structure keeps both the expanded and unexpanded forms. */
35struct macro_arg
36{
37 const cpp_token **first; /* First token in unexpanded argument. */
38 const cpp_token **expanded; /* Macro-expanded argument. */
39 const cpp_token *stringified; /* Stringified argument. */
40 unsigned int count; /* # of tokens in argument. */
41 unsigned int expanded_count; /* # of tokens in expanded argument. */
42 location_t *virt_locs; /* Where virtual locations for
43 unexpanded tokens are stored. */
44 location_t *expanded_virt_locs; /* Where virtual locations for
45 expanded tokens are
46 stored. */
47};
48
49/* The kind of macro tokens which the instance of
50 macro_arg_token_iter is supposed to iterate over. */
51enum macro_arg_token_kind {
52 MACRO_ARG_TOKEN_NORMAL,
53 /* This is a macro argument token that got transformed into a string
54 literal, e.g. #foo. */
55 MACRO_ARG_TOKEN_STRINGIFIED,
56 /* This is a token resulting from the expansion of a macro
57 argument that was itself a macro. */
58 MACRO_ARG_TOKEN_EXPANDED
59};
60
61/* An iterator over tokens coming from a function-like macro
62 argument. */
63typedef struct macro_arg_token_iter macro_arg_token_iter;
64struct macro_arg_token_iter
65{
66 /* Whether or not -ftrack-macro-expansion is used. */
67 bool track_macro_exp_p;
68 /* The kind of token over which we are supposed to iterate. */
69 enum macro_arg_token_kind kind;
70 /* A pointer to the current token pointed to by the iterator. */
71 const cpp_token **token_ptr;
72 /* A pointer to the "full" location of the current token. If
73 -ftrack-macro-expansion is used this location tracks loci across
74 macro expansion. */
75 const location_t *location_ptr;
76#if CHECKING_P
77 /* The number of times the iterator went forward. This useful only
78 when checking is enabled. */
79 size_t num_forwards;
80#endif
81};
82
83/* Saved data about an identifier being used as a macro argument
84 name. */
85struct macro_arg_saved_data {
86 /* The canonical (UTF-8) spelling of this identifier. */
87 cpp_hashnode *canonical_node;
88 /* The previous value & type of this identifier. */
89 union _cpp_hashnode_value value;
90 node_type type;
91};
92
93static const char *vaopt_paste_error =
94 N_("'##' cannot appear at either end of __VA_OPT__");
95
96static void expand_arg (cpp_reader *, macro_arg *);
97
98/* A class for tracking __VA_OPT__ state while iterating over a
99 sequence of tokens. This is used during both macro definition and
100 expansion. */
101class vaopt_state {
102
103 public:
104
105 enum update_type
106 {
107 ERROR,
108 DROP,
109 INCLUDE,
110 BEGIN,
111 END
112 };
113
114 /* Initialize the state tracker. ANY_ARGS is true if variable
115 arguments were provided to the macro invocation. */
116 vaopt_state (cpp_reader *pfile, bool is_variadic, macro_arg *arg)
117 : m_pfile (pfile),
118 m_arg (arg),
119 m_variadic (is_variadic),
120 m_last_was_paste (false),
121 m_stringify (false),
122 m_state (0),
123 m_paste_location (0),
124 m_location (0),
125 m_update (ERROR)
126 {
127 }
128
129 /* Given a token, update the state of this tracker and return a
130 boolean indicating whether the token should be be included in the
131 expansion. */
132 update_type update (const cpp_token *token)
133 {
134 /* If the macro isn't variadic, just don't bother. */
135 if (!m_variadic)
136 return INCLUDE;
137
138 if (token->type == CPP_NAME
139 && token->val.node.node == m_pfile->spec_nodes.n__VA_OPT__)
140 {
141 if (m_state > 0)
142 {
143 cpp_error_at (pfile: m_pfile, CPP_DL_ERROR, src_loc: token->src_loc,
144 msgid: "__VA_OPT__ may not appear in a __VA_OPT__");
145 return ERROR;
146 }
147 ++m_state;
148 m_location = token->src_loc;
149 m_stringify = (token->flags & STRINGIFY_ARG) != 0;
150 return BEGIN;
151 }
152 else if (m_state == 1)
153 {
154 if (token->type != CPP_OPEN_PAREN)
155 {
156 cpp_error_at (pfile: m_pfile, CPP_DL_ERROR, src_loc: m_location,
157 msgid: "__VA_OPT__ must be followed by an "
158 "open parenthesis");
159 return ERROR;
160 }
161 ++m_state;
162 if (m_update == ERROR)
163 {
164 if (m_arg == NULL)
165 m_update = INCLUDE;
166 else
167 {
168 m_update = DROP;
169 if (!m_arg->expanded)
170 expand_arg (m_pfile, m_arg);
171 for (unsigned idx = 0; idx < m_arg->expanded_count; ++idx)
172 if (m_arg->expanded[idx]->type != CPP_PADDING)
173 {
174 m_update = INCLUDE;
175 break;
176 }
177 }
178 }
179 return DROP;
180 }
181 else if (m_state >= 2)
182 {
183 if (m_state == 2 && token->type == CPP_PASTE)
184 {
185 cpp_error_at (pfile: m_pfile, CPP_DL_ERROR, src_loc: token->src_loc,
186 msgid: vaopt_paste_error);
187 return ERROR;
188 }
189 /* Advance states before further considering this token, in
190 case we see a close paren immediately after the open
191 paren. */
192 if (m_state == 2)
193 ++m_state;
194
195 bool was_paste = m_last_was_paste;
196 m_last_was_paste = false;
197 if (token->type == CPP_PASTE)
198 {
199 m_last_was_paste = true;
200 m_paste_location = token->src_loc;
201 }
202 else if (token->type == CPP_OPEN_PAREN)
203 ++m_state;
204 else if (token->type == CPP_CLOSE_PAREN)
205 {
206 --m_state;
207 if (m_state == 2)
208 {
209 /* Saw the final paren. */
210 m_state = 0;
211
212 if (was_paste)
213 {
214 cpp_error_at (pfile: m_pfile, CPP_DL_ERROR, src_loc: token->src_loc,
215 msgid: vaopt_paste_error);
216 return ERROR;
217 }
218
219 return END;
220 }
221 }
222 return m_update;
223 }
224
225 /* Nothing to do with __VA_OPT__. */
226 return INCLUDE;
227 }
228
229 /* Ensure that any __VA_OPT__ was completed. If ok, return true.
230 Otherwise, issue an error and return false. */
231 bool completed ()
232 {
233 if (m_variadic && m_state != 0)
234 cpp_error_at (pfile: m_pfile, CPP_DL_ERROR, src_loc: m_location,
235 msgid: "unterminated __VA_OPT__");
236 return m_state == 0;
237 }
238
239 /* Return true for # __VA_OPT__. */
240 bool stringify () const
241 {
242 return m_stringify;
243 }
244
245 private:
246
247 /* The cpp_reader. */
248 cpp_reader *m_pfile;
249
250 /* The __VA_ARGS__ argument. */
251 macro_arg *m_arg;
252
253 /* True if the macro is variadic. */
254 bool m_variadic;
255 /* If true, the previous token was ##. This is used to detect when
256 a paste occurs at the end of the sequence. */
257 bool m_last_was_paste;
258 /* True for #__VA_OPT__. */
259 bool m_stringify;
260
261 /* The state variable:
262 0 means not parsing
263 1 means __VA_OPT__ seen, looking for "("
264 2 means "(" seen (so the next token can't be "##")
265 >= 3 means looking for ")", the number encodes the paren depth. */
266 int m_state;
267
268 /* The location of the paste token. */
269 location_t m_paste_location;
270
271 /* Location of the __VA_OPT__ token. */
272 location_t m_location;
273
274 /* If __VA_ARGS__ substitutes to no preprocessing tokens,
275 INCLUDE, otherwise DROP. ERROR when unknown yet. */
276 update_type m_update;
277};
278
279/* Macro expansion. */
280
281static cpp_macro *get_deferred_or_lazy_macro (cpp_reader *, cpp_hashnode *,
282 location_t);
283static int enter_macro_context (cpp_reader *, cpp_hashnode *,
284 const cpp_token *, location_t);
285static int builtin_macro (cpp_reader *, cpp_hashnode *,
286 location_t, location_t);
287static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
288 const cpp_token **, unsigned int);
289static void push_extended_tokens_context (cpp_reader *, cpp_hashnode *,
290 _cpp_buff *, location_t *,
291 const cpp_token **, unsigned int);
292static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
293 _cpp_buff **, unsigned *);
294static cpp_context *next_context (cpp_reader *);
295static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
296static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
297static const cpp_token *stringify_arg (cpp_reader *, const cpp_token **,
298 unsigned int);
299static void paste_all_tokens (cpp_reader *, const cpp_token *);
300static bool paste_tokens (cpp_reader *, location_t,
301 const cpp_token **, const cpp_token *);
302static void alloc_expanded_arg_mem (cpp_reader *, macro_arg *, size_t);
303static void ensure_expanded_arg_room (cpp_reader *, macro_arg *, size_t, size_t *);
304static void delete_macro_args (_cpp_buff*, unsigned num_args);
305static void set_arg_token (macro_arg *, const cpp_token *,
306 location_t, size_t,
307 enum macro_arg_token_kind,
308 bool);
309static const location_t *get_arg_token_location (const macro_arg *,
310 enum macro_arg_token_kind);
311static const cpp_token **arg_token_ptr_at (const macro_arg *,
312 size_t,
313 enum macro_arg_token_kind,
314 location_t **virt_location);
315
316static void macro_arg_token_iter_init (macro_arg_token_iter *, bool,
317 enum macro_arg_token_kind,
318 const macro_arg *,
319 const cpp_token **);
320static const cpp_token *macro_arg_token_iter_get_token
321(const macro_arg_token_iter *it);
322static location_t macro_arg_token_iter_get_location
323(const macro_arg_token_iter *);
324static void macro_arg_token_iter_forward (macro_arg_token_iter *);
325static _cpp_buff *tokens_buff_new (cpp_reader *, size_t,
326 location_t **);
327static size_t tokens_buff_count (_cpp_buff *);
328static const cpp_token **tokens_buff_last_token_ptr (_cpp_buff *);
329static inline const cpp_token **tokens_buff_put_token_to (const cpp_token **,
330 location_t *,
331 const cpp_token *,
332 location_t,
333 location_t,
334 const line_map_macro *,
335 unsigned int);
336
337static const cpp_token **tokens_buff_add_token (_cpp_buff *,
338 location_t *,
339 const cpp_token *,
340 location_t,
341 location_t,
342 const line_map_macro *,
343 unsigned int);
344static inline void tokens_buff_remove_last_token (_cpp_buff *);
345static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
346 macro_arg *, location_t);
347static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
348 _cpp_buff **, unsigned *);
349static cpp_macro *create_iso_definition (cpp_reader *);
350
351/* #define directive parsing and handling. */
352
353static cpp_macro *lex_expansion_token (cpp_reader *, cpp_macro *);
354static bool parse_params (cpp_reader *, unsigned *, bool *);
355static void check_trad_stringification (cpp_reader *, const cpp_macro *,
356 const cpp_string *);
357static bool reached_end_of_context (cpp_context *);
358static void consume_next_token_from_context (cpp_reader *pfile,
359 const cpp_token **,
360 location_t *);
361static const cpp_token* cpp_get_token_1 (cpp_reader *, location_t *);
362
363static cpp_hashnode* macro_of_context (cpp_context *context);
364
365/* Statistical counter tracking the number of macros that got
366 expanded. */
367unsigned num_expanded_macros_counter = 0;
368/* Statistical counter tracking the total number tokens resulting
369 from macro expansion. */
370unsigned num_macro_tokens_counter = 0;
371
372/* Wrapper around cpp_get_token to skip CPP_PADDING tokens
373 and not consume CPP_EOF. */
374static const cpp_token *
375cpp_get_token_no_padding (cpp_reader *pfile)
376{
377 for (;;)
378 {
379 const cpp_token *ret = cpp_peek_token (pfile, 0);
380 if (ret->type == CPP_EOF)
381 return ret;
382 ret = cpp_get_token (pfile);
383 if (ret->type != CPP_PADDING)
384 return ret;
385 }
386}
387
388/* Handle meeting "__has_include" builtin macro. */
389
390static int
391builtin_has_include (cpp_reader *pfile, cpp_hashnode *op, bool has_next)
392{
393 int result = 0;
394
395 if (!pfile->state.in_directive)
396 cpp_error (pfile, CPP_DL_ERROR,
397 msgid: "\"%s\" used outside of preprocessing directive",
398 NODE_NAME (op));
399
400 pfile->state.angled_headers = true;
401 const cpp_token *token = cpp_get_token_no_padding (pfile);
402 bool paren = token->type == CPP_OPEN_PAREN;
403 if (paren)
404 token = cpp_get_token_no_padding (pfile);
405 else
406 cpp_error (pfile, CPP_DL_ERROR,
407 msgid: "missing '(' before \"%s\" operand", NODE_NAME (op));
408 pfile->state.angled_headers = false;
409
410 bool bracket = token->type != CPP_STRING;
411 char *fname = NULL;
412 if (token->type == CPP_STRING || token->type == CPP_HEADER_NAME)
413 {
414 fname = XNEWVEC (char, token->val.str.len - 1);
415 memcpy (dest: fname, src: token->val.str.text + 1, n: token->val.str.len - 2);
416 fname[token->val.str.len - 2] = '\0';
417 }
418 else if (token->type == CPP_LESS)
419 fname = _cpp_bracket_include (pfile);
420 else
421 cpp_error (pfile, CPP_DL_ERROR,
422 msgid: "operator \"%s\" requires a header-name", NODE_NAME (op));
423
424 if (fname)
425 {
426 /* Do not do the lookup if we're skipping, that's unnecessary
427 IO. */
428 if (!pfile->state.skip_eval
429 && _cpp_has_header (pfile, fname, bracket,
430 has_next ? IT_INCLUDE_NEXT : IT_INCLUDE))
431 result = 1;
432
433 XDELETEVEC (fname);
434 }
435
436 if (paren
437 && cpp_get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
438 cpp_error (pfile, CPP_DL_ERROR,
439 msgid: "missing ')' after \"%s\" operand", NODE_NAME (op));
440
441 return result;
442}
443
444/* Emits a warning if NODE is a macro defined in the main file that
445 has not been used. */
446int
447_cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
448 void *v ATTRIBUTE_UNUSED)
449{
450 if (cpp_user_macro_p (node))
451 {
452 cpp_macro *macro = node->value.macro;
453
454 if (!macro->used
455 && MAIN_FILE_P (ord_map: linemap_check_ordinary
456 (map: linemap_lookup (pfile->line_table,
457 macro->line))))
458 cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, macro->line, 0,
459 msgid: "macro \"%s\" is not used", NODE_NAME (node));
460 }
461
462 return 1;
463}
464
465/* Allocates and returns a CPP_STRING token, containing TEXT of length
466 LEN, after null-terminating it. TEXT must be in permanent storage. */
467static const cpp_token *
468new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
469{
470 cpp_token *token = _cpp_temp_token (pfile);
471
472 text[len] = '\0';
473 token->type = CPP_STRING;
474 token->val.str.len = len;
475 token->val.str.text = text;
476 token->flags = 0;
477 return token;
478}
479
480static const char * const monthnames[] =
481{
482 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
483 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
484};
485
486/* Helper function for builtin_macro. Returns the text generated by
487 a builtin macro. */
488const uchar *
489_cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node,
490 location_t loc)
491{
492 const uchar *result = NULL;
493 linenum_type number = 1;
494
495 switch (node->value.builtin)
496 {
497 default:
498 cpp_error (pfile, CPP_DL_ICE, msgid: "invalid built-in macro \"%s\"",
499 NODE_NAME (node));
500 break;
501
502 case BT_TIMESTAMP:
503 {
504 if (CPP_OPTION (pfile, warn_date_time))
505 cpp_warning (pfile, CPP_W_DATE_TIME, msgid: "macro \"%s\" might prevent "
506 "reproducible builds", NODE_NAME (node));
507
508 cpp_buffer *pbuffer = cpp_get_buffer (pfile);
509 if (pbuffer->timestamp == NULL)
510 {
511 /* Initialize timestamp value of the assotiated file. */
512 struct _cpp_file *file = cpp_get_file (pbuffer);
513 if (file)
514 {
515 /* Generate __TIMESTAMP__ string, that represents
516 the date and time of the last modification
517 of the current source file. The string constant
518 looks like "Sun Sep 16 01:03:52 1973". */
519 struct tm *tb = NULL;
520 struct stat *st = _cpp_get_file_stat (file);
521 if (st)
522 tb = localtime (timer: &st->st_mtime);
523 if (tb)
524 {
525 char *str = asctime (tp: tb);
526 size_t len = strlen (s: str);
527 unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
528 buf[0] = '"';
529 strcpy (dest: (char *) buf + 1, src: str);
530 buf[len] = '"';
531 pbuffer->timestamp = buf;
532 }
533 else
534 {
535 cpp_errno (pfile, CPP_DL_WARNING,
536 msgid: "could not determine file timestamp");
537 pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
538 }
539 }
540 }
541 result = pbuffer->timestamp;
542 }
543 break;
544 case BT_FILE:
545 case BT_FILE_NAME:
546 case BT_BASE_FILE:
547 {
548 unsigned int len;
549 const char *name;
550 uchar *buf;
551
552 if (node->value.builtin == BT_FILE
553 || node->value.builtin == BT_FILE_NAME)
554 {
555 name = linemap_get_expansion_filename (pfile->line_table,
556 pfile->line_table->highest_line);
557 if ((node->value.builtin == BT_FILE_NAME) && name)
558 name = lbasename (name);
559 }
560 else
561 {
562 name = _cpp_get_file_name (pfile->main_file);
563 if (!name)
564 abort ();
565 }
566 if (pfile->cb.remap_filename && !pfile->state.in_directive)
567 name = pfile->cb.remap_filename (name);
568 len = strlen (s: name);
569 buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
570 result = buf;
571 *buf = '"';
572 buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
573 *buf++ = '"';
574 *buf = '\0';
575 }
576 break;
577
578 case BT_INCLUDE_LEVEL:
579 /* The line map depth counts the primary source as level 1, but
580 historically __INCLUDE_DEPTH__ has called the primary source
581 level 0. */
582 number = pfile->line_table->depth - 1;
583 break;
584
585 case BT_SPECLINE:
586 /* If __LINE__ is embedded in a macro, it must expand to the
587 line of the macro's invocation, not its definition.
588 Otherwise things like assert() will not work properly.
589 See WG14 N1911, WG21 N4220 sec 6.5, and PR 61861. */
590 if (CPP_OPTION (pfile, traditional))
591 loc = pfile->line_table->highest_line;
592 else
593 loc = linemap_resolve_location (pfile->line_table, loc,
594 lrk: LRK_MACRO_EXPANSION_POINT, NULL);
595 number = linemap_get_expansion_line (pfile->line_table, loc);
596 break;
597
598 /* __STDC__ has the value 1 under normal circumstances.
599 However, if (a) we are in a system header, (b) the option
600 stdc_0_in_system_headers is true (set by target config), and
601 (c) we are not in strictly conforming mode, then it has the
602 value 0. (b) and (c) are already checked in cpp_init_builtins. */
603 case BT_STDC:
604 if (_cpp_in_system_header (pfile))
605 number = 0;
606 else
607 number = 1;
608 break;
609
610 case BT_DATE:
611 case BT_TIME:
612 if (CPP_OPTION (pfile, warn_date_time))
613 cpp_warning (pfile, CPP_W_DATE_TIME, msgid: "macro \"%s\" might prevent "
614 "reproducible builds", NODE_NAME (node));
615 if (pfile->date == NULL)
616 {
617 /* Allocate __DATE__ and __TIME__ strings from permanent
618 storage. We only do this once, and don't generate them
619 at init time, because time() and localtime() are very
620 slow on some systems. */
621 time_t tt;
622 auto kind = cpp_get_date (pfile, &tt);
623
624 if (kind == CPP_time_kind::UNKNOWN)
625 {
626 cpp_errno (pfile, CPP_DL_WARNING,
627 msgid: "could not determine date and time");
628
629 pfile->date = UC"\"??? ?? ????\"";
630 pfile->time = UC"\"??:??:??\"";
631 }
632 else
633 {
634 struct tm *tb = (kind == CPP_time_kind::FIXED
635 ? gmtime : localtime) (&tt);
636
637 pfile->date = _cpp_unaligned_alloc (pfile,
638 sizeof ("\"Oct 11 1347\""));
639 sprintf (s: (char *) pfile->date, format: "\"%s %2d %4d\"",
640 monthnames[tb->tm_mon], tb->tm_mday,
641 tb->tm_year + 1900);
642
643 pfile->time = _cpp_unaligned_alloc (pfile,
644 sizeof ("\"12:34:56\""));
645 sprintf (s: (char *) pfile->time, format: "\"%02d:%02d:%02d\"",
646 tb->tm_hour, tb->tm_min, tb->tm_sec);
647 }
648 }
649
650 if (node->value.builtin == BT_DATE)
651 result = pfile->date;
652 else
653 result = pfile->time;
654 break;
655
656 case BT_COUNTER:
657 if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
658 cpp_error (pfile, CPP_DL_ERROR,
659 msgid: "__COUNTER__ expanded inside directive with -fdirectives-only");
660 number = pfile->counter++;
661 break;
662
663 case BT_HAS_ATTRIBUTE:
664 number = pfile->cb.has_attribute (pfile, false);
665 break;
666
667 case BT_HAS_STD_ATTRIBUTE:
668 number = pfile->cb.has_attribute (pfile, true);
669 break;
670
671 case BT_HAS_BUILTIN:
672 number = pfile->cb.has_builtin (pfile);
673 break;
674
675 case BT_HAS_INCLUDE:
676 case BT_HAS_INCLUDE_NEXT:
677 number = builtin_has_include (pfile, op: node,
678 has_next: node->value.builtin == BT_HAS_INCLUDE_NEXT);
679 break;
680 }
681
682 if (result == NULL)
683 {
684 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
685 result = _cpp_unaligned_alloc (pfile, 21);
686 sprintf (s: (char *) result, format: "%u", number);
687 }
688
689 return result;
690}
691
692/* Get an idempotent date. Either the cached value, the value from
693 source epoch, or failing that, the value from time(2). Use this
694 during compilation so that every time stamp is the same. */
695CPP_time_kind
696cpp_get_date (cpp_reader *pfile, time_t *result)
697{
698 if (!pfile->time_stamp_kind)
699 {
700 int kind = 0;
701 if (pfile->cb.get_source_date_epoch)
702 {
703 /* Try reading the fixed epoch. */
704 pfile->time_stamp = pfile->cb.get_source_date_epoch (pfile);
705 if (pfile->time_stamp != time_t (-1))
706 kind = int (CPP_time_kind::FIXED);
707 }
708
709 if (!kind)
710 {
711 /* Pedantically time_t (-1) is a legitimate value for
712 "number of seconds since the Epoch". It is a silly
713 time. */
714 errno = 0;
715 pfile->time_stamp = time (timer: nullptr);
716 /* Annoyingly a library could legally set errno and return a
717 valid time! Bad library! */
718 if (pfile->time_stamp == time_t (-1) && errno)
719 kind = errno;
720 else
721 kind = int (CPP_time_kind::DYNAMIC);
722 }
723
724 pfile->time_stamp_kind = kind;
725 }
726
727 *result = pfile->time_stamp;
728 if (pfile->time_stamp_kind >= 0)
729 {
730 errno = pfile->time_stamp_kind;
731 return CPP_time_kind::UNKNOWN;
732 }
733
734 return CPP_time_kind (pfile->time_stamp_kind);
735}
736
737/* Convert builtin macros like __FILE__ to a token and push it on the
738 context stack. Also handles _Pragma, for which a new token may not
739 be created. Returns 1 if it generates a new token context, 0 to
740 return the token to the caller. LOC is the location of the expansion
741 point of the macro. */
742static int
743builtin_macro (cpp_reader *pfile, cpp_hashnode *node,
744 location_t loc, location_t expand_loc)
745{
746 const uchar *buf;
747 size_t len;
748 char *nbuf;
749
750 if (node->value.builtin == BT_PRAGMA)
751 {
752 /* Don't interpret _Pragma within directives. The standard is
753 not clear on this, but to me this makes most sense.
754 Similarly, don't interpret _Pragma inside expand_args, we might
755 need to stringize it later on. */
756 if (pfile->state.in_directive || pfile->state.ignore__Pragma)
757 return 0;
758
759 return _cpp_do__Pragma (pfile, loc);
760 }
761
762 buf = _cpp_builtin_macro_text (pfile, node, loc: expand_loc);
763 len = ustrlen (s1: buf);
764 nbuf = (char *) alloca (len + 1);
765 memcpy (dest: nbuf, src: buf, n: len);
766 nbuf[len]='\n';
767
768 cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
769 _cpp_clean_line (pfile);
770
771 /* Set pfile->cur_token as required by _cpp_lex_direct. */
772 pfile->cur_token = _cpp_temp_token (pfile);
773 cpp_token *token = _cpp_lex_direct (pfile);
774 /* We should point to the expansion point of the builtin macro. */
775 token->src_loc = loc;
776 if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
777 {
778 /* We are tracking tokens resulting from macro expansion.
779 Create a macro line map and generate a virtual location for
780 the token resulting from the expansion of the built-in
781 macro. */
782 location_t *virt_locs = NULL;
783 _cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs);
784 const line_map_macro * map =
785 linemap_enter_macro (pfile->line_table, node, loc, 1);
786 tokens_buff_add_token (token_buf, virt_locs, token,
787 pfile->line_table->builtin_location,
788 pfile->line_table->builtin_location,
789 map, /*macro_token_index=*/0);
790 push_extended_tokens_context (pfile, node, token_buf, virt_locs,
791 (const cpp_token **)token_buf->base,
792 1);
793 }
794 else
795 _cpp_push_token_context (pfile, NULL, token, 1);
796 if (pfile->buffer->cur != pfile->buffer->rlimit)
797 cpp_error (pfile, CPP_DL_ICE, msgid: "invalid built-in macro \"%s\"",
798 NODE_NAME (node));
799 _cpp_pop_buffer (pfile);
800
801 return 1;
802}
803
804/* Copies SRC, of length LEN, to DEST, adding backslashes before all
805 backslashes and double quotes. DEST must be of sufficient size.
806 Returns a pointer to the end of the string. */
807uchar *
808cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
809{
810 while (len--)
811 {
812 uchar c = *src++;
813
814 switch (c)
815 {
816 case '\n':
817 /* Naked LF can appear in raw string literals */
818 c = 'n';
819 /* FALLTHROUGH */
820
821 case '\\':
822 case '"':
823 *dest++ = '\\';
824 /* FALLTHROUGH */
825
826 default:
827 *dest++ = c;
828 }
829 }
830
831 return dest;
832}
833
834/* Convert a token sequence FIRST to FIRST+COUNT-1 to a single string token
835 according to the rules of the ISO C #-operator. */
836static const cpp_token *
837stringify_arg (cpp_reader *pfile, const cpp_token **first, unsigned int count)
838{
839 unsigned char *dest;
840 unsigned int i, escape_it, backslash_count = 0;
841 const cpp_token *source = NULL;
842 size_t len;
843
844 if (BUFF_ROOM (pfile->u_buff) < 3)
845 _cpp_extend_buff (pfile, &pfile->u_buff, 3);
846 dest = BUFF_FRONT (pfile->u_buff);
847 *dest++ = '"';
848
849 /* Loop, reading in the argument's tokens. */
850 for (i = 0; i < count; i++)
851 {
852 const cpp_token *token = first[i];
853
854 if (token->type == CPP_PADDING)
855 {
856 if (source == NULL
857 || (!(source->flags & PREV_WHITE)
858 && token->val.source == NULL))
859 source = token->val.source;
860 continue;
861 }
862
863 escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
864 || token->type == CPP_WSTRING || token->type == CPP_WCHAR
865 || token->type == CPP_STRING32 || token->type == CPP_CHAR32
866 || token->type == CPP_STRING16 || token->type == CPP_CHAR16
867 || token->type == CPP_UTF8STRING || token->type == CPP_UTF8CHAR
868 || cpp_userdef_string_p (type: token->type)
869 || cpp_userdef_char_p (type: token->type));
870
871 /* Room for each char being written in octal, initial space and
872 final quote and NUL. */
873 len = cpp_token_len (token);
874 if (escape_it)
875 len *= 4;
876 len += 3;
877
878 if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
879 {
880 size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
881 _cpp_extend_buff (pfile, &pfile->u_buff, len);
882 dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
883 }
884
885 /* Leading white space? */
886 if (dest - 1 != BUFF_FRONT (pfile->u_buff))
887 {
888 if (source == NULL)
889 source = token;
890 if (source->flags & PREV_WHITE)
891 *dest++ = ' ';
892 }
893 source = NULL;
894
895 if (escape_it)
896 {
897 _cpp_buff *buff = _cpp_get_buff (pfile, len);
898 unsigned char *buf = BUFF_FRONT (buff);
899 len = cpp_spell_token (pfile, token, buf, true) - buf;
900 dest = cpp_quote_string (dest, src: buf, len);
901 _cpp_release_buff (pfile, buff);
902 }
903 else
904 dest = cpp_spell_token (pfile, token, dest, true);
905
906 if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
907 backslash_count++;
908 else
909 backslash_count = 0;
910 }
911
912 /* Ignore the final \ of invalid string literals. */
913 if (backslash_count & 1)
914 {
915 cpp_error (pfile, CPP_DL_WARNING,
916 msgid: "invalid string literal, ignoring final '\\'");
917 dest--;
918 }
919
920 /* Commit the memory, including NUL, and return the token. */
921 *dest++ = '"';
922 len = dest - BUFF_FRONT (pfile->u_buff);
923 BUFF_FRONT (pfile->u_buff) = dest + 1;
924 return new_string_token (pfile, text: dest - len, len);
925}
926
927/* Try to paste two tokens. On success, return nonzero. In any
928 case, PLHS is updated to point to the pasted token, which is
929 guaranteed to not have the PASTE_LEFT flag set. LOCATION is
930 the virtual location used for error reporting. */
931static bool
932paste_tokens (cpp_reader *pfile, location_t location,
933 const cpp_token **plhs, const cpp_token *rhs)
934{
935 unsigned char *buf, *end, *lhsend;
936 cpp_token *lhs;
937 unsigned int len;
938
939 len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 2;
940 buf = (unsigned char *) alloca (len);
941 end = lhsend = cpp_spell_token (pfile, *plhs, buf, true);
942
943 /* Avoid comment headers, since they are still processed in stage 3.
944 It is simpler to insert a space here, rather than modifying the
945 lexer to ignore comments in some circumstances. Simply returning
946 false doesn't work, since we want to clear the PASTE_LEFT flag. */
947 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
948 *end++ = ' ';
949 /* In one obscure case we might see padding here. */
950 if (rhs->type != CPP_PADDING)
951 end = cpp_spell_token (pfile, rhs, end, true);
952 *end = '\n';
953
954 cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
955 _cpp_clean_line (pfile);
956
957 /* Set pfile->cur_token as required by _cpp_lex_direct. */
958 pfile->cur_token = _cpp_temp_token (pfile);
959 lhs = _cpp_lex_direct (pfile);
960 if (pfile->buffer->cur != pfile->buffer->rlimit)
961 {
962 location_t saved_loc = lhs->src_loc;
963
964 _cpp_pop_buffer (pfile);
965
966 unsigned char *rhsstart = lhsend;
967 if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
968 rhsstart++;
969
970 /* We have to remove the PASTE_LEFT flag from the old lhs, but
971 we want to keep the new location. */
972 *lhs = **plhs;
973 *plhs = lhs;
974 lhs->src_loc = saved_loc;
975 lhs->flags &= ~PASTE_LEFT;
976
977 /* Mandatory error for all apart from assembler. */
978 if (CPP_OPTION (pfile, lang) != CLK_ASM)
979 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
980 msgid: "pasting \"%.*s\" and \"%.*s\" does not give "
981 "a valid preprocessing token",
982 (int) (lhsend - buf), buf,
983 (int) (end - rhsstart), rhsstart);
984 return false;
985 }
986
987 lhs->flags |= (*plhs)->flags & (PREV_WHITE | PREV_FALLTHROUGH);
988 *plhs = lhs;
989 _cpp_pop_buffer (pfile);
990 return true;
991}
992
993/* Handles an arbitrarily long sequence of ## operators, with initial
994 operand LHS. This implementation is left-associative,
995 non-recursive, and finishes a paste before handling succeeding
996 ones. If a paste fails, we back up to the RHS of the failing ##
997 operator before pushing the context containing the result of prior
998 successful pastes, with the effect that the RHS appears in the
999 output stream after the pasted LHS normally. */
1000static void
1001paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
1002{
1003 const cpp_token *rhs = NULL;
1004 cpp_context *context = pfile->context;
1005 location_t virt_loc = 0;
1006
1007 /* We are expanding a macro and we must have been called on a token
1008 that appears at the left hand side of a ## operator. */
1009 if (macro_of_context (context: pfile->context) == NULL
1010 || (!(lhs->flags & PASTE_LEFT)))
1011 abort ();
1012
1013 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
1014 /* The caller must have called consume_next_token_from_context
1015 right before calling us. That has incremented the pointer to
1016 the current virtual location. So it now points to the location
1017 of the token that comes right after *LHS. We want the
1018 resulting pasted token to have the location of the current
1019 *LHS, though. */
1020 virt_loc = context->c.mc->cur_virt_loc[-1];
1021 else
1022 /* We are not tracking macro expansion. So the best virtual
1023 location we can get here is the expansion point of the macro we
1024 are currently expanding. */
1025 virt_loc = pfile->invocation_location;
1026
1027 do
1028 {
1029 /* Take the token directly from the current context. We can do
1030 this, because we are in the replacement list of either an
1031 object-like macro, or a function-like macro with arguments
1032 inserted. In either case, the constraints to #define
1033 guarantee we have at least one more token. */
1034 if (context->tokens_kind == TOKENS_KIND_DIRECT)
1035 rhs = FIRST (context).token++;
1036 else if (context->tokens_kind == TOKENS_KIND_INDIRECT)
1037 rhs = *FIRST (context).ptoken++;
1038 else if (context->tokens_kind == TOKENS_KIND_EXTENDED)
1039 {
1040 /* So we are in presence of an extended token context, which
1041 means that each token in this context has a virtual
1042 location attached to it. So let's not forget to update
1043 the pointer to the current virtual location of the
1044 current token when we update the pointer to the current
1045 token */
1046
1047 rhs = *FIRST (context).ptoken++;
1048 /* context->c.mc must be non-null, as if we were not in a
1049 macro context, context->tokens_kind could not be equal to
1050 TOKENS_KIND_EXTENDED. */
1051 context->c.mc->cur_virt_loc++;
1052 }
1053
1054 if (rhs->type == CPP_PADDING)
1055 {
1056 if (rhs->flags & PASTE_LEFT)
1057 abort ();
1058 }
1059 if (!paste_tokens (pfile, location: virt_loc, plhs: &lhs, rhs))
1060 {
1061 _cpp_backup_tokens (pfile, 1);
1062 break;
1063 }
1064 }
1065 while (rhs->flags & PASTE_LEFT);
1066
1067 /* Put the resulting token in its own context. */
1068 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
1069 {
1070 location_t *virt_locs = NULL;
1071 _cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs);
1072 tokens_buff_add_token (token_buf, virt_locs, lhs,
1073 virt_loc, 0, NULL, 0);
1074 push_extended_tokens_context (pfile, context->c.mc->macro_node,
1075 token_buf, virt_locs,
1076 (const cpp_token **)token_buf->base, 1);
1077 }
1078 else
1079 _cpp_push_token_context (pfile, NULL, lhs, 1);
1080}
1081
1082/* Returns TRUE if the number of arguments ARGC supplied in an
1083 invocation of the MACRO referenced by NODE is valid. An empty
1084 invocation to a macro with no parameters should pass ARGC as zero.
1085
1086 Note that MACRO cannot necessarily be deduced from NODE, in case
1087 NODE was redefined whilst collecting arguments. */
1088bool
1089_cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
1090{
1091 if (argc == macro->paramc)
1092 return true;
1093
1094 if (argc < macro->paramc)
1095 {
1096 /* In C++20 and C23 (here the va_opt flag is used), and also as a GNU
1097 extension, variadic arguments are allowed to not appear in
1098 the invocation at all.
1099 e.g. #define debug(format, args...) something
1100 debug("string");
1101
1102 This is exactly the same as if an empty variadic list had been
1103 supplied - debug("string", ). */
1104
1105 if (argc + 1 == macro->paramc && macro->variadic)
1106 {
1107 if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1108 && ! CPP_OPTION (pfile, va_opt))
1109 {
1110 if (CPP_OPTION (pfile, cplusplus))
1111 cpp_error (pfile, CPP_DL_PEDWARN,
1112 msgid: "ISO C++11 requires at least one argument "
1113 "for the \"...\" in a variadic macro");
1114 else
1115 cpp_error (pfile, CPP_DL_PEDWARN,
1116 msgid: "ISO C99 requires at least one argument "
1117 "for the \"...\" in a variadic macro");
1118 }
1119 return true;
1120 }
1121
1122 cpp_error (pfile, CPP_DL_ERROR,
1123 msgid: "macro \"%s\" requires %u arguments, but only %u given",
1124 NODE_NAME (node), macro->paramc, argc);
1125 }
1126 else
1127 cpp_error (pfile, CPP_DL_ERROR,
1128 msgid: "macro \"%s\" passed %u arguments, but takes just %u",
1129 NODE_NAME (node), argc, macro->paramc);
1130
1131 if (macro->line > RESERVED_LOCATION_COUNT)
1132 cpp_error_at (pfile, CPP_DL_NOTE, src_loc: macro->line, msgid: "macro \"%s\" defined here",
1133 NODE_NAME (node));
1134
1135 return false;
1136}
1137
1138/* Reads and returns the arguments to a function-like macro
1139 invocation. Assumes the opening parenthesis has been processed.
1140 If there is an error, emits an appropriate diagnostic and returns
1141 NULL. Each argument is terminated by a CPP_EOF token, for the
1142 future benefit of expand_arg(). If there are any deferred
1143 #pragma directives among macro arguments, store pointers to the
1144 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
1145
1146 What is returned is the buffer that contains the memory allocated
1147 to hold the macro arguments. NODE is the name of the macro this
1148 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
1149 set to the actual number of macro arguments allocated in the
1150 returned buffer. */
1151static _cpp_buff *
1152collect_args (cpp_reader *pfile, const cpp_hashnode *node,
1153 _cpp_buff **pragma_buff, unsigned *num_args)
1154{
1155 _cpp_buff *buff, *base_buff;
1156 cpp_macro *macro;
1157 macro_arg *args, *arg;
1158 const cpp_token *token;
1159 unsigned int argc;
1160 location_t virt_loc;
1161 bool track_macro_expansion_p = CPP_OPTION (pfile, track_macro_expansion);
1162 unsigned num_args_alloced = 0;
1163
1164 macro = node->value.macro;
1165 if (macro->paramc)
1166 argc = macro->paramc;
1167 else
1168 argc = 1;
1169
1170#define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
1171#define ARG_TOKENS_EXTENT 1000
1172
1173 buff = _cpp_get_buff (pfile, argc * (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
1174 * sizeof (cpp_token *)
1175 + sizeof (macro_arg)));
1176 base_buff = buff;
1177 args = (macro_arg *) buff->base;
1178 memset (s: args, c: 0, n: argc * sizeof (macro_arg));
1179 buff->cur = (unsigned char *) &args[argc];
1180 arg = args, argc = 0;
1181
1182 /* Collect the tokens making up each argument. We don't yet know
1183 how many arguments have been supplied, whether too many or too
1184 few. Hence the slightly bizarre usage of "argc" and "arg". */
1185 do
1186 {
1187 unsigned int paren_depth = 0;
1188 unsigned int ntokens = 0;
1189 unsigned virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
1190 num_args_alloced++;
1191
1192 argc++;
1193 arg->first = (const cpp_token **) buff->cur;
1194 if (track_macro_expansion_p)
1195 {
1196 virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
1197 arg->virt_locs = XNEWVEC (location_t,
1198 virt_locs_capacity);
1199 }
1200
1201 for (;;)
1202 {
1203 /* Require space for 2 new tokens (including a CPP_EOF). */
1204 if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
1205 {
1206 buff = _cpp_append_extend_buff (pfile, buff,
1207 ARG_TOKENS_EXTENT
1208 * sizeof (cpp_token *));
1209 arg->first = (const cpp_token **) buff->cur;
1210 }
1211 if (track_macro_expansion_p
1212 && (ntokens + 2 > virt_locs_capacity))
1213 {
1214 virt_locs_capacity += ARG_TOKENS_EXTENT;
1215 arg->virt_locs = XRESIZEVEC (location_t,
1216 arg->virt_locs,
1217 virt_locs_capacity);
1218 }
1219
1220 token = cpp_get_token_1 (pfile, &virt_loc);
1221
1222 if (token->type == CPP_PADDING)
1223 {
1224 /* Drop leading padding. */
1225 if (ntokens == 0)
1226 continue;
1227 }
1228 else if (token->type == CPP_OPEN_PAREN)
1229 paren_depth++;
1230 else if (token->type == CPP_CLOSE_PAREN)
1231 {
1232 if (paren_depth-- == 0)
1233 break;
1234 }
1235 else if (token->type == CPP_COMMA)
1236 {
1237 /* A comma does not terminate an argument within
1238 parentheses or as part of a variable argument. */
1239 if (paren_depth == 0
1240 && ! (macro->variadic && argc == macro->paramc))
1241 break;
1242 }
1243 else if (token->type == CPP_EOF
1244 || (token->type == CPP_HASH && token->flags & BOL))
1245 break;
1246 else if (token->type == CPP_PRAGMA && !(token->flags & PRAGMA_OP))
1247 {
1248 cpp_token *newtok = _cpp_temp_token (pfile);
1249
1250 /* CPP_PRAGMA token lives in directive_result, which will
1251 be overwritten on the next directive. */
1252 *newtok = *token;
1253 token = newtok;
1254 do
1255 {
1256 if (*pragma_buff == NULL
1257 || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
1258 {
1259 _cpp_buff *next;
1260 if (*pragma_buff == NULL)
1261 *pragma_buff
1262 = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
1263 else
1264 {
1265 next = *pragma_buff;
1266 *pragma_buff
1267 = _cpp_get_buff (pfile,
1268 (BUFF_FRONT (*pragma_buff)
1269 - (*pragma_buff)->base) * 2);
1270 (*pragma_buff)->next = next;
1271 }
1272 }
1273 *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
1274 BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
1275 if (token->type == CPP_PRAGMA_EOL)
1276 break;
1277 token = cpp_get_token_1 (pfile, &virt_loc);
1278 }
1279 while (token->type != CPP_EOF);
1280
1281 /* In deferred pragmas parsing_args and prevent_expansion
1282 had been changed, reset it. */
1283 pfile->state.parsing_args = 2;
1284 pfile->state.prevent_expansion = 1;
1285
1286 if (token->type == CPP_EOF)
1287 break;
1288 else
1289 continue;
1290 }
1291 set_arg_token (arg, token, virt_loc,
1292 ntokens, MACRO_ARG_TOKEN_NORMAL,
1293 CPP_OPTION (pfile, track_macro_expansion));
1294 ntokens++;
1295 }
1296
1297 /* Drop trailing padding. */
1298 while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
1299 ntokens--;
1300
1301 arg->count = ntokens;
1302 /* Append an EOF to mark end-of-argument. */
1303 set_arg_token (arg, &pfile->endarg, token->src_loc,
1304 ntokens, MACRO_ARG_TOKEN_NORMAL,
1305 CPP_OPTION (pfile, track_macro_expansion));
1306
1307 /* Terminate the argument. Excess arguments loop back and
1308 overwrite the final legitimate argument, before failing. */
1309 if (argc <= macro->paramc)
1310 {
1311 buff->cur = (unsigned char *) &arg->first[ntokens + 1];
1312 if (argc != macro->paramc)
1313 arg++;
1314 }
1315 }
1316 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
1317
1318 if (token->type == CPP_EOF)
1319 {
1320 /* Unless the EOF is marking the end of an argument, it's a fake
1321 one from the end of a file that _cpp_clean_line will not have
1322 advanced past. */
1323 if (token == &pfile->endarg)
1324 _cpp_backup_tokens (pfile, 1);
1325 cpp_error (pfile, CPP_DL_ERROR,
1326 msgid: "unterminated argument list invoking macro \"%s\"",
1327 NODE_NAME (node));
1328 }
1329 else
1330 {
1331 /* A single empty argument is counted as no argument. */
1332 if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
1333 argc = 0;
1334 if (_cpp_arguments_ok (pfile, macro, node, argc))
1335 {
1336 /* GCC has special semantics for , ## b where b is a varargs
1337 parameter: we remove the comma if b was omitted entirely.
1338 If b was merely an empty argument, the comma is retained.
1339 If the macro takes just one (varargs) parameter, then we
1340 retain the comma only if we are standards conforming.
1341
1342 If FIRST is NULL replace_args () swallows the comma. */
1343 if (macro->variadic && (argc < macro->paramc
1344 || (argc == 1 && args[0].count == 0
1345 && !CPP_OPTION (pfile, std))))
1346 args[macro->paramc - 1].first = NULL;
1347 if (num_args)
1348 *num_args = num_args_alloced;
1349 return base_buff;
1350 }
1351 }
1352
1353 /* An error occurred. */
1354 _cpp_release_buff (pfile, base_buff);
1355 return NULL;
1356}
1357
1358/* Search for an opening parenthesis to the macro of NODE, in such a
1359 way that, if none is found, we don't lose the information in any
1360 intervening padding tokens. If we find the parenthesis, collect
1361 the arguments and return the buffer containing them. PRAGMA_BUFF
1362 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
1363 *NUM_ARGS is set to the number of arguments contained in the
1364 returned buffer. */
1365static _cpp_buff *
1366funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
1367 _cpp_buff **pragma_buff, unsigned *num_args)
1368{
1369 const cpp_token *token, *padding = NULL;
1370
1371 for (;;)
1372 {
1373 token = cpp_get_token (pfile);
1374 if (token->type != CPP_PADDING)
1375 break;
1376 gcc_assert ((token->flags & PREV_WHITE) == 0);
1377 if (padding == NULL
1378 || padding->val.source == NULL
1379 || (!(padding->val.source->flags & PREV_WHITE)
1380 && token->val.source == NULL))
1381 padding = token;
1382 }
1383
1384 if (token->type == CPP_OPEN_PAREN)
1385 {
1386 pfile->state.parsing_args = 2;
1387 return collect_args (pfile, node, pragma_buff, num_args);
1388 }
1389
1390 /* Back up. A CPP_EOF is either an EOF from an argument we're
1391 expanding, or a fake one from lex_direct. We want to backup the
1392 former, but not the latter. We may have skipped padding, in
1393 which case backing up more than one token when expanding macros
1394 is in general too difficult. We re-insert it in its own
1395 context. */
1396 if (token->type != CPP_EOF || token == &pfile->endarg)
1397 {
1398 _cpp_backup_tokens (pfile, 1);
1399 if (padding)
1400 _cpp_push_token_context (pfile, NULL, padding, 1);
1401 }
1402
1403 return NULL;
1404}
1405
1406/* Return the real number of tokens in the expansion of MACRO. */
1407static inline unsigned int
1408macro_real_token_count (const cpp_macro *macro)
1409{
1410 if (__builtin_expect (!macro->extra_tokens, true))
1411 return macro->count;
1412
1413 for (unsigned i = macro->count; i--;)
1414 if (macro->exp.tokens[i].type != CPP_PASTE)
1415 return i + 1;
1416
1417 return 0;
1418}
1419
1420/* Push the context of a macro with hash entry NODE onto the context
1421 stack. If we can successfully expand the macro, we push a context
1422 containing its yet-to-be-rescanned replacement list and return one.
1423 If there were additionally any unexpanded deferred #pragma
1424 directives among macro arguments, push another context containing
1425 the pragma tokens before the yet-to-be-rescanned replacement list
1426 and return two. Otherwise, we don't push a context and return
1427 zero. LOCATION is the location of the expansion point of the
1428 macro. */
1429static int
1430enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
1431 const cpp_token *result, location_t location)
1432{
1433 /* The presence of a macro invalidates a file's controlling macro. */
1434 pfile->mi_valid = false;
1435
1436 pfile->state.angled_headers = false;
1437
1438 /* From here to when we push the context for the macro later down
1439 this function, we need to flag the fact that we are about to
1440 expand a macro. This is useful when -ftrack-macro-expansion is
1441 turned off. In that case, we need to record the location of the
1442 expansion point of the top-most macro we are about to to expand,
1443 into pfile->invocation_location. But we must not record any such
1444 location once the process of expanding the macro starts; that is,
1445 we must not do that recording between now and later down this
1446 function where set this flag to FALSE. */
1447 pfile->about_to_expand_macro_p = true;
1448
1449 if (cpp_user_macro_p (node))
1450 {
1451 cpp_macro *macro = node->value.macro;
1452 _cpp_buff *pragma_buff = NULL;
1453
1454 if (macro->fun_like)
1455 {
1456 _cpp_buff *buff;
1457 unsigned num_args = 0;
1458
1459 pfile->state.prevent_expansion++;
1460 pfile->keep_tokens++;
1461 pfile->state.parsing_args = 1;
1462 buff = funlike_invocation_p (pfile, node, pragma_buff: &pragma_buff,
1463 num_args: &num_args);
1464 pfile->state.parsing_args = 0;
1465 pfile->keep_tokens--;
1466 pfile->state.prevent_expansion--;
1467
1468 if (buff == NULL)
1469 {
1470 if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
1471 cpp_warning (pfile, CPP_W_TRADITIONAL,
1472 msgid: "function-like macro \"%s\" must be used with arguments in traditional C",
1473 NODE_NAME (node));
1474
1475 if (pragma_buff)
1476 _cpp_release_buff (pfile, pragma_buff);
1477
1478 pfile->about_to_expand_macro_p = false;
1479 return 0;
1480 }
1481
1482 if (macro->paramc > 0)
1483 replace_args (pfile, node, macro,
1484 (macro_arg *) buff->base,
1485 location);
1486 /* Free the memory used by the arguments of this
1487 function-like macro. This memory has been allocated by
1488 funlike_invocation_p and by replace_args. */
1489 delete_macro_args (buff, num_args);
1490 }
1491
1492 /* Disable the macro within its expansion. */
1493 node->flags |= NODE_DISABLED;
1494
1495 /* Laziness can only affect the expansion tokens of the macro,
1496 not its fun-likeness or parameters. */
1497 _cpp_maybe_notify_macro_use (pfile, node, loc: location);
1498 if (pfile->cb.used)
1499 pfile->cb.used (pfile, location, node);
1500
1501 macro->used = 1;
1502
1503 if (macro->paramc == 0)
1504 {
1505 unsigned tokens_count = macro_real_token_count (macro);
1506 if (CPP_OPTION (pfile, track_macro_expansion))
1507 {
1508 unsigned int i;
1509 const cpp_token *src = macro->exp.tokens;
1510 const line_map_macro *map;
1511 location_t *virt_locs = NULL;
1512 _cpp_buff *macro_tokens
1513 = tokens_buff_new (pfile, tokens_count, &virt_locs);
1514
1515 /* Create a macro map to record the locations of the
1516 tokens that are involved in the expansion. LOCATION
1517 is the location of the macro expansion point. */
1518 map = linemap_enter_macro (pfile->line_table,
1519 node, location, tokens_count);
1520 for (i = 0; i < tokens_count; ++i)
1521 {
1522 tokens_buff_add_token (macro_tokens, virt_locs,
1523 src, src->src_loc,
1524 src->src_loc, map, i);
1525 ++src;
1526 }
1527 push_extended_tokens_context (pfile, node,
1528 macro_tokens,
1529 virt_locs,
1530 (const cpp_token **)
1531 macro_tokens->base,
1532 tokens_count);
1533 }
1534 else
1535 _cpp_push_token_context (pfile, node, macro->exp.tokens,
1536 tokens_count);
1537 num_macro_tokens_counter += tokens_count;
1538 }
1539
1540 if (pragma_buff)
1541 {
1542 if (!pfile->state.in_directive)
1543 _cpp_push_token_context (pfile, NULL,
1544 padding_token (pfile, result), 1);
1545 do
1546 {
1547 unsigned tokens_count;
1548 _cpp_buff *tail = pragma_buff->next;
1549 pragma_buff->next = NULL;
1550 tokens_count = ((const cpp_token **) BUFF_FRONT (pragma_buff)
1551 - (const cpp_token **) pragma_buff->base);
1552 push_ptoken_context (pfile, NULL, pragma_buff,
1553 (const cpp_token **) pragma_buff->base,
1554 tokens_count);
1555 pragma_buff = tail;
1556 if (!CPP_OPTION (pfile, track_macro_expansion))
1557 num_macro_tokens_counter += tokens_count;
1558
1559 }
1560 while (pragma_buff != NULL);
1561 pfile->about_to_expand_macro_p = false;
1562 return 2;
1563 }
1564
1565 pfile->about_to_expand_macro_p = false;
1566 return 1;
1567 }
1568
1569 pfile->about_to_expand_macro_p = false;
1570 /* Handle built-in macros and the _Pragma operator. */
1571 {
1572 location_t expand_loc;
1573
1574 if (/* The top-level macro invocation that triggered the expansion
1575 we are looking at is with a function-like user macro ... */
1576 cpp_fun_like_macro_p (node: pfile->top_most_macro_node)
1577 /* ... and we are tracking the macro expansion. */
1578 && CPP_OPTION (pfile, track_macro_expansion))
1579 /* Then the location of the end of the macro invocation is the
1580 location of the expansion point of this macro. */
1581 expand_loc = location;
1582 else
1583 /* Otherwise, the location of the end of the macro invocation is
1584 the location of the expansion point of that top-level macro
1585 invocation. */
1586 expand_loc = pfile->invocation_location;
1587
1588 return builtin_macro (pfile, node, loc: location, expand_loc);
1589 }
1590}
1591
1592/* De-allocate the memory used by BUFF which is an array of instances
1593 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1594 present in BUFF. */
1595static void
1596delete_macro_args (_cpp_buff *buff, unsigned num_args)
1597{
1598 macro_arg *macro_args;
1599 unsigned i;
1600
1601 if (buff == NULL)
1602 return;
1603
1604 macro_args = (macro_arg *) buff->base;
1605
1606 /* Walk instances of macro_arg to free their expanded tokens as well
1607 as their macro_arg::virt_locs members. */
1608 for (i = 0; i < num_args; ++i)
1609 {
1610 if (macro_args[i].expanded)
1611 {
1612 free (ptr: macro_args[i].expanded);
1613 macro_args[i].expanded = NULL;
1614 }
1615 if (macro_args[i].virt_locs)
1616 {
1617 free (ptr: macro_args[i].virt_locs);
1618 macro_args[i].virt_locs = NULL;
1619 }
1620 if (macro_args[i].expanded_virt_locs)
1621 {
1622 free (ptr: macro_args[i].expanded_virt_locs);
1623 macro_args[i].expanded_virt_locs = NULL;
1624 }
1625 }
1626 _cpp_free_buff (buff);
1627}
1628
1629/* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1630 to set, LOCATION is its virtual location. "Virtual" location means
1631 the location that encodes loci across macro expansion. Otherwise
1632 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1633 argument ARG is supposed to contain. Note that ARG must be
1634 tailored so that it has enough room to contain INDEX + 1 numbers of
1635 tokens, at least. */
1636static void
1637set_arg_token (macro_arg *arg, const cpp_token *token,
1638 location_t location, size_t index,
1639 enum macro_arg_token_kind kind,
1640 bool track_macro_exp_p)
1641{
1642 const cpp_token **token_ptr;
1643 location_t *loc = NULL;
1644
1645 token_ptr =
1646 arg_token_ptr_at (arg, index, kind,
1647 virt_location: track_macro_exp_p ? &loc : NULL);
1648 *token_ptr = token;
1649
1650 if (loc != NULL)
1651 {
1652 /* We can't set the location of a stringified argument
1653 token and we can't set any location if we aren't tracking
1654 macro expansion locations. */
1655 gcc_checking_assert (kind != MACRO_ARG_TOKEN_STRINGIFIED
1656 && track_macro_exp_p);
1657 *loc = location;
1658 }
1659}
1660
1661/* Get the pointer to the location of the argument token of the
1662 function-like macro argument ARG. This function must be called
1663 only when we -ftrack-macro-expansion is on. */
1664static const location_t *
1665get_arg_token_location (const macro_arg *arg,
1666 enum macro_arg_token_kind kind)
1667{
1668 const location_t *loc = NULL;
1669 const cpp_token **token_ptr =
1670 arg_token_ptr_at (arg, 0, kind, virt_location: (location_t **) &loc);
1671
1672 if (token_ptr == NULL)
1673 return NULL;
1674
1675 return loc;
1676}
1677
1678/* Return the pointer to the INDEXth token of the macro argument ARG.
1679 KIND specifies the kind of token the macro argument ARG contains.
1680 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1681 of the virtual location of the returned token if the
1682 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1683 spelling location of the returned token. */
1684static const cpp_token **
1685arg_token_ptr_at (const macro_arg *arg, size_t index,
1686 enum macro_arg_token_kind kind,
1687 location_t **virt_location)
1688{
1689 const cpp_token **tokens_ptr = NULL;
1690
1691 switch (kind)
1692 {
1693 case MACRO_ARG_TOKEN_NORMAL:
1694 tokens_ptr = arg->first;
1695 break;
1696 case MACRO_ARG_TOKEN_STRINGIFIED:
1697 tokens_ptr = (const cpp_token **) &arg->stringified;
1698 break;
1699 case MACRO_ARG_TOKEN_EXPANDED:
1700 tokens_ptr = arg->expanded;
1701 break;
1702 }
1703
1704 if (tokens_ptr == NULL)
1705 /* This can happen for e.g, an empty token argument to a
1706 funtion-like macro. */
1707 return tokens_ptr;
1708
1709 if (virt_location)
1710 {
1711 if (kind == MACRO_ARG_TOKEN_NORMAL)
1712 *virt_location = &arg->virt_locs[index];
1713 else if (kind == MACRO_ARG_TOKEN_EXPANDED)
1714 *virt_location = &arg->expanded_virt_locs[index];
1715 else if (kind == MACRO_ARG_TOKEN_STRINGIFIED)
1716 *virt_location =
1717 (location_t *) &tokens_ptr[index]->src_loc;
1718 }
1719 return &tokens_ptr[index];
1720}
1721
1722/* Initialize an iterator so that it iterates over the tokens of a
1723 function-like macro argument. KIND is the kind of tokens we want
1724 ITER to iterate over. TOKEN_PTR points the first token ITER will
1725 iterate over. */
1726static void
1727macro_arg_token_iter_init (macro_arg_token_iter *iter,
1728 bool track_macro_exp_p,
1729 enum macro_arg_token_kind kind,
1730 const macro_arg *arg,
1731 const cpp_token **token_ptr)
1732{
1733 iter->track_macro_exp_p = track_macro_exp_p;
1734 iter->kind = kind;
1735 iter->token_ptr = token_ptr;
1736 /* Unconditionally initialize this so that the compiler doesn't warn
1737 about iter->location_ptr being possibly uninitialized later after
1738 this code has been inlined somewhere. */
1739 iter->location_ptr = NULL;
1740 if (track_macro_exp_p)
1741 iter->location_ptr = get_arg_token_location (arg, kind);
1742#if CHECKING_P
1743 iter->num_forwards = 0;
1744 if (track_macro_exp_p
1745 && token_ptr != NULL
1746 && iter->location_ptr == NULL)
1747 abort ();
1748#endif
1749}
1750
1751/* Move the iterator one token forward. Note that if IT was
1752 initialized on an argument that has a stringified token, moving it
1753 forward doesn't make sense as a stringified token is essentially one
1754 string. */
1755static void
1756macro_arg_token_iter_forward (macro_arg_token_iter *it)
1757{
1758 switch (it->kind)
1759 {
1760 case MACRO_ARG_TOKEN_NORMAL:
1761 case MACRO_ARG_TOKEN_EXPANDED:
1762 it->token_ptr++;
1763 if (it->track_macro_exp_p)
1764 it->location_ptr++;
1765 break;
1766 case MACRO_ARG_TOKEN_STRINGIFIED:
1767#if CHECKING_P
1768 if (it->num_forwards > 0)
1769 abort ();
1770#endif
1771 break;
1772 }
1773
1774#if CHECKING_P
1775 it->num_forwards++;
1776#endif
1777}
1778
1779/* Return the token pointed to by the iterator. */
1780static const cpp_token *
1781macro_arg_token_iter_get_token (const macro_arg_token_iter *it)
1782{
1783#if CHECKING_P
1784 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1785 && it->num_forwards > 0)
1786 abort ();
1787#endif
1788 if (it->token_ptr == NULL)
1789 return NULL;
1790 return *it->token_ptr;
1791}
1792
1793/* Return the location of the token pointed to by the iterator.*/
1794static location_t
1795macro_arg_token_iter_get_location (const macro_arg_token_iter *it)
1796{
1797#if CHECKING_P
1798 if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
1799 && it->num_forwards > 0)
1800 abort ();
1801#endif
1802 if (it->track_macro_exp_p)
1803 return *it->location_ptr;
1804 else
1805 return (*it->token_ptr)->src_loc;
1806}
1807
1808/* Return the index of a token [resulting from macro expansion] inside
1809 the total list of tokens resulting from a given macro
1810 expansion. The index can be different depending on whether if we
1811 want each tokens resulting from function-like macro arguments
1812 expansion to have a different location or not.
1813
1814 E.g, consider this function-like macro:
1815
1816 #define M(x) x - 3
1817
1818 Then consider us "calling" it (and thus expanding it) like:
1819
1820 M(1+4)
1821
1822 It will be expanded into:
1823
1824 1+4-3
1825
1826 Let's consider the case of the token '4'.
1827
1828 Its index can be 2 (it's the third token of the set of tokens
1829 resulting from the expansion) or it can be 0 if we consider that
1830 all tokens resulting from the expansion of the argument "1+2" have
1831 the same index, which is 0. In this later case, the index of token
1832 '-' would then be 1 and the index of token '3' would be 2.
1833
1834 The later case is useful to use less memory e.g, for the case of
1835 the user using the option -ftrack-macro-expansion=1.
1836
1837 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1838 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1839 parameter (inside the macro replacement list) that corresponds to
1840 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1841 of.
1842
1843 If we refer to the example above, for the '4' argument token,
1844 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1845 would be set to the token 'x', in the replacement list "x - 3" of
1846 macro M.
1847
1848 This is a subroutine of replace_args. */
1849inline static unsigned
1850expanded_token_index (cpp_reader *pfile, cpp_macro *macro,
1851 const cpp_token *cur_replacement_token,
1852 unsigned absolute_token_index)
1853{
1854 if (CPP_OPTION (pfile, track_macro_expansion) > 1)
1855 return absolute_token_index;
1856 return cur_replacement_token - macro->exp.tokens;
1857}
1858
1859/* Copy whether PASTE_LEFT is set from SRC to *PASTE_FLAG. */
1860
1861static void
1862copy_paste_flag (cpp_reader *pfile, const cpp_token **paste_flag,
1863 const cpp_token *src)
1864{
1865 cpp_token *token = _cpp_temp_token (pfile);
1866 token->type = (*paste_flag)->type;
1867 token->val = (*paste_flag)->val;
1868 if (src->flags & PASTE_LEFT)
1869 token->flags = (*paste_flag)->flags | PASTE_LEFT;
1870 else
1871 token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1872 *paste_flag = token;
1873}
1874
1875/* True IFF the last token emitted into BUFF (if any) is PTR. */
1876
1877static bool
1878last_token_is (_cpp_buff *buff, const cpp_token **ptr)
1879{
1880 return (ptr && tokens_buff_last_token_ptr (buff) == ptr);
1881}
1882
1883/* Replace the parameters in a function-like macro of NODE with the
1884 actual ARGS, and place the result in a newly pushed token context.
1885 Expand each argument before replacing, unless it is operated upon
1886 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1887 the expansion point of the macro. E.g, the location of the
1888 function-like macro invocation. */
1889static void
1890replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro,
1891 macro_arg *args, location_t expansion_point_loc)
1892{
1893 unsigned int i, total;
1894 const cpp_token *src, *limit;
1895 const cpp_token **first = NULL;
1896 macro_arg *arg;
1897 _cpp_buff *buff = NULL;
1898 location_t *virt_locs = NULL;
1899 unsigned int exp_count;
1900 const line_map_macro *map = NULL;
1901 int track_macro_exp;
1902
1903 /* First, fully macro-expand arguments, calculating the number of
1904 tokens in the final expansion as we go. The ordering of the if
1905 statements below is subtle; we must handle stringification before
1906 pasting. */
1907
1908 /* EXP_COUNT is the number of tokens in the macro replacement
1909 list. TOTAL is the number of tokens /after/ macro parameters
1910 have been replaced by their arguments. */
1911 exp_count = macro_real_token_count (macro);
1912 total = exp_count;
1913 limit = macro->exp.tokens + exp_count;
1914
1915 for (src = macro->exp.tokens; src < limit; src++)
1916 if (src->type == CPP_MACRO_ARG)
1917 {
1918 /* Leading and trailing padding tokens. */
1919 total += 2;
1920 /* Account for leading and padding tokens in exp_count too.
1921 This is going to be important later down this function,
1922 when we want to handle the case of (track_macro_exp <
1923 2). */
1924 exp_count += 2;
1925
1926 /* We have an argument. If it is not being stringified or
1927 pasted it is macro-replaced before insertion. */
1928 arg = &args[src->val.macro_arg.arg_no - 1];
1929
1930 if (src->flags & STRINGIFY_ARG)
1931 {
1932 if (!arg->stringified)
1933 arg->stringified = stringify_arg (pfile, first: arg->first, count: arg->count);
1934 }
1935 else if ((src->flags & PASTE_LEFT)
1936 || (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
1937 total += arg->count - 1;
1938 else
1939 {
1940 if (!arg->expanded)
1941 expand_arg (pfile, arg);
1942 total += arg->expanded_count - 1;
1943 }
1944 }
1945
1946 /* When the compiler is called with the -ftrack-macro-expansion
1947 flag, we need to keep track of the location of each token that
1948 results from macro expansion.
1949
1950 A token resulting from macro expansion is not a new token. It is
1951 simply the same token as the token coming from the macro
1952 definition. The new things that are allocated are the buffer
1953 that holds the tokens resulting from macro expansion and a new
1954 location that records many things like the locus of the expansion
1955 point as well as the original locus inside the definition of the
1956 macro. This location is called a virtual location.
1957
1958 So the buffer BUFF holds a set of cpp_token*, and the buffer
1959 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1960
1961 Both of these two buffers are going to be hung off of the macro
1962 context, when the latter is pushed. The memory allocated to
1963 store the tokens and their locations is going to be freed once
1964 the context of macro expansion is popped.
1965
1966 As far as tokens are concerned, the memory overhead of
1967 -ftrack-macro-expansion is proportional to the number of
1968 macros that get expanded multiplied by sizeof (location_t).
1969 The good news is that extra memory gets freed when the macro
1970 context is freed, i.e shortly after the macro got expanded. */
1971
1972 /* Is the -ftrack-macro-expansion flag in effect? */
1973 track_macro_exp = CPP_OPTION (pfile, track_macro_expansion);
1974
1975 /* Now allocate memory space for tokens and locations resulting from
1976 the macro expansion, copy the tokens and replace the arguments.
1977 This memory must be freed when the context of the macro MACRO is
1978 popped. */
1979 buff = tokens_buff_new (pfile, total, track_macro_exp ? &virt_locs : NULL);
1980
1981 first = (const cpp_token **) buff->base;
1982
1983 /* Create a macro map to record the locations of the tokens that are
1984 involved in the expansion. Note that the expansion point is set
1985 to the location of the closing parenthesis. Otherwise, the
1986 subsequent map created for the first token that comes after the
1987 macro map might have a wrong line number. That would lead to
1988 tokens with wrong line numbers after the macro expansion. This
1989 adds up to the memory overhead of the -ftrack-macro-expansion
1990 flag; for every macro that is expanded, a "macro map" is
1991 created. */
1992 if (track_macro_exp)
1993 {
1994 int num_macro_tokens = total;
1995 if (track_macro_exp < 2)
1996 /* Then the number of macro tokens won't take in account the
1997 fact that function-like macro arguments can expand to
1998 multiple tokens. This is to save memory at the expense of
1999 accuracy.
2000
2001 Suppose we have #define SQUARE(A) A * A
2002
2003 And then we do SQUARE(2+3)
2004
2005 Then the tokens 2, +, 3, will have the same location,
2006 saying they come from the expansion of the argument A. */
2007 num_macro_tokens = exp_count;
2008 map = linemap_enter_macro (pfile->line_table, node,
2009 expansion_point_loc,
2010 num_macro_tokens);
2011 }
2012 i = 0;
2013 vaopt_state vaopt_tracker (pfile, macro->variadic, &args[macro->paramc - 1]);
2014 const cpp_token **vaopt_start = NULL;
2015 for (src = macro->exp.tokens; src < limit; src++)
2016 {
2017 unsigned int arg_tokens_count;
2018 macro_arg_token_iter from;
2019 const cpp_token **paste_flag = NULL;
2020 const cpp_token **tmp_token_ptr;
2021
2022 /* __VA_OPT__ handling. */
2023 vaopt_state::update_type vostate = vaopt_tracker.update (token: src);
2024 if (__builtin_expect (vostate != vaopt_state::INCLUDE, false))
2025 {
2026 if (vostate == vaopt_state::BEGIN)
2027 {
2028 /* Padding on the left of __VA_OPT__ (unless RHS of ##). */
2029 if (src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
2030 {
2031 const cpp_token *t = padding_token (pfile, src);
2032 unsigned index = expanded_token_index (pfile, macro, cur_replacement_token: src, absolute_token_index: i);
2033 /* Allocate a virtual location for the padding token and
2034 append the token and its location to BUFF and
2035 VIRT_LOCS. */
2036 tokens_buff_add_token (buff, virt_locs, t,
2037 t->src_loc, t->src_loc,
2038 map, index);
2039 }
2040 vaopt_start = tokens_buff_last_token_ptr (buff);
2041 }
2042 else if (vostate == vaopt_state::END)
2043 {
2044 const cpp_token **start = vaopt_start;
2045 vaopt_start = NULL;
2046
2047 paste_flag = tokens_buff_last_token_ptr (buff);
2048
2049 if (vaopt_tracker.stringify ())
2050 {
2051 unsigned int count
2052 = start ? paste_flag - start : tokens_buff_count (buff);
2053 const cpp_token **first
2054 = start ? start + 1
2055 : (const cpp_token **) (buff->base);
2056 unsigned int i, j;
2057
2058 /* Paste any tokens that need to be pasted before calling
2059 stringify_arg, because stringify_arg uses pfile->u_buff
2060 which paste_tokens can use as well. */
2061 for (i = 0, j = 0; i < count; i++, j++)
2062 {
2063 const cpp_token *token = first[i];
2064
2065 if (token->flags & PASTE_LEFT)
2066 {
2067 location_t virt_loc = pfile->invocation_location;
2068 const cpp_token *rhs;
2069 do
2070 {
2071 if (i == count)
2072 abort ();
2073 rhs = first[++i];
2074 if (!paste_tokens (pfile, location: virt_loc, plhs: &token, rhs))
2075 {
2076 --i;
2077 break;
2078 }
2079 }
2080 while (rhs->flags & PASTE_LEFT);
2081 }
2082
2083 first[j] = token;
2084 }
2085 if (j != i)
2086 {
2087 while (i-- != j)
2088 tokens_buff_remove_last_token (buff);
2089 count = j;
2090 }
2091
2092 const cpp_token *t = stringify_arg (pfile, first, count);
2093 while (count--)
2094 tokens_buff_remove_last_token (buff);
2095 if (src->flags & PASTE_LEFT)
2096 copy_paste_flag (pfile, paste_flag: &t, src);
2097 tokens_buff_add_token (buff, virt_locs,
2098 t, t->src_loc, t->src_loc,
2099 NULL, 0);
2100 continue;
2101 }
2102 if (start && paste_flag == start && (*start)->flags & PASTE_LEFT)
2103 /* If __VA_OPT__ expands to nothing (either because __VA_ARGS__
2104 is empty or because it is __VA_OPT__() ), drop PASTE_LEFT
2105 flag from previous token. */
2106 copy_paste_flag (pfile, paste_flag: start, src: &pfile->avoid_paste);
2107 if (src->flags & PASTE_LEFT)
2108 {
2109 /* Don't avoid paste after all. */
2110 while (paste_flag && paste_flag != start
2111 && *paste_flag == &pfile->avoid_paste)
2112 {
2113 tokens_buff_remove_last_token (buff);
2114 paste_flag = tokens_buff_last_token_ptr (buff);
2115 }
2116
2117 /* With a non-empty __VA_OPT__ on the LHS of ##, the last
2118 token should be flagged PASTE_LEFT. */
2119 if (paste_flag && (*paste_flag)->type != CPP_PADDING)
2120 copy_paste_flag (pfile, paste_flag, src);
2121 }
2122 else
2123 {
2124 /* Otherwise, avoid paste on RHS, __VA_OPT__(c)d or
2125 __VA_OPT__(c)__VA_OPT__(d). */
2126 const cpp_token *t = &pfile->avoid_paste;
2127 tokens_buff_add_token (buff, virt_locs,
2128 t, t->src_loc, t->src_loc,
2129 NULL, 0);
2130 }
2131 }
2132 continue;
2133 }
2134
2135 if (src->type != CPP_MACRO_ARG)
2136 {
2137 /* Allocate a virtual location for token SRC, and add that
2138 token and its virtual location into the buffers BUFF and
2139 VIRT_LOCS. */
2140 unsigned index = expanded_token_index (pfile, macro, cur_replacement_token: src, absolute_token_index: i);
2141 tokens_buff_add_token (buff, virt_locs, src,
2142 src->src_loc, src->src_loc,
2143 map, index);
2144 i += 1;
2145 continue;
2146 }
2147
2148 paste_flag = 0;
2149 arg = &args[src->val.macro_arg.arg_no - 1];
2150 /* SRC is a macro parameter that we need to replace with its
2151 corresponding argument. So at some point we'll need to
2152 iterate over the tokens of the macro argument and copy them
2153 into the "place" now holding the correspondig macro
2154 parameter. We are going to use the iterator type
2155 macro_argo_token_iter to handle that iterating. The 'if'
2156 below is to initialize the iterator depending on the type of
2157 tokens the macro argument has. It also does some adjustment
2158 related to padding tokens and some pasting corner cases. */
2159 if (src->flags & STRINGIFY_ARG)
2160 {
2161 arg_tokens_count = 1;
2162 macro_arg_token_iter_init (iter: &from,
2163 CPP_OPTION (pfile,
2164 track_macro_expansion),
2165 kind: MACRO_ARG_TOKEN_STRINGIFIED,
2166 arg, token_ptr: &arg->stringified);
2167 }
2168 else if (src->flags & PASTE_LEFT)
2169 {
2170 arg_tokens_count = arg->count;
2171 macro_arg_token_iter_init (iter: &from,
2172 CPP_OPTION (pfile,
2173 track_macro_expansion),
2174 kind: MACRO_ARG_TOKEN_NORMAL,
2175 arg, token_ptr: arg->first);
2176 }
2177 else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
2178 {
2179 int num_toks;
2180 arg_tokens_count = arg->count;
2181 macro_arg_token_iter_init (iter: &from,
2182 CPP_OPTION (pfile,
2183 track_macro_expansion),
2184 kind: MACRO_ARG_TOKEN_NORMAL,
2185 arg, token_ptr: arg->first);
2186
2187 num_toks = tokens_buff_count (buff);
2188
2189 if (num_toks != 0)
2190 {
2191 /* So the current parameter token is pasted to the previous
2192 token in the replacement list. Let's look at what
2193 we have as previous and current arguments. */
2194
2195 /* This is the previous argument's token ... */
2196 tmp_token_ptr = tokens_buff_last_token_ptr (buff);
2197
2198 if ((*tmp_token_ptr)->type == CPP_COMMA
2199 && macro->variadic
2200 && src->val.macro_arg.arg_no == macro->paramc)
2201 {
2202 /* ... which is a comma; and the current parameter
2203 is the last parameter of a variadic function-like
2204 macro. If the argument to the current last
2205 parameter is NULL, then swallow the comma,
2206 otherwise drop the paste flag. */
2207 if (macro_arg_token_iter_get_token (it: &from) == NULL)
2208 tokens_buff_remove_last_token (buff);
2209 else
2210 paste_flag = tmp_token_ptr;
2211 }
2212 /* Remove the paste flag if the RHS is a placemarker. */
2213 else if (arg_tokens_count == 0)
2214 paste_flag = tmp_token_ptr;
2215 }
2216 }
2217 else
2218 {
2219 arg_tokens_count = arg->expanded_count;
2220 macro_arg_token_iter_init (iter: &from,
2221 CPP_OPTION (pfile,
2222 track_macro_expansion),
2223 kind: MACRO_ARG_TOKEN_EXPANDED,
2224 arg, token_ptr: arg->expanded);
2225
2226 if (last_token_is (buff, ptr: vaopt_start))
2227 {
2228 /* We're expanding an arg at the beginning of __VA_OPT__.
2229 Skip padding. */
2230 while (arg_tokens_count)
2231 {
2232 const cpp_token *t = macro_arg_token_iter_get_token (it: &from);
2233 if (t->type != CPP_PADDING)
2234 break;
2235 macro_arg_token_iter_forward (it: &from);
2236 --arg_tokens_count;
2237 }
2238 }
2239 }
2240
2241 /* Padding on the left of an argument (unless RHS of ##). */
2242 if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
2243 && src != macro->exp.tokens
2244 && !(src[-1].flags & PASTE_LEFT)
2245 && !last_token_is (buff, ptr: vaopt_start))
2246 {
2247 const cpp_token *t = padding_token (pfile, src);
2248 unsigned index = expanded_token_index (pfile, macro, cur_replacement_token: src, absolute_token_index: i);
2249 /* Allocate a virtual location for the padding token and
2250 append the token and its location to BUFF and
2251 VIRT_LOCS. */
2252 tokens_buff_add_token (buff, virt_locs, t,
2253 t->src_loc, t->src_loc,
2254 map, index);
2255 }
2256
2257 if (arg_tokens_count)
2258 {
2259 /* So now we've got the number of tokens that make up the
2260 argument that is going to replace the current parameter
2261 in the macro's replacement list. */
2262 unsigned int j;
2263 for (j = 0; j < arg_tokens_count; ++j)
2264 {
2265 /* So if track_macro_exp is < 2, the user wants to
2266 save extra memory while tracking macro expansion
2267 locations. So in that case here is what we do:
2268
2269 Suppose we have #define SQUARE(A) A * A
2270
2271 And then we do SQUARE(2+3)
2272
2273 Then the tokens 2, +, 3, will have the same location,
2274 saying they come from the expansion of the argument
2275 A.
2276
2277 So that means we are going to ignore the COUNT tokens
2278 resulting from the expansion of the current macro
2279 argument. In other words all the ARG_TOKENS_COUNT tokens
2280 resulting from the expansion of the macro argument will
2281 have the index I. Normally, each of those tokens should
2282 have index I+J. */
2283 unsigned token_index = i;
2284 unsigned index;
2285 if (track_macro_exp > 1)
2286 token_index += j;
2287
2288 index = expanded_token_index (pfile, macro, cur_replacement_token: src, absolute_token_index: token_index);
2289 const cpp_token *tok = macro_arg_token_iter_get_token (it: &from);
2290 tokens_buff_add_token (buff, virt_locs, tok,
2291 macro_arg_token_iter_get_location (it: &from),
2292 src->src_loc, map, index);
2293 macro_arg_token_iter_forward (it: &from);
2294 }
2295
2296 /* With a non-empty argument on the LHS of ##, the last
2297 token should be flagged PASTE_LEFT. */
2298 if (src->flags & PASTE_LEFT)
2299 paste_flag
2300 = (const cpp_token **) tokens_buff_last_token_ptr (buff);
2301 }
2302 else if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, c99)
2303 && ! macro->syshdr && ! _cpp_in_system_header (pfile))
2304 {
2305 if (CPP_OPTION (pfile, cplusplus))
2306 cpp_pedwarning (pfile, CPP_W_PEDANTIC,
2307 msgid: "invoking macro %s argument %d: "
2308 "empty macro arguments are undefined"
2309 " in ISO C++98",
2310 NODE_NAME (node), src->val.macro_arg.arg_no);
2311 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat))
2312 cpp_pedwarning (pfile,
2313 CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
2314 ? CPP_W_C90_C99_COMPAT : CPP_W_PEDANTIC,
2315 msgid: "invoking macro %s argument %d: "
2316 "empty macro arguments are undefined"
2317 " in ISO C90",
2318 NODE_NAME (node), src->val.macro_arg.arg_no);
2319 }
2320 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
2321 && ! CPP_OPTION (pfile, cplusplus)
2322 && ! macro->syshdr && ! _cpp_in_system_header (pfile))
2323 cpp_warning (pfile, CPP_W_C90_C99_COMPAT,
2324 msgid: "invoking macro %s argument %d: "
2325 "empty macro arguments are undefined"
2326 " in ISO C90",
2327 NODE_NAME (node), src->val.macro_arg.arg_no);
2328
2329 /* Avoid paste on RHS (even case count == 0). */
2330 if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
2331 {
2332 const cpp_token *t = &pfile->avoid_paste;
2333 tokens_buff_add_token (buff, virt_locs,
2334 t, t->src_loc, t->src_loc,
2335 NULL, 0);
2336 }
2337
2338 /* Add a new paste flag, or remove an unwanted one. */
2339 if (paste_flag)
2340 copy_paste_flag (pfile, paste_flag, src);
2341
2342 i += arg_tokens_count;
2343 }
2344
2345 if (track_macro_exp)
2346 push_extended_tokens_context (pfile, node, buff, virt_locs, first,
2347 tokens_buff_count (buff));
2348 else
2349 push_ptoken_context (pfile, node, buff, first,
2350 tokens_buff_count (buff));
2351
2352 num_macro_tokens_counter += tokens_buff_count (buff);
2353}
2354
2355/* Return a special padding token, with padding inherited from SOURCE. */
2356static const cpp_token *
2357padding_token (cpp_reader *pfile, const cpp_token *source)
2358{
2359 cpp_token *result = _cpp_temp_token (pfile);
2360
2361 result->type = CPP_PADDING;
2362
2363 /* Data in GCed data structures cannot be made const so far, so we
2364 need a cast here. */
2365 result->val.source = (cpp_token *) source;
2366 result->flags = 0;
2367 return result;
2368}
2369
2370/* Get a new uninitialized context. Create a new one if we cannot
2371 re-use an old one. */
2372static cpp_context *
2373next_context (cpp_reader *pfile)
2374{
2375 cpp_context *result = pfile->context->next;
2376
2377 if (result == 0)
2378 {
2379 result = XNEW (cpp_context);
2380 memset (s: result, c: 0, n: sizeof (cpp_context));
2381 result->prev = pfile->context;
2382 result->next = 0;
2383 pfile->context->next = result;
2384 }
2385
2386 pfile->context = result;
2387 return result;
2388}
2389
2390/* Push a list of pointers to tokens. */
2391static void
2392push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
2393 const cpp_token **first, unsigned int count)
2394{
2395 cpp_context *context = next_context (pfile);
2396
2397 context->tokens_kind = TOKENS_KIND_INDIRECT;
2398 context->c.macro = macro;
2399 context->buff = buff;
2400 FIRST (context).ptoken = first;
2401 LAST (context).ptoken = first + count;
2402}
2403
2404/* Push a list of tokens.
2405
2406 A NULL macro means that we should continue the current macro
2407 expansion, in essence. That means that if we are currently in a
2408 macro expansion context, we'll make the new pfile->context refer to
2409 the current macro. */
2410void
2411_cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
2412 const cpp_token *first, unsigned int count)
2413{
2414 cpp_context *context;
2415
2416 if (macro == NULL)
2417 macro = macro_of_context (context: pfile->context);
2418
2419 context = next_context (pfile);
2420 context->tokens_kind = TOKENS_KIND_DIRECT;
2421 context->c.macro = macro;
2422 context->buff = NULL;
2423 FIRST (context).token = first;
2424 LAST (context).token = first + count;
2425}
2426
2427/* Build a context containing a list of tokens as well as their
2428 virtual locations and push it. TOKENS_BUFF is the buffer that
2429 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
2430 non-NULL, it means that the context owns it, meaning that
2431 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
2432 contains the virtual locations.
2433
2434 A NULL macro means that we should continue the current macro
2435 expansion, in essence. That means that if we are currently in a
2436 macro expansion context, we'll make the new pfile->context refer to
2437 the current macro. */
2438static void
2439push_extended_tokens_context (cpp_reader *pfile,
2440 cpp_hashnode *macro,
2441 _cpp_buff *token_buff,
2442 location_t *virt_locs,
2443 const cpp_token **first,
2444 unsigned int count)
2445{
2446 cpp_context *context;
2447 macro_context *m;
2448
2449 if (macro == NULL)
2450 macro = macro_of_context (context: pfile->context);
2451
2452 context = next_context (pfile);
2453 context->tokens_kind = TOKENS_KIND_EXTENDED;
2454 context->buff = token_buff;
2455
2456 m = XNEW (macro_context);
2457 m->macro_node = macro;
2458 m->virt_locs = virt_locs;
2459 m->cur_virt_loc = virt_locs;
2460 context->c.mc = m;
2461 FIRST (context).ptoken = first;
2462 LAST (context).ptoken = first + count;
2463}
2464
2465/* Push a traditional macro's replacement text. */
2466void
2467_cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
2468 const uchar *start, size_t len)
2469{
2470 cpp_context *context = next_context (pfile);
2471
2472 context->tokens_kind = TOKENS_KIND_DIRECT;
2473 context->c.macro = macro;
2474 context->buff = NULL;
2475 CUR (context) = start;
2476 RLIMIT (context) = start + len;
2477 macro->flags |= NODE_DISABLED;
2478}
2479
2480/* Creates a buffer that holds tokens a.k.a "token buffer", usually
2481 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
2482 non-null (which means that -ftrack-macro-expansion is on),
2483 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
2484 hold the virtual locations of the tokens resulting from macro
2485 expansion. */
2486static _cpp_buff*
2487tokens_buff_new (cpp_reader *pfile, size_t len,
2488 location_t **virt_locs)
2489{
2490 size_t tokens_size = len * sizeof (cpp_token *);
2491 size_t locs_size = len * sizeof (location_t);
2492
2493 if (virt_locs != NULL)
2494 *virt_locs = XNEWVEC (location_t, locs_size);
2495 return _cpp_get_buff (pfile, tokens_size);
2496}
2497
2498/* Returns the number of tokens contained in a token buffer. The
2499 buffer holds a set of cpp_token*. */
2500static size_t
2501tokens_buff_count (_cpp_buff *buff)
2502{
2503 return (BUFF_FRONT (buff) - buff->base) / sizeof (cpp_token *);
2504}
2505
2506/* Return a pointer to the last token contained in the token buffer
2507 BUFF. */
2508static const cpp_token **
2509tokens_buff_last_token_ptr (_cpp_buff *buff)
2510{
2511 if (BUFF_FRONT (buff) == buff->base)
2512 return NULL;
2513 return &((const cpp_token **) BUFF_FRONT (buff))[-1];
2514}
2515
2516/* Remove the last token contained in the token buffer TOKENS_BUFF.
2517 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
2518 containing the virtual locations of the tokens in TOKENS_BUFF; in
2519 which case the function updates that buffer as well. */
2520static inline void
2521tokens_buff_remove_last_token (_cpp_buff *tokens_buff)
2522
2523{
2524 if (BUFF_FRONT (tokens_buff) > tokens_buff->base)
2525 BUFF_FRONT (tokens_buff) =
2526 (unsigned char *) &((cpp_token **) BUFF_FRONT (tokens_buff))[-1];
2527}
2528
2529/* Insert a token into the token buffer at the position pointed to by
2530 DEST. Note that the buffer is not enlarged so the previous token
2531 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
2532 means -ftrack-macro-expansion is effect; it then points to where to
2533 insert the virtual location of TOKEN. TOKEN is the token to
2534 insert. VIRT_LOC is the virtual location of the token, i.e, the
2535 location possibly encoding its locus across macro expansion. If
2536 TOKEN is an argument of a function-like macro (inside a macro
2537 replacement list), PARM_DEF_LOC is the spelling location of the
2538 macro parameter that TOKEN is replacing, in the replacement list of
2539 the macro. If TOKEN is not an argument of a function-like macro or
2540 if it doesn't come from a macro expansion, then VIRT_LOC can just
2541 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
2542 means TOKEN comes from a macro expansion and MAP is the macro map
2543 associated to the macro. MACRO_TOKEN_INDEX points to the index of
2544 the token in the macro map; it is not considered if MAP is NULL.
2545
2546 Upon successful completion this function returns the a pointer to
2547 the position of the token coming right after the insertion
2548 point. */
2549static inline const cpp_token **
2550tokens_buff_put_token_to (const cpp_token **dest,
2551 location_t *virt_loc_dest,
2552 const cpp_token *token,
2553 location_t virt_loc,
2554 location_t parm_def_loc,
2555 const line_map_macro *map,
2556 unsigned int macro_token_index)
2557{
2558 location_t macro_loc = virt_loc;
2559 const cpp_token **result;
2560
2561 if (virt_loc_dest)
2562 {
2563 /* -ftrack-macro-expansion is on. */
2564 if (map)
2565 macro_loc = linemap_add_macro_token (map, macro_token_index,
2566 virt_loc, parm_def_loc);
2567 *virt_loc_dest = macro_loc;
2568 }
2569 *dest = token;
2570 result = &dest[1];
2571
2572 return result;
2573}
2574
2575/* Adds a token at the end of the tokens contained in BUFFER. Note
2576 that this function doesn't enlarge BUFFER when the number of tokens
2577 reaches BUFFER's size; it aborts in that situation.
2578
2579 TOKEN is the token to append. VIRT_LOC is the virtual location of
2580 the token, i.e, the location possibly encoding its locus across
2581 macro expansion. If TOKEN is an argument of a function-like macro
2582 (inside a macro replacement list), PARM_DEF_LOC is the location of
2583 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
2584 from a macro expansion, then VIRT_LOC can just be set to the same
2585 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
2586 from a macro expansion and MAP is the macro map associated to the
2587 macro. MACRO_TOKEN_INDEX points to the index of the token in the
2588 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
2589 non-null, it means -ftrack-macro-expansion is on; in which case
2590 this function adds the virtual location DEF_LOC to the VIRT_LOCS
2591 array, at the same index as the one of TOKEN in BUFFER. Upon
2592 successful completion this function returns the a pointer to the
2593 position of the token coming right after the insertion point. */
2594static const cpp_token **
2595tokens_buff_add_token (_cpp_buff *buffer,
2596 location_t *virt_locs,
2597 const cpp_token *token,
2598 location_t virt_loc,
2599 location_t parm_def_loc,
2600 const line_map_macro *map,
2601 unsigned int macro_token_index)
2602{
2603 const cpp_token **result;
2604 location_t *virt_loc_dest = NULL;
2605 unsigned token_index =
2606 (BUFF_FRONT (buffer) - buffer->base) / sizeof (cpp_token *);
2607
2608 /* Abort if we pass the end the buffer. */
2609 if (BUFF_FRONT (buffer) > BUFF_LIMIT (buffer))
2610 abort ();
2611
2612 if (virt_locs != NULL)
2613 virt_loc_dest = &virt_locs[token_index];
2614
2615 result =
2616 tokens_buff_put_token_to (dest: (const cpp_token **) BUFF_FRONT (buffer),
2617 virt_loc_dest, token, virt_loc, parm_def_loc,
2618 map, macro_token_index);
2619
2620 BUFF_FRONT (buffer) = (unsigned char *) result;
2621 return result;
2622}
2623
2624/* Allocate space for the function-like macro argument ARG to store
2625 the tokens resulting from the macro-expansion of the tokens that
2626 make up ARG itself. That space is allocated in ARG->expanded and
2627 needs to be freed using free. */
2628static void
2629alloc_expanded_arg_mem (cpp_reader *pfile, macro_arg *arg, size_t capacity)
2630{
2631 gcc_checking_assert (arg->expanded == NULL
2632 && arg->expanded_virt_locs == NULL);
2633
2634 arg->expanded = XNEWVEC (const cpp_token *, capacity);
2635 if (CPP_OPTION (pfile, track_macro_expansion))
2636 arg->expanded_virt_locs = XNEWVEC (location_t, capacity);
2637
2638}
2639
2640/* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2641 tokens. */
2642static void
2643ensure_expanded_arg_room (cpp_reader *pfile, macro_arg *arg,
2644 size_t size, size_t *expanded_capacity)
2645{
2646 if (size <= *expanded_capacity)
2647 return;
2648
2649 size *= 2;
2650
2651 arg->expanded =
2652 XRESIZEVEC (const cpp_token *, arg->expanded, size);
2653 *expanded_capacity = size;
2654
2655 if (CPP_OPTION (pfile, track_macro_expansion))
2656 {
2657 if (arg->expanded_virt_locs == NULL)
2658 arg->expanded_virt_locs = XNEWVEC (location_t, size);
2659 else
2660 arg->expanded_virt_locs = XRESIZEVEC (location_t,
2661 arg->expanded_virt_locs,
2662 size);
2663 }
2664}
2665
2666/* Expand an argument ARG before replacing parameters in a
2667 function-like macro. This works by pushing a context with the
2668 argument's tokens, and then expanding that into a temporary buffer
2669 as if it were a normal part of the token stream. collect_args()
2670 has terminated the argument's tokens with a CPP_EOF so that we know
2671 when we have fully expanded the argument. */
2672static void
2673expand_arg (cpp_reader *pfile, macro_arg *arg)
2674{
2675 size_t capacity;
2676 bool saved_warn_trad;
2677 bool track_macro_exp_p = CPP_OPTION (pfile, track_macro_expansion);
2678 bool saved_ignore__Pragma;
2679
2680 if (arg->count == 0
2681 || arg->expanded != NULL)
2682 return;
2683
2684 /* Don't warn about funlike macros when pre-expanding. */
2685 saved_warn_trad = CPP_WTRADITIONAL (pfile);
2686 CPP_WTRADITIONAL (pfile) = 0;
2687
2688 /* Loop, reading in the tokens of the argument. */
2689 capacity = 256;
2690 alloc_expanded_arg_mem (pfile, arg, capacity);
2691
2692 if (track_macro_exp_p)
2693 push_extended_tokens_context (pfile, NULL, NULL,
2694 virt_locs: arg->virt_locs,
2695 first: arg->first,
2696 count: arg->count + 1);
2697 else
2698 push_ptoken_context (pfile, NULL, NULL,
2699 first: arg->first, count: arg->count + 1);
2700
2701 saved_ignore__Pragma = pfile->state.ignore__Pragma;
2702 pfile->state.ignore__Pragma = 1;
2703
2704 for (;;)
2705 {
2706 const cpp_token *token;
2707 location_t location;
2708
2709 ensure_expanded_arg_room (pfile, arg, size: arg->expanded_count + 1,
2710 expanded_capacity: &capacity);
2711
2712 token = cpp_get_token_1 (pfile, &location);
2713
2714 if (token->type == CPP_EOF)
2715 break;
2716
2717 set_arg_token (arg, token, location,
2718 index: arg->expanded_count, kind: MACRO_ARG_TOKEN_EXPANDED,
2719 CPP_OPTION (pfile, track_macro_expansion));
2720 arg->expanded_count++;
2721 }
2722
2723 _cpp_pop_context (pfile);
2724
2725 CPP_WTRADITIONAL (pfile) = saved_warn_trad;
2726 pfile->state.ignore__Pragma = saved_ignore__Pragma;
2727}
2728
2729/* Returns the macro associated to the current context if we are in
2730 the context a macro expansion, NULL otherwise. */
2731static cpp_hashnode*
2732macro_of_context (cpp_context *context)
2733{
2734 if (context == NULL)
2735 return NULL;
2736
2737 return (context->tokens_kind == TOKENS_KIND_EXTENDED)
2738 ? context->c.mc->macro_node
2739 : context->c.macro;
2740}
2741
2742/* Return TRUE iff we are expanding a macro or are about to start
2743 expanding one. If we are effectively expanding a macro, the
2744 function macro_of_context returns a pointer to the macro being
2745 expanded. */
2746static bool
2747in_macro_expansion_p (cpp_reader *pfile)
2748{
2749 if (pfile == NULL)
2750 return false;
2751
2752 return (pfile->about_to_expand_macro_p
2753 || macro_of_context (context: pfile->context));
2754}
2755
2756/* Pop the current context off the stack, re-enabling the macro if the
2757 context represented a macro's replacement list. Initially the
2758 context structure was not freed so that we can re-use it later, but
2759 now we do free it to reduce peak memory consumption. */
2760void
2761_cpp_pop_context (cpp_reader *pfile)
2762{
2763 cpp_context *context = pfile->context;
2764
2765 /* We should not be popping the base context. */
2766 gcc_assert (context != &pfile->base_context);
2767
2768 if (context->c.macro)
2769 {
2770 cpp_hashnode *macro;
2771 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
2772 {
2773 macro_context *mc = context->c.mc;
2774 macro = mc->macro_node;
2775 /* If context->buff is set, it means the life time of tokens
2776 is bound to the life time of this context; so we must
2777 free the tokens; that means we must free the virtual
2778 locations of these tokens too. */
2779 if (context->buff && mc->virt_locs)
2780 {
2781 free (ptr: mc->virt_locs);
2782 mc->virt_locs = NULL;
2783 }
2784 free (ptr: mc);
2785 context->c.mc = NULL;
2786 }
2787 else
2788 macro = context->c.macro;
2789
2790 /* Beware that MACRO can be NULL in cases like when we are
2791 called from expand_arg. In those cases, a dummy context with
2792 tokens is pushed just for the purpose of walking them using
2793 cpp_get_token_1. In that case, no 'macro' field is set into
2794 the dummy context. */
2795 if (macro != NULL
2796 /* Several contiguous macro expansion contexts can be
2797 associated to the same macro; that means it's the same
2798 macro expansion that spans across all these (sub)
2799 contexts. So we should re-enable an expansion-disabled
2800 macro only when we are sure we are really out of that
2801 macro expansion. */
2802 && macro_of_context (context: context->prev) != macro)
2803 macro->flags &= ~NODE_DISABLED;
2804
2805 if (macro == pfile->top_most_macro_node && context->prev == NULL)
2806 /* We are popping the context of the top-most macro node. */
2807 pfile->top_most_macro_node = NULL;
2808 }
2809
2810 if (context->buff)
2811 {
2812 /* Decrease memory peak consumption by freeing the memory used
2813 by the context. */
2814 _cpp_free_buff (context->buff);
2815 }
2816
2817 pfile->context = context->prev;
2818 /* decrease peak memory consumption by feeing the context. */
2819 pfile->context->next = NULL;
2820 free (ptr: context);
2821}
2822
2823/* Return TRUE if we reached the end of the set of tokens stored in
2824 CONTEXT, FALSE otherwise. */
2825static inline bool
2826reached_end_of_context (cpp_context *context)
2827{
2828 if (context->tokens_kind == TOKENS_KIND_DIRECT)
2829 return FIRST (context).token == LAST (context).token;
2830 else if (context->tokens_kind == TOKENS_KIND_INDIRECT
2831 || context->tokens_kind == TOKENS_KIND_EXTENDED)
2832 return FIRST (context).ptoken == LAST (context).ptoken;
2833 else
2834 abort ();
2835}
2836
2837/* Consume the next token contained in the current context of PFILE,
2838 and return it in *TOKEN. It's "full location" is returned in
2839 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2840 means the location encoding the locus of the token across macro
2841 expansion; otherwise it's just is the "normal" location of the
2842 token which (*TOKEN)->src_loc. */
2843static inline void
2844consume_next_token_from_context (cpp_reader *pfile,
2845 const cpp_token ** token,
2846 location_t *location)
2847{
2848 cpp_context *c = pfile->context;
2849
2850 if ((c)->tokens_kind == TOKENS_KIND_DIRECT)
2851 {
2852 *token = FIRST (c).token;
2853 *location = (*token)->src_loc;
2854 FIRST (c).token++;
2855 }
2856 else if ((c)->tokens_kind == TOKENS_KIND_INDIRECT)
2857 {
2858 *token = *FIRST (c).ptoken;
2859 *location = (*token)->src_loc;
2860 FIRST (c).ptoken++;
2861 }
2862 else if ((c)->tokens_kind == TOKENS_KIND_EXTENDED)
2863 {
2864 macro_context *m = c->c.mc;
2865 *token = *FIRST (c).ptoken;
2866 if (m->virt_locs)
2867 {
2868 *location = *m->cur_virt_loc;
2869 m->cur_virt_loc++;
2870 }
2871 else
2872 *location = (*token)->src_loc;
2873 FIRST (c).ptoken++;
2874 }
2875 else
2876 abort ();
2877}
2878
2879/* In the traditional mode of the preprocessor, if we are currently in
2880 a directive, the location of a token must be the location of the
2881 start of the directive line. This function returns the proper
2882 location if we are in the traditional mode, and just returns
2883 LOCATION otherwise. */
2884
2885static inline location_t
2886maybe_adjust_loc_for_trad_cpp (cpp_reader *pfile, location_t location)
2887{
2888 if (CPP_OPTION (pfile, traditional))
2889 {
2890 if (pfile->state.in_directive)
2891 return pfile->directive_line;
2892 }
2893 return location;
2894}
2895
2896/* Routine to get a token as well as its location.
2897
2898 Macro expansions and directives are transparently handled,
2899 including entering included files. Thus tokens are post-macro
2900 expansion, and after any intervening directives. External callers
2901 see CPP_EOF only at EOF. Internal callers also see it when meeting
2902 a directive inside a macro call, when at the end of a directive and
2903 state.in_directive is still 1, and at the end of argument
2904 pre-expansion.
2905
2906 LOC is an out parameter; *LOC is set to the location "as expected
2907 by the user". Please read the comment of
2908 cpp_get_token_with_location to learn more about the meaning of this
2909 location. */
2910static const cpp_token*
2911cpp_get_token_1 (cpp_reader *pfile, location_t *location)
2912{
2913 const cpp_token *result;
2914 /* This token is a virtual token that either encodes a location
2915 related to macro expansion or a spelling location. */
2916 location_t virt_loc = 0;
2917 /* pfile->about_to_expand_macro_p can be overriden by indirect calls
2918 to functions that push macro contexts. So let's save it so that
2919 we can restore it when we are about to leave this routine. */
2920 bool saved_about_to_expand_macro = pfile->about_to_expand_macro_p;
2921
2922 for (;;)
2923 {
2924 cpp_hashnode *node;
2925 cpp_context *context = pfile->context;
2926
2927 /* Context->prev == 0 <=> base context. */
2928 if (!context->prev)
2929 {
2930 result = _cpp_lex_token (pfile);
2931 virt_loc = result->src_loc;
2932 }
2933 else if (!reached_end_of_context (context))
2934 {
2935 consume_next_token_from_context (pfile, token: &result,
2936 location: &virt_loc);
2937 if (result->flags & PASTE_LEFT)
2938 {
2939 paste_all_tokens (pfile, lhs: result);
2940 if (pfile->state.in_directive)
2941 continue;
2942 result = padding_token (pfile, source: result);
2943 goto out;
2944 }
2945 }
2946 else
2947 {
2948 if (pfile->context->c.macro)
2949 ++num_expanded_macros_counter;
2950 _cpp_pop_context (pfile);
2951 if (pfile->state.in_directive)
2952 continue;
2953 result = &pfile->avoid_paste;
2954 goto out;
2955 }
2956
2957 if (pfile->state.in_directive && result->type == CPP_COMMENT)
2958 continue;
2959
2960 if (result->type != CPP_NAME)
2961 break;
2962
2963 node = result->val.node.node;
2964
2965 if (node->type == NT_VOID || (result->flags & NO_EXPAND))
2966 break;
2967
2968 if (!(node->flags & NODE_USED)
2969 && node->type == NT_USER_MACRO
2970 && !node->value.macro
2971 && !cpp_get_deferred_macro (pfile, node, result->src_loc))
2972 break;
2973
2974 if (!(node->flags & NODE_DISABLED))
2975 {
2976 int ret = 0;
2977 /* If not in a macro context, and we're going to start an
2978 expansion, record the location and the top level macro
2979 about to be expanded. */
2980 if (!in_macro_expansion_p (pfile))
2981 {
2982 pfile->invocation_location = result->src_loc;
2983 pfile->top_most_macro_node = node;
2984 }
2985 if (pfile->state.prevent_expansion)
2986 break;
2987
2988 /* Conditional macros require that a predicate be evaluated
2989 first. */
2990 if ((node->flags & NODE_CONDITIONAL) != 0)
2991 {
2992 if (pfile->cb.macro_to_expand)
2993 {
2994 bool whitespace_after;
2995 const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
2996
2997 whitespace_after = (peek_tok->type == CPP_PADDING
2998 || (peek_tok->flags & PREV_WHITE));
2999 node = pfile->cb.macro_to_expand (pfile, result);
3000 if (node)
3001 ret = enter_macro_context (pfile, node, result, location: virt_loc);
3002 else if (whitespace_after)
3003 {
3004 /* If macro_to_expand hook returned NULL and it
3005 ate some tokens, see if we don't need to add
3006 a padding token in between this and the
3007 next token. */
3008 peek_tok = cpp_peek_token (pfile, 0);
3009 if (peek_tok->type != CPP_PADDING
3010 && (peek_tok->flags & PREV_WHITE) == 0)
3011 _cpp_push_token_context (pfile, NULL,
3012 first: padding_token (pfile,
3013 source: peek_tok), count: 1);
3014 }
3015 }
3016 }
3017 else
3018 ret = enter_macro_context (pfile, node, result, location: virt_loc);
3019 if (ret)
3020 {
3021 if (pfile->state.in_directive || ret == 2)
3022 continue;
3023 result = padding_token (pfile, source: result);
3024 goto out;
3025 }
3026 }
3027 else
3028 {
3029 /* Flag this token as always unexpandable. FIXME: move this
3030 to collect_args()?. */
3031 cpp_token *t = _cpp_temp_token (pfile);
3032 t->type = result->type;
3033 t->flags = result->flags | NO_EXPAND;
3034 t->val = result->val;
3035 result = t;
3036 }
3037
3038 break;
3039 }
3040
3041 out:
3042 if (location != NULL)
3043 {
3044 if (virt_loc == 0)
3045 virt_loc = result->src_loc;
3046 *location = virt_loc;
3047
3048 if (!CPP_OPTION (pfile, track_macro_expansion)
3049 && macro_of_context (context: pfile->context) != NULL)
3050 /* We are in a macro expansion context, are not tracking
3051 virtual location, but were asked to report the location
3052 of the expansion point of the macro being expanded. */
3053 *location = pfile->invocation_location;
3054
3055 *location = maybe_adjust_loc_for_trad_cpp (pfile, location: *location);
3056 }
3057
3058 pfile->about_to_expand_macro_p = saved_about_to_expand_macro;
3059
3060 if (pfile->state.directive_file_token
3061 && !pfile->state.parsing_args
3062 && !(result->type == CPP_PADDING || result->type == CPP_COMMENT)
3063 && !(15 & --pfile->state.directive_file_token))
3064 {
3065 /* Do header-name frobbery. Concatenate < ... > as approprate.
3066 Do header search if needed, and finally drop the outer <> or
3067 "". */
3068 pfile->state.angled_headers = false;
3069
3070 /* Do angle-header reconstitution. Then do include searching.
3071 We'll always end up with a ""-quoted header-name in that
3072 case. If searching finds nothing, we emit a diagnostic and
3073 an empty string. */
3074 size_t len = 0;
3075 char *fname = NULL;
3076
3077 cpp_token *tmp = _cpp_temp_token (pfile);
3078 *tmp = *result;
3079
3080 tmp->type = CPP_HEADER_NAME;
3081 bool need_search = !pfile->state.directive_file_token;
3082 pfile->state.directive_file_token = 0;
3083
3084 bool angle = result->type != CPP_STRING;
3085 if (result->type == CPP_HEADER_NAME
3086 || (result->type == CPP_STRING && result->val.str.text[0] != 'R'))
3087 {
3088 len = result->val.str.len - 2;
3089 fname = XNEWVEC (char, len + 1);
3090 memcpy (dest: fname, src: result->val.str.text + 1, n: len);
3091 fname[len] = 0;
3092 }
3093 else if (result->type == CPP_LESS)
3094 fname = _cpp_bracket_include (pfile);
3095
3096 if (fname)
3097 {
3098 /* We have a header-name. Look it up. This will emit an
3099 unfound diagnostic. Canonicalize the found name. */
3100 const char *found = fname;
3101
3102 if (need_search)
3103 {
3104 found = _cpp_find_header_unit (pfile, file: fname, angle_p: angle, tmp->src_loc);
3105 if (!found)
3106 found = "";
3107 len = strlen (s: found);
3108 }
3109 /* Force a leading './' if it's not absolute. */
3110 bool dotme = (found[0] == '.' ? !IS_DIR_SEPARATOR (found[1])
3111 : found[0] && !IS_ABSOLUTE_PATH (found));
3112
3113 if (BUFF_ROOM (pfile->u_buff) < len + 1 + dotme * 2)
3114 _cpp_extend_buff (pfile, &pfile->u_buff, len + 1 + dotme * 2);
3115 unsigned char *buf = BUFF_FRONT (pfile->u_buff);
3116 size_t pos = 0;
3117
3118 if (dotme)
3119 {
3120 buf[pos++] = '.';
3121 /* Apparently '/' is unconditional. */
3122 buf[pos++] = '/';
3123 }
3124 memcpy (dest: &buf[pos], src: found, n: len);
3125 pos += len;
3126 buf[pos] = 0;
3127
3128 tmp->val.str.len = pos;
3129 tmp->val.str.text = buf;
3130
3131 tmp->type = CPP_HEADER_NAME;
3132 XDELETEVEC (fname);
3133
3134 result = tmp;
3135 }
3136 }
3137
3138 return result;
3139}
3140
3141/* External routine to get a token. Also used nearly everywhere
3142 internally, except for places where we know we can safely call
3143 _cpp_lex_token directly, such as lexing a directive name.
3144
3145 Macro expansions and directives are transparently handled,
3146 including entering included files. Thus tokens are post-macro
3147 expansion, and after any intervening directives. External callers
3148 see CPP_EOF only at EOF. Internal callers also see it when meeting
3149 a directive inside a macro call, when at the end of a directive and
3150 state.in_directive is still 1, and at the end of argument
3151 pre-expansion. */
3152const cpp_token *
3153cpp_get_token (cpp_reader *pfile)
3154{
3155 return cpp_get_token_1 (pfile, NULL);
3156}
3157
3158/* Like cpp_get_token, but also returns a virtual token location
3159 separate from the spelling location carried by the returned token.
3160
3161 LOC is an out parameter; *LOC is set to the location "as expected
3162 by the user". This matters when a token results from macro
3163 expansion; in that case the token's spelling location indicates the
3164 locus of the token in the definition of the macro but *LOC
3165 virtually encodes all the other meaningful locuses associated to
3166 the token.
3167
3168 What? virtual location? Yes, virtual location.
3169
3170 If the token results from macro expansion and if macro expansion
3171 location tracking is enabled its virtual location encodes (at the
3172 same time):
3173
3174 - the spelling location of the token
3175
3176 - the locus of the macro expansion point
3177
3178 - the locus of the point where the token got instantiated as part
3179 of the macro expansion process.
3180
3181 You have to use the linemap API to get the locus you are interested
3182 in from a given virtual location.
3183
3184 Note however that virtual locations are not necessarily ordered for
3185 relations '<' and '>'. One must use the function
3186 linemap_location_before_p instead of using the relational operator
3187 '<'.
3188
3189 If macro expansion tracking is off and if the token results from
3190 macro expansion the virtual location is the expansion point of the
3191 macro that got expanded.
3192
3193 When the token doesn't result from macro expansion, the virtual
3194 location is just the same thing as its spelling location. */
3195
3196const cpp_token *
3197cpp_get_token_with_location (cpp_reader *pfile, location_t *loc)
3198{
3199 return cpp_get_token_1 (pfile, location: loc);
3200}
3201
3202/* Returns true if we're expanding an object-like macro that was
3203 defined in a system header. Just checks the macro at the top of
3204 the stack. Used for diagnostic suppression.
3205 Also return true for builtin macros. */
3206int
3207cpp_sys_macro_p (cpp_reader *pfile)
3208{
3209 cpp_hashnode *node = NULL;
3210
3211 if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
3212 node = pfile->context->c.mc->macro_node;
3213 else
3214 node = pfile->context->c.macro;
3215
3216 if (!node)
3217 return false;
3218 if (cpp_builtin_macro_p (node))
3219 return true;
3220 return node->value.macro && node->value.macro->syshdr;
3221}
3222
3223/* Read each token in, until end of the current file. Directives are
3224 transparently processed. */
3225void
3226cpp_scan_nooutput (cpp_reader *pfile)
3227{
3228 /* Request a CPP_EOF token at the end of this file, rather than
3229 transparently continuing with the including file. */
3230 pfile->buffer->return_at_eof = true;
3231
3232 pfile->state.discarding_output++;
3233 pfile->state.prevent_expansion++;
3234
3235 if (CPP_OPTION (pfile, traditional))
3236 while (_cpp_read_logical_line_trad (pfile))
3237 ;
3238 else
3239 while (cpp_get_token (pfile)->type != CPP_EOF)
3240 ;
3241
3242 pfile->state.discarding_output--;
3243 pfile->state.prevent_expansion--;
3244}
3245
3246/* Step back one or more tokens obtained from the lexer. */
3247void
3248_cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
3249{
3250 pfile->lookaheads += count;
3251 while (count--)
3252 {
3253 pfile->cur_token--;
3254 if (pfile->cur_token == pfile->cur_run->base
3255 /* Possible with -fpreprocessed and no leading #line. */
3256 && pfile->cur_run->prev != NULL)
3257 {
3258 pfile->cur_run = pfile->cur_run->prev;
3259 pfile->cur_token = pfile->cur_run->limit;
3260 }
3261 }
3262}
3263
3264/* Step back one (or more) tokens. Can only step back more than 1 if
3265 they are from the lexer, and not from macro expansion. */
3266void
3267_cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
3268{
3269 if (pfile->context->prev == NULL)
3270 _cpp_backup_tokens_direct (pfile, count);
3271 else
3272 {
3273 if (count != 1)
3274 abort ();
3275 if (pfile->context->tokens_kind == TOKENS_KIND_DIRECT)
3276 FIRST (pfile->context).token--;
3277 else if (pfile->context->tokens_kind == TOKENS_KIND_INDIRECT)
3278 FIRST (pfile->context).ptoken--;
3279 else if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
3280 {
3281 FIRST (pfile->context).ptoken--;
3282 if (pfile->context->c.macro)
3283 {
3284 macro_context *m = pfile->context->c.mc;
3285 m->cur_virt_loc--;
3286 gcc_checking_assert (m->cur_virt_loc >= m->virt_locs);
3287 }
3288 else
3289 abort ();
3290 }
3291 else
3292 abort ();
3293 }
3294}
3295
3296/* #define directive parsing and handling. */
3297
3298/* Returns true if a macro redefinition warning is required. */
3299static bool
3300warn_of_redefinition (cpp_reader *pfile, cpp_hashnode *node,
3301 const cpp_macro *macro2)
3302{
3303 /* Some redefinitions need to be warned about regardless. */
3304 if (node->flags & NODE_WARN)
3305 return true;
3306
3307 /* Suppress warnings for builtins that lack the NODE_WARN flag,
3308 unless Wbuiltin-macro-redefined. */
3309 if (cpp_builtin_macro_p (node))
3310 return CPP_OPTION (pfile, warn_builtin_macro_redefined);
3311
3312 /* Redefinitions of conditional (context-sensitive) macros, on
3313 the other hand, must be allowed silently. */
3314 if (node->flags & NODE_CONDITIONAL)
3315 return false;
3316
3317 if (cpp_macro *macro1 = get_deferred_or_lazy_macro (pfile, node, macro2->line))
3318 return cpp_compare_macros (macro1, macro2);
3319 return false;
3320}
3321
3322/* Return TRUE if MACRO1 and MACRO2 differ. */
3323
3324bool
3325cpp_compare_macros (const cpp_macro *macro1, const cpp_macro *macro2)
3326{
3327 /* Redefinition of a macro is allowed if and only if the old and new
3328 definitions are the same. (6.10.3 paragraph 2). */
3329
3330 /* Don't check count here as it can be different in valid
3331 traditional redefinitions with just whitespace differences. */
3332 if (macro1->paramc != macro2->paramc
3333 || macro1->fun_like != macro2->fun_like
3334 || macro1->variadic != macro2->variadic)
3335 return true;
3336
3337 /* Check parameter spellings. */
3338 for (unsigned i = macro1->paramc; i--; )
3339 if (macro1->parm.params[i] != macro2->parm.params[i])
3340 return true;
3341
3342 /* Check the replacement text or tokens. */
3343 if (macro1->kind == cmk_traditional)
3344 return _cpp_expansions_different_trad (macro1, macro2);
3345
3346 if (macro1->count != macro2->count)
3347 return true;
3348
3349 for (unsigned i= macro1->count; i--; )
3350 if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
3351 return true;
3352
3353 return false;
3354}
3355
3356/* Free the definition of hashnode H. */
3357void
3358_cpp_free_definition (cpp_hashnode *h)
3359{
3360 /* Macros and assertions no longer have anything to free. */
3361 h->type = NT_VOID;
3362 h->value.answers = NULL;
3363 h->flags &= ~(NODE_DISABLED | NODE_USED);
3364}
3365
3366/* Save parameter NODE (spelling SPELLING) to the parameter list of
3367 macro MACRO. Returns true on success, false on failure. */
3368bool
3369_cpp_save_parameter (cpp_reader *pfile, unsigned n, cpp_hashnode *node,
3370 cpp_hashnode *spelling)
3371{
3372 /* Constraint 6.10.3.6 - duplicate parameter names. */
3373 if (node->type == NT_MACRO_ARG)
3374 {
3375 cpp_error (pfile, CPP_DL_ERROR, msgid: "duplicate macro parameter \"%s\"",
3376 NODE_NAME (node));
3377 return false;
3378 }
3379
3380 unsigned len = (n + 1) * sizeof (struct macro_arg_saved_data);
3381 if (len > pfile->macro_buffer_len)
3382 {
3383 pfile->macro_buffer
3384 = XRESIZEVEC (unsigned char, pfile->macro_buffer, len);
3385 pfile->macro_buffer_len = len;
3386 }
3387
3388 macro_arg_saved_data *saved = (macro_arg_saved_data *)pfile->macro_buffer;
3389 saved[n].canonical_node = node;
3390 saved[n].value = node->value;
3391 saved[n].type = node->type;
3392
3393 void *base = _cpp_reserve_room (pfile, have: n * sizeof (cpp_hashnode *),
3394 extra: sizeof (cpp_hashnode *));
3395 ((cpp_hashnode **)base)[n] = spelling;
3396
3397 /* Morph into a macro arg. */
3398 node->type = NT_MACRO_ARG;
3399 /* Index is 1 based. */
3400 node->value.arg_index = n + 1;
3401
3402 return true;
3403}
3404
3405/* Restore the parameters to their previous state. */
3406void
3407_cpp_unsave_parameters (cpp_reader *pfile, unsigned n)
3408{
3409 /* Clear the fast argument lookup indices. */
3410 while (n--)
3411 {
3412 struct macro_arg_saved_data *save =
3413 &((struct macro_arg_saved_data *) pfile->macro_buffer)[n];
3414
3415 struct cpp_hashnode *node = save->canonical_node;
3416 node->type = save->type;
3417 node->value = save->value;
3418 }
3419}
3420
3421/* Check the syntax of the parameters in a MACRO definition. Return
3422 false on failure. Set *N_PTR and *VARADIC_PTR as appropriate.
3423 '(' ')'
3424 '(' parm-list ',' last-parm ')'
3425 '(' last-parm ')'
3426 parm-list: name
3427 | parm-list, name
3428 last-parm: name
3429 | name '...'
3430 | '...'
3431*/
3432
3433static bool
3434parse_params (cpp_reader *pfile, unsigned *n_ptr, bool *varadic_ptr)
3435{
3436 unsigned nparms = 0;
3437 bool ok = false;
3438
3439 for (bool prev_ident = false;;)
3440 {
3441 const cpp_token *token = _cpp_lex_token (pfile);
3442
3443 switch (token->type)
3444 {
3445 case CPP_COMMENT:
3446 /* Allow/ignore comments in parameter lists if we are
3447 preserving comments in macro expansions. */
3448 if (!CPP_OPTION (pfile, discard_comments_in_macro_exp))
3449 break;
3450
3451 /* FALLTHRU */
3452 default:
3453 bad:
3454 {
3455 const char *const msgs[5] =
3456 {
3457 N_("expected parameter name, found \"%s\""),
3458 N_("expected ',' or ')', found \"%s\""),
3459 N_("expected parameter name before end of line"),
3460 N_("expected ')' before end of line"),
3461 N_("expected ')' after \"...\"")
3462 };
3463 unsigned ix = prev_ident;
3464 const unsigned char *as_text = NULL;
3465 if (*varadic_ptr)
3466 ix = 4;
3467 else if (token->type == CPP_EOF)
3468 ix += 2;
3469 else
3470 as_text = cpp_token_as_text (pfile, token);
3471 cpp_error (pfile, CPP_DL_ERROR, msgid: msgs[ix], as_text);
3472 }
3473 goto out;
3474
3475 case CPP_NAME:
3476 if (prev_ident || *varadic_ptr)
3477 goto bad;
3478 prev_ident = true;
3479
3480 if (!_cpp_save_parameter (pfile, n: nparms, node: token->val.node.node,
3481 spelling: token->val.node.spelling))
3482 goto out;
3483 nparms++;
3484 break;
3485
3486 case CPP_CLOSE_PAREN:
3487 if (prev_ident || !nparms || *varadic_ptr)
3488 {
3489 ok = true;
3490 goto out;
3491 }
3492
3493 /* FALLTHRU */
3494 case CPP_COMMA:
3495 if (!prev_ident || *varadic_ptr)
3496 goto bad;
3497 prev_ident = false;
3498 break;
3499
3500 case CPP_ELLIPSIS:
3501 if (*varadic_ptr)
3502 goto bad;
3503 *varadic_ptr = true;
3504 if (!prev_ident)
3505 {
3506 /* An ISO bare ellipsis. */
3507 _cpp_save_parameter (pfile, n: nparms,
3508 node: pfile->spec_nodes.n__VA_ARGS__,
3509 spelling: pfile->spec_nodes.n__VA_ARGS__);
3510 nparms++;
3511 pfile->state.va_args_ok = 1;
3512 if (! CPP_OPTION (pfile, c99)
3513 && CPP_OPTION (pfile, cpp_pedantic)
3514 && CPP_OPTION (pfile, warn_variadic_macros))
3515 cpp_pedwarning
3516 (pfile, CPP_W_VARIADIC_MACROS,
3517 CPP_OPTION (pfile, cplusplus)
3518 ? N_("anonymous variadic macros were introduced in C++11")
3519 : N_("anonymous variadic macros were introduced in C99"));
3520 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
3521 && ! CPP_OPTION (pfile, cplusplus))
3522 cpp_error (pfile, CPP_DL_WARNING,
3523 msgid: "anonymous variadic macros were introduced in C99");
3524 }
3525 else if (CPP_OPTION (pfile, cpp_pedantic)
3526 && CPP_OPTION (pfile, warn_variadic_macros))
3527 cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
3528 CPP_OPTION (pfile, cplusplus)
3529 ? N_("ISO C++ does not permit named variadic macros")
3530 : N_("ISO C does not permit named variadic macros"));
3531 break;
3532 }
3533 }
3534
3535 out:
3536 *n_ptr = nparms;
3537
3538 return ok;
3539}
3540
3541/* Lex a token from the expansion of MACRO, but mark parameters as we
3542 find them and warn of traditional stringification. */
3543static cpp_macro *
3544lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
3545{
3546 macro = (cpp_macro *)_cpp_reserve_room (pfile,
3547 have: sizeof (cpp_macro) - sizeof (cpp_token)
3548 + macro->count * sizeof (cpp_token),
3549 extra: sizeof (cpp_token));
3550 cpp_token *saved_cur_token = pfile->cur_token;
3551 pfile->cur_token = &macro->exp.tokens[macro->count];
3552 cpp_token *token = _cpp_lex_direct (pfile);
3553 pfile->cur_token = saved_cur_token;
3554
3555 /* Is this a parameter? */
3556 if (token->type == CPP_NAME && token->val.node.node->type == NT_MACRO_ARG)
3557 {
3558 /* Morph into a parameter reference. */
3559 cpp_hashnode *spelling = token->val.node.spelling;
3560 token->type = CPP_MACRO_ARG;
3561 token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
3562 token->val.macro_arg.spelling = spelling;
3563 }
3564 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
3565 && (token->type == CPP_STRING || token->type == CPP_CHAR))
3566 check_trad_stringification (pfile, macro, &token->val.str);
3567
3568 return macro;
3569}
3570
3571static cpp_macro *
3572create_iso_definition (cpp_reader *pfile)
3573{
3574 bool following_paste_op = false;
3575 const char *paste_op_error_msg =
3576 N_("'##' cannot appear at either end of a macro expansion");
3577 unsigned int num_extra_tokens = 0;
3578 unsigned nparms = 0;
3579 cpp_hashnode **params = NULL;
3580 bool varadic = false;
3581 bool ok = false;
3582 cpp_macro *macro = NULL;
3583
3584 /* Look at the first token, to see if this is a function-like
3585 macro. */
3586 cpp_token first;
3587 cpp_token *saved_cur_token = pfile->cur_token;
3588 pfile->cur_token = &first;
3589 cpp_token *token = _cpp_lex_direct (pfile);
3590 pfile->cur_token = saved_cur_token;
3591
3592 if (token->flags & PREV_WHITE)
3593 /* Preceeded by space, must be part of expansion. */;
3594 else if (token->type == CPP_OPEN_PAREN)
3595 {
3596 /* An open-paren, get a parameter list. */
3597 if (!parse_params (pfile, n_ptr: &nparms, varadic_ptr: &varadic))
3598 goto out;
3599
3600 params = (cpp_hashnode **)_cpp_commit_buff
3601 (pfile, size: sizeof (cpp_hashnode *) * nparms);
3602 token = NULL;
3603 }
3604 else if (token->type != CPP_EOF
3605 && !(token->type == CPP_COMMENT
3606 && ! CPP_OPTION (pfile, discard_comments_in_macro_exp)))
3607 {
3608 /* While ISO C99 requires whitespace before replacement text
3609 in a macro definition, ISO C90 with TC1 allows characters
3610 from the basic source character set there. */
3611 if (CPP_OPTION (pfile, c99))
3612 cpp_error (pfile, CPP_DL_PEDWARN,
3613 CPP_OPTION (pfile, cplusplus)
3614 ? N_("ISO C++11 requires whitespace after the macro name")
3615 : N_("ISO C99 requires whitespace after the macro name"));
3616 else
3617 {
3618 enum cpp_diagnostic_level warntype = CPP_DL_WARNING;
3619 switch (token->type)
3620 {
3621 case CPP_ATSIGN:
3622 case CPP_AT_NAME:
3623 case CPP_OBJC_STRING:
3624 /* '@' is not in basic character set. */
3625 warntype = CPP_DL_PEDWARN;
3626 break;
3627 case CPP_OTHER:
3628 /* Basic character set sans letters, digits and _. */
3629 if (strchr (s: "!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
3630 c: token->val.str.text[0]) == NULL)
3631 warntype = CPP_DL_PEDWARN;
3632 break;
3633 default:
3634 /* All other tokens start with a character from basic
3635 character set. */
3636 break;
3637 }
3638 cpp_error (pfile, warntype,
3639 msgid: "missing whitespace after the macro name");
3640 }
3641 }
3642
3643 macro = _cpp_new_macro (pfile, cmk_macro,
3644 _cpp_reserve_room (pfile, have: 0, extra: sizeof (cpp_macro)));
3645
3646 if (!token)
3647 {
3648 macro->variadic = varadic;
3649 macro->paramc = nparms;
3650 macro->parm.params = params;
3651 macro->fun_like = true;
3652 }
3653 else
3654 {
3655 /* Preserve the token we peeked, there is already a single slot for it. */
3656 macro->exp.tokens[0] = *token;
3657 token = &macro->exp.tokens[0];
3658 macro->count = 1;
3659 }
3660
3661 for (vaopt_state vaopt_tracker (pfile, macro->variadic, NULL);; token = NULL)
3662 {
3663 if (!token)
3664 {
3665 macro = lex_expansion_token (pfile, macro);
3666 token = &macro->exp.tokens[macro->count++];
3667 }
3668
3669 /* Check the stringifying # constraint 6.10.3.2.1 of
3670 function-like macros when lexing the subsequent token. */
3671 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
3672 {
3673 if (token->type == CPP_MACRO_ARG
3674 || (macro->variadic
3675 && token->type == CPP_NAME
3676 && token->val.node.node == pfile->spec_nodes.n__VA_OPT__))
3677 {
3678 if (token->flags & PREV_WHITE)
3679 token->flags |= SP_PREV_WHITE;
3680 if (token[-1].flags & DIGRAPH)
3681 token->flags |= SP_DIGRAPH;
3682 token->flags &= ~PREV_WHITE;
3683 token->flags |= STRINGIFY_ARG;
3684 token->flags |= token[-1].flags & PREV_WHITE;
3685 token[-1] = token[0];
3686 macro->count--;
3687 }
3688 /* Let assembler get away with murder. */
3689 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
3690 {
3691 cpp_error (pfile, CPP_DL_ERROR,
3692 msgid: "'#' is not followed by a macro parameter");
3693 goto out;
3694 }
3695 }
3696
3697 if (token->type == CPP_EOF)
3698 {
3699 /* Paste operator constraint 6.10.3.3.1:
3700 Token-paste ##, can appear in both object-like and
3701 function-like macros, but not at the end. */
3702 if (following_paste_op)
3703 {
3704 cpp_error (pfile, CPP_DL_ERROR, msgid: paste_op_error_msg);
3705 goto out;
3706 }
3707 if (!vaopt_tracker.completed ())
3708 goto out;
3709 break;
3710 }
3711
3712 /* Paste operator constraint 6.10.3.3.1. */
3713 if (token->type == CPP_PASTE)
3714 {
3715 /* Token-paste ##, can appear in both object-like and
3716 function-like macros, but not at the beginning. */
3717 if (macro->count == 1)
3718 {
3719 cpp_error (pfile, CPP_DL_ERROR, msgid: paste_op_error_msg);
3720 goto out;
3721 }
3722
3723 if (following_paste_op)
3724 {
3725 /* Consecutive paste operators. This one will be moved
3726 to the end. */
3727 num_extra_tokens++;
3728 token->val.token_no = macro->count - 1;
3729 }
3730 else
3731 {
3732 /* Drop the paste operator. */
3733 --macro->count;
3734 token[-1].flags |= PASTE_LEFT;
3735 if (token->flags & DIGRAPH)
3736 token[-1].flags |= SP_DIGRAPH;
3737 if (token->flags & PREV_WHITE)
3738 token[-1].flags |= SP_PREV_WHITE;
3739 }
3740 following_paste_op = true;
3741 }
3742 else
3743 following_paste_op = false;
3744
3745 if (vaopt_tracker.update (token) == vaopt_state::ERROR)
3746 goto out;
3747 }
3748
3749 /* We're committed to winning now. */
3750 ok = true;
3751
3752 /* Don't count the CPP_EOF. */
3753 macro->count--;
3754
3755 macro = (cpp_macro *)_cpp_commit_buff
3756 (pfile, size: sizeof (cpp_macro) - sizeof (cpp_token)
3757 + sizeof (cpp_token) * macro->count);
3758
3759 /* Clear whitespace on first token. */
3760 if (macro->count)
3761 macro->exp.tokens[0].flags &= ~PREV_WHITE;
3762
3763 if (num_extra_tokens)
3764 {
3765 /* Place second and subsequent ## or %:%: tokens in sequences of
3766 consecutive such tokens at the end of the list to preserve
3767 information about where they appear, how they are spelt and
3768 whether they are preceded by whitespace without otherwise
3769 interfering with macro expansion. Remember, this is
3770 extremely rare, so efficiency is not a priority. */
3771 cpp_token *temp = (cpp_token *)_cpp_reserve_room
3772 (pfile, have: 0, extra: num_extra_tokens * sizeof (cpp_token));
3773 unsigned extra_ix = 0, norm_ix = 0;
3774 cpp_token *exp = macro->exp.tokens;
3775 for (unsigned ix = 0; ix != macro->count; ix++)
3776 if (exp[ix].type == CPP_PASTE)
3777 temp[extra_ix++] = exp[ix];
3778 else
3779 exp[norm_ix++] = exp[ix];
3780 memcpy (dest: &exp[norm_ix], src: temp, n: num_extra_tokens * sizeof (cpp_token));
3781
3782 /* Record there are extra tokens. */
3783 macro->extra_tokens = 1;
3784 }
3785
3786 out:
3787 pfile->state.va_args_ok = 0;
3788 _cpp_unsave_parameters (pfile, n: nparms);
3789
3790 return ok ? macro : NULL;
3791}
3792
3793cpp_macro *
3794_cpp_new_macro (cpp_reader *pfile, cpp_macro_kind kind, void *placement)
3795{
3796 cpp_macro *macro = (cpp_macro *) placement;
3797
3798 /* Zero init all the fields. This'll tell the compiler know all the
3799 following inits are writing a virgin object. */
3800 memset (s: macro, c: 0, offsetof (cpp_macro, exp));
3801
3802 macro->line = pfile->directive_line;
3803 macro->parm.params = 0;
3804 macro->lazy = 0;
3805 macro->paramc = 0;
3806 macro->variadic = 0;
3807 macro->used = !CPP_OPTION (pfile, warn_unused_macros);
3808 macro->count = 0;
3809 macro->fun_like = 0;
3810 macro->imported_p = false;
3811 macro->extra_tokens = 0;
3812 /* To suppress some diagnostics. */
3813 macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
3814
3815 macro->kind = kind;
3816
3817 return macro;
3818}
3819
3820/* Parse a macro and save its expansion. Returns nonzero on success. */
3821bool
3822_cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node,
3823 location_t name_loc)
3824{
3825 cpp_macro *macro;
3826
3827 if (CPP_OPTION (pfile, traditional))
3828 macro = _cpp_create_trad_definition (pfile);
3829 else
3830 macro = create_iso_definition (pfile);
3831
3832 if (!macro)
3833 return false;
3834
3835 /* _cpp_new_macro () has set macro->line to pfile->directive_line, which
3836 denotes the line containing the #define with no column information. If
3837 provided, change to name_loc, which will be the token src_loc for the
3838 macro name, including the location and range information. */
3839 if (name_loc)
3840 macro->line = name_loc;
3841
3842 if (cpp_macro_p (node))
3843 {
3844 if (CPP_OPTION (pfile, warn_unused_macros))
3845 _cpp_warn_if_unused_macro (pfile, node, NULL);
3846
3847 if (warn_of_redefinition (pfile, node, macro2: macro))
3848 {
3849 const enum cpp_warning_reason reason
3850 = (cpp_builtin_macro_p (node) && !(node->flags & NODE_WARN))
3851 ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
3852
3853 bool warned =
3854 cpp_pedwarning_with_line (pfile, reason,
3855 macro->line, 0,
3856 msgid: "\"%s\" redefined", NODE_NAME (node));
3857
3858 if (warned && cpp_user_macro_p (node))
3859 cpp_error_with_line (pfile, CPP_DL_NOTE,
3860 node->value.macro->line, 0,
3861 msgid: "this is the location of the previous definition");
3862 }
3863 _cpp_free_definition (h: node);
3864 }
3865
3866 /* Enter definition in hash table. */
3867 node->type = NT_USER_MACRO;
3868 node->value.macro = macro;
3869 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
3870 && ustrcmp (NODE_NAME (node), s2: (const uchar *) "__STDC_FORMAT_MACROS")
3871 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3872 in the C standard, as something that one must use in C++.
3873 However DR#593 and C++11 indicate that they play no role in C++.
3874 We special-case them anyway. */
3875 && ustrcmp (NODE_NAME (node), s2: (const uchar *) "__STDC_LIMIT_MACROS")
3876 && ustrcmp (NODE_NAME (node), s2: (const uchar *) "__STDC_CONSTANT_MACROS"))
3877 node->flags |= NODE_WARN;
3878
3879 /* If user defines one of the conditional macros, remove the
3880 conditional flag */
3881 node->flags &= ~NODE_CONDITIONAL;
3882
3883 return true;
3884}
3885
3886extern void
3887cpp_define_lazily (cpp_reader *pfile, cpp_hashnode *node, unsigned num)
3888{
3889 cpp_macro *macro = node->value.macro;
3890
3891 gcc_checking_assert (pfile->cb.user_lazy_macro && macro && num < UCHAR_MAX);
3892
3893 macro->lazy = num + 1;
3894}
3895
3896/* NODE is a deferred macro, resolve it, returning the definition
3897 (which may be NULL). */
3898cpp_macro *
3899cpp_get_deferred_macro (cpp_reader *pfile, cpp_hashnode *node,
3900 location_t loc)
3901{
3902 gcc_checking_assert (node->type == NT_USER_MACRO);
3903
3904 node->value.macro = pfile->cb.user_deferred_macro (pfile, loc, node);
3905
3906 if (!node->value.macro)
3907 node->type = NT_VOID;
3908
3909 return node->value.macro;
3910}
3911
3912static cpp_macro *
3913get_deferred_or_lazy_macro (cpp_reader *pfile, cpp_hashnode *node,
3914 location_t loc)
3915{
3916 cpp_macro *macro = node->value.macro;
3917 if (!macro)
3918 {
3919 macro = cpp_get_deferred_macro (pfile, node, loc);
3920 gcc_checking_assert (!macro || !macro->lazy);
3921 }
3922 else if (macro->lazy)
3923 {
3924 pfile->cb.user_lazy_macro (pfile, macro, macro->lazy - 1);
3925 macro->lazy = 0;
3926 }
3927
3928 return macro;
3929}
3930
3931/* Notify the use of NODE in a macro-aware context (i.e. expanding it,
3932 or testing its existance). Also applies any lazy definition.
3933 Return FALSE if the macro isn't really there. */
3934
3935extern bool
3936_cpp_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node,
3937 location_t loc)
3938{
3939 node->flags |= NODE_USED;
3940 switch (node->type)
3941 {
3942 case NT_USER_MACRO:
3943 if (!get_deferred_or_lazy_macro (pfile, node, loc))
3944 return false;
3945 /* FALLTHROUGH. */
3946
3947 case NT_BUILTIN_MACRO:
3948 if (pfile->cb.used_define)
3949 pfile->cb.used_define (pfile, loc, node);
3950 break;
3951
3952 case NT_VOID:
3953 if (pfile->cb.used_undef)
3954 pfile->cb.used_undef (pfile, loc, node);
3955 break;
3956
3957 default:
3958 abort ();
3959 }
3960
3961 return true;
3962}
3963
3964/* Warn if a token in STRING matches one of a function-like MACRO's
3965 parameters. */
3966static void
3967check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
3968 const cpp_string *string)
3969{
3970 unsigned int i, len;
3971 const uchar *p, *q, *limit;
3972
3973 /* Loop over the string. */
3974 limit = string->text + string->len - 1;
3975 for (p = string->text + 1; p < limit; p = q)
3976 {
3977 /* Find the start of an identifier. */
3978 while (p < limit && !is_idstart (*p))
3979 p++;
3980
3981 /* Find the end of the identifier. */
3982 q = p;
3983 while (q < limit && is_idchar (*q))
3984 q++;
3985
3986 len = q - p;
3987
3988 /* Loop over the function macro arguments to see if the
3989 identifier inside the string matches one of them. */
3990 for (i = 0; i < macro->paramc; i++)
3991 {
3992 const cpp_hashnode *node = macro->parm.params[i];
3993
3994 if (NODE_LEN (node) == len
3995 && !memcmp (s1: p, NODE_NAME (node), n: len))
3996 {
3997 cpp_warning (pfile, CPP_W_TRADITIONAL,
3998 msgid: "macro argument \"%s\" would be stringified in traditional C",
3999 NODE_NAME (node));
4000 break;
4001 }
4002 }
4003 }
4004}
4005
4006/* Returns the name, arguments and expansion of a macro, in a format
4007 suitable to be read back in again, and therefore also for DWARF 2
4008 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
4009 Caller is expected to generate the "#define" bit if needed. The
4010 returned text is temporary, and automatically freed later. */
4011const unsigned char *
4012cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node)
4013{
4014 gcc_checking_assert (cpp_user_macro_p (node));
4015
4016 if (const cpp_macro *macro = get_deferred_or_lazy_macro (pfile, node, loc: 0))
4017 return cpp_macro_definition (pfile, node, macro);
4018 return NULL;
4019}
4020
4021const unsigned char *
4022cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node,
4023 const cpp_macro *macro)
4024{
4025 unsigned int i, len;
4026 unsigned char *buffer;
4027
4028 /* Calculate length. */
4029 len = NODE_LEN (node) * 10 + 2; /* ' ' and NUL. */
4030 if (macro->fun_like)
4031 {
4032 len += 4; /* "()" plus possible final ".." of named
4033 varargs (we have + 1 below). */
4034 for (i = 0; i < macro->paramc; i++)
4035 len += NODE_LEN (macro->parm.params[i]) + 1; /* "," */
4036 }
4037
4038 /* This should match below where we fill in the buffer. */
4039 if (CPP_OPTION (pfile, traditional))
4040 len += _cpp_replacement_text_len (macro);
4041 else
4042 {
4043 unsigned int count = macro_real_token_count (macro);
4044 for (i = 0; i < count; i++)
4045 {
4046 const cpp_token *token = &macro->exp.tokens[i];
4047
4048 if (token->type == CPP_MACRO_ARG)
4049 len += NODE_LEN (token->val.macro_arg.spelling);
4050 else
4051 len += cpp_token_len (token);
4052
4053 if (token->flags & STRINGIFY_ARG)
4054 len++; /* "#" */
4055 if (token->flags & PASTE_LEFT)
4056 len += 3; /* " ##" */
4057 if (token->flags & PREV_WHITE)
4058 len++; /* " " */
4059 }
4060 }
4061
4062 if (len > pfile->macro_buffer_len)
4063 {
4064 pfile->macro_buffer = XRESIZEVEC (unsigned char,
4065 pfile->macro_buffer, len);
4066 pfile->macro_buffer_len = len;
4067 }
4068
4069 /* Fill in the buffer. Start with the macro name. */
4070 buffer = pfile->macro_buffer;
4071 buffer = _cpp_spell_ident_ucns (buffer, node);
4072
4073 /* Parameter names. */
4074 if (macro->fun_like)
4075 {
4076 *buffer++ = '(';
4077 for (i = 0; i < macro->paramc; i++)
4078 {
4079 cpp_hashnode *param = macro->parm.params[i];
4080
4081 if (param != pfile->spec_nodes.n__VA_ARGS__)
4082 {
4083 memcpy (dest: buffer, NODE_NAME (param), NODE_LEN (param));
4084 buffer += NODE_LEN (param);
4085 }
4086
4087 if (i + 1 < macro->paramc)
4088 /* Don't emit a space after the comma here; we're trying
4089 to emit a Dwarf-friendly definition, and the Dwarf spec
4090 forbids spaces in the argument list. */
4091 *buffer++ = ',';
4092 else if (macro->variadic)
4093 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
4094 }
4095 *buffer++ = ')';
4096 }
4097
4098 /* The Dwarf spec requires a space after the macro name, even if the
4099 definition is the empty string. */
4100 *buffer++ = ' ';
4101
4102 if (CPP_OPTION (pfile, traditional))
4103 buffer = _cpp_copy_replacement_text (macro, buffer);
4104 else if (macro->count)
4105 /* Expansion tokens. */
4106 {
4107 unsigned int count = macro_real_token_count (macro);
4108 for (i = 0; i < count; i++)
4109 {
4110 const cpp_token *token = &macro->exp.tokens[i];
4111
4112 if (token->flags & PREV_WHITE)
4113 *buffer++ = ' ';
4114 if (token->flags & STRINGIFY_ARG)
4115 *buffer++ = '#';
4116
4117 if (token->type == CPP_MACRO_ARG)
4118 {
4119 memcpy (dest: buffer,
4120 NODE_NAME (token->val.macro_arg.spelling),
4121 NODE_LEN (token->val.macro_arg.spelling));
4122 buffer += NODE_LEN (token->val.macro_arg.spelling);
4123 }
4124 else
4125 buffer = cpp_spell_token (pfile, token, buffer, true);
4126
4127 if (token->flags & PASTE_LEFT)
4128 {
4129 *buffer++ = ' ';
4130 *buffer++ = '#';
4131 *buffer++ = '#';
4132 /* Next has PREV_WHITE; see _cpp_create_definition. */
4133 }
4134 }
4135 }
4136
4137 *buffer = '\0';
4138 return pfile->macro_buffer;
4139}
4140

source code of libcpp/macro.cc