OSDN Git Service

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