1 /* Part of CPP library. (Macro and #define handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000 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 "intl.h" /* for _("<command line>") below. */
32 #ifndef STDC_0_IN_SYSTEM_HEADERS
33 #define STDC_0_IN_SYSTEM_HEADERS 0 /* Boolean macro. */
38 cpp_hashnode
**params
; /* Parameters, if any. */
39 cpp_token
*expansion
; /* First token of replacement list. */
40 const char *file
; /* Defined in file name. */
41 unsigned int line
; /* Starting line number. */
42 unsigned int count
; /* Number of tokens in expansion. */
43 unsigned short paramc
; /* Number of parameters. */
44 unsigned int fun_like
: 1; /* If a function-like macro. */
45 unsigned int variadic
: 1; /* If a variadic macro. */
46 unsigned int disabled
: 1; /* If macro is disabled. */
49 typedef struct macro_arg macro_arg
;
52 cpp_token
*first
; /* First token in unexpanded argument. */
53 cpp_token
*expanded
; /* Macro-expanded argument. */
54 cpp_token
*stringified
; /* Stringified argument. */
55 unsigned int count
; /* # of tokens in argument. */
56 unsigned int expanded_count
; /* # of tokens in expanded argument. */
59 /* Macro expansion. */
61 static void lock_pools
PARAMS ((cpp_reader
*));
62 static void unlock_pools
PARAMS ((cpp_reader
*));
63 static int enter_macro_context
PARAMS ((cpp_reader
*, cpp_hashnode
*));
64 static void builtin_macro
PARAMS ((cpp_reader
*, cpp_token
*));
65 static cpp_context
*push_arg_context
PARAMS ((cpp_reader
*, macro_arg
*));
66 static enum cpp_ttype parse_arg
PARAMS ((cpp_reader
*, macro_arg
*, int));
67 static macro_arg
*parse_args
PARAMS ((cpp_reader
*, const cpp_hashnode
*));
68 static cpp_context
*next_context
PARAMS ((cpp_reader
*));
69 static void expand_arg
PARAMS ((cpp_reader
*, macro_arg
*));
70 static unsigned char *quote_string
PARAMS ((unsigned char *,
71 const unsigned char *,
73 static void make_string_token
PARAMS ((cpp_pool
*, cpp_token
*,
74 const U_CHAR
*, unsigned int));
75 static void make_number_token
PARAMS ((cpp_reader
*, cpp_token
*, int));
76 static void stringify_arg
PARAMS ((cpp_reader
*, macro_arg
*));
77 static void paste_all_tokens
PARAMS ((cpp_reader
*, cpp_token
*));
78 static int paste_tokens
PARAMS ((cpp_reader
*, cpp_token
*, cpp_token
*));
79 static int funlike_invocation_p
PARAMS ((cpp_reader
*, const cpp_hashnode
*,
81 static void replace_args
PARAMS ((cpp_reader
*, cpp_macro
*, macro_arg
*,
86 static void save_lookahead_token
PARAMS ((cpp_reader
*, const cpp_token
*));
87 static void take_lookahead_token
PARAMS ((cpp_reader
*, cpp_token
*));
88 static cpp_lookahead
*alloc_lookahead
PARAMS ((cpp_reader
*));
89 static void free_lookahead
PARAMS ((cpp_lookahead
*));
91 /* #define directive parsing and handling. */
93 static cpp_token
*lex_expansion_token
PARAMS ((cpp_reader
*, cpp_macro
*));
94 static int check_macro_redefinition
PARAMS ((cpp_reader
*,
97 static int save_parameter
PARAMS ((cpp_reader
*, cpp_macro
*, cpp_hashnode
*));
98 static int parse_params
PARAMS ((cpp_reader
*, cpp_macro
*));
99 static void check_trad_stringification
PARAMS ((cpp_reader
*,
101 const cpp_string
*));
103 /* Allocates a buffer to hold a token's TEXT, and converts TOKEN to a
104 CPP_STRING token containing TEXT in quoted form. */
106 make_string_token (pool
, token
, text
, len
)
112 U_CHAR
*buf
= _cpp_pool_alloc (pool
, len
* 4);
114 token
->type
= CPP_STRING
;
115 token
->val
.str
.text
= buf
;
116 token
->val
.str
.len
= quote_string (buf
, text
, len
) - buf
;
120 /* Allocates and converts a temporary token to a CPP_NUMBER token,
121 evaluating to NUMBER. */
123 make_number_token (pfile
, token
, number
)
128 unsigned char *buf
= _cpp_pool_alloc (pfile
->string_pool
, 20);
130 sprintf ((char *) buf
, "%d", number
);
131 token
->type
= CPP_NUMBER
;
132 token
->val
.str
.text
= buf
;
133 token
->val
.str
.len
= ustrlen (buf
);
137 static const char * const monthnames
[] =
139 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
140 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
143 /* Handle builtin macros like __FILE__. */
145 builtin_macro (pfile
, token
)
149 unsigned char flags
= token
->flags
& PREV_WHITE
;
150 cpp_hashnode
*node
= token
->val
.node
;
153 switch (node
->value
.builtin
)
160 ip
= CPP_BUFFER (pfile
);
165 if (node
->value
.builtin
== BT_BASE_FILE
)
166 while (CPP_PREV_BUFFER (ip
) != NULL
)
167 ip
= CPP_PREV_BUFFER (ip
);
169 file
= ip
->nominal_fname
;
171 make_string_token (pfile
->string_pool
, token
,
172 (const U_CHAR
*) file
, strlen (file
));
176 case BT_INCLUDE_LEVEL
:
177 /* pfile->include_depth counts the primary source as level 1,
178 but historically __INCLUDE_DEPTH__ has called the primary
180 make_number_token (pfile
, token
, pfile
->include_depth
- 1);
184 /* If __LINE__ is embedded in a macro, it must expand to the
185 line of the macro's invocation, not its definition.
186 Otherwise things like assert() will not work properly. */
187 make_number_token (pfile
, token
, cpp_get_line (pfile
)->line
);
194 if (STDC_0_IN_SYSTEM_HEADERS
&& CPP_IN_SYSTEM_HEADER (pfile
)
195 && pfile
->spec_nodes
.n__STRICT_ANSI__
->type
== NT_VOID
)
197 make_number_token (pfile
, token
, stdc
);
203 if (pfile
->date
.type
== CPP_EOF
)
205 /* Allocate __DATE__ and __TIME__ from permanent storage,
206 and save them in pfile so we don't have to do this again.
207 We don't generate these strings at init time because
208 time() and localtime() are very slow on some systems. */
209 time_t tt
= time (NULL
);
210 struct tm
*tb
= localtime (&tt
);
212 make_string_token (&pfile
->ident_pool
, &pfile
->date
,
214 make_string_token (&pfile
->ident_pool
, &pfile
->time
,
217 sprintf ((char *) pfile
->date
.val
.str
.text
, "%s %2d %4d",
218 monthnames
[tb
->tm_mon
], tb
->tm_mday
, tb
->tm_year
+ 1900);
219 sprintf ((char *) pfile
->time
.val
.str
.text
, "%02d:%02d:%02d",
220 tb
->tm_hour
, tb
->tm_min
, tb
->tm_sec
);
222 *token
= node
->value
.builtin
== BT_DATE
? pfile
->date
: pfile
->time
;
226 cpp_ice (pfile
, "invalid builtin macro \"%s\"", node
->name
);
230 token
->flags
= flags
;
233 /* Used by cpperror.c to obtain the correct line and column to report
235 const cpp_lexer_pos
*
239 return &pfile
->lexer_pos
;
246 _cpp_lock_pool (&pfile
->temp_string_pool
);
247 _cpp_lock_pool (&pfile
->argument_pool
);
254 _cpp_unlock_pool (&pfile
->temp_string_pool
);
255 _cpp_unlock_pool (&pfile
->argument_pool
);
258 /* Adds backslashes before all backslashes and double quotes appearing
259 in strings. Non-printable characters are converted to octal. */
261 quote_string (dest
, src
, len
)
270 if (c
== '\\' || c
== '"')
281 sprintf ((char *) dest
, "\\%03o", c
);
290 /* Convert a token sequence to a single string token according to the
291 rules of the ISO C #-operator. */
293 stringify_arg (pfile
, arg
)
297 cpp_pool
*pool
= pfile
->string_pool
;
298 unsigned char *start
= POOL_FRONT (pool
);
299 unsigned int i
, escape_it
, total_len
= 0, backslash_count
= 0;
301 /* Loop, reading in the argument's tokens. */
302 for (i
= 0; i
< arg
->count
; i
++)
305 const cpp_token
*token
= &arg
->first
[i
];
306 unsigned int len
= cpp_token_len (token
);
308 escape_it
= (token
->type
== CPP_STRING
|| token
->type
== CPP_WSTRING
309 || token
->type
== CPP_CHAR
|| token
->type
== CPP_WCHAR
310 || token
->type
== CPP_OSTRING
);
313 /* Worst case is each char is octal. */
315 len
++; /* Room for initial space. */
317 dest
= &start
[total_len
];
318 if (dest
+ len
> POOL_LIMIT (pool
))
320 _cpp_next_chunk (pool
, len
, (unsigned char **) &start
);
321 dest
= &start
[total_len
];
324 /* No leading white space. */
325 if (token
->flags
& PREV_WHITE
&& total_len
> 0)
330 unsigned char *buf
= (unsigned char *) xmalloc (len
);
332 len
= cpp_spell_token (pfile
, token
, buf
) - buf
;
333 dest
= quote_string (dest
, buf
, len
);
337 dest
= cpp_spell_token (pfile
, token
, dest
);
338 total_len
= dest
- start
;
340 if (token
->type
== CPP_OTHER
&& token
->val
.c
== '\\')
346 /* Ignore the final \ of invalid string literals. */
347 if (backslash_count
& 1)
349 cpp_warning (pfile
, "invalid string literal, ignoring final '\\'");
353 POOL_COMMIT (pool
, total_len
);
355 arg
->stringified
= xnew (cpp_token
);
356 arg
->stringified
->flags
= 0;
357 arg
->stringified
->type
= CPP_STRING
;
358 arg
->stringified
->val
.str
.text
= start
;
359 arg
->stringified
->val
.str
.len
= total_len
;
362 /* Try to paste two tokens. On success, the LHS becomes the pasted
363 token, and 0 is returned. For failure, we update the flags of the
364 RHS appropriately and return non-zero. */
366 paste_tokens (pfile
, lhs
, rhs
)
368 cpp_token
*lhs
, *rhs
;
374 type
= cpp_can_paste (pfile
, lhs
, rhs
, &digraph
);
378 /* Mandatory warning for all apart from assembler. */
379 if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
381 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
382 cpp_token_as_text (pfile
, lhs
),
383 cpp_token_as_text (pfile
, rhs
));
385 /* The standard states that behaviour is undefined. By the
386 principle of least surpise, we step back before the RHS, and
387 mark it to prevent macro expansion. Tests in the testsuite
388 rely on clearing PREV_WHITE here, though you could argue we
389 should actually set it. Assembler can have '.' in labels and
390 so requires that we don't insert spaces there. Maybe we should
391 change this to put out a space unless it's assembler. */
392 rhs
->flags
&= ~PREV_WHITE
;
393 rhs
->flags
|= NO_EXPAND
;
397 flags
= lhs
->flags
& ~DIGRAPH
;
401 /* Identifiers and numbers need spellings to be pasted. */
402 if (type
== CPP_NAME
|| type
== CPP_NUMBER
)
404 unsigned int total_len
= cpp_token_len (lhs
) + cpp_token_len (rhs
);
405 unsigned char *result
, *end
;
408 pool
= type
== CPP_NAME
? &pfile
->ident_pool
: pfile
->string_pool
;
409 result
= _cpp_pool_alloc (pool
, total_len
+ 1);
411 /* Paste the spellings and null terminate. */
412 end
= cpp_spell_token (pfile
, rhs
, cpp_spell_token (pfile
, lhs
, result
));
414 total_len
= end
- result
;
416 if (type
== CPP_NAME
)
418 lhs
->val
.node
= cpp_lookup (pfile
, result
, total_len
);
419 if (lhs
->val
.node
->flags
& NODE_OPERATOR
)
422 lhs
->type
= lhs
->val
.node
->value
.operator;
427 lhs
->val
.str
.text
= result
;
428 lhs
->val
.str
.len
= total_len
;
431 else if (type
== CPP_WCHAR
|| type
== CPP_WSTRING
)
432 lhs
->val
.str
= rhs
->val
.str
;
434 /* Set type and flags after pasting spellings. */
441 /* Handles an arbitrarily long sequence of ## operators. This
442 implementation is left-associative, non-recursive, and finishes a
443 paste before handling succeeding ones. If the paste fails, we back
444 up a token to just after the ## operator, with the effect that it
445 appears in the output stream normally. */
447 paste_all_tokens (pfile
, lhs
)
452 unsigned char orig_flags
= lhs
->flags
;
456 /* Take the token directly from the current context. We can do
457 this, because we are in the replacement list of either an
458 object-like macro, or a function-like macro with arguments
459 inserted. In either case, the constraints to #define
460 guarantee we have at least one more token. */
461 rhs
= pfile
->context
->list
.first
++;
462 if (paste_tokens (pfile
, lhs
, rhs
))
464 /* We failed. Step back so we read the RHS in next. */
465 pfile
->context
->list
.first
--;
469 while (rhs
->flags
& PASTE_LEFT
);
471 /* The pasted token has the PREV_WHITE flag of the LHS, is no longer
472 PASTE_LEFT, and is subject to macro expansion. */
473 lhs
->flags
&= ~(PREV_WHITE
| PASTE_LEFT
| NO_EXPAND
);
474 lhs
->flags
|= orig_flags
& PREV_WHITE
;
477 /* Reads the unexpanded tokens of a macro argument into ARG. VAR_ARGS
478 is non-zero if this is a variadic macro. Returns the type of the
479 token that caused reading to finish. */
480 static enum cpp_ttype
481 parse_arg (pfile
, arg
, variadic
)
483 struct macro_arg
*arg
;
486 enum cpp_ttype result
;
487 unsigned int paren
= 0;
490 arg
->first
= (cpp_token
*) POOL_FRONT (&pfile
->argument_pool
);
491 for (;; arg
->count
++)
493 cpp_token
*token
= &arg
->first
[arg
->count
];
494 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->argument_pool
))
496 _cpp_next_chunk (&pfile
->argument_pool
, sizeof (cpp_token
),
497 (unsigned char **) &arg
->first
);
498 token
= &arg
->first
[arg
->count
];
501 /* Newlines in arguments are white space (6.10.3.10). */
502 line
= pfile
->lexer_pos
.output_line
;
503 cpp_get_token (pfile
, token
);
504 if (line
!= pfile
->lexer_pos
.output_line
)
505 token
->flags
|= PREV_WHITE
;
507 result
= token
->type
;
508 if (result
== CPP_OPEN_PAREN
)
510 else if (result
== CPP_CLOSE_PAREN
&& paren
-- == 0)
512 /* Commas are not terminators within parantheses or variadic. */
513 else if (result
== CPP_COMMA
&& paren
== 0 && !variadic
)
515 else if (result
== CPP_EOF
)
516 break; /* Error reported by caller. */
519 /* Commit the memory used to store the arguments. */
520 POOL_COMMIT (&pfile
->argument_pool
, arg
->count
* sizeof (cpp_token
));
525 /* Parse the arguments making up a macro invocation. */
527 parse_args (pfile
, node
)
529 const cpp_hashnode
*node
;
531 cpp_macro
*macro
= node
->value
.macro
;
532 macro_arg
*args
, *cur
;
536 /* Allocate room for at least one argument, and zero it out. */
537 argc
= macro
->paramc
? macro
->paramc
: 1;
538 args
= xcnewvec (macro_arg
, argc
);
540 for (cur
= args
, argc
= 0; ;)
544 type
= parse_arg (pfile
, cur
, argc
== macro
->paramc
&& macro
->variadic
);
545 if (type
== CPP_CLOSE_PAREN
|| type
== CPP_EOF
)
548 /* Re-use the last argument for excess arguments. */
549 if (argc
< macro
->paramc
)
555 cpp_error (pfile
, "unterminated argument list invoking macro \"%s\"",
559 else if (argc
< macro
->paramc
)
561 /* As an extension, a rest argument is allowed to not appear in
562 the invocation at all.
563 e.g. #define debug(format, args...) something
566 This is exactly the same as if there had been an empty rest
567 argument - debug("string", ). */
569 if (argc
+ 1 == macro
->paramc
&& macro
->variadic
)
571 if (CPP_PEDANTIC (pfile
))
572 cpp_pedwarn (pfile
, "ISO C99 requires rest arguments to be used");
577 "macro \"%s\" requires %u arguments, but only %u given",
578 node
->name
, macro
->paramc
, argc
);
582 else if (argc
> macro
->paramc
)
584 /* Empty argument to a macro taking no arguments is OK. */
585 if (argc
!= 1 || cur
->count
)
588 "macro \"%s\" passed %u arguments, but takes just %u",
589 node
->name
, argc
, macro
->paramc
);
604 funlike_invocation_p (pfile
, node
, list
)
606 const cpp_hashnode
*node
;
607 struct toklist
*list
;
609 cpp_context
*orig
, *final
;
610 cpp_token maybe_paren
;
612 cpp_lexer_pos macro_pos
;
614 macro_pos
= pfile
->lexer_pos
;
615 pfile
->state
.parsing_args
= 1;
616 pfile
->state
.prevent_expansion
++;
617 orig
= pfile
->context
;
619 cpp_start_lookahead (pfile
);
620 cpp_get_token (pfile
, &maybe_paren
);
621 cpp_stop_lookahead (pfile
, maybe_paren
.type
== CPP_OPEN_PAREN
);
623 if (maybe_paren
.type
== CPP_OPEN_PAREN
)
624 args
= parse_args (pfile
, node
);
625 else if (CPP_WTRADITIONAL (pfile
))
627 "function-like macro \"%s\" must be used with arguments in traditional C",
630 /* Restore original context. */
631 final
= pfile
->context
;
632 pfile
->context
= orig
;
633 pfile
->state
.prevent_expansion
--;
634 pfile
->state
.parsing_args
= 0;
638 /* The macro's expansion appears where the name would have. */
639 pfile
->lexer_pos
= macro_pos
;
641 if (node
->value
.macro
->paramc
> 0)
643 /* Don't save tokens during pre-expansion. */
644 struct cpp_lookahead
*la_saved
= pfile
->la_write
;
646 replace_args (pfile
, node
->value
.macro
, args
, list
);
647 pfile
->la_write
= la_saved
;
652 /* Re-disable macros *after* pre-expansion. */
653 while (final
!= orig
)
656 final
->macro
->disabled
= 1;
662 /* Push the context of a macro onto the context stack. TOKEN is the
663 macro name. If we can successfully start expanding the macro,
664 TOKEN is replaced with the first token of the expansion, and we
667 enter_macro_context (pfile
, node
)
671 cpp_context
*context
;
672 cpp_macro
*macro
= node
->value
.macro
;
675 /* Save the position of the outermost macro invocation. */
676 if (!pfile
->context
->prev
)
679 if (macro
->fun_like
&& !funlike_invocation_p (pfile
, node
, &list
))
681 if (!pfile
->context
->prev
)
682 unlock_pools (pfile
);
686 if (macro
->paramc
== 0)
688 list
.first
= macro
->expansion
;
689 list
.limit
= macro
->expansion
+ macro
->count
;
692 if (list
.first
!= list
.limit
)
694 /* Push its context. */
695 context
= next_context (pfile
);
696 context
->list
= list
;
697 context
->macro
= macro
;
699 /* Disable the macro within its expansion. */
706 /* Move to the next context. Create one if there is none. */
711 cpp_context
*prev
= pfile
->context
;
712 cpp_context
*result
= prev
->next
;
716 result
= xnew (cpp_context
);
722 pfile
->context
= result
;
727 replace_args (pfile
, macro
, args
, list
)
731 struct toklist
*list
;
733 unsigned int i
, total
;
734 const cpp_token
*src
, *limit
;
738 src
= macro
->expansion
;
739 limit
= src
+ macro
->count
;
741 /* First, fully macro-expand arguments, calculating the number of
742 tokens in the final expansion as we go. This ensures that the
743 possible recursive use of argument_pool is fine. */
745 for (; src
< limit
; src
++)
746 if (src
->type
== CPP_MACRO_ARG
)
748 /* We have an argument. If it is not being stringified or
749 pasted it is macro-replaced before insertion. */
750 arg
= &args
[src
->val
.arg_no
- 1];
752 if (src
->flags
& STRINGIFY_ARG
)
754 if (!arg
->stringified
)
755 stringify_arg (pfile
, arg
);
757 else if ((src
->flags
& PASTE_LEFT
)
758 || (src
> macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
)))
759 total
+= arg
->count
- 1;
764 arg
->expanded_count
= 0;
766 expand_arg (pfile
, arg
);
768 total
+= arg
->expanded_count
- 1;
772 dest
= (cpp_token
*) _cpp_pool_alloc (&pfile
->argument_pool
,
773 total
* sizeof (cpp_token
));
776 for (src
= macro
->expansion
; src
< limit
; src
++)
777 if (src
->type
== CPP_MACRO_ARG
)
780 const cpp_token
*from
;
782 arg
= &args
[src
->val
.arg_no
- 1];
783 if (src
->flags
& STRINGIFY_ARG
)
784 from
= arg
->stringified
, count
= 1;
785 else if (src
->flags
& PASTE_LEFT
)
786 count
= arg
->count
, from
= arg
->first
;
787 else if (src
> macro
->expansion
&& (src
[-1].flags
& PASTE_LEFT
))
789 count
= arg
->count
, from
= arg
->first
;
790 if (dest
!= list
->first
)
792 /* GCC has special semantics for , ## b where b is a
793 varargs parameter: the comma disappears if b was
794 given no actual arguments (not merely if b is an
795 empty argument); otherwise pasting is turned off. */
796 if (dest
[-1].type
== CPP_COMMA
798 && src
->val
.arg_no
== macro
->paramc
)
803 dest
[-1].flags
&= ~PASTE_LEFT
;
805 /* Count == 0 is the RHS a placemarker case. */
807 dest
[-1].flags
&= ~PASTE_LEFT
;
811 count
= arg
->expanded_count
, from
= arg
->expanded
;
813 /* Count == 0 is the LHS a placemarker case. */
816 memcpy (dest
, from
, count
* sizeof (cpp_token
));
818 /* The first token gets PREV_WHITE of the CPP_MACRO_ARG. */
819 dest
->flags
&= ~PREV_WHITE
;
820 dest
->flags
|= src
->flags
& PREV_WHITE
;
822 /* The last token gets the PASTE_LEFT of the CPP_MACRO_ARG. */
823 dest
[count
- 1].flags
|= src
->flags
& PASTE_LEFT
;
833 /* Free the expanded arguments. */
834 for (i
= 0; i
< macro
->paramc
; i
++)
836 if (args
[i
].expanded
)
837 free (args
[i
].expanded
);
838 if (args
[i
].stringified
)
839 free (args
[i
].stringified
);
843 /* Subroutine of expand_arg to put the unexpanded tokens on the
846 push_arg_context (pfile
, arg
)
850 cpp_context
*context
= next_context (pfile
);
852 context
->list
.first
= arg
->first
;
853 context
->list
.limit
= arg
->first
+ arg
->count
;
859 expand_arg (pfile
, arg
)
864 unsigned int capacity
= 256;
866 /* Loop, reading in the arguments. */
867 arg
->expanded
= (cpp_token
*) xmalloc (capacity
* sizeof (cpp_token
));
869 push_arg_context (pfile
, arg
);
872 if (arg
->expanded_count
>= capacity
)
875 arg
->expanded
= (cpp_token
*)
876 xrealloc (arg
->expanded
, capacity
* sizeof (cpp_token
));
878 token
= &arg
->expanded
[arg
->expanded_count
++];
879 cpp_get_token (pfile
, token
);
881 while (token
->type
!= CPP_EOF
);
883 arg
->expanded_count
--;
885 /* Pop the context we pushed. */
886 pfile
->context
= pfile
->context
->prev
;
890 _cpp_pop_context (pfile
)
893 cpp_context
*context
= pfile
->context
;
895 pfile
->context
= context
->prev
;
896 if (!pfile
->context
->prev
&& !pfile
->state
.parsing_args
)
897 unlock_pools (pfile
);
899 /* Re-enable a macro, temporarily if parsing_args, when leaving its
901 context
->macro
->disabled
= 0;
904 /* Eternal routine to get a token. Also used nearly everywhere
905 internally, except for places where we know we can safely call
906 the lexer directly, such as lexing a directive name.
908 Macro expansions and directives are transparently handled,
909 including entering included files. Thus tokens are post-macro
910 expansion, and after any intervening directives. External callers
911 see CPP_EOF only at EOF. Internal callers also see it when meeting
912 a directive inside a macro call, when at the end of a directive and
913 state.in_directive is still 1, and at the end of argument
916 cpp_get_token (pfile
, token
)
920 unsigned char flags
= 0;
924 cpp_context
*context
= pfile
->context
;
927 take_lookahead_token (pfile
, token
);
928 /* Context->prev == 0 <=> base context. */
929 else if (!context
->prev
)
930 _cpp_lex_token (pfile
, token
);
931 else if (context
->list
.first
!= context
->list
.limit
)
933 *token
= *context
->list
.first
++;
934 token
->flags
|= flags
;
936 /* PASTE_LEFT tokens can only appear in macro expansions. */
937 if (token
->flags
& PASTE_LEFT
)
938 paste_all_tokens (pfile
, token
);
944 _cpp_pop_context (pfile
);
947 /* End of argument pre-expansion. */
948 token
->type
= CPP_EOF
;
953 if (token
->type
!= CPP_NAME
)
956 /* Handle macros and the _Pragma operator. */
957 if (token
->val
.node
->type
== NT_MACRO
958 && !pfile
->state
.prevent_expansion
959 && !(token
->flags
& NO_EXPAND
))
961 cpp_hashnode
*node
= token
->val
.node
;
963 /* Macros invalidate controlling macros. */
964 pfile
->mi_state
= MI_FAILED
;
966 if (node
->flags
& NODE_BUILTIN
)
968 builtin_macro (pfile
, token
);
972 /* Merge PREV_WHITE of tokens. */
973 flags
= token
->flags
& PREV_WHITE
;
975 if (node
->value
.macro
->disabled
)
976 token
->flags
|= NO_EXPAND
;
977 else if (enter_macro_context (pfile
, node
))
981 /* Don't interpret _Pragma within directives. The standard is
982 not clear on this, but to me this makes most sense. */
983 if (token
->val
.node
!= pfile
->spec_nodes
.n__Pragma
984 || pfile
->state
.in_directive
)
987 /* Handle it, and loop back for another token. MI is cleared
988 since this token came from either the lexer or a macro. */
989 _cpp_do__Pragma (pfile
);
993 save_lookahead_token (pfile
, token
);
996 /* Read each token in, until EOF. Directives are transparently
999 cpp_scan_buffer_nooutput (pfile
, all_buffers
)
1004 cpp_buffer
*buffer
= all_buffers
? 0: pfile
->buffer
->prev
;
1008 cpp_get_token (pfile
, &token
);
1009 while (token
.type
!= CPP_EOF
);
1010 while (cpp_pop_buffer (pfile
) != buffer
);
1013 /* Lookahead handling. */
1016 save_lookahead_token (pfile
, token
)
1018 const cpp_token
*token
;
1020 if (token
->type
!= CPP_EOF
)
1022 cpp_lookahead
*la
= pfile
->la_write
;
1023 cpp_token_with_pos
*twp
;
1025 if (la
->count
== la
->cap
)
1027 la
->cap
+= la
->cap
+ 8;
1028 la
->tokens
= (cpp_token_with_pos
*)
1029 xrealloc (la
->tokens
, la
->cap
* sizeof (cpp_token_with_pos
));
1032 twp
= &la
->tokens
[la
->count
++];
1033 twp
->token
= *token
;
1034 twp
->pos
= *cpp_get_line (pfile
);
1039 take_lookahead_token (pfile
, token
)
1043 cpp_lookahead
*la
= pfile
->la_read
;
1044 cpp_token_with_pos
*twp
= &la
->tokens
[la
->cur
];
1046 *token
= twp
->token
;
1047 pfile
->lexer_pos
= twp
->pos
;
1049 if (++la
->cur
== la
->count
)
1050 _cpp_release_lookahead (pfile
);
1053 /* Moves the lookahead at the front of the read list to the free store. */
1055 _cpp_release_lookahead (pfile
)
1058 cpp_lookahead
*la
= pfile
->la_read
;
1060 pfile
->la_read
= la
->next
;
1061 la
->next
= pfile
->la_unused
;
1062 pfile
->la_unused
= la
;
1063 unlock_pools (pfile
);
1066 /* Take a new lookahead from the free store, or allocate one if none. */
1067 static cpp_lookahead
*
1068 alloc_lookahead (pfile
)
1071 cpp_lookahead
*la
= pfile
->la_unused
;
1074 pfile
->la_unused
= la
->next
;
1077 la
= xnew (cpp_lookahead
);
1082 la
->cur
= la
->count
= 0;
1086 /* Free memory associated with a lookahead list. */
1092 free ((PTR
) la
->tokens
);
1096 /* Free all the lookaheads of a cpp_reader. */
1098 _cpp_free_lookaheads (pfile
)
1101 cpp_lookahead
*la
, *lan
;
1104 free_lookahead (pfile
->la_read
);
1105 if (pfile
->la_write
)
1106 free_lookahead (pfile
->la_write
);
1108 for (la
= pfile
->la_unused
; la
; la
= lan
)
1111 free_lookahead (la
);
1115 /* Allocate a lookahead and move it to the front of the write list. */
1117 cpp_start_lookahead (pfile
)
1120 cpp_lookahead
*la
= alloc_lookahead (pfile
);
1122 la
->next
= pfile
->la_write
;
1123 pfile
->la_write
= la
;
1125 la
->pos
= *cpp_get_line (pfile
);
1127 /* Don't allow memory pools to be re-used whilst we're reading ahead. */
1131 /* Stop reading ahead - either step back, or drop the read ahead. */
1133 cpp_stop_lookahead (pfile
, drop
)
1137 cpp_lookahead
*la
= pfile
->la_write
;
1139 pfile
->la_write
= la
->next
;
1140 la
->next
= pfile
->la_read
;
1141 pfile
->la_read
= la
;
1143 if (drop
|| la
->count
== 0)
1144 _cpp_release_lookahead (pfile
);
1146 pfile
->lexer_pos
= la
->pos
;
1149 /* Push a single token back to the front of the queue. Only to be
1150 used by cpplib, and only then when necessary. POS is the position
1151 to report for the preceding token. */
1153 _cpp_push_token (pfile
, token
, pos
)
1155 const cpp_token
*token
;
1156 const cpp_lexer_pos
*pos
;
1158 cpp_start_lookahead (pfile
);
1159 save_lookahead_token (pfile
, token
);
1160 cpp_stop_lookahead (pfile
, 0);
1161 pfile
->lexer_pos
= *pos
;
1164 /* #define directive parsing and handling. */
1166 /* Returns non-zero if a macro redefinition is trivial. */
1168 check_macro_redefinition (pfile
, node
, macro2
)
1170 const cpp_hashnode
*node
;
1171 const cpp_macro
*macro2
;
1173 const cpp_macro
*macro1
;
1176 if (node
->type
!= NT_MACRO
|| node
->flags
& NODE_BUILTIN
)
1177 return ! pfile
->done_initializing
;
1179 macro1
= node
->value
.macro
;
1181 /* The quick failures. */
1182 if (macro1
->count
!= macro2
->count
1183 || macro1
->paramc
!= macro2
->paramc
1184 || macro1
->fun_like
!= macro2
->fun_like
1185 || macro1
->variadic
!= macro2
->variadic
)
1188 /* Check each token. */
1189 for (i
= 0; i
< macro1
->count
; i
++)
1190 if (! _cpp_equiv_tokens (¯o1
->expansion
[i
], ¯o2
->expansion
[i
]))
1193 /* Check parameter spellings. */
1194 for (i
= 0; i
< macro1
->paramc
; i
++)
1195 if (macro1
->params
[i
] != macro2
->params
[i
])
1201 /* Free the definition of hashnode H. */
1204 _cpp_free_definition (h
)
1207 /* Macros and assertions no longer have anything to free. */
1209 /* Clear builtin flag in case of redefinition. */
1210 h
->flags
&= ~NODE_BUILTIN
;
1214 save_parameter (pfile
, macro
, node
)
1219 cpp_hashnode
**dest
;
1221 /* Constraint 6.10.3.6 - duplicate parameter names. */
1222 if (node
->arg_index
)
1224 cpp_error (pfile
, "duplicate macro parameter \"%s\"", node
->name
);
1228 dest
= ¯o
->params
[macro
->paramc
];
1230 /* Check we have room for the parameters. */
1231 if ((unsigned char *) (dest
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1233 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_hashnode
*),
1234 (unsigned char **) ¯o
->params
);
1235 dest
= ¯o
->params
[macro
->paramc
];
1239 node
->arg_index
= ++macro
->paramc
;
1244 parse_params (pfile
, macro
)
1249 unsigned int prev_ident
= 0;
1251 macro
->params
= (cpp_hashnode
**) POOL_FRONT (&pfile
->macro_pool
);
1254 _cpp_lex_token (pfile
, &token
);
1259 cpp_error (pfile
, "\"%s\" may not appear in macro parameter list",
1260 cpp_token_as_text (pfile
, &token
));
1266 cpp_error (pfile
, "macro parameters must be comma-separated");
1271 if (save_parameter (pfile
, macro
, token
.val
.node
))
1275 case CPP_CLOSE_PAREN
:
1276 if (prev_ident
|| macro
->paramc
== 0)
1279 /* Fall through to pick up the error. */
1283 cpp_error (pfile
, "parameter name missing");
1290 macro
->variadic
= 1;
1293 save_parameter (pfile
, macro
, pfile
->spec_nodes
.n__VA_ARGS__
);
1294 pfile
->state
.va_args_ok
= 1;
1295 if (! CPP_OPTION (pfile
, c99
) && CPP_OPTION (pfile
, pedantic
))
1297 "anonymous variadic macros were introduced in C99");
1299 else if (CPP_OPTION (pfile
, pedantic
))
1300 cpp_pedwarn (pfile
, "ISO C does not permit named variadic macros");
1302 /* We're at the end, and just expect a closing parenthesis. */
1303 _cpp_lex_token (pfile
, &token
);
1304 if (token
.type
== CPP_CLOSE_PAREN
)
1309 cpp_error (pfile
, "missing ')' in macro parameter list");
1313 /* Success. Commit the parameter array. */
1314 POOL_COMMIT (&pfile
->macro_pool
,
1315 macro
->paramc
* sizeof (cpp_hashnode
*));
1320 /* Lex a token from a macro's replacement list. Translate it to a
1321 CPP_MACRO_ARG if appropriate. */
1323 lex_expansion_token (pfile
, macro
)
1327 cpp_token
*token
= ¯o
->expansion
[macro
->count
];
1329 /* Check we have room for the token. */
1330 if ((unsigned char *) (token
+ 1) >= POOL_LIMIT (&pfile
->macro_pool
))
1332 _cpp_next_chunk (&pfile
->macro_pool
, sizeof (cpp_token
),
1333 (unsigned char **) ¯o
->expansion
);
1334 token
= ¯o
->expansion
[macro
->count
];
1338 _cpp_lex_token (pfile
, token
);
1340 /* Is this an argument? */
1341 if (token
->type
== CPP_NAME
&& token
->val
.node
->arg_index
)
1343 token
->type
= CPP_MACRO_ARG
;
1344 token
->val
.arg_no
= token
->val
.node
->arg_index
;
1346 else if (CPP_WTRADITIONAL (pfile
) && macro
->paramc
> 0
1347 && (token
->type
== CPP_STRING
|| token
->type
== CPP_CHAR
))
1348 check_trad_stringification (pfile
, macro
, &token
->val
.str
);
1353 /* Parse a macro and save its expansion. Returns non-zero on success. */
1355 _cpp_create_definition (pfile
, node
)
1361 unsigned int i
, ok
= 1;
1363 macro
= (cpp_macro
*) _cpp_pool_alloc (&pfile
->macro_pool
,
1364 sizeof (cpp_macro
));
1365 macro
->file
= pfile
->buffer
->nominal_fname
;
1366 macro
->line
= pfile
->directive_pos
.line
;
1369 macro
->fun_like
= 0;
1370 macro
->variadic
= 0;
1372 macro
->expansion
= (cpp_token
*) POOL_FRONT (&pfile
->macro_pool
);
1374 /* Get the first token of the expansion (or the '(' of a
1375 function-like macro). */
1376 token
= lex_expansion_token (pfile
, macro
);
1377 if (token
->type
== CPP_OPEN_PAREN
&& !(token
->flags
& PREV_WHITE
))
1379 if (!(ok
= parse_params (pfile
, macro
)))
1382 macro
->fun_like
= 1;
1383 /* Some of the pool may have been used for the parameter store. */
1384 macro
->expansion
= (cpp_token
*) POOL_FRONT (&pfile
->macro_pool
);
1385 token
= lex_expansion_token (pfile
, macro
);
1387 else if (token
->type
!= CPP_EOF
&& !(token
->flags
& PREV_WHITE
))
1388 cpp_pedwarn (pfile
, "ISO C requires whitespace after the macro name");
1390 /* Setting it here means we don't catch leading comments. */
1391 pfile
->state
.save_comments
= ! CPP_OPTION (pfile
, discard_comments
);
1395 /* Check the stringifying # constraint 6.10.3.2.1 of
1396 function-like macros when lexing the subsequent token. */
1397 if (macro
->count
> 1 && token
[-1].type
== CPP_HASH
&& macro
->fun_like
)
1399 if (token
->type
== CPP_MACRO_ARG
)
1401 token
->flags
&= ~PREV_WHITE
;
1402 token
->flags
|= STRINGIFY_ARG
;
1403 token
->flags
|= token
[-1].flags
& PREV_WHITE
;
1404 token
[-1] = token
[0];
1407 /* Let assembler get away with murder. */
1408 else if (CPP_OPTION (pfile
, lang
) != CLK_ASM
)
1411 cpp_error (pfile
, "'#' is not followed by a macro parameter");
1416 if (token
->type
== CPP_EOF
)
1419 /* Paste operator constraint 6.10.3.3.1. */
1420 if (token
->type
== CPP_PASTE
)
1422 /* Token-paste ##, can appear in both object-like and
1423 function-like macros, but not at the ends. */
1424 if (--macro
->count
> 0)
1425 token
= lex_expansion_token (pfile
, macro
);
1427 if (macro
->count
== 0 || token
->type
== CPP_EOF
)
1431 "'##' cannot appear at either end of a macro expansion");
1435 token
[-1].flags
|= PASTE_LEFT
;
1436 /* Give it a PREV_WHITE for -dM etc. */
1437 token
->flags
|= PREV_WHITE
;
1440 token
= lex_expansion_token (pfile
, macro
);
1443 /* Don't count the CPP_EOF. */
1446 /* Clear the whitespace flag from the leading token. */
1447 macro
->expansion
[0].flags
&= ~PREV_WHITE
;
1449 /* Implement the macro-defined-to-itself optimisation. */
1450 macro
->disabled
= (macro
->count
== 1 && !macro
->fun_like
1451 && macro
->expansion
[0].type
== CPP_NAME
1452 && macro
->expansion
[0].val
.node
== node
);
1454 /* Commit the memory. */
1455 POOL_COMMIT (&pfile
->macro_pool
, macro
->count
* sizeof (cpp_token
));
1457 /* Redefinition of a macro is allowed if and only if the old and new
1458 definitions are the same. (6.10.3 paragraph 2). */
1459 if (node
->type
!= NT_VOID
)
1461 if (CPP_PEDANTIC (pfile
)
1462 && !check_macro_redefinition (pfile
, node
, macro
))
1464 cpp_pedwarn_with_line (pfile
, pfile
->directive_pos
.line
,
1465 pfile
->directive_pos
.col
,
1466 "\"%s\" redefined", node
->name
);
1468 if (pfile
->done_initializing
&& node
->type
== NT_MACRO
1469 && !(node
->flags
& NODE_BUILTIN
))
1470 cpp_pedwarn_with_file_and_line (pfile
,
1471 node
->value
.macro
->file
,
1472 node
->value
.macro
->line
, 1,
1473 "this is the location of the previous definition");
1475 _cpp_free_definition (node
);
1478 /* Enter definition in hash table. */
1479 node
->type
= NT_MACRO
;
1480 node
->value
.macro
= macro
;
1484 /* Stop the lexer accepting __VA_ARGS__. */
1485 pfile
->state
.va_args_ok
= 0;
1487 /* Clear the fast argument lookup indices. */
1488 for (i
= macro
->paramc
; i
-- > 0; )
1489 macro
->params
[i
]->arg_index
= 0;
1494 /* Warn if a token in `string' matches one of the function macro
1495 arguments in `info'. This function assumes that the macro is a
1496 function macro and not an object macro. */
1498 check_trad_stringification (pfile
, macro
, string
)
1500 const cpp_macro
*macro
;
1501 const cpp_string
*string
;
1503 unsigned int i
, len
;
1504 const U_CHAR
*p
, *q
, *limit
= string
->text
+ string
->len
;
1506 /* Loop over the string. */
1507 for (p
= string
->text
; p
< limit
; p
= q
)
1509 /* Find the start of an identifier. */
1510 while (p
< limit
&& !is_idstart (*p
))
1513 /* Find the end of the identifier. */
1515 while (q
< limit
&& is_idchar (*q
))
1520 /* Loop over the function macro arguments to see if the
1521 identifier inside the string matches one of them. */
1522 for (i
= 0; i
< macro
->paramc
; i
++)
1524 const cpp_hashnode
*node
= macro
->params
[i
];
1526 if (node
->length
== len
&& !memcmp (p
, node
->name
, len
))
1529 "macro argument \"%s\" would be stringified with -traditional.",
1537 /* Returns the expansion of a macro, in a format suitable to be read
1538 back in again, and therefore also for DWARF 2 debugging info.
1539 Caller is expected to generate the "#define NAME" bit. The
1540 returned text is temporary, and automatically freed later. */
1542 const unsigned char *
1543 cpp_macro_definition (pfile
, node
)
1545 const cpp_hashnode
*node
;
1547 unsigned int i
, len
;
1548 const cpp_macro
*macro
= node
->value
.macro
;
1549 unsigned char *buffer
;
1551 if (node
->type
!= NT_MACRO
|| (node
->flags
& NODE_BUILTIN
))
1553 cpp_ice (pfile
, "invalid hash type %d in dump_definition", node
->type
);
1557 /* Calculate length. */
1559 if (macro
->fun_like
)
1561 len
+= 3; /* "()" plus possible final "." of ellipsis. */
1562 for (i
= 0; i
< macro
->paramc
; i
++)
1563 len
+= macro
->params
[i
]->length
+ 2; /* ", " */
1566 for (i
= 0; i
< macro
->count
; i
++)
1568 cpp_token
*token
= ¯o
->expansion
[i
];
1570 if (token
->type
== CPP_MACRO_ARG
)
1571 len
+= macro
->params
[token
->val
.arg_no
- 1]->length
;
1573 len
+= cpp_token_len (token
); /* Includes room for ' '. */
1574 if (token
->flags
& STRINGIFY_ARG
)
1576 if (token
->flags
& PASTE_LEFT
)
1577 len
+= 3; /* " ##" */
1580 if (len
> pfile
->macro_buffer_len
)
1581 pfile
->macro_buffer
= (U_CHAR
*) xrealloc (pfile
->macro_buffer
, len
);
1582 buffer
= pfile
->macro_buffer
;
1584 /* Parameter names. */
1585 if (macro
->fun_like
)
1588 for (i
= 0; i
< macro
->paramc
; i
++)
1590 cpp_hashnode
*param
= macro
->params
[i
];
1592 if (param
!= pfile
->spec_nodes
.n__VA_ARGS__
)
1594 memcpy (buffer
, param
->name
, param
->length
);
1595 buffer
+= param
->length
;
1598 if (i
+ 1 < macro
->paramc
)
1599 *buffer
++ = ',', *buffer
++ = ' ';
1600 else if (macro
->variadic
)
1601 *buffer
++ = '.', *buffer
++ = '.', *buffer
++ = '.';
1606 /* Expansion tokens. */
1610 for (i
= 0; i
< macro
->count
; i
++)
1612 cpp_token
*token
= ¯o
->expansion
[i
];
1614 if (token
->flags
& PREV_WHITE
)
1616 if (token
->flags
& STRINGIFY_ARG
)
1619 if (token
->type
== CPP_MACRO_ARG
)
1621 len
= macro
->params
[token
->val
.arg_no
- 1]->length
;
1622 memcpy (buffer
, macro
->params
[token
->val
.arg_no
- 1]->name
, len
);
1626 buffer
= cpp_spell_token (pfile
, token
, buffer
);
1628 if (token
->flags
& PASTE_LEFT
)
1633 /* Next has PREV_WHITE; see _cpp_create_definition. */
1639 return pfile
->macro_buffer
;