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
*, 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_ice (pfile
, "invalid built-in macro \"%s\"", NODE_NAME (node
));
155 const struct line_map
*map
= pfile
->map
;
157 if (node
->value
.builtin
== BT_BASE_FILE
)
158 while (! MAIN_FILE_P (map
))
159 map
= INCLUDED_FROM (&pfile
->line_maps
, map
);
163 buf
= _cpp_unaligned_alloc (pfile
, len
* 4 + 1);
164 len
= cpp_quote_string (buf
, (const unsigned char *) name
, len
) - buf
;
166 result
= new_string_token (pfile
, buf
, len
);
170 case BT_INCLUDE_LEVEL
:
171 /* The line map depth counts the primary source as level 1, but
172 historically __INCLUDE_DEPTH__ has called the primary source
174 result
= new_number_token (pfile
, pfile
->line_maps
.depth
- 1);
178 /* If __LINE__ is embedded in a macro, it must expand to the
179 line of the macro's invocation, not its definition.
180 Otherwise things like assert() will not work properly. */
181 result
= new_number_token (pfile
,
182 SOURCE_LINE (pfile
->map
,
183 pfile
->cur_token
[-1].line
));
188 int stdc
= (!CPP_IN_SYSTEM_HEADER (pfile
)
189 || pfile
->spec_nodes
.n__STRICT_ANSI__
->type
!= NT_VOID
);
190 result
= new_number_token (pfile
, stdc
);
196 if (pfile
->date
.type
== CPP_EOF
)
198 /* Allocate __DATE__ and __TIME__ strings from permanent
199 storage. We only do this once, and don't generate them
200 at init time, because time() and localtime() are very
201 slow on some systems. */
202 time_t tt
= time (NULL
);
203 struct tm
*tb
= localtime (&tt
);
205 pfile
->date
.val
.str
.text
=
206 _cpp_unaligned_alloc (pfile
, sizeof ("Oct 11 1347"));
207 pfile
->date
.val
.str
.len
= sizeof ("Oct 11 1347") - 1;
208 pfile
->date
.type
= CPP_STRING
;
209 pfile
->date
.flags
= 0;
210 sprintf ((char *) pfile
->date
.val
.str
.text
, "%s %2d %4d",
211 monthnames
[tb
->tm_mon
], tb
->tm_mday
, tb
->tm_year
+ 1900);
213 pfile
->time
.val
.str
.text
=
214 _cpp_unaligned_alloc (pfile
, sizeof ("12:34:56"));
215 pfile
->time
.val
.str
.len
= sizeof ("12:34:56") - 1;
216 pfile
->time
.type
= CPP_STRING
;
217 pfile
->time
.flags
= 0;
218 sprintf ((char *) pfile
->time
.val
.str
.text
, "%02d:%02d:%02d",
219 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
222 if (node
->value
.builtin
== BT_DATE
)
223 result
= &pfile
->date
;
225 result
= &pfile
->time
;
229 /* Don't interpret _Pragma within directives. The standard is
230 not clear on this, but to me this makes most sense. */
231 if (pfile
->state
.in_directive
)
234 _cpp_do__Pragma (pfile
);
238 push_token_context (pfile
, NULL
, result
, 1);
242 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
243 backslashes and double quotes. Non-printable characters are
244 converted to octal. DEST must be of sufficient size. Returns
245 a pointer to the end of the string. */
247 cpp_quote_string (dest
, src
, len
)
256 if (c
== '\\' || c
== '"')
267 sprintf ((char *) dest
, "\\%03o", c
);
276 /* Convert a token sequence ARG to a single string token according to
277 the rules of the ISO C #-operator. */
278 static const cpp_token
*
279 stringify_arg (pfile
, arg
)
283 unsigned char *dest
= BUFF_FRONT (pfile
->u_buff
);
284 unsigned int i
, escape_it
, backslash_count
= 0;
285 const cpp_token
*source
= NULL
;
288 /* Loop, reading in the argument's tokens. */
289 for (i
= 0; i
< arg
->count
; i
++)
291 const cpp_token
*token
= arg
->first
[i
];
293 if (token
->type
== CPP_PADDING
)
296 source
= token
->val
.source
;
300 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_WSTRING
301 || token
->type
== CPP_CHAR
|| token
->type
== CPP_WCHAR
);
303 /* Room for each char being written in octal, initial space and
305 len
= cpp_token_len (token
);
310 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
312 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
313 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
314 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
317 /* Leading white space? */
318 if (dest
!= BUFF_FRONT (pfile
->u_buff
))
322 if (source
->flags
& PREV_WHITE
)
329 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
330 unsigned char *buf
= BUFF_FRONT (buff
);
331 len
= cpp_spell_token (pfile
, token
, buf
) - buf
;
332 dest
= cpp_quote_string (dest
, buf
, len
);
333 _cpp_release_buff (pfile
, buff
);
336 dest
= cpp_spell_token (pfile
, token
, dest
);
338 if (token
->type
== CPP_OTHER
&& token
->val
.c
== '\\')
344 /* Ignore the final \ of invalid string literals. */
345 if (backslash_count
& 1)
347 cpp_warning (pfile
, "invalid string literal, ignoring final '\\'");
351 /* Commit the memory, including NUL, and return the token. */
352 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
353 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
354 return new_string_token (pfile
, dest
- len
, len
);
357 /* Try to paste two tokens. On success, return non-zero. In any
358 case, PLHS is updated to point to the pasted token, which is
359 guaranteed to not have the PASTE_LEFT flag set. */
361 paste_tokens (pfile
, plhs
, rhs
)
363 const cpp_token
**plhs
, *rhs
;
365 unsigned char *buf
, *end
;
366 const cpp_token
*lhs
;
371 len
= cpp_token_len (lhs
) + cpp_token_len (rhs
) + 1;
372 buf
= (unsigned char *) alloca (len
);
373 end
= cpp_spell_token (pfile
, lhs
, buf
);
375 /* Avoid comment headers, since they are still processed in stage 3.
376 It is simpler to insert a space here, rather than modifying the
377 lexer to ignore comments in some circumstances. Simply returning
378 false doesn't work, since we want to clear the PASTE_LEFT flag. */
379 if (lhs
->type
== CPP_DIV
380 && (rhs
->type
== CPP_MULT
|| rhs
->type
== CPP_DIV
))
382 end
= cpp_spell_token (pfile
, rhs
, end
);
385 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true, 1);
387 /* Tweak the column number the lexer will report. */
388 pfile
->buffer
->col_adjust
= pfile
->cur_token
[-1].col
- 1;
390 /* We don't want a leading # to be interpreted as a directive. */
391 pfile
->buffer
->saved_flags
= 0;
393 /* Set pfile->cur_token as required by _cpp_lex_direct. */
394 pfile
->cur_token
= _cpp_temp_token (pfile
);
395 *plhs
= _cpp_lex_direct (pfile
);
396 valid
= pfile
->buffer
->cur
== pfile
->buffer
->rlimit
;
397 _cpp_pop_buffer (pfile
);
402 /* Handles an arbitrarily long sequence of ## operators, with initial
403 operand LHS. This implementation is left-associative,
404 non-recursive, and finishes a paste before handling succeeding
405 ones. If a paste fails, we back up to the RHS of the failing ##
406 operator before pushing the context containing the result of prior
407 successful pastes, with the effect that the RHS appears in the
408 output stream after the pasted LHS normally. */
410 paste_all_tokens (pfile
, lhs
)
412 const cpp_token
*lhs
;
414 const cpp_token
*rhs
;
415 cpp_context
*context
= pfile
->context
;
419 /* Take the token directly from the current context. We can do
420 this, because we are in the replacement list of either an
421 object-like macro, or a function-like macro with arguments
422 inserted. In either case, the constraints to #define
423 guarantee we have at least one more token. */
424 if (context
->direct_p
)
425 rhs
= context
->first
.token
++;
427 rhs
= *context
->first
.ptoken
++;
429 if (rhs
->type
== CPP_PADDING
)
432 if (!paste_tokens (pfile
, &lhs
, rhs
))
434 _cpp_backup_tokens (pfile
, 1);
436 /* Mandatory warning for all apart from assembler. */
437 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
439 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
440 cpp_token_as_text (pfile
, lhs
),
441 cpp_token_as_text (pfile
, rhs
));
445 while (rhs
->flags
& PASTE_LEFT
);
447 /* Put the resulting token in its own context. */
448 push_token_context (pfile
, NULL
, lhs
, 1);
451 /* Reads and returns the arguments to a function-like macro
452 invocation. Assumes the opening parenthesis has been processed.
453 If there is an error, emits an appropriate diagnostic and returns
454 NULL. Each argument is terminated by a CPP_EOF token, for the
455 future benefit of expand_arg(). */
457 collect_args (pfile
, node
)
459 const cpp_hashnode
*node
;
461 _cpp_buff
*buff
, *base_buff
;
463 macro_arg
*args
, *arg
;
464 const cpp_token
*token
;
468 macro
= node
->value
.macro
;
470 argc
= macro
->paramc
;
473 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
474 + sizeof (macro_arg
)));
476 args
= (macro_arg
*) buff
->base
;
477 memset (args
, 0, argc
* sizeof (macro_arg
));
478 buff
->cur
= (unsigned char *) &args
[argc
];
479 arg
= args
, argc
= 0;
481 /* Collect the tokens making up each argument. We don't yet know
482 how many arguments have been supplied, whether too many or too
483 few. Hence the slightly bizarre usage of "argc" and "arg". */
486 unsigned int paren_depth
= 0;
487 unsigned int ntokens
= 0;
490 arg
->first
= (const cpp_token
**) buff
->cur
;
494 /* Require space for 2 new tokens (including a CPP_EOF). */
495 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
497 buff
= _cpp_append_extend_buff (pfile
, buff
,
498 1000 * sizeof (cpp_token
*));
499 arg
->first
= (const cpp_token
**) buff
->cur
;
502 token
= cpp_get_token (pfile
);
504 if (token
->type
== CPP_PADDING
)
506 /* Drop leading padding. */
510 else if (token
->type
== CPP_OPEN_PAREN
)
512 else if (token
->type
== CPP_CLOSE_PAREN
)
514 if (paren_depth
-- == 0)
517 else if (token
->type
== CPP_COMMA
)
519 /* A comma does not terminate an argument within
520 parentheses or as part of a variable argument. */
522 && ! (macro
->variadic
&& argc
== macro
->paramc
))
525 else if (token
->type
== CPP_EOF
526 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
529 arg
->first
[ntokens
++] = token
;
532 /* Drop trailing padding. */
533 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
536 arg
->count
= ntokens
;
537 arg
->first
[ntokens
] = &pfile
->eof
;
539 /* Terminate the argument. Excess arguments loop back and
540 overwrite the final legitimate argument, before failing. */
541 if (argc
<= macro
->paramc
)
543 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
544 if (argc
!= macro
->paramc
)
548 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
550 if (token
->type
== CPP_EOF
)
552 /* We still need the CPP_EOF to end directives, and to end
553 pre-expansion of a macro argument. Step back is not
554 unconditional, since we don't want to return a CPP_EOF to our
555 callers at the end of an -include-d file. */
556 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
557 _cpp_backup_tokens (pfile
, 1);
558 cpp_error (pfile
, "unterminated argument list invoking macro \"%s\"",
562 else if (argc
< macro
->paramc
)
564 /* As an extension, a rest argument is allowed to not appear in
565 the invocation at all.
566 e.g. #define debug(format, args...) something
569 This is exactly the same as if there had been an empty rest
570 argument - debug("string", ). */
572 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
574 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
575 cpp_pedwarn (pfile
, "ISO C99 requires rest arguments to be used");
580 "macro \"%s\" requires %u arguments, but only %u given",
581 NODE_NAME (node
), macro
->paramc
, argc
);
585 else if (argc
> macro
->paramc
)
587 /* Empty argument to a macro taking no arguments is OK. */
588 if (argc
!= 1 || arg
->count
)
591 "macro \"%s\" passed %u arguments, but takes just %u",
592 NODE_NAME (node
), argc
, macro
->paramc
);
600 _cpp_release_buff (pfile
, base_buff
);
604 /* Search for an opening parenthesis to the macro of NODE, in such a
605 way that, if none is found, we don't lose the information in any
606 intervening padding tokens. If we find the parenthesis, collect
607 the arguments and return the buffer containing them. */
609 funlike_invocation_p (pfile
, node
)
613 const cpp_token
*token
, *padding
= NULL
;
617 token
= cpp_get_token (pfile
);
618 if (token
->type
!= CPP_PADDING
)
621 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
625 if (token
->type
== CPP_OPEN_PAREN
)
627 pfile
->state
.parsing_args
= 2;
628 return collect_args (pfile
, node
);
631 /* Back up. We may have skipped padding, in which case backing up
632 more than one token when expanding macros is in general too
633 difficult. We re-insert it in its own context. */
634 _cpp_backup_tokens (pfile
, 1);
636 push_token_context (pfile
, NULL
, padding
, 1);
641 /* Push the context of a macro with hash entry NODE onto the context
642 stack. If we can successfully expand the macro, we push a context
643 containing its yet-to-be-rescanned replacement list and return one.
644 Otherwise, we don't push a context and return zero. */
646 enter_macro_context (pfile
, node
)
650 /* The presence of a macro invalidates a file's controlling macro. */
651 pfile
->mi_valid
= false;
653 /* Handle standard macros. */
654 if (! (node
->flags
& NODE_BUILTIN
))
656 cpp_macro
*macro
= node
->value
.macro
;
662 pfile
->state
.prevent_expansion
++;
663 pfile
->keep_tokens
++;
664 pfile
->state
.parsing_args
= 1;
665 buff
= funlike_invocation_p (pfile
, node
);
666 pfile
->state
.parsing_args
= 0;
667 pfile
->keep_tokens
--;
668 pfile
->state
.prevent_expansion
--;
672 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
674 "function-like macro \"%s\" must be used with arguments in traditional C",
680 if (macro
->paramc
> 0)
681 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
682 _cpp_release_buff (pfile
, buff
);
685 /* Disable the macro within its expansion. */
686 node
->flags
|= NODE_DISABLED
;
688 if (macro
->paramc
== 0)
689 push_token_context (pfile
, node
, macro
->expansion
, macro
->count
);
694 /* Handle built-in macros and the _Pragma operator. */
695 return builtin_macro (pfile
, node
);
698 /* Replace the parameters in a function-like macro of NODE with the
699 actual ARGS, and place the result in a newly pushed token context.
700 Expand each argument before replacing, unless it is operated upon
701 by the # or ## operators. */
703 replace_args (pfile
, node
, macro
, args
)
709 unsigned int i
, total
;
710 const cpp_token
*src
, *limit
;
711 const cpp_token
**dest
, **first
;
715 /* First, fully macro-expand arguments, calculating the number of
716 tokens in the final expansion as we go. The ordering of the if
717 statements below is subtle; we must handle stringification before
719 total
= macro
->count
;
720 limit
= macro
->expansion
+ macro
->count
;
722 for (src
= macro
->expansion
; src
< limit
; src
++)
723 if (src
->type
== CPP_MACRO_ARG
)
725 /* Leading and trailing padding tokens. */
728 /* We have an argument. If it is not being stringified or
729 pasted it is macro-replaced before insertion. */
730 arg
= &args
[src
->val
.arg_no
- 1];
732 if (src
->flags
& STRINGIFY_ARG
)
734 if (!arg
->stringified
)
735 arg
->stringified
= stringify_arg (pfile
, arg
);
737 else if ((src
->flags
& PASTE_LEFT
)
738 || (src
> macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
)))
739 total
+= arg
->count
- 1;
743 expand_arg (pfile
, arg
);
744 total
+= arg
->expanded_count
- 1;
748 /* Now allocate space for the expansion, copy the tokens and replace
750 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
751 first
= (const cpp_token
**) buff
->base
;
754 for (src
= macro
->expansion
; src
< limit
; src
++)
757 const cpp_token
**from
, **paste_flag
;
759 if (src
->type
!= CPP_MACRO_ARG
)
766 arg
= &args
[src
->val
.arg_no
- 1];
767 if (src
->flags
& STRINGIFY_ARG
)
768 count
= 1, from
= &arg
->stringified
;
769 else if (src
->flags
& PASTE_LEFT
)
770 count
= arg
->count
, from
= arg
->first
;
771 else if (src
!= macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
))
773 count
= arg
->count
, from
= arg
->first
;
776 /* GCC has special semantics for , ## b where b is a
777 varargs parameter: the comma disappears if b was
778 given no actual arguments (not merely if b is an
779 empty argument); otherwise the paste flag is removed. */
780 if (dest
[-1]->type
== CPP_COMMA
782 && src
->val
.arg_no
== macro
->paramc
)
787 paste_flag
= dest
- 1;
789 /* Remove the paste flag if the RHS is a placemarker. */
791 paste_flag
= dest
- 1;
795 count
= arg
->expanded_count
, from
= arg
->expanded
;
797 /* Padding on the left of an argument (unless RHS of ##). */
798 if (!pfile
->state
.in_directive
799 && src
!= macro
->expansion
&& !(src
[-1].flags
& PASTE_LEFT
))
800 *dest
++ = padding_token (pfile
, src
);
804 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
807 /* With a non-empty argument on the LHS of ##, the last
808 token should be flagged PASTE_LEFT. */
809 if (src
->flags
& PASTE_LEFT
)
810 paste_flag
= dest
- 1;
813 /* Avoid paste on RHS (even case count == 0). */
814 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
815 *dest
++ = &pfile
->avoid_paste
;
817 /* Add a new paste flag, or remove an unwanted one. */
820 cpp_token
*token
= _cpp_temp_token (pfile
);
821 token
->type
= (*paste_flag
)->type
;
822 token
->val
.str
= (*paste_flag
)->val
.str
;
823 if (src
->flags
& PASTE_LEFT
)
824 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
826 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
831 /* Free the expanded arguments. */
832 for (i
= 0; i
< macro
->paramc
; i
++)
833 if (args
[i
].expanded
)
834 free (args
[i
].expanded
);
836 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
839 /* Return a special padding token, with padding inherited from SOURCE. */
840 static const cpp_token
*
841 padding_token (pfile
, source
)
843 const cpp_token
*source
;
845 cpp_token
*result
= _cpp_temp_token (pfile
);
847 result
->type
= CPP_PADDING
;
848 result
->val
.source
= source
;
853 /* Get a new uninitialized context. Create a new one if we cannot
854 re-use an old one. */
859 cpp_context
*result
= pfile
->context
->next
;
863 result
= xnew (cpp_context
);
864 result
->prev
= pfile
->context
;
866 pfile
->context
->next
= result
;
869 pfile
->context
= result
;
873 /* Push a list of pointers to tokens. */
875 push_ptoken_context (pfile
, macro
, buff
, first
, count
)
879 const cpp_token
**first
;
882 cpp_context
*context
= next_context (pfile
);
884 context
->direct_p
= false;
885 context
->macro
= macro
;
886 context
->buff
= buff
;
887 context
->first
.ptoken
= first
;
888 context
->last
.ptoken
= first
+ count
;
891 /* Push a list of tokens. */
893 push_token_context (pfile
, macro
, first
, count
)
896 const cpp_token
*first
;
899 cpp_context
*context
= next_context (pfile
);
901 context
->direct_p
= true;
902 context
->macro
= macro
;
903 context
->buff
= NULL
;
904 context
->first
.token
= first
;
905 context
->last
.token
= first
+ count
;
908 /* Expand an argument ARG before replacing parameters in a
909 function-like macro. This works by pushing a context with the
910 argument's tokens, and then expanding that into a temporary buffer
911 as if it were a normal part of the token stream. collect_args()
912 has terminated the argument's tokens with a CPP_EOF so that we know
913 when we have fully expanded the argument. */
915 expand_arg (pfile
, arg
)
919 unsigned int capacity
;
924 /* Loop, reading in the arguments. */
926 arg
->expanded
= (const cpp_token
**)
927 xmalloc (capacity
* sizeof (cpp_token
*));
929 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
932 const cpp_token
*token
;
934 if (arg
->expanded_count
+ 1 >= capacity
)
937 arg
->expanded
= (const cpp_token
**)
938 xrealloc (arg
->expanded
, capacity
* sizeof (cpp_token
*));
941 token
= cpp_get_token (pfile
);
943 if (token
->type
== CPP_EOF
)
946 arg
->expanded
[arg
->expanded_count
++] = token
;
949 _cpp_pop_context (pfile
);
952 /* Pop the current context off the stack, re-enabling the macro if the
953 context represented a macro's replacement list. The context
954 structure is not freed so that we can re-use it later. */
956 _cpp_pop_context (pfile
)
959 cpp_context
*context
= pfile
->context
;
962 context
->macro
->flags
&= ~NODE_DISABLED
;
965 _cpp_release_buff (pfile
, context
->buff
);
967 pfile
->context
= context
->prev
;
970 /* Eternal routine to get a token. Also used nearly everywhere
971 internally, except for places where we know we can safely call
972 the lexer directly, such as lexing a directive name.
974 Macro expansions and directives are transparently handled,
975 including entering included files. Thus tokens are post-macro
976 expansion, and after any intervening directives. External callers
977 see CPP_EOF only at EOF. Internal callers also see it when meeting
978 a directive inside a macro call, when at the end of a directive and
979 state.in_directive is still 1, and at the end of argument
982 cpp_get_token (pfile
)
985 const cpp_token
*result
;
990 cpp_context
*context
= pfile
->context
;
992 /* Context->prev == 0 <=> base context. */
994 result
= _cpp_lex_token (pfile
);
995 else if (context
->first
.token
!= context
->last
.token
)
997 if (context
->direct_p
)
998 result
= context
->first
.token
++;
1000 result
= *context
->first
.ptoken
++;
1002 if (result
->flags
& PASTE_LEFT
)
1004 paste_all_tokens (pfile
, result
);
1005 if (pfile
->state
.in_directive
)
1007 return padding_token (pfile
, result
);
1012 _cpp_pop_context (pfile
);
1013 if (pfile
->state
.in_directive
)
1015 return &pfile
->avoid_paste
;
1018 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1021 if (result
->type
!= CPP_NAME
)
1024 node
= result
->val
.node
;
1026 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1029 if (!(node
->flags
& NODE_DISABLED
))
1031 if (!pfile
->state
.prevent_expansion
1032 && enter_macro_context (pfile
, node
))
1034 if (pfile
->state
.in_directive
)
1036 return padding_token (pfile
, result
);
1041 /* Flag this token as always unexpandable. FIXME: move this
1042 to collect_args()?. */
1043 cpp_token
*t
= _cpp_temp_token (pfile
);
1044 t
->type
= result
->type
;
1045 t
->flags
= result
->flags
| NO_EXPAND
;
1046 t
->val
.str
= result
->val
.str
;
1056 /* Returns true if we're expanding an object-like macro that was
1057 defined in a system header. Just checks the macro at the top of
1058 the stack. Used for diagnostic suppression. */
1060 cpp_sys_macro_p (pfile
)
1063 cpp_hashnode
*node
= pfile
->context
->macro
;
1065 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1068 /* Read each token in, until EOF. Directives are transparently
1071 cpp_scan_nooutput (pfile
)
1074 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1078 /* Step back one (or more) tokens. Can only step mack more than 1 if
1079 they are from the lexer, and not from macro expansion. */
1081 _cpp_backup_tokens (pfile
, count
)
1085 if (pfile
->context
->prev
== NULL
)
1087 pfile
->lookaheads
+= count
;
1091 if (pfile
->cur_token
== pfile
->cur_run
->base
1092 /* Possible with -fpreprocessed and no leading #line. */
1093 && pfile
->cur_run
->prev
!= NULL
)
1095 pfile
->cur_run
= pfile
->cur_run
->prev
;
1096 pfile
->cur_token
= pfile
->cur_run
->limit
;
1104 if (pfile
->context
->direct_p
)
1105 pfile
->context
->first
.token
--;
1107 pfile
->context
->first
.ptoken
--;
1111 /* #define directive parsing and handling. */
1113 /* Returns non-zero if a macro redefinition warning is required. */
1115 warn_of_redefinition (node
, macro2
)
1116 const cpp_hashnode
*node
;
1117 const cpp_macro
*macro2
;
1119 const cpp_macro
*macro1
;
1122 /* Some redefinitions need to be warned about regardless. */
1123 if (node
->flags
& NODE_WARN
)
1126 /* Redefinition of a macro is allowed if and only if the old and new
1127 definitions are the same. (6.10.3 paragraph 2). */
1128 macro1
= node
->value
.macro
;
1130 /* The quick failures. */
1131 if (macro1
->count
!= macro2
->count
1132 || macro1
->paramc
!= macro2
->paramc
1133 || macro1
->fun_like
!= macro2
->fun_like
1134 || macro1
->variadic
!= macro2
->variadic
)
1137 /* Check each token. */
1138 for (i
= 0; i
< macro1
->count
; i
++)
1139 if (! _cpp_equiv_tokens (¯o1
->expansion
[i
], ¯o2
->expansion
[i
]))
1142 /* Check parameter spellings. */
1143 for (i
= 0; i
< macro1
->paramc
; i
++)
1144 if (macro1
->params
[i
] != macro2
->params
[i
])
1150 /* Free the definition of hashnode H. */
1152 _cpp_free_definition (h
)
1155 /* Macros and assertions no longer have anything to free. */
1157 /* Clear builtin flag in case of redefinition. */
1158 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
);
1161 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1162 zero on success, non-zero if the parameter is a duplicate. */
1164 save_parameter (pfile
, macro
, node
)
1169 /* Constraint 6.10.3.6 - duplicate parameter names. */
1170 if (node
->arg_index
)
1172 cpp_error (pfile
, "duplicate macro parameter \"%s\"", NODE_NAME (node
));
1176 if (BUFF_ROOM (pfile
->a_buff
)
1177 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1178 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1180 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1181 node
->arg_index
= macro
->paramc
;
1185 /* Check the syntax of the parameters in a MACRO definition. */
1187 parse_params (pfile
, macro
)
1191 unsigned int prev_ident
= 0;
1195 const cpp_token
*token
= _cpp_lex_token (pfile
);
1197 switch (token
->type
)
1200 /* Allow/ignore comments in parameter lists if we are
1201 preserving comments in macro expansions. */
1202 if (token
->type
== CPP_COMMENT
1203 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1206 cpp_error (pfile
, "\"%s\" may not appear in macro parameter list",
1207 cpp_token_as_text (pfile
, token
));
1213 cpp_error (pfile
, "macro parameters must be comma-separated");
1218 if (save_parameter (pfile
, macro
, token
->val
.node
))
1222 case CPP_CLOSE_PAREN
:
1223 if (prev_ident
|| macro
->paramc
== 0)
1226 /* Fall through to pick up the error. */
1230 cpp_error (pfile
, "parameter name missing");
1237 macro
->variadic
= 1;
1240 save_parameter (pfile
, macro
, pfile
->spec_nodes
.n__VA_ARGS__
);
1241 pfile
->state
.va_args_ok
= 1;
1242 if (! CPP_OPTION (pfile
, c99
) && CPP_OPTION (pfile
, pedantic
))
1244 "anonymous variadic macros were introduced in C99");
1246 else if (CPP_OPTION (pfile
, pedantic
))
1247 cpp_pedwarn (pfile
, "ISO C does not permit named variadic macros");
1249 /* We're at the end, and just expect a closing parenthesis. */
1250 token
= _cpp_lex_token (pfile
);
1251 if (token
->type
== CPP_CLOSE_PAREN
)
1256 cpp_error (pfile
, "missing ')' in macro parameter list");
1262 /* Allocate room for a token from a macro's replacement list. */
1264 alloc_expansion_token (pfile
, macro
)
1268 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1269 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1271 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1274 /* Lex a token from the expansion of MACRO, but mark parameters as we
1275 find them and warn of traditional stringification. */
1277 lex_expansion_token (pfile
, macro
)
1283 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1284 token
= _cpp_lex_direct (pfile
);
1286 /* Is this a parameter? */
1287 if (token
->type
== CPP_NAME
&& token
->val
.node
->arg_index
)
1289 token
->type
= CPP_MACRO_ARG
;
1290 token
->val
.arg_no
= token
->val
.node
->arg_index
;
1292 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1293 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1294 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1299 /* Parse a macro and save its expansion. Returns non-zero on success. */
1301 _cpp_create_definition (pfile
, node
)
1306 cpp_token
*token
, *saved_cur_token
;
1307 const cpp_token
*ctoken
;
1308 unsigned int i
, ok
= 1;
1310 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1311 macro
->line
= pfile
->directive_line
;
1314 macro
->variadic
= 0;
1316 macro
->fun_like
= 0;
1318 /* Get the first token of the expansion (or the '(' of a
1319 function-like macro). */
1320 ctoken
= _cpp_lex_token (pfile
);
1322 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1324 ok
= parse_params (pfile
, macro
);
1325 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1329 /* Success. Commit the parameter array. */
1330 BUFF_FRONT (pfile
->a_buff
) = (U_CHAR
*) ¯o
->params
[macro
->paramc
];
1331 macro
->fun_like
= 1;
1333 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1334 cpp_pedwarn (pfile
, "ISO C requires whitespace after the macro name");
1336 saved_cur_token
= pfile
->cur_token
;
1338 if (macro
->fun_like
)
1339 token
= lex_expansion_token (pfile
, macro
);
1342 token
= alloc_expansion_token (pfile
, macro
);
1348 /* Check the stringifying # constraint 6.10.3.2.1 of
1349 function-like macros when lexing the subsequent token. */
1350 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1352 if (token
->type
== CPP_MACRO_ARG
)
1354 token
->flags
&= ~PREV_WHITE
;
1355 token
->flags
|= STRINGIFY_ARG
;
1356 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1357 token
[-1] = token
[0];
1360 /* Let assembler get away with murder. */
1361 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1364 cpp_error (pfile
, "'#' is not followed by a macro parameter");
1369 if (token
->type
== CPP_EOF
)
1372 /* Paste operator constraint 6.10.3.3.1. */
1373 if (token
->type
== CPP_PASTE
)
1375 /* Token-paste ##, can appear in both object-like and
1376 function-like macros, but not at the ends. */
1377 if (--macro
->count
> 0)
1378 token
= lex_expansion_token (pfile
, macro
);
1380 if (macro
->count
== 0 || token
->type
== CPP_EOF
)
1384 "'##' cannot appear at either end of a macro expansion");
1388 token
[-1].flags
|= PASTE_LEFT
;
1391 token
= lex_expansion_token (pfile
, macro
);
1394 macro
->expansion
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1396 /* Don't count the CPP_EOF. */
1399 /* Clear whitespace on first token for warn_of_redefinition(). */
1401 macro
->expansion
[0].flags
&= ~PREV_WHITE
;
1403 /* Commit the memory. */
1404 BUFF_FRONT (pfile
->a_buff
) = (U_CHAR
*) ¯o
->expansion
[macro
->count
];
1406 /* Implement the macro-defined-to-itself optimisation. */
1407 if (macro
->count
== 1 && !macro
->fun_like
1408 && macro
->expansion
[0].type
== CPP_NAME
1409 && macro
->expansion
[0].val
.node
== node
)
1410 node
->flags
|= NODE_DISABLED
;
1412 /* To suppress some diagnostics. */
1413 macro
->syshdr
= pfile
->map
->sysp
!= 0;
1415 if (node
->type
!= NT_VOID
)
1417 if (warn_of_redefinition (node
, macro
))
1419 cpp_pedwarn_with_line (pfile
, pfile
->directive_line
, 0,
1420 "\"%s\" redefined", NODE_NAME (node
));
1422 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1423 cpp_pedwarn_with_line (pfile
, node
->value
.macro
->line
, 0,
1424 "this is the location of the previous definition");
1426 _cpp_free_definition (node
);
1429 /* Enter definition in hash table. */
1430 node
->type
= NT_MACRO
;
1431 node
->value
.macro
= macro
;
1432 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
1433 node
->flags
|= NODE_WARN
;
1437 /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position. */
1438 saved_cur_token
[-1].type
= pfile
->cur_token
[-1].type
;
1439 pfile
->cur_token
= saved_cur_token
;
1443 /* Stop the lexer accepting __VA_ARGS__. */
1444 pfile
->state
.va_args_ok
= 0;
1446 /* Clear the fast argument lookup indices. */
1447 for (i
= macro
->paramc
; i
-- > 0; )
1448 macro
->params
[i
]->arg_index
= 0;
1453 /* Warn if a token in STRING matches one of a function-like MACRO's
1456 check_trad_stringification (pfile
, macro
, string
)
1458 const cpp_macro
*macro
;
1459 const cpp_string
*string
;
1461 unsigned int i
, len
;
1462 const U_CHAR
*p
, *q
, *limit
= string
->text
+ string
->len
;
1464 /* Loop over the string. */
1465 for (p
= string
->text
; p
< limit
; p
= q
)
1467 /* Find the start of an identifier. */
1468 while (p
< limit
&& !is_idstart (*p
))
1471 /* Find the end of the identifier. */
1473 while (q
< limit
&& is_idchar (*q
))
1478 /* Loop over the function macro arguments to see if the
1479 identifier inside the string matches one of them. */
1480 for (i
= 0; i
< macro
->paramc
; i
++)
1482 const cpp_hashnode
*node
= macro
->params
[i
];
1484 if (NODE_LEN (node
) == len
1485 && !memcmp (p
, NODE_NAME (node
), len
))
1488 "macro argument \"%s\" would be stringified in traditional C",
1496 /* Returns the name, arguments and expansion of a macro, in a format
1497 suitable to be read back in again, and therefore also for DWARF 2
1498 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1499 Caller is expected to generate the "#define" bit if needed. The
1500 returned text is temporary, and automatically freed later. */
1501 const unsigned char *
1502 cpp_macro_definition (pfile
, node
)
1504 const cpp_hashnode
*node
;
1506 unsigned int i
, len
;
1507 const cpp_macro
*macro
= node
->value
.macro
;
1508 unsigned char *buffer
;
1510 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1512 cpp_ice (pfile
, "invalid hash type %d in cpp_macro_definition", node
->type
);
1516 /* Calculate length. */
1517 len
= NODE_LEN (node
) + 1; /* ' ' */
1518 if (macro
->fun_like
)
1520 len
+= 4; /* "()" plus possible final ".." of named
1521 varargs (we have + 1 below). */
1522 for (i
= 0; i
< macro
->paramc
; i
++)
1523 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1526 for (i
= 0; i
< macro
->count
; i
++)
1528 cpp_token
*token
= ¯o
->expansion
[i
];
1530 if (token
->type
== CPP_MACRO_ARG
)
1531 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1533 len
+= cpp_token_len (token
); /* Includes room for ' '. */
1534 if (token
->flags
& STRINGIFY_ARG
)
1536 if (token
->flags
& PASTE_LEFT
)
1537 len
+= 3; /* " ##" */
1540 if (len
> pfile
->macro_buffer_len
)
1542 pfile
->macro_buffer
= (U_CHAR
*) xrealloc (pfile
->macro_buffer
, len
);
1543 pfile
->macro_buffer_len
= len
;
1546 /* Fill in the buffer. Start with the macro name. */
1547 buffer
= pfile
->macro_buffer
;
1548 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1549 buffer
+= NODE_LEN (node
);
1551 /* Parameter names. */
1552 if (macro
->fun_like
)
1555 for (i
= 0; i
< macro
->paramc
; i
++)
1557 cpp_hashnode
*param
= macro
->params
[i
];
1559 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1561 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1562 buffer
+= NODE_LEN (param
);
1565 if (i
+ 1 < macro
->paramc
)
1566 /* Don't emit a space after the comma here; we're trying
1567 to emit a Dwarf-friendly definition, and the Dwarf spec
1568 forbids spaces in the argument list. */
1570 else if (macro
->variadic
)
1571 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1576 /* The Dwarf spec requires a space after the macro name, even if the
1577 definition is the empty string. */
1580 /* Expansion tokens. */
1583 for (i
= 0; i
< macro
->count
; i
++)
1585 cpp_token
*token
= ¯o
->expansion
[i
];
1587 if (token
->flags
& PREV_WHITE
)
1589 if (token
->flags
& STRINGIFY_ARG
)
1592 if (token
->type
== CPP_MACRO_ARG
)
1594 len
= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1596 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]), len
);
1600 buffer
= cpp_spell_token (pfile
, token
, buffer
);
1602 if (token
->flags
& PASTE_LEFT
)
1607 /* Next has PREV_WHITE; see _cpp_create_definition. */
1613 return pfile
->macro_buffer
;