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 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23 In other words, you are welcome to use, share and improve this program.
24 You are forbidden to forbid anyone else to use, share and improve
25 what you give them. Help stamp out software-hoarding! */
32 typedef struct macro_arg macro_arg
;
35 const cpp_token
**first
; /* First token in unexpanded argument. */
36 const cpp_token
**expanded
; /* Macro-expanded argument. */
37 const cpp_token
*stringified
; /* Stringified argument. */
38 unsigned int count
; /* # of tokens in argument. */
39 unsigned int expanded_count
; /* # of tokens in expanded argument. */
42 /* Macro expansion. */
44 static int enter_macro_context (cpp_reader
*, cpp_hashnode
*);
45 static int builtin_macro (cpp_reader
*, cpp_hashnode
*);
46 static void push_ptoken_context (cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
47 const cpp_token
**, unsigned int);
48 static _cpp_buff
*collect_args (cpp_reader
*, const cpp_hashnode
*);
49 static cpp_context
*next_context (cpp_reader
*);
50 static const cpp_token
*padding_token (cpp_reader
*, const cpp_token
*);
51 static void expand_arg (cpp_reader
*, macro_arg
*);
52 static const cpp_token
*new_string_token (cpp_reader
*, uchar
*, unsigned int);
53 static const cpp_token
*stringify_arg (cpp_reader
*, macro_arg
*);
54 static void paste_all_tokens (cpp_reader
*, const cpp_token
*);
55 static bool paste_tokens (cpp_reader
*, const cpp_token
**, const cpp_token
*);
56 static void replace_args (cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
58 static _cpp_buff
*funlike_invocation_p (cpp_reader
*, cpp_hashnode
*);
59 static bool create_iso_definition (cpp_reader
*, cpp_macro
*);
61 /* #define directive parsing and handling. */
63 static cpp_token
*alloc_expansion_token (cpp_reader
*, cpp_macro
*);
64 static cpp_token
*lex_expansion_token (cpp_reader
*, cpp_macro
*);
65 static bool warn_of_redefinition (cpp_reader
*, const cpp_hashnode
*,
67 static bool parse_params (cpp_reader
*, cpp_macro
*);
68 static void check_trad_stringification (cpp_reader
*, const cpp_macro
*,
71 /* Emits a warning if NODE is a macro defined in the main file that
74 _cpp_warn_if_unused_macro (cpp_reader
*pfile
, cpp_hashnode
*node
,
75 void *v ATTRIBUTE_UNUSED
)
77 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
79 cpp_macro
*macro
= node
->value
.macro
;
82 && MAIN_FILE_P (linemap_lookup (pfile
->line_table
, macro
->line
)))
83 cpp_error_with_line (pfile
, CPP_DL_WARNING
, macro
->line
, 0,
84 "macro \"%s\" is not used", NODE_NAME (node
));
90 /* Allocates and returns a CPP_STRING token, containing TEXT of length
91 LEN, after null-terminating it. TEXT must be in permanent storage. */
92 static const cpp_token
*
93 new_string_token (cpp_reader
*pfile
, unsigned char *text
, unsigned int len
)
95 cpp_token
*token
= _cpp_temp_token (pfile
);
98 token
->type
= CPP_STRING
;
99 token
->val
.str
.len
= len
;
100 token
->val
.str
.text
= text
;
105 static const char * const monthnames
[] =
107 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
108 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
111 /* Helper function for builtin_macro. Returns the text generated by
114 _cpp_builtin_macro_text (cpp_reader
*pfile
, cpp_hashnode
*node
)
116 const struct line_map
*map
;
117 const uchar
*result
= NULL
;
118 unsigned int number
= 1;
120 switch (node
->value
.builtin
)
123 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
129 cpp_buffer
*pbuffer
= cpp_get_buffer (pfile
);
130 if (pbuffer
->timestamp
== NULL
)
132 /* Initialize timestamp value of the assotiated file. */
133 struct _cpp_file
*file
= cpp_get_file (pbuffer
);
136 /* Generate __TIMESTAMP__ string, that represents
137 the date and time of the last modification
138 of the current source file. The string constant
139 looks like "Sun Sep 16 01:03:52 1973". */
140 struct tm
*tb
= NULL
;
141 struct stat
*st
= _cpp_get_file_stat (file
);
143 tb
= localtime (&st
->st_mtime
);
146 char *str
= asctime (tb
);
147 size_t len
= strlen (str
);
148 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, len
+ 2);
150 strcpy ((char *) buf
+ 1, str
);
152 pbuffer
->timestamp
= buf
;
156 cpp_errno (pfile
, CPP_DL_WARNING
,
157 "could not determine file timestamp");
158 pbuffer
->timestamp
= U
"\"??? ??? ?? ??:??:?? ????\"";
162 result
= pbuffer
->timestamp
;
171 map
= linemap_lookup (pfile
->line_table
, pfile
->line_table
->highest_line
);
173 if (node
->value
.builtin
== BT_BASE_FILE
)
174 while (! MAIN_FILE_P (map
))
175 map
= INCLUDED_FROM (pfile
->line_table
, map
);
179 buf
= _cpp_unaligned_alloc (pfile
, len
* 2 + 3);
182 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
188 case BT_INCLUDE_LEVEL
:
189 /* The line map depth counts the primary source as level 1, but
190 historically __INCLUDE_DEPTH__ has called the primary source
192 number
= pfile
->line_table
->depth
- 1;
196 map
= &pfile
->line_table
->maps
[pfile
->line_table
->used
-1];
197 /* If __LINE__ is embedded in a macro, it must expand to the
198 line of the macro's invocation, not its definition.
199 Otherwise things like assert() will not work properly. */
200 if (CPP_OPTION (pfile
, traditional
))
201 number
= pfile
->line_table
->highest_line
;
203 number
= pfile
->cur_token
[-1].src_loc
;
204 number
= SOURCE_LINE (map
, number
);
207 /* __STDC__ has the value 1 under normal circumstances.
208 However, if (a) we are in a system header, (b) the option
209 stdc_0_in_system_headers is true (set by target config), and
210 (c) we are not in strictly conforming mode, then it has the
211 value 0. (b) and (c) are already checked in cpp_init_builtins. */
213 if (cpp_in_system_header (pfile
))
221 if (pfile
->date
== NULL
)
223 /* Allocate __DATE__ and __TIME__ strings from permanent
224 storage. We only do this once, and don't generate them
225 at init time, because time() and localtime() are very
226 slow on some systems. */
228 struct tm
*tb
= NULL
;
230 /* (time_t) -1 is a legitimate value for "number of seconds
231 since the Epoch", so we have to do a little dance to
232 distinguish that from a genuine error. */
235 if (tt
!= (time_t)-1 || errno
== 0)
236 tb
= localtime (&tt
);
240 pfile
->date
= _cpp_unaligned_alloc (pfile
,
241 sizeof ("\"Oct 11 1347\""));
242 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
243 monthnames
[tb
->tm_mon
], tb
->tm_mday
,
246 pfile
->time
= _cpp_unaligned_alloc (pfile
,
247 sizeof ("\"12:34:56\""));
248 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
249 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
253 cpp_errno (pfile
, CPP_DL_WARNING
,
254 "could not determine date and time");
256 pfile
->date
= U
"\"??? ?? ????\"";
257 pfile
->time
= U
"\"??:??:??\"";
261 if (node
->value
.builtin
== BT_DATE
)
262 result
= pfile
->date
;
264 result
= pfile
->time
;
268 if (CPP_OPTION (pfile
, directives_only
) && pfile
->state
.in_directive
)
269 cpp_error (pfile
, CPP_DL_ERROR
,
270 "__COUNTER__ expanded inside directive with -fdirectives-only");
271 number
= pfile
->counter
++;
277 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
278 result
= _cpp_unaligned_alloc (pfile
, 21);
279 sprintf ((char *) result
, "%u", number
);
285 /* Convert builtin macros like __FILE__ to a token and push it on the
286 context stack. Also handles _Pragma, for which a new token may not
287 be created. Returns 1 if it generates a new token context, 0 to
288 return the token to the caller. */
290 builtin_macro (cpp_reader
*pfile
, cpp_hashnode
*node
)
296 if (node
->value
.builtin
== BT_PRAGMA
)
298 /* Don't interpret _Pragma within directives. The standard is
299 not clear on this, but to me this makes most sense. */
300 if (pfile
->state
.in_directive
)
303 _cpp_do__Pragma (pfile
);
307 buf
= _cpp_builtin_macro_text (pfile
, node
);
309 nbuf
= (char *) alloca (len
+ 1);
310 memcpy (nbuf
, buf
, len
);
313 cpp_push_buffer (pfile
, (uchar
*) nbuf
, len
, /* from_stage3 */ true);
314 _cpp_clean_line (pfile
);
316 /* Set pfile->cur_token as required by _cpp_lex_direct. */
317 pfile
->cur_token
= _cpp_temp_token (pfile
);
318 _cpp_push_token_context (pfile
, NULL
, _cpp_lex_direct (pfile
), 1);
319 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
320 cpp_error (pfile
, CPP_DL_ICE
, "invalid built-in macro \"%s\"",
322 _cpp_pop_buffer (pfile
);
327 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
328 backslashes and double quotes. DEST must be of sufficient size.
329 Returns a pointer to the end of the string. */
331 cpp_quote_string (uchar
*dest
, const uchar
*src
, unsigned int len
)
337 if (c
== '\\' || c
== '"')
349 /* Convert a token sequence ARG to a single string token according to
350 the rules of the ISO C #-operator. */
351 static const cpp_token
*
352 stringify_arg (cpp_reader
*pfile
, macro_arg
*arg
)
355 unsigned int i
, escape_it
, backslash_count
= 0;
356 const cpp_token
*source
= NULL
;
359 if (BUFF_ROOM (pfile
->u_buff
) < 3)
360 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 3);
361 dest
= BUFF_FRONT (pfile
->u_buff
);
364 /* Loop, reading in the argument's tokens. */
365 for (i
= 0; i
< arg
->count
; i
++)
367 const cpp_token
*token
= arg
->first
[i
];
369 if (token
->type
== CPP_PADDING
)
372 source
= token
->val
.source
;
376 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_WSTRING
377 || token
->type
== CPP_CHAR
|| token
->type
== CPP_WCHAR
);
379 /* Room for each char being written in octal, initial space and
380 final quote and NUL. */
381 len
= cpp_token_len (token
);
386 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
388 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
389 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
390 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
393 /* Leading white space? */
394 if (dest
- 1 != BUFF_FRONT (pfile
->u_buff
))
398 if (source
->flags
& PREV_WHITE
)
405 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
406 unsigned char *buf
= BUFF_FRONT (buff
);
407 len
= cpp_spell_token (pfile
, token
, buf
, true) - buf
;
408 dest
= cpp_quote_string (dest
, buf
, len
);
409 _cpp_release_buff (pfile
, buff
);
412 dest
= cpp_spell_token (pfile
, token
, dest
, true);
414 if (token
->type
== CPP_OTHER
&& token
->val
.str
.text
[0] == '\\')
420 /* Ignore the final \ of invalid string literals. */
421 if (backslash_count
& 1)
423 cpp_error (pfile
, CPP_DL_WARNING
,
424 "invalid string literal, ignoring final '\\'");
428 /* Commit the memory, including NUL, and return the token. */
430 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
431 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
432 return new_string_token (pfile
, dest
- len
, len
);
435 /* Try to paste two tokens. On success, return nonzero. In any
436 case, PLHS is updated to point to the pasted token, which is
437 guaranteed to not have the PASTE_LEFT flag set. */
439 paste_tokens (cpp_reader
*pfile
, const cpp_token
**plhs
, const cpp_token
*rhs
)
441 unsigned char *buf
, *end
, *lhsend
;
445 len
= cpp_token_len (*plhs
) + cpp_token_len (rhs
) + 1;
446 buf
= (unsigned char *) alloca (len
);
447 end
= lhsend
= cpp_spell_token (pfile
, *plhs
, buf
, false);
449 /* Avoid comment headers, since they are still processed in stage 3.
450 It is simpler to insert a space here, rather than modifying the
451 lexer to ignore comments in some circumstances. Simply returning
452 false doesn't work, since we want to clear the PASTE_LEFT flag. */
453 if ((*plhs
)->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
455 end
= cpp_spell_token (pfile
, rhs
, end
, false);
458 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true);
459 _cpp_clean_line (pfile
);
461 /* Set pfile->cur_token as required by _cpp_lex_direct. */
462 pfile
->cur_token
= _cpp_temp_token (pfile
);
463 lhs
= _cpp_lex_direct (pfile
);
464 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
466 source_location saved_loc
= lhs
->src_loc
;
468 _cpp_pop_buffer (pfile
);
469 _cpp_backup_tokens (pfile
, 1);
472 /* We have to remove the PASTE_LEFT flag from the old lhs, but
473 we want to keep the new location. */
476 lhs
->src_loc
= saved_loc
;
477 lhs
->flags
&= ~PASTE_LEFT
;
479 /* Mandatory error for all apart from assembler. */
480 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
481 cpp_error (pfile
, CPP_DL_ERROR
,
482 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
483 buf
, cpp_token_as_text (pfile
, rhs
));
488 _cpp_pop_buffer (pfile
);
492 /* Handles an arbitrarily long sequence of ## operators, with initial
493 operand LHS. This implementation is left-associative,
494 non-recursive, and finishes a paste before handling succeeding
495 ones. If a paste fails, we back up to the RHS of the failing ##
496 operator before pushing the context containing the result of prior
497 successful pastes, with the effect that the RHS appears in the
498 output stream after the pasted LHS normally. */
500 paste_all_tokens (cpp_reader
*pfile
, const cpp_token
*lhs
)
502 const cpp_token
*rhs
;
503 cpp_context
*context
= pfile
->context
;
507 /* Take the token directly from the current context. We can do
508 this, because we are in the replacement list of either an
509 object-like macro, or a function-like macro with arguments
510 inserted. In either case, the constraints to #define
511 guarantee we have at least one more token. */
512 if (context
->direct_p
)
513 rhs
= FIRST (context
).token
++;
515 rhs
= *FIRST (context
).ptoken
++;
517 if (rhs
->type
== CPP_PADDING
)
520 if (!paste_tokens (pfile
, &lhs
, rhs
))
523 while (rhs
->flags
& PASTE_LEFT
);
525 /* Put the resulting token in its own context. */
526 _cpp_push_token_context (pfile
, NULL
, lhs
, 1);
529 /* Returns TRUE if the number of arguments ARGC supplied in an
530 invocation of the MACRO referenced by NODE is valid. An empty
531 invocation to a macro with no parameters should pass ARGC as zero.
533 Note that MACRO cannot necessarily be deduced from NODE, in case
534 NODE was redefined whilst collecting arguments. */
536 _cpp_arguments_ok (cpp_reader
*pfile
, cpp_macro
*macro
, const cpp_hashnode
*node
, unsigned int argc
)
538 if (argc
== macro
->paramc
)
541 if (argc
< macro
->paramc
)
543 /* As an extension, a rest argument is allowed to not appear in
544 the invocation at all.
545 e.g. #define debug(format, args...) something
548 This is exactly the same as if there had been an empty rest
549 argument - debug("string", ). */
551 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
553 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
554 cpp_error (pfile
, CPP_DL_PEDWARN
,
555 "ISO C99 requires rest arguments to be used");
559 cpp_error (pfile
, CPP_DL_ERROR
,
560 "macro \"%s\" requires %u arguments, but only %u given",
561 NODE_NAME (node
), macro
->paramc
, argc
);
564 cpp_error (pfile
, CPP_DL_ERROR
,
565 "macro \"%s\" passed %u arguments, but takes just %u",
566 NODE_NAME (node
), argc
, macro
->paramc
);
571 /* Reads and returns the arguments to a function-like macro
572 invocation. Assumes the opening parenthesis has been processed.
573 If there is an error, emits an appropriate diagnostic and returns
574 NULL. Each argument is terminated by a CPP_EOF token, for the
575 future benefit of expand_arg(). */
577 collect_args (cpp_reader
*pfile
, const cpp_hashnode
*node
)
579 _cpp_buff
*buff
, *base_buff
;
581 macro_arg
*args
, *arg
;
582 const cpp_token
*token
;
585 macro
= node
->value
.macro
;
587 argc
= macro
->paramc
;
590 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
591 + sizeof (macro_arg
)));
593 args
= (macro_arg
*) buff
->base
;
594 memset (args
, 0, argc
* sizeof (macro_arg
));
595 buff
->cur
= (unsigned char *) &args
[argc
];
596 arg
= args
, argc
= 0;
598 /* Collect the tokens making up each argument. We don't yet know
599 how many arguments have been supplied, whether too many or too
600 few. Hence the slightly bizarre usage of "argc" and "arg". */
603 unsigned int paren_depth
= 0;
604 unsigned int ntokens
= 0;
607 arg
->first
= (const cpp_token
**) buff
->cur
;
611 /* Require space for 2 new tokens (including a CPP_EOF). */
612 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
614 buff
= _cpp_append_extend_buff (pfile
, buff
,
615 1000 * sizeof (cpp_token
*));
616 arg
->first
= (const cpp_token
**) buff
->cur
;
619 token
= cpp_get_token (pfile
);
621 if (token
->type
== CPP_PADDING
)
623 /* Drop leading padding. */
627 else if (token
->type
== CPP_OPEN_PAREN
)
629 else if (token
->type
== CPP_CLOSE_PAREN
)
631 if (paren_depth
-- == 0)
634 else if (token
->type
== CPP_COMMA
)
636 /* A comma does not terminate an argument within
637 parentheses or as part of a variable argument. */
639 && ! (macro
->variadic
&& argc
== macro
->paramc
))
642 else if (token
->type
== CPP_EOF
643 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
646 arg
->first
[ntokens
++] = token
;
649 /* Drop trailing padding. */
650 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
653 arg
->count
= ntokens
;
654 arg
->first
[ntokens
] = &pfile
->eof
;
656 /* Terminate the argument. Excess arguments loop back and
657 overwrite the final legitimate argument, before failing. */
658 if (argc
<= macro
->paramc
)
660 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
661 if (argc
!= macro
->paramc
)
665 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
667 if (token
->type
== CPP_EOF
)
669 /* We still need the CPP_EOF to end directives, and to end
670 pre-expansion of a macro argument. Step back is not
671 unconditional, since we don't want to return a CPP_EOF to our
672 callers at the end of an -include-d file. */
673 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
674 _cpp_backup_tokens (pfile
, 1);
675 cpp_error (pfile
, CPP_DL_ERROR
,
676 "unterminated argument list invoking macro \"%s\"",
681 /* A single empty argument is counted as no argument. */
682 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
684 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
686 /* GCC has special semantics for , ## b where b is a varargs
687 parameter: we remove the comma if b was omitted entirely.
688 If b was merely an empty argument, the comma is retained.
689 If the macro takes just one (varargs) parameter, then we
690 retain the comma only if we are standards conforming.
692 If FIRST is NULL replace_args () swallows the comma. */
693 if (macro
->variadic
&& (argc
< macro
->paramc
694 || (argc
== 1 && args
[0].count
== 0
695 && !CPP_OPTION (pfile
, std
))))
696 args
[macro
->paramc
- 1].first
= NULL
;
701 /* An error occurred. */
702 _cpp_release_buff (pfile
, base_buff
);
706 /* Search for an opening parenthesis to the macro of NODE, in such a
707 way that, if none is found, we don't lose the information in any
708 intervening padding tokens. If we find the parenthesis, collect
709 the arguments and return the buffer containing them. */
711 funlike_invocation_p (cpp_reader
*pfile
, cpp_hashnode
*node
)
713 const cpp_token
*token
, *padding
= NULL
;
717 token
= cpp_get_token (pfile
);
718 if (token
->type
!= CPP_PADDING
)
721 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
725 if (token
->type
== CPP_OPEN_PAREN
)
727 pfile
->state
.parsing_args
= 2;
728 return collect_args (pfile
, node
);
731 /* CPP_EOF can be the end of macro arguments, or the end of the
732 file. We mustn't back up over the latter. Ugh. */
733 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
735 /* Back up. We may have skipped padding, in which case backing
736 up more than one token when expanding macros is in general
737 too difficult. We re-insert it in its own context. */
738 _cpp_backup_tokens (pfile
, 1);
740 _cpp_push_token_context (pfile
, NULL
, padding
, 1);
746 /* Push the context of a macro with hash entry NODE onto the context
747 stack. If we can successfully expand the macro, we push a context
748 containing its yet-to-be-rescanned replacement list and return one.
749 Otherwise, we don't push a context and return zero. */
751 enter_macro_context (cpp_reader
*pfile
, cpp_hashnode
*node
)
753 /* The presence of a macro invalidates a file's controlling macro. */
754 pfile
->mi_valid
= false;
756 pfile
->state
.angled_headers
= false;
758 /* Handle standard macros. */
759 if (! (node
->flags
& NODE_BUILTIN
))
761 cpp_macro
*macro
= node
->value
.macro
;
767 pfile
->state
.prevent_expansion
++;
768 pfile
->keep_tokens
++;
769 pfile
->state
.parsing_args
= 1;
770 buff
= funlike_invocation_p (pfile
, node
);
771 pfile
->state
.parsing_args
= 0;
772 pfile
->keep_tokens
--;
773 pfile
->state
.prevent_expansion
--;
777 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
778 cpp_error (pfile
, CPP_DL_WARNING
,
779 "function-like macro \"%s\" must be used with arguments in traditional C",
785 if (macro
->paramc
> 0)
786 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
787 _cpp_release_buff (pfile
, buff
);
790 /* Disable the macro within its expansion. */
791 node
->flags
|= NODE_DISABLED
;
795 if (macro
->paramc
== 0)
796 _cpp_push_token_context (pfile
, node
, macro
->exp
.tokens
, macro
->count
);
801 /* Handle built-in macros and the _Pragma operator. */
802 return builtin_macro (pfile
, node
);
805 /* Replace the parameters in a function-like macro of NODE with the
806 actual ARGS, and place the result in a newly pushed token context.
807 Expand each argument before replacing, unless it is operated upon
808 by the # or ## operators. */
810 replace_args (cpp_reader
*pfile
, cpp_hashnode
*node
, cpp_macro
*macro
, macro_arg
*args
)
812 unsigned int i
, total
;
813 const cpp_token
*src
, *limit
;
814 const cpp_token
**dest
, **first
;
818 /* First, fully macro-expand arguments, calculating the number of
819 tokens in the final expansion as we go. The ordering of the if
820 statements below is subtle; we must handle stringification before
822 total
= macro
->count
;
823 limit
= macro
->exp
.tokens
+ macro
->count
;
825 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
826 if (src
->type
== CPP_MACRO_ARG
)
828 /* Leading and trailing padding tokens. */
831 /* We have an argument. If it is not being stringified or
832 pasted it is macro-replaced before insertion. */
833 arg
= &args
[src
->val
.arg_no
- 1];
835 if (src
->flags
& STRINGIFY_ARG
)
837 if (!arg
->stringified
)
838 arg
->stringified
= stringify_arg (pfile
, arg
);
840 else if ((src
->flags
& PASTE_LEFT
)
841 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
842 total
+= arg
->count
- 1;
846 expand_arg (pfile
, arg
);
847 total
+= arg
->expanded_count
- 1;
851 /* Now allocate space for the expansion, copy the tokens and replace
853 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
854 first
= (const cpp_token
**) buff
->base
;
857 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
860 const cpp_token
**from
, **paste_flag
;
862 if (src
->type
!= CPP_MACRO_ARG
)
869 arg
= &args
[src
->val
.arg_no
- 1];
870 if (src
->flags
& STRINGIFY_ARG
)
871 count
= 1, from
= &arg
->stringified
;
872 else if (src
->flags
& PASTE_LEFT
)
873 count
= arg
->count
, from
= arg
->first
;
874 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
876 count
= arg
->count
, from
= arg
->first
;
879 if (dest
[-1]->type
== CPP_COMMA
881 && src
->val
.arg_no
== macro
->paramc
)
883 /* Swallow a pasted comma if from == NULL, otherwise
884 drop the paste flag. */
888 paste_flag
= dest
- 1;
890 /* Remove the paste flag if the RHS is a placemarker. */
892 paste_flag
= dest
- 1;
896 count
= arg
->expanded_count
, from
= arg
->expanded
;
898 /* Padding on the left of an argument (unless RHS of ##). */
899 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
900 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
901 *dest
++ = padding_token (pfile
, src
);
905 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
908 /* With a non-empty argument on the LHS of ##, the last
909 token should be flagged PASTE_LEFT. */
910 if (src
->flags
& PASTE_LEFT
)
911 paste_flag
= dest
- 1;
914 /* Avoid paste on RHS (even case count == 0). */
915 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
916 *dest
++ = &pfile
->avoid_paste
;
918 /* Add a new paste flag, or remove an unwanted one. */
921 cpp_token
*token
= _cpp_temp_token (pfile
);
922 token
->type
= (*paste_flag
)->type
;
923 token
->val
= (*paste_flag
)->val
;
924 if (src
->flags
& PASTE_LEFT
)
925 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
927 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
932 /* Free the expanded arguments. */
933 for (i
= 0; i
< macro
->paramc
; i
++)
934 if (args
[i
].expanded
)
935 free (args
[i
].expanded
);
937 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
940 /* Return a special padding token, with padding inherited from SOURCE. */
941 static const cpp_token
*
942 padding_token (cpp_reader
*pfile
, const cpp_token
*source
)
944 cpp_token
*result
= _cpp_temp_token (pfile
);
946 result
->type
= CPP_PADDING
;
948 /* Data in GCed data structures cannot be made const so far, so we
950 result
->val
.source
= (cpp_token
*) source
;
955 /* Get a new uninitialized context. Create a new one if we cannot
956 re-use an old one. */
958 next_context (cpp_reader
*pfile
)
960 cpp_context
*result
= pfile
->context
->next
;
964 result
= XNEW (cpp_context
);
965 result
->prev
= pfile
->context
;
967 pfile
->context
->next
= result
;
970 pfile
->context
= result
;
974 /* Push a list of pointers to tokens. */
976 push_ptoken_context (cpp_reader
*pfile
, cpp_hashnode
*macro
, _cpp_buff
*buff
,
977 const cpp_token
**first
, unsigned int count
)
979 cpp_context
*context
= next_context (pfile
);
981 context
->direct_p
= false;
982 context
->macro
= macro
;
983 context
->buff
= buff
;
984 FIRST (context
).ptoken
= first
;
985 LAST (context
).ptoken
= first
+ count
;
988 /* Push a list of tokens. */
990 _cpp_push_token_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
991 const cpp_token
*first
, unsigned int count
)
993 cpp_context
*context
= next_context (pfile
);
995 context
->direct_p
= true;
996 context
->macro
= macro
;
997 context
->buff
= NULL
;
998 FIRST (context
).token
= first
;
999 LAST (context
).token
= first
+ count
;
1002 /* Push a traditional macro's replacement text. */
1004 _cpp_push_text_context (cpp_reader
*pfile
, cpp_hashnode
*macro
,
1005 const uchar
*start
, size_t len
)
1007 cpp_context
*context
= next_context (pfile
);
1009 context
->direct_p
= true;
1010 context
->macro
= macro
;
1011 context
->buff
= NULL
;
1012 CUR (context
) = start
;
1013 RLIMIT (context
) = start
+ len
;
1014 macro
->flags
|= NODE_DISABLED
;
1017 /* Expand an argument ARG before replacing parameters in a
1018 function-like macro. This works by pushing a context with the
1019 argument's tokens, and then expanding that into a temporary buffer
1020 as if it were a normal part of the token stream. collect_args()
1021 has terminated the argument's tokens with a CPP_EOF so that we know
1022 when we have fully expanded the argument. */
1024 expand_arg (cpp_reader
*pfile
, macro_arg
*arg
)
1026 unsigned int capacity
;
1027 bool saved_warn_trad
;
1029 if (arg
->count
== 0)
1032 /* Don't warn about funlike macros when pre-expanding. */
1033 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
1034 CPP_WTRADITIONAL (pfile
) = 0;
1036 /* Loop, reading in the arguments. */
1038 arg
->expanded
= XNEWVEC (const cpp_token
*, capacity
);
1040 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
1043 const cpp_token
*token
;
1045 if (arg
->expanded_count
+ 1 >= capacity
)
1048 arg
->expanded
= XRESIZEVEC (const cpp_token
*, arg
->expanded
,
1052 token
= cpp_get_token (pfile
);
1054 if (token
->type
== CPP_EOF
)
1057 arg
->expanded
[arg
->expanded_count
++] = token
;
1060 _cpp_pop_context (pfile
);
1062 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
1065 /* Pop the current context off the stack, re-enabling the macro if the
1066 context represented a macro's replacement list. The context
1067 structure is not freed so that we can re-use it later. */
1069 _cpp_pop_context (cpp_reader
*pfile
)
1071 cpp_context
*context
= pfile
->context
;
1074 context
->macro
->flags
&= ~NODE_DISABLED
;
1077 _cpp_release_buff (pfile
, context
->buff
);
1079 pfile
->context
= context
->prev
;
1082 /* External routine to get a token. Also used nearly everywhere
1083 internally, except for places where we know we can safely call
1084 _cpp_lex_token directly, such as lexing a directive name.
1086 Macro expansions and directives are transparently handled,
1087 including entering included files. Thus tokens are post-macro
1088 expansion, and after any intervening directives. External callers
1089 see CPP_EOF only at EOF. Internal callers also see it when meeting
1090 a directive inside a macro call, when at the end of a directive and
1091 state.in_directive is still 1, and at the end of argument
1094 cpp_get_token (cpp_reader
*pfile
)
1096 const cpp_token
*result
;
1097 bool can_set
= pfile
->set_invocation_location
;
1098 pfile
->set_invocation_location
= false;
1103 cpp_context
*context
= pfile
->context
;
1105 /* Context->prev == 0 <=> base context. */
1107 result
= _cpp_lex_token (pfile
);
1108 else if (FIRST (context
).token
!= LAST (context
).token
)
1110 if (context
->direct_p
)
1111 result
= FIRST (context
).token
++;
1113 result
= *FIRST (context
).ptoken
++;
1115 if (result
->flags
& PASTE_LEFT
)
1117 paste_all_tokens (pfile
, result
);
1118 if (pfile
->state
.in_directive
)
1120 return padding_token (pfile
, result
);
1125 _cpp_pop_context (pfile
);
1126 if (pfile
->state
.in_directive
)
1128 return &pfile
->avoid_paste
;
1131 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1134 if (result
->type
!= CPP_NAME
)
1137 node
= result
->val
.node
;
1139 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1142 if (!(node
->flags
& NODE_DISABLED
))
1144 /* If not in a macro context, and we're going to start an
1145 expansion, record the location. */
1146 if (can_set
&& !context
->macro
)
1147 pfile
->invocation_location
= result
->src_loc
;
1148 if (!pfile
->state
.prevent_expansion
1149 && enter_macro_context (pfile
, node
))
1151 if (pfile
->state
.in_directive
)
1153 return padding_token (pfile
, result
);
1158 /* Flag this token as always unexpandable. FIXME: move this
1159 to collect_args()?. */
1160 cpp_token
*t
= _cpp_temp_token (pfile
);
1161 t
->type
= result
->type
;
1162 t
->flags
= result
->flags
| NO_EXPAND
;
1163 t
->val
= result
->val
;
1173 /* Like cpp_get_token, but also returns a location separate from the
1174 one provided by the returned token. LOC is an out parameter; *LOC
1175 is set to the location "as expected by the user". This matters
1176 when a token results from macro expansion -- the token's location
1177 will indicate where the macro is defined, but *LOC will be the
1178 location of the start of the expansion. */
1180 cpp_get_token_with_location (cpp_reader
*pfile
, source_location
*loc
)
1182 const cpp_token
*result
;
1184 pfile
->set_invocation_location
= true;
1185 result
= cpp_get_token (pfile
);
1186 if (pfile
->context
->macro
)
1187 *loc
= pfile
->invocation_location
;
1189 *loc
= result
->src_loc
;
1194 /* Returns true if we're expanding an object-like macro that was
1195 defined in a system header. Just checks the macro at the top of
1196 the stack. Used for diagnostic suppression. */
1198 cpp_sys_macro_p (cpp_reader
*pfile
)
1200 cpp_hashnode
*node
= pfile
->context
->macro
;
1202 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1205 /* Read each token in, until end of the current file. Directives are
1206 transparently processed. */
1208 cpp_scan_nooutput (cpp_reader
*pfile
)
1210 /* Request a CPP_EOF token at the end of this file, rather than
1211 transparently continuing with the including file. */
1212 pfile
->buffer
->return_at_eof
= true;
1214 pfile
->state
.discarding_output
++;
1215 pfile
->state
.prevent_expansion
++;
1217 if (CPP_OPTION (pfile
, traditional
))
1218 while (_cpp_read_logical_line_trad (pfile
))
1221 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1224 pfile
->state
.discarding_output
--;
1225 pfile
->state
.prevent_expansion
--;
1228 /* Step back one (or more) tokens. Can only step back more than 1 if
1229 they are from the lexer, and not from macro expansion. */
1231 _cpp_backup_tokens (cpp_reader
*pfile
, unsigned int count
)
1233 if (pfile
->context
->prev
== NULL
)
1235 pfile
->lookaheads
+= count
;
1239 if (pfile
->cur_token
== pfile
->cur_run
->base
1240 /* Possible with -fpreprocessed and no leading #line. */
1241 && pfile
->cur_run
->prev
!= NULL
)
1243 pfile
->cur_run
= pfile
->cur_run
->prev
;
1244 pfile
->cur_token
= pfile
->cur_run
->limit
;
1252 if (pfile
->context
->direct_p
)
1253 FIRST (pfile
->context
).token
--;
1255 FIRST (pfile
->context
).ptoken
--;
1259 /* #define directive parsing and handling. */
1261 /* Returns nonzero if a macro redefinition warning is required. */
1263 warn_of_redefinition (cpp_reader
*pfile
, const cpp_hashnode
*node
,
1264 const cpp_macro
*macro2
)
1266 const cpp_macro
*macro1
;
1269 /* Some redefinitions need to be warned about regardless. */
1270 if (node
->flags
& NODE_WARN
)
1273 /* Redefinition of a macro is allowed if and only if the old and new
1274 definitions are the same. (6.10.3 paragraph 2). */
1275 macro1
= node
->value
.macro
;
1277 /* Don't check count here as it can be different in valid
1278 traditional redefinitions with just whitespace differences. */
1279 if (macro1
->paramc
!= macro2
->paramc
1280 || macro1
->fun_like
!= macro2
->fun_like
1281 || macro1
->variadic
!= macro2
->variadic
)
1284 /* Check parameter spellings. */
1285 for (i
= 0; i
< macro1
->paramc
; i
++)
1286 if (macro1
->params
[i
] != macro2
->params
[i
])
1289 /* Check the replacement text or tokens. */
1290 if (CPP_OPTION (pfile
, traditional
))
1291 return _cpp_expansions_different_trad (macro1
, macro2
);
1293 if (macro1
->count
!= macro2
->count
)
1296 for (i
= 0; i
< macro1
->count
; i
++)
1297 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
1303 /* Free the definition of hashnode H. */
1305 _cpp_free_definition (cpp_hashnode
*h
)
1307 /* Macros and assertions no longer have anything to free. */
1309 /* Clear builtin flag in case of redefinition. */
1310 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
);
1313 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1314 zero on success, nonzero if the parameter is a duplicate. */
1316 _cpp_save_parameter (cpp_reader
*pfile
, cpp_macro
*macro
, cpp_hashnode
*node
)
1319 /* Constraint 6.10.3.6 - duplicate parameter names. */
1320 if (node
->flags
& NODE_MACRO_ARG
)
1322 cpp_error (pfile
, CPP_DL_ERROR
, "duplicate macro parameter \"%s\"",
1327 if (BUFF_ROOM (pfile
->a_buff
)
1328 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1329 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1331 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1332 node
->flags
|= NODE_MACRO_ARG
;
1333 len
= macro
->paramc
* sizeof (union _cpp_hashnode_value
);
1334 if (len
> pfile
->macro_buffer_len
)
1336 pfile
->macro_buffer
= XRESIZEVEC (unsigned char, pfile
->macro_buffer
,
1338 pfile
->macro_buffer_len
= len
;
1340 ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[macro
->paramc
- 1]
1343 node
->value
.arg_index
= macro
->paramc
;
1347 /* Check the syntax of the parameters in a MACRO definition. Returns
1348 false if an error occurs. */
1350 parse_params (cpp_reader
*pfile
, cpp_macro
*macro
)
1352 unsigned int prev_ident
= 0;
1356 const cpp_token
*token
= _cpp_lex_token (pfile
);
1358 switch (token
->type
)
1361 /* Allow/ignore comments in parameter lists if we are
1362 preserving comments in macro expansions. */
1363 if (token
->type
== CPP_COMMENT
1364 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1367 cpp_error (pfile
, CPP_DL_ERROR
,
1368 "\"%s\" may not appear in macro parameter list",
1369 cpp_token_as_text (pfile
, token
));
1375 cpp_error (pfile
, CPP_DL_ERROR
,
1376 "macro parameters must be comma-separated");
1381 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
))
1385 case CPP_CLOSE_PAREN
:
1386 if (prev_ident
|| macro
->paramc
== 0)
1389 /* Fall through to pick up the error. */
1393 cpp_error (pfile
, CPP_DL_ERROR
, "parameter name missing");
1400 macro
->variadic
= 1;
1403 _cpp_save_parameter (pfile
, macro
,
1404 pfile
->spec_nodes
.n__VA_ARGS__
);
1405 pfile
->state
.va_args_ok
= 1;
1406 if (! CPP_OPTION (pfile
, c99
)
1407 && CPP_OPTION (pfile
, pedantic
)
1408 && CPP_OPTION (pfile
, warn_variadic_macros
))
1409 cpp_error (pfile
, CPP_DL_PEDWARN
,
1410 "anonymous variadic macros were introduced in C99");
1412 else if (CPP_OPTION (pfile
, pedantic
)
1413 && CPP_OPTION (pfile
, warn_variadic_macros
))
1414 cpp_error (pfile
, CPP_DL_PEDWARN
,
1415 "ISO C does not permit named variadic macros");
1417 /* We're at the end, and just expect a closing parenthesis. */
1418 token
= _cpp_lex_token (pfile
);
1419 if (token
->type
== CPP_CLOSE_PAREN
)
1424 cpp_error (pfile
, CPP_DL_ERROR
, "missing ')' in macro parameter list");
1430 /* Allocate room for a token from a macro's replacement list. */
1432 alloc_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1434 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1435 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1437 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1440 /* Lex a token from the expansion of MACRO, but mark parameters as we
1441 find them and warn of traditional stringification. */
1443 lex_expansion_token (cpp_reader
*pfile
, cpp_macro
*macro
)
1445 cpp_token
*token
, *saved_cur_token
;
1447 saved_cur_token
= pfile
->cur_token
;
1448 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1449 token
= _cpp_lex_direct (pfile
);
1450 pfile
->cur_token
= saved_cur_token
;
1452 /* Is this a parameter? */
1453 if (token
->type
== CPP_NAME
1454 && (token
->val
.node
->flags
& NODE_MACRO_ARG
) != 0)
1456 token
->type
= CPP_MACRO_ARG
;
1457 token
->val
.arg_no
= token
->val
.node
->value
.arg_index
;
1459 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1460 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1461 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1467 create_iso_definition (cpp_reader
*pfile
, cpp_macro
*macro
)
1470 const cpp_token
*ctoken
;
1471 bool following_paste_op
= false;
1472 const char *paste_op_error_msg
=
1473 N_("'##' cannot appear at either end of a macro expansion");
1475 /* Get the first token of the expansion (or the '(' of a
1476 function-like macro). */
1477 ctoken
= _cpp_lex_token (pfile
);
1479 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1481 bool ok
= parse_params (pfile
, macro
);
1482 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1486 /* Success. Commit or allocate the parameter array. */
1487 if (pfile
->hash_table
->alloc_subobject
)
1489 cpp_hashnode
**params
=
1490 (cpp_hashnode
**) pfile
->hash_table
->alloc_subobject
1491 (sizeof (cpp_hashnode
*) * macro
->paramc
);
1492 memcpy (params
, macro
->params
,
1493 sizeof (cpp_hashnode
*) * macro
->paramc
);
1494 macro
->params
= params
;
1497 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1498 macro
->fun_like
= 1;
1500 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1502 /* While ISO C99 requires whitespace before replacement text
1503 in a macro definition, ISO C90 with TC1 allows there characters
1504 from the basic source character set. */
1505 if (CPP_OPTION (pfile
, c99
))
1506 cpp_error (pfile
, CPP_DL_PEDWARN
,
1507 "ISO C99 requires whitespace after the macro name");
1510 int warntype
= CPP_DL_WARNING
;
1511 switch (ctoken
->type
)
1515 case CPP_OBJC_STRING
:
1516 /* '@' is not in basic character set. */
1517 warntype
= CPP_DL_PEDWARN
;
1520 /* Basic character set sans letters, digits and _. */
1521 if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1522 ctoken
->val
.str
.text
[0]) == NULL
)
1523 warntype
= CPP_DL_PEDWARN
;
1526 /* All other tokens start with a character from basic
1530 cpp_error (pfile
, warntype
,
1531 "missing whitespace after the macro name");
1535 if (macro
->fun_like
)
1536 token
= lex_expansion_token (pfile
, macro
);
1539 token
= alloc_expansion_token (pfile
, macro
);
1545 /* Check the stringifying # constraint 6.10.3.2.1 of
1546 function-like macros when lexing the subsequent token. */
1547 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1549 if (token
->type
== CPP_MACRO_ARG
)
1551 token
->flags
&= ~PREV_WHITE
;
1552 token
->flags
|= STRINGIFY_ARG
;
1553 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1554 token
[-1] = token
[0];
1557 /* Let assembler get away with murder. */
1558 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1560 cpp_error (pfile
, CPP_DL_ERROR
,
1561 "'#' is not followed by a macro parameter");
1566 if (token
->type
== CPP_EOF
)
1568 /* Paste operator constraint 6.10.3.3.1:
1569 Token-paste ##, can appear in both object-like and
1570 function-like macros, but not at the end. */
1571 if (following_paste_op
)
1573 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
1579 /* Paste operator constraint 6.10.3.3.1. */
1580 if (token
->type
== CPP_PASTE
)
1582 /* Token-paste ##, can appear in both object-like and
1583 function-like macros, but not at the beginning. */
1584 if (macro
->count
== 1)
1586 cpp_error (pfile
, CPP_DL_ERROR
, paste_op_error_msg
);
1591 token
[-1].flags
|= PASTE_LEFT
;
1594 following_paste_op
= (token
->type
== CPP_PASTE
);
1595 token
= lex_expansion_token (pfile
, macro
);
1598 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1599 macro
->traditional
= 0;
1601 /* Don't count the CPP_EOF. */
1604 /* Clear whitespace on first token for warn_of_redefinition(). */
1606 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
1608 /* Commit or allocate the memory. */
1609 if (pfile
->hash_table
->alloc_subobject
)
1612 (cpp_token
*) pfile
->hash_table
->alloc_subobject (sizeof (cpp_token
)
1614 memcpy (tokns
, macro
->exp
.tokens
, sizeof (cpp_token
) * macro
->count
);
1615 macro
->exp
.tokens
= tokns
;
1618 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
1623 /* Parse a macro and save its expansion. Returns nonzero on success. */
1625 _cpp_create_definition (cpp_reader
*pfile
, cpp_hashnode
*node
)
1631 if (pfile
->hash_table
->alloc_subobject
)
1632 macro
= (cpp_macro
*) pfile
->hash_table
->alloc_subobject
1633 (sizeof (cpp_macro
));
1635 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1636 macro
->line
= pfile
->directive_line
;
1639 macro
->variadic
= 0;
1640 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
1642 macro
->fun_like
= 0;
1643 /* To suppress some diagnostics. */
1644 macro
->syshdr
= pfile
->buffer
&& pfile
->buffer
->sysp
!= 0;
1646 if (CPP_OPTION (pfile
, traditional
))
1647 ok
= _cpp_create_trad_definition (pfile
, macro
);
1650 ok
= create_iso_definition (pfile
, macro
);
1652 /* We set the type for SEEN_EOL() in directives.c.
1654 Longer term we should lex the whole line before coming here,
1655 and just copy the expansion. */
1657 /* Stop the lexer accepting __VA_ARGS__. */
1658 pfile
->state
.va_args_ok
= 0;
1661 /* Clear the fast argument lookup indices. */
1662 for (i
= macro
->paramc
; i
-- > 0; )
1664 struct cpp_hashnode
*node
= macro
->params
[i
];
1665 node
->flags
&= ~ NODE_MACRO_ARG
;
1666 node
->value
= ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[i
];
1672 if (node
->type
== NT_MACRO
)
1674 if (CPP_OPTION (pfile
, warn_unused_macros
))
1675 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
1677 if (warn_of_redefinition (pfile
, node
, macro
))
1679 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, pfile
->directive_line
, 0,
1680 "\"%s\" redefined", NODE_NAME (node
));
1682 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1683 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
,
1684 node
->value
.macro
->line
, 0,
1685 "this is the location of the previous definition");
1689 if (node
->type
!= NT_VOID
)
1690 _cpp_free_definition (node
);
1692 /* Enter definition in hash table. */
1693 node
->type
= NT_MACRO
;
1694 node
->value
.macro
= macro
;
1695 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
1696 node
->flags
|= NODE_WARN
;
1701 /* Warn if a token in STRING matches one of a function-like MACRO's
1704 check_trad_stringification (cpp_reader
*pfile
, const cpp_macro
*macro
,
1705 const cpp_string
*string
)
1707 unsigned int i
, len
;
1708 const uchar
*p
, *q
, *limit
;
1710 /* Loop over the string. */
1711 limit
= string
->text
+ string
->len
- 1;
1712 for (p
= string
->text
+ 1; p
< limit
; p
= q
)
1714 /* Find the start of an identifier. */
1715 while (p
< limit
&& !is_idstart (*p
))
1718 /* Find the end of the identifier. */
1720 while (q
< limit
&& is_idchar (*q
))
1725 /* Loop over the function macro arguments to see if the
1726 identifier inside the string matches one of them. */
1727 for (i
= 0; i
< macro
->paramc
; i
++)
1729 const cpp_hashnode
*node
= macro
->params
[i
];
1731 if (NODE_LEN (node
) == len
1732 && !memcmp (p
, NODE_NAME (node
), len
))
1734 cpp_error (pfile
, CPP_DL_WARNING
,
1735 "macro argument \"%s\" would be stringified in traditional C",
1743 /* Returns the name, arguments and expansion of a macro, in a format
1744 suitable to be read back in again, and therefore also for DWARF 2
1745 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1746 Caller is expected to generate the "#define" bit if needed. The
1747 returned text is temporary, and automatically freed later. */
1748 const unsigned char *
1749 cpp_macro_definition (cpp_reader
*pfile
, const cpp_hashnode
*node
)
1751 unsigned int i
, len
;
1752 const cpp_macro
*macro
= node
->value
.macro
;
1753 unsigned char *buffer
;
1755 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1757 cpp_error (pfile
, CPP_DL_ICE
,
1758 "invalid hash type %d in cpp_macro_definition", node
->type
);
1762 /* Calculate length. */
1763 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
1764 if (macro
->fun_like
)
1766 len
+= 4; /* "()" plus possible final ".." of named
1767 varargs (we have + 1 below). */
1768 for (i
= 0; i
< macro
->paramc
; i
++)
1769 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1772 /* This should match below where we fill in the buffer. */
1773 if (CPP_OPTION (pfile
, traditional
))
1774 len
+= _cpp_replacement_text_len (macro
);
1777 for (i
= 0; i
< macro
->count
; i
++)
1779 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1781 if (token
->type
== CPP_MACRO_ARG
)
1782 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1784 len
+= cpp_token_len (token
);
1786 if (token
->flags
& STRINGIFY_ARG
)
1788 if (token
->flags
& PASTE_LEFT
)
1789 len
+= 3; /* " ##" */
1790 if (token
->flags
& PREV_WHITE
)
1795 if (len
> pfile
->macro_buffer_len
)
1797 pfile
->macro_buffer
= XRESIZEVEC (unsigned char,
1798 pfile
->macro_buffer
, len
);
1799 pfile
->macro_buffer_len
= len
;
1802 /* Fill in the buffer. Start with the macro name. */
1803 buffer
= pfile
->macro_buffer
;
1804 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1805 buffer
+= NODE_LEN (node
);
1807 /* Parameter names. */
1808 if (macro
->fun_like
)
1811 for (i
= 0; i
< macro
->paramc
; i
++)
1813 cpp_hashnode
*param
= macro
->params
[i
];
1815 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1817 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1818 buffer
+= NODE_LEN (param
);
1821 if (i
+ 1 < macro
->paramc
)
1822 /* Don't emit a space after the comma here; we're trying
1823 to emit a Dwarf-friendly definition, and the Dwarf spec
1824 forbids spaces in the argument list. */
1826 else if (macro
->variadic
)
1827 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1832 /* The Dwarf spec requires a space after the macro name, even if the
1833 definition is the empty string. */
1836 if (CPP_OPTION (pfile
, traditional
))
1837 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
1838 else if (macro
->count
)
1839 /* Expansion tokens. */
1841 for (i
= 0; i
< macro
->count
; i
++)
1843 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1845 if (token
->flags
& PREV_WHITE
)
1847 if (token
->flags
& STRINGIFY_ARG
)
1850 if (token
->type
== CPP_MACRO_ARG
)
1853 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]),
1854 NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]));
1855 buffer
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1858 buffer
= cpp_spell_token (pfile
, token
, buffer
, false);
1860 if (token
->flags
& PASTE_LEFT
)
1865 /* Next has PREV_WHITE; see _cpp_create_definition. */
1871 return pfile
->macro_buffer
;