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 var_args : 1; /* If a variable-args 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_token *));
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 void paste_payloads PARAMS ((cpp_reader *, cpp_token *,
80 static int funlike_invocation_p PARAMS ((cpp_reader *, const cpp_hashnode *,
82 static void replace_args PARAMS ((cpp_reader *, cpp_macro *, macro_arg *,
87 static void save_lookahead_token PARAMS ((cpp_reader *, const cpp_token *));
88 static void take_lookahead_token PARAMS ((cpp_reader *, cpp_token *));
89 static void release_lookahead PARAMS ((cpp_reader *));
90 static cpp_lookahead *alloc_lookahead PARAMS ((cpp_reader *));
91 static void free_lookahead PARAMS ((cpp_lookahead *));
93 /* #define directive parsing and handling. */
95 static cpp_token *lex_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
96 static int check_macro_redefinition PARAMS ((cpp_reader *,
99 static int save_parameter PARAMS ((cpp_reader *, cpp_macro *, cpp_hashnode *));
100 static int parse_params PARAMS ((cpp_reader *, cpp_macro *));
101 static void check_trad_stringification PARAMS ((cpp_reader *,
103 const cpp_string *));
105 /* Allocates a buffer to hold a token's TEXT, and converts TOKEN to a
106 CPP_STRING token containing TEXT in quoted form. */
108 make_string_token (pool, token, text, len)
114 U_CHAR *buf = _cpp_pool_alloc (pool, len * 4);
116 token->type = CPP_STRING;
117 token->val.str.text = buf;
118 token->val.str.len = quote_string (buf, text, len) - buf;
122 /* Allocates and converts a temporary token to a CPP_NUMBER token,
123 evaluating to NUMBER. */
125 make_number_token (pfile, token, number)
130 unsigned char *buf = _cpp_pool_alloc (pfile->string_pool, 20);
132 sprintf ((char *) buf, "%d", number);
133 token->type = CPP_NUMBER;
134 token->val.str.text = buf;
135 token->val.str.len = ustrlen (buf);
139 static const char * const monthnames[] =
141 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
142 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
145 /* Handle builtin macros like __FILE__. */
147 builtin_macro (pfile, token)
151 unsigned char flags = token->flags & PREV_WHITE;
152 cpp_hashnode *node = token->val.node;
155 switch (node->value.builtin)
162 ip = CPP_BUFFER (pfile);
167 if (node->value.builtin == BT_BASE_FILE)
168 while (CPP_PREV_BUFFER (ip) != NULL)
169 ip = CPP_PREV_BUFFER (ip);
171 file = ip->nominal_fname;
173 make_string_token (pfile->string_pool, token,
174 (U_CHAR *) file, strlen (file));
178 case BT_INCLUDE_LEVEL:
179 /* pfile->include_depth counts the primary source as level 1,
180 but historically __INCLUDE_DEPTH__ has called the primary
182 make_number_token (pfile, token, pfile->include_depth - 1);
186 /* If __LINE__ is embedded in a macro, it must expand to the
187 line of the macro's invocation, not its definition.
188 Otherwise things like assert() will not work properly. */
189 make_number_token (pfile, token, cpp_get_line (pfile)->line);
196 if (STDC_0_IN_SYSTEM_HEADERS && CPP_IN_SYSTEM_HEADER (pfile)
197 && pfile->spec_nodes.n__STRICT_ANSI__->type == NT_VOID)
199 make_number_token (pfile, token, stdc);
205 if (pfile->date.type == CPP_EOF)
207 /* Allocate __DATE__ and __TIME__ from permanent storage,
208 and save them in pfile so we don't have to do this again.
209 We don't generate these strings at init time because
210 time() and localtime() are very slow on some systems. */
211 time_t tt = time (NULL);
212 struct tm *tb = localtime (&tt);
214 make_string_token (&pfile->ident_pool, &pfile->date,
216 make_string_token (&pfile->ident_pool, &pfile->time,
219 sprintf ((char *) pfile->date.val.str.text, "%s %2d %4d",
220 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
221 sprintf ((char *) pfile->time.val.str.text, "%02d:%02d:%02d",
222 tb->tm_hour, tb->tm_min, tb->tm_sec);
224 *token = node->value.builtin == BT_DATE ? pfile->date: pfile->time;
228 cpp_ice (pfile, "invalid builtin macro \"%s\"", node->name);
232 token->flags = flags;
235 /* Used by cpperror.c to obtain the correct line and column to report
237 const cpp_lexer_pos *
241 /* Within a macro expansion, return the position of the outermost
243 if (pfile->context->prev)
244 return &pfile->macro_pos;
245 return &pfile->lexer_pos;
252 _cpp_lock_pool (&pfile->temp_string_pool);
253 _cpp_lock_pool (&pfile->argument_pool);
260 _cpp_unlock_pool (&pfile->temp_string_pool);
261 _cpp_unlock_pool (&pfile->argument_pool);
265 paste_payloads (pfile, lhs, rhs)
268 const cpp_token *rhs;
270 unsigned int total_len = cpp_token_len (lhs) + cpp_token_len (rhs);
271 unsigned char *result, *end;
274 pool = lhs->type == CPP_NAME ? &pfile->ident_pool: pfile->string_pool;
275 result = _cpp_pool_alloc (pool, total_len + 1);
277 /* Paste the spellings and null terminate. */
278 end = cpp_spell_token (pfile, rhs, cpp_spell_token (pfile, lhs, result));
280 total_len = end - result;
282 if (lhs->type == CPP_NAME)
284 lhs->val.node = cpp_lookup (pfile, result, total_len);
285 if (lhs->val.node->flags & NODE_OPERATOR)
287 lhs->flags |= NAMED_OP;
288 lhs->type = lhs->val.node->value.operator;
293 lhs->val.str.text = result;
294 lhs->val.str.len = total_len;
298 /* Adds backslashes before all backslashes and double quotes appearing
299 in strings. Non-printable characters are converted to octal. */
301 quote_string (dest, src, len)
310 if (c == '\\' || c == '"')
321 sprintf ((char *) dest, "\\%03o", c);
330 /* Convert a token sequence to a single string token according to the
331 rules of the ISO C #-operator. */
333 stringify_arg (pfile, arg)
337 cpp_pool *pool = pfile->string_pool;
338 unsigned char *start = POOL_FRONT (pool);
339 unsigned int i, escape_it, total_len = 0, backslash_count = 0;
340 unsigned int prev_white = 0;
342 /* Loop, reading in the argument's tokens. */
343 for (i = 0; i < arg->count; i++)
346 const cpp_token *token = &arg->first[i];
347 unsigned int len = cpp_token_len (token);
349 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
350 || token->type == CPP_CHAR || token->type == CPP_WCHAR
351 || token->type == CPP_OSTRING);
354 /* Worst case is each char is octal. */
356 len++; /* Room for initial space. */
358 dest = &start[total_len];
359 if (dest + len > POOL_LIMIT (pool))
361 _cpp_next_chunk (pool, len, (unsigned char **) &start);
362 dest = &start[total_len];
365 prev_white |= token->flags & PREV_WHITE;
366 if (token->type == CPP_PLACEMARKER)
369 /* No leading white space. */
379 unsigned char *buf = (unsigned char *) xmalloc (len);
381 len = cpp_spell_token (pfile, token, buf) - buf;
382 dest = quote_string (dest, buf, len);
386 dest = cpp_spell_token (pfile, token, dest);
387 total_len = dest - start;
389 if (token->type == CPP_OTHER && token->val.c == '\\')
395 /* Ignore the final \ of invalid string literals. */
396 if (backslash_count & 1)
398 cpp_warning (pfile, "invalid string literal, ignoring final '\\'");
402 POOL_COMMIT (pool, total_len);
404 arg->stringified = xnew (cpp_token);
405 arg->stringified->flags = 0;
406 arg->stringified->type = CPP_STRING;
407 arg->stringified->val.str.text = start;
408 arg->stringified->val.str.len = total_len;
411 /* Handles an arbitrarily long sequence of ## operators. This
412 implementation is left-associative, non-recursive, and finishes a
413 paste before handling succeeding ones. If the paste fails, the
414 right hand side of the ## operator is placed in the then-current
415 context's lookahead buffer, with the effect that it appears in the
416 output stream normally. */
418 paste_all_tokens (pfile, lhs)
422 unsigned char orig_flags = lhs->flags;
427 /* Take the token directly from the current context. We can do
428 this, because we are in the replacement list of either an
429 object-like macro, or a function-like macro with arguments
430 inserted. In either case, the constraints to #define
431 guarantee we have at least one more token (empty arguments
432 become placemarkers). */
433 rhs = pfile->context->list.first++;
435 if (rhs->type == CPP_PLACEMARKER)
437 /* GCC has special extended semantics for , ## b where b is
438 a varargs parameter: the comma disappears if b was given
439 no actual arguments (not merely if b is an empty
441 if (lhs->type == CPP_COMMA && (rhs->flags & VARARGS_FIRST))
442 lhs->type = CPP_PLACEMARKER;
444 else if (lhs->type == CPP_PLACEMARKER)
449 enum cpp_ttype type = cpp_can_paste (pfile, lhs, rhs, &digraph);
453 /* Do nothing special about , ## <whatever> if
454 <whatever> came from a variable argument, because the
455 author probably intended the ## to trigger the
456 special extended semantics (see above). */
457 if (lhs->type == CPP_COMMA && (rhs->flags & VARARGS_FIRST))
461 if (CPP_OPTION (pfile, warn_paste))
463 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
464 cpp_token_as_text (pfile, lhs),
465 cpp_token_as_text (pfile, rhs));
467 /* The standard states that behaviour is undefined.
468 By the principle of least surpise, we step back
469 before the RHS, and mark it to prevent macro
470 expansion. Tests in the testsuite rely on
471 clearing PREV_WHITE here, though you could argue
472 we should actually set it. */
473 rhs->flags &= ~PREV_WHITE;
474 rhs->flags |= NO_EXPAND;
477 /* Step back so we read the RHS in next. */
478 pfile->context->list.first--;
483 lhs->flags &= ~DIGRAPH;
485 lhs->flags |= DIGRAPH;
487 if (type == CPP_NAME || type == CPP_NUMBER)
488 paste_payloads (pfile, lhs, rhs);
489 else if (type == CPP_WCHAR || type == CPP_WSTRING)
490 lhs->val.str = rhs->val.str;
493 while (rhs->flags & PASTE_LEFT);
495 /* The pasted token has the PREV_WHITE flag of the LHS, is no longer
496 PASTE_LEFT, and is subject to macro expansion. */
497 lhs->flags &= ~(PREV_WHITE | PASTE_LEFT | NO_EXPAND);
498 lhs->flags |= orig_flags & PREV_WHITE;
501 /* Reads the unexpanded tokens of a macro argument into ARG. Empty
502 arguments are saved as a single CPP_PLACEMARKER token. VAR_ARGS is
503 non-zero if this is a variable argument. Returns the type of the
504 token that caused reading to finish. */
505 static enum cpp_ttype
506 parse_arg (pfile, arg, var_args)
508 struct macro_arg *arg;
511 enum cpp_ttype result;
512 unsigned int paren = 0;
514 arg->first = (cpp_token *) POOL_FRONT (&pfile->argument_pool);
515 for (;; arg->count++)
517 cpp_token *token = &arg->first[arg->count];
518 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->argument_pool))
520 _cpp_next_chunk (&pfile->argument_pool, sizeof (cpp_token),
521 (unsigned char **) &arg->first);
522 token = &arg->first[arg->count];
525 _cpp_get_token (pfile, token);
526 result = token->type;
528 if (result == CPP_OPEN_PAREN)
530 else if (result == CPP_CLOSE_PAREN && paren-- == 0)
532 /* Commas are not terminators within parantheses or var_args. */
533 else if (result == CPP_COMMA && paren == 0 && !var_args)
535 else if (result == CPP_EOF)
536 break; /* Error reported by caller. */
537 else if (result == CPP_DHASH)
539 /* 6.10.3 paragraph 11: If there are sequences of
540 preprocessing tokens within the list of arguments that
541 would otherwise act as preprocessing directives, the
542 behavior is undefined.
544 This implementation will report a hard error, terminate
545 the macro invocation, and proceed to process the
547 cpp_error (pfile, "directives may not be used inside a macro argument");
548 _cpp_push_token (pfile, token, &pfile->lexer_pos);
554 /* Empty arguments become a single placemarker token. */
557 arg->first->type = CPP_PLACEMARKER;
561 /* Commit the memory used to store the arguments. */
562 POOL_COMMIT (&pfile->argument_pool, arg->count * sizeof (cpp_token));
567 /* Parse the arguments making up a macro invocation. */
569 parse_args (pfile, node)
571 const cpp_hashnode *node;
573 cpp_macro *macro = node->value.macro;
574 macro_arg *args, *cur;
578 /* Allocate room for at least one argument, and zero it out. */
579 argc = macro->paramc ? macro->paramc: 1;
580 args = xcnewvec (macro_arg, argc);
582 for (cur = args, argc = 0; ;)
586 type = parse_arg (pfile, cur, argc == macro->paramc && macro->var_args);
587 if (type == CPP_CLOSE_PAREN || type == CPP_EOF)
590 /* Re-use the last argument for excess arguments. */
591 if (argc < macro->paramc)
597 cpp_error (pfile, "unterminated argument list invoking macro \"%s\"",
601 else if (argc < macro->paramc)
603 /* As an extension, a rest argument is allowed to not appear in
604 the invocation at all.
605 e.g. #define debug(format, args...) something
608 This is exactly the same as if there had been an empty rest
609 argument - debug("string", ). */
611 if (argc + 1 == macro->paramc && macro->var_args)
613 /* parse_arg ensured there was space for the closing
614 parenthesis. Use this space to store a placemarker. */
615 args[argc].first = (cpp_token *) POOL_FRONT (&pfile->argument_pool);
616 args[argc].first->type = CPP_PLACEMARKER;
617 args[argc].count = 1;
618 POOL_COMMIT (&pfile->argument_pool, sizeof (cpp_token));
620 if (CPP_OPTION (pfile, c99) && CPP_PEDANTIC (pfile))
621 cpp_pedwarn (pfile, "ISO C99 requires rest arguments to be used");
626 "macro \"%s\" requires %u arguments, but only %u given",
627 node->name, macro->paramc, argc);
631 else if (argc > macro->paramc)
633 /* An empty argument to an empty function-like macro is fine. */
634 if (argc != 1 || args[0].first->type != CPP_PLACEMARKER)
637 "macro \"%s\" passed %u arguments, but takes just %u",
638 node->name, argc, macro->paramc);
653 funlike_invocation_p (pfile, node, list)
655 const cpp_hashnode *node;
656 struct toklist *list;
658 cpp_context *orig_context;
659 cpp_token maybe_paren;
662 pfile->state.parsing_args = 1;
663 pfile->state.prevent_expansion++;
664 orig_context = pfile->context;
666 cpp_start_lookahead (pfile);
667 cpp_get_token (pfile, &maybe_paren);
668 cpp_stop_lookahead (pfile, maybe_paren.type == CPP_OPEN_PAREN);
670 if (maybe_paren.type == CPP_OPEN_PAREN)
671 args = parse_args (pfile, node);
672 else if (CPP_WTRADITIONAL (pfile))
674 "function-like macro \"%s\" must be used with arguments in traditional C",
677 /* Restore original context. */
678 pfile->context = orig_context;
679 pfile->state.prevent_expansion--;
680 pfile->state.parsing_args = 0;
684 if (node->value.macro->paramc > 0)
685 replace_args (pfile, node->value.macro, args, list);
692 /* Push the context of a macro onto the context stack. TOKEN is the
693 macro name. If we can successfully start expanding the macro,
694 TOKEN is replaced with the first token of the expansion, and we
697 enter_macro_context (pfile, token)
701 cpp_context *context;
706 macro = token->val.node->value.macro;
709 token->flags |= NO_EXPAND;
713 /* Save the position of the outermost macro invocation. */
714 if (!pfile->context->prev)
716 pfile->macro_pos = pfile->lexer_pos;
720 if (macro->fun_like && !funlike_invocation_p (pfile, token->val.node, &list))
722 if (!pfile->context->prev)
723 unlock_pools (pfile);
727 /* Now push its context. */
728 context = next_context (pfile);
729 if (macro->paramc == 0)
731 context->list.first = macro->expansion;
732 context->list.limit = macro->expansion + macro->count;
735 context->list = list;
736 context->macro = macro;
738 /* The first expansion token inherits the PREV_WHITE of TOKEN. */
739 flags = token->flags & PREV_WHITE;
740 *token = *context->list.first++;
741 token->flags |= flags;
743 /* Disable the macro within its expansion. */
749 /* Move to the next context. Create one if there is none. */
754 cpp_context *prev = pfile->context;
755 cpp_context *result = prev->next;
759 result = xnew (cpp_context);
765 pfile->context = result;
770 replace_args (pfile, macro, args, list)
774 struct toklist *list;
776 unsigned int i, total;
777 const cpp_token *src, *limit;
781 src = macro->expansion;
782 limit = src + macro->count;
784 /* First, fully macro-expand arguments, calculating the number of
785 tokens in the final expansion as we go. This ensures that the
786 possible recursive use of argument_pool is fine. */
788 for (; src < limit; src++)
789 if (src->type == CPP_MACRO_ARG)
791 /* We have an argument. If it is not being stringified or
792 pasted it is macro-replaced before insertion. */
793 arg = &args[src->val.arg_no - 1];
794 if (src->flags & STRINGIFY_ARG)
796 if (!arg->stringified)
797 stringify_arg (pfile, arg);
799 else if ((src->flags & PASTE_LEFT)
800 || (src > macro->expansion && (src[-1].flags & PASTE_LEFT)))
801 total += arg->count - 1;
805 expand_arg (pfile, arg);
806 total += arg->expanded_count - 1;
810 dest = (cpp_token *) _cpp_pool_alloc (&pfile->argument_pool,
811 total * sizeof (cpp_token));
813 list->limit = list->first + total;
815 for (src = macro->expansion; src < limit; src++)
816 if (src->type == CPP_MACRO_ARG)
819 const cpp_token *from;
821 arg = &args[src->val.arg_no - 1];
822 if (src->flags & STRINGIFY_ARG)
823 from = arg->stringified, count = 1;
824 else if ((src->flags & PASTE_LEFT)
825 || (src > macro->expansion && (src[-1].flags & PASTE_LEFT)))
826 count = arg->count, from = arg->first;
828 count = arg->expanded_count, from = arg->expanded;
829 memcpy (dest, from, count * sizeof (cpp_token));
831 /* The first token gets PREV_WHITE of the CPP_MACRO_ARG. If
832 it is a variable argument, it is also flagged. */
833 dest->flags &= ~PREV_WHITE;
834 dest->flags |= src->flags & PREV_WHITE;
835 if (macro->var_args && src->val.arg_no == macro->paramc)
836 dest->flags |= VARARGS_FIRST;
838 /* The last token gets the PASTE_LEFT of the CPP_MACRO_ARG. */
839 dest[count - 1].flags |= src->flags & PASTE_LEFT;
846 /* Free the expanded arguments. */
847 for (i = 0; i < macro->paramc; i++)
849 if (args[i].expanded)
850 free (args[i].expanded);
851 if (args[i].stringified)
852 free (args[i].stringified);
856 /* Subroutine of expand_arg to put the unexpanded tokens on the
859 push_arg_context (pfile, arg)
863 cpp_context *context = next_context (pfile);
865 context->list.first = arg->first;
866 context->list.limit = arg->first + arg->count;
872 expand_arg (pfile, arg)
877 unsigned int capacity = 256;
879 /* Loop, reading in the arguments. */
880 arg->expanded = (cpp_token *) xmalloc (capacity * sizeof (cpp_token));
881 arg->expanded_count = 0;
883 push_arg_context (pfile, arg);
886 if (arg->expanded_count >= capacity)
889 arg->expanded = (cpp_token *)
890 xrealloc (arg->expanded, capacity * sizeof (cpp_token));
892 token = &arg->expanded[arg->expanded_count++];
893 _cpp_get_token (pfile, token);
895 while (token->type != CPP_EOF);
897 arg->expanded_count--;
899 /* Pop the context we pushed. */
900 pfile->context = pfile->context->prev;
904 _cpp_pop_context (pfile)
907 cpp_context *context = pfile->context;
909 pfile->context = context->prev;
910 /* Re-enable a macro and free resources when leaving its expansion. */
911 if (!pfile->state.parsing_args)
913 if (!pfile->context->prev)
914 unlock_pools (pfile);
915 context->macro->disabled = 0;
919 /* Internal routine to return a token, either from an in-progress
920 macro expansion, or from the source file as appropriate. Handles
921 macros, so tokens returned are post-expansion. Does not filter
922 CPP_PLACEMARKER tokens. Returns CPP_EOF at EOL and EOF. */
924 _cpp_get_token (pfile, token)
931 cpp_context *context = pfile->context;
934 take_lookahead_token (pfile, token);
935 /* Context->prev == 0 <=> base context. */
936 else if (!context->prev)
937 _cpp_lex_token (pfile, token);
938 else if (context->list.first != context->list.limit)
939 *token = *context->list.first++;
944 _cpp_pop_context (pfile);
947 token->type = CPP_EOF;
953 /* Only perform macro expansion (and therefore pasting) when not
954 skipping, or when skipping but in a directive. The only
955 directive where this could be true is #elif. A possible later
956 optimisation: get do_elif to clear skipping so we don't need the
957 directive test here. */
958 if (pfile->skipping && !pfile->state.in_directive)
963 if (token->flags & PASTE_LEFT)
964 paste_all_tokens (pfile, token);
966 if (token->type != CPP_NAME)
969 /* Handle macros and the _Pragma operator. */
970 if (token->val.node->type == NT_MACRO
971 && !pfile->state.prevent_expansion
972 && !(token->flags & NO_EXPAND))
974 /* Macros invalidate controlling macros. */
975 pfile->mi_state = MI_FAILED;
977 if (token->val.node->flags & NODE_BUILTIN)
979 builtin_macro (pfile, token);
983 if (enter_macro_context (pfile, token))
987 if (token->val.node != pfile->spec_nodes.n__Pragma)
990 /* Invalidate controlling macros. */
991 pfile->mi_state = MI_FAILED;
992 _cpp_do__Pragma (pfile);
997 /* External interface to get a token. Tokens are returned after macro
998 expansion and directives have been handled, as a continuous stream.
999 Transparently enters included files. CPP_EOF indicates end of
1000 original source file. Filters out CPP_PLACEMARKER tokens.
1002 For the benefit of #pragma callbacks which may want to get the
1003 pragma's tokens, returns CPP_EOF to indicate end-of-directive in
1006 cpp_get_token (pfile, token)
1012 _cpp_get_token (pfile, token);
1014 if (token->type == CPP_EOF)
1016 /* In directives we should pass through EOLs for the callbacks. */
1017 if (pfile->buffer->cur == pfile->buffer->rlimit
1018 || pfile->state.in_directive || pfile->state.parsing_args)
1022 else if (token->type == CPP_DHASH)
1024 /* Handle directives. */
1025 if (_cpp_handle_directive (pfile, token->flags & PREV_WHITE))
1027 /* This is in fact an assembler #. */
1028 if (pfile->skipping)
1030 token->type = CPP_HASH;
1032 /* We are not merging the PREV_WHITE of CPP_PLACEMARKERS. I
1033 don't think it really matters. */
1034 else if (pfile->skipping || token->type == CPP_PLACEMARKER)
1037 /* Non-comment tokens invalidate any controlling macros. */
1038 if (token->type != CPP_COMMENT)
1039 pfile->mi_state = MI_FAILED;
1044 if (pfile->la_write)
1045 save_lookahead_token (pfile, token);
1048 /* Read each token in, until EOF. Directives are transparently
1051 cpp_scan_buffer_nooutput (pfile)
1058 cpp_get_token (pfile, &token);
1059 while (token.type != CPP_EOF);
1060 while (cpp_pop_buffer (pfile) != 0);
1063 /* Lookahead handling. */
1066 save_lookahead_token (pfile, token)
1068 const cpp_token *token;
1070 if (token->type != CPP_EOF)
1072 cpp_lookahead *la = pfile->la_write;
1073 cpp_token_with_pos *twp;
1075 if (la->count == la->cap)
1077 la->cap += la->cap + 8;
1078 la->tokens = (cpp_token_with_pos *)
1079 xrealloc (la->tokens, la->cap * sizeof (cpp_token_with_pos));
1082 twp = &la->tokens[la->count++];
1083 twp->token = *token;
1084 twp->pos = *cpp_get_line (pfile);
1089 take_lookahead_token (pfile, token)
1093 cpp_lookahead *la = pfile->la_read;
1094 cpp_token_with_pos *twp = &la->tokens[la->cur];
1096 *token = twp->token;
1097 pfile->lexer_pos = twp->pos;
1099 if (++la->cur == la->count)
1100 release_lookahead (pfile);
1103 /* Moves the lookahead at the front of the read list to the free store. */
1105 release_lookahead (pfile)
1108 cpp_lookahead *la = pfile->la_read;
1110 pfile->la_read = la->next;
1111 la->next = pfile->la_unused;
1112 pfile->la_unused = la;
1113 unlock_pools (pfile);
1116 /* Take a new lookahead from the free store, or allocate one if none. */
1117 static cpp_lookahead *
1118 alloc_lookahead (pfile)
1121 cpp_lookahead *la = pfile->la_unused;
1124 pfile->la_unused = la->next;
1127 la = xnew (cpp_lookahead);
1132 la->cur = la->count = 0;
1136 /* Free memory associated with a lookahead list. */
1142 free ((PTR) la->tokens);
1146 /* Free all the lookaheads of a cpp_reader. */
1148 _cpp_free_lookaheads (pfile)
1151 cpp_lookahead *la, *lan;
1154 free_lookahead (pfile->la_read);
1155 if (pfile->la_write)
1156 free_lookahead (pfile->la_write);
1158 for (la = pfile->la_unused; la; la = lan)
1161 free_lookahead (la);
1165 /* Allocate a lookahead and move it to the front of the write list. */
1167 cpp_start_lookahead (pfile)
1170 cpp_lookahead *la = alloc_lookahead (pfile);
1172 la->next = pfile->la_write;
1173 pfile->la_write = la;
1175 la->pos = *cpp_get_line (pfile);
1177 /* Don't allow memory pools to be re-used whilst we're reading ahead. */
1181 /* Stop reading ahead - either step back, or drop the read ahead. */
1183 cpp_stop_lookahead (pfile, drop)
1187 cpp_lookahead *la = pfile->la_write;
1189 pfile->la_write = la->next;
1190 la->next = pfile->la_read;
1191 pfile->la_read = la;
1193 if (drop || la->count == 0)
1194 release_lookahead (pfile);
1196 pfile->lexer_pos = la->pos;
1199 /* Push a single token back to the front of the queue. Only to be
1200 used by cpplib, and only then when necessary. POS is the position
1201 to report for the preceding token. */
1203 _cpp_push_token (pfile, token, pos)
1205 const cpp_token *token;
1206 const cpp_lexer_pos *pos;
1208 cpp_start_lookahead (pfile);
1209 save_lookahead_token (pfile, token);
1210 cpp_stop_lookahead (pfile, 0);
1211 pfile->lexer_pos = *pos;
1214 /* #define directive parsing and handling. */
1216 /* Returns non-zero if a macro redefinition is trivial. */
1218 check_macro_redefinition (pfile, node, macro2)
1220 const cpp_hashnode *node;
1221 const cpp_macro *macro2;
1223 const cpp_macro *macro1;
1226 if (node->type != NT_MACRO || node->flags & NODE_BUILTIN)
1227 return ! pfile->done_initializing;
1229 macro1 = node->value.macro;
1231 /* The quick failures. */
1232 if (macro1->count != macro2->count
1233 || macro1->paramc != macro2->paramc
1234 || macro1->fun_like != macro2->fun_like
1235 || macro1->var_args != macro2->var_args)
1238 /* Check each token. */
1239 for (i = 0; i < macro1->count; i++)
1240 if (! _cpp_equiv_tokens (¯o1->expansion[i], ¯o2->expansion[i]))
1243 /* Check parameter spellings. */
1244 for (i = 0; i < macro1->paramc; i++)
1245 if (macro1->params[i] != macro2->params[i])
1251 /* Free the definition of hashnode H. */
1254 _cpp_free_definition (h)
1257 /* Macros and assertions no longer have anything to free. */
1259 /* Clear builtin flag in case of redefinition. */
1260 h->flags &= ~NODE_BUILTIN;
1264 save_parameter (pfile, macro, node)
1269 cpp_hashnode **dest;
1271 /* Constraint 6.10.3.6 - duplicate parameter names. */
1272 if (node->arg_index)
1274 cpp_error (pfile, "duplicate macro parameter \"%s\"", node->name);
1278 dest = ¯o->params[macro->paramc];
1280 /* Check we have room for the parameters. */
1281 if ((unsigned char *) (dest + 1) >= POOL_LIMIT (&pfile->macro_pool))
1283 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_hashnode *),
1284 (unsigned char **) ¯o->params);
1285 dest = ¯o->params[macro->paramc];
1289 node->arg_index = ++macro->paramc;
1294 parse_params (pfile, macro)
1299 unsigned int prev_ident = 0;
1301 macro->params = (cpp_hashnode **) POOL_FRONT (&pfile->macro_pool);
1304 _cpp_lex_token (pfile, &token);
1309 cpp_error (pfile, "\"%s\" may not appear in macro parameter list",
1310 cpp_token_as_text (pfile, &token));
1316 cpp_error (pfile, "macro parameters must be comma-separated");
1321 if (save_parameter (pfile, macro, token.val.node))
1325 case CPP_CLOSE_PAREN:
1326 if (prev_ident || macro->paramc == 0)
1329 /* Fall through to pick up the error. */
1333 cpp_error (pfile, "parameter name missing");
1340 macro->var_args = 1;
1343 save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1344 pfile->state.va_args_ok = 1;
1345 if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1347 "C89 does not permit anonymous variable arguments");
1349 else if (CPP_OPTION (pfile, pedantic))
1351 "ISO C does not permit named variable arguments");
1353 /* We're at the end, and just expect a closing parenthesis. */
1354 _cpp_lex_token (pfile, &token);
1355 if (token.type == CPP_CLOSE_PAREN)
1360 cpp_error (pfile, "missing ')' in macro parameter list");
1364 /* Success. Commit the parameter array. */
1365 POOL_COMMIT (&pfile->macro_pool,
1366 macro->paramc * sizeof (cpp_hashnode *));
1371 /* Lex a token from a macro's replacement list. Translate it to a
1372 CPP_MACRO_ARG if appropriate. */
1374 lex_expansion_token (pfile, macro)
1378 cpp_token *token = ¯o->expansion[macro->count];
1380 /* Check we have room for the token. */
1381 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1383 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1384 (unsigned char **) ¯o->expansion);
1385 token = ¯o->expansion[macro->count];
1389 _cpp_lex_token (pfile, token);
1391 /* Is this an argument? */
1392 if (token->type == CPP_NAME && token->val.node->arg_index)
1394 token->type = CPP_MACRO_ARG;
1395 token->val.arg_no = token->val.node->arg_index;
1397 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1398 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1399 check_trad_stringification (pfile, macro, &token->val.str);
1404 /* Parse a macro and save its expansion. Returns non-zero on success. */
1406 _cpp_create_definition (pfile, node)
1412 unsigned int i, ok = 1;
1414 macro = (cpp_macro *) _cpp_pool_alloc (&pfile->macro_pool,
1415 sizeof (cpp_macro));
1416 macro->file = pfile->buffer->nominal_fname;
1417 macro->line = pfile->directive_pos.line;
1420 macro->fun_like = 0;
1421 macro->var_args = 0;
1423 macro->expansion = (cpp_token *) POOL_FRONT (&pfile->macro_pool);
1425 /* Get the first token of the expansion (or the '(' of a
1426 function-like macro). */
1427 token = lex_expansion_token (pfile, macro);
1428 if (token->type == CPP_OPEN_PAREN && !(token->flags & PREV_WHITE))
1430 if (!(ok = parse_params (pfile, macro)))
1433 macro->fun_like = 1;
1434 /* Some of the pool may have been used for the parameter store. */
1435 macro->expansion = (cpp_token *) POOL_FRONT (&pfile->macro_pool);
1436 token = lex_expansion_token (pfile, macro);
1438 else if (token->type != CPP_EOF && !(token->flags & PREV_WHITE))
1439 cpp_pedwarn (pfile, "ISO C requires whitespace after the macro name");
1441 /* Setting it here means we don't catch leading comments. */
1442 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
1446 /* Check the stringifying # constraint 6.10.3.2.1 of
1447 function-like macros when lexing the subsequent token. */
1448 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1450 if (token->type == CPP_MACRO_ARG)
1452 token->flags &= ~PREV_WHITE;
1453 token->flags |= STRINGIFY_ARG;
1454 token->flags |= token[-1].flags & PREV_WHITE;
1455 token[-1] = token[0];
1458 /* Let assembler get away with murder. */
1459 else if (!CPP_OPTION (pfile, lang_asm))
1462 cpp_error (pfile, "'#' is not followed by a macro parameter");
1467 if (token->type == CPP_EOF)
1470 /* Paste operator constraint 6.10.3.3.1. */
1471 if (token->type == CPP_PASTE)
1473 /* Token-paste ##, can appear in both object-like and
1474 function-like macros, but not at the ends. */
1475 if (--macro->count > 0)
1476 token = lex_expansion_token (pfile, macro);
1478 if (macro->count == 0 || token->type == CPP_EOF)
1482 "'##' cannot appear at either end of a macro expansion");
1486 token[-1].flags |= PASTE_LEFT;
1487 /* Give it a PREV_WHITE for -dM etc. */
1488 token->flags |= PREV_WHITE;
1491 token = lex_expansion_token (pfile, macro);
1494 /* Don't count the CPP_EOF. Empty macros become a place marker. */
1495 if (macro->count > 1)
1498 macro->expansion[0].type = CPP_PLACEMARKER;
1500 /* Clear the whitespace flag from the leading token. */
1501 macro->expansion[0].flags &= ~PREV_WHITE;
1503 /* Implement the macro-defined-to-itself optimisation. */
1504 macro->disabled = (macro->count == 1 && !macro->fun_like
1505 && macro->expansion[0].type == CPP_NAME
1506 && macro->expansion[0].val.node == node);
1508 /* Commit the memory. */
1509 POOL_COMMIT (&pfile->macro_pool, macro->count * sizeof (cpp_token));
1511 /* Redefinition of a macro is allowed if and only if the old and new
1512 definitions are the same. (6.10.3 paragraph 2). */
1513 if (node->type != NT_VOID)
1515 if (CPP_PEDANTIC (pfile)
1516 && !check_macro_redefinition (pfile, node, macro))
1518 cpp_pedwarn_with_line (pfile, pfile->directive_pos.line,
1519 pfile->directive_pos.col,
1520 "\"%s\" redefined", node->name);
1522 if (pfile->done_initializing && node->type == NT_MACRO
1523 && !(node->flags & NODE_BUILTIN))
1524 cpp_pedwarn_with_file_and_line (pfile,
1525 node->value.macro->file,
1526 node->value.macro->line, 1,
1527 "this is the location of the previous definition");
1529 _cpp_free_definition (node);
1532 /* Enter definition in hash table. */
1533 node->type = NT_MACRO;
1534 node->value.macro = macro;
1538 /* Stop the lexer accepting __VA_ARGS__. */
1539 pfile->state.va_args_ok = 0;
1541 /* Clear the fast argument lookup indices. */
1542 for (i = macro->paramc; i-- > 0; )
1543 macro->params[i]->arg_index = 0;
1548 /* Warn if a token in `string' matches one of the function macro
1549 arguments in `info'. This function assumes that the macro is a
1550 function macro and not an object macro. */
1552 check_trad_stringification (pfile, macro, string)
1554 const cpp_macro *macro;
1555 const cpp_string *string;
1557 unsigned int i, len;
1558 const U_CHAR *p, *q, *limit = string->text + string->len;
1560 /* Loop over the string. */
1561 for (p = string->text; p < limit; p = q)
1563 /* Find the start of an identifier. */
1564 while (p < limit && !is_idstart (*p))
1567 /* Find the end of the identifier. */
1569 while (q < limit && is_idchar (*q))
1574 /* Loop over the function macro arguments to see if the
1575 identifier inside the string matches one of them. */
1576 for (i = 0; i < macro->paramc; i++)
1578 const cpp_hashnode *node = macro->params[i];
1580 if (node->length == len && !memcmp (p, node->name, len))
1583 "macro argument \"%s\" would be stringified with -traditional.",
1591 /* Returns the expansion of a macro, in a format suitable to be read
1592 back in again, and therefore also for DWARF 2 debugging info.
1593 Caller is expected to generate the "#define NAME" bit. The
1594 returned text is temporary, and automatically freed later. */
1596 const unsigned char *
1597 cpp_macro_definition (pfile, node)
1599 const cpp_hashnode *node;
1601 unsigned int i, len;
1602 const cpp_macro *macro = node->value.macro;
1603 unsigned char *buffer;
1605 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1607 cpp_ice (pfile, "invalid hash type %d in dump_definition", node->type);
1611 /* Calculate length. */
1613 if (macro->fun_like)
1615 len += 3; /* "()" plus possible final "." of ellipsis. */
1616 for (i = 0; i < macro->paramc; i++)
1617 len += macro->params[i]->length + 2; /* ", " */
1620 if (macro->count > 1 || macro->expansion[0].type != CPP_PLACEMARKER)
1622 for (i = 0; i < macro->count; i++)
1624 cpp_token *token = ¯o->expansion[i];
1626 if (token->type == CPP_MACRO_ARG)
1627 len += macro->params[token->val.arg_no - 1]->length;
1629 len += cpp_token_len (token); /* Includes room for ' '. */
1630 if (token->flags & STRINGIFY_ARG)
1632 if (token->flags & PASTE_LEFT)
1633 len += 3; /* " ##" */
1637 if (len > pfile->macro_buffer_len)
1638 pfile->macro_buffer = (U_CHAR *) xrealloc (pfile->macro_buffer, len);
1639 buffer = pfile->macro_buffer;
1641 /* Parameter names. */
1642 if (macro->fun_like)
1645 for (i = 0; i < macro->paramc; i++)
1647 cpp_hashnode *param = macro->params[i];
1649 if (param != pfile->spec_nodes.n__VA_ARGS__)
1651 memcpy (buffer, param->name, param->length);
1652 buffer += param->length;
1655 if (i + 1 < macro->paramc)
1656 *buffer++ = ',', *buffer++ = ' ';
1657 else if (macro->var_args)
1658 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1663 /* Expansion tokens. */
1664 if (macro->count > 1 || macro->expansion[0].type != CPP_PLACEMARKER)
1667 for (i = 0; i < macro->count; i++)
1669 cpp_token *token = ¯o->expansion[i];
1671 if (token->flags & PREV_WHITE)
1673 if (token->flags & STRINGIFY_ARG)
1676 if (token->type == CPP_MACRO_ARG)
1678 len = macro->params[token->val.arg_no - 1]->length;
1679 memcpy (buffer, macro->params[token->val.arg_no - 1]->name, len);
1683 buffer = cpp_spell_token (pfile, token, buffer);
1685 if (token->flags & PASTE_LEFT)
1690 /* Next has PREV_WHITE; see _cpp_create_definition. */
1696 return pfile->macro_buffer;