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, 2007, 2008, 2009 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 3, 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; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>.
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
*,
46 static int builtin_macro (cpp_reader
*, cpp_hashnode
*);
47 static void push_ptoken_context (cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
48 const cpp_token
**, unsigned int);
49 static _cpp_buff
*collect_args (cpp_reader
*, const cpp_hashnode
*,
51 static cpp_context
*next_context (cpp_reader
*);
52 static const cpp_token
*padding_token (cpp_reader
*, const cpp_token
*);
53 static void expand_arg (cpp_reader
*, macro_arg
*);
54 static const cpp_token
*new_string_token (cpp_reader
*, uchar
*, unsigned int);
55 static const cpp_token
*stringify_arg (cpp_reader
*, macro_arg
*);
56 static void paste_all_tokens (cpp_reader
*, const cpp_token
*);
57 static bool paste_tokens (cpp_reader
*, const cpp_token
**, const cpp_token
*);
58 static void replace_args (cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
60 static _cpp_buff
*funlike_invocation_p (cpp_reader
*, cpp_hashnode
*,
62 static bool create_iso_definition (cpp_reader
*, cpp_macro
*);
64 /* #define directive parsing and handling. */
66 static cpp_token
*alloc_expansion_token (cpp_reader
*, cpp_macro
*);
67 static cpp_token
*lex_expansion_token (cpp_reader
*, cpp_macro
*);
68 static bool warn_of_redefinition (cpp_reader
*, const cpp_hashnode
*,
70 static bool parse_params (cpp_reader
*, cpp_macro
*);
71 static void check_trad_stringification (cpp_reader
*, const cpp_macro
*,
74 /* Emits a warning if NODE is a macro defined in the main file that
77 _cpp_warn_if_unused_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
78 void *v ATTRIBUTE_UNUSED
)
80 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
82 cpp_macro
*macro
= node
->value
.macro
;
85 && MAIN_FILE_P (linemap_lookup (pfile
->line_table
, macro
->line
)))
86 cpp_error_with_line (pfile
, CPP_DL_WARNING
, macro
->line
, 0,
87 "macro \"%s\" is not used", NODE_NAME (node
));
93 /* Allocates and returns a CPP_STRING token, containing TEXT of length
94 LEN, after null-terminating it. TEXT must be in permanent storage. */
95 static const cpp_token
*
96 new_string_token (cpp_reader
*pfile
, unsigned char *text
, unsigned int len
)
98 cpp_token
*token
= _cpp_temp_token (pfile
);
101 token
->type
= CPP_STRING
;
102 token
->val
.str
.len
= len
;
103 token
->val
.str
.text
= text
;
108 static const char * const monthnames
[] =
110 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
111 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
114 /* Helper function for builtin_macro. Returns the text generated by
117 _cpp_builtin_macro_text (cpp_reader
*pfile
, cpp_hashnode
*node
)
119 const struct line_map
*map
;
120 const uchar
*result
= NULL
;
121 linenum_type number
= 1;
123 switch (node
->value
.builtin
)
126 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
132 cpp_buffer
*pbuffer
= cpp_get_buffer (pfile
);
133 if (pbuffer
->timestamp
== NULL
)
135 /* Initialize timestamp value of the assotiated file. */
136 struct _cpp_file
*file
= cpp_get_file (pbuffer
);
139 /* Generate __TIMESTAMP__ string, that represents
140 the date and time of the last modification
141 of the current source file. The string constant
142 looks like "Sun Sep 16 01:03:52 1973". */
143 struct tm
*tb
= NULL
;
144 struct stat
*st
= _cpp_get_file_stat (file
);
146 tb
= localtime (&st
->st_mtime
);
149 char *str
= asctime (tb
);
150 size_t len
= strlen (str
);
151 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
153 strcpy ((char *) buf
+ 1, str
);
155 pbuffer
->timestamp
= buf
;
159 cpp_errno (pfile
, CPP_DL_WARNING
,
160 "could not determine file timestamp");
161 pbuffer
->timestamp
= UC
"\"??? ??? ?? ??:??:?? ????\"";
165 result
= pbuffer
->timestamp
;
174 map
= linemap_lookup (pfile
->line_table
, pfile
->line_table
->highest_line
);
176 if (node
->value
.builtin
== BT_BASE_FILE
)
177 while (! MAIN_FILE_P (map
))
178 map
= INCLUDED_FROM (pfile
->line_table
, map
);
182 buf
= _cpp_unaligned_alloc (pfile
, len
* 2 + 3);
185 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
191 case BT_INCLUDE_LEVEL
:
192 /* The line map depth counts the primary source as level 1, but
193 historically __INCLUDE_DEPTH__ has called the primary source
195 number
= pfile
->line_table
->depth
- 1;
199 map
= &pfile
->line_table
->maps
[pfile
->line_table
->used
-1];
200 /* If __LINE__ is embedded in a macro, it must expand to the
201 line of the macro's invocation, not its definition.
202 Otherwise things like assert() will not work properly. */
203 number
= SOURCE_LINE (map
,
204 CPP_OPTION (pfile
, traditional
)
205 ? pfile
->line_table
->highest_line
206 : pfile
->cur_token
[-1].src_loc
);
209 /* __STDC__ has the value 1 under normal circumstances.
210 However, if (a) we are in a system header, (b) the option
211 stdc_0_in_system_headers is true (set by target config), and
212 (c) we are not in strictly conforming mode, then it has the
213 value 0. (b) and (c) are already checked in cpp_init_builtins. */
215 if (cpp_in_system_header (pfile
))
223 if (pfile
->date
== NULL
)
225 /* Allocate __DATE__ and __TIME__ strings from permanent
226 storage. We only do this once, and don't generate them
227 at init time, because time() and localtime() are very
228 slow on some systems. */
230 struct tm
*tb
= NULL
;
232 /* (time_t) -1 is a legitimate value for "number of seconds
233 since the Epoch", so we have to do a little dance to
234 distinguish that from a genuine error. */
237 if (tt
!= (time_t)-1 || errno
== 0)
238 tb
= localtime (&tt
);
242 pfile
->date
= _cpp_unaligned_alloc (pfile
,
243 sizeof ("\"Oct 11 1347\""));
244 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
245 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
248 pfile
->time
= _cpp_unaligned_alloc (pfile
,
249 sizeof ("\"12:34:56\""));
250 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
251 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
255 cpp_errno (pfile
, CPP_DL_WARNING
,
256 "could not determine date and time");
258 pfile
->date
= UC
"\"??? ?? ????\"";
259 pfile
->time
= UC
"\"??:??:??\"";
263 if (node
->value
.builtin
== BT_DATE
)
264 result
= pfile
->date
;
266 result
= pfile
->time
;
270 if (CPP_OPTION (pfile
, directives_only
) && pfile
->state
.in_directive
)
271 cpp_error (pfile
, CPP_DL_ERROR
,
272 "__COUNTER__ expanded inside directive with -fdirectives-only");
273 number
= pfile
->counter
++;
279 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
280 result
= _cpp_unaligned_alloc (pfile
, 21);
281 sprintf ((char *) result
, "%u", number
);
287 /* Convert builtin macros like __FILE__ to a token and push it on the
288 context stack. Also handles _Pragma, for which a new token may not
289 be created. Returns 1 if it generates a new token context, 0 to
290 return the token to the caller. */
292 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
)
298 if (node
->value
.builtin
== BT_PRAGMA
)
300 /* Don't interpret _Pragma within directives. The standard is
301 not clear on this, but to me this makes most sense. */
302 if (pfile
->state
.in_directive
)
305 return _cpp_do__Pragma (pfile
);
308 buf
= _cpp_builtin_macro_text (pfile
, node
);
310 nbuf
= (char *) alloca (len
+ 1);
311 memcpy (nbuf
, buf
, len
);
314 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
315 _cpp_clean_line (pfile
);
317 /* Set pfile->cur_token as required by _cpp_lex_direct. */
318 pfile
->cur_token
= _cpp_temp_token (pfile
);
319 _cpp_push_token_context (pfile
, NULL
, _cpp_lex_direct (pfile
), 1);
320 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
321 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
323 _cpp_pop_buffer (pfile
);
328 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
329 backslashes and double quotes. DEST must be of sufficient size.
330 Returns a pointer to the end of the string. */
332 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
338 if (c
== '\\' || c
== '"')
350 /* Convert a token sequence ARG to a single string token according to
351 the rules of the ISO C #-operator. */
352 static const cpp_token
*
353 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
356 unsigned int i
, escape_it
, backslash_count
= 0;
357 const cpp_token
*source
= NULL
;
360 if (BUFF_ROOM (pfile
->u_buff
) < 3)
361 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
362 dest
= BUFF_FRONT (pfile
->u_buff
);
365 /* Loop, reading in the argument's tokens. */
366 for (i
= 0; i
< arg
->count
; i
++)
368 const cpp_token
*token
= arg
->first
[i
];
370 if (token
->type
== CPP_PADDING
)
373 || (!(source
->flags
& PREV_WHITE
)
374 && token
->val
.source
== NULL
))
375 source
= token
->val
.source
;
379 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
380 || token
->type
== CPP_WSTRING
|| token
->type
== CPP_STRING
381 || token
->type
== CPP_STRING32
|| token
->type
== CPP_CHAR32
382 || token
->type
== CPP_STRING16
|| token
->type
== CPP_CHAR16
);
384 /* Room for each char being written in octal, initial space and
385 final quote and NUL. */
386 len
= cpp_token_len (token
);
391 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
393 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
394 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
395 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
398 /* Leading white space? */
399 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
403 if (source
->flags
& PREV_WHITE
)
410 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
411 unsigned char *buf
= BUFF_FRONT (buff
);
412 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
413 dest
= cpp_quote_string (dest
, buf
, len
);
414 _cpp_release_buff (pfile
, buff
);
417 dest
= cpp_spell_token (pfile
, token
, dest
, true);
419 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
425 /* Ignore the final \ of invalid string literals. */
426 if (backslash_count
& 1)
428 cpp_error (pfile
, CPP_DL_WARNING
,
429 "invalid string literal, ignoring final '\\'");
433 /* Commit the memory, including NUL, and return the token. */
435 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
436 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
437 return new_string_token (pfile
, dest
- len
, len
);
440 /* Try to paste two tokens. On success, return nonzero. In any
441 case, PLHS is updated to point to the pasted token, which is
442 guaranteed to not have the PASTE_LEFT flag set. */
444 paste_tokens (cpp_reader
*pfile
, const cpp_token
**plhs
, const cpp_token
*rhs
)
446 unsigned char *buf
, *end
, *lhsend
;
450 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
451 buf
= (unsigned char *) alloca (len
);
452 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, false);
454 /* Avoid comment headers, since they are still processed in stage 3.
455 It is simpler to insert a space here, rather than modifying the
456 lexer to ignore comments in some circumstances. Simply returning
457 false doesn't work, since we want to clear the PASTE_LEFT flag. */
458 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
460 /* In one obscure case we might see padding here. */
461 if (rhs
->type
!= CPP_PADDING
)
462 end
= cpp_spell_token (pfile
, rhs
, end
, false);
465 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
466 _cpp_clean_line (pfile
);
468 /* Set pfile->cur_token as required by _cpp_lex_direct. */
469 pfile
->cur_token
= _cpp_temp_token (pfile
);
470 lhs
= _cpp_lex_direct (pfile
);
471 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
473 source_location saved_loc
= lhs
->src_loc
;
475 _cpp_pop_buffer (pfile
);
476 _cpp_backup_tokens (pfile
, 1);
479 /* We have to remove the PASTE_LEFT flag from the old lhs, but
480 we want to keep the new location. */
483 lhs
->src_loc
= saved_loc
;
484 lhs
->flags
&= ~PASTE_LEFT
;
486 /* Mandatory error for all apart from assembler. */
487 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
488 cpp_error (pfile
, CPP_DL_ERROR
,
489 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
490 buf
, cpp_token_as_text (pfile
, rhs
));
495 _cpp_pop_buffer (pfile
);
499 /* Handles an arbitrarily long sequence of ## operators, with initial
500 operand LHS. This implementation is left-associative,
501 non-recursive, and finishes a paste before handling succeeding
502 ones. If a paste fails, we back up to the RHS of the failing ##
503 operator before pushing the context containing the result of prior
504 successful pastes, with the effect that the RHS appears in the
505 output stream after the pasted LHS normally. */
507 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
509 const cpp_token
*rhs
;
510 cpp_context
*context
= pfile
->context
;
514 /* Take the token directly from the current context. We can do
515 this, because we are in the replacement list of either an
516 object-like macro, or a function-like macro with arguments
517 inserted. In either case, the constraints to #define
518 guarantee we have at least one more token. */
519 if (context
->direct_p
)
520 rhs
= FIRST (context
).token
++;
522 rhs
= *FIRST (context
).ptoken
++;
524 if (rhs
->type
== CPP_PADDING
)
526 if (rhs
->flags
& PASTE_LEFT
)
529 if (!paste_tokens (pfile
, &lhs
, rhs
))
532 while (rhs
->flags
& PASTE_LEFT
);
534 /* Put the resulting token in its own context. */
535 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
538 /* Returns TRUE if the number of arguments ARGC supplied in an
539 invocation of the MACRO referenced by NODE is valid. An empty
540 invocation to a macro with no parameters should pass ARGC as zero.
542 Note that MACRO cannot necessarily be deduced from NODE, in case
543 NODE was redefined whilst collecting arguments. */
545 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
547 if (argc
== macro
->paramc
)
550 if (argc
< macro
->paramc
)
552 /* As an extension, a rest argument is allowed to not appear in
553 the invocation at all.
554 e.g. #define debug(format, args...) something
557 This is exactly the same as if there had been an empty rest
558 argument - debug("string", ). */
560 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
562 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
563 cpp_error (pfile
, CPP_DL_PEDWARN
,
564 "ISO C99 requires rest arguments to be used");
568 cpp_error (pfile
, CPP_DL_ERROR
,
569 "macro \"%s\" requires %u arguments, but only %u given",
570 NODE_NAME (node
), macro
->paramc
, argc
);
573 cpp_error (pfile
, CPP_DL_ERROR
,
574 "macro \"%s\" passed %u arguments, but takes just %u",
575 NODE_NAME (node
), argc
, macro
->paramc
);
580 /* Reads and returns the arguments to a function-like macro
581 invocation. Assumes the opening parenthesis has been processed.
582 If there is an error, emits an appropriate diagnostic and returns
583 NULL. Each argument is terminated by a CPP_EOF token, for the
584 future benefit of expand_arg(). If there are any deferred
585 #pragma directives among macro arguments, store pointers to the
586 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. */
588 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
,
589 _cpp_buff
**pragma_buff
)
591 _cpp_buff
*buff
, *base_buff
;
593 macro_arg
*args
, *arg
;
594 const cpp_token
*token
;
597 macro
= node
->value
.macro
;
599 argc
= macro
->paramc
;
602 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
603 + sizeof (macro_arg
)));
605 args
= (macro_arg
*) buff
->base
;
606 memset (args
, 0, argc
* sizeof (macro_arg
));
607 buff
->cur
= (unsigned char *) &args
[argc
];
608 arg
= args
, argc
= 0;
610 /* Collect the tokens making up each argument. We don't yet know
611 how many arguments have been supplied, whether too many or too
612 few. Hence the slightly bizarre usage of "argc" and "arg". */
615 unsigned int paren_depth
= 0;
616 unsigned int ntokens
= 0;
619 arg
->first
= (const cpp_token
**) buff
->cur
;
623 /* Require space for 2 new tokens (including a CPP_EOF). */
624 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
626 buff
= _cpp_append_extend_buff (pfile
, buff
,
627 1000 * sizeof (cpp_token
*));
628 arg
->first
= (const cpp_token
**) buff
->cur
;
631 token
= cpp_get_token (pfile
);
633 if (token
->type
== CPP_PADDING
)
635 /* Drop leading padding. */
639 else if (token
->type
== CPP_OPEN_PAREN
)
641 else if (token
->type
== CPP_CLOSE_PAREN
)
643 if (paren_depth
-- == 0)
646 else if (token
->type
== CPP_COMMA
)
648 /* A comma does not terminate an argument within
649 parentheses or as part of a variable argument. */
651 && ! (macro
->variadic
&& argc
== macro
->paramc
))
654 else if (token
->type
== CPP_EOF
655 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
657 else if (token
->type
== CPP_PRAGMA
)
659 cpp_token
*newtok
= _cpp_temp_token (pfile
);
661 /* CPP_PRAGMA token lives in directive_result, which will
662 be overwritten on the next directive. */
667 if (*pragma_buff
== NULL
668 || BUFF_ROOM (*pragma_buff
) < sizeof (cpp_token
*))
671 if (*pragma_buff
== NULL
)
673 = _cpp_get_buff (pfile
, 32 * sizeof (cpp_token
*));
678 = _cpp_get_buff (pfile
,
679 (BUFF_FRONT (*pragma_buff
)
680 - (*pragma_buff
)->base
) * 2);
681 (*pragma_buff
)->next
= next
;
684 *(const cpp_token
**) BUFF_FRONT (*pragma_buff
) = token
;
685 BUFF_FRONT (*pragma_buff
) += sizeof (cpp_token
*);
686 if (token
->type
== CPP_PRAGMA_EOL
)
688 token
= cpp_get_token (pfile
);
690 while (token
->type
!= CPP_EOF
);
692 /* In deferred pragmas parsing_args and prevent_expansion
693 had been changed, reset it. */
694 pfile
->state
.parsing_args
= 2;
695 pfile
->state
.prevent_expansion
= 1;
697 if (token
->type
== CPP_EOF
)
703 arg
->first
[ntokens
++] = token
;
706 /* Drop trailing padding. */
707 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
710 arg
->count
= ntokens
;
711 arg
->first
[ntokens
] = &pfile
->eof
;
713 /* Terminate the argument. Excess arguments loop back and
714 overwrite the final legitimate argument, before failing. */
715 if (argc
<= macro
->paramc
)
717 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
718 if (argc
!= macro
->paramc
)
722 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
724 if (token
->type
== CPP_EOF
)
726 /* We still need the CPP_EOF to end directives, and to end
727 pre-expansion of a macro argument. Step back is not
728 unconditional, since we don't want to return a CPP_EOF to our
729 callers at the end of an -include-d file. */
730 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
731 _cpp_backup_tokens (pfile
, 1);
732 cpp_error (pfile
, CPP_DL_ERROR
,
733 "unterminated argument list invoking macro \"%s\"",
738 /* A single empty argument is counted as no argument. */
739 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
741 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
743 /* GCC has special semantics for , ## b where b is a varargs
744 parameter: we remove the comma if b was omitted entirely.
745 If b was merely an empty argument, the comma is retained.
746 If the macro takes just one (varargs) parameter, then we
747 retain the comma only if we are standards conforming.
749 If FIRST is NULL replace_args () swallows the comma. */
750 if (macro
->variadic
&& (argc
< macro
->paramc
751 || (argc
== 1 && args
[0].count
== 0
752 && !CPP_OPTION (pfile
, std
))))
753 args
[macro
->paramc
- 1].first
= NULL
;
758 /* An error occurred. */
759 _cpp_release_buff (pfile
, base_buff
);
763 /* Search for an opening parenthesis to the macro of NODE, in such a
764 way that, if none is found, we don't lose the information in any
765 intervening padding tokens. If we find the parenthesis, collect
766 the arguments and return the buffer containing them. PRAGMA_BUFF
767 argument is the same as in collect_args. */
769 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
770 _cpp_buff
**pragma_buff
)
772 const cpp_token
*token
, *padding
= NULL
;
776 token
= cpp_get_token (pfile
);
777 if (token
->type
!= CPP_PADDING
)
780 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
784 if (token
->type
== CPP_OPEN_PAREN
)
786 pfile
->state
.parsing_args
= 2;
787 return collect_args (pfile
, node
, pragma_buff
);
790 /* CPP_EOF can be the end of macro arguments, or the end of the
791 file. We mustn't back up over the latter. Ugh. */
792 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
794 /* Back up. We may have skipped padding, in which case backing
795 up more than one token when expanding macros is in general
796 too difficult. We re-insert it in its own context. */
797 _cpp_backup_tokens (pfile
, 1);
799 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
805 /* Push the context of a macro with hash entry NODE onto the context
806 stack. If we can successfully expand the macro, we push a context
807 containing its yet-to-be-rescanned replacement list and return one.
808 If there were additionally any unexpanded deferred #pragma directives
809 among macro arguments, push another context containing the
810 pragma tokens before the yet-to-be-rescanned replacement list
811 and return two. Otherwise, we don't push a context and return zero. */
813 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
814 const cpp_token
*result
)
816 /* The presence of a macro invalidates a file's controlling macro. */
817 pfile
->mi_valid
= false;
819 pfile
->state
.angled_headers
= false;
821 if ((node
->flags
& NODE_BUILTIN
) && !(node
->flags
& NODE_USED
))
823 node
->flags
|= NODE_USED
;
824 if (pfile
->cb
.used_define
)
825 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
828 /* Handle standard macros. */
829 if (! (node
->flags
& NODE_BUILTIN
))
831 cpp_macro
*macro
= node
->value
.macro
;
832 _cpp_buff
*pragma_buff
= NULL
;
838 pfile
->state
.prevent_expansion
++;
839 pfile
->keep_tokens
++;
840 pfile
->state
.parsing_args
= 1;
841 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
);
842 pfile
->state
.parsing_args
= 0;
843 pfile
->keep_tokens
--;
844 pfile
->state
.prevent_expansion
--;
848 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
849 cpp_error (pfile
, CPP_DL_WARNING
,
850 "function-like macro \"%s\" must be used with arguments in traditional C",
854 _cpp_release_buff (pfile
, pragma_buff
);
859 if (macro
->paramc
> 0)
860 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
861 _cpp_release_buff (pfile
, buff
);
864 /* Disable the macro within its expansion. */
865 node
->flags
|= NODE_DISABLED
;
867 if (!(node
->flags
& NODE_USED
))
869 node
->flags
|= NODE_USED
;
870 if (pfile
->cb
.used_define
)
871 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
876 if (macro
->paramc
== 0)
877 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
, macro
->count
);
881 if (!pfile
->state
.in_directive
)
882 _cpp_push_token_context (pfile
, NULL
,
883 padding_token (pfile
, result
), 1);
886 _cpp_buff
*tail
= pragma_buff
->next
;
887 pragma_buff
->next
= NULL
;
888 push_ptoken_context (pfile
, NULL
, pragma_buff
,
889 (const cpp_token
**) pragma_buff
->base
,
890 ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
891 - (const cpp_token
**) pragma_buff
->base
));
894 while (pragma_buff
!= NULL
);
901 /* Handle built-in macros and the _Pragma operator. */
902 return builtin_macro (pfile
, node
);
905 /* Replace the parameters in a function-like macro of NODE with the
906 actual ARGS, and place the result in a newly pushed token context.
907 Expand each argument before replacing, unless it is operated upon
908 by the # or ## operators. */
910 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
, macro_arg
*args
)
912 unsigned int i
, total
;
913 const cpp_token
*src
, *limit
;
914 const cpp_token
**dest
, **first
;
918 /* First, fully macro-expand arguments, calculating the number of
919 tokens in the final expansion as we go. The ordering of the if
920 statements below is subtle; we must handle stringification before
922 total
= macro
->count
;
923 limit
= macro
->exp
.tokens
+ macro
->count
;
925 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
926 if (src
->type
== CPP_MACRO_ARG
)
928 /* Leading and trailing padding tokens. */
931 /* We have an argument. If it is not being stringified or
932 pasted it is macro-replaced before insertion. */
933 arg
= &args
[src
->val
.arg_no
- 1];
935 if (src
->flags
& STRINGIFY_ARG
)
937 if (!arg
->stringified
)
938 arg
->stringified
= stringify_arg (pfile
, arg
);
940 else if ((src
->flags
& PASTE_LEFT
)
941 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
942 total
+= arg
->count
- 1;
946 expand_arg (pfile
, arg
);
947 total
+= arg
->expanded_count
- 1;
951 /* Now allocate space for the expansion, copy the tokens and replace
953 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
954 first
= (const cpp_token
**) buff
->base
;
957 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
960 const cpp_token
**from
, **paste_flag
;
962 if (src
->type
!= CPP_MACRO_ARG
)
969 arg
= &args
[src
->val
.arg_no
- 1];
970 if (src
->flags
& STRINGIFY_ARG
)
971 count
= 1, from
= &arg
->stringified
;
972 else if (src
->flags
& PASTE_LEFT
)
973 count
= arg
->count
, from
= arg
->first
;
974 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
976 count
= arg
->count
, from
= arg
->first
;
979 if (dest
[-1]->type
== CPP_COMMA
981 && src
->val
.arg_no
== macro
->paramc
)
983 /* Swallow a pasted comma if from == NULL, otherwise
984 drop the paste flag. */
988 paste_flag
= dest
- 1;
990 /* Remove the paste flag if the RHS is a placemarker. */
992 paste_flag
= dest
- 1;
996 count
= arg
->expanded_count
, from
= arg
->expanded
;
998 /* Padding on the left of an argument (unless RHS of ##). */
999 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
1000 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
1001 *dest
++ = padding_token (pfile
, src
);
1005 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
1008 /* With a non-empty argument on the LHS of ##, the last
1009 token should be flagged PASTE_LEFT. */
1010 if (src
->flags
& PASTE_LEFT
)
1011 paste_flag
= dest
- 1;
1013 else if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
1014 && ! CPP_OPTION (pfile
, c99
)
1015 && ! cpp_in_system_header (pfile
))
1017 cpp_error (pfile
, CPP_DL_PEDWARN
,
1018 "invoking macro %s argument %d: "
1019 "empty macro arguments are undefined"
1020 " in ISO C90 and ISO C++98",
1025 /* Avoid paste on RHS (even case count == 0). */
1026 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
1027 *dest
++ = &pfile
->avoid_paste
;
1029 /* Add a new paste flag, or remove an unwanted one. */
1032 cpp_token
*token
= _cpp_temp_token (pfile
);
1033 token
->type
= (*paste_flag
)->type
;
1034 token
->val
= (*paste_flag
)->val
;
1035 if (src
->flags
& PASTE_LEFT
)
1036 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1038 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1039 *paste_flag
= token
;
1043 /* Free the expanded arguments. */
1044 for (i
= 0; i
< macro
->paramc
; i
++)
1045 if (args
[i
].expanded
)
1046 free (args
[i
].expanded
);
1048 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
1051 /* Return a special padding token, with padding inherited from SOURCE. */
1052 static const cpp_token
*
1053 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
1055 cpp_token
*result
= _cpp_temp_token (pfile
);
1057 result
->type
= CPP_PADDING
;
1059 /* Data in GCed data structures cannot be made const so far, so we
1060 need a cast here. */
1061 result
->val
.source
= (cpp_token
*) source
;
1066 /* Get a new uninitialized context. Create a new one if we cannot
1067 re-use an old one. */
1068 static cpp_context
*
1069 next_context (cpp_reader
*pfile
)
1071 cpp_context
*result
= pfile
->context
->next
;
1075 result
= XNEW (cpp_context
);
1076 result
->prev
= pfile
->context
;
1078 pfile
->context
->next
= result
;
1081 pfile
->context
= result
;
1085 /* Push a list of pointers to tokens. */
1087 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
1088 const cpp_token
**first
, unsigned int count
)
1090 cpp_context
*context
= next_context (pfile
);
1092 context
->direct_p
= false;
1093 context
->macro
= macro
;
1094 context
->buff
= buff
;
1095 FIRST (context
).ptoken
= first
;
1096 LAST (context
).ptoken
= first
+ count
;
1099 /* Push a list of tokens. */
1101 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1102 const cpp_token
*first
, unsigned int count
)
1104 cpp_context
*context
= next_context (pfile
);
1106 context
->direct_p
= true;
1107 context
->macro
= macro
;
1108 context
->buff
= NULL
;
1109 FIRST (context
).token
= first
;
1110 LAST (context
).token
= first
+ count
;
1113 /* Push a traditional macro's replacement text. */
1115 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1116 const uchar
*start
, size_t len
)
1118 cpp_context
*context
= next_context (pfile
);
1120 context
->direct_p
= true;
1121 context
->macro
= macro
;
1122 context
->buff
= NULL
;
1123 CUR (context
) = start
;
1124 RLIMIT (context
) = start
+ len
;
1125 macro
->flags
|= NODE_DISABLED
;
1128 /* Expand an argument ARG before replacing parameters in a
1129 function-like macro. This works by pushing a context with the
1130 argument's tokens, and then expanding that into a temporary buffer
1131 as if it were a normal part of the token stream. collect_args()
1132 has terminated the argument's tokens with a CPP_EOF so that we know
1133 when we have fully expanded the argument. */
1135 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
1137 unsigned int capacity
;
1138 bool saved_warn_trad
;
1140 if (arg
->count
== 0)
1143 /* Don't warn about funlike macros when pre-expanding. */
1144 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
1145 CPP_WTRADITIONAL (pfile
) = 0;
1147 /* Loop, reading in the arguments. */
1149 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
1151 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
1154 const cpp_token
*token
;
1156 if (arg
->expanded_count
+ 1 >= capacity
)
1159 arg
->expanded
= XRESIZEVEC (const cpp_token
*, arg
->expanded
,
1163 token
= cpp_get_token (pfile
);
1165 if (token
->type
== CPP_EOF
)
1168 arg
->expanded
[arg
->expanded_count
++] = token
;
1171 _cpp_pop_context (pfile
);
1173 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
1176 /* Pop the current context off the stack, re-enabling the macro if the
1177 context represented a macro's replacement list. The context
1178 structure is not freed so that we can re-use it later. */
1180 _cpp_pop_context (cpp_reader
*pfile
)
1182 cpp_context
*context
= pfile
->context
;
1185 context
->macro
->flags
&= ~NODE_DISABLED
;
1188 _cpp_release_buff (pfile
, context
->buff
);
1190 pfile
->context
= context
->prev
;
1193 /* External routine to get a token. Also used nearly everywhere
1194 internally, except for places where we know we can safely call
1195 _cpp_lex_token directly, such as lexing a directive name.
1197 Macro expansions and directives are transparently handled,
1198 including entering included files. Thus tokens are post-macro
1199 expansion, and after any intervening directives. External callers
1200 see CPP_EOF only at EOF. Internal callers also see it when meeting
1201 a directive inside a macro call, when at the end of a directive and
1202 state.in_directive is still 1, and at the end of argument
1205 cpp_get_token (cpp_reader
*pfile
)
1207 const cpp_token
*result
;
1208 bool can_set
= pfile
->set_invocation_location
;
1209 pfile
->set_invocation_location
= false;
1214 cpp_context
*context
= pfile
->context
;
1216 /* Context->prev == 0 <=> base context. */
1218 result
= _cpp_lex_token (pfile
);
1219 else if (FIRST (context
).token
!= LAST (context
).token
)
1221 if (context
->direct_p
)
1222 result
= FIRST (context
).token
++;
1224 result
= *FIRST (context
).ptoken
++;
1226 if (result
->flags
& PASTE_LEFT
)
1228 paste_all_tokens (pfile
, result
);
1229 if (pfile
->state
.in_directive
)
1231 return padding_token (pfile
, result
);
1236 _cpp_pop_context (pfile
);
1237 if (pfile
->state
.in_directive
)
1239 return &pfile
->avoid_paste
;
1242 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1245 if (result
->type
!= CPP_NAME
)
1248 node
= result
->val
.node
;
1250 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1253 if (!(node
->flags
& NODE_DISABLED
))
1256 /* If not in a macro context, and we're going to start an
1257 expansion, record the location. */
1258 if (can_set
&& !context
->macro
)
1259 pfile
->invocation_location
= result
->src_loc
;
1260 if (pfile
->state
.prevent_expansion
)
1263 /* Conditional macros require that a predicate be evaluated
1265 if ((node
->flags
& NODE_CONDITIONAL
) != 0)
1267 if (pfile
->cb
.macro_to_expand
)
1269 bool whitespace_after
;
1270 const cpp_token
*peek_tok
= cpp_peek_token (pfile
, 0);
1272 whitespace_after
= (peek_tok
->type
== CPP_PADDING
1273 || (peek_tok
->flags
& PREV_WHITE
));
1274 node
= pfile
->cb
.macro_to_expand (pfile
, result
);
1276 ret
= enter_macro_context (pfile
, node
, result
);
1277 else if (whitespace_after
)
1279 /* If macro_to_expand hook returned NULL and it
1280 ate some tokens, see if we don't need to add
1281 a padding token in between this and the
1283 peek_tok
= cpp_peek_token (pfile
, 0);
1284 if (peek_tok
->type
!= CPP_PADDING
1285 && (peek_tok
->flags
& PREV_WHITE
) == 0)
1286 _cpp_push_token_context (pfile
, NULL
,
1287 padding_token (pfile
,
1293 ret
= enter_macro_context (pfile
, node
, result
);
1296 if (pfile
->state
.in_directive
|| ret
== 2)
1298 return padding_token (pfile
, result
);
1303 /* Flag this token as always unexpandable. FIXME: move this
1304 to collect_args()?. */
1305 cpp_token
*t
= _cpp_temp_token (pfile
);
1306 t
->type
= result
->type
;
1307 t
->flags
= result
->flags
| NO_EXPAND
;
1308 t
->val
= result
->val
;
1318 /* Like cpp_get_token, but also returns a location separate from the
1319 one provided by the returned token. LOC is an out parameter; *LOC
1320 is set to the location "as expected by the user". This matters
1321 when a token results from macro expansion -- the token's location
1322 will indicate where the macro is defined, but *LOC will be the
1323 location of the start of the expansion. */
1325 cpp_get_token_with_location (cpp_reader
*pfile
, source_location
*loc
)
1327 const cpp_token
*result
;
1329 pfile
->set_invocation_location
= true;
1330 result
= cpp_get_token (pfile
);
1331 if (pfile
->context
->macro
)
1332 *loc
= pfile
->invocation_location
;
1334 *loc
= result
->src_loc
;
1339 /* Returns true if we're expanding an object-like macro that was
1340 defined in a system header. Just checks the macro at the top of
1341 the stack. Used for diagnostic suppression. */
1343 cpp_sys_macro_p (cpp_reader
*pfile
)
1345 cpp_hashnode
*node
= pfile
->context
->macro
;
1347 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1350 /* Read each token in, until end of the current file. Directives are
1351 transparently processed. */
1353 cpp_scan_nooutput (cpp_reader
*pfile
)
1355 /* Request a CPP_EOF token at the end of this file, rather than
1356 transparently continuing with the including file. */
1357 pfile
->buffer
->return_at_eof
= true;
1359 pfile
->state
.discarding_output
++;
1360 pfile
->state
.prevent_expansion
++;
1362 if (CPP_OPTION (pfile
, traditional
))
1363 while (_cpp_read_logical_line_trad (pfile
))
1366 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1369 pfile
->state
.discarding_output
--;
1370 pfile
->state
.prevent_expansion
--;
1373 /* Step back one or more tokens obtained from the lexer. */
1375 _cpp_backup_tokens_direct (cpp_reader
*pfile
, unsigned int count
)
1377 pfile
->lookaheads
+= count
;
1381 if (pfile
->cur_token
== pfile
->cur_run
->base
1382 /* Possible with -fpreprocessed and no leading #line. */
1383 && pfile
->cur_run
->prev
!= NULL
)
1385 pfile
->cur_run
= pfile
->cur_run
->prev
;
1386 pfile
->cur_token
= pfile
->cur_run
->limit
;
1391 /* Step back one (or more) tokens. Can only step back more than 1 if
1392 they are from the lexer, and not from macro expansion. */
1394 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
1396 if (pfile
->context
->prev
== NULL
)
1397 _cpp_backup_tokens_direct (pfile
, count
);
1402 if (pfile
->context
->direct_p
)
1403 FIRST (pfile
->context
).token
--;
1405 FIRST (pfile
->context
).ptoken
--;
1409 /* #define directive parsing and handling. */
1411 /* Returns nonzero if a macro redefinition warning is required. */
1413 warn_of_redefinition (cpp_reader
*pfile
, const cpp_hashnode
*node
,
1414 const cpp_macro
*macro2
)
1416 const cpp_macro
*macro1
;
1419 /* Some redefinitions need to be warned about regardless. */
1420 if (node
->flags
& NODE_WARN
)
1423 /* Suppress warnings for builtins that lack the NODE_WARN flag. */
1424 if (node
->flags
& NODE_BUILTIN
)
1427 /* Redefinitions of conditional (context-sensitive) macros, on
1428 the other hand, must be allowed silently. */
1429 if (node
->flags
& NODE_CONDITIONAL
)
1432 /* Redefinition of a macro is allowed if and only if the old and new
1433 definitions are the same. (6.10.3 paragraph 2). */
1434 macro1
= node
->value
.macro
;
1436 /* Don't check count here as it can be different in valid
1437 traditional redefinitions with just whitespace differences. */
1438 if (macro1
->paramc
!= macro2
->paramc
1439 || macro1
->fun_like
!= macro2
->fun_like
1440 || macro1
->variadic
!= macro2
->variadic
)
1443 /* Check parameter spellings. */
1444 for (i
= 0; i
< macro1
->paramc
; i
++)
1445 if (macro1
->params
[i
] != macro2
->params
[i
])
1448 /* Check the replacement text or tokens. */
1449 if (CPP_OPTION (pfile
, traditional
))
1450 return _cpp_expansions_different_trad (macro1
, macro2
);
1452 if (macro1
->count
!= macro2
->count
)
1455 for (i
= 0; i
< macro1
->count
; i
++)
1456 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
1462 /* Free the definition of hashnode H. */
1464 _cpp_free_definition (cpp_hashnode
*h
)
1466 /* Macros and assertions no longer have anything to free. */
1468 /* Clear builtin flag in case of redefinition. */
1469 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
| NODE_USED
);
1472 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1473 zero on success, nonzero if the parameter is a duplicate. */
1475 _cpp_save_parameter (cpp_reader
*pfile
, cpp_macro
*macro
, cpp_hashnode
*node
)
1478 /* Constraint 6.10.3.6 - duplicate parameter names. */
1479 if (node
->flags
& NODE_MACRO_ARG
)
1481 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
1486 if (BUFF_ROOM (pfile
->a_buff
)
1487 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1488 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1490 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1491 node
->flags
|= NODE_MACRO_ARG
;
1492 len
= macro
->paramc
* sizeof (union _cpp_hashnode_value
);
1493 if (len
> pfile
->macro_buffer_len
)
1495 pfile
->macro_buffer
= XRESIZEVEC (unsigned char, pfile
->macro_buffer
,
1497 pfile
->macro_buffer_len
= len
;
1499 ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[macro
->paramc
- 1]
1502 node
->value
.arg_index
= macro
->paramc
;
1506 /* Check the syntax of the parameters in a MACRO definition. Returns
1507 false if an error occurs. */
1509 parse_params (cpp_reader
*pfile
, cpp_macro
*macro
)
1511 unsigned int prev_ident
= 0;
1515 const cpp_token
*token
= _cpp_lex_token (pfile
);
1517 switch (token
->type
)
1520 /* Allow/ignore comments in parameter lists if we are
1521 preserving comments in macro expansions. */
1522 if (token
->type
== CPP_COMMENT
1523 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1526 cpp_error (pfile
, CPP_DL_ERROR
,
1527 "\"%s\" may not appear in macro parameter list",
1528 cpp_token_as_text (pfile
, token
));
1534 cpp_error (pfile
, CPP_DL_ERROR
,
1535 "macro parameters must be comma-separated");
1540 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
))
1544 case CPP_CLOSE_PAREN
:
1545 if (prev_ident
|| macro
->paramc
== 0)
1548 /* Fall through to pick up the error. */
1552 cpp_error (pfile
, CPP_DL_ERROR
, "parameter name missing");
1559 macro
->variadic
= 1;
1562 _cpp_save_parameter (pfile
, macro
,
1563 pfile
->spec_nodes
.n__VA_ARGS__
);
1564 pfile
->state
.va_args_ok
= 1;
1565 if (! CPP_OPTION (pfile
, c99
)
1566 && CPP_OPTION (pfile
, pedantic
)
1567 && CPP_OPTION (pfile
, warn_variadic_macros
))
1568 cpp_error (pfile
, CPP_DL_PEDWARN
,
1569 "anonymous variadic macros were introduced in C99");
1571 else if (CPP_OPTION (pfile
, pedantic
)
1572 && CPP_OPTION (pfile
, warn_variadic_macros
))
1573 cpp_error (pfile
, CPP_DL_PEDWARN
,
1574 "ISO C does not permit named variadic macros");
1576 /* We're at the end, and just expect a closing parenthesis. */
1577 token
= _cpp_lex_token (pfile
);
1578 if (token
->type
== CPP_CLOSE_PAREN
)
1583 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' in macro parameter list");
1589 /* Allocate room for a token from a macro's replacement list. */
1591 alloc_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1593 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1594 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1596 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1599 /* Lex a token from the expansion of MACRO, but mark parameters as we
1600 find them and warn of traditional stringification. */
1602 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1604 cpp_token
*token
, *saved_cur_token
;
1606 saved_cur_token
= pfile
->cur_token
;
1607 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1608 token
= _cpp_lex_direct (pfile
);
1609 pfile
->cur_token
= saved_cur_token
;
1611 /* Is this a parameter? */
1612 if (token
->type
== CPP_NAME
1613 && (token
->val
.node
->flags
& NODE_MACRO_ARG
) != 0)
1615 token
->type
= CPP_MACRO_ARG
;
1616 token
->val
.arg_no
= token
->val
.node
->value
.arg_index
;
1618 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1619 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1620 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1626 create_iso_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
1629 const cpp_token
*ctoken
;
1630 bool following_paste_op
= false;
1631 const char *paste_op_error_msg
=
1632 N_("'##' cannot appear at either end of a macro expansion");
1634 /* Get the first token of the expansion (or the '(' of a
1635 function-like macro). */
1636 ctoken
= _cpp_lex_token (pfile
);
1638 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1640 bool ok
= parse_params (pfile
, macro
);
1641 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1645 /* Success. Commit or allocate the parameter array. */
1646 if (pfile
->hash_table
->alloc_subobject
)
1648 cpp_hashnode
**params
=
1649 (cpp_hashnode
**) pfile
->hash_table
->alloc_subobject
1650 (sizeof (cpp_hashnode
*) * macro
->paramc
);
1651 memcpy (params
, macro
->params
,
1652 sizeof (cpp_hashnode
*) * macro
->paramc
);
1653 macro
->params
= params
;
1656 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1657 macro
->fun_like
= 1;
1659 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1661 /* While ISO C99 requires whitespace before replacement text
1662 in a macro definition, ISO C90 with TC1 allows there characters
1663 from the basic source character set. */
1664 if (CPP_OPTION (pfile
, c99
))
1665 cpp_error (pfile
, CPP_DL_PEDWARN
,
1666 "ISO C99 requires whitespace after the macro name");
1669 int warntype
= CPP_DL_WARNING
;
1670 switch (ctoken
->type
)
1674 case CPP_OBJC_STRING
:
1675 /* '@' is not in basic character set. */
1676 warntype
= CPP_DL_PEDWARN
;
1679 /* Basic character set sans letters, digits and _. */
1680 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1681 ctoken
->val
.str
.text
[0]) == NULL
)
1682 warntype
= CPP_DL_PEDWARN
;
1685 /* All other tokens start with a character from basic
1689 cpp_error (pfile
, warntype
,
1690 "missing whitespace after the macro name");
1694 if (macro
->fun_like
)
1695 token
= lex_expansion_token (pfile
, macro
);
1698 token
= alloc_expansion_token (pfile
, macro
);
1704 /* Check the stringifying # constraint 6.10.3.2.1 of
1705 function-like macros when lexing the subsequent token. */
1706 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1708 if (token
->type
== CPP_MACRO_ARG
)
1710 token
->flags
&= ~PREV_WHITE
;
1711 token
->flags
|= STRINGIFY_ARG
;
1712 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1713 token
[-1] = token
[0];
1716 /* Let assembler get away with murder. */
1717 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1719 cpp_error (pfile
, CPP_DL_ERROR
,
1720 "'#' is not followed by a macro parameter");
1725 if (token
->type
== CPP_EOF
)
1727 /* Paste operator constraint 6.10.3.3.1:
1728 Token-paste ##, can appear in both object-like and
1729 function-like macros, but not at the end. */
1730 if (following_paste_op
)
1732 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
1738 /* Paste operator constraint 6.10.3.3.1. */
1739 if (token
->type
== CPP_PASTE
)
1741 /* Token-paste ##, can appear in both object-like and
1742 function-like macros, but not at the beginning. */
1743 if (macro
->count
== 1)
1745 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
1750 token
[-1].flags
|= PASTE_LEFT
;
1753 following_paste_op
= (token
->type
== CPP_PASTE
);
1754 token
= lex_expansion_token (pfile
, macro
);
1757 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1758 macro
->traditional
= 0;
1760 /* Don't count the CPP_EOF. */
1763 /* Clear whitespace on first token for warn_of_redefinition(). */
1765 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
1767 /* Commit or allocate the memory. */
1768 if (pfile
->hash_table
->alloc_subobject
)
1771 (cpp_token
*) pfile
->hash_table
->alloc_subobject (sizeof (cpp_token
)
1773 memcpy (tokns
, macro
->exp
.tokens
, sizeof (cpp_token
) * macro
->count
);
1774 macro
->exp
.tokens
= tokns
;
1777 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
1782 /* Parse a macro and save its expansion. Returns nonzero on success. */
1784 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
1790 if (pfile
->hash_table
->alloc_subobject
)
1791 macro
= (cpp_macro
*) pfile
->hash_table
->alloc_subobject
1792 (sizeof (cpp_macro
));
1794 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1795 macro
->line
= pfile
->directive_line
;
1798 macro
->variadic
= 0;
1799 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
1801 macro
->fun_like
= 0;
1802 /* To suppress some diagnostics. */
1803 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
1805 if (CPP_OPTION (pfile
, traditional
))
1806 ok
= _cpp_create_trad_definition (pfile
, macro
);
1809 ok
= create_iso_definition (pfile
, macro
);
1811 /* We set the type for SEEN_EOL() in directives.c.
1813 Longer term we should lex the whole line before coming here,
1814 and just copy the expansion. */
1816 /* Stop the lexer accepting __VA_ARGS__. */
1817 pfile
->state
.va_args_ok
= 0;
1820 /* Clear the fast argument lookup indices. */
1821 for (i
= macro
->paramc
; i
-- > 0; )
1823 struct cpp_hashnode
*node
= macro
->params
[i
];
1824 node
->flags
&= ~ NODE_MACRO_ARG
;
1825 node
->value
= ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[i
];
1831 if (node
->type
== NT_MACRO
)
1833 if (CPP_OPTION (pfile
, warn_unused_macros
))
1834 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
1836 if (warn_of_redefinition (pfile
, node
, macro
))
1839 warned
= cpp_error_with_line (pfile
, CPP_DL_PEDWARN
,
1840 pfile
->directive_line
, 0,
1841 "\"%s\" redefined", NODE_NAME (node
));
1843 if (warned
&& node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1844 cpp_error_with_line (pfile
, CPP_DL_NOTE
,
1845 node
->value
.macro
->line
, 0,
1846 "this is the location of the previous definition");
1850 if (node
->type
!= NT_VOID
)
1851 _cpp_free_definition (node
);
1853 /* Enter definition in hash table. */
1854 node
->type
= NT_MACRO
;
1855 node
->value
.macro
= macro
;
1856 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
1857 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
1858 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1859 in the C standard, as something that one must use in C++.
1860 However DR#593 indicates that these aren't actually mentioned
1861 in the C++ standard. We special-case them anyway. */
1862 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
1863 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
1864 node
->flags
|= NODE_WARN
;
1866 /* If user defines one of the conditional macros, remove the
1868 node
->flags
&= ~NODE_CONDITIONAL
;
1873 /* Warn if a token in STRING matches one of a function-like MACRO's
1876 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
1877 const cpp_string
*string
)
1879 unsigned int i
, len
;
1880 const uchar
*p
, *q
, *limit
;
1882 /* Loop over the string. */
1883 limit
= string
->text
+ string
->len
- 1;
1884 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
1886 /* Find the start of an identifier. */
1887 while (p
< limit
&& !is_idstart (*p
))
1890 /* Find the end of the identifier. */
1892 while (q
< limit
&& is_idchar (*q
))
1897 /* Loop over the function macro arguments to see if the
1898 identifier inside the string matches one of them. */
1899 for (i
= 0; i
< macro
->paramc
; i
++)
1901 const cpp_hashnode
*node
= macro
->params
[i
];
1903 if (NODE_LEN (node
) == len
1904 && !memcmp (p
, NODE_NAME (node
), len
))
1906 cpp_error (pfile
, CPP_DL_WARNING
,
1907 "macro argument \"%s\" would be stringified in traditional C",
1915 /* Returns the name, arguments and expansion of a macro, in a format
1916 suitable to be read back in again, and therefore also for DWARF 2
1917 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1918 Caller is expected to generate the "#define" bit if needed. The
1919 returned text is temporary, and automatically freed later. */
1920 const unsigned char *
1921 cpp_macro_definition (cpp_reader
*pfile
, const cpp_hashnode
*node
)
1923 unsigned int i
, len
;
1924 const cpp_macro
*macro
= node
->value
.macro
;
1925 unsigned char *buffer
;
1927 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1929 cpp_error (pfile
, CPP_DL_ICE
,
1930 "invalid hash type %d in cpp_macro_definition", node
->type
);
1934 /* Calculate length. */
1935 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
1936 if (macro
->fun_like
)
1938 len
+= 4; /* "()" plus possible final ".." of named
1939 varargs (we have + 1 below). */
1940 for (i
= 0; i
< macro
->paramc
; i
++)
1941 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1944 /* This should match below where we fill in the buffer. */
1945 if (CPP_OPTION (pfile
, traditional
))
1946 len
+= _cpp_replacement_text_len (macro
);
1949 for (i
= 0; i
< macro
->count
; i
++)
1951 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1953 if (token
->type
== CPP_MACRO_ARG
)
1954 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1956 len
+= cpp_token_len (token
);
1958 if (token
->flags
& STRINGIFY_ARG
)
1960 if (token
->flags
& PASTE_LEFT
)
1961 len
+= 3; /* " ##" */
1962 if (token
->flags
& PREV_WHITE
)
1967 if (len
> pfile
->macro_buffer_len
)
1969 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
1970 pfile
->macro_buffer
, len
);
1971 pfile
->macro_buffer_len
= len
;
1974 /* Fill in the buffer. Start with the macro name. */
1975 buffer
= pfile
->macro_buffer
;
1976 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1977 buffer
+= NODE_LEN (node
);
1979 /* Parameter names. */
1980 if (macro
->fun_like
)
1983 for (i
= 0; i
< macro
->paramc
; i
++)
1985 cpp_hashnode
*param
= macro
->params
[i
];
1987 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1989 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1990 buffer
+= NODE_LEN (param
);
1993 if (i
+ 1 < macro
->paramc
)
1994 /* Don't emit a space after the comma here; we're trying
1995 to emit a Dwarf-friendly definition, and the Dwarf spec
1996 forbids spaces in the argument list. */
1998 else if (macro
->variadic
)
1999 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
2004 /* The Dwarf spec requires a space after the macro name, even if the
2005 definition is the empty string. */
2008 if (CPP_OPTION (pfile
, traditional
))
2009 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
2010 else if (macro
->count
)
2011 /* Expansion tokens. */
2013 for (i
= 0; i
< macro
->count
; i
++)
2015 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
2017 if (token
->flags
& PREV_WHITE
)
2019 if (token
->flags
& STRINGIFY_ARG
)
2022 if (token
->type
== CPP_MACRO_ARG
)
2025 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]),
2026 NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]));
2027 buffer
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
2030 buffer
= cpp_spell_token (pfile
, token
, buffer
, false);
2032 if (token
->flags
& PASTE_LEFT
)
2037 /* Next has PREV_WHITE; see _cpp_create_definition. */
2043 return pfile
->macro_buffer
;