OSDN Git Service

3a3bf412724b3354699e2acf1c0a8ae0db4be2b5
[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, 2008 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   /* In one obscure case we might see padding here.  */
455   if (rhs->type != CPP_PADDING)
456     end = cpp_spell_token (pfile, rhs, end, false);
457   *end = '\n';
458
459   cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
460   _cpp_clean_line (pfile);
461
462   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
463   pfile->cur_token = _cpp_temp_token (pfile);
464   lhs = _cpp_lex_direct (pfile);
465   if (pfile->buffer->cur != pfile->buffer->rlimit)
466     {
467       source_location saved_loc = lhs->src_loc;
468
469       _cpp_pop_buffer (pfile);
470       _cpp_backup_tokens (pfile, 1);
471       *lhsend = '\0';
472
473       /* We have to remove the PASTE_LEFT flag from the old lhs, but
474          we want to keep the new location.  */
475       *lhs = **plhs;
476       *plhs = lhs;
477       lhs->src_loc = saved_loc;
478       lhs->flags &= ~PASTE_LEFT;
479
480       /* Mandatory error for all apart from assembler.  */
481       if (CPP_OPTION (pfile, lang) != CLK_ASM)
482         cpp_error (pfile, CPP_DL_ERROR,
483          "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
484                    buf, cpp_token_as_text (pfile, rhs));
485       return false;
486     }
487
488   *plhs = lhs;
489   _cpp_pop_buffer (pfile);
490   return true;
491 }
492
493 /* Handles an arbitrarily long sequence of ## operators, with initial
494    operand LHS.  This implementation is left-associative,
495    non-recursive, and finishes a paste before handling succeeding
496    ones.  If a paste fails, we back up to the RHS of the failing ##
497    operator before pushing the context containing the result of prior
498    successful pastes, with the effect that the RHS appears in the
499    output stream after the pasted LHS normally.  */
500 static void
501 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
502 {
503   const cpp_token *rhs;
504   cpp_context *context = pfile->context;
505
506   do
507     {
508       /* Take the token directly from the current context.  We can do
509          this, because we are in the replacement list of either an
510          object-like macro, or a function-like macro with arguments
511          inserted.  In either case, the constraints to #define
512          guarantee we have at least one more token.  */
513       if (context->direct_p)
514         rhs = FIRST (context).token++;
515       else
516         rhs = *FIRST (context).ptoken++;
517
518       if (rhs->type == CPP_PADDING)
519         {
520           if (rhs->flags & PASTE_LEFT)
521             abort ();
522         }
523       if (!paste_tokens (pfile, &lhs, rhs))
524         break;
525     }
526   while (rhs->flags & PASTE_LEFT);
527
528   /* Put the resulting token in its own context.  */
529   _cpp_push_token_context (pfile, NULL, lhs, 1);
530 }
531
532 /* Returns TRUE if the number of arguments ARGC supplied in an
533    invocation of the MACRO referenced by NODE is valid.  An empty
534    invocation to a macro with no parameters should pass ARGC as zero.
535
536    Note that MACRO cannot necessarily be deduced from NODE, in case
537    NODE was redefined whilst collecting arguments.  */
538 bool
539 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
540 {
541   if (argc == macro->paramc)
542     return true;
543
544   if (argc < macro->paramc)
545     {
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
549          debug("string");
550
551          This is exactly the same as if there had been an empty rest
552          argument - debug("string", ).  */
553
554       if (argc + 1 == macro->paramc && macro->variadic)
555         {
556           if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
557             cpp_error (pfile, CPP_DL_PEDWARN,
558                        "ISO C99 requires rest arguments to be used");
559           return true;
560         }
561
562       cpp_error (pfile, CPP_DL_ERROR,
563                  "macro \"%s\" requires %u arguments, but only %u given",
564                  NODE_NAME (node), macro->paramc, argc);
565     }
566   else
567     cpp_error (pfile, CPP_DL_ERROR,
568                "macro \"%s\" passed %u arguments, but takes just %u",
569                NODE_NAME (node), argc, macro->paramc);
570
571   return false;
572 }
573
574 /* Reads and returns the arguments to a function-like macro
575    invocation.  Assumes the opening parenthesis has been processed.
576    If there is an error, emits an appropriate diagnostic and returns
577    NULL.  Each argument is terminated by a CPP_EOF token, for the
578    future benefit of expand_arg().  */
579 static _cpp_buff *
580 collect_args (cpp_reader *pfile, const cpp_hashnode *node)
581 {
582   _cpp_buff *buff, *base_buff;
583   cpp_macro *macro;
584   macro_arg *args, *arg;
585   const cpp_token *token;
586   unsigned int argc;
587
588   macro = node->value.macro;
589   if (macro->paramc)
590     argc = macro->paramc;
591   else
592     argc = 1;
593   buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
594                                        + sizeof (macro_arg)));
595   base_buff = buff;
596   args = (macro_arg *) buff->base;
597   memset (args, 0, argc * sizeof (macro_arg));
598   buff->cur = (unsigned char *) &args[argc];
599   arg = args, argc = 0;
600
601   /* Collect the tokens making up each argument.  We don't yet know
602      how many arguments have been supplied, whether too many or too
603      few.  Hence the slightly bizarre usage of "argc" and "arg".  */
604   do
605     {
606       unsigned int paren_depth = 0;
607       unsigned int ntokens = 0;
608
609       argc++;
610       arg->first = (const cpp_token **) buff->cur;
611
612       for (;;)
613         {
614           /* Require space for 2 new tokens (including a CPP_EOF).  */
615           if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
616             {
617               buff = _cpp_append_extend_buff (pfile, buff,
618                                               1000 * sizeof (cpp_token *));
619               arg->first = (const cpp_token **) buff->cur;
620             }
621
622           token = cpp_get_token (pfile);
623
624           if (token->type == CPP_PADDING)
625             {
626               /* Drop leading padding.  */
627               if (ntokens == 0)
628                 continue;
629             }
630           else if (token->type == CPP_OPEN_PAREN)
631             paren_depth++;
632           else if (token->type == CPP_CLOSE_PAREN)
633             {
634               if (paren_depth-- == 0)
635                 break;
636             }
637           else if (token->type == CPP_COMMA)
638             {
639               /* A comma does not terminate an argument within
640                  parentheses or as part of a variable argument.  */
641               if (paren_depth == 0
642                   && ! (macro->variadic && argc == macro->paramc))
643                 break;
644             }
645           else if (token->type == CPP_EOF
646                    || (token->type == CPP_HASH && token->flags & BOL))
647             break;
648
649           arg->first[ntokens++] = token;
650         }
651
652       /* Drop trailing padding.  */
653       while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
654         ntokens--;
655
656       arg->count = ntokens;
657       arg->first[ntokens] = &pfile->eof;
658
659       /* Terminate the argument.  Excess arguments loop back and
660          overwrite the final legitimate argument, before failing.  */
661       if (argc <= macro->paramc)
662         {
663           buff->cur = (unsigned char *) &arg->first[ntokens + 1];
664           if (argc != macro->paramc)
665             arg++;
666         }
667     }
668   while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
669
670   if (token->type == CPP_EOF)
671     {
672       /* We still need the CPP_EOF to end directives, and to end
673          pre-expansion of a macro argument.  Step back is not
674          unconditional, since we don't want to return a CPP_EOF to our
675          callers at the end of an -include-d file.  */
676       if (pfile->context->prev || pfile->state.in_directive)
677         _cpp_backup_tokens (pfile, 1);
678       cpp_error (pfile, CPP_DL_ERROR,
679                  "unterminated argument list invoking macro \"%s\"",
680                  NODE_NAME (node));
681     }
682   else
683     {
684       /* A single empty argument is counted as no argument.  */
685       if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
686         argc = 0;
687       if (_cpp_arguments_ok (pfile, macro, node, argc))
688         {
689           /* GCC has special semantics for , ## b where b is a varargs
690              parameter: we remove the comma if b was omitted entirely.
691              If b was merely an empty argument, the comma is retained.
692              If the macro takes just one (varargs) parameter, then we
693              retain the comma only if we are standards conforming.
694
695              If FIRST is NULL replace_args () swallows the comma.  */
696           if (macro->variadic && (argc < macro->paramc
697                                   || (argc == 1 && args[0].count == 0
698                                       && !CPP_OPTION (pfile, std))))
699             args[macro->paramc - 1].first = NULL;
700           return base_buff;
701         }
702     }
703
704   /* An error occurred.  */
705   _cpp_release_buff (pfile, base_buff);
706   return NULL;
707 }
708
709 /* Search for an opening parenthesis to the macro of NODE, in such a
710    way that, if none is found, we don't lose the information in any
711    intervening padding tokens.  If we find the parenthesis, collect
712    the arguments and return the buffer containing them.  */
713 static _cpp_buff *
714 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node)
715 {
716   const cpp_token *token, *padding = NULL;
717
718   for (;;)
719     {
720       token = cpp_get_token (pfile);
721       if (token->type != CPP_PADDING)
722         break;
723       if (padding == NULL
724           || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
725         padding = token;
726     }
727
728   if (token->type == CPP_OPEN_PAREN)
729     {
730       pfile->state.parsing_args = 2;
731       return collect_args (pfile, node);
732     }
733
734   /* CPP_EOF can be the end of macro arguments, or the end of the
735      file.  We mustn't back up over the latter.  Ugh.  */
736   if (token->type != CPP_EOF || token == &pfile->eof)
737     {
738       /* Back up.  We may have skipped padding, in which case backing
739          up more than one token when expanding macros is in general
740          too difficult.  We re-insert it in its own context.  */
741       _cpp_backup_tokens (pfile, 1);
742       if (padding)
743         _cpp_push_token_context (pfile, NULL, padding, 1);
744     }
745
746   return NULL;
747 }
748
749 /* Push the context of a macro with hash entry NODE onto the context
750    stack.  If we can successfully expand the macro, we push a context
751    containing its yet-to-be-rescanned replacement list and return one.
752    Otherwise, we don't push a context and return zero.  */
753 static int
754 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node)
755 {
756   /* The presence of a macro invalidates a file's controlling macro.  */
757   pfile->mi_valid = false;
758
759   pfile->state.angled_headers = false;
760
761   /* Handle standard macros.  */
762   if (! (node->flags & NODE_BUILTIN))
763     {
764       cpp_macro *macro = node->value.macro;
765
766       if (macro->fun_like)
767         {
768           _cpp_buff *buff;
769
770           pfile->state.prevent_expansion++;
771           pfile->keep_tokens++;
772           pfile->state.parsing_args = 1;
773           buff = funlike_invocation_p (pfile, node);
774           pfile->state.parsing_args = 0;
775           pfile->keep_tokens--;
776           pfile->state.prevent_expansion--;
777
778           if (buff == NULL)
779             {
780               if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
781                 cpp_error (pfile, CPP_DL_WARNING,
782  "function-like macro \"%s\" must be used with arguments in traditional C",
783                            NODE_NAME (node));
784
785               return 0;
786             }
787
788           if (macro->paramc > 0)
789             replace_args (pfile, node, macro, (macro_arg *) buff->base);
790           _cpp_release_buff (pfile, buff);
791         }
792
793       /* Disable the macro within its expansion.  */
794       node->flags |= NODE_DISABLED;
795
796       macro->used = 1;
797
798       if (macro->paramc == 0)
799         _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
800
801       return 1;
802     }
803
804   /* Handle built-in macros and the _Pragma operator.  */
805   return builtin_macro (pfile, node);
806 }
807
808 /* Replace the parameters in a function-like macro of NODE with the
809    actual ARGS, and place the result in a newly pushed token context.
810    Expand each argument before replacing, unless it is operated upon
811    by the # or ## operators.  */
812 static void
813 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
814 {
815   unsigned int i, total;
816   const cpp_token *src, *limit;
817   const cpp_token **dest, **first;
818   macro_arg *arg;
819   _cpp_buff *buff;
820
821   /* First, fully macro-expand arguments, calculating the number of
822      tokens in the final expansion as we go.  The ordering of the if
823      statements below is subtle; we must handle stringification before
824      pasting.  */
825   total = macro->count;
826   limit = macro->exp.tokens + macro->count;
827
828   for (src = macro->exp.tokens; src < limit; src++)
829     if (src->type == CPP_MACRO_ARG)
830       {
831         /* Leading and trailing padding tokens.  */
832         total += 2;
833
834         /* We have an argument.  If it is not being stringified or
835            pasted it is macro-replaced before insertion.  */
836         arg = &args[src->val.arg_no - 1];
837
838         if (src->flags & STRINGIFY_ARG)
839           {
840             if (!arg->stringified)
841               arg->stringified = stringify_arg (pfile, arg);
842           }
843         else if ((src->flags & PASTE_LEFT)
844                  || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
845           total += arg->count - 1;
846         else
847           {
848             if (!arg->expanded)
849               expand_arg (pfile, arg);
850             total += arg->expanded_count - 1;
851           }
852       }
853
854   /* Now allocate space for the expansion, copy the tokens and replace
855      the arguments.  */
856   buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
857   first = (const cpp_token **) buff->base;
858   dest = first;
859
860   for (src = macro->exp.tokens; src < limit; src++)
861     {
862       unsigned int count;
863       const cpp_token **from, **paste_flag;
864
865       if (src->type != CPP_MACRO_ARG)
866         {
867           *dest++ = src;
868           continue;
869         }
870
871       paste_flag = 0;
872       arg = &args[src->val.arg_no - 1];
873       if (src->flags & STRINGIFY_ARG)
874         count = 1, from = &arg->stringified;
875       else if (src->flags & PASTE_LEFT)
876         count = arg->count, from = arg->first;
877       else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
878         {
879           count = arg->count, from = arg->first;
880           if (dest != first)
881             {
882               if (dest[-1]->type == CPP_COMMA
883                   && macro->variadic
884                   && src->val.arg_no == macro->paramc)
885                 {
886                   /* Swallow a pasted comma if from == NULL, otherwise
887                      drop the paste flag.  */
888                   if (from == NULL)
889                     dest--;
890                   else
891                     paste_flag = dest - 1;
892                 }
893               /* Remove the paste flag if the RHS is a placemarker.  */
894               else if (count == 0)
895                 paste_flag = dest - 1;
896             }
897         }
898       else
899         count = arg->expanded_count, from = arg->expanded;
900
901       /* Padding on the left of an argument (unless RHS of ##).  */
902       if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
903           && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
904         *dest++ = padding_token (pfile, src);
905
906       if (count)
907         {
908           memcpy (dest, from, count * sizeof (cpp_token *));
909           dest += count;
910
911           /* With a non-empty argument on the LHS of ##, the last
912              token should be flagged PASTE_LEFT.  */
913           if (src->flags & PASTE_LEFT)
914             paste_flag = dest - 1;
915         }
916
917       /* Avoid paste on RHS (even case count == 0).  */
918       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
919         *dest++ = &pfile->avoid_paste;
920
921       /* Add a new paste flag, or remove an unwanted one.  */
922       if (paste_flag)
923         {
924           cpp_token *token = _cpp_temp_token (pfile);
925           token->type = (*paste_flag)->type;
926           token->val = (*paste_flag)->val;
927           if (src->flags & PASTE_LEFT)
928             token->flags = (*paste_flag)->flags | PASTE_LEFT;
929           else
930             token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
931           *paste_flag = token;
932         }
933     }
934
935   /* Free the expanded arguments.  */
936   for (i = 0; i < macro->paramc; i++)
937     if (args[i].expanded)
938       free (args[i].expanded);
939
940   push_ptoken_context (pfile, node, buff, first, dest - first);
941 }
942
943 /* Return a special padding token, with padding inherited from SOURCE.  */
944 static const cpp_token *
945 padding_token (cpp_reader *pfile, const cpp_token *source)
946 {
947   cpp_token *result = _cpp_temp_token (pfile);
948
949   result->type = CPP_PADDING;
950
951   /* Data in GCed data structures cannot be made const so far, so we
952      need a cast here.  */
953   result->val.source = (cpp_token *) source;
954   result->flags = 0;
955   return result;
956 }
957
958 /* Get a new uninitialized context.  Create a new one if we cannot
959    re-use an old one.  */
960 static cpp_context *
961 next_context (cpp_reader *pfile)
962 {
963   cpp_context *result = pfile->context->next;
964
965   if (result == 0)
966     {
967       result = XNEW (cpp_context);
968       result->prev = pfile->context;
969       result->next = 0;
970       pfile->context->next = result;
971     }
972
973   pfile->context = result;
974   return result;
975 }
976
977 /* Push a list of pointers to tokens.  */
978 static void
979 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
980                      const cpp_token **first, unsigned int count)
981 {
982   cpp_context *context = next_context (pfile);
983
984   context->direct_p = false;
985   context->macro = macro;
986   context->buff = buff;
987   FIRST (context).ptoken = first;
988   LAST (context).ptoken = first + count;
989 }
990
991 /* Push a list of tokens.  */
992 void
993 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
994                          const cpp_token *first, unsigned int count)
995 {
996   cpp_context *context = next_context (pfile);
997
998   context->direct_p = true;
999   context->macro = macro;
1000   context->buff = NULL;
1001   FIRST (context).token = first;
1002   LAST (context).token = first + count;
1003 }
1004
1005 /* Push a traditional macro's replacement text.  */
1006 void
1007 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1008                         const uchar *start, size_t len)
1009 {
1010   cpp_context *context = next_context (pfile);
1011
1012   context->direct_p = true;
1013   context->macro = macro;
1014   context->buff = NULL;
1015   CUR (context) = start;
1016   RLIMIT (context) = start + len;
1017   macro->flags |= NODE_DISABLED;
1018 }
1019
1020 /* Expand an argument ARG before replacing parameters in a
1021    function-like macro.  This works by pushing a context with the
1022    argument's tokens, and then expanding that into a temporary buffer
1023    as if it were a normal part of the token stream.  collect_args()
1024    has terminated the argument's tokens with a CPP_EOF so that we know
1025    when we have fully expanded the argument.  */
1026 static void
1027 expand_arg (cpp_reader *pfile, macro_arg *arg)
1028 {
1029   unsigned int capacity;
1030   bool saved_warn_trad;
1031
1032   if (arg->count == 0)
1033     return;
1034
1035   /* Don't warn about funlike macros when pre-expanding.  */
1036   saved_warn_trad = CPP_WTRADITIONAL (pfile);
1037   CPP_WTRADITIONAL (pfile) = 0;
1038
1039   /* Loop, reading in the arguments.  */
1040   capacity = 256;
1041   arg->expanded = XNEWVEC (const cpp_token *, capacity);
1042
1043   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1044   for (;;)
1045     {
1046       const cpp_token *token;
1047
1048       if (arg->expanded_count + 1 >= capacity)
1049         {
1050           capacity *= 2;
1051           arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1052                                       capacity);
1053         }
1054
1055       token = cpp_get_token (pfile);
1056
1057       if (token->type == CPP_EOF)
1058         break;
1059
1060       arg->expanded[arg->expanded_count++] = token;
1061     }
1062
1063   _cpp_pop_context (pfile);
1064
1065   CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1066 }
1067
1068 /* Pop the current context off the stack, re-enabling the macro if the
1069    context represented a macro's replacement list.  The context
1070    structure is not freed so that we can re-use it later.  */
1071 void
1072 _cpp_pop_context (cpp_reader *pfile)
1073 {
1074   cpp_context *context = pfile->context;
1075
1076   if (context->macro)
1077     context->macro->flags &= ~NODE_DISABLED;
1078
1079   if (context->buff)
1080     _cpp_release_buff (pfile, context->buff);
1081
1082   pfile->context = context->prev;
1083 }
1084
1085 /* External routine to get a token.  Also used nearly everywhere
1086    internally, except for places where we know we can safely call
1087    _cpp_lex_token directly, such as lexing a directive name.
1088
1089    Macro expansions and directives are transparently handled,
1090    including entering included files.  Thus tokens are post-macro
1091    expansion, and after any intervening directives.  External callers
1092    see CPP_EOF only at EOF.  Internal callers also see it when meeting
1093    a directive inside a macro call, when at the end of a directive and
1094    state.in_directive is still 1, and at the end of argument
1095    pre-expansion.  */
1096 const cpp_token *
1097 cpp_get_token (cpp_reader *pfile)
1098 {
1099   const cpp_token *result;
1100   bool can_set = pfile->set_invocation_location;
1101   pfile->set_invocation_location = false;
1102
1103   for (;;)
1104     {
1105       cpp_hashnode *node;
1106       cpp_context *context = pfile->context;
1107
1108       /* Context->prev == 0 <=> base context.  */
1109       if (!context->prev)
1110         result = _cpp_lex_token (pfile);
1111       else if (FIRST (context).token != LAST (context).token)
1112         {
1113           if (context->direct_p)
1114             result = FIRST (context).token++;
1115           else
1116             result = *FIRST (context).ptoken++;
1117
1118           if (result->flags & PASTE_LEFT)
1119             {
1120               paste_all_tokens (pfile, result);
1121               if (pfile->state.in_directive)
1122                 continue;
1123               return padding_token (pfile, result);
1124             }
1125         }
1126       else
1127         {
1128           _cpp_pop_context (pfile);
1129           if (pfile->state.in_directive)
1130             continue;
1131           return &pfile->avoid_paste;
1132         }
1133
1134       if (pfile->state.in_directive && result->type == CPP_COMMENT)
1135         continue;
1136
1137       if (result->type != CPP_NAME)
1138         break;
1139
1140       node = result->val.node;
1141
1142       if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1143         break;
1144
1145       if (!(node->flags & NODE_DISABLED))
1146         {
1147           /* If not in a macro context, and we're going to start an
1148              expansion, record the location.  */
1149           if (can_set && !context->macro)
1150             pfile->invocation_location = result->src_loc;
1151           if (!pfile->state.prevent_expansion
1152               && enter_macro_context (pfile, node))
1153             {
1154               if (pfile->state.in_directive)
1155                 continue;
1156               return padding_token (pfile, result);
1157             }
1158         }
1159       else
1160         {
1161           /* Flag this token as always unexpandable.  FIXME: move this
1162              to collect_args()?.  */
1163           cpp_token *t = _cpp_temp_token (pfile);
1164           t->type = result->type;
1165           t->flags = result->flags | NO_EXPAND;
1166           t->val = result->val;
1167           result = t;
1168         }
1169
1170       break;
1171     }
1172
1173   return result;
1174 }
1175
1176 /* Like cpp_get_token, but also returns a location separate from the
1177    one provided by the returned token.  LOC is an out parameter; *LOC
1178    is set to the location "as expected by the user".  This matters
1179    when a token results from macro expansion -- the token's location
1180    will indicate where the macro is defined, but *LOC will be the
1181    location of the start of the expansion.  */
1182 const cpp_token *
1183 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1184 {
1185   const cpp_token *result;
1186
1187   pfile->set_invocation_location = true;
1188   result = cpp_get_token (pfile);
1189   if (pfile->context->macro)
1190     *loc = pfile->invocation_location;
1191   else
1192     *loc = result->src_loc;
1193
1194   return result;
1195 }
1196
1197 /* Returns true if we're expanding an object-like macro that was
1198    defined in a system header.  Just checks the macro at the top of
1199    the stack.  Used for diagnostic suppression.  */
1200 int
1201 cpp_sys_macro_p (cpp_reader *pfile)
1202 {
1203   cpp_hashnode *node = pfile->context->macro;
1204
1205   return node && node->value.macro && node->value.macro->syshdr;
1206 }
1207
1208 /* Read each token in, until end of the current file.  Directives are
1209    transparently processed.  */
1210 void
1211 cpp_scan_nooutput (cpp_reader *pfile)
1212 {
1213   /* Request a CPP_EOF token at the end of this file, rather than
1214      transparently continuing with the including file.  */
1215   pfile->buffer->return_at_eof = true;
1216
1217   pfile->state.discarding_output++;
1218   pfile->state.prevent_expansion++;
1219
1220   if (CPP_OPTION (pfile, traditional))
1221     while (_cpp_read_logical_line_trad (pfile))
1222       ;
1223   else
1224     while (cpp_get_token (pfile)->type != CPP_EOF)
1225       ;
1226
1227   pfile->state.discarding_output--;
1228   pfile->state.prevent_expansion--;
1229 }
1230
1231 /* Step back one (or more) tokens.  Can only step back more than 1 if
1232    they are from the lexer, and not from macro expansion.  */
1233 void
1234 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1235 {
1236   if (pfile->context->prev == NULL)
1237     {
1238       pfile->lookaheads += count;
1239       while (count--)
1240         {
1241           pfile->cur_token--;
1242           if (pfile->cur_token == pfile->cur_run->base
1243               /* Possible with -fpreprocessed and no leading #line.  */
1244               && pfile->cur_run->prev != NULL)
1245             {
1246               pfile->cur_run = pfile->cur_run->prev;
1247               pfile->cur_token = pfile->cur_run->limit;
1248             }
1249         }
1250     }
1251   else
1252     {
1253       if (count != 1)
1254         abort ();
1255       if (pfile->context->direct_p)
1256         FIRST (pfile->context).token--;
1257       else
1258         FIRST (pfile->context).ptoken--;
1259     }
1260 }
1261
1262 /* #define directive parsing and handling.  */
1263
1264 /* Returns nonzero if a macro redefinition warning is required.  */
1265 static bool
1266 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1267                       const cpp_macro *macro2)
1268 {
1269   const cpp_macro *macro1;
1270   unsigned int i;
1271
1272   /* Some redefinitions need to be warned about regardless.  */
1273   if (node->flags & NODE_WARN)
1274     return true;
1275
1276   /* Redefinition of a macro is allowed if and only if the old and new
1277      definitions are the same.  (6.10.3 paragraph 2).  */
1278   macro1 = node->value.macro;
1279
1280   /* Don't check count here as it can be different in valid
1281      traditional redefinitions with just whitespace differences.  */
1282   if (macro1->paramc != macro2->paramc
1283       || macro1->fun_like != macro2->fun_like
1284       || macro1->variadic != macro2->variadic)
1285     return true;
1286
1287   /* Check parameter spellings.  */
1288   for (i = 0; i < macro1->paramc; i++)
1289     if (macro1->params[i] != macro2->params[i])
1290       return true;
1291
1292   /* Check the replacement text or tokens.  */
1293   if (CPP_OPTION (pfile, traditional))
1294     return _cpp_expansions_different_trad (macro1, macro2);
1295
1296   if (macro1->count != macro2->count)
1297     return true;
1298
1299   for (i = 0; i < macro1->count; i++)
1300     if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1301       return true;
1302
1303   return false;
1304 }
1305
1306 /* Free the definition of hashnode H.  */
1307 void
1308 _cpp_free_definition (cpp_hashnode *h)
1309 {
1310   /* Macros and assertions no longer have anything to free.  */
1311   h->type = NT_VOID;
1312   /* Clear builtin flag in case of redefinition.  */
1313   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1314 }
1315
1316 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1317    zero on success, nonzero if the parameter is a duplicate.  */
1318 bool
1319 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1320 {
1321   unsigned int len;
1322   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1323   if (node->flags & NODE_MACRO_ARG)
1324     {
1325       cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1326                  NODE_NAME (node));
1327       return true;
1328     }
1329
1330   if (BUFF_ROOM (pfile->a_buff)
1331       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1332     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1333
1334   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1335   node->flags |= NODE_MACRO_ARG;
1336   len = macro->paramc * sizeof (union _cpp_hashnode_value);
1337   if (len > pfile->macro_buffer_len)
1338     {
1339       pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1340                                         len);
1341       pfile->macro_buffer_len = len;
1342     }
1343   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1344     = node->value;
1345   
1346   node->value.arg_index  = macro->paramc;
1347   return false;
1348 }
1349
1350 /* Check the syntax of the parameters in a MACRO definition.  Returns
1351    false if an error occurs.  */
1352 static bool
1353 parse_params (cpp_reader *pfile, cpp_macro *macro)
1354 {
1355   unsigned int prev_ident = 0;
1356
1357   for (;;)
1358     {
1359       const cpp_token *token = _cpp_lex_token (pfile);
1360
1361       switch (token->type)
1362         {
1363         default:
1364           /* Allow/ignore comments in parameter lists if we are
1365              preserving comments in macro expansions.  */
1366           if (token->type == CPP_COMMENT
1367               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1368             continue;
1369
1370           cpp_error (pfile, CPP_DL_ERROR,
1371                      "\"%s\" may not appear in macro parameter list",
1372                      cpp_token_as_text (pfile, token));
1373           return false;
1374
1375         case CPP_NAME:
1376           if (prev_ident)
1377             {
1378               cpp_error (pfile, CPP_DL_ERROR,
1379                          "macro parameters must be comma-separated");
1380               return false;
1381             }
1382           prev_ident = 1;
1383
1384           if (_cpp_save_parameter (pfile, macro, token->val.node))
1385             return false;
1386           continue;
1387
1388         case CPP_CLOSE_PAREN:
1389           if (prev_ident || macro->paramc == 0)
1390             return true;
1391
1392           /* Fall through to pick up the error.  */
1393         case CPP_COMMA:
1394           if (!prev_ident)
1395             {
1396               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1397               return false;
1398             }
1399           prev_ident = 0;
1400           continue;
1401
1402         case CPP_ELLIPSIS:
1403           macro->variadic = 1;
1404           if (!prev_ident)
1405             {
1406               _cpp_save_parameter (pfile, macro,
1407                                    pfile->spec_nodes.n__VA_ARGS__);
1408               pfile->state.va_args_ok = 1;
1409               if (! CPP_OPTION (pfile, c99)
1410                   && CPP_OPTION (pfile, pedantic)
1411                   && CPP_OPTION (pfile, warn_variadic_macros))
1412                 cpp_error (pfile, CPP_DL_PEDWARN,
1413                            "anonymous variadic macros were introduced in C99");
1414             }
1415           else if (CPP_OPTION (pfile, pedantic)
1416                    && CPP_OPTION (pfile, warn_variadic_macros))
1417             cpp_error (pfile, CPP_DL_PEDWARN,
1418                        "ISO C does not permit named variadic macros");
1419
1420           /* We're at the end, and just expect a closing parenthesis.  */
1421           token = _cpp_lex_token (pfile);
1422           if (token->type == CPP_CLOSE_PAREN)
1423             return true;
1424           /* Fall through.  */
1425
1426         case CPP_EOF:
1427           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1428           return false;
1429         }
1430     }
1431 }
1432
1433 /* Allocate room for a token from a macro's replacement list.  */
1434 static cpp_token *
1435 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1436 {
1437   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1438     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1439
1440   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1441 }
1442
1443 /* Lex a token from the expansion of MACRO, but mark parameters as we
1444    find them and warn of traditional stringification.  */
1445 static cpp_token *
1446 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1447 {
1448   cpp_token *token, *saved_cur_token;
1449
1450   saved_cur_token = pfile->cur_token;
1451   pfile->cur_token = alloc_expansion_token (pfile, macro);
1452   token = _cpp_lex_direct (pfile);
1453   pfile->cur_token = saved_cur_token;
1454
1455   /* Is this a parameter?  */
1456   if (token->type == CPP_NAME
1457       && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1458     {
1459       token->type = CPP_MACRO_ARG;
1460       token->val.arg_no = token->val.node->value.arg_index;
1461     }
1462   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1463            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1464     check_trad_stringification (pfile, macro, &token->val.str);
1465
1466   return token;
1467 }
1468
1469 static bool
1470 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1471 {
1472   cpp_token *token;
1473   const cpp_token *ctoken;
1474   bool following_paste_op = false;
1475   const char *paste_op_error_msg =
1476     N_("'##' cannot appear at either end of a macro expansion");
1477
1478   /* Get the first token of the expansion (or the '(' of a
1479      function-like macro).  */
1480   ctoken = _cpp_lex_token (pfile);
1481
1482   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1483     {
1484       bool ok = parse_params (pfile, macro);
1485       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1486       if (!ok)
1487         return false;
1488
1489       /* Success.  Commit or allocate the parameter array.  */
1490       if (pfile->hash_table->alloc_subobject)
1491         {
1492           cpp_hashnode **params =
1493             (cpp_hashnode **) pfile->hash_table->alloc_subobject
1494             (sizeof (cpp_hashnode *) * macro->paramc);
1495           memcpy (params, macro->params,
1496                   sizeof (cpp_hashnode *) * macro->paramc);
1497           macro->params = params;
1498         }
1499       else
1500         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1501       macro->fun_like = 1;
1502     }
1503   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1504     {
1505       /* While ISO C99 requires whitespace before replacement text
1506          in a macro definition, ISO C90 with TC1 allows there characters
1507          from the basic source character set.  */
1508       if (CPP_OPTION (pfile, c99))
1509         cpp_error (pfile, CPP_DL_PEDWARN,
1510                    "ISO C99 requires whitespace after the macro name");
1511       else
1512         {
1513           int warntype = CPP_DL_WARNING;
1514           switch (ctoken->type)
1515             {
1516             case CPP_ATSIGN:
1517             case CPP_AT_NAME:
1518             case CPP_OBJC_STRING:
1519               /* '@' is not in basic character set.  */
1520               warntype = CPP_DL_PEDWARN;
1521               break;
1522             case CPP_OTHER:
1523               /* Basic character set sans letters, digits and _.  */
1524               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1525                           ctoken->val.str.text[0]) == NULL)
1526                 warntype = CPP_DL_PEDWARN;
1527               break;
1528             default:
1529               /* All other tokens start with a character from basic
1530                  character set.  */
1531               break;
1532             }
1533           cpp_error (pfile, warntype,
1534                      "missing whitespace after the macro name");
1535         }
1536     }
1537
1538   if (macro->fun_like)
1539     token = lex_expansion_token (pfile, macro);
1540   else
1541     {
1542       token = alloc_expansion_token (pfile, macro);
1543       *token = *ctoken;
1544     }
1545
1546   for (;;)
1547     {
1548       /* Check the stringifying # constraint 6.10.3.2.1 of
1549          function-like macros when lexing the subsequent token.  */
1550       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1551         {
1552           if (token->type == CPP_MACRO_ARG)
1553             {
1554               token->flags &= ~PREV_WHITE;
1555               token->flags |= STRINGIFY_ARG;
1556               token->flags |= token[-1].flags & PREV_WHITE;
1557               token[-1] = token[0];
1558               macro->count--;
1559             }
1560           /* Let assembler get away with murder.  */
1561           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1562             {
1563               cpp_error (pfile, CPP_DL_ERROR,
1564                          "'#' is not followed by a macro parameter");
1565               return false;
1566             }
1567         }
1568
1569       if (token->type == CPP_EOF)
1570         {
1571           /* Paste operator constraint 6.10.3.3.1:
1572              Token-paste ##, can appear in both object-like and
1573              function-like macros, but not at the end.  */
1574           if (following_paste_op)
1575             {
1576               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1577               return false;
1578             }
1579           break;
1580         }
1581
1582       /* Paste operator constraint 6.10.3.3.1.  */
1583       if (token->type == CPP_PASTE)
1584         {
1585           /* Token-paste ##, can appear in both object-like and
1586              function-like macros, but not at the beginning.  */
1587           if (macro->count == 1)
1588             {
1589               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1590               return false;
1591             }
1592
1593           --macro->count;
1594           token[-1].flags |= PASTE_LEFT;
1595         }
1596
1597       following_paste_op = (token->type == CPP_PASTE);
1598       token = lex_expansion_token (pfile, macro);
1599     }
1600
1601   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1602   macro->traditional = 0;
1603
1604   /* Don't count the CPP_EOF.  */
1605   macro->count--;
1606
1607   /* Clear whitespace on first token for warn_of_redefinition().  */
1608   if (macro->count)
1609     macro->exp.tokens[0].flags &= ~PREV_WHITE;
1610
1611   /* Commit or allocate the memory.  */
1612   if (pfile->hash_table->alloc_subobject)
1613     {
1614       cpp_token *tokns =
1615         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1616                                                           * macro->count);
1617       memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1618       macro->exp.tokens = tokns;
1619     }
1620   else
1621     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
1622
1623   return true;
1624 }
1625
1626 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
1627 bool
1628 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1629 {
1630   cpp_macro *macro;
1631   unsigned int i;
1632   bool ok;
1633
1634   if (pfile->hash_table->alloc_subobject)
1635     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1636       (sizeof (cpp_macro));
1637   else
1638     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1639   macro->line = pfile->directive_line;
1640   macro->params = 0;
1641   macro->paramc = 0;
1642   macro->variadic = 0;
1643   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1644   macro->count = 0;
1645   macro->fun_like = 0;
1646   /* To suppress some diagnostics.  */
1647   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1648
1649   if (CPP_OPTION (pfile, traditional))
1650     ok = _cpp_create_trad_definition (pfile, macro);
1651   else
1652     {
1653       ok = create_iso_definition (pfile, macro);
1654
1655       /* We set the type for SEEN_EOL() in directives.c.
1656
1657          Longer term we should lex the whole line before coming here,
1658          and just copy the expansion.  */
1659
1660       /* Stop the lexer accepting __VA_ARGS__.  */
1661       pfile->state.va_args_ok = 0;
1662     }
1663
1664   /* Clear the fast argument lookup indices.  */
1665   for (i = macro->paramc; i-- > 0; )
1666     {
1667       struct cpp_hashnode *node = macro->params[i];
1668       node->flags &= ~ NODE_MACRO_ARG;
1669       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1670     }
1671
1672   if (!ok)
1673     return ok;
1674
1675   if (node->type == NT_MACRO)
1676     {
1677       if (CPP_OPTION (pfile, warn_unused_macros))
1678         _cpp_warn_if_unused_macro (pfile, node, NULL);
1679
1680       if (warn_of_redefinition (pfile, node, macro))
1681         {
1682           cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1683                                "\"%s\" redefined", NODE_NAME (node));
1684
1685           if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1686             cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1687                                  node->value.macro->line, 0,
1688                          "this is the location of the previous definition");
1689         }
1690     }
1691
1692   if (node->type != NT_VOID)
1693     _cpp_free_definition (node);
1694
1695   /* Enter definition in hash table.  */
1696   node->type = NT_MACRO;
1697   node->value.macro = macro;
1698   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
1699       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1700       /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1701          in the C standard, as something that one must use in C++.
1702          However DR#593 indicates that these aren't actually mentioned
1703          in the C++ standard.  We special-case them anyway.  */
1704       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1705       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
1706     node->flags |= NODE_WARN;
1707
1708   return ok;
1709 }
1710
1711 /* Warn if a token in STRING matches one of a function-like MACRO's
1712    parameters.  */
1713 static void
1714 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1715                             const cpp_string *string)
1716 {
1717   unsigned int i, len;
1718   const uchar *p, *q, *limit;
1719
1720   /* Loop over the string.  */
1721   limit = string->text + string->len - 1;
1722   for (p = string->text + 1; p < limit; p = q)
1723     {
1724       /* Find the start of an identifier.  */
1725       while (p < limit && !is_idstart (*p))
1726         p++;
1727
1728       /* Find the end of the identifier.  */
1729       q = p;
1730       while (q < limit && is_idchar (*q))
1731         q++;
1732
1733       len = q - p;
1734
1735       /* Loop over the function macro arguments to see if the
1736          identifier inside the string matches one of them.  */
1737       for (i = 0; i < macro->paramc; i++)
1738         {
1739           const cpp_hashnode *node = macro->params[i];
1740
1741           if (NODE_LEN (node) == len
1742               && !memcmp (p, NODE_NAME (node), len))
1743             {
1744               cpp_error (pfile, CPP_DL_WARNING,
1745            "macro argument \"%s\" would be stringified in traditional C",
1746                          NODE_NAME (node));
1747               break;
1748             }
1749         }
1750     }
1751 }
1752
1753 /* Returns the name, arguments and expansion of a macro, in a format
1754    suitable to be read back in again, and therefore also for DWARF 2
1755    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1756    Caller is expected to generate the "#define" bit if needed.  The
1757    returned text is temporary, and automatically freed later.  */
1758 const unsigned char *
1759 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1760 {
1761   unsigned int i, len;
1762   const cpp_macro *macro = node->value.macro;
1763   unsigned char *buffer;
1764
1765   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1766     {
1767       cpp_error (pfile, CPP_DL_ICE,
1768                  "invalid hash type %d in cpp_macro_definition", node->type);
1769       return 0;
1770     }
1771
1772   /* Calculate length.  */
1773   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
1774   if (macro->fun_like)
1775     {
1776       len += 4;         /* "()" plus possible final ".." of named
1777                            varargs (we have + 1 below).  */
1778       for (i = 0; i < macro->paramc; i++)
1779         len += NODE_LEN (macro->params[i]) + 1; /* "," */
1780     }
1781
1782   /* This should match below where we fill in the buffer.  */
1783   if (CPP_OPTION (pfile, traditional))
1784     len += _cpp_replacement_text_len (macro);
1785   else
1786     {
1787       for (i = 0; i < macro->count; i++)
1788         {
1789           cpp_token *token = &macro->exp.tokens[i];
1790
1791           if (token->type == CPP_MACRO_ARG)
1792             len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1793           else
1794             len += cpp_token_len (token);
1795
1796           if (token->flags & STRINGIFY_ARG)
1797             len++;                      /* "#" */
1798           if (token->flags & PASTE_LEFT)
1799             len += 3;           /* " ##" */
1800           if (token->flags & PREV_WHITE)
1801             len++;              /* " " */
1802         }
1803     }
1804
1805   if (len > pfile->macro_buffer_len)
1806     {
1807       pfile->macro_buffer = XRESIZEVEC (unsigned char,
1808                                         pfile->macro_buffer, len);
1809       pfile->macro_buffer_len = len;
1810     }
1811
1812   /* Fill in the buffer.  Start with the macro name.  */
1813   buffer = pfile->macro_buffer;
1814   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1815   buffer += NODE_LEN (node);
1816
1817   /* Parameter names.  */
1818   if (macro->fun_like)
1819     {
1820       *buffer++ = '(';
1821       for (i = 0; i < macro->paramc; i++)
1822         {
1823           cpp_hashnode *param = macro->params[i];
1824
1825           if (param != pfile->spec_nodes.n__VA_ARGS__)
1826             {
1827               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1828               buffer += NODE_LEN (param);
1829             }
1830
1831           if (i + 1 < macro->paramc)
1832             /* Don't emit a space after the comma here; we're trying
1833                to emit a Dwarf-friendly definition, and the Dwarf spec
1834                forbids spaces in the argument list.  */
1835             *buffer++ = ',';
1836           else if (macro->variadic)
1837             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1838         }
1839       *buffer++ = ')';
1840     }
1841
1842   /* The Dwarf spec requires a space after the macro name, even if the
1843      definition is the empty string.  */
1844   *buffer++ = ' ';
1845
1846   if (CPP_OPTION (pfile, traditional))
1847     buffer = _cpp_copy_replacement_text (macro, buffer);
1848   else if (macro->count)
1849   /* Expansion tokens.  */
1850     {
1851       for (i = 0; i < macro->count; i++)
1852         {
1853           cpp_token *token = &macro->exp.tokens[i];
1854
1855           if (token->flags & PREV_WHITE)
1856             *buffer++ = ' ';
1857           if (token->flags & STRINGIFY_ARG)
1858             *buffer++ = '#';
1859
1860           if (token->type == CPP_MACRO_ARG)
1861             {
1862               memcpy (buffer,
1863                       NODE_NAME (macro->params[token->val.arg_no - 1]),
1864                       NODE_LEN (macro->params[token->val.arg_no - 1]));
1865               buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1866             }
1867           else
1868             buffer = cpp_spell_token (pfile, token, buffer, false);
1869
1870           if (token->flags & PASTE_LEFT)
1871             {
1872               *buffer++ = ' ';
1873               *buffer++ = '#';
1874               *buffer++ = '#';
1875               /* Next has PREV_WHITE; see _cpp_create_definition.  */
1876             }
1877         }
1878     }
1879
1880   *buffer = '\0';
1881   return pfile->macro_buffer;
1882 }