OSDN Git Service

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