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 unsigned char *quote_string
PARAMS ((unsigned char *,
68 const unsigned char *,
70 static const cpp_token
*new_string_token
PARAMS ((cpp_reader
*, U_CHAR
*,
72 static const cpp_token
*new_number_token
PARAMS ((cpp_reader
*, unsigned int));
73 static const cpp_token
*stringify_arg
PARAMS ((cpp_reader
*, macro_arg
*));
74 static void paste_all_tokens
PARAMS ((cpp_reader
*, const cpp_token
*));
75 static bool paste_tokens
PARAMS ((cpp_reader
*, const cpp_token
**,
77 static void replace_args
PARAMS ((cpp_reader
*, cpp_hashnode
*, macro_arg
*));
78 static _cpp_buff
*funlike_invocation_p
PARAMS ((cpp_reader
*, cpp_hashnode
*));
80 /* #define directive parsing and handling. */
82 static cpp_token
*alloc_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
83 static cpp_token
*lex_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
84 static int warn_of_redefinition
PARAMS ((const cpp_hashnode
*,
86 static int save_parameter
PARAMS ((cpp_reader
*, cpp_macro
*, cpp_hashnode
*));
87 static int parse_params
PARAMS ((cpp_reader
*, cpp_macro
*));
88 static void check_trad_stringification
PARAMS ((cpp_reader
*,
92 /* Allocates and returns a CPP_STRING token, containing TEXT of length
93 LEN, after null-terminating it. TEXT must be in permanent storage. */
94 static const cpp_token
*
95 new_string_token (pfile
, text
, len
)
100 cpp_token
*token
= _cpp_temp_token (pfile
);
103 token
->type
= CPP_STRING
;
104 token
->val
.str
.len
= len
;
105 token
->val
.str
.text
= text
;
110 /* Allocates and returns a CPP_NUMBER token evaluating to NUMBER. */
111 static const cpp_token
*
112 new_number_token (pfile
, number
)
116 cpp_token
*token
= _cpp_temp_token (pfile
);
117 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
118 unsigned char *buf
= _cpp_unaligned_alloc (pfile
, 21);
120 sprintf ((char *) buf
, "%u", number
);
121 token
->type
= CPP_NUMBER
;
122 token
->val
.str
.text
= buf
;
123 token
->val
.str
.len
= ustrlen (buf
);
128 static const char * const monthnames
[] =
130 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
131 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
134 /* Handle builtin macros like __FILE__, and push the resulting token
135 on the context stack. Also handles _Pragma, for which no new token
136 is created. Returns 1 if it generates a new token context, 0 to
137 return the token to the caller. */
139 builtin_macro (pfile
, node
)
143 const cpp_token
*result
;
145 switch (node
->value
.builtin
)
148 cpp_ice (pfile
, "invalid built-in macro \"%s\"", NODE_NAME (node
));
157 const struct line_map
*map
= pfile
->map
;
159 if (node
->value
.builtin
== BT_BASE_FILE
)
160 while (! MAIN_FILE_P (map
))
161 map
= INCLUDED_FROM (&pfile
->line_maps
, map
);
165 buf
= _cpp_unaligned_alloc (pfile
, len
* 4 + 1);
166 len
= quote_string (buf
, (const unsigned char *) name
, len
) - buf
;
168 result
= new_string_token (pfile
, buf
, len
);
172 case BT_INCLUDE_LEVEL
:
173 /* The line map depth counts the primary source as level 1, but
174 historically __INCLUDE_DEPTH__ has called the primary source
176 result
= new_number_token (pfile
, pfile
->line_maps
.depth
- 1);
180 /* If __LINE__ is embedded in a macro, it must expand to the
181 line of the macro's invocation, not its definition.
182 Otherwise things like assert() will not work properly. */
183 result
= new_number_token (pfile
,
184 SOURCE_LINE (pfile
->map
,
185 pfile
->cur_token
[-1].line
));
190 int stdc
= (!CPP_IN_SYSTEM_HEADER (pfile
)
191 || pfile
->spec_nodes
.n__STRICT_ANSI__
->type
!= NT_VOID
);
192 result
= new_number_token (pfile
, stdc
);
198 if (pfile
->date
.type
== CPP_EOF
)
200 /* Allocate __DATE__ and __TIME__ strings from permanent
201 storage. We only do this once, and don't generate them
202 at init time, because time() and localtime() are very
203 slow on some systems. */
204 time_t tt
= time (NULL
);
205 struct tm
*tb
= localtime (&tt
);
207 pfile
->date
.val
.str
.text
=
208 _cpp_unaligned_alloc (pfile
, sizeof ("Oct 11 1347"));
209 pfile
->date
.val
.str
.len
= sizeof ("Oct 11 1347") - 1;
210 pfile
->date
.type
= CPP_STRING
;
211 pfile
->date
.flags
= 0;
212 sprintf ((char *) pfile
->date
.val
.str
.text
, "%s %2d %4d",
213 monthnames
[tb
->tm_mon
], tb
->tm_mday
, tb
->tm_year
+ 1900);
215 pfile
->time
.val
.str
.text
=
216 _cpp_unaligned_alloc (pfile
, sizeof ("12:34:56"));
217 pfile
->time
.val
.str
.len
= sizeof ("12:34:56") - 1;
218 pfile
->time
.type
= CPP_STRING
;
219 pfile
->time
.flags
= 0;
220 sprintf ((char *) pfile
->time
.val
.str
.text
, "%02d:%02d:%02d",
221 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
224 if (node
->value
.builtin
== BT_DATE
)
225 result
= &pfile
->date
;
227 result
= &pfile
->time
;
231 /* Don't interpret _Pragma within directives. The standard is
232 not clear on this, but to me this makes most sense. */
233 if (pfile
->state
.in_directive
)
236 _cpp_do__Pragma (pfile
);
240 push_token_context (pfile
, NULL
, result
, 1);
244 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
245 backslashes and double quotes. Non-printable characters are
246 converted to octal. DEST must be of sufficient size. */
248 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
= 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_warning (pfile
, "invalid string literal, ignoring final '\\'");
352 /* Commit the memory, including NUL, and return the token. */
353 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
354 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
355 return new_string_token (pfile
, dest
- len
, len
);
358 /* Try to paste two tokens. On success, return non-zero. In any
359 case, PLHS is updated to point to the pasted token, which is
360 guaranteed to not have the PASTE_LEFT flag set. */
362 paste_tokens (pfile
, plhs
, rhs
)
364 const cpp_token
**plhs
, *rhs
;
366 unsigned char *buf
, *end
;
367 const cpp_token
*lhs
;
372 len
= cpp_token_len (lhs
) + cpp_token_len (rhs
) + 1;
373 buf
= (unsigned char *) alloca (len
);
374 end
= cpp_spell_token (pfile
, lhs
, buf
);
376 /* Avoid comment headers, since they are still processed in stage 3.
377 It is simpler to insert a space here, rather than modifying the
378 lexer to ignore comments in some circumstances. Simply returning
379 false doesn't work, since we want to clear the PASTE_LEFT flag. */
380 if (lhs
->type
== CPP_DIV
381 && (rhs
->type
== CPP_MULT
|| rhs
->type
== CPP_DIV
))
383 end
= cpp_spell_token (pfile
, rhs
, end
);
386 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true, 1);
388 /* Tweak the column number the lexer will report. */
389 pfile
->buffer
->col_adjust
= pfile
->cur_token
[-1].col
- 1;
391 /* We don't want a leading # to be interpreted as a directive. */
392 pfile
->buffer
->saved_flags
= 0;
394 /* Set pfile->cur_token as required by _cpp_lex_direct. */
395 pfile
->cur_token
= _cpp_temp_token (pfile
);
396 *plhs
= _cpp_lex_direct (pfile
);
397 valid
= pfile
->buffer
->cur
== pfile
->buffer
->rlimit
;
398 _cpp_pop_buffer (pfile
);
403 /* Handles an arbitrarily long sequence of ## operators, with initial
404 operand LHS. This implementation is left-associative,
405 non-recursive, and finishes a paste before handling succeeding
406 ones. If a paste fails, we back up to the RHS of the failing ##
407 operator before pushing the context containing the result of prior
408 successful pastes, with the effect that the RHS appears in the
409 output stream after the pasted LHS normally. */
411 paste_all_tokens (pfile
, lhs
)
413 const cpp_token
*lhs
;
415 const cpp_token
*rhs
;
416 cpp_context
*context
= pfile
->context
;
420 /* Take the token directly from the current context. We can do
421 this, because we are in the replacement list of either an
422 object-like macro, or a function-like macro with arguments
423 inserted. In either case, the constraints to #define
424 guarantee we have at least one more token. */
425 if (context
->direct_p
)
426 rhs
= context
->first
.token
++;
428 rhs
= *context
->first
.ptoken
++;
430 if (rhs
->type
== CPP_PADDING
)
433 if (!paste_tokens (pfile
, &lhs
, rhs
))
435 _cpp_backup_tokens (pfile
, 1);
437 /* Mandatory warning for all apart from assembler. */
438 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
440 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
441 cpp_token_as_text (pfile
, lhs
),
442 cpp_token_as_text (pfile
, rhs
));
446 while (rhs
->flags
& PASTE_LEFT
);
448 /* Put the resulting token in its own context. */
449 push_token_context (pfile
, NULL
, lhs
, 1);
452 /* Reads and returns the arguments to a function-like macro
453 invocation. Assumes the opening parenthesis has been processed.
454 If there is an error, emits an appropriate diagnostic and returns
455 NULL. Each argument is terminated by a CPP_EOF token, for the
456 future benefit of expand_arg(). */
458 collect_args (pfile
, node
)
460 const cpp_hashnode
*node
;
462 _cpp_buff
*buff
, *base_buff
;
464 macro_arg
*args
, *arg
;
465 const cpp_token
*token
;
469 macro
= node
->value
.macro
;
471 argc
= macro
->paramc
;
474 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
475 + sizeof (macro_arg
)));
477 args
= (macro_arg
*) buff
->base
;
478 memset (args
, 0, argc
* sizeof (macro_arg
));
479 buff
->cur
= (unsigned char *) &args
[argc
];
480 arg
= args
, argc
= 0;
482 /* Collect the tokens making up each argument. We don't yet know
483 how many arguments have been supplied, whether too many or too
484 few. Hence the slightly bizarre usage of "argc" and "arg". */
487 unsigned int paren_depth
= 0;
488 unsigned int ntokens
= 0;
491 arg
->first
= (const cpp_token
**) buff
->cur
;
495 /* Require space for 2 new tokens (including a CPP_EOF). */
496 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
498 buff
= _cpp_append_extend_buff (pfile
, buff
,
499 1000 * sizeof (cpp_token
*));
500 arg
->first
= (const cpp_token
**) buff
->cur
;
503 token
= cpp_get_token (pfile
);
505 if (token
->type
== CPP_PADDING
)
507 /* Drop leading padding. */
511 else if (token
->type
== CPP_OPEN_PAREN
)
513 else if (token
->type
== CPP_CLOSE_PAREN
)
515 if (paren_depth
-- == 0)
518 else if (token
->type
== CPP_COMMA
)
520 /* A comma does not terminate an argument within
521 parentheses or as part of a variable argument. */
523 && ! (macro
->variadic
&& argc
== macro
->paramc
))
526 else if (token
->type
== CPP_EOF
527 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
530 arg
->first
[ntokens
++] = token
;
533 /* Drop trailing padding. */
534 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
537 arg
->count
= ntokens
;
538 arg
->first
[ntokens
] = &pfile
->eof
;
540 /* Terminate the argument. Excess arguments loop back and
541 overwrite the final legitimate argument, before failing. */
542 if (argc
<= macro
->paramc
)
544 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
545 if (argc
!= macro
->paramc
)
549 while (token
->type
!= CPP_CLOSE_PAREN
550 && token
->type
!= CPP_EOF
551 && token
->type
!= CPP_HASH
);
553 if (token
->type
== CPP_EOF
|| token
->type
== CPP_HASH
)
555 bool step_back
= false;
557 /* 6.10.3 paragraph 11: If there are sequences of preprocessing
558 tokens within the list of arguments that would otherwise act
559 as preprocessing directives, the behavior is undefined.
561 This implementation will report a hard error, terminate the
562 macro invocation, and proceed to process the directive. */
563 if (token
->type
== CPP_HASH
)
566 "directives may not be used inside a macro argument");
570 step_back
= (pfile
->context
->prev
|| pfile
->state
.in_directive
);
572 /* We still need the CPP_EOF to end directives, and to end
573 pre-expansion of a macro argument. Step back is not
574 unconditional, since we don't want to return a CPP_EOF to our
575 callers at the end of an -include-d file. */
577 _cpp_backup_tokens (pfile
, 1);
578 cpp_error (pfile
, "unterminated argument list invoking macro \"%s\"",
582 else if (argc
< macro
->paramc
)
584 /* As an extension, a rest argument is allowed to not appear in
585 the invocation at all.
586 e.g. #define debug(format, args...) something
589 This is exactly the same as if there had been an empty rest
590 argument - debug("string", ). */
592 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
594 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
595 cpp_pedwarn (pfile
, "ISO C99 requires rest arguments to be used");
600 "macro \"%s\" requires %u arguments, but only %u given",
601 NODE_NAME (node
), macro
->paramc
, argc
);
605 else if (argc
> macro
->paramc
)
607 /* Empty argument to a macro taking no arguments is OK. */
608 if (argc
!= 1 || arg
->count
)
611 "macro \"%s\" passed %u arguments, but takes just %u",
612 NODE_NAME (node
), argc
, macro
->paramc
);
620 _cpp_release_buff (pfile
, base_buff
);
624 /* Search for an opening parenthesis to the macro of NODE, in such a
625 way that, if none is found, we don't lose the information in any
626 intervening padding tokens. If we find the parenthesis, collect
627 the arguments and return the buffer containing them. */
629 funlike_invocation_p (pfile
, node
)
633 const cpp_token
*token
, *padding
= NULL
;
637 token
= cpp_get_token (pfile
);
638 if (token
->type
!= CPP_PADDING
)
641 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
645 if (token
->type
== CPP_OPEN_PAREN
)
647 pfile
->state
.parsing_args
= 2;
648 return collect_args (pfile
, node
);
651 /* Back up. We may have skipped padding, in which case backing up
652 more than one token when expanding macros is in general too
653 difficult. We re-insert it in its own context. */
654 _cpp_backup_tokens (pfile
, 1);
656 push_token_context (pfile
, NULL
, padding
, 1);
661 /* Push the context of a macro with hash entry NODE onto the context
662 stack. If we can successfully expand the macro, we push a context
663 containing its yet-to-be-rescanned replacement list and return one.
664 Otherwise, we don't push a context and return zero. */
666 enter_macro_context (pfile
, node
)
670 /* The presence of a macro invalidates a file's controlling macro. */
671 pfile
->mi_valid
= false;
673 /* Handle standard macros. */
674 if (! (node
->flags
& NODE_BUILTIN
))
676 cpp_macro
*macro
= node
->value
.macro
;
682 pfile
->state
.prevent_expansion
++;
683 pfile
->keep_tokens
++;
684 pfile
->state
.parsing_args
= 1;
685 buff
= funlike_invocation_p (pfile
, node
);
686 pfile
->state
.parsing_args
= 0;
687 pfile
->keep_tokens
--;
688 pfile
->state
.prevent_expansion
--;
692 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
694 "function-like macro \"%s\" must be used with arguments in traditional C",
700 if (node
->value
.macro
->paramc
> 0)
701 replace_args (pfile
, node
, (macro_arg
*) buff
->base
);
702 _cpp_release_buff (pfile
, buff
);
705 /* Disable the macro within its expansion. */
706 node
->flags
|= NODE_DISABLED
;
708 if (macro
->paramc
== 0)
709 push_token_context (pfile
, node
, macro
->expansion
, macro
->count
);
714 /* Handle built-in macros and the _Pragma operator. */
715 return builtin_macro (pfile
, node
);
718 /* Replace the parameters in a function-like macro of NODE with the
719 actual ARGS, and place the result in a newly pushed token context.
720 Expand each argument before replacing, unless it is operated upon
721 by the # or ## operators. */
723 replace_args (pfile
, node
, args
)
728 unsigned int i
, total
;
729 const cpp_token
*src
, *limit
;
730 const cpp_token
**dest
, **first
;
735 /* First, fully macro-expand arguments, calculating the number of
736 tokens in the final expansion as we go. The ordering of the if
737 statements below is subtle; we must handle stringification before
739 macro
= node
->value
.macro
;
740 total
= macro
->count
;
741 limit
= macro
->expansion
+ macro
->count
;
743 for (src
= macro
->expansion
; src
< limit
; src
++)
744 if (src
->type
== CPP_MACRO_ARG
)
746 /* Leading and trailing padding tokens. */
749 /* We have an argument. If it is not being stringified or
750 pasted it is macro-replaced before insertion. */
751 arg
= &args
[src
->val
.arg_no
- 1];
753 if (src
->flags
& STRINGIFY_ARG
)
755 if (!arg
->stringified
)
756 arg
->stringified
= stringify_arg (pfile
, arg
);
758 else if ((src
->flags
& PASTE_LEFT
)
759 || (src
> macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
)))
760 total
+= arg
->count
- 1;
764 expand_arg (pfile
, arg
);
765 total
+= arg
->expanded_count
- 1;
769 /* Now allocate space for the expansion, copy the tokens and replace
771 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
772 first
= (const cpp_token
**) buff
->base
;
775 for (src
= macro
->expansion
; src
< limit
; src
++)
778 const cpp_token
**from
, **paste_flag
;
780 if (src
->type
!= CPP_MACRO_ARG
)
787 arg
= &args
[src
->val
.arg_no
- 1];
788 if (src
->flags
& STRINGIFY_ARG
)
789 count
= 1, from
= &arg
->stringified
;
790 else if (src
->flags
& PASTE_LEFT
)
791 count
= arg
->count
, from
= arg
->first
;
792 else if (src
!= macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
))
794 count
= arg
->count
, from
= arg
->first
;
797 /* GCC has special semantics for , ## b where b is a
798 varargs parameter: the comma disappears if b was
799 given no actual arguments (not merely if b is an
800 empty argument); otherwise the paste flag is removed. */
801 if (dest
[-1]->type
== CPP_COMMA
803 && src
->val
.arg_no
== macro
->paramc
)
808 paste_flag
= dest
- 1;
810 /* Remove the paste flag if the RHS is a placemarker. */
812 paste_flag
= dest
- 1;
816 count
= arg
->expanded_count
, from
= arg
->expanded
;
818 /* Padding on the left of an argument (unless RHS of ##). */
819 if (!pfile
->state
.in_directive
820 && src
!= macro
->expansion
&& !(src
[-1].flags
& PASTE_LEFT
))
821 *dest
++ = padding_token (pfile
, src
);
825 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
828 /* With a non-empty argument on the LHS of ##, the last
829 token should be flagged PASTE_LEFT. */
830 if (src
->flags
& PASTE_LEFT
)
831 paste_flag
= dest
- 1;
834 /* Avoid paste on RHS (even case count == 0). */
835 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
836 *dest
++ = &pfile
->avoid_paste
;
838 /* Add a new paste flag, or remove an unwanted one. */
841 cpp_token
*token
= _cpp_temp_token (pfile
);
842 token
->type
= (*paste_flag
)->type
;
843 token
->val
.str
= (*paste_flag
)->val
.str
;
844 if (src
->flags
& PASTE_LEFT
)
845 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
847 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
852 /* Free the expanded arguments. */
853 for (i
= 0; i
< macro
->paramc
; i
++)
854 if (args
[i
].expanded
)
855 free (args
[i
].expanded
);
857 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
860 /* Return a special padding token, with padding inherited from SOURCE. */
861 static const cpp_token
*
862 padding_token (pfile
, source
)
864 const cpp_token
*source
;
866 cpp_token
*result
= _cpp_temp_token (pfile
);
868 result
->type
= CPP_PADDING
;
869 result
->val
.source
= source
;
874 /* Get a new uninitialized context. Create a new one if we cannot
875 re-use an old one. */
880 cpp_context
*result
= pfile
->context
->next
;
884 result
= xnew (cpp_context
);
885 result
->prev
= pfile
->context
;
887 pfile
->context
->next
= result
;
890 pfile
->context
= result
;
894 /* Push a list of pointers to tokens. */
896 push_ptoken_context (pfile
, macro
, buff
, first
, count
)
900 const cpp_token
**first
;
903 cpp_context
*context
= next_context (pfile
);
905 context
->direct_p
= false;
906 context
->macro
= macro
;
907 context
->buff
= buff
;
908 context
->first
.ptoken
= first
;
909 context
->last
.ptoken
= first
+ count
;
912 /* Push a list of tokens. */
914 push_token_context (pfile
, macro
, first
, count
)
917 const cpp_token
*first
;
920 cpp_context
*context
= next_context (pfile
);
922 context
->direct_p
= true;
923 context
->macro
= macro
;
924 context
->buff
= NULL
;
925 context
->first
.token
= first
;
926 context
->last
.token
= first
+ count
;
929 /* Expand an argument ARG before replacing parameters in a
930 function-like macro. This works by pushing a context with the
931 argument's tokens, and then expanding that into a temporary buffer
932 as if it were a normal part of the token stream. collect_args()
933 has terminated the argument's tokens with a CPP_EOF so that we know
934 when we have fully expanded the argument. */
936 expand_arg (pfile
, arg
)
940 unsigned int capacity
;
945 /* Loop, reading in the arguments. */
947 arg
->expanded
= (const cpp_token
**)
948 xmalloc (capacity
* sizeof (cpp_token
*));
950 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
953 const cpp_token
*token
;
955 if (arg
->expanded_count
+ 1 >= capacity
)
958 arg
->expanded
= (const cpp_token
**)
959 xrealloc (arg
->expanded
, capacity
* sizeof (cpp_token
*));
962 token
= cpp_get_token (pfile
);
964 if (token
->type
== CPP_EOF
)
967 arg
->expanded
[arg
->expanded_count
++] = token
;
970 _cpp_pop_context (pfile
);
973 /* Pop the current context off the stack, re-enabling the macro if the
974 context represented a macro's replacement list. The context
975 structure is not freed so that we can re-use it later. */
977 _cpp_pop_context (pfile
)
980 cpp_context
*context
= pfile
->context
;
983 context
->macro
->flags
&= ~NODE_DISABLED
;
986 _cpp_release_buff (pfile
, context
->buff
);
988 pfile
->context
= context
->prev
;
991 /* Eternal routine to get a token. Also used nearly everywhere
992 internally, except for places where we know we can safely call
993 the lexer directly, such as lexing a directive name.
995 Macro expansions and directives are transparently handled,
996 including entering included files. Thus tokens are post-macro
997 expansion, and after any intervening directives. External callers
998 see CPP_EOF only at EOF. Internal callers also see it when meeting
999 a directive inside a macro call, when at the end of a directive and
1000 state.in_directive is still 1, and at the end of argument
1003 cpp_get_token (pfile
)
1006 const cpp_token
*result
;
1011 cpp_context
*context
= pfile
->context
;
1013 /* Context->prev == 0 <=> base context. */
1015 result
= _cpp_lex_token (pfile
);
1016 else if (context
->first
.token
!= context
->last
.token
)
1018 if (context
->direct_p
)
1019 result
= context
->first
.token
++;
1021 result
= *context
->first
.ptoken
++;
1023 if (result
->flags
& PASTE_LEFT
)
1025 paste_all_tokens (pfile
, result
);
1026 if (pfile
->state
.in_directive
)
1028 return padding_token (pfile
, result
);
1033 _cpp_pop_context (pfile
);
1034 if (pfile
->state
.in_directive
)
1036 return &pfile
->avoid_paste
;
1039 if (result
->type
!= CPP_NAME
)
1042 node
= result
->val
.node
;
1044 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1047 if (!(node
->flags
& NODE_DISABLED
))
1049 if (!pfile
->state
.prevent_expansion
1050 && enter_macro_context (pfile
, node
))
1052 if (pfile
->state
.in_directive
)
1054 return padding_token (pfile
, result
);
1059 /* Flag this token as always unexpandable. FIXME: move this
1060 to collect_args()?. */
1061 cpp_token
*t
= _cpp_temp_token (pfile
);
1062 t
->type
= result
->type
;
1063 t
->flags
= result
->flags
| NO_EXPAND
;
1064 t
->val
.str
= result
->val
.str
;
1074 /* Returns true if we're expanding an object-like macro that was
1075 defined in a system header. Just checks the macro at the top of
1076 the stack. Used for diagnostic suppression. */
1078 cpp_sys_macro_p (pfile
)
1081 cpp_hashnode
*node
= pfile
->context
->macro
;
1083 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1086 /* Read each token in, until EOF. Directives are transparently
1089 cpp_scan_nooutput (pfile
)
1092 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1096 /* Step back one (or more) tokens. Can only step mack more than 1 if
1097 they are from the lexer, and not from macro expansion. */
1099 _cpp_backup_tokens (pfile
, count
)
1103 if (pfile
->context
->prev
== NULL
)
1105 pfile
->lookaheads
+= count
;
1109 if (pfile
->cur_token
== pfile
->cur_run
->base
1110 /* Possible with -fpreprocessed and no leading #line. */
1111 && pfile
->cur_run
->prev
!= NULL
)
1113 pfile
->cur_run
= pfile
->cur_run
->prev
;
1114 pfile
->cur_token
= pfile
->cur_run
->limit
;
1122 if (pfile
->context
->direct_p
)
1123 pfile
->context
->first
.token
--;
1125 pfile
->context
->first
.ptoken
--;
1129 /* #define directive parsing and handling. */
1131 /* Returns non-zero if a macro redefinition warning is required. */
1133 warn_of_redefinition (node
, macro2
)
1134 const cpp_hashnode
*node
;
1135 const cpp_macro
*macro2
;
1137 const cpp_macro
*macro1
;
1140 /* Some redefinitions need to be warned about regardless. */
1141 if (node
->flags
& NODE_WARN
)
1144 /* Redefinition of a macro is allowed if and only if the old and new
1145 definitions are the same. (6.10.3 paragraph 2). */
1146 macro1
= node
->value
.macro
;
1148 /* The quick failures. */
1149 if (macro1
->count
!= macro2
->count
1150 || macro1
->paramc
!= macro2
->paramc
1151 || macro1
->fun_like
!= macro2
->fun_like
1152 || macro1
->variadic
!= macro2
->variadic
)
1155 /* Check each token. */
1156 for (i
= 0; i
< macro1
->count
; i
++)
1157 if (! _cpp_equiv_tokens (¯o1
->expansion
[i
], ¯o2
->expansion
[i
]))
1160 /* Check parameter spellings. */
1161 for (i
= 0; i
< macro1
->paramc
; i
++)
1162 if (macro1
->params
[i
] != macro2
->params
[i
])
1168 /* Free the definition of hashnode H. */
1170 _cpp_free_definition (h
)
1173 /* Macros and assertions no longer have anything to free. */
1175 /* Clear builtin flag in case of redefinition. */
1176 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
);
1179 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1180 zero on success, non-zero if the parameter is a duplicate. */
1182 save_parameter (pfile
, macro
, node
)
1187 /* Constraint 6.10.3.6 - duplicate parameter names. */
1188 if (node
->arg_index
)
1190 cpp_error (pfile
, "duplicate macro parameter \"%s\"", NODE_NAME (node
));
1194 if (BUFF_ROOM (pfile
->a_buff
)
1195 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1196 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1198 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1199 node
->arg_index
= macro
->paramc
;
1203 /* Check the syntax of the parameters in a MACRO definition. */
1205 parse_params (pfile
, macro
)
1209 unsigned int prev_ident
= 0;
1213 const cpp_token
*token
= _cpp_lex_token (pfile
);
1215 switch (token
->type
)
1218 cpp_error (pfile
, "\"%s\" may not appear in macro parameter list",
1219 cpp_token_as_text (pfile
, token
));
1225 cpp_error (pfile
, "macro parameters must be comma-separated");
1230 if (save_parameter (pfile
, macro
, token
->val
.node
))
1234 case CPP_CLOSE_PAREN
:
1235 if (prev_ident
|| macro
->paramc
== 0)
1238 /* Fall through to pick up the error. */
1242 cpp_error (pfile
, "parameter name missing");
1249 macro
->variadic
= 1;
1252 save_parameter (pfile
, macro
, pfile
->spec_nodes
.n__VA_ARGS__
);
1253 pfile
->state
.va_args_ok
= 1;
1254 if (! CPP_OPTION (pfile
, c99
) && CPP_OPTION (pfile
, pedantic
))
1256 "anonymous variadic macros were introduced in C99");
1258 else if (CPP_OPTION (pfile
, pedantic
))
1259 cpp_pedwarn (pfile
, "ISO C does not permit named variadic macros");
1261 /* We're at the end, and just expect a closing parenthesis. */
1262 token
= _cpp_lex_token (pfile
);
1263 if (token
->type
== CPP_CLOSE_PAREN
)
1268 cpp_error (pfile
, "missing ')' in macro parameter list");
1274 /* Allocate room for a token from a macro's replacement list. */
1276 alloc_expansion_token (pfile
, macro
)
1280 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1281 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1283 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1286 /* Lex a token from the expansion of MACRO, but mark parameters as we
1287 find them and warn of traditional stringification. */
1289 lex_expansion_token (pfile
, macro
)
1295 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1296 token
= _cpp_lex_direct (pfile
);
1298 /* Is this a parameter? */
1299 if (token
->type
== CPP_NAME
&& token
->val
.node
->arg_index
)
1301 token
->type
= CPP_MACRO_ARG
;
1302 token
->val
.arg_no
= token
->val
.node
->arg_index
;
1304 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1305 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1306 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1311 /* Parse a macro and save its expansion. Returns non-zero on success. */
1313 _cpp_create_definition (pfile
, node
)
1318 cpp_token
*token
, *saved_cur_token
;
1319 const cpp_token
*ctoken
;
1320 unsigned int i
, ok
= 1;
1322 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1323 macro
->line
= pfile
->directive_line
;
1326 macro
->variadic
= 0;
1328 macro
->fun_like
= 0;
1330 /* Get the first token of the expansion (or the '(' of a
1331 function-like macro). */
1332 ctoken
= _cpp_lex_token (pfile
);
1334 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1336 ok
= parse_params (pfile
, macro
);
1337 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1341 /* Success. Commit the parameter array. */
1342 BUFF_FRONT (pfile
->a_buff
) = (U_CHAR
*) ¯o
->params
[macro
->paramc
];
1343 macro
->fun_like
= 1;
1345 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1346 cpp_pedwarn (pfile
, "ISO C requires whitespace after the macro name");
1348 saved_cur_token
= pfile
->cur_token
;
1350 if (macro
->fun_like
)
1351 token
= lex_expansion_token (pfile
, macro
);
1354 token
= alloc_expansion_token (pfile
, macro
);
1360 /* Check the stringifying # constraint 6.10.3.2.1 of
1361 function-like macros when lexing the subsequent token. */
1362 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1364 if (token
->type
== CPP_MACRO_ARG
)
1366 token
->flags
&= ~PREV_WHITE
;
1367 token
->flags
|= STRINGIFY_ARG
;
1368 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1369 token
[-1] = token
[0];
1372 /* Let assembler get away with murder. */
1373 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1376 cpp_error (pfile
, "'#' is not followed by a macro parameter");
1381 if (token
->type
== CPP_EOF
)
1384 /* Paste operator constraint 6.10.3.3.1. */
1385 if (token
->type
== CPP_PASTE
)
1387 /* Token-paste ##, can appear in both object-like and
1388 function-like macros, but not at the ends. */
1389 if (--macro
->count
> 0)
1390 token
= lex_expansion_token (pfile
, macro
);
1392 if (macro
->count
== 0 || token
->type
== CPP_EOF
)
1396 "'##' cannot appear at either end of a macro expansion");
1400 token
[-1].flags
|= PASTE_LEFT
;
1403 token
= lex_expansion_token (pfile
, macro
);
1406 macro
->expansion
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1408 /* Don't count the CPP_EOF. */
1411 /* Clear whitespace on first token for warn_of_redefinition(). */
1413 macro
->expansion
[0].flags
&= ~PREV_WHITE
;
1415 /* Commit the memory. */
1416 BUFF_FRONT (pfile
->a_buff
) = (U_CHAR
*) ¯o
->expansion
[macro
->count
];
1418 /* Implement the macro-defined-to-itself optimisation. */
1419 if (macro
->count
== 1 && !macro
->fun_like
1420 && macro
->expansion
[0].type
== CPP_NAME
1421 && macro
->expansion
[0].val
.node
== node
)
1422 node
->flags
|= NODE_DISABLED
;
1424 /* To suppress some diagnostics. */
1425 macro
->syshdr
= pfile
->map
->sysp
!= 0;
1427 if (node
->type
!= NT_VOID
)
1429 if (warn_of_redefinition (node
, macro
))
1431 cpp_pedwarn_with_line (pfile
, pfile
->directive_line
, 0,
1432 "\"%s\" redefined", NODE_NAME (node
));
1434 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1435 cpp_pedwarn_with_line (pfile
, node
->value
.macro
->line
, 0,
1436 "this is the location of the previous definition");
1438 _cpp_free_definition (node
);
1441 /* Enter definition in hash table. */
1442 node
->type
= NT_MACRO
;
1443 node
->value
.macro
= macro
;
1444 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
1445 node
->flags
|= NODE_WARN
;
1449 /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position. */
1450 saved_cur_token
[-1].type
= pfile
->cur_token
[-1].type
;
1451 pfile
->cur_token
= saved_cur_token
;
1455 /* Stop the lexer accepting __VA_ARGS__. */
1456 pfile
->state
.va_args_ok
= 0;
1458 /* Clear the fast argument lookup indices. */
1459 for (i
= macro
->paramc
; i
-- > 0; )
1460 macro
->params
[i
]->arg_index
= 0;
1465 /* Warn if a token in STRING matches one of a function-like MACRO's
1468 check_trad_stringification (pfile
, macro
, string
)
1470 const cpp_macro
*macro
;
1471 const cpp_string
*string
;
1473 unsigned int i
, len
;
1474 const U_CHAR
*p
, *q
, *limit
= string
->text
+ string
->len
;
1476 /* Loop over the string. */
1477 for (p
= string
->text
; p
< limit
; p
= q
)
1479 /* Find the start of an identifier. */
1480 while (p
< limit
&& !is_idstart (*p
))
1483 /* Find the end of the identifier. */
1485 while (q
< limit
&& is_idchar (*q
))
1490 /* Loop over the function macro arguments to see if the
1491 identifier inside the string matches one of them. */
1492 for (i
= 0; i
< macro
->paramc
; i
++)
1494 const cpp_hashnode
*node
= macro
->params
[i
];
1496 if (NODE_LEN (node
) == len
1497 && !memcmp (p
, NODE_NAME (node
), len
))
1500 "macro argument \"%s\" would be stringified with -traditional",
1508 /* Returns the name, arguments and expansion of a macro, in a format
1509 suitable to be read back in again, and therefore also for DWARF 2
1510 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1511 Caller is expected to generate the "#define" bit if needed. The
1512 returned text is temporary, and automatically freed later. */
1513 const unsigned char *
1514 cpp_macro_definition (pfile
, node
)
1516 const cpp_hashnode
*node
;
1518 unsigned int i
, len
;
1519 const cpp_macro
*macro
= node
->value
.macro
;
1520 unsigned char *buffer
;
1522 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1524 cpp_ice (pfile
, "invalid hash type %d in cpp_macro_definition", node
->type
);
1528 /* Calculate length. */
1529 len
= NODE_LEN (node
) + 1; /* ' ' */
1530 if (macro
->fun_like
)
1532 len
+= 3; /* "()" plus possible final "." of named
1533 varargs (we have + 2 below). */
1534 for (i
= 0; i
< macro
->paramc
; i
++)
1535 len
+= NODE_LEN (macro
->params
[i
]) + 2; /* ", " */
1538 for (i
= 0; i
< macro
->count
; i
++)
1540 cpp_token
*token
= ¯o
->expansion
[i
];
1542 if (token
->type
== CPP_MACRO_ARG
)
1543 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1545 len
+= cpp_token_len (token
); /* Includes room for ' '. */
1546 if (token
->flags
& STRINGIFY_ARG
)
1548 if (token
->flags
& PASTE_LEFT
)
1549 len
+= 3; /* " ##" */
1552 if (len
> pfile
->macro_buffer_len
)
1554 pfile
->macro_buffer
= (U_CHAR
*) xrealloc (pfile
->macro_buffer
, len
);
1555 pfile
->macro_buffer_len
= len
;
1558 /* Fill in the buffer. Start with the macro name. */
1559 buffer
= pfile
->macro_buffer
;
1560 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1561 buffer
+= NODE_LEN (node
);
1563 /* Parameter names. */
1564 if (macro
->fun_like
)
1567 for (i
= 0; i
< macro
->paramc
; i
++)
1569 cpp_hashnode
*param
= macro
->params
[i
];
1571 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1573 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1574 buffer
+= NODE_LEN (param
);
1577 if (i
+ 1 < macro
->paramc
)
1578 *buffer
++ = ',', *buffer
++ = ' ';
1579 else if (macro
->variadic
)
1580 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1585 /* Expansion tokens. */
1589 for (i
= 0; i
< macro
->count
; i
++)
1591 cpp_token
*token
= ¯o
->expansion
[i
];
1593 if (token
->flags
& PREV_WHITE
)
1595 if (token
->flags
& STRINGIFY_ARG
)
1598 if (token
->type
== CPP_MACRO_ARG
)
1600 len
= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1602 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]), len
);
1606 buffer
= cpp_spell_token (pfile
, token
, buffer
);
1608 if (token
->flags
& PASTE_LEFT
)
1613 /* Next has PREV_WHITE; see _cpp_create_definition. */
1619 return pfile
->macro_buffer
;