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 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. */
34 cpp_hashnode **params; /* Parameters, if any. */
35 cpp_token *expansion; /* First token of replacement list. */
36 unsigned int line; /* Starting line number. */
37 unsigned int count; /* Number of tokens in expansion. */
38 unsigned short paramc; /* Number of parameters. */
39 unsigned int fun_like : 1; /* If a function-like macro. */
40 unsigned int variadic : 1; /* If a variadic macro. */
41 unsigned int disabled : 1; /* If macro is disabled. */
42 unsigned int syshdr : 1; /* If macro defined in system header. */
45 typedef struct macro_arg macro_arg;
48 cpp_token *first; /* First token in unexpanded argument. */
49 cpp_token *expanded; /* Macro-expanded argument. */
50 cpp_token *stringified; /* Stringified argument. */
51 unsigned int count; /* # of tokens in argument. */
52 unsigned int expanded_count; /* # of tokens in expanded argument. */
55 /* Macro expansion. */
57 static void lock_pools PARAMS ((cpp_reader *));
58 static void unlock_pools PARAMS ((cpp_reader *));
59 static int enter_macro_context PARAMS ((cpp_reader *, cpp_hashnode *));
60 static void builtin_macro PARAMS ((cpp_reader *, cpp_token *));
61 static cpp_context *push_arg_context PARAMS ((cpp_reader *, macro_arg *));
62 static enum cpp_ttype parse_arg PARAMS ((cpp_reader *, macro_arg *, int));
63 static macro_arg *parse_args PARAMS ((cpp_reader *, const cpp_hashnode *));
64 static cpp_context *next_context PARAMS ((cpp_reader *));
65 static void expand_arg PARAMS ((cpp_reader *, macro_arg *));
66 static unsigned char *quote_string PARAMS ((unsigned char *,
67 const unsigned char *,
69 static void make_string_token PARAMS ((cpp_pool *, cpp_token *,
70 const U_CHAR *, unsigned int));
71 static void make_number_token PARAMS ((cpp_reader *, cpp_token *, int));
72 static void stringify_arg PARAMS ((cpp_reader *, macro_arg *));
73 static void paste_all_tokens PARAMS ((cpp_reader *, cpp_token *));
74 static int paste_tokens PARAMS ((cpp_reader *, cpp_token *, cpp_token *));
75 static int funlike_invocation_p PARAMS ((cpp_reader *, const cpp_hashnode *,
77 static void replace_args PARAMS ((cpp_reader *, cpp_macro *, macro_arg *,
82 static void save_lookahead_token PARAMS ((cpp_reader *, const cpp_token *));
83 static void take_lookahead_token PARAMS ((cpp_reader *, cpp_token *));
84 static cpp_lookahead *alloc_lookahead PARAMS ((cpp_reader *));
85 static void free_lookahead PARAMS ((cpp_lookahead *));
87 /* #define directive parsing and handling. */
89 static cpp_token *lex_expansion_token PARAMS ((cpp_reader *, cpp_macro *));
90 static int warn_of_redefinition PARAMS ((cpp_reader *, const cpp_hashnode *,
92 static int save_parameter PARAMS ((cpp_reader *, cpp_macro *, cpp_hashnode *));
93 static int parse_params PARAMS ((cpp_reader *, cpp_macro *));
94 static void check_trad_stringification PARAMS ((cpp_reader *,
98 /* Allocates a buffer to hold a token's TEXT, and converts TOKEN to a
99 CPP_STRING token containing TEXT in quoted form. */
101 make_string_token (pool, token, text, len)
107 U_CHAR *buf = _cpp_pool_alloc (pool, len * 4 + 1);
109 token->type = CPP_STRING;
110 token->val.str.text = buf;
111 token->val.str.len = quote_string (buf, text, len) - buf;
112 buf[token->val.str.len] = '\0';
116 /* Allocates and converts a temporary token to a CPP_NUMBER token,
117 evaluating to NUMBER. */
119 make_number_token (pfile, token, number)
124 unsigned char *buf = _cpp_pool_alloc (&pfile->ident_pool, 20);
126 sprintf ((char *) buf, "%d", number);
127 token->type = CPP_NUMBER;
128 token->val.str.text = buf;
129 token->val.str.len = ustrlen (buf);
133 static const char * const monthnames[] =
135 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
136 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
139 /* Handle builtin macros like __FILE__. */
141 builtin_macro (pfile, token)
145 unsigned char flags = ((token->flags & PREV_WHITE) | AVOID_LPASTE);
146 cpp_hashnode *node = token->val.node;
148 switch (node->value.builtin)
154 const struct line_map *map = pfile->map;
156 if (node->value.builtin == BT_BASE_FILE)
157 while (! MAIN_FILE_P (map))
158 map = INCLUDED_FROM (&pfile->line_maps, map);
161 make_string_token (&pfile->ident_pool, token,
162 (const unsigned char *) name, strlen (name));
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 make_number_token (pfile, token, 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 make_number_token (pfile, token,
178 SOURCE_LINE (pfile->map, cpp_get_line (pfile)->line));
183 int stdc = (!CPP_IN_SYSTEM_HEADER (pfile)
184 || pfile->spec_nodes.n__STRICT_ANSI__->type != NT_VOID);
185 make_number_token (pfile, token, stdc);
191 if (pfile->date.type == CPP_EOF)
193 /* Allocate __DATE__ and __TIME__ from permanent storage,
194 and save them in pfile so we don't have to do this again.
195 We don't generate these strings at init time because
196 time() and localtime() are very slow on some systems. */
197 time_t tt = time (NULL);
198 struct tm *tb = localtime (&tt);
200 make_string_token (&pfile->ident_pool, &pfile->date,
202 make_string_token (&pfile->ident_pool, &pfile->time,
205 sprintf ((char *) pfile->date.val.str.text, "%s %2d %4d",
206 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
207 sprintf ((char *) pfile->time.val.str.text, "%02d:%02d:%02d",
208 tb->tm_hour, tb->tm_min, tb->tm_sec);
210 *token = node->value.builtin == BT_DATE ? pfile->date: pfile->time;
214 cpp_ice (pfile, "invalid builtin macro \"%s\"", NODE_NAME (node));
218 token->flags = flags;
221 /* Used by cpperror.c to obtain the correct line and column to report
223 const cpp_lexer_pos *
227 return &pfile->lexer_pos;
234 _cpp_lock_pool (&pfile->argument_pool);
241 _cpp_unlock_pool (&pfile->argument_pool);
244 /* Adds backslashes before all backslashes and double quotes appearing
245 in strings. Non-printable characters are converted to octal. */
247 quote_string (dest, src, len)
256 if (c == '\\' || c == '"')
267 sprintf ((char *) dest, "\\%03o", c);
276 /* Convert a token sequence to a single string token according to the
277 rules of the ISO C #-operator. */
279 stringify_arg (pfile, arg)
283 cpp_pool *pool = &pfile->ident_pool;
284 unsigned char *start = POOL_FRONT (pool);
285 unsigned int i, escape_it, total_len = 0, backslash_count = 0;
287 /* Loop, reading in the argument's tokens. */
288 for (i = 0; i < arg->count; i++)
291 const cpp_token *token = &arg->first[i];
292 unsigned int len = cpp_token_len (token);
294 escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
295 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
298 /* Worst case is each char is octal. */
300 len += 2; /* Room for initial space and final NUL. */
302 dest = &start[total_len];
303 if (dest + len > POOL_LIMIT (pool))
305 _cpp_next_chunk (pool, len, (unsigned char **) &start);
306 dest = &start[total_len];
309 /* No leading white space. */
310 if (token->flags & PREV_WHITE && total_len > 0)
315 unsigned char *buf = (unsigned char *) xmalloc (len);
317 len = cpp_spell_token (pfile, token, buf) - buf;
318 dest = quote_string (dest, buf, len);
322 dest = cpp_spell_token (pfile, token, dest);
323 total_len = dest - start;
325 if (token->type == CPP_OTHER && token->val.c == '\\')
331 /* Ignore the final \ of invalid string literals. */
332 if (backslash_count & 1)
334 cpp_warning (pfile, "invalid string literal, ignoring final '\\'");
338 /* Null terminate, and commit the memory. */
339 start[total_len] = '\0';
340 POOL_COMMIT (pool, total_len + 1);
342 arg->stringified = xnew (cpp_token);
343 arg->stringified->flags = 0;
344 arg->stringified->type = CPP_STRING;
345 arg->stringified->val.str.text = start;
346 arg->stringified->val.str.len = total_len;
349 /* Try to paste two tokens. On success, the LHS becomes the pasted
350 token, and 0 is returned. For failure, we update the flags of the
351 RHS appropriately and return non-zero. */
353 paste_tokens (pfile, lhs, rhs)
355 cpp_token *lhs, *rhs;
361 type = cpp_can_paste (pfile, lhs, rhs, &digraph);
365 /* Mandatory warning for all apart from assembler. */
366 if (CPP_OPTION (pfile, lang) != CLK_ASM)
368 "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
369 cpp_token_as_text (pfile, lhs),
370 cpp_token_as_text (pfile, rhs));
372 /* The standard states that behaviour is undefined. By the
373 principle of least surpise, we step back before the RHS, and
374 mark it to prevent macro expansion. Tests in the testsuite
375 rely on clearing PREV_WHITE here, though you could argue we
376 should actually set it. Assembler can have '.' in labels and
377 so requires that we don't insert spaces there. Maybe we should
378 change this to put out a space unless it's assembler. */
379 rhs->flags &= ~PREV_WHITE;
380 rhs->flags |= NO_EXPAND;
384 flags = lhs->flags & ~DIGRAPH;
388 /* Identifiers and numbers need spellings to be pasted. */
389 if (type == CPP_NAME || type == CPP_NUMBER)
391 unsigned int total_len = cpp_token_len (lhs) + cpp_token_len (rhs);
392 unsigned char *result, *end;
394 result = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
396 /* Paste the spellings and null terminate. */
397 end = cpp_spell_token (pfile, rhs, cpp_spell_token (pfile, lhs, result));
399 total_len = end - result;
401 if (type == CPP_NAME)
403 lhs->val.node = cpp_lookup (pfile, result, total_len);
404 if (lhs->val.node->flags & NODE_OPERATOR)
407 lhs->type = lhs->val.node->value.operator;
412 lhs->val.str.text = result;
413 lhs->val.str.len = total_len;
416 else if (type == CPP_WCHAR || type == CPP_WSTRING)
417 lhs->val.str = rhs->val.str;
419 /* Set type and flags after pasting spellings. */
426 /* Handles an arbitrarily long sequence of ## operators. This
427 implementation is left-associative, non-recursive, and finishes a
428 paste before handling succeeding ones. If the paste fails, we back
429 up a token to just after the ## operator, with the effect that it
430 appears in the output stream normally. */
432 paste_all_tokens (pfile, lhs)
437 unsigned char orig_flags = lhs->flags;
441 /* Take the token directly from the current context. We can do
442 this, because we are in the replacement list of either an
443 object-like macro, or a function-like macro with arguments
444 inserted. In either case, the constraints to #define
445 guarantee we have at least one more token. */
446 rhs = pfile->context->list.first++;
447 if (paste_tokens (pfile, lhs, rhs))
449 /* We failed. Step back so we read the RHS in next. */
450 pfile->context->list.first--;
454 while (rhs->flags & PASTE_LEFT);
456 /* The pasted token has the PREV_WHITE flag of the LHS, is no longer
457 PASTE_LEFT, and is subject to macro expansion. */
458 lhs->flags &= ~(PREV_WHITE | PASTE_LEFT | NO_EXPAND);
459 lhs->flags |= orig_flags & (PREV_WHITE | AVOID_LPASTE);
462 /* Reads the unexpanded tokens of a macro argument into ARG. VAR_ARGS
463 is non-zero if this is a variadic macro. Returns the type of the
464 token that caused reading to finish. */
465 static enum cpp_ttype
466 parse_arg (pfile, arg, variadic)
468 struct macro_arg *arg;
471 enum cpp_ttype result;
472 unsigned int paren = 0;
475 arg->first = (cpp_token *) POOL_FRONT (&pfile->argument_pool);
476 for (;; arg->count++)
478 cpp_token *token = &arg->first[arg->count];
479 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->argument_pool))
481 _cpp_next_chunk (&pfile->argument_pool, sizeof (cpp_token),
482 (unsigned char **) &arg->first);
483 token = &arg->first[arg->count];
486 /* Newlines in arguments are white space (6.10.3.10). */
488 cpp_get_token (pfile, token);
489 if (line != pfile->line)
490 token->flags |= PREV_WHITE;
492 result = token->type;
493 if (result == CPP_OPEN_PAREN)
495 else if (result == CPP_CLOSE_PAREN && paren-- == 0)
497 /* Commas are not terminators within parantheses or variadic. */
498 else if (result == CPP_COMMA && paren == 0 && !variadic)
500 else if (result == CPP_EOF)
501 break; /* Error reported by caller. */
504 /* Commit the memory used to store the arguments. */
505 POOL_COMMIT (&pfile->argument_pool, arg->count * sizeof (cpp_token));
510 /* Parse the arguments making up a macro invocation. */
512 parse_args (pfile, node)
514 const cpp_hashnode *node;
516 cpp_macro *macro = node->value.macro;
517 macro_arg *args, *cur;
521 /* Allocate room for at least one argument, and zero it out. */
522 argc = macro->paramc ? macro->paramc: 1;
523 args = xcnewvec (macro_arg, argc);
525 for (cur = args, argc = 0; ;)
529 type = parse_arg (pfile, cur, argc == macro->paramc && macro->variadic);
530 if (type == CPP_CLOSE_PAREN || type == CPP_EOF)
533 /* Re-use the last argument for excess arguments. */
534 if (argc < macro->paramc)
540 cpp_error (pfile, "unterminated argument list invoking macro \"%s\"",
544 else if (argc < macro->paramc)
546 /* As an extension, a rest argument is allowed to not appear in
547 the invocation at all.
548 e.g. #define debug(format, args...) something
551 This is exactly the same as if there had been an empty rest
552 argument - debug("string", ). */
554 if (argc + 1 == macro->paramc && macro->variadic)
556 if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
557 cpp_pedwarn (pfile, "ISO C99 requires rest arguments to be used");
562 "macro \"%s\" requires %u arguments, but only %u given",
563 NODE_NAME (node), macro->paramc, argc);
567 else if (argc > macro->paramc)
569 /* Empty argument to a macro taking no arguments is OK. */
570 if (argc != 1 || cur->count)
573 "macro \"%s\" passed %u arguments, but takes just %u",
574 NODE_NAME (node), argc, macro->paramc);
589 funlike_invocation_p (pfile, node, list)
591 const cpp_hashnode *node;
592 struct toklist *list;
594 cpp_token maybe_paren;
596 cpp_lexer_pos macro_pos;
598 macro_pos = pfile->lexer_pos;
599 pfile->state.parsing_args = 1;
600 pfile->state.prevent_expansion++;
602 pfile->keep_tokens++;
603 cpp_start_lookahead (pfile);
604 cpp_get_token (pfile, &maybe_paren);
605 cpp_stop_lookahead (pfile, maybe_paren.type == CPP_OPEN_PAREN);
606 pfile->state.parsing_args = 2;
608 if (maybe_paren.type == CPP_OPEN_PAREN)
609 args = parse_args (pfile, node);
610 else if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
612 "function-like macro \"%s\" must be used with arguments in traditional C",
615 pfile->state.prevent_expansion--;
616 pfile->state.parsing_args = 0;
617 pfile->keep_tokens--;
619 /* Reset the position in case of failure. If success, the macro's
620 expansion appears where the name would have. */
621 pfile->lexer_pos = macro_pos;
625 if (node->value.macro->paramc > 0)
627 /* Don't save tokens during pre-expansion. */
628 struct cpp_lookahead *la_saved = pfile->la_write;
630 replace_args (pfile, node->value.macro, args, list);
631 pfile->la_write = la_saved;
639 /* Push the context of a macro onto the context stack. TOKEN is the
640 macro name. If we can successfully start expanding the macro,
641 TOKEN is replaced with the first token of the expansion, and we
644 enter_macro_context (pfile, node)
648 cpp_context *context;
649 cpp_macro *macro = node->value.macro;
652 /* Save the position of the outermost macro invocation. */
653 if (!pfile->context->prev)
656 if (macro->fun_like && !funlike_invocation_p (pfile, node, &list))
658 if (!pfile->context->prev)
659 unlock_pools (pfile);
663 if (macro->paramc == 0)
665 list.first = macro->expansion;
666 list.limit = macro->expansion + macro->count;
669 context = next_context (pfile);
670 context->list = list;
671 context->macro = macro;
673 /* Disable the macro within its expansion. */
679 /* Move to the next context. Create one if there is none. */
684 cpp_context *prev = pfile->context;
685 cpp_context *result = prev->next;
689 result = xnew (cpp_context);
695 pfile->context = result;
700 replace_args (pfile, macro, args, list)
704 struct toklist *list;
706 unsigned char flags = 0;
707 unsigned int i, total;
708 const cpp_token *src, *limit;
712 src = macro->expansion;
713 limit = src + macro->count;
715 /* First, fully macro-expand arguments, calculating the number of
716 tokens in the final expansion as we go. This ensures that the
717 possible recursive use of argument_pool is fine. */
719 for (; src < limit; src++)
720 if (src->type == CPP_MACRO_ARG)
722 /* We have an argument. If it is not being stringified or
723 pasted it is macro-replaced before insertion. */
724 arg = &args[src->val.arg_no - 1];
726 if (src->flags & STRINGIFY_ARG)
728 if (!arg->stringified)
729 stringify_arg (pfile, arg);
731 else if ((src->flags & PASTE_LEFT)
732 || (src > macro->expansion && (src[-1].flags & PASTE_LEFT)))
733 total += arg->count - 1;
738 arg->expanded_count = 0;
740 expand_arg (pfile, arg);
742 total += arg->expanded_count - 1;
746 dest = (cpp_token *) _cpp_pool_alloc (&pfile->argument_pool,
747 total * sizeof (cpp_token));
750 for (src = macro->expansion; src < limit; src++)
751 if (src->type == CPP_MACRO_ARG)
754 const cpp_token *from;
756 arg = &args[src->val.arg_no - 1];
757 if (src->flags & STRINGIFY_ARG)
759 from = arg->stringified, count = 1;
760 /* Ugh. Maintain position of original argument. */
761 arg->stringified->line = src->line;
762 arg->stringified->col = src->col;
764 else if (src->flags & PASTE_LEFT)
765 count = arg->count, from = arg->first;
766 else if (src > macro->expansion && (src[-1].flags & PASTE_LEFT))
768 count = arg->count, from = arg->first;
769 if (dest != list->first)
771 /* GCC has special semantics for , ## b where b is a
772 varargs parameter: the comma disappears if b was
773 given no actual arguments (not merely if b is an
774 empty argument); otherwise pasting is turned off. */
775 if (dest[-1].type == CPP_COMMA
777 && src->val.arg_no == macro->paramc)
782 dest[-1].flags &= ~PASTE_LEFT;
784 /* Count == 0 is the RHS a placemarker case. */
786 dest[-1].flags &= ~PASTE_LEFT;
790 count = arg->expanded_count, from = arg->expanded;
792 /* Count == 0 is the LHS a placemarker case. */
795 memcpy (dest, from, count * sizeof (cpp_token));
797 /* The first token gets PREV_WHITE of the CPP_MACRO_ARG. */
798 dest->flags &= ~PREV_WHITE;
799 dest->flags |= src->flags & PREV_WHITE;
800 dest->flags |= AVOID_LPASTE;
802 /* The last token gets the PASTE_LEFT of the CPP_MACRO_ARG. */
803 dest[count - 1].flags |= src->flags & PASTE_LEFT;
808 /* The token after the argument must avoid an accidental paste. */
809 flags = AVOID_LPASTE;
814 dest->flags |= flags;
821 /* Free the expanded arguments. */
822 for (i = 0; i < macro->paramc; i++)
824 if (args[i].expanded)
825 free (args[i].expanded);
826 if (args[i].stringified)
827 free (args[i].stringified);
831 /* Subroutine of expand_arg to put the unexpanded tokens on the
834 push_arg_context (pfile, arg)
838 cpp_context *context = next_context (pfile);
840 context->list.first = arg->first;
841 context->list.limit = arg->first + arg->count;
847 expand_arg (pfile, arg)
852 unsigned int capacity = 256;
854 /* Loop, reading in the arguments. */
855 arg->expanded = (cpp_token *) xmalloc (capacity * sizeof (cpp_token));
857 push_arg_context (pfile, arg);
860 if (arg->expanded_count >= capacity)
863 arg->expanded = (cpp_token *)
864 xrealloc (arg->expanded, capacity * sizeof (cpp_token));
866 token = &arg->expanded[arg->expanded_count++];
867 cpp_get_token (pfile, token);
869 while (token->type != CPP_EOF);
871 arg->expanded_count--;
873 /* Pop the context we pushed. */
874 pfile->context = pfile->context->prev;
878 _cpp_pop_context (pfile)
881 cpp_context *context = pfile->context;
883 pfile->context = context->prev;
884 if (!pfile->context->prev && !pfile->state.parsing_args)
885 unlock_pools (pfile);
887 /* Re-enable a macro when leaving its expansion. */
888 context->macro->disabled = 0;
891 /* Eternal routine to get a token. Also used nearly everywhere
892 internally, except for places where we know we can safely call
893 the lexer directly, such as lexing a directive name.
895 Macro expansions and directives are transparently handled,
896 including entering included files. Thus tokens are post-macro
897 expansion, and after any intervening directives. External callers
898 see CPP_EOF only at EOF. Internal callers also see it when meeting
899 a directive inside a macro call, when at the end of a directive and
900 state.in_directive is still 1, and at the end of argument
903 cpp_get_token (pfile, token)
909 cpp_context *context = pfile->context;
912 take_lookahead_token (pfile, token);
913 /* Context->prev == 0 <=> base context. */
914 else if (!context->prev)
915 _cpp_lex_token (pfile, token);
916 else if (context->list.first != context->list.limit)
918 *token = *context->list.first++;
919 token->flags |= pfile->buffer->saved_flags;
920 pfile->buffer->saved_flags = 0;
921 /* PASTE_LEFT tokens can only appear in macro expansions. */
922 if (token->flags & PASTE_LEFT)
924 /* Maintains position of original token. */
925 paste_all_tokens (pfile, token);
926 pfile->buffer->saved_flags = AVOID_LPASTE;
933 /* Avoid accidental paste at the end of a macro. */
934 pfile->buffer->saved_flags |= AVOID_LPASTE;
935 _cpp_pop_context (pfile);
938 /* End of argument pre-expansion. */
939 token->type = CPP_EOF;
944 if (token->type != CPP_NAME)
947 /* Handle macros and the _Pragma operator. */
948 if (token->val.node->type == NT_MACRO
949 && !pfile->state.prevent_expansion
950 && !(token->flags & NO_EXPAND))
952 cpp_hashnode *node = token->val.node;
954 /* Macros invalidate controlling macros. */
955 pfile->mi_valid = false;
957 if (node->flags & NODE_BUILTIN)
959 /* Maintains position of original token. */
960 builtin_macro (pfile, token);
961 pfile->buffer->saved_flags = AVOID_LPASTE;
965 if (node->value.macro->disabled)
966 token->flags |= NO_EXPAND;
967 else if (enter_macro_context (pfile, node))
969 /* Pass AVOID_LPASTE and our PREV_WHITE to next token. */
970 pfile->buffer->saved_flags = ((token->flags & PREV_WHITE)
976 /* Don't interpret _Pragma within directives. The standard is
977 not clear on this, but to me this makes most sense. */
978 if (token->val.node != pfile->spec_nodes.n__Pragma
979 || pfile->state.in_directive)
982 /* Handle it, and loop back for another token. MI is cleared
983 since this token came from either the lexer or a macro. */
984 _cpp_do__Pragma (pfile);
988 save_lookahead_token (pfile, token);
991 /* Returns true if we're expanding an object-like macro that was
992 defined in a system header. Just checks the macro at the top of
993 the stack. Used for diagnostic suppression. */
995 cpp_sys_macro_p (pfile)
998 cpp_macro *macro = pfile->context->macro;
1000 return macro && macro->syshdr;
1003 /* Read each token in, until EOF. Directives are transparently
1006 cpp_scan_nooutput (pfile)
1012 cpp_get_token (pfile, &token);
1013 while (token.type != CPP_EOF);
1016 /* Lookahead handling. */
1019 save_lookahead_token (pfile, token)
1021 const cpp_token *token;
1023 cpp_lookahead *la = pfile->la_write;
1024 cpp_token_with_pos *twp;
1026 if (la->count == la->cap)
1028 la->cap += la->cap + 8;
1029 la->tokens = (cpp_token_with_pos *)
1030 xrealloc (la->tokens, la->cap * sizeof (cpp_token_with_pos));
1033 twp = &la->tokens[la->count++];
1034 twp->token = *token;
1035 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 warning is required. */
1168 warn_of_redefinition (pfile, node, macro2)
1170 const cpp_hashnode *node;
1171 const cpp_macro *macro2;
1173 const cpp_macro *macro1;
1176 /* Some redefinitions need to be warned about regardless. */
1177 if (node->flags & NODE_WARN)
1180 if (! CPP_PEDANTIC (pfile))
1183 /* Redefinition of a macro is allowed if and only if the old and new
1184 definitions are the same. (6.10.3 paragraph 2). */
1185 macro1 = node->value.macro;
1187 /* The quick failures. */
1188 if (macro1->count != macro2->count
1189 || macro1->paramc != macro2->paramc
1190 || macro1->fun_like != macro2->fun_like
1191 || macro1->variadic != macro2->variadic)
1194 /* Check each token. */
1195 for (i = 0; i < macro1->count; i++)
1196 if (! _cpp_equiv_tokens (¯o1->expansion[i], ¯o2->expansion[i]))
1199 /* Check parameter spellings. */
1200 for (i = 0; i < macro1->paramc; i++)
1201 if (macro1->params[i] != macro2->params[i])
1207 /* Free the definition of hashnode H. */
1210 _cpp_free_definition (h)
1213 /* Macros and assertions no longer have anything to free. */
1215 /* Clear builtin flag in case of redefinition. */
1216 h->flags &= ~NODE_BUILTIN;
1220 save_parameter (pfile, macro, node)
1225 cpp_hashnode **dest;
1227 /* Constraint 6.10.3.6 - duplicate parameter names. */
1228 if (node->arg_index)
1230 cpp_error (pfile, "duplicate macro parameter \"%s\"", NODE_NAME (node));
1234 dest = ¯o->params[macro->paramc];
1236 /* Check we have room for the parameters. */
1237 if ((unsigned char *) (dest + 1) >= POOL_LIMIT (&pfile->macro_pool))
1239 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_hashnode *),
1240 (unsigned char **) ¯o->params);
1241 dest = ¯o->params[macro->paramc];
1245 node->arg_index = ++macro->paramc;
1250 parse_params (pfile, macro)
1255 unsigned int prev_ident = 0;
1257 macro->params = (cpp_hashnode **) POOL_FRONT (&pfile->macro_pool);
1260 _cpp_lex_token (pfile, &token);
1265 cpp_error (pfile, "\"%s\" may not appear in macro parameter list",
1266 cpp_token_as_text (pfile, &token));
1272 cpp_error (pfile, "macro parameters must be comma-separated");
1277 if (save_parameter (pfile, macro, token.val.node))
1281 case CPP_CLOSE_PAREN:
1282 if (prev_ident || macro->paramc == 0)
1285 /* Fall through to pick up the error. */
1289 cpp_error (pfile, "parameter name missing");
1296 macro->variadic = 1;
1299 save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1300 pfile->state.va_args_ok = 1;
1301 if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1303 "anonymous variadic macros were introduced in C99");
1305 else if (CPP_OPTION (pfile, pedantic))
1306 cpp_pedwarn (pfile, "ISO C does not permit named variadic macros");
1308 /* We're at the end, and just expect a closing parenthesis. */
1309 _cpp_lex_token (pfile, &token);
1310 if (token.type == CPP_CLOSE_PAREN)
1315 cpp_error (pfile, "missing ')' in macro parameter list");
1319 /* Success. Commit the parameter array. */
1320 POOL_COMMIT (&pfile->macro_pool,
1321 macro->paramc * sizeof (cpp_hashnode *));
1326 /* Lex a token from a macro's replacement list. Translate it to a
1327 CPP_MACRO_ARG if appropriate. */
1329 lex_expansion_token (pfile, macro)
1333 cpp_token *token = ¯o->expansion[macro->count];
1335 /* Check we have room for the token. */
1336 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1338 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1339 (unsigned char **) ¯o->expansion);
1340 token = ¯o->expansion[macro->count];
1344 _cpp_lex_token (pfile, token);
1346 /* Is this an argument? */
1347 if (token->type == CPP_NAME && token->val.node->arg_index)
1349 token->type = CPP_MACRO_ARG;
1350 token->val.arg_no = token->val.node->arg_index;
1352 else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1353 && (token->type == CPP_STRING || token->type == CPP_CHAR))
1354 check_trad_stringification (pfile, macro, &token->val.str);
1359 /* Parse a macro and save its expansion. Returns non-zero on success. */
1361 _cpp_create_definition (pfile, node)
1367 unsigned int i, ok = 1;
1369 macro = (cpp_macro *) _cpp_pool_alloc (&pfile->macro_pool,
1370 sizeof (cpp_macro));
1371 macro->line = pfile->directive_pos.line;
1374 macro->fun_like = 0;
1375 macro->variadic = 0;
1377 macro->expansion = (cpp_token *) POOL_FRONT (&pfile->macro_pool);
1379 /* Get the first token of the expansion (or the '(' of a
1380 function-like macro). */
1381 token = lex_expansion_token (pfile, macro);
1382 if (token->type == CPP_OPEN_PAREN && !(token->flags & PREV_WHITE))
1384 if (!(ok = parse_params (pfile, macro)))
1387 macro->fun_like = 1;
1388 /* Some of the pool may have been used for the parameter store. */
1389 macro->expansion = (cpp_token *) POOL_FRONT (&pfile->macro_pool);
1390 token = lex_expansion_token (pfile, macro);
1392 else if (token->type != CPP_EOF && !(token->flags & PREV_WHITE))
1393 cpp_pedwarn (pfile, "ISO C requires whitespace after the macro name");
1395 /* Setting it here means we don't catch leading comments. */
1396 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
1400 /* Check the stringifying # constraint 6.10.3.2.1 of
1401 function-like macros when lexing the subsequent token. */
1402 if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1404 if (token->type == CPP_MACRO_ARG)
1406 token->flags &= ~PREV_WHITE;
1407 token->flags |= STRINGIFY_ARG;
1408 token->flags |= token[-1].flags & PREV_WHITE;
1409 token[-1] = token[0];
1412 /* Let assembler get away with murder. */
1413 else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1416 cpp_error (pfile, "'#' is not followed by a macro parameter");
1421 if (token->type == CPP_EOF)
1424 /* Paste operator constraint 6.10.3.3.1. */
1425 if (token->type == CPP_PASTE)
1427 /* Token-paste ##, can appear in both object-like and
1428 function-like macros, but not at the ends. */
1429 if (--macro->count > 0)
1430 token = lex_expansion_token (pfile, macro);
1432 if (macro->count == 0 || token->type == CPP_EOF)
1436 "'##' cannot appear at either end of a macro expansion");
1440 token[-1].flags |= PASTE_LEFT;
1441 /* Give it a PREV_WHITE for -dM etc. */
1442 token->flags |= PREV_WHITE;
1445 token = lex_expansion_token (pfile, macro);
1448 /* Don't count the CPP_EOF. */
1451 /* Clear the whitespace flag from the leading token. */
1452 macro->expansion[0].flags &= ~PREV_WHITE;
1454 /* Implement the macro-defined-to-itself optimisation. */
1455 macro->disabled = (macro->count == 1 && !macro->fun_like
1456 && macro->expansion[0].type == CPP_NAME
1457 && macro->expansion[0].val.node == node);
1459 /* To suppress some diagnostics. */
1460 macro->syshdr = pfile->map->sysp != 0;
1462 /* Commit the memory. */
1463 POOL_COMMIT (&pfile->macro_pool, macro->count * sizeof (cpp_token));
1465 if (node->type != NT_VOID)
1467 if (warn_of_redefinition (pfile, node, macro))
1469 cpp_pedwarn_with_line (pfile, pfile->directive_pos.line,
1470 pfile->directive_pos.col,
1471 "\"%s\" redefined", NODE_NAME (node));
1473 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1474 cpp_pedwarn_with_line (pfile, node->value.macro->line, 1,
1475 "this is the location of the previous definition");
1477 _cpp_free_definition (node);
1480 /* Enter definition in hash table. */
1481 node->type = NT_MACRO;
1482 node->value.macro = macro;
1483 if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1484 node->flags |= NODE_WARN;
1488 /* Stop the lexer accepting __VA_ARGS__. */
1489 pfile->state.va_args_ok = 0;
1491 /* Clear the fast argument lookup indices. */
1492 for (i = macro->paramc; i-- > 0; )
1493 macro->params[i]->arg_index = 0;
1498 /* Warn if a token in `string' matches one of the function macro
1499 arguments in `info'. This function assumes that the macro is a
1500 function macro and not an object macro. */
1502 check_trad_stringification (pfile, macro, string)
1504 const cpp_macro *macro;
1505 const cpp_string *string;
1507 unsigned int i, len;
1508 const U_CHAR *p, *q, *limit = string->text + string->len;
1510 /* Loop over the string. */
1511 for (p = string->text; p < limit; p = q)
1513 /* Find the start of an identifier. */
1514 while (p < limit && !is_idstart (*p))
1517 /* Find the end of the identifier. */
1519 while (q < limit && is_idchar (*q))
1524 /* Loop over the function macro arguments to see if the
1525 identifier inside the string matches one of them. */
1526 for (i = 0; i < macro->paramc; i++)
1528 const cpp_hashnode *node = macro->params[i];
1530 if (NODE_LEN (node) == len
1531 && !memcmp (p, NODE_NAME (node), len))
1534 "macro argument \"%s\" would be stringified with -traditional.",
1542 /* Returns the name, arguments and expansion of a macro, in a format
1543 suitable to be read back in again, and therefore also for DWARF 2
1544 debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1545 Caller is expected to generate the "#define" bit if needed. The
1546 returned text is temporary, and automatically freed later. */
1548 const unsigned char *
1549 cpp_macro_definition (pfile, node)
1551 const cpp_hashnode *node;
1553 unsigned int i, len;
1554 const cpp_macro *macro = node->value.macro;
1555 unsigned char *buffer;
1557 if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1559 cpp_ice (pfile, "invalid hash type %d in cpp_macro_definition", node->type);
1563 /* Calculate length. */
1564 len = NODE_LEN (node) + 1; /* ' ' */
1565 if (macro->fun_like)
1567 len += 3; /* "()" plus possible final "." of named
1568 varargs (we have + 2 below). */
1569 for (i = 0; i < macro->paramc; i++)
1570 len += NODE_LEN (macro->params[i]) + 2; /* ", " */
1573 for (i = 0; i < macro->count; i++)
1575 cpp_token *token = ¯o->expansion[i];
1577 if (token->type == CPP_MACRO_ARG)
1578 len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1580 len += cpp_token_len (token); /* Includes room for ' '. */
1581 if (token->flags & STRINGIFY_ARG)
1583 if (token->flags & PASTE_LEFT)
1584 len += 3; /* " ##" */
1587 if (len > pfile->macro_buffer_len)
1589 pfile->macro_buffer = (U_CHAR *) xrealloc (pfile->macro_buffer, len);
1590 pfile->macro_buffer_len = len;
1593 /* Fill in the buffer. Start with the macro name. */
1594 buffer = pfile->macro_buffer;
1595 memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1596 buffer += NODE_LEN (node);
1598 /* Parameter names. */
1599 if (macro->fun_like)
1602 for (i = 0; i < macro->paramc; i++)
1604 cpp_hashnode *param = macro->params[i];
1606 if (param != pfile->spec_nodes.n__VA_ARGS__)
1608 memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1609 buffer += NODE_LEN (param);
1612 if (i + 1 < macro->paramc)
1613 *buffer++ = ',', *buffer++ = ' ';
1614 else if (macro->variadic)
1615 *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1620 /* Expansion tokens. */
1624 for (i = 0; i < macro->count; i++)
1626 cpp_token *token = ¯o->expansion[i];
1628 if (token->flags & PREV_WHITE)
1630 if (token->flags & STRINGIFY_ARG)
1633 if (token->type == CPP_MACRO_ARG)
1635 len = NODE_LEN (macro->params[token->val.arg_no - 1]);
1637 NODE_NAME (macro->params[token->val.arg_no - 1]), len);
1641 buffer = cpp_spell_token (pfile, token, buffer);
1643 if (token->flags & PASTE_LEFT)
1648 /* Next has PREV_WHITE; see _cpp_create_definition. */
1654 return pfile->macro_buffer;