contrib/gcc-4.4/libcpp/macro.c

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