OSDN Git Service

gcc/testsuite
[pf3gnuchains/gcc-fork.git] / libcpp / macro.c
1 /* Part of CPP library.  (Macro and #define handling.)
2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005,
4    2006, 2007 Free Software Foundation, Inc.
5    Written by Per Bothner, 1994.
6    Based on CCCP program by Paul Rubin, June 1986
7    Adapted to ANSI C, Richard Stallman, Jan 1987
8
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
12 later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22
23  In other words, you are welcome to use, share and improve this program.
24  You are forbidden to forbid anyone else to use, share and improve
25  what you give them.   Help stamp out software-hoarding!  */
26
27 #include "config.h"
28 #include "system.h"
29 #include "cpplib.h"
30 #include "internal.h"
31
32 typedef struct macro_arg macro_arg;
33 struct macro_arg
34 {
35   const cpp_token **first;      /* First token in unexpanded argument.  */
36   const cpp_token **expanded;   /* Macro-expanded argument.  */
37   const cpp_token *stringified; /* Stringified argument.  */
38   unsigned int count;           /* # of tokens in argument.  */
39   unsigned int expanded_count;  /* # of tokens in expanded argument.  */
40 };
41
42 /* Macro expansion.  */
43
44 static int enter_macro_context (cpp_reader *, cpp_hashnode *);
45 static int builtin_macro (cpp_reader *, cpp_hashnode *);
46 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
47                                  const cpp_token **, unsigned int);
48 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *);
49 static cpp_context *next_context (cpp_reader *);
50 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
51 static void expand_arg (cpp_reader *, macro_arg *);
52 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
53 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
54 static void paste_all_tokens (cpp_reader *, const cpp_token *);
55 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
56 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
57                           macro_arg *);
58 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *);
59 static bool create_iso_definition (cpp_reader *, cpp_macro *);
60
61 /* #define directive parsing and handling.  */
62
63 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
64 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
65 static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,
66                                   const cpp_macro *);
67 static bool parse_params (cpp_reader *, cpp_macro *);
68 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
69                                         const cpp_string *);
70
71 /* Emits a warning if NODE is a macro defined in the main file that
72    has not been used.  */
73 int
74 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
75                            void *v ATTRIBUTE_UNUSED)
76 {
77   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
78     {
79       cpp_macro *macro = node->value.macro;
80
81       if (!macro->used
82           && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
83         cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
84                              "macro \"%s\" is not used", NODE_NAME (node));
85     }
86
87   return 1;
88 }
89
90 /* Allocates and returns a CPP_STRING token, containing TEXT of length
91    LEN, after null-terminating it.  TEXT must be in permanent storage.  */
92 static const cpp_token *
93 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
94 {
95   cpp_token *token = _cpp_temp_token (pfile);
96
97   text[len] = '\0';
98   token->type = CPP_STRING;
99   token->val.str.len = len;
100   token->val.str.text = text;
101   token->flags = 0;
102   return token;
103 }
104
105 static const char * const monthnames[] =
106 {
107   "Jan", "Feb", "Mar", "Apr", "May", "Jun",
108   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
109 };
110
111 /* Helper function for builtin_macro.  Returns the text generated by
112    a builtin macro. */
113 const uchar *
114 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
115 {
116   const struct line_map *map;
117   const uchar *result = NULL;
118   unsigned int number = 1;
119
120   switch (node->value.builtin)
121     {
122     default:
123       cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
124                  NODE_NAME (node));
125       break;
126
127     case BT_TIMESTAMP:
128       {
129         cpp_buffer *pbuffer = cpp_get_buffer (pfile);
130         if (pbuffer->timestamp == NULL)
131           {
132             /* Initialize timestamp value of the assotiated file. */
133             struct _cpp_file *file = cpp_get_file (pbuffer);
134             if (file)
135               {
136                 /* Generate __TIMESTAMP__ string, that represents 
137                    the date and time of the last modification 
138                    of the current source file. The string constant 
139                    looks like "Sun Sep 16 01:03:52 1973".  */
140                 struct tm *tb = NULL;
141                 struct stat *st = _cpp_get_file_stat (file);
142                 if (st)
143                   tb = localtime (&st->st_mtime);
144                 if (tb)
145                   {
146                     char *str = asctime (tb);
147                     size_t len = strlen (str);
148                     unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
149                     buf[0] = '"';
150                     strcpy ((char *) buf + 1, str);
151                     buf[len] = '"';
152                     pbuffer->timestamp = buf;
153                   }
154                 else
155                   {
156                     cpp_errno (pfile, CPP_DL_WARNING,
157                         "could not determine file timestamp");
158                     pbuffer->timestamp = U"\"??? ??? ?? ??:??:?? ????\"";
159                   }
160               }
161           }
162         result = pbuffer->timestamp;
163       }
164       break;
165     case BT_FILE:
166     case BT_BASE_FILE:
167       {
168         unsigned int len;
169         const char *name;
170         uchar *buf;
171         map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
172
173         if (node->value.builtin == BT_BASE_FILE)
174           while (! MAIN_FILE_P (map))
175             map = INCLUDED_FROM (pfile->line_table, map);
176
177         name = map->to_file;
178         len = strlen (name);
179         buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
180         result = buf;
181         *buf = '"';
182         buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
183         *buf++ = '"';
184         *buf = '\0';
185       }
186       break;
187
188     case BT_INCLUDE_LEVEL:
189       /* The line map depth counts the primary source as level 1, but
190          historically __INCLUDE_DEPTH__ has called the primary source
191          level 0.  */
192       number = pfile->line_table->depth - 1;
193       break;
194
195     case BT_SPECLINE:
196       map = &pfile->line_table->maps[pfile->line_table->used-1];
197       /* If __LINE__ is embedded in a macro, it must expand to the
198          line of the macro's invocation, not its definition.
199          Otherwise things like assert() will not work properly.  */
200       if (CPP_OPTION (pfile, traditional))
201         number = pfile->line_table->highest_line;
202       else
203         number = pfile->cur_token[-1].src_loc;
204       number = SOURCE_LINE (map, number);
205       break;
206
207       /* __STDC__ has the value 1 under normal circumstances.
208          However, if (a) we are in a system header, (b) the option
209          stdc_0_in_system_headers is true (set by target config), and
210          (c) we are not in strictly conforming mode, then it has the
211          value 0.  (b) and (c) are already checked in cpp_init_builtins.  */
212     case BT_STDC:
213       if (cpp_in_system_header (pfile))
214         number = 0;
215       else
216         number = 1;
217       break;
218
219     case BT_DATE:
220     case BT_TIME:
221       if (pfile->date == NULL)
222         {
223           /* Allocate __DATE__ and __TIME__ strings from permanent
224              storage.  We only do this once, and don't generate them
225              at init time, because time() and localtime() are very
226              slow on some systems.  */
227           time_t tt;
228           struct tm *tb = NULL;
229
230           /* (time_t) -1 is a legitimate value for "number of seconds
231              since the Epoch", so we have to do a little dance to
232              distinguish that from a genuine error.  */
233           errno = 0;
234           tt = time(NULL);
235           if (tt != (time_t)-1 || errno == 0)
236             tb = localtime (&tt);
237
238           if (tb)
239             {
240               pfile->date = _cpp_unaligned_alloc (pfile,
241                                                   sizeof ("\"Oct 11 1347\""));
242               sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
243                        monthnames[tb->tm_mon], tb->tm_mday,
244                        tb->tm_year + 1900);
245
246               pfile->time = _cpp_unaligned_alloc (pfile,
247                                                   sizeof ("\"12:34:56\""));
248               sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
249                        tb->tm_hour, tb->tm_min, tb->tm_sec);
250             }
251           else
252             {
253               cpp_errno (pfile, CPP_DL_WARNING,
254                          "could not determine date and time");
255                 
256               pfile->date = U"\"??? ?? ????\"";
257               pfile->time = U"\"??:??:??\"";
258             }
259         }
260
261       if (node->value.builtin == BT_DATE)
262         result = pfile->date;
263       else
264         result = pfile->time;
265       break;
266
267     case BT_COUNTER:
268       if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
269         cpp_error (pfile, CPP_DL_ERROR,
270             "__COUNTER__ expanded inside directive with -fdirectives-only");
271       number = pfile->counter++;
272       break;
273     }
274
275   if (result == NULL)
276     {
277       /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers.  */
278       result = _cpp_unaligned_alloc (pfile, 21);
279       sprintf ((char *) result, "%u", number);
280     }
281
282   return result;      
283 }
284
285 /* Convert builtin macros like __FILE__ to a token and push it on the
286    context stack.  Also handles _Pragma, for which a new token may not
287    be created.  Returns 1 if it generates a new token context, 0 to
288    return the token to the caller.  */
289 static int
290 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
291 {
292   const uchar *buf;
293   size_t len;
294   char *nbuf;
295
296   if (node->value.builtin == BT_PRAGMA)
297     {
298       /* Don't interpret _Pragma within directives.  The standard is
299          not clear on this, but to me this makes most sense.  */
300       if (pfile->state.in_directive)
301         return 0;
302
303       return _cpp_do__Pragma (pfile);
304     }
305
306   buf = _cpp_builtin_macro_text (pfile, node);
307   len = ustrlen (buf);
308   nbuf = (char *) alloca (len + 1);
309   memcpy (nbuf, buf, len);
310   nbuf[len]='\n';
311
312   cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
313   _cpp_clean_line (pfile);
314
315   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
316   pfile->cur_token = _cpp_temp_token (pfile);
317   _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
318   if (pfile->buffer->cur != pfile->buffer->rlimit)
319     cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
320                NODE_NAME (node));
321   _cpp_pop_buffer (pfile);
322
323   return 1;
324 }
325
326 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
327    backslashes and double quotes. DEST must be of sufficient size.
328    Returns a pointer to the end of the string.  */
329 uchar *
330 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
331 {
332   while (len--)
333     {
334       uchar c = *src++;
335
336       if (c == '\\' || c == '"')
337         {
338           *dest++ = '\\';
339           *dest++ = c;
340         }
341       else
342           *dest++ = c;
343     }
344
345   return dest;
346 }
347
348 /* Convert a token sequence ARG to a single string token according to
349    the rules of the ISO C #-operator.  */
350 static const cpp_token *
351 stringify_arg (cpp_reader *pfile, macro_arg *arg)
352 {
353   unsigned char *dest;
354   unsigned int i, escape_it, backslash_count = 0;
355   const cpp_token *source = NULL;
356   size_t len;
357
358   if (BUFF_ROOM (pfile->u_buff) < 3)
359     _cpp_extend_buff (pfile, &pfile->u_buff, 3);
360   dest = BUFF_FRONT (pfile->u_buff);
361   *dest++ = '"';
362
363   /* Loop, reading in the argument's tokens.  */
364   for (i = 0; i < arg->count; i++)
365     {
366       const cpp_token *token = arg->first[i];
367
368       if (token->type == CPP_PADDING)
369         {
370           if (source == NULL)
371             source = token->val.source;
372           continue;
373         }
374
375       escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
376                    || token->type == CPP_CHAR || token->type == CPP_WCHAR);
377
378       /* Room for each char being written in octal, initial space and
379          final quote and NUL.  */
380       len = cpp_token_len (token);
381       if (escape_it)
382         len *= 4;
383       len += 3;
384
385       if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
386         {
387           size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
388           _cpp_extend_buff (pfile, &pfile->u_buff, len);
389           dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
390         }
391
392       /* Leading white space?  */
393       if (dest - 1 != BUFF_FRONT (pfile->u_buff))
394         {
395           if (source == NULL)
396             source = token;
397           if (source->flags & PREV_WHITE)
398             *dest++ = ' ';
399         }
400       source = NULL;
401
402       if (escape_it)
403         {
404           _cpp_buff *buff = _cpp_get_buff (pfile, len);
405           unsigned char *buf = BUFF_FRONT (buff);
406           len = cpp_spell_token (pfile, token, buf, true) - buf;
407           dest = cpp_quote_string (dest, buf, len);
408           _cpp_release_buff (pfile, buff);
409         }
410       else
411         dest = cpp_spell_token (pfile, token, dest, true);
412
413       if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
414         backslash_count++;
415       else
416         backslash_count = 0;
417     }
418
419   /* Ignore the final \ of invalid string literals.  */
420   if (backslash_count & 1)
421     {
422       cpp_error (pfile, CPP_DL_WARNING,
423                  "invalid string literal, ignoring final '\\'");
424       dest--;
425     }
426
427   /* Commit the memory, including NUL, and return the token.  */
428   *dest++ = '"';
429   len = dest - BUFF_FRONT (pfile->u_buff);
430   BUFF_FRONT (pfile->u_buff) = dest + 1;
431   return new_string_token (pfile, dest - len, len);
432 }
433
434 /* Try to paste two tokens.  On success, return nonzero.  In any
435    case, PLHS is updated to point to the pasted token, which is
436    guaranteed to not have the PASTE_LEFT flag set.  */
437 static bool
438 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
439 {
440   unsigned char *buf, *end, *lhsend;
441   cpp_token *lhs;
442   unsigned int len;
443
444   len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
445   buf = (unsigned char *) alloca (len);
446   end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
447
448   /* Avoid comment headers, since they are still processed in stage 3.
449      It is simpler to insert a space here, rather than modifying the
450      lexer to ignore comments in some circumstances.  Simply returning
451      false doesn't work, since we want to clear the PASTE_LEFT flag.  */
452   if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
453     *end++ = ' ';
454   end = cpp_spell_token (pfile, rhs, end, false);
455   *end = '\n';
456
457   cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
458   _cpp_clean_line (pfile);
459
460   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
461   pfile->cur_token = _cpp_temp_token (pfile);
462   lhs = _cpp_lex_direct (pfile);
463   if (pfile->buffer->cur != pfile->buffer->rlimit)
464     {
465       source_location saved_loc = lhs->src_loc;
466
467       _cpp_pop_buffer (pfile);
468       _cpp_backup_tokens (pfile, 1);
469       *lhsend = '\0';
470
471       /* We have to remove the PASTE_LEFT flag from the old lhs, but
472          we want to keep the new location.  */
473       *lhs = **plhs;
474       *plhs = lhs;
475       lhs->src_loc = saved_loc;
476       lhs->flags &= ~PASTE_LEFT;
477
478       /* Mandatory error for all apart from assembler.  */
479       if (CPP_OPTION (pfile, lang) != CLK_ASM)
480         cpp_error (pfile, CPP_DL_ERROR,
481          "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
482                    buf, cpp_token_as_text (pfile, rhs));
483       return false;
484     }
485
486   *plhs = lhs;
487   _cpp_pop_buffer (pfile);
488   return true;
489 }
490
491 /* Handles an arbitrarily long sequence of ## operators, with initial
492    operand LHS.  This implementation is left-associative,
493    non-recursive, and finishes a paste before handling succeeding
494    ones.  If a paste fails, we back up to the RHS of the failing ##
495    operator before pushing the context containing the result of prior
496    successful pastes, with the effect that the RHS appears in the
497    output stream after the pasted LHS normally.  */
498 static void
499 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
500 {
501   const cpp_token *rhs;
502   cpp_context *context = pfile->context;
503
504   do
505     {
506       /* Take the token directly from the current context.  We can do
507          this, because we are in the replacement list of either an
508          object-like macro, or a function-like macro with arguments
509          inserted.  In either case, the constraints to #define
510          guarantee we have at least one more token.  */
511       if (context->direct_p)
512         rhs = FIRST (context).token++;
513       else
514         rhs = *FIRST (context).ptoken++;
515
516       if (rhs->type == CPP_PADDING)
517         abort ();
518
519       if (!paste_tokens (pfile, &lhs, rhs))
520         break;
521     }
522   while (rhs->flags & PASTE_LEFT);
523
524   /* Put the resulting token in its own context.  */
525   _cpp_push_token_context (pfile, NULL, lhs, 1);
526 }
527
528 /* Returns TRUE if the number of arguments ARGC supplied in an
529    invocation of the MACRO referenced by NODE is valid.  An empty
530    invocation to a macro with no parameters should pass ARGC as zero.
531
532    Note that MACRO cannot necessarily be deduced from NODE, in case
533    NODE was redefined whilst collecting arguments.  */
534 bool
535 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
536 {
537   if (argc == macro->paramc)
538     return true;
539
540   if (argc < macro->paramc)
541     {
542       /* As an extension, a rest argument is allowed to not appear in
543          the invocation at all.
544          e.g. #define debug(format, args...) something
545          debug("string");
546
547          This is exactly the same as if there had been an empty rest
548          argument - debug("string", ).  */
549
550       if (argc + 1 == macro->paramc && macro->variadic)
551         {
552           if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
553             cpp_error (pfile, CPP_DL_PEDWARN,
554                        "ISO C99 requires rest arguments to be used");
555           return true;
556         }
557
558       cpp_error (pfile, CPP_DL_ERROR,
559                  "macro \"%s\" requires %u arguments, but only %u given",
560                  NODE_NAME (node), macro->paramc, argc);
561     }
562   else
563     cpp_error (pfile, CPP_DL_ERROR,
564                "macro \"%s\" passed %u arguments, but takes just %u",
565                NODE_NAME (node), argc, macro->paramc);
566
567   return false;
568 }
569
570 /* Reads and returns the arguments to a function-like macro
571    invocation.  Assumes the opening parenthesis has been processed.
572    If there is an error, emits an appropriate diagnostic and returns
573    NULL.  Each argument is terminated by a CPP_EOF token, for the
574    future benefit of expand_arg().  */
575 static _cpp_buff *
576 collect_args (cpp_reader *pfile, const cpp_hashnode *node)
577 {
578   _cpp_buff *buff, *base_buff;
579   cpp_macro *macro;
580   macro_arg *args, *arg;
581   const cpp_token *token;
582   unsigned int argc;
583
584   macro = node->value.macro;
585   if (macro->paramc)
586     argc = macro->paramc;
587   else
588     argc = 1;
589   buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
590                                        + sizeof (macro_arg)));
591   base_buff = buff;
592   args = (macro_arg *) buff->base;
593   memset (args, 0, argc * sizeof (macro_arg));
594   buff->cur = (unsigned char *) &args[argc];
595   arg = args, argc = 0;
596
597   /* Collect the tokens making up each argument.  We don't yet know
598      how many arguments have been supplied, whether too many or too
599      few.  Hence the slightly bizarre usage of "argc" and "arg".  */
600   do
601     {
602       unsigned int paren_depth = 0;
603       unsigned int ntokens = 0;
604
605       argc++;
606       arg->first = (const cpp_token **) buff->cur;
607
608       for (;;)
609         {
610           /* Require space for 2 new tokens (including a CPP_EOF).  */
611           if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
612             {
613               buff = _cpp_append_extend_buff (pfile, buff,
614                                               1000 * sizeof (cpp_token *));
615               arg->first = (const cpp_token **) buff->cur;
616             }
617
618           token = cpp_get_token (pfile);
619
620           if (token->type == CPP_PADDING)
621             {
622               /* Drop leading padding.  */
623               if (ntokens == 0)
624                 continue;
625             }
626           else if (token->type == CPP_OPEN_PAREN)
627             paren_depth++;
628           else if (token->type == CPP_CLOSE_PAREN)
629             {
630               if (paren_depth-- == 0)
631                 break;
632             }
633           else if (token->type == CPP_COMMA)
634             {
635               /* A comma does not terminate an argument within
636                  parentheses or as part of a variable argument.  */
637               if (paren_depth == 0
638                   && ! (macro->variadic && argc == macro->paramc))
639                 break;
640             }
641           else if (token->type == CPP_EOF
642                    || (token->type == CPP_HASH && token->flags & BOL))
643             break;
644
645           arg->first[ntokens++] = token;
646         }
647
648       /* Drop trailing padding.  */
649       while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
650         ntokens--;
651
652       arg->count = ntokens;
653       arg->first[ntokens] = &pfile->eof;
654
655       /* Terminate the argument.  Excess arguments loop back and
656          overwrite the final legitimate argument, before failing.  */
657       if (argc <= macro->paramc)
658         {
659           buff->cur = (unsigned char *) &arg->first[ntokens + 1];
660           if (argc != macro->paramc)
661             arg++;
662         }
663     }
664   while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
665
666   if (token->type == CPP_EOF)
667     {
668       /* We still need the CPP_EOF to end directives, and to end
669          pre-expansion of a macro argument.  Step back is not
670          unconditional, since we don't want to return a CPP_EOF to our
671          callers at the end of an -include-d file.  */
672       if (pfile->context->prev || pfile->state.in_directive)
673         _cpp_backup_tokens (pfile, 1);
674       cpp_error (pfile, CPP_DL_ERROR,
675                  "unterminated argument list invoking macro \"%s\"",
676                  NODE_NAME (node));
677     }
678   else
679     {
680       /* A single empty argument is counted as no argument.  */
681       if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
682         argc = 0;
683       if (_cpp_arguments_ok (pfile, macro, node, argc))
684         {
685           /* GCC has special semantics for , ## b where b is a varargs
686              parameter: we remove the comma if b was omitted entirely.
687              If b was merely an empty argument, the comma is retained.
688              If the macro takes just one (varargs) parameter, then we
689              retain the comma only if we are standards conforming.
690
691              If FIRST is NULL replace_args () swallows the comma.  */
692           if (macro->variadic && (argc < macro->paramc
693                                   || (argc == 1 && args[0].count == 0
694                                       && !CPP_OPTION (pfile, std))))
695             args[macro->paramc - 1].first = NULL;
696           return base_buff;
697         }
698     }
699
700   /* An error occurred.  */
701   _cpp_release_buff (pfile, base_buff);
702   return NULL;
703 }
704
705 /* Search for an opening parenthesis to the macro of NODE, in such a
706    way that, if none is found, we don't lose the information in any
707    intervening padding tokens.  If we find the parenthesis, collect
708    the arguments and return the buffer containing them.  */
709 static _cpp_buff *
710 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node)
711 {
712   const cpp_token *token, *padding = NULL;
713
714   for (;;)
715     {
716       token = cpp_get_token (pfile);
717       if (token->type != CPP_PADDING)
718         break;
719       if (padding == NULL
720           || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
721         padding = token;
722     }
723
724   if (token->type == CPP_OPEN_PAREN)
725     {
726       pfile->state.parsing_args = 2;
727       return collect_args (pfile, node);
728     }
729
730   /* CPP_EOF can be the end of macro arguments, or the end of the
731      file.  We mustn't back up over the latter.  Ugh.  */
732   if (token->type != CPP_EOF || token == &pfile->eof)
733     {
734       /* Back up.  We may have skipped padding, in which case backing
735          up more than one token when expanding macros is in general
736          too difficult.  We re-insert it in its own context.  */
737       _cpp_backup_tokens (pfile, 1);
738       if (padding)
739         _cpp_push_token_context (pfile, NULL, padding, 1);
740     }
741
742   return NULL;
743 }
744
745 /* Push the context of a macro with hash entry NODE onto the context
746    stack.  If we can successfully expand the macro, we push a context
747    containing its yet-to-be-rescanned replacement list and return one.
748    Otherwise, we don't push a context and return zero.  */
749 static int
750 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node)
751 {
752   /* The presence of a macro invalidates a file's controlling macro.  */
753   pfile->mi_valid = false;
754
755   pfile->state.angled_headers = false;
756
757   /* Handle standard macros.  */
758   if (! (node->flags & NODE_BUILTIN))
759     {
760       cpp_macro *macro = node->value.macro;
761
762       if (macro->fun_like)
763         {
764           _cpp_buff *buff;
765
766           pfile->state.prevent_expansion++;
767           pfile->keep_tokens++;
768           pfile->state.parsing_args = 1;
769           buff = funlike_invocation_p (pfile, node);
770           pfile->state.parsing_args = 0;
771           pfile->keep_tokens--;
772           pfile->state.prevent_expansion--;
773
774           if (buff == NULL)
775             {
776               if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
777                 cpp_error (pfile, CPP_DL_WARNING,
778  "function-like macro \"%s\" must be used with arguments in traditional C",
779                            NODE_NAME (node));
780
781               return 0;
782             }
783
784           if (macro->paramc > 0)
785             replace_args (pfile, node, macro, (macro_arg *) buff->base);
786           _cpp_release_buff (pfile, buff);
787         }
788
789       /* Disable the macro within its expansion.  */
790       node->flags |= NODE_DISABLED;
791
792       macro->used = 1;
793
794       if (macro->paramc == 0)
795         _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
796
797       return 1;
798     }
799
800   /* Handle built-in macros and the _Pragma operator.  */
801   return builtin_macro (pfile, node);
802 }
803
804 /* Replace the parameters in a function-like macro of NODE with the
805    actual ARGS, and place the result in a newly pushed token context.
806    Expand each argument before replacing, unless it is operated upon
807    by the # or ## operators.  */
808 static void
809 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
810 {
811   unsigned int i, total;
812   const cpp_token *src, *limit;
813   const cpp_token **dest, **first;
814   macro_arg *arg;
815   _cpp_buff *buff;
816
817   /* First, fully macro-expand arguments, calculating the number of
818      tokens in the final expansion as we go.  The ordering of the if
819      statements below is subtle; we must handle stringification before
820      pasting.  */
821   total = macro->count;
822   limit = macro->exp.tokens + macro->count;
823
824   for (src = macro->exp.tokens; src < limit; src++)
825     if (src->type == CPP_MACRO_ARG)
826       {
827         /* Leading and trailing padding tokens.  */
828         total += 2;
829
830         /* We have an argument.  If it is not being stringified or
831            pasted it is macro-replaced before insertion.  */
832         arg = &args[src->val.arg_no - 1];
833
834         if (src->flags & STRINGIFY_ARG)
835           {
836             if (!arg->stringified)
837               arg->stringified = stringify_arg (pfile, arg);
838           }
839         else if ((src->flags & PASTE_LEFT)
840                  || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
841           total += arg->count - 1;
842         else
843           {
844             if (!arg->expanded)
845               expand_arg (pfile, arg);
846             total += arg->expanded_count - 1;
847           }
848       }
849
850   /* Now allocate space for the expansion, copy the tokens and replace
851      the arguments.  */
852   buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
853   first = (const cpp_token **) buff->base;
854   dest = first;
855
856   for (src = macro->exp.tokens; src < limit; src++)
857     {
858       unsigned int count;
859       const cpp_token **from, **paste_flag;
860
861       if (src->type != CPP_MACRO_ARG)
862         {
863           *dest++ = src;
864           continue;
865         }
866
867       paste_flag = 0;
868       arg = &args[src->val.arg_no - 1];
869       if (src->flags & STRINGIFY_ARG)
870         count = 1, from = &arg->stringified;
871       else if (src->flags & PASTE_LEFT)
872         count = arg->count, from = arg->first;
873       else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
874         {
875           count = arg->count, from = arg->first;
876           if (dest != first)
877             {
878               if (dest[-1]->type == CPP_COMMA
879                   && macro->variadic
880                   && src->val.arg_no == macro->paramc)
881                 {
882                   /* Swallow a pasted comma if from == NULL, otherwise
883                      drop the paste flag.  */
884                   if (from == NULL)
885                     dest--;
886                   else
887                     paste_flag = dest - 1;
888                 }
889               /* Remove the paste flag if the RHS is a placemarker.  */
890               else if (count == 0)
891                 paste_flag = dest - 1;
892             }
893         }
894       else
895         count = arg->expanded_count, from = arg->expanded;
896
897       /* Padding on the left of an argument (unless RHS of ##).  */
898       if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
899           && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
900         *dest++ = padding_token (pfile, src);
901
902       if (count)
903         {
904           memcpy (dest, from, count * sizeof (cpp_token *));
905           dest += count;
906
907           /* With a non-empty argument on the LHS of ##, the last
908              token should be flagged PASTE_LEFT.  */
909           if (src->flags & PASTE_LEFT)
910             paste_flag = dest - 1;
911         }
912
913       /* Avoid paste on RHS (even case count == 0).  */
914       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
915         *dest++ = &pfile->avoid_paste;
916
917       /* Add a new paste flag, or remove an unwanted one.  */
918       if (paste_flag)
919         {
920           cpp_token *token = _cpp_temp_token (pfile);
921           token->type = (*paste_flag)->type;
922           token->val = (*paste_flag)->val;
923           if (src->flags & PASTE_LEFT)
924             token->flags = (*paste_flag)->flags | PASTE_LEFT;
925           else
926             token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
927           *paste_flag = token;
928         }
929     }
930
931   /* Free the expanded arguments.  */
932   for (i = 0; i < macro->paramc; i++)
933     if (args[i].expanded)
934       free (args[i].expanded);
935
936   push_ptoken_context (pfile, node, buff, first, dest - first);
937 }
938
939 /* Return a special padding token, with padding inherited from SOURCE.  */
940 static const cpp_token *
941 padding_token (cpp_reader *pfile, const cpp_token *source)
942 {
943   cpp_token *result = _cpp_temp_token (pfile);
944
945   result->type = CPP_PADDING;
946
947   /* Data in GCed data structures cannot be made const so far, so we
948      need a cast here.  */
949   result->val.source = (cpp_token *) source;
950   result->flags = 0;
951   return result;
952 }
953
954 /* Get a new uninitialized context.  Create a new one if we cannot
955    re-use an old one.  */
956 static cpp_context *
957 next_context (cpp_reader *pfile)
958 {
959   cpp_context *result = pfile->context->next;
960
961   if (result == 0)
962     {
963       result = XNEW (cpp_context);
964       result->prev = pfile->context;
965       result->next = 0;
966       pfile->context->next = result;
967     }
968
969   pfile->context = result;
970   return result;
971 }
972
973 /* Push a list of pointers to tokens.  */
974 static void
975 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
976                      const cpp_token **first, unsigned int count)
977 {
978   cpp_context *context = next_context (pfile);
979
980   context->direct_p = false;
981   context->macro = macro;
982   context->buff = buff;
983   FIRST (context).ptoken = first;
984   LAST (context).ptoken = first + count;
985 }
986
987 /* Push a list of tokens.  */
988 void
989 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
990                          const cpp_token *first, unsigned int count)
991 {
992   cpp_context *context = next_context (pfile);
993
994   context->direct_p = true;
995   context->macro = macro;
996   context->buff = NULL;
997   FIRST (context).token = first;
998   LAST (context).token = first + count;
999 }
1000
1001 /* Push a traditional macro's replacement text.  */
1002 void
1003 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1004                         const uchar *start, size_t len)
1005 {
1006   cpp_context *context = next_context (pfile);
1007
1008   context->direct_p = true;
1009   context->macro = macro;
1010   context->buff = NULL;
1011   CUR (context) = start;
1012   RLIMIT (context) = start + len;
1013   macro->flags |= NODE_DISABLED;
1014 }
1015
1016 /* Expand an argument ARG before replacing parameters in a
1017    function-like macro.  This works by pushing a context with the
1018    argument's tokens, and then expanding that into a temporary buffer
1019    as if it were a normal part of the token stream.  collect_args()
1020    has terminated the argument's tokens with a CPP_EOF so that we know
1021    when we have fully expanded the argument.  */
1022 static void
1023 expand_arg (cpp_reader *pfile, macro_arg *arg)
1024 {
1025   unsigned int capacity;
1026   bool saved_warn_trad;
1027
1028   if (arg->count == 0)
1029     return;
1030
1031   /* Don't warn about funlike macros when pre-expanding.  */
1032   saved_warn_trad = CPP_WTRADITIONAL (pfile);
1033   CPP_WTRADITIONAL (pfile) = 0;
1034
1035   /* Loop, reading in the arguments.  */
1036   capacity = 256;
1037   arg->expanded = XNEWVEC (const cpp_token *, capacity);
1038
1039   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1040   for (;;)
1041     {
1042       const cpp_token *token;
1043
1044       if (arg->expanded_count + 1 >= capacity)
1045         {
1046           capacity *= 2;
1047           arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1048                                       capacity);
1049         }
1050
1051       token = cpp_get_token (pfile);
1052
1053       if (token->type == CPP_EOF)
1054         break;
1055
1056       arg->expanded[arg->expanded_count++] = token;
1057     }
1058
1059   _cpp_pop_context (pfile);
1060
1061   CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1062 }
1063
1064 /* Pop the current context off the stack, re-enabling the macro if the
1065    context represented a macro's replacement list.  The context
1066    structure is not freed so that we can re-use it later.  */
1067 void
1068 _cpp_pop_context (cpp_reader *pfile)
1069 {
1070   cpp_context *context = pfile->context;
1071
1072   if (context->macro)
1073     context->macro->flags &= ~NODE_DISABLED;
1074
1075   if (context->buff)
1076     _cpp_release_buff (pfile, context->buff);
1077
1078   pfile->context = context->prev;
1079 }
1080
1081 /* External routine to get a token.  Also used nearly everywhere
1082    internally, except for places where we know we can safely call
1083    _cpp_lex_token directly, such as lexing a directive name.
1084
1085    Macro expansions and directives are transparently handled,
1086    including entering included files.  Thus tokens are post-macro
1087    expansion, and after any intervening directives.  External callers
1088    see CPP_EOF only at EOF.  Internal callers also see it when meeting
1089    a directive inside a macro call, when at the end of a directive and
1090    state.in_directive is still 1, and at the end of argument
1091    pre-expansion.  */
1092 const cpp_token *
1093 cpp_get_token (cpp_reader *pfile)
1094 {
1095   const cpp_token *result;
1096   bool can_set = pfile->set_invocation_location;
1097   pfile->set_invocation_location = false;
1098
1099   for (;;)
1100     {
1101       cpp_hashnode *node;
1102       cpp_context *context = pfile->context;
1103
1104       /* Context->prev == 0 <=> base context.  */
1105       if (!context->prev)
1106         result = _cpp_lex_token (pfile);
1107       else if (FIRST (context).token != LAST (context).token)
1108         {
1109           if (context->direct_p)
1110             result = FIRST (context).token++;
1111           else
1112             result = *FIRST (context).ptoken++;
1113
1114           if (result->flags & PASTE_LEFT)
1115             {
1116               paste_all_tokens (pfile, result);
1117               if (pfile->state.in_directive)
1118                 continue;
1119               return padding_token (pfile, result);
1120             }
1121         }
1122       else
1123         {
1124           _cpp_pop_context (pfile);
1125           if (pfile->state.in_directive)
1126             continue;
1127           return &pfile->avoid_paste;
1128         }
1129
1130       if (pfile->state.in_directive && result->type == CPP_COMMENT)
1131         continue;
1132
1133       if (result->type != CPP_NAME)
1134         break;
1135
1136       node = result->val.node;
1137
1138       if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1139         break;
1140
1141       if (!(node->flags & NODE_DISABLED))
1142         {
1143           /* If not in a macro context, and we're going to start an
1144              expansion, record the location.  */
1145           if (can_set && !context->macro)
1146             pfile->invocation_location = result->src_loc;
1147           if (!pfile->state.prevent_expansion
1148               && enter_macro_context (pfile, node))
1149             {
1150               if (pfile->state.in_directive)
1151                 continue;
1152               return padding_token (pfile, result);
1153             }
1154         }
1155       else
1156         {
1157           /* Flag this token as always unexpandable.  FIXME: move this
1158              to collect_args()?.  */
1159           cpp_token *t = _cpp_temp_token (pfile);
1160           t->type = result->type;
1161           t->flags = result->flags | NO_EXPAND;
1162           t->val = result->val;
1163           result = t;
1164         }
1165
1166       break;
1167     }
1168
1169   return result;
1170 }
1171
1172 /* Like cpp_get_token, but also returns a location separate from the
1173    one provided by the returned token.  LOC is an out parameter; *LOC
1174    is set to the location "as expected by the user".  This matters
1175    when a token results from macro expansion -- the token's location
1176    will indicate where the macro is defined, but *LOC will be the
1177    location of the start of the expansion.  */
1178 const cpp_token *
1179 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1180 {
1181   const cpp_token *result;
1182
1183   pfile->set_invocation_location = true;
1184   result = cpp_get_token (pfile);
1185   if (pfile->context->macro)
1186     *loc = pfile->invocation_location;
1187   else
1188     *loc = result->src_loc;
1189
1190   return result;
1191 }
1192
1193 /* Returns true if we're expanding an object-like macro that was
1194    defined in a system header.  Just checks the macro at the top of
1195    the stack.  Used for diagnostic suppression.  */
1196 int
1197 cpp_sys_macro_p (cpp_reader *pfile)
1198 {
1199   cpp_hashnode *node = pfile->context->macro;
1200
1201   return node && node->value.macro && node->value.macro->syshdr;
1202 }
1203
1204 /* Read each token in, until end of the current file.  Directives are
1205    transparently processed.  */
1206 void
1207 cpp_scan_nooutput (cpp_reader *pfile)
1208 {
1209   /* Request a CPP_EOF token at the end of this file, rather than
1210      transparently continuing with the including file.  */
1211   pfile->buffer->return_at_eof = true;
1212
1213   pfile->state.discarding_output++;
1214   pfile->state.prevent_expansion++;
1215
1216   if (CPP_OPTION (pfile, traditional))
1217     while (_cpp_read_logical_line_trad (pfile))
1218       ;
1219   else
1220     while (cpp_get_token (pfile)->type != CPP_EOF)
1221       ;
1222
1223   pfile->state.discarding_output--;
1224   pfile->state.prevent_expansion--;
1225 }
1226
1227 /* Step back one (or more) tokens.  Can only step back more than 1 if
1228    they are from the lexer, and not from macro expansion.  */
1229 void
1230 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1231 {
1232   if (pfile->context->prev == NULL)
1233     {
1234       pfile->lookaheads += count;
1235       while (count--)
1236         {
1237           pfile->cur_token--;
1238           if (pfile->cur_token == pfile->cur_run->base
1239               /* Possible with -fpreprocessed and no leading #line.  */
1240               && pfile->cur_run->prev != NULL)
1241             {
1242               pfile->cur_run = pfile->cur_run->prev;
1243               pfile->cur_token = pfile->cur_run->limit;
1244             }
1245         }
1246     }
1247   else
1248     {
1249       if (count != 1)
1250         abort ();
1251       if (pfile->context->direct_p)
1252         FIRST (pfile->context).token--;
1253       else
1254         FIRST (pfile->context).ptoken--;
1255     }
1256 }
1257
1258 /* #define directive parsing and handling.  */
1259
1260 /* Returns nonzero if a macro redefinition warning is required.  */
1261 static bool
1262 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1263                       const cpp_macro *macro2)
1264 {
1265   const cpp_macro *macro1;
1266   unsigned int i;
1267
1268   /* Some redefinitions need to be warned about regardless.  */
1269   if (node->flags & NODE_WARN)
1270     return true;
1271
1272   /* Redefinition of a macro is allowed if and only if the old and new
1273      definitions are the same.  (6.10.3 paragraph 2).  */
1274   macro1 = node->value.macro;
1275
1276   /* Don't check count here as it can be different in valid
1277      traditional redefinitions with just whitespace differences.  */
1278   if (macro1->paramc != macro2->paramc
1279       || macro1->fun_like != macro2->fun_like
1280       || macro1->variadic != macro2->variadic)
1281     return true;
1282
1283   /* Check parameter spellings.  */
1284   for (i = 0; i < macro1->paramc; i++)
1285     if (macro1->params[i] != macro2->params[i])
1286       return true;
1287
1288   /* Check the replacement text or tokens.  */
1289   if (CPP_OPTION (pfile, traditional))
1290     return _cpp_expansions_different_trad (macro1, macro2);
1291
1292   if (macro1->count != macro2->count)
1293     return true;
1294
1295   for (i = 0; i < macro1->count; i++)
1296     if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1297       return true;
1298
1299   return false;
1300 }
1301
1302 /* Free the definition of hashnode H.  */
1303 void
1304 _cpp_free_definition (cpp_hashnode *h)
1305 {
1306   /* Macros and assertions no longer have anything to free.  */
1307   h->type = NT_VOID;
1308   /* Clear builtin flag in case of redefinition.  */
1309   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1310 }
1311
1312 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1313    zero on success, nonzero if the parameter is a duplicate.  */
1314 bool
1315 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1316 {
1317   unsigned int len;
1318   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1319   if (node->flags & NODE_MACRO_ARG)
1320     {
1321       cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1322                  NODE_NAME (node));
1323       return true;
1324     }
1325
1326   if (BUFF_ROOM (pfile->a_buff)
1327       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1328     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1329
1330   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1331   node->flags |= NODE_MACRO_ARG;
1332   len = macro->paramc * sizeof (union _cpp_hashnode_value);
1333   if (len > pfile->macro_buffer_len)
1334     {
1335       pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1336                                         len);
1337       pfile->macro_buffer_len = len;
1338     }
1339   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1340     = node->value;
1341   
1342   node->value.arg_index  = macro->paramc;
1343   return false;
1344 }
1345
1346 /* Check the syntax of the parameters in a MACRO definition.  Returns
1347    false if an error occurs.  */
1348 static bool
1349 parse_params (cpp_reader *pfile, cpp_macro *macro)
1350 {
1351   unsigned int prev_ident = 0;
1352
1353   for (;;)
1354     {
1355       const cpp_token *token = _cpp_lex_token (pfile);
1356
1357       switch (token->type)
1358         {
1359         default:
1360           /* Allow/ignore comments in parameter lists if we are
1361              preserving comments in macro expansions.  */
1362           if (token->type == CPP_COMMENT
1363               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1364             continue;
1365
1366           cpp_error (pfile, CPP_DL_ERROR,
1367                      "\"%s\" may not appear in macro parameter list",
1368                      cpp_token_as_text (pfile, token));
1369           return false;
1370
1371         case CPP_NAME:
1372           if (prev_ident)
1373             {
1374               cpp_error (pfile, CPP_DL_ERROR,
1375                          "macro parameters must be comma-separated");
1376               return false;
1377             }
1378           prev_ident = 1;
1379
1380           if (_cpp_save_parameter (pfile, macro, token->val.node))
1381             return false;
1382           continue;
1383
1384         case CPP_CLOSE_PAREN:
1385           if (prev_ident || macro->paramc == 0)
1386             return true;
1387
1388           /* Fall through to pick up the error.  */
1389         case CPP_COMMA:
1390           if (!prev_ident)
1391             {
1392               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1393               return false;
1394             }
1395           prev_ident = 0;
1396           continue;
1397
1398         case CPP_ELLIPSIS:
1399           macro->variadic = 1;
1400           if (!prev_ident)
1401             {
1402               _cpp_save_parameter (pfile, macro,
1403                                    pfile->spec_nodes.n__VA_ARGS__);
1404               pfile->state.va_args_ok = 1;
1405               if (! CPP_OPTION (pfile, c99)
1406                   && CPP_OPTION (pfile, pedantic)
1407                   && CPP_OPTION (pfile, warn_variadic_macros))
1408                 cpp_error (pfile, CPP_DL_PEDWARN,
1409                            "anonymous variadic macros were introduced in C99");
1410             }
1411           else if (CPP_OPTION (pfile, pedantic)
1412                    && CPP_OPTION (pfile, warn_variadic_macros))
1413             cpp_error (pfile, CPP_DL_PEDWARN,
1414                        "ISO C does not permit named variadic macros");
1415
1416           /* We're at the end, and just expect a closing parenthesis.  */
1417           token = _cpp_lex_token (pfile);
1418           if (token->type == CPP_CLOSE_PAREN)
1419             return true;
1420           /* Fall through.  */
1421
1422         case CPP_EOF:
1423           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1424           return false;
1425         }
1426     }
1427 }
1428
1429 /* Allocate room for a token from a macro's replacement list.  */
1430 static cpp_token *
1431 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1432 {
1433   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1434     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1435
1436   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1437 }
1438
1439 /* Lex a token from the expansion of MACRO, but mark parameters as we
1440    find them and warn of traditional stringification.  */
1441 static cpp_token *
1442 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1443 {
1444   cpp_token *token, *saved_cur_token;
1445
1446   saved_cur_token = pfile->cur_token;
1447   pfile->cur_token = alloc_expansion_token (pfile, macro);
1448   token = _cpp_lex_direct (pfile);
1449   pfile->cur_token = saved_cur_token;
1450
1451   /* Is this a parameter?  */
1452   if (token->type == CPP_NAME
1453       && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1454     {
1455       token->type = CPP_MACRO_ARG;
1456       token->val.arg_no = token->val.node->value.arg_index;
1457     }
1458   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1459            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1460     check_trad_stringification (pfile, macro, &token->val.str);
1461
1462   return token;
1463 }
1464
1465 static bool
1466 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1467 {
1468   cpp_token *token;
1469   const cpp_token *ctoken;
1470   bool following_paste_op = false;
1471   const char *paste_op_error_msg =
1472     N_("'##' cannot appear at either end of a macro expansion");
1473
1474   /* Get the first token of the expansion (or the '(' of a
1475      function-like macro).  */
1476   ctoken = _cpp_lex_token (pfile);
1477
1478   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1479     {
1480       bool ok = parse_params (pfile, macro);
1481       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1482       if (!ok)
1483         return false;
1484
1485       /* Success.  Commit or allocate the parameter array.  */
1486       if (pfile->hash_table->alloc_subobject)
1487         {
1488           cpp_hashnode **params =
1489             (cpp_hashnode **) pfile->hash_table->alloc_subobject
1490             (sizeof (cpp_hashnode *) * macro->paramc);
1491           memcpy (params, macro->params,
1492                   sizeof (cpp_hashnode *) * macro->paramc);
1493           macro->params = params;
1494         }
1495       else
1496         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1497       macro->fun_like = 1;
1498     }
1499   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1500     {
1501       /* While ISO C99 requires whitespace before replacement text
1502          in a macro definition, ISO C90 with TC1 allows there characters
1503          from the basic source character set.  */
1504       if (CPP_OPTION (pfile, c99))
1505         cpp_error (pfile, CPP_DL_PEDWARN,
1506                    "ISO C99 requires whitespace after the macro name");
1507       else
1508         {
1509           int warntype = CPP_DL_WARNING;
1510           switch (ctoken->type)
1511             {
1512             case CPP_ATSIGN:
1513             case CPP_AT_NAME:
1514             case CPP_OBJC_STRING:
1515               /* '@' is not in basic character set.  */
1516               warntype = CPP_DL_PEDWARN;
1517               break;
1518             case CPP_OTHER:
1519               /* Basic character set sans letters, digits and _.  */
1520               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1521                           ctoken->val.str.text[0]) == NULL)
1522                 warntype = CPP_DL_PEDWARN;
1523               break;
1524             default:
1525               /* All other tokens start with a character from basic
1526                  character set.  */
1527               break;
1528             }
1529           cpp_error (pfile, warntype,
1530                      "missing whitespace after the macro name");
1531         }
1532     }
1533
1534   if (macro->fun_like)
1535     token = lex_expansion_token (pfile, macro);
1536   else
1537     {
1538       token = alloc_expansion_token (pfile, macro);
1539       *token = *ctoken;
1540     }
1541
1542   for (;;)
1543     {
1544       /* Check the stringifying # constraint 6.10.3.2.1 of
1545          function-like macros when lexing the subsequent token.  */
1546       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1547         {
1548           if (token->type == CPP_MACRO_ARG)
1549             {
1550               token->flags &= ~PREV_WHITE;
1551               token->flags |= STRINGIFY_ARG;
1552               token->flags |= token[-1].flags & PREV_WHITE;
1553               token[-1] = token[0];
1554               macro->count--;
1555             }
1556           /* Let assembler get away with murder.  */
1557           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1558             {
1559               cpp_error (pfile, CPP_DL_ERROR,
1560                          "'#' is not followed by a macro parameter");
1561               return false;
1562             }
1563         }
1564
1565       if (token->type == CPP_EOF)
1566         {
1567           /* Paste operator constraint 6.10.3.3.1:
1568              Token-paste ##, can appear in both object-like and
1569              function-like macros, but not at the end.  */
1570           if (following_paste_op)
1571             {
1572               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1573               return false;
1574             }
1575           break;
1576         }
1577
1578       /* Paste operator constraint 6.10.3.3.1.  */
1579       if (token->type == CPP_PASTE)
1580         {
1581           /* Token-paste ##, can appear in both object-like and
1582              function-like macros, but not at the beginning.  */
1583           if (macro->count == 1)
1584             {
1585               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1586               return false;
1587             }
1588
1589           --macro->count;
1590           token[-1].flags |= PASTE_LEFT;
1591         }
1592
1593       following_paste_op = (token->type == CPP_PASTE);
1594       token = lex_expansion_token (pfile, macro);
1595     }
1596
1597   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1598   macro->traditional = 0;
1599
1600   /* Don't count the CPP_EOF.  */
1601   macro->count--;
1602
1603   /* Clear whitespace on first token for warn_of_redefinition().  */
1604   if (macro->count)
1605     macro->exp.tokens[0].flags &= ~PREV_WHITE;
1606
1607   /* Commit or allocate the memory.  */
1608   if (pfile->hash_table->alloc_subobject)
1609     {
1610       cpp_token *tokns =
1611         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1612                                                           * macro->count);
1613       memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1614       macro->exp.tokens = tokns;
1615     }
1616   else
1617     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
1618
1619   return true;
1620 }
1621
1622 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
1623 bool
1624 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1625 {
1626   cpp_macro *macro;
1627   unsigned int i;
1628   bool ok;
1629
1630   if (pfile->hash_table->alloc_subobject)
1631     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1632       (sizeof (cpp_macro));
1633   else
1634     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1635   macro->line = pfile->directive_line;
1636   macro->params = 0;
1637   macro->paramc = 0;
1638   macro->variadic = 0;
1639   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1640   macro->count = 0;
1641   macro->fun_like = 0;
1642   /* To suppress some diagnostics.  */
1643   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1644
1645   if (CPP_OPTION (pfile, traditional))
1646     ok = _cpp_create_trad_definition (pfile, macro);
1647   else
1648     {
1649       ok = create_iso_definition (pfile, macro);
1650
1651       /* We set the type for SEEN_EOL() in directives.c.
1652
1653          Longer term we should lex the whole line before coming here,
1654          and just copy the expansion.  */
1655
1656       /* Stop the lexer accepting __VA_ARGS__.  */
1657       pfile->state.va_args_ok = 0;
1658     }
1659
1660   /* Clear the fast argument lookup indices.  */
1661   for (i = macro->paramc; i-- > 0; )
1662     {
1663       struct cpp_hashnode *node = macro->params[i];
1664       node->flags &= ~ NODE_MACRO_ARG;
1665       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1666     }
1667
1668   if (!ok)
1669     return ok;
1670
1671   if (node->type == NT_MACRO)
1672     {
1673       if (CPP_OPTION (pfile, warn_unused_macros))
1674         _cpp_warn_if_unused_macro (pfile, node, NULL);
1675
1676       if (warn_of_redefinition (pfile, node, macro))
1677         {
1678           cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1679                                "\"%s\" redefined", NODE_NAME (node));
1680
1681           if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1682             cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1683                                  node->value.macro->line, 0,
1684                          "this is the location of the previous definition");
1685         }
1686     }
1687
1688   if (node->type != NT_VOID)
1689     _cpp_free_definition (node);
1690
1691   /* Enter definition in hash table.  */
1692   node->type = NT_MACRO;
1693   node->value.macro = macro;
1694   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1695     node->flags |= NODE_WARN;
1696
1697   return ok;
1698 }
1699
1700 /* Warn if a token in STRING matches one of a function-like MACRO's
1701    parameters.  */
1702 static void
1703 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1704                             const cpp_string *string)
1705 {
1706   unsigned int i, len;
1707   const uchar *p, *q, *limit;
1708
1709   /* Loop over the string.  */
1710   limit = string->text + string->len - 1;
1711   for (p = string->text + 1; p < limit; p = q)
1712     {
1713       /* Find the start of an identifier.  */
1714       while (p < limit && !is_idstart (*p))
1715         p++;
1716
1717       /* Find the end of the identifier.  */
1718       q = p;
1719       while (q < limit && is_idchar (*q))
1720         q++;
1721
1722       len = q - p;
1723
1724       /* Loop over the function macro arguments to see if the
1725          identifier inside the string matches one of them.  */
1726       for (i = 0; i < macro->paramc; i++)
1727         {
1728           const cpp_hashnode *node = macro->params[i];
1729
1730           if (NODE_LEN (node) == len
1731               && !memcmp (p, NODE_NAME (node), len))
1732             {
1733               cpp_error (pfile, CPP_DL_WARNING,
1734            "macro argument \"%s\" would be stringified in traditional C",
1735                          NODE_NAME (node));
1736               break;
1737             }
1738         }
1739     }
1740 }
1741
1742 /* Returns the name, arguments and expansion of a macro, in a format
1743    suitable to be read back in again, and therefore also for DWARF 2
1744    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1745    Caller is expected to generate the "#define" bit if needed.  The
1746    returned text is temporary, and automatically freed later.  */
1747 const unsigned char *
1748 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1749 {
1750   unsigned int i, len;
1751   const cpp_macro *macro = node->value.macro;
1752   unsigned char *buffer;
1753
1754   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1755     {
1756       cpp_error (pfile, CPP_DL_ICE,
1757                  "invalid hash type %d in cpp_macro_definition", node->type);
1758       return 0;
1759     }
1760
1761   /* Calculate length.  */
1762   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
1763   if (macro->fun_like)
1764     {
1765       len += 4;         /* "()" plus possible final ".." of named
1766                            varargs (we have + 1 below).  */
1767       for (i = 0; i < macro->paramc; i++)
1768         len += NODE_LEN (macro->params[i]) + 1; /* "," */
1769     }
1770
1771   /* This should match below where we fill in the buffer.  */
1772   if (CPP_OPTION (pfile, traditional))
1773     len += _cpp_replacement_text_len (macro);
1774   else
1775     {
1776       for (i = 0; i < macro->count; i++)
1777         {
1778           cpp_token *token = &macro->exp.tokens[i];
1779
1780           if (token->type == CPP_MACRO_ARG)
1781             len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1782           else
1783             len += cpp_token_len (token);
1784
1785           if (token->flags & STRINGIFY_ARG)
1786             len++;                      /* "#" */
1787           if (token->flags & PASTE_LEFT)
1788             len += 3;           /* " ##" */
1789           if (token->flags & PREV_WHITE)
1790             len++;              /* " " */
1791         }
1792     }
1793
1794   if (len > pfile->macro_buffer_len)
1795     {
1796       pfile->macro_buffer = XRESIZEVEC (unsigned char,
1797                                         pfile->macro_buffer, len);
1798       pfile->macro_buffer_len = len;
1799     }
1800
1801   /* Fill in the buffer.  Start with the macro name.  */
1802   buffer = pfile->macro_buffer;
1803   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1804   buffer += NODE_LEN (node);
1805
1806   /* Parameter names.  */
1807   if (macro->fun_like)
1808     {
1809       *buffer++ = '(';
1810       for (i = 0; i < macro->paramc; i++)
1811         {
1812           cpp_hashnode *param = macro->params[i];
1813
1814           if (param != pfile->spec_nodes.n__VA_ARGS__)
1815             {
1816               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1817               buffer += NODE_LEN (param);
1818             }
1819
1820           if (i + 1 < macro->paramc)
1821             /* Don't emit a space after the comma here; we're trying
1822                to emit a Dwarf-friendly definition, and the Dwarf spec
1823                forbids spaces in the argument list.  */
1824             *buffer++ = ',';
1825           else if (macro->variadic)
1826             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1827         }
1828       *buffer++ = ')';
1829     }
1830
1831   /* The Dwarf spec requires a space after the macro name, even if the
1832      definition is the empty string.  */
1833   *buffer++ = ' ';
1834
1835   if (CPP_OPTION (pfile, traditional))
1836     buffer = _cpp_copy_replacement_text (macro, buffer);
1837   else if (macro->count)
1838   /* Expansion tokens.  */
1839     {
1840       for (i = 0; i < macro->count; i++)
1841         {
1842           cpp_token *token = &macro->exp.tokens[i];
1843
1844           if (token->flags & PREV_WHITE)
1845             *buffer++ = ' ';
1846           if (token->flags & STRINGIFY_ARG)
1847             *buffer++ = '#';
1848
1849           if (token->type == CPP_MACRO_ARG)
1850             {
1851               memcpy (buffer,
1852                       NODE_NAME (macro->params[token->val.arg_no - 1]),
1853                       NODE_LEN (macro->params[token->val.arg_no - 1]));
1854               buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1855             }
1856           else
1857             buffer = cpp_spell_token (pfile, token, buffer, false);
1858
1859           if (token->flags & PASTE_LEFT)
1860             {
1861               *buffer++ = ' ';
1862               *buffer++ = '#';
1863               *buffer++ = '#';
1864               /* Next has PREV_WHITE; see _cpp_create_definition.  */
1865             }
1866         }
1867     }
1868
1869   *buffer = '\0';
1870   return pfile->macro_buffer;
1871 }