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