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 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 In other words, you are welcome to use, share and improve this program.
23 You are forbidden to forbid anyone else to use, share and improve
24 what you give them. Help stamp out software-hoarding! */
33 cpp_hashnode
**params
; /* Parameters, if any. */
34 cpp_token
*expansion
; /* First token of replacement list. */
35 unsigned int line
; /* Starting line number. */
36 unsigned int count
; /* Number of tokens in expansion. */
37 unsigned short paramc
; /* Number of parameters. */
38 unsigned int fun_like
: 1; /* If a function-like macro. */
39 unsigned int variadic
: 1; /* If a variadic macro. */
40 unsigned int syshdr
: 1; /* If macro defined in system header. */
43 typedef struct macro_arg macro_arg
;
46 const cpp_token
**first
; /* First token in unexpanded argument. */
47 const cpp_token
**expanded
; /* Macro-expanded argument. */
48 const cpp_token
*stringified
; /* Stringified argument. */
49 unsigned int count
; /* # of tokens in argument. */
50 unsigned int expanded_count
; /* # of tokens in expanded argument. */
53 /* Macro expansion. */
55 static int enter_macro_context
PARAMS ((cpp_reader
*, cpp_hashnode
*));
56 static int builtin_macro
PARAMS ((cpp_reader
*, cpp_hashnode
*));
57 static void push_token_context
58 PARAMS ((cpp_reader
*, cpp_hashnode
*, const cpp_token
*, unsigned int));
59 static void push_ptoken_context
60 PARAMS ((cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
61 const cpp_token
**, unsigned int));
62 static _cpp_buff
*collect_args
PARAMS ((cpp_reader
*, const cpp_hashnode
*));
63 static cpp_context
*next_context
PARAMS ((cpp_reader
*));
64 static const cpp_token
*padding_token
65 PARAMS ((cpp_reader
*, const cpp_token
*));
66 static void expand_arg
PARAMS ((cpp_reader
*, macro_arg
*));
67 static const cpp_token
*new_string_token
PARAMS ((cpp_reader
*, uchar
*,
69 static const cpp_token
*new_number_token
PARAMS ((cpp_reader
*, unsigned int));
70 static const cpp_token
*stringify_arg
PARAMS ((cpp_reader
*, macro_arg
*));
71 static void paste_all_tokens
PARAMS ((cpp_reader
*, const cpp_token
*));
72 static bool paste_tokens
PARAMS ((cpp_reader
*, const cpp_token
**,
74 static void replace_args
PARAMS ((cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
76 static _cpp_buff
*funlike_invocation_p
PARAMS ((cpp_reader
*, cpp_hashnode
*));
78 /* #define directive parsing and handling. */
80 static cpp_token
*alloc_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
81 static cpp_token
*lex_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
82 static int warn_of_redefinition
PARAMS ((const cpp_hashnode
*,
84 static int save_parameter
PARAMS ((cpp_reader
*, cpp_macro
*, cpp_hashnode
*));
85 static int parse_params
PARAMS ((cpp_reader
*, cpp_macro
*));
86 static void check_trad_stringification
PARAMS ((cpp_reader
*,
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 (pfile
, text
, 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 /* Allocates and returns a CPP_NUMBER token evaluating to NUMBER. */
109 static const cpp_token
*
110 new_number_token (pfile
, number
)
114 cpp_token
*token
= _cpp_temp_token (pfile
);
115 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
116 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, 21);
118 sprintf ((char *) buf
, "%u", number
);
119 token
->type
= CPP_NUMBER
;
120 token
->val
.str
.text
= buf
;
121 token
->val
.str
.len
= ustrlen (buf
);
126 static const char * const monthnames
[] =
128 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
129 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
132 /* Handle builtin macros like __FILE__, and push the resulting token
133 on the context stack. Also handles _Pragma, for which no new token
134 is created. Returns 1 if it generates a new token context, 0 to
135 return the token to the caller. */
137 builtin_macro (pfile
, node
)
141 const cpp_token
*result
;
143 switch (node
->value
.builtin
)
146 cpp_error (pfile
, DL_ICE
, "invalid built-in macro \"%s\"",
156 const struct line_map
*map
= pfile
->map
;
158 if (node
->value
.builtin
== BT_BASE_FILE
)
159 while (! MAIN_FILE_P (map
))
160 map
= INCLUDED_FROM (&pfile
->line_maps
, map
);
164 buf
= _cpp_unaligned_alloc (pfile
, len
* 4 + 1);
165 len
= cpp_quote_string (buf
, (const unsigned char *) name
, len
) - buf
;
167 result
= new_string_token (pfile
, buf
, len
);
171 case BT_INCLUDE_LEVEL
:
172 /* The line map depth counts the primary source as level 1, but
173 historically __INCLUDE_DEPTH__ has called the primary source
175 result
= new_number_token (pfile
, pfile
->line_maps
.depth
- 1);
179 /* If __LINE__ is embedded in a macro, it must expand to the
180 line of the macro's invocation, not its definition.
181 Otherwise things like assert() will not work properly. */
182 result
= new_number_token (pfile
,
183 SOURCE_LINE (pfile
->map
,
184 pfile
->cur_token
[-1].line
));
189 int stdc
= (!CPP_IN_SYSTEM_HEADER (pfile
)
190 || pfile
->spec_nodes
.n__STRICT_ANSI__
->type
!= NT_VOID
);
191 result
= new_number_token (pfile
, stdc
);
197 if (pfile
->date
.type
== CPP_EOF
)
199 /* Allocate __DATE__ and __TIME__ strings from permanent
200 storage. We only do this once, and don't generate them
201 at init time, because time() and localtime() are very
202 slow on some systems. */
203 time_t tt
= time (NULL
);
204 struct tm
*tb
= localtime (&tt
);
206 pfile
->date
.val
.str
.text
=
207 _cpp_unaligned_alloc (pfile
, sizeof ("Oct 11 1347"));
208 pfile
->date
.val
.str
.len
= sizeof ("Oct 11 1347") - 1;
209 pfile
->date
.type
= CPP_STRING
;
210 pfile
->date
.flags
= 0;
211 sprintf ((char *) pfile
->date
.val
.str
.text
, "%s %2d %4d",
212 monthnames
[tb
->tm_mon
], tb
->tm_mday
, tb
->tm_year
+ 1900);
214 pfile
->time
.val
.str
.text
=
215 _cpp_unaligned_alloc (pfile
, sizeof ("12:34:56"));
216 pfile
->time
.val
.str
.len
= sizeof ("12:34:56") - 1;
217 pfile
->time
.type
= CPP_STRING
;
218 pfile
->time
.flags
= 0;
219 sprintf ((char *) pfile
->time
.val
.str
.text
, "%02d:%02d:%02d",
220 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
223 if (node
->value
.builtin
== BT_DATE
)
224 result
= &pfile
->date
;
226 result
= &pfile
->time
;
230 /* Don't interpret _Pragma within directives. The standard is
231 not clear on this, but to me this makes most sense. */
232 if (pfile
->state
.in_directive
)
235 _cpp_do__Pragma (pfile
);
239 push_token_context (pfile
, NULL
, result
, 1);
243 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
244 backslashes and double quotes. Non-printable characters are
245 converted to octal. DEST must be of sufficient size. Returns
246 a pointer to the end of the string. */
248 cpp_quote_string (dest
, src
, len
)
257 if (c
== '\\' || c
== '"')
268 sprintf ((char *) dest
, "\\%03o", c
);
277 /* Convert a token sequence ARG to a single string token according to
278 the rules of the ISO C #-operator. */
279 static const cpp_token
*
280 stringify_arg (pfile
, arg
)
284 unsigned char *dest
= BUFF_FRONT (pfile
->u_buff
);
285 unsigned int i
, escape_it
, backslash_count
= 0;
286 const cpp_token
*source
= NULL
;
289 /* Loop, reading in the argument's tokens. */
290 for (i
= 0; i
< arg
->count
; i
++)
292 const cpp_token
*token
= arg
->first
[i
];
294 if (token
->type
== CPP_PADDING
)
297 source
= token
->val
.source
;
301 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_WSTRING
302 || token
->type
== CPP_CHAR
|| token
->type
== CPP_WCHAR
);
304 /* Room for each char being written in octal, initial space and
306 len
= cpp_token_len (token
);
311 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
313 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
314 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
315 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
318 /* Leading white space? */
319 if (dest
!= BUFF_FRONT (pfile
->u_buff
))
323 if (source
->flags
& PREV_WHITE
)
330 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
331 unsigned char *buf
= BUFF_FRONT (buff
);
332 len
= cpp_spell_token (pfile
, token
, buf
) - buf
;
333 dest
= cpp_quote_string (dest
, buf
, len
);
334 _cpp_release_buff (pfile
, buff
);
337 dest
= cpp_spell_token (pfile
, token
, dest
);
339 if (token
->type
== CPP_OTHER
&& token
->val
.c
== '\\')
345 /* Ignore the final \ of invalid string literals. */
346 if (backslash_count
& 1)
348 cpp_error (pfile
, DL_WARNING
,
349 "invalid string literal, ignoring final '\\'");
353 /* Commit the memory, including NUL, and return the token. */
354 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
355 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
356 return new_string_token (pfile
, dest
- len
, len
);
359 /* Try to paste two tokens. On success, return non-zero. In any
360 case, PLHS is updated to point to the pasted token, which is
361 guaranteed to not have the PASTE_LEFT flag set. */
363 paste_tokens (pfile
, plhs
, rhs
)
365 const cpp_token
**plhs
, *rhs
;
367 unsigned char *buf
, *end
;
368 const cpp_token
*lhs
;
373 len
= cpp_token_len (lhs
) + cpp_token_len (rhs
) + 1;
374 buf
= (unsigned char *) alloca (len
);
375 end
= cpp_spell_token (pfile
, lhs
, buf
);
377 /* Avoid comment headers, since they are still processed in stage 3.
378 It is simpler to insert a space here, rather than modifying the
379 lexer to ignore comments in some circumstances. Simply returning
380 false doesn't work, since we want to clear the PASTE_LEFT flag. */
381 if (lhs
->type
== CPP_DIV
382 && (rhs
->type
== CPP_MULT
|| rhs
->type
== CPP_DIV
))
384 end
= cpp_spell_token (pfile
, rhs
, end
);
387 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true, 1);
389 /* Tweak the column number the lexer will report. */
390 pfile
->buffer
->col_adjust
= pfile
->cur_token
[-1].col
- 1;
392 /* We don't want a leading # to be interpreted as a directive. */
393 pfile
->buffer
->saved_flags
= 0;
395 /* Set pfile->cur_token as required by _cpp_lex_direct. */
396 pfile
->cur_token
= _cpp_temp_token (pfile
);
397 *plhs
= _cpp_lex_direct (pfile
);
398 valid
= pfile
->buffer
->cur
== pfile
->buffer
->rlimit
;
399 _cpp_pop_buffer (pfile
);
404 /* Handles an arbitrarily long sequence of ## operators, with initial
405 operand LHS. This implementation is left-associative,
406 non-recursive, and finishes a paste before handling succeeding
407 ones. If a paste fails, we back up to the RHS of the failing ##
408 operator before pushing the context containing the result of prior
409 successful pastes, with the effect that the RHS appears in the
410 output stream after the pasted LHS normally. */
412 paste_all_tokens (pfile
, lhs
)
414 const cpp_token
*lhs
;
416 const cpp_token
*rhs
;
417 cpp_context
*context
= pfile
->context
;
421 /* Take the token directly from the current context. We can do
422 this, because we are in the replacement list of either an
423 object-like macro, or a function-like macro with arguments
424 inserted. In either case, the constraints to #define
425 guarantee we have at least one more token. */
426 if (context
->direct_p
)
427 rhs
= context
->first
.token
++;
429 rhs
= *context
->first
.ptoken
++;
431 if (rhs
->type
== CPP_PADDING
)
434 if (!paste_tokens (pfile
, &lhs
, rhs
))
436 _cpp_backup_tokens (pfile
, 1);
438 /* Mandatory error for all apart from assembler. */
439 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
440 cpp_error (pfile
, DL_ERROR
,
441 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
442 cpp_token_as_text (pfile
, lhs
),
443 cpp_token_as_text (pfile
, rhs
));
447 while (rhs
->flags
& PASTE_LEFT
);
449 /* Put the resulting token in its own context. */
450 push_token_context (pfile
, NULL
, lhs
, 1);
453 /* Reads and returns the arguments to a function-like macro
454 invocation. Assumes the opening parenthesis has been processed.
455 If there is an error, emits an appropriate diagnostic and returns
456 NULL. Each argument is terminated by a CPP_EOF token, for the
457 future benefit of expand_arg(). */
459 collect_args (pfile
, node
)
461 const cpp_hashnode
*node
;
463 _cpp_buff
*buff
, *base_buff
;
465 macro_arg
*args
, *arg
;
466 const cpp_token
*token
;
470 macro
= node
->value
.macro
;
472 argc
= macro
->paramc
;
475 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
476 + sizeof (macro_arg
)));
478 args
= (macro_arg
*) buff
->base
;
479 memset (args
, 0, argc
* sizeof (macro_arg
));
480 buff
->cur
= (unsigned char *) &args
[argc
];
481 arg
= args
, argc
= 0;
483 /* Collect the tokens making up each argument. We don't yet know
484 how many arguments have been supplied, whether too many or too
485 few. Hence the slightly bizarre usage of "argc" and "arg". */
488 unsigned int paren_depth
= 0;
489 unsigned int ntokens
= 0;
492 arg
->first
= (const cpp_token
**) buff
->cur
;
496 /* Require space for 2 new tokens (including a CPP_EOF). */
497 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
499 buff
= _cpp_append_extend_buff (pfile
, buff
,
500 1000 * sizeof (cpp_token
*));
501 arg
->first
= (const cpp_token
**) buff
->cur
;
504 token
= cpp_get_token (pfile
);
506 if (token
->type
== CPP_PADDING
)
508 /* Drop leading padding. */
512 else if (token
->type
== CPP_OPEN_PAREN
)
514 else if (token
->type
== CPP_CLOSE_PAREN
)
516 if (paren_depth
-- == 0)
519 else if (token
->type
== CPP_COMMA
)
521 /* A comma does not terminate an argument within
522 parentheses or as part of a variable argument. */
524 && ! (macro
->variadic
&& argc
== macro
->paramc
))
527 else if (token
->type
== CPP_EOF
528 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
531 arg
->first
[ntokens
++] = token
;
534 /* Drop trailing padding. */
535 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
538 arg
->count
= ntokens
;
539 arg
->first
[ntokens
] = &pfile
->eof
;
541 /* Terminate the argument. Excess arguments loop back and
542 overwrite the final legitimate argument, before failing. */
543 if (argc
<= macro
->paramc
)
545 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
546 if (argc
!= macro
->paramc
)
550 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
552 if (token
->type
== CPP_EOF
)
554 /* We still need the CPP_EOF to end directives, and to end
555 pre-expansion of a macro argument. Step back is not
556 unconditional, since we don't want to return a CPP_EOF to our
557 callers at the end of an -include-d file. */
558 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
559 _cpp_backup_tokens (pfile
, 1);
560 cpp_error (pfile
, DL_ERROR
,
561 "unterminated argument list invoking macro \"%s\"",
565 else if (argc
< macro
->paramc
)
567 /* As an extension, a rest argument is allowed to not appear in
568 the invocation at all.
569 e.g. #define debug(format, args...) something
572 This is exactly the same as if there had been an empty rest
573 argument - debug("string", ). */
575 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
577 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
578 cpp_error (pfile
, DL_PEDWARN
,
579 "ISO C99 requires rest arguments to be used");
583 cpp_error (pfile
, DL_ERROR
,
584 "macro \"%s\" requires %u arguments, but only %u given",
585 NODE_NAME (node
), macro
->paramc
, argc
);
589 else if (argc
> macro
->paramc
)
591 /* Empty argument to a macro taking no arguments is OK. */
592 if (argc
!= 1 || arg
->count
)
594 cpp_error (pfile
, DL_ERROR
,
595 "macro \"%s\" passed %u arguments, but takes just %u",
596 NODE_NAME (node
), argc
, macro
->paramc
);
604 _cpp_release_buff (pfile
, base_buff
);
608 /* Search for an opening parenthesis to the macro of NODE, in such a
609 way that, if none is found, we don't lose the information in any
610 intervening padding tokens. If we find the parenthesis, collect
611 the arguments and return the buffer containing them. */
613 funlike_invocation_p (pfile
, node
)
617 const cpp_token
*token
, *padding
= NULL
;
621 token
= cpp_get_token (pfile
);
622 if (token
->type
!= CPP_PADDING
)
625 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
629 if (token
->type
== CPP_OPEN_PAREN
)
631 pfile
->state
.parsing_args
= 2;
632 return collect_args (pfile
, node
);
635 /* CPP_EOF can be the end of macro arguments, or the end of the
636 file. We mustn't back up over the latter. Ugh. */
637 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
639 /* Back up. We may have skipped padding, in which case backing
640 up more than one token when expanding macros is in general
641 too difficult. We re-insert it in its own context. */
642 _cpp_backup_tokens (pfile
, 1);
644 push_token_context (pfile
, NULL
, padding
, 1);
650 /* Push the context of a macro with hash entry NODE onto the context
651 stack. If we can successfully expand the macro, we push a context
652 containing its yet-to-be-rescanned replacement list and return one.
653 Otherwise, we don't push a context and return zero. */
655 enter_macro_context (pfile
, node
)
659 /* The presence of a macro invalidates a file's controlling macro. */
660 pfile
->mi_valid
= false;
662 /* Handle standard macros. */
663 if (! (node
->flags
& NODE_BUILTIN
))
665 cpp_macro
*macro
= node
->value
.macro
;
671 pfile
->state
.prevent_expansion
++;
672 pfile
->keep_tokens
++;
673 pfile
->state
.parsing_args
= 1;
674 buff
= funlike_invocation_p (pfile
, node
);
675 pfile
->state
.parsing_args
= 0;
676 pfile
->keep_tokens
--;
677 pfile
->state
.prevent_expansion
--;
681 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
682 cpp_error (pfile
, DL_WARNING
,
683 "function-like macro \"%s\" must be used with arguments in traditional C",
689 if (macro
->paramc
> 0)
690 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
691 _cpp_release_buff (pfile
, buff
);
694 /* Disable the macro within its expansion. */
695 node
->flags
|= NODE_DISABLED
;
697 if (macro
->paramc
== 0)
698 push_token_context (pfile
, node
, macro
->expansion
, macro
->count
);
703 /* Handle built-in macros and the _Pragma operator. */
704 return builtin_macro (pfile
, node
);
707 /* Replace the parameters in a function-like macro of NODE with the
708 actual ARGS, and place the result in a newly pushed token context.
709 Expand each argument before replacing, unless it is operated upon
710 by the # or ## operators. */
712 replace_args (pfile
, node
, macro
, args
)
718 unsigned int i
, total
;
719 const cpp_token
*src
, *limit
;
720 const cpp_token
**dest
, **first
;
724 /* First, fully macro-expand arguments, calculating the number of
725 tokens in the final expansion as we go. The ordering of the if
726 statements below is subtle; we must handle stringification before
728 total
= macro
->count
;
729 limit
= macro
->expansion
+ macro
->count
;
731 for (src
= macro
->expansion
; src
< limit
; src
++)
732 if (src
->type
== CPP_MACRO_ARG
)
734 /* Leading and trailing padding tokens. */
737 /* We have an argument. If it is not being stringified or
738 pasted it is macro-replaced before insertion. */
739 arg
= &args
[src
->val
.arg_no
- 1];
741 if (src
->flags
& STRINGIFY_ARG
)
743 if (!arg
->stringified
)
744 arg
->stringified
= stringify_arg (pfile
, arg
);
746 else if ((src
->flags
& PASTE_LEFT
)
747 || (src
> macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
)))
748 total
+= arg
->count
- 1;
752 expand_arg (pfile
, arg
);
753 total
+= arg
->expanded_count
- 1;
757 /* Now allocate space for the expansion, copy the tokens and replace
759 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
760 first
= (const cpp_token
**) buff
->base
;
763 for (src
= macro
->expansion
; src
< limit
; src
++)
766 const cpp_token
**from
, **paste_flag
;
768 if (src
->type
!= CPP_MACRO_ARG
)
775 arg
= &args
[src
->val
.arg_no
- 1];
776 if (src
->flags
& STRINGIFY_ARG
)
777 count
= 1, from
= &arg
->stringified
;
778 else if (src
->flags
& PASTE_LEFT
)
779 count
= arg
->count
, from
= arg
->first
;
780 else if (src
!= macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
))
782 count
= arg
->count
, from
= arg
->first
;
785 /* GCC has special semantics for , ## b where b is a
786 varargs parameter: the comma disappears if b was
787 given no actual arguments (not merely if b is an
788 empty argument); otherwise the paste flag is removed. */
789 if (dest
[-1]->type
== CPP_COMMA
791 && src
->val
.arg_no
== macro
->paramc
)
796 paste_flag
= dest
- 1;
798 /* Remove the paste flag if the RHS is a placemarker. */
800 paste_flag
= dest
- 1;
804 count
= arg
->expanded_count
, from
= arg
->expanded
;
806 /* Padding on the left of an argument (unless RHS of ##). */
807 if (!pfile
->state
.in_directive
808 && src
!= macro
->expansion
&& !(src
[-1].flags
& PASTE_LEFT
))
809 *dest
++ = padding_token (pfile
, src
);
813 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
816 /* With a non-empty argument on the LHS of ##, the last
817 token should be flagged PASTE_LEFT. */
818 if (src
->flags
& PASTE_LEFT
)
819 paste_flag
= dest
- 1;
822 /* Avoid paste on RHS (even case count == 0). */
823 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
824 *dest
++ = &pfile
->avoid_paste
;
826 /* Add a new paste flag, or remove an unwanted one. */
829 cpp_token
*token
= _cpp_temp_token (pfile
);
830 token
->type
= (*paste_flag
)->type
;
831 token
->val
.str
= (*paste_flag
)->val
.str
;
832 if (src
->flags
& PASTE_LEFT
)
833 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
835 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
840 /* Free the expanded arguments. */
841 for (i
= 0; i
< macro
->paramc
; i
++)
842 if (args
[i
].expanded
)
843 free (args
[i
].expanded
);
845 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
848 /* Return a special padding token, with padding inherited from SOURCE. */
849 static const cpp_token
*
850 padding_token (pfile
, source
)
852 const cpp_token
*source
;
854 cpp_token
*result
= _cpp_temp_token (pfile
);
856 result
->type
= CPP_PADDING
;
857 result
->val
.source
= source
;
862 /* Get a new uninitialized context. Create a new one if we cannot
863 re-use an old one. */
868 cpp_context
*result
= pfile
->context
->next
;
872 result
= xnew (cpp_context
);
873 result
->prev
= pfile
->context
;
875 pfile
->context
->next
= result
;
878 pfile
->context
= result
;
882 /* Push a list of pointers to tokens. */
884 push_ptoken_context (pfile
, macro
, buff
, first
, count
)
888 const cpp_token
**first
;
891 cpp_context
*context
= next_context (pfile
);
893 context
->direct_p
= false;
894 context
->macro
= macro
;
895 context
->buff
= buff
;
896 context
->first
.ptoken
= first
;
897 context
->last
.ptoken
= first
+ count
;
900 /* Push a list of tokens. */
902 push_token_context (pfile
, macro
, first
, count
)
905 const cpp_token
*first
;
908 cpp_context
*context
= next_context (pfile
);
910 context
->direct_p
= true;
911 context
->macro
= macro
;
912 context
->buff
= NULL
;
913 context
->first
.token
= first
;
914 context
->last
.token
= first
+ count
;
917 /* Expand an argument ARG before replacing parameters in a
918 function-like macro. This works by pushing a context with the
919 argument's tokens, and then expanding that into a temporary buffer
920 as if it were a normal part of the token stream. collect_args()
921 has terminated the argument's tokens with a CPP_EOF so that we know
922 when we have fully expanded the argument. */
924 expand_arg (pfile
, arg
)
928 unsigned int capacity
;
933 /* Loop, reading in the arguments. */
935 arg
->expanded
= (const cpp_token
**)
936 xmalloc (capacity
* sizeof (cpp_token
*));
938 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
941 const cpp_token
*token
;
943 if (arg
->expanded_count
+ 1 >= capacity
)
946 arg
->expanded
= (const cpp_token
**)
947 xrealloc (arg
->expanded
, capacity
* sizeof (cpp_token
*));
950 token
= cpp_get_token (pfile
);
952 if (token
->type
== CPP_EOF
)
955 arg
->expanded
[arg
->expanded_count
++] = token
;
958 _cpp_pop_context (pfile
);
961 /* Pop the current context off the stack, re-enabling the macro if the
962 context represented a macro's replacement list. The context
963 structure is not freed so that we can re-use it later. */
965 _cpp_pop_context (pfile
)
968 cpp_context
*context
= pfile
->context
;
971 context
->macro
->flags
&= ~NODE_DISABLED
;
974 _cpp_release_buff (pfile
, context
->buff
);
976 pfile
->context
= context
->prev
;
979 /* Eternal routine to get a token. Also used nearly everywhere
980 internally, except for places where we know we can safely call
981 the lexer directly, such as lexing a directive name.
983 Macro expansions and directives are transparently handled,
984 including entering included files. Thus tokens are post-macro
985 expansion, and after any intervening directives. External callers
986 see CPP_EOF only at EOF. Internal callers also see it when meeting
987 a directive inside a macro call, when at the end of a directive and
988 state.in_directive is still 1, and at the end of argument
991 cpp_get_token (pfile
)
994 const cpp_token
*result
;
999 cpp_context
*context
= pfile
->context
;
1001 /* Context->prev == 0 <=> base context. */
1003 result
= _cpp_lex_token (pfile
);
1004 else if (context
->first
.token
!= context
->last
.token
)
1006 if (context
->direct_p
)
1007 result
= context
->first
.token
++;
1009 result
= *context
->first
.ptoken
++;
1011 if (result
->flags
& PASTE_LEFT
)
1013 paste_all_tokens (pfile
, result
);
1014 if (pfile
->state
.in_directive
)
1016 return padding_token (pfile
, result
);
1021 _cpp_pop_context (pfile
);
1022 if (pfile
->state
.in_directive
)
1024 return &pfile
->avoid_paste
;
1027 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1030 if (result
->type
!= CPP_NAME
)
1033 node
= result
->val
.node
;
1035 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1038 if (!(node
->flags
& NODE_DISABLED
))
1040 if (!pfile
->state
.prevent_expansion
1041 && enter_macro_context (pfile
, node
))
1043 if (pfile
->state
.in_directive
)
1045 return padding_token (pfile
, result
);
1050 /* Flag this token as always unexpandable. FIXME: move this
1051 to collect_args()?. */
1052 cpp_token
*t
= _cpp_temp_token (pfile
);
1053 t
->type
= result
->type
;
1054 t
->flags
= result
->flags
| NO_EXPAND
;
1055 t
->val
.str
= result
->val
.str
;
1065 /* Returns true if we're expanding an object-like macro that was
1066 defined in a system header. Just checks the macro at the top of
1067 the stack. Used for diagnostic suppression. */
1069 cpp_sys_macro_p (pfile
)
1072 cpp_hashnode
*node
= pfile
->context
->macro
;
1074 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1077 /* Read each token in, until end of the current file. Directives are
1078 transparently processed. */
1080 cpp_scan_nooutput (pfile
)
1083 /* Request a CPP_EOF token at the end of this file, rather than
1084 transparently continuing with the including file. */
1085 pfile
->buffer
->return_at_eof
= true;
1087 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1091 /* Step back one (or more) tokens. Can only step mack more than 1 if
1092 they are from the lexer, and not from macro expansion. */
1094 _cpp_backup_tokens (pfile
, count
)
1098 if (pfile
->context
->prev
== NULL
)
1100 pfile
->lookaheads
+= count
;
1104 if (pfile
->cur_token
== pfile
->cur_run
->base
1105 /* Possible with -fpreprocessed and no leading #line. */
1106 && pfile
->cur_run
->prev
!= NULL
)
1108 pfile
->cur_run
= pfile
->cur_run
->prev
;
1109 pfile
->cur_token
= pfile
->cur_run
->limit
;
1117 if (pfile
->context
->direct_p
)
1118 pfile
->context
->first
.token
--;
1120 pfile
->context
->first
.ptoken
--;
1124 /* #define directive parsing and handling. */
1126 /* Returns non-zero if a macro redefinition warning is required. */
1128 warn_of_redefinition (node
, macro2
)
1129 const cpp_hashnode
*node
;
1130 const cpp_macro
*macro2
;
1132 const cpp_macro
*macro1
;
1135 /* Some redefinitions need to be warned about regardless. */
1136 if (node
->flags
& NODE_WARN
)
1139 /* Redefinition of a macro is allowed if and only if the old and new
1140 definitions are the same. (6.10.3 paragraph 2). */
1141 macro1
= node
->value
.macro
;
1143 /* The quick failures. */
1144 if (macro1
->count
!= macro2
->count
1145 || macro1
->paramc
!= macro2
->paramc
1146 || macro1
->fun_like
!= macro2
->fun_like
1147 || macro1
->variadic
!= macro2
->variadic
)
1150 /* Check each token. */
1151 for (i
= 0; i
< macro1
->count
; i
++)
1152 if (! _cpp_equiv_tokens (¯o1
->expansion
[i
], ¯o2
->expansion
[i
]))
1155 /* Check parameter spellings. */
1156 for (i
= 0; i
< macro1
->paramc
; i
++)
1157 if (macro1
->params
[i
] != macro2
->params
[i
])
1163 /* Free the definition of hashnode H. */
1165 _cpp_free_definition (h
)
1168 /* Macros and assertions no longer have anything to free. */
1170 /* Clear builtin flag in case of redefinition. */
1171 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
);
1174 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1175 zero on success, non-zero if the parameter is a duplicate. */
1177 save_parameter (pfile
, macro
, node
)
1182 /* Constraint 6.10.3.6 - duplicate parameter names. */
1183 if (node
->arg_index
)
1185 cpp_error (pfile
, DL_ERROR
, "duplicate macro parameter \"%s\"",
1190 if (BUFF_ROOM (pfile
->a_buff
)
1191 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1192 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1194 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1195 node
->arg_index
= macro
->paramc
;
1199 /* Check the syntax of the parameters in a MACRO definition. */
1201 parse_params (pfile
, macro
)
1205 unsigned int prev_ident
= 0;
1209 const cpp_token
*token
= _cpp_lex_token (pfile
);
1211 switch (token
->type
)
1214 /* Allow/ignore comments in parameter lists if we are
1215 preserving comments in macro expansions. */
1216 if (token
->type
== CPP_COMMENT
1217 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1220 cpp_error (pfile
, DL_ERROR
,
1221 "\"%s\" may not appear in macro parameter list",
1222 cpp_token_as_text (pfile
, token
));
1228 cpp_error (pfile
, DL_ERROR
,
1229 "macro parameters must be comma-separated");
1234 if (save_parameter (pfile
, macro
, token
->val
.node
))
1238 case CPP_CLOSE_PAREN
:
1239 if (prev_ident
|| macro
->paramc
== 0)
1242 /* Fall through to pick up the error. */
1246 cpp_error (pfile
, DL_ERROR
, "parameter name missing");
1253 macro
->variadic
= 1;
1256 save_parameter (pfile
, macro
, pfile
->spec_nodes
.n__VA_ARGS__
);
1257 pfile
->state
.va_args_ok
= 1;
1258 if (! CPP_OPTION (pfile
, c99
) && CPP_OPTION (pfile
, pedantic
))
1259 cpp_error (pfile
, DL_PEDWARN
,
1260 "anonymous variadic macros were introduced in C99");
1262 else if (CPP_OPTION (pfile
, pedantic
))
1263 cpp_error (pfile
, DL_PEDWARN
,
1264 "ISO C does not permit named variadic macros");
1266 /* We're at the end, and just expect a closing parenthesis. */
1267 token
= _cpp_lex_token (pfile
);
1268 if (token
->type
== CPP_CLOSE_PAREN
)
1273 cpp_error (pfile
, DL_ERROR
, "missing ')' in macro parameter list");
1279 /* Allocate room for a token from a macro's replacement list. */
1281 alloc_expansion_token (pfile
, macro
)
1285 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1286 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1288 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1291 /* Lex a token from the expansion of MACRO, but mark parameters as we
1292 find them and warn of traditional stringification. */
1294 lex_expansion_token (pfile
, macro
)
1300 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1301 token
= _cpp_lex_direct (pfile
);
1303 /* Is this a parameter? */
1304 if (token
->type
== CPP_NAME
&& token
->val
.node
->arg_index
)
1306 token
->type
= CPP_MACRO_ARG
;
1307 token
->val
.arg_no
= token
->val
.node
->arg_index
;
1309 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1310 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1311 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1316 /* Parse a macro and save its expansion. Returns non-zero on success. */
1318 _cpp_create_definition (pfile
, node
)
1323 cpp_token
*token
, *saved_cur_token
;
1324 const cpp_token
*ctoken
;
1325 unsigned int i
, ok
= 1;
1327 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1328 macro
->line
= pfile
->directive_line
;
1331 macro
->variadic
= 0;
1333 macro
->fun_like
= 0;
1335 /* Get the first token of the expansion (or the '(' of a
1336 function-like macro). */
1337 ctoken
= _cpp_lex_token (pfile
);
1339 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1341 ok
= parse_params (pfile
, macro
);
1342 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1346 /* Success. Commit the parameter array. */
1347 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1348 macro
->fun_like
= 1;
1350 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1351 cpp_error (pfile
, DL_PEDWARN
,
1352 "ISO C requires whitespace after the macro name");
1354 saved_cur_token
= pfile
->cur_token
;
1356 if (macro
->fun_like
)
1357 token
= lex_expansion_token (pfile
, macro
);
1360 token
= alloc_expansion_token (pfile
, macro
);
1366 /* Check the stringifying # constraint 6.10.3.2.1 of
1367 function-like macros when lexing the subsequent token. */
1368 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1370 if (token
->type
== CPP_MACRO_ARG
)
1372 token
->flags
&= ~PREV_WHITE
;
1373 token
->flags
|= STRINGIFY_ARG
;
1374 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1375 token
[-1] = token
[0];
1378 /* Let assembler get away with murder. */
1379 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1382 cpp_error (pfile
, DL_ERROR
,
1383 "'#' is not followed by a macro parameter");
1388 if (token
->type
== CPP_EOF
)
1391 /* Paste operator constraint 6.10.3.3.1. */
1392 if (token
->type
== CPP_PASTE
)
1394 /* Token-paste ##, can appear in both object-like and
1395 function-like macros, but not at the ends. */
1396 if (--macro
->count
> 0)
1397 token
= lex_expansion_token (pfile
, macro
);
1399 if (macro
->count
== 0 || token
->type
== CPP_EOF
)
1402 cpp_error (pfile
, DL_ERROR
,
1403 "'##' cannot appear at either end of a macro expansion");
1407 token
[-1].flags
|= PASTE_LEFT
;
1410 token
= lex_expansion_token (pfile
, macro
);
1413 macro
->expansion
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1415 /* Don't count the CPP_EOF. */
1418 /* Clear whitespace on first token for warn_of_redefinition(). */
1420 macro
->expansion
[0].flags
&= ~PREV_WHITE
;
1422 /* Commit the memory. */
1423 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->expansion
[macro
->count
];
1425 /* Implement the macro-defined-to-itself optimisation. */
1426 if (macro
->count
== 1 && !macro
->fun_like
1427 && macro
->expansion
[0].type
== CPP_NAME
1428 && macro
->expansion
[0].val
.node
== node
)
1429 node
->flags
|= NODE_DISABLED
;
1431 /* To suppress some diagnostics. */
1432 macro
->syshdr
= pfile
->map
->sysp
!= 0;
1434 if (node
->type
!= NT_VOID
)
1436 if (warn_of_redefinition (node
, macro
))
1438 cpp_error_with_line (pfile
, DL_PEDWARN
, pfile
->directive_line
, 0,
1439 "\"%s\" redefined", NODE_NAME (node
));
1441 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1442 cpp_error_with_line (pfile
, DL_PEDWARN
, node
->value
.macro
->line
, 0,
1443 "this is the location of the previous definition");
1445 _cpp_free_definition (node
);
1448 /* Enter definition in hash table. */
1449 node
->type
= NT_MACRO
;
1450 node
->value
.macro
= macro
;
1451 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
1452 node
->flags
|= NODE_WARN
;
1456 /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position. */
1457 saved_cur_token
[-1].type
= pfile
->cur_token
[-1].type
;
1458 pfile
->cur_token
= saved_cur_token
;
1462 /* Stop the lexer accepting __VA_ARGS__. */
1463 pfile
->state
.va_args_ok
= 0;
1465 /* Clear the fast argument lookup indices. */
1466 for (i
= macro
->paramc
; i
-- > 0; )
1467 macro
->params
[i
]->arg_index
= 0;
1472 /* Warn if a token in STRING matches one of a function-like MACRO's
1475 check_trad_stringification (pfile
, macro
, string
)
1477 const cpp_macro
*macro
;
1478 const cpp_string
*string
;
1480 unsigned int i
, len
;
1481 const uchar
*p
, *q
, *limit
= string
->text
+ string
->len
;
1483 /* Loop over the string. */
1484 for (p
= string
->text
; p
< limit
; p
= q
)
1486 /* Find the start of an identifier. */
1487 while (p
< limit
&& !is_idstart (*p
))
1490 /* Find the end of the identifier. */
1492 while (q
< limit
&& is_idchar (*q
))
1497 /* Loop over the function macro arguments to see if the
1498 identifier inside the string matches one of them. */
1499 for (i
= 0; i
< macro
->paramc
; i
++)
1501 const cpp_hashnode
*node
= macro
->params
[i
];
1503 if (NODE_LEN (node
) == len
1504 && !memcmp (p
, NODE_NAME (node
), len
))
1506 cpp_error (pfile
, DL_WARNING
,
1507 "macro argument \"%s\" would be stringified in traditional C",
1515 /* Returns the name, arguments and expansion of a macro, in a format
1516 suitable to be read back in again, and therefore also for DWARF 2
1517 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1518 Caller is expected to generate the "#define" bit if needed. The
1519 returned text is temporary, and automatically freed later. */
1520 const unsigned char *
1521 cpp_macro_definition (pfile
, node
)
1523 const cpp_hashnode
*node
;
1525 unsigned int i
, len
;
1526 const cpp_macro
*macro
= node
->value
.macro
;
1527 unsigned char *buffer
;
1529 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1531 cpp_error (pfile
, DL_ICE
,
1532 "invalid hash type %d in cpp_macro_definition", node
->type
);
1536 /* Calculate length. */
1537 len
= NODE_LEN (node
) + 1; /* ' ' */
1538 if (macro
->fun_like
)
1540 len
+= 4; /* "()" plus possible final ".." of named
1541 varargs (we have + 1 below). */
1542 for (i
= 0; i
< macro
->paramc
; i
++)
1543 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1546 for (i
= 0; i
< macro
->count
; i
++)
1548 cpp_token
*token
= ¯o
->expansion
[i
];
1550 if (token
->type
== CPP_MACRO_ARG
)
1551 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1553 len
+= cpp_token_len (token
); /* Includes room for ' '. */
1554 if (token
->flags
& STRINGIFY_ARG
)
1556 if (token
->flags
& PASTE_LEFT
)
1557 len
+= 3; /* " ##" */
1560 if (len
> pfile
->macro_buffer_len
)
1562 pfile
->macro_buffer
= (uchar
*) xrealloc (pfile
->macro_buffer
, len
);
1563 pfile
->macro_buffer_len
= len
;
1566 /* Fill in the buffer. Start with the macro name. */
1567 buffer
= pfile
->macro_buffer
;
1568 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1569 buffer
+= NODE_LEN (node
);
1571 /* Parameter names. */
1572 if (macro
->fun_like
)
1575 for (i
= 0; i
< macro
->paramc
; i
++)
1577 cpp_hashnode
*param
= macro
->params
[i
];
1579 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1581 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1582 buffer
+= NODE_LEN (param
);
1585 if (i
+ 1 < macro
->paramc
)
1586 /* Don't emit a space after the comma here; we're trying
1587 to emit a Dwarf-friendly definition, and the Dwarf spec
1588 forbids spaces in the argument list. */
1590 else if (macro
->variadic
)
1591 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1596 /* The Dwarf spec requires a space after the macro name, even if the
1597 definition is the empty string. */
1600 /* Expansion tokens. */
1603 for (i
= 0; i
< macro
->count
; i
++)
1605 cpp_token
*token
= ¯o
->expansion
[i
];
1607 if (token
->flags
& PREV_WHITE
)
1609 if (token
->flags
& STRINGIFY_ARG
)
1612 if (token
->type
== CPP_MACRO_ARG
)
1614 len
= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1616 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]), len
);
1620 buffer
= cpp_spell_token (pfile
, token
, buffer
);
1622 if (token
->flags
& PASTE_LEFT
)
1627 /* Next has PREV_WHITE; see _cpp_create_definition. */
1633 return pfile
->macro_buffer
;