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 set_arg_token (arg
, &pfile
->eof
, pfile
->eof
.src_loc
,
1245 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1246 CPP_OPTION (pfile
, track_macro_expansion
));
1248 /* Terminate the argument. Excess arguments loop back and
1249 overwrite the final legitimate argument, before failing. */
1250 if (argc
<= macro
->paramc
)
1252 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
1253 if (argc
!= macro
->paramc
)
1257 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
1259 if (token
->type
== CPP_EOF
)
1261 /* We still need the CPP_EOF to end directives, to end
1262 pre-expansion of a macro argument, and at the end of the main
1263 file. We do not want it at the end of a -include'd (forced)
1265 if (pfile
->state
.in_directive
1266 || !pfile
->line_table
->depth
1267 || pfile
->context
->prev
)
1268 _cpp_backup_tokens (pfile
, 1);
1269 cpp_error (pfile
, CPP_DL_ERROR
,
1270 "unterminated argument list invoking macro \"%s\"",
1275 /* A single empty argument is counted as no argument. */
1276 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
1278 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
1280 /* GCC has special semantics for , ## b where b is a varargs
1281 parameter: we remove the comma if b was omitted entirely.
1282 If b was merely an empty argument, the comma is retained.
1283 If the macro takes just one (varargs) parameter, then we
1284 retain the comma only if we are standards conforming.
1286 If FIRST is NULL replace_args () swallows the comma. */
1287 if (macro
->variadic
&& (argc
< macro
->paramc
1288 || (argc
== 1 && args
[0].count
== 0
1289 && !CPP_OPTION (pfile
, std
))))
1290 args
[macro
->paramc
- 1].first
= NULL
;
1292 *num_args
= num_args_alloced
;
1297 /* An error occurred. */
1298 _cpp_release_buff (pfile
, base_buff
);
1302 /* Search for an opening parenthesis to the macro of NODE, in such a
1303 way that, if none is found, we don't lose the information in any
1304 intervening padding tokens. If we find the parenthesis, collect
1305 the arguments and return the buffer containing them. PRAGMA_BUFF
1306 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
1307 *NUM_ARGS is set to the number of arguments contained in the
1310 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
1311 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1313 const cpp_token
*token
, *padding
= NULL
;
1317 token
= cpp_get_token (pfile
);
1318 if (token
->type
!= CPP_PADDING
)
1321 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
1325 if (token
->type
== CPP_OPEN_PAREN
)
1327 pfile
->state
.parsing_args
= 2;
1328 return collect_args (pfile
, node
, pragma_buff
, num_args
);
1331 /* CPP_EOF can be the end of macro arguments, or the end of the
1332 file. We mustn't back up over the latter. Ugh. */
1333 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
1335 /* Back up. We may have skipped padding, in which case backing
1336 up more than one token when expanding macros is in general
1337 too difficult. We re-insert it in its own context. */
1338 _cpp_backup_tokens (pfile
, 1);
1340 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
1346 /* Return the real number of tokens in the expansion of MACRO. */
1347 static inline unsigned int
1348 macro_real_token_count (const cpp_macro
*macro
)
1350 if (__builtin_expect (!macro
->extra_tokens
, true))
1351 return macro
->count
;
1353 for (unsigned i
= macro
->count
; i
--;)
1354 if (macro
->exp
.tokens
[i
].type
!= CPP_PASTE
)
1360 /* Push the context of a macro with hash entry NODE onto the context
1361 stack. If we can successfully expand the macro, we push a context
1362 containing its yet-to-be-rescanned replacement list and return one.
1363 If there were additionally any unexpanded deferred #pragma
1364 directives among macro arguments, push another context containing
1365 the pragma tokens before the yet-to-be-rescanned replacement list
1366 and return two. Otherwise, we don't push a context and return
1367 zero. LOCATION is the location of the expansion point of the
1370 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
1371 const cpp_token
*result
, location_t location
)
1373 /* The presence of a macro invalidates a file's controlling macro. */
1374 pfile
->mi_valid
= false;
1376 pfile
->state
.angled_headers
= false;
1378 /* From here to when we push the context for the macro later down
1379 this function, we need to flag the fact that we are about to
1380 expand a macro. This is useful when -ftrack-macro-expansion is
1381 turned off. In that case, we need to record the location of the
1382 expansion point of the top-most macro we are about to to expand,
1383 into pfile->invocation_location. But we must not record any such
1384 location once the process of expanding the macro starts; that is,
1385 we must not do that recording between now and later down this
1386 function where set this flag to FALSE. */
1387 pfile
->about_to_expand_macro_p
= true;
1389 if (cpp_user_macro_p (node
))
1391 cpp_macro
*macro
= node
->value
.macro
;
1392 _cpp_buff
*pragma_buff
= NULL
;
1394 if (macro
->fun_like
)
1397 unsigned num_args
= 0;
1399 pfile
->state
.prevent_expansion
++;
1400 pfile
->keep_tokens
++;
1401 pfile
->state
.parsing_args
= 1;
1402 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
,
1404 pfile
->state
.parsing_args
= 0;
1405 pfile
->keep_tokens
--;
1406 pfile
->state
.prevent_expansion
--;
1410 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
1411 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1412 "function-like macro \"%s\" must be used with arguments in traditional C",
1416 _cpp_release_buff (pfile
, pragma_buff
);
1418 pfile
->about_to_expand_macro_p
= false;
1422 if (macro
->paramc
> 0)
1423 replace_args (pfile
, node
, macro
,
1424 (macro_arg
*) buff
->base
,
1426 /* Free the memory used by the arguments of this
1427 function-like macro. This memory has been allocated by
1428 funlike_invocation_p and by replace_args. */
1429 delete_macro_args (buff
, num_args
);
1432 /* Disable the macro within its expansion. */
1433 node
->flags
|= NODE_DISABLED
;
1435 /* Laziness can only affect the expansion tokens of the macro,
1436 not its fun-likeness or parameters. */
1437 _cpp_maybe_notify_macro_use (pfile
, node
);
1439 pfile
->cb
.used (pfile
, location
, node
);
1443 if (macro
->paramc
== 0)
1445 unsigned tokens_count
= macro_real_token_count (macro
);
1446 if (CPP_OPTION (pfile
, track_macro_expansion
))
1449 const cpp_token
*src
= macro
->exp
.tokens
;
1450 const line_map_macro
*map
;
1451 location_t
*virt_locs
= NULL
;
1452 _cpp_buff
*macro_tokens
1453 = tokens_buff_new (pfile
, tokens_count
, &virt_locs
);
1455 /* Create a macro map to record the locations of the
1456 tokens that are involved in the expansion. LOCATION
1457 is the location of the macro expansion point. */
1458 map
= linemap_enter_macro (pfile
->line_table
,
1459 node
, location
, tokens_count
);
1460 for (i
= 0; i
< tokens_count
; ++i
)
1462 tokens_buff_add_token (macro_tokens
, virt_locs
,
1464 src
->src_loc
, map
, i
);
1467 push_extended_tokens_context (pfile
, node
,
1470 (const cpp_token
**)
1475 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
,
1477 num_macro_tokens_counter
+= tokens_count
;
1482 if (!pfile
->state
.in_directive
)
1483 _cpp_push_token_context (pfile
, NULL
,
1484 padding_token (pfile
, result
), 1);
1487 unsigned tokens_count
;
1488 _cpp_buff
*tail
= pragma_buff
->next
;
1489 pragma_buff
->next
= NULL
;
1490 tokens_count
= ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
1491 - (const cpp_token
**) pragma_buff
->base
);
1492 push_ptoken_context (pfile
, NULL
, pragma_buff
,
1493 (const cpp_token
**) pragma_buff
->base
,
1496 if (!CPP_OPTION (pfile
, track_macro_expansion
))
1497 num_macro_tokens_counter
+= tokens_count
;
1500 while (pragma_buff
!= NULL
);
1501 pfile
->about_to_expand_macro_p
= false;
1505 pfile
->about_to_expand_macro_p
= false;
1509 pfile
->about_to_expand_macro_p
= false;
1510 /* Handle built-in macros and the _Pragma operator. */
1512 location_t expand_loc
;
1514 if (/* The top-level macro invocation that triggered the expansion
1515 we are looking at is with a function-like user macro ... */
1516 cpp_fun_like_macro_p (pfile
->top_most_macro_node
)
1517 /* ... and we are tracking the macro expansion. */
1518 && CPP_OPTION (pfile
, track_macro_expansion
))
1519 /* Then the location of the end of the macro invocation is the
1520 location of the expansion point of this macro. */
1521 expand_loc
= location
;
1523 /* Otherwise, the location of the end of the macro invocation is
1524 the location of the expansion point of that top-level macro
1526 expand_loc
= pfile
->invocation_location
;
1528 return builtin_macro (pfile
, node
, location
, expand_loc
);
1532 /* De-allocate the memory used by BUFF which is an array of instances
1533 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1536 delete_macro_args (_cpp_buff
*buff
, unsigned num_args
)
1538 macro_arg
*macro_args
;
1544 macro_args
= (macro_arg
*) buff
->base
;
1546 /* Walk instances of macro_arg to free their expanded tokens as well
1547 as their macro_arg::virt_locs members. */
1548 for (i
= 0; i
< num_args
; ++i
)
1550 if (macro_args
[i
].expanded
)
1552 free (macro_args
[i
].expanded
);
1553 macro_args
[i
].expanded
= NULL
;
1555 if (macro_args
[i
].virt_locs
)
1557 free (macro_args
[i
].virt_locs
);
1558 macro_args
[i
].virt_locs
= NULL
;
1560 if (macro_args
[i
].expanded_virt_locs
)
1562 free (macro_args
[i
].expanded_virt_locs
);
1563 macro_args
[i
].expanded_virt_locs
= NULL
;
1566 _cpp_free_buff (buff
);
1569 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1570 to set, LOCATION is its virtual location. "Virtual" location means
1571 the location that encodes loci across macro expansion. Otherwise
1572 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1573 argument ARG is supposed to contain. Note that ARG must be
1574 tailored so that it has enough room to contain INDEX + 1 numbers of
1575 tokens, at least. */
1577 set_arg_token (macro_arg
*arg
, const cpp_token
*token
,
1578 location_t location
, size_t index
,
1579 enum macro_arg_token_kind kind
,
1580 bool track_macro_exp_p
)
1582 const cpp_token
**token_ptr
;
1583 location_t
*loc
= NULL
;
1586 arg_token_ptr_at (arg
, index
, kind
,
1587 track_macro_exp_p
? &loc
: NULL
);
1592 /* We can't set the location of a stringified argument
1593 token and we can't set any location if we aren't tracking
1594 macro expansion locations. */
1595 gcc_checking_assert (kind
!= MACRO_ARG_TOKEN_STRINGIFIED
1596 && track_macro_exp_p
);
1601 /* Get the pointer to the location of the argument token of the
1602 function-like macro argument ARG. This function must be called
1603 only when we -ftrack-macro-expansion is on. */
1604 static const location_t
*
1605 get_arg_token_location (const macro_arg
*arg
,
1606 enum macro_arg_token_kind kind
)
1608 const location_t
*loc
= NULL
;
1609 const cpp_token
**token_ptr
=
1610 arg_token_ptr_at (arg
, 0, kind
, (location_t
**) &loc
);
1612 if (token_ptr
== NULL
)
1618 /* Return the pointer to the INDEXth token of the macro argument ARG.
1619 KIND specifies the kind of token the macro argument ARG contains.
1620 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1621 of the virtual location of the returned token if the
1622 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1623 spelling location of the returned token. */
1624 static const cpp_token
**
1625 arg_token_ptr_at (const macro_arg
*arg
, size_t index
,
1626 enum macro_arg_token_kind kind
,
1627 location_t
**virt_location
)
1629 const cpp_token
**tokens_ptr
= NULL
;
1633 case MACRO_ARG_TOKEN_NORMAL
:
1634 tokens_ptr
= arg
->first
;
1636 case MACRO_ARG_TOKEN_STRINGIFIED
:
1637 tokens_ptr
= (const cpp_token
**) &arg
->stringified
;
1639 case MACRO_ARG_TOKEN_EXPANDED
:
1640 tokens_ptr
= arg
->expanded
;
1644 if (tokens_ptr
== NULL
)
1645 /* This can happen for e.g, an empty token argument to a
1646 funtion-like macro. */
1651 if (kind
== MACRO_ARG_TOKEN_NORMAL
)
1652 *virt_location
= &arg
->virt_locs
[index
];
1653 else if (kind
== MACRO_ARG_TOKEN_EXPANDED
)
1654 *virt_location
= &arg
->expanded_virt_locs
[index
];
1655 else if (kind
== MACRO_ARG_TOKEN_STRINGIFIED
)
1657 (location_t
*) &tokens_ptr
[index
]->src_loc
;
1659 return &tokens_ptr
[index
];
1662 /* Initialize an iterator so that it iterates over the tokens of a
1663 function-like macro argument. KIND is the kind of tokens we want
1664 ITER to iterate over. TOKEN_PTR points the first token ITER will
1667 macro_arg_token_iter_init (macro_arg_token_iter
*iter
,
1668 bool track_macro_exp_p
,
1669 enum macro_arg_token_kind kind
,
1670 const macro_arg
*arg
,
1671 const cpp_token
**token_ptr
)
1673 iter
->track_macro_exp_p
= track_macro_exp_p
;
1675 iter
->token_ptr
= token_ptr
;
1676 /* Unconditionally initialize this so that the compiler doesn't warn
1677 about iter->location_ptr being possibly uninitialized later after
1678 this code has been inlined somewhere. */
1679 iter
->location_ptr
= NULL
;
1680 if (track_macro_exp_p
)
1681 iter
->location_ptr
= get_arg_token_location (arg
, kind
);
1683 iter
->num_forwards
= 0;
1684 if (track_macro_exp_p
1685 && token_ptr
!= NULL
1686 && iter
->location_ptr
== NULL
)
1691 /* Move the iterator one token forward. Note that if IT was
1692 initialized on an argument that has a stringified token, moving it
1693 forward doesn't make sense as a stringified token is essentially one
1696 macro_arg_token_iter_forward (macro_arg_token_iter
*it
)
1700 case MACRO_ARG_TOKEN_NORMAL
:
1701 case MACRO_ARG_TOKEN_EXPANDED
:
1703 if (it
->track_macro_exp_p
)
1706 case MACRO_ARG_TOKEN_STRINGIFIED
:
1708 if (it
->num_forwards
> 0)
1719 /* Return the token pointed to by the iterator. */
1720 static const cpp_token
*
1721 macro_arg_token_iter_get_token (const macro_arg_token_iter
*it
)
1724 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1725 && it
->num_forwards
> 0)
1728 if (it
->token_ptr
== NULL
)
1730 return *it
->token_ptr
;
1733 /* Return the location of the token pointed to by the iterator.*/
1735 macro_arg_token_iter_get_location (const macro_arg_token_iter
*it
)
1738 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1739 && it
->num_forwards
> 0)
1742 if (it
->track_macro_exp_p
)
1743 return *it
->location_ptr
;
1745 return (*it
->token_ptr
)->src_loc
;
1748 /* Return the index of a token [resulting from macro expansion] inside
1749 the total list of tokens resulting from a given macro
1750 expansion. The index can be different depending on whether if we
1751 want each tokens resulting from function-like macro arguments
1752 expansion to have a different location or not.
1754 E.g, consider this function-like macro:
1758 Then consider us "calling" it (and thus expanding it) like:
1762 It will be expanded into:
1766 Let's consider the case of the token '4'.
1768 Its index can be 2 (it's the third token of the set of tokens
1769 resulting from the expansion) or it can be 0 if we consider that
1770 all tokens resulting from the expansion of the argument "1+2" have
1771 the same index, which is 0. In this later case, the index of token
1772 '-' would then be 1 and the index of token '3' would be 2.
1774 The later case is useful to use less memory e.g, for the case of
1775 the user using the option -ftrack-macro-expansion=1.
1777 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1778 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1779 parameter (inside the macro replacement list) that corresponds to
1780 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1783 If we refer to the example above, for the '4' argument token,
1784 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1785 would be set to the token 'x', in the replacement list "x - 3" of
1788 This is a subroutine of replace_args. */
1789 inline static unsigned
1790 expanded_token_index (cpp_reader
*pfile
, cpp_macro
*macro
,
1791 const cpp_token
*cur_replacement_token
,
1792 unsigned absolute_token_index
)
1794 if (CPP_OPTION (pfile
, track_macro_expansion
) > 1)
1795 return absolute_token_index
;
1796 return cur_replacement_token
- macro
->exp
.tokens
;
1799 /* Copy whether PASTE_LEFT is set from SRC to *PASTE_FLAG. */
1802 copy_paste_flag (cpp_reader
*pfile
, const cpp_token
**paste_flag
,
1803 const cpp_token
*src
)
1805 cpp_token
*token
= _cpp_temp_token (pfile
);
1806 token
->type
= (*paste_flag
)->type
;
1807 token
->val
= (*paste_flag
)->val
;
1808 if (src
->flags
& PASTE_LEFT
)
1809 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1811 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1812 *paste_flag
= token
;
1815 /* True IFF the last token emitted into BUFF (if any) is PTR. */
1818 last_token_is (_cpp_buff
*buff
, const cpp_token
**ptr
)
1820 return (ptr
&& tokens_buff_last_token_ptr (buff
) == ptr
);
1823 /* Replace the parameters in a function-like macro of NODE with the
1824 actual ARGS, and place the result in a newly pushed token context.
1825 Expand each argument before replacing, unless it is operated upon
1826 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1827 the expansion point of the macro. E.g, the location of the
1828 function-like macro invocation. */
1830 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
,
1831 macro_arg
*args
, location_t expansion_point_loc
)
1833 unsigned int i
, total
;
1834 const cpp_token
*src
, *limit
;
1835 const cpp_token
**first
= NULL
;
1837 _cpp_buff
*buff
= NULL
;
1838 location_t
*virt_locs
= NULL
;
1839 unsigned int exp_count
;
1840 const line_map_macro
*map
= NULL
;
1841 int track_macro_exp
;
1843 /* First, fully macro-expand arguments, calculating the number of
1844 tokens in the final expansion as we go. The ordering of the if
1845 statements below is subtle; we must handle stringification before
1848 /* EXP_COUNT is the number of tokens in the macro replacement
1849 list. TOTAL is the number of tokens /after/ macro parameters
1850 have been replaced by their arguments. */
1851 exp_count
= macro_real_token_count (macro
);
1853 limit
= macro
->exp
.tokens
+ exp_count
;
1855 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1856 if (src
->type
== CPP_MACRO_ARG
)
1858 /* Leading and trailing padding tokens. */
1860 /* Account for leading and padding tokens in exp_count too.
1861 This is going to be important later down this function,
1862 when we want to handle the case of (track_macro_exp <
1866 /* We have an argument. If it is not being stringified or
1867 pasted it is macro-replaced before insertion. */
1868 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
1870 if (src
->flags
& STRINGIFY_ARG
)
1872 if (!arg
->stringified
)
1873 arg
->stringified
= stringify_arg (pfile
, arg
);
1875 else if ((src
->flags
& PASTE_LEFT
)
1876 || (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
1877 total
+= arg
->count
- 1;
1881 expand_arg (pfile
, arg
);
1882 total
+= arg
->expanded_count
- 1;
1886 /* When the compiler is called with the -ftrack-macro-expansion
1887 flag, we need to keep track of the location of each token that
1888 results from macro expansion.
1890 A token resulting from macro expansion is not a new token. It is
1891 simply the same token as the token coming from the macro
1892 definition. The new things that are allocated are the buffer
1893 that holds the tokens resulting from macro expansion and a new
1894 location that records many things like the locus of the expansion
1895 point as well as the original locus inside the definition of the
1896 macro. This location is called a virtual location.
1898 So the buffer BUFF holds a set of cpp_token*, and the buffer
1899 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1901 Both of these two buffers are going to be hung off of the macro
1902 context, when the latter is pushed. The memory allocated to
1903 store the tokens and their locations is going to be freed once
1904 the context of macro expansion is popped.
1906 As far as tokens are concerned, the memory overhead of
1907 -ftrack-macro-expansion is proportional to the number of
1908 macros that get expanded multiplied by sizeof (location_t).
1909 The good news is that extra memory gets freed when the macro
1910 context is freed, i.e shortly after the macro got expanded. */
1912 /* Is the -ftrack-macro-expansion flag in effect? */
1913 track_macro_exp
= CPP_OPTION (pfile
, track_macro_expansion
);
1915 /* Now allocate memory space for tokens and locations resulting from
1916 the macro expansion, copy the tokens and replace the arguments.
1917 This memory must be freed when the context of the macro MACRO is
1919 buff
= tokens_buff_new (pfile
, total
, track_macro_exp
? &virt_locs
: NULL
);
1921 first
= (const cpp_token
**) buff
->base
;
1923 /* Create a macro map to record the locations of the tokens that are
1924 involved in the expansion. Note that the expansion point is set
1925 to the location of the closing parenthesis. Otherwise, the
1926 subsequent map created for the first token that comes after the
1927 macro map might have a wrong line number. That would lead to
1928 tokens with wrong line numbers after the macro expansion. This
1929 adds up to the memory overhead of the -ftrack-macro-expansion
1930 flag; for every macro that is expanded, a "macro map" is
1932 if (track_macro_exp
)
1934 int num_macro_tokens
= total
;
1935 if (track_macro_exp
< 2)
1936 /* Then the number of macro tokens won't take in account the
1937 fact that function-like macro arguments can expand to
1938 multiple tokens. This is to save memory at the expense of
1941 Suppose we have #define SQUARE(A) A * A
1943 And then we do SQUARE(2+3)
1945 Then the tokens 2, +, 3, will have the same location,
1946 saying they come from the expansion of the argument A. */
1947 num_macro_tokens
= exp_count
;
1948 map
= linemap_enter_macro (pfile
->line_table
, node
,
1949 expansion_point_loc
,
1953 vaopt_state
vaopt_tracker (pfile
, macro
->variadic
, &args
[macro
->paramc
- 1]);
1954 const cpp_token
**vaopt_start
= NULL
;
1955 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1957 unsigned int arg_tokens_count
;
1958 macro_arg_token_iter from
;
1959 const cpp_token
**paste_flag
= NULL
;
1960 const cpp_token
**tmp_token_ptr
;
1962 /* __VA_OPT__ handling. */
1963 vaopt_state::update_type vostate
= vaopt_tracker
.update (src
);
1964 if (vostate
!= vaopt_state::INCLUDE
)
1966 if (vostate
== vaopt_state::BEGIN
)
1968 /* Padding on the left of __VA_OPT__ (unless RHS of ##). */
1969 if (src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
1971 const cpp_token
*t
= padding_token (pfile
, src
);
1972 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
1973 /* Allocate a virtual location for the padding token and
1974 append the token and its location to BUFF and
1976 tokens_buff_add_token (buff
, virt_locs
, t
,
1977 t
->src_loc
, t
->src_loc
,
1980 vaopt_start
= tokens_buff_last_token_ptr (buff
);
1982 else if (vostate
== vaopt_state::END
)
1984 const cpp_token
**start
= vaopt_start
;
1987 /* Remove any tail padding from inside the __VA_OPT__. */
1988 paste_flag
= tokens_buff_last_token_ptr (buff
);
1989 while (paste_flag
&& paste_flag
!= start
1990 && (*paste_flag
)->type
== CPP_PADDING
)
1992 tokens_buff_remove_last_token (buff
);
1993 paste_flag
= tokens_buff_last_token_ptr (buff
);
1996 if (src
->flags
& PASTE_LEFT
)
1998 /* With a non-empty __VA_OPT__ on the LHS of ##, the last
1999 token should be flagged PASTE_LEFT. */
2000 if (paste_flag
&& (*paste_flag
)->type
!= CPP_PADDING
)
2001 copy_paste_flag (pfile
, paste_flag
, src
);
2005 /* Otherwise, avoid paste on RHS, __VA_OPT__(c)d or
2006 __VA_OPT__(c)__VA_OPT__(d). */
2007 const cpp_token
*t
= &pfile
->avoid_paste
;
2008 tokens_buff_add_token (buff
, virt_locs
,
2009 t
, t
->src_loc
, t
->src_loc
,
2016 if (src
->type
!= CPP_MACRO_ARG
)
2018 /* Allocate a virtual location for token SRC, and add that
2019 token and its virtual location into the buffers BUFF and
2021 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2022 tokens_buff_add_token (buff
, virt_locs
, src
,
2023 src
->src_loc
, src
->src_loc
,
2030 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
2031 /* SRC is a macro parameter that we need to replace with its
2032 corresponding argument. So at some point we'll need to
2033 iterate over the tokens of the macro argument and copy them
2034 into the "place" now holding the correspondig macro
2035 parameter. We are going to use the iterator type
2036 macro_argo_token_iter to handle that iterating. The 'if'
2037 below is to initialize the iterator depending on the type of
2038 tokens the macro argument has. It also does some adjustment
2039 related to padding tokens and some pasting corner cases. */
2040 if (src
->flags
& STRINGIFY_ARG
)
2042 arg_tokens_count
= 1;
2043 macro_arg_token_iter_init (&from
,
2045 track_macro_expansion
),
2046 MACRO_ARG_TOKEN_STRINGIFIED
,
2047 arg
, &arg
->stringified
);
2049 else if (src
->flags
& PASTE_LEFT
)
2051 arg_tokens_count
= arg
->count
;
2052 macro_arg_token_iter_init (&from
,
2054 track_macro_expansion
),
2055 MACRO_ARG_TOKEN_NORMAL
,
2058 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
2061 arg_tokens_count
= arg
->count
;
2062 macro_arg_token_iter_init (&from
,
2064 track_macro_expansion
),
2065 MACRO_ARG_TOKEN_NORMAL
,
2068 num_toks
= tokens_buff_count (buff
);
2072 /* So the current parameter token is pasted to the previous
2073 token in the replacement list. Let's look at what
2074 we have as previous and current arguments. */
2076 /* This is the previous argument's token ... */
2077 tmp_token_ptr
= tokens_buff_last_token_ptr (buff
);
2079 if ((*tmp_token_ptr
)->type
== CPP_COMMA
2081 && src
->val
.macro_arg
.arg_no
== macro
->paramc
)
2083 /* ... which is a comma; and the current parameter
2084 is the last parameter of a variadic function-like
2085 macro. If the argument to the current last
2086 parameter is NULL, then swallow the comma,
2087 otherwise drop the paste flag. */
2088 if (macro_arg_token_iter_get_token (&from
) == NULL
)
2089 tokens_buff_remove_last_token (buff
);
2091 paste_flag
= tmp_token_ptr
;
2093 /* Remove the paste flag if the RHS is a placemarker, unless the
2094 previous emitted token is at the beginning of __VA_OPT__;
2095 placemarkers within __VA_OPT__ are ignored in that case. */
2096 else if (arg_tokens_count
== 0
2097 && tmp_token_ptr
!= vaopt_start
)
2098 paste_flag
= tmp_token_ptr
;
2103 arg_tokens_count
= arg
->expanded_count
;
2104 macro_arg_token_iter_init (&from
,
2106 track_macro_expansion
),
2107 MACRO_ARG_TOKEN_EXPANDED
,
2108 arg
, arg
->expanded
);
2110 if (last_token_is (buff
, vaopt_start
))
2112 /* We're expanding an arg at the beginning of __VA_OPT__.
2114 while (arg_tokens_count
)
2116 const cpp_token
*t
= macro_arg_token_iter_get_token (&from
);
2117 if (t
->type
!= CPP_PADDING
)
2119 macro_arg_token_iter_forward (&from
);
2125 /* Padding on the left of an argument (unless RHS of ##). */
2126 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
2127 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
)
2128 && !last_token_is (buff
, vaopt_start
))
2130 const cpp_token
*t
= padding_token (pfile
, src
);
2131 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2132 /* Allocate a virtual location for the padding token and
2133 append the token and its location to BUFF and
2135 tokens_buff_add_token (buff
, virt_locs
, t
,
2136 t
->src_loc
, t
->src_loc
,
2140 if (arg_tokens_count
)
2142 /* So now we've got the number of tokens that make up the
2143 argument that is going to replace the current parameter
2144 in the macro's replacement list. */
2146 for (j
= 0; j
< arg_tokens_count
; ++j
)
2148 /* So if track_macro_exp is < 2, the user wants to
2149 save extra memory while tracking macro expansion
2150 locations. So in that case here is what we do:
2152 Suppose we have #define SQUARE(A) A * A
2154 And then we do SQUARE(2+3)
2156 Then the tokens 2, +, 3, will have the same location,
2157 saying they come from the expansion of the argument
2160 So that means we are going to ignore the COUNT tokens
2161 resulting from the expansion of the current macro
2162 argument. In other words all the ARG_TOKENS_COUNT tokens
2163 resulting from the expansion of the macro argument will
2164 have the index I. Normally, each of those tokens should
2166 unsigned token_index
= i
;
2168 if (track_macro_exp
> 1)
2171 index
= expanded_token_index (pfile
, macro
, src
, token_index
);
2172 tokens_buff_add_token (buff
, virt_locs
,
2173 macro_arg_token_iter_get_token (&from
),
2174 macro_arg_token_iter_get_location (&from
),
2175 src
->src_loc
, map
, index
);
2176 macro_arg_token_iter_forward (&from
);
2179 /* With a non-empty argument on the LHS of ##, the last
2180 token should be flagged PASTE_LEFT. */
2181 if (src
->flags
& PASTE_LEFT
)
2183 = (const cpp_token
**) tokens_buff_last_token_ptr (buff
);
2185 else if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, c99
)
2186 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2188 if (CPP_OPTION (pfile
, cplusplus
))
2189 cpp_pedwarning (pfile
, CPP_W_PEDANTIC
,
2190 "invoking macro %s argument %d: "
2191 "empty macro arguments are undefined"
2193 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2194 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
))
2195 cpp_pedwarning (pfile
,
2196 CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2197 ? CPP_W_C90_C99_COMPAT
: CPP_W_PEDANTIC
,
2198 "invoking macro %s argument %d: "
2199 "empty macro arguments are undefined"
2201 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2203 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2204 && ! CPP_OPTION (pfile
, cplusplus
)
2205 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2206 cpp_warning (pfile
, CPP_W_C90_C99_COMPAT
,
2207 "invoking macro %s argument %d: "
2208 "empty macro arguments are undefined"
2210 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2212 /* Avoid paste on RHS (even case count == 0). */
2213 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
)
2214 && !last_token_is (buff
, vaopt_start
))
2216 const cpp_token
*t
= &pfile
->avoid_paste
;
2217 tokens_buff_add_token (buff
, virt_locs
,
2218 t
, t
->src_loc
, t
->src_loc
,
2222 /* Add a new paste flag, or remove an unwanted one. */
2224 copy_paste_flag (pfile
, paste_flag
, src
);
2226 i
+= arg_tokens_count
;
2229 if (track_macro_exp
)
2230 push_extended_tokens_context (pfile
, node
, buff
, virt_locs
, first
,
2231 tokens_buff_count (buff
));
2233 push_ptoken_context (pfile
, node
, buff
, first
,
2234 tokens_buff_count (buff
));
2236 num_macro_tokens_counter
+= tokens_buff_count (buff
);
2239 /* Return a special padding token, with padding inherited from SOURCE. */
2240 static const cpp_token
*
2241 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
2243 cpp_token
*result
= _cpp_temp_token (pfile
);
2245 result
->type
= CPP_PADDING
;
2247 /* Data in GCed data structures cannot be made const so far, so we
2248 need a cast here. */
2249 result
->val
.source
= (cpp_token
*) source
;
2254 /* Get a new uninitialized context. Create a new one if we cannot
2255 re-use an old one. */
2256 static cpp_context
*
2257 next_context (cpp_reader
*pfile
)
2259 cpp_context
*result
= pfile
->context
->next
;
2263 result
= XNEW (cpp_context
);
2264 memset (result
, 0, sizeof (cpp_context
));
2265 result
->prev
= pfile
->context
;
2267 pfile
->context
->next
= result
;
2270 pfile
->context
= result
;
2274 /* Push a list of pointers to tokens. */
2276 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
2277 const cpp_token
**first
, unsigned int count
)
2279 cpp_context
*context
= next_context (pfile
);
2281 context
->tokens_kind
= TOKENS_KIND_INDIRECT
;
2282 context
->c
.macro
= macro
;
2283 context
->buff
= buff
;
2284 FIRST (context
).ptoken
= first
;
2285 LAST (context
).ptoken
= first
+ count
;
2288 /* Push a list of tokens.
2290 A NULL macro means that we should continue the current macro
2291 expansion, in essence. That means that if we are currently in a
2292 macro expansion context, we'll make the new pfile->context refer to
2293 the current macro. */
2295 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2296 const cpp_token
*first
, unsigned int count
)
2298 cpp_context
*context
;
2301 macro
= macro_of_context (pfile
->context
);
2303 context
= next_context (pfile
);
2304 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2305 context
->c
.macro
= macro
;
2306 context
->buff
= NULL
;
2307 FIRST (context
).token
= first
;
2308 LAST (context
).token
= first
+ count
;
2311 /* Build a context containing a list of tokens as well as their
2312 virtual locations and push it. TOKENS_BUFF is the buffer that
2313 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
2314 non-NULL, it means that the context owns it, meaning that
2315 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
2316 contains the virtual locations.
2318 A NULL macro means that we should continue the current macro
2319 expansion, in essence. That means that if we are currently in a
2320 macro expansion context, we'll make the new pfile->context refer to
2321 the current macro. */
2323 push_extended_tokens_context (cpp_reader
*pfile
,
2324 cpp_hashnode
*macro
,
2325 _cpp_buff
*token_buff
,
2326 location_t
*virt_locs
,
2327 const cpp_token
**first
,
2330 cpp_context
*context
;
2334 macro
= macro_of_context (pfile
->context
);
2336 context
= next_context (pfile
);
2337 context
->tokens_kind
= TOKENS_KIND_EXTENDED
;
2338 context
->buff
= token_buff
;
2340 m
= XNEW (macro_context
);
2341 m
->macro_node
= macro
;
2342 m
->virt_locs
= virt_locs
;
2343 m
->cur_virt_loc
= virt_locs
;
2345 FIRST (context
).ptoken
= first
;
2346 LAST (context
).ptoken
= first
+ count
;
2349 /* Push a traditional macro's replacement text. */
2351 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2352 const uchar
*start
, size_t len
)
2354 cpp_context
*context
= next_context (pfile
);
2356 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2357 context
->c
.macro
= macro
;
2358 context
->buff
= NULL
;
2359 CUR (context
) = start
;
2360 RLIMIT (context
) = start
+ len
;
2361 macro
->flags
|= NODE_DISABLED
;
2364 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
2365 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
2366 non-null (which means that -ftrack-macro-expansion is on),
2367 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
2368 hold the virtual locations of the tokens resulting from macro
2371 tokens_buff_new (cpp_reader
*pfile
, size_t len
,
2372 location_t
**virt_locs
)
2374 size_t tokens_size
= len
* sizeof (cpp_token
*);
2375 size_t locs_size
= len
* sizeof (location_t
);
2377 if (virt_locs
!= NULL
)
2378 *virt_locs
= XNEWVEC (location_t
, locs_size
);
2379 return _cpp_get_buff (pfile
, tokens_size
);
2382 /* Returns the number of tokens contained in a token buffer. The
2383 buffer holds a set of cpp_token*. */
2385 tokens_buff_count (_cpp_buff
*buff
)
2387 return (BUFF_FRONT (buff
) - buff
->base
) / sizeof (cpp_token
*);
2390 /* Return a pointer to the last token contained in the token buffer
2392 static const cpp_token
**
2393 tokens_buff_last_token_ptr (_cpp_buff
*buff
)
2395 if (BUFF_FRONT (buff
) == buff
->base
)
2397 return &((const cpp_token
**) BUFF_FRONT (buff
))[-1];
2400 /* Remove the last token contained in the token buffer TOKENS_BUFF.
2401 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
2402 containing the virtual locations of the tokens in TOKENS_BUFF; in
2403 which case the function updates that buffer as well. */
2405 tokens_buff_remove_last_token (_cpp_buff
*tokens_buff
)
2408 if (BUFF_FRONT (tokens_buff
) > tokens_buff
->base
)
2409 BUFF_FRONT (tokens_buff
) =
2410 (unsigned char *) &((cpp_token
**) BUFF_FRONT (tokens_buff
))[-1];
2413 /* Insert a token into the token buffer at the position pointed to by
2414 DEST. Note that the buffer is not enlarged so the previous token
2415 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
2416 means -ftrack-macro-expansion is effect; it then points to where to
2417 insert the virtual location of TOKEN. TOKEN is the token to
2418 insert. VIRT_LOC is the virtual location of the token, i.e, the
2419 location possibly encoding its locus across macro expansion. If
2420 TOKEN is an argument of a function-like macro (inside a macro
2421 replacement list), PARM_DEF_LOC is the spelling location of the
2422 macro parameter that TOKEN is replacing, in the replacement list of
2423 the macro. If TOKEN is not an argument of a function-like macro or
2424 if it doesn't come from a macro expansion, then VIRT_LOC can just
2425 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
2426 means TOKEN comes from a macro expansion and MAP is the macro map
2427 associated to the macro. MACRO_TOKEN_INDEX points to the index of
2428 the token in the macro map; it is not considered if MAP is NULL.
2430 Upon successful completion this function returns the a pointer to
2431 the position of the token coming right after the insertion
2433 static inline const cpp_token
**
2434 tokens_buff_put_token_to (const cpp_token
**dest
,
2435 location_t
*virt_loc_dest
,
2436 const cpp_token
*token
,
2437 location_t virt_loc
,
2438 location_t parm_def_loc
,
2439 const line_map_macro
*map
,
2440 unsigned int macro_token_index
)
2442 location_t macro_loc
= virt_loc
;
2443 const cpp_token
**result
;
2447 /* -ftrack-macro-expansion is on. */
2449 macro_loc
= linemap_add_macro_token (map
, macro_token_index
,
2450 virt_loc
, parm_def_loc
);
2451 *virt_loc_dest
= macro_loc
;
2459 /* Adds a token at the end of the tokens contained in BUFFER. Note
2460 that this function doesn't enlarge BUFFER when the number of tokens
2461 reaches BUFFER's size; it aborts in that situation.
2463 TOKEN is the token to append. VIRT_LOC is the virtual location of
2464 the token, i.e, the location possibly encoding its locus across
2465 macro expansion. If TOKEN is an argument of a function-like macro
2466 (inside a macro replacement list), PARM_DEF_LOC is the location of
2467 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
2468 from a macro expansion, then VIRT_LOC can just be set to the same
2469 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
2470 from a macro expansion and MAP is the macro map associated to the
2471 macro. MACRO_TOKEN_INDEX points to the index of the token in the
2472 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
2473 non-null, it means -ftrack-macro-expansion is on; in which case
2474 this function adds the virtual location DEF_LOC to the VIRT_LOCS
2475 array, at the same index as the one of TOKEN in BUFFER. Upon
2476 successful completion this function returns the a pointer to the
2477 position of the token coming right after the insertion point. */
2478 static const cpp_token
**
2479 tokens_buff_add_token (_cpp_buff
*buffer
,
2480 location_t
*virt_locs
,
2481 const cpp_token
*token
,
2482 location_t virt_loc
,
2483 location_t parm_def_loc
,
2484 const line_map_macro
*map
,
2485 unsigned int macro_token_index
)
2487 const cpp_token
**result
;
2488 location_t
*virt_loc_dest
= NULL
;
2489 unsigned token_index
=
2490 (BUFF_FRONT (buffer
) - buffer
->base
) / sizeof (cpp_token
*);
2492 /* Abort if we pass the end the buffer. */
2493 if (BUFF_FRONT (buffer
) > BUFF_LIMIT (buffer
))
2496 if (virt_locs
!= NULL
)
2497 virt_loc_dest
= &virt_locs
[token_index
];
2500 tokens_buff_put_token_to ((const cpp_token
**) BUFF_FRONT (buffer
),
2501 virt_loc_dest
, token
, virt_loc
, parm_def_loc
,
2502 map
, macro_token_index
);
2504 BUFF_FRONT (buffer
) = (unsigned char *) result
;
2508 /* Allocate space for the function-like macro argument ARG to store
2509 the tokens resulting from the macro-expansion of the tokens that
2510 make up ARG itself. That space is allocated in ARG->expanded and
2511 needs to be freed using free. */
2513 alloc_expanded_arg_mem (cpp_reader
*pfile
, macro_arg
*arg
, size_t capacity
)
2515 gcc_checking_assert (arg
->expanded
== NULL
2516 && arg
->expanded_virt_locs
== NULL
);
2518 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
2519 if (CPP_OPTION (pfile
, track_macro_expansion
))
2520 arg
->expanded_virt_locs
= XNEWVEC (location_t
, capacity
);
2524 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2527 ensure_expanded_arg_room (cpp_reader
*pfile
, macro_arg
*arg
,
2528 size_t size
, size_t *expanded_capacity
)
2530 if (size
<= *expanded_capacity
)
2536 XRESIZEVEC (const cpp_token
*, arg
->expanded
, size
);
2537 *expanded_capacity
= size
;
2539 if (CPP_OPTION (pfile
, track_macro_expansion
))
2541 if (arg
->expanded_virt_locs
== NULL
)
2542 arg
->expanded_virt_locs
= XNEWVEC (location_t
, size
);
2544 arg
->expanded_virt_locs
= XRESIZEVEC (location_t
,
2545 arg
->expanded_virt_locs
,
2550 /* Expand an argument ARG before replacing parameters in a
2551 function-like macro. This works by pushing a context with the
2552 argument's tokens, and then expanding that into a temporary buffer
2553 as if it were a normal part of the token stream. collect_args()
2554 has terminated the argument's tokens with a CPP_EOF so that we know
2555 when we have fully expanded the argument. */
2557 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
2560 bool saved_warn_trad
;
2561 bool track_macro_exp_p
= CPP_OPTION (pfile
, track_macro_expansion
);
2564 || arg
->expanded
!= NULL
)
2567 /* Don't warn about funlike macros when pre-expanding. */
2568 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
2569 CPP_WTRADITIONAL (pfile
) = 0;
2571 /* Loop, reading in the tokens of the argument. */
2573 alloc_expanded_arg_mem (pfile
, arg
, capacity
);
2575 if (track_macro_exp_p
)
2576 push_extended_tokens_context (pfile
, NULL
, NULL
,
2581 push_ptoken_context (pfile
, NULL
, NULL
,
2582 arg
->first
, arg
->count
+ 1);
2586 const cpp_token
*token
;
2587 location_t location
;
2589 ensure_expanded_arg_room (pfile
, arg
, arg
->expanded_count
+ 1,
2592 token
= cpp_get_token_1 (pfile
, &location
);
2594 if (token
->type
== CPP_EOF
)
2597 set_arg_token (arg
, token
, location
,
2598 arg
->expanded_count
, MACRO_ARG_TOKEN_EXPANDED
,
2599 CPP_OPTION (pfile
, track_macro_expansion
));
2600 arg
->expanded_count
++;
2603 _cpp_pop_context (pfile
);
2605 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
2608 /* Returns the macro associated to the current context if we are in
2609 the context a macro expansion, NULL otherwise. */
2610 static cpp_hashnode
*
2611 macro_of_context (cpp_context
*context
)
2613 if (context
== NULL
)
2616 return (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2617 ? context
->c
.mc
->macro_node
2621 /* Return TRUE iff we are expanding a macro or are about to start
2622 expanding one. If we are effectively expanding a macro, the
2623 function macro_of_context returns a pointer to the macro being
2626 in_macro_expansion_p (cpp_reader
*pfile
)
2631 return (pfile
->about_to_expand_macro_p
2632 || macro_of_context (pfile
->context
));
2635 /* Pop the current context off the stack, re-enabling the macro if the
2636 context represented a macro's replacement list. Initially the
2637 context structure was not freed so that we can re-use it later, but
2638 now we do free it to reduce peak memory consumption. */
2640 _cpp_pop_context (cpp_reader
*pfile
)
2642 cpp_context
*context
= pfile
->context
;
2644 /* We should not be popping the base context. */
2645 if (context
== &pfile
->base_context
)
2648 if (context
->c
.macro
)
2650 cpp_hashnode
*macro
;
2651 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2653 macro_context
*mc
= context
->c
.mc
;
2654 macro
= mc
->macro_node
;
2655 /* If context->buff is set, it means the life time of tokens
2656 is bound to the life time of this context; so we must
2657 free the tokens; that means we must free the virtual
2658 locations of these tokens too. */
2659 if (context
->buff
&& mc
->virt_locs
)
2661 free (mc
->virt_locs
);
2662 mc
->virt_locs
= NULL
;
2665 context
->c
.mc
= NULL
;
2668 macro
= context
->c
.macro
;
2670 /* Beware that MACRO can be NULL in cases like when we are
2671 called from expand_arg. In those cases, a dummy context with
2672 tokens is pushed just for the purpose of walking them using
2673 cpp_get_token_1. In that case, no 'macro' field is set into
2674 the dummy context. */
2676 /* Several contiguous macro expansion contexts can be
2677 associated to the same macro; that means it's the same
2678 macro expansion that spans across all these (sub)
2679 contexts. So we should re-enable an expansion-disabled
2680 macro only when we are sure we are really out of that
2682 && macro_of_context (context
->prev
) != macro
)
2683 macro
->flags
&= ~NODE_DISABLED
;
2685 if (macro
== pfile
->top_most_macro_node
&& context
->prev
== NULL
)
2686 /* We are popping the context of the top-most macro node. */
2687 pfile
->top_most_macro_node
= NULL
;
2692 /* Decrease memory peak consumption by freeing the memory used
2694 _cpp_free_buff (context
->buff
);
2697 pfile
->context
= context
->prev
;
2698 /* decrease peak memory consumption by feeing the context. */
2699 pfile
->context
->next
= NULL
;
2703 /* Return TRUE if we reached the end of the set of tokens stored in
2704 CONTEXT, FALSE otherwise. */
2706 reached_end_of_context (cpp_context
*context
)
2708 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
2709 return FIRST (context
).token
== LAST (context
).token
;
2710 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
2711 || context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2712 return FIRST (context
).ptoken
== LAST (context
).ptoken
;
2717 /* Consume the next token contained in the current context of PFILE,
2718 and return it in *TOKEN. It's "full location" is returned in
2719 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2720 means the location encoding the locus of the token across macro
2721 expansion; otherwise it's just is the "normal" location of the
2722 token which (*TOKEN)->src_loc. */
2724 consume_next_token_from_context (cpp_reader
*pfile
,
2725 const cpp_token
** token
,
2726 location_t
*location
)
2728 cpp_context
*c
= pfile
->context
;
2730 if ((c
)->tokens_kind
== TOKENS_KIND_DIRECT
)
2732 *token
= FIRST (c
).token
;
2733 *location
= (*token
)->src_loc
;
2736 else if ((c
)->tokens_kind
== TOKENS_KIND_INDIRECT
)
2738 *token
= *FIRST (c
).ptoken
;
2739 *location
= (*token
)->src_loc
;
2742 else if ((c
)->tokens_kind
== TOKENS_KIND_EXTENDED
)
2744 macro_context
*m
= c
->c
.mc
;
2745 *token
= *FIRST (c
).ptoken
;
2748 *location
= *m
->cur_virt_loc
;
2752 *location
= (*token
)->src_loc
;
2759 /* In the traditional mode of the preprocessor, if we are currently in
2760 a directive, the location of a token must be the location of the
2761 start of the directive line. This function returns the proper
2762 location if we are in the traditional mode, and just returns
2763 LOCATION otherwise. */
2765 static inline location_t
2766 maybe_adjust_loc_for_trad_cpp (cpp_reader
*pfile
, location_t location
)
2768 if (CPP_OPTION (pfile
, traditional
))
2770 if (pfile
->state
.in_directive
)
2771 return pfile
->directive_line
;
2776 /* Routine to get a token as well as its location.
2778 Macro expansions and directives are transparently handled,
2779 including entering included files. Thus tokens are post-macro
2780 expansion, and after any intervening directives. External callers
2781 see CPP_EOF only at EOF. Internal callers also see it when meeting
2782 a directive inside a macro call, when at the end of a directive and
2783 state.in_directive is still 1, and at the end of argument
2786 LOC is an out parameter; *LOC is set to the location "as expected
2787 by the user". Please read the comment of
2788 cpp_get_token_with_location to learn more about the meaning of this
2790 static const cpp_token
*
2791 cpp_get_token_1 (cpp_reader
*pfile
, location_t
*location
)
2793 const cpp_token
*result
;
2794 /* This token is a virtual token that either encodes a location
2795 related to macro expansion or a spelling location. */
2796 location_t virt_loc
= 0;
2797 /* pfile->about_to_expand_macro_p can be overriden by indirect calls
2798 to functions that push macro contexts. So let's save it so that
2799 we can restore it when we are about to leave this routine. */
2800 bool saved_about_to_expand_macro
= pfile
->about_to_expand_macro_p
;
2805 cpp_context
*context
= pfile
->context
;
2807 /* Context->prev == 0 <=> base context. */
2810 result
= _cpp_lex_token (pfile
);
2811 virt_loc
= result
->src_loc
;
2813 else if (!reached_end_of_context (context
))
2815 consume_next_token_from_context (pfile
, &result
,
2817 if (result
->flags
& PASTE_LEFT
)
2819 paste_all_tokens (pfile
, result
);
2820 if (pfile
->state
.in_directive
)
2822 result
= padding_token (pfile
, result
);
2828 if (pfile
->context
->c
.macro
)
2829 ++num_expanded_macros_counter
;
2830 _cpp_pop_context (pfile
);
2831 if (pfile
->state
.in_directive
)
2833 result
= &pfile
->avoid_paste
;
2837 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
2840 if (result
->type
!= CPP_NAME
)
2843 node
= result
->val
.node
.node
;
2845 if (node
->type
== NT_VOID
|| (result
->flags
& NO_EXPAND
))
2848 if (!(node
->flags
& NODE_DISABLED
))
2851 /* If not in a macro context, and we're going to start an
2852 expansion, record the location and the top level macro
2853 about to be expanded. */
2854 if (!in_macro_expansion_p (pfile
))
2856 pfile
->invocation_location
= result
->src_loc
;
2857 pfile
->top_most_macro_node
= node
;
2859 if (pfile
->state
.prevent_expansion
)
2862 /* Conditional macros require that a predicate be evaluated
2864 if ((node
->flags
& NODE_CONDITIONAL
) != 0)
2866 if (pfile
->cb
.macro_to_expand
)
2868 bool whitespace_after
;
2869 const cpp_token
*peek_tok
= cpp_peek_token (pfile
, 0);
2871 whitespace_after
= (peek_tok
->type
== CPP_PADDING
2872 || (peek_tok
->flags
& PREV_WHITE
));
2873 node
= pfile
->cb
.macro_to_expand (pfile
, result
);
2875 ret
= enter_macro_context (pfile
, node
, result
, virt_loc
);
2876 else if (whitespace_after
)
2878 /* If macro_to_expand hook returned NULL and it
2879 ate some tokens, see if we don't need to add
2880 a padding token in between this and the
2882 peek_tok
= cpp_peek_token (pfile
, 0);
2883 if (peek_tok
->type
!= CPP_PADDING
2884 && (peek_tok
->flags
& PREV_WHITE
) == 0)
2885 _cpp_push_token_context (pfile
, NULL
,
2886 padding_token (pfile
,
2892 ret
= enter_macro_context (pfile
, node
, result
, virt_loc
);
2895 if (pfile
->state
.in_directive
|| ret
== 2)
2897 result
= padding_token (pfile
, result
);
2903 /* Flag this token as always unexpandable. FIXME: move this
2904 to collect_args()?. */
2905 cpp_token
*t
= _cpp_temp_token (pfile
);
2906 t
->type
= result
->type
;
2907 t
->flags
= result
->flags
| NO_EXPAND
;
2908 t
->val
= result
->val
;
2916 if (location
!= NULL
)
2919 virt_loc
= result
->src_loc
;
2920 *location
= virt_loc
;
2922 if (!CPP_OPTION (pfile
, track_macro_expansion
)
2923 && macro_of_context (pfile
->context
) != NULL
)
2924 /* We are in a macro expansion context, are not tracking
2925 virtual location, but were asked to report the location
2926 of the expansion point of the macro being expanded. */
2927 *location
= pfile
->invocation_location
;
2929 *location
= maybe_adjust_loc_for_trad_cpp (pfile
, *location
);
2932 pfile
->about_to_expand_macro_p
= saved_about_to_expand_macro
;
2936 /* External routine to get a token. Also used nearly everywhere
2937 internally, except for places where we know we can safely call
2938 _cpp_lex_token directly, such as lexing a directive name.
2940 Macro expansions and directives are transparently handled,
2941 including entering included files. Thus tokens are post-macro
2942 expansion, and after any intervening directives. External callers
2943 see CPP_EOF only at EOF. Internal callers also see it when meeting
2944 a directive inside a macro call, when at the end of a directive and
2945 state.in_directive is still 1, and at the end of argument
2948 cpp_get_token (cpp_reader
*pfile
)
2950 return cpp_get_token_1 (pfile
, NULL
);
2953 /* Like cpp_get_token, but also returns a virtual token location
2954 separate from the spelling location carried by the returned token.
2956 LOC is an out parameter; *LOC is set to the location "as expected
2957 by the user". This matters when a token results from macro
2958 expansion; in that case the token's spelling location indicates the
2959 locus of the token in the definition of the macro but *LOC
2960 virtually encodes all the other meaningful locuses associated to
2963 What? virtual location? Yes, virtual location.
2965 If the token results from macro expansion and if macro expansion
2966 location tracking is enabled its virtual location encodes (at the
2969 - the spelling location of the token
2971 - the locus of the macro expansion point
2973 - the locus of the point where the token got instantiated as part
2974 of the macro expansion process.
2976 You have to use the linemap API to get the locus you are interested
2977 in from a given virtual location.
2979 Note however that virtual locations are not necessarily ordered for
2980 relations '<' and '>'. One must use the function
2981 linemap_location_before_p instead of using the relational operator
2984 If macro expansion tracking is off and if the token results from
2985 macro expansion the virtual location is the expansion point of the
2986 macro that got expanded.
2988 When the token doesn't result from macro expansion, the virtual
2989 location is just the same thing as its spelling location. */
2992 cpp_get_token_with_location (cpp_reader
*pfile
, location_t
*loc
)
2994 return cpp_get_token_1 (pfile
, loc
);
2997 /* Returns true if we're expanding an object-like macro that was
2998 defined in a system header. Just checks the macro at the top of
2999 the stack. Used for diagnostic suppression. */
3001 cpp_sys_macro_p (cpp_reader
*pfile
)
3003 cpp_hashnode
*node
= NULL
;
3005 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
3006 node
= pfile
->context
->c
.mc
->macro_node
;
3008 node
= pfile
->context
->c
.macro
;
3010 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
3013 /* Read each token in, until end of the current file. Directives are
3014 transparently processed. */
3016 cpp_scan_nooutput (cpp_reader
*pfile
)
3018 /* Request a CPP_EOF token at the end of this file, rather than
3019 transparently continuing with the including file. */
3020 pfile
->buffer
->return_at_eof
= true;
3022 pfile
->state
.discarding_output
++;
3023 pfile
->state
.prevent_expansion
++;
3025 if (CPP_OPTION (pfile
, traditional
))
3026 while (_cpp_read_logical_line_trad (pfile
))
3029 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
3032 pfile
->state
.discarding_output
--;
3033 pfile
->state
.prevent_expansion
--;
3036 /* Step back one or more tokens obtained from the lexer. */
3038 _cpp_backup_tokens_direct (cpp_reader
*pfile
, unsigned int count
)
3040 pfile
->lookaheads
+= count
;
3044 if (pfile
->cur_token
== pfile
->cur_run
->base
3045 /* Possible with -fpreprocessed and no leading #line. */
3046 && pfile
->cur_run
->prev
!= NULL
)
3048 pfile
->cur_run
= pfile
->cur_run
->prev
;
3049 pfile
->cur_token
= pfile
->cur_run
->limit
;
3054 /* Step back one (or more) tokens. Can only step back more than 1 if
3055 they are from the lexer, and not from macro expansion. */
3057 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
3059 if (pfile
->context
->prev
== NULL
)
3060 _cpp_backup_tokens_direct (pfile
, count
);
3065 if (pfile
->context
->tokens_kind
== TOKENS_KIND_DIRECT
)
3066 FIRST (pfile
->context
).token
--;
3067 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
3068 FIRST (pfile
->context
).ptoken
--;
3069 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
3071 FIRST (pfile
->context
).ptoken
--;
3072 if (pfile
->context
->c
.macro
)
3074 macro_context
*m
= pfile
->context
->c
.mc
;
3076 gcc_checking_assert (m
->cur_virt_loc
>= m
->virt_locs
);
3086 /* #define directive parsing and handling. */
3088 /* Returns true if a macro redefinition warning is required. */
3090 warn_of_redefinition (cpp_reader
*pfile
, cpp_hashnode
*node
,
3091 const cpp_macro
*macro2
)
3093 /* Some redefinitions need to be warned about regardless. */
3094 if (node
->flags
& NODE_WARN
)
3097 /* Suppress warnings for builtins that lack the NODE_WARN flag,
3098 unless Wbuiltin-macro-redefined. */
3099 if (cpp_builtin_macro_p (node
))
3100 return CPP_OPTION (pfile
, warn_builtin_macro_redefined
);
3102 /* Redefinitions of conditional (context-sensitive) macros, on
3103 the other hand, must be allowed silently. */
3104 if (node
->flags
& NODE_CONDITIONAL
)
3107 cpp_macro
*macro1
= node
->value
.macro
;
3110 /* We don't want to mark MACRO as used, but do need to finalize
3112 pfile
->cb
.user_lazy_macro (pfile
, macro1
, macro1
->lazy
- 1);
3116 /* Redefinition of a macro is allowed if and only if the old and new
3117 definitions are the same. (6.10.3 paragraph 2). */
3119 /* Don't check count here as it can be different in valid
3120 traditional redefinitions with just whitespace differences. */
3121 if (macro1
->paramc
!= macro2
->paramc
3122 || macro1
->fun_like
!= macro2
->fun_like
3123 || macro1
->variadic
!= macro2
->variadic
)
3126 /* Check parameter spellings. */
3127 for (unsigned i
= macro1
->paramc
; i
--; )
3128 if (macro1
->parm
.params
[i
] != macro2
->parm
.params
[i
])
3131 /* Check the replacement text or tokens. */
3132 if (macro1
->kind
== cmk_traditional
)
3133 return _cpp_expansions_different_trad (macro1
, macro2
);
3135 if (macro1
->count
!= macro2
->count
)
3138 for (unsigned i
= macro1
->count
; i
--; )
3139 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
3145 /* Free the definition of hashnode H. */
3147 _cpp_free_definition (cpp_hashnode
*h
)
3149 /* Macros and assertions no longer have anything to free. */
3151 h
->value
.answers
= NULL
;
3152 h
->flags
&= ~(NODE_DISABLED
| NODE_USED
);
3155 /* Save parameter NODE (spelling SPELLING) to the parameter list of
3156 macro MACRO. Returns true on success, false on failure. */
3158 _cpp_save_parameter (cpp_reader
*pfile
, unsigned n
, cpp_hashnode
*node
,
3159 cpp_hashnode
*spelling
)
3161 /* Constraint 6.10.3.6 - duplicate parameter names. */
3162 if (node
->type
== NT_MACRO_ARG
)
3164 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
3169 unsigned len
= (n
+ 1) * sizeof (struct macro_arg_saved_data
);
3170 if (len
> pfile
->macro_buffer_len
)
3173 = XRESIZEVEC (unsigned char, pfile
->macro_buffer
, len
);
3174 pfile
->macro_buffer_len
= len
;
3177 macro_arg_saved_data
*saved
= (macro_arg_saved_data
*)pfile
->macro_buffer
;
3178 saved
[n
].canonical_node
= node
;
3179 saved
[n
].value
= node
->value
;
3180 saved
[n
].type
= node
->type
;
3182 void *base
= _cpp_reserve_room (pfile
, n
* sizeof (cpp_hashnode
*),
3183 sizeof (cpp_hashnode
*));
3184 ((cpp_hashnode
**)base
)[n
] = spelling
;
3186 /* Morph into a macro arg. */
3187 node
->type
= NT_MACRO_ARG
;
3188 /* Index is 1 based. */
3189 node
->value
.arg_index
= n
+ 1;
3194 /* Restore the parameters to their previous state. */
3196 _cpp_unsave_parameters (cpp_reader
*pfile
, unsigned n
)
3198 /* Clear the fast argument lookup indices. */
3201 struct macro_arg_saved_data
*save
=
3202 &((struct macro_arg_saved_data
*) pfile
->macro_buffer
)[n
];
3204 struct cpp_hashnode
*node
= save
->canonical_node
;
3205 node
->type
= save
->type
;
3206 node
->value
= save
->value
;
3210 /* Check the syntax of the parameters in a MACRO definition. Return
3211 false on failure. Set *N_PTR and *VARADIC_PTR as appropriate.
3213 '(' parm-list ',' last-parm ')'
3223 parse_params (cpp_reader
*pfile
, unsigned *n_ptr
, bool *varadic_ptr
)
3225 unsigned nparms
= 0;
3228 for (bool prev_ident
= false;;)
3230 const cpp_token
*token
= _cpp_lex_token (pfile
);
3232 switch (token
->type
)
3235 /* Allow/ignore comments in parameter lists if we are
3236 preserving comments in macro expansions. */
3237 if (!CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
3244 const char *const msgs
[5] =
3246 N_("expected parameter name, found \"%s\""),
3247 N_("expected ',' or ')', found \"%s\""),
3248 N_("expected parameter name before end of line"),
3249 N_("expected ')' before end of line"),
3250 N_("expected ')' after \"...\"")
3252 unsigned ix
= prev_ident
;
3253 const unsigned char *as_text
= NULL
;
3256 else if (token
->type
== CPP_EOF
)
3259 as_text
= cpp_token_as_text (pfile
, token
);
3260 cpp_error (pfile
, CPP_DL_ERROR
, msgs
[ix
], as_text
);
3265 if (prev_ident
|| *varadic_ptr
)
3269 if (!_cpp_save_parameter (pfile
, nparms
, token
->val
.node
.node
,
3270 token
->val
.node
.spelling
))
3275 case CPP_CLOSE_PAREN
:
3276 if (prev_ident
|| !nparms
|| *varadic_ptr
)
3284 if (!prev_ident
|| *varadic_ptr
)
3292 *varadic_ptr
= true;
3295 /* An ISO bare ellipsis. */
3296 _cpp_save_parameter (pfile
, nparms
,
3297 pfile
->spec_nodes
.n__VA_ARGS__
,
3298 pfile
->spec_nodes
.n__VA_ARGS__
);
3300 pfile
->state
.va_args_ok
= 1;
3301 if (! CPP_OPTION (pfile
, c99
)
3302 && CPP_OPTION (pfile
, cpp_pedantic
)
3303 && CPP_OPTION (pfile
, warn_variadic_macros
))
3305 (pfile
, CPP_W_VARIADIC_MACROS
,
3306 CPP_OPTION (pfile
, cplusplus
)
3307 ? N_("anonymous variadic macros were introduced in C++11")
3308 : N_("anonymous variadic macros were introduced in C99"));
3309 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
3310 && ! CPP_OPTION (pfile
, cplusplus
))
3311 cpp_error (pfile
, CPP_DL_WARNING
,
3312 "anonymous variadic macros were introduced in C99");
3314 else if (CPP_OPTION (pfile
, cpp_pedantic
)
3315 && CPP_OPTION (pfile
, warn_variadic_macros
))
3316 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
3317 CPP_OPTION (pfile
, cplusplus
)
3318 ? N_("ISO C++ does not permit named variadic macros")
3319 : N_("ISO C does not permit named variadic macros"));
3330 /* Lex a token from the expansion of MACRO, but mark parameters as we
3331 find them and warn of traditional stringification. */
3333 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
3335 macro
= (cpp_macro
*)_cpp_reserve_room (pfile
,
3336 sizeof (cpp_macro
) - sizeof (cpp_token
)
3337 + macro
->count
* sizeof (cpp_token
),
3338 sizeof (cpp_token
));
3339 cpp_token
*saved_cur_token
= pfile
->cur_token
;
3340 pfile
->cur_token
= ¯o
->exp
.tokens
[macro
->count
];
3341 cpp_token
*token
= _cpp_lex_direct (pfile
);
3342 pfile
->cur_token
= saved_cur_token
;
3344 /* Is this a parameter? */
3345 if (token
->type
== CPP_NAME
&& token
->val
.node
.node
->type
== NT_MACRO_ARG
)
3347 /* Morph into a parameter reference. */
3348 cpp_hashnode
*spelling
= token
->val
.node
.spelling
;
3349 token
->type
= CPP_MACRO_ARG
;
3350 token
->val
.macro_arg
.arg_no
= token
->val
.node
.node
->value
.arg_index
;
3351 token
->val
.macro_arg
.spelling
= spelling
;
3353 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
3354 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
3355 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
3361 create_iso_definition (cpp_reader
*pfile
)
3363 bool following_paste_op
= false;
3364 const char *paste_op_error_msg
=
3365 N_("'##' cannot appear at either end of a macro expansion");
3366 unsigned int num_extra_tokens
= 0;
3367 unsigned nparms
= 0;
3368 cpp_hashnode
**params
= NULL
;
3369 bool varadic
= false;
3371 cpp_macro
*macro
= NULL
;
3373 /* Look at the first token, to see if this is a function-like
3376 cpp_token
*saved_cur_token
= pfile
->cur_token
;
3377 pfile
->cur_token
= &first
;
3378 cpp_token
*token
= _cpp_lex_direct (pfile
);
3379 pfile
->cur_token
= saved_cur_token
;
3381 if (token
->flags
& PREV_WHITE
)
3382 /* Preceeded by space, must be part of expansion. */;
3383 else if (token
->type
== CPP_OPEN_PAREN
)
3385 /* An open-paren, get a parameter list. */
3386 if (!parse_params (pfile
, &nparms
, &varadic
))
3389 params
= (cpp_hashnode
**)_cpp_commit_buff
3390 (pfile
, sizeof (cpp_hashnode
*) * nparms
);
3393 else if (token
->type
!= CPP_EOF
3394 && !(token
->type
== CPP_COMMENT
3395 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
)))
3397 /* While ISO C99 requires whitespace before replacement text
3398 in a macro definition, ISO C90 with TC1 allows characters
3399 from the basic source character set there. */
3400 if (CPP_OPTION (pfile
, c99
))
3401 cpp_error (pfile
, CPP_DL_PEDWARN
,
3402 CPP_OPTION (pfile
, cplusplus
)
3403 ? N_("ISO C++11 requires whitespace after the macro name")
3404 : N_("ISO C99 requires whitespace after the macro name"));
3407 enum cpp_diagnostic_level warntype
= CPP_DL_WARNING
;
3408 switch (token
->type
)
3412 case CPP_OBJC_STRING
:
3413 /* '@' is not in basic character set. */
3414 warntype
= CPP_DL_PEDWARN
;
3417 /* Basic character set sans letters, digits and _. */
3418 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
3419 token
->val
.str
.text
[0]) == NULL
)
3420 warntype
= CPP_DL_PEDWARN
;
3423 /* All other tokens start with a character from basic
3427 cpp_error (pfile
, warntype
,
3428 "missing whitespace after the macro name");
3432 macro
= _cpp_new_macro (pfile
, cmk_macro
,
3433 _cpp_reserve_room (pfile
, 0, sizeof (cpp_macro
)));
3437 macro
->variadic
= varadic
;
3438 macro
->paramc
= nparms
;
3439 macro
->parm
.params
= params
;
3440 macro
->fun_like
= true;
3444 /* Preserve the token we peeked, there is already a single slot for it. */
3445 macro
->exp
.tokens
[0] = *token
;
3446 token
= ¯o
->exp
.tokens
[0];
3450 for (vaopt_state
vaopt_tracker (pfile
, macro
->variadic
, NULL
);; token
= NULL
)
3454 macro
= lex_expansion_token (pfile
, macro
);
3455 token
= ¯o
->exp
.tokens
[macro
->count
++];
3458 /* Check the stringifying # constraint 6.10.3.2.1 of
3459 function-like macros when lexing the subsequent token. */
3460 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
3462 if (token
->type
== CPP_MACRO_ARG
)
3464 if (token
->flags
& PREV_WHITE
)
3465 token
->flags
|= SP_PREV_WHITE
;
3466 if (token
[-1].flags
& DIGRAPH
)
3467 token
->flags
|= SP_DIGRAPH
;
3468 token
->flags
&= ~PREV_WHITE
;
3469 token
->flags
|= STRINGIFY_ARG
;
3470 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
3471 token
[-1] = token
[0];
3474 /* Let assembler get away with murder. */
3475 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
3477 cpp_error (pfile
, CPP_DL_ERROR
,
3478 "'#' is not followed by a macro parameter");
3483 if (token
->type
== CPP_EOF
)
3485 /* Paste operator constraint 6.10.3.3.1:
3486 Token-paste ##, can appear in both object-like and
3487 function-like macros, but not at the end. */
3488 if (following_paste_op
)
3490 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3493 if (!vaopt_tracker
.completed ())
3498 /* Paste operator constraint 6.10.3.3.1. */
3499 if (token
->type
== CPP_PASTE
)
3501 /* Token-paste ##, can appear in both object-like and
3502 function-like macros, but not at the beginning. */
3503 if (macro
->count
== 1)
3505 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3509 if (following_paste_op
)
3511 /* Consecutive paste operators. This one will be moved
3514 token
->val
.token_no
= macro
->count
- 1;
3518 /* Drop the paste operator. */
3520 token
[-1].flags
|= PASTE_LEFT
;
3521 if (token
->flags
& DIGRAPH
)
3522 token
[-1].flags
|= SP_DIGRAPH
;
3523 if (token
->flags
& PREV_WHITE
)
3524 token
[-1].flags
|= SP_PREV_WHITE
;
3526 following_paste_op
= true;
3529 following_paste_op
= false;
3531 if (vaopt_tracker
.update (token
) == vaopt_state::ERROR
)
3535 /* We're committed to winning now. */
3538 /* Don't count the CPP_EOF. */
3541 macro
= (cpp_macro
*)_cpp_commit_buff
3542 (pfile
, sizeof (cpp_macro
) - sizeof (cpp_token
)
3543 + sizeof (cpp_token
) * macro
->count
);
3545 /* Clear whitespace on first token. */
3547 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
3549 if (num_extra_tokens
)
3551 /* Place second and subsequent ## or %:%: tokens in sequences of
3552 consecutive such tokens at the end of the list to preserve
3553 information about where they appear, how they are spelt and
3554 whether they are preceded by whitespace without otherwise
3555 interfering with macro expansion. Remember, this is
3556 extremely rare, so efficiency is not a priority. */
3557 cpp_token
*temp
= (cpp_token
*)_cpp_reserve_room
3558 (pfile
, 0, num_extra_tokens
* sizeof (cpp_token
));
3559 unsigned extra_ix
= 0, norm_ix
= 0;
3560 cpp_token
*exp
= macro
->exp
.tokens
;
3561 for (unsigned ix
= 0; ix
!= macro
->count
; ix
++)
3562 if (exp
[ix
].type
== CPP_PASTE
)
3563 temp
[extra_ix
++] = exp
[ix
];
3565 exp
[norm_ix
++] = exp
[ix
];
3566 memcpy (&exp
[norm_ix
], temp
, num_extra_tokens
* sizeof (cpp_token
));
3568 /* Record there are extra tokens. */
3569 macro
->extra_tokens
= 1;
3573 pfile
->state
.va_args_ok
= 0;
3574 _cpp_unsave_parameters (pfile
, nparms
);
3576 return ok
? macro
: NULL
;
3580 _cpp_new_macro (cpp_reader
*pfile
, cpp_macro_kind kind
, void *placement
)
3582 cpp_macro
*macro
= (cpp_macro
*) placement
;
3584 macro
->line
= pfile
->directive_line
;
3585 macro
->parm
.params
= 0;
3588 macro
->variadic
= 0;
3589 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
3591 macro
->fun_like
= 0;
3592 macro
->extra_tokens
= 0;
3593 /* To suppress some diagnostics. */
3594 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
3601 /* Parse a macro and save its expansion. Returns nonzero on success. */
3603 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3607 if (CPP_OPTION (pfile
, traditional
))
3608 macro
= _cpp_create_trad_definition (pfile
);
3610 macro
= create_iso_definition (pfile
);
3615 if (cpp_macro_p (node
))
3617 if (CPP_OPTION (pfile
, warn_unused_macros
))
3618 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
3620 if (warn_of_redefinition (pfile
, node
, macro
))
3622 const enum cpp_warning_reason reason
3623 = (cpp_builtin_macro_p (node
) && !(node
->flags
& NODE_WARN
))
3624 ? CPP_W_BUILTIN_MACRO_REDEFINED
: CPP_W_NONE
;
3627 cpp_pedwarning_with_line (pfile
, reason
,
3628 pfile
->directive_line
, 0,
3629 "\"%s\" redefined", NODE_NAME (node
));
3631 if (warned
&& cpp_user_macro_p (node
))
3632 cpp_error_with_line (pfile
, CPP_DL_NOTE
,
3633 node
->value
.macro
->line
, 0,
3634 "this is the location of the previous definition");
3636 _cpp_free_definition (node
);
3639 /* Enter definition in hash table. */
3640 node
->type
= NT_USER_MACRO
;
3641 node
->value
.macro
= macro
;
3642 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
3643 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
3644 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3645 in the C standard, as something that one must use in C++.
3646 However DR#593 and C++11 indicate that they play no role in C++.
3647 We special-case them anyway. */
3648 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
3649 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
3650 node
->flags
|= NODE_WARN
;
3652 /* If user defines one of the conditional macros, remove the
3654 node
->flags
&= ~NODE_CONDITIONAL
;
3660 cpp_define_lazily (cpp_reader
*pfile
, cpp_hashnode
*node
, unsigned num
)
3662 cpp_macro
*macro
= node
->value
.macro
;
3664 gcc_checking_assert (pfile
->cb
.user_lazy_macro
&& macro
&& num
< UCHAR_MAX
);
3666 macro
->lazy
= num
+ 1;
3669 /* Notify the use of NODE in a macro-aware context (i.e. expanding it,
3670 or testing its existance). Also applies any lazy definition. */
3673 _cpp_notify_macro_use (cpp_reader
*pfile
, cpp_hashnode
*node
)
3675 node
->flags
|= NODE_USED
;
3680 cpp_macro
*macro
= node
->value
.macro
;
3683 pfile
->cb
.user_lazy_macro (pfile
, macro
, macro
->lazy
- 1);
3689 case NT_BUILTIN_MACRO
:
3690 if (pfile
->cb
.used_define
)
3691 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
3695 if (pfile
->cb
.used_undef
)
3696 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
3704 /* Warn if a token in STRING matches one of a function-like MACRO's
3707 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
3708 const cpp_string
*string
)
3710 unsigned int i
, len
;
3711 const uchar
*p
, *q
, *limit
;
3713 /* Loop over the string. */
3714 limit
= string
->text
+ string
->len
- 1;
3715 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
3717 /* Find the start of an identifier. */
3718 while (p
< limit
&& !is_idstart (*p
))
3721 /* Find the end of the identifier. */
3723 while (q
< limit
&& is_idchar (*q
))
3728 /* Loop over the function macro arguments to see if the
3729 identifier inside the string matches one of them. */
3730 for (i
= 0; i
< macro
->paramc
; i
++)
3732 const cpp_hashnode
*node
= macro
->parm
.params
[i
];
3734 if (NODE_LEN (node
) == len
3735 && !memcmp (p
, NODE_NAME (node
), len
))
3737 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
3738 "macro argument \"%s\" would be stringified in traditional C",
3746 /* Returns the name, arguments and expansion of a macro, in a format
3747 suitable to be read back in again, and therefore also for DWARF 2
3748 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3749 Caller is expected to generate the "#define" bit if needed. The
3750 returned text is temporary, and automatically freed later. */
3751 const unsigned char *
3752 cpp_macro_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3754 unsigned int i
, len
;
3755 unsigned char *buffer
;
3757 gcc_checking_assert (cpp_user_macro_p (node
));
3759 const cpp_macro
*macro
= node
->value
.macro
;
3761 /* Calculate length. */
3762 len
= NODE_LEN (node
) * 10 + 2; /* ' ' and NUL. */
3763 if (macro
->fun_like
)
3765 len
+= 4; /* "()" plus possible final ".." of named
3766 varargs (we have + 1 below). */
3767 for (i
= 0; i
< macro
->paramc
; i
++)
3768 len
+= NODE_LEN (macro
->parm
.params
[i
]) + 1; /* "," */
3771 /* This should match below where we fill in the buffer. */
3772 if (CPP_OPTION (pfile
, traditional
))
3773 len
+= _cpp_replacement_text_len (macro
);
3776 unsigned int count
= macro_real_token_count (macro
);
3777 for (i
= 0; i
< count
; i
++)
3779 const cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3781 if (token
->type
== CPP_MACRO_ARG
)
3782 len
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3784 len
+= cpp_token_len (token
);
3786 if (token
->flags
& STRINGIFY_ARG
)
3788 if (token
->flags
& PASTE_LEFT
)
3789 len
+= 3; /* " ##" */
3790 if (token
->flags
& PREV_WHITE
)
3795 if (len
> pfile
->macro_buffer_len
)
3797 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
3798 pfile
->macro_buffer
, len
);
3799 pfile
->macro_buffer_len
= len
;
3802 /* Fill in the buffer. Start with the macro name. */
3803 buffer
= pfile
->macro_buffer
;
3804 buffer
= _cpp_spell_ident_ucns (buffer
, node
);
3806 /* Parameter names. */
3807 if (macro
->fun_like
)
3810 for (i
= 0; i
< macro
->paramc
; i
++)
3812 cpp_hashnode
*param
= macro
->parm
.params
[i
];
3814 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
3816 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
3817 buffer
+= NODE_LEN (param
);
3820 if (i
+ 1 < macro
->paramc
)
3821 /* Don't emit a space after the comma here; we're trying
3822 to emit a Dwarf-friendly definition, and the Dwarf spec
3823 forbids spaces in the argument list. */
3825 else if (macro
->variadic
)
3826 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
3831 /* The Dwarf spec requires a space after the macro name, even if the
3832 definition is the empty string. */
3835 if (CPP_OPTION (pfile
, traditional
))
3836 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
3837 else if (macro
->count
)
3838 /* Expansion tokens. */
3840 unsigned int count
= macro_real_token_count (macro
);
3841 for (i
= 0; i
< count
; i
++)
3843 const cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3845 if (token
->flags
& PREV_WHITE
)
3847 if (token
->flags
& STRINGIFY_ARG
)
3850 if (token
->type
== CPP_MACRO_ARG
)
3853 NODE_NAME (token
->val
.macro_arg
.spelling
),
3854 NODE_LEN (token
->val
.macro_arg
.spelling
));
3855 buffer
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3858 buffer
= cpp_spell_token (pfile
, token
, buffer
, true);
3860 if (token
->flags
& PASTE_LEFT
)
3865 /* Next has PREV_WHITE; see _cpp_create_definition. */
3871 return pfile
->macro_buffer
;