OSDN Git Service

Update comment for last commit.
[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_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.used_define)
839         pfile->cb.used_define (pfile, pfile->directive_line, node);
840     }
841
842   /* Handle standard macros.  */
843   if (! (node->flags & NODE_BUILTIN))
844     {
845       cpp_macro *macro = node->value.macro;
846       _cpp_buff *pragma_buff = NULL;
847
848       if (macro->fun_like)
849         {
850           _cpp_buff *buff;
851
852           pfile->state.prevent_expansion++;
853           pfile->keep_tokens++;
854           pfile->state.parsing_args = 1;
855           buff = funlike_invocation_p (pfile, node, &pragma_buff);
856           pfile->state.parsing_args = 0;
857           pfile->keep_tokens--;
858           pfile->state.prevent_expansion--;
859
860           if (buff == NULL)
861             {
862               if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
863                 cpp_warning (pfile, CPP_W_TRADITIONAL,
864  "function-like macro \"%s\" must be used with arguments in traditional C",
865                              NODE_NAME (node));
866
867               if (pragma_buff)
868                 _cpp_release_buff (pfile, pragma_buff);
869
870               return 0;
871             }
872
873           if (macro->paramc > 0)
874             replace_args (pfile, node, macro, (macro_arg *) buff->base);
875           _cpp_release_buff (pfile, buff);
876         }
877
878       /* Disable the macro within its expansion.  */
879       node->flags |= NODE_DISABLED;
880
881       if (!(node->flags & NODE_USED))
882         {
883           node->flags |= NODE_USED;
884           if (pfile->cb.used_define)
885             pfile->cb.used_define (pfile, pfile->directive_line, node);
886         }
887
888       if (pfile->cb.used)
889         pfile->cb.used (pfile, result->src_loc, node);
890
891       macro->used = 1;
892
893       if (macro->paramc == 0)
894         _cpp_push_token_context (pfile, node, macro->exp.tokens,
895                                  macro_real_token_count (macro));
896
897       if (pragma_buff)
898         {
899           if (!pfile->state.in_directive)
900             _cpp_push_token_context (pfile, NULL,
901                                      padding_token (pfile, result), 1);
902           do
903             {
904               _cpp_buff *tail = pragma_buff->next;
905               pragma_buff->next = NULL;
906               push_ptoken_context (pfile, NULL, pragma_buff,
907                                    (const cpp_token **) pragma_buff->base,
908                                    ((const cpp_token **) BUFF_FRONT (pragma_buff)
909                                     - (const cpp_token **) pragma_buff->base));
910               pragma_buff = tail;
911             }
912           while (pragma_buff != NULL);
913           return 2;
914         }
915
916       return 1;
917     }
918
919   /* Handle built-in macros and the _Pragma operator.  */
920   return builtin_macro (pfile, node);
921 }
922
923 /* Replace the parameters in a function-like macro of NODE with the
924    actual ARGS, and place the result in a newly pushed token context.
925    Expand each argument before replacing, unless it is operated upon
926    by the # or ## operators.  */
927 static void
928 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
929 {
930   unsigned int i, total;
931   const cpp_token *src, *limit;
932   const cpp_token **dest, **first;
933   macro_arg *arg;
934   _cpp_buff *buff;
935   unsigned int count;
936
937   /* First, fully macro-expand arguments, calculating the number of
938      tokens in the final expansion as we go.  The ordering of the if
939      statements below is subtle; we must handle stringification before
940      pasting.  */
941   count = macro_real_token_count (macro);
942   total = count;
943   limit = macro->exp.tokens + count;
944
945   for (src = macro->exp.tokens; src < limit; src++)
946     if (src->type == CPP_MACRO_ARG)
947       {
948         /* Leading and trailing padding tokens.  */
949         total += 2;
950
951         /* We have an argument.  If it is not being stringified or
952            pasted it is macro-replaced before insertion.  */
953         arg = &args[src->val.macro_arg.arg_no - 1];
954
955         if (src->flags & STRINGIFY_ARG)
956           {
957             if (!arg->stringified)
958               arg->stringified = stringify_arg (pfile, arg);
959           }
960         else if ((src->flags & PASTE_LEFT)
961                  || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
962           total += arg->count - 1;
963         else
964           {
965             if (!arg->expanded)
966               expand_arg (pfile, arg);
967             total += arg->expanded_count - 1;
968           }
969       }
970
971   /* Now allocate space for the expansion, copy the tokens and replace
972      the arguments.  */
973   buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
974   first = (const cpp_token **) buff->base;
975   dest = first;
976
977   for (src = macro->exp.tokens; src < limit; src++)
978     {
979       unsigned int count;
980       const cpp_token **from, **paste_flag;
981
982       if (src->type != CPP_MACRO_ARG)
983         {
984           *dest++ = src;
985           continue;
986         }
987
988       paste_flag = 0;
989       arg = &args[src->val.macro_arg.arg_no - 1];
990       if (src->flags & STRINGIFY_ARG)
991         count = 1, from = &arg->stringified;
992       else if (src->flags & PASTE_LEFT)
993         count = arg->count, from = arg->first;
994       else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
995         {
996           count = arg->count, from = arg->first;
997           if (dest != first)
998             {
999               if (dest[-1]->type == CPP_COMMA
1000                   && macro->variadic
1001                   && src->val.macro_arg.arg_no == macro->paramc)
1002                 {
1003                   /* Swallow a pasted comma if from == NULL, otherwise
1004                      drop the paste flag.  */
1005                   if (from == NULL)
1006                     dest--;
1007                   else
1008                     paste_flag = dest - 1;
1009                 }
1010               /* Remove the paste flag if the RHS is a placemarker.  */
1011               else if (count == 0)
1012                 paste_flag = dest - 1;
1013             }
1014         }
1015       else
1016         count = arg->expanded_count, from = arg->expanded;
1017
1018       /* Padding on the left of an argument (unless RHS of ##).  */
1019       if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
1020           && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
1021         *dest++ = padding_token (pfile, src);
1022
1023       if (count)
1024         {
1025           memcpy (dest, from, count * sizeof (cpp_token *));
1026           dest += count;
1027
1028           /* With a non-empty argument on the LHS of ##, the last
1029              token should be flagged PASTE_LEFT.  */
1030           if (src->flags & PASTE_LEFT)
1031             paste_flag = dest - 1;
1032         }
1033       else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1034                && ! CPP_OPTION (pfile, c99)
1035                && ! cpp_in_system_header (pfile))
1036         {
1037           cpp_error (pfile, CPP_DL_PEDWARN,
1038                      "invoking macro %s argument %d: "
1039                      "empty macro arguments are undefined"
1040                      " in ISO C90 and ISO C++98",
1041                      NODE_NAME (node),
1042                      src->val.macro_arg.arg_no);
1043         }
1044
1045       /* Avoid paste on RHS (even case count == 0).  */
1046       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1047         *dest++ = &pfile->avoid_paste;
1048
1049       /* Add a new paste flag, or remove an unwanted one.  */
1050       if (paste_flag)
1051         {
1052           cpp_token *token = _cpp_temp_token (pfile);
1053           token->type = (*paste_flag)->type;
1054           token->val = (*paste_flag)->val;
1055           if (src->flags & PASTE_LEFT)
1056             token->flags = (*paste_flag)->flags | PASTE_LEFT;
1057           else
1058             token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1059           *paste_flag = token;
1060         }
1061     }
1062
1063   /* Free the expanded arguments.  */
1064   for (i = 0; i < macro->paramc; i++)
1065     if (args[i].expanded)
1066       free (args[i].expanded);
1067
1068   push_ptoken_context (pfile, node, buff, first, dest - first);
1069 }
1070
1071 /* Return a special padding token, with padding inherited from SOURCE.  */
1072 static const cpp_token *
1073 padding_token (cpp_reader *pfile, const cpp_token *source)
1074 {
1075   cpp_token *result = _cpp_temp_token (pfile);
1076
1077   result->type = CPP_PADDING;
1078
1079   /* Data in GCed data structures cannot be made const so far, so we
1080      need a cast here.  */
1081   result->val.source = (cpp_token *) source;
1082   result->flags = 0;
1083   return result;
1084 }
1085
1086 /* Get a new uninitialized context.  Create a new one if we cannot
1087    re-use an old one.  */
1088 static cpp_context *
1089 next_context (cpp_reader *pfile)
1090 {
1091   cpp_context *result = pfile->context->next;
1092
1093   if (result == 0)
1094     {
1095       result = XNEW (cpp_context);
1096       result->prev = pfile->context;
1097       result->next = 0;
1098       pfile->context->next = result;
1099     }
1100
1101   pfile->context = result;
1102   return result;
1103 }
1104
1105 /* Push a list of pointers to tokens.  */
1106 static void
1107 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1108                      const cpp_token **first, unsigned int count)
1109 {
1110   cpp_context *context = next_context (pfile);
1111
1112   context->direct_p = false;
1113   context->macro = macro;
1114   context->buff = buff;
1115   FIRST (context).ptoken = first;
1116   LAST (context).ptoken = first + count;
1117 }
1118
1119 /* Push a list of tokens.  */
1120 void
1121 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1122                          const cpp_token *first, unsigned int count)
1123 {
1124   cpp_context *context = next_context (pfile);
1125
1126   context->direct_p = true;
1127   context->macro = macro;
1128   context->buff = NULL;
1129   FIRST (context).token = first;
1130   LAST (context).token = first + count;
1131 }
1132
1133 /* Push a traditional macro's replacement text.  */
1134 void
1135 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1136                         const uchar *start, size_t len)
1137 {
1138   cpp_context *context = next_context (pfile);
1139
1140   context->direct_p = true;
1141   context->macro = macro;
1142   context->buff = NULL;
1143   CUR (context) = start;
1144   RLIMIT (context) = start + len;
1145   macro->flags |= NODE_DISABLED;
1146 }
1147
1148 /* Expand an argument ARG before replacing parameters in a
1149    function-like macro.  This works by pushing a context with the
1150    argument's tokens, and then expanding that into a temporary buffer
1151    as if it were a normal part of the token stream.  collect_args()
1152    has terminated the argument's tokens with a CPP_EOF so that we know
1153    when we have fully expanded the argument.  */
1154 static void
1155 expand_arg (cpp_reader *pfile, macro_arg *arg)
1156 {
1157   unsigned int capacity;
1158   bool saved_warn_trad;
1159
1160   if (arg->count == 0)
1161     return;
1162
1163   /* Don't warn about funlike macros when pre-expanding.  */
1164   saved_warn_trad = CPP_WTRADITIONAL (pfile);
1165   CPP_WTRADITIONAL (pfile) = 0;
1166
1167   /* Loop, reading in the arguments.  */
1168   capacity = 256;
1169   arg->expanded = XNEWVEC (const cpp_token *, capacity);
1170
1171   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1172   for (;;)
1173     {
1174       const cpp_token *token;
1175
1176       if (arg->expanded_count + 1 >= capacity)
1177         {
1178           capacity *= 2;
1179           arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1180                                       capacity);
1181         }
1182
1183       token = cpp_get_token (pfile);
1184
1185       if (token->type == CPP_EOF)
1186         break;
1187
1188       arg->expanded[arg->expanded_count++] = token;
1189     }
1190
1191   _cpp_pop_context (pfile);
1192
1193   CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1194 }
1195
1196 /* Pop the current context off the stack, re-enabling the macro if the
1197    context represented a macro's replacement list.  The context
1198    structure is not freed so that we can re-use it later.  */
1199 void
1200 _cpp_pop_context (cpp_reader *pfile)
1201 {
1202   cpp_context *context = pfile->context;
1203
1204   if (context->macro)
1205     context->macro->flags &= ~NODE_DISABLED;
1206
1207   if (context->buff)
1208     _cpp_release_buff (pfile, context->buff);
1209
1210   pfile->context = context->prev;
1211 }
1212
1213 /* External routine to get a token.  Also used nearly everywhere
1214    internally, except for places where we know we can safely call
1215    _cpp_lex_token directly, such as lexing a directive name.
1216
1217    Macro expansions and directives are transparently handled,
1218    including entering included files.  Thus tokens are post-macro
1219    expansion, and after any intervening directives.  External callers
1220    see CPP_EOF only at EOF.  Internal callers also see it when meeting
1221    a directive inside a macro call, when at the end of a directive and
1222    state.in_directive is still 1, and at the end of argument
1223    pre-expansion.  */
1224 const cpp_token *
1225 cpp_get_token (cpp_reader *pfile)
1226 {
1227   const cpp_token *result;
1228   bool can_set = pfile->set_invocation_location;
1229   pfile->set_invocation_location = false;
1230
1231   for (;;)
1232     {
1233       cpp_hashnode *node;
1234       cpp_context *context = pfile->context;
1235
1236       /* Context->prev == 0 <=> base context.  */
1237       if (!context->prev)
1238         result = _cpp_lex_token (pfile);
1239       else if (FIRST (context).token != LAST (context).token)
1240         {
1241           if (context->direct_p)
1242             result = FIRST (context).token++;
1243           else
1244             result = *FIRST (context).ptoken++;
1245
1246           if (result->flags & PASTE_LEFT)
1247             {
1248               paste_all_tokens (pfile, result);
1249               if (pfile->state.in_directive)
1250                 continue;
1251               return padding_token (pfile, result);
1252             }
1253         }
1254       else
1255         {
1256           _cpp_pop_context (pfile);
1257           if (pfile->state.in_directive)
1258             continue;
1259           return &pfile->avoid_paste;
1260         }
1261
1262       if (pfile->state.in_directive && result->type == CPP_COMMENT)
1263         continue;
1264
1265       if (result->type != CPP_NAME)
1266         break;
1267
1268       node = result->val.node.node;
1269
1270       if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1271         break;
1272
1273       if (!(node->flags & NODE_DISABLED))
1274         {
1275           int ret = 0;
1276           /* If not in a macro context, and we're going to start an
1277              expansion, record the location.  */
1278           if (can_set && !context->macro)
1279             pfile->invocation_location = result->src_loc;
1280           if (pfile->state.prevent_expansion)
1281             break;
1282
1283           /* Conditional macros require that a predicate be evaluated
1284              first.  */
1285           if ((node->flags & NODE_CONDITIONAL) != 0)
1286             {
1287               if (pfile->cb.macro_to_expand)
1288                 {
1289                   bool whitespace_after;
1290                   const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
1291
1292                   whitespace_after = (peek_tok->type == CPP_PADDING
1293                                       || (peek_tok->flags & PREV_WHITE));
1294                   node = pfile->cb.macro_to_expand (pfile, result);
1295                   if (node)
1296                     ret = enter_macro_context (pfile, node, result);
1297                   else if (whitespace_after)
1298                     {
1299                       /* If macro_to_expand hook returned NULL and it
1300                          ate some tokens, see if we don't need to add
1301                          a padding token in between this and the
1302                          next token.  */
1303                       peek_tok = cpp_peek_token (pfile, 0);
1304                       if (peek_tok->type != CPP_PADDING
1305                           && (peek_tok->flags & PREV_WHITE) == 0)
1306                         _cpp_push_token_context (pfile, NULL,
1307                                                  padding_token (pfile,
1308                                                                 peek_tok), 1);
1309                     }
1310                 }
1311             }
1312           else
1313             ret = enter_macro_context (pfile, node, result);
1314           if (ret)
1315             {
1316               if (pfile->state.in_directive || ret == 2)
1317                 continue;
1318               return padding_token (pfile, result);
1319             }
1320         }
1321       else
1322         {
1323           /* Flag this token as always unexpandable.  FIXME: move this
1324              to collect_args()?.  */
1325           cpp_token *t = _cpp_temp_token (pfile);
1326           t->type = result->type;
1327           t->flags = result->flags | NO_EXPAND;
1328           t->val = result->val;
1329           result = t;
1330         }
1331
1332       break;
1333     }
1334
1335   return result;
1336 }
1337
1338 /* Like cpp_get_token, but also returns a location separate from the
1339    one provided by the returned token.  LOC is an out parameter; *LOC
1340    is set to the location "as expected by the user".  This matters
1341    when a token results from macro expansion -- the token's location
1342    will indicate where the macro is defined, but *LOC will be the
1343    location of the start of the expansion.  */
1344 const cpp_token *
1345 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1346 {
1347   const cpp_token *result;
1348
1349   pfile->set_invocation_location = true;
1350   result = cpp_get_token (pfile);
1351   if (pfile->context->macro)
1352     *loc = pfile->invocation_location;
1353   else
1354     *loc = result->src_loc;
1355
1356   return result;
1357 }
1358
1359 /* Returns true if we're expanding an object-like macro that was
1360    defined in a system header.  Just checks the macro at the top of
1361    the stack.  Used for diagnostic suppression.  */
1362 int
1363 cpp_sys_macro_p (cpp_reader *pfile)
1364 {
1365   cpp_hashnode *node = pfile->context->macro;
1366
1367   return node && node->value.macro && node->value.macro->syshdr;
1368 }
1369
1370 /* Read each token in, until end of the current file.  Directives are
1371    transparently processed.  */
1372 void
1373 cpp_scan_nooutput (cpp_reader *pfile)
1374 {
1375   /* Request a CPP_EOF token at the end of this file, rather than
1376      transparently continuing with the including file.  */
1377   pfile->buffer->return_at_eof = true;
1378
1379   pfile->state.discarding_output++;
1380   pfile->state.prevent_expansion++;
1381
1382   if (CPP_OPTION (pfile, traditional))
1383     while (_cpp_read_logical_line_trad (pfile))
1384       ;
1385   else
1386     while (cpp_get_token (pfile)->type != CPP_EOF)
1387       ;
1388
1389   pfile->state.discarding_output--;
1390   pfile->state.prevent_expansion--;
1391 }
1392
1393 /* Step back one or more tokens obtained from the lexer.  */
1394 void
1395 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
1396 {
1397   pfile->lookaheads += count;
1398   while (count--)
1399     {
1400       pfile->cur_token--;
1401       if (pfile->cur_token == pfile->cur_run->base
1402           /* Possible with -fpreprocessed and no leading #line.  */
1403           && pfile->cur_run->prev != NULL)
1404         {
1405           pfile->cur_run = pfile->cur_run->prev;
1406           pfile->cur_token = pfile->cur_run->limit;
1407         }
1408     }
1409 }
1410
1411 /* Step back one (or more) tokens.  Can only step back more than 1 if
1412    they are from the lexer, and not from macro expansion.  */
1413 void
1414 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1415 {
1416   if (pfile->context->prev == NULL)
1417     _cpp_backup_tokens_direct (pfile, count);
1418   else
1419     {
1420       if (count != 1)
1421         abort ();
1422       if (pfile->context->direct_p)
1423         FIRST (pfile->context).token--;
1424       else
1425         FIRST (pfile->context).ptoken--;
1426     }
1427 }
1428
1429 /* #define directive parsing and handling.  */
1430
1431 /* Returns nonzero if a macro redefinition warning is required.  */
1432 static bool
1433 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1434                       const cpp_macro *macro2)
1435 {
1436   const cpp_macro *macro1;
1437   unsigned int i;
1438
1439   /* Some redefinitions need to be warned about regardless.  */
1440   if (node->flags & NODE_WARN)
1441     return true;
1442
1443   /* Suppress warnings for builtins that lack the NODE_WARN flag.  */
1444   if (node->flags & NODE_BUILTIN)
1445     return false;
1446
1447   /* Redefinitions of conditional (context-sensitive) macros, on
1448      the other hand, must be allowed silently.  */
1449   if (node->flags & NODE_CONDITIONAL)
1450     return false;
1451
1452   /* Redefinition of a macro is allowed if and only if the old and new
1453      definitions are the same.  (6.10.3 paragraph 2).  */
1454   macro1 = node->value.macro;
1455
1456   /* Don't check count here as it can be different in valid
1457      traditional redefinitions with just whitespace differences.  */
1458   if (macro1->paramc != macro2->paramc
1459       || macro1->fun_like != macro2->fun_like
1460       || macro1->variadic != macro2->variadic)
1461     return true;
1462
1463   /* Check parameter spellings.  */
1464   for (i = 0; i < macro1->paramc; i++)
1465     if (macro1->params[i] != macro2->params[i])
1466       return true;
1467
1468   /* Check the replacement text or tokens.  */
1469   if (CPP_OPTION (pfile, traditional))
1470     return _cpp_expansions_different_trad (macro1, macro2);
1471
1472   if (macro1->count != macro2->count)
1473     return true;
1474
1475   for (i = 0; i < macro1->count; i++)
1476     if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1477       return true;
1478
1479   return false;
1480 }
1481
1482 /* Free the definition of hashnode H.  */
1483 void
1484 _cpp_free_definition (cpp_hashnode *h)
1485 {
1486   /* Macros and assertions no longer have anything to free.  */
1487   h->type = NT_VOID;
1488   /* Clear builtin flag in case of redefinition.  */
1489   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
1490 }
1491
1492 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1493    zero on success, nonzero if the parameter is a duplicate.  */
1494 bool
1495 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1496 {
1497   unsigned int len;
1498   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1499   if (node->flags & NODE_MACRO_ARG)
1500     {
1501       cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1502                  NODE_NAME (node));
1503       return true;
1504     }
1505
1506   if (BUFF_ROOM (pfile->a_buff)
1507       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1508     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1509
1510   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1511   node->flags |= NODE_MACRO_ARG;
1512   len = macro->paramc * sizeof (union _cpp_hashnode_value);
1513   if (len > pfile->macro_buffer_len)
1514     {
1515       pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1516                                         len);
1517       pfile->macro_buffer_len = len;
1518     }
1519   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1520     = node->value;
1521   
1522   node->value.arg_index  = macro->paramc;
1523   return false;
1524 }
1525
1526 /* Check the syntax of the parameters in a MACRO definition.  Returns
1527    false if an error occurs.  */
1528 static bool
1529 parse_params (cpp_reader *pfile, cpp_macro *macro)
1530 {
1531   unsigned int prev_ident = 0;
1532
1533   for (;;)
1534     {
1535       const cpp_token *token = _cpp_lex_token (pfile);
1536
1537       switch (token->type)
1538         {
1539         default:
1540           /* Allow/ignore comments in parameter lists if we are
1541              preserving comments in macro expansions.  */
1542           if (token->type == CPP_COMMENT
1543               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1544             continue;
1545
1546           cpp_error (pfile, CPP_DL_ERROR,
1547                      "\"%s\" may not appear in macro parameter list",
1548                      cpp_token_as_text (pfile, token));
1549           return false;
1550
1551         case CPP_NAME:
1552           if (prev_ident)
1553             {
1554               cpp_error (pfile, CPP_DL_ERROR,
1555                          "macro parameters must be comma-separated");
1556               return false;
1557             }
1558           prev_ident = 1;
1559
1560           if (_cpp_save_parameter (pfile, macro, token->val.node.node))
1561             return false;
1562           continue;
1563
1564         case CPP_CLOSE_PAREN:
1565           if (prev_ident || macro->paramc == 0)
1566             return true;
1567
1568           /* Fall through to pick up the error.  */
1569         case CPP_COMMA:
1570           if (!prev_ident)
1571             {
1572               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1573               return false;
1574             }
1575           prev_ident = 0;
1576           continue;
1577
1578         case CPP_ELLIPSIS:
1579           macro->variadic = 1;
1580           if (!prev_ident)
1581             {
1582               _cpp_save_parameter (pfile, macro,
1583                                    pfile->spec_nodes.n__VA_ARGS__);
1584               pfile->state.va_args_ok = 1;
1585               if (! CPP_OPTION (pfile, c99)
1586                   && CPP_OPTION (pfile, pedantic)
1587                   && CPP_OPTION (pfile, warn_variadic_macros))
1588                 cpp_pedwarning
1589                   (pfile, CPP_W_VARIADIC_MACROS,
1590                    "anonymous variadic macros were introduced in C99");
1591             }
1592           else if (CPP_OPTION (pfile, pedantic)
1593                    && CPP_OPTION (pfile, warn_variadic_macros))
1594             cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
1595                             "ISO C does not permit named variadic macros");
1596
1597           /* We're at the end, and just expect a closing parenthesis.  */
1598           token = _cpp_lex_token (pfile);
1599           if (token->type == CPP_CLOSE_PAREN)
1600             return true;
1601           /* Fall through.  */
1602
1603         case CPP_EOF:
1604           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1605           return false;
1606         }
1607     }
1608 }
1609
1610 /* Allocate room for a token from a macro's replacement list.  */
1611 static cpp_token *
1612 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1613 {
1614   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1615     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1616
1617   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1618 }
1619
1620 /* Lex a token from the expansion of MACRO, but mark parameters as we
1621    find them and warn of traditional stringification.  */
1622 static cpp_token *
1623 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1624 {
1625   cpp_token *token, *saved_cur_token;
1626
1627   saved_cur_token = pfile->cur_token;
1628   pfile->cur_token = alloc_expansion_token (pfile, macro);
1629   token = _cpp_lex_direct (pfile);
1630   pfile->cur_token = saved_cur_token;
1631
1632   /* Is this a parameter?  */
1633   if (token->type == CPP_NAME
1634       && (token->val.node.node->flags & NODE_MACRO_ARG) != 0)
1635     {
1636       token->type = CPP_MACRO_ARG;
1637       token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
1638     }
1639   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1640            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1641     check_trad_stringification (pfile, macro, &token->val.str);
1642
1643   return token;
1644 }
1645
1646 static bool
1647 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1648 {
1649   cpp_token *token;
1650   const cpp_token *ctoken;
1651   bool following_paste_op = false;
1652   const char *paste_op_error_msg =
1653     N_("'##' cannot appear at either end of a macro expansion");
1654   unsigned int num_extra_tokens = 0;
1655
1656   /* Get the first token of the expansion (or the '(' of a
1657      function-like macro).  */
1658   ctoken = _cpp_lex_token (pfile);
1659
1660   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1661     {
1662       bool ok = parse_params (pfile, macro);
1663       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1664       if (!ok)
1665         return false;
1666
1667       /* Success.  Commit or allocate the parameter array.  */
1668       if (pfile->hash_table->alloc_subobject)
1669         {
1670           cpp_hashnode **params =
1671             (cpp_hashnode **) pfile->hash_table->alloc_subobject
1672             (sizeof (cpp_hashnode *) * macro->paramc);
1673           memcpy (params, macro->params,
1674                   sizeof (cpp_hashnode *) * macro->paramc);
1675           macro->params = params;
1676         }
1677       else
1678         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1679       macro->fun_like = 1;
1680     }
1681   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1682     {
1683       /* While ISO C99 requires whitespace before replacement text
1684          in a macro definition, ISO C90 with TC1 allows there characters
1685          from the basic source character set.  */
1686       if (CPP_OPTION (pfile, c99))
1687         cpp_error (pfile, CPP_DL_PEDWARN,
1688                    "ISO C99 requires whitespace after the macro name");
1689       else
1690         {
1691           int warntype = CPP_DL_WARNING;
1692           switch (ctoken->type)
1693             {
1694             case CPP_ATSIGN:
1695             case CPP_AT_NAME:
1696             case CPP_OBJC_STRING:
1697               /* '@' is not in basic character set.  */
1698               warntype = CPP_DL_PEDWARN;
1699               break;
1700             case CPP_OTHER:
1701               /* Basic character set sans letters, digits and _.  */
1702               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1703                           ctoken->val.str.text[0]) == NULL)
1704                 warntype = CPP_DL_PEDWARN;
1705               break;
1706             default:
1707               /* All other tokens start with a character from basic
1708                  character set.  */
1709               break;
1710             }
1711           cpp_error (pfile, warntype,
1712                      "missing whitespace after the macro name");
1713         }
1714     }
1715
1716   if (macro->fun_like)
1717     token = lex_expansion_token (pfile, macro);
1718   else
1719     {
1720       token = alloc_expansion_token (pfile, macro);
1721       *token = *ctoken;
1722     }
1723
1724   for (;;)
1725     {
1726       /* Check the stringifying # constraint 6.10.3.2.1 of
1727          function-like macros when lexing the subsequent token.  */
1728       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1729         {
1730           if (token->type == CPP_MACRO_ARG)
1731             {
1732               if (token->flags & PREV_WHITE)
1733                 token->flags |= SP_PREV_WHITE;
1734               if (token[-1].flags & DIGRAPH)
1735                 token->flags |= SP_DIGRAPH;
1736               token->flags &= ~PREV_WHITE;
1737               token->flags |= STRINGIFY_ARG;
1738               token->flags |= token[-1].flags & PREV_WHITE;
1739               token[-1] = token[0];
1740               macro->count--;
1741             }
1742           /* Let assembler get away with murder.  */
1743           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1744             {
1745               cpp_error (pfile, CPP_DL_ERROR,
1746                          "'#' is not followed by a macro parameter");
1747               return false;
1748             }
1749         }
1750
1751       if (token->type == CPP_EOF)
1752         {
1753           /* Paste operator constraint 6.10.3.3.1:
1754              Token-paste ##, can appear in both object-like and
1755              function-like macros, but not at the end.  */
1756           if (following_paste_op)
1757             {
1758               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1759               return false;
1760             }
1761           break;
1762         }
1763
1764       /* Paste operator constraint 6.10.3.3.1.  */
1765       if (token->type == CPP_PASTE)
1766         {
1767           /* Token-paste ##, can appear in both object-like and
1768              function-like macros, but not at the beginning.  */
1769           if (macro->count == 1)
1770             {
1771               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1772               return false;
1773             }
1774
1775           if (token[-1].flags & PASTE_LEFT)
1776             {
1777               macro->extra_tokens = 1;
1778               num_extra_tokens++;
1779               token->val.token_no = macro->count - 1;
1780             }
1781           else
1782             {
1783               --macro->count;
1784               token[-1].flags |= PASTE_LEFT;
1785               if (token->flags & DIGRAPH)
1786                 token[-1].flags |= SP_DIGRAPH;
1787               if (token->flags & PREV_WHITE)
1788                 token[-1].flags |= SP_PREV_WHITE;
1789             }
1790         }
1791
1792       following_paste_op = (token->type == CPP_PASTE);
1793       token = lex_expansion_token (pfile, macro);
1794     }
1795
1796   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1797   macro->traditional = 0;
1798
1799   /* Don't count the CPP_EOF.  */
1800   macro->count--;
1801
1802   /* Clear whitespace on first token for warn_of_redefinition().  */
1803   if (macro->count)
1804     macro->exp.tokens[0].flags &= ~PREV_WHITE;
1805
1806   /* Commit or allocate the memory.  */
1807   if (pfile->hash_table->alloc_subobject)
1808     {
1809       cpp_token *tokns =
1810         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1811                                                           * macro->count);
1812       if (num_extra_tokens)
1813         {
1814           /* Place second and subsequent ## or %:%: tokens in
1815              sequences of consecutive such tokens at the end of the
1816              list to preserve information about where they appear, how
1817              they are spelt and whether they are preceded by
1818              whitespace without otherwise interfering with macro
1819              expansion.  */
1820           cpp_token *normal_dest = tokns;
1821           cpp_token *extra_dest = tokns + macro->count - num_extra_tokens;
1822           unsigned int i;
1823           for (i = 0; i < macro->count; i++)
1824             {
1825               if (macro->exp.tokens[i].type == CPP_PASTE)
1826                 *extra_dest++ = macro->exp.tokens[i];
1827               else
1828                 *normal_dest++ = macro->exp.tokens[i];
1829             }
1830         }
1831       else
1832         memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1833       macro->exp.tokens = tokns;
1834     }
1835   else
1836     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
1837
1838   return true;
1839 }
1840
1841 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
1842 bool
1843 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1844 {
1845   cpp_macro *macro;
1846   unsigned int i;
1847   bool ok;
1848
1849   if (pfile->hash_table->alloc_subobject)
1850     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1851       (sizeof (cpp_macro));
1852   else
1853     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1854   macro->line = pfile->directive_line;
1855   macro->params = 0;
1856   macro->paramc = 0;
1857   macro->variadic = 0;
1858   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1859   macro->count = 0;
1860   macro->fun_like = 0;
1861   macro->extra_tokens = 0;
1862   /* To suppress some diagnostics.  */
1863   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1864
1865   if (CPP_OPTION (pfile, traditional))
1866     ok = _cpp_create_trad_definition (pfile, macro);
1867   else
1868     {
1869       ok = create_iso_definition (pfile, macro);
1870
1871       /* We set the type for SEEN_EOL() in directives.c.
1872
1873          Longer term we should lex the whole line before coming here,
1874          and just copy the expansion.  */
1875
1876       /* Stop the lexer accepting __VA_ARGS__.  */
1877       pfile->state.va_args_ok = 0;
1878     }
1879
1880   /* Clear the fast argument lookup indices.  */
1881   for (i = macro->paramc; i-- > 0; )
1882     {
1883       struct cpp_hashnode *node = macro->params[i];
1884       node->flags &= ~ NODE_MACRO_ARG;
1885       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1886     }
1887
1888   if (!ok)
1889     return ok;
1890
1891   if (node->type == NT_MACRO)
1892     {
1893       if (CPP_OPTION (pfile, warn_unused_macros))
1894         _cpp_warn_if_unused_macro (pfile, node, NULL);
1895
1896       if (warn_of_redefinition (pfile, node, macro))
1897         {
1898           const int reason = (node->flags & NODE_BUILTIN)
1899                              ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
1900           bool warned;
1901
1902           warned = cpp_pedwarning_with_line (pfile, reason,
1903                                              pfile->directive_line, 0,
1904                                              "\"%s\" redefined",
1905                                              NODE_NAME (node));
1906
1907           if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1908             cpp_error_with_line (pfile, CPP_DL_NOTE,
1909                                  node->value.macro->line, 0,
1910                          "this is the location of the previous definition");
1911         }
1912     }
1913
1914   if (node->type != NT_VOID)
1915     _cpp_free_definition (node);
1916
1917   /* Enter definition in hash table.  */
1918   node->type = NT_MACRO;
1919   node->value.macro = macro;
1920   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
1921       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1922       /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1923          in the C standard, as something that one must use in C++.
1924          However DR#593 indicates that these aren't actually mentioned
1925          in the C++ standard.  We special-case them anyway.  */
1926       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1927       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
1928     node->flags |= NODE_WARN;
1929
1930   /* If user defines one of the conditional macros, remove the
1931      conditional flag */
1932   node->flags &= ~NODE_CONDITIONAL;
1933
1934   return ok;
1935 }
1936
1937 /* Warn if a token in STRING matches one of a function-like MACRO's
1938    parameters.  */
1939 static void
1940 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1941                             const cpp_string *string)
1942 {
1943   unsigned int i, len;
1944   const uchar *p, *q, *limit;
1945
1946   /* Loop over the string.  */
1947   limit = string->text + string->len - 1;
1948   for (p = string->text + 1; p < limit; p = q)
1949     {
1950       /* Find the start of an identifier.  */
1951       while (p < limit && !is_idstart (*p))
1952         p++;
1953
1954       /* Find the end of the identifier.  */
1955       q = p;
1956       while (q < limit && is_idchar (*q))
1957         q++;
1958
1959       len = q - p;
1960
1961       /* Loop over the function macro arguments to see if the
1962          identifier inside the string matches one of them.  */
1963       for (i = 0; i < macro->paramc; i++)
1964         {
1965           const cpp_hashnode *node = macro->params[i];
1966
1967           if (NODE_LEN (node) == len
1968               && !memcmp (p, NODE_NAME (node), len))
1969             {
1970               cpp_error (pfile, CPP_DL_WARNING,
1971            "macro argument \"%s\" would be stringified in traditional C",
1972                          NODE_NAME (node));
1973               break;
1974             }
1975         }
1976     }
1977 }
1978
1979 /* Returns the name, arguments and expansion of a macro, in a format
1980    suitable to be read back in again, and therefore also for DWARF 2
1981    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1982    Caller is expected to generate the "#define" bit if needed.  The
1983    returned text is temporary, and automatically freed later.  */
1984 const unsigned char *
1985 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1986 {
1987   unsigned int i, len;
1988   const cpp_macro *macro = node->value.macro;
1989   unsigned char *buffer;
1990
1991   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1992     {
1993       cpp_error (pfile, CPP_DL_ICE,
1994                  "invalid hash type %d in cpp_macro_definition", node->type);
1995       return 0;
1996     }
1997
1998   /* Calculate length.  */
1999   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
2000   if (macro->fun_like)
2001     {
2002       len += 4;         /* "()" plus possible final ".." of named
2003                            varargs (we have + 1 below).  */
2004       for (i = 0; i < macro->paramc; i++)
2005         len += NODE_LEN (macro->params[i]) + 1; /* "," */
2006     }
2007
2008   /* This should match below where we fill in the buffer.  */
2009   if (CPP_OPTION (pfile, traditional))
2010     len += _cpp_replacement_text_len (macro);
2011   else
2012     {
2013       unsigned int count = macro_real_token_count (macro);
2014       for (i = 0; i < count; i++)
2015         {
2016           cpp_token *token = &macro->exp.tokens[i];
2017
2018           if (token->type == CPP_MACRO_ARG)
2019             len += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
2020           else
2021             len += cpp_token_len (token);
2022
2023           if (token->flags & STRINGIFY_ARG)
2024             len++;                      /* "#" */
2025           if (token->flags & PASTE_LEFT)
2026             len += 3;           /* " ##" */
2027           if (token->flags & PREV_WHITE)
2028             len++;              /* " " */
2029         }
2030     }
2031
2032   if (len > pfile->macro_buffer_len)
2033     {
2034       pfile->macro_buffer = XRESIZEVEC (unsigned char,
2035                                         pfile->macro_buffer, len);
2036       pfile->macro_buffer_len = len;
2037     }
2038
2039   /* Fill in the buffer.  Start with the macro name.  */
2040   buffer = pfile->macro_buffer;
2041   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
2042   buffer += NODE_LEN (node);
2043
2044   /* Parameter names.  */
2045   if (macro->fun_like)
2046     {
2047       *buffer++ = '(';
2048       for (i = 0; i < macro->paramc; i++)
2049         {
2050           cpp_hashnode *param = macro->params[i];
2051
2052           if (param != pfile->spec_nodes.n__VA_ARGS__)
2053             {
2054               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
2055               buffer += NODE_LEN (param);
2056             }
2057
2058           if (i + 1 < macro->paramc)
2059             /* Don't emit a space after the comma here; we're trying
2060                to emit a Dwarf-friendly definition, and the Dwarf spec
2061                forbids spaces in the argument list.  */
2062             *buffer++ = ',';
2063           else if (macro->variadic)
2064             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
2065         }
2066       *buffer++ = ')';
2067     }
2068
2069   /* The Dwarf spec requires a space after the macro name, even if the
2070      definition is the empty string.  */
2071   *buffer++ = ' ';
2072
2073   if (CPP_OPTION (pfile, traditional))
2074     buffer = _cpp_copy_replacement_text (macro, buffer);
2075   else if (macro->count)
2076   /* Expansion tokens.  */
2077     {
2078       unsigned int count = macro_real_token_count (macro);
2079       for (i = 0; i < count; i++)
2080         {
2081           cpp_token *token = &macro->exp.tokens[i];
2082
2083           if (token->flags & PREV_WHITE)
2084             *buffer++ = ' ';
2085           if (token->flags & STRINGIFY_ARG)
2086             *buffer++ = '#';
2087
2088           if (token->type == CPP_MACRO_ARG)
2089             {
2090               memcpy (buffer,
2091                       NODE_NAME (macro->params[token->val.macro_arg.arg_no - 1]),
2092                       NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]));
2093               buffer += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
2094             }
2095           else
2096             buffer = cpp_spell_token (pfile, token, buffer, false);
2097
2098           if (token->flags & PASTE_LEFT)
2099             {
2100               *buffer++ = ' ';
2101               *buffer++ = '#';
2102               *buffer++ = '#';
2103               /* Next has PREV_WHITE; see _cpp_create_definition.  */
2104             }
2105         }
2106     }
2107
2108   *buffer = '\0';
2109   return pfile->macro_buffer;
2110 }