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 /* A class for tracking __VA_OPT__ state while iterating over a
97 sequence of tokens. This is used during both macro definition and
103 /* Initialize the state tracker. ANY_ARGS is true if variable
104 arguments were provided to the macro invocation. */
105 vaopt_state (cpp_reader
*pfile
, bool is_variadic
, bool any_args
)
107 m_allowed (any_args
),
108 m_variadic (is_variadic
),
109 m_last_was_paste (false),
111 m_paste_location (0),
125 /* Given a token, update the state of this tracker and return a
126 boolean indicating whether the token should be be included in the
128 update_type
update (const cpp_token
*token
)
130 /* If the macro isn't variadic, just don't bother. */
134 if (token
->type
== CPP_NAME
135 && token
->val
.node
.node
== m_pfile
->spec_nodes
.n__VA_OPT__
)
139 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
140 "__VA_OPT__ may not appear in a __VA_OPT__");
144 m_location
= token
->src_loc
;
147 else if (m_state
== 1)
149 if (token
->type
!= CPP_OPEN_PAREN
)
151 cpp_error_at (m_pfile
, CPP_DL_ERROR
, m_location
,
152 "__VA_OPT__ must be followed by an "
159 else if (m_state
>= 2)
161 if (m_state
== 2 && token
->type
== CPP_PASTE
)
163 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
167 /* Advance states before further considering this token, in
168 case we see a close paren immediately after the open
173 bool was_paste
= m_last_was_paste
;
174 m_last_was_paste
= false;
175 if (token
->type
== CPP_PASTE
)
177 m_last_was_paste
= true;
178 m_paste_location
= token
->src_loc
;
180 else if (token
->type
== CPP_OPEN_PAREN
)
182 else if (token
->type
== CPP_CLOSE_PAREN
)
187 /* Saw the final paren. */
192 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
200 return m_allowed
? INCLUDE
: DROP
;
203 /* Nothing to do with __VA_OPT__. */
207 /* Ensure that any __VA_OPT__ was completed. If ok, return true.
208 Otherwise, issue an error and return false. */
211 if (m_variadic
&& m_state
!= 0)
212 cpp_error_at (m_pfile
, CPP_DL_ERROR
, m_location
,
213 "unterminated __VA_OPT__");
219 /* The cpp_reader. */
222 /* True if there were varargs. */
224 /* True if the macro is variadic. */
226 /* If true, the previous token was ##. This is used to detect when
227 a paste occurs at the end of the sequence. */
228 bool m_last_was_paste
;
230 /* The state variable:
232 1 means __VA_OPT__ seen, looking for "("
233 2 means "(" seen (so the next token can't be "##")
234 >= 3 means looking for ")", the number encodes the paren depth. */
237 /* The location of the paste token. */
238 location_t m_paste_location
;
240 /* Location of the __VA_OPT__ token. */
241 location_t m_location
;
244 /* Macro expansion. */
246 static int enter_macro_context (cpp_reader
*, cpp_hashnode
*,
247 const cpp_token
*, location_t
);
248 static int builtin_macro (cpp_reader
*, cpp_hashnode
*,
249 location_t
, location_t
);
250 static void push_ptoken_context (cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
251 const cpp_token
**, unsigned int);
252 static void push_extended_tokens_context (cpp_reader
*, cpp_hashnode
*,
253 _cpp_buff
*, location_t
*,
254 const cpp_token
**, unsigned int);
255 static _cpp_buff
*collect_args (cpp_reader
*, const cpp_hashnode
*,
256 _cpp_buff
**, unsigned *);
257 static cpp_context
*next_context (cpp_reader
*);
258 static const cpp_token
*padding_token (cpp_reader
*, const cpp_token
*);
259 static void expand_arg (cpp_reader
*, macro_arg
*);
260 static const cpp_token
*new_string_token (cpp_reader
*, uchar
*, unsigned int);
261 static const cpp_token
*stringify_arg (cpp_reader
*, macro_arg
*);
262 static void paste_all_tokens (cpp_reader
*, const cpp_token
*);
263 static bool paste_tokens (cpp_reader
*, location_t
,
264 const cpp_token
**, const cpp_token
*);
265 static void alloc_expanded_arg_mem (cpp_reader
*, macro_arg
*, size_t);
266 static void ensure_expanded_arg_room (cpp_reader
*, macro_arg
*, size_t, size_t *);
267 static void delete_macro_args (_cpp_buff
*, unsigned num_args
);
268 static void set_arg_token (macro_arg
*, const cpp_token
*,
270 enum macro_arg_token_kind
,
272 static const location_t
*get_arg_token_location (const macro_arg
*,
273 enum macro_arg_token_kind
);
274 static const cpp_token
**arg_token_ptr_at (const macro_arg
*,
276 enum macro_arg_token_kind
,
277 location_t
**virt_location
);
279 static void macro_arg_token_iter_init (macro_arg_token_iter
*, bool,
280 enum macro_arg_token_kind
,
283 static const cpp_token
*macro_arg_token_iter_get_token
284 (const macro_arg_token_iter
*it
);
285 static location_t macro_arg_token_iter_get_location
286 (const macro_arg_token_iter
*);
287 static void macro_arg_token_iter_forward (macro_arg_token_iter
*);
288 static _cpp_buff
*tokens_buff_new (cpp_reader
*, size_t,
290 static size_t tokens_buff_count (_cpp_buff
*);
291 static const cpp_token
**tokens_buff_last_token_ptr (_cpp_buff
*);
292 static inline const cpp_token
**tokens_buff_put_token_to (const cpp_token
**,
297 const line_map_macro
*,
300 static const cpp_token
**tokens_buff_add_token (_cpp_buff
*,
305 const line_map_macro
*,
307 static inline void tokens_buff_remove_last_token (_cpp_buff
*);
308 static void replace_args (cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
309 macro_arg
*, location_t
);
310 static _cpp_buff
*funlike_invocation_p (cpp_reader
*, cpp_hashnode
*,
311 _cpp_buff
**, unsigned *);
312 static cpp_macro
*create_iso_definition (cpp_reader
*);
314 /* #define directive parsing and handling. */
316 static cpp_macro
*lex_expansion_token (cpp_reader
*, cpp_macro
*);
317 static bool warn_of_redefinition (cpp_reader
*, cpp_hashnode
*,
319 static bool parse_params (cpp_reader
*, unsigned *, bool *);
320 static void check_trad_stringification (cpp_reader
*, const cpp_macro
*,
322 static bool reached_end_of_context (cpp_context
*);
323 static void consume_next_token_from_context (cpp_reader
*pfile
,
326 static const cpp_token
* cpp_get_token_1 (cpp_reader
*, location_t
*);
328 static cpp_hashnode
* macro_of_context (cpp_context
*context
);
330 static bool in_macro_expansion_p (cpp_reader
*pfile
);
332 /* Statistical counter tracking the number of macros that got
334 unsigned num_expanded_macros_counter
= 0;
335 /* Statistical counter tracking the total number tokens resulting
336 from macro expansion. */
337 unsigned num_macro_tokens_counter
= 0;
339 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
340 and not consume CPP_EOF. */
341 static const cpp_token
*
342 cpp_get_token_no_padding (cpp_reader
*pfile
)
346 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
347 if (ret
->type
== CPP_EOF
)
349 ret
= cpp_get_token (pfile
);
350 if (ret
->type
!= CPP_PADDING
)
355 /* Handle meeting "__has_include" builtin macro. */
358 builtin_has_include (cpp_reader
*pfile
, cpp_hashnode
*op
, bool has_next
)
362 if (!pfile
->state
.in_directive
)
363 cpp_error (pfile
, CPP_DL_ERROR
,
364 "\"%s\" used outside of preprocessing directive",
367 pfile
->state
.angled_headers
= true;
368 const cpp_token
*token
= cpp_get_token_no_padding (pfile
);
369 bool paren
= token
->type
== CPP_OPEN_PAREN
;
371 token
= cpp_get_token_no_padding (pfile
);
373 cpp_error (pfile
, CPP_DL_ERROR
,
374 "missing '(' before \"%s\" operand", NODE_NAME (op
));
375 pfile
->state
.angled_headers
= false;
377 bool bracket
= token
->type
!= CPP_STRING
;
379 if (token
->type
== CPP_STRING
|| token
->type
== CPP_HEADER_NAME
)
381 fname
= XNEWVEC (char, token
->val
.str
.len
- 1);
382 memcpy (fname
, token
->val
.str
.text
+ 1, token
->val
.str
.len
- 2);
383 fname
[token
->val
.str
.len
- 2] = '\0';
385 else if (token
->type
== CPP_LESS
)
386 fname
= _cpp_bracket_include (pfile
);
388 cpp_error (pfile
, CPP_DL_ERROR
,
389 "operator \"%s\" requires a header-name", NODE_NAME (op
));
393 /* Do not do the lookup if we're skipping, that's unnecessary
395 if (!pfile
->state
.skip_eval
396 && _cpp_has_header (pfile
, fname
, bracket
,
397 has_next
? IT_INCLUDE_NEXT
: IT_INCLUDE
))
404 && cpp_get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
405 cpp_error (pfile
, CPP_DL_ERROR
,
406 "missing ')' after \"%s\" operand", NODE_NAME (op
));
411 /* Emits a warning if NODE is a macro defined in the main file that
412 has not been used. */
414 _cpp_warn_if_unused_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
415 void *v ATTRIBUTE_UNUSED
)
417 if (cpp_user_macro_p (node
))
419 cpp_macro
*macro
= node
->value
.macro
;
422 && MAIN_FILE_P (linemap_check_ordinary
423 (linemap_lookup (pfile
->line_table
,
425 cpp_warning_with_line (pfile
, CPP_W_UNUSED_MACROS
, macro
->line
, 0,
426 "macro \"%s\" is not used", NODE_NAME (node
));
432 /* Allocates and returns a CPP_STRING token, containing TEXT of length
433 LEN, after null-terminating it. TEXT must be in permanent storage. */
434 static const cpp_token
*
435 new_string_token (cpp_reader
*pfile
, unsigned char *text
, unsigned int len
)
437 cpp_token
*token
= _cpp_temp_token (pfile
);
440 token
->type
= CPP_STRING
;
441 token
->val
.str
.len
= len
;
442 token
->val
.str
.text
= text
;
447 static const char * const monthnames
[] =
449 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
450 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
453 /* Helper function for builtin_macro. Returns the text generated by
456 _cpp_builtin_macro_text (cpp_reader
*pfile
, cpp_hashnode
*node
,
459 const uchar
*result
= NULL
;
460 linenum_type number
= 1;
462 switch (node
->value
.builtin
)
465 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
471 if (CPP_OPTION (pfile
, warn_date_time
))
472 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
473 "reproducible builds", NODE_NAME (node
));
475 cpp_buffer
*pbuffer
= cpp_get_buffer (pfile
);
476 if (pbuffer
->timestamp
== NULL
)
478 /* Initialize timestamp value of the assotiated file. */
479 struct _cpp_file
*file
= cpp_get_file (pbuffer
);
482 /* Generate __TIMESTAMP__ string, that represents
483 the date and time of the last modification
484 of the current source file. The string constant
485 looks like "Sun Sep 16 01:03:52 1973". */
486 struct tm
*tb
= NULL
;
487 struct stat
*st
= _cpp_get_file_stat (file
);
489 tb
= localtime (&st
->st_mtime
);
492 char *str
= asctime (tb
);
493 size_t len
= strlen (str
);
494 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
496 strcpy ((char *) buf
+ 1, str
);
498 pbuffer
->timestamp
= buf
;
502 cpp_errno (pfile
, CPP_DL_WARNING
,
503 "could not determine file timestamp");
504 pbuffer
->timestamp
= UC
"\"??? ??? ?? ??:??:?? ????\"";
508 result
= pbuffer
->timestamp
;
518 if (node
->value
.builtin
== BT_FILE
)
519 name
= linemap_get_expansion_filename (pfile
->line_table
,
520 pfile
->line_table
->highest_line
);
523 name
= _cpp_get_file_name (pfile
->main_file
);
527 if (pfile
->cb
.remap_filename
)
528 name
= pfile
->cb
.remap_filename (name
);
530 buf
= _cpp_unaligned_alloc (pfile
, len
* 2 + 3);
533 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
539 case BT_INCLUDE_LEVEL
:
540 /* The line map depth counts the primary source as level 1, but
541 historically __INCLUDE_DEPTH__ has called the primary source
543 number
= pfile
->line_table
->depth
- 1;
547 /* If __LINE__ is embedded in a macro, it must expand to the
548 line of the macro's invocation, not its definition.
549 Otherwise things like assert() will not work properly.
550 See WG14 N1911, WG21 N4220 sec 6.5, and PR 61861. */
551 if (CPP_OPTION (pfile
, traditional
))
552 loc
= pfile
->line_table
->highest_line
;
554 loc
= linemap_resolve_location (pfile
->line_table
, loc
,
555 LRK_MACRO_EXPANSION_POINT
, NULL
);
556 number
= linemap_get_expansion_line (pfile
->line_table
, loc
);
559 /* __STDC__ has the value 1 under normal circumstances.
560 However, if (a) we are in a system header, (b) the option
561 stdc_0_in_system_headers is true (set by target config), and
562 (c) we are not in strictly conforming mode, then it has the
563 value 0. (b) and (c) are already checked in cpp_init_builtins. */
565 if (cpp_in_system_header (pfile
))
573 if (CPP_OPTION (pfile
, warn_date_time
))
574 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
575 "reproducible builds", NODE_NAME (node
));
576 if (pfile
->date
== NULL
)
578 /* Allocate __DATE__ and __TIME__ strings from permanent
579 storage. We only do this once, and don't generate them
580 at init time, because time() and localtime() are very
581 slow on some systems. */
583 struct tm
*tb
= NULL
;
585 /* Set a reproducible timestamp for __DATE__ and __TIME__ macro
586 if SOURCE_DATE_EPOCH is defined. */
587 if (pfile
->source_date_epoch
== (time_t) -2
588 && pfile
->cb
.get_source_date_epoch
!= NULL
)
589 pfile
->source_date_epoch
= pfile
->cb
.get_source_date_epoch (pfile
);
591 if (pfile
->source_date_epoch
>= (time_t) 0)
592 tb
= gmtime (&pfile
->source_date_epoch
);
595 /* (time_t) -1 is a legitimate value for "number of seconds
596 since the Epoch", so we have to do a little dance to
597 distinguish that from a genuine error. */
600 if (tt
!= (time_t)-1 || errno
== 0)
601 tb
= localtime (&tt
);
606 pfile
->date
= _cpp_unaligned_alloc (pfile
,
607 sizeof ("\"Oct 11 1347\""));
608 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
609 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
612 pfile
->time
= _cpp_unaligned_alloc (pfile
,
613 sizeof ("\"12:34:56\""));
614 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
615 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
619 cpp_errno (pfile
, CPP_DL_WARNING
,
620 "could not determine date and time");
622 pfile
->date
= UC
"\"??? ?? ????\"";
623 pfile
->time
= UC
"\"??:??:??\"";
627 if (node
->value
.builtin
== BT_DATE
)
628 result
= pfile
->date
;
630 result
= pfile
->time
;
634 if (CPP_OPTION (pfile
, directives_only
) && pfile
->state
.in_directive
)
635 cpp_error (pfile
, CPP_DL_ERROR
,
636 "__COUNTER__ expanded inside directive with -fdirectives-only");
637 number
= pfile
->counter
++;
640 case BT_HAS_ATTRIBUTE
:
641 number
= pfile
->cb
.has_attribute (pfile
);
645 number
= pfile
->cb
.has_builtin (pfile
);
649 case BT_HAS_INCLUDE_NEXT
:
650 number
= builtin_has_include (pfile
, node
,
651 node
->value
.builtin
== BT_HAS_INCLUDE_NEXT
);
657 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
658 result
= _cpp_unaligned_alloc (pfile
, 21);
659 sprintf ((char *) result
, "%u", number
);
665 /* Convert builtin macros like __FILE__ to a token and push it on the
666 context stack. Also handles _Pragma, for which a new token may not
667 be created. Returns 1 if it generates a new token context, 0 to
668 return the token to the caller. LOC is the location of the expansion
669 point of the macro. */
671 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
672 location_t loc
, location_t expand_loc
)
678 if (node
->value
.builtin
== BT_PRAGMA
)
680 /* Don't interpret _Pragma within directives. The standard is
681 not clear on this, but to me this makes most sense. */
682 if (pfile
->state
.in_directive
)
685 return _cpp_do__Pragma (pfile
, loc
);
688 buf
= _cpp_builtin_macro_text (pfile
, node
, expand_loc
);
690 nbuf
= (char *) alloca (len
+ 1);
691 memcpy (nbuf
, buf
, len
);
694 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
695 _cpp_clean_line (pfile
);
697 /* Set pfile->cur_token as required by _cpp_lex_direct. */
698 pfile
->cur_token
= _cpp_temp_token (pfile
);
699 cpp_token
*token
= _cpp_lex_direct (pfile
);
700 /* We should point to the expansion point of the builtin macro. */
701 token
->src_loc
= loc
;
702 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
704 /* We are tracking tokens resulting from macro expansion.
705 Create a macro line map and generate a virtual location for
706 the token resulting from the expansion of the built-in
708 location_t
*virt_locs
= NULL
;
709 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
710 const line_map_macro
* map
=
711 linemap_enter_macro (pfile
->line_table
, node
, loc
, 1);
712 tokens_buff_add_token (token_buf
, virt_locs
, token
,
713 pfile
->line_table
->builtin_location
,
714 pfile
->line_table
->builtin_location
,
715 map
, /*macro_token_index=*/0);
716 push_extended_tokens_context (pfile
, node
, token_buf
, virt_locs
,
717 (const cpp_token
**)token_buf
->base
,
721 _cpp_push_token_context (pfile
, NULL
, token
, 1);
722 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
723 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
725 _cpp_pop_buffer (pfile
);
730 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
731 backslashes and double quotes. DEST must be of sufficient size.
732 Returns a pointer to the end of the string. */
734 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
743 /* Naked LF can appear in raw string literals */
760 /* Convert a token sequence ARG to a single string token according to
761 the rules of the ISO C #-operator. */
762 static const cpp_token
*
763 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
766 unsigned int i
, escape_it
, backslash_count
= 0;
767 const cpp_token
*source
= NULL
;
770 if (BUFF_ROOM (pfile
->u_buff
) < 3)
771 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
772 dest
= BUFF_FRONT (pfile
->u_buff
);
775 /* Loop, reading in the argument's tokens. */
776 for (i
= 0; i
< arg
->count
; i
++)
778 const cpp_token
*token
= arg
->first
[i
];
780 if (token
->type
== CPP_PADDING
)
783 || (!(source
->flags
& PREV_WHITE
)
784 && token
->val
.source
== NULL
))
785 source
= token
->val
.source
;
789 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
790 || token
->type
== CPP_WSTRING
|| token
->type
== CPP_WCHAR
791 || token
->type
== CPP_STRING32
|| token
->type
== CPP_CHAR32
792 || token
->type
== CPP_STRING16
|| token
->type
== CPP_CHAR16
793 || token
->type
== CPP_UTF8STRING
|| token
->type
== CPP_UTF8CHAR
794 || cpp_userdef_string_p (token
->type
)
795 || cpp_userdef_char_p (token
->type
));
797 /* Room for each char being written in octal, initial space and
798 final quote and NUL. */
799 len
= cpp_token_len (token
);
804 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
806 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
807 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
808 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
811 /* Leading white space? */
812 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
816 if (source
->flags
& PREV_WHITE
)
823 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
824 unsigned char *buf
= BUFF_FRONT (buff
);
825 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
826 dest
= cpp_quote_string (dest
, buf
, len
);
827 _cpp_release_buff (pfile
, buff
);
830 dest
= cpp_spell_token (pfile
, token
, dest
, true);
832 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
838 /* Ignore the final \ of invalid string literals. */
839 if (backslash_count
& 1)
841 cpp_error (pfile
, CPP_DL_WARNING
,
842 "invalid string literal, ignoring final '\\'");
846 /* Commit the memory, including NUL, and return the token. */
848 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
849 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
850 return new_string_token (pfile
, dest
- len
, len
);
853 /* Try to paste two tokens. On success, return nonzero. In any
854 case, PLHS is updated to point to the pasted token, which is
855 guaranteed to not have the PASTE_LEFT flag set. LOCATION is
856 the virtual location used for error reporting. */
858 paste_tokens (cpp_reader
*pfile
, location_t location
,
859 const cpp_token
**plhs
, const cpp_token
*rhs
)
861 unsigned char *buf
, *end
, *lhsend
;
865 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
866 buf
= (unsigned char *) alloca (len
);
867 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, true);
869 /* Avoid comment headers, since they are still processed in stage 3.
870 It is simpler to insert a space here, rather than modifying the
871 lexer to ignore comments in some circumstances. Simply returning
872 false doesn't work, since we want to clear the PASTE_LEFT flag. */
873 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
875 /* In one obscure case we might see padding here. */
876 if (rhs
->type
!= CPP_PADDING
)
877 end
= cpp_spell_token (pfile
, rhs
, end
, true);
880 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
881 _cpp_clean_line (pfile
);
883 /* Set pfile->cur_token as required by _cpp_lex_direct. */
884 pfile
->cur_token
= _cpp_temp_token (pfile
);
885 lhs
= _cpp_lex_direct (pfile
);
886 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
888 location_t saved_loc
= lhs
->src_loc
;
890 _cpp_pop_buffer (pfile
);
891 _cpp_backup_tokens (pfile
, 1);
894 /* We have to remove the PASTE_LEFT flag from the old lhs, but
895 we want to keep the new location. */
898 lhs
->src_loc
= saved_loc
;
899 lhs
->flags
&= ~PASTE_LEFT
;
901 /* Mandatory error for all apart from assembler. */
902 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
903 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
904 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
905 buf
, cpp_token_as_text (pfile
, rhs
));
910 _cpp_pop_buffer (pfile
);
914 /* Handles an arbitrarily long sequence of ## operators, with initial
915 operand LHS. This implementation is left-associative,
916 non-recursive, and finishes a paste before handling succeeding
917 ones. If a paste fails, we back up to the RHS of the failing ##
918 operator before pushing the context containing the result of prior
919 successful pastes, with the effect that the RHS appears in the
920 output stream after the pasted LHS normally. */
922 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
924 const cpp_token
*rhs
= NULL
;
925 cpp_context
*context
= pfile
->context
;
926 location_t virt_loc
= 0;
928 /* We are expanding a macro and we must have been called on a token
929 that appears at the left hand side of a ## operator. */
930 if (macro_of_context (pfile
->context
) == NULL
931 || (!(lhs
->flags
& PASTE_LEFT
)))
934 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
935 /* The caller must have called consume_next_token_from_context
936 right before calling us. That has incremented the pointer to
937 the current virtual location. So it now points to the location
938 of the token that comes right after *LHS. We want the
939 resulting pasted token to have the location of the current
941 virt_loc
= context
->c
.mc
->cur_virt_loc
[-1];
943 /* We are not tracking macro expansion. So the best virtual
944 location we can get here is the expansion point of the macro we
945 are currently expanding. */
946 virt_loc
= pfile
->invocation_location
;
950 /* Take the token directly from the current context. We can do
951 this, because we are in the replacement list of either an
952 object-like macro, or a function-like macro with arguments
953 inserted. In either case, the constraints to #define
954 guarantee we have at least one more token. */
955 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
956 rhs
= FIRST (context
).token
++;
957 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
958 rhs
= *FIRST (context
).ptoken
++;
959 else if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
961 /* So we are in presence of an extended token context, which
962 means that each token in this context has a virtual
963 location attached to it. So let's not forget to update
964 the pointer to the current virtual location of the
965 current token when we update the pointer to the current
968 rhs
= *FIRST (context
).ptoken
++;
969 /* context->c.mc must be non-null, as if we were not in a
970 macro context, context->tokens_kind could not be equal to
971 TOKENS_KIND_EXTENDED. */
972 context
->c
.mc
->cur_virt_loc
++;
975 if (rhs
->type
== CPP_PADDING
)
977 if (rhs
->flags
& PASTE_LEFT
)
980 if (!paste_tokens (pfile
, virt_loc
, &lhs
, rhs
))
983 while (rhs
->flags
& PASTE_LEFT
);
985 /* Put the resulting token in its own context. */
986 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
988 location_t
*virt_locs
= NULL
;
989 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
990 tokens_buff_add_token (token_buf
, virt_locs
, lhs
,
991 virt_loc
, 0, NULL
, 0);
992 push_extended_tokens_context (pfile
, context
->c
.mc
->macro_node
,
993 token_buf
, virt_locs
,
994 (const cpp_token
**)token_buf
->base
, 1);
997 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
1000 /* Returns TRUE if the number of arguments ARGC supplied in an
1001 invocation of the MACRO referenced by NODE is valid. An empty
1002 invocation to a macro with no parameters should pass ARGC as zero.
1004 Note that MACRO cannot necessarily be deduced from NODE, in case
1005 NODE was redefined whilst collecting arguments. */
1007 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
1009 if (argc
== macro
->paramc
)
1012 if (argc
< macro
->paramc
)
1014 /* In C++2a (here the va_opt flag is used), and also as a GNU
1015 extension, variadic arguments are allowed to not appear in
1016 the invocation at all.
1017 e.g. #define debug(format, args...) something
1020 This is exactly the same as if an empty variadic list had been
1021 supplied - debug("string", ). */
1023 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
1025 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
1026 && ! CPP_OPTION (pfile
, va_opt
))
1028 if (CPP_OPTION (pfile
, cplusplus
))
1029 cpp_error (pfile
, CPP_DL_PEDWARN
,
1030 "ISO C++11 requires at least one argument "
1031 "for the \"...\" in a variadic macro");
1033 cpp_error (pfile
, CPP_DL_PEDWARN
,
1034 "ISO C99 requires at least one argument "
1035 "for the \"...\" in a variadic macro");
1040 cpp_error (pfile
, CPP_DL_ERROR
,
1041 "macro \"%s\" requires %u arguments, but only %u given",
1042 NODE_NAME (node
), macro
->paramc
, argc
);
1045 cpp_error (pfile
, CPP_DL_ERROR
,
1046 "macro \"%s\" passed %u arguments, but takes just %u",
1047 NODE_NAME (node
), argc
, macro
->paramc
);
1049 if (macro
->line
> RESERVED_LOCATION_COUNT
)
1050 cpp_error_at (pfile
, CPP_DL_NOTE
, macro
->line
, "macro \"%s\" defined here",
1056 /* Reads and returns the arguments to a function-like macro
1057 invocation. Assumes the opening parenthesis has been processed.
1058 If there is an error, emits an appropriate diagnostic and returns
1059 NULL. Each argument is terminated by a CPP_EOF token, for the
1060 future benefit of expand_arg(). If there are any deferred
1061 #pragma directives among macro arguments, store pointers to the
1062 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
1064 What is returned is the buffer that contains the memory allocated
1065 to hold the macro arguments. NODE is the name of the macro this
1066 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
1067 set to the actual number of macro arguments allocated in the
1070 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
,
1071 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1073 _cpp_buff
*buff
, *base_buff
;
1075 macro_arg
*args
, *arg
;
1076 const cpp_token
*token
;
1078 location_t virt_loc
;
1079 bool track_macro_expansion_p
= CPP_OPTION (pfile
, track_macro_expansion
);
1080 unsigned num_args_alloced
= 0;
1082 macro
= node
->value
.macro
;
1084 argc
= macro
->paramc
;
1088 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
1089 #define ARG_TOKENS_EXTENT 1000
1091 buff
= _cpp_get_buff (pfile
, argc
* (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
1092 * sizeof (cpp_token
*)
1093 + sizeof (macro_arg
)));
1095 args
= (macro_arg
*) buff
->base
;
1096 memset (args
, 0, argc
* sizeof (macro_arg
));
1097 buff
->cur
= (unsigned char *) &args
[argc
];
1098 arg
= args
, argc
= 0;
1100 /* Collect the tokens making up each argument. We don't yet know
1101 how many arguments have been supplied, whether too many or too
1102 few. Hence the slightly bizarre usage of "argc" and "arg". */
1105 unsigned int paren_depth
= 0;
1106 unsigned int ntokens
= 0;
1107 unsigned virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
1111 arg
->first
= (const cpp_token
**) buff
->cur
;
1112 if (track_macro_expansion_p
)
1114 virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
1115 arg
->virt_locs
= XNEWVEC (location_t
,
1116 virt_locs_capacity
);
1121 /* Require space for 2 new tokens (including a CPP_EOF). */
1122 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
1124 buff
= _cpp_append_extend_buff (pfile
, buff
,
1126 * sizeof (cpp_token
*));
1127 arg
->first
= (const cpp_token
**) buff
->cur
;
1129 if (track_macro_expansion_p
1130 && (ntokens
+ 2 > virt_locs_capacity
))
1132 virt_locs_capacity
+= ARG_TOKENS_EXTENT
;
1133 arg
->virt_locs
= XRESIZEVEC (location_t
,
1135 virt_locs_capacity
);
1138 token
= cpp_get_token_1 (pfile
, &virt_loc
);
1140 if (token
->type
== CPP_PADDING
)
1142 /* Drop leading padding. */
1146 else if (token
->type
== CPP_OPEN_PAREN
)
1148 else if (token
->type
== CPP_CLOSE_PAREN
)
1150 if (paren_depth
-- == 0)
1153 else if (token
->type
== CPP_COMMA
)
1155 /* A comma does not terminate an argument within
1156 parentheses or as part of a variable argument. */
1157 if (paren_depth
== 0
1158 && ! (macro
->variadic
&& argc
== macro
->paramc
))
1161 else if (token
->type
== CPP_EOF
1162 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
1164 else if (token
->type
== CPP_PRAGMA
)
1166 cpp_token
*newtok
= _cpp_temp_token (pfile
);
1168 /* CPP_PRAGMA token lives in directive_result, which will
1169 be overwritten on the next directive. */
1174 if (*pragma_buff
== NULL
1175 || BUFF_ROOM (*pragma_buff
) < sizeof (cpp_token
*))
1178 if (*pragma_buff
== NULL
)
1180 = _cpp_get_buff (pfile
, 32 * sizeof (cpp_token
*));
1183 next
= *pragma_buff
;
1185 = _cpp_get_buff (pfile
,
1186 (BUFF_FRONT (*pragma_buff
)
1187 - (*pragma_buff
)->base
) * 2);
1188 (*pragma_buff
)->next
= next
;
1191 *(const cpp_token
**) BUFF_FRONT (*pragma_buff
) = token
;
1192 BUFF_FRONT (*pragma_buff
) += sizeof (cpp_token
*);
1193 if (token
->type
== CPP_PRAGMA_EOL
)
1195 token
= cpp_get_token_1 (pfile
, &virt_loc
);
1197 while (token
->type
!= CPP_EOF
);
1199 /* In deferred pragmas parsing_args and prevent_expansion
1200 had been changed, reset it. */
1201 pfile
->state
.parsing_args
= 2;
1202 pfile
->state
.prevent_expansion
= 1;
1204 if (token
->type
== CPP_EOF
)
1209 set_arg_token (arg
, token
, virt_loc
,
1210 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1211 CPP_OPTION (pfile
, track_macro_expansion
));
1215 /* Drop trailing padding. */
1216 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
1219 arg
->count
= ntokens
;
1220 set_arg_token (arg
, &pfile
->eof
, pfile
->eof
.src_loc
,
1221 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1222 CPP_OPTION (pfile
, track_macro_expansion
));
1224 /* Terminate the argument. Excess arguments loop back and
1225 overwrite the final legitimate argument, before failing. */
1226 if (argc
<= macro
->paramc
)
1228 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
1229 if (argc
!= macro
->paramc
)
1233 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
1235 if (token
->type
== CPP_EOF
)
1237 /* We still need the CPP_EOF to end directives, and to end
1238 pre-expansion of a macro argument. Step back is not
1239 unconditional, since we don't want to return a CPP_EOF to our
1240 callers at the end of an -include-d file. */
1241 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
1242 _cpp_backup_tokens (pfile
, 1);
1243 cpp_error (pfile
, CPP_DL_ERROR
,
1244 "unterminated argument list invoking macro \"%s\"",
1249 /* A single empty argument is counted as no argument. */
1250 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
1252 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
1254 /* GCC has special semantics for , ## b where b is a varargs
1255 parameter: we remove the comma if b was omitted entirely.
1256 If b was merely an empty argument, the comma is retained.
1257 If the macro takes just one (varargs) parameter, then we
1258 retain the comma only if we are standards conforming.
1260 If FIRST is NULL replace_args () swallows the comma. */
1261 if (macro
->variadic
&& (argc
< macro
->paramc
1262 || (argc
== 1 && args
[0].count
== 0
1263 && !CPP_OPTION (pfile
, std
))))
1264 args
[macro
->paramc
- 1].first
= NULL
;
1266 *num_args
= num_args_alloced
;
1271 /* An error occurred. */
1272 _cpp_release_buff (pfile
, base_buff
);
1276 /* Search for an opening parenthesis to the macro of NODE, in such a
1277 way that, if none is found, we don't lose the information in any
1278 intervening padding tokens. If we find the parenthesis, collect
1279 the arguments and return the buffer containing them. PRAGMA_BUFF
1280 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
1281 *NUM_ARGS is set to the number of arguments contained in the
1284 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
1285 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1287 const cpp_token
*token
, *padding
= NULL
;
1291 token
= cpp_get_token (pfile
);
1292 if (token
->type
!= CPP_PADDING
)
1295 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
1299 if (token
->type
== CPP_OPEN_PAREN
)
1301 pfile
->state
.parsing_args
= 2;
1302 return collect_args (pfile
, node
, pragma_buff
, num_args
);
1305 /* CPP_EOF can be the end of macro arguments, or the end of the
1306 file. We mustn't back up over the latter. Ugh. */
1307 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
1309 /* Back up. We may have skipped padding, in which case backing
1310 up more than one token when expanding macros is in general
1311 too difficult. We re-insert it in its own context. */
1312 _cpp_backup_tokens (pfile
, 1);
1314 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
1320 /* Return the real number of tokens in the expansion of MACRO. */
1321 static inline unsigned int
1322 macro_real_token_count (const cpp_macro
*macro
)
1324 if (__builtin_expect (!macro
->extra_tokens
, true))
1325 return macro
->count
;
1327 for (unsigned i
= macro
->count
; i
--;)
1328 if (macro
->exp
.tokens
[i
].type
!= CPP_PASTE
)
1334 /* Push the context of a macro with hash entry NODE onto the context
1335 stack. If we can successfully expand the macro, we push a context
1336 containing its yet-to-be-rescanned replacement list and return one.
1337 If there were additionally any unexpanded deferred #pragma
1338 directives among macro arguments, push another context containing
1339 the pragma tokens before the yet-to-be-rescanned replacement list
1340 and return two. Otherwise, we don't push a context and return
1341 zero. LOCATION is the location of the expansion point of the
1344 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
1345 const cpp_token
*result
, location_t location
)
1347 /* The presence of a macro invalidates a file's controlling macro. */
1348 pfile
->mi_valid
= false;
1350 pfile
->state
.angled_headers
= false;
1352 /* From here to when we push the context for the macro later down
1353 this function, we need to flag the fact that we are about to
1354 expand a macro. This is useful when -ftrack-macro-expansion is
1355 turned off. In that case, we need to record the location of the
1356 expansion point of the top-most macro we are about to to expand,
1357 into pfile->invocation_location. But we must not record any such
1358 location once the process of expanding the macro starts; that is,
1359 we must not do that recording between now and later down this
1360 function where set this flag to FALSE. */
1361 pfile
->about_to_expand_macro_p
= true;
1363 if (cpp_user_macro_p (node
))
1365 cpp_macro
*macro
= node
->value
.macro
;
1366 _cpp_buff
*pragma_buff
= NULL
;
1368 if (macro
->fun_like
)
1371 unsigned num_args
= 0;
1373 pfile
->state
.prevent_expansion
++;
1374 pfile
->keep_tokens
++;
1375 pfile
->state
.parsing_args
= 1;
1376 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
,
1378 pfile
->state
.parsing_args
= 0;
1379 pfile
->keep_tokens
--;
1380 pfile
->state
.prevent_expansion
--;
1384 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
1385 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1386 "function-like macro \"%s\" must be used with arguments in traditional C",
1390 _cpp_release_buff (pfile
, pragma_buff
);
1392 pfile
->about_to_expand_macro_p
= false;
1396 if (macro
->paramc
> 0)
1397 replace_args (pfile
, node
, macro
,
1398 (macro_arg
*) buff
->base
,
1400 /* Free the memory used by the arguments of this
1401 function-like macro. This memory has been allocated by
1402 funlike_invocation_p and by replace_args. */
1403 delete_macro_args (buff
, num_args
);
1406 /* Disable the macro within its expansion. */
1407 node
->flags
|= NODE_DISABLED
;
1409 /* Laziness can only affect the expansion tokens of the macro,
1410 not its fun-likeness or parameters. */
1411 _cpp_maybe_notify_macro_use (pfile
, node
);
1413 pfile
->cb
.used (pfile
, location
, node
);
1417 if (macro
->paramc
== 0)
1419 unsigned tokens_count
= macro_real_token_count (macro
);
1420 if (CPP_OPTION (pfile
, track_macro_expansion
))
1423 const cpp_token
*src
= macro
->exp
.tokens
;
1424 const line_map_macro
*map
;
1425 location_t
*virt_locs
= NULL
;
1426 _cpp_buff
*macro_tokens
1427 = tokens_buff_new (pfile
, tokens_count
, &virt_locs
);
1429 /* Create a macro map to record the locations of the
1430 tokens that are involved in the expansion. LOCATION
1431 is the location of the macro expansion point. */
1432 map
= linemap_enter_macro (pfile
->line_table
,
1433 node
, location
, tokens_count
);
1434 for (i
= 0; i
< tokens_count
; ++i
)
1436 tokens_buff_add_token (macro_tokens
, virt_locs
,
1438 src
->src_loc
, map
, i
);
1441 push_extended_tokens_context (pfile
, node
,
1444 (const cpp_token
**)
1449 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
,
1451 num_macro_tokens_counter
+= tokens_count
;
1456 if (!pfile
->state
.in_directive
)
1457 _cpp_push_token_context (pfile
, NULL
,
1458 padding_token (pfile
, result
), 1);
1461 unsigned tokens_count
;
1462 _cpp_buff
*tail
= pragma_buff
->next
;
1463 pragma_buff
->next
= NULL
;
1464 tokens_count
= ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
1465 - (const cpp_token
**) pragma_buff
->base
);
1466 push_ptoken_context (pfile
, NULL
, pragma_buff
,
1467 (const cpp_token
**) pragma_buff
->base
,
1470 if (!CPP_OPTION (pfile
, track_macro_expansion
))
1471 num_macro_tokens_counter
+= tokens_count
;
1474 while (pragma_buff
!= NULL
);
1475 pfile
->about_to_expand_macro_p
= false;
1479 pfile
->about_to_expand_macro_p
= false;
1483 pfile
->about_to_expand_macro_p
= false;
1484 /* Handle built-in macros and the _Pragma operator. */
1486 location_t expand_loc
;
1488 if (/* The top-level macro invocation that triggered the expansion
1489 we are looking at is with a function-like user macro ... */
1490 cpp_fun_like_macro_p (pfile
->top_most_macro_node
)
1491 /* ... and we are tracking the macro expansion. */
1492 && CPP_OPTION (pfile
, track_macro_expansion
))
1493 /* Then the location of the end of the macro invocation is the
1494 location of the expansion point of this macro. */
1495 expand_loc
= location
;
1497 /* Otherwise, the location of the end of the macro invocation is
1498 the location of the expansion point of that top-level macro
1500 expand_loc
= pfile
->invocation_location
;
1502 return builtin_macro (pfile
, node
, location
, expand_loc
);
1506 /* De-allocate the memory used by BUFF which is an array of instances
1507 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1510 delete_macro_args (_cpp_buff
*buff
, unsigned num_args
)
1512 macro_arg
*macro_args
;
1518 macro_args
= (macro_arg
*) buff
->base
;
1520 /* Walk instances of macro_arg to free their expanded tokens as well
1521 as their macro_arg::virt_locs members. */
1522 for (i
= 0; i
< num_args
; ++i
)
1524 if (macro_args
[i
].expanded
)
1526 free (macro_args
[i
].expanded
);
1527 macro_args
[i
].expanded
= NULL
;
1529 if (macro_args
[i
].virt_locs
)
1531 free (macro_args
[i
].virt_locs
);
1532 macro_args
[i
].virt_locs
= NULL
;
1534 if (macro_args
[i
].expanded_virt_locs
)
1536 free (macro_args
[i
].expanded_virt_locs
);
1537 macro_args
[i
].expanded_virt_locs
= NULL
;
1540 _cpp_free_buff (buff
);
1543 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1544 to set, LOCATION is its virtual location. "Virtual" location means
1545 the location that encodes loci across macro expansion. Otherwise
1546 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1547 argument ARG is supposed to contain. Note that ARG must be
1548 tailored so that it has enough room to contain INDEX + 1 numbers of
1549 tokens, at least. */
1551 set_arg_token (macro_arg
*arg
, const cpp_token
*token
,
1552 location_t location
, size_t index
,
1553 enum macro_arg_token_kind kind
,
1554 bool track_macro_exp_p
)
1556 const cpp_token
**token_ptr
;
1557 location_t
*loc
= NULL
;
1560 arg_token_ptr_at (arg
, index
, kind
,
1561 track_macro_exp_p
? &loc
: NULL
);
1566 /* We can't set the location of a stringified argument
1567 token and we can't set any location if we aren't tracking
1568 macro expansion locations. */
1569 gcc_checking_assert (kind
!= MACRO_ARG_TOKEN_STRINGIFIED
1570 && track_macro_exp_p
);
1575 /* Get the pointer to the location of the argument token of the
1576 function-like macro argument ARG. This function must be called
1577 only when we -ftrack-macro-expansion is on. */
1578 static const location_t
*
1579 get_arg_token_location (const macro_arg
*arg
,
1580 enum macro_arg_token_kind kind
)
1582 const location_t
*loc
= NULL
;
1583 const cpp_token
**token_ptr
=
1584 arg_token_ptr_at (arg
, 0, kind
, (location_t
**) &loc
);
1586 if (token_ptr
== NULL
)
1592 /* Return the pointer to the INDEXth token of the macro argument ARG.
1593 KIND specifies the kind of token the macro argument ARG contains.
1594 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1595 of the virtual location of the returned token if the
1596 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1597 spelling location of the returned token. */
1598 static const cpp_token
**
1599 arg_token_ptr_at (const macro_arg
*arg
, size_t index
,
1600 enum macro_arg_token_kind kind
,
1601 location_t
**virt_location
)
1603 const cpp_token
**tokens_ptr
= NULL
;
1607 case MACRO_ARG_TOKEN_NORMAL
:
1608 tokens_ptr
= arg
->first
;
1610 case MACRO_ARG_TOKEN_STRINGIFIED
:
1611 tokens_ptr
= (const cpp_token
**) &arg
->stringified
;
1613 case MACRO_ARG_TOKEN_EXPANDED
:
1614 tokens_ptr
= arg
->expanded
;
1618 if (tokens_ptr
== NULL
)
1619 /* This can happen for e.g, an empty token argument to a
1620 funtion-like macro. */
1625 if (kind
== MACRO_ARG_TOKEN_NORMAL
)
1626 *virt_location
= &arg
->virt_locs
[index
];
1627 else if (kind
== MACRO_ARG_TOKEN_EXPANDED
)
1628 *virt_location
= &arg
->expanded_virt_locs
[index
];
1629 else if (kind
== MACRO_ARG_TOKEN_STRINGIFIED
)
1631 (location_t
*) &tokens_ptr
[index
]->src_loc
;
1633 return &tokens_ptr
[index
];
1636 /* Initialize an iterator so that it iterates over the tokens of a
1637 function-like macro argument. KIND is the kind of tokens we want
1638 ITER to iterate over. TOKEN_PTR points the first token ITER will
1641 macro_arg_token_iter_init (macro_arg_token_iter
*iter
,
1642 bool track_macro_exp_p
,
1643 enum macro_arg_token_kind kind
,
1644 const macro_arg
*arg
,
1645 const cpp_token
**token_ptr
)
1647 iter
->track_macro_exp_p
= track_macro_exp_p
;
1649 iter
->token_ptr
= token_ptr
;
1650 /* Unconditionally initialize this so that the compiler doesn't warn
1651 about iter->location_ptr being possibly uninitialized later after
1652 this code has been inlined somewhere. */
1653 iter
->location_ptr
= NULL
;
1654 if (track_macro_exp_p
)
1655 iter
->location_ptr
= get_arg_token_location (arg
, kind
);
1657 iter
->num_forwards
= 0;
1658 if (track_macro_exp_p
1659 && token_ptr
!= NULL
1660 && iter
->location_ptr
== NULL
)
1665 /* Move the iterator one token forward. Note that if IT was
1666 initialized on an argument that has a stringified token, moving it
1667 forward doesn't make sense as a stringified token is essentially one
1670 macro_arg_token_iter_forward (macro_arg_token_iter
*it
)
1674 case MACRO_ARG_TOKEN_NORMAL
:
1675 case MACRO_ARG_TOKEN_EXPANDED
:
1677 if (it
->track_macro_exp_p
)
1680 case MACRO_ARG_TOKEN_STRINGIFIED
:
1682 if (it
->num_forwards
> 0)
1693 /* Return the token pointed to by the iterator. */
1694 static const cpp_token
*
1695 macro_arg_token_iter_get_token (const macro_arg_token_iter
*it
)
1698 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1699 && it
->num_forwards
> 0)
1702 if (it
->token_ptr
== NULL
)
1704 return *it
->token_ptr
;
1707 /* Return the location of the token pointed to by the iterator.*/
1709 macro_arg_token_iter_get_location (const macro_arg_token_iter
*it
)
1712 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1713 && it
->num_forwards
> 0)
1716 if (it
->track_macro_exp_p
)
1717 return *it
->location_ptr
;
1719 return (*it
->token_ptr
)->src_loc
;
1722 /* Return the index of a token [resulting from macro expansion] inside
1723 the total list of tokens resulting from a given macro
1724 expansion. The index can be different depending on whether if we
1725 want each tokens resulting from function-like macro arguments
1726 expansion to have a different location or not.
1728 E.g, consider this function-like macro:
1732 Then consider us "calling" it (and thus expanding it) like:
1736 It will be expanded into:
1740 Let's consider the case of the token '4'.
1742 Its index can be 2 (it's the third token of the set of tokens
1743 resulting from the expansion) or it can be 0 if we consider that
1744 all tokens resulting from the expansion of the argument "1+2" have
1745 the same index, which is 0. In this later case, the index of token
1746 '-' would then be 1 and the index of token '3' would be 2.
1748 The later case is useful to use less memory e.g, for the case of
1749 the user using the option -ftrack-macro-expansion=1.
1751 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1752 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1753 parameter (inside the macro replacement list) that corresponds to
1754 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1757 If we refer to the example above, for the '4' argument token,
1758 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1759 would be set to the token 'x', in the replacement list "x - 3" of
1762 This is a subroutine of replace_args. */
1763 inline static unsigned
1764 expanded_token_index (cpp_reader
*pfile
, cpp_macro
*macro
,
1765 const cpp_token
*cur_replacement_token
,
1766 unsigned absolute_token_index
)
1768 if (CPP_OPTION (pfile
, track_macro_expansion
) > 1)
1769 return absolute_token_index
;
1770 return cur_replacement_token
- macro
->exp
.tokens
;
1773 /* Copy whether PASTE_LEFT is set from SRC to *PASTE_FLAG. */
1776 copy_paste_flag (cpp_reader
*pfile
, const cpp_token
**paste_flag
,
1777 const cpp_token
*src
)
1779 cpp_token
*token
= _cpp_temp_token (pfile
);
1780 token
->type
= (*paste_flag
)->type
;
1781 token
->val
= (*paste_flag
)->val
;
1782 if (src
->flags
& PASTE_LEFT
)
1783 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1785 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1786 *paste_flag
= token
;
1789 /* True IFF the last token emitted into BUFF (if any) is PTR. */
1792 last_token_is (_cpp_buff
*buff
, const cpp_token
**ptr
)
1794 return (ptr
&& tokens_buff_last_token_ptr (buff
) == ptr
);
1797 /* Replace the parameters in a function-like macro of NODE with the
1798 actual ARGS, and place the result in a newly pushed token context.
1799 Expand each argument before replacing, unless it is operated upon
1800 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1801 the expansion point of the macro. E.g, the location of the
1802 function-like macro invocation. */
1804 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
,
1805 macro_arg
*args
, location_t expansion_point_loc
)
1807 unsigned int i
, total
;
1808 const cpp_token
*src
, *limit
;
1809 const cpp_token
**first
= NULL
;
1811 _cpp_buff
*buff
= NULL
;
1812 location_t
*virt_locs
= NULL
;
1813 unsigned int exp_count
;
1814 const line_map_macro
*map
= NULL
;
1815 int track_macro_exp
;
1817 /* First, fully macro-expand arguments, calculating the number of
1818 tokens in the final expansion as we go. The ordering of the if
1819 statements below is subtle; we must handle stringification before
1822 /* EXP_COUNT is the number of tokens in the macro replacement
1823 list. TOTAL is the number of tokens /after/ macro parameters
1824 have been replaced by their arguments. */
1825 exp_count
= macro_real_token_count (macro
);
1827 limit
= macro
->exp
.tokens
+ exp_count
;
1829 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1830 if (src
->type
== CPP_MACRO_ARG
)
1832 /* Leading and trailing padding tokens. */
1834 /* Account for leading and padding tokens in exp_count too.
1835 This is going to be important later down this function,
1836 when we want to handle the case of (track_macro_exp <
1840 /* We have an argument. If it is not being stringified or
1841 pasted it is macro-replaced before insertion. */
1842 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
1844 if (src
->flags
& STRINGIFY_ARG
)
1846 if (!arg
->stringified
)
1847 arg
->stringified
= stringify_arg (pfile
, arg
);
1849 else if ((src
->flags
& PASTE_LEFT
)
1850 || (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
1851 total
+= arg
->count
- 1;
1855 expand_arg (pfile
, arg
);
1856 total
+= arg
->expanded_count
- 1;
1860 /* When the compiler is called with the -ftrack-macro-expansion
1861 flag, we need to keep track of the location of each token that
1862 results from macro expansion.
1864 A token resulting from macro expansion is not a new token. It is
1865 simply the same token as the token coming from the macro
1866 definition. The new things that are allocated are the buffer
1867 that holds the tokens resulting from macro expansion and a new
1868 location that records many things like the locus of the expansion
1869 point as well as the original locus inside the definition of the
1870 macro. This location is called a virtual location.
1872 So the buffer BUFF holds a set of cpp_token*, and the buffer
1873 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1875 Both of these two buffers are going to be hung off of the macro
1876 context, when the latter is pushed. The memory allocated to
1877 store the tokens and their locations is going to be freed once
1878 the context of macro expansion is popped.
1880 As far as tokens are concerned, the memory overhead of
1881 -ftrack-macro-expansion is proportional to the number of
1882 macros that get expanded multiplied by sizeof (location_t).
1883 The good news is that extra memory gets freed when the macro
1884 context is freed, i.e shortly after the macro got expanded. */
1886 /* Is the -ftrack-macro-expansion flag in effect? */
1887 track_macro_exp
= CPP_OPTION (pfile
, track_macro_expansion
);
1889 /* Now allocate memory space for tokens and locations resulting from
1890 the macro expansion, copy the tokens and replace the arguments.
1891 This memory must be freed when the context of the macro MACRO is
1893 buff
= tokens_buff_new (pfile
, total
, track_macro_exp
? &virt_locs
: NULL
);
1895 first
= (const cpp_token
**) buff
->base
;
1897 /* Create a macro map to record the locations of the tokens that are
1898 involved in the expansion. Note that the expansion point is set
1899 to the location of the closing parenthesis. Otherwise, the
1900 subsequent map created for the first token that comes after the
1901 macro map might have a wrong line number. That would lead to
1902 tokens with wrong line numbers after the macro expansion. This
1903 adds up to the memory overhead of the -ftrack-macro-expansion
1904 flag; for every macro that is expanded, a "macro map" is
1906 if (track_macro_exp
)
1908 int num_macro_tokens
= total
;
1909 if (track_macro_exp
< 2)
1910 /* Then the number of macro tokens won't take in account the
1911 fact that function-like macro arguments can expand to
1912 multiple tokens. This is to save memory at the expense of
1915 Suppose we have #define SQUARE(A) A * A
1917 And then we do SQUARE(2+3)
1919 Then the tokens 2, +, 3, will have the same location,
1920 saying they come from the expansion of the argument A. */
1921 num_macro_tokens
= exp_count
;
1922 map
= linemap_enter_macro (pfile
->line_table
, node
,
1923 expansion_point_loc
,
1927 vaopt_state
vaopt_tracker (pfile
, macro
->variadic
,
1928 args
[macro
->paramc
- 1].count
> 0);
1929 const cpp_token
**vaopt_start
= NULL
;
1930 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1932 unsigned int arg_tokens_count
;
1933 macro_arg_token_iter from
;
1934 const cpp_token
**paste_flag
= NULL
;
1935 const cpp_token
**tmp_token_ptr
;
1937 /* __VA_OPT__ handling. */
1938 vaopt_state::update_type vostate
= vaopt_tracker
.update (src
);
1939 if (vostate
!= vaopt_state::INCLUDE
)
1941 if (vostate
== vaopt_state::BEGIN
)
1943 /* Padding on the left of __VA_OPT__ (unless RHS of ##). */
1944 if (src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
1946 const cpp_token
*t
= padding_token (pfile
, src
);
1947 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
1948 /* Allocate a virtual location for the padding token and
1949 append the token and its location to BUFF and
1951 tokens_buff_add_token (buff
, virt_locs
, t
,
1952 t
->src_loc
, t
->src_loc
,
1955 vaopt_start
= tokens_buff_last_token_ptr (buff
);
1957 else if (vostate
== vaopt_state::END
)
1959 const cpp_token
**start
= vaopt_start
;
1962 /* Remove any tail padding from inside the __VA_OPT__. */
1963 paste_flag
= tokens_buff_last_token_ptr (buff
);
1964 while (paste_flag
&& paste_flag
!= start
1965 && (*paste_flag
)->type
== CPP_PADDING
)
1967 tokens_buff_remove_last_token (buff
);
1968 paste_flag
= tokens_buff_last_token_ptr (buff
);
1971 if (src
->flags
& PASTE_LEFT
)
1973 /* With a non-empty __VA_OPT__ on the LHS of ##, the last
1974 token should be flagged PASTE_LEFT. */
1975 if (paste_flag
&& (*paste_flag
)->type
!= CPP_PADDING
)
1976 copy_paste_flag (pfile
, paste_flag
, src
);
1980 /* Otherwise, avoid paste on RHS, __VA_OPT__(c)d or
1981 __VA_OPT__(c)__VA_OPT__(d). */
1982 const cpp_token
*t
= &pfile
->avoid_paste
;
1983 tokens_buff_add_token (buff
, virt_locs
,
1984 t
, t
->src_loc
, t
->src_loc
,
1991 if (src
->type
!= CPP_MACRO_ARG
)
1993 /* Allocate a virtual location for token SRC, and add that
1994 token and its virtual location into the buffers BUFF and
1996 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
1997 tokens_buff_add_token (buff
, virt_locs
, src
,
1998 src
->src_loc
, src
->src_loc
,
2005 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
2006 /* SRC is a macro parameter that we need to replace with its
2007 corresponding argument. So at some point we'll need to
2008 iterate over the tokens of the macro argument and copy them
2009 into the "place" now holding the correspondig macro
2010 parameter. We are going to use the iterator type
2011 macro_argo_token_iter to handle that iterating. The 'if'
2012 below is to initialize the iterator depending on the type of
2013 tokens the macro argument has. It also does some adjustment
2014 related to padding tokens and some pasting corner cases. */
2015 if (src
->flags
& STRINGIFY_ARG
)
2017 arg_tokens_count
= 1;
2018 macro_arg_token_iter_init (&from
,
2020 track_macro_expansion
),
2021 MACRO_ARG_TOKEN_STRINGIFIED
,
2022 arg
, &arg
->stringified
);
2024 else if (src
->flags
& PASTE_LEFT
)
2026 arg_tokens_count
= arg
->count
;
2027 macro_arg_token_iter_init (&from
,
2029 track_macro_expansion
),
2030 MACRO_ARG_TOKEN_NORMAL
,
2033 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
2036 arg_tokens_count
= arg
->count
;
2037 macro_arg_token_iter_init (&from
,
2039 track_macro_expansion
),
2040 MACRO_ARG_TOKEN_NORMAL
,
2043 num_toks
= tokens_buff_count (buff
);
2047 /* So the current parameter token is pasted to the previous
2048 token in the replacement list. Let's look at what
2049 we have as previous and current arguments. */
2051 /* This is the previous argument's token ... */
2052 tmp_token_ptr
= tokens_buff_last_token_ptr (buff
);
2054 if ((*tmp_token_ptr
)->type
== CPP_COMMA
2056 && src
->val
.macro_arg
.arg_no
== macro
->paramc
)
2058 /* ... which is a comma; and the current parameter
2059 is the last parameter of a variadic function-like
2060 macro. If the argument to the current last
2061 parameter is NULL, then swallow the comma,
2062 otherwise drop the paste flag. */
2063 if (macro_arg_token_iter_get_token (&from
) == NULL
)
2064 tokens_buff_remove_last_token (buff
);
2066 paste_flag
= tmp_token_ptr
;
2068 /* Remove the paste flag if the RHS is a placemarker, unless the
2069 previous emitted token is at the beginning of __VA_OPT__;
2070 placemarkers within __VA_OPT__ are ignored in that case. */
2071 else if (arg_tokens_count
== 0
2072 && tmp_token_ptr
!= vaopt_start
)
2073 paste_flag
= tmp_token_ptr
;
2078 arg_tokens_count
= arg
->expanded_count
;
2079 macro_arg_token_iter_init (&from
,
2081 track_macro_expansion
),
2082 MACRO_ARG_TOKEN_EXPANDED
,
2083 arg
, arg
->expanded
);
2085 if (last_token_is (buff
, vaopt_start
))
2087 /* We're expanding an arg at the beginning of __VA_OPT__.
2089 while (arg_tokens_count
)
2091 const cpp_token
*t
= macro_arg_token_iter_get_token (&from
);
2092 if (t
->type
!= CPP_PADDING
)
2094 macro_arg_token_iter_forward (&from
);
2100 /* Padding on the left of an argument (unless RHS of ##). */
2101 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
2102 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
)
2103 && !last_token_is (buff
, vaopt_start
))
2105 const cpp_token
*t
= padding_token (pfile
, src
);
2106 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2107 /* Allocate a virtual location for the padding token and
2108 append the token and its location to BUFF and
2110 tokens_buff_add_token (buff
, virt_locs
, t
,
2111 t
->src_loc
, t
->src_loc
,
2115 if (arg_tokens_count
)
2117 /* So now we've got the number of tokens that make up the
2118 argument that is going to replace the current parameter
2119 in the macro's replacement list. */
2121 for (j
= 0; j
< arg_tokens_count
; ++j
)
2123 /* So if track_macro_exp is < 2, the user wants to
2124 save extra memory while tracking macro expansion
2125 locations. So in that case here is what we do:
2127 Suppose we have #define SQUARE(A) A * A
2129 And then we do SQUARE(2+3)
2131 Then the tokens 2, +, 3, will have the same location,
2132 saying they come from the expansion of the argument
2135 So that means we are going to ignore the COUNT tokens
2136 resulting from the expansion of the current macro
2137 argument. In other words all the ARG_TOKENS_COUNT tokens
2138 resulting from the expansion of the macro argument will
2139 have the index I. Normally, each of those tokens should
2141 unsigned token_index
= i
;
2143 if (track_macro_exp
> 1)
2146 index
= expanded_token_index (pfile
, macro
, src
, token_index
);
2147 tokens_buff_add_token (buff
, virt_locs
,
2148 macro_arg_token_iter_get_token (&from
),
2149 macro_arg_token_iter_get_location (&from
),
2150 src
->src_loc
, map
, index
);
2151 macro_arg_token_iter_forward (&from
);
2154 /* With a non-empty argument on the LHS of ##, the last
2155 token should be flagged PASTE_LEFT. */
2156 if (src
->flags
& PASTE_LEFT
)
2158 = (const cpp_token
**) tokens_buff_last_token_ptr (buff
);
2160 else if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, c99
)
2161 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2163 if (CPP_OPTION (pfile
, cplusplus
))
2164 cpp_pedwarning (pfile
, CPP_W_PEDANTIC
,
2165 "invoking macro %s argument %d: "
2166 "empty macro arguments are undefined"
2168 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2169 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
))
2170 cpp_pedwarning (pfile
,
2171 CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2172 ? CPP_W_C90_C99_COMPAT
: CPP_W_PEDANTIC
,
2173 "invoking macro %s argument %d: "
2174 "empty macro arguments are undefined"
2176 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2178 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2179 && ! CPP_OPTION (pfile
, cplusplus
)
2180 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2181 cpp_warning (pfile
, CPP_W_C90_C99_COMPAT
,
2182 "invoking macro %s argument %d: "
2183 "empty macro arguments are undefined"
2185 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2187 /* Avoid paste on RHS (even case count == 0). */
2188 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
)
2189 && !last_token_is (buff
, vaopt_start
))
2191 const cpp_token
*t
= &pfile
->avoid_paste
;
2192 tokens_buff_add_token (buff
, virt_locs
,
2193 t
, t
->src_loc
, t
->src_loc
,
2197 /* Add a new paste flag, or remove an unwanted one. */
2199 copy_paste_flag (pfile
, paste_flag
, src
);
2201 i
+= arg_tokens_count
;
2204 if (track_macro_exp
)
2205 push_extended_tokens_context (pfile
, node
, buff
, virt_locs
, first
,
2206 tokens_buff_count (buff
));
2208 push_ptoken_context (pfile
, node
, buff
, first
,
2209 tokens_buff_count (buff
));
2211 num_macro_tokens_counter
+= tokens_buff_count (buff
);
2214 /* Return a special padding token, with padding inherited from SOURCE. */
2215 static const cpp_token
*
2216 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
2218 cpp_token
*result
= _cpp_temp_token (pfile
);
2220 result
->type
= CPP_PADDING
;
2222 /* Data in GCed data structures cannot be made const so far, so we
2223 need a cast here. */
2224 result
->val
.source
= (cpp_token
*) source
;
2229 /* Get a new uninitialized context. Create a new one if we cannot
2230 re-use an old one. */
2231 static cpp_context
*
2232 next_context (cpp_reader
*pfile
)
2234 cpp_context
*result
= pfile
->context
->next
;
2238 result
= XNEW (cpp_context
);
2239 memset (result
, 0, sizeof (cpp_context
));
2240 result
->prev
= pfile
->context
;
2242 pfile
->context
->next
= result
;
2245 pfile
->context
= result
;
2249 /* Push a list of pointers to tokens. */
2251 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
2252 const cpp_token
**first
, unsigned int count
)
2254 cpp_context
*context
= next_context (pfile
);
2256 context
->tokens_kind
= TOKENS_KIND_INDIRECT
;
2257 context
->c
.macro
= macro
;
2258 context
->buff
= buff
;
2259 FIRST (context
).ptoken
= first
;
2260 LAST (context
).ptoken
= first
+ count
;
2263 /* Push a list of tokens.
2265 A NULL macro means that we should continue the current macro
2266 expansion, in essence. That means that if we are currently in a
2267 macro expansion context, we'll make the new pfile->context refer to
2268 the current macro. */
2270 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2271 const cpp_token
*first
, unsigned int count
)
2273 cpp_context
*context
;
2276 macro
= macro_of_context (pfile
->context
);
2278 context
= next_context (pfile
);
2279 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2280 context
->c
.macro
= macro
;
2281 context
->buff
= NULL
;
2282 FIRST (context
).token
= first
;
2283 LAST (context
).token
= first
+ count
;
2286 /* Build a context containing a list of tokens as well as their
2287 virtual locations and push it. TOKENS_BUFF is the buffer that
2288 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
2289 non-NULL, it means that the context owns it, meaning that
2290 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
2291 contains the virtual locations.
2293 A NULL macro means that we should continue the current macro
2294 expansion, in essence. That means that if we are currently in a
2295 macro expansion context, we'll make the new pfile->context refer to
2296 the current macro. */
2298 push_extended_tokens_context (cpp_reader
*pfile
,
2299 cpp_hashnode
*macro
,
2300 _cpp_buff
*token_buff
,
2301 location_t
*virt_locs
,
2302 const cpp_token
**first
,
2305 cpp_context
*context
;
2309 macro
= macro_of_context (pfile
->context
);
2311 context
= next_context (pfile
);
2312 context
->tokens_kind
= TOKENS_KIND_EXTENDED
;
2313 context
->buff
= token_buff
;
2315 m
= XNEW (macro_context
);
2316 m
->macro_node
= macro
;
2317 m
->virt_locs
= virt_locs
;
2318 m
->cur_virt_loc
= virt_locs
;
2320 FIRST (context
).ptoken
= first
;
2321 LAST (context
).ptoken
= first
+ count
;
2324 /* Push a traditional macro's replacement text. */
2326 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2327 const uchar
*start
, size_t len
)
2329 cpp_context
*context
= next_context (pfile
);
2331 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2332 context
->c
.macro
= macro
;
2333 context
->buff
= NULL
;
2334 CUR (context
) = start
;
2335 RLIMIT (context
) = start
+ len
;
2336 macro
->flags
|= NODE_DISABLED
;
2339 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
2340 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
2341 non-null (which means that -ftrack-macro-expansion is on),
2342 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
2343 hold the virtual locations of the tokens resulting from macro
2346 tokens_buff_new (cpp_reader
*pfile
, size_t len
,
2347 location_t
**virt_locs
)
2349 size_t tokens_size
= len
* sizeof (cpp_token
*);
2350 size_t locs_size
= len
* sizeof (location_t
);
2352 if (virt_locs
!= NULL
)
2353 *virt_locs
= XNEWVEC (location_t
, locs_size
);
2354 return _cpp_get_buff (pfile
, tokens_size
);
2357 /* Returns the number of tokens contained in a token buffer. The
2358 buffer holds a set of cpp_token*. */
2360 tokens_buff_count (_cpp_buff
*buff
)
2362 return (BUFF_FRONT (buff
) - buff
->base
) / sizeof (cpp_token
*);
2365 /* Return a pointer to the last token contained in the token buffer
2367 static const cpp_token
**
2368 tokens_buff_last_token_ptr (_cpp_buff
*buff
)
2370 if (BUFF_FRONT (buff
) == buff
->base
)
2372 return &((const cpp_token
**) BUFF_FRONT (buff
))[-1];
2375 /* Remove the last token contained in the token buffer TOKENS_BUFF.
2376 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
2377 containing the virtual locations of the tokens in TOKENS_BUFF; in
2378 which case the function updates that buffer as well. */
2380 tokens_buff_remove_last_token (_cpp_buff
*tokens_buff
)
2383 if (BUFF_FRONT (tokens_buff
) > tokens_buff
->base
)
2384 BUFF_FRONT (tokens_buff
) =
2385 (unsigned char *) &((cpp_token
**) BUFF_FRONT (tokens_buff
))[-1];
2388 /* Insert a token into the token buffer at the position pointed to by
2389 DEST. Note that the buffer is not enlarged so the previous token
2390 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
2391 means -ftrack-macro-expansion is effect; it then points to where to
2392 insert the virtual location of TOKEN. TOKEN is the token to
2393 insert. VIRT_LOC is the virtual location of the token, i.e, the
2394 location possibly encoding its locus across macro expansion. If
2395 TOKEN is an argument of a function-like macro (inside a macro
2396 replacement list), PARM_DEF_LOC is the spelling location of the
2397 macro parameter that TOKEN is replacing, in the replacement list of
2398 the macro. If TOKEN is not an argument of a function-like macro or
2399 if it doesn't come from a macro expansion, then VIRT_LOC can just
2400 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
2401 means TOKEN comes from a macro expansion and MAP is the macro map
2402 associated to the macro. MACRO_TOKEN_INDEX points to the index of
2403 the token in the macro map; it is not considered if MAP is NULL.
2405 Upon successful completion this function returns the a pointer to
2406 the position of the token coming right after the insertion
2408 static inline const cpp_token
**
2409 tokens_buff_put_token_to (const cpp_token
**dest
,
2410 location_t
*virt_loc_dest
,
2411 const cpp_token
*token
,
2412 location_t virt_loc
,
2413 location_t parm_def_loc
,
2414 const line_map_macro
*map
,
2415 unsigned int macro_token_index
)
2417 location_t macro_loc
= virt_loc
;
2418 const cpp_token
**result
;
2422 /* -ftrack-macro-expansion is on. */
2424 macro_loc
= linemap_add_macro_token (map
, macro_token_index
,
2425 virt_loc
, parm_def_loc
);
2426 *virt_loc_dest
= macro_loc
;
2434 /* Adds a token at the end of the tokens contained in BUFFER. Note
2435 that this function doesn't enlarge BUFFER when the number of tokens
2436 reaches BUFFER's size; it aborts in that situation.
2438 TOKEN is the token to append. VIRT_LOC is the virtual location of
2439 the token, i.e, the location possibly encoding its locus across
2440 macro expansion. If TOKEN is an argument of a function-like macro
2441 (inside a macro replacement list), PARM_DEF_LOC is the location of
2442 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
2443 from a macro expansion, then VIRT_LOC can just be set to the same
2444 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
2445 from a macro expansion and MAP is the macro map associated to the
2446 macro. MACRO_TOKEN_INDEX points to the index of the token in the
2447 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
2448 non-null, it means -ftrack-macro-expansion is on; in which case
2449 this function adds the virtual location DEF_LOC to the VIRT_LOCS
2450 array, at the same index as the one of TOKEN in BUFFER. Upon
2451 successful completion this function returns the a pointer to the
2452 position of the token coming right after the insertion point. */
2453 static const cpp_token
**
2454 tokens_buff_add_token (_cpp_buff
*buffer
,
2455 location_t
*virt_locs
,
2456 const cpp_token
*token
,
2457 location_t virt_loc
,
2458 location_t parm_def_loc
,
2459 const line_map_macro
*map
,
2460 unsigned int macro_token_index
)
2462 const cpp_token
**result
;
2463 location_t
*virt_loc_dest
= NULL
;
2464 unsigned token_index
=
2465 (BUFF_FRONT (buffer
) - buffer
->base
) / sizeof (cpp_token
*);
2467 /* Abort if we pass the end the buffer. */
2468 if (BUFF_FRONT (buffer
) > BUFF_LIMIT (buffer
))
2471 if (virt_locs
!= NULL
)
2472 virt_loc_dest
= &virt_locs
[token_index
];
2475 tokens_buff_put_token_to ((const cpp_token
**) BUFF_FRONT (buffer
),
2476 virt_loc_dest
, token
, virt_loc
, parm_def_loc
,
2477 map
, macro_token_index
);
2479 BUFF_FRONT (buffer
) = (unsigned char *) result
;
2483 /* Allocate space for the function-like macro argument ARG to store
2484 the tokens resulting from the macro-expansion of the tokens that
2485 make up ARG itself. That space is allocated in ARG->expanded and
2486 needs to be freed using free. */
2488 alloc_expanded_arg_mem (cpp_reader
*pfile
, macro_arg
*arg
, size_t capacity
)
2490 gcc_checking_assert (arg
->expanded
== NULL
2491 && arg
->expanded_virt_locs
== NULL
);
2493 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
2494 if (CPP_OPTION (pfile
, track_macro_expansion
))
2495 arg
->expanded_virt_locs
= XNEWVEC (location_t
, capacity
);
2499 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2502 ensure_expanded_arg_room (cpp_reader
*pfile
, macro_arg
*arg
,
2503 size_t size
, size_t *expanded_capacity
)
2505 if (size
<= *expanded_capacity
)
2511 XRESIZEVEC (const cpp_token
*, arg
->expanded
, size
);
2512 *expanded_capacity
= size
;
2514 if (CPP_OPTION (pfile
, track_macro_expansion
))
2516 if (arg
->expanded_virt_locs
== NULL
)
2517 arg
->expanded_virt_locs
= XNEWVEC (location_t
, size
);
2519 arg
->expanded_virt_locs
= XRESIZEVEC (location_t
,
2520 arg
->expanded_virt_locs
,
2525 /* Expand an argument ARG before replacing parameters in a
2526 function-like macro. This works by pushing a context with the
2527 argument's tokens, and then expanding that into a temporary buffer
2528 as if it were a normal part of the token stream. collect_args()
2529 has terminated the argument's tokens with a CPP_EOF so that we know
2530 when we have fully expanded the argument. */
2532 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
2535 bool saved_warn_trad
;
2536 bool track_macro_exp_p
= CPP_OPTION (pfile
, track_macro_expansion
);
2539 || arg
->expanded
!= NULL
)
2542 /* Don't warn about funlike macros when pre-expanding. */
2543 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
2544 CPP_WTRADITIONAL (pfile
) = 0;
2546 /* Loop, reading in the tokens of the argument. */
2548 alloc_expanded_arg_mem (pfile
, arg
, capacity
);
2550 if (track_macro_exp_p
)
2551 push_extended_tokens_context (pfile
, NULL
, NULL
,
2556 push_ptoken_context (pfile
, NULL
, NULL
,
2557 arg
->first
, arg
->count
+ 1);
2561 const cpp_token
*token
;
2562 location_t location
;
2564 ensure_expanded_arg_room (pfile
, arg
, arg
->expanded_count
+ 1,
2567 token
= cpp_get_token_1 (pfile
, &location
);
2569 if (token
->type
== CPP_EOF
)
2572 set_arg_token (arg
, token
, location
,
2573 arg
->expanded_count
, MACRO_ARG_TOKEN_EXPANDED
,
2574 CPP_OPTION (pfile
, track_macro_expansion
));
2575 arg
->expanded_count
++;
2578 _cpp_pop_context (pfile
);
2580 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
2583 /* Returns the macro associated to the current context if we are in
2584 the context a macro expansion, NULL otherwise. */
2585 static cpp_hashnode
*
2586 macro_of_context (cpp_context
*context
)
2588 if (context
== NULL
)
2591 return (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2592 ? context
->c
.mc
->macro_node
2596 /* Return TRUE iff we are expanding a macro or are about to start
2597 expanding one. If we are effectively expanding a macro, the
2598 function macro_of_context returns a pointer to the macro being
2601 in_macro_expansion_p (cpp_reader
*pfile
)
2606 return (pfile
->about_to_expand_macro_p
2607 || macro_of_context (pfile
->context
));
2610 /* Pop the current context off the stack, re-enabling the macro if the
2611 context represented a macro's replacement list. Initially the
2612 context structure was not freed so that we can re-use it later, but
2613 now we do free it to reduce peak memory consumption. */
2615 _cpp_pop_context (cpp_reader
*pfile
)
2617 cpp_context
*context
= pfile
->context
;
2619 /* We should not be popping the base context. */
2620 if (context
== &pfile
->base_context
)
2623 if (context
->c
.macro
)
2625 cpp_hashnode
*macro
;
2626 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2628 macro_context
*mc
= context
->c
.mc
;
2629 macro
= mc
->macro_node
;
2630 /* If context->buff is set, it means the life time of tokens
2631 is bound to the life time of this context; so we must
2632 free the tokens; that means we must free the virtual
2633 locations of these tokens too. */
2634 if (context
->buff
&& mc
->virt_locs
)
2636 free (mc
->virt_locs
);
2637 mc
->virt_locs
= NULL
;
2640 context
->c
.mc
= NULL
;
2643 macro
= context
->c
.macro
;
2645 /* Beware that MACRO can be NULL in cases like when we are
2646 called from expand_arg. In those cases, a dummy context with
2647 tokens is pushed just for the purpose of walking them using
2648 cpp_get_token_1. In that case, no 'macro' field is set into
2649 the dummy context. */
2651 /* Several contiguous macro expansion contexts can be
2652 associated to the same macro; that means it's the same
2653 macro expansion that spans across all these (sub)
2654 contexts. So we should re-enable an expansion-disabled
2655 macro only when we are sure we are really out of that
2657 && macro_of_context (context
->prev
) != macro
)
2658 macro
->flags
&= ~NODE_DISABLED
;
2660 if (macro
== pfile
->top_most_macro_node
&& context
->prev
== NULL
)
2661 /* We are popping the context of the top-most macro node. */
2662 pfile
->top_most_macro_node
= NULL
;
2667 /* Decrease memory peak consumption by freeing the memory used
2669 _cpp_free_buff (context
->buff
);
2672 pfile
->context
= context
->prev
;
2673 /* decrease peak memory consumption by feeing the context. */
2674 pfile
->context
->next
= NULL
;
2678 /* Return TRUE if we reached the end of the set of tokens stored in
2679 CONTEXT, FALSE otherwise. */
2681 reached_end_of_context (cpp_context
*context
)
2683 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
2684 return FIRST (context
).token
== LAST (context
).token
;
2685 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
2686 || context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2687 return FIRST (context
).ptoken
== LAST (context
).ptoken
;
2692 /* Consume the next token contained in the current context of PFILE,
2693 and return it in *TOKEN. It's "full location" is returned in
2694 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2695 means the location encoding the locus of the token across macro
2696 expansion; otherwise it's just is the "normal" location of the
2697 token which (*TOKEN)->src_loc. */
2699 consume_next_token_from_context (cpp_reader
*pfile
,
2700 const cpp_token
** token
,
2701 location_t
*location
)
2703 cpp_context
*c
= pfile
->context
;
2705 if ((c
)->tokens_kind
== TOKENS_KIND_DIRECT
)
2707 *token
= FIRST (c
).token
;
2708 *location
= (*token
)->src_loc
;
2711 else if ((c
)->tokens_kind
== TOKENS_KIND_INDIRECT
)
2713 *token
= *FIRST (c
).ptoken
;
2714 *location
= (*token
)->src_loc
;
2717 else if ((c
)->tokens_kind
== TOKENS_KIND_EXTENDED
)
2719 macro_context
*m
= c
->c
.mc
;
2720 *token
= *FIRST (c
).ptoken
;
2723 *location
= *m
->cur_virt_loc
;
2727 *location
= (*token
)->src_loc
;
2734 /* In the traditional mode of the preprocessor, if we are currently in
2735 a directive, the location of a token must be the location of the
2736 start of the directive line. This function returns the proper
2737 location if we are in the traditional mode, and just returns
2738 LOCATION otherwise. */
2740 static inline location_t
2741 maybe_adjust_loc_for_trad_cpp (cpp_reader
*pfile
, location_t location
)
2743 if (CPP_OPTION (pfile
, traditional
))
2745 if (pfile
->state
.in_directive
)
2746 return pfile
->directive_line
;
2751 /* Routine to get a token as well as its location.
2753 Macro expansions and directives are transparently handled,
2754 including entering included files. Thus tokens are post-macro
2755 expansion, and after any intervening directives. External callers
2756 see CPP_EOF only at EOF. Internal callers also see it when meeting
2757 a directive inside a macro call, when at the end of a directive and
2758 state.in_directive is still 1, and at the end of argument
2761 LOC is an out parameter; *LOC is set to the location "as expected
2762 by the user". Please read the comment of
2763 cpp_get_token_with_location to learn more about the meaning of this
2765 static const cpp_token
*
2766 cpp_get_token_1 (cpp_reader
*pfile
, location_t
*location
)
2768 const cpp_token
*result
;
2769 /* This token is a virtual token that either encodes a location
2770 related to macro expansion or a spelling location. */
2771 location_t virt_loc
= 0;
2772 /* pfile->about_to_expand_macro_p can be overriden by indirect calls
2773 to functions that push macro contexts. So let's save it so that
2774 we can restore it when we are about to leave this routine. */
2775 bool saved_about_to_expand_macro
= pfile
->about_to_expand_macro_p
;
2780 cpp_context
*context
= pfile
->context
;
2782 /* Context->prev == 0 <=> base context. */
2785 result
= _cpp_lex_token (pfile
);
2786 virt_loc
= result
->src_loc
;
2788 else if (!reached_end_of_context (context
))
2790 consume_next_token_from_context (pfile
, &result
,
2792 if (result
->flags
& PASTE_LEFT
)
2794 paste_all_tokens (pfile
, result
);
2795 if (pfile
->state
.in_directive
)
2797 result
= padding_token (pfile
, result
);
2803 if (pfile
->context
->c
.macro
)
2804 ++num_expanded_macros_counter
;
2805 _cpp_pop_context (pfile
);
2806 if (pfile
->state
.in_directive
)
2808 result
= &pfile
->avoid_paste
;
2812 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
2815 if (result
->type
!= CPP_NAME
)
2818 node
= result
->val
.node
.node
;
2820 if (node
->type
== NT_VOID
|| (result
->flags
& NO_EXPAND
))
2823 if (!(node
->flags
& NODE_DISABLED
))
2826 /* If not in a macro context, and we're going to start an
2827 expansion, record the location and the top level macro
2828 about to be expanded. */
2829 if (!in_macro_expansion_p (pfile
))
2831 pfile
->invocation_location
= result
->src_loc
;
2832 pfile
->top_most_macro_node
= node
;
2834 if (pfile
->state
.prevent_expansion
)
2837 /* Conditional macros require that a predicate be evaluated
2839 if ((node
->flags
& NODE_CONDITIONAL
) != 0)
2841 if (pfile
->cb
.macro_to_expand
)
2843 bool whitespace_after
;
2844 const cpp_token
*peek_tok
= cpp_peek_token (pfile
, 0);
2846 whitespace_after
= (peek_tok
->type
== CPP_PADDING
2847 || (peek_tok
->flags
& PREV_WHITE
));
2848 node
= pfile
->cb
.macro_to_expand (pfile
, result
);
2850 ret
= enter_macro_context (pfile
, node
, result
,
2852 else if (whitespace_after
)
2854 /* If macro_to_expand hook returned NULL and it
2855 ate some tokens, see if we don't need to add
2856 a padding token in between this and the
2858 peek_tok
= cpp_peek_token (pfile
, 0);
2859 if (peek_tok
->type
!= CPP_PADDING
2860 && (peek_tok
->flags
& PREV_WHITE
) == 0)
2861 _cpp_push_token_context (pfile
, NULL
,
2862 padding_token (pfile
,
2868 ret
= enter_macro_context (pfile
, node
, result
,
2872 if (pfile
->state
.in_directive
|| ret
== 2)
2874 result
= padding_token (pfile
, result
);
2880 /* Flag this token as always unexpandable. FIXME: move this
2881 to collect_args()?. */
2882 cpp_token
*t
= _cpp_temp_token (pfile
);
2883 t
->type
= result
->type
;
2884 t
->flags
= result
->flags
| NO_EXPAND
;
2885 t
->val
= result
->val
;
2893 if (location
!= NULL
)
2896 virt_loc
= result
->src_loc
;
2897 *location
= virt_loc
;
2899 if (!CPP_OPTION (pfile
, track_macro_expansion
)
2900 && macro_of_context (pfile
->context
) != NULL
)
2901 /* We are in a macro expansion context, are not tracking
2902 virtual location, but were asked to report the location
2903 of the expansion point of the macro being expanded. */
2904 *location
= pfile
->invocation_location
;
2906 *location
= maybe_adjust_loc_for_trad_cpp (pfile
, *location
);
2909 pfile
->about_to_expand_macro_p
= saved_about_to_expand_macro
;
2913 /* External routine to get a token. Also used nearly everywhere
2914 internally, except for places where we know we can safely call
2915 _cpp_lex_token directly, such as lexing a directive name.
2917 Macro expansions and directives are transparently handled,
2918 including entering included files. Thus tokens are post-macro
2919 expansion, and after any intervening directives. External callers
2920 see CPP_EOF only at EOF. Internal callers also see it when meeting
2921 a directive inside a macro call, when at the end of a directive and
2922 state.in_directive is still 1, and at the end of argument
2925 cpp_get_token (cpp_reader
*pfile
)
2927 return cpp_get_token_1 (pfile
, NULL
);
2930 /* Like cpp_get_token, but also returns a virtual token location
2931 separate from the spelling location carried by the returned token.
2933 LOC is an out parameter; *LOC is set to the location "as expected
2934 by the user". This matters when a token results from macro
2935 expansion; in that case the token's spelling location indicates the
2936 locus of the token in the definition of the macro but *LOC
2937 virtually encodes all the other meaningful locuses associated to
2940 What? virtual location? Yes, virtual location.
2942 If the token results from macro expansion and if macro expansion
2943 location tracking is enabled its virtual location encodes (at the
2946 - the spelling location of the token
2948 - the locus of the macro expansion point
2950 - the locus of the point where the token got instantiated as part
2951 of the macro expansion process.
2953 You have to use the linemap API to get the locus you are interested
2954 in from a given virtual location.
2956 Note however that virtual locations are not necessarily ordered for
2957 relations '<' and '>'. One must use the function
2958 linemap_location_before_p instead of using the relational operator
2961 If macro expansion tracking is off and if the token results from
2962 macro expansion the virtual location is the expansion point of the
2963 macro that got expanded.
2965 When the token doesn't result from macro expansion, the virtual
2966 location is just the same thing as its spelling location. */
2969 cpp_get_token_with_location (cpp_reader
*pfile
, location_t
*loc
)
2971 return cpp_get_token_1 (pfile
, loc
);
2974 /* Returns true if we're expanding an object-like macro that was
2975 defined in a system header. Just checks the macro at the top of
2976 the stack. Used for diagnostic suppression. */
2978 cpp_sys_macro_p (cpp_reader
*pfile
)
2980 cpp_hashnode
*node
= NULL
;
2982 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2983 node
= pfile
->context
->c
.mc
->macro_node
;
2985 node
= pfile
->context
->c
.macro
;
2987 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
2990 /* Read each token in, until end of the current file. Directives are
2991 transparently processed. */
2993 cpp_scan_nooutput (cpp_reader
*pfile
)
2995 /* Request a CPP_EOF token at the end of this file, rather than
2996 transparently continuing with the including file. */
2997 pfile
->buffer
->return_at_eof
= true;
2999 pfile
->state
.discarding_output
++;
3000 pfile
->state
.prevent_expansion
++;
3002 if (CPP_OPTION (pfile
, traditional
))
3003 while (_cpp_read_logical_line_trad (pfile
))
3006 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
3009 pfile
->state
.discarding_output
--;
3010 pfile
->state
.prevent_expansion
--;
3013 /* Step back one or more tokens obtained from the lexer. */
3015 _cpp_backup_tokens_direct (cpp_reader
*pfile
, unsigned int count
)
3017 pfile
->lookaheads
+= count
;
3021 if (pfile
->cur_token
== pfile
->cur_run
->base
3022 /* Possible with -fpreprocessed and no leading #line. */
3023 && pfile
->cur_run
->prev
!= NULL
)
3025 pfile
->cur_run
= pfile
->cur_run
->prev
;
3026 pfile
->cur_token
= pfile
->cur_run
->limit
;
3031 /* Step back one (or more) tokens. Can only step back more than 1 if
3032 they are from the lexer, and not from macro expansion. */
3034 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
3036 if (pfile
->context
->prev
== NULL
)
3037 _cpp_backup_tokens_direct (pfile
, count
);
3042 if (pfile
->context
->tokens_kind
== TOKENS_KIND_DIRECT
)
3043 FIRST (pfile
->context
).token
--;
3044 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
3045 FIRST (pfile
->context
).ptoken
--;
3046 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
3048 FIRST (pfile
->context
).ptoken
--;
3049 if (pfile
->context
->c
.macro
)
3051 macro_context
*m
= pfile
->context
->c
.mc
;
3053 gcc_checking_assert (m
->cur_virt_loc
>= m
->virt_locs
);
3063 /* #define directive parsing and handling. */
3065 /* Returns true if a macro redefinition warning is required. */
3067 warn_of_redefinition (cpp_reader
*pfile
, cpp_hashnode
*node
,
3068 const cpp_macro
*macro2
)
3070 /* Some redefinitions need to be warned about regardless. */
3071 if (node
->flags
& NODE_WARN
)
3074 /* Suppress warnings for builtins that lack the NODE_WARN flag,
3075 unless Wbuiltin-macro-redefined. */
3076 if (cpp_builtin_macro_p (node
))
3077 return CPP_OPTION (pfile
, warn_builtin_macro_redefined
);
3079 /* Redefinitions of conditional (context-sensitive) macros, on
3080 the other hand, must be allowed silently. */
3081 if (node
->flags
& NODE_CONDITIONAL
)
3084 cpp_macro
*macro1
= node
->value
.macro
;
3087 /* We don't want to mark MACRO as used, but do need to finalize
3089 pfile
->cb
.user_lazy_macro (pfile
, macro1
, macro1
->lazy
- 1);
3093 /* Redefinition of a macro is allowed if and only if the old and new
3094 definitions are the same. (6.10.3 paragraph 2). */
3096 /* Don't check count here as it can be different in valid
3097 traditional redefinitions with just whitespace differences. */
3098 if (macro1
->paramc
!= macro2
->paramc
3099 || macro1
->fun_like
!= macro2
->fun_like
3100 || macro1
->variadic
!= macro2
->variadic
)
3103 /* Check parameter spellings. */
3104 for (unsigned i
= macro1
->paramc
; i
--; )
3105 if (macro1
->parm
.params
[i
] != macro2
->parm
.params
[i
])
3108 /* Check the replacement text or tokens. */
3109 if (macro1
->kind
== cmk_traditional
)
3110 return _cpp_expansions_different_trad (macro1
, macro2
);
3112 if (macro1
->count
!= macro2
->count
)
3115 for (unsigned i
= macro1
->count
; i
--; )
3116 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
3122 /* Free the definition of hashnode H. */
3124 _cpp_free_definition (cpp_hashnode
*h
)
3126 /* Macros and assertions no longer have anything to free. */
3128 h
->value
.answers
= NULL
;
3129 h
->flags
&= ~(NODE_DISABLED
| NODE_USED
);
3132 /* Save parameter NODE (spelling SPELLING) to the parameter list of
3133 macro MACRO. Returns true on success, false on failure. */
3135 _cpp_save_parameter (cpp_reader
*pfile
, unsigned n
, cpp_hashnode
*node
,
3136 cpp_hashnode
*spelling
)
3138 /* Constraint 6.10.3.6 - duplicate parameter names. */
3139 if (node
->type
== NT_MACRO_ARG
)
3141 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
3146 unsigned len
= (n
+ 1) * sizeof (struct macro_arg_saved_data
);
3147 if (len
> pfile
->macro_buffer_len
)
3150 = XRESIZEVEC (unsigned char, pfile
->macro_buffer
, len
);
3151 pfile
->macro_buffer_len
= len
;
3154 macro_arg_saved_data
*saved
= (macro_arg_saved_data
*)pfile
->macro_buffer
;
3155 saved
[n
].canonical_node
= node
;
3156 saved
[n
].value
= node
->value
;
3157 saved
[n
].type
= node
->type
;
3159 void *base
= _cpp_reserve_room (pfile
, n
* sizeof (cpp_hashnode
*),
3160 sizeof (cpp_hashnode
*));
3161 ((cpp_hashnode
**)base
)[n
] = spelling
;
3163 /* Morph into a macro arg. */
3164 node
->type
= NT_MACRO_ARG
;
3165 /* Index is 1 based. */
3166 node
->value
.arg_index
= n
+ 1;
3171 /* Restore the parameters to their previous state. */
3173 _cpp_unsave_parameters (cpp_reader
*pfile
, unsigned n
)
3175 /* Clear the fast argument lookup indices. */
3178 struct macro_arg_saved_data
*save
=
3179 &((struct macro_arg_saved_data
*) pfile
->macro_buffer
)[n
];
3181 struct cpp_hashnode
*node
= save
->canonical_node
;
3182 node
->type
= save
->type
;
3183 node
->value
= save
->value
;
3187 /* Check the syntax of the parameters in a MACRO definition. Return
3188 false on failure. Set *N_PTR and *VARADIC_PTR as appropriate.
3190 '(' parm-list ',' last-parm ')'
3200 parse_params (cpp_reader
*pfile
, unsigned *n_ptr
, bool *varadic_ptr
)
3202 unsigned nparms
= 0;
3205 for (bool prev_ident
= false;;)
3207 const cpp_token
*token
= _cpp_lex_token (pfile
);
3209 switch (token
->type
)
3212 /* Allow/ignore comments in parameter lists if we are
3213 preserving comments in macro expansions. */
3214 if (!CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
3221 const char *const msgs
[5] =
3223 N_("expected parameter name, found \"%s\""),
3224 N_("expected ',' or ')', found \"%s\""),
3225 N_("expected parameter name before end of line"),
3226 N_("expected ')' before end of line"),
3227 N_("expected ')' after \"...\"")
3229 unsigned ix
= prev_ident
;
3230 const unsigned char *as_text
= NULL
;
3233 else if (token
->type
== CPP_EOF
)
3236 as_text
= cpp_token_as_text (pfile
, token
);
3237 cpp_error (pfile
, CPP_DL_ERROR
, msgs
[ix
], as_text
);
3242 if (prev_ident
|| *varadic_ptr
)
3246 if (!_cpp_save_parameter (pfile
, nparms
, token
->val
.node
.node
,
3247 token
->val
.node
.spelling
))
3252 case CPP_CLOSE_PAREN
:
3253 if (prev_ident
|| !nparms
|| *varadic_ptr
)
3261 if (!prev_ident
|| *varadic_ptr
)
3269 *varadic_ptr
= true;
3272 /* An ISO bare ellipsis. */
3273 _cpp_save_parameter (pfile
, nparms
,
3274 pfile
->spec_nodes
.n__VA_ARGS__
,
3275 pfile
->spec_nodes
.n__VA_ARGS__
);
3277 pfile
->state
.va_args_ok
= 1;
3278 if (! CPP_OPTION (pfile
, c99
)
3279 && CPP_OPTION (pfile
, cpp_pedantic
)
3280 && CPP_OPTION (pfile
, warn_variadic_macros
))
3282 (pfile
, CPP_W_VARIADIC_MACROS
,
3283 CPP_OPTION (pfile
, cplusplus
)
3284 ? N_("anonymous variadic macros were introduced in C++11")
3285 : N_("anonymous variadic macros were introduced in C99"));
3286 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
3287 && ! CPP_OPTION (pfile
, cplusplus
))
3288 cpp_error (pfile
, CPP_DL_WARNING
,
3289 "anonymous variadic macros were introduced in C99");
3291 else if (CPP_OPTION (pfile
, cpp_pedantic
)
3292 && CPP_OPTION (pfile
, warn_variadic_macros
))
3293 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
3294 CPP_OPTION (pfile
, cplusplus
)
3295 ? N_("ISO C++ does not permit named variadic macros")
3296 : N_("ISO C does not permit named variadic macros"));
3307 /* Lex a token from the expansion of MACRO, but mark parameters as we
3308 find them and warn of traditional stringification. */
3310 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
3312 macro
= (cpp_macro
*)_cpp_reserve_room (pfile
,
3313 sizeof (cpp_macro
) - sizeof (cpp_token
)
3314 + macro
->count
* sizeof (cpp_token
),
3315 sizeof (cpp_token
));
3316 cpp_token
*saved_cur_token
= pfile
->cur_token
;
3317 pfile
->cur_token
= ¯o
->exp
.tokens
[macro
->count
];
3318 cpp_token
*token
= _cpp_lex_direct (pfile
);
3319 pfile
->cur_token
= saved_cur_token
;
3321 /* Is this a parameter? */
3322 if (token
->type
== CPP_NAME
&& token
->val
.node
.node
->type
== NT_MACRO_ARG
)
3324 /* Morph into a parameter reference. */
3325 cpp_hashnode
*spelling
= token
->val
.node
.spelling
;
3326 token
->type
= CPP_MACRO_ARG
;
3327 token
->val
.macro_arg
.arg_no
= token
->val
.node
.node
->value
.arg_index
;
3328 token
->val
.macro_arg
.spelling
= spelling
;
3330 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
3331 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
3332 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
3338 create_iso_definition (cpp_reader
*pfile
)
3340 bool following_paste_op
= false;
3341 const char *paste_op_error_msg
=
3342 N_("'##' cannot appear at either end of a macro expansion");
3343 unsigned int num_extra_tokens
= 0;
3344 unsigned nparms
= 0;
3345 cpp_hashnode
**params
= NULL
;
3346 bool varadic
= false;
3348 cpp_macro
*macro
= NULL
;
3350 /* Look at the first token, to see if this is a function-like
3353 cpp_token
*saved_cur_token
= pfile
->cur_token
;
3354 pfile
->cur_token
= &first
;
3355 cpp_token
*token
= _cpp_lex_direct (pfile
);
3356 pfile
->cur_token
= saved_cur_token
;
3358 if (token
->flags
& PREV_WHITE
)
3359 /* Preceeded by space, must be part of expansion. */;
3360 else if (token
->type
== CPP_OPEN_PAREN
)
3362 /* An open-paren, get a parameter list. */
3363 if (!parse_params (pfile
, &nparms
, &varadic
))
3366 params
= (cpp_hashnode
**)_cpp_commit_buff
3367 (pfile
, sizeof (cpp_hashnode
*) * nparms
);
3370 else if (token
->type
!= CPP_EOF
3371 && !(token
->type
== CPP_COMMENT
3372 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
)))
3374 /* While ISO C99 requires whitespace before replacement text
3375 in a macro definition, ISO C90 with TC1 allows characters
3376 from the basic source character set there. */
3377 if (CPP_OPTION (pfile
, c99
))
3378 cpp_error (pfile
, CPP_DL_PEDWARN
,
3379 CPP_OPTION (pfile
, cplusplus
)
3380 ? N_("ISO C++11 requires whitespace after the macro name")
3381 : N_("ISO C99 requires whitespace after the macro name"));
3384 enum cpp_diagnostic_level warntype
= CPP_DL_WARNING
;
3385 switch (token
->type
)
3389 case CPP_OBJC_STRING
:
3390 /* '@' is not in basic character set. */
3391 warntype
= CPP_DL_PEDWARN
;
3394 /* Basic character set sans letters, digits and _. */
3395 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
3396 token
->val
.str
.text
[0]) == NULL
)
3397 warntype
= CPP_DL_PEDWARN
;
3400 /* All other tokens start with a character from basic
3404 cpp_error (pfile
, warntype
,
3405 "missing whitespace after the macro name");
3409 macro
= _cpp_new_macro (pfile
, cmk_macro
,
3410 _cpp_reserve_room (pfile
, 0, sizeof (cpp_macro
)));
3414 macro
->variadic
= varadic
;
3415 macro
->paramc
= nparms
;
3416 macro
->parm
.params
= params
;
3417 macro
->fun_like
= true;
3421 /* Preserve the token we peeked, there is already a single slot for it. */
3422 macro
->exp
.tokens
[0] = *token
;
3423 token
= ¯o
->exp
.tokens
[0];
3427 for (vaopt_state
vaopt_tracker (pfile
, macro
->variadic
, true);; token
= NULL
)
3431 macro
= lex_expansion_token (pfile
, macro
);
3432 token
= ¯o
->exp
.tokens
[macro
->count
++];
3435 /* Check the stringifying # constraint 6.10.3.2.1 of
3436 function-like macros when lexing the subsequent token. */
3437 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
3439 if (token
->type
== CPP_MACRO_ARG
)
3441 if (token
->flags
& PREV_WHITE
)
3442 token
->flags
|= SP_PREV_WHITE
;
3443 if (token
[-1].flags
& DIGRAPH
)
3444 token
->flags
|= SP_DIGRAPH
;
3445 token
->flags
&= ~PREV_WHITE
;
3446 token
->flags
|= STRINGIFY_ARG
;
3447 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
3448 token
[-1] = token
[0];
3451 /* Let assembler get away with murder. */
3452 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
3454 cpp_error (pfile
, CPP_DL_ERROR
,
3455 "'#' is not followed by a macro parameter");
3460 if (token
->type
== CPP_EOF
)
3462 /* Paste operator constraint 6.10.3.3.1:
3463 Token-paste ##, can appear in both object-like and
3464 function-like macros, but not at the end. */
3465 if (following_paste_op
)
3467 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3470 if (!vaopt_tracker
.completed ())
3475 /* Paste operator constraint 6.10.3.3.1. */
3476 if (token
->type
== CPP_PASTE
)
3478 /* Token-paste ##, can appear in both object-like and
3479 function-like macros, but not at the beginning. */
3480 if (macro
->count
== 1)
3482 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3486 if (following_paste_op
)
3488 /* Consecutive paste operators. This one will be moved
3491 token
->val
.token_no
= macro
->count
- 1;
3495 /* Drop the paste operator. */
3497 token
[-1].flags
|= PASTE_LEFT
;
3498 if (token
->flags
& DIGRAPH
)
3499 token
[-1].flags
|= SP_DIGRAPH
;
3500 if (token
->flags
& PREV_WHITE
)
3501 token
[-1].flags
|= SP_PREV_WHITE
;
3503 following_paste_op
= true;
3506 following_paste_op
= false;
3508 if (vaopt_tracker
.update (token
) == vaopt_state::ERROR
)
3512 /* We're committed to winning now. */
3515 /* Don't count the CPP_EOF. */
3518 macro
= (cpp_macro
*)_cpp_commit_buff
3519 (pfile
, sizeof (cpp_macro
) - sizeof (cpp_token
)
3520 + sizeof (cpp_token
) * macro
->count
);
3522 /* Clear whitespace on first token. */
3524 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
3526 if (num_extra_tokens
)
3528 /* Place second and subsequent ## or %:%: tokens in sequences of
3529 consecutive such tokens at the end of the list to preserve
3530 information about where they appear, how they are spelt and
3531 whether they are preceded by whitespace without otherwise
3532 interfering with macro expansion. Remember, this is
3533 extremely rare, so efficiency is not a priority. */
3534 cpp_token
*temp
= (cpp_token
*)_cpp_reserve_room
3535 (pfile
, 0, num_extra_tokens
* sizeof (cpp_token
));
3536 unsigned extra_ix
= 0, norm_ix
= 0;
3537 cpp_token
*exp
= macro
->exp
.tokens
;
3538 for (unsigned ix
= 0; ix
!= macro
->count
; ix
++)
3539 if (exp
[ix
].type
== CPP_PASTE
)
3540 temp
[extra_ix
++] = exp
[ix
];
3542 exp
[norm_ix
++] = exp
[ix
];
3543 memcpy (&exp
[norm_ix
], temp
, num_extra_tokens
* sizeof (cpp_token
));
3545 /* Record there are extra tokens. */
3546 macro
->extra_tokens
= 1;
3550 pfile
->state
.va_args_ok
= 0;
3551 _cpp_unsave_parameters (pfile
, nparms
);
3553 return ok
? macro
: NULL
;
3557 _cpp_new_macro (cpp_reader
*pfile
, cpp_macro_kind kind
, void *placement
)
3559 cpp_macro
*macro
= (cpp_macro
*) placement
;
3561 macro
->line
= pfile
->directive_line
;
3562 macro
->parm
.params
= 0;
3565 macro
->variadic
= 0;
3566 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
3568 macro
->fun_like
= 0;
3569 macro
->extra_tokens
= 0;
3570 /* To suppress some diagnostics. */
3571 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
3578 /* Parse a macro and save its expansion. Returns nonzero on success. */
3580 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3584 if (CPP_OPTION (pfile
, traditional
))
3585 macro
= _cpp_create_trad_definition (pfile
);
3587 macro
= create_iso_definition (pfile
);
3592 if (cpp_macro_p (node
))
3594 if (CPP_OPTION (pfile
, warn_unused_macros
))
3595 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
3597 if (warn_of_redefinition (pfile
, node
, macro
))
3599 const enum cpp_warning_reason reason
3600 = (cpp_builtin_macro_p (node
) && !(node
->flags
& NODE_WARN
))
3601 ? CPP_W_BUILTIN_MACRO_REDEFINED
: CPP_W_NONE
;
3604 cpp_pedwarning_with_line (pfile
, reason
,
3605 pfile
->directive_line
, 0,
3606 "\"%s\" redefined", NODE_NAME (node
));
3608 if (warned
&& cpp_user_macro_p (node
))
3609 cpp_error_with_line (pfile
, CPP_DL_NOTE
,
3610 node
->value
.macro
->line
, 0,
3611 "this is the location of the previous definition");
3613 _cpp_free_definition (node
);
3616 /* Enter definition in hash table. */
3617 node
->type
= NT_USER_MACRO
;
3618 node
->value
.macro
= macro
;
3619 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
3620 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
3621 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3622 in the C standard, as something that one must use in C++.
3623 However DR#593 and C++11 indicate that they play no role in C++.
3624 We special-case them anyway. */
3625 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
3626 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
3627 node
->flags
|= NODE_WARN
;
3629 /* If user defines one of the conditional macros, remove the
3631 node
->flags
&= ~NODE_CONDITIONAL
;
3637 cpp_define_lazily (cpp_reader
*pfile
, cpp_hashnode
*node
, unsigned num
)
3639 cpp_macro
*macro
= node
->value
.macro
;
3641 gcc_checking_assert (pfile
->cb
.user_lazy_macro
&& macro
&& num
< UCHAR_MAX
);
3643 macro
->lazy
= num
+ 1;
3646 /* Notify the use of NODE in a macro-aware context (i.e. expanding it,
3647 or testing its existance). Also applies any lazy definition. */
3650 _cpp_notify_macro_use (cpp_reader
*pfile
, cpp_hashnode
*node
)
3652 node
->flags
|= NODE_USED
;
3657 cpp_macro
*macro
= node
->value
.macro
;
3660 pfile
->cb
.user_lazy_macro (pfile
, macro
, macro
->lazy
- 1);
3666 case NT_BUILTIN_MACRO
:
3667 if (pfile
->cb
.used_define
)
3668 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
3672 if (pfile
->cb
.used_undef
)
3673 pfile
->cb
.used_undef (pfile
, pfile
->directive_line
, node
);
3681 /* Warn if a token in STRING matches one of a function-like MACRO's
3684 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
3685 const cpp_string
*string
)
3687 unsigned int i
, len
;
3688 const uchar
*p
, *q
, *limit
;
3690 /* Loop over the string. */
3691 limit
= string
->text
+ string
->len
- 1;
3692 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
3694 /* Find the start of an identifier. */
3695 while (p
< limit
&& !is_idstart (*p
))
3698 /* Find the end of the identifier. */
3700 while (q
< limit
&& is_idchar (*q
))
3705 /* Loop over the function macro arguments to see if the
3706 identifier inside the string matches one of them. */
3707 for (i
= 0; i
< macro
->paramc
; i
++)
3709 const cpp_hashnode
*node
= macro
->parm
.params
[i
];
3711 if (NODE_LEN (node
) == len
3712 && !memcmp (p
, NODE_NAME (node
), len
))
3714 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
3715 "macro argument \"%s\" would be stringified in traditional C",
3723 /* Returns the name, arguments and expansion of a macro, in a format
3724 suitable to be read back in again, and therefore also for DWARF 2
3725 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3726 Caller is expected to generate the "#define" bit if needed. The
3727 returned text is temporary, and automatically freed later. */
3728 const unsigned char *
3729 cpp_macro_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3731 unsigned int i
, len
;
3732 unsigned char *buffer
;
3734 gcc_checking_assert (cpp_user_macro_p (node
));
3736 const cpp_macro
*macro
= node
->value
.macro
;
3738 /* Calculate length. */
3739 len
= NODE_LEN (node
) * 10 + 2; /* ' ' and NUL. */
3740 if (macro
->fun_like
)
3742 len
+= 4; /* "()" plus possible final ".." of named
3743 varargs (we have + 1 below). */
3744 for (i
= 0; i
< macro
->paramc
; i
++)
3745 len
+= NODE_LEN (macro
->parm
.params
[i
]) + 1; /* "," */
3748 /* This should match below where we fill in the buffer. */
3749 if (CPP_OPTION (pfile
, traditional
))
3750 len
+= _cpp_replacement_text_len (macro
);
3753 unsigned int count
= macro_real_token_count (macro
);
3754 for (i
= 0; i
< count
; i
++)
3756 const cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3758 if (token
->type
== CPP_MACRO_ARG
)
3759 len
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3761 len
+= cpp_token_len (token
);
3763 if (token
->flags
& STRINGIFY_ARG
)
3765 if (token
->flags
& PASTE_LEFT
)
3766 len
+= 3; /* " ##" */
3767 if (token
->flags
& PREV_WHITE
)
3772 if (len
> pfile
->macro_buffer_len
)
3774 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
3775 pfile
->macro_buffer
, len
);
3776 pfile
->macro_buffer_len
= len
;
3779 /* Fill in the buffer. Start with the macro name. */
3780 buffer
= pfile
->macro_buffer
;
3781 buffer
= _cpp_spell_ident_ucns (buffer
, node
);
3783 /* Parameter names. */
3784 if (macro
->fun_like
)
3787 for (i
= 0; i
< macro
->paramc
; i
++)
3789 cpp_hashnode
*param
= macro
->parm
.params
[i
];
3791 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
3793 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
3794 buffer
+= NODE_LEN (param
);
3797 if (i
+ 1 < macro
->paramc
)
3798 /* Don't emit a space after the comma here; we're trying
3799 to emit a Dwarf-friendly definition, and the Dwarf spec
3800 forbids spaces in the argument list. */
3802 else if (macro
->variadic
)
3803 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
3808 /* The Dwarf spec requires a space after the macro name, even if the
3809 definition is the empty string. */
3812 if (CPP_OPTION (pfile
, traditional
))
3813 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
3814 else if (macro
->count
)
3815 /* Expansion tokens. */
3817 unsigned int count
= macro_real_token_count (macro
);
3818 for (i
= 0; i
< count
; i
++)
3820 const cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3822 if (token
->flags
& PREV_WHITE
)
3824 if (token
->flags
& STRINGIFY_ARG
)
3827 if (token
->type
== CPP_MACRO_ARG
)
3830 NODE_NAME (token
->val
.macro_arg
.spelling
),
3831 NODE_LEN (token
->val
.macro_arg
.spelling
));
3832 buffer
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3835 buffer
= cpp_spell_token (pfile
, token
, buffer
, true);
3837 if (token
->flags
& PASTE_LEFT
)
3842 /* Next has PREV_WHITE; see _cpp_create_definition. */
3848 return pfile
->macro_buffer
;