1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986-2014 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 litteral, 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
;
76 #ifdef ENABLE_CHECKING
77 /* The number of times the iterator went forward. This useful only
78 when checking is enabled. */
83 /* Macro expansion. */
85 static int enter_macro_context (cpp_reader
*, cpp_hashnode
*,
86 const cpp_token
*, source_location
);
87 static int builtin_macro (cpp_reader
*, cpp_hashnode
*, source_location
);
88 static void push_ptoken_context (cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
89 const cpp_token
**, unsigned int);
90 static void push_extended_tokens_context (cpp_reader
*, cpp_hashnode
*,
91 _cpp_buff
*, source_location
*,
92 const cpp_token
**, unsigned int);
93 static _cpp_buff
*collect_args (cpp_reader
*, const cpp_hashnode
*,
94 _cpp_buff
**, unsigned *);
95 static cpp_context
*next_context (cpp_reader
*);
96 static const cpp_token
*padding_token (cpp_reader
*, const cpp_token
*);
97 static void expand_arg (cpp_reader
*, macro_arg
*);
98 static const cpp_token
*new_string_token (cpp_reader
*, uchar
*, unsigned int);
99 static const cpp_token
*stringify_arg (cpp_reader
*, macro_arg
*);
100 static void paste_all_tokens (cpp_reader
*, const cpp_token
*);
101 static bool paste_tokens (cpp_reader
*, source_location
,
102 const cpp_token
**, const cpp_token
*);
103 static void alloc_expanded_arg_mem (cpp_reader
*, macro_arg
*, size_t);
104 static void ensure_expanded_arg_room (cpp_reader
*, macro_arg
*, size_t, size_t *);
105 static void delete_macro_args (_cpp_buff
*, unsigned num_args
);
106 static void set_arg_token (macro_arg
*, const cpp_token
*,
107 source_location
, size_t,
108 enum macro_arg_token_kind
,
110 static const source_location
*get_arg_token_location (const macro_arg
*,
111 enum macro_arg_token_kind
);
112 static const cpp_token
**arg_token_ptr_at (const macro_arg
*,
114 enum macro_arg_token_kind
,
115 source_location
**virt_location
);
117 static void macro_arg_token_iter_init (macro_arg_token_iter
*, bool,
118 enum macro_arg_token_kind
,
121 static const cpp_token
*macro_arg_token_iter_get_token
122 (const macro_arg_token_iter
*it
);
123 static source_location macro_arg_token_iter_get_location
124 (const macro_arg_token_iter
*);
125 static void macro_arg_token_iter_forward (macro_arg_token_iter
*);
126 static _cpp_buff
*tokens_buff_new (cpp_reader
*, size_t,
128 static size_t tokens_buff_count (_cpp_buff
*);
129 static const cpp_token
**tokens_buff_last_token_ptr (_cpp_buff
*);
130 static inline const cpp_token
**tokens_buff_put_token_to (const cpp_token
**,
135 const struct line_map
*,
138 static const cpp_token
**tokens_buff_add_token (_cpp_buff
*,
143 const struct line_map
*,
145 static inline void tokens_buff_remove_last_token (_cpp_buff
*);
146 static void replace_args (cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
147 macro_arg
*, source_location
);
148 static _cpp_buff
*funlike_invocation_p (cpp_reader
*, cpp_hashnode
*,
149 _cpp_buff
**, unsigned *);
150 static bool create_iso_definition (cpp_reader
*, cpp_macro
*);
152 /* #define directive parsing and handling. */
154 static cpp_token
*alloc_expansion_token (cpp_reader
*, cpp_macro
*);
155 static cpp_token
*lex_expansion_token (cpp_reader
*, cpp_macro
*);
156 static bool warn_of_redefinition (cpp_reader
*, cpp_hashnode
*,
158 static bool parse_params (cpp_reader
*, cpp_macro
*);
159 static void check_trad_stringification (cpp_reader
*, const cpp_macro
*,
161 static bool reached_end_of_context (cpp_context
*);
162 static void consume_next_token_from_context (cpp_reader
*pfile
,
165 static const cpp_token
* cpp_get_token_1 (cpp_reader
*, source_location
*);
167 static cpp_hashnode
* macro_of_context (cpp_context
*context
);
169 static bool in_macro_expansion_p (cpp_reader
*pfile
);
171 /* Statistical counter tracking the number of macros that got
173 unsigned num_expanded_macros_counter
= 0;
174 /* Statistical counter tracking the total number tokens resulting
175 from macro expansion. */
176 unsigned num_macro_tokens_counter
= 0;
178 /* Emits a warning if NODE is a macro defined in the main file that
179 has not been used. */
181 _cpp_warn_if_unused_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
182 void *v ATTRIBUTE_UNUSED
)
184 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
186 cpp_macro
*macro
= node
->value
.macro
;
189 && MAIN_FILE_P (linemap_lookup (pfile
->line_table
, macro
->line
)))
190 cpp_warning_with_line (pfile
, CPP_W_UNUSED_MACROS
, macro
->line
, 0,
191 "macro \"%s\" is not used", NODE_NAME (node
));
197 /* Allocates and returns a CPP_STRING token, containing TEXT of length
198 LEN, after null-terminating it. TEXT must be in permanent storage. */
199 static const cpp_token
*
200 new_string_token (cpp_reader
*pfile
, unsigned char *text
, unsigned int len
)
202 cpp_token
*token
= _cpp_temp_token (pfile
);
205 token
->type
= CPP_STRING
;
206 token
->val
.str
.len
= len
;
207 token
->val
.str
.text
= text
;
212 static const char * const monthnames
[] =
214 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
215 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
218 /* Helper function for builtin_macro. Returns the text generated by
221 _cpp_builtin_macro_text (cpp_reader
*pfile
, cpp_hashnode
*node
)
223 const uchar
*result
= NULL
;
224 linenum_type number
= 1;
226 switch (node
->value
.builtin
)
229 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
235 if (CPP_OPTION (pfile
, warn_date_time
))
236 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
237 "reproducible builds", NODE_NAME (node
));
239 cpp_buffer
*pbuffer
= cpp_get_buffer (pfile
);
240 if (pbuffer
->timestamp
== NULL
)
242 /* Initialize timestamp value of the assotiated file. */
243 struct _cpp_file
*file
= cpp_get_file (pbuffer
);
246 /* Generate __TIMESTAMP__ string, that represents
247 the date and time of the last modification
248 of the current source file. The string constant
249 looks like "Sun Sep 16 01:03:52 1973". */
250 struct tm
*tb
= NULL
;
251 struct stat
*st
= _cpp_get_file_stat (file
);
253 tb
= localtime (&st
->st_mtime
);
256 char *str
= asctime (tb
);
257 size_t len
= strlen (str
);
258 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
260 strcpy ((char *) buf
+ 1, str
);
262 pbuffer
->timestamp
= buf
;
266 cpp_errno (pfile
, CPP_DL_WARNING
,
267 "could not determine file timestamp");
268 pbuffer
->timestamp
= UC
"\"??? ??? ?? ??:??:?? ????\"";
272 result
= pbuffer
->timestamp
;
282 if (node
->value
.builtin
== BT_FILE
)
283 name
= linemap_get_expansion_filename (pfile
->line_table
,
284 pfile
->line_table
->highest_line
);
287 name
= _cpp_get_file_name (pfile
->main_file
);
292 buf
= _cpp_unaligned_alloc (pfile
, len
* 2 + 3);
295 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
301 case BT_INCLUDE_LEVEL
:
302 /* The line map depth counts the primary source as level 1, but
303 historically __INCLUDE_DEPTH__ has called the primary source
305 number
= pfile
->line_table
->depth
- 1;
309 /* If __LINE__ is embedded in a macro, it must expand to the
310 line of the macro's invocation, not its definition.
311 Otherwise things like assert() will not work properly. */
312 number
= linemap_get_expansion_line (pfile
->line_table
,
313 CPP_OPTION (pfile
, traditional
)
314 ? pfile
->line_table
->highest_line
315 : pfile
->cur_token
[-1].src_loc
);
318 /* __STDC__ has the value 1 under normal circumstances.
319 However, if (a) we are in a system header, (b) the option
320 stdc_0_in_system_headers is true (set by target config), and
321 (c) we are not in strictly conforming mode, then it has the
322 value 0. (b) and (c) are already checked in cpp_init_builtins. */
324 if (cpp_in_system_header (pfile
))
332 if (CPP_OPTION (pfile
, warn_date_time
))
333 cpp_warning (pfile
, CPP_W_DATE_TIME
, "macro \"%s\" might prevent "
334 "reproducible builds", NODE_NAME (node
));
335 if (pfile
->date
== NULL
)
337 /* Allocate __DATE__ and __TIME__ strings from permanent
338 storage. We only do this once, and don't generate them
339 at init time, because time() and localtime() are very
340 slow on some systems. */
342 struct tm
*tb
= NULL
;
344 /* (time_t) -1 is a legitimate value for "number of seconds
345 since the Epoch", so we have to do a little dance to
346 distinguish that from a genuine error. */
349 if (tt
!= (time_t)-1 || errno
== 0)
350 tb
= localtime (&tt
);
354 pfile
->date
= _cpp_unaligned_alloc (pfile
,
355 sizeof ("\"Oct 11 1347\""));
356 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
357 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
360 pfile
->time
= _cpp_unaligned_alloc (pfile
,
361 sizeof ("\"12:34:56\""));
362 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
363 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
367 cpp_errno (pfile
, CPP_DL_WARNING
,
368 "could not determine date and time");
370 pfile
->date
= UC
"\"??? ?? ????\"";
371 pfile
->time
= UC
"\"??:??:??\"";
375 if (node
->value
.builtin
== BT_DATE
)
376 result
= pfile
->date
;
378 result
= pfile
->time
;
382 if (CPP_OPTION (pfile
, directives_only
) && pfile
->state
.in_directive
)
383 cpp_error (pfile
, CPP_DL_ERROR
,
384 "__COUNTER__ expanded inside directive with -fdirectives-only");
385 number
= pfile
->counter
++;
391 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
392 result
= _cpp_unaligned_alloc (pfile
, 21);
393 sprintf ((char *) result
, "%u", number
);
399 /* Convert builtin macros like __FILE__ to a token and push it on the
400 context stack. Also handles _Pragma, for which a new token may not
401 be created. Returns 1 if it generates a new token context, 0 to
402 return the token to the caller. LOC is the location of the expansion
403 point of the macro. */
405 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
, source_location loc
)
411 if (node
->value
.builtin
== BT_PRAGMA
)
413 /* Don't interpret _Pragma within directives. The standard is
414 not clear on this, but to me this makes most sense. */
415 if (pfile
->state
.in_directive
)
418 return _cpp_do__Pragma (pfile
);
421 buf
= _cpp_builtin_macro_text (pfile
, node
);
423 nbuf
= (char *) alloca (len
+ 1);
424 memcpy (nbuf
, buf
, len
);
427 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
428 _cpp_clean_line (pfile
);
430 /* Set pfile->cur_token as required by _cpp_lex_direct. */
431 pfile
->cur_token
= _cpp_temp_token (pfile
);
432 cpp_token
*token
= _cpp_lex_direct (pfile
);
433 /* We should point to the expansion point of the builtin macro. */
434 token
->src_loc
= loc
;
435 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
437 /* We are tracking tokens resulting from macro expansion.
438 Create a macro line map and generate a virtual location for
439 the token resulting from the expansion of the built-in
441 source_location
*virt_locs
= NULL
;
442 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
443 const line_map
* map
=
444 linemap_enter_macro (pfile
->line_table
, node
,
446 tokens_buff_add_token (token_buf
, virt_locs
, token
,
447 pfile
->line_table
->builtin_location
,
448 pfile
->line_table
->builtin_location
,
449 map
, /*macro_token_index=*/0);
450 push_extended_tokens_context (pfile
, node
, token_buf
, virt_locs
,
451 (const cpp_token
**)token_buf
->base
,
455 _cpp_push_token_context (pfile
, NULL
, token
, 1);
456 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
457 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
459 _cpp_pop_buffer (pfile
);
464 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
465 backslashes and double quotes. DEST must be of sufficient size.
466 Returns a pointer to the end of the string. */
468 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
474 if (c
== '\\' || c
== '"')
486 /* Convert a token sequence ARG to a single string token according to
487 the rules of the ISO C #-operator. */
488 static const cpp_token
*
489 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
492 unsigned int i
, escape_it
, backslash_count
= 0;
493 const cpp_token
*source
= NULL
;
496 if (BUFF_ROOM (pfile
->u_buff
) < 3)
497 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
498 dest
= BUFF_FRONT (pfile
->u_buff
);
501 /* Loop, reading in the argument's tokens. */
502 for (i
= 0; i
< arg
->count
; i
++)
504 const cpp_token
*token
= arg
->first
[i
];
506 if (token
->type
== CPP_PADDING
)
509 || (!(source
->flags
& PREV_WHITE
)
510 && token
->val
.source
== NULL
))
511 source
= token
->val
.source
;
515 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
516 || token
->type
== CPP_WSTRING
|| token
->type
== CPP_WCHAR
517 || token
->type
== CPP_STRING32
|| token
->type
== CPP_CHAR32
518 || token
->type
== CPP_STRING16
|| token
->type
== CPP_CHAR16
519 || token
->type
== CPP_UTF8STRING
520 || cpp_userdef_string_p (token
->type
)
521 || cpp_userdef_char_p (token
->type
));
523 /* Room for each char being written in octal, initial space and
524 final quote and NUL. */
525 len
= cpp_token_len (token
);
530 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
532 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
533 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
534 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
537 /* Leading white space? */
538 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
542 if (source
->flags
& PREV_WHITE
)
549 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
550 unsigned char *buf
= BUFF_FRONT (buff
);
551 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
552 dest
= cpp_quote_string (dest
, buf
, len
);
553 _cpp_release_buff (pfile
, buff
);
556 dest
= cpp_spell_token (pfile
, token
, dest
, true);
558 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
564 /* Ignore the final \ of invalid string literals. */
565 if (backslash_count
& 1)
567 cpp_error (pfile
, CPP_DL_WARNING
,
568 "invalid string literal, ignoring final '\\'");
572 /* Commit the memory, including NUL, and return the token. */
574 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
575 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
576 return new_string_token (pfile
, dest
- len
, len
);
579 /* Try to paste two tokens. On success, return nonzero. In any
580 case, PLHS is updated to point to the pasted token, which is
581 guaranteed to not have the PASTE_LEFT flag set. LOCATION is
582 the virtual location used for error reporting. */
584 paste_tokens (cpp_reader
*pfile
, source_location location
,
585 const cpp_token
**plhs
, const cpp_token
*rhs
)
587 unsigned char *buf
, *end
, *lhsend
;
591 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
592 buf
= (unsigned char *) alloca (len
);
593 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, false);
595 /* Avoid comment headers, since they are still processed in stage 3.
596 It is simpler to insert a space here, rather than modifying the
597 lexer to ignore comments in some circumstances. Simply returning
598 false doesn't work, since we want to clear the PASTE_LEFT flag. */
599 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
601 /* In one obscure case we might see padding here. */
602 if (rhs
->type
!= CPP_PADDING
)
603 end
= cpp_spell_token (pfile
, rhs
, end
, false);
606 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
607 _cpp_clean_line (pfile
);
609 /* Set pfile->cur_token as required by _cpp_lex_direct. */
610 pfile
->cur_token
= _cpp_temp_token (pfile
);
611 lhs
= _cpp_lex_direct (pfile
);
612 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
614 source_location saved_loc
= lhs
->src_loc
;
616 _cpp_pop_buffer (pfile
);
617 _cpp_backup_tokens (pfile
, 1);
620 /* We have to remove the PASTE_LEFT flag from the old lhs, but
621 we want to keep the new location. */
624 lhs
->src_loc
= saved_loc
;
625 lhs
->flags
&= ~PASTE_LEFT
;
627 /* Mandatory error for all apart from assembler. */
628 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
629 cpp_error_with_line (pfile
, CPP_DL_ERROR
, location
, 0,
630 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
631 buf
, cpp_token_as_text (pfile
, rhs
));
636 _cpp_pop_buffer (pfile
);
640 /* Handles an arbitrarily long sequence of ## operators, with initial
641 operand LHS. This implementation is left-associative,
642 non-recursive, and finishes a paste before handling succeeding
643 ones. If a paste fails, we back up to the RHS of the failing ##
644 operator before pushing the context containing the result of prior
645 successful pastes, with the effect that the RHS appears in the
646 output stream after the pasted LHS normally. */
648 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
650 const cpp_token
*rhs
= NULL
;
651 cpp_context
*context
= pfile
->context
;
652 source_location virt_loc
= 0;
654 /* We are expanding a macro and we must have been called on a token
655 that appears at the left hand side of a ## operator. */
656 if (macro_of_context (pfile
->context
) == NULL
657 || (!(lhs
->flags
& PASTE_LEFT
)))
660 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
661 /* The caller must have called consume_next_token_from_context
662 right before calling us. That has incremented the pointer to
663 the current virtual location. So it now points to the location
664 of the token that comes right after *LHS. We want the
665 resulting pasted token to have the location of the current
667 virt_loc
= context
->c
.mc
->cur_virt_loc
[-1];
669 /* We are not tracking macro expansion. So the best virtual
670 location we can get here is the expansion point of the macro we
671 are currently expanding. */
672 virt_loc
= pfile
->invocation_location
;
676 /* Take the token directly from the current context. We can do
677 this, because we are in the replacement list of either an
678 object-like macro, or a function-like macro with arguments
679 inserted. In either case, the constraints to #define
680 guarantee we have at least one more token. */
681 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
682 rhs
= FIRST (context
).token
++;
683 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
684 rhs
= *FIRST (context
).ptoken
++;
685 else if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
687 /* So we are in presence of an extended token context, which
688 means that each token in this context has a virtual
689 location attached to it. So let's not forget to update
690 the pointer to the current virtual location of the
691 current token when we update the pointer to the current
694 rhs
= *FIRST (context
).ptoken
++;
695 /* context->c.mc must be non-null, as if we were not in a
696 macro context, context->tokens_kind could not be equal to
697 TOKENS_KIND_EXTENDED. */
698 context
->c
.mc
->cur_virt_loc
++;
701 if (rhs
->type
== CPP_PADDING
)
703 if (rhs
->flags
& PASTE_LEFT
)
706 if (!paste_tokens (pfile
, virt_loc
, &lhs
, rhs
))
709 while (rhs
->flags
& PASTE_LEFT
);
711 /* Put the resulting token in its own context. */
712 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
714 source_location
*virt_locs
= NULL
;
715 _cpp_buff
*token_buf
= tokens_buff_new (pfile
, 1, &virt_locs
);
716 tokens_buff_add_token (token_buf
, virt_locs
, lhs
,
717 virt_loc
, 0, NULL
, 0);
718 push_extended_tokens_context (pfile
, context
->c
.mc
->macro_node
,
719 token_buf
, virt_locs
,
720 (const cpp_token
**)token_buf
->base
, 1);
723 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
726 /* Returns TRUE if the number of arguments ARGC supplied in an
727 invocation of the MACRO referenced by NODE is valid. An empty
728 invocation to a macro with no parameters should pass ARGC as zero.
730 Note that MACRO cannot necessarily be deduced from NODE, in case
731 NODE was redefined whilst collecting arguments. */
733 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
735 if (argc
== macro
->paramc
)
738 if (argc
< macro
->paramc
)
740 /* As an extension, variadic arguments are allowed to not appear in
741 the invocation at all.
742 e.g. #define debug(format, args...) something
745 This is exactly the same as if an empty variadic list had been
746 supplied - debug("string", ). */
748 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
750 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
752 if (CPP_OPTION (pfile
, cplusplus
))
753 cpp_error (pfile
, CPP_DL_PEDWARN
,
754 "ISO C++11 requires at least one argument "
755 "for the \"...\" in a variadic macro");
757 cpp_error (pfile
, CPP_DL_PEDWARN
,
758 "ISO C99 requires at least one argument "
759 "for the \"...\" in a variadic macro");
764 cpp_error (pfile
, CPP_DL_ERROR
,
765 "macro \"%s\" requires %u arguments, but only %u given",
766 NODE_NAME (node
), macro
->paramc
, argc
);
769 cpp_error (pfile
, CPP_DL_ERROR
,
770 "macro \"%s\" passed %u arguments, but takes just %u",
771 NODE_NAME (node
), argc
, macro
->paramc
);
776 /* Reads and returns the arguments to a function-like macro
777 invocation. Assumes the opening parenthesis has been processed.
778 If there is an error, emits an appropriate diagnostic and returns
779 NULL. Each argument is terminated by a CPP_EOF token, for the
780 future benefit of expand_arg(). If there are any deferred
781 #pragma directives among macro arguments, store pointers to the
782 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.
784 What is returned is the buffer that contains the memory allocated
785 to hold the macro arguments. NODE is the name of the macro this
786 function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
787 set to the actual number of macro arguments allocated in the
790 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
,
791 _cpp_buff
**pragma_buff
, unsigned *num_args
)
793 _cpp_buff
*buff
, *base_buff
;
795 macro_arg
*args
, *arg
;
796 const cpp_token
*token
;
798 source_location virt_loc
;
799 bool track_macro_expansion_p
= CPP_OPTION (pfile
, track_macro_expansion
);
800 unsigned num_args_alloced
= 0;
802 macro
= node
->value
.macro
;
804 argc
= macro
->paramc
;
808 #define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
809 #define ARG_TOKENS_EXTENT 1000
811 buff
= _cpp_get_buff (pfile
, argc
* (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
812 * sizeof (cpp_token
*)
813 + sizeof (macro_arg
)));
815 args
= (macro_arg
*) buff
->base
;
816 memset (args
, 0, argc
* sizeof (macro_arg
));
817 buff
->cur
= (unsigned char *) &args
[argc
];
818 arg
= args
, argc
= 0;
820 /* Collect the tokens making up each argument. We don't yet know
821 how many arguments have been supplied, whether too many or too
822 few. Hence the slightly bizarre usage of "argc" and "arg". */
825 unsigned int paren_depth
= 0;
826 unsigned int ntokens
= 0;
827 unsigned virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
831 arg
->first
= (const cpp_token
**) buff
->cur
;
832 if (track_macro_expansion_p
)
834 virt_locs_capacity
= DEFAULT_NUM_TOKENS_PER_MACRO_ARG
;
835 arg
->virt_locs
= XNEWVEC (source_location
,
841 /* Require space for 2 new tokens (including a CPP_EOF). */
842 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
844 buff
= _cpp_append_extend_buff (pfile
, buff
,
846 * sizeof (cpp_token
*));
847 arg
->first
= (const cpp_token
**) buff
->cur
;
849 if (track_macro_expansion_p
850 && (ntokens
+ 2 > virt_locs_capacity
))
852 virt_locs_capacity
+= ARG_TOKENS_EXTENT
;
853 arg
->virt_locs
= XRESIZEVEC (source_location
,
858 token
= cpp_get_token_1 (pfile
, &virt_loc
);
860 if (token
->type
== CPP_PADDING
)
862 /* Drop leading padding. */
866 else if (token
->type
== CPP_OPEN_PAREN
)
868 else if (token
->type
== CPP_CLOSE_PAREN
)
870 if (paren_depth
-- == 0)
873 else if (token
->type
== CPP_COMMA
)
875 /* A comma does not terminate an argument within
876 parentheses or as part of a variable argument. */
878 && ! (macro
->variadic
&& argc
== macro
->paramc
))
881 else if (token
->type
== CPP_EOF
882 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
884 else if (token
->type
== CPP_PRAGMA
)
886 cpp_token
*newtok
= _cpp_temp_token (pfile
);
888 /* CPP_PRAGMA token lives in directive_result, which will
889 be overwritten on the next directive. */
894 if (*pragma_buff
== NULL
895 || BUFF_ROOM (*pragma_buff
) < sizeof (cpp_token
*))
898 if (*pragma_buff
== NULL
)
900 = _cpp_get_buff (pfile
, 32 * sizeof (cpp_token
*));
905 = _cpp_get_buff (pfile
,
906 (BUFF_FRONT (*pragma_buff
)
907 - (*pragma_buff
)->base
) * 2);
908 (*pragma_buff
)->next
= next
;
911 *(const cpp_token
**) BUFF_FRONT (*pragma_buff
) = token
;
912 BUFF_FRONT (*pragma_buff
) += sizeof (cpp_token
*);
913 if (token
->type
== CPP_PRAGMA_EOL
)
915 token
= cpp_get_token_1 (pfile
, &virt_loc
);
917 while (token
->type
!= CPP_EOF
);
919 /* In deferred pragmas parsing_args and prevent_expansion
920 had been changed, reset it. */
921 pfile
->state
.parsing_args
= 2;
922 pfile
->state
.prevent_expansion
= 1;
924 if (token
->type
== CPP_EOF
)
929 set_arg_token (arg
, token
, virt_loc
,
930 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
931 CPP_OPTION (pfile
, track_macro_expansion
));
935 /* Drop trailing padding. */
936 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
939 arg
->count
= ntokens
;
940 set_arg_token (arg
, &pfile
->eof
, pfile
->eof
.src_loc
,
941 ntokens
, MACRO_ARG_TOKEN_NORMAL
,
942 CPP_OPTION (pfile
, track_macro_expansion
));
944 /* Terminate the argument. Excess arguments loop back and
945 overwrite the final legitimate argument, before failing. */
946 if (argc
<= macro
->paramc
)
948 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
949 if (argc
!= macro
->paramc
)
953 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
955 if (token
->type
== CPP_EOF
)
957 /* We still need the CPP_EOF to end directives, and to end
958 pre-expansion of a macro argument. Step back is not
959 unconditional, since we don't want to return a CPP_EOF to our
960 callers at the end of an -include-d file. */
961 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
962 _cpp_backup_tokens (pfile
, 1);
963 cpp_error (pfile
, CPP_DL_ERROR
,
964 "unterminated argument list invoking macro \"%s\"",
969 /* A single empty argument is counted as no argument. */
970 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
972 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
974 /* GCC has special semantics for , ## b where b is a varargs
975 parameter: we remove the comma if b was omitted entirely.
976 If b was merely an empty argument, the comma is retained.
977 If the macro takes just one (varargs) parameter, then we
978 retain the comma only if we are standards conforming.
980 If FIRST is NULL replace_args () swallows the comma. */
981 if (macro
->variadic
&& (argc
< macro
->paramc
982 || (argc
== 1 && args
[0].count
== 0
983 && !CPP_OPTION (pfile
, std
))))
984 args
[macro
->paramc
- 1].first
= NULL
;
986 *num_args
= num_args_alloced
;
991 /* An error occurred. */
992 _cpp_release_buff (pfile
, base_buff
);
996 /* Search for an opening parenthesis to the macro of NODE, in such a
997 way that, if none is found, we don't lose the information in any
998 intervening padding tokens. If we find the parenthesis, collect
999 the arguments and return the buffer containing them. PRAGMA_BUFF
1000 argument is the same as in collect_args. If NUM_ARGS is non-NULL,
1001 *NUM_ARGS is set to the number of arguments contained in the
1004 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
1005 _cpp_buff
**pragma_buff
, unsigned *num_args
)
1007 const cpp_token
*token
, *padding
= NULL
;
1011 token
= cpp_get_token (pfile
);
1012 if (token
->type
!= CPP_PADDING
)
1015 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
1019 if (token
->type
== CPP_OPEN_PAREN
)
1021 pfile
->state
.parsing_args
= 2;
1022 return collect_args (pfile
, node
, pragma_buff
, num_args
);
1025 /* CPP_EOF can be the end of macro arguments, or the end of the
1026 file. We mustn't back up over the latter. Ugh. */
1027 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
1029 /* Back up. We may have skipped padding, in which case backing
1030 up more than one token when expanding macros is in general
1031 too difficult. We re-insert it in its own context. */
1032 _cpp_backup_tokens (pfile
, 1);
1034 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
1040 /* Return the real number of tokens in the expansion of MACRO. */
1041 static inline unsigned int
1042 macro_real_token_count (const cpp_macro
*macro
)
1045 if (__builtin_expect (!macro
->extra_tokens
, true))
1046 return macro
->count
;
1047 for (i
= 0; i
< macro
->count
; i
++)
1048 if (macro
->exp
.tokens
[i
].type
== CPP_PASTE
)
1053 /* Push the context of a macro with hash entry NODE onto the context
1054 stack. If we can successfully expand the macro, we push a context
1055 containing its yet-to-be-rescanned replacement list and return one.
1056 If there were additionally any unexpanded deferred #pragma
1057 directives among macro arguments, push another context containing
1058 the pragma tokens before the yet-to-be-rescanned replacement list
1059 and return two. Otherwise, we don't push a context and return
1060 zero. LOCATION is the location of the expansion point of the
1063 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
1064 const cpp_token
*result
, source_location location
)
1066 /* The presence of a macro invalidates a file's controlling macro. */
1067 pfile
->mi_valid
= false;
1069 pfile
->state
.angled_headers
= false;
1071 /* From here to when we push the context for the macro later down
1072 this function, we need to flag the fact that we are about to
1073 expand a macro. This is useful when -ftrack-macro-expansion is
1074 turned off. In that case, we need to record the location of the
1075 expansion point of the top-most macro we are about to to expand,
1076 into pfile->invocation_location. But we must not record any such
1077 location once the process of expanding the macro starts; that is,
1078 we must not do that recording between now and later down this
1079 function where set this flag to FALSE. */
1080 pfile
->about_to_expand_macro_p
= true;
1082 if ((node
->flags
& NODE_BUILTIN
) && !(node
->flags
& NODE_USED
))
1084 node
->flags
|= NODE_USED
;
1085 if ((!pfile
->cb
.user_builtin_macro
1086 || !pfile
->cb
.user_builtin_macro (pfile
, node
))
1087 && pfile
->cb
.used_define
)
1088 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1091 /* Handle standard macros. */
1092 if (! (node
->flags
& NODE_BUILTIN
))
1094 cpp_macro
*macro
= node
->value
.macro
;
1095 _cpp_buff
*pragma_buff
= NULL
;
1097 if (macro
->fun_like
)
1100 unsigned num_args
= 0;
1102 pfile
->state
.prevent_expansion
++;
1103 pfile
->keep_tokens
++;
1104 pfile
->state
.parsing_args
= 1;
1105 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
,
1107 pfile
->state
.parsing_args
= 0;
1108 pfile
->keep_tokens
--;
1109 pfile
->state
.prevent_expansion
--;
1113 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
1114 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
1115 "function-like macro \"%s\" must be used with arguments in traditional C",
1119 _cpp_release_buff (pfile
, pragma_buff
);
1121 pfile
->about_to_expand_macro_p
= false;
1125 if (macro
->paramc
> 0)
1126 replace_args (pfile
, node
, macro
,
1127 (macro_arg
*) buff
->base
,
1129 /* Free the memory used by the arguments of this
1130 function-like macro. This memory has been allocated by
1131 funlike_invocation_p and by replace_args. */
1132 delete_macro_args (buff
, num_args
);
1135 /* Disable the macro within its expansion. */
1136 node
->flags
|= NODE_DISABLED
;
1138 if (!(node
->flags
& NODE_USED
))
1140 node
->flags
|= NODE_USED
;
1141 if (pfile
->cb
.used_define
)
1142 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
1146 pfile
->cb
.used (pfile
, location
, node
);
1150 if (macro
->paramc
== 0)
1152 unsigned tokens_count
= macro_real_token_count (macro
);
1153 if (CPP_OPTION (pfile
, track_macro_expansion
))
1156 const cpp_token
*src
= macro
->exp
.tokens
;
1157 const struct line_map
*map
;
1158 source_location
*virt_locs
= NULL
;
1159 _cpp_buff
*macro_tokens
1160 = tokens_buff_new (pfile
, tokens_count
, &virt_locs
);
1162 /* Create a macro map to record the locations of the
1163 tokens that are involved in the expansion. LOCATION
1164 is the location of the macro expansion point. */
1165 map
= linemap_enter_macro (pfile
->line_table
,
1166 node
, location
, tokens_count
);
1167 for (i
= 0; i
< tokens_count
; ++i
)
1169 tokens_buff_add_token (macro_tokens
, virt_locs
,
1171 src
->src_loc
, map
, i
);
1174 push_extended_tokens_context (pfile
, node
,
1177 (const cpp_token
**)
1182 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
,
1184 num_macro_tokens_counter
+= tokens_count
;
1189 if (!pfile
->state
.in_directive
)
1190 _cpp_push_token_context (pfile
, NULL
,
1191 padding_token (pfile
, result
), 1);
1194 unsigned tokens_count
;
1195 _cpp_buff
*tail
= pragma_buff
->next
;
1196 pragma_buff
->next
= NULL
;
1197 tokens_count
= ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
1198 - (const cpp_token
**) pragma_buff
->base
);
1199 push_ptoken_context (pfile
, NULL
, pragma_buff
,
1200 (const cpp_token
**) pragma_buff
->base
,
1203 if (!CPP_OPTION (pfile
, track_macro_expansion
))
1204 num_macro_tokens_counter
+= tokens_count
;
1207 while (pragma_buff
!= NULL
);
1208 pfile
->about_to_expand_macro_p
= false;
1212 pfile
->about_to_expand_macro_p
= false;
1216 pfile
->about_to_expand_macro_p
= false;
1217 /* Handle built-in macros and the _Pragma operator. */
1218 return builtin_macro (pfile
, node
, location
);
1221 /* De-allocate the memory used by BUFF which is an array of instances
1222 of macro_arg. NUM_ARGS is the number of instances of macro_arg
1225 delete_macro_args (_cpp_buff
*buff
, unsigned num_args
)
1227 macro_arg
*macro_args
;
1233 macro_args
= (macro_arg
*) buff
->base
;
1235 /* Walk instances of macro_arg to free their expanded tokens as well
1236 as their macro_arg::virt_locs members. */
1237 for (i
= 0; i
< num_args
; ++i
)
1239 if (macro_args
[i
].expanded
)
1241 free (macro_args
[i
].expanded
);
1242 macro_args
[i
].expanded
= NULL
;
1244 if (macro_args
[i
].virt_locs
)
1246 free (macro_args
[i
].virt_locs
);
1247 macro_args
[i
].virt_locs
= NULL
;
1249 if (macro_args
[i
].expanded_virt_locs
)
1251 free (macro_args
[i
].expanded_virt_locs
);
1252 macro_args
[i
].expanded_virt_locs
= NULL
;
1255 _cpp_free_buff (buff
);
1258 /* Set the INDEXth token of the macro argument ARG. TOKEN is the token
1259 to set, LOCATION is its virtual location. "Virtual" location means
1260 the location that encodes loci across macro expansion. Otherwise
1261 it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
1262 argument ARG is supposed to contain. Note that ARG must be
1263 tailored so that it has enough room to contain INDEX + 1 numbers of
1264 tokens, at least. */
1266 set_arg_token (macro_arg
*arg
, const cpp_token
*token
,
1267 source_location location
, size_t index
,
1268 enum macro_arg_token_kind kind
,
1269 bool track_macro_exp_p
)
1271 const cpp_token
**token_ptr
;
1272 source_location
*loc
= NULL
;
1275 arg_token_ptr_at (arg
, index
, kind
,
1276 track_macro_exp_p
? &loc
: NULL
);
1281 #ifdef ENABLE_CHECKING
1282 if (kind
== MACRO_ARG_TOKEN_STRINGIFIED
1283 || !track_macro_exp_p
)
1284 /* We can't set the location of a stringified argument
1285 token and we can't set any location if we aren't tracking
1286 macro expansion locations. */
1293 /* Get the pointer to the location of the argument token of the
1294 function-like macro argument ARG. This function must be called
1295 only when we -ftrack-macro-expansion is on. */
1296 static const source_location
*
1297 get_arg_token_location (const macro_arg
*arg
,
1298 enum macro_arg_token_kind kind
)
1300 const source_location
*loc
= NULL
;
1301 const cpp_token
**token_ptr
=
1302 arg_token_ptr_at (arg
, 0, kind
, (source_location
**) &loc
);
1304 if (token_ptr
== NULL
)
1310 /* Return the pointer to the INDEXth token of the macro argument ARG.
1311 KIND specifies the kind of token the macro argument ARG contains.
1312 If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
1313 of the virtual location of the returned token if the
1314 -ftrack-macro-expansion flag is on; otherwise, it's set to the
1315 spelling location of the returned token. */
1316 static const cpp_token
**
1317 arg_token_ptr_at (const macro_arg
*arg
, size_t index
,
1318 enum macro_arg_token_kind kind
,
1319 source_location
**virt_location
)
1321 const cpp_token
**tokens_ptr
= NULL
;
1325 case MACRO_ARG_TOKEN_NORMAL
:
1326 tokens_ptr
= arg
->first
;
1328 case MACRO_ARG_TOKEN_STRINGIFIED
:
1329 tokens_ptr
= (const cpp_token
**) &arg
->stringified
;
1331 case MACRO_ARG_TOKEN_EXPANDED
:
1332 tokens_ptr
= arg
->expanded
;
1336 if (tokens_ptr
== NULL
)
1337 /* This can happen for e.g, an empty token argument to a
1338 funtion-like macro. */
1343 if (kind
== MACRO_ARG_TOKEN_NORMAL
)
1344 *virt_location
= &arg
->virt_locs
[index
];
1345 else if (kind
== MACRO_ARG_TOKEN_EXPANDED
)
1346 *virt_location
= &arg
->expanded_virt_locs
[index
];
1347 else if (kind
== MACRO_ARG_TOKEN_STRINGIFIED
)
1349 (source_location
*) &tokens_ptr
[index
]->src_loc
;
1351 return &tokens_ptr
[index
];
1354 /* Initialize an iterator so that it iterates over the tokens of a
1355 function-like macro argument. KIND is the kind of tokens we want
1356 ITER to iterate over. TOKEN_PTR points the first token ITER will
1359 macro_arg_token_iter_init (macro_arg_token_iter
*iter
,
1360 bool track_macro_exp_p
,
1361 enum macro_arg_token_kind kind
,
1362 const macro_arg
*arg
,
1363 const cpp_token
**token_ptr
)
1365 iter
->track_macro_exp_p
= track_macro_exp_p
;
1367 iter
->token_ptr
= token_ptr
;
1368 /* Unconditionally initialize this so that the compiler doesn't warn
1369 about iter->location_ptr being possibly uninitialized later after
1370 this code has been inlined somewhere. */
1371 iter
->location_ptr
= NULL
;
1372 if (track_macro_exp_p
)
1373 iter
->location_ptr
= get_arg_token_location (arg
, kind
);
1374 #ifdef ENABLE_CHECKING
1375 iter
->num_forwards
= 0;
1376 if (track_macro_exp_p
1377 && token_ptr
!= NULL
1378 && iter
->location_ptr
== NULL
)
1383 /* Move the iterator one token forward. Note that if IT was
1384 initialized on an argument that has a stringified token, moving it
1385 forward doesn't make sense as a stringified token is essentially one
1388 macro_arg_token_iter_forward (macro_arg_token_iter
*it
)
1392 case MACRO_ARG_TOKEN_NORMAL
:
1393 case MACRO_ARG_TOKEN_EXPANDED
:
1395 if (it
->track_macro_exp_p
)
1398 case MACRO_ARG_TOKEN_STRINGIFIED
:
1399 #ifdef ENABLE_CHECKING
1400 if (it
->num_forwards
> 0)
1406 #ifdef ENABLE_CHECKING
1411 /* Return the token pointed to by the iterator. */
1412 static const cpp_token
*
1413 macro_arg_token_iter_get_token (const macro_arg_token_iter
*it
)
1415 #ifdef ENABLE_CHECKING
1416 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1417 && it
->num_forwards
> 0)
1420 if (it
->token_ptr
== NULL
)
1422 return *it
->token_ptr
;
1425 /* Return the location of the token pointed to by the iterator.*/
1426 static source_location
1427 macro_arg_token_iter_get_location (const macro_arg_token_iter
*it
)
1429 #ifdef ENABLE_CHECKING
1430 if (it
->kind
== MACRO_ARG_TOKEN_STRINGIFIED
1431 && it
->num_forwards
> 0)
1434 if (it
->track_macro_exp_p
)
1435 return *it
->location_ptr
;
1437 return (*it
->token_ptr
)->src_loc
;
1440 /* Return the index of a token [resulting from macro expansion] inside
1441 the total list of tokens resulting from a given macro
1442 expansion. The index can be different depending on whether if we
1443 want each tokens resulting from function-like macro arguments
1444 expansion to have a different location or not.
1446 E.g, consider this function-like macro:
1450 Then consider us "calling" it (and thus expanding it) like:
1454 It will be expanded into:
1458 Let's consider the case of the token '4'.
1460 Its index can be 2 (it's the third token of the set of tokens
1461 resulting from the expansion) or it can be 0 if we consider that
1462 all tokens resulting from the expansion of the argument "1+2" have
1463 the same index, which is 0. In this later case, the index of token
1464 '-' would then be 1 and the index of token '3' would be 2.
1466 The later case is useful to use less memory e.g, for the case of
1467 the user using the option -ftrack-macro-expansion=1.
1469 ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
1470 are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
1471 parameter (inside the macro replacement list) that corresponds to
1472 the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
1475 If we refer to the example above, for the '4' argument token,
1476 ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
1477 would be set to the token 'x', in the replacement list "x - 3" of
1480 This is a subroutine of replace_args. */
1481 inline static unsigned
1482 expanded_token_index (cpp_reader
*pfile
, cpp_macro
*macro
,
1483 const cpp_token
*cur_replacement_token
,
1484 unsigned absolute_token_index
)
1486 if (CPP_OPTION (pfile
, track_macro_expansion
) > 1)
1487 return absolute_token_index
;
1488 return cur_replacement_token
- macro
->exp
.tokens
;
1491 /* Replace the parameters in a function-like macro of NODE with the
1492 actual ARGS, and place the result in a newly pushed token context.
1493 Expand each argument before replacing, unless it is operated upon
1494 by the # or ## operators. EXPANSION_POINT_LOC is the location of
1495 the expansion point of the macro. E.g, the location of the
1496 function-like macro invocation. */
1498 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
,
1499 macro_arg
*args
, source_location expansion_point_loc
)
1501 unsigned int i
, total
;
1502 const cpp_token
*src
, *limit
;
1503 const cpp_token
**first
= NULL
;
1505 _cpp_buff
*buff
= NULL
;
1506 source_location
*virt_locs
= NULL
;
1507 unsigned int exp_count
;
1508 const struct line_map
*map
= NULL
;
1509 int track_macro_exp
;
1511 /* First, fully macro-expand arguments, calculating the number of
1512 tokens in the final expansion as we go. The ordering of the if
1513 statements below is subtle; we must handle stringification before
1516 /* EXP_COUNT is the number of tokens in the macro replacement
1517 list. TOTAL is the number of tokens /after/ macro parameters
1518 have been replaced by their arguments. */
1519 exp_count
= macro_real_token_count (macro
);
1521 limit
= macro
->exp
.tokens
+ exp_count
;
1523 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1524 if (src
->type
== CPP_MACRO_ARG
)
1526 /* Leading and trailing padding tokens. */
1528 /* Account for leading and padding tokens in exp_count too.
1529 This is going to be important later down this function,
1530 when we want to handle the case of (track_macro_exp <
1534 /* We have an argument. If it is not being stringified or
1535 pasted it is macro-replaced before insertion. */
1536 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
1538 if (src
->flags
& STRINGIFY_ARG
)
1540 if (!arg
->stringified
)
1541 arg
->stringified
= stringify_arg (pfile
, arg
);
1543 else if ((src
->flags
& PASTE_LEFT
)
1544 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
1545 total
+= arg
->count
- 1;
1549 expand_arg (pfile
, arg
);
1550 total
+= arg
->expanded_count
- 1;
1554 /* When the compiler is called with the -ftrack-macro-expansion
1555 flag, we need to keep track of the location of each token that
1556 results from macro expansion.
1558 A token resulting from macro expansion is not a new token. It is
1559 simply the same token as the token coming from the macro
1560 definition. The new things that are allocated are the buffer
1561 that holds the tokens resulting from macro expansion and a new
1562 location that records many things like the locus of the expansion
1563 point as well as the original locus inside the definition of the
1564 macro. This location is called a virtual location.
1566 So the buffer BUFF holds a set of cpp_token*, and the buffer
1567 VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
1569 Both of these two buffers are going to be hung off of the macro
1570 context, when the latter is pushed. The memory allocated to
1571 store the tokens and their locations is going to be freed once
1572 the context of macro expansion is popped.
1574 As far as tokens are concerned, the memory overhead of
1575 -ftrack-macro-expansion is proportional to the number of
1576 macros that get expanded multiplied by sizeof (source_location).
1577 The good news is that extra memory gets freed when the macro
1578 context is freed, i.e shortly after the macro got expanded. */
1580 /* Is the -ftrack-macro-expansion flag in effect? */
1581 track_macro_exp
= CPP_OPTION (pfile
, track_macro_expansion
);
1583 /* Now allocate memory space for tokens and locations resulting from
1584 the macro expansion, copy the tokens and replace the arguments.
1585 This memory must be freed when the context of the macro MACRO is
1587 buff
= tokens_buff_new (pfile
, total
, track_macro_exp
? &virt_locs
: NULL
);
1589 first
= (const cpp_token
**) buff
->base
;
1591 /* Create a macro map to record the locations of the tokens that are
1592 involved in the expansion. Note that the expansion point is set
1593 to the location of the closing parenthesis. Otherwise, the
1594 subsequent map created for the first token that comes after the
1595 macro map might have a wrong line number. That would lead to
1596 tokens with wrong line numbers after the macro expansion. This
1597 adds up to the memory overhead of the -ftrack-macro-expansion
1598 flag; for every macro that is expanded, a "macro map" is
1600 if (track_macro_exp
)
1602 int num_macro_tokens
= total
;
1603 if (track_macro_exp
< 2)
1604 /* Then the number of macro tokens won't take in account the
1605 fact that function-like macro arguments can expand to
1606 multiple tokens. This is to save memory at the expense of
1609 Suppose we have #define SQARE(A) A * A
1611 And then we do SQARE(2+3)
1613 Then the tokens 2, +, 3, will have the same location,
1614 saying they come from the expansion of the argument A. */
1615 num_macro_tokens
= exp_count
;
1616 map
= linemap_enter_macro (pfile
->line_table
, node
,
1617 expansion_point_loc
,
1621 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
1623 unsigned int arg_tokens_count
;
1624 macro_arg_token_iter from
;
1625 const cpp_token
**paste_flag
= NULL
;
1626 const cpp_token
**tmp_token_ptr
;
1628 if (src
->type
!= CPP_MACRO_ARG
)
1630 /* Allocate a virtual location for token SRC, and add that
1631 token and its virtual location into the buffers BUFF and
1633 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
1634 tokens_buff_add_token (buff
, virt_locs
, src
,
1635 src
->src_loc
, src
->src_loc
,
1642 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
1643 /* SRC is a macro parameter that we need to replace with its
1644 corresponding argument. So at some point we'll need to
1645 iterate over the tokens of the macro argument and copy them
1646 into the "place" now holding the correspondig macro
1647 parameter. We are going to use the iterator type
1648 macro_argo_token_iter to handle that iterating. The 'if'
1649 below is to initialize the iterator depending on the type of
1650 tokens the macro argument has. It also does some adjustment
1651 related to padding tokens and some pasting corner cases. */
1652 if (src
->flags
& STRINGIFY_ARG
)
1654 arg_tokens_count
= 1;
1655 macro_arg_token_iter_init (&from
,
1657 track_macro_expansion
),
1658 MACRO_ARG_TOKEN_STRINGIFIED
,
1659 arg
, &arg
->stringified
);
1661 else if (src
->flags
& PASTE_LEFT
)
1663 arg_tokens_count
= arg
->count
;
1664 macro_arg_token_iter_init (&from
,
1666 track_macro_expansion
),
1667 MACRO_ARG_TOKEN_NORMAL
,
1670 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
1673 arg_tokens_count
= arg
->count
;
1674 macro_arg_token_iter_init (&from
,
1676 track_macro_expansion
),
1677 MACRO_ARG_TOKEN_NORMAL
,
1680 num_toks
= tokens_buff_count (buff
);
1684 /* So the current parameter token is pasted to the previous
1685 token in the replacement list. Let's look at what
1686 we have as previous and current arguments. */
1688 /* This is the previous argument's token ... */
1689 tmp_token_ptr
= tokens_buff_last_token_ptr (buff
);
1691 if ((*tmp_token_ptr
)->type
== CPP_COMMA
1693 && src
->val
.macro_arg
.arg_no
== macro
->paramc
)
1695 /* ... which is a comma; and the current parameter
1696 is the last parameter of a variadic function-like
1697 macro. If the argument to the current last
1698 parameter is NULL, then swallow the comma,
1699 otherwise drop the paste flag. */
1700 if (macro_arg_token_iter_get_token (&from
) == NULL
)
1701 tokens_buff_remove_last_token (buff
);
1703 paste_flag
= tmp_token_ptr
;
1705 /* Remove the paste flag if the RHS is a placemarker. */
1706 else if (arg_tokens_count
== 0)
1707 paste_flag
= tmp_token_ptr
;
1712 arg_tokens_count
= arg
->expanded_count
;
1713 macro_arg_token_iter_init (&from
,
1715 track_macro_expansion
),
1716 MACRO_ARG_TOKEN_EXPANDED
,
1717 arg
, arg
->expanded
);
1720 /* Padding on the left of an argument (unless RHS of ##). */
1721 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
1722 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
1724 const cpp_token
*t
= padding_token (pfile
, src
);
1725 unsigned index
= expanded_token_index (pfile
, macro
, src
, i
);
1726 /* Allocate a virtual location for the padding token and
1727 append the token and its location to BUFF and
1729 tokens_buff_add_token (buff
, virt_locs
, t
,
1730 t
->src_loc
, t
->src_loc
,
1734 if (arg_tokens_count
)
1736 /* So now we've got the number of tokens that make up the
1737 argument that is going to replace the current parameter
1738 in the macro's replacement list. */
1740 for (j
= 0; j
< arg_tokens_count
; ++j
)
1742 /* So if track_macro_exp is < 2, the user wants to
1743 save extra memory while tracking macro expansion
1744 locations. So in that case here is what we do:
1746 Suppose we have #define SQARE(A) A * A
1748 And then we do SQARE(2+3)
1750 Then the tokens 2, +, 3, will have the same location,
1751 saying they come from the expansion of the argument
1754 So that means we are going to ignore the COUNT tokens
1755 resulting from the expansion of the current macro
1756 arugment. In other words all the ARG_TOKENS_COUNT tokens
1757 resulting from the expansion of the macro argument will
1758 have the index I. Normally, each of those token should
1760 unsigned token_index
= i
;
1762 if (track_macro_exp
> 1)
1765 index
= expanded_token_index (pfile
, macro
, src
, token_index
);
1766 tokens_buff_add_token (buff
, virt_locs
,
1767 macro_arg_token_iter_get_token (&from
),
1768 macro_arg_token_iter_get_location (&from
),
1769 src
->src_loc
, map
, index
);
1770 macro_arg_token_iter_forward (&from
);
1773 /* With a non-empty argument on the LHS of ##, the last
1774 token should be flagged PASTE_LEFT. */
1775 if (src
->flags
& PASTE_LEFT
)
1777 (const cpp_token
**) tokens_buff_last_token_ptr (buff
);
1779 else if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
1780 && ! CPP_OPTION (pfile
, c99
)
1781 && ! cpp_in_system_header (pfile
))
1783 if (CPP_OPTION (pfile
, cplusplus
))
1784 cpp_error (pfile
, CPP_DL_PEDWARN
,
1785 "invoking macro %s argument %d: "
1786 "empty macro arguments are undefined"
1789 src
->val
.macro_arg
.arg_no
);
1790 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
))
1791 cpp_error (pfile
, CPP_DL_PEDWARN
,
1792 "invoking macro %s argument %d: "
1793 "empty macro arguments are undefined"
1796 src
->val
.macro_arg
.arg_no
);
1798 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
1800 && ! cpp_in_system_header (pfile
)
1801 && ! CPP_OPTION (pfile
, cplusplus
))
1802 cpp_error (pfile
, CPP_DL_WARNING
,
1803 "invoking macro %s argument %d: "
1804 "empty macro arguments are undefined"
1807 src
->val
.macro_arg
.arg_no
);
1809 /* Avoid paste on RHS (even case count == 0). */
1810 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
1812 const cpp_token
*t
= &pfile
->avoid_paste
;
1813 tokens_buff_add_token (buff
, virt_locs
,
1814 t
, t
->src_loc
, t
->src_loc
,
1818 /* Add a new paste flag, or remove an unwanted one. */
1821 cpp_token
*token
= _cpp_temp_token (pfile
);
1822 token
->type
= (*paste_flag
)->type
;
1823 token
->val
= (*paste_flag
)->val
;
1824 if (src
->flags
& PASTE_LEFT
)
1825 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1827 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1828 *paste_flag
= token
;
1831 i
+= arg_tokens_count
;
1834 if (track_macro_exp
)
1835 push_extended_tokens_context (pfile
, node
, buff
, virt_locs
, first
,
1836 tokens_buff_count (buff
));
1838 push_ptoken_context (pfile
, node
, buff
, first
,
1839 tokens_buff_count (buff
));
1841 num_macro_tokens_counter
+= tokens_buff_count (buff
);
1844 /* Return a special padding token, with padding inherited from SOURCE. */
1845 static const cpp_token
*
1846 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
1848 cpp_token
*result
= _cpp_temp_token (pfile
);
1850 result
->type
= CPP_PADDING
;
1852 /* Data in GCed data structures cannot be made const so far, so we
1853 need a cast here. */
1854 result
->val
.source
= (cpp_token
*) source
;
1859 /* Get a new uninitialized context. Create a new one if we cannot
1860 re-use an old one. */
1861 static cpp_context
*
1862 next_context (cpp_reader
*pfile
)
1864 cpp_context
*result
= pfile
->context
->next
;
1868 result
= XNEW (cpp_context
);
1869 memset (result
, 0, sizeof (cpp_context
));
1870 result
->prev
= pfile
->context
;
1872 pfile
->context
->next
= result
;
1875 pfile
->context
= result
;
1879 /* Push a list of pointers to tokens. */
1881 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
1882 const cpp_token
**first
, unsigned int count
)
1884 cpp_context
*context
= next_context (pfile
);
1886 context
->tokens_kind
= TOKENS_KIND_INDIRECT
;
1887 context
->c
.macro
= macro
;
1888 context
->buff
= buff
;
1889 FIRST (context
).ptoken
= first
;
1890 LAST (context
).ptoken
= first
+ count
;
1893 /* Push a list of tokens.
1895 A NULL macro means that we should continue the current macro
1896 expansion, in essence. That means that if we are currently in a
1897 macro expansion context, we'll make the new pfile->context refer to
1898 the current macro. */
1900 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1901 const cpp_token
*first
, unsigned int count
)
1903 cpp_context
*context
;
1906 macro
= macro_of_context (pfile
->context
);
1908 context
= next_context (pfile
);
1909 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
1910 context
->c
.macro
= macro
;
1911 context
->buff
= NULL
;
1912 FIRST (context
).token
= first
;
1913 LAST (context
).token
= first
+ count
;
1916 /* Build a context containing a list of tokens as well as their
1917 virtual locations and push it. TOKENS_BUFF is the buffer that
1918 contains the tokens pointed to by FIRST. If TOKENS_BUFF is
1919 non-NULL, it means that the context owns it, meaning that
1920 _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
1921 contains the virtual locations.
1923 A NULL macro means that we should continue the current macro
1924 expansion, in essence. That means that if we are currently in a
1925 macro expansion context, we'll make the new pfile->context refer to
1926 the current macro. */
1928 push_extended_tokens_context (cpp_reader
*pfile
,
1929 cpp_hashnode
*macro
,
1930 _cpp_buff
*token_buff
,
1931 source_location
*virt_locs
,
1932 const cpp_token
**first
,
1935 cpp_context
*context
;
1939 macro
= macro_of_context (pfile
->context
);
1941 context
= next_context (pfile
);
1942 context
->tokens_kind
= TOKENS_KIND_EXTENDED
;
1943 context
->buff
= token_buff
;
1945 m
= XNEW (macro_context
);
1946 m
->macro_node
= macro
;
1947 m
->virt_locs
= virt_locs
;
1948 m
->cur_virt_loc
= virt_locs
;
1950 FIRST (context
).ptoken
= first
;
1951 LAST (context
).ptoken
= first
+ count
;
1954 /* Push a traditional macro's replacement text. */
1956 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1957 const uchar
*start
, size_t len
)
1959 cpp_context
*context
= next_context (pfile
);
1961 context
->tokens_kind
= TOKENS_KIND_DIRECT
;
1962 context
->c
.macro
= macro
;
1963 context
->buff
= NULL
;
1964 CUR (context
) = start
;
1965 RLIMIT (context
) = start
+ len
;
1966 macro
->flags
|= NODE_DISABLED
;
1969 /* Creates a buffer that holds tokens a.k.a "token buffer", usually
1970 for the purpose of storing them on a cpp_context. If VIRT_LOCS is
1971 non-null (which means that -ftrack-macro-expansion is on),
1972 *VIRT_LOCS is set to a newly allocated buffer that is supposed to
1973 hold the virtual locations of the tokens resulting from macro
1976 tokens_buff_new (cpp_reader
*pfile
, size_t len
,
1977 source_location
**virt_locs
)
1979 size_t tokens_size
= len
* sizeof (cpp_token
*);
1980 size_t locs_size
= len
* sizeof (source_location
);
1982 if (virt_locs
!= NULL
)
1983 *virt_locs
= XNEWVEC (source_location
, locs_size
);
1984 return _cpp_get_buff (pfile
, tokens_size
);
1987 /* Returns the number of tokens contained in a token buffer. The
1988 buffer holds a set of cpp_token*. */
1990 tokens_buff_count (_cpp_buff
*buff
)
1992 return (BUFF_FRONT (buff
) - buff
->base
) / sizeof (cpp_token
*);
1995 /* Return a pointer to the last token contained in the token buffer
1997 static const cpp_token
**
1998 tokens_buff_last_token_ptr (_cpp_buff
*buff
)
2000 return &((const cpp_token
**) BUFF_FRONT (buff
))[-1];
2003 /* Remove the last token contained in the token buffer TOKENS_BUFF.
2004 If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
2005 containing the virtual locations of the tokens in TOKENS_BUFF; in
2006 which case the function updates that buffer as well. */
2008 tokens_buff_remove_last_token (_cpp_buff
*tokens_buff
)
2011 if (BUFF_FRONT (tokens_buff
) > tokens_buff
->base
)
2012 BUFF_FRONT (tokens_buff
) =
2013 (unsigned char *) &((cpp_token
**) BUFF_FRONT (tokens_buff
))[-1];
2016 /* Insert a token into the token buffer at the position pointed to by
2017 DEST. Note that the buffer is not enlarged so the previous token
2018 that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
2019 means -ftrack-macro-expansion is effect; it then points to where to
2020 insert the virtual location of TOKEN. TOKEN is the token to
2021 insert. VIRT_LOC is the virtual location of the token, i.e, the
2022 location possibly encoding its locus across macro expansion. If
2023 TOKEN is an argument of a function-like macro (inside a macro
2024 replacement list), PARM_DEF_LOC is the spelling location of the
2025 macro parameter that TOKEN is replacing, in the replacement list of
2026 the macro. If TOKEN is not an argument of a function-like macro or
2027 if it doesn't come from a macro expansion, then VIRT_LOC can just
2028 be set to the same value as PARM_DEF_LOC. If MAP is non null, it
2029 means TOKEN comes from a macro expansion and MAP is the macro map
2030 associated to the macro. MACRO_TOKEN_INDEX points to the index of
2031 the token in the macro map; it is not considered if MAP is NULL.
2033 Upon successful completion this function returns the a pointer to
2034 the position of the token coming right after the insertion
2036 static inline const cpp_token
**
2037 tokens_buff_put_token_to (const cpp_token
**dest
,
2038 source_location
*virt_loc_dest
,
2039 const cpp_token
*token
,
2040 source_location virt_loc
,
2041 source_location parm_def_loc
,
2042 const struct line_map
*map
,
2043 unsigned int macro_token_index
)
2045 source_location macro_loc
= virt_loc
;
2046 const cpp_token
**result
;
2050 /* -ftrack-macro-expansion is on. */
2052 macro_loc
= linemap_add_macro_token (map
, macro_token_index
,
2053 virt_loc
, parm_def_loc
);
2054 *virt_loc_dest
= macro_loc
;
2062 /* Adds a token at the end of the tokens contained in BUFFER. Note
2063 that this function doesn't enlarge BUFFER when the number of tokens
2064 reaches BUFFER's size; it aborts in that situation.
2066 TOKEN is the token to append. VIRT_LOC is the virtual location of
2067 the token, i.e, the location possibly encoding its locus across
2068 macro expansion. If TOKEN is an argument of a function-like macro
2069 (inside a macro replacement list), PARM_DEF_LOC is the location of
2070 the macro parameter that TOKEN is replacing. If TOKEN doesn't come
2071 from a macro expansion, then VIRT_LOC can just be set to the same
2072 value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
2073 from a macro expansion and MAP is the macro map associated to the
2074 macro. MACRO_TOKEN_INDEX points to the index of the token in the
2075 macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
2076 non-null, it means -ftrack-macro-expansion is on; in which case
2077 this function adds the virtual location DEF_LOC to the VIRT_LOCS
2078 array, at the same index as the one of TOKEN in BUFFER. Upon
2079 successful completion this function returns the a pointer to the
2080 position of the token coming right after the insertion point. */
2081 static const cpp_token
**
2082 tokens_buff_add_token (_cpp_buff
*buffer
,
2083 source_location
*virt_locs
,
2084 const cpp_token
*token
,
2085 source_location virt_loc
,
2086 source_location parm_def_loc
,
2087 const struct line_map
*map
,
2088 unsigned int macro_token_index
)
2090 const cpp_token
**result
;
2091 source_location
*virt_loc_dest
= NULL
;
2092 unsigned token_index
=
2093 (BUFF_FRONT (buffer
) - buffer
->base
) / sizeof (cpp_token
*);
2095 /* Abort if we pass the end the buffer. */
2096 if (BUFF_FRONT (buffer
) > BUFF_LIMIT (buffer
))
2099 if (virt_locs
!= NULL
)
2100 virt_loc_dest
= &virt_locs
[token_index
];
2103 tokens_buff_put_token_to ((const cpp_token
**) BUFF_FRONT (buffer
),
2104 virt_loc_dest
, token
, virt_loc
, parm_def_loc
,
2105 map
, macro_token_index
);
2107 BUFF_FRONT (buffer
) = (unsigned char *) result
;
2111 /* Allocate space for the function-like macro argument ARG to store
2112 the tokens resulting from the macro-expansion of the tokens that
2113 make up ARG itself. That space is allocated in ARG->expanded and
2114 needs to be freed using free. */
2116 alloc_expanded_arg_mem (cpp_reader
*pfile
, macro_arg
*arg
, size_t capacity
)
2118 #ifdef ENABLE_CHECKING
2119 if (arg
->expanded
!= NULL
2120 || arg
->expanded_virt_locs
!= NULL
)
2123 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
2124 if (CPP_OPTION (pfile
, track_macro_expansion
))
2125 arg
->expanded_virt_locs
= XNEWVEC (source_location
, capacity
);
2129 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
2132 ensure_expanded_arg_room (cpp_reader
*pfile
, macro_arg
*arg
,
2133 size_t size
, size_t *expanded_capacity
)
2135 if (size
<= *expanded_capacity
)
2141 XRESIZEVEC (const cpp_token
*, arg
->expanded
, size
);
2142 *expanded_capacity
= size
;
2144 if (CPP_OPTION (pfile
, track_macro_expansion
))
2146 if (arg
->expanded_virt_locs
== NULL
)
2147 arg
->expanded_virt_locs
= XNEWVEC (source_location
, size
);
2149 arg
->expanded_virt_locs
= XRESIZEVEC (source_location
,
2150 arg
->expanded_virt_locs
,
2155 /* Expand an argument ARG before replacing parameters in a
2156 function-like macro. This works by pushing a context with the
2157 argument's tokens, and then expanding that into a temporary buffer
2158 as if it were a normal part of the token stream. collect_args()
2159 has terminated the argument's tokens with a CPP_EOF so that we know
2160 when we have fully expanded the argument. */
2162 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
2165 bool saved_warn_trad
;
2166 bool track_macro_exp_p
= CPP_OPTION (pfile
, track_macro_expansion
);
2169 || arg
->expanded
!= NULL
)
2172 /* Don't warn about funlike macros when pre-expanding. */
2173 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
2174 CPP_WTRADITIONAL (pfile
) = 0;
2176 /* Loop, reading in the tokens of the argument. */
2178 alloc_expanded_arg_mem (pfile
, arg
, capacity
);
2180 if (track_macro_exp_p
)
2181 push_extended_tokens_context (pfile
, NULL
, NULL
,
2186 push_ptoken_context (pfile
, NULL
, NULL
,
2187 arg
->first
, arg
->count
+ 1);
2191 const cpp_token
*token
;
2192 source_location location
;
2194 ensure_expanded_arg_room (pfile
, arg
, arg
->expanded_count
+ 1,
2197 token
= cpp_get_token_1 (pfile
, &location
);
2199 if (token
->type
== CPP_EOF
)
2202 set_arg_token (arg
, token
, location
,
2203 arg
->expanded_count
, MACRO_ARG_TOKEN_EXPANDED
,
2204 CPP_OPTION (pfile
, track_macro_expansion
));
2205 arg
->expanded_count
++;
2208 _cpp_pop_context (pfile
);
2210 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
2213 /* Returns the macro associated to the current context if we are in
2214 the context a macro expansion, NULL otherwise. */
2215 static cpp_hashnode
*
2216 macro_of_context (cpp_context
*context
)
2218 if (context
== NULL
)
2221 return (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2222 ? context
->c
.mc
->macro_node
2226 /* Return TRUE iff we are expanding a macro or are about to start
2227 expanding one. If we are effectively expanding a macro, the
2228 function macro_of_context returns a pointer to the macro being
2231 in_macro_expansion_p (cpp_reader
*pfile
)
2236 return (pfile
->about_to_expand_macro_p
2237 || macro_of_context (pfile
->context
));
2240 /* Pop the current context off the stack, re-enabling the macro if the
2241 context represented a macro's replacement list. Initially the
2242 context structure was not freed so that we can re-use it later, but
2243 now we do free it to reduce peak memory consumption. */
2245 _cpp_pop_context (cpp_reader
*pfile
)
2247 cpp_context
*context
= pfile
->context
;
2249 /* We should not be popping the base context. */
2250 if (context
== &pfile
->base_context
)
2253 if (context
->c
.macro
)
2255 cpp_hashnode
*macro
;
2256 if (context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2258 macro_context
*mc
= context
->c
.mc
;
2259 macro
= mc
->macro_node
;
2260 /* If context->buff is set, it means the life time of tokens
2261 is bound to the life time of this context; so we must
2262 free the tokens; that means we must free the virtual
2263 locations of these tokens too. */
2264 if (context
->buff
&& mc
->virt_locs
)
2266 free (mc
->virt_locs
);
2267 mc
->virt_locs
= NULL
;
2270 context
->c
.mc
= NULL
;
2273 macro
= context
->c
.macro
;
2275 /* Beware that MACRO can be NULL in cases like when we are
2276 called from expand_arg. In those cases, a dummy context with
2277 tokens is pushed just for the purpose of walking them using
2278 cpp_get_token_1. In that case, no 'macro' field is set into
2279 the dummy context. */
2281 /* Several contiguous macro expansion contexts can be
2282 associated to the same macro; that means it's the same
2283 macro expansion that spans across all these (sub)
2284 contexts. So we should re-enable an expansion-disabled
2285 macro only when we are sure we are really out of that
2287 && macro_of_context (context
->prev
) != macro
)
2288 macro
->flags
&= ~NODE_DISABLED
;
2293 /* Decrease memory peak consumption by freeing the memory used
2295 _cpp_free_buff (context
->buff
);
2298 pfile
->context
= context
->prev
;
2299 /* decrease peak memory consumption by feeing the context. */
2300 pfile
->context
->next
= NULL
;
2304 /* Return TRUE if we reached the end of the set of tokens stored in
2305 CONTEXT, FALSE otherwise. */
2307 reached_end_of_context (cpp_context
*context
)
2309 if (context
->tokens_kind
== TOKENS_KIND_DIRECT
)
2310 return FIRST (context
).token
== LAST (context
).token
;
2311 else if (context
->tokens_kind
== TOKENS_KIND_INDIRECT
2312 || context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2313 return FIRST (context
).ptoken
== LAST (context
).ptoken
;
2318 /* Consume the next token contained in the current context of PFILE,
2319 and return it in *TOKEN. It's "full location" is returned in
2320 *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
2321 means the location encoding the locus of the token across macro
2322 expansion; otherwise it's just is the "normal" location of the
2323 token which (*TOKEN)->src_loc. */
2325 consume_next_token_from_context (cpp_reader
*pfile
,
2326 const cpp_token
** token
,
2327 source_location
*location
)
2329 cpp_context
*c
= pfile
->context
;
2331 if ((c
)->tokens_kind
== TOKENS_KIND_DIRECT
)
2333 *token
= FIRST (c
).token
;
2334 *location
= (*token
)->src_loc
;
2337 else if ((c
)->tokens_kind
== TOKENS_KIND_INDIRECT
)
2339 *token
= *FIRST (c
).ptoken
;
2340 *location
= (*token
)->src_loc
;
2343 else if ((c
)->tokens_kind
== TOKENS_KIND_EXTENDED
)
2345 macro_context
*m
= c
->c
.mc
;
2346 *token
= *FIRST (c
).ptoken
;
2349 *location
= *m
->cur_virt_loc
;
2353 *location
= (*token
)->src_loc
;
2360 /* In the traditional mode of the preprocessor, if we are currently in
2361 a directive, the location of a token must be the location of the
2362 start of the directive line. This function returns the proper
2363 location if we are in the traditional mode, and just returns
2364 LOCATION otherwise. */
2366 static inline source_location
2367 maybe_adjust_loc_for_trad_cpp (cpp_reader
*pfile
, source_location location
)
2369 if (CPP_OPTION (pfile
, traditional
))
2371 if (pfile
->state
.in_directive
)
2372 return pfile
->directive_line
;
2377 /* Routine to get a token as well as its location.
2379 Macro expansions and directives are transparently handled,
2380 including entering included files. Thus tokens are post-macro
2381 expansion, and after any intervening directives. External callers
2382 see CPP_EOF only at EOF. Internal callers also see it when meeting
2383 a directive inside a macro call, when at the end of a directive and
2384 state.in_directive is still 1, and at the end of argument
2387 LOC is an out parameter; *LOC is set to the location "as expected
2388 by the user". Please read the comment of
2389 cpp_get_token_with_location to learn more about the meaning of this
2391 static const cpp_token
*
2392 cpp_get_token_1 (cpp_reader
*pfile
, source_location
*location
)
2394 const cpp_token
*result
;
2395 /* This token is a virtual token that either encodes a location
2396 related to macro expansion or a spelling location. */
2397 source_location virt_loc
= 0;
2398 /* pfile->about_to_expand_macro_p can be overriden by indirect calls
2399 to functions that push macro contexts. So let's save it so that
2400 we can restore it when we are about to leave this routine. */
2401 bool saved_about_to_expand_macro
= pfile
->about_to_expand_macro_p
;
2406 cpp_context
*context
= pfile
->context
;
2408 /* Context->prev == 0 <=> base context. */
2411 result
= _cpp_lex_token (pfile
);
2412 virt_loc
= result
->src_loc
;
2414 else if (!reached_end_of_context (context
))
2416 consume_next_token_from_context (pfile
, &result
,
2418 if (result
->flags
& PASTE_LEFT
)
2420 paste_all_tokens (pfile
, result
);
2421 if (pfile
->state
.in_directive
)
2423 result
= padding_token (pfile
, result
);
2429 if (pfile
->context
->c
.macro
)
2430 ++num_expanded_macros_counter
;
2431 _cpp_pop_context (pfile
);
2432 if (pfile
->state
.in_directive
)
2434 result
= &pfile
->avoid_paste
;
2438 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
2441 if (result
->type
!= CPP_NAME
)
2444 node
= result
->val
.node
.node
;
2446 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
2449 if (!(node
->flags
& NODE_DISABLED
))
2452 /* If not in a macro context, and we're going to start an
2453 expansion, record the location. */
2454 if (!in_macro_expansion_p (pfile
))
2455 pfile
->invocation_location
= result
->src_loc
;
2456 if (pfile
->state
.prevent_expansion
)
2459 /* Conditional macros require that a predicate be evaluated
2461 if ((node
->flags
& NODE_CONDITIONAL
) != 0)
2463 if (pfile
->cb
.macro_to_expand
)
2465 bool whitespace_after
;
2466 const cpp_token
*peek_tok
= cpp_peek_token (pfile
, 0);
2468 whitespace_after
= (peek_tok
->type
== CPP_PADDING
2469 || (peek_tok
->flags
& PREV_WHITE
));
2470 node
= pfile
->cb
.macro_to_expand (pfile
, result
);
2472 ret
= enter_macro_context (pfile
, node
, result
,
2474 else if (whitespace_after
)
2476 /* If macro_to_expand hook returned NULL and it
2477 ate some tokens, see if we don't need to add
2478 a padding token in between this and the
2480 peek_tok
= cpp_peek_token (pfile
, 0);
2481 if (peek_tok
->type
!= CPP_PADDING
2482 && (peek_tok
->flags
& PREV_WHITE
) == 0)
2483 _cpp_push_token_context (pfile
, NULL
,
2484 padding_token (pfile
,
2490 ret
= enter_macro_context (pfile
, node
, result
,
2494 if (pfile
->state
.in_directive
|| ret
== 2)
2496 result
= padding_token (pfile
, result
);
2502 /* Flag this token as always unexpandable. FIXME: move this
2503 to collect_args()?. */
2504 cpp_token
*t
= _cpp_temp_token (pfile
);
2505 t
->type
= result
->type
;
2506 t
->flags
= result
->flags
| NO_EXPAND
;
2507 t
->val
= result
->val
;
2515 if (location
!= NULL
)
2518 virt_loc
= result
->src_loc
;
2519 *location
= virt_loc
;
2521 if (!CPP_OPTION (pfile
, track_macro_expansion
)
2522 && macro_of_context (pfile
->context
) != NULL
)
2523 /* We are in a macro expansion context, are not tracking
2524 virtual location, but were asked to report the location
2525 of the expansion point of the macro being expanded. */
2526 *location
= pfile
->invocation_location
;
2528 *location
= maybe_adjust_loc_for_trad_cpp (pfile
, *location
);
2531 pfile
->about_to_expand_macro_p
= saved_about_to_expand_macro
;
2535 /* External routine to get a token. Also used nearly everywhere
2536 internally, except for places where we know we can safely call
2537 _cpp_lex_token directly, such as lexing a directive name.
2539 Macro expansions and directives are transparently handled,
2540 including entering included files. Thus tokens are post-macro
2541 expansion, and after any intervening directives. External callers
2542 see CPP_EOF only at EOF. Internal callers also see it when meeting
2543 a directive inside a macro call, when at the end of a directive and
2544 state.in_directive is still 1, and at the end of argument
2547 cpp_get_token (cpp_reader
*pfile
)
2549 return cpp_get_token_1 (pfile
, NULL
);
2552 /* Like cpp_get_token, but also returns a virtual token location
2553 separate from the spelling location carried by the returned token.
2555 LOC is an out parameter; *LOC is set to the location "as expected
2556 by the user". This matters when a token results from macro
2557 expansion; in that case the token's spelling location indicates the
2558 locus of the token in the definition of the macro but *LOC
2559 virtually encodes all the other meaningful locuses associated to
2562 What? virtual location? Yes, virtual location.
2564 If the token results from macro expansion and if macro expansion
2565 location tracking is enabled its virtual location encodes (at the
2568 - the spelling location of the token
2570 - the locus of the macro expansion point
2572 - the locus of the point where the token got instantiated as part
2573 of the macro expansion process.
2575 You have to use the linemap API to get the locus you are interested
2576 in from a given virtual location.
2578 Note however that virtual locations are not necessarily ordered for
2579 relations '<' and '>'. One must use the function
2580 linemap_location_before_p instead of using the relational operator
2583 If macro expansion tracking is off and if the token results from
2584 macro expansion the virtual location is the expansion point of the
2585 macro that got expanded.
2587 When the token doesn't result from macro expansion, the virtual
2588 location is just the same thing as its spelling location. */
2591 cpp_get_token_with_location (cpp_reader
*pfile
, source_location
*loc
)
2593 return cpp_get_token_1 (pfile
, loc
);
2596 /* Returns true if we're expanding an object-like macro that was
2597 defined in a system header. Just checks the macro at the top of
2598 the stack. Used for diagnostic suppression. */
2600 cpp_sys_macro_p (cpp_reader
*pfile
)
2602 cpp_hashnode
*node
= NULL
;
2604 if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2605 node
= pfile
->context
->c
.mc
->macro_node
;
2607 node
= pfile
->context
->c
.macro
;
2609 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
2612 /* Read each token in, until end of the current file. Directives are
2613 transparently processed. */
2615 cpp_scan_nooutput (cpp_reader
*pfile
)
2617 /* Request a CPP_EOF token at the end of this file, rather than
2618 transparently continuing with the including file. */
2619 pfile
->buffer
->return_at_eof
= true;
2621 pfile
->state
.discarding_output
++;
2622 pfile
->state
.prevent_expansion
++;
2624 if (CPP_OPTION (pfile
, traditional
))
2625 while (_cpp_read_logical_line_trad (pfile
))
2628 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
2631 pfile
->state
.discarding_output
--;
2632 pfile
->state
.prevent_expansion
--;
2635 /* Step back one or more tokens obtained from the lexer. */
2637 _cpp_backup_tokens_direct (cpp_reader
*pfile
, unsigned int count
)
2639 pfile
->lookaheads
+= count
;
2643 if (pfile
->cur_token
== pfile
->cur_run
->base
2644 /* Possible with -fpreprocessed and no leading #line. */
2645 && pfile
->cur_run
->prev
!= NULL
)
2647 pfile
->cur_run
= pfile
->cur_run
->prev
;
2648 pfile
->cur_token
= pfile
->cur_run
->limit
;
2653 /* Step back one (or more) tokens. Can only step back more than 1 if
2654 they are from the lexer, and not from macro expansion. */
2656 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
2658 if (pfile
->context
->prev
== NULL
)
2659 _cpp_backup_tokens_direct (pfile
, count
);
2664 if (pfile
->context
->tokens_kind
== TOKENS_KIND_DIRECT
)
2665 FIRST (pfile
->context
).token
--;
2666 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_INDIRECT
)
2667 FIRST (pfile
->context
).ptoken
--;
2668 else if (pfile
->context
->tokens_kind
== TOKENS_KIND_EXTENDED
)
2670 FIRST (pfile
->context
).ptoken
--;
2671 if (pfile
->context
->c
.macro
)
2673 macro_context
*m
= pfile
->context
->c
.mc
;
2675 #ifdef ENABLE_CHECKING
2676 if (m
->cur_virt_loc
< m
->virt_locs
)
2688 /* #define directive parsing and handling. */
2690 /* Returns nonzero if a macro redefinition warning is required. */
2692 warn_of_redefinition (cpp_reader
*pfile
, cpp_hashnode
*node
,
2693 const cpp_macro
*macro2
)
2695 const cpp_macro
*macro1
;
2698 /* Some redefinitions need to be warned about regardless. */
2699 if (node
->flags
& NODE_WARN
)
2702 /* Suppress warnings for builtins that lack the NODE_WARN flag. */
2703 if (node
->flags
& NODE_BUILTIN
)
2705 if (!pfile
->cb
.user_builtin_macro
2706 || !pfile
->cb
.user_builtin_macro (pfile
, node
))
2710 /* Redefinitions of conditional (context-sensitive) macros, on
2711 the other hand, must be allowed silently. */
2712 if (node
->flags
& NODE_CONDITIONAL
)
2715 /* Redefinition of a macro is allowed if and only if the old and new
2716 definitions are the same. (6.10.3 paragraph 2). */
2717 macro1
= node
->value
.macro
;
2719 /* Don't check count here as it can be different in valid
2720 traditional redefinitions with just whitespace differences. */
2721 if (macro1
->paramc
!= macro2
->paramc
2722 || macro1
->fun_like
!= macro2
->fun_like
2723 || macro1
->variadic
!= macro2
->variadic
)
2726 /* Check parameter spellings. */
2727 for (i
= 0; i
< macro1
->paramc
; i
++)
2728 if (macro1
->params
[i
] != macro2
->params
[i
])
2731 /* Check the replacement text or tokens. */
2732 if (CPP_OPTION (pfile
, traditional
))
2733 return _cpp_expansions_different_trad (macro1
, macro2
);
2735 if (macro1
->count
!= macro2
->count
)
2738 for (i
= 0; i
< macro1
->count
; i
++)
2739 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
2745 /* Free the definition of hashnode H. */
2747 _cpp_free_definition (cpp_hashnode
*h
)
2749 /* Macros and assertions no longer have anything to free. */
2751 /* Clear builtin flag in case of redefinition. */
2752 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
| NODE_USED
);
2755 /* Save parameter NODE to the parameter list of macro MACRO. Returns
2756 zero on success, nonzero if the parameter is a duplicate. */
2758 _cpp_save_parameter (cpp_reader
*pfile
, cpp_macro
*macro
, cpp_hashnode
*node
)
2761 /* Constraint 6.10.3.6 - duplicate parameter names. */
2762 if (node
->flags
& NODE_MACRO_ARG
)
2764 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
2769 if (BUFF_ROOM (pfile
->a_buff
)
2770 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
2771 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
2773 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
2774 node
->flags
|= NODE_MACRO_ARG
;
2775 len
= macro
->paramc
* sizeof (union _cpp_hashnode_value
);
2776 if (len
> pfile
->macro_buffer_len
)
2778 pfile
->macro_buffer
= XRESIZEVEC (unsigned char, pfile
->macro_buffer
,
2780 pfile
->macro_buffer_len
= len
;
2782 ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[macro
->paramc
- 1]
2785 node
->value
.arg_index
= macro
->paramc
;
2789 /* Check the syntax of the parameters in a MACRO definition. Returns
2790 false if an error occurs. */
2792 parse_params (cpp_reader
*pfile
, cpp_macro
*macro
)
2794 unsigned int prev_ident
= 0;
2798 const cpp_token
*token
= _cpp_lex_token (pfile
);
2800 switch (token
->type
)
2803 /* Allow/ignore comments in parameter lists if we are
2804 preserving comments in macro expansions. */
2805 if (token
->type
== CPP_COMMENT
2806 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
2809 cpp_error (pfile
, CPP_DL_ERROR
,
2810 "\"%s\" may not appear in macro parameter list",
2811 cpp_token_as_text (pfile
, token
));
2817 cpp_error (pfile
, CPP_DL_ERROR
,
2818 "macro parameters must be comma-separated");
2823 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
.node
))
2827 case CPP_CLOSE_PAREN
:
2828 if (prev_ident
|| macro
->paramc
== 0)
2831 /* Fall through to pick up the error. */
2835 cpp_error (pfile
, CPP_DL_ERROR
, "parameter name missing");
2842 macro
->variadic
= 1;
2845 _cpp_save_parameter (pfile
, macro
,
2846 pfile
->spec_nodes
.n__VA_ARGS__
);
2847 pfile
->state
.va_args_ok
= 1;
2848 if (! CPP_OPTION (pfile
, c99
)
2849 && CPP_OPTION (pfile
, cpp_pedantic
)
2850 && CPP_OPTION (pfile
, warn_variadic_macros
))
2852 if (CPP_OPTION (pfile
, cplusplus
))
2854 (pfile
, CPP_W_VARIADIC_MACROS
,
2855 "anonymous variadic macros were introduced in C++11");
2858 (pfile
, CPP_W_VARIADIC_MACROS
,
2859 "anonymous variadic macros were introduced in C99");
2861 else if (CPP_OPTION (pfile
, cpp_warn_c90_c99_compat
) > 0
2862 && ! CPP_OPTION (pfile
, cplusplus
))
2863 cpp_error (pfile
, CPP_DL_WARNING
,
2864 "anonymous variadic macros were introduced in C99");
2866 else if (CPP_OPTION (pfile
, cpp_pedantic
)
2867 && CPP_OPTION (pfile
, warn_variadic_macros
))
2869 if (CPP_OPTION (pfile
, cplusplus
))
2870 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
2871 "ISO C++ does not permit named variadic macros");
2873 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
2874 "ISO C does not permit named variadic macros");
2877 /* We're at the end, and just expect a closing parenthesis. */
2878 token
= _cpp_lex_token (pfile
);
2879 if (token
->type
== CPP_CLOSE_PAREN
)
2884 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' in macro parameter list");
2890 /* Allocate room for a token from a macro's replacement list. */
2892 alloc_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
2894 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
2895 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
2897 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
2900 /* Lex a token from the expansion of MACRO, but mark parameters as we
2901 find them and warn of traditional stringification. */
2903 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
2905 cpp_token
*token
, *saved_cur_token
;
2907 saved_cur_token
= pfile
->cur_token
;
2908 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
2909 token
= _cpp_lex_direct (pfile
);
2910 pfile
->cur_token
= saved_cur_token
;
2912 /* Is this a parameter? */
2913 if (token
->type
== CPP_NAME
2914 && (token
->val
.node
.node
->flags
& NODE_MACRO_ARG
) != 0)
2916 token
->type
= CPP_MACRO_ARG
;
2917 token
->val
.macro_arg
.arg_no
= token
->val
.node
.node
->value
.arg_index
;
2919 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
2920 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
2921 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
2927 create_iso_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
2930 const cpp_token
*ctoken
;
2931 bool following_paste_op
= false;
2932 const char *paste_op_error_msg
=
2933 N_("'##' cannot appear at either end of a macro expansion");
2934 unsigned int num_extra_tokens
= 0;
2936 /* Get the first token of the expansion (or the '(' of a
2937 function-like macro). */
2938 ctoken
= _cpp_lex_token (pfile
);
2940 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
2942 bool ok
= parse_params (pfile
, macro
);
2943 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
2947 /* Success. Commit or allocate the parameter array. */
2948 if (pfile
->hash_table
->alloc_subobject
)
2950 cpp_hashnode
**params
=
2951 (cpp_hashnode
**) pfile
->hash_table
->alloc_subobject
2952 (sizeof (cpp_hashnode
*) * macro
->paramc
);
2953 memcpy (params
, macro
->params
,
2954 sizeof (cpp_hashnode
*) * macro
->paramc
);
2955 macro
->params
= params
;
2958 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
2959 macro
->fun_like
= 1;
2961 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
2963 /* While ISO C99 requires whitespace before replacement text
2964 in a macro definition, ISO C90 with TC1 allows characters
2965 from the basic source character set there. */
2966 if (CPP_OPTION (pfile
, c99
))
2968 if (CPP_OPTION (pfile
, cplusplus
))
2969 cpp_error (pfile
, CPP_DL_PEDWARN
,
2970 "ISO C++11 requires whitespace after the macro name");
2972 cpp_error (pfile
, CPP_DL_PEDWARN
,
2973 "ISO C99 requires whitespace after the macro name");
2977 int warntype
= CPP_DL_WARNING
;
2978 switch (ctoken
->type
)
2982 case CPP_OBJC_STRING
:
2983 /* '@' is not in basic character set. */
2984 warntype
= CPP_DL_PEDWARN
;
2987 /* Basic character set sans letters, digits and _. */
2988 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
2989 ctoken
->val
.str
.text
[0]) == NULL
)
2990 warntype
= CPP_DL_PEDWARN
;
2993 /* All other tokens start with a character from basic
2997 cpp_error (pfile
, warntype
,
2998 "missing whitespace after the macro name");
3002 if (macro
->fun_like
)
3003 token
= lex_expansion_token (pfile
, macro
);
3006 token
= alloc_expansion_token (pfile
, macro
);
3012 /* Check the stringifying # constraint 6.10.3.2.1 of
3013 function-like macros when lexing the subsequent token. */
3014 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
3016 if (token
->type
== CPP_MACRO_ARG
)
3018 if (token
->flags
& PREV_WHITE
)
3019 token
->flags
|= SP_PREV_WHITE
;
3020 if (token
[-1].flags
& DIGRAPH
)
3021 token
->flags
|= SP_DIGRAPH
;
3022 token
->flags
&= ~PREV_WHITE
;
3023 token
->flags
|= STRINGIFY_ARG
;
3024 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
3025 token
[-1] = token
[0];
3028 /* Let assembler get away with murder. */
3029 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
3031 cpp_error (pfile
, CPP_DL_ERROR
,
3032 "'#' is not followed by a macro parameter");
3037 if (token
->type
== CPP_EOF
)
3039 /* Paste operator constraint 6.10.3.3.1:
3040 Token-paste ##, can appear in both object-like and
3041 function-like macros, but not at the end. */
3042 if (following_paste_op
)
3044 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3050 /* Paste operator constraint 6.10.3.3.1. */
3051 if (token
->type
== CPP_PASTE
)
3053 /* Token-paste ##, can appear in both object-like and
3054 function-like macros, but not at the beginning. */
3055 if (macro
->count
== 1)
3057 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
3061 if (token
[-1].flags
& PASTE_LEFT
)
3063 macro
->extra_tokens
= 1;
3065 token
->val
.token_no
= macro
->count
- 1;
3070 token
[-1].flags
|= PASTE_LEFT
;
3071 if (token
->flags
& DIGRAPH
)
3072 token
[-1].flags
|= SP_DIGRAPH
;
3073 if (token
->flags
& PREV_WHITE
)
3074 token
[-1].flags
|= SP_PREV_WHITE
;
3078 following_paste_op
= (token
->type
== CPP_PASTE
);
3079 token
= lex_expansion_token (pfile
, macro
);
3082 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
3083 macro
->traditional
= 0;
3085 /* Don't count the CPP_EOF. */
3088 /* Clear whitespace on first token for warn_of_redefinition(). */
3090 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
3092 /* Commit or allocate the memory. */
3093 if (pfile
->hash_table
->alloc_subobject
)
3096 (cpp_token
*) pfile
->hash_table
->alloc_subobject (sizeof (cpp_token
)
3098 if (num_extra_tokens
)
3100 /* Place second and subsequent ## or %:%: tokens in
3101 sequences of consecutive such tokens at the end of the
3102 list to preserve information about where they appear, how
3103 they are spelt and whether they are preceded by
3104 whitespace without otherwise interfering with macro
3106 cpp_token
*normal_dest
= tokns
;
3107 cpp_token
*extra_dest
= tokns
+ macro
->count
- num_extra_tokens
;
3109 for (i
= 0; i
< macro
->count
; i
++)
3111 if (macro
->exp
.tokens
[i
].type
== CPP_PASTE
)
3112 *extra_dest
++ = macro
->exp
.tokens
[i
];
3114 *normal_dest
++ = macro
->exp
.tokens
[i
];
3118 memcpy (tokns
, macro
->exp
.tokens
, sizeof (cpp_token
) * macro
->count
);
3119 macro
->exp
.tokens
= tokns
;
3122 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
3127 /* Parse a macro and save its expansion. Returns nonzero on success. */
3129 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3135 if (pfile
->hash_table
->alloc_subobject
)
3136 macro
= (cpp_macro
*) pfile
->hash_table
->alloc_subobject
3137 (sizeof (cpp_macro
));
3139 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
3140 macro
->line
= pfile
->directive_line
;
3143 macro
->variadic
= 0;
3144 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
3146 macro
->fun_like
= 0;
3147 macro
->extra_tokens
= 0;
3148 /* To suppress some diagnostics. */
3149 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
3151 if (CPP_OPTION (pfile
, traditional
))
3152 ok
= _cpp_create_trad_definition (pfile
, macro
);
3155 ok
= create_iso_definition (pfile
, macro
);
3157 /* We set the type for SEEN_EOL() in directives.c.
3159 Longer term we should lex the whole line before coming here,
3160 and just copy the expansion. */
3162 /* Stop the lexer accepting __VA_ARGS__. */
3163 pfile
->state
.va_args_ok
= 0;
3166 /* Clear the fast argument lookup indices. */
3167 for (i
= macro
->paramc
; i
-- > 0; )
3169 struct cpp_hashnode
*node
= macro
->params
[i
];
3170 node
->flags
&= ~ NODE_MACRO_ARG
;
3171 node
->value
= ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[i
];
3177 if (node
->type
== NT_MACRO
)
3179 if (CPP_OPTION (pfile
, warn_unused_macros
))
3180 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
3182 if (warn_of_redefinition (pfile
, node
, macro
))
3184 const int reason
= (node
->flags
& NODE_BUILTIN
)
3185 ? CPP_W_BUILTIN_MACRO_REDEFINED
: CPP_W_NONE
;
3188 warned
= cpp_pedwarning_with_line (pfile
, reason
,
3189 pfile
->directive_line
, 0,
3193 if (warned
&& node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
3194 cpp_error_with_line (pfile
, CPP_DL_NOTE
,
3195 node
->value
.macro
->line
, 0,
3196 "this is the location of the previous definition");
3200 if (node
->type
!= NT_VOID
)
3201 _cpp_free_definition (node
);
3203 /* Enter definition in hash table. */
3204 node
->type
= NT_MACRO
;
3205 node
->value
.macro
= macro
;
3206 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
3207 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
3208 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
3209 in the C standard, as something that one must use in C++.
3210 However DR#593 and C++11 indicate that they play no role in C++.
3211 We special-case them anyway. */
3212 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
3213 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
3214 node
->flags
|= NODE_WARN
;
3216 /* If user defines one of the conditional macros, remove the
3218 node
->flags
&= ~NODE_CONDITIONAL
;
3223 /* Warn if a token in STRING matches one of a function-like MACRO's
3226 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
3227 const cpp_string
*string
)
3229 unsigned int i
, len
;
3230 const uchar
*p
, *q
, *limit
;
3232 /* Loop over the string. */
3233 limit
= string
->text
+ string
->len
- 1;
3234 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
3236 /* Find the start of an identifier. */
3237 while (p
< limit
&& !is_idstart (*p
))
3240 /* Find the end of the identifier. */
3242 while (q
< limit
&& is_idchar (*q
))
3247 /* Loop over the function macro arguments to see if the
3248 identifier inside the string matches one of them. */
3249 for (i
= 0; i
< macro
->paramc
; i
++)
3251 const cpp_hashnode
*node
= macro
->params
[i
];
3253 if (NODE_LEN (node
) == len
3254 && !memcmp (p
, NODE_NAME (node
), len
))
3256 cpp_error (pfile
, CPP_DL_WARNING
,
3257 "macro argument \"%s\" would be stringified in traditional C",
3265 /* Returns the name, arguments and expansion of a macro, in a format
3266 suitable to be read back in again, and therefore also for DWARF 2
3267 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
3268 Caller is expected to generate the "#define" bit if needed. The
3269 returned text is temporary, and automatically freed later. */
3270 const unsigned char *
3271 cpp_macro_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
3273 unsigned int i
, len
;
3274 const cpp_macro
*macro
;
3275 unsigned char *buffer
;
3277 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
3279 if (node
->type
!= NT_MACRO
3280 || !pfile
->cb
.user_builtin_macro
3281 || !pfile
->cb
.user_builtin_macro (pfile
, node
))
3283 cpp_error (pfile
, CPP_DL_ICE
,
3284 "invalid hash type %d in cpp_macro_definition",
3290 macro
= node
->value
.macro
;
3291 /* Calculate length. */
3292 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
3293 if (macro
->fun_like
)
3295 len
+= 4; /* "()" plus possible final ".." of named
3296 varargs (we have + 1 below). */
3297 for (i
= 0; i
< macro
->paramc
; i
++)
3298 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
3301 /* This should match below where we fill in the buffer. */
3302 if (CPP_OPTION (pfile
, traditional
))
3303 len
+= _cpp_replacement_text_len (macro
);
3306 unsigned int count
= macro_real_token_count (macro
);
3307 for (i
= 0; i
< count
; i
++)
3309 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3311 if (token
->type
== CPP_MACRO_ARG
)
3312 len
+= NODE_LEN (macro
->params
[token
->val
.macro_arg
.arg_no
- 1]);
3314 len
+= cpp_token_len (token
);
3316 if (token
->flags
& STRINGIFY_ARG
)
3318 if (token
->flags
& PASTE_LEFT
)
3319 len
+= 3; /* " ##" */
3320 if (token
->flags
& PREV_WHITE
)
3325 if (len
> pfile
->macro_buffer_len
)
3327 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
3328 pfile
->macro_buffer
, len
);
3329 pfile
->macro_buffer_len
= len
;
3332 /* Fill in the buffer. Start with the macro name. */
3333 buffer
= pfile
->macro_buffer
;
3334 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
3335 buffer
+= NODE_LEN (node
);
3337 /* Parameter names. */
3338 if (macro
->fun_like
)
3341 for (i
= 0; i
< macro
->paramc
; i
++)
3343 cpp_hashnode
*param
= macro
->params
[i
];
3345 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
3347 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
3348 buffer
+= NODE_LEN (param
);
3351 if (i
+ 1 < macro
->paramc
)
3352 /* Don't emit a space after the comma here; we're trying
3353 to emit a Dwarf-friendly definition, and the Dwarf spec
3354 forbids spaces in the argument list. */
3356 else if (macro
->variadic
)
3357 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
3362 /* The Dwarf spec requires a space after the macro name, even if the
3363 definition is the empty string. */
3366 if (CPP_OPTION (pfile
, traditional
))
3367 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
3368 else if (macro
->count
)
3369 /* Expansion tokens. */
3371 unsigned int count
= macro_real_token_count (macro
);
3372 for (i
= 0; i
< count
; i
++)
3374 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
3376 if (token
->flags
& PREV_WHITE
)
3378 if (token
->flags
& STRINGIFY_ARG
)
3381 if (token
->type
== CPP_MACRO_ARG
)
3384 NODE_NAME (macro
->params
[token
->val
.macro_arg
.arg_no
- 1]),
3385 NODE_LEN (macro
->params
[token
->val
.macro_arg
.arg_no
- 1]));
3386 buffer
+= NODE_LEN (macro
->params
[token
->val
.macro_arg
.arg_no
- 1]);
3389 buffer
= cpp_spell_token (pfile
, token
, buffer
, false);
3391 if (token
->flags
& PASTE_LEFT
)
3396 /* Next has PREV_WHITE; see _cpp_create_definition. */
3402 return pfile
->macro_buffer
;