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 parse_params (cpp_reader
*, unsigned *, bool *);
344 static void check_trad_stringification (cpp_reader
*, const cpp_macro
*,
346 static bool reached_end_of_context (cpp_context
*);
347 static void consume_next_token_from_context (cpp_reader
*pfile
,
350 static const cpp_token
* cpp_get_token_1 (cpp_reader
*, location_t
*);
352 static cpp_hashnode
* macro_of_context (cpp_context
*context
);
354 static bool in_macro_expansion_p (cpp_reader
*pfile
);
356 /* Statistical counter tracking the number of macros that got
358 unsigned num_expanded_macros_counter
= 0;
359 /* Statistical counter tracking the total number tokens resulting
360 from macro expansion. */
361 unsigned num_macro_tokens_counter
= 0;
363 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
364 and not consume CPP_EOF. */
365 static const cpp_token
*
366 cpp_get_token_no_padding (cpp_reader
*pfile
)
370 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
371 if (ret
->type
== CPP_EOF
)
373 ret
= cpp_get_token (pfile
);
374 if (ret
->type
!= CPP_PADDING
)
379 /* Handle meeting "__has_include" builtin macro. */
382 builtin_has_include (cpp_reader
*pfile
, cpp_hashnode
*op
, bool has_next
)
386 if (!pfile
->state
.in_directive
)
387 cpp_error (pfile
, CPP_DL_ERROR
,
388 "\"%s\" used outside of preprocessing directive",
391 pfile
->state
.angled_headers
= true;
392 const cpp_token
*token
= cpp_get_token_no_padding (pfile
);
393 bool paren
= token
->type
== CPP_OPEN_PAREN
;
395 token
= cpp_get_token_no_padding (pfile
);
397 cpp_error (pfile
, CPP_DL_ERROR
,
398 "missing '(' before \"%s\" operand", NODE_NAME (op
));
399 pfile
->state
.angled_headers
= false;
401 bool bracket
= token
->type
!= CPP_STRING
;
403 if (token
->type
== CPP_STRING
|| token
->type
== CPP_HEADER_NAME
)
405 fname
= XNEWVEC (char, token
->val
.str
.len
- 1);
406 memcpy (fname
, token
->val
.str
.text
+ 1, token
->val
.str
.len
- 2);
407 fname
[token
->val
.str
.len
- 2] = '\0';
409 else if (token
->type
== CPP_LESS
)
410 fname
= _cpp_bracket_include (pfile
);
412 cpp_error (pfile
, CPP_DL_ERROR
,
413 "operator \"%s\" requires a header-name", NODE_NAME (op
));
417 /* Do not do the lookup if we're skipping, that's unnecessary
419 if (!pfile
->state
.skip_eval
420 && _cpp_has_header (pfile
, fname
, bracket
,
421 has_next
? IT_INCLUDE_NEXT
: IT_INCLUDE
))
428 && cpp_get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
429 cpp_error (pfile
, CPP_DL_ERROR
,
430 "missing ')' after \"%s\" operand", NODE_NAME (op
));
435 /* Emits a warning if NODE is a macro defined in the main file that
436 has not been used. */
438 _cpp_warn_if_unused_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
439 void *v ATTRIBUTE_UNUSED
)
441 if (cpp_user_macro_p (node
))
443 cpp_macro
*macro
= node
->value
.macro
;
446 && MAIN_FILE_P (linemap_check_ordinary
447 (linemap_lookup (pfile
->line_table
,
449 cpp_warning_with_line (pfile
, CPP_W_UNUSED_MACROS
, macro
->line
, 0,
450 "macro \"%s\" is not used", NODE_NAME (node
));
456 /* Allocates and returns a CPP_STRING token, containing TEXT of length
457 LEN, after null-terminating it. TEXT must be in permanent storage. */
458 static const cpp_token
*
459 new_string_token (cpp_reader
*pfile
, unsigned char *text
, unsigned int len
)
461 cpp_token
*token
= _cpp_temp_token (pfile
);
464 token
->type
= CPP_STRING
;
465 token
->val
.str
.len
= len
;
466 token
->val
.str
.text
= text
;
471 static const char * const monthnames
[] =
473 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
474 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
477 /* Helper function for builtin_macro. Returns the text generated by
480 _cpp_builtin_macro_text (cpp_reader
*pfile
, cpp_hashnode
*node
,
483 const uchar
*result
= NULL
;
484 linenum_type number
= 1;
486 switch (node
->value
.builtin
)
489 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
495 if (CPP_OPTION (pfile
, warn_date_time
))
496 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
497 "reproducible builds", NODE_NAME (node
));
499 cpp_buffer
*pbuffer
= cpp_get_buffer (pfile
);
500 if (pbuffer
->timestamp
== NULL
)
502 /* Initialize timestamp value of the assotiated file. */
503 struct _cpp_file
*file
= cpp_get_file (pbuffer
);
506 /* Generate __TIMESTAMP__ string, that represents
507 the date and time of the last modification
508 of the current source file. The string constant
509 looks like "Sun Sep 16 01:03:52 1973". */
510 struct tm
*tb
= NULL
;
511 struct stat
*st
= _cpp_get_file_stat (file
);
513 tb
= localtime (&st
->st_mtime
);
516 char *str
= asctime (tb
);
517 size_t len
= strlen (str
);
518 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
520 strcpy ((char *) buf
+ 1, str
);
522 pbuffer
->timestamp
= buf
;
526 cpp_errno (pfile
, CPP_DL_WARNING
,
527 "could not determine file timestamp");
528 pbuffer
->timestamp
= UC
"\"??? ??? ?? ??:??:?? ????\"";
532 result
= pbuffer
->timestamp
;
542 if (node
->value
.builtin
== BT_FILE
)
543 name
= linemap_get_expansion_filename (pfile
->line_table
,
544 pfile
->line_table
->highest_line
);
547 name
= _cpp_get_file_name (pfile
->main_file
);
551 if (pfile
->cb
.remap_filename
)
552 name
= pfile
->cb
.remap_filename (name
);
554 buf
= _cpp_unaligned_alloc (pfile
, len
* 2 + 3);
557 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
563 case BT_INCLUDE_LEVEL
:
564 /* The line map depth counts the primary source as level 1, but
565 historically __INCLUDE_DEPTH__ has called the primary source
567 number
= pfile
->line_table
->depth
- 1;
571 /* If __LINE__ is embedded in a macro, it must expand to the
572 line of the macro's invocation, not its definition.
573 Otherwise things like assert() will not work properly.
574 See WG14 N1911, WG21 N4220 sec 6.5, and PR 61861. */
575 if (CPP_OPTION (pfile
, traditional
))
576 loc
= pfile
->line_table
->highest_line
;
578 loc
= linemap_resolve_location (pfile
->line_table
, loc
,
579 LRK_MACRO_EXPANSION_POINT
, NULL
);
580 number
= linemap_get_expansion_line (pfile
->line_table
, loc
);
583 /* __STDC__ has the value 1 under normal circumstances.
584 However, if (a) we are in a system header, (b) the option
585 stdc_0_in_system_headers is true (set by target config), and
586 (c) we are not in strictly conforming mode, then it has the
587 value 0. (b) and (c) are already checked in cpp_init_builtins. */
589 if (cpp_in_system_header (pfile
))
597 if (CPP_OPTION (pfile
, warn_date_time
))
598 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
599 "reproducible builds", NODE_NAME (node
));
600 if (pfile
->date
== NULL
)
602 /* Allocate __DATE__ and __TIME__ strings from permanent
603 storage. We only do this once, and don't generate them
604 at init time, because time() and localtime() are very
605 slow on some systems. */
607 struct tm
*tb
= NULL
;
609 /* Set a reproducible timestamp for __DATE__ and __TIME__ macro
610 if SOURCE_DATE_EPOCH is defined. */
611 if (pfile
->source_date_epoch
== (time_t) -2
612 && pfile
->cb
.get_source_date_epoch
!= NULL
)
613 pfile
->source_date_epoch
= pfile
->cb
.get_source_date_epoch (pfile
);
615 if (pfile
->source_date_epoch
>= (time_t) 0)
616 tb
= gmtime (&pfile
->source_date_epoch
);
619 /* (time_t) -1 is a legitimate value for "number of seconds
620 since the Epoch", so we have to do a little dance to
621 distinguish that from a genuine error. */
624 if (tt
!= (time_t)-1 || errno
== 0)
625 tb
= localtime (&tt
);
630 pfile
->date
= _cpp_unaligned_alloc (pfile
,
631 sizeof ("\"Oct 11 1347\""));
632 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
633 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
636 pfile
->time
= _cpp_unaligned_alloc (pfile
,
637 sizeof ("\"12:34:56\""));
638 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
639 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
643 cpp_errno (pfile
, CPP_DL_WARNING
,
644 "could not determine date and time");
646 pfile
->date
= UC
"\"??? ?? ????\"";
647 pfile
->time
= UC
"\"??:??:??\"";
651 if (node
->value
.builtin
== BT_DATE
)
652 result
= pfile
->date
;
654 result
= pfile
->time
;
658 if (CPP_OPTION (pfile
, directives_only
) && pfile
->state
.in_directive
)
659 cpp_error (pfile
, CPP_DL_ERROR
,
660 "__COUNTER__ expanded inside directive with -fdirectives-only");
661 number
= pfile
->counter
++;
664 case BT_HAS_ATTRIBUTE
:
665 number
= pfile
->cb
.has_attribute (pfile
);
669 number
= pfile
->cb
.has_builtin (pfile
);
673 case BT_HAS_INCLUDE_NEXT
:
674 number
= builtin_has_include (pfile
, node
,
675 node
->value
.builtin
== BT_HAS_INCLUDE_NEXT
);
681 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
682 result
= _cpp_unaligned_alloc (pfile
, 21);
683 sprintf ((char *) result
, "%u", number
);
689 /* Convert builtin macros like __FILE__ to a token and push it on the
690 context stack. Also handles _Pragma, for which a new token may not
691 be created. Returns 1 if it generates a new token context, 0 to
692 return the token to the caller. LOC is the location of the expansion
693 point of the macro. */
695 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
696 location_t loc
, location_t expand_loc
)
702 if (node
->value
.builtin
== BT_PRAGMA
)
704 /* Don't interpret _Pragma within directives. The standard is
705 not clear on this, but to me this makes most sense. */
706 if (pfile
->state
.in_directive
)
709 return _cpp_do__Pragma (pfile
, loc
);
712 buf
= _cpp_builtin_macro_text (pfile
, node
, expand_loc
);
714 nbuf
= (char *) alloca (len
+ 1);
715 memcpy (nbuf
, buf
, len
);
718 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
719 _cpp_clean_line (pfile
);
721 /* Set pfile->cur_token as required by _cpp_lex_direct. */
722 pfile
->cur_token
= _cpp_temp_token (pfile
);
723 cpp_token
*token
= _cpp_lex_direct (pfile
);
724 /* We should point to the expansion point of the builtin macro. */
725 token
->src_loc
= loc
;
726 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
728 /* We are tracking tokens resulting from macro expansion.
729 Create a macro line map and generate a virtual location for
730 the token resulting from the expansion of the built-in
732 location_t
*virt_locs
= NULL
;
733 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
734 const line_map_macro
* map
=
735 linemap_enter_macro (pfile
->line_table
, node
, loc
, 1);
736 tokens_buff_add_token (token_buf
, virt_locs
, token
,
737 pfile
->line_table
->builtin_location
,
738 pfile
->line_table
->builtin_location
,
739 map
, /*macro_token_index=*/0);
740 push_extended_tokens_context (pfile
, node
, token_buf
, virt_locs
,
741 (const cpp_token
**)token_buf
->base
,
745 _cpp_push_token_context (pfile
, NULL
, token
, 1);
746 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
747 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
749 _cpp_pop_buffer (pfile
);
754 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
755 backslashes and double quotes. DEST must be of sufficient size.
756 Returns a pointer to the end of the string. */
758 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
767 /* Naked LF can appear in raw string literals */
784 /* Convert a token sequence ARG to a single string token according to
785 the rules of the ISO C #-operator. */
786 static const cpp_token
*
787 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
790 unsigned int i
, escape_it
, backslash_count
= 0;
791 const cpp_token
*source
= NULL
;
794 if (BUFF_ROOM (pfile
->u_buff
) < 3)
795 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
796 dest
= BUFF_FRONT (pfile
->u_buff
);
799 /* Loop, reading in the argument's tokens. */
800 for (i
= 0; i
< arg
->count
; i
++)
802 const cpp_token
*token
= arg
->first
[i
];
804 if (token
->type
== CPP_PADDING
)
807 || (!(source
->flags
& PREV_WHITE
)
808 && token
->val
.source
== NULL
))
809 source
= token
->val
.source
;
813 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
814 || token
->type
== CPP_WSTRING
|| token
->type
== CPP_WCHAR
815 || token
->type
== CPP_STRING32
|| token
->type
== CPP_CHAR32
816 || token
->type
== CPP_STRING16
|| token
->type
== CPP_CHAR16
817 || token
->type
== CPP_UTF8STRING
|| token
->type
== CPP_UTF8CHAR
818 || cpp_userdef_string_p (token
->type
)
819 || cpp_userdef_char_p (token
->type
));
821 /* Room for each char being written in octal, initial space and
822 final quote and NUL. */
823 len
= cpp_token_len (token
);
828 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
830 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
831 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
832 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
835 /* Leading white space? */
836 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
840 if (source
->flags
& PREV_WHITE
)
847 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
848 unsigned char *buf
= BUFF_FRONT (buff
);
849 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
850 dest
= cpp_quote_string (dest
, buf
, len
);
851 _cpp_release_buff (pfile
, buff
);
854 dest
= cpp_spell_token (pfile
, token
, dest
, true);
856 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
862 /* Ignore the final \ of invalid string literals. */
863 if (backslash_count
& 1)
865 cpp_error (pfile
, CPP_DL_WARNING
,
866 "invalid string literal, ignoring final '\\'");
870 /* Commit the memory, including NUL, and return the token. */
872 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
873 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
874 return new_string_token (pfile
, dest
- len
, len
);
877 /* Try to paste two tokens. On success, return nonzero. In any
878 case, PLHS is updated to point to the pasted token, which is
879 guaranteed to not have the PASTE_LEFT flag set. LOCATION is
880 the virtual location used for error reporting. */
882 paste_tokens (cpp_reader
*pfile
, location_t location
,
883 const cpp_token
**plhs
, const cpp_token
*rhs
)
885 unsigned char *buf
, *end
, *lhsend
;
889 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
890 buf
= (unsigned char *) alloca (len
);
891 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, true);
893 /* Avoid comment headers, since they are still processed in stage 3.
894 It is simpler to insert a space here, rather than modifying the
895 lexer to ignore comments in some circumstances. Simply returning
896 false doesn't work, since we want to clear the PASTE_LEFT flag. */
897 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
899 /* In one obscure case we might see padding here. */
900 if (rhs
->type
!= CPP_PADDING
)
901 end
= cpp_spell_token (pfile
, rhs
, end
, true);
904 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
905 _cpp_clean_line (pfile
);
907 /* Set pfile->cur_token as required by _cpp_lex_direct. */
908 pfile
->cur_token
= _cpp_temp_token (pfile
);
909 lhs
= _cpp_lex_direct (pfile
);
910 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
912 location_t saved_loc
= lhs
->src_loc
;
914 _cpp_pop_buffer (pfile
);
915 _cpp_backup_tokens (pfile
, 1);
918 /* We have to remove the PASTE_LEFT flag from the old lhs, but
919 we want to keep the new location. */
922 lhs
->src_loc
= saved_loc
;
923 lhs
->flags
&= ~PASTE_LEFT
;
925 /* Mandatory error for all apart from assembler. */
926 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
927 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
928 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
929 buf
, cpp_token_as_text (pfile
, rhs
));
934 _cpp_pop_buffer (pfile
);
938 /* Handles an arbitrarily long sequence of ## operators, with initial
939 operand LHS. This implementation is left-associative,
940 non-recursive, and finishes a paste before handling succeeding
941 ones. If a paste fails, we back up to the RHS of the failing ##
942 operator before pushing the context containing the result of prior
943 successful pastes, with the effect that the RHS appears in the
944 output stream after the pasted LHS normally. */
946 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
948 const cpp_token
*rhs
= NULL
;
949 cpp_context
*context
= pfile
->context
;
950 location_t virt_loc
= 0;
952 /* We are expanding a macro and we must have been called on a token
953 that appears at the left hand side of a ## operator. */
954 if (macro_of_context (pfile
->context
) == NULL
955 || (!(lhs
->flags
& PASTE_LEFT
)))
958 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
959 /* The caller must have called consume_next_token_from_context
960 right before calling us. That has incremented the pointer to
961 the current virtual location. So it now points to the location
962 of the token that comes right after *LHS. We want the
963 resulting pasted token to have the location of the current
965 virt_loc
= context
->c
.mc
->cur_virt_loc
[-1];
967 /* We are not tracking macro expansion. So the best virtual
968 location we can get here is the expansion point of the macro we
969 are currently expanding. */
970 virt_loc
= pfile
->invocation_location
;
974 /* Take the token directly from the current context. We can do
975 this, because we are in the replacement list of either an
976 object-like macro, or a function-like macro with arguments
977 inserted. In either case, the constraints to #define
978 guarantee we have at least one more token. */
979 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
980 rhs
= FIRST (context
).token
++;
981 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
982 rhs
= *FIRST (context
).ptoken
++;
983 else if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
985 /* So we are in presence of an extended token context, which
986 means that each token in this context has a virtual
987 location attached to it. So let's not forget to update
988 the pointer to the current virtual location of the
989 current token when we update the pointer to the current
992 rhs
= *FIRST (context
).ptoken
++;
993 /* context->c.mc must be non-null, as if we were not in a
994 macro context, context->tokens_kind could not be equal to
995 TOKENS_KIND_EXTENDED. */
996 context
->c
.mc
->cur_virt_loc
++;
999 if (rhs
->type
== CPP_PADDING
)
1001 if (rhs
->flags
& PASTE_LEFT
)
1004 if (!paste_tokens (pfile
, virt_loc
, &lhs
, rhs
))
1007 while (rhs
->flags
& PASTE_LEFT
);
1009 /* Put the resulting token in its own context. */
1010 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
1012 location_t
*virt_locs
= NULL
;
1013 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
1014 tokens_buff_add_token (token_buf
, virt_locs
, lhs
,
1015 virt_loc
, 0, NULL
, 0);
1016 push_extended_tokens_context (pfile
, context
->c
.mc
->macro_node
,
1017 token_buf
, virt_locs
,
1018 (const cpp_token
**)token_buf
->base
, 1);
1021 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
1024 /* Returns TRUE if the number of arguments ARGC supplied in an
1025 invocation of the MACRO referenced by NODE is valid. An empty
1026 invocation to a macro with no parameters should pass ARGC as zero.
1028 Note that MACRO cannot necessarily be deduced from NODE, in case
1029 NODE was redefined whilst collecting arguments. */
1031 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
1033 if (argc
== macro
->paramc
)
1036 if (argc
< macro
->paramc
)
1038 /* In C++20 (here the va_opt flag is used), and also as a GNU
1039 extension, variadic arguments are allowed to not appear in
1040 the invocation at all.
1041 e.g. #define debug(format, args...) something
1044 This is exactly the same as if an empty variadic list had been
1045 supplied - debug("string", ). */
1047 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
1049 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
1050 && ! CPP_OPTION (pfile
, va_opt
))
1052 if (CPP_OPTION (pfile
, cplusplus
))
1053 cpp_error (pfile
, CPP_DL_PEDWARN
,
1054 "ISO C++11 requires at least one argument "
1055 "for the \"...\" in a variadic macro");
1057 cpp_error (pfile
, CPP_DL_PEDWARN
,
1058 "ISO C99 requires at least one argument "
1059 "for the \"...\" in a variadic macro");
1064 cpp_error (pfile
, CPP_DL_ERROR
,
1065 "macro \"%s\" requires %u arguments, but only %u given",
1066 NODE_NAME (node
), macro
->paramc
, argc
);
1069 cpp_error (pfile
, CPP_DL_ERROR
,
1070 "macro \"%s\" passed %u arguments, but takes just %u",
1071 NODE_NAME (node
), argc
, macro
->paramc
);
1073 if (macro
->line
> RESERVED_LOCATION_COUNT
)
1074 cpp_error_at (pfile
, CPP_DL_NOTE
, macro
->line
, "macro \"%s\" defined here",
1080 /* Reads and returns the arguments to a function-like macro
1081 invocation. Assumes the opening parenthesis has been processed.
1082 If there is an error, emits an appropriate diagnostic and returns
1083 NULL. Each argument is terminated by a CPP_EOF token, for the
1084 future benefit of expand_arg(). If there are any deferred
1085 #pragma directives among macro arguments, store pointers to the
1086 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
1088 What is returned is the buffer that contains the memory allocated
1089 to hold the macro arguments. NODE is the name of the macro this
1090 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
1091 set to the actual number of macro arguments allocated in the
1094 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
,
1095 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1097 _cpp_buff
*buff
, *base_buff
;
1099 macro_arg
*args
, *arg
;
1100 const cpp_token
*token
;
1102 location_t virt_loc
;
1103 bool track_macro_expansion_p
= CPP_OPTION (pfile
, track_macro_expansion
);
1104 unsigned num_args_alloced
= 0;
1106 macro
= node
->value
.macro
;
1108 argc
= macro
->paramc
;
1112 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
1113 #define ARG_TOKENS_EXTENT 1000
1115 buff
= _cpp_get_buff (pfile
, argc
* (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
1116 * sizeof (cpp_token
*)
1117 + sizeof (macro_arg
)));
1119 args
= (macro_arg
*) buff
->base
;
1120 memset (args
, 0, argc
* sizeof (macro_arg
));
1121 buff
->cur
= (unsigned char *) &args
[argc
];
1122 arg
= args
, argc
= 0;
1124 /* Collect the tokens making up each argument. We don't yet know
1125 how many arguments have been supplied, whether too many or too
1126 few. Hence the slightly bizarre usage of "argc" and "arg". */
1129 unsigned int paren_depth
= 0;
1130 unsigned int ntokens
= 0;
1131 unsigned virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
1135 arg
->first
= (const cpp_token
**) buff
->cur
;
1136 if (track_macro_expansion_p
)
1138 virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
1139 arg
->virt_locs
= XNEWVEC (location_t
,
1140 virt_locs_capacity
);
1145 /* Require space for 2 new tokens (including a CPP_EOF). */
1146 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
1148 buff
= _cpp_append_extend_buff (pfile
, buff
,
1150 * sizeof (cpp_token
*));
1151 arg
->first
= (const cpp_token
**) buff
->cur
;
1153 if (track_macro_expansion_p
1154 && (ntokens
+ 2 > virt_locs_capacity
))
1156 virt_locs_capacity
+= ARG_TOKENS_EXTENT
;
1157 arg
->virt_locs
= XRESIZEVEC (location_t
,
1159 virt_locs_capacity
);
1162 token
= cpp_get_token_1 (pfile
, &virt_loc
);
1164 if (token
->type
== CPP_PADDING
)
1166 /* Drop leading padding. */
1170 else if (token
->type
== CPP_OPEN_PAREN
)
1172 else if (token
->type
== CPP_CLOSE_PAREN
)
1174 if (paren_depth
-- == 0)
1177 else if (token
->type
== CPP_COMMA
)
1179 /* A comma does not terminate an argument within
1180 parentheses or as part of a variable argument. */
1181 if (paren_depth
== 0
1182 && ! (macro
->variadic
&& argc
== macro
->paramc
))
1185 else if (token
->type
== CPP_EOF
1186 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
1188 else if (token
->type
== CPP_PRAGMA
)
1190 cpp_token
*newtok
= _cpp_temp_token (pfile
);
1192 /* CPP_PRAGMA token lives in directive_result, which will
1193 be overwritten on the next directive. */
1198 if (*pragma_buff
== NULL
1199 || BUFF_ROOM (*pragma_buff
) < sizeof (cpp_token
*))
1202 if (*pragma_buff
== NULL
)
1204 = _cpp_get_buff (pfile
, 32 * sizeof (cpp_token
*));
1207 next
= *pragma_buff
;
1209 = _cpp_get_buff (pfile
,
1210 (BUFF_FRONT (*pragma_buff
)
1211 - (*pragma_buff
)->base
) * 2);
1212 (*pragma_buff
)->next
= next
;
1215 *(const cpp_token
**) BUFF_FRONT (*pragma_buff
) = token
;
1216 BUFF_FRONT (*pragma_buff
) += sizeof (cpp_token
*);
1217 if (token
->type
== CPP_PRAGMA_EOL
)
1219 token
= cpp_get_token_1 (pfile
, &virt_loc
);
1221 while (token
->type
!= CPP_EOF
);
1223 /* In deferred pragmas parsing_args and prevent_expansion
1224 had been changed, reset it. */
1225 pfile
->state
.parsing_args
= 2;
1226 pfile
->state
.prevent_expansion
= 1;
1228 if (token
->type
== CPP_EOF
)
1233 set_arg_token (arg
, token
, virt_loc
,
1234 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1235 CPP_OPTION (pfile
, track_macro_expansion
));
1239 /* Drop trailing padding. */
1240 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
1243 arg
->count
= ntokens
;
1244 /* Append an EOF to mark end-of-argument. */
1245 set_arg_token (arg
, &pfile
->endarg
, token
->src_loc
,
1246 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1247 CPP_OPTION (pfile
, track_macro_expansion
));
1249 /* Terminate the argument. Excess arguments loop back and
1250 overwrite the final legitimate argument, before failing. */
1251 if (argc
<= macro
->paramc
)
1253 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
1254 if (argc
!= macro
->paramc
)
1258 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
1260 if (token
->type
== CPP_EOF
)
1262 /* Unless the EOF is marking the end of an argument, it's a fake
1263 one from the end of a file that _cpp_clean_line will not have
1265 if (token
== &pfile
->endarg
)
1266 _cpp_backup_tokens (pfile
, 1);
1267 cpp_error (pfile
, CPP_DL_ERROR
,
1268 "unterminated argument list invoking macro \"%s\"",
1273 /* A single empty argument is counted as no argument. */
1274 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
1276 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
1278 /* GCC has special semantics for , ## b where b is a varargs
1279 parameter: we remove the comma if b was omitted entirely.
1280 If b was merely an empty argument, the comma is retained.
1281 If the macro takes just one (varargs) parameter, then we
1282 retain the comma only if we are standards conforming.
1284 If FIRST is NULL replace_args () swallows the comma. */
1285 if (macro
->variadic
&& (argc
< macro
->paramc
1286 || (argc
== 1 && args
[0].count
== 0
1287 && !CPP_OPTION (pfile
, std
))))
1288 args
[macro
->paramc
- 1].first
= NULL
;
1290 *num_args
= num_args_alloced
;
1295 /* An error occurred. */
1296 _cpp_release_buff (pfile
, base_buff
);
1300 /* Search for an opening parenthesis to the macro of NODE, in such a
1301 way that, if none is found, we don't lose the information in any
1302 intervening padding tokens. If we find the parenthesis, collect
1303 the arguments and return the buffer containing them. PRAGMA_BUFF
1304 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
1305 *NUM_ARGS is set to the number of arguments contained in the
1308 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
1309 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1311 const cpp_token
*token
, *padding
= NULL
;
1315 token
= cpp_get_token (pfile
);
1316 if (token
->type
!= CPP_PADDING
)
1319 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
1323 if (token
->type
== CPP_OPEN_PAREN
)
1325 pfile
->state
.parsing_args
= 2;
1326 return collect_args (pfile
, node
, pragma_buff
, num_args
);
1329 /* Back up. A CPP_EOF is either an EOF from an argument we're
1330 expanding, or a fake one from lex_direct. We want to backup the
1331 former, but not the latter. We may have skipped padding, in
1332 which case backing up more than one token when expanding macros
1333 is in general too difficult. We re-insert it in its own
1335 if (token
->type
!= CPP_EOF
|| token
== &pfile
->endarg
)
1337 _cpp_backup_tokens (pfile
, 1);
1339 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
1345 /* Return the real number of tokens in the expansion of MACRO. */
1346 static inline unsigned int
1347 macro_real_token_count (const cpp_macro
*macro
)
1349 if (__builtin_expect (!macro
->extra_tokens
, true))
1350 return macro
->count
;
1352 for (unsigned i
= macro
->count
; i
--;)
1353 if (macro
->exp
.tokens
[i
].type
!= CPP_PASTE
)
1359 /* Push the context of a macro with hash entry NODE onto the context
1360 stack. If we can successfully expand the macro, we push a context
1361 containing its yet-to-be-rescanned replacement list and return one.
1362 If there were additionally any unexpanded deferred #pragma
1363 directives among macro arguments, push another context containing
1364 the pragma tokens before the yet-to-be-rescanned replacement list
1365 and return two. Otherwise, we don't push a context and return
1366 zero. LOCATION is the location of the expansion point of the
1369 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
1370 const cpp_token
*result
, location_t location
)
1372 /* The presence of a macro invalidates a file's controlling macro. */
1373 pfile
->mi_valid
= false;
1375 pfile
->state
.angled_headers
= false;
1377 /* From here to when we push the context for the macro later down
1378 this function, we need to flag the fact that we are about to
1379 expand a macro. This is useful when -ftrack-macro-expansion is
1380 turned off. In that case, we need to record the location of the
1381 expansion point of the top-most macro we are about to to expand,
1382 into pfile->invocation_location. But we must not record any such
1383 location once the process of expanding the macro starts; that is,
1384 we must not do that recording between now and later down this
1385 function where set this flag to FALSE. */
1386 pfile
->about_to_expand_macro_p
= true;
1388 if (cpp_user_macro_p (node
))
1390 cpp_macro
*macro
= node
->value
.macro
;
1391 _cpp_buff
*pragma_buff
= NULL
;
1393 if (macro
->fun_like
)
1396 unsigned num_args
= 0;
1398 pfile
->state
.prevent_expansion
++;
1399 pfile
->keep_tokens
++;
1400 pfile
->state
.parsing_args
= 1;
1401 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
,
1403 pfile
->state
.parsing_args
= 0;
1404 pfile
->keep_tokens
--;
1405 pfile
->state
.prevent_expansion
--;
1409 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
1410 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1411 "function-like macro \"%s\" must be used with arguments in traditional C",
1415 _cpp_release_buff (pfile
, pragma_buff
);
1417 pfile
->about_to_expand_macro_p
= false;
1421 if (macro
->paramc
> 0)
1422 replace_args (pfile
, node
, macro
,
1423 (macro_arg
*) buff
->base
,
1425 /* Free the memory used by the arguments of this
1426 function-like macro. This memory has been allocated by
1427 funlike_invocation_p and by replace_args. */
1428 delete_macro_args (buff
, num_args
);
1431 /* Disable the macro within its expansion. */
1432 node
->flags
|= NODE_DISABLED
;
1434 /* Laziness can only affect the expansion tokens of the macro,
1435 not its fun-likeness or parameters. */
1436 _cpp_maybe_notify_macro_use (pfile
, node
);
1438 pfile
->cb
.used (pfile
, location
, node
);
1442 if (macro
->paramc
== 0)
1444 unsigned tokens_count
= macro_real_token_count (macro
);
1445 if (CPP_OPTION (pfile
, track_macro_expansion
))
1448 const cpp_token
*src
= macro
->exp
.tokens
;
1449 const line_map_macro
*map
;
1450 location_t
*virt_locs
= NULL
;
1451 _cpp_buff
*macro_tokens
1452 = tokens_buff_new (pfile
, tokens_count
, &virt_locs
);
1454 /* Create a macro map to record the locations of the
1455 tokens that are involved in the expansion. LOCATION
1456 is the location of the macro expansion point. */
1457 map
= linemap_enter_macro (pfile
->line_table
,
1458 node
, location
, tokens_count
);
1459 for (i
= 0; i
< tokens_count
; ++i
)
1461 tokens_buff_add_token (macro_tokens
, virt_locs
,
1463 src
->src_loc
, map
, i
);
1466 push_extended_tokens_context (pfile
, node
,
1469 (const cpp_token
**)
1474 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
,
1476 num_macro_tokens_counter
+= tokens_count
;
1481 if (!pfile
->state
.in_directive
)
1482 _cpp_push_token_context (pfile
, NULL
,
1483 padding_token (pfile
, result
), 1);
1486 unsigned tokens_count
;
1487 _cpp_buff
*tail
= pragma_buff
->next
;
1488 pragma_buff
->next
= NULL
;
1489 tokens_count
= ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
1490 - (const cpp_token
**) pragma_buff
->base
);
1491 push_ptoken_context (pfile
, NULL
, pragma_buff
,
1492 (const cpp_token
**) pragma_buff
->base
,
1495 if (!CPP_OPTION (pfile
, track_macro_expansion
))
1496 num_macro_tokens_counter
+= tokens_count
;
1499 while (pragma_buff
!= NULL
);
1500 pfile
->about_to_expand_macro_p
= false;
1504 pfile
->about_to_expand_macro_p
= false;
1508 pfile
->about_to_expand_macro_p
= false;
1509 /* Handle built-in macros and the _Pragma operator. */
1511 location_t expand_loc
;
1513 if (/* The top-level macro invocation that triggered the expansion
1514 we are looking at is with a function-like user macro ... */
1515 cpp_fun_like_macro_p (pfile
->top_most_macro_node
)
1516 /* ... and we are tracking the macro expansion. */
1517 && CPP_OPTION (pfile
, track_macro_expansion
))
1518 /* Then the location of the end of the macro invocation is the
1519 location of the expansion point of this macro. */
1520 expand_loc
= location
;
1522 /* Otherwise, the location of the end of the macro invocation is
1523 the location of the expansion point of that top-level macro
1525 expand_loc
= pfile
->invocation_location
;
1527 return builtin_macro (pfile
, node
, location
, expand_loc
);
1531 /* De-allocate the memory used by BUFF which is an array of instances
1532 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1535 delete_macro_args (_cpp_buff
*buff
, unsigned num_args
)
1537 macro_arg
*macro_args
;
1543 macro_args
= (macro_arg
*) buff
->base
;
1545 /* Walk instances of macro_arg to free their expanded tokens as well
1546 as their macro_arg::virt_locs members. */
1547 for (i
= 0; i
< num_args
; ++i
)
1549 if (macro_args
[i
].expanded
)
1551 free (macro_args
[i
].expanded
);
1552 macro_args
[i
].expanded
= NULL
;
1554 if (macro_args
[i
].virt_locs
)
1556 free (macro_args
[i
].virt_locs
);
1557 macro_args
[i
].virt_locs
= NULL
;
1559 if (macro_args
[i
].expanded_virt_locs
)
1561 free (macro_args
[i
].expanded_virt_locs
);
1562 macro_args
[i
].expanded_virt_locs
= NULL
;
1565 _cpp_free_buff (buff
);
1568 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1569 to set, LOCATION is its virtual location. "Virtual" location means
1570 the location that encodes loci across macro expansion. Otherwise
1571 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1572 argument ARG is supposed to contain. Note that ARG must be
1573 tailored so that it has enough room to contain INDEX + 1 numbers of
1574 tokens, at least. */
1576 set_arg_token (macro_arg
*arg
, const cpp_token
*token
,
1577 location_t location
, size_t index
,
1578 enum macro_arg_token_kind kind
,
1579 bool track_macro_exp_p
)
1581 const cpp_token
**token_ptr
;
1582 location_t
*loc
= NULL
;
1585 arg_token_ptr_at (arg
, index
, kind
,
1586 track_macro_exp_p
? &loc
: NULL
);
1591 /* We can't set the location of a stringified argument
1592 token and we can't set any location if we aren't tracking
1593 macro expansion locations. */
1594 gcc_checking_assert (kind
!= MACRO_ARG_TOKEN_STRINGIFIED
1595 && track_macro_exp_p
);
1600 /* Get the pointer to the location of the argument token of the
1601 function-like macro argument ARG. This function must be called
1602 only when we -ftrack-macro-expansion is on. */
1603 static const location_t
*
1604 get_arg_token_location (const macro_arg
*arg
,
1605 enum macro_arg_token_kind kind
)
1607 const location_t
*loc
= NULL
;
1608 const cpp_token
**token_ptr
=
1609 arg_token_ptr_at (arg
, 0, kind
, (location_t
**) &loc
);
1611 if (token_ptr
== NULL
)
1617 /* Return the pointer to the INDEXth token of the macro argument ARG.
1618 KIND specifies the kind of token the macro argument ARG contains.
1619 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1620 of the virtual location of the returned token if the
1621 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1622 spelling location of the returned token. */
1623 static const cpp_token
**
1624 arg_token_ptr_at (const macro_arg
*arg
, size_t index
,
1625 enum macro_arg_token_kind kind
,
1626 location_t
**virt_location
)
1628 const cpp_token
**tokens_ptr
= NULL
;
1632 case MACRO_ARG_TOKEN_NORMAL
:
1633 tokens_ptr
= arg
->first
;
1635 case MACRO_ARG_TOKEN_STRINGIFIED
:
1636 tokens_ptr
= (const cpp_token
**) &arg
->stringified
;
1638 case MACRO_ARG_TOKEN_EXPANDED
:
1639 tokens_ptr
= arg
->expanded
;
1643 if (tokens_ptr
== NULL
)
1644 /* This can happen for e.g, an empty token argument to a
1645 funtion-like macro. */
1650 if (kind
== MACRO_ARG_TOKEN_NORMAL
)
1651 *virt_location
= &arg
->virt_locs
[index
];
1652 else if (kind
== MACRO_ARG_TOKEN_EXPANDED
)
1653 *virt_location
= &arg
->expanded_virt_locs
[index
];
1654 else if (kind
== MACRO_ARG_TOKEN_STRINGIFIED
)
1656 (location_t
*) &tokens_ptr
[index
]->src_loc
;
1658 return &tokens_ptr
[index
];
1661 /* Initialize an iterator so that it iterates over the tokens of a
1662 function-like macro argument. KIND is the kind of tokens we want
1663 ITER to iterate over. TOKEN_PTR points the first token ITER will
1666 macro_arg_token_iter_init (macro_arg_token_iter
*iter
,
1667 bool track_macro_exp_p
,
1668 enum macro_arg_token_kind kind
,
1669 const macro_arg
*arg
,
1670 const cpp_token
**token_ptr
)
1672 iter
->track_macro_exp_p
= track_macro_exp_p
;
1674 iter
->token_ptr
= token_ptr
;
1675 /* Unconditionally initialize this so that the compiler doesn't warn
1676 about iter->location_ptr being possibly uninitialized later after
1677 this code has been inlined somewhere. */
1678 iter
->location_ptr
= NULL
;
1679 if (track_macro_exp_p
)
1680 iter
->location_ptr
= get_arg_token_location (arg
, kind
);
1682 iter
->num_forwards
= 0;
1683 if (track_macro_exp_p
1684 && token_ptr
!= NULL
1685 && iter
->location_ptr
== NULL
)
1690 /* Move the iterator one token forward. Note that if IT was
1691 initialized on an argument that has a stringified token, moving it
1692 forward doesn't make sense as a stringified token is essentially one
1695 macro_arg_token_iter_forward (macro_arg_token_iter
*it
)
1699 case MACRO_ARG_TOKEN_NORMAL
:
1700 case MACRO_ARG_TOKEN_EXPANDED
:
1702 if (it
->track_macro_exp_p
)
1705 case MACRO_ARG_TOKEN_STRINGIFIED
:
1707 if (it
->num_forwards
> 0)
1718 /* Return the token pointed to by the iterator. */
1719 static const cpp_token
*
1720 macro_arg_token_iter_get_token (const macro_arg_token_iter
*it
)
1723 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1724 && it
->num_forwards
> 0)
1727 if (it
->token_ptr
== NULL
)
1729 return *it
->token_ptr
;
1732 /* Return the location of the token pointed to by the iterator.*/
1734 macro_arg_token_iter_get_location (const macro_arg_token_iter
*it
)
1737 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1738 && it
->num_forwards
> 0)
1741 if (it
->track_macro_exp_p
)
1742 return *it
->location_ptr
;
1744 return (*it
->token_ptr
)->src_loc
;
1747 /* Return the index of a token [resulting from macro expansion] inside
1748 the total list of tokens resulting from a given macro
1749 expansion. The index can be different depending on whether if we
1750 want each tokens resulting from function-like macro arguments
1751 expansion to have a different location or not.
1753 E.g, consider this function-like macro:
1757 Then consider us "calling" it (and thus expanding it) like:
1761 It will be expanded into:
1765 Let's consider the case of the token '4'.
1767 Its index can be 2 (it's the third token of the set of tokens
1768 resulting from the expansion) or it can be 0 if we consider that
1769 all tokens resulting from the expansion of the argument "1+2" have
1770 the same index, which is 0. In this later case, the index of token
1771 '-' would then be 1 and the index of token '3' would be 2.
1773 The later case is useful to use less memory e.g, for the case of
1774 the user using the option -ftrack-macro-expansion=1.
1776 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1777 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1778 parameter (inside the macro replacement list) that corresponds to
1779 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1782 If we refer to the example above, for the '4' argument token,
1783 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1784 would be set to the token 'x', in the replacement list "x - 3" of
1787 This is a subroutine of replace_args. */
1788 inline static unsigned
1789 expanded_token_index (cpp_reader
*pfile
, cpp_macro
*macro
,
1790 const cpp_token
*cur_replacement_token
,
1791 unsigned absolute_token_index
)
1793 if (CPP_OPTION (pfile
, track_macro_expansion
) > 1)
1794 return absolute_token_index
;
1795 return cur_replacement_token
- macro
->exp
.tokens
;
1798 /* Copy whether PASTE_LEFT is set from SRC to *PASTE_FLAG. */
1801 copy_paste_flag (cpp_reader
*pfile
, const cpp_token
**paste_flag
,
1802 const cpp_token
*src
)
1804 cpp_token
*token
= _cpp_temp_token (pfile
);
1805 token
->type
= (*paste_flag
)->type
;
1806 token
->val
= (*paste_flag
)->val
;
1807 if (src
->flags
& PASTE_LEFT
)
1808 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1810 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1811 *paste_flag
= token
;
1814 /* True IFF the last token emitted into BUFF (if any) is PTR. */
1817 last_token_is (_cpp_buff
*buff
, const cpp_token
**ptr
)
1819 return (ptr
&& tokens_buff_last_token_ptr (buff
) == ptr
);
1822 /* Replace the parameters in a function-like macro of NODE with the
1823 actual ARGS, and place the result in a newly pushed token context.
1824 Expand each argument before replacing, unless it is operated upon
1825 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1826 the expansion point of the macro. E.g, the location of the
1827 function-like macro invocation. */
1829 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
,
1830 macro_arg
*args
, location_t expansion_point_loc
)
1832 unsigned int i
, total
;
1833 const cpp_token
*src
, *limit
;
1834 const cpp_token
**first
= NULL
;
1836 _cpp_buff
*buff
= NULL
;
1837 location_t
*virt_locs
= NULL
;
1838 unsigned int exp_count
;
1839 const line_map_macro
*map
= NULL
;
1840 int track_macro_exp
;
1842 /* First, fully macro-expand arguments, calculating the number of
1843 tokens in the final expansion as we go. The ordering of the if
1844 statements below is subtle; we must handle stringification before
1847 /* EXP_COUNT is the number of tokens in the macro replacement
1848 list. TOTAL is the number of tokens /after/ macro parameters
1849 have been replaced by their arguments. */
1850 exp_count
= macro_real_token_count (macro
);
1852 limit
= macro
->exp
.tokens
+ exp_count
;
1854 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1855 if (src
->type
== CPP_MACRO_ARG
)
1857 /* Leading and trailing padding tokens. */
1859 /* Account for leading and padding tokens in exp_count too.
1860 This is going to be important later down this function,
1861 when we want to handle the case of (track_macro_exp <
1865 /* We have an argument. If it is not being stringified or
1866 pasted it is macro-replaced before insertion. */
1867 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
1869 if (src
->flags
& STRINGIFY_ARG
)
1871 if (!arg
->stringified
)
1872 arg
->stringified
= stringify_arg (pfile
, arg
);
1874 else if ((src
->flags
& PASTE_LEFT
)
1875 || (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
1876 total
+= arg
->count
- 1;
1880 expand_arg (pfile
, arg
);
1881 total
+= arg
->expanded_count
- 1;
1885 /* When the compiler is called with the -ftrack-macro-expansion
1886 flag, we need to keep track of the location of each token that
1887 results from macro expansion.
1889 A token resulting from macro expansion is not a new token. It is
1890 simply the same token as the token coming from the macro
1891 definition. The new things that are allocated are the buffer
1892 that holds the tokens resulting from macro expansion and a new
1893 location that records many things like the locus of the expansion
1894 point as well as the original locus inside the definition of the
1895 macro. This location is called a virtual location.
1897 So the buffer BUFF holds a set of cpp_token*, and the buffer
1898 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1900 Both of these two buffers are going to be hung off of the macro
1901 context, when the latter is pushed. The memory allocated to
1902 store the tokens and their locations is going to be freed once
1903 the context of macro expansion is popped.
1905 As far as tokens are concerned, the memory overhead of
1906 -ftrack-macro-expansion is proportional to the number of
1907 macros that get expanded multiplied by sizeof (location_t).
1908 The good news is that extra memory gets freed when the macro
1909 context is freed, i.e shortly after the macro got expanded. */
1911 /* Is the -ftrack-macro-expansion flag in effect? */
1912 track_macro_exp
= CPP_OPTION (pfile
, track_macro_expansion
);
1914 /* Now allocate memory space for tokens and locations resulting from
1915 the macro expansion, copy the tokens and replace the arguments.
1916 This memory must be freed when the context of the macro MACRO is
1918 buff
= tokens_buff_new (pfile
, total
, track_macro_exp
? &virt_locs
: NULL
);
1920 first
= (const cpp_token
**) buff
->base
;
1922 /* Create a macro map to record the locations of the tokens that are
1923 involved in the expansion. Note that the expansion point is set
1924 to the location of the closing parenthesis. Otherwise, the
1925 subsequent map created for the first token that comes after the
1926 macro map might have a wrong line number. That would lead to
1927 tokens with wrong line numbers after the macro expansion. This
1928 adds up to the memory overhead of the -ftrack-macro-expansion
1929 flag; for every macro that is expanded, a "macro map" is
1931 if (track_macro_exp
)
1933 int num_macro_tokens
= total
;
1934 if (track_macro_exp
< 2)
1935 /* Then the number of macro tokens won't take in account the
1936 fact that function-like macro arguments can expand to
1937 multiple tokens. This is to save memory at the expense of
1940 Suppose we have #define SQUARE(A) A * A
1942 And then we do SQUARE(2+3)
1944 Then the tokens 2, +, 3, will have the same location,
1945 saying they come from the expansion of the argument A. */
1946 num_macro_tokens
= exp_count
;
1947 map
= linemap_enter_macro (pfile
->line_table
, node
,
1948 expansion_point_loc
,
1952 vaopt_state
vaopt_tracker (pfile
, macro
->variadic
, &args
[macro
->paramc
- 1]);
1953 const cpp_token
**vaopt_start
= NULL
;
1954 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1956 unsigned int arg_tokens_count
;
1957 macro_arg_token_iter from
;
1958 const cpp_token
**paste_flag
= NULL
;
1959 const cpp_token
**tmp_token_ptr
;
1961 /* __VA_OPT__ handling. */
1962 vaopt_state::update_type vostate
= vaopt_tracker
.update (src
);
1963 if (vostate
!= vaopt_state::INCLUDE
)
1965 if (vostate
== vaopt_state::BEGIN
)
1967 /* Padding on the left of __VA_OPT__ (unless RHS of ##). */
1968 if (src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
1970 const cpp_token
*t
= padding_token (pfile
, src
);
1971 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
1972 /* Allocate a virtual location for the padding token and
1973 append the token and its location to BUFF and
1975 tokens_buff_add_token (buff
, virt_locs
, t
,
1976 t
->src_loc
, t
->src_loc
,
1979 vaopt_start
= tokens_buff_last_token_ptr (buff
);
1981 else if (vostate
== vaopt_state::END
)
1983 const cpp_token
**start
= vaopt_start
;
1986 /* Remove any tail padding from inside the __VA_OPT__. */
1987 paste_flag
= tokens_buff_last_token_ptr (buff
);
1988 while (paste_flag
&& paste_flag
!= start
1989 && (*paste_flag
)->type
== CPP_PADDING
)
1991 tokens_buff_remove_last_token (buff
);
1992 paste_flag
= tokens_buff_last_token_ptr (buff
);
1995 if (src
->flags
& PASTE_LEFT
)
1997 /* With a non-empty __VA_OPT__ on the LHS of ##, the last
1998 token should be flagged PASTE_LEFT. */
1999 if (paste_flag
&& (*paste_flag
)->type
!= CPP_PADDING
)
2000 copy_paste_flag (pfile
, paste_flag
, src
);
2004 /* Otherwise, avoid paste on RHS, __VA_OPT__(c)d or
2005 __VA_OPT__(c)__VA_OPT__(d). */
2006 const cpp_token
*t
= &pfile
->avoid_paste
;
2007 tokens_buff_add_token (buff
, virt_locs
,
2008 t
, t
->src_loc
, t
->src_loc
,
2015 if (src
->type
!= CPP_MACRO_ARG
)
2017 /* Allocate a virtual location for token SRC, and add that
2018 token and its virtual location into the buffers BUFF and
2020 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2021 tokens_buff_add_token (buff
, virt_locs
, src
,
2022 src
->src_loc
, src
->src_loc
,
2029 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
2030 /* SRC is a macro parameter that we need to replace with its
2031 corresponding argument. So at some point we'll need to
2032 iterate over the tokens of the macro argument and copy them
2033 into the "place" now holding the correspondig macro
2034 parameter. We are going to use the iterator type
2035 macro_argo_token_iter to handle that iterating. The 'if'
2036 below is to initialize the iterator depending on the type of
2037 tokens the macro argument has. It also does some adjustment
2038 related to padding tokens and some pasting corner cases. */
2039 if (src
->flags
& STRINGIFY_ARG
)
2041 arg_tokens_count
= 1;
2042 macro_arg_token_iter_init (&from
,
2044 track_macro_expansion
),
2045 MACRO_ARG_TOKEN_STRINGIFIED
,
2046 arg
, &arg
->stringified
);
2048 else if (src
->flags
& PASTE_LEFT
)
2050 arg_tokens_count
= arg
->count
;
2051 macro_arg_token_iter_init (&from
,
2053 track_macro_expansion
),
2054 MACRO_ARG_TOKEN_NORMAL
,
2057 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
2060 arg_tokens_count
= arg
->count
;
2061 macro_arg_token_iter_init (&from
,
2063 track_macro_expansion
),
2064 MACRO_ARG_TOKEN_NORMAL
,
2067 num_toks
= tokens_buff_count (buff
);
2071 /* So the current parameter token is pasted to the previous
2072 token in the replacement list. Let's look at what
2073 we have as previous and current arguments. */
2075 /* This is the previous argument's token ... */
2076 tmp_token_ptr
= tokens_buff_last_token_ptr (buff
);
2078 if ((*tmp_token_ptr
)->type
== CPP_COMMA
2080 && src
->val
.macro_arg
.arg_no
== macro
->paramc
)
2082 /* ... which is a comma; and the current parameter
2083 is the last parameter of a variadic function-like
2084 macro. If the argument to the current last
2085 parameter is NULL, then swallow the comma,
2086 otherwise drop the paste flag. */
2087 if (macro_arg_token_iter_get_token (&from
) == NULL
)
2088 tokens_buff_remove_last_token (buff
);
2090 paste_flag
= tmp_token_ptr
;
2092 /* Remove the paste flag if the RHS is a placemarker, unless the
2093 previous emitted token is at the beginning of __VA_OPT__;
2094 placemarkers within __VA_OPT__ are ignored in that case. */
2095 else if (arg_tokens_count
== 0
2096 && tmp_token_ptr
!= vaopt_start
)
2097 paste_flag
= tmp_token_ptr
;
2102 arg_tokens_count
= arg
->expanded_count
;
2103 macro_arg_token_iter_init (&from
,
2105 track_macro_expansion
),
2106 MACRO_ARG_TOKEN_EXPANDED
,
2107 arg
, arg
->expanded
);
2109 if (last_token_is (buff
, vaopt_start
))
2111 /* We're expanding an arg at the beginning of __VA_OPT__.
2113 while (arg_tokens_count
)
2115 const cpp_token
*t
= macro_arg_token_iter_get_token (&from
);
2116 if (t
->type
!= CPP_PADDING
)
2118 macro_arg_token_iter_forward (&from
);
2124 /* Padding on the left of an argument (unless RHS of ##). */
2125 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
2126 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
)
2127 && !last_token_is (buff
, vaopt_start
))
2129 const cpp_token
*t
= padding_token (pfile
, src
);
2130 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2131 /* Allocate a virtual location for the padding token and
2132 append the token and its location to BUFF and
2134 tokens_buff_add_token (buff
, virt_locs
, t
,
2135 t
->src_loc
, t
->src_loc
,
2139 if (arg_tokens_count
)
2141 /* So now we've got the number of tokens that make up the
2142 argument that is going to replace the current parameter
2143 in the macro's replacement list. */
2145 for (j
= 0; j
< arg_tokens_count
; ++j
)
2147 /* So if track_macro_exp is < 2, the user wants to
2148 save extra memory while tracking macro expansion
2149 locations. So in that case here is what we do:
2151 Suppose we have #define SQUARE(A) A * A
2153 And then we do SQUARE(2+3)
2155 Then the tokens 2, +, 3, will have the same location,
2156 saying they come from the expansion of the argument
2159 So that means we are going to ignore the COUNT tokens
2160 resulting from the expansion of the current macro
2161 argument. In other words all the ARG_TOKENS_COUNT tokens
2162 resulting from the expansion of the macro argument will
2163 have the index I. Normally, each of those tokens should
2165 unsigned token_index
= i
;
2167 if (track_macro_exp
> 1)
2170 index
= expanded_token_index (pfile
, macro
, src
, token_index
);
2171 tokens_buff_add_token (buff
, virt_locs
,
2172 macro_arg_token_iter_get_token (&from
),
2173 macro_arg_token_iter_get_location (&from
),
2174 src
->src_loc
, map
, index
);
2175 macro_arg_token_iter_forward (&from
);
2178 /* With a non-empty argument on the LHS of ##, the last
2179 token should be flagged PASTE_LEFT. */
2180 if (src
->flags
& PASTE_LEFT
)
2182 = (const cpp_token
**) tokens_buff_last_token_ptr (buff
);
2184 else if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, c99
)
2185 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2187 if (CPP_OPTION (pfile
, cplusplus
))
2188 cpp_pedwarning (pfile
, CPP_W_PEDANTIC
,
2189 "invoking macro %s argument %d: "
2190 "empty macro arguments are undefined"
2192 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2193 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
))
2194 cpp_pedwarning (pfile
,
2195 CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2196 ? CPP_W_C90_C99_COMPAT
: CPP_W_PEDANTIC
,
2197 "invoking macro %s argument %d: "
2198 "empty macro arguments are undefined"
2200 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2202 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2203 && ! CPP_OPTION (pfile
, cplusplus
)
2204 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2205 cpp_warning (pfile
, CPP_W_C90_C99_COMPAT
,
2206 "invoking macro %s argument %d: "
2207 "empty macro arguments are undefined"
2209 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2211 /* Avoid paste on RHS (even case count == 0). */
2212 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
)
2213 && !last_token_is (buff
, vaopt_start
))
2215 const cpp_token
*t
= &pfile
->avoid_paste
;
2216 tokens_buff_add_token (buff
, virt_locs
,
2217 t
, t
->src_loc
, t
->src_loc
,
2221 /* Add a new paste flag, or remove an unwanted one. */
2223 copy_paste_flag (pfile
, paste_flag
, src
);
2225 i
+= arg_tokens_count
;
2228 if (track_macro_exp
)
2229 push_extended_tokens_context (pfile
, node
, buff
, virt_locs
, first
,
2230 tokens_buff_count (buff
));
2232 push_ptoken_context (pfile
, node
, buff
, first
,
2233 tokens_buff_count (buff
));
2235 num_macro_tokens_counter
+= tokens_buff_count (buff
);
2238 /* Return a special padding token, with padding inherited from SOURCE. */
2239 static const cpp_token
*
2240 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
2242 cpp_token
*result
= _cpp_temp_token (pfile
);
2244 result
->type
= CPP_PADDING
;
2246 /* Data in GCed data structures cannot be made const so far, so we
2247 need a cast here. */
2248 result
->val
.source
= (cpp_token
*) source
;
2253 /* Get a new uninitialized context. Create a new one if we cannot
2254 re-use an old one. */
2255 static cpp_context
*
2256 next_context (cpp_reader
*pfile
)
2258 cpp_context
*result
= pfile
->context
->next
;
2262 result
= XNEW (cpp_context
);
2263 memset (result
, 0, sizeof (cpp_context
));
2264 result
->prev
= pfile
->context
;
2266 pfile
->context
->next
= result
;
2269 pfile
->context
= result
;
2273 /* Push a list of pointers to tokens. */
2275 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
2276 const cpp_token
**first
, unsigned int count
)
2278 cpp_context
*context
= next_context (pfile
);
2280 context
->tokens_kind
= TOKENS_KIND_INDIRECT
;
2281 context
->c
.macro
= macro
;
2282 context
->buff
= buff
;
2283 FIRST (context
).ptoken
= first
;
2284 LAST (context
).ptoken
= first
+ count
;
2287 /* Push a list of tokens.
2289 A NULL macro means that we should continue the current macro
2290 expansion, in essence. That means that if we are currently in a
2291 macro expansion context, we'll make the new pfile->context refer to
2292 the current macro. */
2294 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2295 const cpp_token
*first
, unsigned int count
)
2297 cpp_context
*context
;
2300 macro
= macro_of_context (pfile
->context
);
2302 context
= next_context (pfile
);
2303 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2304 context
->c
.macro
= macro
;
2305 context
->buff
= NULL
;
2306 FIRST (context
).token
= first
;
2307 LAST (context
).token
= first
+ count
;
2310 /* Build a context containing a list of tokens as well as their
2311 virtual locations and push it. TOKENS_BUFF is the buffer that
2312 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
2313 non-NULL, it means that the context owns it, meaning that
2314 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
2315 contains the virtual locations.
2317 A NULL macro means that we should continue the current macro
2318 expansion, in essence. That means that if we are currently in a
2319 macro expansion context, we'll make the new pfile->context refer to
2320 the current macro. */
2322 push_extended_tokens_context (cpp_reader
*pfile
,
2323 cpp_hashnode
*macro
,
2324 _cpp_buff
*token_buff
,
2325 location_t
*virt_locs
,
2326 const cpp_token
**first
,
2329 cpp_context
*context
;
2333 macro
= macro_of_context (pfile
->context
);
2335 context
= next_context (pfile
);
2336 context
->tokens_kind
= TOKENS_KIND_EXTENDED
;
2337 context
->buff
= token_buff
;
2339 m
= XNEW (macro_context
);
2340 m
->macro_node
= macro
;
2341 m
->virt_locs
= virt_locs
;
2342 m
->cur_virt_loc
= virt_locs
;
2344 FIRST (context
).ptoken
= first
;
2345 LAST (context
).ptoken
= first
+ count
;
2348 /* Push a traditional macro's replacement text. */
2350 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2351 const uchar
*start
, size_t len
)
2353 cpp_context
*context
= next_context (pfile
);
2355 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2356 context
->c
.macro
= macro
;
2357 context
->buff
= NULL
;
2358 CUR (context
) = start
;
2359 RLIMIT (context
) = start
+ len
;
2360 macro
->flags
|= NODE_DISABLED
;
2363 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
2364 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
2365 non-null (which means that -ftrack-macro-expansion is on),
2366 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
2367 hold the virtual locations of the tokens resulting from macro
2370 tokens_buff_new (cpp_reader
*pfile
, size_t len
,
2371 location_t
**virt_locs
)
2373 size_t tokens_size
= len
* sizeof (cpp_token
*);
2374 size_t locs_size
= len
* sizeof (location_t
);
2376 if (virt_locs
!= NULL
)
2377 *virt_locs
= XNEWVEC (location_t
, locs_size
);
2378 return _cpp_get_buff (pfile
, tokens_size
);
2381 /* Returns the number of tokens contained in a token buffer. The
2382 buffer holds a set of cpp_token*. */
2384 tokens_buff_count (_cpp_buff
*buff
)
2386 return (BUFF_FRONT (buff
) - buff
->base
) / sizeof (cpp_token
*);
2389 /* Return a pointer to the last token contained in the token buffer
2391 static const cpp_token
**
2392 tokens_buff_last_token_ptr (_cpp_buff
*buff
)
2394 if (BUFF_FRONT (buff
) == buff
->base
)
2396 return &((const cpp_token
**) BUFF_FRONT (buff
))[-1];
2399 /* Remove the last token contained in the token buffer TOKENS_BUFF.
2400 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
2401 containing the virtual locations of the tokens in TOKENS_BUFF; in
2402 which case the function updates that buffer as well. */
2404 tokens_buff_remove_last_token (_cpp_buff
*tokens_buff
)
2407 if (BUFF_FRONT (tokens_buff
) > tokens_buff
->base
)
2408 BUFF_FRONT (tokens_buff
) =
2409 (unsigned char *) &((cpp_token
**) BUFF_FRONT (tokens_buff
))[-1];
2412 /* Insert a token into the token buffer at the position pointed to by
2413 DEST. Note that the buffer is not enlarged so the previous token
2414 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
2415 means -ftrack-macro-expansion is effect; it then points to where to
2416 insert the virtual location of TOKEN. TOKEN is the token to
2417 insert. VIRT_LOC is the virtual location of the token, i.e, the
2418 location possibly encoding its locus across macro expansion. If
2419 TOKEN is an argument of a function-like macro (inside a macro
2420 replacement list), PARM_DEF_LOC is the spelling location of the
2421 macro parameter that TOKEN is replacing, in the replacement list of
2422 the macro. If TOKEN is not an argument of a function-like macro or
2423 if it doesn't come from a macro expansion, then VIRT_LOC can just
2424 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
2425 means TOKEN comes from a macro expansion and MAP is the macro map
2426 associated to the macro. MACRO_TOKEN_INDEX points to the index of
2427 the token in the macro map; it is not considered if MAP is NULL.
2429 Upon successful completion this function returns the a pointer to
2430 the position of the token coming right after the insertion
2432 static inline const cpp_token
**
2433 tokens_buff_put_token_to (const cpp_token
**dest
,
2434 location_t
*virt_loc_dest
,
2435 const cpp_token
*token
,
2436 location_t virt_loc
,
2437 location_t parm_def_loc
,
2438 const line_map_macro
*map
,
2439 unsigned int macro_token_index
)
2441 location_t macro_loc
= virt_loc
;
2442 const cpp_token
**result
;
2446 /* -ftrack-macro-expansion is on. */
2448 macro_loc
= linemap_add_macro_token (map
, macro_token_index
,
2449 virt_loc
, parm_def_loc
);
2450 *virt_loc_dest
= macro_loc
;
2458 /* Adds a token at the end of the tokens contained in BUFFER. Note
2459 that this function doesn't enlarge BUFFER when the number of tokens
2460 reaches BUFFER's size; it aborts in that situation.
2462 TOKEN is the token to append. VIRT_LOC is the virtual location of
2463 the token, i.e, the location possibly encoding its locus across
2464 macro expansion. If TOKEN is an argument of a function-like macro
2465 (inside a macro replacement list), PARM_DEF_LOC is the location of
2466 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
2467 from a macro expansion, then VIRT_LOC can just be set to the same
2468 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
2469 from a macro expansion and MAP is the macro map associated to the
2470 macro. MACRO_TOKEN_INDEX points to the index of the token in the
2471 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
2472 non-null, it means -ftrack-macro-expansion is on; in which case
2473 this function adds the virtual location DEF_LOC to the VIRT_LOCS
2474 array, at the same index as the one of TOKEN in BUFFER. Upon
2475 successful completion this function returns the a pointer to the
2476 position of the token coming right after the insertion point. */
2477 static const cpp_token
**
2478 tokens_buff_add_token (_cpp_buff
*buffer
,
2479 location_t
*virt_locs
,
2480 const cpp_token
*token
,
2481 location_t virt_loc
,
2482 location_t parm_def_loc
,
2483 const line_map_macro
*map
,
2484 unsigned int macro_token_index
)
2486 const cpp_token
**result
;
2487 location_t
*virt_loc_dest
= NULL
;
2488 unsigned token_index
=
2489 (BUFF_FRONT (buffer
) - buffer
->base
) / sizeof (cpp_token
*);
2491 /* Abort if we pass the end the buffer. */
2492 if (BUFF_FRONT (buffer
) > BUFF_LIMIT (buffer
))
2495 if (virt_locs
!= NULL
)
2496 virt_loc_dest
= &virt_locs
[token_index
];
2499 tokens_buff_put_token_to ((const cpp_token
**) BUFF_FRONT (buffer
),
2500 virt_loc_dest
, token
, virt_loc
, parm_def_loc
,
2501 map
, macro_token_index
);
2503 BUFF_FRONT (buffer
) = (unsigned char *) result
;
2507 /* Allocate space for the function-like macro argument ARG to store
2508 the tokens resulting from the macro-expansion of the tokens that
2509 make up ARG itself. That space is allocated in ARG->expanded and
2510 needs to be freed using free. */
2512 alloc_expanded_arg_mem (cpp_reader
*pfile
, macro_arg
*arg
, size_t capacity
)
2514 gcc_checking_assert (arg
->expanded
== NULL
2515 && arg
->expanded_virt_locs
== NULL
);
2517 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
2518 if (CPP_OPTION (pfile
, track_macro_expansion
))
2519 arg
->expanded_virt_locs
= XNEWVEC (location_t
, capacity
);
2523 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2526 ensure_expanded_arg_room (cpp_reader
*pfile
, macro_arg
*arg
,
2527 size_t size
, size_t *expanded_capacity
)
2529 if (size
<= *expanded_capacity
)
2535 XRESIZEVEC (const cpp_token
*, arg
->expanded
, size
);
2536 *expanded_capacity
= size
;
2538 if (CPP_OPTION (pfile
, track_macro_expansion
))
2540 if (arg
->expanded_virt_locs
== NULL
)
2541 arg
->expanded_virt_locs
= XNEWVEC (location_t
, size
);
2543 arg
->expanded_virt_locs
= XRESIZEVEC (location_t
,
2544 arg
->expanded_virt_locs
,
2549 /* Expand an argument ARG before replacing parameters in a
2550 function-like macro. This works by pushing a context with the
2551 argument's tokens, and then expanding that into a temporary buffer
2552 as if it were a normal part of the token stream. collect_args()
2553 has terminated the argument's tokens with a CPP_EOF so that we know
2554 when we have fully expanded the argument. */
2556 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
2559 bool saved_warn_trad
;
2560 bool track_macro_exp_p
= CPP_OPTION (pfile
, track_macro_expansion
);
2563 || arg
->expanded
!= NULL
)
2566 /* Don't warn about funlike macros when pre-expanding. */
2567 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
2568 CPP_WTRADITIONAL (pfile
) = 0;
2570 /* Loop, reading in the tokens of the argument. */
2572 alloc_expanded_arg_mem (pfile
, arg
, capacity
);
2574 if (track_macro_exp_p
)
2575 push_extended_tokens_context (pfile
, NULL
, NULL
,
2580 push_ptoken_context (pfile
, NULL
, NULL
,
2581 arg
->first
, arg
->count
+ 1);
2585 const cpp_token
*token
;
2586 location_t location
;
2588 ensure_expanded_arg_room (pfile
, arg
, arg
->expanded_count
+ 1,
2591 token
= cpp_get_token_1 (pfile
, &location
);
2593 if (token
->type
== CPP_EOF
)
2596 set_arg_token (arg
, token
, location
,
2597 arg
->expanded_count
, MACRO_ARG_TOKEN_EXPANDED
,
2598 CPP_OPTION (pfile
, track_macro_expansion
));
2599 arg
->expanded_count
++;
2602 _cpp_pop_context (pfile
);
2604 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
2607 /* Returns the macro associated to the current context if we are in
2608 the context a macro expansion, NULL otherwise. */
2609 static cpp_hashnode
*
2610 macro_of_context (cpp_context
*context
)
2612 if (context
== NULL
)
2615 return (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2616 ? context
->c
.mc
->macro_node
2620 /* Return TRUE iff we are expanding a macro or are about to start
2621 expanding one. If we are effectively expanding a macro, the
2622 function macro_of_context returns a pointer to the macro being
2625 in_macro_expansion_p (cpp_reader
*pfile
)
2630 return (pfile
->about_to_expand_macro_p
2631 || macro_of_context (pfile
->context
));
2634 /* Pop the current context off the stack, re-enabling the macro if the
2635 context represented a macro's replacement list. Initially the
2636 context structure was not freed so that we can re-use it later, but
2637 now we do free it to reduce peak memory consumption. */
2639 _cpp_pop_context (cpp_reader
*pfile
)
2641 cpp_context
*context
= pfile
->context
;
2643 /* We should not be popping the base context. */
2644 gcc_assert (context
!= &pfile
->base_context
);
2646 if (context
->c
.macro
)
2648 cpp_hashnode
*macro
;
2649 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2651 macro_context
*mc
= context
->c
.mc
;
2652 macro
= mc
->macro_node
;
2653 /* If context->buff is set, it means the life time of tokens
2654 is bound to the life time of this context; so we must
2655 free the tokens; that means we must free the virtual
2656 locations of these tokens too. */
2657 if (context
->buff
&& mc
->virt_locs
)
2659 free (mc
->virt_locs
);
2660 mc
->virt_locs
= NULL
;
2663 context
->c
.mc
= NULL
;
2666 macro
= context
->c
.macro
;
2668 /* Beware that MACRO can be NULL in cases like when we are
2669 called from expand_arg. In those cases, a dummy context with
2670 tokens is pushed just for the purpose of walking them using
2671 cpp_get_token_1. In that case, no 'macro' field is set into
2672 the dummy context. */
2674 /* Several contiguous macro expansion contexts can be
2675 associated to the same macro; that means it's the same
2676 macro expansion that spans across all these (sub)
2677 contexts. So we should re-enable an expansion-disabled
2678 macro only when we are sure we are really out of that
2680 && macro_of_context (context
->prev
) != macro
)
2681 macro
->flags
&= ~NODE_DISABLED
;
2683 if (macro
== pfile
->top_most_macro_node
&& context
->prev
== NULL
)
2684 /* We are popping the context of the top-most macro node. */
2685 pfile
->top_most_macro_node
= NULL
;
2690 /* Decrease memory peak consumption by freeing the memory used
2692 _cpp_free_buff (context
->buff
);
2695 pfile
->context
= context
->prev
;
2696 /* decrease peak memory consumption by feeing the context. */
2697 pfile
->context
->next
= NULL
;
2701 /* Return TRUE if we reached the end of the set of tokens stored in
2702 CONTEXT, FALSE otherwise. */
2704 reached_end_of_context (cpp_context
*context
)
2706 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
2707 return FIRST (context
).token
== LAST (context
).token
;
2708 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
2709 || context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2710 return FIRST (context
).ptoken
== LAST (context
).ptoken
;
2715 /* Consume the next token contained in the current context of PFILE,
2716 and return it in *TOKEN. It's "full location" is returned in
2717 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2718 means the location encoding the locus of the token across macro
2719 expansion; otherwise it's just is the "normal" location of the
2720 token which (*TOKEN)->src_loc. */
2722 consume_next_token_from_context (cpp_reader
*pfile
,
2723 const cpp_token
** token
,
2724 location_t
*location
)
2726 cpp_context
*c
= pfile
->context
;
2728 if ((c
)->tokens_kind
== TOKENS_KIND_DIRECT
)
2730 *token
= FIRST (c
).token
;
2731 *location
= (*token
)->src_loc
;
2734 else if ((c
)->tokens_kind
== TOKENS_KIND_INDIRECT
)
2736 *token
= *FIRST (c
).ptoken
;
2737 *location
= (*token
)->src_loc
;
2740 else if ((c
)->tokens_kind
== TOKENS_KIND_EXTENDED
)
2742 macro_context
*m
= c
->c
.mc
;
2743 *token
= *FIRST (c
).ptoken
;
2746 *location
= *m
->cur_virt_loc
;
2750 *location
= (*token
)->src_loc
;
2757 /* In the traditional mode of the preprocessor, if we are currently in
2758 a directive, the location of a token must be the location of the
2759 start of the directive line. This function returns the proper
2760 location if we are in the traditional mode, and just returns
2761 LOCATION otherwise. */
2763 static inline location_t
2764 maybe_adjust_loc_for_trad_cpp (cpp_reader
*pfile
, location_t location
)
2766 if (CPP_OPTION (pfile
, traditional
))
2768 if (pfile
->state
.in_directive
)
2769 return pfile
->directive_line
;
2774 /* Routine to get a token as well as its location.
2776 Macro expansions and directives are transparently handled,
2777 including entering included files. Thus tokens are post-macro
2778 expansion, and after any intervening directives. External callers
2779 see CPP_EOF only at EOF. Internal callers also see it when meeting
2780 a directive inside a macro call, when at the end of a directive and
2781 state.in_directive is still 1, and at the end of argument
2784 LOC is an out parameter; *LOC is set to the location "as expected
2785 by the user". Please read the comment of
2786 cpp_get_token_with_location to learn more about the meaning of this
2788 static const cpp_token
*
2789 cpp_get_token_1 (cpp_reader
*pfile
, location_t
*location
)
2791 const cpp_token
*result
;
2792 /* This token is a virtual token that either encodes a location
2793 related to macro expansion or a spelling location. */
2794 location_t virt_loc
= 0;
2795 /* pfile->about_to_expand_macro_p can be overriden by indirect calls
2796 to functions that push macro contexts. So let's save it so that
2797 we can restore it when we are about to leave this routine. */
2798 bool saved_about_to_expand_macro
= pfile
->about_to_expand_macro_p
;
2803 cpp_context
*context
= pfile
->context
;
2805 /* Context->prev == 0 <=> base context. */
2808 result
= _cpp_lex_token (pfile
);
2809 virt_loc
= result
->src_loc
;
2811 else if (!reached_end_of_context (context
))
2813 consume_next_token_from_context (pfile
, &result
,
2815 if (result
->flags
& PASTE_LEFT
)
2817 paste_all_tokens (pfile
, result
);
2818 if (pfile
->state
.in_directive
)
2820 result
= padding_token (pfile
, result
);
2826 if (pfile
->context
->c
.macro
)
2827 ++num_expanded_macros_counter
;
2828 _cpp_pop_context (pfile
);
2829 if (pfile
->state
.in_directive
)
2831 result
= &pfile
->avoid_paste
;
2835 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
2838 if (result
->type
!= CPP_NAME
)
2841 node
= result
->val
.node
.node
;
2843 if (node
->type
== NT_VOID
|| (result
->flags
& NO_EXPAND
))
2846 if (!(node
->flags
& NODE_DISABLED
))
2849 /* If not in a macro context, and we're going to start an
2850 expansion, record the location and the top level macro
2851 about to be expanded. */
2852 if (!in_macro_expansion_p (pfile
))
2854 pfile
->invocation_location
= result
->src_loc
;
2855 pfile
->top_most_macro_node
= node
;
2857 if (pfile
->state
.prevent_expansion
)
2860 /* Conditional macros require that a predicate be evaluated
2862 if ((node
->flags
& NODE_CONDITIONAL
) != 0)
2864 if (pfile
->cb
.macro_to_expand
)
2866 bool whitespace_after
;
2867 const cpp_token
*peek_tok
= cpp_peek_token (pfile
, 0);
2869 whitespace_after
= (peek_tok
->type
== CPP_PADDING
2870 || (peek_tok
->flags
& PREV_WHITE
));
2871 node
= pfile
->cb
.macro_to_expand (pfile
, result
);
2873 ret
= enter_macro_context (pfile
, node
, result
, virt_loc
);
2874 else if (whitespace_after
)
2876 /* If macro_to_expand hook returned NULL and it
2877 ate some tokens, see if we don't need to add
2878 a padding token in between this and the
2880 peek_tok
= cpp_peek_token (pfile
, 0);
2881 if (peek_tok
->type
!= CPP_PADDING
2882 && (peek_tok
->flags
& PREV_WHITE
) == 0)
2883 _cpp_push_token_context (pfile
, NULL
,
2884 padding_token (pfile
,
2890 ret
= enter_macro_context (pfile
, node
, result
, virt_loc
);
2893 if (pfile
->state
.in_directive
|| ret
== 2)
2895 result
= padding_token (pfile
, result
);
2901 /* Flag this token as always unexpandable. FIXME: move this
2902 to collect_args()?. */
2903 cpp_token
*t
= _cpp_temp_token (pfile
);
2904 t
->type
= result
->type
;
2905 t
->flags
= result
->flags
| NO_EXPAND
;
2906 t
->val
= result
->val
;
2914 if (location
!= NULL
)
2917 virt_loc
= result
->src_loc
;
2918 *location
= virt_loc
;
2920 if (!CPP_OPTION (pfile
, track_macro_expansion
)
2921 && macro_of_context (pfile
->context
) != NULL
)
2922 /* We are in a macro expansion context, are not tracking
2923 virtual location, but were asked to report the location
2924 of the expansion point of the macro being expanded. */
2925 *location
= pfile
->invocation_location
;
2927 *location
= maybe_adjust_loc_for_trad_cpp (pfile
, *location
);
2930 pfile
->about_to_expand_macro_p
= saved_about_to_expand_macro
;
2934 /* External routine to get a token. Also used nearly everywhere
2935 internally, except for places where we know we can safely call
2936 _cpp_lex_token directly, such as lexing a directive name.
2938 Macro expansions and directives are transparently handled,
2939 including entering included files. Thus tokens are post-macro
2940 expansion, and after any intervening directives. External callers
2941 see CPP_EOF only at EOF. Internal callers also see it when meeting
2942 a directive inside a macro call, when at the end of a directive and
2943 state.in_directive is still 1, and at the end of argument
2946 cpp_get_token (cpp_reader
*pfile
)
2948 return cpp_get_token_1 (pfile
, NULL
);
2951 /* Like cpp_get_token, but also returns a virtual token location
2952 separate from the spelling location carried by the returned token.
2954 LOC is an out parameter; *LOC is set to the location "as expected
2955 by the user". This matters when a token results from macro
2956 expansion; in that case the token's spelling location indicates the
2957 locus of the token in the definition of the macro but *LOC
2958 virtually encodes all the other meaningful locuses associated to
2961 What? virtual location? Yes, virtual location.
2963 If the token results from macro expansion and if macro expansion
2964 location tracking is enabled its virtual location encodes (at the
2967 - the spelling location of the token
2969 - the locus of the macro expansion point
2971 - the locus of the point where the token got instantiated as part
2972 of the macro expansion process.
2974 You have to use the linemap API to get the locus you are interested
2975 in from a given virtual location.
2977 Note however that virtual locations are not necessarily ordered for
2978 relations '<' and '>'. One must use the function
2979 linemap_location_before_p instead of using the relational operator
2982 If macro expansion tracking is off and if the token results from
2983 macro expansion the virtual location is the expansion point of the
2984 macro that got expanded.
2986 When the token doesn't result from macro expansion, the virtual
2987 location is just the same thing as its spelling location. */
2990 cpp_get_token_with_location (cpp_reader
*pfile
, location_t
*loc
)
2992 return cpp_get_token_1 (pfile
, loc
);
2995 /* Returns true if we're expanding an object-like macro that was
2996 defined in a system header. Just checks the macro at the top of
2997 the stack. Used for diagnostic suppression. */
2999 cpp_sys_macro_p (cpp_reader
*pfile
)
3001 cpp_hashnode
*node
= NULL
;
3003 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
3004 node
= pfile
->context
->c
.mc
->macro_node
;
3006 node
= pfile
->context
->c
.macro
;
3008 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
3011 /* Read each token in, until end of the current file. Directives are
3012 transparently processed. */
3014 cpp_scan_nooutput (cpp_reader
*pfile
)
3016 /* Request a CPP_EOF token at the end of this file, rather than
3017 transparently continuing with the including file. */
3018 pfile
->buffer
->return_at_eof
= true;
3020 pfile
->state
.discarding_output
++;
3021 pfile
->state
.prevent_expansion
++;
3023 if (CPP_OPTION (pfile
, traditional
))
3024 while (_cpp_read_logical_line_trad (pfile
))
3027 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
3030 pfile
->state
.discarding_output
--;
3031 pfile
->state
.prevent_expansion
--;
3034 /* Step back one or more tokens obtained from the lexer. */
3036 _cpp_backup_tokens_direct (cpp_reader
*pfile
, unsigned int count
)
3038 pfile
->lookaheads
+= count
;
3042 if (pfile
->cur_token
== pfile
->cur_run
->base
3043 /* Possible with -fpreprocessed and no leading #line. */
3044 && pfile
->cur_run
->prev
!= NULL
)
3046 pfile
->cur_run
= pfile
->cur_run
->prev
;
3047 pfile
->cur_token
= pfile
->cur_run
->limit
;
3052 /* Step back one (or more) tokens. Can only step back more than 1 if
3053 they are from the lexer, and not from macro expansion. */
3055 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
3057 if (pfile
->context
->prev
== NULL
)
3058 _cpp_backup_tokens_direct (pfile
, count
);
3063 if (pfile
->context
->tokens_kind
== TOKENS_KIND_DIRECT
)
3064 FIRST (pfile
->context
).token
--;
3065 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
3066 FIRST (pfile
->context
).ptoken
--;
3067 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
3069 FIRST (pfile
->context
).ptoken
--;
3070 if (pfile
->context
->c
.macro
)
3072 macro_context
*m
= pfile
->context
->c
.mc
;
3074 gcc_checking_assert (m
->cur_virt_loc
>= m
->virt_locs
);
3084 /* #define directive parsing and handling. */
3086 /* Returns true if a macro redefinition warning is required. */
3088 warn_of_redefinition (cpp_reader
*pfile
, cpp_hashnode
*node
,
3089 const cpp_macro
*macro2
)
3091 /* Some redefinitions need to be warned about regardless. */
3092 if (node
->flags
& NODE_WARN
)
3095 /* Suppress warnings for builtins that lack the NODE_WARN flag,
3096 unless Wbuiltin-macro-redefined. */
3097 if (cpp_builtin_macro_p (node
))
3098 return CPP_OPTION (pfile
, warn_builtin_macro_redefined
);
3100 /* Redefinitions of conditional (context-sensitive) macros, on
3101 the other hand, must be allowed silently. */
3102 if (node
->flags
& NODE_CONDITIONAL
)
3105 cpp_macro
*macro1
= node
->value
.macro
;
3108 /* We don't want to mark MACRO as used, but do need to finalize
3110 pfile
->cb
.user_lazy_macro (pfile
, macro1
, macro1
->lazy
- 1);
3114 /* Redefinition of a macro is allowed if and only if the old and new
3115 definitions are the same. (6.10.3 paragraph 2). */
3117 /* Don't check count here as it can be different in valid
3118 traditional redefinitions with just whitespace differences. */
3119 if (macro1
->paramc
!= macro2
->paramc
3120 || macro1
->fun_like
!= macro2
->fun_like
3121 || macro1
->variadic
!= macro2
->variadic
)
3124 /* Check parameter spellings. */
3125 for (unsigned i
= macro1
->paramc
; i
--; )
3126 if (macro1
->parm
.params
[i
] != macro2
->parm
.params
[i
])
3129 /* Check the replacement text or tokens. */
3130 if (macro1
->kind
== cmk_traditional
)
3131 return _cpp_expansions_different_trad (macro1
, macro2
);
3133 if (macro1
->count
!= macro2
->count
)
3136 for (unsigned i
= macro1
->count
; i
--; )
3137 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
3143 /* Free the definition of hashnode H. */
3145 _cpp_free_definition (cpp_hashnode
*h
)
3147 /* Macros and assertions no longer have anything to free. */
3149 h
->value
.answers
= NULL
;
3150 h
->flags
&= ~(NODE_DISABLED
| NODE_USED
);
3153 /* Save parameter NODE (spelling SPELLING) to the parameter list of
3154 macro MACRO. Returns true on success, false on failure. */
3156 _cpp_save_parameter (cpp_reader
*pfile
, unsigned n
, cpp_hashnode
*node
,
3157 cpp_hashnode
*spelling
)
3159 /* Constraint 6.10.3.6 - duplicate parameter names. */
3160 if (node
->type
== NT_MACRO_ARG
)
3162 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
3167 unsigned len
= (n
+ 1) * sizeof (struct macro_arg_saved_data
);
3168 if (len
> pfile
->macro_buffer_len
)
3171 = XRESIZEVEC (unsigned char, pfile
->macro_buffer
, len
);
3172 pfile
->macro_buffer_len
= len
;
3175 macro_arg_saved_data
*saved
= (macro_arg_saved_data
*)pfile
->macro_buffer
;
3176 saved
[n
].canonical_node
= node
;
3177 saved
[n
].value
= node
->value
;
3178 saved
[n
].type
= node
->type
;
3180 void *base
= _cpp_reserve_room (pfile
, n
* sizeof (cpp_hashnode
*),
3181 sizeof (cpp_hashnode
*));
3182 ((cpp_hashnode
**)base
)[n
] = spelling
;
3184 /* Morph into a macro arg. */
3185 node
->type
= NT_MACRO_ARG
;
3186 /* Index is 1 based. */
3187 node
->value
.arg_index
= n
+ 1;
3192 /* Restore the parameters to their previous state. */
3194 _cpp_unsave_parameters (cpp_reader
*pfile
, unsigned n
)
3196 /* Clear the fast argument lookup indices. */
3199 struct macro_arg_saved_data
*save
=
3200 &((struct macro_arg_saved_data
*) pfile
->macro_buffer
)[n
];
3202 struct cpp_hashnode
*node
= save
->canonical_node
;
3203 node
->type
= save
->type
;
3204 node
->value
= save
->value
;
3208 /* Check the syntax of the parameters in a MACRO definition. Return
3209 false on failure. Set *N_PTR and *VARADIC_PTR as appropriate.
3211 '(' parm-list ',' last-parm ')'
3221 parse_params (cpp_reader
*pfile
, unsigned *n_ptr
, bool *varadic_ptr
)
3223 unsigned nparms
= 0;
3226 for (bool prev_ident
= false;;)
3228 const cpp_token
*token
= _cpp_lex_token (pfile
);
3230 switch (token
->type
)
3233 /* Allow/ignore comments in parameter lists if we are
3234 preserving comments in macro expansions. */
3235 if (!CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
3242 const char *const msgs
[5] =
3244 N_("expected parameter name, found \"%s\""),
3245 N_("expected ',' or ')', found \"%s\""),
3246 N_("expected parameter name before end of line"),
3247 N_("expected ')' before end of line"),
3248 N_("expected ')' after \"...\"")
3250 unsigned ix
= prev_ident
;
3251 const unsigned char *as_text
= NULL
;
3254 else if (token
->type
== CPP_EOF
)
3257 as_text
= cpp_token_as_text (pfile
, token
);
3258 cpp_error (pfile
, CPP_DL_ERROR
, msgs
[ix
], as_text
);
3263 if (prev_ident
|| *varadic_ptr
)
3267 if (!_cpp_save_parameter (pfile
, nparms
, token
->val
.node
.node
,
3268 token
->val
.node
.spelling
))
3273 case CPP_CLOSE_PAREN
:
3274 if (prev_ident
|| !nparms
|| *varadic_ptr
)
3282 if (!prev_ident
|| *varadic_ptr
)
3290 *varadic_ptr
= true;
3293 /* An ISO bare ellipsis. */
3294 _cpp_save_parameter (pfile
, nparms
,
3295 pfile
->spec_nodes
.n__VA_ARGS__
,
3296 pfile
->spec_nodes
.n__VA_ARGS__
);
3298 pfile
->state
.va_args_ok
= 1;
3299 if (! CPP_OPTION (pfile
, c99
)
3300 && CPP_OPTION (pfile
, cpp_pedantic
)
3301 && CPP_OPTION (pfile
, warn_variadic_macros
))
3303 (pfile
, CPP_W_VARIADIC_MACROS
,
3304 CPP_OPTION (pfile
, cplusplus
)
3305 ? N_("anonymous variadic macros were introduced in C++11")
3306 : N_("anonymous variadic macros were introduced in C99"));
3307 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
3308 && ! CPP_OPTION (pfile
, cplusplus
))
3309 cpp_error (pfile
, CPP_DL_WARNING
,
3310 "anonymous variadic macros were introduced in C99");
3312 else if (CPP_OPTION (pfile
, cpp_pedantic
)
3313 && CPP_OPTION (pfile
, warn_variadic_macros
))
3314 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
3315 CPP_OPTION (pfile
, cplusplus
)
3316 ? N_("ISO C++ does not permit named variadic macros")
3317 : N_("ISO C does not permit named variadic macros"));
3328 /* Lex a token from the expansion of MACRO, but mark parameters as we
3329 find them and warn of traditional stringification. */
3331 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
3333 macro
= (cpp_macro
*)_cpp_reserve_room (pfile
,
3334 sizeof (cpp_macro
) - sizeof (cpp_token
)
3335 + macro
->count
* sizeof (cpp_token
),
3336 sizeof (cpp_token
));
3337 cpp_token
*saved_cur_token
= pfile
->cur_token
;
3338 pfile
->cur_token
= ¯o
->exp
.tokens
[macro
->count
];
3339 cpp_token
*token
= _cpp_lex_direct (pfile
);
3340 pfile
->cur_token
= saved_cur_token
;
3342 /* Is this a parameter? */
3343 if (token
->type
== CPP_NAME
&& token
->val
.node
.node
->type
== NT_MACRO_ARG
)
3345 /* Morph into a parameter reference. */
3346 cpp_hashnode
*spelling
= token
->val
.node
.spelling
;
3347 token
->type
= CPP_MACRO_ARG
;
3348 token
->val
.macro_arg
.arg_no
= token
->val
.node
.node
->value
.arg_index
;
3349 token
->val
.macro_arg
.spelling
= spelling
;
3351 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
3352 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
3353 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
3359 create_iso_definition (cpp_reader
*pfile
)
3361 bool following_paste_op
= false;
3362 const char *paste_op_error_msg
=
3363 N_("'##' cannot appear at either end of a macro expansion");
3364 unsigned int num_extra_tokens
= 0;
3365 unsigned nparms
= 0;
3366 cpp_hashnode
**params
= NULL
;
3367 bool varadic
= false;
3369 cpp_macro
*macro
= NULL
;
3371 /* Look at the first token, to see if this is a function-like
3374 cpp_token
*saved_cur_token
= pfile
->cur_token
;
3375 pfile
->cur_token
= &first
;
3376 cpp_token
*token
= _cpp_lex_direct (pfile
);
3377 pfile
->cur_token
= saved_cur_token
;
3379 if (token
->flags
& PREV_WHITE
)
3380 /* Preceeded by space, must be part of expansion. */;
3381 else if (token
->type
== CPP_OPEN_PAREN
)
3383 /* An open-paren, get a parameter list. */
3384 if (!parse_params (pfile
, &nparms
, &varadic
))
3387 params
= (cpp_hashnode
**)_cpp_commit_buff
3388 (pfile
, sizeof (cpp_hashnode
*) * nparms
);
3391 else if (token
->type
!= CPP_EOF
3392 && !(token
->type
== CPP_COMMENT
3393 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
)))
3395 /* While ISO C99 requires whitespace before replacement text
3396 in a macro definition, ISO C90 with TC1 allows characters
3397 from the basic source character set there. */
3398 if (CPP_OPTION (pfile
, c99
))
3399 cpp_error (pfile
, CPP_DL_PEDWARN
,
3400 CPP_OPTION (pfile
, cplusplus
)
3401 ? N_("ISO C++11 requires whitespace after the macro name")
3402 : N_("ISO C99 requires whitespace after the macro name"));
3405 enum cpp_diagnostic_level warntype
= CPP_DL_WARNING
;
3406 switch (token
->type
)
3410 case CPP_OBJC_STRING
:
3411 /* '@' is not in basic character set. */
3412 warntype
= CPP_DL_PEDWARN
;
3415 /* Basic character set sans letters, digits and _. */
3416 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
3417 token
->val
.str
.text
[0]) == NULL
)
3418 warntype
= CPP_DL_PEDWARN
;
3421 /* All other tokens start with a character from basic
3425 cpp_error (pfile
, warntype
,
3426 "missing whitespace after the macro name");
3430 macro
= _cpp_new_macro (pfile
, cmk_macro
,
3431 _cpp_reserve_room (pfile
, 0, sizeof (cpp_macro
)));
3435 macro
->variadic
= varadic
;
3436 macro
->paramc
= nparms
;
3437 macro
->parm
.params
= params
;
3438 macro
->fun_like
= true;
3442 /* Preserve the token we peeked, there is already a single slot for it. */
3443 macro
->exp
.tokens
[0] = *token
;
3444 token
= ¯o
->exp
.tokens
[0];
3448 for (vaopt_state
vaopt_tracker (pfile
, macro
->variadic
, NULL
);; token
= NULL
)
3452 macro
= lex_expansion_token (pfile
, macro
);
3453 token
= ¯o
->exp
.tokens
[macro
->count
++];
3456 /* Check the stringifying # constraint 6.10.3.2.1 of
3457 function-like macros when lexing the subsequent token. */
3458 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
3460 if (token
->type
== CPP_MACRO_ARG
)
3462 if (token
->flags
& PREV_WHITE
)
3463 token
->flags
|= SP_PREV_WHITE
;
3464 if (token
[-1].flags
& DIGRAPH
)
3465 token
->flags
|= SP_DIGRAPH
;
3466 token
->flags
&= ~PREV_WHITE
;
3467 token
->flags
|= STRINGIFY_ARG
;
3468 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
3469 token
[-1] = token
[0];
3472 /* Let assembler get away with murder. */
3473 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
3475 cpp_error (pfile
, CPP_DL_ERROR
,
3476 "'#' is not followed by a macro parameter");
3481 if (token
->type
== CPP_EOF
)
3483 /* Paste operator constraint 6.10.3.3.1:
3484 Token-paste ##, can appear in both object-like and
3485 function-like macros, but not at the end. */
3486 if (following_paste_op
)
3488 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3491 if (!vaopt_tracker
.completed ())
3496 /* Paste operator constraint 6.10.3.3.1. */
3497 if (token
->type
== CPP_PASTE
)
3499 /* Token-paste ##, can appear in both object-like and
3500 function-like macros, but not at the beginning. */
3501 if (macro
->count
== 1)
3503 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3507 if (following_paste_op
)
3509 /* Consecutive paste operators. This one will be moved
3512 token
->val
.token_no
= macro
->count
- 1;
3516 /* Drop the paste operator. */
3518 token
[-1].flags
|= PASTE_LEFT
;
3519 if (token
->flags
& DIGRAPH
)
3520 token
[-1].flags
|= SP_DIGRAPH
;
3521 if (token
->flags
& PREV_WHITE
)
3522 token
[-1].flags
|= SP_PREV_WHITE
;
3524 following_paste_op
= true;
3527 following_paste_op
= false;
3529 if (vaopt_tracker
.update (token
) == vaopt_state::ERROR
)
3533 /* We're committed to winning now. */
3536 /* Don't count the CPP_EOF. */
3539 macro
= (cpp_macro
*)_cpp_commit_buff
3540 (pfile
, sizeof (cpp_macro
) - sizeof (cpp_token
)
3541 + sizeof (cpp_token
) * macro
->count
);
3543 /* Clear whitespace on first token. */
3545 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
3547 if (num_extra_tokens
)
3549 /* Place second and subsequent ## or %:%: tokens in sequences of
3550 consecutive such tokens at the end of the list to preserve
3551 information about where they appear, how they are spelt and
3552 whether they are preceded by whitespace without otherwise
3553 interfering with macro expansion. Remember, this is
3554 extremely rare, so efficiency is not a priority. */
3555 cpp_token
*temp
= (cpp_token
*)_cpp_reserve_room
3556 (pfile
, 0, num_extra_tokens
* sizeof (cpp_token
));
3557 unsigned extra_ix
= 0, norm_ix
= 0;
3558 cpp_token
*exp
= macro
->exp
.tokens
;
3559 for (unsigned ix
= 0; ix
!= macro
->count
; ix
++)
3560 if (exp
[ix
].type
== CPP_PASTE
)
3561 temp
[extra_ix
++] = exp
[ix
];
3563 exp
[norm_ix
++] = exp
[ix
];
3564 memcpy (&exp
[norm_ix
], temp
, num_extra_tokens
* sizeof (cpp_token
));
3566 /* Record there are extra tokens. */
3567 macro
->extra_tokens
= 1;
3571 pfile
->state
.va_args_ok
= 0;
3572 _cpp_unsave_parameters (pfile
, nparms
);
3574 return ok
? macro
: NULL
;
3578 _cpp_new_macro (cpp_reader
*pfile
, cpp_macro_kind kind
, void *placement
)
3580 cpp_macro
*macro
= (cpp_macro
*) placement
;
3582 macro
->line
= pfile
->directive_line
;
3583 macro
->parm
.params
= 0;
3586 macro
->variadic
= 0;
3587 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
3589 macro
->fun_like
= 0;
3590 macro
->extra_tokens
= 0;
3591 /* To suppress some diagnostics. */
3592 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
3599 /* Parse a macro and save its expansion. Returns nonzero on success. */
3601 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3605 if (CPP_OPTION (pfile
, traditional
))
3606 macro
= _cpp_create_trad_definition (pfile
);
3608 macro
= create_iso_definition (pfile
);
3613 if (cpp_macro_p (node
))
3615 if (CPP_OPTION (pfile
, warn_unused_macros
))
3616 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
3618 if (warn_of_redefinition (pfile
, node
, macro
))
3620 const enum cpp_warning_reason reason
3621 = (cpp_builtin_macro_p (node
) && !(node
->flags
& NODE_WARN
))
3622 ? CPP_W_BUILTIN_MACRO_REDEFINED
: CPP_W_NONE
;
3625 cpp_pedwarning_with_line (pfile
, reason
,
3626 pfile
->directive_line
, 0,
3627 "\"%s\" redefined", NODE_NAME (node
));
3629 if (warned
&& cpp_user_macro_p (node
))
3630 cpp_error_with_line (pfile
, CPP_DL_NOTE
,
3631 node
->value
.macro
->line
, 0,
3632 "this is the location of the previous definition");
3634 _cpp_free_definition (node
);
3637 /* Enter definition in hash table. */
3638 node
->type
= NT_USER_MACRO
;
3639 node
->value
.macro
= macro
;
3640 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
3641 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
3642 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3643 in the C standard, as something that one must use in C++.
3644 However DR#593 and C++11 indicate that they play no role in C++.
3645 We special-case them anyway. */
3646 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
3647 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
3648 node
->flags
|= NODE_WARN
;
3650 /* If user defines one of the conditional macros, remove the
3652 node
->flags
&= ~NODE_CONDITIONAL
;
3658 cpp_define_lazily (cpp_reader
*pfile
, cpp_hashnode
*node
, unsigned num
)
3660 cpp_macro
*macro
= node
->value
.macro
;
3662 gcc_checking_assert (pfile
->cb
.user_lazy_macro
&& macro
&& num
< UCHAR_MAX
);
3664 macro
->lazy
= num
+ 1;
3667 /* Notify the use of NODE in a macro-aware context (i.e. expanding it,
3668 or testing its existance). Also applies any lazy definition. */
3671 _cpp_notify_macro_use (cpp_reader
*pfile
, cpp_hashnode
*node
)
3673 node
->flags
|= NODE_USED
;
3678 cpp_macro
*macro
= node
->value
.macro
;
3681 pfile
->cb
.user_lazy_macro (pfile
, macro
, macro
->lazy
- 1);
3687 case NT_BUILTIN_MACRO
:
3688 if (pfile
->cb
.used_define
)
3689 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
3693 if (pfile
->cb
.used_undef
)
3694 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
3702 /* Warn if a token in STRING matches one of a function-like MACRO's
3705 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
3706 const cpp_string
*string
)
3708 unsigned int i
, len
;
3709 const uchar
*p
, *q
, *limit
;
3711 /* Loop over the string. */
3712 limit
= string
->text
+ string
->len
- 1;
3713 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
3715 /* Find the start of an identifier. */
3716 while (p
< limit
&& !is_idstart (*p
))
3719 /* Find the end of the identifier. */
3721 while (q
< limit
&& is_idchar (*q
))
3726 /* Loop over the function macro arguments to see if the
3727 identifier inside the string matches one of them. */
3728 for (i
= 0; i
< macro
->paramc
; i
++)
3730 const cpp_hashnode
*node
= macro
->parm
.params
[i
];
3732 if (NODE_LEN (node
) == len
3733 && !memcmp (p
, NODE_NAME (node
), len
))
3735 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
3736 "macro argument \"%s\" would be stringified in traditional C",
3744 /* Returns the name, arguments and expansion of a macro, in a format
3745 suitable to be read back in again, and therefore also for DWARF 2
3746 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3747 Caller is expected to generate the "#define" bit if needed. The
3748 returned text is temporary, and automatically freed later. */
3749 const unsigned char *
3750 cpp_macro_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3752 unsigned int i
, len
;
3753 unsigned char *buffer
;
3755 gcc_checking_assert (cpp_user_macro_p (node
));
3757 const cpp_macro
*macro
= node
->value
.macro
;
3759 /* Calculate length. */
3760 len
= NODE_LEN (node
) * 10 + 2; /* ' ' and NUL. */
3761 if (macro
->fun_like
)
3763 len
+= 4; /* "()" plus possible final ".." of named
3764 varargs (we have + 1 below). */
3765 for (i
= 0; i
< macro
->paramc
; i
++)
3766 len
+= NODE_LEN (macro
->parm
.params
[i
]) + 1; /* "," */
3769 /* This should match below where we fill in the buffer. */
3770 if (CPP_OPTION (pfile
, traditional
))
3771 len
+= _cpp_replacement_text_len (macro
);
3774 unsigned int count
= macro_real_token_count (macro
);
3775 for (i
= 0; i
< count
; i
++)
3777 const cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3779 if (token
->type
== CPP_MACRO_ARG
)
3780 len
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3782 len
+= cpp_token_len (token
);
3784 if (token
->flags
& STRINGIFY_ARG
)
3786 if (token
->flags
& PASTE_LEFT
)
3787 len
+= 3; /* " ##" */
3788 if (token
->flags
& PREV_WHITE
)
3793 if (len
> pfile
->macro_buffer_len
)
3795 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
3796 pfile
->macro_buffer
, len
);
3797 pfile
->macro_buffer_len
= len
;
3800 /* Fill in the buffer. Start with the macro name. */
3801 buffer
= pfile
->macro_buffer
;
3802 buffer
= _cpp_spell_ident_ucns (buffer
, node
);
3804 /* Parameter names. */
3805 if (macro
->fun_like
)
3808 for (i
= 0; i
< macro
->paramc
; i
++)
3810 cpp_hashnode
*param
= macro
->parm
.params
[i
];
3812 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
3814 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
3815 buffer
+= NODE_LEN (param
);
3818 if (i
+ 1 < macro
->paramc
)
3819 /* Don't emit a space after the comma here; we're trying
3820 to emit a Dwarf-friendly definition, and the Dwarf spec
3821 forbids spaces in the argument list. */
3823 else if (macro
->variadic
)
3824 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
3829 /* The Dwarf spec requires a space after the macro name, even if the
3830 definition is the empty string. */
3833 if (CPP_OPTION (pfile
, traditional
))
3834 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
3835 else if (macro
->count
)
3836 /* Expansion tokens. */
3838 unsigned int count
= macro_real_token_count (macro
);
3839 for (i
= 0; i
< count
; i
++)
3841 const cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3843 if (token
->flags
& PREV_WHITE
)
3845 if (token
->flags
& STRINGIFY_ARG
)
3848 if (token
->type
== CPP_MACRO_ARG
)
3851 NODE_NAME (token
->val
.macro_arg
.spelling
),
3852 NODE_LEN (token
->val
.macro_arg
.spelling
));
3853 buffer
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3856 buffer
= cpp_spell_token (pfile
, token
, buffer
, true);
3858 if (token
->flags
& PASTE_LEFT
)
3863 /* Next has PREV_WHITE; see _cpp_create_definition. */
3869 return pfile
->macro_buffer
;