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, 2010 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
*, 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_warning_with_line (pfile
, CPP_W_UNUSED_MACROS
, 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_WCHAR
381 || token
->type
== CPP_STRING32
|| token
->type
== CPP_CHAR32
382 || token
->type
== CPP_STRING16
|| token
->type
== CPP_CHAR16
383 || token
->type
== CPP_UTF8STRING
);
385 /* Room for each char being written in octal, initial space and
386 final quote and NUL. */
387 len
= cpp_token_len (token
);
392 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
394 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
395 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
396 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
399 /* Leading white space? */
400 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
404 if (source
->flags
& PREV_WHITE
)
411 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
412 unsigned char *buf
= BUFF_FRONT (buff
);
413 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
414 dest
= cpp_quote_string (dest
, buf
, len
);
415 _cpp_release_buff (pfile
, buff
);
418 dest
= cpp_spell_token (pfile
, token
, dest
, true);
420 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
426 /* Ignore the final \ of invalid string literals. */
427 if (backslash_count
& 1)
429 cpp_error (pfile
, CPP_DL_WARNING
,
430 "invalid string literal, ignoring final '\\'");
434 /* Commit the memory, including NUL, and return the token. */
436 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
437 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
438 return new_string_token (pfile
, dest
- len
, len
);
441 /* Try to paste two tokens. On success, return nonzero. In any
442 case, PLHS is updated to point to the pasted token, which is
443 guaranteed to not have the PASTE_LEFT flag set. */
445 paste_tokens (cpp_reader
*pfile
, const cpp_token
**plhs
, const cpp_token
*rhs
)
447 unsigned char *buf
, *end
, *lhsend
;
451 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
452 buf
= (unsigned char *) alloca (len
);
453 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, false);
455 /* Avoid comment headers, since they are still processed in stage 3.
456 It is simpler to insert a space here, rather than modifying the
457 lexer to ignore comments in some circumstances. Simply returning
458 false doesn't work, since we want to clear the PASTE_LEFT flag. */
459 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
461 /* In one obscure case we might see padding here. */
462 if (rhs
->type
!= CPP_PADDING
)
463 end
= cpp_spell_token (pfile
, rhs
, end
, false);
466 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
467 _cpp_clean_line (pfile
);
469 /* Set pfile->cur_token as required by _cpp_lex_direct. */
470 pfile
->cur_token
= _cpp_temp_token (pfile
);
471 lhs
= _cpp_lex_direct (pfile
);
472 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
474 source_location saved_loc
= lhs
->src_loc
;
476 _cpp_pop_buffer (pfile
);
477 _cpp_backup_tokens (pfile
, 1);
480 /* We have to remove the PASTE_LEFT flag from the old lhs, but
481 we want to keep the new location. */
484 lhs
->src_loc
= saved_loc
;
485 lhs
->flags
&= ~PASTE_LEFT
;
487 /* Mandatory error for all apart from assembler. */
488 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
489 cpp_error (pfile
, CPP_DL_ERROR
,
490 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
491 buf
, cpp_token_as_text (pfile
, rhs
));
496 _cpp_pop_buffer (pfile
);
500 /* Handles an arbitrarily long sequence of ## operators, with initial
501 operand LHS. This implementation is left-associative,
502 non-recursive, and finishes a paste before handling succeeding
503 ones. If a paste fails, we back up to the RHS of the failing ##
504 operator before pushing the context containing the result of prior
505 successful pastes, with the effect that the RHS appears in the
506 output stream after the pasted LHS normally. */
508 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
510 const cpp_token
*rhs
;
511 cpp_context
*context
= pfile
->context
;
515 /* Take the token directly from the current context. We can do
516 this, because we are in the replacement list of either an
517 object-like macro, or a function-like macro with arguments
518 inserted. In either case, the constraints to #define
519 guarantee we have at least one more token. */
520 if (context
->direct_p
)
521 rhs
= FIRST (context
).token
++;
523 rhs
= *FIRST (context
).ptoken
++;
525 if (rhs
->type
== CPP_PADDING
)
527 if (rhs
->flags
& PASTE_LEFT
)
530 if (!paste_tokens (pfile
, &lhs
, rhs
))
533 while (rhs
->flags
& PASTE_LEFT
);
535 /* Put the resulting token in its own context. */
536 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
539 /* Returns TRUE if the number of arguments ARGC supplied in an
540 invocation of the MACRO referenced by NODE is valid. An empty
541 invocation to a macro with no parameters should pass ARGC as zero.
543 Note that MACRO cannot necessarily be deduced from NODE, in case
544 NODE was redefined whilst collecting arguments. */
546 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
548 if (argc
== macro
->paramc
)
551 if (argc
< macro
->paramc
)
553 /* As an extension, a rest argument is allowed to not appear in
554 the invocation at all.
555 e.g. #define debug(format, args...) something
558 This is exactly the same as if there had been an empty rest
559 argument - debug("string", ). */
561 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
563 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
564 cpp_error (pfile
, CPP_DL_PEDWARN
,
565 "ISO C99 requires rest arguments to be used");
569 cpp_error (pfile
, CPP_DL_ERROR
,
570 "macro \"%s\" requires %u arguments, but only %u given",
571 NODE_NAME (node
), macro
->paramc
, argc
);
574 cpp_error (pfile
, CPP_DL_ERROR
,
575 "macro \"%s\" passed %u arguments, but takes just %u",
576 NODE_NAME (node
), argc
, macro
->paramc
);
581 /* Reads and returns the arguments to a function-like macro
582 invocation. Assumes the opening parenthesis has been processed.
583 If there is an error, emits an appropriate diagnostic and returns
584 NULL. Each argument is terminated by a CPP_EOF token, for the
585 future benefit of expand_arg(). If there are any deferred
586 #pragma directives among macro arguments, store pointers to the
587 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. */
589 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
,
590 _cpp_buff
**pragma_buff
)
592 _cpp_buff
*buff
, *base_buff
;
594 macro_arg
*args
, *arg
;
595 const cpp_token
*token
;
598 macro
= node
->value
.macro
;
600 argc
= macro
->paramc
;
603 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
604 + sizeof (macro_arg
)));
606 args
= (macro_arg
*) buff
->base
;
607 memset (args
, 0, argc
* sizeof (macro_arg
));
608 buff
->cur
= (unsigned char *) &args
[argc
];
609 arg
= args
, argc
= 0;
611 /* Collect the tokens making up each argument. We don't yet know
612 how many arguments have been supplied, whether too many or too
613 few. Hence the slightly bizarre usage of "argc" and "arg". */
616 unsigned int paren_depth
= 0;
617 unsigned int ntokens
= 0;
620 arg
->first
= (const cpp_token
**) buff
->cur
;
624 /* Require space for 2 new tokens (including a CPP_EOF). */
625 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
627 buff
= _cpp_append_extend_buff (pfile
, buff
,
628 1000 * sizeof (cpp_token
*));
629 arg
->first
= (const cpp_token
**) buff
->cur
;
632 token
= cpp_get_token (pfile
);
634 if (token
->type
== CPP_PADDING
)
636 /* Drop leading padding. */
640 else if (token
->type
== CPP_OPEN_PAREN
)
642 else if (token
->type
== CPP_CLOSE_PAREN
)
644 if (paren_depth
-- == 0)
647 else if (token
->type
== CPP_COMMA
)
649 /* A comma does not terminate an argument within
650 parentheses or as part of a variable argument. */
652 && ! (macro
->variadic
&& argc
== macro
->paramc
))
655 else if (token
->type
== CPP_EOF
656 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
658 else if (token
->type
== CPP_PRAGMA
)
660 cpp_token
*newtok
= _cpp_temp_token (pfile
);
662 /* CPP_PRAGMA token lives in directive_result, which will
663 be overwritten on the next directive. */
668 if (*pragma_buff
== NULL
669 || BUFF_ROOM (*pragma_buff
) < sizeof (cpp_token
*))
672 if (*pragma_buff
== NULL
)
674 = _cpp_get_buff (pfile
, 32 * sizeof (cpp_token
*));
679 = _cpp_get_buff (pfile
,
680 (BUFF_FRONT (*pragma_buff
)
681 - (*pragma_buff
)->base
) * 2);
682 (*pragma_buff
)->next
= next
;
685 *(const cpp_token
**) BUFF_FRONT (*pragma_buff
) = token
;
686 BUFF_FRONT (*pragma_buff
) += sizeof (cpp_token
*);
687 if (token
->type
== CPP_PRAGMA_EOL
)
689 token
= cpp_get_token (pfile
);
691 while (token
->type
!= CPP_EOF
);
693 /* In deferred pragmas parsing_args and prevent_expansion
694 had been changed, reset it. */
695 pfile
->state
.parsing_args
= 2;
696 pfile
->state
.prevent_expansion
= 1;
698 if (token
->type
== CPP_EOF
)
704 arg
->first
[ntokens
++] = token
;
707 /* Drop trailing padding. */
708 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
711 arg
->count
= ntokens
;
712 arg
->first
[ntokens
] = &pfile
->eof
;
714 /* Terminate the argument. Excess arguments loop back and
715 overwrite the final legitimate argument, before failing. */
716 if (argc
<= macro
->paramc
)
718 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
719 if (argc
!= macro
->paramc
)
723 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
725 if (token
->type
== CPP_EOF
)
727 /* We still need the CPP_EOF to end directives, and to end
728 pre-expansion of a macro argument. Step back is not
729 unconditional, since we don't want to return a CPP_EOF to our
730 callers at the end of an -include-d file. */
731 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
732 _cpp_backup_tokens (pfile
, 1);
733 cpp_error (pfile
, CPP_DL_ERROR
,
734 "unterminated argument list invoking macro \"%s\"",
739 /* A single empty argument is counted as no argument. */
740 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
742 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
744 /* GCC has special semantics for , ## b where b is a varargs
745 parameter: we remove the comma if b was omitted entirely.
746 If b was merely an empty argument, the comma is retained.
747 If the macro takes just one (varargs) parameter, then we
748 retain the comma only if we are standards conforming.
750 If FIRST is NULL replace_args () swallows the comma. */
751 if (macro
->variadic
&& (argc
< macro
->paramc
752 || (argc
== 1 && args
[0].count
== 0
753 && !CPP_OPTION (pfile
, std
))))
754 args
[macro
->paramc
- 1].first
= NULL
;
759 /* An error occurred. */
760 _cpp_release_buff (pfile
, base_buff
);
764 /* Search for an opening parenthesis to the macro of NODE, in such a
765 way that, if none is found, we don't lose the information in any
766 intervening padding tokens. If we find the parenthesis, collect
767 the arguments and return the buffer containing them. PRAGMA_BUFF
768 argument is the same as in collect_args. */
770 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
771 _cpp_buff
**pragma_buff
)
773 const cpp_token
*token
, *padding
= NULL
;
777 token
= cpp_get_token (pfile
);
778 if (token
->type
!= CPP_PADDING
)
781 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
785 if (token
->type
== CPP_OPEN_PAREN
)
787 pfile
->state
.parsing_args
= 2;
788 return collect_args (pfile
, node
, pragma_buff
);
791 /* CPP_EOF can be the end of macro arguments, or the end of the
792 file. We mustn't back up over the latter. Ugh. */
793 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
795 /* Back up. We may have skipped padding, in which case backing
796 up more than one token when expanding macros is in general
797 too difficult. We re-insert it in its own context. */
798 _cpp_backup_tokens (pfile
, 1);
800 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
806 /* Return the real number of tokens in the expansion of MACRO. */
807 static inline unsigned int
808 macro_real_token_count (const cpp_macro
*macro
)
811 if (__builtin_expect (!macro
->extra_tokens
, true))
813 for (i
= 0; i
< macro
->count
; i
++)
814 if (macro
->exp
.tokens
[i
].type
== CPP_PASTE
)
819 /* Push the context of a macro with hash entry NODE onto the context
820 stack. If we can successfully expand the macro, we push a context
821 containing its yet-to-be-rescanned replacement list and return one.
822 If there were additionally any unexpanded deferred #pragma directives
823 among macro arguments, push another context containing the
824 pragma tokens before the yet-to-be-rescanned replacement list
825 and return two. Otherwise, we don't push a context and return zero. */
827 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
828 const cpp_token
*result
)
830 /* The presence of a macro invalidates a file's controlling macro. */
831 pfile
->mi_valid
= false;
833 pfile
->state
.angled_headers
= false;
835 if ((node
->flags
& NODE_BUILTIN
) && !(node
->flags
& NODE_USED
))
837 node
->flags
|= NODE_USED
;
838 if ((!pfile
->cb
.user_builtin_macro
839 || !pfile
->cb
.user_builtin_macro (pfile
, node
))
840 && pfile
->cb
.used_define
)
841 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
844 /* Handle standard macros. */
845 if (! (node
->flags
& NODE_BUILTIN
))
847 cpp_macro
*macro
= node
->value
.macro
;
848 _cpp_buff
*pragma_buff
= NULL
;
854 pfile
->state
.prevent_expansion
++;
855 pfile
->keep_tokens
++;
856 pfile
->state
.parsing_args
= 1;
857 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
);
858 pfile
->state
.parsing_args
= 0;
859 pfile
->keep_tokens
--;
860 pfile
->state
.prevent_expansion
--;
864 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
865 cpp_warning (pfile
, CPP_W_TRADITIONAL
,
866 "function-like macro \"%s\" must be used with arguments in traditional C",
870 _cpp_release_buff (pfile
, pragma_buff
);
875 if (macro
->paramc
> 0)
876 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
877 _cpp_release_buff (pfile
, buff
);
880 /* Disable the macro within its expansion. */
881 node
->flags
|= NODE_DISABLED
;
883 node
->expanded_to_text
= 1;
885 if (!(node
->flags
& NODE_USED
))
887 node
->flags
|= NODE_USED
;
888 if (pfile
->cb
.used_define
)
889 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
893 pfile
->cb
.used (pfile
, result
->src_loc
, node
);
897 if (macro
->paramc
== 0)
898 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
,
899 macro_real_token_count (macro
));
903 if (!pfile
->state
.in_directive
)
904 _cpp_push_token_context (pfile
, NULL
,
905 padding_token (pfile
, result
), 1);
908 _cpp_buff
*tail
= pragma_buff
->next
;
909 pragma_buff
->next
= NULL
;
910 push_ptoken_context (pfile
, NULL
, pragma_buff
,
911 (const cpp_token
**) pragma_buff
->base
,
912 ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
913 - (const cpp_token
**) pragma_buff
->base
));
916 while (pragma_buff
!= NULL
);
923 /* Handle built-in macros and the _Pragma operator. */
924 return builtin_macro (pfile
, node
);
927 /* Replace the parameters in a function-like macro of NODE with the
928 actual ARGS, and place the result in a newly pushed token context.
929 Expand each argument before replacing, unless it is operated upon
930 by the # or ## operators. */
932 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
, macro_arg
*args
)
934 unsigned int i
, total
;
935 const cpp_token
*src
, *limit
;
936 const cpp_token
**dest
, **first
;
941 /* First, fully macro-expand arguments, calculating the number of
942 tokens in the final expansion as we go. The ordering of the if
943 statements below is subtle; we must handle stringification before
945 count
= macro_real_token_count (macro
);
947 limit
= macro
->exp
.tokens
+ count
;
949 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
950 if (src
->type
== CPP_MACRO_ARG
)
952 /* Leading and trailing padding tokens. */
955 /* We have an argument. If it is not being stringified or
956 pasted it is macro-replaced before insertion. */
957 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
959 if (src
->flags
& STRINGIFY_ARG
)
961 if (!arg
->stringified
)
962 arg
->stringified
= stringify_arg (pfile
, arg
);
964 else if ((src
->flags
& PASTE_LEFT
)
965 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
966 total
+= arg
->count
- 1;
970 expand_arg (pfile
, arg
);
971 total
+= arg
->expanded_count
- 1;
975 /* Now allocate space for the expansion, copy the tokens and replace
977 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
978 first
= (const cpp_token
**) buff
->base
;
981 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
984 const cpp_token
**from
, **paste_flag
;
986 if (src
->type
!= CPP_MACRO_ARG
)
993 arg
= &args
[src
->val
.macro_arg
.arg_no
- 1];
994 if (src
->flags
& STRINGIFY_ARG
)
995 count
= 1, from
= &arg
->stringified
;
996 else if (src
->flags
& PASTE_LEFT
)
997 count
= arg
->count
, from
= arg
->first
;
998 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
1000 count
= arg
->count
, from
= arg
->first
;
1003 if (dest
[-1]->type
== CPP_COMMA
1005 && src
->val
.macro_arg
.arg_no
== macro
->paramc
)
1007 /* Swallow a pasted comma if from == NULL, otherwise
1008 drop the paste flag. */
1012 paste_flag
= dest
- 1;
1014 /* Remove the paste flag if the RHS is a placemarker. */
1015 else if (count
== 0)
1016 paste_flag
= dest
- 1;
1020 count
= arg
->expanded_count
, from
= arg
->expanded
;
1022 /* Padding on the left of an argument (unless RHS of ##). */
1023 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
1024 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
1025 *dest
++ = padding_token (pfile
, src
);
1029 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
1032 /* With a non-empty argument on the LHS of ##, the last
1033 token should be flagged PASTE_LEFT. */
1034 if (src
->flags
& PASTE_LEFT
)
1035 paste_flag
= dest
- 1;
1037 else if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
1038 && ! CPP_OPTION (pfile
, c99
)
1039 && ! cpp_in_system_header (pfile
))
1041 cpp_error (pfile
, CPP_DL_PEDWARN
,
1042 "invoking macro %s argument %d: "
1043 "empty macro arguments are undefined"
1044 " in ISO C90 and ISO C++98",
1046 src
->val
.macro_arg
.arg_no
);
1049 /* Avoid paste on RHS (even case count == 0). */
1050 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
1051 *dest
++ = &pfile
->avoid_paste
;
1053 /* Add a new paste flag, or remove an unwanted one. */
1056 cpp_token
*token
= _cpp_temp_token (pfile
);
1057 token
->type
= (*paste_flag
)->type
;
1058 token
->val
= (*paste_flag
)->val
;
1059 if (src
->flags
& PASTE_LEFT
)
1060 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1062 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1063 *paste_flag
= token
;
1067 /* Free the expanded arguments. */
1068 for (i
= 0; i
< macro
->paramc
; i
++)
1069 if (args
[i
].expanded
)
1070 free (args
[i
].expanded
);
1072 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
1075 /* Return a special padding token, with padding inherited from SOURCE. */
1076 static const cpp_token
*
1077 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
1079 cpp_token
*result
= _cpp_temp_token (pfile
);
1081 result
->type
= CPP_PADDING
;
1083 /* Data in GCed data structures cannot be made const so far, so we
1084 need a cast here. */
1085 result
->val
.source
= (cpp_token
*) source
;
1090 /* Get a new uninitialized context. Create a new one if we cannot
1091 re-use an old one. */
1092 static cpp_context
*
1093 next_context (cpp_reader
*pfile
)
1095 cpp_context
*result
= pfile
->context
->next
;
1099 result
= XNEW (cpp_context
);
1100 result
->prev
= pfile
->context
;
1102 pfile
->context
->next
= result
;
1105 pfile
->context
= result
;
1109 /* Push a list of pointers to tokens. */
1111 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
1112 const cpp_token
**first
, unsigned int count
)
1114 cpp_context
*context
= next_context (pfile
);
1116 context
->direct_p
= false;
1117 context
->macro
= macro
;
1118 context
->buff
= buff
;
1119 FIRST (context
).ptoken
= first
;
1120 LAST (context
).ptoken
= first
+ count
;
1123 /* Push a list of tokens. */
1125 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1126 const cpp_token
*first
, unsigned int count
)
1128 cpp_context
*context
= next_context (pfile
);
1130 context
->direct_p
= true;
1131 context
->macro
= macro
;
1132 context
->buff
= NULL
;
1133 FIRST (context
).token
= first
;
1134 LAST (context
).token
= first
+ count
;
1137 /* Push a traditional macro's replacement text. */
1139 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1140 const uchar
*start
, size_t len
)
1142 cpp_context
*context
= next_context (pfile
);
1144 context
->direct_p
= true;
1145 context
->macro
= macro
;
1146 context
->buff
= NULL
;
1147 CUR (context
) = start
;
1148 RLIMIT (context
) = start
+ len
;
1149 macro
->flags
|= NODE_DISABLED
;
1152 /* Expand an argument ARG before replacing parameters in a
1153 function-like macro. This works by pushing a context with the
1154 argument's tokens, and then expanding that into a temporary buffer
1155 as if it were a normal part of the token stream. collect_args()
1156 has terminated the argument's tokens with a CPP_EOF so that we know
1157 when we have fully expanded the argument. */
1159 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
1161 unsigned int capacity
;
1162 bool saved_warn_trad
;
1164 if (arg
->count
== 0)
1167 /* Don't warn about funlike macros when pre-expanding. */
1168 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
1169 CPP_WTRADITIONAL (pfile
) = 0;
1171 /* Loop, reading in the arguments. */
1173 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
1175 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
1178 const cpp_token
*token
;
1180 if (arg
->expanded_count
+ 1 >= capacity
)
1183 arg
->expanded
= XRESIZEVEC (const cpp_token
*, arg
->expanded
,
1187 token
= cpp_get_token (pfile
);
1189 if (token
->type
== CPP_EOF
)
1192 arg
->expanded
[arg
->expanded_count
++] = token
;
1195 _cpp_pop_context (pfile
);
1197 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
1200 /* Pop the current context off the stack, re-enabling the macro if the
1201 context represented a macro's replacement list. The context
1202 structure is not freed so that we can re-use it later. */
1204 _cpp_pop_context (cpp_reader
*pfile
)
1206 cpp_context
*context
= pfile
->context
;
1209 context
->macro
->flags
&= ~NODE_DISABLED
;
1212 _cpp_release_buff (pfile
, context
->buff
);
1214 pfile
->context
= context
->prev
;
1217 /* External routine to get a token. Also used nearly everywhere
1218 internally, except for places where we know we can safely call
1219 _cpp_lex_token directly, such as lexing a directive name.
1221 Macro expansions and directives are transparently handled,
1222 including entering included files. Thus tokens are post-macro
1223 expansion, and after any intervening directives. External callers
1224 see CPP_EOF only at EOF. Internal callers also see it when meeting
1225 a directive inside a macro call, when at the end of a directive and
1226 state.in_directive is still 1, and at the end of argument
1229 cpp_get_token (cpp_reader
*pfile
)
1231 const cpp_token
*result
;
1232 bool can_set
= pfile
->set_invocation_location
;
1233 pfile
->set_invocation_location
= false;
1238 cpp_context
*context
= pfile
->context
;
1240 /* Context->prev == 0 <=> base context. */
1242 result
= _cpp_lex_token (pfile
);
1243 else if (FIRST (context
).token
!= LAST (context
).token
)
1245 if (context
->direct_p
)
1246 result
= FIRST (context
).token
++;
1248 result
= *FIRST (context
).ptoken
++;
1250 if (result
->flags
& PASTE_LEFT
)
1252 paste_all_tokens (pfile
, result
);
1253 if (pfile
->state
.in_directive
)
1255 return padding_token (pfile
, result
);
1260 _cpp_pop_context (pfile
);
1261 if (pfile
->state
.in_directive
)
1263 return &pfile
->avoid_paste
;
1266 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1269 if (result
->type
!= CPP_NAME
)
1272 node
= result
->val
.node
.node
;
1273 node
->expanded_to_text
= 1;
1275 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1278 if (!(node
->flags
& NODE_DISABLED
))
1281 /* If not in a macro context, and we're going to start an
1282 expansion, record the location. */
1283 if (can_set
&& !context
->macro
)
1284 pfile
->invocation_location
= result
->src_loc
;
1285 if (pfile
->state
.prevent_expansion
)
1288 /* Conditional macros require that a predicate be evaluated
1290 if ((node
->flags
& NODE_CONDITIONAL
) != 0)
1292 if (pfile
->cb
.macro_to_expand
)
1294 bool whitespace_after
;
1295 const cpp_token
*peek_tok
= cpp_peek_token (pfile
, 0);
1297 whitespace_after
= (peek_tok
->type
== CPP_PADDING
1298 || (peek_tok
->flags
& PREV_WHITE
));
1299 node
= pfile
->cb
.macro_to_expand (pfile
, result
);
1301 ret
= enter_macro_context (pfile
, node
, result
);
1302 else if (whitespace_after
)
1304 /* If macro_to_expand hook returned NULL and it
1305 ate some tokens, see if we don't need to add
1306 a padding token in between this and the
1308 peek_tok
= cpp_peek_token (pfile
, 0);
1309 if (peek_tok
->type
!= CPP_PADDING
1310 && (peek_tok
->flags
& PREV_WHITE
) == 0)
1311 _cpp_push_token_context (pfile
, NULL
,
1312 padding_token (pfile
,
1318 ret
= enter_macro_context (pfile
, node
, result
);
1321 if (pfile
->state
.in_directive
|| ret
== 2)
1323 return padding_token (pfile
, result
);
1328 /* Flag this token as always unexpandable. FIXME: move this
1329 to collect_args()?. */
1330 cpp_token
*t
= _cpp_temp_token (pfile
);
1331 t
->type
= result
->type
;
1332 t
->flags
= result
->flags
| NO_EXPAND
;
1333 t
->val
= result
->val
;
1343 /* Like cpp_get_token, but also returns a location separate from the
1344 one provided by the returned token. LOC is an out parameter; *LOC
1345 is set to the location "as expected by the user". This matters
1346 when a token results from macro expansion -- the token's location
1347 will indicate where the macro is defined, but *LOC will be the
1348 location of the start of the expansion. */
1350 cpp_get_token_with_location (cpp_reader
*pfile
, source_location
*loc
)
1352 const cpp_token
*result
;
1354 pfile
->set_invocation_location
= true;
1355 result
= cpp_get_token (pfile
);
1356 if (pfile
->context
->macro
)
1357 *loc
= pfile
->invocation_location
;
1359 *loc
= result
->src_loc
;
1364 /* Returns true if we're expanding an object-like macro that was
1365 defined in a system header. Just checks the macro at the top of
1366 the stack. Used for diagnostic suppression. */
1368 cpp_sys_macro_p (cpp_reader
*pfile
)
1370 cpp_hashnode
*node
= pfile
->context
->macro
;
1372 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1375 /* Read each token in, until end of the current file. Directives are
1376 transparently processed. */
1378 cpp_scan_nooutput (cpp_reader
*pfile
)
1380 /* Request a CPP_EOF token at the end of this file, rather than
1381 transparently continuing with the including file. */
1382 pfile
->buffer
->return_at_eof
= true;
1384 pfile
->state
.discarding_output
++;
1385 pfile
->state
.prevent_expansion
++;
1387 if (CPP_OPTION (pfile
, traditional
))
1388 while (_cpp_read_logical_line_trad (pfile
))
1391 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1394 pfile
->state
.discarding_output
--;
1395 pfile
->state
.prevent_expansion
--;
1398 /* Step back one or more tokens obtained from the lexer. */
1400 _cpp_backup_tokens_direct (cpp_reader
*pfile
, unsigned int count
)
1402 pfile
->lookaheads
+= count
;
1406 if (pfile
->cur_token
== pfile
->cur_run
->base
1407 /* Possible with -fpreprocessed and no leading #line. */
1408 && pfile
->cur_run
->prev
!= NULL
)
1410 pfile
->cur_run
= pfile
->cur_run
->prev
;
1411 pfile
->cur_token
= pfile
->cur_run
->limit
;
1416 /* Step back one (or more) tokens. Can only step back more than 1 if
1417 they are from the lexer, and not from macro expansion. */
1419 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
1421 if (pfile
->context
->prev
== NULL
)
1422 _cpp_backup_tokens_direct (pfile
, count
);
1427 if (pfile
->context
->direct_p
)
1428 FIRST (pfile
->context
).token
--;
1430 FIRST (pfile
->context
).ptoken
--;
1434 /* #define directive parsing and handling. */
1436 /* Returns nonzero if a macro redefinition warning is required. */
1438 warn_of_redefinition (cpp_reader
*pfile
, cpp_hashnode
*node
,
1439 const cpp_macro
*macro2
)
1441 const cpp_macro
*macro1
;
1444 /* Some redefinitions need to be warned about regardless. */
1445 if (node
->flags
& NODE_WARN
)
1448 /* Suppress warnings for builtins that lack the NODE_WARN flag. */
1449 if (node
->flags
& NODE_BUILTIN
)
1451 if (!pfile
->cb
.user_builtin_macro
1452 || !pfile
->cb
.user_builtin_macro (pfile
, node
))
1456 /* Redefinitions of conditional (context-sensitive) macros, on
1457 the other hand, must be allowed silently. */
1458 if (node
->flags
& NODE_CONDITIONAL
)
1461 /* Redefinition of a macro is allowed if and only if the old and new
1462 definitions are the same. (6.10.3 paragraph 2). */
1463 macro1
= node
->value
.macro
;
1465 /* Don't check count here as it can be different in valid
1466 traditional redefinitions with just whitespace differences. */
1467 if (macro1
->paramc
!= macro2
->paramc
1468 || macro1
->fun_like
!= macro2
->fun_like
1469 || macro1
->variadic
!= macro2
->variadic
)
1472 /* Check parameter spellings. */
1473 for (i
= 0; i
< macro1
->paramc
; i
++)
1474 if (macro1
->params
[i
] != macro2
->params
[i
])
1477 /* Check the replacement text or tokens. */
1478 if (CPP_OPTION (pfile
, traditional
))
1479 return _cpp_expansions_different_trad (macro1
, macro2
);
1481 if (macro1
->count
!= macro2
->count
)
1484 for (i
= 0; i
< macro1
->count
; i
++)
1485 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
1491 /* Free the definition of hashnode H. */
1493 _cpp_free_definition (cpp_hashnode
*h
)
1495 /* Macros and assertions no longer have anything to free. */
1497 /* Clear builtin flag in case of redefinition. */
1498 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
| NODE_USED
);
1501 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1502 zero on success, nonzero if the parameter is a duplicate. */
1504 _cpp_save_parameter (cpp_reader
*pfile
, cpp_macro
*macro
, cpp_hashnode
*node
)
1507 /* Constraint 6.10.3.6 - duplicate parameter names. */
1508 if (node
->flags
& NODE_MACRO_ARG
)
1510 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
1515 if (BUFF_ROOM (pfile
->a_buff
)
1516 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1517 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1519 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1520 node
->flags
|= NODE_MACRO_ARG
;
1521 len
= macro
->paramc
;
1522 if (len
> pfile
->param_buffer_len
)
1524 pfile
->param_buffer
= XRESIZEVEC (union _cpp_hashnode_value
,
1525 pfile
->param_buffer
, len
);
1526 pfile
->param_buffer_len
= len
;
1528 pfile
->param_buffer
[macro
->paramc
- 1] = node
->value
;
1530 node
->value
.arg_index
= macro
->paramc
;
1534 /* Check the syntax of the parameters in a MACRO definition. Returns
1535 false if an error occurs. */
1537 parse_params (cpp_reader
*pfile
, cpp_macro
*macro
)
1539 unsigned int prev_ident
= 0;
1543 const cpp_token
*token
= _cpp_lex_token (pfile
);
1545 switch (token
->type
)
1548 /* Allow/ignore comments in parameter lists if we are
1549 preserving comments in macro expansions. */
1550 if (token
->type
== CPP_COMMENT
1551 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1554 cpp_error (pfile
, CPP_DL_ERROR
,
1555 "\"%s\" may not appear in macro parameter list",
1556 cpp_token_as_text (pfile
, token
));
1562 cpp_error (pfile
, CPP_DL_ERROR
,
1563 "macro parameters must be comma-separated");
1568 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
.node
))
1572 case CPP_CLOSE_PAREN
:
1573 if (prev_ident
|| macro
->paramc
== 0)
1576 /* Fall through to pick up the error. */
1580 cpp_error (pfile
, CPP_DL_ERROR
, "parameter name missing");
1587 macro
->variadic
= 1;
1590 _cpp_save_parameter (pfile
, macro
,
1591 pfile
->spec_nodes
.n__VA_ARGS__
);
1592 pfile
->state
.va_args_ok
= 1;
1593 if (! CPP_OPTION (pfile
, c99
)
1594 && CPP_OPTION (pfile
, cpp_pedantic
)
1595 && CPP_OPTION (pfile
, warn_variadic_macros
))
1597 (pfile
, CPP_W_VARIADIC_MACROS
,
1598 "anonymous variadic macros were introduced in C99");
1600 else if (CPP_OPTION (pfile
, cpp_pedantic
)
1601 && CPP_OPTION (pfile
, warn_variadic_macros
))
1602 cpp_pedwarning (pfile
, CPP_W_VARIADIC_MACROS
,
1603 "ISO C does not permit named variadic macros");
1605 /* We're at the end, and just expect a closing parenthesis. */
1606 token
= _cpp_lex_token (pfile
);
1607 if (token
->type
== CPP_CLOSE_PAREN
)
1612 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' in macro parameter list");
1618 /* Allocate room for a token from a macro's replacement list. */
1620 alloc_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1622 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1623 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1625 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1628 /* Lex a token from the expansion of MACRO, but mark parameters as we
1629 find them and warn of traditional stringification. */
1631 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1633 cpp_token
*token
, *saved_cur_token
;
1635 saved_cur_token
= pfile
->cur_token
;
1636 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1637 token
= _cpp_lex_direct (pfile
);
1638 pfile
->cur_token
= saved_cur_token
;
1640 /* Is this a parameter? */
1641 if (token
->type
== CPP_NAME
1642 && (token
->val
.node
.node
->flags
& NODE_MACRO_ARG
) != 0)
1644 token
->type
= CPP_MACRO_ARG
;
1645 token
->val
.macro_arg
.arg_no
= token
->val
.node
.node
->value
.arg_index
;
1647 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1648 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1649 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1655 create_iso_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
1658 const cpp_token
*ctoken
;
1659 bool following_paste_op
= false;
1660 const char *paste_op_error_msg
=
1661 N_("'##' cannot appear at either end of a macro expansion");
1662 unsigned int num_extra_tokens
= 0;
1664 /* Get the first token of the expansion (or the '(' of a
1665 function-like macro). */
1666 ctoken
= _cpp_lex_token (pfile
);
1668 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1670 bool ok
= parse_params (pfile
, macro
);
1671 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1675 /* Success. Commit or allocate the parameter array. */
1676 if (pfile
->hash_table
->alloc_subobject
)
1678 cpp_hashnode
**params
=
1679 (cpp_hashnode
**) pfile
->hash_table
->alloc_subobject
1680 (sizeof (cpp_hashnode
*) * macro
->paramc
);
1681 memcpy (params
, macro
->params
,
1682 sizeof (cpp_hashnode
*) * macro
->paramc
);
1683 macro
->params
= params
;
1686 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1687 macro
->fun_like
= 1;
1689 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1691 /* While ISO C99 requires whitespace before replacement text
1692 in a macro definition, ISO C90 with TC1 allows there characters
1693 from the basic source character set. */
1694 if (CPP_OPTION (pfile
, c99
))
1695 cpp_error (pfile
, CPP_DL_PEDWARN
,
1696 "ISO C99 requires whitespace after the macro name");
1699 int warntype
= CPP_DL_WARNING
;
1700 switch (ctoken
->type
)
1704 case CPP_OBJC_STRING
:
1705 /* '@' is not in basic character set. */
1706 warntype
= CPP_DL_PEDWARN
;
1709 /* Basic character set sans letters, digits and _. */
1710 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1711 ctoken
->val
.str
.text
[0]) == NULL
)
1712 warntype
= CPP_DL_PEDWARN
;
1715 /* All other tokens start with a character from basic
1719 cpp_error (pfile
, warntype
,
1720 "missing whitespace after the macro name");
1724 if (macro
->fun_like
)
1725 token
= lex_expansion_token (pfile
, macro
);
1728 token
= alloc_expansion_token (pfile
, macro
);
1734 /* Check the stringifying # constraint 6.10.3.2.1 of
1735 function-like macros when lexing the subsequent token. */
1736 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1738 if (token
->type
== CPP_MACRO_ARG
)
1740 if (token
->flags
& PREV_WHITE
)
1741 token
->flags
|= SP_PREV_WHITE
;
1742 if (token
[-1].flags
& DIGRAPH
)
1743 token
->flags
|= SP_DIGRAPH
;
1744 token
->flags
&= ~PREV_WHITE
;
1745 token
->flags
|= STRINGIFY_ARG
;
1746 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1747 token
[-1] = token
[0];
1750 /* Let assembler get away with murder. */
1751 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1753 cpp_error (pfile
, CPP_DL_ERROR
,
1754 "'#' is not followed by a macro parameter");
1759 if (token
->type
== CPP_EOF
)
1761 /* Paste operator constraint 6.10.3.3.1:
1762 Token-paste ##, can appear in both object-like and
1763 function-like macros, but not at the end. */
1764 if (following_paste_op
)
1766 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
1772 /* Paste operator constraint 6.10.3.3.1. */
1773 if (token
->type
== CPP_PASTE
)
1775 /* Token-paste ##, can appear in both object-like and
1776 function-like macros, but not at the beginning. */
1777 if (macro
->count
== 1)
1779 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
1783 if (token
[-1].flags
& PASTE_LEFT
)
1785 macro
->extra_tokens
= 1;
1787 token
->val
.token_no
= macro
->count
- 1;
1792 token
[-1].flags
|= PASTE_LEFT
;
1793 if (token
->flags
& DIGRAPH
)
1794 token
[-1].flags
|= SP_DIGRAPH
;
1795 if (token
->flags
& PREV_WHITE
)
1796 token
[-1].flags
|= SP_PREV_WHITE
;
1800 following_paste_op
= (token
->type
== CPP_PASTE
);
1801 token
= lex_expansion_token (pfile
, macro
);
1804 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1805 macro
->traditional
= 0;
1807 /* Don't count the CPP_EOF. */
1810 /* Clear whitespace on first token for warn_of_redefinition(). */
1812 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
1814 /* Commit or allocate the memory. */
1815 if (pfile
->hash_table
->alloc_subobject
)
1818 (cpp_token
*) pfile
->hash_table
->alloc_subobject (sizeof (cpp_token
)
1820 if (num_extra_tokens
)
1822 /* Place second and subsequent ## or %:%: tokens in
1823 sequences of consecutive such tokens at the end of the
1824 list to preserve information about where they appear, how
1825 they are spelt and whether they are preceded by
1826 whitespace without otherwise interfering with macro
1828 cpp_token
*normal_dest
= tokns
;
1829 cpp_token
*extra_dest
= tokns
+ macro
->count
- num_extra_tokens
;
1831 for (i
= 0; i
< macro
->count
; i
++)
1833 if (macro
->exp
.tokens
[i
].type
== CPP_PASTE
)
1834 *extra_dest
++ = macro
->exp
.tokens
[i
];
1836 *normal_dest
++ = macro
->exp
.tokens
[i
];
1840 memcpy (tokns
, macro
->exp
.tokens
, sizeof (cpp_token
) * macro
->count
);
1841 macro
->exp
.tokens
= tokns
;
1844 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
1849 /* Parse a macro and save its expansion. Returns nonzero on success. */
1851 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
1857 if (pfile
->hash_table
->alloc_subobject
)
1858 macro
= (cpp_macro
*) pfile
->hash_table
->alloc_subobject
1859 (sizeof (cpp_macro
));
1861 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1862 macro
->line
= pfile
->directive_line
;
1865 macro
->variadic
= 0;
1866 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
1868 macro
->fun_like
= 0;
1869 macro
->extra_tokens
= 0;
1870 /* To suppress some diagnostics. */
1871 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
1873 if (CPP_OPTION (pfile
, traditional
))
1874 ok
= _cpp_create_trad_definition (pfile
, macro
);
1877 ok
= create_iso_definition (pfile
, macro
);
1879 /* We set the type for SEEN_EOL() in directives.c.
1881 Longer term we should lex the whole line before coming here,
1882 and just copy the expansion. */
1884 /* Stop the lexer accepting __VA_ARGS__. */
1885 pfile
->state
.va_args_ok
= 0;
1888 /* Clear the fast argument lookup indices. */
1889 for (i
= macro
->paramc
; i
-- > 0; )
1891 struct cpp_hashnode
*node
= macro
->params
[i
];
1892 node
->flags
&= ~ NODE_MACRO_ARG
;
1893 node
->value
= pfile
->param_buffer
[i
];
1899 if (node
->type
== NT_MACRO
)
1901 if (CPP_OPTION (pfile
, warn_unused_macros
))
1902 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
1904 if (warn_of_redefinition (pfile
, node
, macro
))
1906 const int reason
= (node
->flags
& NODE_BUILTIN
)
1907 ? CPP_W_BUILTIN_MACRO_REDEFINED
: CPP_W_NONE
;
1910 warned
= cpp_pedwarning_with_line (pfile
, reason
,
1911 pfile
->directive_line
, 0,
1915 if (warned
&& node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1916 cpp_error_with_line (pfile
, CPP_DL_NOTE
,
1917 node
->value
.macro
->line
, 0,
1918 "this is the location of the previous definition");
1922 if (node
->type
!= NT_VOID
)
1923 _cpp_free_definition (node
);
1925 /* Enter definition in hash table. */
1926 node
->type
= NT_MACRO
;
1927 node
->value
.macro
= macro
;
1928 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
1929 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
1930 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1931 in the C standard, as something that one must use in C++.
1932 However DR#593 indicates that these aren't actually mentioned
1933 in the C++ standard. We special-case them anyway. */
1934 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
1935 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
1936 node
->flags
|= NODE_WARN
;
1938 /* If user defines one of the conditional macros, remove the
1940 node
->flags
&= ~NODE_CONDITIONAL
;
1945 /* Warn if a token in STRING matches one of a function-like MACRO's
1948 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
1949 const cpp_string
*string
)
1951 unsigned int i
, len
;
1952 const uchar
*p
, *q
, *limit
;
1954 /* Loop over the string. */
1955 limit
= string
->text
+ string
->len
- 1;
1956 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
1958 /* Find the start of an identifier. */
1959 while (p
< limit
&& !is_idstart (*p
))
1962 /* Find the end of the identifier. */
1964 while (q
< limit
&& is_idchar (*q
))
1969 /* Loop over the function macro arguments to see if the
1970 identifier inside the string matches one of them. */
1971 for (i
= 0; i
< macro
->paramc
; i
++)
1973 const cpp_hashnode
*node
= macro
->params
[i
];
1975 if (NODE_LEN (node
) == len
1976 && !memcmp (p
, NODE_NAME (node
), len
))
1978 cpp_error (pfile
, CPP_DL_WARNING
,
1979 "macro argument \"%s\" would be stringified in traditional C",
1987 /* Returns the name, arguments and expansion of a macro, in a format
1988 suitable to be read back in again, and therefore also for DWARF 2
1989 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1990 Caller is expected to generate the "#define" bit if needed. The
1991 returned text is temporary, and automatically freed later. */
1992 const unsigned char *
1993 cpp_macro_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
1995 unsigned int i
, len
;
1996 const cpp_macro
*macro
;
1997 unsigned char *buffer
;
1999 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
2001 if (node
->type
!= NT_MACRO
2002 || !pfile
->cb
.user_builtin_macro
2003 || !pfile
->cb
.user_builtin_macro (pfile
, node
))
2005 cpp_error (pfile
, CPP_DL_ICE
,
2006 "invalid hash type %d in cpp_macro_definition",
2012 macro
= node
->value
.macro
;
2013 /* Calculate length. */
2014 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
2015 if (macro
->fun_like
)
2017 len
+= 4; /* "()" plus possible final ".." of named
2018 varargs (we have + 1 below). */
2019 for (i
= 0; i
< macro
->paramc
; i
++)
2020 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
2023 /* This should match below where we fill in the buffer. */
2024 if (CPP_OPTION (pfile
, traditional
))
2025 len
+= _cpp_replacement_text_len (macro
);
2028 unsigned int count
= macro_real_token_count (macro
);
2029 for (i
= 0; i
< count
; i
++)
2031 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
2033 if (token
->type
== CPP_MACRO_ARG
)
2034 len
+= NODE_LEN (macro
->params
[token
->val
.macro_arg
.arg_no
- 1]);
2036 len
+= cpp_token_len (token
);
2038 if (token
->flags
& STRINGIFY_ARG
)
2040 if (token
->flags
& PASTE_LEFT
)
2041 len
+= 3; /* " ##" */
2042 if (token
->flags
& PREV_WHITE
)
2047 if (len
> pfile
->macro_buffer_len
)
2049 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
2050 pfile
->macro_buffer
, len
);
2051 pfile
->macro_buffer_len
= len
;
2054 /* Fill in the buffer. Start with the macro name. */
2055 buffer
= pfile
->macro_buffer
;
2056 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
2057 buffer
+= NODE_LEN (node
);
2059 /* Parameter names. */
2060 if (macro
->fun_like
)
2063 for (i
= 0; i
< macro
->paramc
; i
++)
2065 cpp_hashnode
*param
= macro
->params
[i
];
2067 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
2069 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
2070 buffer
+= NODE_LEN (param
);
2073 if (i
+ 1 < macro
->paramc
)
2074 /* Don't emit a space after the comma here; we're trying
2075 to emit a Dwarf-friendly definition, and the Dwarf spec
2076 forbids spaces in the argument list. */
2078 else if (macro
->variadic
)
2079 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
2084 /* The Dwarf spec requires a space after the macro name, even if the
2085 definition is the empty string. */
2088 if (CPP_OPTION (pfile
, traditional
))
2089 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
2090 else if (macro
->count
)
2091 /* Expansion tokens. */
2093 unsigned int count
= macro_real_token_count (macro
);
2094 for (i
= 0; i
< count
; i
++)
2096 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
2098 if (token
->flags
& PREV_WHITE
)
2100 if (token
->flags
& STRINGIFY_ARG
)
2103 if (token
->type
== CPP_MACRO_ARG
)
2106 NODE_NAME (macro
->params
[token
->val
.macro_arg
.arg_no
- 1]),
2107 NODE_LEN (macro
->params
[token
->val
.macro_arg
.arg_no
- 1]));
2108 buffer
+= NODE_LEN (macro
->params
[token
->val
.macro_arg
.arg_no
- 1]);
2111 buffer
= cpp_spell_token (pfile
, token
, buffer
, false);
2113 if (token
->flags
& PASTE_LEFT
)
2118 /* Next has PREV_WHITE; see _cpp_create_definition. */
2124 return pfile
->macro_buffer
;