OSDN Git Service

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