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 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23 In other words, you are welcome to use, share and improve this program.
24 You are forbidden to forbid anyone else to use, share and improve
25 what you give them. Help stamp out software-hoarding! */
32 typedef struct macro_arg macro_arg
;
35 const cpp_token
**first
; /* First token in unexpanded argument. */
36 const cpp_token
**expanded
; /* Macro-expanded argument. */
37 const cpp_token
*stringified
; /* Stringified argument. */
38 unsigned int count
; /* # of tokens in argument. */
39 unsigned int expanded_count
; /* # of tokens in expanded argument. */
42 /* Macro expansion. */
44 static int enter_macro_context (cpp_reader
*, cpp_hashnode
*,
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 unsigned int 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 if (CPP_OPTION (pfile
, traditional
))
204 number
= pfile
->line_table
->highest_line
;
206 number
= pfile
->cur_token
[-1].src_loc
;
207 number
= SOURCE_LINE (map
, number
);
210 /* __STDC__ has the value 1 under normal circumstances.
211 However, if (a) we are in a system header, (b) the option
212 stdc_0_in_system_headers is true (set by target config), and
213 (c) we are not in strictly conforming mode, then it has the
214 value 0. (b) and (c) are already checked in cpp_init_builtins. */
216 if (cpp_in_system_header (pfile
))
224 if (pfile
->date
== NULL
)
226 /* Allocate __DATE__ and __TIME__ strings from permanent
227 storage. We only do this once, and don't generate them
228 at init time, because time() and localtime() are very
229 slow on some systems. */
231 struct tm
*tb
= NULL
;
233 /* (time_t) -1 is a legitimate value for "number of seconds
234 since the Epoch", so we have to do a little dance to
235 distinguish that from a genuine error. */
238 if (tt
!= (time_t)-1 || errno
== 0)
239 tb
= localtime (&tt
);
243 pfile
->date
= _cpp_unaligned_alloc (pfile
,
244 sizeof ("\"Oct 11 1347\""));
245 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
246 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
249 pfile
->time
= _cpp_unaligned_alloc (pfile
,
250 sizeof ("\"12:34:56\""));
251 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
252 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
256 cpp_errno (pfile
, CPP_DL_WARNING
,
257 "could not determine date and time");
259 pfile
->date
= UC
"\"??? ?? ????\"";
260 pfile
->time
= UC
"\"??:??:??\"";
264 if (node
->value
.builtin
== BT_DATE
)
265 result
= pfile
->date
;
267 result
= pfile
->time
;
271 if (CPP_OPTION (pfile
, directives_only
) && pfile
->state
.in_directive
)
272 cpp_error (pfile
, CPP_DL_ERROR
,
273 "__COUNTER__ expanded inside directive with -fdirectives-only");
274 number
= pfile
->counter
++;
280 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
281 result
= _cpp_unaligned_alloc (pfile
, 21);
282 sprintf ((char *) result
, "%u", number
);
288 /* Convert builtin macros like __FILE__ to a token and push it on the
289 context stack. Also handles _Pragma, for which a new token may not
290 be created. Returns 1 if it generates a new token context, 0 to
291 return the token to the caller. */
293 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
)
299 if (node
->value
.builtin
== BT_PRAGMA
)
301 /* Don't interpret _Pragma within directives. The standard is
302 not clear on this, but to me this makes most sense. */
303 if (pfile
->state
.in_directive
)
306 return _cpp_do__Pragma (pfile
);
309 buf
= _cpp_builtin_macro_text (pfile
, node
);
311 nbuf
= (char *) alloca (len
+ 1);
312 memcpy (nbuf
, buf
, len
);
315 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
316 _cpp_clean_line (pfile
);
318 /* Set pfile->cur_token as required by _cpp_lex_direct. */
319 pfile
->cur_token
= _cpp_temp_token (pfile
);
320 _cpp_push_token_context (pfile
, NULL
, _cpp_lex_direct (pfile
), 1);
321 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
322 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
324 _cpp_pop_buffer (pfile
);
329 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
330 backslashes and double quotes. DEST must be of sufficient size.
331 Returns a pointer to the end of the string. */
333 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
339 if (c
== '\\' || c
== '"')
351 /* Convert a token sequence ARG to a single string token according to
352 the rules of the ISO C #-operator. */
353 static const cpp_token
*
354 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
357 unsigned int i
, escape_it
, backslash_count
= 0;
358 const cpp_token
*source
= NULL
;
361 if (BUFF_ROOM (pfile
->u_buff
) < 3)
362 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
363 dest
= BUFF_FRONT (pfile
->u_buff
);
366 /* Loop, reading in the argument's tokens. */
367 for (i
= 0; i
< arg
->count
; i
++)
369 const cpp_token
*token
= arg
->first
[i
];
371 if (token
->type
== CPP_PADDING
)
374 source
= token
->val
.source
;
378 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
379 || token
->type
== CPP_WSTRING
|| token
->type
== CPP_STRING
380 || token
->type
== CPP_STRING32
|| token
->type
== CPP_CHAR32
381 || token
->type
== CPP_STRING16
|| token
->type
== CPP_CHAR16
);
383 /* Room for each char being written in octal, initial space and
384 final quote and NUL. */
385 len
= cpp_token_len (token
);
390 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
392 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
393 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
394 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
397 /* Leading white space? */
398 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
402 if (source
->flags
& PREV_WHITE
)
409 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
410 unsigned char *buf
= BUFF_FRONT (buff
);
411 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
412 dest
= cpp_quote_string (dest
, buf
, len
);
413 _cpp_release_buff (pfile
, buff
);
416 dest
= cpp_spell_token (pfile
, token
, dest
, true);
418 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
424 /* Ignore the final \ of invalid string literals. */
425 if (backslash_count
& 1)
427 cpp_error (pfile
, CPP_DL_WARNING
,
428 "invalid string literal, ignoring final '\\'");
432 /* Commit the memory, including NUL, and return the token. */
434 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
435 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
436 return new_string_token (pfile
, dest
- len
, len
);
439 /* Try to paste two tokens. On success, return nonzero. In any
440 case, PLHS is updated to point to the pasted token, which is
441 guaranteed to not have the PASTE_LEFT flag set. */
443 paste_tokens (cpp_reader
*pfile
, const cpp_token
**plhs
, const cpp_token
*rhs
)
445 unsigned char *buf
, *end
, *lhsend
;
449 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
450 buf
= (unsigned char *) alloca (len
);
451 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, false);
453 /* Avoid comment headers, since they are still processed in stage 3.
454 It is simpler to insert a space here, rather than modifying the
455 lexer to ignore comments in some circumstances. Simply returning
456 false doesn't work, since we want to clear the PASTE_LEFT flag. */
457 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
459 /* In one obscure case we might see padding here. */
460 if (rhs
->type
!= CPP_PADDING
)
461 end
= cpp_spell_token (pfile
, rhs
, end
, false);
464 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
465 _cpp_clean_line (pfile
);
467 /* Set pfile->cur_token as required by _cpp_lex_direct. */
468 pfile
->cur_token
= _cpp_temp_token (pfile
);
469 lhs
= _cpp_lex_direct (pfile
);
470 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
472 source_location saved_loc
= lhs
->src_loc
;
474 _cpp_pop_buffer (pfile
);
475 _cpp_backup_tokens (pfile
, 1);
478 /* We have to remove the PASTE_LEFT flag from the old lhs, but
479 we want to keep the new location. */
482 lhs
->src_loc
= saved_loc
;
483 lhs
->flags
&= ~PASTE_LEFT
;
485 /* Mandatory error for all apart from assembler. */
486 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
487 cpp_error (pfile
, CPP_DL_ERROR
,
488 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
489 buf
, cpp_token_as_text (pfile
, rhs
));
494 _cpp_pop_buffer (pfile
);
498 /* Handles an arbitrarily long sequence of ## operators, with initial
499 operand LHS. This implementation is left-associative,
500 non-recursive, and finishes a paste before handling succeeding
501 ones. If a paste fails, we back up to the RHS of the failing ##
502 operator before pushing the context containing the result of prior
503 successful pastes, with the effect that the RHS appears in the
504 output stream after the pasted LHS normally. */
506 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
508 const cpp_token
*rhs
;
509 cpp_context
*context
= pfile
->context
;
513 /* Take the token directly from the current context. We can do
514 this, because we are in the replacement list of either an
515 object-like macro, or a function-like macro with arguments
516 inserted. In either case, the constraints to #define
517 guarantee we have at least one more token. */
518 if (context
->direct_p
)
519 rhs
= FIRST (context
).token
++;
521 rhs
= *FIRST (context
).ptoken
++;
523 if (rhs
->type
== CPP_PADDING
)
525 if (rhs
->flags
& PASTE_LEFT
)
528 if (!paste_tokens (pfile
, &lhs
, rhs
))
531 while (rhs
->flags
& PASTE_LEFT
);
533 /* Put the resulting token in its own context. */
534 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
537 /* Returns TRUE if the number of arguments ARGC supplied in an
538 invocation of the MACRO referenced by NODE is valid. An empty
539 invocation to a macro with no parameters should pass ARGC as zero.
541 Note that MACRO cannot necessarily be deduced from NODE, in case
542 NODE was redefined whilst collecting arguments. */
544 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
546 if (argc
== macro
->paramc
)
549 if (argc
< macro
->paramc
)
551 /* As an extension, a rest argument is allowed to not appear in
552 the invocation at all.
553 e.g. #define debug(format, args...) something
556 This is exactly the same as if there had been an empty rest
557 argument - debug("string", ). */
559 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
561 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
562 cpp_error (pfile
, CPP_DL_PEDWARN
,
563 "ISO C99 requires rest arguments to be used");
567 cpp_error (pfile
, CPP_DL_ERROR
,
568 "macro \"%s\" requires %u arguments, but only %u given",
569 NODE_NAME (node
), macro
->paramc
, argc
);
572 cpp_error (pfile
, CPP_DL_ERROR
,
573 "macro \"%s\" passed %u arguments, but takes just %u",
574 NODE_NAME (node
), argc
, macro
->paramc
);
579 /* Reads and returns the arguments to a function-like macro
580 invocation. Assumes the opening parenthesis has been processed.
581 If there is an error, emits an appropriate diagnostic and returns
582 NULL. Each argument is terminated by a CPP_EOF token, for the
583 future benefit of expand_arg(). If there are any deferred
584 #pragma directives among macro arguments, store pointers to the
585 CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer. */
587 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
,
588 _cpp_buff
**pragma_buff
)
590 _cpp_buff
*buff
, *base_buff
;
592 macro_arg
*args
, *arg
;
593 const cpp_token
*token
;
596 macro
= node
->value
.macro
;
598 argc
= macro
->paramc
;
601 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
602 + sizeof (macro_arg
)));
604 args
= (macro_arg
*) buff
->base
;
605 memset (args
, 0, argc
* sizeof (macro_arg
));
606 buff
->cur
= (unsigned char *) &args
[argc
];
607 arg
= args
, argc
= 0;
609 /* Collect the tokens making up each argument. We don't yet know
610 how many arguments have been supplied, whether too many or too
611 few. Hence the slightly bizarre usage of "argc" and "arg". */
614 unsigned int paren_depth
= 0;
615 unsigned int ntokens
= 0;
618 arg
->first
= (const cpp_token
**) buff
->cur
;
622 /* Require space for 2 new tokens (including a CPP_EOF). */
623 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
625 buff
= _cpp_append_extend_buff (pfile
, buff
,
626 1000 * sizeof (cpp_token
*));
627 arg
->first
= (const cpp_token
**) buff
->cur
;
630 token
= cpp_get_token (pfile
);
632 if (token
->type
== CPP_PADDING
)
634 /* Drop leading padding. */
638 else if (token
->type
== CPP_OPEN_PAREN
)
640 else if (token
->type
== CPP_CLOSE_PAREN
)
642 if (paren_depth
-- == 0)
645 else if (token
->type
== CPP_COMMA
)
647 /* A comma does not terminate an argument within
648 parentheses or as part of a variable argument. */
650 && ! (macro
->variadic
&& argc
== macro
->paramc
))
653 else if (token
->type
== CPP_EOF
654 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
656 else if (token
->type
== CPP_PRAGMA
)
658 cpp_token
*newtok
= _cpp_temp_token (pfile
);
660 /* CPP_PRAGMA token lives in directive_result, which will
661 be overwritten on the next directive. */
666 if (*pragma_buff
== NULL
667 || BUFF_ROOM (*pragma_buff
) < sizeof (cpp_token
*))
670 if (*pragma_buff
== NULL
)
672 = _cpp_get_buff (pfile
, 32 * sizeof (cpp_token
*));
677 = _cpp_get_buff (pfile
,
678 (BUFF_FRONT (*pragma_buff
)
679 - (*pragma_buff
)->base
) * 2);
680 (*pragma_buff
)->next
= next
;
683 *(const cpp_token
**) BUFF_FRONT (*pragma_buff
) = token
;
684 BUFF_FRONT (*pragma_buff
) += sizeof (cpp_token
*);
685 if (token
->type
== CPP_PRAGMA_EOL
)
687 token
= cpp_get_token (pfile
);
689 while (token
->type
!= CPP_EOF
);
691 /* In deferred pragmas parsing_args and prevent_expansion
692 had been changed, reset it. */
693 pfile
->state
.parsing_args
= 2;
694 pfile
->state
.prevent_expansion
= 1;
696 if (token
->type
== CPP_EOF
)
702 arg
->first
[ntokens
++] = token
;
705 /* Drop trailing padding. */
706 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
709 arg
->count
= ntokens
;
710 arg
->first
[ntokens
] = &pfile
->eof
;
712 /* Terminate the argument. Excess arguments loop back and
713 overwrite the final legitimate argument, before failing. */
714 if (argc
<= macro
->paramc
)
716 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
717 if (argc
!= macro
->paramc
)
721 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
723 if (token
->type
== CPP_EOF
)
725 /* We still need the CPP_EOF to end directives, and to end
726 pre-expansion of a macro argument. Step back is not
727 unconditional, since we don't want to return a CPP_EOF to our
728 callers at the end of an -include-d file. */
729 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
730 _cpp_backup_tokens (pfile
, 1);
731 cpp_error (pfile
, CPP_DL_ERROR
,
732 "unterminated argument list invoking macro \"%s\"",
737 /* A single empty argument is counted as no argument. */
738 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
740 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
742 /* GCC has special semantics for , ## b where b is a varargs
743 parameter: we remove the comma if b was omitted entirely.
744 If b was merely an empty argument, the comma is retained.
745 If the macro takes just one (varargs) parameter, then we
746 retain the comma only if we are standards conforming.
748 If FIRST is NULL replace_args () swallows the comma. */
749 if (macro
->variadic
&& (argc
< macro
->paramc
750 || (argc
== 1 && args
[0].count
== 0
751 && !CPP_OPTION (pfile
, std
))))
752 args
[macro
->paramc
- 1].first
= NULL
;
757 /* An error occurred. */
758 _cpp_release_buff (pfile
, base_buff
);
762 /* Search for an opening parenthesis to the macro of NODE, in such a
763 way that, if none is found, we don't lose the information in any
764 intervening padding tokens. If we find the parenthesis, collect
765 the arguments and return the buffer containing them. PRAGMA_BUFF
766 argument is the same as in collect_args. */
768 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
,
769 _cpp_buff
**pragma_buff
)
771 const cpp_token
*token
, *padding
= NULL
;
775 token
= cpp_get_token (pfile
);
776 if (token
->type
!= CPP_PADDING
)
779 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
783 if (token
->type
== CPP_OPEN_PAREN
)
785 pfile
->state
.parsing_args
= 2;
786 return collect_args (pfile
, node
, pragma_buff
);
789 /* CPP_EOF can be the end of macro arguments, or the end of the
790 file. We mustn't back up over the latter. Ugh. */
791 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
793 /* Back up. We may have skipped padding, in which case backing
794 up more than one token when expanding macros is in general
795 too difficult. We re-insert it in its own context. */
796 _cpp_backup_tokens (pfile
, 1);
798 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
804 /* Push the context of a macro with hash entry NODE onto the context
805 stack. If we can successfully expand the macro, we push a context
806 containing its yet-to-be-rescanned replacement list and return one.
807 If there were additionally any unexpanded deferred #pragma directives
808 among macro arguments, push another context containing the
809 pragma tokens before the yet-to-be-rescanned replacement list
810 and return two. Otherwise, we don't push a context and return zero. */
812 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
,
813 const cpp_token
*result
)
815 /* The presence of a macro invalidates a file's controlling macro. */
816 pfile
->mi_valid
= false;
818 pfile
->state
.angled_headers
= false;
820 if ((node
->flags
& NODE_BUILTIN
) && !(node
->flags
& NODE_USED
))
822 node
->flags
|= NODE_USED
;
823 if (pfile
->cb
.used_define
)
824 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
827 /* Handle standard macros. */
828 if (! (node
->flags
& NODE_BUILTIN
))
830 cpp_macro
*macro
= node
->value
.macro
;
831 _cpp_buff
*pragma_buff
= NULL
;
837 pfile
->state
.prevent_expansion
++;
838 pfile
->keep_tokens
++;
839 pfile
->state
.parsing_args
= 1;
840 buff
= funlike_invocation_p (pfile
, node
, &pragma_buff
);
841 pfile
->state
.parsing_args
= 0;
842 pfile
->keep_tokens
--;
843 pfile
->state
.prevent_expansion
--;
847 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
848 cpp_error (pfile
, CPP_DL_WARNING
,
849 "function-like macro \"%s\" must be used with arguments in traditional C",
853 _cpp_release_buff (pfile
, pragma_buff
);
858 if (macro
->paramc
> 0)
859 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
860 _cpp_release_buff (pfile
, buff
);
863 /* Disable the macro within its expansion. */
864 node
->flags
|= NODE_DISABLED
;
866 if (!(node
->flags
& NODE_USED
))
868 node
->flags
|= NODE_USED
;
869 if (pfile
->cb
.used_define
)
870 pfile
->cb
.used_define (pfile
, pfile
->directive_line
, node
);
875 if (macro
->paramc
== 0)
876 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
, macro
->count
);
880 if (!pfile
->state
.in_directive
)
881 _cpp_push_token_context (pfile
, NULL
,
882 padding_token (pfile
, result
), 1);
885 _cpp_buff
*tail
= pragma_buff
->next
;
886 pragma_buff
->next
= NULL
;
887 push_ptoken_context (pfile
, NULL
, pragma_buff
,
888 (const cpp_token
**) pragma_buff
->base
,
889 ((const cpp_token
**) BUFF_FRONT (pragma_buff
)
890 - (const cpp_token
**) pragma_buff
->base
));
893 while (pragma_buff
!= NULL
);
900 /* Handle built-in macros and the _Pragma operator. */
901 return builtin_macro (pfile
, node
);
904 /* Replace the parameters in a function-like macro of NODE with the
905 actual ARGS, and place the result in a newly pushed token context.
906 Expand each argument before replacing, unless it is operated upon
907 by the # or ## operators. */
909 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
, macro_arg
*args
)
911 unsigned int i
, total
;
912 const cpp_token
*src
, *limit
;
913 const cpp_token
**dest
, **first
;
917 /* First, fully macro-expand arguments, calculating the number of
918 tokens in the final expansion as we go. The ordering of the if
919 statements below is subtle; we must handle stringification before
921 total
= macro
->count
;
922 limit
= macro
->exp
.tokens
+ macro
->count
;
924 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
925 if (src
->type
== CPP_MACRO_ARG
)
927 /* Leading and trailing padding tokens. */
930 /* We have an argument. If it is not being stringified or
931 pasted it is macro-replaced before insertion. */
932 arg
= &args
[src
->val
.arg_no
- 1];
934 if (src
->flags
& STRINGIFY_ARG
)
936 if (!arg
->stringified
)
937 arg
->stringified
= stringify_arg (pfile
, arg
);
939 else if ((src
->flags
& PASTE_LEFT
)
940 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
941 total
+= arg
->count
- 1;
945 expand_arg (pfile
, arg
);
946 total
+= arg
->expanded_count
- 1;
950 /* Now allocate space for the expansion, copy the tokens and replace
952 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
953 first
= (const cpp_token
**) buff
->base
;
956 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
959 const cpp_token
**from
, **paste_flag
;
961 if (src
->type
!= CPP_MACRO_ARG
)
968 arg
= &args
[src
->val
.arg_no
- 1];
969 if (src
->flags
& STRINGIFY_ARG
)
970 count
= 1, from
= &arg
->stringified
;
971 else if (src
->flags
& PASTE_LEFT
)
972 count
= arg
->count
, from
= arg
->first
;
973 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
975 count
= arg
->count
, from
= arg
->first
;
978 if (dest
[-1]->type
== CPP_COMMA
980 && src
->val
.arg_no
== macro
->paramc
)
982 /* Swallow a pasted comma if from == NULL, otherwise
983 drop the paste flag. */
987 paste_flag
= dest
- 1;
989 /* Remove the paste flag if the RHS is a placemarker. */
991 paste_flag
= dest
- 1;
995 count
= arg
->expanded_count
, from
= arg
->expanded
;
997 /* Padding on the left of an argument (unless RHS of ##). */
998 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
999 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
1000 *dest
++ = padding_token (pfile
, src
);
1004 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
1007 /* With a non-empty argument on the LHS of ##, the last
1008 token should be flagged PASTE_LEFT. */
1009 if (src
->flags
& PASTE_LEFT
)
1010 paste_flag
= dest
- 1;
1013 /* Avoid paste on RHS (even case count == 0). */
1014 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
1015 *dest
++ = &pfile
->avoid_paste
;
1017 /* Add a new paste flag, or remove an unwanted one. */
1020 cpp_token
*token
= _cpp_temp_token (pfile
);
1021 token
->type
= (*paste_flag
)->type
;
1022 token
->val
= (*paste_flag
)->val
;
1023 if (src
->flags
& PASTE_LEFT
)
1024 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
1026 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
1027 *paste_flag
= token
;
1031 /* Free the expanded arguments. */
1032 for (i
= 0; i
< macro
->paramc
; i
++)
1033 if (args
[i
].expanded
)
1034 free (args
[i
].expanded
);
1036 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
1039 /* Return a special padding token, with padding inherited from SOURCE. */
1040 static const cpp_token
*
1041 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
1043 cpp_token
*result
= _cpp_temp_token (pfile
);
1045 result
->type
= CPP_PADDING
;
1047 /* Data in GCed data structures cannot be made const so far, so we
1048 need a cast here. */
1049 result
->val
.source
= (cpp_token
*) source
;
1054 /* Get a new uninitialized context. Create a new one if we cannot
1055 re-use an old one. */
1056 static cpp_context
*
1057 next_context (cpp_reader
*pfile
)
1059 cpp_context
*result
= pfile
->context
->next
;
1063 result
= XNEW (cpp_context
);
1064 result
->prev
= pfile
->context
;
1066 pfile
->context
->next
= result
;
1069 pfile
->context
= result
;
1073 /* Push a list of pointers to tokens. */
1075 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
1076 const cpp_token
**first
, unsigned int count
)
1078 cpp_context
*context
= next_context (pfile
);
1080 context
->direct_p
= false;
1081 context
->macro
= macro
;
1082 context
->buff
= buff
;
1083 FIRST (context
).ptoken
= first
;
1084 LAST (context
).ptoken
= first
+ count
;
1087 /* Push a list of tokens. */
1089 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1090 const cpp_token
*first
, unsigned int count
)
1092 cpp_context
*context
= next_context (pfile
);
1094 context
->direct_p
= true;
1095 context
->macro
= macro
;
1096 context
->buff
= NULL
;
1097 FIRST (context
).token
= first
;
1098 LAST (context
).token
= first
+ count
;
1101 /* Push a traditional macro's replacement text. */
1103 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1104 const uchar
*start
, size_t len
)
1106 cpp_context
*context
= next_context (pfile
);
1108 context
->direct_p
= true;
1109 context
->macro
= macro
;
1110 context
->buff
= NULL
;
1111 CUR (context
) = start
;
1112 RLIMIT (context
) = start
+ len
;
1113 macro
->flags
|= NODE_DISABLED
;
1116 /* Expand an argument ARG before replacing parameters in a
1117 function-like macro. This works by pushing a context with the
1118 argument's tokens, and then expanding that into a temporary buffer
1119 as if it were a normal part of the token stream. collect_args()
1120 has terminated the argument's tokens with a CPP_EOF so that we know
1121 when we have fully expanded the argument. */
1123 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
1125 unsigned int capacity
;
1126 bool saved_warn_trad
;
1128 if (arg
->count
== 0)
1131 /* Don't warn about funlike macros when pre-expanding. */
1132 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
1133 CPP_WTRADITIONAL (pfile
) = 0;
1135 /* Loop, reading in the arguments. */
1137 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
1139 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
1142 const cpp_token
*token
;
1144 if (arg
->expanded_count
+ 1 >= capacity
)
1147 arg
->expanded
= XRESIZEVEC (const cpp_token
*, arg
->expanded
,
1151 token
= cpp_get_token (pfile
);
1153 if (token
->type
== CPP_EOF
)
1156 arg
->expanded
[arg
->expanded_count
++] = token
;
1159 _cpp_pop_context (pfile
);
1161 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
1164 /* Pop the current context off the stack, re-enabling the macro if the
1165 context represented a macro's replacement list. The context
1166 structure is not freed so that we can re-use it later. */
1168 _cpp_pop_context (cpp_reader
*pfile
)
1170 cpp_context
*context
= pfile
->context
;
1173 context
->macro
->flags
&= ~NODE_DISABLED
;
1176 _cpp_release_buff (pfile
, context
->buff
);
1178 pfile
->context
= context
->prev
;
1181 /* External routine to get a token. Also used nearly everywhere
1182 internally, except for places where we know we can safely call
1183 _cpp_lex_token directly, such as lexing a directive name.
1185 Macro expansions and directives are transparently handled,
1186 including entering included files. Thus tokens are post-macro
1187 expansion, and after any intervening directives. External callers
1188 see CPP_EOF only at EOF. Internal callers also see it when meeting
1189 a directive inside a macro call, when at the end of a directive and
1190 state.in_directive is still 1, and at the end of argument
1193 cpp_get_token (cpp_reader
*pfile
)
1195 const cpp_token
*result
;
1196 bool can_set
= pfile
->set_invocation_location
;
1197 pfile
->set_invocation_location
= false;
1202 cpp_context
*context
= pfile
->context
;
1204 /* Context->prev == 0 <=> base context. */
1206 result
= _cpp_lex_token (pfile
);
1207 else if (FIRST (context
).token
!= LAST (context
).token
)
1209 if (context
->direct_p
)
1210 result
= FIRST (context
).token
++;
1212 result
= *FIRST (context
).ptoken
++;
1214 if (result
->flags
& PASTE_LEFT
)
1216 paste_all_tokens (pfile
, result
);
1217 if (pfile
->state
.in_directive
)
1219 return padding_token (pfile
, result
);
1224 _cpp_pop_context (pfile
);
1225 if (pfile
->state
.in_directive
)
1227 return &pfile
->avoid_paste
;
1230 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1233 if (result
->type
!= CPP_NAME
)
1236 node
= result
->val
.node
;
1238 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1241 if (!(node
->flags
& NODE_DISABLED
))
1244 /* If not in a macro context, and we're going to start an
1245 expansion, record the location. */
1246 if (can_set
&& !context
->macro
)
1247 pfile
->invocation_location
= result
->src_loc
;
1248 if (pfile
->state
.prevent_expansion
)
1250 ret
= enter_macro_context (pfile
, node
, result
);
1253 if (pfile
->state
.in_directive
|| ret
== 2)
1255 return padding_token (pfile
, result
);
1260 /* Flag this token as always unexpandable. FIXME: move this
1261 to collect_args()?. */
1262 cpp_token
*t
= _cpp_temp_token (pfile
);
1263 t
->type
= result
->type
;
1264 t
->flags
= result
->flags
| NO_EXPAND
;
1265 t
->val
= result
->val
;
1275 /* Like cpp_get_token, but also returns a location separate from the
1276 one provided by the returned token. LOC is an out parameter; *LOC
1277 is set to the location "as expected by the user". This matters
1278 when a token results from macro expansion -- the token's location
1279 will indicate where the macro is defined, but *LOC will be the
1280 location of the start of the expansion. */
1282 cpp_get_token_with_location (cpp_reader
*pfile
, source_location
*loc
)
1284 const cpp_token
*result
;
1286 pfile
->set_invocation_location
= true;
1287 result
= cpp_get_token (pfile
);
1288 if (pfile
->context
->macro
)
1289 *loc
= pfile
->invocation_location
;
1291 *loc
= result
->src_loc
;
1296 /* Returns true if we're expanding an object-like macro that was
1297 defined in a system header. Just checks the macro at the top of
1298 the stack. Used for diagnostic suppression. */
1300 cpp_sys_macro_p (cpp_reader
*pfile
)
1302 cpp_hashnode
*node
= pfile
->context
->macro
;
1304 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1307 /* Read each token in, until end of the current file. Directives are
1308 transparently processed. */
1310 cpp_scan_nooutput (cpp_reader
*pfile
)
1312 /* Request a CPP_EOF token at the end of this file, rather than
1313 transparently continuing with the including file. */
1314 pfile
->buffer
->return_at_eof
= true;
1316 pfile
->state
.discarding_output
++;
1317 pfile
->state
.prevent_expansion
++;
1319 if (CPP_OPTION (pfile
, traditional
))
1320 while (_cpp_read_logical_line_trad (pfile
))
1323 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1326 pfile
->state
.discarding_output
--;
1327 pfile
->state
.prevent_expansion
--;
1330 /* Step back one (or more) tokens. Can only step back more than 1 if
1331 they are from the lexer, and not from macro expansion. */
1333 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
1335 if (pfile
->context
->prev
== NULL
)
1337 pfile
->lookaheads
+= count
;
1341 if (pfile
->cur_token
== pfile
->cur_run
->base
1342 /* Possible with -fpreprocessed and no leading #line. */
1343 && pfile
->cur_run
->prev
!= NULL
)
1345 pfile
->cur_run
= pfile
->cur_run
->prev
;
1346 pfile
->cur_token
= pfile
->cur_run
->limit
;
1354 if (pfile
->context
->direct_p
)
1355 FIRST (pfile
->context
).token
--;
1357 FIRST (pfile
->context
).ptoken
--;
1361 /* #define directive parsing and handling. */
1363 /* Returns nonzero if a macro redefinition warning is required. */
1365 warn_of_redefinition (cpp_reader
*pfile
, const cpp_hashnode
*node
,
1366 const cpp_macro
*macro2
)
1368 const cpp_macro
*macro1
;
1371 /* Some redefinitions need to be warned about regardless. */
1372 if (node
->flags
& NODE_WARN
)
1375 /* Redefinition of a macro is allowed if and only if the old and new
1376 definitions are the same. (6.10.3 paragraph 2). */
1377 macro1
= node
->value
.macro
;
1379 /* Don't check count here as it can be different in valid
1380 traditional redefinitions with just whitespace differences. */
1381 if (macro1
->paramc
!= macro2
->paramc
1382 || macro1
->fun_like
!= macro2
->fun_like
1383 || macro1
->variadic
!= macro2
->variadic
)
1386 /* Check parameter spellings. */
1387 for (i
= 0; i
< macro1
->paramc
; i
++)
1388 if (macro1
->params
[i
] != macro2
->params
[i
])
1391 /* Check the replacement text or tokens. */
1392 if (CPP_OPTION (pfile
, traditional
))
1393 return _cpp_expansions_different_trad (macro1
, macro2
);
1395 if (macro1
->count
!= macro2
->count
)
1398 for (i
= 0; i
< macro1
->count
; i
++)
1399 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
1405 /* Free the definition of hashnode H. */
1407 _cpp_free_definition (cpp_hashnode
*h
)
1409 /* Macros and assertions no longer have anything to free. */
1411 /* Clear builtin flag in case of redefinition. */
1412 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
| NODE_USED
);
1415 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1416 zero on success, nonzero if the parameter is a duplicate. */
1418 _cpp_save_parameter (cpp_reader
*pfile
, cpp_macro
*macro
, cpp_hashnode
*node
)
1421 /* Constraint 6.10.3.6 - duplicate parameter names. */
1422 if (node
->flags
& NODE_MACRO_ARG
)
1424 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
1429 if (BUFF_ROOM (pfile
->a_buff
)
1430 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1431 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1433 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1434 node
->flags
|= NODE_MACRO_ARG
;
1435 len
= macro
->paramc
* sizeof (union _cpp_hashnode_value
);
1436 if (len
> pfile
->macro_buffer_len
)
1438 pfile
->macro_buffer
= XRESIZEVEC (unsigned char, pfile
->macro_buffer
,
1440 pfile
->macro_buffer_len
= len
;
1442 ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[macro
->paramc
- 1]
1445 node
->value
.arg_index
= macro
->paramc
;
1449 /* Check the syntax of the parameters in a MACRO definition. Returns
1450 false if an error occurs. */
1452 parse_params (cpp_reader
*pfile
, cpp_macro
*macro
)
1454 unsigned int prev_ident
= 0;
1458 const cpp_token
*token
= _cpp_lex_token (pfile
);
1460 switch (token
->type
)
1463 /* Allow/ignore comments in parameter lists if we are
1464 preserving comments in macro expansions. */
1465 if (token
->type
== CPP_COMMENT
1466 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1469 cpp_error (pfile
, CPP_DL_ERROR
,
1470 "\"%s\" may not appear in macro parameter list",
1471 cpp_token_as_text (pfile
, token
));
1477 cpp_error (pfile
, CPP_DL_ERROR
,
1478 "macro parameters must be comma-separated");
1483 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
))
1487 case CPP_CLOSE_PAREN
:
1488 if (prev_ident
|| macro
->paramc
== 0)
1491 /* Fall through to pick up the error. */
1495 cpp_error (pfile
, CPP_DL_ERROR
, "parameter name missing");
1502 macro
->variadic
= 1;
1505 _cpp_save_parameter (pfile
, macro
,
1506 pfile
->spec_nodes
.n__VA_ARGS__
);
1507 pfile
->state
.va_args_ok
= 1;
1508 if (! CPP_OPTION (pfile
, c99
)
1509 && CPP_OPTION (pfile
, pedantic
)
1510 && CPP_OPTION (pfile
, warn_variadic_macros
))
1511 cpp_error (pfile
, CPP_DL_PEDWARN
,
1512 "anonymous variadic macros were introduced in C99");
1514 else if (CPP_OPTION (pfile
, pedantic
)
1515 && CPP_OPTION (pfile
, warn_variadic_macros
))
1516 cpp_error (pfile
, CPP_DL_PEDWARN
,
1517 "ISO C does not permit named variadic macros");
1519 /* We're at the end, and just expect a closing parenthesis. */
1520 token
= _cpp_lex_token (pfile
);
1521 if (token
->type
== CPP_CLOSE_PAREN
)
1526 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' in macro parameter list");
1532 /* Allocate room for a token from a macro's replacement list. */
1534 alloc_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1536 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1537 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1539 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1542 /* Lex a token from the expansion of MACRO, but mark parameters as we
1543 find them and warn of traditional stringification. */
1545 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1547 cpp_token
*token
, *saved_cur_token
;
1549 saved_cur_token
= pfile
->cur_token
;
1550 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1551 token
= _cpp_lex_direct (pfile
);
1552 pfile
->cur_token
= saved_cur_token
;
1554 /* Is this a parameter? */
1555 if (token
->type
== CPP_NAME
1556 && (token
->val
.node
->flags
& NODE_MACRO_ARG
) != 0)
1558 token
->type
= CPP_MACRO_ARG
;
1559 token
->val
.arg_no
= token
->val
.node
->value
.arg_index
;
1561 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1562 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1563 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1569 create_iso_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
1572 const cpp_token
*ctoken
;
1573 bool following_paste_op
= false;
1574 const char *paste_op_error_msg
=
1575 N_("'##' cannot appear at either end of a macro expansion");
1577 /* Get the first token of the expansion (or the '(' of a
1578 function-like macro). */
1579 ctoken
= _cpp_lex_token (pfile
);
1581 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1583 bool ok
= parse_params (pfile
, macro
);
1584 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1588 /* Success. Commit or allocate the parameter array. */
1589 if (pfile
->hash_table
->alloc_subobject
)
1591 cpp_hashnode
**params
=
1592 (cpp_hashnode
**) pfile
->hash_table
->alloc_subobject
1593 (sizeof (cpp_hashnode
*) * macro
->paramc
);
1594 memcpy (params
, macro
->params
,
1595 sizeof (cpp_hashnode
*) * macro
->paramc
);
1596 macro
->params
= params
;
1599 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1600 macro
->fun_like
= 1;
1602 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1604 /* While ISO C99 requires whitespace before replacement text
1605 in a macro definition, ISO C90 with TC1 allows there characters
1606 from the basic source character set. */
1607 if (CPP_OPTION (pfile
, c99
))
1608 cpp_error (pfile
, CPP_DL_PEDWARN
,
1609 "ISO C99 requires whitespace after the macro name");
1612 int warntype
= CPP_DL_WARNING
;
1613 switch (ctoken
->type
)
1617 case CPP_OBJC_STRING
:
1618 /* '@' is not in basic character set. */
1619 warntype
= CPP_DL_PEDWARN
;
1622 /* Basic character set sans letters, digits and _. */
1623 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1624 ctoken
->val
.str
.text
[0]) == NULL
)
1625 warntype
= CPP_DL_PEDWARN
;
1628 /* All other tokens start with a character from basic
1632 cpp_error (pfile
, warntype
,
1633 "missing whitespace after the macro name");
1637 if (macro
->fun_like
)
1638 token
= lex_expansion_token (pfile
, macro
);
1641 token
= alloc_expansion_token (pfile
, macro
);
1647 /* Check the stringifying # constraint 6.10.3.2.1 of
1648 function-like macros when lexing the subsequent token. */
1649 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1651 if (token
->type
== CPP_MACRO_ARG
)
1653 token
->flags
&= ~PREV_WHITE
;
1654 token
->flags
|= STRINGIFY_ARG
;
1655 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1656 token
[-1] = token
[0];
1659 /* Let assembler get away with murder. */
1660 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1662 cpp_error (pfile
, CPP_DL_ERROR
,
1663 "'#' is not followed by a macro parameter");
1668 if (token
->type
== CPP_EOF
)
1670 /* Paste operator constraint 6.10.3.3.1:
1671 Token-paste ##, can appear in both object-like and
1672 function-like macros, but not at the end. */
1673 if (following_paste_op
)
1675 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
1681 /* Paste operator constraint 6.10.3.3.1. */
1682 if (token
->type
== CPP_PASTE
)
1684 /* Token-paste ##, can appear in both object-like and
1685 function-like macros, but not at the beginning. */
1686 if (macro
->count
== 1)
1688 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
1693 token
[-1].flags
|= PASTE_LEFT
;
1696 following_paste_op
= (token
->type
== CPP_PASTE
);
1697 token
= lex_expansion_token (pfile
, macro
);
1700 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1701 macro
->traditional
= 0;
1703 /* Don't count the CPP_EOF. */
1706 /* Clear whitespace on first token for warn_of_redefinition(). */
1708 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
1710 /* Commit or allocate the memory. */
1711 if (pfile
->hash_table
->alloc_subobject
)
1714 (cpp_token
*) pfile
->hash_table
->alloc_subobject (sizeof (cpp_token
)
1716 memcpy (tokns
, macro
->exp
.tokens
, sizeof (cpp_token
) * macro
->count
);
1717 macro
->exp
.tokens
= tokns
;
1720 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
1725 /* Parse a macro and save its expansion. Returns nonzero on success. */
1727 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
1733 if (pfile
->hash_table
->alloc_subobject
)
1734 macro
= (cpp_macro
*) pfile
->hash_table
->alloc_subobject
1735 (sizeof (cpp_macro
));
1737 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1738 macro
->line
= pfile
->directive_line
;
1741 macro
->variadic
= 0;
1742 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
1744 macro
->fun_like
= 0;
1745 /* To suppress some diagnostics. */
1746 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
1748 if (CPP_OPTION (pfile
, traditional
))
1749 ok
= _cpp_create_trad_definition (pfile
, macro
);
1752 ok
= create_iso_definition (pfile
, macro
);
1754 /* We set the type for SEEN_EOL() in directives.c.
1756 Longer term we should lex the whole line before coming here,
1757 and just copy the expansion. */
1759 /* Stop the lexer accepting __VA_ARGS__. */
1760 pfile
->state
.va_args_ok
= 0;
1763 /* Clear the fast argument lookup indices. */
1764 for (i
= macro
->paramc
; i
-- > 0; )
1766 struct cpp_hashnode
*node
= macro
->params
[i
];
1767 node
->flags
&= ~ NODE_MACRO_ARG
;
1768 node
->value
= ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[i
];
1774 if (node
->type
== NT_MACRO
)
1776 if (CPP_OPTION (pfile
, warn_unused_macros
))
1777 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
1779 if (warn_of_redefinition (pfile
, node
, macro
))
1781 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, pfile
->directive_line
, 0,
1782 "\"%s\" redefined", NODE_NAME (node
));
1784 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1785 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
,
1786 node
->value
.macro
->line
, 0,
1787 "this is the location of the previous definition");
1791 if (node
->type
!= NT_VOID
)
1792 _cpp_free_definition (node
);
1794 /* Enter definition in hash table. */
1795 node
->type
= NT_MACRO
;
1796 node
->value
.macro
= macro
;
1797 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_"))
1798 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_FORMAT_MACROS")
1799 /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1800 in the C standard, as something that one must use in C++.
1801 However DR#593 indicates that these aren't actually mentioned
1802 in the C++ standard. We special-case them anyway. */
1803 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_LIMIT_MACROS")
1804 && ustrcmp (NODE_NAME (node
), (const uchar
*) "__STDC_CONSTANT_MACROS"))
1805 node
->flags
|= NODE_WARN
;
1810 /* Warn if a token in STRING matches one of a function-like MACRO's
1813 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
1814 const cpp_string
*string
)
1816 unsigned int i
, len
;
1817 const uchar
*p
, *q
, *limit
;
1819 /* Loop over the string. */
1820 limit
= string
->text
+ string
->len
- 1;
1821 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
1823 /* Find the start of an identifier. */
1824 while (p
< limit
&& !is_idstart (*p
))
1827 /* Find the end of the identifier. */
1829 while (q
< limit
&& is_idchar (*q
))
1834 /* Loop over the function macro arguments to see if the
1835 identifier inside the string matches one of them. */
1836 for (i
= 0; i
< macro
->paramc
; i
++)
1838 const cpp_hashnode
*node
= macro
->params
[i
];
1840 if (NODE_LEN (node
) == len
1841 && !memcmp (p
, NODE_NAME (node
), len
))
1843 cpp_error (pfile
, CPP_DL_WARNING
,
1844 "macro argument \"%s\" would be stringified in traditional C",
1852 /* Returns the name, arguments and expansion of a macro, in a format
1853 suitable to be read back in again, and therefore also for DWARF 2
1854 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1855 Caller is expected to generate the "#define" bit if needed. The
1856 returned text is temporary, and automatically freed later. */
1857 const unsigned char *
1858 cpp_macro_definition (cpp_reader
*pfile
, const cpp_hashnode
*node
)
1860 unsigned int i
, len
;
1861 const cpp_macro
*macro
= node
->value
.macro
;
1862 unsigned char *buffer
;
1864 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1866 cpp_error (pfile
, CPP_DL_ICE
,
1867 "invalid hash type %d in cpp_macro_definition", node
->type
);
1871 /* Calculate length. */
1872 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
1873 if (macro
->fun_like
)
1875 len
+= 4; /* "()" plus possible final ".." of named
1876 varargs (we have + 1 below). */
1877 for (i
= 0; i
< macro
->paramc
; i
++)
1878 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1881 /* This should match below where we fill in the buffer. */
1882 if (CPP_OPTION (pfile
, traditional
))
1883 len
+= _cpp_replacement_text_len (macro
);
1886 for (i
= 0; i
< macro
->count
; i
++)
1888 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1890 if (token
->type
== CPP_MACRO_ARG
)
1891 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1893 len
+= cpp_token_len (token
);
1895 if (token
->flags
& STRINGIFY_ARG
)
1897 if (token
->flags
& PASTE_LEFT
)
1898 len
+= 3; /* " ##" */
1899 if (token
->flags
& PREV_WHITE
)
1904 if (len
> pfile
->macro_buffer_len
)
1906 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
1907 pfile
->macro_buffer
, len
);
1908 pfile
->macro_buffer_len
= len
;
1911 /* Fill in the buffer. Start with the macro name. */
1912 buffer
= pfile
->macro_buffer
;
1913 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1914 buffer
+= NODE_LEN (node
);
1916 /* Parameter names. */
1917 if (macro
->fun_like
)
1920 for (i
= 0; i
< macro
->paramc
; i
++)
1922 cpp_hashnode
*param
= macro
->params
[i
];
1924 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1926 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1927 buffer
+= NODE_LEN (param
);
1930 if (i
+ 1 < macro
->paramc
)
1931 /* Don't emit a space after the comma here; we're trying
1932 to emit a Dwarf-friendly definition, and the Dwarf spec
1933 forbids spaces in the argument list. */
1935 else if (macro
->variadic
)
1936 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1941 /* The Dwarf spec requires a space after the macro name, even if the
1942 definition is the empty string. */
1945 if (CPP_OPTION (pfile
, traditional
))
1946 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
1947 else if (macro
->count
)
1948 /* Expansion tokens. */
1950 for (i
= 0; i
< macro
->count
; i
++)
1952 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1954 if (token
->flags
& PREV_WHITE
)
1956 if (token
->flags
& STRINGIFY_ARG
)
1959 if (token
->type
== CPP_MACRO_ARG
)
1962 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]),
1963 NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]));
1964 buffer
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1967 buffer
= cpp_spell_token (pfile
, token
, buffer
, false);
1969 if (token
->flags
& PASTE_LEFT
)
1974 /* Next has PREV_WHITE; see _cpp_create_definition. */
1980 return pfile
->macro_buffer
;