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
*, U_CHAR
*,
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
*, macro_arg
*));
75 static _cpp_buff
*funlike_invocation_p
PARAMS ((cpp_reader
*, cpp_hashnode
*));
77 /* #define directive parsing and handling. */
79 static cpp_token
*alloc_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
80 static cpp_token
*lex_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
81 static int warn_of_redefinition
PARAMS ((const cpp_hashnode
*,
83 static int save_parameter
PARAMS ((cpp_reader
*, cpp_macro
*, cpp_hashnode
*));
84 static int parse_params
PARAMS ((cpp_reader
*, cpp_macro
*));
85 static void check_trad_stringification
PARAMS ((cpp_reader
*,
89 /* Allocates and returns a CPP_STRING token, containing TEXT of length
90 LEN, after null-terminating it. TEXT must be in permanent storage. */
91 static const cpp_token
*
92 new_string_token (pfile
, text
, len
)
97 cpp_token
*token
= _cpp_temp_token (pfile
);
100 token
->type
= CPP_STRING
;
101 token
->val
.str
.len
= len
;
102 token
->val
.str
.text
= text
;
107 /* Allocates and returns a CPP_NUMBER token evaluating to NUMBER. */
108 static const cpp_token
*
109 new_number_token (pfile
, number
)
113 cpp_token
*token
= _cpp_temp_token (pfile
);
114 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
115 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, 21);
117 sprintf ((char *) buf
, "%u", number
);
118 token
->type
= CPP_NUMBER
;
119 token
->val
.str
.text
= buf
;
120 token
->val
.str
.len
= ustrlen (buf
);
125 static const char * const monthnames
[] =
127 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
128 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
131 /* Handle builtin macros like __FILE__, and push the resulting token
132 on the context stack. Also handles _Pragma, for which no new token
133 is created. Returns 1 if it generates a new token context, 0 to
134 return the token to the caller. */
136 builtin_macro (pfile
, node
)
140 const cpp_token
*result
;
142 switch (node
->value
.builtin
)
145 cpp_ice (pfile
, "invalid built-in macro \"%s\"", NODE_NAME (node
));
154 const struct line_map
*map
= pfile
->map
;
156 if (node
->value
.builtin
== BT_BASE_FILE
)
157 while (! MAIN_FILE_P (map
))
158 map
= INCLUDED_FROM (&pfile
->line_maps
, map
);
162 buf
= _cpp_unaligned_alloc (pfile
, len
* 4 + 1);
163 len
= cpp_quote_string (buf
, (const unsigned char *) name
, len
) - buf
;
165 result
= new_string_token (pfile
, buf
, len
);
169 case BT_INCLUDE_LEVEL
:
170 /* The line map depth counts the primary source as level 1, but
171 historically __INCLUDE_DEPTH__ has called the primary source
173 result
= new_number_token (pfile
, pfile
->line_maps
.depth
- 1);
177 /* If __LINE__ is embedded in a macro, it must expand to the
178 line of the macro's invocation, not its definition.
179 Otherwise things like assert() will not work properly. */
180 result
= new_number_token (pfile
,
181 SOURCE_LINE (pfile
->map
,
182 pfile
->cur_token
[-1].line
));
187 int stdc
= (!CPP_IN_SYSTEM_HEADER (pfile
)
188 || pfile
->spec_nodes
.n__STRICT_ANSI__
->type
!= NT_VOID
);
189 result
= new_number_token (pfile
, stdc
);
195 if (pfile
->date
.type
== CPP_EOF
)
197 /* Allocate __DATE__ and __TIME__ strings from permanent
198 storage. We only do this once, and don't generate them
199 at init time, because time() and localtime() are very
200 slow on some systems. */
201 time_t tt
= time (NULL
);
202 struct tm
*tb
= localtime (&tt
);
204 pfile
->date
.val
.str
.text
=
205 _cpp_unaligned_alloc (pfile
, sizeof ("Oct 11 1347"));
206 pfile
->date
.val
.str
.len
= sizeof ("Oct 11 1347") - 1;
207 pfile
->date
.type
= CPP_STRING
;
208 pfile
->date
.flags
= 0;
209 sprintf ((char *) pfile
->date
.val
.str
.text
, "%s %2d %4d",
210 monthnames
[tb
->tm_mon
], tb
->tm_mday
, tb
->tm_year
+ 1900);
212 pfile
->time
.val
.str
.text
=
213 _cpp_unaligned_alloc (pfile
, sizeof ("12:34:56"));
214 pfile
->time
.val
.str
.len
= sizeof ("12:34:56") - 1;
215 pfile
->time
.type
= CPP_STRING
;
216 pfile
->time
.flags
= 0;
217 sprintf ((char *) pfile
->time
.val
.str
.text
, "%02d:%02d:%02d",
218 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
221 if (node
->value
.builtin
== BT_DATE
)
222 result
= &pfile
->date
;
224 result
= &pfile
->time
;
228 /* Don't interpret _Pragma within directives. The standard is
229 not clear on this, but to me this makes most sense. */
230 if (pfile
->state
.in_directive
)
233 _cpp_do__Pragma (pfile
);
237 push_token_context (pfile
, NULL
, result
, 1);
241 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
242 backslashes and double quotes. Non-printable characters are
243 converted to octal. DEST must be of sufficient size. Returns
244 a pointer to the end of the string. */
246 cpp_quote_string (dest
, src
, len
)
255 if (c
== '\\' || c
== '"')
266 sprintf ((char *) dest
, "\\%03o", c
);
275 /* Convert a token sequence ARG to a single string token according to
276 the rules of the ISO C #-operator. */
277 static const cpp_token
*
278 stringify_arg (pfile
, arg
)
282 unsigned char *dest
= BUFF_FRONT (pfile
->u_buff
);
283 unsigned int i
, escape_it
, backslash_count
= 0;
284 const cpp_token
*source
= NULL
;
287 /* Loop, reading in the argument's tokens. */
288 for (i
= 0; i
< arg
->count
; i
++)
290 const cpp_token
*token
= arg
->first
[i
];
292 if (token
->type
== CPP_PADDING
)
295 source
= token
->val
.source
;
299 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_WSTRING
300 || token
->type
== CPP_CHAR
|| token
->type
== CPP_WCHAR
);
302 /* Room for each char being written in octal, initial space and
304 len
= cpp_token_len (token
);
309 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
311 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
312 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
313 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
316 /* Leading white space? */
317 if (dest
!= BUFF_FRONT (pfile
->u_buff
))
321 if (source
->flags
& PREV_WHITE
)
328 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
329 unsigned char *buf
= BUFF_FRONT (buff
);
330 len
= cpp_spell_token (pfile
, token
, buf
) - buf
;
331 dest
= cpp_quote_string (dest
, buf
, len
);
332 _cpp_release_buff (pfile
, buff
);
335 dest
= cpp_spell_token (pfile
, token
, dest
);
337 if (token
->type
== CPP_OTHER
&& token
->val
.c
== '\\')
343 /* Ignore the final \ of invalid string literals. */
344 if (backslash_count
& 1)
346 cpp_warning (pfile
, "invalid string literal, ignoring final '\\'");
350 /* Commit the memory, including NUL, and return the token. */
351 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
352 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
353 return new_string_token (pfile
, dest
- len
, len
);
356 /* Try to paste two tokens. On success, return non-zero. In any
357 case, PLHS is updated to point to the pasted token, which is
358 guaranteed to not have the PASTE_LEFT flag set. */
360 paste_tokens (pfile
, plhs
, rhs
)
362 const cpp_token
**plhs
, *rhs
;
364 unsigned char *buf
, *end
;
365 const cpp_token
*lhs
;
370 len
= cpp_token_len (lhs
) + cpp_token_len (rhs
) + 1;
371 buf
= (unsigned char *) alloca (len
);
372 end
= cpp_spell_token (pfile
, lhs
, buf
);
374 /* Avoid comment headers, since they are still processed in stage 3.
375 It is simpler to insert a space here, rather than modifying the
376 lexer to ignore comments in some circumstances. Simply returning
377 false doesn't work, since we want to clear the PASTE_LEFT flag. */
378 if (lhs
->type
== CPP_DIV
379 && (rhs
->type
== CPP_MULT
|| rhs
->type
== CPP_DIV
))
381 end
= cpp_spell_token (pfile
, rhs
, end
);
384 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true, 1);
386 /* Tweak the column number the lexer will report. */
387 pfile
->buffer
->col_adjust
= pfile
->cur_token
[-1].col
- 1;
389 /* We don't want a leading # to be interpreted as a directive. */
390 pfile
->buffer
->saved_flags
= 0;
392 /* Set pfile->cur_token as required by _cpp_lex_direct. */
393 pfile
->cur_token
= _cpp_temp_token (pfile
);
394 *plhs
= _cpp_lex_direct (pfile
);
395 valid
= pfile
->buffer
->cur
== pfile
->buffer
->rlimit
;
396 _cpp_pop_buffer (pfile
);
401 /* Handles an arbitrarily long sequence of ## operators, with initial
402 operand LHS. This implementation is left-associative,
403 non-recursive, and finishes a paste before handling succeeding
404 ones. If a paste fails, we back up to the RHS of the failing ##
405 operator before pushing the context containing the result of prior
406 successful pastes, with the effect that the RHS appears in the
407 output stream after the pasted LHS normally. */
409 paste_all_tokens (pfile
, lhs
)
411 const cpp_token
*lhs
;
413 const cpp_token
*rhs
;
414 cpp_context
*context
= pfile
->context
;
418 /* Take the token directly from the current context. We can do
419 this, because we are in the replacement list of either an
420 object-like macro, or a function-like macro with arguments
421 inserted. In either case, the constraints to #define
422 guarantee we have at least one more token. */
423 if (context
->direct_p
)
424 rhs
= context
->first
.token
++;
426 rhs
= *context
->first
.ptoken
++;
428 if (rhs
->type
== CPP_PADDING
)
431 if (!paste_tokens (pfile
, &lhs
, rhs
))
433 _cpp_backup_tokens (pfile
, 1);
435 /* Mandatory warning for all apart from assembler. */
436 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
438 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
439 cpp_token_as_text (pfile
, lhs
),
440 cpp_token_as_text (pfile
, rhs
));
444 while (rhs
->flags
& PASTE_LEFT
);
446 /* Put the resulting token in its own context. */
447 push_token_context (pfile
, NULL
, lhs
, 1);
450 /* Reads and returns the arguments to a function-like macro
451 invocation. Assumes the opening parenthesis has been processed.
452 If there is an error, emits an appropriate diagnostic and returns
453 NULL. Each argument is terminated by a CPP_EOF token, for the
454 future benefit of expand_arg(). */
456 collect_args (pfile
, node
)
458 const cpp_hashnode
*node
;
460 _cpp_buff
*buff
, *base_buff
;
462 macro_arg
*args
, *arg
;
463 const cpp_token
*token
;
467 macro
= node
->value
.macro
;
469 argc
= macro
->paramc
;
472 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
473 + sizeof (macro_arg
)));
475 args
= (macro_arg
*) buff
->base
;
476 memset (args
, 0, argc
* sizeof (macro_arg
));
477 buff
->cur
= (unsigned char *) &args
[argc
];
478 arg
= args
, argc
= 0;
480 /* Collect the tokens making up each argument. We don't yet know
481 how many arguments have been supplied, whether too many or too
482 few. Hence the slightly bizarre usage of "argc" and "arg". */
485 unsigned int paren_depth
= 0;
486 unsigned int ntokens
= 0;
489 arg
->first
= (const cpp_token
**) buff
->cur
;
493 /* Require space for 2 new tokens (including a CPP_EOF). */
494 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
496 buff
= _cpp_append_extend_buff (pfile
, buff
,
497 1000 * sizeof (cpp_token
*));
498 arg
->first
= (const cpp_token
**) buff
->cur
;
501 token
= cpp_get_token (pfile
);
503 if (token
->type
== CPP_PADDING
)
505 /* Drop leading padding. */
509 else if (token
->type
== CPP_OPEN_PAREN
)
511 else if (token
->type
== CPP_CLOSE_PAREN
)
513 if (paren_depth
-- == 0)
516 else if (token
->type
== CPP_COMMA
)
518 /* A comma does not terminate an argument within
519 parentheses or as part of a variable argument. */
521 && ! (macro
->variadic
&& argc
== macro
->paramc
))
524 else if (token
->type
== CPP_EOF
525 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
528 arg
->first
[ntokens
++] = token
;
531 /* Drop trailing padding. */
532 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
535 arg
->count
= ntokens
;
536 arg
->first
[ntokens
] = &pfile
->eof
;
538 /* Terminate the argument. Excess arguments loop back and
539 overwrite the final legitimate argument, before failing. */
540 if (argc
<= macro
->paramc
)
542 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
543 if (argc
!= macro
->paramc
)
547 while (token
->type
!= CPP_CLOSE_PAREN
548 && token
->type
!= CPP_EOF
549 && token
->type
!= CPP_HASH
);
551 if (token
->type
== CPP_EOF
|| token
->type
== CPP_HASH
)
553 bool step_back
= false;
555 /* 6.10.3 paragraph 11: If there are sequences of preprocessing
556 tokens within the list of arguments that would otherwise act
557 as preprocessing directives, the behavior is undefined.
559 This implementation will report a hard error, terminate the
560 macro invocation, and proceed to process the directive. */
561 if (token
->type
== CPP_HASH
)
564 "directives may not be used inside a macro argument");
568 step_back
= (pfile
->context
->prev
|| pfile
->state
.in_directive
);
570 /* We still need the CPP_EOF to end directives, and to end
571 pre-expansion of a macro argument. Step back is not
572 unconditional, since we don't want to return a CPP_EOF to our
573 callers at the end of an -include-d file. */
575 _cpp_backup_tokens (pfile
, 1);
576 cpp_error (pfile
, "unterminated argument list invoking macro \"%s\"",
580 else if (argc
< macro
->paramc
)
582 /* As an extension, a rest argument is allowed to not appear in
583 the invocation at all.
584 e.g. #define debug(format, args...) something
587 This is exactly the same as if there had been an empty rest
588 argument - debug("string", ). */
590 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
592 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
593 cpp_pedwarn (pfile
, "ISO C99 requires rest arguments to be used");
598 "macro \"%s\" requires %u arguments, but only %u given",
599 NODE_NAME (node
), macro
->paramc
, argc
);
603 else if (argc
> macro
->paramc
)
605 /* Empty argument to a macro taking no arguments is OK. */
606 if (argc
!= 1 || arg
->count
)
609 "macro \"%s\" passed %u arguments, but takes just %u",
610 NODE_NAME (node
), argc
, macro
->paramc
);
618 _cpp_release_buff (pfile
, base_buff
);
622 /* Search for an opening parenthesis to the macro of NODE, in such a
623 way that, if none is found, we don't lose the information in any
624 intervening padding tokens. If we find the parenthesis, collect
625 the arguments and return the buffer containing them. */
627 funlike_invocation_p (pfile
, node
)
631 const cpp_token
*token
, *padding
= NULL
;
635 token
= cpp_get_token (pfile
);
636 if (token
->type
!= CPP_PADDING
)
639 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
643 if (token
->type
== CPP_OPEN_PAREN
)
645 pfile
->state
.parsing_args
= 2;
646 return collect_args (pfile
, node
);
649 /* CPP_EOF can be the end of macro arguments, or the end of the
650 file. We mustn't back up over the latter. Ugh. */
651 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
653 /* Back up. We may have skipped padding, in which case backing
654 up more than one token when expanding macros is in general
655 too difficult. We re-insert it in its own context. */
656 _cpp_backup_tokens (pfile
, 1);
658 push_token_context (pfile
, NULL
, padding
, 1);
664 /* Push the context of a macro with hash entry NODE onto the context
665 stack. If we can successfully expand the macro, we push a context
666 containing its yet-to-be-rescanned replacement list and return one.
667 Otherwise, we don't push a context and return zero. */
669 enter_macro_context (pfile
, node
)
673 /* The presence of a macro invalidates a file's controlling macro. */
674 pfile
->mi_valid
= false;
676 pfile
->state
.angled_headers
= false;
678 /* Handle standard macros. */
679 if (! (node
->flags
& NODE_BUILTIN
))
681 cpp_macro
*macro
= node
->value
.macro
;
687 pfile
->state
.prevent_expansion
++;
688 pfile
->keep_tokens
++;
689 pfile
->state
.parsing_args
= 1;
690 buff
= funlike_invocation_p (pfile
, node
);
691 pfile
->state
.parsing_args
= 0;
692 pfile
->keep_tokens
--;
693 pfile
->state
.prevent_expansion
--;
697 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
699 "function-like macro \"%s\" must be used with arguments in traditional C",
705 if (node
->value
.macro
->paramc
> 0)
706 replace_args (pfile
, node
, (macro_arg
*) buff
->base
);
707 _cpp_release_buff (pfile
, buff
);
710 /* Disable the macro within its expansion. */
711 node
->flags
|= NODE_DISABLED
;
713 if (macro
->paramc
== 0)
714 push_token_context (pfile
, node
, macro
->expansion
, macro
->count
);
719 /* Handle built-in macros and the _Pragma operator. */
720 return builtin_macro (pfile
, node
);
723 /* Replace the parameters in a function-like macro of NODE with the
724 actual ARGS, and place the result in a newly pushed token context.
725 Expand each argument before replacing, unless it is operated upon
726 by the # or ## operators. */
728 replace_args (pfile
, node
, args
)
733 unsigned int i
, total
;
734 const cpp_token
*src
, *limit
;
735 const cpp_token
**dest
, **first
;
740 /* First, fully macro-expand arguments, calculating the number of
741 tokens in the final expansion as we go. The ordering of the if
742 statements below is subtle; we must handle stringification before
744 macro
= node
->value
.macro
;
745 total
= macro
->count
;
746 limit
= macro
->expansion
+ macro
->count
;
748 for (src
= macro
->expansion
; src
< limit
; src
++)
749 if (src
->type
== CPP_MACRO_ARG
)
751 /* Leading and trailing padding tokens. */
754 /* We have an argument. If it is not being stringified or
755 pasted it is macro-replaced before insertion. */
756 arg
= &args
[src
->val
.arg_no
- 1];
758 if (src
->flags
& STRINGIFY_ARG
)
760 if (!arg
->stringified
)
761 arg
->stringified
= stringify_arg (pfile
, arg
);
763 else if ((src
->flags
& PASTE_LEFT
)
764 || (src
> macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
)))
765 total
+= arg
->count
- 1;
769 expand_arg (pfile
, arg
);
770 total
+= arg
->expanded_count
- 1;
774 /* Now allocate space for the expansion, copy the tokens and replace
776 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
777 first
= (const cpp_token
**) buff
->base
;
780 for (src
= macro
->expansion
; src
< limit
; src
++)
783 const cpp_token
**from
, **paste_flag
;
785 if (src
->type
!= CPP_MACRO_ARG
)
792 arg
= &args
[src
->val
.arg_no
- 1];
793 if (src
->flags
& STRINGIFY_ARG
)
794 count
= 1, from
= &arg
->stringified
;
795 else if (src
->flags
& PASTE_LEFT
)
796 count
= arg
->count
, from
= arg
->first
;
797 else if (src
!= macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
))
799 count
= arg
->count
, from
= arg
->first
;
802 /* GCC has special semantics for , ## b where b is a
803 varargs parameter: the comma disappears if b was
804 given no actual arguments (not merely if b is an
805 empty argument); otherwise the paste flag is removed. */
806 if (dest
[-1]->type
== CPP_COMMA
808 && src
->val
.arg_no
== macro
->paramc
)
813 paste_flag
= dest
- 1;
815 /* Remove the paste flag if the RHS is a placemarker. */
817 paste_flag
= dest
- 1;
821 count
= arg
->expanded_count
, from
= arg
->expanded
;
823 /* Padding on the left of an argument (unless RHS of ##). */
824 if (!pfile
->state
.in_directive
825 && src
!= macro
->expansion
&& !(src
[-1].flags
& PASTE_LEFT
))
826 *dest
++ = padding_token (pfile
, src
);
830 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
833 /* With a non-empty argument on the LHS of ##, the last
834 token should be flagged PASTE_LEFT. */
835 if (src
->flags
& PASTE_LEFT
)
836 paste_flag
= dest
- 1;
839 /* Avoid paste on RHS (even case count == 0). */
840 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
841 *dest
++ = &pfile
->avoid_paste
;
843 /* Add a new paste flag, or remove an unwanted one. */
846 cpp_token
*token
= _cpp_temp_token (pfile
);
847 token
->type
= (*paste_flag
)->type
;
848 token
->val
.str
= (*paste_flag
)->val
.str
;
849 if (src
->flags
& PASTE_LEFT
)
850 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
852 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
857 /* Free the expanded arguments. */
858 for (i
= 0; i
< macro
->paramc
; i
++)
859 if (args
[i
].expanded
)
860 free (args
[i
].expanded
);
862 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
865 /* Return a special padding token, with padding inherited from SOURCE. */
866 static const cpp_token
*
867 padding_token (pfile
, source
)
869 const cpp_token
*source
;
871 cpp_token
*result
= _cpp_temp_token (pfile
);
873 result
->type
= CPP_PADDING
;
874 result
->val
.source
= source
;
879 /* Get a new uninitialized context. Create a new one if we cannot
880 re-use an old one. */
885 cpp_context
*result
= pfile
->context
->next
;
889 result
= xnew (cpp_context
);
890 result
->prev
= pfile
->context
;
892 pfile
->context
->next
= result
;
895 pfile
->context
= result
;
899 /* Push a list of pointers to tokens. */
901 push_ptoken_context (pfile
, macro
, buff
, first
, count
)
905 const cpp_token
**first
;
908 cpp_context
*context
= next_context (pfile
);
910 context
->direct_p
= false;
911 context
->macro
= macro
;
912 context
->buff
= buff
;
913 context
->first
.ptoken
= first
;
914 context
->last
.ptoken
= first
+ count
;
917 /* Push a list of tokens. */
919 push_token_context (pfile
, macro
, first
, count
)
922 const cpp_token
*first
;
925 cpp_context
*context
= next_context (pfile
);
927 context
->direct_p
= true;
928 context
->macro
= macro
;
929 context
->buff
= NULL
;
930 context
->first
.token
= first
;
931 context
->last
.token
= first
+ count
;
934 /* Expand an argument ARG before replacing parameters in a
935 function-like macro. This works by pushing a context with the
936 argument's tokens, and then expanding that into a temporary buffer
937 as if it were a normal part of the token stream. collect_args()
938 has terminated the argument's tokens with a CPP_EOF so that we know
939 when we have fully expanded the argument. */
941 expand_arg (pfile
, arg
)
945 unsigned int capacity
;
950 /* Loop, reading in the arguments. */
952 arg
->expanded
= (const cpp_token
**)
953 xmalloc (capacity
* sizeof (cpp_token
*));
955 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
958 const cpp_token
*token
;
960 if (arg
->expanded_count
+ 1 >= capacity
)
963 arg
->expanded
= (const cpp_token
**)
964 xrealloc (arg
->expanded
, capacity
* sizeof (cpp_token
*));
967 token
= cpp_get_token (pfile
);
969 if (token
->type
== CPP_EOF
)
972 arg
->expanded
[arg
->expanded_count
++] = token
;
975 _cpp_pop_context (pfile
);
978 /* Pop the current context off the stack, re-enabling the macro if the
979 context represented a macro's replacement list. The context
980 structure is not freed so that we can re-use it later. */
982 _cpp_pop_context (pfile
)
985 cpp_context
*context
= pfile
->context
;
988 context
->macro
->flags
&= ~NODE_DISABLED
;
991 _cpp_release_buff (pfile
, context
->buff
);
993 pfile
->context
= context
->prev
;
996 /* Eternal routine to get a token. Also used nearly everywhere
997 internally, except for places where we know we can safely call
998 the lexer directly, such as lexing a directive name.
1000 Macro expansions and directives are transparently handled,
1001 including entering included files. Thus tokens are post-macro
1002 expansion, and after any intervening directives. External callers
1003 see CPP_EOF only at EOF. Internal callers also see it when meeting
1004 a directive inside a macro call, when at the end of a directive and
1005 state.in_directive is still 1, and at the end of argument
1008 cpp_get_token (pfile
)
1011 const cpp_token
*result
;
1016 cpp_context
*context
= pfile
->context
;
1018 /* Context->prev == 0 <=> base context. */
1020 result
= _cpp_lex_token (pfile
);
1021 else if (context
->first
.token
!= context
->last
.token
)
1023 if (context
->direct_p
)
1024 result
= context
->first
.token
++;
1026 result
= *context
->first
.ptoken
++;
1028 if (result
->flags
& PASTE_LEFT
)
1030 paste_all_tokens (pfile
, result
);
1031 if (pfile
->state
.in_directive
)
1033 return padding_token (pfile
, result
);
1038 _cpp_pop_context (pfile
);
1039 if (pfile
->state
.in_directive
)
1041 return &pfile
->avoid_paste
;
1044 if (result
->type
!= CPP_NAME
)
1047 node
= result
->val
.node
;
1049 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1052 if (!(node
->flags
& NODE_DISABLED
))
1054 if (!pfile
->state
.prevent_expansion
1055 && enter_macro_context (pfile
, node
))
1057 if (pfile
->state
.in_directive
)
1059 return padding_token (pfile
, result
);
1064 /* Flag this token as always unexpandable. FIXME: move this
1065 to collect_args()?. */
1066 cpp_token
*t
= _cpp_temp_token (pfile
);
1067 t
->type
= result
->type
;
1068 t
->flags
= result
->flags
| NO_EXPAND
;
1069 t
->val
.str
= result
->val
.str
;
1079 /* Returns true if we're expanding an object-like macro that was
1080 defined in a system header. Just checks the macro at the top of
1081 the stack. Used for diagnostic suppression. */
1083 cpp_sys_macro_p (pfile
)
1086 cpp_hashnode
*node
= pfile
->context
->macro
;
1088 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1091 /* Read each token in, until EOF. Directives are transparently
1094 cpp_scan_nooutput (pfile
)
1097 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1101 /* Step back one (or more) tokens. Can only step mack more than 1 if
1102 they are from the lexer, and not from macro expansion. */
1104 _cpp_backup_tokens (pfile
, count
)
1108 if (pfile
->context
->prev
== NULL
)
1110 pfile
->lookaheads
+= count
;
1114 if (pfile
->cur_token
== pfile
->cur_run
->base
1115 /* Possible with -fpreprocessed and no leading #line. */
1116 && pfile
->cur_run
->prev
!= NULL
)
1118 pfile
->cur_run
= pfile
->cur_run
->prev
;
1119 pfile
->cur_token
= pfile
->cur_run
->limit
;
1127 if (pfile
->context
->direct_p
)
1128 pfile
->context
->first
.token
--;
1130 pfile
->context
->first
.ptoken
--;
1134 /* #define directive parsing and handling. */
1136 /* Returns non-zero if a macro redefinition warning is required. */
1138 warn_of_redefinition (node
, macro2
)
1139 const cpp_hashnode
*node
;
1140 const cpp_macro
*macro2
;
1142 const cpp_macro
*macro1
;
1145 /* Some redefinitions need to be warned about regardless. */
1146 if (node
->flags
& NODE_WARN
)
1149 /* Redefinition of a macro is allowed if and only if the old and new
1150 definitions are the same. (6.10.3 paragraph 2). */
1151 macro1
= node
->value
.macro
;
1153 /* The quick failures. */
1154 if (macro1
->count
!= macro2
->count
1155 || macro1
->paramc
!= macro2
->paramc
1156 || macro1
->fun_like
!= macro2
->fun_like
1157 || macro1
->variadic
!= macro2
->variadic
)
1160 /* Check each token. */
1161 for (i
= 0; i
< macro1
->count
; i
++)
1162 if (! _cpp_equiv_tokens (¯o1
->expansion
[i
], ¯o2
->expansion
[i
]))
1165 /* Check parameter spellings. */
1166 for (i
= 0; i
< macro1
->paramc
; i
++)
1167 if (macro1
->params
[i
] != macro2
->params
[i
])
1173 /* Free the definition of hashnode H. */
1175 _cpp_free_definition (h
)
1178 /* Macros and assertions no longer have anything to free. */
1180 /* Clear builtin flag in case of redefinition. */
1181 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
);
1184 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1185 zero on success, non-zero if the parameter is a duplicate. */
1187 save_parameter (pfile
, macro
, node
)
1192 /* Constraint 6.10.3.6 - duplicate parameter names. */
1193 if (node
->arg_index
)
1195 cpp_error (pfile
, "duplicate macro parameter \"%s\"", NODE_NAME (node
));
1199 if (BUFF_ROOM (pfile
->a_buff
)
1200 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1201 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1203 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1204 node
->arg_index
= macro
->paramc
;
1208 /* Check the syntax of the parameters in a MACRO definition. */
1210 parse_params (pfile
, macro
)
1214 unsigned int prev_ident
= 0;
1218 const cpp_token
*token
= _cpp_lex_token (pfile
);
1220 switch (token
->type
)
1223 cpp_error (pfile
, "\"%s\" may not appear in macro parameter list",
1224 cpp_token_as_text (pfile
, token
));
1230 cpp_error (pfile
, "macro parameters must be comma-separated");
1235 if (save_parameter (pfile
, macro
, token
->val
.node
))
1239 case CPP_CLOSE_PAREN
:
1240 if (prev_ident
|| macro
->paramc
== 0)
1243 /* Fall through to pick up the error. */
1247 cpp_error (pfile
, "parameter name missing");
1254 macro
->variadic
= 1;
1257 save_parameter (pfile
, macro
, pfile
->spec_nodes
.n__VA_ARGS__
);
1258 pfile
->state
.va_args_ok
= 1;
1259 if (! CPP_OPTION (pfile
, c99
) && CPP_OPTION (pfile
, pedantic
))
1261 "anonymous variadic macros were introduced in C99");
1263 else if (CPP_OPTION (pfile
, pedantic
))
1264 cpp_pedwarn (pfile
, "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
, "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
) = (U_CHAR
*) ¯o
->params
[macro
->paramc
];
1348 macro
->fun_like
= 1;
1350 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1351 cpp_pedwarn (pfile
, "ISO C requires whitespace after the macro name");
1353 saved_cur_token
= pfile
->cur_token
;
1355 if (macro
->fun_like
)
1356 token
= lex_expansion_token (pfile
, macro
);
1359 token
= alloc_expansion_token (pfile
, macro
);
1365 /* Check the stringifying # constraint 6.10.3.2.1 of
1366 function-like macros when lexing the subsequent token. */
1367 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1369 if (token
->type
== CPP_MACRO_ARG
)
1371 token
->flags
&= ~PREV_WHITE
;
1372 token
->flags
|= STRINGIFY_ARG
;
1373 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1374 token
[-1] = token
[0];
1377 /* Let assembler get away with murder. */
1378 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1381 cpp_error (pfile
, "'#' is not followed by a macro parameter");
1386 if (token
->type
== CPP_EOF
)
1389 /* Paste operator constraint 6.10.3.3.1. */
1390 if (token
->type
== CPP_PASTE
)
1392 /* Token-paste ##, can appear in both object-like and
1393 function-like macros, but not at the ends. */
1394 if (--macro
->count
> 0)
1395 token
= lex_expansion_token (pfile
, macro
);
1397 if (macro
->count
== 0 || token
->type
== CPP_EOF
)
1401 "'##' cannot appear at either end of a macro expansion");
1405 token
[-1].flags
|= PASTE_LEFT
;
1408 token
= lex_expansion_token (pfile
, macro
);
1411 macro
->expansion
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1413 /* Don't count the CPP_EOF. */
1416 /* Clear whitespace on first token for warn_of_redefinition(). */
1418 macro
->expansion
[0].flags
&= ~PREV_WHITE
;
1420 /* Commit the memory. */
1421 BUFF_FRONT (pfile
->a_buff
) = (U_CHAR
*) ¯o
->expansion
[macro
->count
];
1423 /* Implement the macro-defined-to-itself optimisation. */
1424 if (macro
->count
== 1 && !macro
->fun_like
1425 && macro
->expansion
[0].type
== CPP_NAME
1426 && macro
->expansion
[0].val
.node
== node
)
1427 node
->flags
|= NODE_DISABLED
;
1429 /* To suppress some diagnostics. */
1430 macro
->syshdr
= pfile
->map
->sysp
!= 0;
1432 if (node
->type
!= NT_VOID
)
1434 if (warn_of_redefinition (node
, macro
))
1436 cpp_pedwarn_with_line (pfile
, pfile
->directive_line
, 0,
1437 "\"%s\" redefined", NODE_NAME (node
));
1439 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1440 cpp_pedwarn_with_line (pfile
, node
->value
.macro
->line
, 0,
1441 "this is the location of the previous definition");
1443 _cpp_free_definition (node
);
1446 /* Enter definition in hash table. */
1447 node
->type
= NT_MACRO
;
1448 node
->value
.macro
= macro
;
1449 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
1450 node
->flags
|= NODE_WARN
;
1454 /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position. */
1455 saved_cur_token
[-1].type
= pfile
->cur_token
[-1].type
;
1456 pfile
->cur_token
= saved_cur_token
;
1460 /* Stop the lexer accepting __VA_ARGS__. */
1461 pfile
->state
.va_args_ok
= 0;
1463 /* Clear the fast argument lookup indices. */
1464 for (i
= macro
->paramc
; i
-- > 0; )
1465 macro
->params
[i
]->arg_index
= 0;
1470 /* Warn if a token in STRING matches one of a function-like MACRO's
1473 check_trad_stringification (pfile
, macro
, string
)
1475 const cpp_macro
*macro
;
1476 const cpp_string
*string
;
1478 unsigned int i
, len
;
1479 const U_CHAR
*p
, *q
, *limit
= string
->text
+ string
->len
;
1481 /* Loop over the string. */
1482 for (p
= string
->text
; p
< limit
; p
= q
)
1484 /* Find the start of an identifier. */
1485 while (p
< limit
&& !is_idstart (*p
))
1488 /* Find the end of the identifier. */
1490 while (q
< limit
&& is_idchar (*q
))
1495 /* Loop over the function macro arguments to see if the
1496 identifier inside the string matches one of them. */
1497 for (i
= 0; i
< macro
->paramc
; i
++)
1499 const cpp_hashnode
*node
= macro
->params
[i
];
1501 if (NODE_LEN (node
) == len
1502 && !memcmp (p
, NODE_NAME (node
), len
))
1505 "macro argument \"%s\" would be stringified with -traditional",
1513 /* Returns the name, arguments and expansion of a macro, in a format
1514 suitable to be read back in again, and therefore also for DWARF 2
1515 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1516 Caller is expected to generate the "#define" bit if needed. The
1517 returned text is temporary, and automatically freed later. */
1518 const unsigned char *
1519 cpp_macro_definition (pfile
, node
)
1521 const cpp_hashnode
*node
;
1523 unsigned int i
, len
;
1524 const cpp_macro
*macro
= node
->value
.macro
;
1525 unsigned char *buffer
;
1527 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1529 cpp_ice (pfile
, "invalid hash type %d in cpp_macro_definition", node
->type
);
1533 /* Calculate length. */
1534 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
1535 if (macro
->fun_like
)
1537 len
+= 4; /* "()" plus possible final ".." of named
1538 varargs (we have + 1 below). */
1539 for (i
= 0; i
< macro
->paramc
; i
++)
1540 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1543 for (i
= 0; i
< macro
->count
; i
++)
1545 cpp_token
*token
= ¯o
->expansion
[i
];
1547 if (token
->type
== CPP_MACRO_ARG
)
1548 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1550 len
+= cpp_token_len (token
); /* Includes room for ' '. */
1551 if (token
->flags
& STRINGIFY_ARG
)
1553 if (token
->flags
& PASTE_LEFT
)
1554 len
+= 3; /* " ##" */
1557 if (len
> pfile
->macro_buffer_len
)
1559 pfile
->macro_buffer
= (U_CHAR
*) xrealloc (pfile
->macro_buffer
, len
);
1560 pfile
->macro_buffer_len
= len
;
1563 /* Fill in the buffer. Start with the macro name. */
1564 buffer
= pfile
->macro_buffer
;
1565 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1566 buffer
+= NODE_LEN (node
);
1568 /* Parameter names. */
1569 if (macro
->fun_like
)
1572 for (i
= 0; i
< macro
->paramc
; i
++)
1574 cpp_hashnode
*param
= macro
->params
[i
];
1576 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1578 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1579 buffer
+= NODE_LEN (param
);
1582 if (i
+ 1 < macro
->paramc
)
1583 /* Don't emit a space after the comma here; we're trying
1584 to emit a Dwarf-friendly definition, and the Dwarf spec
1585 forbids spaces in the argument list. */
1587 else if (macro
->variadic
)
1588 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1593 /* The Dwarf spec requires a space after the macro name, even if the
1594 definition is the empty string. */
1597 /* Expansion tokens. */
1600 for (i
= 0; i
< macro
->count
; i
++)
1602 cpp_token
*token
= ¯o
->expansion
[i
];
1604 if (token
->flags
& PREV_WHITE
)
1606 if (token
->flags
& STRINGIFY_ARG
)
1609 if (token
->type
== CPP_MACRO_ARG
)
1611 len
= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1613 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]), len
);
1617 buffer
= cpp_spell_token (pfile
, token
, buffer
);
1619 if (token
->flags
& PASTE_LEFT
)
1624 /* Next has PREV_WHITE; see _cpp_create_definition. */
1630 return pfile
->macro_buffer
;