OSDN Git Service

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