1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986-2020 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding! */
30 typedef struct macro_arg macro_arg
;
31 /* This structure represents the tokens of a macro argument. These
32 tokens can be macro themselves, in which case they can be either
33 expanded or unexpanded. When they are expanded, this data
34 structure keeps both the expanded and unexpanded forms. */
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
49 /* The kind of macro tokens which the instance of
50 macro_arg_token_iter is supposed to iterate over. */
51 enum macro_arg_token_kind
{
52 MACRO_ARG_TOKEN_NORMAL
,
53 /* This is a macro argument token that got transformed into a string
54 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
61 /* An iterator over tokens coming from a function-like macro
63 typedef struct macro_arg_token_iter macro_arg_token_iter
;
64 struct macro_arg_token_iter
66 /* Whether or not -ftrack-macro-expansion is used. */
67 bool track_macro_exp_p
;
68 /* The kind of token over which we are supposed to iterate. */
69 enum macro_arg_token_kind kind
;
70 /* A pointer to the current token pointed to by the iterator. */
71 const cpp_token
**token_ptr
;
72 /* A pointer to the "full" location of the current token. If
73 -ftrack-macro-expansion is used this location tracks loci across
75 const location_t
*location_ptr
;
77 /* The number of times the iterator went forward. This useful only
78 when checking is enabled. */
83 /* Saved data about an identifier being used as a macro argument
85 struct 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
;
93 static const char *vaopt_paste_error
=
94 N_("'##' cannot appear at either end of __VA_OPT__");
96 static void expand_arg (cpp_reader
*, macro_arg
*);
98 /* A class for tracking __VA_OPT__ state while iterating over a
99 sequence of tokens. This is used during both macro definition and
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
)
119 m_variadic (is_variadic
),
120 m_last_was_paste (false),
122 m_paste_location (0),
128 /* Given a token, update the state of this tracker and return a
129 boolean indicating whether the token should be be included in the
131 update_type
update (const cpp_token
*token
)
133 /* If the macro isn't variadic, just don't bother. */
137 if (token
->type
== CPP_NAME
138 && token
->val
.node
.node
== m_pfile
->spec_nodes
.n__VA_OPT__
)
142 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
143 "__VA_OPT__ may not appear in a __VA_OPT__");
147 m_location
= token
->src_loc
;
150 else if (m_state
== 1)
152 if (token
->type
!= CPP_OPEN_PAREN
)
154 cpp_error_at (m_pfile
, CPP_DL_ERROR
, m_location
,
155 "__VA_OPT__ must be followed by an "
160 if (m_update
== ERROR
)
167 if (!m_arg
->expanded
)
168 expand_arg (m_pfile
, m_arg
);
169 for (unsigned idx
= 0; idx
< m_arg
->expanded_count
; ++idx
)
170 if (m_arg
->expanded
[idx
]->type
!= CPP_PADDING
)
179 else if (m_state
>= 2)
181 if (m_state
== 2 && token
->type
== CPP_PASTE
)
183 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
187 /* Advance states before further considering this token, in
188 case we see a close paren immediately after the open
193 bool was_paste
= m_last_was_paste
;
194 m_last_was_paste
= false;
195 if (token
->type
== CPP_PASTE
)
197 m_last_was_paste
= true;
198 m_paste_location
= token
->src_loc
;
200 else if (token
->type
== CPP_OPEN_PAREN
)
202 else if (token
->type
== CPP_CLOSE_PAREN
)
207 /* Saw the final paren. */
212 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
223 /* Nothing to do with __VA_OPT__. */
227 /* Ensure that any __VA_OPT__ was completed. If ok, return true.
228 Otherwise, issue an error and return false. */
231 if (m_variadic
&& m_state
!= 0)
232 cpp_error_at (m_pfile
, CPP_DL_ERROR
, m_location
,
233 "unterminated __VA_OPT__");
239 /* The cpp_reader. */
242 /* The __VA_ARGS__ argument. */
245 /* True if the macro is variadic. */
247 /* If true, the previous token was ##. This is used to detect when
248 a paste occurs at the end of the sequence. */
249 bool m_last_was_paste
;
251 /* The state variable:
253 1 means __VA_OPT__ seen, looking for "("
254 2 means "(" seen (so the next token can't be "##")
255 >= 3 means looking for ")", the number encodes the paren depth. */
258 /* The location of the paste token. */
259 location_t m_paste_location
;
261 /* Location of the __VA_OPT__ token. */
262 location_t m_location
;
264 /* If __VA_ARGS__ substitutes to no preprocessing tokens,
265 INCLUDE, otherwise DROP. ERROR when unknown yet. */
266 update_type m_update
;
269 /* Macro expansion. */
271 static int enter_macro_context (cpp_reader
*, cpp_hashnode
*,
272 const cpp_token
*, location_t
);
273 static int builtin_macro (cpp_reader
*, cpp_hashnode
*,
274 location_t
, location_t
);
275 static void push_ptoken_context (cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
276 const cpp_token
**, unsigned int);
277 static void push_extended_tokens_context (cpp_reader
*, cpp_hashnode
*,
278 _cpp_buff
*, location_t
*,
279 const cpp_token
**, unsigned int);
280 static _cpp_buff
*collect_args (cpp_reader
*, const cpp_hashnode
*,
281 _cpp_buff
**, unsigned *);
282 static cpp_context
*next_context (cpp_reader
*);
283 static const cpp_token
*padding_token (cpp_reader
*, const cpp_token
*);
284 static const cpp_token
*new_string_token (cpp_reader
*, uchar
*, unsigned int);
285 static const cpp_token
*stringify_arg (cpp_reader
*, macro_arg
*);
286 static void paste_all_tokens (cpp_reader
*, const cpp_token
*);
287 static bool paste_tokens (cpp_reader
*, location_t
,
288 const cpp_token
**, const cpp_token
*);
289 static void alloc_expanded_arg_mem (cpp_reader
*, macro_arg
*, size_t);
290 static void ensure_expanded_arg_room (cpp_reader
*, macro_arg
*, size_t, size_t *);
291 static void delete_macro_args (_cpp_buff
*, unsigned num_args
);
292 static void set_arg_token (macro_arg
*, const cpp_token
*,
294 enum macro_arg_token_kind
,
296 static const location_t
*get_arg_token_location (const macro_arg
*,
297 enum macro_arg_token_kind
);
298 static const cpp_token
**arg_token_ptr_at (const macro_arg
*,
300 enum macro_arg_token_kind
,
301 location_t
**virt_location
);
303 static void macro_arg_token_iter_init (macro_arg_token_iter
*, bool,
304 enum macro_arg_token_kind
,
307 static const cpp_token
*macro_arg_token_iter_get_token
308 (const macro_arg_token_iter
*it
);
309 static location_t macro_arg_token_iter_get_location
310 (const macro_arg_token_iter
*);
311 static void macro_arg_token_iter_forward (macro_arg_token_iter
*);
312 static _cpp_buff
*tokens_buff_new (cpp_reader
*, size_t,
314 static size_t tokens_buff_count (_cpp_buff
*);
315 static const cpp_token
**tokens_buff_last_token_ptr (_cpp_buff
*);
316 static inline const cpp_token
**tokens_buff_put_token_to (const cpp_token
**,
321 const line_map_macro
*,
324 static const cpp_token
**tokens_buff_add_token (_cpp_buff
*,
329 const line_map_macro
*,
331 static inline void tokens_buff_remove_last_token (_cpp_buff
*);
332 static void replace_args (cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
333 macro_arg
*, location_t
);
334 static _cpp_buff
*funlike_invocation_p (cpp_reader
*, cpp_hashnode
*,
335 _cpp_buff
**, unsigned *);
336 static cpp_macro
*create_iso_definition (cpp_reader
*);
338 /* #define directive parsing and handling. */
340 static cpp_macro
*lex_expansion_token (cpp_reader
*, cpp_macro
*);
341 static bool warn_of_redefinition (cpp_reader
*, cpp_hashnode
*,
343 static bool compare_macros (const cpp_macro
*, const cpp_macro
*);
345 static bool parse_params (cpp_reader
*, unsigned *, bool *);
346 static void check_trad_stringification (cpp_reader
*, const cpp_macro
*,
348 static bool reached_end_of_context (cpp_context
*);
349 static void consume_next_token_from_context (cpp_reader
*pfile
,
352 static const cpp_token
* cpp_get_token_1 (cpp_reader
*, location_t
*);
354 static cpp_hashnode
* macro_of_context (cpp_context
*context
);
356 static bool in_macro_expansion_p (cpp_reader
*pfile
);
358 /* Statistical counter tracking the number of macros that got
360 unsigned num_expanded_macros_counter
= 0;
361 /* Statistical counter tracking the total number tokens resulting
362 from macro expansion. */
363 unsigned num_macro_tokens_counter
= 0;
365 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
366 and not consume CPP_EOF. */
367 static const cpp_token
*
368 cpp_get_token_no_padding (cpp_reader
*pfile
)
372 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
373 if (ret
->type
== CPP_EOF
)
375 ret
= cpp_get_token (pfile
);
376 if (ret
->type
!= CPP_PADDING
)
381 /* Handle meeting "__has_include" builtin macro. */
384 builtin_has_include (cpp_reader
*pfile
, cpp_hashnode
*op
, bool has_next
)
388 if (!pfile
->state
.in_directive
)
389 cpp_error (pfile
, CPP_DL_ERROR
,
390 "\"%s\" used outside of preprocessing directive",
393 pfile
->state
.angled_headers
= true;
394 const cpp_token
*token
= cpp_get_token_no_padding (pfile
);
395 bool paren
= token
->type
== CPP_OPEN_PAREN
;
397 token
= cpp_get_token_no_padding (pfile
);
399 cpp_error (pfile
, CPP_DL_ERROR
,
400 "missing '(' before \"%s\" operand", NODE_NAME (op
));
401 pfile
->state
.angled_headers
= false;
403 bool bracket
= token
->type
!= CPP_STRING
;
405 if (token
->type
== CPP_STRING
|| token
->type
== CPP_HEADER_NAME
)
407 fname
= XNEWVEC (char, token
->val
.str
.len
- 1);
408 memcpy (fname
, token
->val
.str
.text
+ 1, token
->val
.str
.len
- 2);
409 fname
[token
->val
.str
.len
- 2] = '\0';
411 else if (token
->type
== CPP_LESS
)
412 fname
= _cpp_bracket_include (pfile
);
414 cpp_error (pfile
, CPP_DL_ERROR
,
415 "operator \"%s\" requires a header-name", NODE_NAME (op
));
419 /* Do not do the lookup if we're skipping, that's unnecessary
421 if (!pfile
->state
.skip_eval
422 && _cpp_has_header (pfile
, fname
, bracket
,
423 has_next
? IT_INCLUDE_NEXT
: IT_INCLUDE
))
430 && cpp_get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
431 cpp_error (pfile
, CPP_DL_ERROR
,
432 "missing ')' after \"%s\" operand", NODE_NAME (op
));
437 /* Emits a warning if NODE is a macro defined in the main file that
438 has not been used. */
440 _cpp_warn_if_unused_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
441 void *v ATTRIBUTE_UNUSED
)
443 if (cpp_user_macro_p (node
))
445 cpp_macro
*macro
= node
->value
.macro
;
448 && MAIN_FILE_P (linemap_check_ordinary
449 (linemap_lookup (pfile
->line_table
,
451 cpp_warning_with_line (pfile
, CPP_W_UNUSED_MACROS
, macro
->line
, 0,
452 "macro \"%s\" is not used", NODE_NAME (node
));
458 /* Allocates and returns a CPP_STRING token, containing TEXT of length
459 LEN, after null-terminating it. TEXT must be in permanent storage. */
460 static const cpp_token
*
461 new_string_token (cpp_reader
*pfile
, unsigned char *text
, unsigned int len
)
463 cpp_token
*token
= _cpp_temp_token (pfile
);
466 token
->type
= CPP_STRING
;
467 token
->val
.str
.len
= len
;
468 token
->val
.str
.text
= text
;
473 static const char * const monthnames
[] =
475 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
476 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
479 /* Helper function for builtin_macro. Returns the text generated by
482 _cpp_builtin_macro_text (cpp_reader
*pfile
, cpp_hashnode
*node
,
485 const uchar
*result
= NULL
;
486 linenum_type number
= 1;
488 switch (node
->value
.builtin
)
491 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
497 if (CPP_OPTION (pfile
, warn_date_time
))
498 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
499 "reproducible builds", NODE_NAME (node
));
501 cpp_buffer
*pbuffer
= cpp_get_buffer (pfile
);
502 if (pbuffer
->timestamp
== NULL
)
504 /* Initialize timestamp value of the assotiated file. */
505 struct _cpp_file
*file
= cpp_get_file (pbuffer
);
508 /* Generate __TIMESTAMP__ string, that represents
509 the date and time of the last modification
510 of the current source file. The string constant
511 looks like "Sun Sep 16 01:03:52 1973". */
512 struct tm
*tb
= NULL
;
513 struct stat
*st
= _cpp_get_file_stat (file
);
515 tb
= localtime (&st
->st_mtime
);
518 char *str
= asctime (tb
);
519 size_t len
= strlen (str
);
520 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
522 strcpy ((char *) buf
+ 1, str
);
524 pbuffer
->timestamp
= buf
;
528 cpp_errno (pfile
, CPP_DL_WARNING
,
529 "could not determine file timestamp");
530 pbuffer
->timestamp
= UC
"\"??? ??? ?? ??:??:?? ????\"";
534 result
= pbuffer
->timestamp
;
544 if (node
->value
.builtin
== BT_FILE
)
545 name
= linemap_get_expansion_filename (pfile
->line_table
,
546 pfile
->line_table
->highest_line
);
549 name
= _cpp_get_file_name (pfile
->main_file
);
553 if (pfile
->cb
.remap_filename
)
554 name
= pfile
->cb
.remap_filename (name
);
556 buf
= _cpp_unaligned_alloc (pfile
, len
* 2 + 3);
559 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
565 case BT_INCLUDE_LEVEL
:
566 /* The line map depth counts the primary source as level 1, but
567 historically __INCLUDE_DEPTH__ has called the primary source
569 number
= pfile
->line_table
->depth
- 1;
573 /* If __LINE__ is embedded in a macro, it must expand to the
574 line of the macro's invocation, not its definition.
575 Otherwise things like assert() will not work properly.
576 See WG14 N1911, WG21 N4220 sec 6.5, and PR 61861. */
577 if (CPP_OPTION (pfile
, traditional
))
578 loc
= pfile
->line_table
->highest_line
;
580 loc
= linemap_resolve_location (pfile
->line_table
, loc
,
581 LRK_MACRO_EXPANSION_POINT
, NULL
);
582 number
= linemap_get_expansion_line (pfile
->line_table
, loc
);
585 /* __STDC__ has the value 1 under normal circumstances.
586 However, if (a) we are in a system header, (b) the option
587 stdc_0_in_system_headers is true (set by target config), and
588 (c) we are not in strictly conforming mode, then it has the
589 value 0. (b) and (c) are already checked in cpp_init_builtins. */
591 if (cpp_in_system_header (pfile
))
599 if (CPP_OPTION (pfile
, warn_date_time
))
600 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
601 "reproducible builds", NODE_NAME (node
));
602 if (pfile
->date
== NULL
)
604 /* Allocate __DATE__ and __TIME__ strings from permanent
605 storage. We only do this once, and don't generate them
606 at init time, because time() and localtime() are very
607 slow on some systems. */
609 auto kind
= cpp_get_date (pfile
, &tt
);
611 if (kind
== CPP_time_kind::UNKNOWN
)
613 cpp_errno (pfile
, CPP_DL_WARNING
,
614 "could not determine date and time");
616 pfile
->date
= UC
"\"??? ?? ????\"";
617 pfile
->time
= UC
"\"??:??:??\"";
621 struct tm
*tb
= (kind
== CPP_time_kind::FIXED
622 ? gmtime
: localtime
) (&tt
);
624 pfile
->date
= _cpp_unaligned_alloc (pfile
,
625 sizeof ("\"Oct 11 1347\""));
626 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
627 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
630 pfile
->time
= _cpp_unaligned_alloc (pfile
,
631 sizeof ("\"12:34:56\""));
632 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
633 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
637 if (node
->value
.builtin
== BT_DATE
)
638 result
= pfile
->date
;
640 result
= pfile
->time
;
644 if (CPP_OPTION (pfile
, directives_only
) && pfile
->state
.in_directive
)
645 cpp_error (pfile
, CPP_DL_ERROR
,
646 "__COUNTER__ expanded inside directive with -fdirectives-only");
647 number
= pfile
->counter
++;
650 case BT_HAS_ATTRIBUTE
:
651 number
= pfile
->cb
.has_attribute (pfile
, false);
654 case BT_HAS_STD_ATTRIBUTE
:
655 number
= pfile
->cb
.has_attribute (pfile
, true);
659 number
= pfile
->cb
.has_builtin (pfile
);
663 case BT_HAS_INCLUDE_NEXT
:
664 number
= builtin_has_include (pfile
, node
,
665 node
->value
.builtin
== BT_HAS_INCLUDE_NEXT
);
671 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
672 result
= _cpp_unaligned_alloc (pfile
, 21);
673 sprintf ((char *) result
, "%u", number
);
679 /* Get an idempotent date. Either the cached value, the value from
680 source epoch, or failing that, the value from time(2). Use this
681 during compilation so that every time stamp is the same. */
683 cpp_get_date (cpp_reader
*pfile
, time_t *result
)
685 if (!pfile
->time_stamp_kind
)
688 if (pfile
->cb
.get_source_date_epoch
)
690 /* Try reading the fixed epoch. */
691 pfile
->time_stamp
= pfile
->cb
.get_source_date_epoch (pfile
);
692 if (pfile
->time_stamp
!= time_t (-1))
693 kind
= int (CPP_time_kind::FIXED
);
698 /* Pedantically time_t (-1) is a legitimate value for
699 "number of seconds since the Epoch". It is a silly
702 pfile
->time_stamp
= time (nullptr);
703 /* Annoyingly a library could legally set errno and return a
704 valid time! Bad library! */
705 if (pfile
->time_stamp
== time_t (-1) && errno
)
708 kind
= int (CPP_time_kind::DYNAMIC
);
711 pfile
->time_stamp_kind
= kind
;
714 *result
= pfile
->time_stamp
;
715 if (pfile
->time_stamp_kind
>= 0)
717 errno
= pfile
->time_stamp_kind
;
718 return CPP_time_kind::UNKNOWN
;
721 return CPP_time_kind (pfile
->time_stamp_kind
);
724 /* Convert builtin macros like __FILE__ to a token and push it on the
725 context stack. Also handles _Pragma, for which a new token may not
726 be created. Returns 1 if it generates a new token context, 0 to
727 return the token to the caller. LOC is the location of the expansion
728 point of the macro. */
730 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
731 location_t loc
, location_t expand_loc
)
737 if (node
->value
.builtin
== BT_PRAGMA
)
739 /* Don't interpret _Pragma within directives. The standard is
740 not clear on this, but to me this makes most sense. */
741 if (pfile
->state
.in_directive
)
744 return _cpp_do__Pragma (pfile
, loc
);
747 buf
= _cpp_builtin_macro_text (pfile
, node
, expand_loc
);
749 nbuf
= (char *) alloca (len
+ 1);
750 memcpy (nbuf
, buf
, len
);
753 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
754 _cpp_clean_line (pfile
);
756 /* Set pfile->cur_token as required by _cpp_lex_direct. */
757 pfile
->cur_token
= _cpp_temp_token (pfile
);
758 cpp_token
*token
= _cpp_lex_direct (pfile
);
759 /* We should point to the expansion point of the builtin macro. */
760 token
->src_loc
= loc
;
761 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
763 /* We are tracking tokens resulting from macro expansion.
764 Create a macro line map and generate a virtual location for
765 the token resulting from the expansion of the built-in
767 location_t
*virt_locs
= NULL
;
768 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
769 const line_map_macro
* map
=
770 linemap_enter_macro (pfile
->line_table
, node
, loc
, 1);
771 tokens_buff_add_token (token_buf
, virt_locs
, token
,
772 pfile
->line_table
->builtin_location
,
773 pfile
->line_table
->builtin_location
,
774 map
, /*macro_token_index=*/0);
775 push_extended_tokens_context (pfile
, node
, token_buf
, virt_locs
,
776 (const cpp_token
**)token_buf
->base
,
780 _cpp_push_token_context (pfile
, NULL
, token
, 1);
781 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
782 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
784 _cpp_pop_buffer (pfile
);
789 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
790 backslashes and double quotes. DEST must be of sufficient size.
791 Returns a pointer to the end of the string. */
793 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
802 /* Naked LF can appear in raw string literals */
819 /* Convert a token sequence ARG to a single string token according to
820 the rules of the ISO C #-operator. */
821 static const cpp_token
*
822 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
825 unsigned int i
, escape_it
, backslash_count
= 0;
826 const cpp_token
*source
= NULL
;
829 if (BUFF_ROOM (pfile
->u_buff
) < 3)
830 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
831 dest
= BUFF_FRONT (pfile
->u_buff
);
834 /* Loop, reading in the argument's tokens. */
835 for (i
= 0; i
< arg
->count
; i
++)
837 const cpp_token
*token
= arg
->first
[i
];
839 if (token
->type
== CPP_PADDING
)
842 || (!(source
->flags
& PREV_WHITE
)
843 && token
->val
.source
== NULL
))
844 source
= token
->val
.source
;
848 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
849 || token
->type
== CPP_WSTRING
|| token
->type
== CPP_WCHAR
850 || token
->type
== CPP_STRING32
|| token
->type
== CPP_CHAR32
851 || token
->type
== CPP_STRING16
|| token
->type
== CPP_CHAR16
852 || token
->type
== CPP_UTF8STRING
|| token
->type
== CPP_UTF8CHAR
853 || cpp_userdef_string_p (token
->type
)
854 || cpp_userdef_char_p (token
->type
));
856 /* Room for each char being written in octal, initial space and
857 final quote and NUL. */
858 len
= cpp_token_len (token
);
863 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
865 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
866 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
867 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
870 /* Leading white space? */
871 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
875 if (source
->flags
& PREV_WHITE
)
882 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
883 unsigned char *buf
= BUFF_FRONT (buff
);
884 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
885 dest
= cpp_quote_string (dest
, buf
, len
);
886 _cpp_release_buff (pfile
, buff
);
889 dest
= cpp_spell_token (pfile
, token
, dest
, true);
891 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
897 /* Ignore the final \ of invalid string literals. */
898 if (backslash_count
& 1)
900 cpp_error (pfile
, CPP_DL_WARNING
,
901 "invalid string literal, ignoring final '\\'");
905 /* Commit the memory, including NUL, and return the token. */
907 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
908 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
909 return new_string_token (pfile
, dest
- len
, len
);
912 /* Try to paste two tokens. On success, return nonzero. In any
913 case, PLHS is updated to point to the pasted token, which is
914 guaranteed to not have the PASTE_LEFT flag set. LOCATION is
915 the virtual location used for error reporting. */
917 paste_tokens (cpp_reader
*pfile
, location_t location
,
918 const cpp_token
**plhs
, const cpp_token
*rhs
)
920 unsigned char *buf
, *end
, *lhsend
;
924 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
925 buf
= (unsigned char *) alloca (len
);
926 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, true);
928 /* Avoid comment headers, since they are still processed in stage 3.
929 It is simpler to insert a space here, rather than modifying the
930 lexer to ignore comments in some circumstances. Simply returning
931 false doesn't work, since we want to clear the PASTE_LEFT flag. */
932 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
934 /* In one obscure case we might see padding here. */
935 if (rhs
->type
!= CPP_PADDING
)
936 end
= cpp_spell_token (pfile
, rhs
, end
, true);
939 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
940 _cpp_clean_line (pfile
);
942 /* Set pfile->cur_token as required by _cpp_lex_direct. */
943 pfile
->cur_token
= _cpp_temp_token (pfile
);
944 lhs
= _cpp_lex_direct (pfile
);
945 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
947 location_t saved_loc
= lhs
->src_loc
;
949 _cpp_pop_buffer (pfile
);
950 _cpp_backup_tokens (pfile
, 1);
953 /* We have to remove the PASTE_LEFT flag from the old lhs, but
954 we want to keep the new location. */
957 lhs
->src_loc
= saved_loc
;
958 lhs
->flags
&= ~PASTE_LEFT
;
960 /* Mandatory error for all apart from assembler. */
961 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
962 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
963 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
964 buf
, cpp_token_as_text (pfile
, rhs
));
969 _cpp_pop_buffer (pfile
);
973 /* Handles an arbitrarily long sequence of ## operators, with initial
974 operand LHS. This implementation is left-associative,
975 non-recursive, and finishes a paste before handling succeeding
976 ones. If a paste fails, we back up to the RHS of the failing ##
977 operator before pushing the context containing the result of prior
978 successful pastes, with the effect that the RHS appears in the
979 output stream after the pasted LHS normally. */
981 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
983 const cpp_token
*rhs
= NULL
;
984 cpp_context
*context
= pfile
->context
;
985 location_t virt_loc
= 0;
987 /* We are expanding a macro and we must have been called on a token
988 that appears at the left hand side of a ## operator. */
989 if (macro_of_context (pfile
->context
) == NULL
990 || (!(lhs
->flags
& PASTE_LEFT
)))
993 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
994 /* The caller must have called consume_next_token_from_context
995 right before calling us. That has incremented the pointer to
996 the current virtual location. So it now points to the location
997 of the token that comes right after *LHS. We want the
998 resulting pasted token to have the location of the current
1000 virt_loc
= context
->c
.mc
->cur_virt_loc
[-1];
1002 /* We are not tracking macro expansion. So the best virtual
1003 location we can get here is the expansion point of the macro we
1004 are currently expanding. */
1005 virt_loc
= pfile
->invocation_location
;
1009 /* Take the token directly from the current context. We can do
1010 this, because we are in the replacement list of either an
1011 object-like macro, or a function-like macro with arguments
1012 inserted. In either case, the constraints to #define
1013 guarantee we have at least one more token. */
1014 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
1015 rhs
= FIRST (context
).token
++;
1016 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
1017 rhs
= *FIRST (context
).ptoken
++;
1018 else if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
1020 /* So we are in presence of an extended token context, which
1021 means that each token in this context has a virtual
1022 location attached to it. So let's not forget to update
1023 the pointer to the current virtual location of the
1024 current token when we update the pointer to the current
1027 rhs
= *FIRST (context
).ptoken
++;
1028 /* context->c.mc must be non-null, as if we were not in a
1029 macro context, context->tokens_kind could not be equal to
1030 TOKENS_KIND_EXTENDED. */
1031 context
->c
.mc
->cur_virt_loc
++;
1034 if (rhs
->type
== CPP_PADDING
)
1036 if (rhs
->flags
& PASTE_LEFT
)
1039 if (!paste_tokens (pfile
, virt_loc
, &lhs
, rhs
))
1042 while (rhs
->flags
& PASTE_LEFT
);
1044 /* Put the resulting token in its own context. */
1045 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
1047 location_t
*virt_locs
= NULL
;
1048 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
1049 tokens_buff_add_token (token_buf
, virt_locs
, lhs
,
1050 virt_loc
, 0, NULL
, 0);
1051 push_extended_tokens_context (pfile
, context
->c
.mc
->macro_node
,
1052 token_buf
, virt_locs
,
1053 (const cpp_token
**)token_buf
->base
, 1);
1056 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
1059 /* Returns TRUE if the number of arguments ARGC supplied in an
1060 invocation of the MACRO referenced by NODE is valid. An empty
1061 invocation to a macro with no parameters should pass ARGC as zero.
1063 Note that MACRO cannot necessarily be deduced from NODE, in case
1064 NODE was redefined whilst collecting arguments. */
1066 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
1068 if (argc
== macro
->paramc
)
1071 if (argc
< macro
->paramc
)
1073 /* In C++20 (here the va_opt flag is used), and also as a GNU
1074 extension, variadic arguments are allowed to not appear in
1075 the invocation at all.
1076 e.g. #define debug(format, args...) something
1079 This is exactly the same as if an empty variadic list had been
1080 supplied - debug("string", ). */
1082 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
1084 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
1085 && ! CPP_OPTION (pfile
, va_opt
))
1087 if (CPP_OPTION (pfile
, cplusplus
))
1088 cpp_error (pfile
, CPP_DL_PEDWARN
,
1089 "ISO C++11 requires at least one argument "
1090 "for the \"...\" in a variadic macro");
1092 cpp_error (pfile
, CPP_DL_PEDWARN
,
1093 "ISO C99 requires at least one argument "
1094 "for the \"...\" in a variadic macro");
1099 cpp_error (pfile
, CPP_DL_ERROR
,
1100 "macro \"%s\" requires %u arguments, but only %u given",
1101 NODE_NAME (node
), macro
->paramc
, argc
);
1104 cpp_error (pfile
, CPP_DL_ERROR
,
1105 "macro \"%s\" passed %u arguments, but takes just %u",
1106 NODE_NAME (node
), argc
, macro
->paramc
);
1108 if (macro
->line
> RESERVED_LOCATION_COUNT
)
1109 cpp_error_at (pfile
, CPP_DL_NOTE
, macro
->line
, "macro \"%s\" defined here",
1115 /* Reads and returns the arguments to a function-like macro
1116 invocation. Assumes the opening parenthesis has been processed.
1117 If there is an error, emits an appropriate diagnostic and returns
1118 NULL. Each argument is terminated by a CPP_EOF token, for the
1119 future benefit of expand_arg(). If there are any deferred
1120 #pragma directives among macro arguments, store pointers to the
1121 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
1123 What is returned is the buffer that contains the memory allocated
1124 to hold the macro arguments. NODE is the name of the macro this
1125 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
1126 set to the actual number of macro arguments allocated in the
1129 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
,
1130 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1132 _cpp_buff
*buff
, *base_buff
;
1134 macro_arg
*args
, *arg
;
1135 const cpp_token
*token
;
1137 location_t virt_loc
;
1138 bool track_macro_expansion_p
= CPP_OPTION (pfile
, track_macro_expansion
);
1139 unsigned num_args_alloced
= 0;
1141 macro
= node
->value
.macro
;
1143 argc
= macro
->paramc
;
1147 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
1148 #define ARG_TOKENS_EXTENT 1000
1150 buff
= _cpp_get_buff (pfile
, argc
* (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
1151 * sizeof (cpp_token
*)
1152 + sizeof (macro_arg
)));
1154 args
= (macro_arg
*) buff
->base
;
1155 memset (args
, 0, argc
* sizeof (macro_arg
));
1156 buff
->cur
= (unsigned char *) &args
[argc
];
1157 arg
= args
, argc
= 0;
1159 /* Collect the tokens making up each argument. We don't yet know
1160 how many arguments have been supplied, whether too many or too
1161 few. Hence the slightly bizarre usage of "argc" and "arg". */
1164 unsigned int paren_depth
= 0;
1165 unsigned int ntokens
= 0;
1166 unsigned virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
1170 arg
->first
= (const cpp_token
**) buff
->cur
;
1171 if (track_macro_expansion_p
)
1173 virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
1174 arg
->virt_locs
= XNEWVEC (location_t
,
1175 virt_locs_capacity
);
1180 /* Require space for 2 new tokens (including a CPP_EOF). */
1181 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
1183 buff
= _cpp_append_extend_buff (pfile
, buff
,
1185 * sizeof (cpp_token
*));
1186 arg
->first
= (const cpp_token
**) buff
->cur
;
1188 if (track_macro_expansion_p
1189 && (ntokens
+ 2 > virt_locs_capacity
))
1191 virt_locs_capacity
+= ARG_TOKENS_EXTENT
;
1192 arg
->virt_locs
= XRESIZEVEC (location_t
,
1194 virt_locs_capacity
);
1197 token
= cpp_get_token_1 (pfile
, &virt_loc
);
1199 if (token
->type
== CPP_PADDING
)
1201 /* Drop leading padding. */
1205 else if (token
->type
== CPP_OPEN_PAREN
)
1207 else if (token
->type
== CPP_CLOSE_PAREN
)
1209 if (paren_depth
-- == 0)
1212 else if (token
->type
== CPP_COMMA
)
1214 /* A comma does not terminate an argument within
1215 parentheses or as part of a variable argument. */
1216 if (paren_depth
== 0
1217 && ! (macro
->variadic
&& argc
== macro
->paramc
))
1220 else if (token
->type
== CPP_EOF
1221 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
1223 else if (token
->type
== CPP_PRAGMA
)
1225 cpp_token
*newtok
= _cpp_temp_token (pfile
);
1227 /* CPP_PRAGMA token lives in directive_result, which will
1228 be overwritten on the next directive. */
1233 if (*pragma_buff
== NULL
1234 || BUFF_ROOM (*pragma_buff
) < sizeof (cpp_token
*))
1237 if (*pragma_buff
== NULL
)
1239 = _cpp_get_buff (pfile
, 32 * sizeof (cpp_token
*));
1242 next
= *pragma_buff
;
1244 = _cpp_get_buff (pfile
,
1245 (BUFF_FRONT (*pragma_buff
)
1246 - (*pragma_buff
)->base
) * 2);
1247 (*pragma_buff
)->next
= next
;
1250 *(const cpp_token
**) BUFF_FRONT (*pragma_buff
) = token
;
1251 BUFF_FRONT (*pragma_buff
) += sizeof (cpp_token
*);
1252 if (token
->type
== CPP_PRAGMA_EOL
)
1254 token
= cpp_get_token_1 (pfile
, &virt_loc
);
1256 while (token
->type
!= CPP_EOF
);
1258 /* In deferred pragmas parsing_args and prevent_expansion
1259 had been changed, reset it. */
1260 pfile
->state
.parsing_args
= 2;
1261 pfile
->state
.prevent_expansion
= 1;
1263 if (token
->type
== CPP_EOF
)
1268 set_arg_token (arg
, token
, virt_loc
,
1269 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1270 CPP_OPTION (pfile
, track_macro_expansion
));
1274 /* Drop trailing padding. */
1275 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
1278 arg
->count
= ntokens
;
1279 /* Append an EOF to mark end-of-argument. */
1280 set_arg_token (arg
, &pfile
->endarg
, token
->src_loc
,
1281 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1282 CPP_OPTION (pfile
, track_macro_expansion
));
1284 /* Terminate the argument. Excess arguments loop back and
1285 overwrite the final legitimate argument, before failing. */
1286 if (argc
<= macro
->paramc
)
1288 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
1289 if (argc
!= macro
->paramc
)
1293 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
1295 if (token
->type
== CPP_EOF
)
1297 /* Unless the EOF is marking the end of an argument, it's a fake
1298 one from the end of a file that _cpp_clean_line will not have
1300 if (token
== &pfile
->endarg
)
1301 _cpp_backup_tokens (pfile
, 1);
1302 cpp_error (pfile
, CPP_DL_ERROR
,
1303 "unterminated argument list invoking macro \"%s\"",
1308 /* A single empty argument is counted as no argument. */
1309 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
1311 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
1313 /* GCC has special semantics for , ## b where b is a varargs
1314 parameter: we remove the comma if b was omitted entirely.
1315 If b was merely an empty argument, the comma is retained.
1316 If the macro takes just one (varargs) parameter, then we
1317 retain the comma only if we are standards conforming.
1319 If FIRST is NULL replace_args () swallows the comma. */
1320 if (macro
->variadic
&& (argc
< macro
->paramc
1321 || (argc
== 1 && args
[0].count
== 0
1322 && !CPP_OPTION (pfile
, std
))))
1323 args
[macro
->paramc
- 1].first
= NULL
;
1325 *num_args
= num_args_alloced
;
1330 /* An error occurred. */
1331 _cpp_release_buff (pfile
, base_buff
);
1335 /* Search for an opening parenthesis to the macro of NODE, in such a
1336 way that, if none is found, we don't lose the information in any
1337 intervening padding tokens. If we find the parenthesis, collect
1338 the arguments and return the buffer containing them. PRAGMA_BUFF
1339 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
1340 *NUM_ARGS is set to the number of arguments contained in the
1343 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
1344 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1346 const cpp_token
*token
, *padding
= NULL
;
1350 token
= cpp_get_token (pfile
);
1351 if (token
->type
!= CPP_PADDING
)
1354 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
1358 if (token
->type
== CPP_OPEN_PAREN
)
1360 pfile
->state
.parsing_args
= 2;
1361 return collect_args (pfile
, node
, pragma_buff
, num_args
);
1364 /* Back up. A CPP_EOF is either an EOF from an argument we're
1365 expanding, or a fake one from lex_direct. We want to backup the
1366 former, but not the latter. We may have skipped padding, in
1367 which case backing up more than one token when expanding macros
1368 is in general too difficult. We re-insert it in its own
1370 if (token
->type
!= CPP_EOF
|| token
== &pfile
->endarg
)
1372 _cpp_backup_tokens (pfile
, 1);
1374 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
1380 /* Return the real number of tokens in the expansion of MACRO. */
1381 static inline unsigned int
1382 macro_real_token_count (const cpp_macro
*macro
)
1384 if (__builtin_expect (!macro
->extra_tokens
, true))
1385 return macro
->count
;
1387 for (unsigned i
= macro
->count
; i
--;)
1388 if (macro
->exp
.tokens
[i
].type
!= CPP_PASTE
)
1394 /* Push the context of a macro with hash entry NODE onto the context
1395 stack. If we can successfully expand the macro, we push a context
1396 containing its yet-to-be-rescanned replacement list and return one.
1397 If there were additionally any unexpanded deferred #pragma
1398 directives among macro arguments, push another context containing
1399 the pragma tokens before the yet-to-be-rescanned replacement list
1400 and return two. Otherwise, we don't push a context and return
1401 zero. LOCATION is the location of the expansion point of the
1404 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
1405 const cpp_token
*result
, location_t location
)
1407 /* The presence of a macro invalidates a file's controlling macro. */
1408 pfile
->mi_valid
= false;
1410 pfile
->state
.angled_headers
= false;
1412 /* From here to when we push the context for the macro later down
1413 this function, we need to flag the fact that we are about to
1414 expand a macro. This is useful when -ftrack-macro-expansion is
1415 turned off. In that case, we need to record the location of the
1416 expansion point of the top-most macro we are about to to expand,
1417 into pfile->invocation_location. But we must not record any such
1418 location once the process of expanding the macro starts; that is,
1419 we must not do that recording between now and later down this
1420 function where set this flag to FALSE. */
1421 pfile
->about_to_expand_macro_p
= true;
1423 if (cpp_user_macro_p (node
))
1425 cpp_macro
*macro
= node
->value
.macro
;
1426 _cpp_buff
*pragma_buff
= NULL
;
1428 if (macro
->fun_like
)
1431 unsigned num_args
= 0;
1433 pfile
->state
.prevent_expansion
++;
1434 pfile
->keep_tokens
++;
1435 pfile
->state
.parsing_args
= 1;
1436 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
,
1438 pfile
->state
.parsing_args
= 0;
1439 pfile
->keep_tokens
--;
1440 pfile
->state
.prevent_expansion
--;
1444 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
1445 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1446 "function-like macro \"%s\" must be used with arguments in traditional C",
1450 _cpp_release_buff (pfile
, pragma_buff
);
1452 pfile
->about_to_expand_macro_p
= false;
1456 if (macro
->paramc
> 0)
1457 replace_args (pfile
, node
, macro
,
1458 (macro_arg
*) buff
->base
,
1460 /* Free the memory used by the arguments of this
1461 function-like macro. This memory has been allocated by
1462 funlike_invocation_p and by replace_args. */
1463 delete_macro_args (buff
, num_args
);
1466 /* Disable the macro within its expansion. */
1467 node
->flags
|= NODE_DISABLED
;
1469 /* Laziness can only affect the expansion tokens of the macro,
1470 not its fun-likeness or parameters. */
1471 _cpp_maybe_notify_macro_use (pfile
, node
, location
);
1473 pfile
->cb
.used (pfile
, location
, node
);
1477 if (macro
->paramc
== 0)
1479 unsigned tokens_count
= macro_real_token_count (macro
);
1480 if (CPP_OPTION (pfile
, track_macro_expansion
))
1483 const cpp_token
*src
= macro
->exp
.tokens
;
1484 const line_map_macro
*map
;
1485 location_t
*virt_locs
= NULL
;
1486 _cpp_buff
*macro_tokens
1487 = tokens_buff_new (pfile
, tokens_count
, &virt_locs
);
1489 /* Create a macro map to record the locations of the
1490 tokens that are involved in the expansion. LOCATION
1491 is the location of the macro expansion point. */
1492 map
= linemap_enter_macro (pfile
->line_table
,
1493 node
, location
, tokens_count
);
1494 for (i
= 0; i
< tokens_count
; ++i
)
1496 tokens_buff_add_token (macro_tokens
, virt_locs
,
1498 src
->src_loc
, map
, i
);
1501 push_extended_tokens_context (pfile
, node
,
1504 (const cpp_token
**)
1509 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
,
1511 num_macro_tokens_counter
+= tokens_count
;
1516 if (!pfile
->state
.in_directive
)
1517 _cpp_push_token_context (pfile
, NULL
,
1518 padding_token (pfile
, result
), 1);
1521 unsigned tokens_count
;
1522 _cpp_buff
*tail
= pragma_buff
->next
;
1523 pragma_buff
->next
= NULL
;
1524 tokens_count
= ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
1525 - (const cpp_token
**) pragma_buff
->base
);
1526 push_ptoken_context (pfile
, NULL
, pragma_buff
,
1527 (const cpp_token
**) pragma_buff
->base
,
1530 if (!CPP_OPTION (pfile
, track_macro_expansion
))
1531 num_macro_tokens_counter
+= tokens_count
;
1534 while (pragma_buff
!= NULL
);
1535 pfile
->about_to_expand_macro_p
= false;
1539 pfile
->about_to_expand_macro_p
= false;
1543 pfile
->about_to_expand_macro_p
= false;
1544 /* Handle built-in macros and the _Pragma operator. */
1546 location_t expand_loc
;
1548 if (/* The top-level macro invocation that triggered the expansion
1549 we are looking at is with a function-like user macro ... */
1550 cpp_fun_like_macro_p (pfile
->top_most_macro_node
)
1551 /* ... and we are tracking the macro expansion. */
1552 && CPP_OPTION (pfile
, track_macro_expansion
))
1553 /* Then the location of the end of the macro invocation is the
1554 location of the expansion point of this macro. */
1555 expand_loc
= location
;
1557 /* Otherwise, the location of the end of the macro invocation is
1558 the location of the expansion point of that top-level macro
1560 expand_loc
= pfile
->invocation_location
;
1562 return builtin_macro (pfile
, node
, location
, expand_loc
);
1566 /* De-allocate the memory used by BUFF which is an array of instances
1567 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1570 delete_macro_args (_cpp_buff
*buff
, unsigned num_args
)
1572 macro_arg
*macro_args
;
1578 macro_args
= (macro_arg
*) buff
->base
;
1580 /* Walk instances of macro_arg to free their expanded tokens as well
1581 as their macro_arg::virt_locs members. */
1582 for (i
= 0; i
< num_args
; ++i
)
1584 if (macro_args
[i
].expanded
)
1586 free (macro_args
[i
].expanded
);
1587 macro_args
[i
].expanded
= NULL
;
1589 if (macro_args
[i
].virt_locs
)
1591 free (macro_args
[i
].virt_locs
);
1592 macro_args
[i
].virt_locs
= NULL
;
1594 if (macro_args
[i
].expanded_virt_locs
)
1596 free (macro_args
[i
].expanded_virt_locs
);
1597 macro_args
[i
].expanded_virt_locs
= NULL
;
1600 _cpp_free_buff (buff
);
1603 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1604 to set, LOCATION is its virtual location. "Virtual" location means
1605 the location that encodes loci across macro expansion. Otherwise
1606 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1607 argument ARG is supposed to contain. Note that ARG must be
1608 tailored so that it has enough room to contain INDEX + 1 numbers of
1609 tokens, at least. */
1611 set_arg_token (macro_arg
*arg
, const cpp_token
*token
,
1612 location_t location
, size_t index
,
1613 enum macro_arg_token_kind kind
,
1614 bool track_macro_exp_p
)
1616 const cpp_token
**token_ptr
;
1617 location_t
*loc
= NULL
;
1620 arg_token_ptr_at (arg
, index
, kind
,
1621 track_macro_exp_p
? &loc
: NULL
);
1626 /* We can't set the location of a stringified argument
1627 token and we can't set any location if we aren't tracking
1628 macro expansion locations. */
1629 gcc_checking_assert (kind
!= MACRO_ARG_TOKEN_STRINGIFIED
1630 && track_macro_exp_p
);
1635 /* Get the pointer to the location of the argument token of the
1636 function-like macro argument ARG. This function must be called
1637 only when we -ftrack-macro-expansion is on. */
1638 static const location_t
*
1639 get_arg_token_location (const macro_arg
*arg
,
1640 enum macro_arg_token_kind kind
)
1642 const location_t
*loc
= NULL
;
1643 const cpp_token
**token_ptr
=
1644 arg_token_ptr_at (arg
, 0, kind
, (location_t
**) &loc
);
1646 if (token_ptr
== NULL
)
1652 /* Return the pointer to the INDEXth token of the macro argument ARG.
1653 KIND specifies the kind of token the macro argument ARG contains.
1654 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1655 of the virtual location of the returned token if the
1656 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1657 spelling location of the returned token. */
1658 static const cpp_token
**
1659 arg_token_ptr_at (const macro_arg
*arg
, size_t index
,
1660 enum macro_arg_token_kind kind
,
1661 location_t
**virt_location
)
1663 const cpp_token
**tokens_ptr
= NULL
;
1667 case MACRO_ARG_TOKEN_NORMAL
:
1668 tokens_ptr
= arg
->first
;
1670 case MACRO_ARG_TOKEN_STRINGIFIED
:
1671 tokens_ptr
= (const cpp_token
**) &arg
->stringified
;
1673 case MACRO_ARG_TOKEN_EXPANDED
:
1674 tokens_ptr
= arg
->expanded
;
1678 if (tokens_ptr
== NULL
)
1679 /* This can happen for e.g, an empty token argument to a
1680 funtion-like macro. */
1685 if (kind
== MACRO_ARG_TOKEN_NORMAL
)
1686 *virt_location
= &arg
->virt_locs
[index
];
1687 else if (kind
== MACRO_ARG_TOKEN_EXPANDED
)
1688 *virt_location
= &arg
->expanded_virt_locs
[index
];
1689 else if (kind
== MACRO_ARG_TOKEN_STRINGIFIED
)
1691 (location_t
*) &tokens_ptr
[index
]->src_loc
;
1693 return &tokens_ptr
[index
];
1696 /* Initialize an iterator so that it iterates over the tokens of a
1697 function-like macro argument. KIND is the kind of tokens we want
1698 ITER to iterate over. TOKEN_PTR points the first token ITER will
1701 macro_arg_token_iter_init (macro_arg_token_iter
*iter
,
1702 bool track_macro_exp_p
,
1703 enum macro_arg_token_kind kind
,
1704 const macro_arg
*arg
,
1705 const cpp_token
**token_ptr
)
1707 iter
->track_macro_exp_p
= track_macro_exp_p
;
1709 iter
->token_ptr
= token_ptr
;
1710 /* Unconditionally initialize this so that the compiler doesn't warn
1711 about iter->location_ptr being possibly uninitialized later after
1712 this code has been inlined somewhere. */
1713 iter
->location_ptr
= NULL
;
1714 if (track_macro_exp_p
)
1715 iter
->location_ptr
= get_arg_token_location (arg
, kind
);
1717 iter
->num_forwards
= 0;
1718 if (track_macro_exp_p
1719 && token_ptr
!= NULL
1720 && iter
->location_ptr
== NULL
)
1725 /* Move the iterator one token forward. Note that if IT was
1726 initialized on an argument that has a stringified token, moving it
1727 forward doesn't make sense as a stringified token is essentially one
1730 macro_arg_token_iter_forward (macro_arg_token_iter
*it
)
1734 case MACRO_ARG_TOKEN_NORMAL
:
1735 case MACRO_ARG_TOKEN_EXPANDED
:
1737 if (it
->track_macro_exp_p
)
1740 case MACRO_ARG_TOKEN_STRINGIFIED
:
1742 if (it
->num_forwards
> 0)
1753 /* Return the token pointed to by the iterator. */
1754 static const cpp_token
*
1755 macro_arg_token_iter_get_token (const macro_arg_token_iter
*it
)
1758 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1759 && it
->num_forwards
> 0)
1762 if (it
->token_ptr
== NULL
)
1764 return *it
->token_ptr
;
1767 /* Return the location of the token pointed to by the iterator.*/
1769 macro_arg_token_iter_get_location (const macro_arg_token_iter
*it
)
1772 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1773 && it
->num_forwards
> 0)
1776 if (it
->track_macro_exp_p
)
1777 return *it
->location_ptr
;
1779 return (*it
->token_ptr
)->src_loc
;
1782 /* Return the index of a token [resulting from macro expansion] inside
1783 the total list of tokens resulting from a given macro
1784 expansion. The index can be different depending on whether if we
1785 want each tokens resulting from function-like macro arguments
1786 expansion to have a different location or not.
1788 E.g, consider this function-like macro:
1792 Then consider us "calling" it (and thus expanding it) like:
1796 It will be expanded into:
1800 Let's consider the case of the token '4'.
1802 Its index can be 2 (it's the third token of the set of tokens
1803 resulting from the expansion) or it can be 0 if we consider that
1804 all tokens resulting from the expansion of the argument "1+2" have
1805 the same index, which is 0. In this later case, the index of token
1806 '-' would then be 1 and the index of token '3' would be 2.
1808 The later case is useful to use less memory e.g, for the case of
1809 the user using the option -ftrack-macro-expansion=1.
1811 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1812 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1813 parameter (inside the macro replacement list) that corresponds to
1814 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1817 If we refer to the example above, for the '4' argument token,
1818 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1819 would be set to the token 'x', in the replacement list "x - 3" of
1822 This is a subroutine of replace_args. */
1823 inline static unsigned
1824 expanded_token_index (cpp_reader
*pfile
, cpp_macro
*macro
,
1825 const cpp_token
*cur_replacement_token
,
1826 unsigned absolute_token_index
)
1828 if (CPP_OPTION (pfile
, track_macro_expansion
) > 1)
1829 return absolute_token_index
;
1830 return cur_replacement_token
- macro
->exp
.tokens
;
1833 /* Copy whether PASTE_LEFT is set from SRC to *PASTE_FLAG. */
1836 copy_paste_flag (cpp_reader
*pfile
, const cpp_token
**paste_flag
,
1837 const cpp_token
*src
)
1839 cpp_token
*token
= _cpp_temp_token (pfile
);
1840 token
->type
= (*paste_flag
)->type
;
1841 token
->val
= (*paste_flag
)->val
;
1842 if (src
->flags
& PASTE_LEFT
)
1843 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1845 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1846 *paste_flag
= token
;
1849 /* True IFF the last token emitted into BUFF (if any) is PTR. */
1852 last_token_is (_cpp_buff
*buff
, const cpp_token
**ptr
)
1854 return (ptr
&& tokens_buff_last_token_ptr (buff
) == ptr
);
1857 /* Replace the parameters in a function-like macro of NODE with the
1858 actual ARGS, and place the result in a newly pushed token context.
1859 Expand each argument before replacing, unless it is operated upon
1860 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1861 the expansion point of the macro. E.g, the location of the
1862 function-like macro invocation. */
1864 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
,
1865 macro_arg
*args
, location_t expansion_point_loc
)
1867 unsigned int i
, total
;
1868 const cpp_token
*src
, *limit
;
1869 const cpp_token
**first
= NULL
;
1871 _cpp_buff
*buff
= NULL
;
1872 location_t
*virt_locs
= NULL
;
1873 unsigned int exp_count
;
1874 const line_map_macro
*map
= NULL
;
1875 int track_macro_exp
;
1877 /* First, fully macro-expand arguments, calculating the number of
1878 tokens in the final expansion as we go. The ordering of the if
1879 statements below is subtle; we must handle stringification before
1882 /* EXP_COUNT is the number of tokens in the macro replacement
1883 list. TOTAL is the number of tokens /after/ macro parameters
1884 have been replaced by their arguments. */
1885 exp_count
= macro_real_token_count (macro
);
1887 limit
= macro
->exp
.tokens
+ exp_count
;
1889 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1890 if (src
->type
== CPP_MACRO_ARG
)
1892 /* Leading and trailing padding tokens. */
1894 /* Account for leading and padding tokens in exp_count too.
1895 This is going to be important later down this function,
1896 when we want to handle the case of (track_macro_exp <
1900 /* We have an argument. If it is not being stringified or
1901 pasted it is macro-replaced before insertion. */
1902 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
1904 if (src
->flags
& STRINGIFY_ARG
)
1906 if (!arg
->stringified
)
1907 arg
->stringified
= stringify_arg (pfile
, arg
);
1909 else if ((src
->flags
& PASTE_LEFT
)
1910 || (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
1911 total
+= arg
->count
- 1;
1915 expand_arg (pfile
, arg
);
1916 total
+= arg
->expanded_count
- 1;
1920 /* When the compiler is called with the -ftrack-macro-expansion
1921 flag, we need to keep track of the location of each token that
1922 results from macro expansion.
1924 A token resulting from macro expansion is not a new token. It is
1925 simply the same token as the token coming from the macro
1926 definition. The new things that are allocated are the buffer
1927 that holds the tokens resulting from macro expansion and a new
1928 location that records many things like the locus of the expansion
1929 point as well as the original locus inside the definition of the
1930 macro. This location is called a virtual location.
1932 So the buffer BUFF holds a set of cpp_token*, and the buffer
1933 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1935 Both of these two buffers are going to be hung off of the macro
1936 context, when the latter is pushed. The memory allocated to
1937 store the tokens and their locations is going to be freed once
1938 the context of macro expansion is popped.
1940 As far as tokens are concerned, the memory overhead of
1941 -ftrack-macro-expansion is proportional to the number of
1942 macros that get expanded multiplied by sizeof (location_t).
1943 The good news is that extra memory gets freed when the macro
1944 context is freed, i.e shortly after the macro got expanded. */
1946 /* Is the -ftrack-macro-expansion flag in effect? */
1947 track_macro_exp
= CPP_OPTION (pfile
, track_macro_expansion
);
1949 /* Now allocate memory space for tokens and locations resulting from
1950 the macro expansion, copy the tokens and replace the arguments.
1951 This memory must be freed when the context of the macro MACRO is
1953 buff
= tokens_buff_new (pfile
, total
, track_macro_exp
? &virt_locs
: NULL
);
1955 first
= (const cpp_token
**) buff
->base
;
1957 /* Create a macro map to record the locations of the tokens that are
1958 involved in the expansion. Note that the expansion point is set
1959 to the location of the closing parenthesis. Otherwise, the
1960 subsequent map created for the first token that comes after the
1961 macro map might have a wrong line number. That would lead to
1962 tokens with wrong line numbers after the macro expansion. This
1963 adds up to the memory overhead of the -ftrack-macro-expansion
1964 flag; for every macro that is expanded, a "macro map" is
1966 if (track_macro_exp
)
1968 int num_macro_tokens
= total
;
1969 if (track_macro_exp
< 2)
1970 /* Then the number of macro tokens won't take in account the
1971 fact that function-like macro arguments can expand to
1972 multiple tokens. This is to save memory at the expense of
1975 Suppose we have #define SQUARE(A) A * A
1977 And then we do SQUARE(2+3)
1979 Then the tokens 2, +, 3, will have the same location,
1980 saying they come from the expansion of the argument A. */
1981 num_macro_tokens
= exp_count
;
1982 map
= linemap_enter_macro (pfile
->line_table
, node
,
1983 expansion_point_loc
,
1987 vaopt_state
vaopt_tracker (pfile
, macro
->variadic
, &args
[macro
->paramc
- 1]);
1988 const cpp_token
**vaopt_start
= NULL
;
1989 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1991 unsigned int arg_tokens_count
;
1992 macro_arg_token_iter from
;
1993 const cpp_token
**paste_flag
= NULL
;
1994 const cpp_token
**tmp_token_ptr
;
1996 /* __VA_OPT__ handling. */
1997 vaopt_state::update_type vostate
= vaopt_tracker
.update (src
);
1998 if (vostate
!= vaopt_state::INCLUDE
)
2000 if (vostate
== vaopt_state::BEGIN
)
2002 /* Padding on the left of __VA_OPT__ (unless RHS of ##). */
2003 if (src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
2005 const cpp_token
*t
= padding_token (pfile
, src
);
2006 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2007 /* Allocate a virtual location for the padding token and
2008 append the token and its location to BUFF and
2010 tokens_buff_add_token (buff
, virt_locs
, t
,
2011 t
->src_loc
, t
->src_loc
,
2014 vaopt_start
= tokens_buff_last_token_ptr (buff
);
2016 else if (vostate
== vaopt_state::END
)
2018 const cpp_token
**start
= vaopt_start
;
2021 /* Remove any tail padding from inside the __VA_OPT__. */
2022 paste_flag
= tokens_buff_last_token_ptr (buff
);
2023 while (paste_flag
&& paste_flag
!= start
2024 && (*paste_flag
)->type
== CPP_PADDING
)
2026 tokens_buff_remove_last_token (buff
);
2027 paste_flag
= tokens_buff_last_token_ptr (buff
);
2030 if (src
->flags
& PASTE_LEFT
)
2032 /* With a non-empty __VA_OPT__ on the LHS of ##, the last
2033 token should be flagged PASTE_LEFT. */
2034 if (paste_flag
&& (*paste_flag
)->type
!= CPP_PADDING
)
2035 copy_paste_flag (pfile
, paste_flag
, src
);
2039 /* Otherwise, avoid paste on RHS, __VA_OPT__(c)d or
2040 __VA_OPT__(c)__VA_OPT__(d). */
2041 const cpp_token
*t
= &pfile
->avoid_paste
;
2042 tokens_buff_add_token (buff
, virt_locs
,
2043 t
, t
->src_loc
, t
->src_loc
,
2050 if (src
->type
!= CPP_MACRO_ARG
)
2052 /* Allocate a virtual location for token SRC, and add that
2053 token and its virtual location into the buffers BUFF and
2055 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2056 tokens_buff_add_token (buff
, virt_locs
, src
,
2057 src
->src_loc
, src
->src_loc
,
2064 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
2065 /* SRC is a macro parameter that we need to replace with its
2066 corresponding argument. So at some point we'll need to
2067 iterate over the tokens of the macro argument and copy them
2068 into the "place" now holding the correspondig macro
2069 parameter. We are going to use the iterator type
2070 macro_argo_token_iter to handle that iterating. The 'if'
2071 below is to initialize the iterator depending on the type of
2072 tokens the macro argument has. It also does some adjustment
2073 related to padding tokens and some pasting corner cases. */
2074 if (src
->flags
& STRINGIFY_ARG
)
2076 arg_tokens_count
= 1;
2077 macro_arg_token_iter_init (&from
,
2079 track_macro_expansion
),
2080 MACRO_ARG_TOKEN_STRINGIFIED
,
2081 arg
, &arg
->stringified
);
2083 else if (src
->flags
& PASTE_LEFT
)
2085 arg_tokens_count
= arg
->count
;
2086 macro_arg_token_iter_init (&from
,
2088 track_macro_expansion
),
2089 MACRO_ARG_TOKEN_NORMAL
,
2092 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
2095 arg_tokens_count
= arg
->count
;
2096 macro_arg_token_iter_init (&from
,
2098 track_macro_expansion
),
2099 MACRO_ARG_TOKEN_NORMAL
,
2102 num_toks
= tokens_buff_count (buff
);
2106 /* So the current parameter token is pasted to the previous
2107 token in the replacement list. Let's look at what
2108 we have as previous and current arguments. */
2110 /* This is the previous argument's token ... */
2111 tmp_token_ptr
= tokens_buff_last_token_ptr (buff
);
2113 if ((*tmp_token_ptr
)->type
== CPP_COMMA
2115 && src
->val
.macro_arg
.arg_no
== macro
->paramc
)
2117 /* ... which is a comma; and the current parameter
2118 is the last parameter of a variadic function-like
2119 macro. If the argument to the current last
2120 parameter is NULL, then swallow the comma,
2121 otherwise drop the paste flag. */
2122 if (macro_arg_token_iter_get_token (&from
) == NULL
)
2123 tokens_buff_remove_last_token (buff
);
2125 paste_flag
= tmp_token_ptr
;
2127 /* Remove the paste flag if the RHS is a placemarker, unless the
2128 previous emitted token is at the beginning of __VA_OPT__;
2129 placemarkers within __VA_OPT__ are ignored in that case. */
2130 else if (arg_tokens_count
== 0
2131 && tmp_token_ptr
!= vaopt_start
)
2132 paste_flag
= tmp_token_ptr
;
2137 arg_tokens_count
= arg
->expanded_count
;
2138 macro_arg_token_iter_init (&from
,
2140 track_macro_expansion
),
2141 MACRO_ARG_TOKEN_EXPANDED
,
2142 arg
, arg
->expanded
);
2144 if (last_token_is (buff
, vaopt_start
))
2146 /* We're expanding an arg at the beginning of __VA_OPT__.
2148 while (arg_tokens_count
)
2150 const cpp_token
*t
= macro_arg_token_iter_get_token (&from
);
2151 if (t
->type
!= CPP_PADDING
)
2153 macro_arg_token_iter_forward (&from
);
2159 /* Padding on the left of an argument (unless RHS of ##). */
2160 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
2161 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
)
2162 && !last_token_is (buff
, vaopt_start
))
2164 const cpp_token
*t
= padding_token (pfile
, src
);
2165 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2166 /* Allocate a virtual location for the padding token and
2167 append the token and its location to BUFF and
2169 tokens_buff_add_token (buff
, virt_locs
, t
,
2170 t
->src_loc
, t
->src_loc
,
2174 if (arg_tokens_count
)
2176 /* So now we've got the number of tokens that make up the
2177 argument that is going to replace the current parameter
2178 in the macro's replacement list. */
2180 for (j
= 0; j
< arg_tokens_count
; ++j
)
2182 /* So if track_macro_exp is < 2, the user wants to
2183 save extra memory while tracking macro expansion
2184 locations. So in that case here is what we do:
2186 Suppose we have #define SQUARE(A) A * A
2188 And then we do SQUARE(2+3)
2190 Then the tokens 2, +, 3, will have the same location,
2191 saying they come from the expansion of the argument
2194 So that means we are going to ignore the COUNT tokens
2195 resulting from the expansion of the current macro
2196 argument. In other words all the ARG_TOKENS_COUNT tokens
2197 resulting from the expansion of the macro argument will
2198 have the index I. Normally, each of those tokens should
2200 unsigned token_index
= i
;
2202 if (track_macro_exp
> 1)
2205 index
= expanded_token_index (pfile
, macro
, src
, token_index
);
2206 tokens_buff_add_token (buff
, virt_locs
,
2207 macro_arg_token_iter_get_token (&from
),
2208 macro_arg_token_iter_get_location (&from
),
2209 src
->src_loc
, map
, index
);
2210 macro_arg_token_iter_forward (&from
);
2213 /* With a non-empty argument on the LHS of ##, the last
2214 token should be flagged PASTE_LEFT. */
2215 if (src
->flags
& PASTE_LEFT
)
2217 = (const cpp_token
**) tokens_buff_last_token_ptr (buff
);
2219 else if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, c99
)
2220 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2222 if (CPP_OPTION (pfile
, cplusplus
))
2223 cpp_pedwarning (pfile
, CPP_W_PEDANTIC
,
2224 "invoking macro %s argument %d: "
2225 "empty macro arguments are undefined"
2227 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2228 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
))
2229 cpp_pedwarning (pfile
,
2230 CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2231 ? CPP_W_C90_C99_COMPAT
: CPP_W_PEDANTIC
,
2232 "invoking macro %s argument %d: "
2233 "empty macro arguments are undefined"
2235 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2237 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2238 && ! CPP_OPTION (pfile
, cplusplus
)
2239 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2240 cpp_warning (pfile
, CPP_W_C90_C99_COMPAT
,
2241 "invoking macro %s argument %d: "
2242 "empty macro arguments are undefined"
2244 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2246 /* Avoid paste on RHS (even case count == 0). */
2247 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
)
2248 && !last_token_is (buff
, vaopt_start
))
2250 const cpp_token
*t
= &pfile
->avoid_paste
;
2251 tokens_buff_add_token (buff
, virt_locs
,
2252 t
, t
->src_loc
, t
->src_loc
,
2256 /* Add a new paste flag, or remove an unwanted one. */
2258 copy_paste_flag (pfile
, paste_flag
, src
);
2260 i
+= arg_tokens_count
;
2263 if (track_macro_exp
)
2264 push_extended_tokens_context (pfile
, node
, buff
, virt_locs
, first
,
2265 tokens_buff_count (buff
));
2267 push_ptoken_context (pfile
, node
, buff
, first
,
2268 tokens_buff_count (buff
));
2270 num_macro_tokens_counter
+= tokens_buff_count (buff
);
2273 /* Return a special padding token, with padding inherited from SOURCE. */
2274 static const cpp_token
*
2275 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
2277 cpp_token
*result
= _cpp_temp_token (pfile
);
2279 result
->type
= CPP_PADDING
;
2281 /* Data in GCed data structures cannot be made const so far, so we
2282 need a cast here. */
2283 result
->val
.source
= (cpp_token
*) source
;
2288 /* Get a new uninitialized context. Create a new one if we cannot
2289 re-use an old one. */
2290 static cpp_context
*
2291 next_context (cpp_reader
*pfile
)
2293 cpp_context
*result
= pfile
->context
->next
;
2297 result
= XNEW (cpp_context
);
2298 memset (result
, 0, sizeof (cpp_context
));
2299 result
->prev
= pfile
->context
;
2301 pfile
->context
->next
= result
;
2304 pfile
->context
= result
;
2308 /* Push a list of pointers to tokens. */
2310 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
2311 const cpp_token
**first
, unsigned int count
)
2313 cpp_context
*context
= next_context (pfile
);
2315 context
->tokens_kind
= TOKENS_KIND_INDIRECT
;
2316 context
->c
.macro
= macro
;
2317 context
->buff
= buff
;
2318 FIRST (context
).ptoken
= first
;
2319 LAST (context
).ptoken
= first
+ count
;
2322 /* Push a list of tokens.
2324 A NULL macro means that we should continue the current macro
2325 expansion, in essence. That means that if we are currently in a
2326 macro expansion context, we'll make the new pfile->context refer to
2327 the current macro. */
2329 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2330 const cpp_token
*first
, unsigned int count
)
2332 cpp_context
*context
;
2335 macro
= macro_of_context (pfile
->context
);
2337 context
= next_context (pfile
);
2338 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2339 context
->c
.macro
= macro
;
2340 context
->buff
= NULL
;
2341 FIRST (context
).token
= first
;
2342 LAST (context
).token
= first
+ count
;
2345 /* Build a context containing a list of tokens as well as their
2346 virtual locations and push it. TOKENS_BUFF is the buffer that
2347 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
2348 non-NULL, it means that the context owns it, meaning that
2349 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
2350 contains the virtual locations.
2352 A NULL macro means that we should continue the current macro
2353 expansion, in essence. That means that if we are currently in a
2354 macro expansion context, we'll make the new pfile->context refer to
2355 the current macro. */
2357 push_extended_tokens_context (cpp_reader
*pfile
,
2358 cpp_hashnode
*macro
,
2359 _cpp_buff
*token_buff
,
2360 location_t
*virt_locs
,
2361 const cpp_token
**first
,
2364 cpp_context
*context
;
2368 macro
= macro_of_context (pfile
->context
);
2370 context
= next_context (pfile
);
2371 context
->tokens_kind
= TOKENS_KIND_EXTENDED
;
2372 context
->buff
= token_buff
;
2374 m
= XNEW (macro_context
);
2375 m
->macro_node
= macro
;
2376 m
->virt_locs
= virt_locs
;
2377 m
->cur_virt_loc
= virt_locs
;
2379 FIRST (context
).ptoken
= first
;
2380 LAST (context
).ptoken
= first
+ count
;
2383 /* Push a traditional macro's replacement text. */
2385 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2386 const uchar
*start
, size_t len
)
2388 cpp_context
*context
= next_context (pfile
);
2390 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2391 context
->c
.macro
= macro
;
2392 context
->buff
= NULL
;
2393 CUR (context
) = start
;
2394 RLIMIT (context
) = start
+ len
;
2395 macro
->flags
|= NODE_DISABLED
;
2398 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
2399 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
2400 non-null (which means that -ftrack-macro-expansion is on),
2401 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
2402 hold the virtual locations of the tokens resulting from macro
2405 tokens_buff_new (cpp_reader
*pfile
, size_t len
,
2406 location_t
**virt_locs
)
2408 size_t tokens_size
= len
* sizeof (cpp_token
*);
2409 size_t locs_size
= len
* sizeof (location_t
);
2411 if (virt_locs
!= NULL
)
2412 *virt_locs
= XNEWVEC (location_t
, locs_size
);
2413 return _cpp_get_buff (pfile
, tokens_size
);
2416 /* Returns the number of tokens contained in a token buffer. The
2417 buffer holds a set of cpp_token*. */
2419 tokens_buff_count (_cpp_buff
*buff
)
2421 return (BUFF_FRONT (buff
) - buff
->base
) / sizeof (cpp_token
*);
2424 /* Return a pointer to the last token contained in the token buffer
2426 static const cpp_token
**
2427 tokens_buff_last_token_ptr (_cpp_buff
*buff
)
2429 if (BUFF_FRONT (buff
) == buff
->base
)
2431 return &((const cpp_token
**) BUFF_FRONT (buff
))[-1];
2434 /* Remove the last token contained in the token buffer TOKENS_BUFF.
2435 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
2436 containing the virtual locations of the tokens in TOKENS_BUFF; in
2437 which case the function updates that buffer as well. */
2439 tokens_buff_remove_last_token (_cpp_buff
*tokens_buff
)
2442 if (BUFF_FRONT (tokens_buff
) > tokens_buff
->base
)
2443 BUFF_FRONT (tokens_buff
) =
2444 (unsigned char *) &((cpp_token
**) BUFF_FRONT (tokens_buff
))[-1];
2447 /* Insert a token into the token buffer at the position pointed to by
2448 DEST. Note that the buffer is not enlarged so the previous token
2449 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
2450 means -ftrack-macro-expansion is effect; it then points to where to
2451 insert the virtual location of TOKEN. TOKEN is the token to
2452 insert. VIRT_LOC is the virtual location of the token, i.e, the
2453 location possibly encoding its locus across macro expansion. If
2454 TOKEN is an argument of a function-like macro (inside a macro
2455 replacement list), PARM_DEF_LOC is the spelling location of the
2456 macro parameter that TOKEN is replacing, in the replacement list of
2457 the macro. If TOKEN is not an argument of a function-like macro or
2458 if it doesn't come from a macro expansion, then VIRT_LOC can just
2459 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
2460 means TOKEN comes from a macro expansion and MAP is the macro map
2461 associated to the macro. MACRO_TOKEN_INDEX points to the index of
2462 the token in the macro map; it is not considered if MAP is NULL.
2464 Upon successful completion this function returns the a pointer to
2465 the position of the token coming right after the insertion
2467 static inline const cpp_token
**
2468 tokens_buff_put_token_to (const cpp_token
**dest
,
2469 location_t
*virt_loc_dest
,
2470 const cpp_token
*token
,
2471 location_t virt_loc
,
2472 location_t parm_def_loc
,
2473 const line_map_macro
*map
,
2474 unsigned int macro_token_index
)
2476 location_t macro_loc
= virt_loc
;
2477 const cpp_token
**result
;
2481 /* -ftrack-macro-expansion is on. */
2483 macro_loc
= linemap_add_macro_token (map
, macro_token_index
,
2484 virt_loc
, parm_def_loc
);
2485 *virt_loc_dest
= macro_loc
;
2493 /* Adds a token at the end of the tokens contained in BUFFER. Note
2494 that this function doesn't enlarge BUFFER when the number of tokens
2495 reaches BUFFER's size; it aborts in that situation.
2497 TOKEN is the token to append. VIRT_LOC is the virtual location of
2498 the token, i.e, the location possibly encoding its locus across
2499 macro expansion. If TOKEN is an argument of a function-like macro
2500 (inside a macro replacement list), PARM_DEF_LOC is the location of
2501 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
2502 from a macro expansion, then VIRT_LOC can just be set to the same
2503 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
2504 from a macro expansion and MAP is the macro map associated to the
2505 macro. MACRO_TOKEN_INDEX points to the index of the token in the
2506 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
2507 non-null, it means -ftrack-macro-expansion is on; in which case
2508 this function adds the virtual location DEF_LOC to the VIRT_LOCS
2509 array, at the same index as the one of TOKEN in BUFFER. Upon
2510 successful completion this function returns the a pointer to the
2511 position of the token coming right after the insertion point. */
2512 static const cpp_token
**
2513 tokens_buff_add_token (_cpp_buff
*buffer
,
2514 location_t
*virt_locs
,
2515 const cpp_token
*token
,
2516 location_t virt_loc
,
2517 location_t parm_def_loc
,
2518 const line_map_macro
*map
,
2519 unsigned int macro_token_index
)
2521 const cpp_token
**result
;
2522 location_t
*virt_loc_dest
= NULL
;
2523 unsigned token_index
=
2524 (BUFF_FRONT (buffer
) - buffer
->base
) / sizeof (cpp_token
*);
2526 /* Abort if we pass the end the buffer. */
2527 if (BUFF_FRONT (buffer
) > BUFF_LIMIT (buffer
))
2530 if (virt_locs
!= NULL
)
2531 virt_loc_dest
= &virt_locs
[token_index
];
2534 tokens_buff_put_token_to ((const cpp_token
**) BUFF_FRONT (buffer
),
2535 virt_loc_dest
, token
, virt_loc
, parm_def_loc
,
2536 map
, macro_token_index
);
2538 BUFF_FRONT (buffer
) = (unsigned char *) result
;
2542 /* Allocate space for the function-like macro argument ARG to store
2543 the tokens resulting from the macro-expansion of the tokens that
2544 make up ARG itself. That space is allocated in ARG->expanded and
2545 needs to be freed using free. */
2547 alloc_expanded_arg_mem (cpp_reader
*pfile
, macro_arg
*arg
, size_t capacity
)
2549 gcc_checking_assert (arg
->expanded
== NULL
2550 && arg
->expanded_virt_locs
== NULL
);
2552 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
2553 if (CPP_OPTION (pfile
, track_macro_expansion
))
2554 arg
->expanded_virt_locs
= XNEWVEC (location_t
, capacity
);
2558 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2561 ensure_expanded_arg_room (cpp_reader
*pfile
, macro_arg
*arg
,
2562 size_t size
, size_t *expanded_capacity
)
2564 if (size
<= *expanded_capacity
)
2570 XRESIZEVEC (const cpp_token
*, arg
->expanded
, size
);
2571 *expanded_capacity
= size
;
2573 if (CPP_OPTION (pfile
, track_macro_expansion
))
2575 if (arg
->expanded_virt_locs
== NULL
)
2576 arg
->expanded_virt_locs
= XNEWVEC (location_t
, size
);
2578 arg
->expanded_virt_locs
= XRESIZEVEC (location_t
,
2579 arg
->expanded_virt_locs
,
2584 /* Expand an argument ARG before replacing parameters in a
2585 function-like macro. This works by pushing a context with the
2586 argument's tokens, and then expanding that into a temporary buffer
2587 as if it were a normal part of the token stream. collect_args()
2588 has terminated the argument's tokens with a CPP_EOF so that we know
2589 when we have fully expanded the argument. */
2591 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
2594 bool saved_warn_trad
;
2595 bool track_macro_exp_p
= CPP_OPTION (pfile
, track_macro_expansion
);
2598 || arg
->expanded
!= NULL
)
2601 /* Don't warn about funlike macros when pre-expanding. */
2602 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
2603 CPP_WTRADITIONAL (pfile
) = 0;
2605 /* Loop, reading in the tokens of the argument. */
2607 alloc_expanded_arg_mem (pfile
, arg
, capacity
);
2609 if (track_macro_exp_p
)
2610 push_extended_tokens_context (pfile
, NULL
, NULL
,
2615 push_ptoken_context (pfile
, NULL
, NULL
,
2616 arg
->first
, arg
->count
+ 1);
2620 const cpp_token
*token
;
2621 location_t location
;
2623 ensure_expanded_arg_room (pfile
, arg
, arg
->expanded_count
+ 1,
2626 token
= cpp_get_token_1 (pfile
, &location
);
2628 if (token
->type
== CPP_EOF
)
2631 set_arg_token (arg
, token
, location
,
2632 arg
->expanded_count
, MACRO_ARG_TOKEN_EXPANDED
,
2633 CPP_OPTION (pfile
, track_macro_expansion
));
2634 arg
->expanded_count
++;
2637 _cpp_pop_context (pfile
);
2639 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
2642 /* Returns the macro associated to the current context if we are in
2643 the context a macro expansion, NULL otherwise. */
2644 static cpp_hashnode
*
2645 macro_of_context (cpp_context
*context
)
2647 if (context
== NULL
)
2650 return (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2651 ? context
->c
.mc
->macro_node
2655 /* Return TRUE iff we are expanding a macro or are about to start
2656 expanding one. If we are effectively expanding a macro, the
2657 function macro_of_context returns a pointer to the macro being
2660 in_macro_expansion_p (cpp_reader
*pfile
)
2665 return (pfile
->about_to_expand_macro_p
2666 || macro_of_context (pfile
->context
));
2669 /* Pop the current context off the stack, re-enabling the macro if the
2670 context represented a macro's replacement list. Initially the
2671 context structure was not freed so that we can re-use it later, but
2672 now we do free it to reduce peak memory consumption. */
2674 _cpp_pop_context (cpp_reader
*pfile
)
2676 cpp_context
*context
= pfile
->context
;
2678 /* We should not be popping the base context. */
2679 gcc_assert (context
!= &pfile
->base_context
);
2681 if (context
->c
.macro
)
2683 cpp_hashnode
*macro
;
2684 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2686 macro_context
*mc
= context
->c
.mc
;
2687 macro
= mc
->macro_node
;
2688 /* If context->buff is set, it means the life time of tokens
2689 is bound to the life time of this context; so we must
2690 free the tokens; that means we must free the virtual
2691 locations of these tokens too. */
2692 if (context
->buff
&& mc
->virt_locs
)
2694 free (mc
->virt_locs
);
2695 mc
->virt_locs
= NULL
;
2698 context
->c
.mc
= NULL
;
2701 macro
= context
->c
.macro
;
2703 /* Beware that MACRO can be NULL in cases like when we are
2704 called from expand_arg. In those cases, a dummy context with
2705 tokens is pushed just for the purpose of walking them using
2706 cpp_get_token_1. In that case, no 'macro' field is set into
2707 the dummy context. */
2709 /* Several contiguous macro expansion contexts can be
2710 associated to the same macro; that means it's the same
2711 macro expansion that spans across all these (sub)
2712 contexts. So we should re-enable an expansion-disabled
2713 macro only when we are sure we are really out of that
2715 && macro_of_context (context
->prev
) != macro
)
2716 macro
->flags
&= ~NODE_DISABLED
;
2718 if (macro
== pfile
->top_most_macro_node
&& context
->prev
== NULL
)
2719 /* We are popping the context of the top-most macro node. */
2720 pfile
->top_most_macro_node
= NULL
;
2725 /* Decrease memory peak consumption by freeing the memory used
2727 _cpp_free_buff (context
->buff
);
2730 pfile
->context
= context
->prev
;
2731 /* decrease peak memory consumption by feeing the context. */
2732 pfile
->context
->next
= NULL
;
2736 /* Return TRUE if we reached the end of the set of tokens stored in
2737 CONTEXT, FALSE otherwise. */
2739 reached_end_of_context (cpp_context
*context
)
2741 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
2742 return FIRST (context
).token
== LAST (context
).token
;
2743 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
2744 || context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2745 return FIRST (context
).ptoken
== LAST (context
).ptoken
;
2750 /* Consume the next token contained in the current context of PFILE,
2751 and return it in *TOKEN. It's "full location" is returned in
2752 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2753 means the location encoding the locus of the token across macro
2754 expansion; otherwise it's just is the "normal" location of the
2755 token which (*TOKEN)->src_loc. */
2757 consume_next_token_from_context (cpp_reader
*pfile
,
2758 const cpp_token
** token
,
2759 location_t
*location
)
2761 cpp_context
*c
= pfile
->context
;
2763 if ((c
)->tokens_kind
== TOKENS_KIND_DIRECT
)
2765 *token
= FIRST (c
).token
;
2766 *location
= (*token
)->src_loc
;
2769 else if ((c
)->tokens_kind
== TOKENS_KIND_INDIRECT
)
2771 *token
= *FIRST (c
).ptoken
;
2772 *location
= (*token
)->src_loc
;
2775 else if ((c
)->tokens_kind
== TOKENS_KIND_EXTENDED
)
2777 macro_context
*m
= c
->c
.mc
;
2778 *token
= *FIRST (c
).ptoken
;
2781 *location
= *m
->cur_virt_loc
;
2785 *location
= (*token
)->src_loc
;
2792 /* In the traditional mode of the preprocessor, if we are currently in
2793 a directive, the location of a token must be the location of the
2794 start of the directive line. This function returns the proper
2795 location if we are in the traditional mode, and just returns
2796 LOCATION otherwise. */
2798 static inline location_t
2799 maybe_adjust_loc_for_trad_cpp (cpp_reader
*pfile
, location_t location
)
2801 if (CPP_OPTION (pfile
, traditional
))
2803 if (pfile
->state
.in_directive
)
2804 return pfile
->directive_line
;
2809 /* Routine to get a token as well as its location.
2811 Macro expansions and directives are transparently handled,
2812 including entering included files. Thus tokens are post-macro
2813 expansion, and after any intervening directives. External callers
2814 see CPP_EOF only at EOF. Internal callers also see it when meeting
2815 a directive inside a macro call, when at the end of a directive and
2816 state.in_directive is still 1, and at the end of argument
2819 LOC is an out parameter; *LOC is set to the location "as expected
2820 by the user". Please read the comment of
2821 cpp_get_token_with_location to learn more about the meaning of this
2823 static const cpp_token
*
2824 cpp_get_token_1 (cpp_reader
*pfile
, location_t
*location
)
2826 const cpp_token
*result
;
2827 /* This token is a virtual token that either encodes a location
2828 related to macro expansion or a spelling location. */
2829 location_t virt_loc
= 0;
2830 /* pfile->about_to_expand_macro_p can be overriden by indirect calls
2831 to functions that push macro contexts. So let's save it so that
2832 we can restore it when we are about to leave this routine. */
2833 bool saved_about_to_expand_macro
= pfile
->about_to_expand_macro_p
;
2838 cpp_context
*context
= pfile
->context
;
2840 /* Context->prev == 0 <=> base context. */
2843 result
= _cpp_lex_token (pfile
);
2844 virt_loc
= result
->src_loc
;
2846 else if (!reached_end_of_context (context
))
2848 consume_next_token_from_context (pfile
, &result
,
2850 if (result
->flags
& PASTE_LEFT
)
2852 paste_all_tokens (pfile
, result
);
2853 if (pfile
->state
.in_directive
)
2855 result
= padding_token (pfile
, result
);
2861 if (pfile
->context
->c
.macro
)
2862 ++num_expanded_macros_counter
;
2863 _cpp_pop_context (pfile
);
2864 if (pfile
->state
.in_directive
)
2866 result
= &pfile
->avoid_paste
;
2870 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
2873 if (result
->type
!= CPP_NAME
)
2876 node
= result
->val
.node
.node
;
2878 if (node
->type
== NT_VOID
|| (result
->flags
& NO_EXPAND
))
2881 if (!(node
->flags
& NODE_DISABLED
))
2884 /* If not in a macro context, and we're going to start an
2885 expansion, record the location and the top level macro
2886 about to be expanded. */
2887 if (!in_macro_expansion_p (pfile
))
2889 pfile
->invocation_location
= result
->src_loc
;
2890 pfile
->top_most_macro_node
= node
;
2892 if (pfile
->state
.prevent_expansion
)
2895 /* Conditional macros require that a predicate be evaluated
2897 if ((node
->flags
& NODE_CONDITIONAL
) != 0)
2899 if (pfile
->cb
.macro_to_expand
)
2901 bool whitespace_after
;
2902 const cpp_token
*peek_tok
= cpp_peek_token (pfile
, 0);
2904 whitespace_after
= (peek_tok
->type
== CPP_PADDING
2905 || (peek_tok
->flags
& PREV_WHITE
));
2906 node
= pfile
->cb
.macro_to_expand (pfile
, result
);
2908 ret
= enter_macro_context (pfile
, node
, result
, virt_loc
);
2909 else if (whitespace_after
)
2911 /* If macro_to_expand hook returned NULL and it
2912 ate some tokens, see if we don't need to add
2913 a padding token in between this and the
2915 peek_tok
= cpp_peek_token (pfile
, 0);
2916 if (peek_tok
->type
!= CPP_PADDING
2917 && (peek_tok
->flags
& PREV_WHITE
) == 0)
2918 _cpp_push_token_context (pfile
, NULL
,
2919 padding_token (pfile
,
2925 ret
= enter_macro_context (pfile
, node
, result
, virt_loc
);
2928 if (pfile
->state
.in_directive
|| ret
== 2)
2930 result
= padding_token (pfile
, result
);
2936 /* Flag this token as always unexpandable. FIXME: move this
2937 to collect_args()?. */
2938 cpp_token
*t
= _cpp_temp_token (pfile
);
2939 t
->type
= result
->type
;
2940 t
->flags
= result
->flags
| NO_EXPAND
;
2941 t
->val
= result
->val
;
2949 if (location
!= NULL
)
2952 virt_loc
= result
->src_loc
;
2953 *location
= virt_loc
;
2955 if (!CPP_OPTION (pfile
, track_macro_expansion
)
2956 && macro_of_context (pfile
->context
) != NULL
)
2957 /* We are in a macro expansion context, are not tracking
2958 virtual location, but were asked to report the location
2959 of the expansion point of the macro being expanded. */
2960 *location
= pfile
->invocation_location
;
2962 *location
= maybe_adjust_loc_for_trad_cpp (pfile
, *location
);
2965 pfile
->about_to_expand_macro_p
= saved_about_to_expand_macro
;
2969 /* External routine to get a token. Also used nearly everywhere
2970 internally, except for places where we know we can safely call
2971 _cpp_lex_token directly, such as lexing a directive name.
2973 Macro expansions and directives are transparently handled,
2974 including entering included files. Thus tokens are post-macro
2975 expansion, and after any intervening directives. External callers
2976 see CPP_EOF only at EOF. Internal callers also see it when meeting
2977 a directive inside a macro call, when at the end of a directive and
2978 state.in_directive is still 1, and at the end of argument
2981 cpp_get_token (cpp_reader
*pfile
)
2983 return cpp_get_token_1 (pfile
, NULL
);
2986 /* Like cpp_get_token, but also returns a virtual token location
2987 separate from the spelling location carried by the returned token.
2989 LOC is an out parameter; *LOC is set to the location "as expected
2990 by the user". This matters when a token results from macro
2991 expansion; in that case the token's spelling location indicates the
2992 locus of the token in the definition of the macro but *LOC
2993 virtually encodes all the other meaningful locuses associated to
2996 What? virtual location? Yes, virtual location.
2998 If the token results from macro expansion and if macro expansion
2999 location tracking is enabled its virtual location encodes (at the
3002 - the spelling location of the token
3004 - the locus of the macro expansion point
3006 - the locus of the point where the token got instantiated as part
3007 of the macro expansion process.
3009 You have to use the linemap API to get the locus you are interested
3010 in from a given virtual location.
3012 Note however that virtual locations are not necessarily ordered for
3013 relations '<' and '>'. One must use the function
3014 linemap_location_before_p instead of using the relational operator
3017 If macro expansion tracking is off and if the token results from
3018 macro expansion the virtual location is the expansion point of the
3019 macro that got expanded.
3021 When the token doesn't result from macro expansion, the virtual
3022 location is just the same thing as its spelling location. */
3025 cpp_get_token_with_location (cpp_reader
*pfile
, location_t
*loc
)
3027 return cpp_get_token_1 (pfile
, loc
);
3030 /* Returns true if we're expanding an object-like macro that was
3031 defined in a system header. Just checks the macro at the top of
3032 the stack. Used for diagnostic suppression. */
3034 cpp_sys_macro_p (cpp_reader
*pfile
)
3036 cpp_hashnode
*node
= NULL
;
3038 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
3039 node
= pfile
->context
->c
.mc
->macro_node
;
3041 node
= pfile
->context
->c
.macro
;
3043 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
3046 /* Read each token in, until end of the current file. Directives are
3047 transparently processed. */
3049 cpp_scan_nooutput (cpp_reader
*pfile
)
3051 /* Request a CPP_EOF token at the end of this file, rather than
3052 transparently continuing with the including file. */
3053 pfile
->buffer
->return_at_eof
= true;
3055 pfile
->state
.discarding_output
++;
3056 pfile
->state
.prevent_expansion
++;
3058 if (CPP_OPTION (pfile
, traditional
))
3059 while (_cpp_read_logical_line_trad (pfile
))
3062 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
3065 pfile
->state
.discarding_output
--;
3066 pfile
->state
.prevent_expansion
--;
3069 /* Step back one or more tokens obtained from the lexer. */
3071 _cpp_backup_tokens_direct (cpp_reader
*pfile
, unsigned int count
)
3073 pfile
->lookaheads
+= count
;
3077 if (pfile
->cur_token
== pfile
->cur_run
->base
3078 /* Possible with -fpreprocessed and no leading #line. */
3079 && pfile
->cur_run
->prev
!= NULL
)
3081 pfile
->cur_run
= pfile
->cur_run
->prev
;
3082 pfile
->cur_token
= pfile
->cur_run
->limit
;
3087 /* Step back one (or more) tokens. Can only step back more than 1 if
3088 they are from the lexer, and not from macro expansion. */
3090 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
3092 if (pfile
->context
->prev
== NULL
)
3093 _cpp_backup_tokens_direct (pfile
, count
);
3098 if (pfile
->context
->tokens_kind
== TOKENS_KIND_DIRECT
)
3099 FIRST (pfile
->context
).token
--;
3100 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
3101 FIRST (pfile
->context
).ptoken
--;
3102 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
3104 FIRST (pfile
->context
).ptoken
--;
3105 if (pfile
->context
->c
.macro
)
3107 macro_context
*m
= pfile
->context
->c
.mc
;
3109 gcc_checking_assert (m
->cur_virt_loc
>= m
->virt_locs
);
3119 /* #define directive parsing and handling. */
3121 /* Returns true if a macro redefinition warning is required. */
3123 warn_of_redefinition (cpp_reader
*pfile
, cpp_hashnode
*node
,
3124 const cpp_macro
*macro2
)
3126 /* Some redefinitions need to be warned about regardless. */
3127 if (node
->flags
& NODE_WARN
)
3130 /* Suppress warnings for builtins that lack the NODE_WARN flag,
3131 unless Wbuiltin-macro-redefined. */
3132 if (cpp_builtin_macro_p (node
))
3133 return CPP_OPTION (pfile
, warn_builtin_macro_redefined
);
3135 /* Redefinitions of conditional (context-sensitive) macros, on
3136 the other hand, must be allowed silently. */
3137 if (node
->flags
& NODE_CONDITIONAL
)
3140 cpp_macro
*macro1
= node
->value
.macro
;
3143 /* We don't want to mark MACRO as used, but do need to finalize
3145 pfile
->cb
.user_lazy_macro (pfile
, macro1
, macro1
->lazy
- 1);
3149 return compare_macros (macro1
, macro2
);
3152 /* Return TRUE if MACRO1 and MACRO2 differ. */
3155 compare_macros (const cpp_macro
*macro1
, const cpp_macro
*macro2
)
3157 /* Redefinition of a macro is allowed if and only if the old and new
3158 definitions are the same. (6.10.3 paragraph 2). */
3160 /* Don't check count here as it can be different in valid
3161 traditional redefinitions with just whitespace differences. */
3162 if (macro1
->paramc
!= macro2
->paramc
3163 || macro1
->fun_like
!= macro2
->fun_like
3164 || macro1
->variadic
!= macro2
->variadic
)
3167 /* Check parameter spellings. */
3168 for (unsigned i
= macro1
->paramc
; i
--; )
3169 if (macro1
->parm
.params
[i
] != macro2
->parm
.params
[i
])
3172 /* Check the replacement text or tokens. */
3173 if (macro1
->kind
== cmk_traditional
)
3174 return _cpp_expansions_different_trad (macro1
, macro2
);
3176 if (macro1
->count
!= macro2
->count
)
3179 for (unsigned i
= macro1
->count
; i
--; )
3180 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
3186 /* Free the definition of hashnode H. */
3188 _cpp_free_definition (cpp_hashnode
*h
)
3190 /* Macros and assertions no longer have anything to free. */
3192 h
->value
.answers
= NULL
;
3193 h
->flags
&= ~(NODE_DISABLED
| NODE_USED
);
3196 /* Save parameter NODE (spelling SPELLING) to the parameter list of
3197 macro MACRO. Returns true on success, false on failure. */
3199 _cpp_save_parameter (cpp_reader
*pfile
, unsigned n
, cpp_hashnode
*node
,
3200 cpp_hashnode
*spelling
)
3202 /* Constraint 6.10.3.6 - duplicate parameter names. */
3203 if (node
->type
== NT_MACRO_ARG
)
3205 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
3210 unsigned len
= (n
+ 1) * sizeof (struct macro_arg_saved_data
);
3211 if (len
> pfile
->macro_buffer_len
)
3214 = XRESIZEVEC (unsigned char, pfile
->macro_buffer
, len
);
3215 pfile
->macro_buffer_len
= len
;
3218 macro_arg_saved_data
*saved
= (macro_arg_saved_data
*)pfile
->macro_buffer
;
3219 saved
[n
].canonical_node
= node
;
3220 saved
[n
].value
= node
->value
;
3221 saved
[n
].type
= node
->type
;
3223 void *base
= _cpp_reserve_room (pfile
, n
* sizeof (cpp_hashnode
*),
3224 sizeof (cpp_hashnode
*));
3225 ((cpp_hashnode
**)base
)[n
] = spelling
;
3227 /* Morph into a macro arg. */
3228 node
->type
= NT_MACRO_ARG
;
3229 /* Index is 1 based. */
3230 node
->value
.arg_index
= n
+ 1;
3235 /* Restore the parameters to their previous state. */
3237 _cpp_unsave_parameters (cpp_reader
*pfile
, unsigned n
)
3239 /* Clear the fast argument lookup indices. */
3242 struct macro_arg_saved_data
*save
=
3243 &((struct macro_arg_saved_data
*) pfile
->macro_buffer
)[n
];
3245 struct cpp_hashnode
*node
= save
->canonical_node
;
3246 node
->type
= save
->type
;
3247 node
->value
= save
->value
;
3251 /* Check the syntax of the parameters in a MACRO definition. Return
3252 false on failure. Set *N_PTR and *VARADIC_PTR as appropriate.
3254 '(' parm-list ',' last-parm ')'
3264 parse_params (cpp_reader
*pfile
, unsigned *n_ptr
, bool *varadic_ptr
)
3266 unsigned nparms
= 0;
3269 for (bool prev_ident
= false;;)
3271 const cpp_token
*token
= _cpp_lex_token (pfile
);
3273 switch (token
->type
)
3276 /* Allow/ignore comments in parameter lists if we are
3277 preserving comments in macro expansions. */
3278 if (!CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
3285 const char *const msgs
[5] =
3287 N_("expected parameter name, found \"%s\""),
3288 N_("expected ',' or ')', found \"%s\""),
3289 N_("expected parameter name before end of line"),
3290 N_("expected ')' before end of line"),
3291 N_("expected ')' after \"...\"")
3293 unsigned ix
= prev_ident
;
3294 const unsigned char *as_text
= NULL
;
3297 else if (token
->type
== CPP_EOF
)
3300 as_text
= cpp_token_as_text (pfile
, token
);
3301 cpp_error (pfile
, CPP_DL_ERROR
, msgs
[ix
], as_text
);
3306 if (prev_ident
|| *varadic_ptr
)
3310 if (!_cpp_save_parameter (pfile
, nparms
, token
->val
.node
.node
,
3311 token
->val
.node
.spelling
))
3316 case CPP_CLOSE_PAREN
:
3317 if (prev_ident
|| !nparms
|| *varadic_ptr
)
3325 if (!prev_ident
|| *varadic_ptr
)
3333 *varadic_ptr
= true;
3336 /* An ISO bare ellipsis. */
3337 _cpp_save_parameter (pfile
, nparms
,
3338 pfile
->spec_nodes
.n__VA_ARGS__
,
3339 pfile
->spec_nodes
.n__VA_ARGS__
);
3341 pfile
->state
.va_args_ok
= 1;
3342 if (! CPP_OPTION (pfile
, c99
)
3343 && CPP_OPTION (pfile
, cpp_pedantic
)
3344 && CPP_OPTION (pfile
, warn_variadic_macros
))
3346 (pfile
, CPP_W_VARIADIC_MACROS
,
3347 CPP_OPTION (pfile
, cplusplus
)
3348 ? N_("anonymous variadic macros were introduced in C++11")
3349 : N_("anonymous variadic macros were introduced in C99"));
3350 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
3351 && ! CPP_OPTION (pfile
, cplusplus
))
3352 cpp_error (pfile
, CPP_DL_WARNING
,
3353 "anonymous variadic macros were introduced in C99");
3355 else if (CPP_OPTION (pfile
, cpp_pedantic
)
3356 && CPP_OPTION (pfile
, warn_variadic_macros
))
3357 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
3358 CPP_OPTION (pfile
, cplusplus
)
3359 ? N_("ISO C++ does not permit named variadic macros")
3360 : N_("ISO C does not permit named variadic macros"));
3371 /* Lex a token from the expansion of MACRO, but mark parameters as we
3372 find them and warn of traditional stringification. */
3374 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
3376 macro
= (cpp_macro
*)_cpp_reserve_room (pfile
,
3377 sizeof (cpp_macro
) - sizeof (cpp_token
)
3378 + macro
->count
* sizeof (cpp_token
),
3379 sizeof (cpp_token
));
3380 cpp_token
*saved_cur_token
= pfile
->cur_token
;
3381 pfile
->cur_token
= ¯o
->exp
.tokens
[macro
->count
];
3382 cpp_token
*token
= _cpp_lex_direct (pfile
);
3383 pfile
->cur_token
= saved_cur_token
;
3385 /* Is this a parameter? */
3386 if (token
->type
== CPP_NAME
&& token
->val
.node
.node
->type
== NT_MACRO_ARG
)
3388 /* Morph into a parameter reference. */
3389 cpp_hashnode
*spelling
= token
->val
.node
.spelling
;
3390 token
->type
= CPP_MACRO_ARG
;
3391 token
->val
.macro_arg
.arg_no
= token
->val
.node
.node
->value
.arg_index
;
3392 token
->val
.macro_arg
.spelling
= spelling
;
3394 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
3395 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
3396 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
3402 create_iso_definition (cpp_reader
*pfile
)
3404 bool following_paste_op
= false;
3405 const char *paste_op_error_msg
=
3406 N_("'##' cannot appear at either end of a macro expansion");
3407 unsigned int num_extra_tokens
= 0;
3408 unsigned nparms
= 0;
3409 cpp_hashnode
**params
= NULL
;
3410 bool varadic
= false;
3412 cpp_macro
*macro
= NULL
;
3414 /* Look at the first token, to see if this is a function-like
3417 cpp_token
*saved_cur_token
= pfile
->cur_token
;
3418 pfile
->cur_token
= &first
;
3419 cpp_token
*token
= _cpp_lex_direct (pfile
);
3420 pfile
->cur_token
= saved_cur_token
;
3422 if (token
->flags
& PREV_WHITE
)
3423 /* Preceeded by space, must be part of expansion. */;
3424 else if (token
->type
== CPP_OPEN_PAREN
)
3426 /* An open-paren, get a parameter list. */
3427 if (!parse_params (pfile
, &nparms
, &varadic
))
3430 params
= (cpp_hashnode
**)_cpp_commit_buff
3431 (pfile
, sizeof (cpp_hashnode
*) * nparms
);
3434 else if (token
->type
!= CPP_EOF
3435 && !(token
->type
== CPP_COMMENT
3436 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
)))
3438 /* While ISO C99 requires whitespace before replacement text
3439 in a macro definition, ISO C90 with TC1 allows characters
3440 from the basic source character set there. */
3441 if (CPP_OPTION (pfile
, c99
))
3442 cpp_error (pfile
, CPP_DL_PEDWARN
,
3443 CPP_OPTION (pfile
, cplusplus
)
3444 ? N_("ISO C++11 requires whitespace after the macro name")
3445 : N_("ISO C99 requires whitespace after the macro name"));
3448 enum cpp_diagnostic_level warntype
= CPP_DL_WARNING
;
3449 switch (token
->type
)
3453 case CPP_OBJC_STRING
:
3454 /* '@' is not in basic character set. */
3455 warntype
= CPP_DL_PEDWARN
;
3458 /* Basic character set sans letters, digits and _. */
3459 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
3460 token
->val
.str
.text
[0]) == NULL
)
3461 warntype
= CPP_DL_PEDWARN
;
3464 /* All other tokens start with a character from basic
3468 cpp_error (pfile
, warntype
,
3469 "missing whitespace after the macro name");
3473 macro
= _cpp_new_macro (pfile
, cmk_macro
,
3474 _cpp_reserve_room (pfile
, 0, sizeof (cpp_macro
)));
3478 macro
->variadic
= varadic
;
3479 macro
->paramc
= nparms
;
3480 macro
->parm
.params
= params
;
3481 macro
->fun_like
= true;
3485 /* Preserve the token we peeked, there is already a single slot for it. */
3486 macro
->exp
.tokens
[0] = *token
;
3487 token
= ¯o
->exp
.tokens
[0];
3491 for (vaopt_state
vaopt_tracker (pfile
, macro
->variadic
, NULL
);; token
= NULL
)
3495 macro
= lex_expansion_token (pfile
, macro
);
3496 token
= ¯o
->exp
.tokens
[macro
->count
++];
3499 /* Check the stringifying # constraint 6.10.3.2.1 of
3500 function-like macros when lexing the subsequent token. */
3501 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
3503 if (token
->type
== CPP_MACRO_ARG
)
3505 if (token
->flags
& PREV_WHITE
)
3506 token
->flags
|= SP_PREV_WHITE
;
3507 if (token
[-1].flags
& DIGRAPH
)
3508 token
->flags
|= SP_DIGRAPH
;
3509 token
->flags
&= ~PREV_WHITE
;
3510 token
->flags
|= STRINGIFY_ARG
;
3511 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
3512 token
[-1] = token
[0];
3515 /* Let assembler get away with murder. */
3516 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
3518 cpp_error (pfile
, CPP_DL_ERROR
,
3519 "'#' is not followed by a macro parameter");
3524 if (token
->type
== CPP_EOF
)
3526 /* Paste operator constraint 6.10.3.3.1:
3527 Token-paste ##, can appear in both object-like and
3528 function-like macros, but not at the end. */
3529 if (following_paste_op
)
3531 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3534 if (!vaopt_tracker
.completed ())
3539 /* Paste operator constraint 6.10.3.3.1. */
3540 if (token
->type
== CPP_PASTE
)
3542 /* Token-paste ##, can appear in both object-like and
3543 function-like macros, but not at the beginning. */
3544 if (macro
->count
== 1)
3546 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3550 if (following_paste_op
)
3552 /* Consecutive paste operators. This one will be moved
3555 token
->val
.token_no
= macro
->count
- 1;
3559 /* Drop the paste operator. */
3561 token
[-1].flags
|= PASTE_LEFT
;
3562 if (token
->flags
& DIGRAPH
)
3563 token
[-1].flags
|= SP_DIGRAPH
;
3564 if (token
->flags
& PREV_WHITE
)
3565 token
[-1].flags
|= SP_PREV_WHITE
;
3567 following_paste_op
= true;
3570 following_paste_op
= false;
3572 if (vaopt_tracker
.update (token
) == vaopt_state::ERROR
)
3576 /* We're committed to winning now. */
3579 /* Don't count the CPP_EOF. */
3582 macro
= (cpp_macro
*)_cpp_commit_buff
3583 (pfile
, sizeof (cpp_macro
) - sizeof (cpp_token
)
3584 + sizeof (cpp_token
) * macro
->count
);
3586 /* Clear whitespace on first token. */
3588 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
3590 if (num_extra_tokens
)
3592 /* Place second and subsequent ## or %:%: tokens in sequences of
3593 consecutive such tokens at the end of the list to preserve
3594 information about where they appear, how they are spelt and
3595 whether they are preceded by whitespace without otherwise
3596 interfering with macro expansion. Remember, this is
3597 extremely rare, so efficiency is not a priority. */
3598 cpp_token
*temp
= (cpp_token
*)_cpp_reserve_room
3599 (pfile
, 0, num_extra_tokens
* sizeof (cpp_token
));
3600 unsigned extra_ix
= 0, norm_ix
= 0;
3601 cpp_token
*exp
= macro
->exp
.tokens
;
3602 for (unsigned ix
= 0; ix
!= macro
->count
; ix
++)
3603 if (exp
[ix
].type
== CPP_PASTE
)
3604 temp
[extra_ix
++] = exp
[ix
];
3606 exp
[norm_ix
++] = exp
[ix
];
3607 memcpy (&exp
[norm_ix
], temp
, num_extra_tokens
* sizeof (cpp_token
));
3609 /* Record there are extra tokens. */
3610 macro
->extra_tokens
= 1;
3614 pfile
->state
.va_args_ok
= 0;
3615 _cpp_unsave_parameters (pfile
, nparms
);
3617 return ok
? macro
: NULL
;
3621 _cpp_new_macro (cpp_reader
*pfile
, cpp_macro_kind kind
, void *placement
)
3623 cpp_macro
*macro
= (cpp_macro
*) placement
;
3625 /* Zero init all the fields. This'll tell the compiler know all the
3626 following inits are writing a virgin object. */
3627 memset (macro
, 0, offsetof (cpp_macro
, exp
));
3629 macro
->line
= pfile
->directive_line
;
3630 macro
->parm
.params
= 0;
3633 macro
->variadic
= 0;
3634 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
3636 macro
->fun_like
= 0;
3637 macro
->extra_tokens
= 0;
3638 /* To suppress some diagnostics. */
3639 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
3646 /* Parse a macro and save its expansion. Returns nonzero on success. */
3648 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3652 if (CPP_OPTION (pfile
, traditional
))
3653 macro
= _cpp_create_trad_definition (pfile
);
3655 macro
= create_iso_definition (pfile
);
3660 if (cpp_macro_p (node
))
3662 if (CPP_OPTION (pfile
, warn_unused_macros
))
3663 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
3665 if (warn_of_redefinition (pfile
, node
, macro
))
3667 const enum cpp_warning_reason reason
3668 = (cpp_builtin_macro_p (node
) && !(node
->flags
& NODE_WARN
))
3669 ? CPP_W_BUILTIN_MACRO_REDEFINED
: CPP_W_NONE
;
3672 cpp_pedwarning_with_line (pfile
, reason
,
3673 pfile
->directive_line
, 0,
3674 "\"%s\" redefined", NODE_NAME (node
));
3676 if (warned
&& cpp_user_macro_p (node
))
3677 cpp_error_with_line (pfile
, CPP_DL_NOTE
,
3678 node
->value
.macro
->line
, 0,
3679 "this is the location of the previous definition");
3681 _cpp_free_definition (node
);
3684 /* Enter definition in hash table. */
3685 node
->type
= NT_USER_MACRO
;
3686 node
->value
.macro
= macro
;
3687 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
3688 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
3689 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3690 in the C standard, as something that one must use in C++.
3691 However DR#593 and C++11 indicate that they play no role in C++.
3692 We special-case them anyway. */
3693 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
3694 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
3695 node
->flags
|= NODE_WARN
;
3697 /* If user defines one of the conditional macros, remove the
3699 node
->flags
&= ~NODE_CONDITIONAL
;
3705 cpp_define_lazily (cpp_reader
*pfile
, cpp_hashnode
*node
, unsigned num
)
3707 cpp_macro
*macro
= node
->value
.macro
;
3709 gcc_checking_assert (pfile
->cb
.user_lazy_macro
&& macro
&& num
< UCHAR_MAX
);
3711 macro
->lazy
= num
+ 1;
3714 /* Notify the use of NODE in a macro-aware context (i.e. expanding it,
3715 or testing its existance). Also applies any lazy definition.
3716 Return FALSE if the macro isn't really there. */
3719 _cpp_notify_macro_use (cpp_reader
*pfile
, cpp_hashnode
*node
,
3722 node
->flags
|= NODE_USED
;
3727 cpp_macro
*macro
= node
->value
.macro
;
3730 pfile
->cb
.user_lazy_macro (pfile
, macro
, macro
->lazy
- 1);
3736 case NT_BUILTIN_MACRO
:
3737 if (pfile
->cb
.used_define
)
3738 pfile
->cb
.used_define (pfile
, loc
, node
);
3742 if (pfile
->cb
.used_undef
)
3743 pfile
->cb
.used_undef (pfile
, loc
, node
);
3751 /* Warn if a token in STRING matches one of a function-like MACRO's
3754 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
3755 const cpp_string
*string
)
3757 unsigned int i
, len
;
3758 const uchar
*p
, *q
, *limit
;
3760 /* Loop over the string. */
3761 limit
= string
->text
+ string
->len
- 1;
3762 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
3764 /* Find the start of an identifier. */
3765 while (p
< limit
&& !is_idstart (*p
))
3768 /* Find the end of the identifier. */
3770 while (q
< limit
&& is_idchar (*q
))
3775 /* Loop over the function macro arguments to see if the
3776 identifier inside the string matches one of them. */
3777 for (i
= 0; i
< macro
->paramc
; i
++)
3779 const cpp_hashnode
*node
= macro
->parm
.params
[i
];
3781 if (NODE_LEN (node
) == len
3782 && !memcmp (p
, NODE_NAME (node
), len
))
3784 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
3785 "macro argument \"%s\" would be stringified in traditional C",
3793 /* Returns the name, arguments and expansion of a macro, in a format
3794 suitable to be read back in again, and therefore also for DWARF 2
3795 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3796 Caller is expected to generate the "#define" bit if needed. The
3797 returned text is temporary, and automatically freed later. */
3798 const unsigned char *
3799 cpp_macro_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3801 unsigned int i
, len
;
3802 unsigned char *buffer
;
3804 gcc_checking_assert (cpp_user_macro_p (node
));
3806 const cpp_macro
*macro
= node
->value
.macro
;
3808 /* Calculate length. */
3809 len
= NODE_LEN (node
) * 10 + 2; /* ' ' and NUL. */
3810 if (macro
->fun_like
)
3812 len
+= 4; /* "()" plus possible final ".." of named
3813 varargs (we have + 1 below). */
3814 for (i
= 0; i
< macro
->paramc
; i
++)
3815 len
+= NODE_LEN (macro
->parm
.params
[i
]) + 1; /* "," */
3818 /* This should match below where we fill in the buffer. */
3819 if (CPP_OPTION (pfile
, traditional
))
3820 len
+= _cpp_replacement_text_len (macro
);
3823 unsigned int count
= macro_real_token_count (macro
);
3824 for (i
= 0; i
< count
; i
++)
3826 const cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3828 if (token
->type
== CPP_MACRO_ARG
)
3829 len
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3831 len
+= cpp_token_len (token
);
3833 if (token
->flags
& STRINGIFY_ARG
)
3835 if (token
->flags
& PASTE_LEFT
)
3836 len
+= 3; /* " ##" */
3837 if (token
->flags
& PREV_WHITE
)
3842 if (len
> pfile
->macro_buffer_len
)
3844 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
3845 pfile
->macro_buffer
, len
);
3846 pfile
->macro_buffer_len
= len
;
3849 /* Fill in the buffer. Start with the macro name. */
3850 buffer
= pfile
->macro_buffer
;
3851 buffer
= _cpp_spell_ident_ucns (buffer
, node
);
3853 /* Parameter names. */
3854 if (macro
->fun_like
)
3857 for (i
= 0; i
< macro
->paramc
; i
++)
3859 cpp_hashnode
*param
= macro
->parm
.params
[i
];
3861 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
3863 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
3864 buffer
+= NODE_LEN (param
);
3867 if (i
+ 1 < macro
->paramc
)
3868 /* Don't emit a space after the comma here; we're trying
3869 to emit a Dwarf-friendly definition, and the Dwarf spec
3870 forbids spaces in the argument list. */
3872 else if (macro
->variadic
)
3873 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
3878 /* The Dwarf spec requires a space after the macro name, even if the
3879 definition is the empty string. */
3882 if (CPP_OPTION (pfile
, traditional
))
3883 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
3884 else if (macro
->count
)
3885 /* Expansion tokens. */
3887 unsigned int count
= macro_real_token_count (macro
);
3888 for (i
= 0; i
< count
; i
++)
3890 const cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3892 if (token
->flags
& PREV_WHITE
)
3894 if (token
->flags
& STRINGIFY_ARG
)
3897 if (token
->type
== CPP_MACRO_ARG
)
3900 NODE_NAME (token
->val
.macro_arg
.spelling
),
3901 NODE_LEN (token
->val
.macro_arg
.spelling
));
3902 buffer
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3905 buffer
= cpp_spell_token (pfile
, token
, buffer
, true);
3907 if (token
->flags
& PASTE_LEFT
)
3912 /* Next has PREV_WHITE; see _cpp_create_definition. */
3918 return pfile
->macro_buffer
;