1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000, 2001, 2002, 2003 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! */
28 #include "coretypes.h"
33 typedef struct macro_arg macro_arg
;
36 const cpp_token
**first
; /* First token in unexpanded argument. */
37 const cpp_token
**expanded
; /* Macro-expanded argument. */
38 const cpp_token
*stringified
; /* Stringified argument. */
39 unsigned int count
; /* # of tokens in argument. */
40 unsigned int expanded_count
; /* # of tokens in expanded argument. */
43 /* Macro expansion. */
45 static int enter_macro_context
PARAMS ((cpp_reader
*, cpp_hashnode
*));
46 static int builtin_macro
PARAMS ((cpp_reader
*, cpp_hashnode
*));
47 static void push_token_context
48 PARAMS ((cpp_reader
*, cpp_hashnode
*, const cpp_token
*, unsigned int));
49 static void push_ptoken_context
50 PARAMS ((cpp_reader
*, cpp_hashnode
*, _cpp_buff
*,
51 const cpp_token
**, unsigned int));
52 static _cpp_buff
*collect_args
PARAMS ((cpp_reader
*, const cpp_hashnode
*));
53 static cpp_context
*next_context
PARAMS ((cpp_reader
*));
54 static const cpp_token
*padding_token
55 PARAMS ((cpp_reader
*, const cpp_token
*));
56 static void expand_arg
PARAMS ((cpp_reader
*, macro_arg
*));
57 static const cpp_token
*new_string_token
PARAMS ((cpp_reader
*, uchar
*,
59 static const cpp_token
*stringify_arg
PARAMS ((cpp_reader
*, macro_arg
*));
60 static void paste_all_tokens
PARAMS ((cpp_reader
*, const cpp_token
*));
61 static bool paste_tokens
PARAMS ((cpp_reader
*, const cpp_token
**,
63 static void replace_args
PARAMS ((cpp_reader
*, cpp_hashnode
*, cpp_macro
*,
65 static _cpp_buff
*funlike_invocation_p
PARAMS ((cpp_reader
*, cpp_hashnode
*));
66 static bool create_iso_definition
PARAMS ((cpp_reader
*, cpp_macro
*));
68 /* #define directive parsing and handling. */
70 static cpp_token
*alloc_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
71 static cpp_token
*lex_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
72 static bool warn_of_redefinition
PARAMS ((cpp_reader
*, const cpp_hashnode
*,
74 static bool parse_params
PARAMS ((cpp_reader
*, cpp_macro
*));
75 static void check_trad_stringification
PARAMS ((cpp_reader
*,
79 /* Emits a warning if NODE is a macro defined in the main file that
82 _cpp_warn_if_unused_macro (pfile
, node
, v
)
85 void *v ATTRIBUTE_UNUSED
;
87 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
89 cpp_macro
*macro
= node
->value
.macro
;
92 && MAIN_FILE_P (lookup_line (&pfile
->line_maps
, macro
->line
)))
93 cpp_error_with_line (pfile
, DL_WARNING
, macro
->line
, 0,
94 "macro \"%s\" is not used", NODE_NAME (node
));
100 /* Allocates and returns a CPP_STRING token, containing TEXT of length
101 LEN, after null-terminating it. TEXT must be in permanent storage. */
102 static const cpp_token
*
103 new_string_token (pfile
, text
, len
)
108 cpp_token
*token
= _cpp_temp_token (pfile
);
111 token
->type
= CPP_STRING
;
112 token
->val
.str
.len
= len
;
113 token
->val
.str
.text
= text
;
118 static const char * const monthnames
[] =
120 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
121 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
124 /* Handle builtin macros like __FILE__, and push the resulting token
125 on the context stack. Also handles _Pragma, for which no new token
126 is created. Returns 1 if it generates a new token context, 0 to
127 return the token to the caller. */
129 _cpp_builtin_macro_text (pfile
, node
)
133 const uchar
*result
= NULL
;
134 unsigned int number
= 1;
136 switch (node
->value
.builtin
)
139 cpp_error (pfile
, DL_ICE
, "invalid built-in macro \"%s\"",
149 const struct line_map
*map
= pfile
->map
;
151 if (node
->value
.builtin
== BT_BASE_FILE
)
152 while (! MAIN_FILE_P (map
))
153 map
= INCLUDED_FROM (&pfile
->line_maps
, map
);
157 buf
= _cpp_unaligned_alloc (pfile
, len
* 4 + 3);
160 buf
= cpp_quote_string (buf
+ 1, (const unsigned char *) name
, len
);
166 case BT_INCLUDE_LEVEL
:
167 /* The line map depth counts the primary source as level 1, but
168 historically __INCLUDE_DEPTH__ has called the primary source
170 number
= pfile
->line_maps
.depth
- 1;
174 /* If __LINE__ is embedded in a macro, it must expand to the
175 line of the macro's invocation, not its definition.
176 Otherwise things like assert() will not work properly. */
177 if (CPP_OPTION (pfile
, traditional
))
178 number
= pfile
->line
;
180 number
= pfile
->cur_token
[-1].line
;
181 number
= SOURCE_LINE (pfile
->map
, number
);
184 /* __STDC__ has the value 1 under normal circumstances.
185 However, if (a) we are in a system header, (b) the option
186 stdc_0_in_system_headers is true (set by target config), and
187 (c) we are not in strictly conforming mode, then it has the
191 if (CPP_IN_SYSTEM_HEADER (pfile
)
192 && CPP_OPTION (pfile
, stdc_0_in_system_headers
)
193 && !CPP_OPTION (pfile
,std
))
202 if (pfile
->date
== NULL
)
204 /* Allocate __DATE__ and __TIME__ strings from permanent
205 storage. We only do this once, and don't generate them
206 at init time, because time() and localtime() are very
207 slow on some systems. */
209 struct tm
*tb
= NULL
;
211 /* (time_t) -1 is a legitimate value for "number of seconds
212 since the Epoch", so we have to do a little dance to
213 distinguish that from a genuine error. */
216 if (tt
!= (time_t)-1 || errno
== 0)
217 tb
= localtime (&tt
);
221 pfile
->date
= _cpp_unaligned_alloc (pfile
,
222 sizeof ("\"Oct 11 1347\""));
223 sprintf ((char *) pfile
->date
, "\"%s %2d %4d\"",
224 monthnames
[tb
->tm_mon
], tb
->tm_mday
, tb
->tm_year
+ 1900);
226 pfile
->time
= _cpp_unaligned_alloc (pfile
,
227 sizeof ("\"12:34:56\""));
228 sprintf ((char *) pfile
->time
, "\"%02d:%02d:%02d\"",
229 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
233 cpp_errno (pfile
, DL_WARNING
,
234 "could not determine date and time");
236 pfile
->date
= U
"\"??? ?? ????\"";
237 pfile
->time
= U
"\"??:??:??\"";
241 if (node
->value
.builtin
== BT_DATE
)
242 result
= pfile
->date
;
244 result
= pfile
->time
;
250 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers. */
251 result
= _cpp_unaligned_alloc (pfile
, 21);
252 sprintf ((char *) result
, "%u", number
);
258 /* Convert builtin macros like __FILE__ to a token and push it on the
259 context stack. Also handles _Pragma, for which no new token is
260 created. Returns 1 if it generates a new token context, 0 to
261 return the token to the caller. */
263 builtin_macro (pfile
, node
)
269 if (node
->value
.builtin
== BT_PRAGMA
)
271 /* Don't interpret _Pragma within directives. The standard is
272 not clear on this, but to me this makes most sense. */
273 if (pfile
->state
.in_directive
)
276 _cpp_do__Pragma (pfile
);
280 buf
= _cpp_builtin_macro_text (pfile
, node
);
282 cpp_push_buffer (pfile
, buf
, ustrlen (buf
), /* from_stage3 */ true, 1);
284 /* Tweak the column number the lexer will report. */
285 pfile
->buffer
->col_adjust
= pfile
->cur_token
[-1].col
- 1;
287 /* We don't want a leading # to be interpreted as a directive. */
288 pfile
->buffer
->saved_flags
= 0;
290 /* Set pfile->cur_token as required by _cpp_lex_direct. */
291 pfile
->cur_token
= _cpp_temp_token (pfile
);
292 push_token_context (pfile
, NULL
, _cpp_lex_direct (pfile
), 1);
293 if (pfile
->buffer
->cur
!= pfile
->buffer
->rlimit
)
294 cpp_error (pfile
, DL_ICE
, "invalid built-in macro \"%s\"",
296 _cpp_pop_buffer (pfile
);
301 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
302 backslashes and double quotes. Non-printable characters are
303 converted to octal. DEST must be of sufficient size. Returns
304 a pointer to the end of the string. */
306 cpp_quote_string (dest
, src
, len
)
315 if (c
== '\\' || c
== '"')
326 sprintf ((char *) dest
, "\\%03o", c
);
335 /* Convert a token sequence ARG to a single string token according to
336 the rules of the ISO C #-operator. */
337 static const cpp_token
*
338 stringify_arg (pfile
, arg
)
342 unsigned char *dest
= BUFF_FRONT (pfile
->u_buff
);
343 unsigned int i
, escape_it
, backslash_count
= 0;
344 const cpp_token
*source
= NULL
;
347 /* Loop, reading in the argument's tokens. */
348 for (i
= 0; i
< arg
->count
; i
++)
350 const cpp_token
*token
= arg
->first
[i
];
352 if (token
->type
== CPP_PADDING
)
355 source
= token
->val
.source
;
359 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_WSTRING
360 || token
->type
== CPP_CHAR
|| token
->type
== CPP_WCHAR
);
362 /* Room for each char being written in octal, initial space and
364 len
= cpp_token_len (token
);
369 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < len
)
371 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
372 _cpp_extend_buff (pfile
, &pfile
->u_buff
, len
);
373 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
376 /* Leading white space? */
377 if (dest
!= BUFF_FRONT (pfile
->u_buff
))
381 if (source
->flags
& PREV_WHITE
)
388 _cpp_buff
*buff
= _cpp_get_buff (pfile
, len
);
389 unsigned char *buf
= BUFF_FRONT (buff
);
390 len
= cpp_spell_token (pfile
, token
, buf
) - buf
;
391 dest
= cpp_quote_string (dest
, buf
, len
);
392 _cpp_release_buff (pfile
, buff
);
395 dest
= cpp_spell_token (pfile
, token
, dest
);
397 if (token
->type
== CPP_OTHER
&& token
->val
.c
== '\\')
403 /* Ignore the final \ of invalid string literals. */
404 if (backslash_count
& 1)
406 cpp_error (pfile
, DL_WARNING
,
407 "invalid string literal, ignoring final '\\'");
411 /* Commit the memory, including NUL, and return the token. */
412 if ((size_t) (BUFF_LIMIT (pfile
->u_buff
) - dest
) < 1)
414 size_t len_so_far
= dest
- BUFF_FRONT (pfile
->u_buff
);
415 _cpp_extend_buff (pfile
, &pfile
->u_buff
, 1);
416 dest
= BUFF_FRONT (pfile
->u_buff
) + len_so_far
;
418 len
= dest
- BUFF_FRONT (pfile
->u_buff
);
419 BUFF_FRONT (pfile
->u_buff
) = dest
+ 1;
420 return new_string_token (pfile
, dest
- len
, len
);
423 /* Try to paste two tokens. On success, return nonzero. In any
424 case, PLHS is updated to point to the pasted token, which is
425 guaranteed to not have the PASTE_LEFT flag set. */
427 paste_tokens (pfile
, plhs
, rhs
)
429 const cpp_token
**plhs
, *rhs
;
431 unsigned char *buf
, *end
;
432 const cpp_token
*lhs
;
437 len
= cpp_token_len (lhs
) + cpp_token_len (rhs
) + 1;
438 buf
= (unsigned char *) alloca (len
);
439 end
= cpp_spell_token (pfile
, lhs
, buf
);
441 /* Avoid comment headers, since they are still processed in stage 3.
442 It is simpler to insert a space here, rather than modifying the
443 lexer to ignore comments in some circumstances. Simply returning
444 false doesn't work, since we want to clear the PASTE_LEFT flag. */
445 if (lhs
->type
== CPP_DIV
&& rhs
->type
!= CPP_EQ
)
447 end
= cpp_spell_token (pfile
, rhs
, end
);
450 cpp_push_buffer (pfile
, buf
, end
- buf
, /* from_stage3 */ true, 1);
452 /* Tweak the column number the lexer will report. */
453 pfile
->buffer
->col_adjust
= pfile
->cur_token
[-1].col
- 1;
455 /* We don't want a leading # to be interpreted as a directive. */
456 pfile
->buffer
->saved_flags
= 0;
458 /* Set pfile->cur_token as required by _cpp_lex_direct. */
459 pfile
->cur_token
= _cpp_temp_token (pfile
);
460 *plhs
= _cpp_lex_direct (pfile
);
461 valid
= pfile
->buffer
->cur
== pfile
->buffer
->rlimit
;
462 _cpp_pop_buffer (pfile
);
467 /* Handles an arbitrarily long sequence of ## operators, with initial
468 operand LHS. This implementation is left-associative,
469 non-recursive, and finishes a paste before handling succeeding
470 ones. If a paste fails, we back up to the RHS of the failing ##
471 operator before pushing the context containing the result of prior
472 successful pastes, with the effect that the RHS appears in the
473 output stream after the pasted LHS normally. */
475 paste_all_tokens (pfile
, lhs
)
477 const cpp_token
*lhs
;
479 const cpp_token
*rhs
;
480 cpp_context
*context
= pfile
->context
;
484 /* Take the token directly from the current context. We can do
485 this, because we are in the replacement list of either an
486 object-like macro, or a function-like macro with arguments
487 inserted. In either case, the constraints to #define
488 guarantee we have at least one more token. */
489 if (context
->direct_p
)
490 rhs
= FIRST (context
).token
++;
492 rhs
= *FIRST (context
).ptoken
++;
494 if (rhs
->type
== CPP_PADDING
)
497 if (!paste_tokens (pfile
, &lhs
, rhs
))
499 _cpp_backup_tokens (pfile
, 1);
501 /* Mandatory error for all apart from assembler. */
502 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
503 cpp_error (pfile
, DL_ERROR
,
504 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
505 cpp_token_as_text (pfile
, lhs
),
506 cpp_token_as_text (pfile
, rhs
));
510 while (rhs
->flags
& PASTE_LEFT
);
512 /* Put the resulting token in its own context. */
513 push_token_context (pfile
, NULL
, lhs
, 1);
516 /* Returns TRUE if the number of arguments ARGC supplied in an
517 invocation of the MACRO referenced by NODE is valid. An empty
518 invocation to a macro with no parameters should pass ARGC as zero.
520 Note that MACRO cannot necessarily be deduced from NODE, in case
521 NODE was redefined whilst collecting arguments. */
523 _cpp_arguments_ok (pfile
, macro
, node
, argc
)
526 const cpp_hashnode
*node
;
529 if (argc
== macro
->paramc
)
532 if (argc
< macro
->paramc
)
534 /* As an extension, a rest argument is allowed to not appear in
535 the invocation at all.
536 e.g. #define debug(format, args...) something
539 This is exactly the same as if there had been an empty rest
540 argument - debug("string", ). */
542 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
544 if (CPP_PEDANTIC (pfile
) && ! macro
->syshdr
)
545 cpp_error (pfile
, DL_PEDWARN
,
546 "ISO C99 requires rest arguments to be used");
550 cpp_error (pfile
, DL_ERROR
,
551 "macro \"%s\" requires %u arguments, but only %u given",
552 NODE_NAME (node
), macro
->paramc
, argc
);
555 cpp_error (pfile
, DL_ERROR
,
556 "macro \"%s\" passed %u arguments, but takes just %u",
557 NODE_NAME (node
), argc
, macro
->paramc
);
562 /* Reads and returns the arguments to a function-like macro
563 invocation. Assumes the opening parenthesis has been processed.
564 If there is an error, emits an appropriate diagnostic and returns
565 NULL. Each argument is terminated by a CPP_EOF token, for the
566 future benefit of expand_arg(). */
568 collect_args (pfile
, node
)
570 const cpp_hashnode
*node
;
572 _cpp_buff
*buff
, *base_buff
;
574 macro_arg
*args
, *arg
;
575 const cpp_token
*token
;
578 macro
= node
->value
.macro
;
580 argc
= macro
->paramc
;
583 buff
= _cpp_get_buff (pfile
, argc
* (50 * sizeof (cpp_token
*)
584 + sizeof (macro_arg
)));
586 args
= (macro_arg
*) buff
->base
;
587 memset (args
, 0, argc
* sizeof (macro_arg
));
588 buff
->cur
= (unsigned char *) &args
[argc
];
589 arg
= args
, argc
= 0;
591 /* Collect the tokens making up each argument. We don't yet know
592 how many arguments have been supplied, whether too many or too
593 few. Hence the slightly bizarre usage of "argc" and "arg". */
596 unsigned int paren_depth
= 0;
597 unsigned int ntokens
= 0;
600 arg
->first
= (const cpp_token
**) buff
->cur
;
604 /* Require space for 2 new tokens (including a CPP_EOF). */
605 if ((unsigned char *) &arg
->first
[ntokens
+ 2] > buff
->limit
)
607 buff
= _cpp_append_extend_buff (pfile
, buff
,
608 1000 * sizeof (cpp_token
*));
609 arg
->first
= (const cpp_token
**) buff
->cur
;
612 token
= cpp_get_token (pfile
);
614 if (token
->type
== CPP_PADDING
)
616 /* Drop leading padding. */
620 else if (token
->type
== CPP_OPEN_PAREN
)
622 else if (token
->type
== CPP_CLOSE_PAREN
)
624 if (paren_depth
-- == 0)
627 else if (token
->type
== CPP_COMMA
)
629 /* A comma does not terminate an argument within
630 parentheses or as part of a variable argument. */
632 && ! (macro
->variadic
&& argc
== macro
->paramc
))
635 else if (token
->type
== CPP_EOF
636 || (token
->type
== CPP_HASH
&& token
->flags
& BOL
))
639 arg
->first
[ntokens
++] = token
;
642 /* Drop trailing padding. */
643 while (ntokens
> 0 && arg
->first
[ntokens
- 1]->type
== CPP_PADDING
)
646 arg
->count
= ntokens
;
647 arg
->first
[ntokens
] = &pfile
->eof
;
649 /* Terminate the argument. Excess arguments loop back and
650 overwrite the final legitimate argument, before failing. */
651 if (argc
<= macro
->paramc
)
653 buff
->cur
= (unsigned char *) &arg
->first
[ntokens
+ 1];
654 if (argc
!= macro
->paramc
)
658 while (token
->type
!= CPP_CLOSE_PAREN
&& token
->type
!= CPP_EOF
);
660 if (token
->type
== CPP_EOF
)
662 /* We still need the CPP_EOF to end directives, and to end
663 pre-expansion of a macro argument. Step back is not
664 unconditional, since we don't want to return a CPP_EOF to our
665 callers at the end of an -include-d file. */
666 if (pfile
->context
->prev
|| pfile
->state
.in_directive
)
667 _cpp_backup_tokens (pfile
, 1);
668 cpp_error (pfile
, DL_ERROR
,
669 "unterminated argument list invoking macro \"%s\"",
674 /* A single empty argument is counted as no argument. */
675 if (argc
== 1 && macro
->paramc
== 0 && args
[0].count
== 0)
677 if (_cpp_arguments_ok (pfile
, macro
, node
, argc
))
679 /* GCC has special semantics for , ## b where b is a varargs
680 parameter: we remove the comma if b was omitted entirely.
681 If b was merely an empty argument, the comma is retained.
682 If the macro takes just one (varargs) parameter, then we
683 retain the comma only if we are standards conforming.
685 If FIRST is NULL replace_args () swallows the comma. */
686 if (macro
->variadic
&& (argc
< macro
->paramc
687 || (argc
== 1 && args
[0].count
== 0
688 && !CPP_OPTION (pfile
, std
))))
689 args
[macro
->paramc
- 1].first
= NULL
;
694 /* An error occurred. */
695 _cpp_release_buff (pfile
, base_buff
);
699 /* Search for an opening parenthesis to the macro of NODE, in such a
700 way that, if none is found, we don't lose the information in any
701 intervening padding tokens. If we find the parenthesis, collect
702 the arguments and return the buffer containing them. */
704 funlike_invocation_p (pfile
, node
)
708 const cpp_token
*token
, *padding
= NULL
;
712 token
= cpp_get_token (pfile
);
713 if (token
->type
!= CPP_PADDING
)
716 || (!(padding
->flags
& PREV_WHITE
) && token
->val
.source
== NULL
))
720 if (token
->type
== CPP_OPEN_PAREN
)
722 pfile
->state
.parsing_args
= 2;
723 return collect_args (pfile
, node
);
726 /* CPP_EOF can be the end of macro arguments, or the end of the
727 file. We mustn't back up over the latter. Ugh. */
728 if (token
->type
!= CPP_EOF
|| token
== &pfile
->eof
)
730 /* Back up. We may have skipped padding, in which case backing
731 up more than one token when expanding macros is in general
732 too difficult. We re-insert it in its own context. */
733 _cpp_backup_tokens (pfile
, 1);
735 push_token_context (pfile
, NULL
, padding
, 1);
741 /* Push the context of a macro with hash entry NODE onto the context
742 stack. If we can successfully expand the macro, we push a context
743 containing its yet-to-be-rescanned replacement list and return one.
744 Otherwise, we don't push a context and return zero. */
746 enter_macro_context (pfile
, node
)
750 /* The presence of a macro invalidates a file's controlling macro. */
751 pfile
->mi_valid
= false;
753 pfile
->state
.angled_headers
= false;
755 /* Handle standard macros. */
756 if (! (node
->flags
& NODE_BUILTIN
))
758 cpp_macro
*macro
= node
->value
.macro
;
764 pfile
->state
.prevent_expansion
++;
765 pfile
->keep_tokens
++;
766 pfile
->state
.parsing_args
= 1;
767 buff
= funlike_invocation_p (pfile
, node
);
768 pfile
->state
.parsing_args
= 0;
769 pfile
->keep_tokens
--;
770 pfile
->state
.prevent_expansion
--;
774 if (CPP_WTRADITIONAL (pfile
) && ! node
->value
.macro
->syshdr
)
775 cpp_error (pfile
, DL_WARNING
,
776 "function-like macro \"%s\" must be used with arguments in traditional C",
782 if (macro
->paramc
> 0)
783 replace_args (pfile
, node
, macro
, (macro_arg
*) buff
->base
);
784 _cpp_release_buff (pfile
, buff
);
787 /* Disable the macro within its expansion. */
788 node
->flags
|= NODE_DISABLED
;
792 if (macro
->paramc
== 0)
793 push_token_context (pfile
, node
, macro
->exp
.tokens
, macro
->count
);
798 /* Handle built-in macros and the _Pragma operator. */
799 return builtin_macro (pfile
, node
);
802 /* Replace the parameters in a function-like macro of NODE with the
803 actual ARGS, and place the result in a newly pushed token context.
804 Expand each argument before replacing, unless it is operated upon
805 by the # or ## operators. */
807 replace_args (pfile
, node
, macro
, args
)
813 unsigned int i
, total
;
814 const cpp_token
*src
, *limit
;
815 const cpp_token
**dest
, **first
;
819 /* First, fully macro-expand arguments, calculating the number of
820 tokens in the final expansion as we go. The ordering of the if
821 statements below is subtle; we must handle stringification before
823 total
= macro
->count
;
824 limit
= macro
->exp
.tokens
+ macro
->count
;
826 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
827 if (src
->type
== CPP_MACRO_ARG
)
829 /* Leading and trailing padding tokens. */
832 /* We have an argument. If it is not being stringified or
833 pasted it is macro-replaced before insertion. */
834 arg
= &args
[src
->val
.arg_no
- 1];
836 if (src
->flags
& STRINGIFY_ARG
)
838 if (!arg
->stringified
)
839 arg
->stringified
= stringify_arg (pfile
, arg
);
841 else if ((src
->flags
& PASTE_LEFT
)
842 || (src
> macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
)))
843 total
+= arg
->count
- 1;
847 expand_arg (pfile
, arg
);
848 total
+= arg
->expanded_count
- 1;
852 /* Now allocate space for the expansion, copy the tokens and replace
854 buff
= _cpp_get_buff (pfile
, total
* sizeof (cpp_token
*));
855 first
= (const cpp_token
**) buff
->base
;
858 for (src
= macro
->exp
.tokens
; src
< limit
; src
++)
861 const cpp_token
**from
, **paste_flag
;
863 if (src
->type
!= CPP_MACRO_ARG
)
870 arg
= &args
[src
->val
.arg_no
- 1];
871 if (src
->flags
& STRINGIFY_ARG
)
872 count
= 1, from
= &arg
->stringified
;
873 else if (src
->flags
& PASTE_LEFT
)
874 count
= arg
->count
, from
= arg
->first
;
875 else if (src
!= macro
->exp
.tokens
&& (src
[-1].flags
& PASTE_LEFT
))
877 count
= arg
->count
, from
= arg
->first
;
880 if (dest
[-1]->type
== CPP_COMMA
882 && src
->val
.arg_no
== macro
->paramc
)
884 /* Swallow a pasted comma if from == NULL, otherwise
885 drop the paste flag. */
889 paste_flag
= dest
- 1;
891 /* Remove the paste flag if the RHS is a placemarker. */
893 paste_flag
= dest
- 1;
897 count
= arg
->expanded_count
, from
= arg
->expanded
;
899 /* Padding on the left of an argument (unless RHS of ##). */
900 if ((!pfile
->state
.in_directive
|| pfile
->state
.directive_wants_padding
)
901 && src
!= macro
->exp
.tokens
&& !(src
[-1].flags
& PASTE_LEFT
))
902 *dest
++ = padding_token (pfile
, src
);
906 memcpy (dest
, from
, count
* sizeof (cpp_token
*));
909 /* With a non-empty argument on the LHS of ##, the last
910 token should be flagged PASTE_LEFT. */
911 if (src
->flags
& PASTE_LEFT
)
912 paste_flag
= dest
- 1;
915 /* Avoid paste on RHS (even case count == 0). */
916 if (!pfile
->state
.in_directive
&& !(src
->flags
& PASTE_LEFT
))
917 *dest
++ = &pfile
->avoid_paste
;
919 /* Add a new paste flag, or remove an unwanted one. */
922 cpp_token
*token
= _cpp_temp_token (pfile
);
923 token
->type
= (*paste_flag
)->type
;
924 token
->val
.str
= (*paste_flag
)->val
.str
;
925 if (src
->flags
& PASTE_LEFT
)
926 token
->flags
= (*paste_flag
)->flags
| PASTE_LEFT
;
928 token
->flags
= (*paste_flag
)->flags
& ~PASTE_LEFT
;
933 /* Free the expanded arguments. */
934 for (i
= 0; i
< macro
->paramc
; i
++)
935 if (args
[i
].expanded
)
936 free (args
[i
].expanded
);
938 push_ptoken_context (pfile
, node
, buff
, first
, dest
- first
);
941 /* Return a special padding token, with padding inherited from SOURCE. */
942 static const cpp_token
*
943 padding_token (pfile
, source
)
945 const cpp_token
*source
;
947 cpp_token
*result
= _cpp_temp_token (pfile
);
949 result
->type
= CPP_PADDING
;
950 result
->val
.source
= source
;
955 /* Get a new uninitialized context. Create a new one if we cannot
956 re-use an old one. */
961 cpp_context
*result
= pfile
->context
->next
;
965 result
= xnew (cpp_context
);
966 result
->prev
= pfile
->context
;
968 pfile
->context
->next
= result
;
971 pfile
->context
= result
;
975 /* Push a list of pointers to tokens. */
977 push_ptoken_context (pfile
, macro
, buff
, first
, count
)
981 const cpp_token
**first
;
984 cpp_context
*context
= next_context (pfile
);
986 context
->direct_p
= false;
987 context
->macro
= macro
;
988 context
->buff
= buff
;
989 FIRST (context
).ptoken
= first
;
990 LAST (context
).ptoken
= first
+ count
;
993 /* Push a list of tokens. */
995 push_token_context (pfile
, macro
, first
, count
)
998 const cpp_token
*first
;
1001 cpp_context
*context
= next_context (pfile
);
1003 context
->direct_p
= true;
1004 context
->macro
= macro
;
1005 context
->buff
= NULL
;
1006 FIRST (context
).token
= first
;
1007 LAST (context
).token
= first
+ count
;
1010 /* Push a traditional macro's replacement text. */
1012 _cpp_push_text_context (pfile
, macro
, start
, len
)
1014 cpp_hashnode
*macro
;
1018 cpp_context
*context
= next_context (pfile
);
1020 context
->direct_p
= true;
1021 context
->macro
= macro
;
1022 context
->buff
= NULL
;
1023 CUR (context
) = start
;
1024 RLIMIT (context
) = start
+ len
;
1025 macro
->flags
|= NODE_DISABLED
;
1028 /* Expand an argument ARG before replacing parameters in a
1029 function-like macro. This works by pushing a context with the
1030 argument's tokens, and then expanding that into a temporary buffer
1031 as if it were a normal part of the token stream. collect_args()
1032 has terminated the argument's tokens with a CPP_EOF so that we know
1033 when we have fully expanded the argument. */
1035 expand_arg (pfile
, arg
)
1039 unsigned int capacity
;
1040 bool saved_warn_trad
;
1042 if (arg
->count
== 0)
1045 /* Don't warn about funlike macros when pre-expanding. */
1046 saved_warn_trad
= CPP_WTRADITIONAL (pfile
);
1047 CPP_WTRADITIONAL (pfile
) = 0;
1049 /* Loop, reading in the arguments. */
1051 arg
->expanded
= (const cpp_token
**)
1052 xmalloc (capacity
* sizeof (cpp_token
*));
1054 push_ptoken_context (pfile
, NULL
, NULL
, arg
->first
, arg
->count
+ 1);
1057 const cpp_token
*token
;
1059 if (arg
->expanded_count
+ 1 >= capacity
)
1062 arg
->expanded
= (const cpp_token
**)
1063 xrealloc (arg
->expanded
, capacity
* sizeof (cpp_token
*));
1066 token
= cpp_get_token (pfile
);
1068 if (token
->type
== CPP_EOF
)
1071 arg
->expanded
[arg
->expanded_count
++] = token
;
1074 _cpp_pop_context (pfile
);
1076 CPP_WTRADITIONAL (pfile
) = saved_warn_trad
;
1079 /* Pop the current context off the stack, re-enabling the macro if the
1080 context represented a macro's replacement list. The context
1081 structure is not freed so that we can re-use it later. */
1083 _cpp_pop_context (pfile
)
1086 cpp_context
*context
= pfile
->context
;
1089 context
->macro
->flags
&= ~NODE_DISABLED
;
1092 _cpp_release_buff (pfile
, context
->buff
);
1094 pfile
->context
= context
->prev
;
1097 /* Eternal routine to get a token. Also used nearly everywhere
1098 internally, except for places where we know we can safely call
1099 the lexer directly, such as lexing a directive name.
1101 Macro expansions and directives are transparently handled,
1102 including entering included files. Thus tokens are post-macro
1103 expansion, and after any intervening directives. External callers
1104 see CPP_EOF only at EOF. Internal callers also see it when meeting
1105 a directive inside a macro call, when at the end of a directive and
1106 state.in_directive is still 1, and at the end of argument
1109 cpp_get_token (pfile
)
1112 const cpp_token
*result
;
1117 cpp_context
*context
= pfile
->context
;
1119 /* Context->prev == 0 <=> base context. */
1121 result
= _cpp_lex_token (pfile
);
1122 else if (FIRST (context
).token
!= LAST (context
).token
)
1124 if (context
->direct_p
)
1125 result
= FIRST (context
).token
++;
1127 result
= *FIRST (context
).ptoken
++;
1129 if (result
->flags
& PASTE_LEFT
)
1131 paste_all_tokens (pfile
, result
);
1132 if (pfile
->state
.in_directive
)
1134 return padding_token (pfile
, result
);
1139 _cpp_pop_context (pfile
);
1140 if (pfile
->state
.in_directive
)
1142 return &pfile
->avoid_paste
;
1145 if (pfile
->state
.in_directive
&& result
->type
== CPP_COMMENT
)
1148 if (result
->type
!= CPP_NAME
)
1151 node
= result
->val
.node
;
1153 if (node
->type
!= NT_MACRO
|| (result
->flags
& NO_EXPAND
))
1156 if (!(node
->flags
& NODE_DISABLED
))
1158 if (!pfile
->state
.prevent_expansion
1159 && enter_macro_context (pfile
, node
))
1161 if (pfile
->state
.in_directive
)
1163 return padding_token (pfile
, result
);
1168 /* Flag this token as always unexpandable. FIXME: move this
1169 to collect_args()?. */
1170 cpp_token
*t
= _cpp_temp_token (pfile
);
1171 t
->type
= result
->type
;
1172 t
->flags
= result
->flags
| NO_EXPAND
;
1173 t
->val
.str
= result
->val
.str
;
1183 /* Returns true if we're expanding an object-like macro that was
1184 defined in a system header. Just checks the macro at the top of
1185 the stack. Used for diagnostic suppression. */
1187 cpp_sys_macro_p (pfile
)
1190 cpp_hashnode
*node
= pfile
->context
->macro
;
1192 return node
&& node
->value
.macro
&& node
->value
.macro
->syshdr
;
1195 /* Read each token in, until end of the current file. Directives are
1196 transparently processed. */
1198 cpp_scan_nooutput (pfile
)
1201 /* Request a CPP_EOF token at the end of this file, rather than
1202 transparently continuing with the including file. */
1203 pfile
->buffer
->return_at_eof
= true;
1205 if (CPP_OPTION (pfile
, traditional
))
1206 while (_cpp_read_logical_line_trad (pfile
))
1209 while (cpp_get_token (pfile
)->type
!= CPP_EOF
)
1213 /* Step back one (or more) tokens. Can only step mack more than 1 if
1214 they are from the lexer, and not from macro expansion. */
1216 _cpp_backup_tokens (pfile
, count
)
1220 if (pfile
->context
->prev
== NULL
)
1222 pfile
->lookaheads
+= count
;
1226 if (pfile
->cur_token
== pfile
->cur_run
->base
1227 /* Possible with -fpreprocessed and no leading #line. */
1228 && pfile
->cur_run
->prev
!= NULL
)
1230 pfile
->cur_run
= pfile
->cur_run
->prev
;
1231 pfile
->cur_token
= pfile
->cur_run
->limit
;
1239 if (pfile
->context
->direct_p
)
1240 FIRST (pfile
->context
).token
--;
1242 FIRST (pfile
->context
).ptoken
--;
1246 /* #define directive parsing and handling. */
1248 /* Returns nonzero if a macro redefinition warning is required. */
1250 warn_of_redefinition (pfile
, node
, macro2
)
1252 const cpp_hashnode
*node
;
1253 const cpp_macro
*macro2
;
1255 const cpp_macro
*macro1
;
1258 /* Some redefinitions need to be warned about regardless. */
1259 if (node
->flags
& NODE_WARN
)
1262 /* Redefinition of a macro is allowed if and only if the old and new
1263 definitions are the same. (6.10.3 paragraph 2). */
1264 macro1
= node
->value
.macro
;
1266 /* Don't check count here as it can be different in valid
1267 traditional redefinitions with just whitespace differences. */
1268 if (macro1
->paramc
!= macro2
->paramc
1269 || macro1
->fun_like
!= macro2
->fun_like
1270 || macro1
->variadic
!= macro2
->variadic
)
1273 /* Check parameter spellings. */
1274 for (i
= 0; i
< macro1
->paramc
; i
++)
1275 if (macro1
->params
[i
] != macro2
->params
[i
])
1278 /* Check the replacement text or tokens. */
1279 if (CPP_OPTION (pfile
, traditional
))
1280 return _cpp_expansions_different_trad (macro1
, macro2
);
1282 if (macro1
->count
== macro2
->count
)
1283 for (i
= 0; i
< macro1
->count
; i
++)
1284 if (!_cpp_equiv_tokens (¯o1
->exp
.tokens
[i
], ¯o2
->exp
.tokens
[i
]))
1290 /* Free the definition of hashnode H. */
1292 _cpp_free_definition (h
)
1295 /* Macros and assertions no longer have anything to free. */
1297 /* Clear builtin flag in case of redefinition. */
1298 h
->flags
&= ~(NODE_BUILTIN
| NODE_DISABLED
);
1301 /* Save parameter NODE to the parameter list of macro MACRO. Returns
1302 zero on success, nonzero if the parameter is a duplicate. */
1304 _cpp_save_parameter (pfile
, macro
, node
)
1310 /* Constraint 6.10.3.6 - duplicate parameter names. */
1311 if (node
->flags
& NODE_MACRO_ARG
)
1313 cpp_error (pfile
, DL_ERROR
, "duplicate macro parameter \"%s\"",
1318 if (BUFF_ROOM (pfile
->a_buff
)
1319 < (macro
->paramc
+ 1) * sizeof (cpp_hashnode
*))
1320 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_hashnode
*));
1322 ((cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
))[macro
->paramc
++] = node
;
1323 node
->flags
|= NODE_MACRO_ARG
;
1324 len
= macro
->paramc
* sizeof (union _cpp_hashnode_value
);
1325 if (len
> pfile
->macro_buffer_len
)
1327 pfile
->macro_buffer
= (uchar
*) xrealloc (pfile
->macro_buffer
, len
);
1328 pfile
->macro_buffer_len
= len
;
1330 ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[macro
->paramc
- 1]
1333 node
->value
.arg_index
= macro
->paramc
;
1337 /* Check the syntax of the parameters in a MACRO definition. Returns
1338 false if an error occurs. */
1340 parse_params (pfile
, macro
)
1344 unsigned int prev_ident
= 0;
1348 const cpp_token
*token
= _cpp_lex_token (pfile
);
1350 switch (token
->type
)
1353 /* Allow/ignore comments in parameter lists if we are
1354 preserving comments in macro expansions. */
1355 if (token
->type
== CPP_COMMENT
1356 && ! CPP_OPTION (pfile
, discard_comments_in_macro_exp
))
1359 cpp_error (pfile
, DL_ERROR
,
1360 "\"%s\" may not appear in macro parameter list",
1361 cpp_token_as_text (pfile
, token
));
1367 cpp_error (pfile
, DL_ERROR
,
1368 "macro parameters must be comma-separated");
1373 if (_cpp_save_parameter (pfile
, macro
, token
->val
.node
))
1377 case CPP_CLOSE_PAREN
:
1378 if (prev_ident
|| macro
->paramc
== 0)
1381 /* Fall through to pick up the error. */
1385 cpp_error (pfile
, DL_ERROR
, "parameter name missing");
1392 macro
->variadic
= 1;
1395 _cpp_save_parameter (pfile
, macro
,
1396 pfile
->spec_nodes
.n__VA_ARGS__
);
1397 pfile
->state
.va_args_ok
= 1;
1398 if (! CPP_OPTION (pfile
, c99
) && CPP_OPTION (pfile
, pedantic
))
1399 cpp_error (pfile
, DL_PEDWARN
,
1400 "anonymous variadic macros were introduced in C99");
1402 else if (CPP_OPTION (pfile
, pedantic
))
1403 cpp_error (pfile
, DL_PEDWARN
,
1404 "ISO C does not permit named variadic macros");
1406 /* We're at the end, and just expect a closing parenthesis. */
1407 token
= _cpp_lex_token (pfile
);
1408 if (token
->type
== CPP_CLOSE_PAREN
)
1413 cpp_error (pfile
, DL_ERROR
, "missing ')' in macro parameter list");
1419 /* Allocate room for a token from a macro's replacement list. */
1421 alloc_expansion_token (pfile
, macro
)
1425 if (BUFF_ROOM (pfile
->a_buff
) < (macro
->count
+ 1) * sizeof (cpp_token
))
1426 _cpp_extend_buff (pfile
, &pfile
->a_buff
, sizeof (cpp_token
));
1428 return &((cpp_token
*) BUFF_FRONT (pfile
->a_buff
))[macro
->count
++];
1431 /* Lex a token from the expansion of MACRO, but mark parameters as we
1432 find them and warn of traditional stringification. */
1434 lex_expansion_token (pfile
, macro
)
1440 pfile
->cur_token
= alloc_expansion_token (pfile
, macro
);
1441 token
= _cpp_lex_direct (pfile
);
1443 /* Is this a parameter? */
1444 if (token
->type
== CPP_NAME
1445 && (token
->val
.node
->flags
& NODE_MACRO_ARG
) != 0)
1447 token
->type
= CPP_MACRO_ARG
;
1448 token
->val
.arg_no
= token
->val
.node
->value
.arg_index
;
1450 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1451 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1452 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1458 create_iso_definition (pfile
, macro
)
1463 const cpp_token
*ctoken
;
1465 /* Get the first token of the expansion (or the '(' of a
1466 function-like macro). */
1467 ctoken
= _cpp_lex_token (pfile
);
1469 if (ctoken
->type
== CPP_OPEN_PAREN
&& !(ctoken
->flags
& PREV_WHITE
))
1471 bool ok
= parse_params (pfile
, macro
);
1472 macro
->params
= (cpp_hashnode
**) BUFF_FRONT (pfile
->a_buff
);
1476 /* Success. Commit the parameter array. */
1477 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->params
[macro
->paramc
];
1478 macro
->fun_like
= 1;
1480 else if (ctoken
->type
!= CPP_EOF
&& !(ctoken
->flags
& PREV_WHITE
))
1481 cpp_error (pfile
, DL_PEDWARN
,
1482 "ISO C requires whitespace after the macro name");
1484 if (macro
->fun_like
)
1485 token
= lex_expansion_token (pfile
, macro
);
1488 token
= alloc_expansion_token (pfile
, macro
);
1494 /* Check the stringifying # constraint 6.10.3.2.1 of
1495 function-like macros when lexing the subsequent token. */
1496 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1498 if (token
->type
== CPP_MACRO_ARG
)
1500 token
->flags
&= ~PREV_WHITE
;
1501 token
->flags
|= STRINGIFY_ARG
;
1502 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1503 token
[-1] = token
[0];
1506 /* Let assembler get away with murder. */
1507 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1509 cpp_error (pfile
, DL_ERROR
,
1510 "'#' is not followed by a macro parameter");
1515 if (token
->type
== CPP_EOF
)
1518 /* Paste operator constraint 6.10.3.3.1. */
1519 if (token
->type
== CPP_PASTE
)
1521 /* Token-paste ##, can appear in both object-like and
1522 function-like macros, but not at the ends. */
1523 if (--macro
->count
> 0)
1524 token
= lex_expansion_token (pfile
, macro
);
1526 if (macro
->count
== 0 || token
->type
== CPP_EOF
)
1528 cpp_error (pfile
, DL_ERROR
,
1529 "'##' cannot appear at either end of a macro expansion");
1533 token
[-1].flags
|= PASTE_LEFT
;
1536 token
= lex_expansion_token (pfile
, macro
);
1539 macro
->exp
.tokens
= (cpp_token
*) BUFF_FRONT (pfile
->a_buff
);
1541 /* Don't count the CPP_EOF. */
1544 /* Clear whitespace on first token for warn_of_redefinition(). */
1546 macro
->exp
.tokens
[0].flags
&= ~PREV_WHITE
;
1548 /* Commit the memory. */
1549 BUFF_FRONT (pfile
->a_buff
) = (uchar
*) ¯o
->exp
.tokens
[macro
->count
];
1554 /* Parse a macro and save its expansion. Returns nonzero on success. */
1556 _cpp_create_definition (pfile
, node
)
1564 macro
= (cpp_macro
*) _cpp_aligned_alloc (pfile
, sizeof (cpp_macro
));
1565 macro
->line
= pfile
->directive_line
;
1568 macro
->variadic
= 0;
1569 macro
->used
= !CPP_OPTION (pfile
, warn_unused_macros
);
1571 macro
->fun_like
= 0;
1572 /* To suppress some diagnostics. */
1573 macro
->syshdr
= pfile
->map
->sysp
!= 0;
1575 if (CPP_OPTION (pfile
, traditional
))
1576 ok
= _cpp_create_trad_definition (pfile
, macro
);
1579 cpp_token
*saved_cur_token
= pfile
->cur_token
;
1581 ok
= create_iso_definition (pfile
, macro
);
1583 /* Restore lexer position because of games lex_expansion_token()
1584 plays lexing the macro. We set the type for SEEN_EOL() in
1587 Longer term we should lex the whole line before coming here,
1588 and just copy the expansion. */
1589 saved_cur_token
[-1].type
= pfile
->cur_token
[-1].type
;
1590 pfile
->cur_token
= saved_cur_token
;
1592 /* Stop the lexer accepting __VA_ARGS__. */
1593 pfile
->state
.va_args_ok
= 0;
1596 /* Clear the fast argument lookup indices. */
1597 for (i
= macro
->paramc
; i
-- > 0; )
1599 struct cpp_hashnode
*node
= macro
->params
[i
];
1600 node
->flags
&= ~ NODE_MACRO_ARG
;
1601 node
->value
= ((union _cpp_hashnode_value
*) pfile
->macro_buffer
)[i
];
1607 if (node
->type
== NT_MACRO
)
1609 if (CPP_OPTION (pfile
, warn_unused_macros
))
1610 _cpp_warn_if_unused_macro (pfile
, node
, NULL
);
1612 if (warn_of_redefinition (pfile
, node
, macro
))
1614 cpp_error_with_line (pfile
, DL_PEDWARN
, pfile
->directive_line
, 0,
1615 "\"%s\" redefined", NODE_NAME (node
));
1617 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
1618 cpp_error_with_line (pfile
, DL_PEDWARN
,
1619 node
->value
.macro
->line
, 0,
1620 "this is the location of the previous definition");
1624 if (node
->type
!= NT_VOID
)
1625 _cpp_free_definition (node
);
1627 /* Enter definition in hash table. */
1628 node
->type
= NT_MACRO
;
1629 node
->value
.macro
= macro
;
1630 if (! ustrncmp (NODE_NAME (node
), DSC ("__STDC_")))
1631 node
->flags
|= NODE_WARN
;
1636 /* Warn if a token in STRING matches one of a function-like MACRO's
1639 check_trad_stringification (pfile
, macro
, string
)
1641 const cpp_macro
*macro
;
1642 const cpp_string
*string
;
1644 unsigned int i
, len
;
1645 const uchar
*p
, *q
, *limit
= string
->text
+ string
->len
;
1647 /* Loop over the string. */
1648 for (p
= string
->text
; p
< limit
; p
= q
)
1650 /* Find the start of an identifier. */
1651 while (p
< limit
&& !is_idstart (*p
))
1654 /* Find the end of the identifier. */
1656 while (q
< limit
&& is_idchar (*q
))
1661 /* Loop over the function macro arguments to see if the
1662 identifier inside the string matches one of them. */
1663 for (i
= 0; i
< macro
->paramc
; i
++)
1665 const cpp_hashnode
*node
= macro
->params
[i
];
1667 if (NODE_LEN (node
) == len
1668 && !memcmp (p
, NODE_NAME (node
), len
))
1670 cpp_error (pfile
, DL_WARNING
,
1671 "macro argument \"%s\" would be stringified in traditional C",
1679 /* Returns the name, arguments and expansion of a macro, in a format
1680 suitable to be read back in again, and therefore also for DWARF 2
1681 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1682 Caller is expected to generate the "#define" bit if needed. The
1683 returned text is temporary, and automatically freed later. */
1684 const unsigned char *
1685 cpp_macro_definition (pfile
, node
)
1687 const cpp_hashnode
*node
;
1689 unsigned int i
, len
;
1690 const cpp_macro
*macro
= node
->value
.macro
;
1691 unsigned char *buffer
;
1693 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1695 cpp_error (pfile
, DL_ICE
,
1696 "invalid hash type %d in cpp_macro_definition", node
->type
);
1700 /* Calculate length. */
1701 len
= NODE_LEN (node
) + 2; /* ' ' and NUL. */
1702 if (macro
->fun_like
)
1704 len
+= 4; /* "()" plus possible final ".." of named
1705 varargs (we have + 1 below). */
1706 for (i
= 0; i
< macro
->paramc
; i
++)
1707 len
+= NODE_LEN (macro
->params
[i
]) + 1; /* "," */
1710 if (CPP_OPTION (pfile
, traditional
))
1711 len
+= _cpp_replacement_text_len (macro
);
1714 for (i
= 0; i
< macro
->count
; i
++)
1716 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1718 if (token
->type
== CPP_MACRO_ARG
)
1719 len
+= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1721 len
+= cpp_token_len (token
); /* Includes room for ' '. */
1722 if (token
->flags
& STRINGIFY_ARG
)
1724 if (token
->flags
& PASTE_LEFT
)
1725 len
+= 3; /* " ##" */
1729 if (len
> pfile
->macro_buffer_len
)
1731 pfile
->macro_buffer
= (uchar
*) xrealloc (pfile
->macro_buffer
, len
);
1732 pfile
->macro_buffer_len
= len
;
1735 /* Fill in the buffer. Start with the macro name. */
1736 buffer
= pfile
->macro_buffer
;
1737 memcpy (buffer
, NODE_NAME (node
), NODE_LEN (node
));
1738 buffer
+= NODE_LEN (node
);
1740 /* Parameter names. */
1741 if (macro
->fun_like
)
1744 for (i
= 0; i
< macro
->paramc
; i
++)
1746 cpp_hashnode
*param
= macro
->params
[i
];
1748 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1750 memcpy (buffer
, NODE_NAME (param
), NODE_LEN (param
));
1751 buffer
+= NODE_LEN (param
);
1754 if (i
+ 1 < macro
->paramc
)
1755 /* Don't emit a space after the comma here; we're trying
1756 to emit a Dwarf-friendly definition, and the Dwarf spec
1757 forbids spaces in the argument list. */
1759 else if (macro
->variadic
)
1760 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1765 /* The Dwarf spec requires a space after the macro name, even if the
1766 definition is the empty string. */
1769 if (CPP_OPTION (pfile
, traditional
))
1770 buffer
= _cpp_copy_replacement_text (macro
, buffer
);
1771 else if (macro
->count
)
1772 /* Expansion tokens. */
1774 for (i
= 0; i
< macro
->count
; i
++)
1776 cpp_token
*token
= ¯o
->exp
.tokens
[i
];
1778 if (token
->flags
& PREV_WHITE
)
1780 if (token
->flags
& STRINGIFY_ARG
)
1783 if (token
->type
== CPP_MACRO_ARG
)
1785 len
= NODE_LEN (macro
->params
[token
->val
.arg_no
- 1]);
1787 NODE_NAME (macro
->params
[token
->val
.arg_no
- 1]), len
);
1791 buffer
= cpp_spell_token (pfile
, token
, buffer
);
1793 if (token
->flags
& PASTE_LEFT
)
1798 /* Next has PREV_WHITE; see _cpp_create_definition. */
1804 return pfile
->macro_buffer
;