1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986-2018 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 source_location
*virt_locs
; /* Where virtual locations for
43 unexpanded tokens are stored. */
44 source_location
*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 source_location
*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 of this identifier. */
89 union _cpp_hashnode_value value
;
92 static const char *vaopt_paste_error
=
93 N_("'##' cannot appear at either end of __VA_OPT__");
95 /* A class for tracking __VA_OPT__ state while iterating over a
96 sequence of tokens. This is used during both macro definition and
102 /* Initialize the state tracker. ANY_ARGS is true if variable
103 arguments were provided to the macro invocation. */
104 vaopt_state (cpp_reader
*pfile
, bool is_variadic
, bool any_args
)
106 m_allowed (any_args
),
107 m_variadic (is_variadic
),
108 m_last_was_paste (false),
110 m_paste_location (0),
124 /* Given a token, update the state of this tracker and return a
125 boolean indicating whether the token should be be included in the
127 update_type
update (const cpp_token
*token
)
129 /* If the macro isn't variadic, just don't bother. */
133 if (token
->type
== CPP_NAME
134 && token
->val
.node
.node
== m_pfile
->spec_nodes
.n__VA_OPT__
)
138 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
139 "__VA_OPT__ may not appear in a __VA_OPT__");
143 m_location
= token
->src_loc
;
146 else if (m_state
== 1)
148 if (token
->type
!= CPP_OPEN_PAREN
)
150 cpp_error_at (m_pfile
, CPP_DL_ERROR
, m_location
,
151 "__VA_OPT__ must be followed by an "
158 else if (m_state
>= 2)
160 if (m_state
== 2 && token
->type
== CPP_PASTE
)
162 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
166 /* Advance states before further considering this token, in
167 case we see a close paren immediately after the open
172 bool was_paste
= m_last_was_paste
;
173 m_last_was_paste
= false;
174 if (token
->type
== CPP_PASTE
)
176 m_last_was_paste
= true;
177 m_paste_location
= token
->src_loc
;
179 else if (token
->type
== CPP_OPEN_PAREN
)
181 else if (token
->type
== CPP_CLOSE_PAREN
)
186 /* Saw the final paren. */
191 cpp_error_at (m_pfile
, CPP_DL_ERROR
, token
->src_loc
,
199 return m_allowed
? INCLUDE
: DROP
;
202 /* Nothing to do with __VA_OPT__. */
206 /* Ensure that any __VA_OPT__ was completed. If ok, return true.
207 Otherwise, issue an error and return false. */
210 if (m_variadic
&& m_state
!= 0)
211 cpp_error_at (m_pfile
, CPP_DL_ERROR
, m_location
,
212 "unterminated __VA_OPT__");
218 /* The cpp_reader. */
221 /* True if there were varargs. */
223 /* True if the macro is variadic. */
225 /* If true, the previous token was ##. This is used to detect when
226 a paste occurs at the end of the sequence. */
227 bool m_last_was_paste
;
229 /* The state variable:
231 1 means __VA_OPT__ seen, looking for "("
232 2 means "(" seen (so the next token can't be "##")
233 >= 3 means looking for ")", the number encodes the paren depth. */
236 /* The location of the paste token. */
237 source_location m_paste_location
;
239 /* Location of the __VA_OPT__ token. */
240 source_location m_location
;
243 /* Macro expansion. */
245 static int enter_macro_context (cpp_reader
*, cpp_hashnode
*,
246 const cpp_token
*, source_location
);
247 static int builtin_macro (cpp_reader
*, cpp_hashnode
*,
248 source_location
, source_location
);
249 static void push_ptoken_context (cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
250 const cpp_token
**, unsigned int);
251 static void push_extended_tokens_context (cpp_reader
*, cpp_hashnode
*,
252 _cpp_buff
*, source_location
*,
253 const cpp_token
**, unsigned int);
254 static _cpp_buff
*collect_args (cpp_reader
*, const cpp_hashnode
*,
255 _cpp_buff
**, unsigned *);
256 static cpp_context
*next_context (cpp_reader
*);
257 static const cpp_token
*padding_token (cpp_reader
*, const cpp_token
*);
258 static void expand_arg (cpp_reader
*, macro_arg
*);
259 static const cpp_token
*new_string_token (cpp_reader
*, uchar
*, unsigned int);
260 static const cpp_token
*stringify_arg (cpp_reader
*, macro_arg
*);
261 static void paste_all_tokens (cpp_reader
*, const cpp_token
*);
262 static bool paste_tokens (cpp_reader
*, source_location
,
263 const cpp_token
**, const cpp_token
*);
264 static void alloc_expanded_arg_mem (cpp_reader
*, macro_arg
*, size_t);
265 static void ensure_expanded_arg_room (cpp_reader
*, macro_arg
*, size_t, size_t *);
266 static void delete_macro_args (_cpp_buff
*, unsigned num_args
);
267 static void set_arg_token (macro_arg
*, const cpp_token
*,
268 source_location
, size_t,
269 enum macro_arg_token_kind
,
271 static const source_location
*get_arg_token_location (const macro_arg
*,
272 enum macro_arg_token_kind
);
273 static const cpp_token
**arg_token_ptr_at (const macro_arg
*,
275 enum macro_arg_token_kind
,
276 source_location
**virt_location
);
278 static void macro_arg_token_iter_init (macro_arg_token_iter
*, bool,
279 enum macro_arg_token_kind
,
282 static const cpp_token
*macro_arg_token_iter_get_token
283 (const macro_arg_token_iter
*it
);
284 static source_location macro_arg_token_iter_get_location
285 (const macro_arg_token_iter
*);
286 static void macro_arg_token_iter_forward (macro_arg_token_iter
*);
287 static _cpp_buff
*tokens_buff_new (cpp_reader
*, size_t,
289 static size_t tokens_buff_count (_cpp_buff
*);
290 static const cpp_token
**tokens_buff_last_token_ptr (_cpp_buff
*);
291 static inline const cpp_token
**tokens_buff_put_token_to (const cpp_token
**,
296 const line_map_macro
*,
299 static const cpp_token
**tokens_buff_add_token (_cpp_buff
*,
304 const line_map_macro
*,
306 static inline void tokens_buff_remove_last_token (_cpp_buff
*);
307 static void replace_args (cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
308 macro_arg
*, source_location
);
309 static _cpp_buff
*funlike_invocation_p (cpp_reader
*, cpp_hashnode
*,
310 _cpp_buff
**, unsigned *);
311 static bool create_iso_definition (cpp_reader
*, cpp_macro
*);
313 /* #define directive parsing and handling. */
315 static cpp_token
*alloc_expansion_token (cpp_reader
*, cpp_macro
*);
316 static cpp_token
*lex_expansion_token (cpp_reader
*, cpp_macro
*);
317 static bool warn_of_redefinition (cpp_reader
*, cpp_hashnode
*,
319 static bool parse_params (cpp_reader
*, cpp_macro
*);
320 static void check_trad_stringification (cpp_reader
*, const cpp_macro
*,
322 static bool reached_end_of_context (cpp_context
*);
323 static void consume_next_token_from_context (cpp_reader
*pfile
,
326 static const cpp_token
* cpp_get_token_1 (cpp_reader
*, source_location
*);
328 static cpp_hashnode
* macro_of_context (cpp_context
*context
);
330 static bool in_macro_expansion_p (cpp_reader
*pfile
);
332 /* Statistical counter tracking the number of macros that got
334 unsigned num_expanded_macros_counter
= 0;
335 /* Statistical counter tracking the total number tokens resulting
336 from macro expansion. */
337 unsigned num_macro_tokens_counter
= 0;
339 /* Emits a warning if NODE is a macro defined in the main file that
340 has not been used. */
342 _cpp_warn_if_unused_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
343 void *v ATTRIBUTE_UNUSED
)
345 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
347 cpp_macro
*macro
= node
->value
.macro
;
350 && MAIN_FILE_P (linemap_check_ordinary
351 (linemap_lookup (pfile
->line_table
,
353 cpp_warning_with_line (pfile
, CPP_W_UNUSED_MACROS
, macro
->line
, 0,
354 "macro \"%s\" is not used", NODE_NAME (node
));
360 /* Allocates and returns a CPP_STRING token, containing TEXT of length
361 LEN, after null-terminating it. TEXT must be in permanent storage. */
362 static const cpp_token
*
363 new_string_token (cpp_reader
*pfile
, unsigned char *text
, unsigned int len
)
365 cpp_token
*token
= _cpp_temp_token (pfile
);
368 token
->type
= CPP_STRING
;
369 token
->val
.str
.len
= len
;
370 token
->val
.str
.text
= text
;
375 static const char * const monthnames
[] =
377 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
378 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
381 /* Helper function for builtin_macro. Returns the text generated by
384 _cpp_builtin_macro_text (cpp_reader
*pfile
, cpp_hashnode
*node
,
387 const uchar
*result
= NULL
;
388 linenum_type number
= 1;
390 switch (node
->value
.builtin
)
393 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
399 if (CPP_OPTION (pfile
, warn_date_time
))
400 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
401 "reproducible builds", NODE_NAME (node
));
403 cpp_buffer
*pbuffer
= cpp_get_buffer (pfile
);
404 if (pbuffer
->timestamp
== NULL
)
406 /* Initialize timestamp value of the assotiated file. */
407 struct _cpp_file
*file
= cpp_get_file (pbuffer
);
410 /* Generate __TIMESTAMP__ string, that represents
411 the date and time of the last modification
412 of the current source file. The string constant
413 looks like "Sun Sep 16 01:03:52 1973". */
414 struct tm
*tb
= NULL
;
415 struct stat
*st
= _cpp_get_file_stat (file
);
417 tb
= localtime (&st
->st_mtime
);
420 char *str
= asctime (tb
);
421 size_t len
= strlen (str
);
422 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
424 strcpy ((char *) buf
+ 1, str
);
426 pbuffer
->timestamp
= buf
;
430 cpp_errno (pfile
, CPP_DL_WARNING
,
431 "could not determine file timestamp");
432 pbuffer
->timestamp
= UC
"\"??? ??? ?? ??:??:?? ????\"";
436 result
= pbuffer
->timestamp
;
446 if (node
->value
.builtin
== BT_FILE
)
447 name
= linemap_get_expansion_filename (pfile
->line_table
,
448 pfile
->line_table
->highest_line
);
451 name
= _cpp_get_file_name (pfile
->main_file
);
455 if (pfile
->cb
.remap_filename
)
456 name
= pfile
->cb
.remap_filename (name
);
458 buf
= _cpp_unaligned_alloc (pfile
, len
* 2 + 3);
461 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
467 case BT_INCLUDE_LEVEL
:
468 /* The line map depth counts the primary source as level 1, but
469 historically __INCLUDE_DEPTH__ has called the primary source
471 number
= pfile
->line_table
->depth
- 1;
475 /* If __LINE__ is embedded in a macro, it must expand to the
476 line of the macro's invocation, not its definition.
477 Otherwise things like assert() will not work properly.
478 See WG14 N1911, WG21 N4220 sec 6.5, and PR 61861. */
479 if (CPP_OPTION (pfile
, traditional
))
480 loc
= pfile
->line_table
->highest_line
;
482 loc
= linemap_resolve_location (pfile
->line_table
, loc
,
483 LRK_MACRO_EXPANSION_POINT
, NULL
);
484 number
= linemap_get_expansion_line (pfile
->line_table
, loc
);
487 /* __STDC__ has the value 1 under normal circumstances.
488 However, if (a) we are in a system header, (b) the option
489 stdc_0_in_system_headers is true (set by target config), and
490 (c) we are not in strictly conforming mode, then it has the
491 value 0. (b) and (c) are already checked in cpp_init_builtins. */
493 if (cpp_in_system_header (pfile
))
501 if (CPP_OPTION (pfile
, warn_date_time
))
502 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
503 "reproducible builds", NODE_NAME (node
));
504 if (pfile
->date
== NULL
)
506 /* Allocate __DATE__ and __TIME__ strings from permanent
507 storage. We only do this once, and don't generate them
508 at init time, because time() and localtime() are very
509 slow on some systems. */
511 struct tm
*tb
= NULL
;
513 /* Set a reproducible timestamp for __DATE__ and __TIME__ macro
514 if SOURCE_DATE_EPOCH is defined. */
515 if (pfile
->source_date_epoch
== (time_t) -2
516 && pfile
->cb
.get_source_date_epoch
!= NULL
)
517 pfile
->source_date_epoch
= pfile
->cb
.get_source_date_epoch (pfile
);
519 if (pfile
->source_date_epoch
>= (time_t) 0)
520 tb
= gmtime (&pfile
->source_date_epoch
);
523 /* (time_t) -1 is a legitimate value for "number of seconds
524 since the Epoch", so we have to do a little dance to
525 distinguish that from a genuine error. */
528 if (tt
!= (time_t)-1 || errno
== 0)
529 tb
= localtime (&tt
);
534 pfile
->date
= _cpp_unaligned_alloc (pfile
,
535 sizeof ("\"Oct 11 1347\""));
536 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
537 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
540 pfile
->time
= _cpp_unaligned_alloc (pfile
,
541 sizeof ("\"12:34:56\""));
542 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
543 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
547 cpp_errno (pfile
, CPP_DL_WARNING
,
548 "could not determine date and time");
550 pfile
->date
= UC
"\"??? ?? ????\"";
551 pfile
->time
= UC
"\"??:??:??\"";
555 if (node
->value
.builtin
== BT_DATE
)
556 result
= pfile
->date
;
558 result
= pfile
->time
;
562 if (CPP_OPTION (pfile
, directives_only
) && pfile
->state
.in_directive
)
563 cpp_error (pfile
, CPP_DL_ERROR
,
564 "__COUNTER__ expanded inside directive with -fdirectives-only");
565 number
= pfile
->counter
++;
568 case BT_HAS_ATTRIBUTE
:
569 number
= pfile
->cb
.has_attribute (pfile
);
575 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
576 result
= _cpp_unaligned_alloc (pfile
, 21);
577 sprintf ((char *) result
, "%u", number
);
583 /* Convert builtin macros like __FILE__ to a token and push it on the
584 context stack. Also handles _Pragma, for which a new token may not
585 be created. Returns 1 if it generates a new token context, 0 to
586 return the token to the caller. LOC is the location of the expansion
587 point of the macro. */
589 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
590 source_location loc
, source_location expand_loc
)
596 if (node
->value
.builtin
== BT_PRAGMA
)
598 /* Don't interpret _Pragma within directives. The standard is
599 not clear on this, but to me this makes most sense. */
600 if (pfile
->state
.in_directive
)
603 return _cpp_do__Pragma (pfile
, loc
);
606 buf
= _cpp_builtin_macro_text (pfile
, node
, expand_loc
);
608 nbuf
= (char *) alloca (len
+ 1);
609 memcpy (nbuf
, buf
, len
);
612 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
613 _cpp_clean_line (pfile
);
615 /* Set pfile->cur_token as required by _cpp_lex_direct. */
616 pfile
->cur_token
= _cpp_temp_token (pfile
);
617 cpp_token
*token
= _cpp_lex_direct (pfile
);
618 /* We should point to the expansion point of the builtin macro. */
619 token
->src_loc
= loc
;
620 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
622 /* We are tracking tokens resulting from macro expansion.
623 Create a macro line map and generate a virtual location for
624 the token resulting from the expansion of the built-in
626 source_location
*virt_locs
= NULL
;
627 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
628 const line_map_macro
* map
=
629 linemap_enter_macro (pfile
->line_table
, node
, loc
, 1);
630 tokens_buff_add_token (token_buf
, virt_locs
, token
,
631 pfile
->line_table
->builtin_location
,
632 pfile
->line_table
->builtin_location
,
633 map
, /*macro_token_index=*/0);
634 push_extended_tokens_context (pfile
, node
, token_buf
, virt_locs
,
635 (const cpp_token
**)token_buf
->base
,
639 _cpp_push_token_context (pfile
, NULL
, token
, 1);
640 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
641 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
643 _cpp_pop_buffer (pfile
);
648 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
649 backslashes and double quotes. DEST must be of sufficient size.
650 Returns a pointer to the end of the string. */
652 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
661 /* Naked LF can appear in raw string literals */
678 /* Convert a token sequence ARG to a single string token according to
679 the rules of the ISO C #-operator. */
680 static const cpp_token
*
681 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
684 unsigned int i
, escape_it
, backslash_count
= 0;
685 const cpp_token
*source
= NULL
;
688 if (BUFF_ROOM (pfile
->u_buff
) < 3)
689 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
690 dest
= BUFF_FRONT (pfile
->u_buff
);
693 /* Loop, reading in the argument's tokens. */
694 for (i
= 0; i
< arg
->count
; i
++)
696 const cpp_token
*token
= arg
->first
[i
];
698 if (token
->type
== CPP_PADDING
)
701 || (!(source
->flags
& PREV_WHITE
)
702 && token
->val
.source
== NULL
))
703 source
= token
->val
.source
;
707 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
708 || token
->type
== CPP_WSTRING
|| token
->type
== CPP_WCHAR
709 || token
->type
== CPP_STRING32
|| token
->type
== CPP_CHAR32
710 || token
->type
== CPP_STRING16
|| token
->type
== CPP_CHAR16
711 || token
->type
== CPP_UTF8STRING
|| token
->type
== CPP_UTF8CHAR
712 || cpp_userdef_string_p (token
->type
)
713 || cpp_userdef_char_p (token
->type
));
715 /* Room for each char being written in octal, initial space and
716 final quote and NUL. */
717 len
= cpp_token_len (token
);
722 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
724 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
725 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
726 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
729 /* Leading white space? */
730 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
734 if (source
->flags
& PREV_WHITE
)
741 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
742 unsigned char *buf
= BUFF_FRONT (buff
);
743 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
744 dest
= cpp_quote_string (dest
, buf
, len
);
745 _cpp_release_buff (pfile
, buff
);
748 dest
= cpp_spell_token (pfile
, token
, dest
, true);
750 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
756 /* Ignore the final \ of invalid string literals. */
757 if (backslash_count
& 1)
759 cpp_error (pfile
, CPP_DL_WARNING
,
760 "invalid string literal, ignoring final '\\'");
764 /* Commit the memory, including NUL, and return the token. */
766 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
767 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
768 return new_string_token (pfile
, dest
- len
, len
);
771 /* Try to paste two tokens. On success, return nonzero. In any
772 case, PLHS is updated to point to the pasted token, which is
773 guaranteed to not have the PASTE_LEFT flag set. LOCATION is
774 the virtual location used for error reporting. */
776 paste_tokens (cpp_reader
*pfile
, source_location location
,
777 const cpp_token
**plhs
, const cpp_token
*rhs
)
779 unsigned char *buf
, *end
, *lhsend
;
783 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
784 buf
= (unsigned char *) alloca (len
);
785 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, true);
787 /* Avoid comment headers, since they are still processed in stage 3.
788 It is simpler to insert a space here, rather than modifying the
789 lexer to ignore comments in some circumstances. Simply returning
790 false doesn't work, since we want to clear the PASTE_LEFT flag. */
791 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
793 /* In one obscure case we might see padding here. */
794 if (rhs
->type
!= CPP_PADDING
)
795 end
= cpp_spell_token (pfile
, rhs
, end
, true);
798 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
799 _cpp_clean_line (pfile
);
801 /* Set pfile->cur_token as required by _cpp_lex_direct. */
802 pfile
->cur_token
= _cpp_temp_token (pfile
);
803 lhs
= _cpp_lex_direct (pfile
);
804 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
806 source_location saved_loc
= lhs
->src_loc
;
808 _cpp_pop_buffer (pfile
);
809 _cpp_backup_tokens (pfile
, 1);
812 /* We have to remove the PASTE_LEFT flag from the old lhs, but
813 we want to keep the new location. */
816 lhs
->src_loc
= saved_loc
;
817 lhs
->flags
&= ~PASTE_LEFT
;
819 /* Mandatory error for all apart from assembler. */
820 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
821 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
822 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
823 buf
, cpp_token_as_text (pfile
, rhs
));
828 _cpp_pop_buffer (pfile
);
832 /* Handles an arbitrarily long sequence of ## operators, with initial
833 operand LHS. This implementation is left-associative,
834 non-recursive, and finishes a paste before handling succeeding
835 ones. If a paste fails, we back up to the RHS of the failing ##
836 operator before pushing the context containing the result of prior
837 successful pastes, with the effect that the RHS appears in the
838 output stream after the pasted LHS normally. */
840 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
842 const cpp_token
*rhs
= NULL
;
843 cpp_context
*context
= pfile
->context
;
844 source_location virt_loc
= 0;
846 /* We are expanding a macro and we must have been called on a token
847 that appears at the left hand side of a ## operator. */
848 if (macro_of_context (pfile
->context
) == NULL
849 || (!(lhs
->flags
& PASTE_LEFT
)))
852 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
853 /* The caller must have called consume_next_token_from_context
854 right before calling us. That has incremented the pointer to
855 the current virtual location. So it now points to the location
856 of the token that comes right after *LHS. We want the
857 resulting pasted token to have the location of the current
859 virt_loc
= context
->c
.mc
->cur_virt_loc
[-1];
861 /* We are not tracking macro expansion. So the best virtual
862 location we can get here is the expansion point of the macro we
863 are currently expanding. */
864 virt_loc
= pfile
->invocation_location
;
868 /* Take the token directly from the current context. We can do
869 this, because we are in the replacement list of either an
870 object-like macro, or a function-like macro with arguments
871 inserted. In either case, the constraints to #define
872 guarantee we have at least one more token. */
873 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
874 rhs
= FIRST (context
).token
++;
875 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
876 rhs
= *FIRST (context
).ptoken
++;
877 else if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
879 /* So we are in presence of an extended token context, which
880 means that each token in this context has a virtual
881 location attached to it. So let's not forget to update
882 the pointer to the current virtual location of the
883 current token when we update the pointer to the current
886 rhs
= *FIRST (context
).ptoken
++;
887 /* context->c.mc must be non-null, as if we were not in a
888 macro context, context->tokens_kind could not be equal to
889 TOKENS_KIND_EXTENDED. */
890 context
->c
.mc
->cur_virt_loc
++;
893 if (rhs
->type
== CPP_PADDING
)
895 if (rhs
->flags
& PASTE_LEFT
)
898 if (!paste_tokens (pfile
, virt_loc
, &lhs
, rhs
))
901 while (rhs
->flags
& PASTE_LEFT
);
903 /* Put the resulting token in its own context. */
904 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
906 source_location
*virt_locs
= NULL
;
907 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
908 tokens_buff_add_token (token_buf
, virt_locs
, lhs
,
909 virt_loc
, 0, NULL
, 0);
910 push_extended_tokens_context (pfile
, context
->c
.mc
->macro_node
,
911 token_buf
, virt_locs
,
912 (const cpp_token
**)token_buf
->base
, 1);
915 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
918 /* Returns TRUE if the number of arguments ARGC supplied in an
919 invocation of the MACRO referenced by NODE is valid. An empty
920 invocation to a macro with no parameters should pass ARGC as zero.
922 Note that MACRO cannot necessarily be deduced from NODE, in case
923 NODE was redefined whilst collecting arguments. */
925 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
927 if (argc
== macro
->paramc
)
930 if (argc
< macro
->paramc
)
932 /* In C++2a (here the va_opt flag is used), and also as a GNU
933 extension, variadic arguments are allowed to not appear in
934 the invocation at all.
935 e.g. #define debug(format, args...) something
938 This is exactly the same as if an empty variadic list had been
939 supplied - debug("string", ). */
941 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
943 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
944 && ! CPP_OPTION (pfile
, va_opt
))
946 if (CPP_OPTION (pfile
, cplusplus
))
947 cpp_error (pfile
, CPP_DL_PEDWARN
,
948 "ISO C++11 requires at least one argument "
949 "for the \"...\" in a variadic macro");
951 cpp_error (pfile
, CPP_DL_PEDWARN
,
952 "ISO C99 requires at least one argument "
953 "for the \"...\" in a variadic macro");
958 cpp_error (pfile
, CPP_DL_ERROR
,
959 "macro \"%s\" requires %u arguments, but only %u given",
960 NODE_NAME (node
), macro
->paramc
, argc
);
963 cpp_error (pfile
, CPP_DL_ERROR
,
964 "macro \"%s\" passed %u arguments, but takes just %u",
965 NODE_NAME (node
), argc
, macro
->paramc
);
970 /* Reads and returns the arguments to a function-like macro
971 invocation. Assumes the opening parenthesis has been processed.
972 If there is an error, emits an appropriate diagnostic and returns
973 NULL. Each argument is terminated by a CPP_EOF token, for the
974 future benefit of expand_arg(). If there are any deferred
975 #pragma directives among macro arguments, store pointers to the
976 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
978 What is returned is the buffer that contains the memory allocated
979 to hold the macro arguments. NODE is the name of the macro this
980 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
981 set to the actual number of macro arguments allocated in the
984 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
,
985 _cpp_buff
**pragma_buff
, unsigned *num_args
)
987 _cpp_buff
*buff
, *base_buff
;
989 macro_arg
*args
, *arg
;
990 const cpp_token
*token
;
992 source_location virt_loc
;
993 bool track_macro_expansion_p
= CPP_OPTION (pfile
, track_macro_expansion
);
994 unsigned num_args_alloced
= 0;
996 macro
= node
->value
.macro
;
998 argc
= macro
->paramc
;
1002 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
1003 #define ARG_TOKENS_EXTENT 1000
1005 buff
= _cpp_get_buff (pfile
, argc
* (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
1006 * sizeof (cpp_token
*)
1007 + sizeof (macro_arg
)));
1009 args
= (macro_arg
*) buff
->base
;
1010 memset (args
, 0, argc
* sizeof (macro_arg
));
1011 buff
->cur
= (unsigned char *) &args
[argc
];
1012 arg
= args
, argc
= 0;
1014 /* Collect the tokens making up each argument. We don't yet know
1015 how many arguments have been supplied, whether too many or too
1016 few. Hence the slightly bizarre usage of "argc" and "arg". */
1019 unsigned int paren_depth
= 0;
1020 unsigned int ntokens
= 0;
1021 unsigned virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
1025 arg
->first
= (const cpp_token
**) buff
->cur
;
1026 if (track_macro_expansion_p
)
1028 virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
1029 arg
->virt_locs
= XNEWVEC (source_location
,
1030 virt_locs_capacity
);
1035 /* Require space for 2 new tokens (including a CPP_EOF). */
1036 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
1038 buff
= _cpp_append_extend_buff (pfile
, buff
,
1040 * sizeof (cpp_token
*));
1041 arg
->first
= (const cpp_token
**) buff
->cur
;
1043 if (track_macro_expansion_p
1044 && (ntokens
+ 2 > virt_locs_capacity
))
1046 virt_locs_capacity
+= ARG_TOKENS_EXTENT
;
1047 arg
->virt_locs
= XRESIZEVEC (source_location
,
1049 virt_locs_capacity
);
1052 token
= cpp_get_token_1 (pfile
, &virt_loc
);
1054 if (token
->type
== CPP_PADDING
)
1056 /* Drop leading padding. */
1060 else if (token
->type
== CPP_OPEN_PAREN
)
1062 else if (token
->type
== CPP_CLOSE_PAREN
)
1064 if (paren_depth
-- == 0)
1067 else if (token
->type
== CPP_COMMA
)
1069 /* A comma does not terminate an argument within
1070 parentheses or as part of a variable argument. */
1071 if (paren_depth
== 0
1072 && ! (macro
->variadic
&& argc
== macro
->paramc
))
1075 else if (token
->type
== CPP_EOF
1076 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
1078 else if (token
->type
== CPP_PRAGMA
)
1080 cpp_token
*newtok
= _cpp_temp_token (pfile
);
1082 /* CPP_PRAGMA token lives in directive_result, which will
1083 be overwritten on the next directive. */
1088 if (*pragma_buff
== NULL
1089 || BUFF_ROOM (*pragma_buff
) < sizeof (cpp_token
*))
1092 if (*pragma_buff
== NULL
)
1094 = _cpp_get_buff (pfile
, 32 * sizeof (cpp_token
*));
1097 next
= *pragma_buff
;
1099 = _cpp_get_buff (pfile
,
1100 (BUFF_FRONT (*pragma_buff
)
1101 - (*pragma_buff
)->base
) * 2);
1102 (*pragma_buff
)->next
= next
;
1105 *(const cpp_token
**) BUFF_FRONT (*pragma_buff
) = token
;
1106 BUFF_FRONT (*pragma_buff
) += sizeof (cpp_token
*);
1107 if (token
->type
== CPP_PRAGMA_EOL
)
1109 token
= cpp_get_token_1 (pfile
, &virt_loc
);
1111 while (token
->type
!= CPP_EOF
);
1113 /* In deferred pragmas parsing_args and prevent_expansion
1114 had been changed, reset it. */
1115 pfile
->state
.parsing_args
= 2;
1116 pfile
->state
.prevent_expansion
= 1;
1118 if (token
->type
== CPP_EOF
)
1123 set_arg_token (arg
, token
, virt_loc
,
1124 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1125 CPP_OPTION (pfile
, track_macro_expansion
));
1129 /* Drop trailing padding. */
1130 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
1133 arg
->count
= ntokens
;
1134 set_arg_token (arg
, &pfile
->eof
, pfile
->eof
.src_loc
,
1135 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
1136 CPP_OPTION (pfile
, track_macro_expansion
));
1138 /* Terminate the argument. Excess arguments loop back and
1139 overwrite the final legitimate argument, before failing. */
1140 if (argc
<= macro
->paramc
)
1142 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
1143 if (argc
!= macro
->paramc
)
1147 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
1149 if (token
->type
== CPP_EOF
)
1151 /* We still need the CPP_EOF to end directives, and to end
1152 pre-expansion of a macro argument. Step back is not
1153 unconditional, since we don't want to return a CPP_EOF to our
1154 callers at the end of an -include-d file. */
1155 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
1156 _cpp_backup_tokens (pfile
, 1);
1157 cpp_error (pfile
, CPP_DL_ERROR
,
1158 "unterminated argument list invoking macro \"%s\"",
1163 /* A single empty argument is counted as no argument. */
1164 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
1166 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
1168 /* GCC has special semantics for , ## b where b is a varargs
1169 parameter: we remove the comma if b was omitted entirely.
1170 If b was merely an empty argument, the comma is retained.
1171 If the macro takes just one (varargs) parameter, then we
1172 retain the comma only if we are standards conforming.
1174 If FIRST is NULL replace_args () swallows the comma. */
1175 if (macro
->variadic
&& (argc
< macro
->paramc
1176 || (argc
== 1 && args
[0].count
== 0
1177 && !CPP_OPTION (pfile
, std
))))
1178 args
[macro
->paramc
- 1].first
= NULL
;
1180 *num_args
= num_args_alloced
;
1185 /* An error occurred. */
1186 _cpp_release_buff (pfile
, base_buff
);
1190 /* Search for an opening parenthesis to the macro of NODE, in such a
1191 way that, if none is found, we don't lose the information in any
1192 intervening padding tokens. If we find the parenthesis, collect
1193 the arguments and return the buffer containing them. PRAGMA_BUFF
1194 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
1195 *NUM_ARGS is set to the number of arguments contained in the
1198 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
1199 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1201 const cpp_token
*token
, *padding
= NULL
;
1205 token
= cpp_get_token (pfile
);
1206 if (token
->type
!= CPP_PADDING
)
1209 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
1213 if (token
->type
== CPP_OPEN_PAREN
)
1215 pfile
->state
.parsing_args
= 2;
1216 return collect_args (pfile
, node
, pragma_buff
, num_args
);
1219 /* CPP_EOF can be the end of macro arguments, or the end of the
1220 file. We mustn't back up over the latter. Ugh. */
1221 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
1223 /* Back up. We may have skipped padding, in which case backing
1224 up more than one token when expanding macros is in general
1225 too difficult. We re-insert it in its own context. */
1226 _cpp_backup_tokens (pfile
, 1);
1228 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
1234 /* Return the real number of tokens in the expansion of MACRO. */
1235 static inline unsigned int
1236 macro_real_token_count (const cpp_macro
*macro
)
1239 if (__builtin_expect (!macro
->extra_tokens
, true))
1240 return macro
->count
;
1241 for (i
= 0; i
< macro
->count
; i
++)
1242 if (macro
->exp
.tokens
[i
].type
== CPP_PASTE
)
1247 /* Push the context of a macro with hash entry NODE onto the context
1248 stack. If we can successfully expand the macro, we push a context
1249 containing its yet-to-be-rescanned replacement list and return one.
1250 If there were additionally any unexpanded deferred #pragma
1251 directives among macro arguments, push another context containing
1252 the pragma tokens before the yet-to-be-rescanned replacement list
1253 and return two. Otherwise, we don't push a context and return
1254 zero. LOCATION is the location of the expansion point of the
1257 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
1258 const cpp_token
*result
, source_location location
)
1260 /* The presence of a macro invalidates a file's controlling macro. */
1261 pfile
->mi_valid
= false;
1263 pfile
->state
.angled_headers
= false;
1265 /* From here to when we push the context for the macro later down
1266 this function, we need to flag the fact that we are about to
1267 expand a macro. This is useful when -ftrack-macro-expansion is
1268 turned off. In that case, we need to record the location of the
1269 expansion point of the top-most macro we are about to to expand,
1270 into pfile->invocation_location. But we must not record any such
1271 location once the process of expanding the macro starts; that is,
1272 we must not do that recording between now and later down this
1273 function where set this flag to FALSE. */
1274 pfile
->about_to_expand_macro_p
= true;
1276 if ((node
->flags
& NODE_BUILTIN
) && !(node
->flags
& NODE_USED
))
1278 node
->flags
|= NODE_USED
;
1279 if ((!pfile
->cb
.user_builtin_macro
1280 || !pfile
->cb
.user_builtin_macro (pfile
, node
))
1281 && pfile
->cb
.used_define
)
1282 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1285 /* Handle standard macros. */
1286 if (! (node
->flags
& NODE_BUILTIN
))
1288 cpp_macro
*macro
= node
->value
.macro
;
1289 _cpp_buff
*pragma_buff
= NULL
;
1291 if (macro
->fun_like
)
1294 unsigned num_args
= 0;
1296 pfile
->state
.prevent_expansion
++;
1297 pfile
->keep_tokens
++;
1298 pfile
->state
.parsing_args
= 1;
1299 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
,
1301 pfile
->state
.parsing_args
= 0;
1302 pfile
->keep_tokens
--;
1303 pfile
->state
.prevent_expansion
--;
1307 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
1308 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1309 "function-like macro \"%s\" must be used with arguments in traditional C",
1313 _cpp_release_buff (pfile
, pragma_buff
);
1315 pfile
->about_to_expand_macro_p
= false;
1319 if (macro
->paramc
> 0)
1320 replace_args (pfile
, node
, macro
,
1321 (macro_arg
*) buff
->base
,
1323 /* Free the memory used by the arguments of this
1324 function-like macro. This memory has been allocated by
1325 funlike_invocation_p and by replace_args. */
1326 delete_macro_args (buff
, num_args
);
1329 /* Disable the macro within its expansion. */
1330 node
->flags
|= NODE_DISABLED
;
1332 if (!(node
->flags
& NODE_USED
))
1334 node
->flags
|= NODE_USED
;
1335 if (pfile
->cb
.used_define
)
1336 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1340 pfile
->cb
.used (pfile
, location
, node
);
1344 if (macro
->paramc
== 0)
1346 unsigned tokens_count
= macro_real_token_count (macro
);
1347 if (CPP_OPTION (pfile
, track_macro_expansion
))
1350 const cpp_token
*src
= macro
->exp
.tokens
;
1351 const line_map_macro
*map
;
1352 source_location
*virt_locs
= NULL
;
1353 _cpp_buff
*macro_tokens
1354 = tokens_buff_new (pfile
, tokens_count
, &virt_locs
);
1356 /* Create a macro map to record the locations of the
1357 tokens that are involved in the expansion. LOCATION
1358 is the location of the macro expansion point. */
1359 map
= linemap_enter_macro (pfile
->line_table
,
1360 node
, location
, tokens_count
);
1361 for (i
= 0; i
< tokens_count
; ++i
)
1363 tokens_buff_add_token (macro_tokens
, virt_locs
,
1365 src
->src_loc
, map
, i
);
1368 push_extended_tokens_context (pfile
, node
,
1371 (const cpp_token
**)
1376 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
,
1378 num_macro_tokens_counter
+= tokens_count
;
1383 if (!pfile
->state
.in_directive
)
1384 _cpp_push_token_context (pfile
, NULL
,
1385 padding_token (pfile
, result
), 1);
1388 unsigned tokens_count
;
1389 _cpp_buff
*tail
= pragma_buff
->next
;
1390 pragma_buff
->next
= NULL
;
1391 tokens_count
= ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
1392 - (const cpp_token
**) pragma_buff
->base
);
1393 push_ptoken_context (pfile
, NULL
, pragma_buff
,
1394 (const cpp_token
**) pragma_buff
->base
,
1397 if (!CPP_OPTION (pfile
, track_macro_expansion
))
1398 num_macro_tokens_counter
+= tokens_count
;
1401 while (pragma_buff
!= NULL
);
1402 pfile
->about_to_expand_macro_p
= false;
1406 pfile
->about_to_expand_macro_p
= false;
1410 pfile
->about_to_expand_macro_p
= false;
1411 /* Handle built-in macros and the _Pragma operator. */
1413 source_location expand_loc
;
1415 if (/* The top-level macro invocation that triggered the expansion
1416 we are looking at is with a standard macro ... */
1417 !(pfile
->top_most_macro_node
->flags
& NODE_BUILTIN
)
1418 /* ... and it's a function-like macro invocation, */
1419 && pfile
->top_most_macro_node
->value
.macro
->fun_like
1420 /* ... and we are tracking the macro expansion. */
1421 && CPP_OPTION (pfile
, track_macro_expansion
))
1422 /* Then the location of the end of the macro invocation is the
1423 location of the expansion point of this macro. */
1424 expand_loc
= location
;
1426 /* Otherwise, the location of the end of the macro invocation is
1427 the location of the expansion point of that top-level macro
1429 expand_loc
= pfile
->invocation_location
;
1431 return builtin_macro (pfile
, node
, location
, expand_loc
);
1435 /* De-allocate the memory used by BUFF which is an array of instances
1436 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1439 delete_macro_args (_cpp_buff
*buff
, unsigned num_args
)
1441 macro_arg
*macro_args
;
1447 macro_args
= (macro_arg
*) buff
->base
;
1449 /* Walk instances of macro_arg to free their expanded tokens as well
1450 as their macro_arg::virt_locs members. */
1451 for (i
= 0; i
< num_args
; ++i
)
1453 if (macro_args
[i
].expanded
)
1455 free (macro_args
[i
].expanded
);
1456 macro_args
[i
].expanded
= NULL
;
1458 if (macro_args
[i
].virt_locs
)
1460 free (macro_args
[i
].virt_locs
);
1461 macro_args
[i
].virt_locs
= NULL
;
1463 if (macro_args
[i
].expanded_virt_locs
)
1465 free (macro_args
[i
].expanded_virt_locs
);
1466 macro_args
[i
].expanded_virt_locs
= NULL
;
1469 _cpp_free_buff (buff
);
1472 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1473 to set, LOCATION is its virtual location. "Virtual" location means
1474 the location that encodes loci across macro expansion. Otherwise
1475 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1476 argument ARG is supposed to contain. Note that ARG must be
1477 tailored so that it has enough room to contain INDEX + 1 numbers of
1478 tokens, at least. */
1480 set_arg_token (macro_arg
*arg
, const cpp_token
*token
,
1481 source_location location
, size_t index
,
1482 enum macro_arg_token_kind kind
,
1483 bool track_macro_exp_p
)
1485 const cpp_token
**token_ptr
;
1486 source_location
*loc
= NULL
;
1489 arg_token_ptr_at (arg
, index
, kind
,
1490 track_macro_exp_p
? &loc
: NULL
);
1495 /* We can't set the location of a stringified argument
1496 token and we can't set any location if we aren't tracking
1497 macro expansion locations. */
1498 gcc_checking_assert (kind
!= MACRO_ARG_TOKEN_STRINGIFIED
1499 && track_macro_exp_p
);
1504 /* Get the pointer to the location of the argument token of the
1505 function-like macro argument ARG. This function must be called
1506 only when we -ftrack-macro-expansion is on. */
1507 static const source_location
*
1508 get_arg_token_location (const macro_arg
*arg
,
1509 enum macro_arg_token_kind kind
)
1511 const source_location
*loc
= NULL
;
1512 const cpp_token
**token_ptr
=
1513 arg_token_ptr_at (arg
, 0, kind
, (source_location
**) &loc
);
1515 if (token_ptr
== NULL
)
1521 /* Return the pointer to the INDEXth token of the macro argument ARG.
1522 KIND specifies the kind of token the macro argument ARG contains.
1523 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1524 of the virtual location of the returned token if the
1525 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1526 spelling location of the returned token. */
1527 static const cpp_token
**
1528 arg_token_ptr_at (const macro_arg
*arg
, size_t index
,
1529 enum macro_arg_token_kind kind
,
1530 source_location
**virt_location
)
1532 const cpp_token
**tokens_ptr
= NULL
;
1536 case MACRO_ARG_TOKEN_NORMAL
:
1537 tokens_ptr
= arg
->first
;
1539 case MACRO_ARG_TOKEN_STRINGIFIED
:
1540 tokens_ptr
= (const cpp_token
**) &arg
->stringified
;
1542 case MACRO_ARG_TOKEN_EXPANDED
:
1543 tokens_ptr
= arg
->expanded
;
1547 if (tokens_ptr
== NULL
)
1548 /* This can happen for e.g, an empty token argument to a
1549 funtion-like macro. */
1554 if (kind
== MACRO_ARG_TOKEN_NORMAL
)
1555 *virt_location
= &arg
->virt_locs
[index
];
1556 else if (kind
== MACRO_ARG_TOKEN_EXPANDED
)
1557 *virt_location
= &arg
->expanded_virt_locs
[index
];
1558 else if (kind
== MACRO_ARG_TOKEN_STRINGIFIED
)
1560 (source_location
*) &tokens_ptr
[index
]->src_loc
;
1562 return &tokens_ptr
[index
];
1565 /* Initialize an iterator so that it iterates over the tokens of a
1566 function-like macro argument. KIND is the kind of tokens we want
1567 ITER to iterate over. TOKEN_PTR points the first token ITER will
1570 macro_arg_token_iter_init (macro_arg_token_iter
*iter
,
1571 bool track_macro_exp_p
,
1572 enum macro_arg_token_kind kind
,
1573 const macro_arg
*arg
,
1574 const cpp_token
**token_ptr
)
1576 iter
->track_macro_exp_p
= track_macro_exp_p
;
1578 iter
->token_ptr
= token_ptr
;
1579 /* Unconditionally initialize this so that the compiler doesn't warn
1580 about iter->location_ptr being possibly uninitialized later after
1581 this code has been inlined somewhere. */
1582 iter
->location_ptr
= NULL
;
1583 if (track_macro_exp_p
)
1584 iter
->location_ptr
= get_arg_token_location (arg
, kind
);
1586 iter
->num_forwards
= 0;
1587 if (track_macro_exp_p
1588 && token_ptr
!= NULL
1589 && iter
->location_ptr
== NULL
)
1594 /* Move the iterator one token forward. Note that if IT was
1595 initialized on an argument that has a stringified token, moving it
1596 forward doesn't make sense as a stringified token is essentially one
1599 macro_arg_token_iter_forward (macro_arg_token_iter
*it
)
1603 case MACRO_ARG_TOKEN_NORMAL
:
1604 case MACRO_ARG_TOKEN_EXPANDED
:
1606 if (it
->track_macro_exp_p
)
1609 case MACRO_ARG_TOKEN_STRINGIFIED
:
1611 if (it
->num_forwards
> 0)
1622 /* Return the token pointed to by the iterator. */
1623 static const cpp_token
*
1624 macro_arg_token_iter_get_token (const macro_arg_token_iter
*it
)
1627 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1628 && it
->num_forwards
> 0)
1631 if (it
->token_ptr
== NULL
)
1633 return *it
->token_ptr
;
1636 /* Return the location of the token pointed to by the iterator.*/
1637 static source_location
1638 macro_arg_token_iter_get_location (const macro_arg_token_iter
*it
)
1641 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1642 && it
->num_forwards
> 0)
1645 if (it
->track_macro_exp_p
)
1646 return *it
->location_ptr
;
1648 return (*it
->token_ptr
)->src_loc
;
1651 /* Return the index of a token [resulting from macro expansion] inside
1652 the total list of tokens resulting from a given macro
1653 expansion. The index can be different depending on whether if we
1654 want each tokens resulting from function-like macro arguments
1655 expansion to have a different location or not.
1657 E.g, consider this function-like macro:
1661 Then consider us "calling" it (and thus expanding it) like:
1665 It will be expanded into:
1669 Let's consider the case of the token '4'.
1671 Its index can be 2 (it's the third token of the set of tokens
1672 resulting from the expansion) or it can be 0 if we consider that
1673 all tokens resulting from the expansion of the argument "1+2" have
1674 the same index, which is 0. In this later case, the index of token
1675 '-' would then be 1 and the index of token '3' would be 2.
1677 The later case is useful to use less memory e.g, for the case of
1678 the user using the option -ftrack-macro-expansion=1.
1680 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1681 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1682 parameter (inside the macro replacement list) that corresponds to
1683 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1686 If we refer to the example above, for the '4' argument token,
1687 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1688 would be set to the token 'x', in the replacement list "x - 3" of
1691 This is a subroutine of replace_args. */
1692 inline static unsigned
1693 expanded_token_index (cpp_reader
*pfile
, cpp_macro
*macro
,
1694 const cpp_token
*cur_replacement_token
,
1695 unsigned absolute_token_index
)
1697 if (CPP_OPTION (pfile
, track_macro_expansion
) > 1)
1698 return absolute_token_index
;
1699 return cur_replacement_token
- macro
->exp
.tokens
;
1702 /* Copy whether PASTE_LEFT is set from SRC to *PASTE_FLAG. */
1705 copy_paste_flag (cpp_reader
*pfile
, const cpp_token
**paste_flag
,
1706 const cpp_token
*src
)
1708 cpp_token
*token
= _cpp_temp_token (pfile
);
1709 token
->type
= (*paste_flag
)->type
;
1710 token
->val
= (*paste_flag
)->val
;
1711 if (src
->flags
& PASTE_LEFT
)
1712 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1714 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1715 *paste_flag
= token
;
1718 /* True IFF the last token emitted into BUFF (if any) is PTR. */
1721 last_token_is (_cpp_buff
*buff
, const cpp_token
**ptr
)
1723 return (ptr
&& tokens_buff_last_token_ptr (buff
) == ptr
);
1726 /* Replace the parameters in a function-like macro of NODE with the
1727 actual ARGS, and place the result in a newly pushed token context.
1728 Expand each argument before replacing, unless it is operated upon
1729 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1730 the expansion point of the macro. E.g, the location of the
1731 function-like macro invocation. */
1733 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
,
1734 macro_arg
*args
, source_location expansion_point_loc
)
1736 unsigned int i
, total
;
1737 const cpp_token
*src
, *limit
;
1738 const cpp_token
**first
= NULL
;
1740 _cpp_buff
*buff
= NULL
;
1741 source_location
*virt_locs
= NULL
;
1742 unsigned int exp_count
;
1743 const line_map_macro
*map
= NULL
;
1744 int track_macro_exp
;
1746 /* First, fully macro-expand arguments, calculating the number of
1747 tokens in the final expansion as we go. The ordering of the if
1748 statements below is subtle; we must handle stringification before
1751 /* EXP_COUNT is the number of tokens in the macro replacement
1752 list. TOTAL is the number of tokens /after/ macro parameters
1753 have been replaced by their arguments. */
1754 exp_count
= macro_real_token_count (macro
);
1756 limit
= macro
->exp
.tokens
+ exp_count
;
1758 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1759 if (src
->type
== CPP_MACRO_ARG
)
1761 /* Leading and trailing padding tokens. */
1763 /* Account for leading and padding tokens in exp_count too.
1764 This is going to be important later down this function,
1765 when we want to handle the case of (track_macro_exp <
1769 /* We have an argument. If it is not being stringified or
1770 pasted it is macro-replaced before insertion. */
1771 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
1773 if (src
->flags
& STRINGIFY_ARG
)
1775 if (!arg
->stringified
)
1776 arg
->stringified
= stringify_arg (pfile
, arg
);
1778 else if ((src
->flags
& PASTE_LEFT
)
1779 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
1780 total
+= arg
->count
- 1;
1784 expand_arg (pfile
, arg
);
1785 total
+= arg
->expanded_count
- 1;
1789 /* When the compiler is called with the -ftrack-macro-expansion
1790 flag, we need to keep track of the location of each token that
1791 results from macro expansion.
1793 A token resulting from macro expansion is not a new token. It is
1794 simply the same token as the token coming from the macro
1795 definition. The new things that are allocated are the buffer
1796 that holds the tokens resulting from macro expansion and a new
1797 location that records many things like the locus of the expansion
1798 point as well as the original locus inside the definition of the
1799 macro. This location is called a virtual location.
1801 So the buffer BUFF holds a set of cpp_token*, and the buffer
1802 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1804 Both of these two buffers are going to be hung off of the macro
1805 context, when the latter is pushed. The memory allocated to
1806 store the tokens and their locations is going to be freed once
1807 the context of macro expansion is popped.
1809 As far as tokens are concerned, the memory overhead of
1810 -ftrack-macro-expansion is proportional to the number of
1811 macros that get expanded multiplied by sizeof (source_location).
1812 The good news is that extra memory gets freed when the macro
1813 context is freed, i.e shortly after the macro got expanded. */
1815 /* Is the -ftrack-macro-expansion flag in effect? */
1816 track_macro_exp
= CPP_OPTION (pfile
, track_macro_expansion
);
1818 /* Now allocate memory space for tokens and locations resulting from
1819 the macro expansion, copy the tokens and replace the arguments.
1820 This memory must be freed when the context of the macro MACRO is
1822 buff
= tokens_buff_new (pfile
, total
, track_macro_exp
? &virt_locs
: NULL
);
1824 first
= (const cpp_token
**) buff
->base
;
1826 /* Create a macro map to record the locations of the tokens that are
1827 involved in the expansion. Note that the expansion point is set
1828 to the location of the closing parenthesis. Otherwise, the
1829 subsequent map created for the first token that comes after the
1830 macro map might have a wrong line number. That would lead to
1831 tokens with wrong line numbers after the macro expansion. This
1832 adds up to the memory overhead of the -ftrack-macro-expansion
1833 flag; for every macro that is expanded, a "macro map" is
1835 if (track_macro_exp
)
1837 int num_macro_tokens
= total
;
1838 if (track_macro_exp
< 2)
1839 /* Then the number of macro tokens won't take in account the
1840 fact that function-like macro arguments can expand to
1841 multiple tokens. This is to save memory at the expense of
1844 Suppose we have #define SQUARE(A) A * A
1846 And then we do SQUARE(2+3)
1848 Then the tokens 2, +, 3, will have the same location,
1849 saying they come from the expansion of the argument A. */
1850 num_macro_tokens
= exp_count
;
1851 map
= linemap_enter_macro (pfile
->line_table
, node
,
1852 expansion_point_loc
,
1856 vaopt_state
vaopt_tracker (pfile
, macro
->variadic
,
1857 args
[macro
->paramc
- 1].count
> 0);
1858 const cpp_token
**vaopt_start
= NULL
;
1859 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1861 unsigned int arg_tokens_count
;
1862 macro_arg_token_iter from
;
1863 const cpp_token
**paste_flag
= NULL
;
1864 const cpp_token
**tmp_token_ptr
;
1866 /* __VA_OPT__ handling. */
1867 vaopt_state::update_type vostate
= vaopt_tracker
.update (src
);
1868 if (vostate
!= vaopt_state::INCLUDE
)
1870 if (vostate
== vaopt_state::BEGIN
)
1872 /* Padding on the left of __VA_OPT__ (unless RHS of ##). */
1873 if (src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
1875 const cpp_token
*t
= padding_token (pfile
, src
);
1876 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
1877 /* Allocate a virtual location for the padding token and
1878 append the token and its location to BUFF and
1880 tokens_buff_add_token (buff
, virt_locs
, t
,
1881 t
->src_loc
, t
->src_loc
,
1884 vaopt_start
= tokens_buff_last_token_ptr (buff
);
1886 else if (vostate
== vaopt_state::END
)
1888 const cpp_token
**start
= vaopt_start
;
1891 /* Remove any tail padding from inside the __VA_OPT__. */
1892 paste_flag
= tokens_buff_last_token_ptr (buff
);
1893 while (paste_flag
&& paste_flag
!= start
1894 && (*paste_flag
)->type
== CPP_PADDING
)
1896 tokens_buff_remove_last_token (buff
);
1897 paste_flag
= tokens_buff_last_token_ptr (buff
);
1900 if (src
->flags
& PASTE_LEFT
)
1902 /* With a non-empty __VA_OPT__ on the LHS of ##, the last
1903 token should be flagged PASTE_LEFT. */
1904 if (paste_flag
&& (*paste_flag
)->type
!= CPP_PADDING
)
1905 copy_paste_flag (pfile
, paste_flag
, src
);
1909 /* Otherwise, avoid paste on RHS, __VA_OPT__(c)d or
1910 __VA_OPT__(c)__VA_OPT__(d). */
1911 const cpp_token
*t
= &pfile
->avoid_paste
;
1912 tokens_buff_add_token (buff
, virt_locs
,
1913 t
, t
->src_loc
, t
->src_loc
,
1920 if (src
->type
!= CPP_MACRO_ARG
)
1922 /* Allocate a virtual location for token SRC, and add that
1923 token and its virtual location into the buffers BUFF and
1925 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
1926 tokens_buff_add_token (buff
, virt_locs
, src
,
1927 src
->src_loc
, src
->src_loc
,
1934 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
1935 /* SRC is a macro parameter that we need to replace with its
1936 corresponding argument. So at some point we'll need to
1937 iterate over the tokens of the macro argument and copy them
1938 into the "place" now holding the correspondig macro
1939 parameter. We are going to use the iterator type
1940 macro_argo_token_iter to handle that iterating. The 'if'
1941 below is to initialize the iterator depending on the type of
1942 tokens the macro argument has. It also does some adjustment
1943 related to padding tokens and some pasting corner cases. */
1944 if (src
->flags
& STRINGIFY_ARG
)
1946 arg_tokens_count
= 1;
1947 macro_arg_token_iter_init (&from
,
1949 track_macro_expansion
),
1950 MACRO_ARG_TOKEN_STRINGIFIED
,
1951 arg
, &arg
->stringified
);
1953 else if (src
->flags
& PASTE_LEFT
)
1955 arg_tokens_count
= arg
->count
;
1956 macro_arg_token_iter_init (&from
,
1958 track_macro_expansion
),
1959 MACRO_ARG_TOKEN_NORMAL
,
1962 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
1965 arg_tokens_count
= arg
->count
;
1966 macro_arg_token_iter_init (&from
,
1968 track_macro_expansion
),
1969 MACRO_ARG_TOKEN_NORMAL
,
1972 num_toks
= tokens_buff_count (buff
);
1976 /* So the current parameter token is pasted to the previous
1977 token in the replacement list. Let's look at what
1978 we have as previous and current arguments. */
1980 /* This is the previous argument's token ... */
1981 tmp_token_ptr
= tokens_buff_last_token_ptr (buff
);
1983 if ((*tmp_token_ptr
)->type
== CPP_COMMA
1985 && src
->val
.macro_arg
.arg_no
== macro
->paramc
)
1987 /* ... which is a comma; and the current parameter
1988 is the last parameter of a variadic function-like
1989 macro. If the argument to the current last
1990 parameter is NULL, then swallow the comma,
1991 otherwise drop the paste flag. */
1992 if (macro_arg_token_iter_get_token (&from
) == NULL
)
1993 tokens_buff_remove_last_token (buff
);
1995 paste_flag
= tmp_token_ptr
;
1997 /* Remove the paste flag if the RHS is a placemarker, unless the
1998 previous emitted token is at the beginning of __VA_OPT__;
1999 placemarkers within __VA_OPT__ are ignored in that case. */
2000 else if (arg_tokens_count
== 0
2001 && tmp_token_ptr
!= vaopt_start
)
2002 paste_flag
= tmp_token_ptr
;
2007 arg_tokens_count
= arg
->expanded_count
;
2008 macro_arg_token_iter_init (&from
,
2010 track_macro_expansion
),
2011 MACRO_ARG_TOKEN_EXPANDED
,
2012 arg
, arg
->expanded
);
2014 if (last_token_is (buff
, vaopt_start
))
2016 /* We're expanding an arg at the beginning of __VA_OPT__.
2018 while (arg_tokens_count
)
2020 const cpp_token
*t
= macro_arg_token_iter_get_token (&from
);
2021 if (t
->type
!= CPP_PADDING
)
2023 macro_arg_token_iter_forward (&from
);
2029 /* Padding on the left of an argument (unless RHS of ##). */
2030 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
2031 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
)
2032 && !last_token_is (buff
, vaopt_start
))
2034 const cpp_token
*t
= padding_token (pfile
, src
);
2035 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
2036 /* Allocate a virtual location for the padding token and
2037 append the token and its location to BUFF and
2039 tokens_buff_add_token (buff
, virt_locs
, t
,
2040 t
->src_loc
, t
->src_loc
,
2044 if (arg_tokens_count
)
2046 /* So now we've got the number of tokens that make up the
2047 argument that is going to replace the current parameter
2048 in the macro's replacement list. */
2050 for (j
= 0; j
< arg_tokens_count
; ++j
)
2052 /* So if track_macro_exp is < 2, the user wants to
2053 save extra memory while tracking macro expansion
2054 locations. So in that case here is what we do:
2056 Suppose we have #define SQUARE(A) A * A
2058 And then we do SQUARE(2+3)
2060 Then the tokens 2, +, 3, will have the same location,
2061 saying they come from the expansion of the argument
2064 So that means we are going to ignore the COUNT tokens
2065 resulting from the expansion of the current macro
2066 argument. In other words all the ARG_TOKENS_COUNT tokens
2067 resulting from the expansion of the macro argument will
2068 have the index I. Normally, each of those tokens should
2070 unsigned token_index
= i
;
2072 if (track_macro_exp
> 1)
2075 index
= expanded_token_index (pfile
, macro
, src
, token_index
);
2076 tokens_buff_add_token (buff
, virt_locs
,
2077 macro_arg_token_iter_get_token (&from
),
2078 macro_arg_token_iter_get_location (&from
),
2079 src
->src_loc
, map
, index
);
2080 macro_arg_token_iter_forward (&from
);
2083 /* With a non-empty argument on the LHS of ##, the last
2084 token should be flagged PASTE_LEFT. */
2085 if (src
->flags
& PASTE_LEFT
)
2087 = (const cpp_token
**) tokens_buff_last_token_ptr (buff
);
2089 else if (CPP_PEDANTIC (pfile
) && ! CPP_OPTION (pfile
, c99
)
2090 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2092 if (CPP_OPTION (pfile
, cplusplus
))
2093 cpp_pedwarning (pfile
, CPP_W_PEDANTIC
,
2094 "invoking macro %s argument %d: "
2095 "empty macro arguments are undefined"
2097 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2098 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
))
2099 cpp_pedwarning (pfile
,
2100 CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2101 ? CPP_W_C90_C99_COMPAT
: CPP_W_PEDANTIC
,
2102 "invoking macro %s argument %d: "
2103 "empty macro arguments are undefined"
2105 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2107 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2108 && ! CPP_OPTION (pfile
, cplusplus
)
2109 && ! macro
->syshdr
&& ! cpp_in_system_header (pfile
))
2110 cpp_warning (pfile
, CPP_W_C90_C99_COMPAT
,
2111 "invoking macro %s argument %d: "
2112 "empty macro arguments are undefined"
2114 NODE_NAME (node
), src
->val
.macro_arg
.arg_no
);
2116 /* Avoid paste on RHS (even case count == 0). */
2117 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
)
2118 && !last_token_is (buff
, vaopt_start
))
2120 const cpp_token
*t
= &pfile
->avoid_paste
;
2121 tokens_buff_add_token (buff
, virt_locs
,
2122 t
, t
->src_loc
, t
->src_loc
,
2126 /* Add a new paste flag, or remove an unwanted one. */
2128 copy_paste_flag (pfile
, paste_flag
, src
);
2130 i
+= arg_tokens_count
;
2133 if (track_macro_exp
)
2134 push_extended_tokens_context (pfile
, node
, buff
, virt_locs
, first
,
2135 tokens_buff_count (buff
));
2137 push_ptoken_context (pfile
, node
, buff
, first
,
2138 tokens_buff_count (buff
));
2140 num_macro_tokens_counter
+= tokens_buff_count (buff
);
2143 /* Return a special padding token, with padding inherited from SOURCE. */
2144 static const cpp_token
*
2145 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
2147 cpp_token
*result
= _cpp_temp_token (pfile
);
2149 result
->type
= CPP_PADDING
;
2151 /* Data in GCed data structures cannot be made const so far, so we
2152 need a cast here. */
2153 result
->val
.source
= (cpp_token
*) source
;
2158 /* Get a new uninitialized context. Create a new one if we cannot
2159 re-use an old one. */
2160 static cpp_context
*
2161 next_context (cpp_reader
*pfile
)
2163 cpp_context
*result
= pfile
->context
->next
;
2167 result
= XNEW (cpp_context
);
2168 memset (result
, 0, sizeof (cpp_context
));
2169 result
->prev
= pfile
->context
;
2171 pfile
->context
->next
= result
;
2174 pfile
->context
= result
;
2178 /* Push a list of pointers to tokens. */
2180 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
2181 const cpp_token
**first
, unsigned int count
)
2183 cpp_context
*context
= next_context (pfile
);
2185 context
->tokens_kind
= TOKENS_KIND_INDIRECT
;
2186 context
->c
.macro
= macro
;
2187 context
->buff
= buff
;
2188 FIRST (context
).ptoken
= first
;
2189 LAST (context
).ptoken
= first
+ count
;
2192 /* Push a list of tokens.
2194 A NULL macro means that we should continue the current macro
2195 expansion, in essence. That means that if we are currently in a
2196 macro expansion context, we'll make the new pfile->context refer to
2197 the current macro. */
2199 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2200 const cpp_token
*first
, unsigned int count
)
2202 cpp_context
*context
;
2205 macro
= macro_of_context (pfile
->context
);
2207 context
= next_context (pfile
);
2208 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2209 context
->c
.macro
= macro
;
2210 context
->buff
= NULL
;
2211 FIRST (context
).token
= first
;
2212 LAST (context
).token
= first
+ count
;
2215 /* Build a context containing a list of tokens as well as their
2216 virtual locations and push it. TOKENS_BUFF is the buffer that
2217 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
2218 non-NULL, it means that the context owns it, meaning that
2219 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
2220 contains the virtual locations.
2222 A NULL macro means that we should continue the current macro
2223 expansion, in essence. That means that if we are currently in a
2224 macro expansion context, we'll make the new pfile->context refer to
2225 the current macro. */
2227 push_extended_tokens_context (cpp_reader
*pfile
,
2228 cpp_hashnode
*macro
,
2229 _cpp_buff
*token_buff
,
2230 source_location
*virt_locs
,
2231 const cpp_token
**first
,
2234 cpp_context
*context
;
2238 macro
= macro_of_context (pfile
->context
);
2240 context
= next_context (pfile
);
2241 context
->tokens_kind
= TOKENS_KIND_EXTENDED
;
2242 context
->buff
= token_buff
;
2244 m
= XNEW (macro_context
);
2245 m
->macro_node
= macro
;
2246 m
->virt_locs
= virt_locs
;
2247 m
->cur_virt_loc
= virt_locs
;
2249 FIRST (context
).ptoken
= first
;
2250 LAST (context
).ptoken
= first
+ count
;
2253 /* Push a traditional macro's replacement text. */
2255 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
2256 const uchar
*start
, size_t len
)
2258 cpp_context
*context
= next_context (pfile
);
2260 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
2261 context
->c
.macro
= macro
;
2262 context
->buff
= NULL
;
2263 CUR (context
) = start
;
2264 RLIMIT (context
) = start
+ len
;
2265 macro
->flags
|= NODE_DISABLED
;
2268 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
2269 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
2270 non-null (which means that -ftrack-macro-expansion is on),
2271 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
2272 hold the virtual locations of the tokens resulting from macro
2275 tokens_buff_new (cpp_reader
*pfile
, size_t len
,
2276 source_location
**virt_locs
)
2278 size_t tokens_size
= len
* sizeof (cpp_token
*);
2279 size_t locs_size
= len
* sizeof (source_location
);
2281 if (virt_locs
!= NULL
)
2282 *virt_locs
= XNEWVEC (source_location
, locs_size
);
2283 return _cpp_get_buff (pfile
, tokens_size
);
2286 /* Returns the number of tokens contained in a token buffer. The
2287 buffer holds a set of cpp_token*. */
2289 tokens_buff_count (_cpp_buff
*buff
)
2291 return (BUFF_FRONT (buff
) - buff
->base
) / sizeof (cpp_token
*);
2294 /* Return a pointer to the last token contained in the token buffer
2296 static const cpp_token
**
2297 tokens_buff_last_token_ptr (_cpp_buff
*buff
)
2299 if (BUFF_FRONT (buff
) == buff
->base
)
2301 return &((const cpp_token
**) BUFF_FRONT (buff
))[-1];
2304 /* Remove the last token contained in the token buffer TOKENS_BUFF.
2305 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
2306 containing the virtual locations of the tokens in TOKENS_BUFF; in
2307 which case the function updates that buffer as well. */
2309 tokens_buff_remove_last_token (_cpp_buff
*tokens_buff
)
2312 if (BUFF_FRONT (tokens_buff
) > tokens_buff
->base
)
2313 BUFF_FRONT (tokens_buff
) =
2314 (unsigned char *) &((cpp_token
**) BUFF_FRONT (tokens_buff
))[-1];
2317 /* Insert a token into the token buffer at the position pointed to by
2318 DEST. Note that the buffer is not enlarged so the previous token
2319 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
2320 means -ftrack-macro-expansion is effect; it then points to where to
2321 insert the virtual location of TOKEN. TOKEN is the token to
2322 insert. VIRT_LOC is the virtual location of the token, i.e, the
2323 location possibly encoding its locus across macro expansion. If
2324 TOKEN is an argument of a function-like macro (inside a macro
2325 replacement list), PARM_DEF_LOC is the spelling location of the
2326 macro parameter that TOKEN is replacing, in the replacement list of
2327 the macro. If TOKEN is not an argument of a function-like macro or
2328 if it doesn't come from a macro expansion, then VIRT_LOC can just
2329 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
2330 means TOKEN comes from a macro expansion and MAP is the macro map
2331 associated to the macro. MACRO_TOKEN_INDEX points to the index of
2332 the token in the macro map; it is not considered if MAP is NULL.
2334 Upon successful completion this function returns the a pointer to
2335 the position of the token coming right after the insertion
2337 static inline const cpp_token
**
2338 tokens_buff_put_token_to (const cpp_token
**dest
,
2339 source_location
*virt_loc_dest
,
2340 const cpp_token
*token
,
2341 source_location virt_loc
,
2342 source_location parm_def_loc
,
2343 const line_map_macro
*map
,
2344 unsigned int macro_token_index
)
2346 source_location macro_loc
= virt_loc
;
2347 const cpp_token
**result
;
2351 /* -ftrack-macro-expansion is on. */
2353 macro_loc
= linemap_add_macro_token (map
, macro_token_index
,
2354 virt_loc
, parm_def_loc
);
2355 *virt_loc_dest
= macro_loc
;
2363 /* Adds a token at the end of the tokens contained in BUFFER. Note
2364 that this function doesn't enlarge BUFFER when the number of tokens
2365 reaches BUFFER's size; it aborts in that situation.
2367 TOKEN is the token to append. VIRT_LOC is the virtual location of
2368 the token, i.e, the location possibly encoding its locus across
2369 macro expansion. If TOKEN is an argument of a function-like macro
2370 (inside a macro replacement list), PARM_DEF_LOC is the location of
2371 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
2372 from a macro expansion, then VIRT_LOC can just be set to the same
2373 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
2374 from a macro expansion and MAP is the macro map associated to the
2375 macro. MACRO_TOKEN_INDEX points to the index of the token in the
2376 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
2377 non-null, it means -ftrack-macro-expansion is on; in which case
2378 this function adds the virtual location DEF_LOC to the VIRT_LOCS
2379 array, at the same index as the one of TOKEN in BUFFER. Upon
2380 successful completion this function returns the a pointer to the
2381 position of the token coming right after the insertion point. */
2382 static const cpp_token
**
2383 tokens_buff_add_token (_cpp_buff
*buffer
,
2384 source_location
*virt_locs
,
2385 const cpp_token
*token
,
2386 source_location virt_loc
,
2387 source_location parm_def_loc
,
2388 const line_map_macro
*map
,
2389 unsigned int macro_token_index
)
2391 const cpp_token
**result
;
2392 source_location
*virt_loc_dest
= NULL
;
2393 unsigned token_index
=
2394 (BUFF_FRONT (buffer
) - buffer
->base
) / sizeof (cpp_token
*);
2396 /* Abort if we pass the end the buffer. */
2397 if (BUFF_FRONT (buffer
) > BUFF_LIMIT (buffer
))
2400 if (virt_locs
!= NULL
)
2401 virt_loc_dest
= &virt_locs
[token_index
];
2404 tokens_buff_put_token_to ((const cpp_token
**) BUFF_FRONT (buffer
),
2405 virt_loc_dest
, token
, virt_loc
, parm_def_loc
,
2406 map
, macro_token_index
);
2408 BUFF_FRONT (buffer
) = (unsigned char *) result
;
2412 /* Allocate space for the function-like macro argument ARG to store
2413 the tokens resulting from the macro-expansion of the tokens that
2414 make up ARG itself. That space is allocated in ARG->expanded and
2415 needs to be freed using free. */
2417 alloc_expanded_arg_mem (cpp_reader
*pfile
, macro_arg
*arg
, size_t capacity
)
2419 gcc_checking_assert (arg
->expanded
== NULL
2420 && arg
->expanded_virt_locs
== NULL
);
2422 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
2423 if (CPP_OPTION (pfile
, track_macro_expansion
))
2424 arg
->expanded_virt_locs
= XNEWVEC (source_location
, capacity
);
2428 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2431 ensure_expanded_arg_room (cpp_reader
*pfile
, macro_arg
*arg
,
2432 size_t size
, size_t *expanded_capacity
)
2434 if (size
<= *expanded_capacity
)
2440 XRESIZEVEC (const cpp_token
*, arg
->expanded
, size
);
2441 *expanded_capacity
= size
;
2443 if (CPP_OPTION (pfile
, track_macro_expansion
))
2445 if (arg
->expanded_virt_locs
== NULL
)
2446 arg
->expanded_virt_locs
= XNEWVEC (source_location
, size
);
2448 arg
->expanded_virt_locs
= XRESIZEVEC (source_location
,
2449 arg
->expanded_virt_locs
,
2454 /* Expand an argument ARG before replacing parameters in a
2455 function-like macro. This works by pushing a context with the
2456 argument's tokens, and then expanding that into a temporary buffer
2457 as if it were a normal part of the token stream. collect_args()
2458 has terminated the argument's tokens with a CPP_EOF so that we know
2459 when we have fully expanded the argument. */
2461 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
2464 bool saved_warn_trad
;
2465 bool track_macro_exp_p
= CPP_OPTION (pfile
, track_macro_expansion
);
2468 || arg
->expanded
!= NULL
)
2471 /* Don't warn about funlike macros when pre-expanding. */
2472 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
2473 CPP_WTRADITIONAL (pfile
) = 0;
2475 /* Loop, reading in the tokens of the argument. */
2477 alloc_expanded_arg_mem (pfile
, arg
, capacity
);
2479 if (track_macro_exp_p
)
2480 push_extended_tokens_context (pfile
, NULL
, NULL
,
2485 push_ptoken_context (pfile
, NULL
, NULL
,
2486 arg
->first
, arg
->count
+ 1);
2490 const cpp_token
*token
;
2491 source_location location
;
2493 ensure_expanded_arg_room (pfile
, arg
, arg
->expanded_count
+ 1,
2496 token
= cpp_get_token_1 (pfile
, &location
);
2498 if (token
->type
== CPP_EOF
)
2501 set_arg_token (arg
, token
, location
,
2502 arg
->expanded_count
, MACRO_ARG_TOKEN_EXPANDED
,
2503 CPP_OPTION (pfile
, track_macro_expansion
));
2504 arg
->expanded_count
++;
2507 _cpp_pop_context (pfile
);
2509 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
2512 /* Returns the macro associated to the current context if we are in
2513 the context a macro expansion, NULL otherwise. */
2514 static cpp_hashnode
*
2515 macro_of_context (cpp_context
*context
)
2517 if (context
== NULL
)
2520 return (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2521 ? context
->c
.mc
->macro_node
2525 /* Return TRUE iff we are expanding a macro or are about to start
2526 expanding one. If we are effectively expanding a macro, the
2527 function macro_of_context returns a pointer to the macro being
2530 in_macro_expansion_p (cpp_reader
*pfile
)
2535 return (pfile
->about_to_expand_macro_p
2536 || macro_of_context (pfile
->context
));
2539 /* Pop the current context off the stack, re-enabling the macro if the
2540 context represented a macro's replacement list. Initially the
2541 context structure was not freed so that we can re-use it later, but
2542 now we do free it to reduce peak memory consumption. */
2544 _cpp_pop_context (cpp_reader
*pfile
)
2546 cpp_context
*context
= pfile
->context
;
2548 /* We should not be popping the base context. */
2549 if (context
== &pfile
->base_context
)
2552 if (context
->c
.macro
)
2554 cpp_hashnode
*macro
;
2555 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2557 macro_context
*mc
= context
->c
.mc
;
2558 macro
= mc
->macro_node
;
2559 /* If context->buff is set, it means the life time of tokens
2560 is bound to the life time of this context; so we must
2561 free the tokens; that means we must free the virtual
2562 locations of these tokens too. */
2563 if (context
->buff
&& mc
->virt_locs
)
2565 free (mc
->virt_locs
);
2566 mc
->virt_locs
= NULL
;
2569 context
->c
.mc
= NULL
;
2572 macro
= context
->c
.macro
;
2574 /* Beware that MACRO can be NULL in cases like when we are
2575 called from expand_arg. In those cases, a dummy context with
2576 tokens is pushed just for the purpose of walking them using
2577 cpp_get_token_1. In that case, no 'macro' field is set into
2578 the dummy context. */
2580 /* Several contiguous macro expansion contexts can be
2581 associated to the same macro; that means it's the same
2582 macro expansion that spans across all these (sub)
2583 contexts. So we should re-enable an expansion-disabled
2584 macro only when we are sure we are really out of that
2586 && macro_of_context (context
->prev
) != macro
)
2587 macro
->flags
&= ~NODE_DISABLED
;
2589 if (macro
== pfile
->top_most_macro_node
&& context
->prev
== NULL
)
2590 /* We are popping the context of the top-most macro node. */
2591 pfile
->top_most_macro_node
= NULL
;
2596 /* Decrease memory peak consumption by freeing the memory used
2598 _cpp_free_buff (context
->buff
);
2601 pfile
->context
= context
->prev
;
2602 /* decrease peak memory consumption by feeing the context. */
2603 pfile
->context
->next
= NULL
;
2607 /* Return TRUE if we reached the end of the set of tokens stored in
2608 CONTEXT, FALSE otherwise. */
2610 reached_end_of_context (cpp_context
*context
)
2612 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
2613 return FIRST (context
).token
== LAST (context
).token
;
2614 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
2615 || context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2616 return FIRST (context
).ptoken
== LAST (context
).ptoken
;
2621 /* Consume the next token contained in the current context of PFILE,
2622 and return it in *TOKEN. It's "full location" is returned in
2623 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2624 means the location encoding the locus of the token across macro
2625 expansion; otherwise it's just is the "normal" location of the
2626 token which (*TOKEN)->src_loc. */
2628 consume_next_token_from_context (cpp_reader
*pfile
,
2629 const cpp_token
** token
,
2630 source_location
*location
)
2632 cpp_context
*c
= pfile
->context
;
2634 if ((c
)->tokens_kind
== TOKENS_KIND_DIRECT
)
2636 *token
= FIRST (c
).token
;
2637 *location
= (*token
)->src_loc
;
2640 else if ((c
)->tokens_kind
== TOKENS_KIND_INDIRECT
)
2642 *token
= *FIRST (c
).ptoken
;
2643 *location
= (*token
)->src_loc
;
2646 else if ((c
)->tokens_kind
== TOKENS_KIND_EXTENDED
)
2648 macro_context
*m
= c
->c
.mc
;
2649 *token
= *FIRST (c
).ptoken
;
2652 *location
= *m
->cur_virt_loc
;
2656 *location
= (*token
)->src_loc
;
2663 /* In the traditional mode of the preprocessor, if we are currently in
2664 a directive, the location of a token must be the location of the
2665 start of the directive line. This function returns the proper
2666 location if we are in the traditional mode, and just returns
2667 LOCATION otherwise. */
2669 static inline source_location
2670 maybe_adjust_loc_for_trad_cpp (cpp_reader
*pfile
, source_location location
)
2672 if (CPP_OPTION (pfile
, traditional
))
2674 if (pfile
->state
.in_directive
)
2675 return pfile
->directive_line
;
2680 /* Routine to get a token as well as its location.
2682 Macro expansions and directives are transparently handled,
2683 including entering included files. Thus tokens are post-macro
2684 expansion, and after any intervening directives. External callers
2685 see CPP_EOF only at EOF. Internal callers also see it when meeting
2686 a directive inside a macro call, when at the end of a directive and
2687 state.in_directive is still 1, and at the end of argument
2690 LOC is an out parameter; *LOC is set to the location "as expected
2691 by the user". Please read the comment of
2692 cpp_get_token_with_location to learn more about the meaning of this
2694 static const cpp_token
*
2695 cpp_get_token_1 (cpp_reader
*pfile
, source_location
*location
)
2697 const cpp_token
*result
;
2698 /* This token is a virtual token that either encodes a location
2699 related to macro expansion or a spelling location. */
2700 source_location virt_loc
= 0;
2701 /* pfile->about_to_expand_macro_p can be overriden by indirect calls
2702 to functions that push macro contexts. So let's save it so that
2703 we can restore it when we are about to leave this routine. */
2704 bool saved_about_to_expand_macro
= pfile
->about_to_expand_macro_p
;
2709 cpp_context
*context
= pfile
->context
;
2711 /* Context->prev == 0 <=> base context. */
2714 result
= _cpp_lex_token (pfile
);
2715 virt_loc
= result
->src_loc
;
2717 else if (!reached_end_of_context (context
))
2719 consume_next_token_from_context (pfile
, &result
,
2721 if (result
->flags
& PASTE_LEFT
)
2723 paste_all_tokens (pfile
, result
);
2724 if (pfile
->state
.in_directive
)
2726 result
= padding_token (pfile
, result
);
2732 if (pfile
->context
->c
.macro
)
2733 ++num_expanded_macros_counter
;
2734 _cpp_pop_context (pfile
);
2735 if (pfile
->state
.in_directive
)
2737 result
= &pfile
->avoid_paste
;
2741 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
2744 if (result
->type
!= CPP_NAME
)
2747 node
= result
->val
.node
.node
;
2749 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
2752 if (!(node
->flags
& NODE_DISABLED
))
2755 /* If not in a macro context, and we're going to start an
2756 expansion, record the location and the top level macro
2757 about to be expanded. */
2758 if (!in_macro_expansion_p (pfile
))
2760 pfile
->invocation_location
= result
->src_loc
;
2761 pfile
->top_most_macro_node
= node
;
2763 if (pfile
->state
.prevent_expansion
)
2766 /* Conditional macros require that a predicate be evaluated
2768 if ((node
->flags
& NODE_CONDITIONAL
) != 0)
2770 if (pfile
->cb
.macro_to_expand
)
2772 bool whitespace_after
;
2773 const cpp_token
*peek_tok
= cpp_peek_token (pfile
, 0);
2775 whitespace_after
= (peek_tok
->type
== CPP_PADDING
2776 || (peek_tok
->flags
& PREV_WHITE
));
2777 node
= pfile
->cb
.macro_to_expand (pfile
, result
);
2779 ret
= enter_macro_context (pfile
, node
, result
,
2781 else if (whitespace_after
)
2783 /* If macro_to_expand hook returned NULL and it
2784 ate some tokens, see if we don't need to add
2785 a padding token in between this and the
2787 peek_tok
= cpp_peek_token (pfile
, 0);
2788 if (peek_tok
->type
!= CPP_PADDING
2789 && (peek_tok
->flags
& PREV_WHITE
) == 0)
2790 _cpp_push_token_context (pfile
, NULL
,
2791 padding_token (pfile
,
2797 ret
= enter_macro_context (pfile
, node
, result
,
2801 if (pfile
->state
.in_directive
|| ret
== 2)
2803 result
= padding_token (pfile
, result
);
2809 /* Flag this token as always unexpandable. FIXME: move this
2810 to collect_args()?. */
2811 cpp_token
*t
= _cpp_temp_token (pfile
);
2812 t
->type
= result
->type
;
2813 t
->flags
= result
->flags
| NO_EXPAND
;
2814 t
->val
= result
->val
;
2822 if (location
!= NULL
)
2825 virt_loc
= result
->src_loc
;
2826 *location
= virt_loc
;
2828 if (!CPP_OPTION (pfile
, track_macro_expansion
)
2829 && macro_of_context (pfile
->context
) != NULL
)
2830 /* We are in a macro expansion context, are not tracking
2831 virtual location, but were asked to report the location
2832 of the expansion point of the macro being expanded. */
2833 *location
= pfile
->invocation_location
;
2835 *location
= maybe_adjust_loc_for_trad_cpp (pfile
, *location
);
2838 pfile
->about_to_expand_macro_p
= saved_about_to_expand_macro
;
2842 /* External routine to get a token. Also used nearly everywhere
2843 internally, except for places where we know we can safely call
2844 _cpp_lex_token directly, such as lexing a directive name.
2846 Macro expansions and directives are transparently handled,
2847 including entering included files. Thus tokens are post-macro
2848 expansion, and after any intervening directives. External callers
2849 see CPP_EOF only at EOF. Internal callers also see it when meeting
2850 a directive inside a macro call, when at the end of a directive and
2851 state.in_directive is still 1, and at the end of argument
2854 cpp_get_token (cpp_reader
*pfile
)
2856 return cpp_get_token_1 (pfile
, NULL
);
2859 /* Like cpp_get_token, but also returns a virtual token location
2860 separate from the spelling location carried by the returned token.
2862 LOC is an out parameter; *LOC is set to the location "as expected
2863 by the user". This matters when a token results from macro
2864 expansion; in that case the token's spelling location indicates the
2865 locus of the token in the definition of the macro but *LOC
2866 virtually encodes all the other meaningful locuses associated to
2869 What? virtual location? Yes, virtual location.
2871 If the token results from macro expansion and if macro expansion
2872 location tracking is enabled its virtual location encodes (at the
2875 - the spelling location of the token
2877 - the locus of the macro expansion point
2879 - the locus of the point where the token got instantiated as part
2880 of the macro expansion process.
2882 You have to use the linemap API to get the locus you are interested
2883 in from a given virtual location.
2885 Note however that virtual locations are not necessarily ordered for
2886 relations '<' and '>'. One must use the function
2887 linemap_location_before_p instead of using the relational operator
2890 If macro expansion tracking is off and if the token results from
2891 macro expansion the virtual location is the expansion point of the
2892 macro that got expanded.
2894 When the token doesn't result from macro expansion, the virtual
2895 location is just the same thing as its spelling location. */
2898 cpp_get_token_with_location (cpp_reader
*pfile
, source_location
*loc
)
2900 return cpp_get_token_1 (pfile
, loc
);
2903 /* Returns true if we're expanding an object-like macro that was
2904 defined in a system header. Just checks the macro at the top of
2905 the stack. Used for diagnostic suppression. */
2907 cpp_sys_macro_p (cpp_reader
*pfile
)
2909 cpp_hashnode
*node
= NULL
;
2911 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2912 node
= pfile
->context
->c
.mc
->macro_node
;
2914 node
= pfile
->context
->c
.macro
;
2916 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
2919 /* Read each token in, until end of the current file. Directives are
2920 transparently processed. */
2922 cpp_scan_nooutput (cpp_reader
*pfile
)
2924 /* Request a CPP_EOF token at the end of this file, rather than
2925 transparently continuing with the including file. */
2926 pfile
->buffer
->return_at_eof
= true;
2928 pfile
->state
.discarding_output
++;
2929 pfile
->state
.prevent_expansion
++;
2931 if (CPP_OPTION (pfile
, traditional
))
2932 while (_cpp_read_logical_line_trad (pfile
))
2935 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
2938 pfile
->state
.discarding_output
--;
2939 pfile
->state
.prevent_expansion
--;
2942 /* Step back one or more tokens obtained from the lexer. */
2944 _cpp_backup_tokens_direct (cpp_reader
*pfile
, unsigned int count
)
2946 pfile
->lookaheads
+= count
;
2950 if (pfile
->cur_token
== pfile
->cur_run
->base
2951 /* Possible with -fpreprocessed and no leading #line. */
2952 && pfile
->cur_run
->prev
!= NULL
)
2954 pfile
->cur_run
= pfile
->cur_run
->prev
;
2955 pfile
->cur_token
= pfile
->cur_run
->limit
;
2960 /* Step back one (or more) tokens. Can only step back more than 1 if
2961 they are from the lexer, and not from macro expansion. */
2963 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
2965 if (pfile
->context
->prev
== NULL
)
2966 _cpp_backup_tokens_direct (pfile
, count
);
2971 if (pfile
->context
->tokens_kind
== TOKENS_KIND_DIRECT
)
2972 FIRST (pfile
->context
).token
--;
2973 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
2974 FIRST (pfile
->context
).ptoken
--;
2975 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2977 FIRST (pfile
->context
).ptoken
--;
2978 if (pfile
->context
->c
.macro
)
2980 macro_context
*m
= pfile
->context
->c
.mc
;
2982 gcc_checking_assert (m
->cur_virt_loc
>= m
->virt_locs
);
2992 /* #define directive parsing and handling. */
2994 /* Returns nonzero if a macro redefinition warning is required. */
2996 warn_of_redefinition (cpp_reader
*pfile
, cpp_hashnode
*node
,
2997 const cpp_macro
*macro2
)
2999 const cpp_macro
*macro1
;
3002 /* Some redefinitions need to be warned about regardless. */
3003 if (node
->flags
& NODE_WARN
)
3006 /* Suppress warnings for builtins that lack the NODE_WARN flag,
3007 unless Wbuiltin-macro-redefined. */
3008 if (node
->flags
& NODE_BUILTIN
3009 && (!pfile
->cb
.user_builtin_macro
3010 || !pfile
->cb
.user_builtin_macro (pfile
, node
)))
3011 return CPP_OPTION (pfile
, warn_builtin_macro_redefined
);
3013 /* Redefinitions of conditional (context-sensitive) macros, on
3014 the other hand, must be allowed silently. */
3015 if (node
->flags
& NODE_CONDITIONAL
)
3018 /* Redefinition of a macro is allowed if and only if the old and new
3019 definitions are the same. (6.10.3 paragraph 2). */
3020 macro1
= node
->value
.macro
;
3022 /* Don't check count here as it can be different in valid
3023 traditional redefinitions with just whitespace differences. */
3024 if (macro1
->paramc
!= macro2
->paramc
3025 || macro1
->fun_like
!= macro2
->fun_like
3026 || macro1
->variadic
!= macro2
->variadic
)
3029 /* Check parameter spellings. */
3030 for (i
= 0; i
< macro1
->paramc
; i
++)
3031 if (macro1
->params
[i
] != macro2
->params
[i
])
3034 /* Check the replacement text or tokens. */
3035 if (CPP_OPTION (pfile
, traditional
))
3036 return _cpp_expansions_different_trad (macro1
, macro2
);
3038 if (macro1
->count
!= macro2
->count
)
3041 for (i
= 0; i
< macro1
->count
; i
++)
3042 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
3048 /* Free the definition of hashnode H. */
3050 _cpp_free_definition (cpp_hashnode
*h
)
3052 /* Macros and assertions no longer have anything to free. */
3054 /* Clear builtin flag in case of redefinition. */
3055 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
| NODE_USED
);
3058 /* Save parameter NODE (spelling SPELLING) to the parameter list of
3059 macro MACRO. Returns zero on success, nonzero if the parameter is
3062 _cpp_save_parameter (cpp_reader
*pfile
, cpp_macro
*macro
, cpp_hashnode
*node
,
3063 cpp_hashnode
*spelling
)
3066 /* Constraint 6.10.3.6 - duplicate parameter names. */
3067 if (node
->flags
& NODE_MACRO_ARG
)
3069 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
3074 if (BUFF_ROOM (pfile
->a_buff
)
3075 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
3076 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
3078 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = spelling
;
3079 node
->flags
|= NODE_MACRO_ARG
;
3080 len
= macro
->paramc
* sizeof (struct macro_arg_saved_data
);
3081 if (len
> pfile
->macro_buffer_len
)
3083 pfile
->macro_buffer
= XRESIZEVEC (unsigned char, pfile
->macro_buffer
,
3085 pfile
->macro_buffer_len
= len
;
3087 struct macro_arg_saved_data save
;
3088 save
.value
= node
->value
;
3089 save
.canonical_node
= node
;
3090 ((struct macro_arg_saved_data
*) pfile
->macro_buffer
)[macro
->paramc
- 1]
3093 node
->value
.arg_index
= macro
->paramc
;
3097 /* Check the syntax of the parameters in a MACRO definition. Returns
3098 false if an error occurs. */
3100 parse_params (cpp_reader
*pfile
, cpp_macro
*macro
)
3102 unsigned int prev_ident
= 0;
3106 const cpp_token
*token
= _cpp_lex_token (pfile
);
3108 switch (token
->type
)
3111 /* Allow/ignore comments in parameter lists if we are
3112 preserving comments in macro expansions. */
3113 if (token
->type
== CPP_COMMENT
3114 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
3117 cpp_error (pfile
, CPP_DL_ERROR
,
3118 "\"%s\" may not appear in macro parameter list",
3119 cpp_token_as_text (pfile
, token
));
3125 cpp_error (pfile
, CPP_DL_ERROR
,
3126 "macro parameters must be comma-separated");
3131 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
.node
,
3132 token
->val
.node
.spelling
))
3136 case CPP_CLOSE_PAREN
:
3137 if (prev_ident
|| macro
->paramc
== 0)
3140 /* Fall through to pick up the error. */
3145 cpp_error (pfile
, CPP_DL_ERROR
, "parameter name missing");
3152 macro
->variadic
= 1;
3155 _cpp_save_parameter (pfile
, macro
,
3156 pfile
->spec_nodes
.n__VA_ARGS__
,
3157 pfile
->spec_nodes
.n__VA_ARGS__
);
3158 pfile
->state
.va_args_ok
= 1;
3159 if (! CPP_OPTION (pfile
, c99
)
3160 && CPP_OPTION (pfile
, cpp_pedantic
)
3161 && CPP_OPTION (pfile
, warn_variadic_macros
))
3163 if (CPP_OPTION (pfile
, cplusplus
))
3165 (pfile
, CPP_W_VARIADIC_MACROS
,
3166 "anonymous variadic macros were introduced in C++11");
3169 (pfile
, CPP_W_VARIADIC_MACROS
,
3170 "anonymous variadic macros were introduced in C99");
3172 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
3173 && ! CPP_OPTION (pfile
, cplusplus
))
3174 cpp_error (pfile
, CPP_DL_WARNING
,
3175 "anonymous variadic macros were introduced in C99");
3177 else if (CPP_OPTION (pfile
, cpp_pedantic
)
3178 && CPP_OPTION (pfile
, warn_variadic_macros
))
3180 if (CPP_OPTION (pfile
, cplusplus
))
3181 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
3182 "ISO C++ does not permit named variadic macros");
3184 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
3185 "ISO C does not permit named variadic macros");
3188 /* We're at the end, and just expect a closing parenthesis. */
3189 token
= _cpp_lex_token (pfile
);
3190 if (token
->type
== CPP_CLOSE_PAREN
)
3195 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' in macro parameter list");
3201 /* Allocate room for a token from a macro's replacement list. */
3203 alloc_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
3205 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
3206 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
3208 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
3211 /* Lex a token from the expansion of MACRO, but mark parameters as we
3212 find them and warn of traditional stringification. */
3214 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
3216 cpp_token
*token
, *saved_cur_token
;
3218 saved_cur_token
= pfile
->cur_token
;
3219 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
3220 token
= _cpp_lex_direct (pfile
);
3221 pfile
->cur_token
= saved_cur_token
;
3223 /* Is this a parameter? */
3224 if (token
->type
== CPP_NAME
3225 && (token
->val
.node
.node
->flags
& NODE_MACRO_ARG
) != 0)
3227 cpp_hashnode
*spelling
= token
->val
.node
.spelling
;
3228 token
->type
= CPP_MACRO_ARG
;
3229 token
->val
.macro_arg
.arg_no
= token
->val
.node
.node
->value
.arg_index
;
3230 token
->val
.macro_arg
.spelling
= spelling
;
3232 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
3233 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
3234 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
3240 create_iso_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
3243 const cpp_token
*ctoken
;
3244 bool following_paste_op
= false;
3245 const char *paste_op_error_msg
=
3246 N_("'##' cannot appear at either end of a macro expansion");
3247 unsigned int num_extra_tokens
= 0;
3249 /* Get the first token of the expansion (or the '(' of a
3250 function-like macro). */
3251 ctoken
= _cpp_lex_token (pfile
);
3253 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
3255 bool ok
= parse_params (pfile
, macro
);
3256 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
3260 /* Success. Commit or allocate the parameter array. */
3261 if (pfile
->hash_table
->alloc_subobject
)
3263 cpp_hashnode
**params
=
3264 (cpp_hashnode
**) pfile
->hash_table
->alloc_subobject
3265 (sizeof (cpp_hashnode
*) * macro
->paramc
);
3266 memcpy (params
, macro
->params
,
3267 sizeof (cpp_hashnode
*) * macro
->paramc
);
3268 macro
->params
= params
;
3271 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
3272 macro
->fun_like
= 1;
3274 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
3276 /* While ISO C99 requires whitespace before replacement text
3277 in a macro definition, ISO C90 with TC1 allows characters
3278 from the basic source character set there. */
3279 if (CPP_OPTION (pfile
, c99
))
3281 if (CPP_OPTION (pfile
, cplusplus
))
3282 cpp_error (pfile
, CPP_DL_PEDWARN
,
3283 "ISO C++11 requires whitespace after the macro name");
3285 cpp_error (pfile
, CPP_DL_PEDWARN
,
3286 "ISO C99 requires whitespace after the macro name");
3290 int warntype
= CPP_DL_WARNING
;
3291 switch (ctoken
->type
)
3295 case CPP_OBJC_STRING
:
3296 /* '@' is not in basic character set. */
3297 warntype
= CPP_DL_PEDWARN
;
3300 /* Basic character set sans letters, digits and _. */
3301 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
3302 ctoken
->val
.str
.text
[0]) == NULL
)
3303 warntype
= CPP_DL_PEDWARN
;
3306 /* All other tokens start with a character from basic
3310 cpp_error (pfile
, warntype
,
3311 "missing whitespace after the macro name");
3315 if (macro
->fun_like
)
3316 token
= lex_expansion_token (pfile
, macro
);
3319 token
= alloc_expansion_token (pfile
, macro
);
3323 /* The argument doesn't matter here. */
3324 vaopt_state
vaopt_tracker (pfile
, macro
->variadic
, true);
3328 /* Check the stringifying # constraint 6.10.3.2.1 of
3329 function-like macros when lexing the subsequent token. */
3330 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
3332 if (token
->type
== CPP_MACRO_ARG
)
3334 if (token
->flags
& PREV_WHITE
)
3335 token
->flags
|= SP_PREV_WHITE
;
3336 if (token
[-1].flags
& DIGRAPH
)
3337 token
->flags
|= SP_DIGRAPH
;
3338 token
->flags
&= ~PREV_WHITE
;
3339 token
->flags
|= STRINGIFY_ARG
;
3340 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
3341 token
[-1] = token
[0];
3344 /* Let assembler get away with murder. */
3345 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
3347 cpp_error (pfile
, CPP_DL_ERROR
,
3348 "'#' is not followed by a macro parameter");
3353 if (token
->type
== CPP_EOF
)
3355 /* Paste operator constraint 6.10.3.3.1:
3356 Token-paste ##, can appear in both object-like and
3357 function-like macros, but not at the end. */
3358 if (following_paste_op
)
3360 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3366 /* Paste operator constraint 6.10.3.3.1. */
3367 if (token
->type
== CPP_PASTE
)
3369 /* Token-paste ##, can appear in both object-like and
3370 function-like macros, but not at the beginning. */
3371 if (macro
->count
== 1)
3373 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3377 if (token
[-1].flags
& PASTE_LEFT
)
3379 macro
->extra_tokens
= 1;
3381 token
->val
.token_no
= macro
->count
- 1;
3386 token
[-1].flags
|= PASTE_LEFT
;
3387 if (token
->flags
& DIGRAPH
)
3388 token
[-1].flags
|= SP_DIGRAPH
;
3389 if (token
->flags
& PREV_WHITE
)
3390 token
[-1].flags
|= SP_PREV_WHITE
;
3394 if (vaopt_tracker
.update (token
) == vaopt_state::ERROR
)
3397 following_paste_op
= (token
->type
== CPP_PASTE
);
3398 token
= lex_expansion_token (pfile
, macro
);
3401 if (!vaopt_tracker
.completed ())
3404 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
3405 macro
->traditional
= 0;
3407 /* Don't count the CPP_EOF. */
3410 /* Clear whitespace on first token for warn_of_redefinition(). */
3412 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
3414 /* Commit or allocate the memory. */
3415 if (pfile
->hash_table
->alloc_subobject
)
3418 (cpp_token
*) pfile
->hash_table
->alloc_subobject (sizeof (cpp_token
)
3420 if (num_extra_tokens
)
3422 /* Place second and subsequent ## or %:%: tokens in
3423 sequences of consecutive such tokens at the end of the
3424 list to preserve information about where they appear, how
3425 they are spelt and whether they are preceded by
3426 whitespace without otherwise interfering with macro
3428 cpp_token
*normal_dest
= tokns
;
3429 cpp_token
*extra_dest
= tokns
+ macro
->count
- num_extra_tokens
;
3431 for (i
= 0; i
< macro
->count
; i
++)
3433 if (macro
->exp
.tokens
[i
].type
== CPP_PASTE
)
3434 *extra_dest
++ = macro
->exp
.tokens
[i
];
3436 *normal_dest
++ = macro
->exp
.tokens
[i
];
3440 memcpy (tokns
, macro
->exp
.tokens
, sizeof (cpp_token
) * macro
->count
);
3441 macro
->exp
.tokens
= tokns
;
3444 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
3449 /* Parse a macro and save its expansion. Returns nonzero on success. */
3451 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3457 if (pfile
->hash_table
->alloc_subobject
)
3458 macro
= (cpp_macro
*) pfile
->hash_table
->alloc_subobject
3459 (sizeof (cpp_macro
));
3461 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
3462 macro
->line
= pfile
->directive_line
;
3465 macro
->variadic
= 0;
3466 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
3468 macro
->fun_like
= 0;
3469 macro
->extra_tokens
= 0;
3470 /* To suppress some diagnostics. */
3471 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
3473 if (CPP_OPTION (pfile
, traditional
))
3474 ok
= _cpp_create_trad_definition (pfile
, macro
);
3477 ok
= create_iso_definition (pfile
, macro
);
3479 /* We set the type for SEEN_EOL() in directives.c.
3481 Longer term we should lex the whole line before coming here,
3482 and just copy the expansion. */
3484 /* Stop the lexer accepting __VA_ARGS__. */
3485 pfile
->state
.va_args_ok
= 0;
3488 /* Clear the fast argument lookup indices. */
3489 for (i
= macro
->paramc
; i
-- > 0; )
3491 struct macro_arg_saved_data
*save
=
3492 &((struct macro_arg_saved_data
*) pfile
->macro_buffer
)[i
];
3493 struct cpp_hashnode
*node
= save
->canonical_node
;
3494 node
->flags
&= ~ NODE_MACRO_ARG
;
3495 node
->value
= save
->value
;
3501 if (node
->type
== NT_MACRO
)
3503 if (CPP_OPTION (pfile
, warn_unused_macros
))
3504 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
3506 if (warn_of_redefinition (pfile
, node
, macro
))
3508 const int reason
= ((node
->flags
& NODE_BUILTIN
)
3509 && !(node
->flags
& NODE_WARN
))
3510 ? CPP_W_BUILTIN_MACRO_REDEFINED
: CPP_W_NONE
;
3513 cpp_pedwarning_with_line (pfile
, reason
,
3514 pfile
->directive_line
, 0,
3515 "\"%s\" redefined", NODE_NAME (node
));
3517 if (warned
&& node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
3518 cpp_error_with_line (pfile
, CPP_DL_NOTE
,
3519 node
->value
.macro
->line
, 0,
3520 "this is the location of the previous definition");
3524 if (node
->type
!= NT_VOID
)
3525 _cpp_free_definition (node
);
3527 /* Enter definition in hash table. */
3528 node
->type
= NT_MACRO
;
3529 node
->value
.macro
= macro
;
3530 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
3531 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
3532 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3533 in the C standard, as something that one must use in C++.
3534 However DR#593 and C++11 indicate that they play no role in C++.
3535 We special-case them anyway. */
3536 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
3537 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
3538 node
->flags
|= NODE_WARN
;
3540 /* If user defines one of the conditional macros, remove the
3542 node
->flags
&= ~NODE_CONDITIONAL
;
3547 /* Warn if a token in STRING matches one of a function-like MACRO's
3550 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
3551 const cpp_string
*string
)
3553 unsigned int i
, len
;
3554 const uchar
*p
, *q
, *limit
;
3556 /* Loop over the string. */
3557 limit
= string
->text
+ string
->len
- 1;
3558 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
3560 /* Find the start of an identifier. */
3561 while (p
< limit
&& !is_idstart (*p
))
3564 /* Find the end of the identifier. */
3566 while (q
< limit
&& is_idchar (*q
))
3571 /* Loop over the function macro arguments to see if the
3572 identifier inside the string matches one of them. */
3573 for (i
= 0; i
< macro
->paramc
; i
++)
3575 const cpp_hashnode
*node
= macro
->params
[i
];
3577 if (NODE_LEN (node
) == len
3578 && !memcmp (p
, NODE_NAME (node
), len
))
3580 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
3581 "macro argument \"%s\" would be stringified in traditional C",
3589 /* Returns true of NODE is a function-like macro. */
3591 cpp_fun_like_macro_p (cpp_hashnode
*node
)
3593 return (node
->type
== NT_MACRO
3594 && (node
->flags
& (NODE_BUILTIN
| NODE_MACRO_ARG
)) == 0
3595 && node
->value
.macro
->fun_like
);
3598 /* Returns the name, arguments and expansion of a macro, in a format
3599 suitable to be read back in again, and therefore also for DWARF 2
3600 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3601 Caller is expected to generate the "#define" bit if needed. The
3602 returned text is temporary, and automatically freed later. */
3603 const unsigned char *
3604 cpp_macro_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3606 unsigned int i
, len
;
3607 const cpp_macro
*macro
;
3608 unsigned char *buffer
;
3610 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
3612 if (node
->type
!= NT_MACRO
3613 || !pfile
->cb
.user_builtin_macro
3614 || !pfile
->cb
.user_builtin_macro (pfile
, node
))
3616 cpp_error (pfile
, CPP_DL_ICE
,
3617 "invalid hash type %d in cpp_macro_definition",
3623 macro
= node
->value
.macro
;
3624 /* Calculate length. */
3625 len
= NODE_LEN (node
) * 10 + 2; /* ' ' and NUL. */
3626 if (macro
->fun_like
)
3628 len
+= 4; /* "()" plus possible final ".." of named
3629 varargs (we have + 1 below). */
3630 for (i
= 0; i
< macro
->paramc
; i
++)
3631 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
3634 /* This should match below where we fill in the buffer. */
3635 if (CPP_OPTION (pfile
, traditional
))
3636 len
+= _cpp_replacement_text_len (macro
);
3639 unsigned int count
= macro_real_token_count (macro
);
3640 for (i
= 0; i
< count
; i
++)
3642 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3644 if (token
->type
== CPP_MACRO_ARG
)
3645 len
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3647 len
+= cpp_token_len (token
);
3649 if (token
->flags
& STRINGIFY_ARG
)
3651 if (token
->flags
& PASTE_LEFT
)
3652 len
+= 3; /* " ##" */
3653 if (token
->flags
& PREV_WHITE
)
3658 if (len
> pfile
->macro_buffer_len
)
3660 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
3661 pfile
->macro_buffer
, len
);
3662 pfile
->macro_buffer_len
= len
;
3665 /* Fill in the buffer. Start with the macro name. */
3666 buffer
= pfile
->macro_buffer
;
3667 buffer
= _cpp_spell_ident_ucns (buffer
, node
);
3669 /* Parameter names. */
3670 if (macro
->fun_like
)
3673 for (i
= 0; i
< macro
->paramc
; i
++)
3675 cpp_hashnode
*param
= macro
->params
[i
];
3677 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
3679 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
3680 buffer
+= NODE_LEN (param
);
3683 if (i
+ 1 < macro
->paramc
)
3684 /* Don't emit a space after the comma here; we're trying
3685 to emit a Dwarf-friendly definition, and the Dwarf spec
3686 forbids spaces in the argument list. */
3688 else if (macro
->variadic
)
3689 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
3694 /* The Dwarf spec requires a space after the macro name, even if the
3695 definition is the empty string. */
3698 if (CPP_OPTION (pfile
, traditional
))
3699 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
3700 else if (macro
->count
)
3701 /* Expansion tokens. */
3703 unsigned int count
= macro_real_token_count (macro
);
3704 for (i
= 0; i
< count
; i
++)
3706 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3708 if (token
->flags
& PREV_WHITE
)
3710 if (token
->flags
& STRINGIFY_ARG
)
3713 if (token
->type
== CPP_MACRO_ARG
)
3716 NODE_NAME (token
->val
.macro_arg
.spelling
),
3717 NODE_LEN (token
->val
.macro_arg
.spelling
));
3718 buffer
+= NODE_LEN (token
->val
.macro_arg
.spelling
);
3721 buffer
= cpp_spell_token (pfile
, token
, buffer
, true);
3723 if (token
->flags
& PASTE_LEFT
)
3728 /* Next has PREV_WHITE; see _cpp_create_definition. */
3734 return pfile
->macro_buffer
;
3737 /* Get the line at which the macro was defined. */
3740 cpp_macro_definition_location (cpp_hashnode
*node
)
3742 return node
->value
.macro
->line
;