1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2006 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23 In other words, you are welcome to use, share and improve this program.
24 You are forbidden to forbid anyone else to use, share and improve
25 what you give them. Help stamp out software-hoarding! */
32 typedef struct macro_arg macro_arg
;
35 const cpp_token
**first
; /* First token in unexpanded argument. */
36 const cpp_token
**expanded
; /* Macro-expanded argument. */
37 const cpp_token
*stringified
; /* Stringified argument. */
38 unsigned int count
; /* # of tokens in argument. */
39 unsigned int expanded_count
; /* # of tokens in expanded argument. */
42 /* Macro expansion. */
44 static int enter_macro_context (cpp_reader
*, cpp_hashnode
*);
45 static int builtin_macro (cpp_reader
*, cpp_hashnode
*);
46 static void push_ptoken_context (cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
47 const cpp_token
**, unsigned int);
48 static _cpp_buff
*collect_args (cpp_reader
*, const cpp_hashnode
*);
49 static cpp_context
*next_context (cpp_reader
*);
50 static const cpp_token
*padding_token (cpp_reader
*, const cpp_token
*);
51 static void expand_arg (cpp_reader
*, macro_arg
*);
52 static const cpp_token
*new_string_token (cpp_reader
*, uchar
*, unsigned int);
53 static const cpp_token
*stringify_arg (cpp_reader
*, macro_arg
*);
54 static void paste_all_tokens (cpp_reader
*, const cpp_token
*);
55 static bool paste_tokens (cpp_reader
*, const cpp_token
**, const cpp_token
*);
56 static void replace_args (cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
58 static _cpp_buff
*funlike_invocation_p (cpp_reader
*, cpp_hashnode
*);
59 static bool create_iso_definition (cpp_reader
*, cpp_macro
*);
61 /* #define directive parsing and handling. */
63 static cpp_token
*alloc_expansion_token (cpp_reader
*, cpp_macro
*);
64 static cpp_token
*lex_expansion_token (cpp_reader
*, cpp_macro
*);
65 static bool warn_of_redefinition (cpp_reader
*, const cpp_hashnode
*,
67 static bool parse_params (cpp_reader
*, cpp_macro
*);
68 static void check_trad_stringification (cpp_reader
*, const cpp_macro
*,
71 /* Emits a warning if NODE is a macro defined in the main file that
74 _cpp_warn_if_unused_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
75 void *v ATTRIBUTE_UNUSED
)
77 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
79 cpp_macro
*macro
= node
->value
.macro
;
82 && MAIN_FILE_P (linemap_lookup (pfile
->line_table
, macro
->line
)))
83 cpp_error_with_line (pfile
, CPP_DL_WARNING
, macro
->line
, 0,
84 "macro \"%s\" is not used", NODE_NAME (node
));
90 /* Allocates and returns a CPP_STRING token, containing TEXT of length
91 LEN, after null-terminating it. TEXT must be in permanent storage. */
92 static const cpp_token
*
93 new_string_token (cpp_reader
*pfile
, unsigned char *text
, unsigned int len
)
95 cpp_token
*token
= _cpp_temp_token (pfile
);
98 token
->type
= CPP_STRING
;
99 token
->val
.str
.len
= len
;
100 token
->val
.str
.text
= text
;
105 static const char * const monthnames
[] =
107 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
108 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
111 /* Helper function for builtin_macro. Returns the text generated by
114 _cpp_builtin_macro_text (cpp_reader
*pfile
, cpp_hashnode
*node
)
116 const struct line_map
*map
;
117 const uchar
*result
= NULL
;
118 unsigned int number
= 1;
120 switch (node
->value
.builtin
)
123 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
129 cpp_buffer
*pbuffer
= cpp_get_buffer (pfile
);
130 if (pbuffer
->timestamp
== NULL
)
132 /* Initialize timestamp value of the assotiated file. */
133 struct _cpp_file
*file
= cpp_get_file (pbuffer
);
136 /* Generate __TIMESTAMP__ string, that represents
137 the date and time of the last modification
138 of the current source file. The string constant
139 looks like "Sun Sep 16 01:03:52 1973". */
140 struct tm
*tb
= NULL
;
141 struct stat
*st
= _cpp_get_file_stat (file
);
143 tb
= localtime (&st
->st_mtime
);
146 char *str
= asctime (tb
);
147 size_t len
= strlen (str
);
148 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
150 strcpy ((char *) buf
+ 1, str
);
152 pbuffer
->timestamp
= buf
;
156 cpp_errno (pfile
, CPP_DL_WARNING
,
157 "could not determine file timestamp");
158 pbuffer
->timestamp
= U
"\"??? ??? ?? ??:??:?? ????\"";
162 result
= pbuffer
->timestamp
;
171 map
= linemap_lookup (pfile
->line_table
, pfile
->line_table
->highest_line
);
173 if (node
->value
.builtin
== BT_BASE_FILE
)
174 while (! MAIN_FILE_P (map
))
175 map
= INCLUDED_FROM (pfile
->line_table
, map
);
179 buf
= _cpp_unaligned_alloc (pfile
, len
* 2 + 3);
182 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
188 case BT_INCLUDE_LEVEL
:
189 /* The line map depth counts the primary source as level 1, but
190 historically __INCLUDE_DEPTH__ has called the primary source
192 number
= pfile
->line_table
->depth
- 1;
196 map
= &pfile
->line_table
->maps
[pfile
->line_table
->used
-1];
197 /* If __LINE__ is embedded in a macro, it must expand to the
198 line of the macro's invocation, not its definition.
199 Otherwise things like assert() will not work properly. */
200 if (CPP_OPTION (pfile
, traditional
))
201 number
= pfile
->line_table
->highest_line
;
203 number
= pfile
->cur_token
[-1].src_loc
;
204 number
= SOURCE_LINE (map
, number
);
207 /* __STDC__ has the value 1 under normal circumstances.
208 However, if (a) we are in a system header, (b) the option
209 stdc_0_in_system_headers is true (set by target config), and
210 (c) we are not in strictly conforming mode, then it has the
211 value 0. (b) and (c) are already checked in cpp_init_builtins. */
213 if (cpp_in_system_header (pfile
))
221 if (pfile
->date
== NULL
)
223 /* Allocate __DATE__ and __TIME__ strings from permanent
224 storage. We only do this once, and don't generate them
225 at init time, because time() and localtime() are very
226 slow on some systems. */
228 struct tm
*tb
= NULL
;
230 /* (time_t) -1 is a legitimate value for "number of seconds
231 since the Epoch", so we have to do a little dance to
232 distinguish that from a genuine error. */
235 if (tt
!= (time_t)-1 || errno
== 0)
236 tb
= localtime (&tt
);
240 pfile
->date
= _cpp_unaligned_alloc (pfile
,
241 sizeof ("\"Oct 11 1347\""));
242 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
243 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
246 pfile
->time
= _cpp_unaligned_alloc (pfile
,
247 sizeof ("\"12:34:56\""));
248 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
249 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
253 cpp_errno (pfile
, CPP_DL_WARNING
,
254 "could not determine date and time");
256 pfile
->date
= U
"\"??? ?? ????\"";
257 pfile
->time
= U
"\"??:??:??\"";
261 if (node
->value
.builtin
== BT_DATE
)
262 result
= pfile
->date
;
264 result
= pfile
->time
;
270 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
271 result
= _cpp_unaligned_alloc (pfile
, 21);
272 sprintf ((char *) result
, "%u", number
);
278 /* Convert builtin macros like __FILE__ to a token and push it on the
279 context stack. Also handles _Pragma, for which a new token may not
280 be created. Returns 1 if it generates a new token context, 0 to
281 return the token to the caller. */
283 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
)
289 if (node
->value
.builtin
== BT_PRAGMA
)
291 /* Don't interpret _Pragma within directives. The standard is
292 not clear on this, but to me this makes most sense. */
293 if (pfile
->state
.in_directive
)
296 _cpp_do__Pragma (pfile
);
300 buf
= _cpp_builtin_macro_text (pfile
, node
);
302 nbuf
= (char *) alloca (len
+ 1);
303 memcpy (nbuf
, buf
, len
);
306 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
307 _cpp_clean_line (pfile
);
309 /* Set pfile->cur_token as required by _cpp_lex_direct. */
310 pfile
->cur_token
= _cpp_temp_token (pfile
);
311 _cpp_push_token_context (pfile
, NULL
, _cpp_lex_direct (pfile
), 1);
312 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
313 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
315 _cpp_pop_buffer (pfile
);
320 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
321 backslashes and double quotes. DEST must be of sufficient size.
322 Returns a pointer to the end of the string. */
324 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
330 if (c
== '\\' || c
== '"')
342 /* Convert a token sequence ARG to a single string token according to
343 the rules of the ISO C #-operator. */
344 static const cpp_token
*
345 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
348 unsigned int i
, escape_it
, backslash_count
= 0;
349 const cpp_token
*source
= NULL
;
352 if (BUFF_ROOM (pfile
->u_buff
) < 3)
353 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
354 dest
= BUFF_FRONT (pfile
->u_buff
);
357 /* Loop, reading in the argument's tokens. */
358 for (i
= 0; i
< arg
->count
; i
++)
360 const cpp_token
*token
= arg
->first
[i
];
362 if (token
->type
== CPP_PADDING
)
365 source
= token
->val
.source
;
369 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_WSTRING
370 || token
->type
== CPP_CHAR
|| token
->type
== CPP_WCHAR
);
372 /* Room for each char being written in octal, initial space and
373 final quote and NUL. */
374 len
= cpp_token_len (token
);
379 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
381 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
382 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
383 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
386 /* Leading white space? */
387 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
391 if (source
->flags
& PREV_WHITE
)
398 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
399 unsigned char *buf
= BUFF_FRONT (buff
);
400 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
401 dest
= cpp_quote_string (dest
, buf
, len
);
402 _cpp_release_buff (pfile
, buff
);
405 dest
= cpp_spell_token (pfile
, token
, dest
, true);
407 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
413 /* Ignore the final \ of invalid string literals. */
414 if (backslash_count
& 1)
416 cpp_error (pfile
, CPP_DL_WARNING
,
417 "invalid string literal, ignoring final '\\'");
421 /* Commit the memory, including NUL, and return the token. */
423 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
424 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
425 return new_string_token (pfile
, dest
- len
, len
);
428 /* Try to paste two tokens. On success, return nonzero. In any
429 case, PLHS is updated to point to the pasted token, which is
430 guaranteed to not have the PASTE_LEFT flag set. */
432 paste_tokens (cpp_reader
*pfile
, const cpp_token
**plhs
, const cpp_token
*rhs
)
434 unsigned char *buf
, *end
, *lhsend
;
438 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
439 buf
= (unsigned char *) alloca (len
);
440 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, false);
442 /* Avoid comment headers, since they are still processed in stage 3.
443 It is simpler to insert a space here, rather than modifying the
444 lexer to ignore comments in some circumstances. Simply returning
445 false doesn't work, since we want to clear the PASTE_LEFT flag. */
446 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
448 end
= cpp_spell_token (pfile
, rhs
, end
, false);
451 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
452 _cpp_clean_line (pfile
);
454 /* Set pfile->cur_token as required by _cpp_lex_direct. */
455 pfile
->cur_token
= _cpp_temp_token (pfile
);
456 lhs
= _cpp_lex_direct (pfile
);
457 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
459 source_location saved_loc
= lhs
->src_loc
;
461 _cpp_pop_buffer (pfile
);
462 _cpp_backup_tokens (pfile
, 1);
465 /* We have to remove the PASTE_LEFT flag from the old lhs, but
466 we want to keep the new location. */
469 lhs
->src_loc
= saved_loc
;
470 lhs
->flags
&= ~PASTE_LEFT
;
472 /* Mandatory error for all apart from assembler. */
473 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
474 cpp_error (pfile
, CPP_DL_ERROR
,
475 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
476 buf
, cpp_token_as_text (pfile
, rhs
));
481 _cpp_pop_buffer (pfile
);
485 /* Handles an arbitrarily long sequence of ## operators, with initial
486 operand LHS. This implementation is left-associative,
487 non-recursive, and finishes a paste before handling succeeding
488 ones. If a paste fails, we back up to the RHS of the failing ##
489 operator before pushing the context containing the result of prior
490 successful pastes, with the effect that the RHS appears in the
491 output stream after the pasted LHS normally. */
493 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
495 const cpp_token
*rhs
;
496 cpp_context
*context
= pfile
->context
;
500 /* Take the token directly from the current context. We can do
501 this, because we are in the replacement list of either an
502 object-like macro, or a function-like macro with arguments
503 inserted. In either case, the constraints to #define
504 guarantee we have at least one more token. */
505 if (context
->direct_p
)
506 rhs
= FIRST (context
).token
++;
508 rhs
= *FIRST (context
).ptoken
++;
510 if (rhs
->type
== CPP_PADDING
)
513 if (!paste_tokens (pfile
, &lhs
, rhs
))
516 while (rhs
->flags
& PASTE_LEFT
);
518 /* Put the resulting token in its own context. */
519 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
522 /* Returns TRUE if the number of arguments ARGC supplied in an
523 invocation of the MACRO referenced by NODE is valid. An empty
524 invocation to a macro with no parameters should pass ARGC as zero.
526 Note that MACRO cannot necessarily be deduced from NODE, in case
527 NODE was redefined whilst collecting arguments. */
529 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
531 if (argc
== macro
->paramc
)
534 if (argc
< macro
->paramc
)
536 /* As an extension, a rest argument is allowed to not appear in
537 the invocation at all.
538 e.g. #define debug(format, args...) something
541 This is exactly the same as if there had been an empty rest
542 argument - debug("string", ). */
544 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
546 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
547 cpp_error (pfile
, CPP_DL_PEDWARN
,
548 "ISO C99 requires rest arguments to be used");
552 cpp_error (pfile
, CPP_DL_ERROR
,
553 "macro \"%s\" requires %u arguments, but only %u given",
554 NODE_NAME (node
), macro
->paramc
, argc
);
557 cpp_error (pfile
, CPP_DL_ERROR
,
558 "macro \"%s\" passed %u arguments, but takes just %u",
559 NODE_NAME (node
), argc
, macro
->paramc
);
564 /* Reads and returns the arguments to a function-like macro
565 invocation. Assumes the opening parenthesis has been processed.
566 If there is an error, emits an appropriate diagnostic and returns
567 NULL. Each argument is terminated by a CPP_EOF token, for the
568 future benefit of expand_arg(). */
570 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
)
572 _cpp_buff
*buff
, *base_buff
;
574 macro_arg
*args
, *arg
;
575 const cpp_token
*token
;
578 macro
= node
->value
.macro
;
580 argc
= macro
->paramc
;
583 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
584 + sizeof (macro_arg
)));
586 args
= (macro_arg
*) buff
->base
;
587 memset (args
, 0, argc
* sizeof (macro_arg
));
588 buff
->cur
= (unsigned char *) &args
[argc
];
589 arg
= args
, argc
= 0;
591 /* Collect the tokens making up each argument. We don't yet know
592 how many arguments have been supplied, whether too many or too
593 few. Hence the slightly bizarre usage of "argc" and "arg". */
596 unsigned int paren_depth
= 0;
597 unsigned int ntokens
= 0;
600 arg
->first
= (const cpp_token
**) buff
->cur
;
604 /* Require space for 2 new tokens (including a CPP_EOF). */
605 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
607 buff
= _cpp_append_extend_buff (pfile
, buff
,
608 1000 * sizeof (cpp_token
*));
609 arg
->first
= (const cpp_token
**) buff
->cur
;
612 token
= cpp_get_token (pfile
);
614 if (token
->type
== CPP_PADDING
)
616 /* Drop leading padding. */
620 else if (token
->type
== CPP_OPEN_PAREN
)
622 else if (token
->type
== CPP_CLOSE_PAREN
)
624 if (paren_depth
-- == 0)
627 else if (token
->type
== CPP_COMMA
)
629 /* A comma does not terminate an argument within
630 parentheses or as part of a variable argument. */
632 && ! (macro
->variadic
&& argc
== macro
->paramc
))
635 else if (token
->type
== CPP_EOF
636 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
639 arg
->first
[ntokens
++] = token
;
642 /* Drop trailing padding. */
643 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
646 arg
->count
= ntokens
;
647 arg
->first
[ntokens
] = &pfile
->eof
;
649 /* Terminate the argument. Excess arguments loop back and
650 overwrite the final legitimate argument, before failing. */
651 if (argc
<= macro
->paramc
)
653 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
654 if (argc
!= macro
->paramc
)
658 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
660 if (token
->type
== CPP_EOF
)
662 /* We still need the CPP_EOF to end directives, and to end
663 pre-expansion of a macro argument. Step back is not
664 unconditional, since we don't want to return a CPP_EOF to our
665 callers at the end of an -include-d file. */
666 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
667 _cpp_backup_tokens (pfile
, 1);
668 cpp_error (pfile
, CPP_DL_ERROR
,
669 "unterminated argument list invoking macro \"%s\"",
674 /* A single empty argument is counted as no argument. */
675 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
677 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
679 /* GCC has special semantics for , ## b where b is a varargs
680 parameter: we remove the comma if b was omitted entirely.
681 If b was merely an empty argument, the comma is retained.
682 If the macro takes just one (varargs) parameter, then we
683 retain the comma only if we are standards conforming.
685 If FIRST is NULL replace_args () swallows the comma. */
686 if (macro
->variadic
&& (argc
< macro
->paramc
687 || (argc
== 1 && args
[0].count
== 0
688 && !CPP_OPTION (pfile
, std
))))
689 args
[macro
->paramc
- 1].first
= NULL
;
694 /* An error occurred. */
695 _cpp_release_buff (pfile
, base_buff
);
699 /* Search for an opening parenthesis to the macro of NODE, in such a
700 way that, if none is found, we don't lose the information in any
701 intervening padding tokens. If we find the parenthesis, collect
702 the arguments and return the buffer containing them. */
704 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
)
706 const cpp_token
*token
, *padding
= NULL
;
710 token
= cpp_get_token (pfile
);
711 if (token
->type
!= CPP_PADDING
)
714 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
718 if (token
->type
== CPP_OPEN_PAREN
)
720 pfile
->state
.parsing_args
= 2;
721 return collect_args (pfile
, node
);
724 /* CPP_EOF can be the end of macro arguments, or the end of the
725 file. We mustn't back up over the latter. Ugh. */
726 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
728 /* Back up. We may have skipped padding, in which case backing
729 up more than one token when expanding macros is in general
730 too difficult. We re-insert it in its own context. */
731 _cpp_backup_tokens (pfile
, 1);
733 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
739 /* Push the context of a macro with hash entry NODE onto the context
740 stack. If we can successfully expand the macro, we push a context
741 containing its yet-to-be-rescanned replacement list and return one.
742 Otherwise, we don't push a context and return zero. */
744 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
)
746 /* The presence of a macro invalidates a file's controlling macro. */
747 pfile
->mi_valid
= false;
749 pfile
->state
.angled_headers
= false;
751 /* Handle standard macros. */
752 if (! (node
->flags
& NODE_BUILTIN
))
754 cpp_macro
*macro
= node
->value
.macro
;
760 pfile
->state
.prevent_expansion
++;
761 pfile
->keep_tokens
++;
762 pfile
->state
.parsing_args
= 1;
763 buff
= funlike_invocation_p (pfile
, node
);
764 pfile
->state
.parsing_args
= 0;
765 pfile
->keep_tokens
--;
766 pfile
->state
.prevent_expansion
--;
770 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
771 cpp_error (pfile
, CPP_DL_WARNING
,
772 "function-like macro \"%s\" must be used with arguments in traditional C",
778 if (macro
->paramc
> 0)
779 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
780 _cpp_release_buff (pfile
, buff
);
783 /* Disable the macro within its expansion. */
784 node
->flags
|= NODE_DISABLED
;
788 if (macro
->paramc
== 0)
789 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
, macro
->count
);
794 /* Handle built-in macros and the _Pragma operator. */
795 return builtin_macro (pfile
, node
);
798 /* Replace the parameters in a function-like macro of NODE with the
799 actual ARGS, and place the result in a newly pushed token context.
800 Expand each argument before replacing, unless it is operated upon
801 by the # or ## operators. */
803 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
, macro_arg
*args
)
805 unsigned int i
, total
;
806 const cpp_token
*src
, *limit
;
807 const cpp_token
**dest
, **first
;
811 /* First, fully macro-expand arguments, calculating the number of
812 tokens in the final expansion as we go. The ordering of the if
813 statements below is subtle; we must handle stringification before
815 total
= macro
->count
;
816 limit
= macro
->exp
.tokens
+ macro
->count
;
818 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
819 if (src
->type
== CPP_MACRO_ARG
)
821 /* Leading and trailing padding tokens. */
824 /* We have an argument. If it is not being stringified or
825 pasted it is macro-replaced before insertion. */
826 arg
= &args
[src
->val
.arg_no
- 1];
828 if (src
->flags
& STRINGIFY_ARG
)
830 if (!arg
->stringified
)
831 arg
->stringified
= stringify_arg (pfile
, arg
);
833 else if ((src
->flags
& PASTE_LEFT
)
834 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
835 total
+= arg
->count
- 1;
839 expand_arg (pfile
, arg
);
840 total
+= arg
->expanded_count
- 1;
844 /* Now allocate space for the expansion, copy the tokens and replace
846 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
847 first
= (const cpp_token
**) buff
->base
;
850 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
853 const cpp_token
**from
, **paste_flag
;
855 if (src
->type
!= CPP_MACRO_ARG
)
862 arg
= &args
[src
->val
.arg_no
- 1];
863 if (src
->flags
& STRINGIFY_ARG
)
864 count
= 1, from
= &arg
->stringified
;
865 else if (src
->flags
& PASTE_LEFT
)
866 count
= arg
->count
, from
= arg
->first
;
867 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
869 count
= arg
->count
, from
= arg
->first
;
872 if (dest
[-1]->type
== CPP_COMMA
874 && src
->val
.arg_no
== macro
->paramc
)
876 /* Swallow a pasted comma if from == NULL, otherwise
877 drop the paste flag. */
881 paste_flag
= dest
- 1;
883 /* Remove the paste flag if the RHS is a placemarker. */
885 paste_flag
= dest
- 1;
889 count
= arg
->expanded_count
, from
= arg
->expanded
;
891 /* Padding on the left of an argument (unless RHS of ##). */
892 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
893 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
894 *dest
++ = padding_token (pfile
, src
);
898 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
901 /* With a non-empty argument on the LHS of ##, the last
902 token should be flagged PASTE_LEFT. */
903 if (src
->flags
& PASTE_LEFT
)
904 paste_flag
= dest
- 1;
907 /* Avoid paste on RHS (even case count == 0). */
908 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
909 *dest
++ = &pfile
->avoid_paste
;
911 /* Add a new paste flag, or remove an unwanted one. */
914 cpp_token
*token
= _cpp_temp_token (pfile
);
915 token
->type
= (*paste_flag
)->type
;
916 token
->val
= (*paste_flag
)->val
;
917 if (src
->flags
& PASTE_LEFT
)
918 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
920 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
925 /* Free the expanded arguments. */
926 for (i
= 0; i
< macro
->paramc
; i
++)
927 if (args
[i
].expanded
)
928 free (args
[i
].expanded
);
930 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
933 /* Return a special padding token, with padding inherited from SOURCE. */
934 static const cpp_token
*
935 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
937 cpp_token
*result
= _cpp_temp_token (pfile
);
939 result
->type
= CPP_PADDING
;
941 /* Data in GCed data structures cannot be made const so far, so we
943 result
->val
.source
= (cpp_token
*) source
;
948 /* Get a new uninitialized context. Create a new one if we cannot
949 re-use an old one. */
951 next_context (cpp_reader
*pfile
)
953 cpp_context
*result
= pfile
->context
->next
;
957 result
= XNEW (cpp_context
);
958 result
->prev
= pfile
->context
;
960 pfile
->context
->next
= result
;
963 pfile
->context
= result
;
967 /* Push a list of pointers to tokens. */
969 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
970 const cpp_token
**first
, unsigned int count
)
972 cpp_context
*context
= next_context (pfile
);
974 context
->direct_p
= false;
975 context
->macro
= macro
;
976 context
->buff
= buff
;
977 FIRST (context
).ptoken
= first
;
978 LAST (context
).ptoken
= first
+ count
;
981 /* Push a list of tokens. */
983 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
984 const cpp_token
*first
, unsigned int count
)
986 cpp_context
*context
= next_context (pfile
);
988 context
->direct_p
= true;
989 context
->macro
= macro
;
990 context
->buff
= NULL
;
991 FIRST (context
).token
= first
;
992 LAST (context
).token
= first
+ count
;
995 /* Push a traditional macro's replacement text. */
997 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
998 const uchar
*start
, size_t len
)
1000 cpp_context
*context
= next_context (pfile
);
1002 context
->direct_p
= true;
1003 context
->macro
= macro
;
1004 context
->buff
= NULL
;
1005 CUR (context
) = start
;
1006 RLIMIT (context
) = start
+ len
;
1007 macro
->flags
|= NODE_DISABLED
;
1010 /* Expand an argument ARG before replacing parameters in a
1011 function-like macro. This works by pushing a context with the
1012 argument's tokens, and then expanding that into a temporary buffer
1013 as if it were a normal part of the token stream. collect_args()
1014 has terminated the argument's tokens with a CPP_EOF so that we know
1015 when we have fully expanded the argument. */
1017 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
1019 unsigned int capacity
;
1020 bool saved_warn_trad
;
1022 if (arg
->count
== 0)
1025 /* Don't warn about funlike macros when pre-expanding. */
1026 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
1027 CPP_WTRADITIONAL (pfile
) = 0;
1029 /* Loop, reading in the arguments. */
1031 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
1033 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
1036 const cpp_token
*token
;
1038 if (arg
->expanded_count
+ 1 >= capacity
)
1041 arg
->expanded
= XRESIZEVEC (const cpp_token
*, arg
->expanded
,
1045 token
= cpp_get_token (pfile
);
1047 if (token
->type
== CPP_EOF
)
1050 arg
->expanded
[arg
->expanded_count
++] = token
;
1053 _cpp_pop_context (pfile
);
1055 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
1058 /* Pop the current context off the stack, re-enabling the macro if the
1059 context represented a macro's replacement list. The context
1060 structure is not freed so that we can re-use it later. */
1062 _cpp_pop_context (cpp_reader
*pfile
)
1064 cpp_context
*context
= pfile
->context
;
1067 context
->macro
->flags
&= ~NODE_DISABLED
;
1070 _cpp_release_buff (pfile
, context
->buff
);
1072 pfile
->context
= context
->prev
;
1075 /* External routine to get a token. Also used nearly everywhere
1076 internally, except for places where we know we can safely call
1077 _cpp_lex_token directly, such as lexing a directive name.
1079 Macro expansions and directives are transparently handled,
1080 including entering included files. Thus tokens are post-macro
1081 expansion, and after any intervening directives. External callers
1082 see CPP_EOF only at EOF. Internal callers also see it when meeting
1083 a directive inside a macro call, when at the end of a directive and
1084 state.in_directive is still 1, and at the end of argument
1087 cpp_get_token (cpp_reader
*pfile
)
1089 const cpp_token
*result
;
1094 cpp_context
*context
= pfile
->context
;
1096 /* Context->prev == 0 <=> base context. */
1098 result
= _cpp_lex_token (pfile
);
1099 else if (FIRST (context
).token
!= LAST (context
).token
)
1101 if (context
->direct_p
)
1102 result
= FIRST (context
).token
++;
1104 result
= *FIRST (context
).ptoken
++;
1106 if (result
->flags
& PASTE_LEFT
)
1108 paste_all_tokens (pfile
, result
);
1109 if (pfile
->state
.in_directive
)
1111 return padding_token (pfile
, result
);
1116 _cpp_pop_context (pfile
);
1117 if (pfile
->state
.in_directive
)
1119 return &pfile
->avoid_paste
;
1122 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1125 if (result
->type
!= CPP_NAME
)
1128 node
= result
->val
.node
;
1130 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1133 if (!(node
->flags
& NODE_DISABLED
))
1135 if (!pfile
->state
.prevent_expansion
1136 && enter_macro_context (pfile
, node
))
1138 if (pfile
->state
.in_directive
)
1140 return padding_token (pfile
, result
);
1145 /* Flag this token as always unexpandable. FIXME: move this
1146 to collect_args()?. */
1147 cpp_token
*t
= _cpp_temp_token (pfile
);
1148 t
->type
= result
->type
;
1149 t
->flags
= result
->flags
| NO_EXPAND
;
1150 t
->val
= result
->val
;
1160 /* Returns true if we're expanding an object-like macro that was
1161 defined in a system header. Just checks the macro at the top of
1162 the stack. Used for diagnostic suppression. */
1164 cpp_sys_macro_p (cpp_reader
*pfile
)
1166 cpp_hashnode
*node
= pfile
->context
->macro
;
1168 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1171 /* Read each token in, until end of the current file. Directives are
1172 transparently processed. */
1174 cpp_scan_nooutput (cpp_reader
*pfile
)
1176 /* Request a CPP_EOF token at the end of this file, rather than
1177 transparently continuing with the including file. */
1178 pfile
->buffer
->return_at_eof
= true;
1180 pfile
->state
.discarding_output
++;
1181 pfile
->state
.prevent_expansion
++;
1183 if (CPP_OPTION (pfile
, traditional
))
1184 while (_cpp_read_logical_line_trad (pfile
))
1187 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1190 pfile
->state
.discarding_output
--;
1191 pfile
->state
.prevent_expansion
--;
1194 /* Step back one (or more) tokens. Can only step back more than 1 if
1195 they are from the lexer, and not from macro expansion. */
1197 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
1199 if (pfile
->context
->prev
== NULL
)
1201 pfile
->lookaheads
+= count
;
1205 if (pfile
->cur_token
== pfile
->cur_run
->base
1206 /* Possible with -fpreprocessed and no leading #line. */
1207 && pfile
->cur_run
->prev
!= NULL
)
1209 pfile
->cur_run
= pfile
->cur_run
->prev
;
1210 pfile
->cur_token
= pfile
->cur_run
->limit
;
1218 if (pfile
->context
->direct_p
)
1219 FIRST (pfile
->context
).token
--;
1221 FIRST (pfile
->context
).ptoken
--;
1225 /* #define directive parsing and handling. */
1227 /* Returns nonzero if a macro redefinition warning is required. */
1229 warn_of_redefinition (cpp_reader
*pfile
, const cpp_hashnode
*node
,
1230 const cpp_macro
*macro2
)
1232 const cpp_macro
*macro1
;
1235 /* Some redefinitions need to be warned about regardless. */
1236 if (node
->flags
& NODE_WARN
)
1239 /* Redefinition of a macro is allowed if and only if the old and new
1240 definitions are the same. (6.10.3 paragraph 2). */
1241 macro1
= node
->value
.macro
;
1243 /* Don't check count here as it can be different in valid
1244 traditional redefinitions with just whitespace differences. */
1245 if (macro1
->paramc
!= macro2
->paramc
1246 || macro1
->fun_like
!= macro2
->fun_like
1247 || macro1
->variadic
!= macro2
->variadic
)
1250 /* Check parameter spellings. */
1251 for (i
= 0; i
< macro1
->paramc
; i
++)
1252 if (macro1
->params
[i
] != macro2
->params
[i
])
1255 /* Check the replacement text or tokens. */
1256 if (CPP_OPTION (pfile
, traditional
))
1257 return _cpp_expansions_different_trad (macro1
, macro2
);
1259 if (macro1
->count
!= macro2
->count
)
1262 for (i
= 0; i
< macro1
->count
; i
++)
1263 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
1269 /* Free the definition of hashnode H. */
1271 _cpp_free_definition (cpp_hashnode
*h
)
1273 /* Macros and assertions no longer have anything to free. */
1275 /* Clear builtin flag in case of redefinition. */
1276 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
);
1279 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1280 zero on success, nonzero if the parameter is a duplicate. */
1282 _cpp_save_parameter (cpp_reader
*pfile
, cpp_macro
*macro
, cpp_hashnode
*node
)
1285 /* Constraint 6.10.3.6 - duplicate parameter names. */
1286 if (node
->flags
& NODE_MACRO_ARG
)
1288 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
1293 if (BUFF_ROOM (pfile
->a_buff
)
1294 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1295 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1297 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1298 node
->flags
|= NODE_MACRO_ARG
;
1299 len
= macro
->paramc
* sizeof (union _cpp_hashnode_value
);
1300 if (len
> pfile
->macro_buffer_len
)
1302 pfile
->macro_buffer
= XRESIZEVEC (unsigned char, pfile
->macro_buffer
,
1304 pfile
->macro_buffer_len
= len
;
1306 ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[macro
->paramc
- 1]
1309 node
->value
.arg_index
= macro
->paramc
;
1313 /* Check the syntax of the parameters in a MACRO definition. Returns
1314 false if an error occurs. */
1316 parse_params (cpp_reader
*pfile
, cpp_macro
*macro
)
1318 unsigned int prev_ident
= 0;
1322 const cpp_token
*token
= _cpp_lex_token (pfile
);
1324 switch (token
->type
)
1327 /* Allow/ignore comments in parameter lists if we are
1328 preserving comments in macro expansions. */
1329 if (token
->type
== CPP_COMMENT
1330 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1333 cpp_error (pfile
, CPP_DL_ERROR
,
1334 "\"%s\" may not appear in macro parameter list",
1335 cpp_token_as_text (pfile
, token
));
1341 cpp_error (pfile
, CPP_DL_ERROR
,
1342 "macro parameters must be comma-separated");
1347 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
))
1351 case CPP_CLOSE_PAREN
:
1352 if (prev_ident
|| macro
->paramc
== 0)
1355 /* Fall through to pick up the error. */
1359 cpp_error (pfile
, CPP_DL_ERROR
, "parameter name missing");
1366 macro
->variadic
= 1;
1369 _cpp_save_parameter (pfile
, macro
,
1370 pfile
->spec_nodes
.n__VA_ARGS__
);
1371 pfile
->state
.va_args_ok
= 1;
1372 if (! CPP_OPTION (pfile
, c99
)
1373 && CPP_OPTION (pfile
, pedantic
)
1374 && CPP_OPTION (pfile
, warn_variadic_macros
))
1375 cpp_error (pfile
, CPP_DL_PEDWARN
,
1376 "anonymous variadic macros were introduced in C99");
1378 else if (CPP_OPTION (pfile
, pedantic
)
1379 && CPP_OPTION (pfile
, warn_variadic_macros
))
1380 cpp_error (pfile
, CPP_DL_PEDWARN
,
1381 "ISO C does not permit named variadic macros");
1383 /* We're at the end, and just expect a closing parenthesis. */
1384 token
= _cpp_lex_token (pfile
);
1385 if (token
->type
== CPP_CLOSE_PAREN
)
1390 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' in macro parameter list");
1396 /* Allocate room for a token from a macro's replacement list. */
1398 alloc_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1400 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1401 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1403 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1406 /* Lex a token from the expansion of MACRO, but mark parameters as we
1407 find them and warn of traditional stringification. */
1409 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1411 cpp_token
*token
, *saved_cur_token
;
1413 saved_cur_token
= pfile
->cur_token
;
1414 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1415 token
= _cpp_lex_direct (pfile
);
1416 pfile
->cur_token
= saved_cur_token
;
1418 /* Is this a parameter? */
1419 if (token
->type
== CPP_NAME
1420 && (token
->val
.node
->flags
& NODE_MACRO_ARG
) != 0)
1422 token
->type
= CPP_MACRO_ARG
;
1423 token
->val
.arg_no
= token
->val
.node
->value
.arg_index
;
1425 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1426 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1427 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1433 create_iso_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
1436 const cpp_token
*ctoken
;
1438 /* Get the first token of the expansion (or the '(' of a
1439 function-like macro). */
1440 ctoken
= _cpp_lex_token (pfile
);
1442 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1444 bool ok
= parse_params (pfile
, macro
);
1445 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1449 /* Success. Commit or allocate the parameter array. */
1450 if (pfile
->hash_table
->alloc_subobject
)
1452 cpp_hashnode
**params
=
1453 (cpp_hashnode
**) pfile
->hash_table
->alloc_subobject
1454 (sizeof (cpp_hashnode
*) * macro
->paramc
);
1455 memcpy (params
, macro
->params
,
1456 sizeof (cpp_hashnode
*) * macro
->paramc
);
1457 macro
->params
= params
;
1460 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1461 macro
->fun_like
= 1;
1463 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1465 /* While ISO C99 requires whitespace before replacement text
1466 in a macro definition, ISO C90 with TC1 allows there characters
1467 from the basic source character set. */
1468 if (CPP_OPTION (pfile
, c99
))
1469 cpp_error (pfile
, CPP_DL_PEDWARN
,
1470 "ISO C99 requires whitespace after the macro name");
1473 int warntype
= CPP_DL_WARNING
;
1474 switch (ctoken
->type
)
1478 case CPP_OBJC_STRING
:
1479 /* '@' is not in basic character set. */
1480 warntype
= CPP_DL_PEDWARN
;
1483 /* Basic character set sans letters, digits and _. */
1484 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1485 ctoken
->val
.str
.text
[0]) == NULL
)
1486 warntype
= CPP_DL_PEDWARN
;
1489 /* All other tokens start with a character from basic
1493 cpp_error (pfile
, warntype
,
1494 "missing whitespace after the macro name");
1498 if (macro
->fun_like
)
1499 token
= lex_expansion_token (pfile
, macro
);
1502 token
= alloc_expansion_token (pfile
, macro
);
1508 /* Check the stringifying # constraint 6.10.3.2.1 of
1509 function-like macros when lexing the subsequent token. */
1510 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1512 if (token
->type
== CPP_MACRO_ARG
)
1514 token
->flags
&= ~PREV_WHITE
;
1515 token
->flags
|= STRINGIFY_ARG
;
1516 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1517 token
[-1] = token
[0];
1520 /* Let assembler get away with murder. */
1521 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1523 cpp_error (pfile
, CPP_DL_ERROR
,
1524 "'#' is not followed by a macro parameter");
1529 if (token
->type
== CPP_EOF
)
1532 /* Paste operator constraint 6.10.3.3.1. */
1533 if (token
->type
== CPP_PASTE
)
1535 /* Token-paste ##, can appear in both object-like and
1536 function-like macros, but not at the ends. */
1537 if (--macro
->count
> 0)
1538 token
= lex_expansion_token (pfile
, macro
);
1540 if (macro
->count
== 0 || token
->type
== CPP_EOF
)
1542 cpp_error (pfile
, CPP_DL_ERROR
,
1543 "'##' cannot appear at either end of a macro expansion");
1547 token
[-1].flags
|= PASTE_LEFT
;
1550 token
= lex_expansion_token (pfile
, macro
);
1553 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1554 macro
->traditional
= 0;
1556 /* Don't count the CPP_EOF. */
1559 /* Clear whitespace on first token for warn_of_redefinition(). */
1561 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
1563 /* Commit or allocate the memory. */
1564 if (pfile
->hash_table
->alloc_subobject
)
1567 (cpp_token
*) pfile
->hash_table
->alloc_subobject (sizeof (cpp_token
)
1569 memcpy (tokns
, macro
->exp
.tokens
, sizeof (cpp_token
) * macro
->count
);
1570 macro
->exp
.tokens
= tokns
;
1573 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
1578 /* Parse a macro and save its expansion. Returns nonzero on success. */
1580 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
1586 if (pfile
->hash_table
->alloc_subobject
)
1587 macro
= (cpp_macro
*) pfile
->hash_table
->alloc_subobject
1588 (sizeof (cpp_macro
));
1590 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1591 macro
->line
= pfile
->directive_line
;
1594 macro
->variadic
= 0;
1595 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
1597 macro
->fun_like
= 0;
1598 /* To suppress some diagnostics. */
1599 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
1601 if (CPP_OPTION (pfile
, traditional
))
1602 ok
= _cpp_create_trad_definition (pfile
, macro
);
1605 ok
= create_iso_definition (pfile
, macro
);
1607 /* We set the type for SEEN_EOL() in directives.c.
1609 Longer term we should lex the whole line before coming here,
1610 and just copy the expansion. */
1612 /* Stop the lexer accepting __VA_ARGS__. */
1613 pfile
->state
.va_args_ok
= 0;
1616 /* Clear the fast argument lookup indices. */
1617 for (i
= macro
->paramc
; i
-- > 0; )
1619 struct cpp_hashnode
*node
= macro
->params
[i
];
1620 node
->flags
&= ~ NODE_MACRO_ARG
;
1621 node
->value
= ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[i
];
1627 if (node
->type
== NT_MACRO
)
1629 if (CPP_OPTION (pfile
, warn_unused_macros
))
1630 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
1632 if (warn_of_redefinition (pfile
, node
, macro
))
1634 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, pfile
->directive_line
, 0,
1635 "\"%s\" redefined", NODE_NAME (node
));
1637 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1638 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
,
1639 node
->value
.macro
->line
, 0,
1640 "this is the location of the previous definition");
1644 if (node
->type
!= NT_VOID
)
1645 _cpp_free_definition (node
);
1647 /* Enter definition in hash table. */
1648 node
->type
= NT_MACRO
;
1649 node
->value
.macro
= macro
;
1650 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
1651 node
->flags
|= NODE_WARN
;
1656 /* Warn if a token in STRING matches one of a function-like MACRO's
1659 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
1660 const cpp_string
*string
)
1662 unsigned int i
, len
;
1663 const uchar
*p
, *q
, *limit
;
1665 /* Loop over the string. */
1666 limit
= string
->text
+ string
->len
- 1;
1667 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
1669 /* Find the start of an identifier. */
1670 while (p
< limit
&& !is_idstart (*p
))
1673 /* Find the end of the identifier. */
1675 while (q
< limit
&& is_idchar (*q
))
1680 /* Loop over the function macro arguments to see if the
1681 identifier inside the string matches one of them. */
1682 for (i
= 0; i
< macro
->paramc
; i
++)
1684 const cpp_hashnode
*node
= macro
->params
[i
];
1686 if (NODE_LEN (node
) == len
1687 && !memcmp (p
, NODE_NAME (node
), len
))
1689 cpp_error (pfile
, CPP_DL_WARNING
,
1690 "macro argument \"%s\" would be stringified in traditional C",
1698 /* Returns the name, arguments and expansion of a macro, in a format
1699 suitable to be read back in again, and therefore also for DWARF 2
1700 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1701 Caller is expected to generate the "#define" bit if needed. The
1702 returned text is temporary, and automatically freed later. */
1703 const unsigned char *
1704 cpp_macro_definition (cpp_reader
*pfile
, const cpp_hashnode
*node
)
1706 unsigned int i
, len
;
1707 const cpp_macro
*macro
= node
->value
.macro
;
1708 unsigned char *buffer
;
1710 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1712 cpp_error (pfile
, CPP_DL_ICE
,
1713 "invalid hash type %d in cpp_macro_definition", node
->type
);
1717 /* Calculate length. */
1718 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
1719 if (macro
->fun_like
)
1721 len
+= 4; /* "()" plus possible final ".." of named
1722 varargs (we have + 1 below). */
1723 for (i
= 0; i
< macro
->paramc
; i
++)
1724 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1727 /* This should match below where we fill in the buffer. */
1728 if (CPP_OPTION (pfile
, traditional
))
1729 len
+= _cpp_replacement_text_len (macro
);
1732 for (i
= 0; i
< macro
->count
; i
++)
1734 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1736 if (token
->type
== CPP_MACRO_ARG
)
1737 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1739 len
+= cpp_token_len (token
);
1741 if (token
->flags
& STRINGIFY_ARG
)
1743 if (token
->flags
& PASTE_LEFT
)
1744 len
+= 3; /* " ##" */
1745 if (token
->flags
& PREV_WHITE
)
1750 if (len
> pfile
->macro_buffer_len
)
1752 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
1753 pfile
->macro_buffer
, len
);
1754 pfile
->macro_buffer_len
= len
;
1757 /* Fill in the buffer. Start with the macro name. */
1758 buffer
= pfile
->macro_buffer
;
1759 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1760 buffer
+= NODE_LEN (node
);
1762 /* Parameter names. */
1763 if (macro
->fun_like
)
1766 for (i
= 0; i
< macro
->paramc
; i
++)
1768 cpp_hashnode
*param
= macro
->params
[i
];
1770 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1772 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1773 buffer
+= NODE_LEN (param
);
1776 if (i
+ 1 < macro
->paramc
)
1777 /* Don't emit a space after the comma here; we're trying
1778 to emit a Dwarf-friendly definition, and the Dwarf spec
1779 forbids spaces in the argument list. */
1781 else if (macro
->variadic
)
1782 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1787 /* The Dwarf spec requires a space after the macro name, even if the
1788 definition is the empty string. */
1791 if (CPP_OPTION (pfile
, traditional
))
1792 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
1793 else if (macro
->count
)
1794 /* Expansion tokens. */
1796 for (i
= 0; i
< macro
->count
; i
++)
1798 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1800 if (token
->flags
& PREV_WHITE
)
1802 if (token
->flags
& STRINGIFY_ARG
)
1805 if (token
->type
== CPP_MACRO_ARG
)
1808 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]),
1809 NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]));
1810 buffer
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1813 buffer
= cpp_spell_token (pfile
, token
, buffer
, false);
1815 if (token
->flags
& PASTE_LEFT
)
1820 /* Next has PREV_WHITE; see _cpp_create_definition. */
1826 return pfile
->macro_buffer
;