libcpp/macro.c

   1 /* Part of CPP library.  (Macro and #define handling.)
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005,
   4    2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   5    Written by Per Bothner, 1994.
   6    Based on CCCP program by Paul Rubin, June 1986
   7    Adapted to ANSI C, Richard Stallman, Jan 1987
   8
   9 This program is free software; you can redistribute it and/or modify it
  10 under the terms of the GNU General Public License as published by the
  11 Free Software Foundation; either version 3, or (at your option) any
  12 later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.
  22
  23  In other words, you are welcome to use, share and improve this program.
  24  You are forbidden to forbid anyone else to use, share and improve
  25  what you give them.   Help stamp out software-hoarding!  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "cpplib.h"
  30 #include "internal.h"
  31
  32 typedef struct macro_arg macro_arg;
  33 struct macro_arg
  34 {
  35   const cpp_token **first;      /* First token in unexpanded argument.  */
  36   const cpp_token **expanded;   /* Macro-expanded argument.  */
  37   const cpp_token *stringified; /* Stringified argument.  */
  38   unsigned int count;           /* # of tokens in argument.  */
  39   unsigned int expanded_count;  /* # of tokens in expanded argument.  */
  40 };
  41
  42 /* Macro expansion.  */
  43
  44 static int enter_macro_context (cpp_reader *, cpp_hashnode *,
  45                                 const cpp_token *);
  46 static int builtin_macro (cpp_reader *, cpp_hashnode *);
  47 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
  48                                  const cpp_token **, unsigned int);
  49 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
  50                                 _cpp_buff **);
  51 static cpp_context *next_context (cpp_reader *);
  52 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
  53 static void expand_arg (cpp_reader *, macro_arg *);
  54 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
  55 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
  56 static void paste_all_tokens (cpp_reader *, const cpp_token *);
  57 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
  58 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
  59                           macro_arg *);
  60 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
  61                                         _cpp_buff **);
  62 static bool create_iso_definition (cpp_reader *, cpp_macro *);
  63
  64 /* #define directive parsing and handling.  */
  65
  66 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
  67 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
  68 static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,
  69                                   const cpp_macro *);
  70 static bool parse_params (cpp_reader *, cpp_macro *);
  71 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
  72                                         const cpp_string *);
  73
  74 /* Emits a warning if NODE is a macro defined in the main file that
  75    has not been used.  */
  76 int
  77 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
  78                            void *v ATTRIBUTE_UNUSED)
  79 {
  80   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
  81     {
  82       cpp_macro *macro = node->value.macro;
  83
  84       if (!macro->used
  85           && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
  86         cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
  87                              "macro \"%s\" is not used", NODE_NAME (node));
  88     }
  89
  90   return 1;
  91 }
  92
  93 /* Allocates and returns a CPP_STRING token, containing TEXT of length
  94    LEN, after null-terminating it.  TEXT must be in permanent storage.  */
  95 static const cpp_token *
  96 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
  97 {
  98   cpp_token *token = _cpp_temp_token (pfile);
  99
 100   text[len] = '\0';
 101   token->type = CPP_STRING;
 102   token->val.str.len = len;
 103   token->val.str.text = text;
 104   token->flags = 0;
 105   return token;
 106 }
 107
 108 static const char * const monthnames[] =
 109 {
 110   "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 111   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 112 };
 113
 114 /* Helper function for builtin_macro.  Returns the text generated by
 115    a builtin macro. */
 116 const uchar *
 117 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
 118 {
 119   const struct line_map *map;
 120   const uchar *result = NULL;
 121   linenum_type number = 1;
 122
 123   switch (node->value.builtin)
 124     {
 125     default:
 126       cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
 127                  NODE_NAME (node));
 128       break;
 129
 130     case BT_TIMESTAMP:
 131       {
 132         cpp_buffer *pbuffer = cpp_get_buffer (pfile);
 133         if (pbuffer->timestamp == NULL)
 134           {
 135             /* Initialize timestamp value of the assotiated file. */
 136             struct _cpp_file *file = cpp_get_file (pbuffer);
 137             if (file)
 138               {
 139                 /* Generate __TIMESTAMP__ string, that represents
 140                    the date and time of the last modification
 141                    of the current source file. The string constant
 142                    looks like "Sun Sep 16 01:03:52 1973".  */
 143                 struct tm *tb = NULL;
 144                 struct stat *st = _cpp_get_file_stat (file);
 145                 if (st)
 146                   tb = localtime (&st->st_mtime);
 147                 if (tb)
 148                   {
 149                     char *str = asctime (tb);
 150                     size_t len = strlen (str);
 151                     unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
 152                     buf[0] = '"';
 153                     strcpy ((char *) buf + 1, str);
 154                     buf[len] = '"';
 155                     pbuffer->timestamp = buf;
 156                   }
 157                 else
 158                   {
 159                     cpp_errno (pfile, CPP_DL_WARNING,
 160                         "could not determine file timestamp");
 161                     pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";
 162                   }
 163               }
 164           }
 165         result = pbuffer->timestamp;
 166       }
 167       break;
 168     case BT_FILE:
 169     case BT_BASE_FILE:
 170       {
 171         unsigned int len;
 172         const char *name;
 173         uchar *buf;
 174         map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
 175
 176         if (node->value.builtin == BT_BASE_FILE)
 177           while (! MAIN_FILE_P (map))
 178             map = INCLUDED_FROM (pfile->line_table, map);
 179
 180         name = map->to_file;
 181         len = strlen (name);
 182         buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
 183         result = buf;
 184         *buf = '"';
 185         buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
 186         *buf++ = '"';
 187         *buf = '\0';
 188       }
 189       break;
 190
 191     case BT_INCLUDE_LEVEL:
 192       /* The line map depth counts the primary source as level 1, but
 193          historically __INCLUDE_DEPTH__ has called the primary source
 194          level 0.  */
 195       number = pfile->line_table->depth - 1;
 196       break;
 197
 198     case BT_SPECLINE:
 199       map = &pfile->line_table->maps[pfile->line_table->used-1];
 200       /* If __LINE__ is embedded in a macro, it must expand to the
 201          line of the macro's invocation, not its definition.
 202          Otherwise things like assert() will not work properly.  */
 203       number = SOURCE_LINE (map,
 204                             CPP_OPTION (pfile, traditional)
 205                             ? pfile->line_table->highest_line
 206                             : pfile->cur_token[-1].src_loc);
 207       break;
 208
 209       /* __STDC__ has the value 1 under normal circumstances.
 210          However, if (a) we are in a system header, (b) the option
 211          stdc_0_in_system_headers is true (set by target config), and
 212          (c) we are not in strictly conforming mode, then it has the
 213          value 0.  (b) and (c) are already checked in cpp_init_builtins.  */
 214     case BT_STDC:
 215       if (cpp_in_system_header (pfile))
 216         number = 0;
 217       else
 218         number = 1;
 219       break;
 220
 221     case BT_DATE:
 222     case BT_TIME:
 223       if (pfile->date == NULL)
 224         {
 225           /* Allocate __DATE__ and __TIME__ strings from permanent
 226              storage.  We only do this once, and don't generate them
 227              at init time, because time() and localtime() are very
 228              slow on some systems.  */
 229           time_t tt;
 230           struct tm *tb = NULL;
 231
 232           /* (time_t) -1 is a legitimate value for "number of seconds
 233              since the Epoch", so we have to do a little dance to
 234              distinguish that from a genuine error.  */
 235           errno = 0;
 236           tt = time(NULL);
 237           if (tt != (time_t)-1 || errno == 0)
 238             tb = localtime (&tt);
 239
 240           if (tb)
 241             {
 242               pfile->date = _cpp_unaligned_alloc (pfile,
 243                                                   sizeof ("\"Oct 11 1347\""));
 244               sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
 245                        monthnames[tb->tm_mon], tb->tm_mday,
 246                        tb->tm_year + 1900);
 247
 248               pfile->time = _cpp_unaligned_alloc (pfile,
 249                                                   sizeof ("\"12:34:56\""));
 250               sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
 251                        tb->tm_hour, tb->tm_min, tb->tm_sec);
 252             }
 253           else
 254             {
 255               cpp_errno (pfile, CPP_DL_WARNING,
 256                          "could not determine date and time");
 257
 258               pfile->date = UC"\"??? ?? ????\"";
 259               pfile->time = UC"\"??:??:??\"";
 260             }
 261         }
 262
 263       if (node->value.builtin == BT_DATE)
 264         result = pfile->date;
 265       else
 266         result = pfile->time;
 267       break;
 268
 269     case BT_COUNTER:
 270       if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
 271         cpp_error (pfile, CPP_DL_ERROR,
 272             "__COUNTER__ expanded inside directive with -fdirectives-only");
 273       number = pfile->counter++;
 274       break;
 275     }
 276
 277   if (result == NULL)
 278     {
 279       /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers.  */
 280       result = _cpp_unaligned_alloc (pfile, 21);
 281       sprintf ((char *) result, "%u", number);
 282     }
 283
 284   return result;
 285 }
 286
 287 /* Convert builtin macros like __FILE__ to a token and push it on the
 288    context stack.  Also handles _Pragma, for which a new token may not
 289    be created.  Returns 1 if it generates a new token context, 0 to
 290    return the token to the caller.  */
 291 static int
 292 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
 293 {
 294   const uchar *buf;
 295   size_t len;
 296   char *nbuf;
 297
 298   if (node->value.builtin == BT_PRAGMA)
 299     {
 300       /* Don't interpret _Pragma within directives.  The standard is
 301          not clear on this, but to me this makes most sense.  */
 302       if (pfile->state.in_directive)
 303         return 0;
 304
 305       return _cpp_do__Pragma (pfile);
 306     }
 307
 308   buf = _cpp_builtin_macro_text (pfile, node);
 309   len = ustrlen (buf);
 310   nbuf = (char *) alloca (len + 1);
 311   memcpy (nbuf, buf, len);
 312   nbuf[len]='\n';
 313
 314   cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
 315   _cpp_clean_line (pfile);
 316
 317   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
 318   pfile->cur_token = _cpp_temp_token (pfile);
 319   _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
 320   if (pfile->buffer->cur != pfile->buffer->rlimit)
 321     cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
 322                NODE_NAME (node));
 323   _cpp_pop_buffer (pfile);
 324
 325   return 1;
 326 }
 327
 328 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
 329    backslashes and double quotes. DEST must be of sufficient size.
 330    Returns a pointer to the end of the string.  */
 331 uchar *
 332 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
 333 {
 334   while (len--)
 335     {
 336       uchar c = *src++;
 337
 338       if (c == '\\' || c == '"')
 339         {
 340           *dest++ = '\\';
 341           *dest++ = c;
 342         }
 343       else
 344           *dest++ = c;
 345     }
 346
 347   return dest;
 348 }
 349
 350 /* Convert a token sequence ARG to a single string token according to
 351    the rules of the ISO C #-operator.  */
 352 static const cpp_token *
 353 stringify_arg (cpp_reader *pfile, macro_arg *arg)
 354 {
 355   unsigned char *dest;
 356   unsigned int i, escape_it, backslash_count = 0;
 357   const cpp_token *source = NULL;
 358   size_t len;
 359
 360   if (BUFF_ROOM (pfile->u_buff) < 3)
 361     _cpp_extend_buff (pfile, &pfile->u_buff, 3);
 362   dest = BUFF_FRONT (pfile->u_buff);
 363   *dest++ = '"';
 364
 365   /* Loop, reading in the argument's tokens.  */
 366   for (i = 0; i < arg->count; i++)
 367     {
 368       const cpp_token *token = arg->first[i];
 369
 370       if (token->type == CPP_PADDING)
 371         {
 372           if (source == NULL
 373               || (!(source->flags & PREV_WHITE)
 374                   && token->val.source == NULL))
 375             source = token->val.source;
 376           continue;
 377         }
 378
 379       escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR
 380                    || token->type == CPP_WSTRING || token->type == CPP_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_error (pfile, CPP_DL_WARNING,
 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       macro->used = 1;
 889
 890       if (macro->paramc == 0)
 891         _cpp_push_token_context (pfile, node, macro->exp.tokens,
 892                                  macro_real_token_count (macro));
 893
 894       if (pragma_buff)
 895         {
 896           if (!pfile->state.in_directive)
 897             _cpp_push_token_context (pfile, NULL,
 898                                      padding_token (pfile, result), 1);
 899           do
 900             {
 901               _cpp_buff *tail = pragma_buff->next;
 902               pragma_buff->next = NULL;
 903               push_ptoken_context (pfile, NULL, pragma_buff,
 904                                    (const cpp_token **) pragma_buff->base,
 905                                    ((const cpp_token **) BUFF_FRONT (pragma_buff)
 906                                     - (const cpp_token **) pragma_buff->base));
 907               pragma_buff = tail;
 908             }
 909           while (pragma_buff != NULL);
 910           return 2;
 911         }
 912
 913       return 1;
 914     }
 915
 916   /* Handle built-in macros and the _Pragma operator.  */
 917   return builtin_macro (pfile, node);
 918 }
 919
 920 /* Replace the parameters in a function-like macro of NODE with the
 921    actual ARGS, and place the result in a newly pushed token context.
 922    Expand each argument before replacing, unless it is operated upon
 923    by the # or ## operators.  */
 924 static void
 925 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
 926 {
 927   unsigned int i, total;
 928   const cpp_token *src, *limit;
 929   const cpp_token **dest, **first;
 930   macro_arg *arg;
 931   _cpp_buff *buff;
 932   unsigned int count;
 933
 934   /* First, fully macro-expand arguments, calculating the number of
 935      tokens in the final expansion as we go.  The ordering of the if
 936      statements below is subtle; we must handle stringification before
 937      pasting.  */
 938   count = macro_real_token_count (macro);
 939   total = count;
 940   limit = macro->exp.tokens + count;
 941
 942   for (src = macro->exp.tokens; src < limit; src++)
 943     if (src->type == CPP_MACRO_ARG)
 944       {
 945         /* Leading and trailing padding tokens.  */
 946         total += 2;
 947
 948         /* We have an argument.  If it is not being stringified or
 949            pasted it is macro-replaced before insertion.  */
 950         arg = &args[src->val.macro_arg.arg_no - 1];
 951
 952         if (src->flags & STRINGIFY_ARG)
 953           {
 954             if (!arg->stringified)
 955               arg->stringified = stringify_arg (pfile, arg);
 956           }
 957         else if ((src->flags & PASTE_LEFT)
 958                  || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
 959           total += arg->count - 1;
 960         else
 961           {
 962             if (!arg->expanded)
 963               expand_arg (pfile, arg);
 964             total += arg->expanded_count - 1;
 965           }
 966       }
 967
 968   /* Now allocate space for the expansion, copy the tokens and replace
 969      the arguments.  */
 970   buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
 971   first = (const cpp_token **) buff->base;
 972   dest = first;
 973
 974   for (src = macro->exp.tokens; src < limit; src++)
 975     {
 976       unsigned int count;
 977       const cpp_token **from, **paste_flag;
 978
 979       if (src->type != CPP_MACRO_ARG)
 980         {
 981           *dest++ = src;
 982           continue;
 983         }
 984
 985       paste_flag = 0;
 986       arg = &args[src->val.macro_arg.arg_no - 1];
 987       if (src->flags & STRINGIFY_ARG)
 988         count = 1, from = &arg->stringified;
 989       else if (src->flags & PASTE_LEFT)
 990         count = arg->count, from = arg->first;
 991       else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
 992         {
 993           count = arg->count, from = arg->first;
 994           if (dest != first)
 995             {
 996               if (dest[-1]->type == CPP_COMMA
 997                   && macro->variadic
 998                   && src->val.macro_arg.arg_no == macro->paramc)
 999                 {
1000                   /* Swallow a pasted comma if from == NULL, otherwise
1001                      drop the paste flag.  */
1002                   if (from == NULL)
1003                     dest--;
1004                   else
1005                     paste_flag = dest - 1;
1006                 }
1007               /* Remove the paste flag if the RHS is a placemarker.  */
1008               else if (count == 0)
1009                 paste_flag = dest - 1;
1010             }
1011         }
1012       else
1013         count = arg->expanded_count, from = arg->expanded;
1014
1015       /* Padding on the left of an argument (unless RHS of ##).  */
1016       if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
1017           && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
1018         *dest++ = padding_token (pfile, src);
1019
1020       if (count)
1021         {
1022           memcpy (dest, from, count * sizeof (cpp_token *));
1023           dest += count;
1024
1025           /* With a non-empty argument on the LHS of ##, the last
1026              token should be flagged PASTE_LEFT.  */
1027           if (src->flags & PASTE_LEFT)
1028             paste_flag = dest - 1;
1029         }
1030       else if (CPP_PEDANTIC (pfile) && ! macro->syshdr
1031                && ! CPP_OPTION (pfile, c99)
1032                && ! cpp_in_system_header (pfile))
1033         {
1034           cpp_error (pfile, CPP_DL_PEDWARN,
1035                      "invoking macro %s argument %d: "
1036                      "empty macro arguments are undefined"
1037                      " in ISO C90 and ISO C++98",
1038                      NODE_NAME (node),
1039                      src->val.macro_arg.arg_no);
1040         }
1041
1042       /* Avoid paste on RHS (even case count == 0).  */
1043       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
1044         *dest++ = &pfile->avoid_paste;
1045
1046       /* Add a new paste flag, or remove an unwanted one.  */
1047       if (paste_flag)
1048         {
1049           cpp_token *token = _cpp_temp_token (pfile);
1050           token->type = (*paste_flag)->type;
1051           token->val = (*paste_flag)->val;
1052           if (src->flags & PASTE_LEFT)
1053             token->flags = (*paste_flag)->flags | PASTE_LEFT;
1054           else
1055             token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
1056           *paste_flag = token;
1057         }
1058     }
1059
1060   /* Free the expanded arguments.  */
1061   for (i = 0; i < macro->paramc; i++)
1062     if (args[i].expanded)
1063       free (args[i].expanded);
1064
1065   push_ptoken_context (pfile, node, buff, first, dest - first);
1066 }
1067
1068 /* Return a special padding token, with padding inherited from SOURCE.  */
1069 static const cpp_token *
1070 padding_token (cpp_reader *pfile, const cpp_token *source)
1071 {
1072   cpp_token *result = _cpp_temp_token (pfile);
1073
1074   result->type = CPP_PADDING;
1075
1076   /* Data in GCed data structures cannot be made const so far, so we
1077      need a cast here.  */
1078   result->val.source = (cpp_token *) source;
1079   result->flags = 0;
1080   return result;
1081 }
1082
1083 /* Get a new uninitialized context.  Create a new one if we cannot
1084    re-use an old one.  */
1085 static cpp_context *
1086 next_context (cpp_reader *pfile)
1087 {
1088   cpp_context *result = pfile->context->next;
1089
1090   if (result == 0)
1091     {
1092       result = XNEW (cpp_context);
1093       result->prev = pfile->context;
1094       result->next = 0;
1095       pfile->context->next = result;
1096     }
1097
1098   pfile->context = result;
1099   return result;
1100 }
1101
1102 /* Push a list of pointers to tokens.  */
1103 static void
1104 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
1105                      const cpp_token **first, unsigned int count)
1106 {
1107   cpp_context *context = next_context (pfile);
1108
1109   context->direct_p = false;
1110   context->macro = macro;
1111   context->buff = buff;
1112   FIRST (context).ptoken = first;
1113   LAST (context).ptoken = first + count;
1114 }
1115
1116 /* Push a list of tokens.  */
1117 void
1118 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
1119                          const cpp_token *first, unsigned int count)
1120 {
1121   cpp_context *context = next_context (pfile);
1122
1123   context->direct_p = true;
1124   context->macro = macro;
1125   context->buff = NULL;
1126   FIRST (context).token = first;
1127   LAST (context).token = first + count;
1128 }
1129
1130 /* Push a traditional macro's replacement text.  */
1131 void
1132 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1133                         const uchar *start, size_t len)
1134 {
1135   cpp_context *context = next_context (pfile);
1136
1137   context->direct_p = true;
1138   context->macro = macro;
1139   context->buff = NULL;
1140   CUR (context) = start;
1141   RLIMIT (context) = start + len;
1142   macro->flags |= NODE_DISABLED;
1143 }
1144
1145 /* Expand an argument ARG before replacing parameters in a
1146    function-like macro.  This works by pushing a context with the
1147    argument's tokens, and then expanding that into a temporary buffer
1148    as if it were a normal part of the token stream.  collect_args()
1149    has terminated the argument's tokens with a CPP_EOF so that we know
1150    when we have fully expanded the argument.  */
1151 static void
1152 expand_arg (cpp_reader *pfile, macro_arg *arg)
1153 {
1154   unsigned int capacity;
1155   bool saved_warn_trad;
1156
1157   if (arg->count == 0)
1158     return;
1159
1160   /* Don't warn about funlike macros when pre-expanding.  */
1161   saved_warn_trad = CPP_WTRADITIONAL (pfile);
1162   CPP_WTRADITIONAL (pfile) = 0;
1163
1164   /* Loop, reading in the arguments.  */
1165   capacity = 256;
1166   arg->expanded = XNEWVEC (const cpp_token *, capacity);
1167
1168   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1169   for (;;)
1170     {
1171       const cpp_token *token;
1172
1173       if (arg->expanded_count + 1 >= capacity)
1174         {
1175           capacity *= 2;
1176           arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1177                                       capacity);
1178         }
1179
1180       token = cpp_get_token (pfile);
1181
1182       if (token->type == CPP_EOF)
1183         break;
1184
1185       arg->expanded[arg->expanded_count++] = token;
1186     }
1187
1188   _cpp_pop_context (pfile);
1189
1190   CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1191 }
1192
1193 /* Pop the current context off the stack, re-enabling the macro if the
1194    context represented a macro's replacement list.  The context
1195    structure is not freed so that we can re-use it later.  */
1196 void
1197 _cpp_pop_context (cpp_reader *pfile)
1198 {
1199   cpp_context *context = pfile->context;
1200
1201   if (context->macro)
1202     context->macro->flags &= ~NODE_DISABLED;
1203
1204   if (context->buff)
1205     _cpp_release_buff (pfile, context->buff);
1206
1207   pfile->context = context->prev;
1208 }
1209
1210 /* External routine to get a token.  Also used nearly everywhere
1211    internally, except for places where we know we can safely call
1212    _cpp_lex_token directly, such as lexing a directive name.
1213
1214    Macro expansions and directives are transparently handled,
1215    including entering included files.  Thus tokens are post-macro
1216    expansion, and after any intervening directives.  External callers
1217    see CPP_EOF only at EOF.  Internal callers also see it when meeting
1218    a directive inside a macro call, when at the end of a directive and
1219    state.in_directive is still 1, and at the end of argument
1220    pre-expansion.  */
1221 const cpp_token *
1222 cpp_get_token (cpp_reader *pfile)
1223 {
1224   const cpp_token *result;
1225   bool can_set = pfile->set_invocation_location;
1226   pfile->set_invocation_location = false;
1227
1228   for (;;)
1229     {
1230       cpp_hashnode *node;
1231       cpp_context *context = pfile->context;
1232
1233       /* Context->prev == 0 <=> base context.  */
1234       if (!context->prev)
1235         result = _cpp_lex_token (pfile);
1236       else if (FIRST (context).token != LAST (context).token)
1237         {
1238           if (context->direct_p)
1239             result = FIRST (context).token++;
1240           else
1241             result = *FIRST (context).ptoken++;
1242
1243           if (result->flags & PASTE_LEFT)
1244             {
1245               paste_all_tokens (pfile, result);
1246               if (pfile->state.in_directive)
1247                 continue;
1248               return padding_token (pfile, result);
1249             }
1250         }
1251       else
1252         {
1253           _cpp_pop_context (pfile);
1254           if (pfile->state.in_directive)
1255             continue;
1256           return &pfile->avoid_paste;
1257         }
1258
1259       if (pfile->state.in_directive && result->type == CPP_COMMENT)
1260         continue;
1261
1262       if (result->type != CPP_NAME)
1263         break;
1264
1265       node = result->val.node.node;
1266
1267       if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1268         break;
1269
1270       if (!(node->flags & NODE_DISABLED))
1271         {
1272           int ret = 0;
1273           /* If not in a macro context, and we're going to start an
1274              expansion, record the location.  */
1275           if (can_set && !context->macro)
1276             pfile->invocation_location = result->src_loc;
1277           if (pfile->state.prevent_expansion)
1278             break;
1279
1280           /* Conditional macros require that a predicate be evaluated
1281              first.  */
1282           if ((node->flags & NODE_CONDITIONAL) != 0)
1283             {
1284               if (pfile->cb.macro_to_expand)
1285                 {
1286                   bool whitespace_after;
1287                   const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
1288
1289                   whitespace_after = (peek_tok->type == CPP_PADDING
1290                                       || (peek_tok->flags & PREV_WHITE));
1291                   node = pfile->cb.macro_to_expand (pfile, result);
1292                   if (node)
1293                     ret = enter_macro_context (pfile, node, result);
1294                   else if (whitespace_after)
1295                     {
1296                       /* If macro_to_expand hook returned NULL and it
1297                          ate some tokens, see if we don't need to add
1298                          a padding token in between this and the
1299                          next token.  */
1300                       peek_tok = cpp_peek_token (pfile, 0);
1301                       if (peek_tok->type != CPP_PADDING
1302                           && (peek_tok->flags & PREV_WHITE) == 0)
1303                         _cpp_push_token_context (pfile, NULL,
1304                                                  padding_token (pfile,
1305                                                                 peek_tok), 1);
1306                     }
1307                 }
1308             }
1309           else
1310             ret = enter_macro_context (pfile, node, result);
1311           if (ret)
1312             {
1313               if (pfile->state.in_directive || ret == 2)
1314                 continue;
1315               return padding_token (pfile, result);
1316             }
1317         }
1318       else
1319         {
1320           /* Flag this token as always unexpandable.  FIXME: move this
1321              to collect_args()?.  */
1322           cpp_token *t = _cpp_temp_token (pfile);
1323           t->type = result->type;
1324           t->flags = result->flags | NO_EXPAND;
1325           t->val = result->val;
1326           result = t;
1327         }
1328
1329       break;
1330     }
1331
1332   return result;
1333 }
1334
1335 /* Like cpp_get_token, but also returns a location separate from the
1336    one provided by the returned token.  LOC is an out parameter; *LOC
1337    is set to the location "as expected by the user".  This matters
1338    when a token results from macro expansion -- the token's location
1339    will indicate where the macro is defined, but *LOC will be the
1340    location of the start of the expansion.  */
1341 const cpp_token *
1342 cpp_get_token_with_location (cpp_reader *pfile, source_location *loc)
1343 {
1344   const cpp_token *result;
1345
1346   pfile->set_invocation_location = true;
1347   result = cpp_get_token (pfile);
1348   if (pfile->context->macro)
1349     *loc = pfile->invocation_location;
1350   else
1351     *loc = result->src_loc;
1352
1353   return result;
1354 }
1355
1356 /* Returns true if we're expanding an object-like macro that was
1357    defined in a system header.  Just checks the macro at the top of
1358    the stack.  Used for diagnostic suppression.  */
1359 int
1360 cpp_sys_macro_p (cpp_reader *pfile)
1361 {
1362   cpp_hashnode *node = pfile->context->macro;
1363
1364   return node && node->value.macro && node->value.macro->syshdr;
1365 }
1366
1367 /* Read each token in, until end of the current file.  Directives are
1368    transparently processed.  */
1369 void
1370 cpp_scan_nooutput (cpp_reader *pfile)
1371 {
1372   /* Request a CPP_EOF token at the end of this file, rather than
1373      transparently continuing with the including file.  */
1374   pfile->buffer->return_at_eof = true;
1375
1376   pfile->state.discarding_output++;
1377   pfile->state.prevent_expansion++;
1378
1379   if (CPP_OPTION (pfile, traditional))
1380     while (_cpp_read_logical_line_trad (pfile))
1381       ;
1382   else
1383     while (cpp_get_token (pfile)->type != CPP_EOF)
1384       ;
1385
1386   pfile->state.discarding_output--;
1387   pfile->state.prevent_expansion--;
1388 }
1389
1390 /* Step back one or more tokens obtained from the lexer.  */
1391 void
1392 _cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
1393 {
1394   pfile->lookaheads += count;
1395   while (count--)
1396     {
1397       pfile->cur_token--;
1398       if (pfile->cur_token == pfile->cur_run->base
1399           /* Possible with -fpreprocessed and no leading #line.  */
1400           && pfile->cur_run->prev != NULL)
1401         {
1402           pfile->cur_run = pfile->cur_run->prev;
1403           pfile->cur_token = pfile->cur_run->limit;
1404         }
1405     }
1406 }
1407
1408 /* Step back one (or more) tokens.  Can only step back more than 1 if
1409    they are from the lexer, and not from macro expansion.  */
1410 void
1411 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1412 {
1413   if (pfile->context->prev == NULL)
1414     _cpp_backup_tokens_direct (pfile, count);
1415   else
1416     {
1417       if (count != 1)
1418         abort ();
1419       if (pfile->context->direct_p)
1420         FIRST (pfile->context).token--;
1421       else
1422         FIRST (pfile->context).ptoken--;
1423     }
1424 }
1425
1426 /* #define directive parsing and handling.  */
1427
1428 /* Returns nonzero if a macro redefinition warning is required.  */
1429 static bool
1430 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1431                       const cpp_macro *macro2)
1432 {
1433   const cpp_macro *macro1;
1434   unsigned int i;
1435
1436   /* Some redefinitions need to be warned about regardless.  */
1437   if (node->flags & NODE_WARN)
1438     return true;
1439
1440   /* Suppress warnings for builtins that lack the NODE_WARN flag.  */
1441   if (node->flags & NODE_BUILTIN)
1442     return false;
1443
1444   /* Redefinitions of conditional (context-sensitive) macros, on
1445      the other hand, must be allowed silently.  */
1446   if (node->flags & NODE_CONDITIONAL)
1447     return false;
1448
1449   /* Redefinition of a macro is allowed if and only if the old and new
1450      definitions are the same.  (6.10.3 paragraph 2).  */
1451   macro1 = node->value.macro;
1452
1453   /* Don't check count here as it can be different in valid
1454      traditional redefinitions with just whitespace differences.  */
1455   if (macro1->paramc != macro2->paramc
1456       || macro1->fun_like != macro2->fun_like
1457       || macro1->variadic != macro2->variadic)
1458     return true;
1459
1460   /* Check parameter spellings.  */
1461   for (i = 0; i < macro1->paramc; i++)
1462     if (macro1->params[i] != macro2->params[i])
1463       return true;
1464
1465   /* Check the replacement text or tokens.  */
1466   if (CPP_OPTION (pfile, traditional))
1467     return _cpp_expansions_different_trad (macro1, macro2);
1468
1469   if (macro1->count != macro2->count)
1470     return true;
1471
1472   for (i = 0; i < macro1->count; i++)
1473     if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1474       return true;
1475
1476   return false;
1477 }
1478
1479 /* Free the definition of hashnode H.  */
1480 void
1481 _cpp_free_definition (cpp_hashnode *h)
1482 {
1483   /* Macros and assertions no longer have anything to free.  */
1484   h->type = NT_VOID;
1485   /* Clear builtin flag in case of redefinition.  */
1486   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED | NODE_USED);
1487 }
1488
1489 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1490    zero on success, nonzero if the parameter is a duplicate.  */
1491 bool
1492 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1493 {
1494   unsigned int len;
1495   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1496   if (node->flags & NODE_MACRO_ARG)
1497     {
1498       cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1499                  NODE_NAME (node));
1500       return true;
1501     }
1502
1503   if (BUFF_ROOM (pfile->a_buff)
1504       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1505     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1506
1507   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1508   node->flags |= NODE_MACRO_ARG;
1509   len = macro->paramc * sizeof (union _cpp_hashnode_value);
1510   if (len > pfile->macro_buffer_len)
1511     {
1512       pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1513                                         len);
1514       pfile->macro_buffer_len = len;
1515     }
1516   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1517     = node->value;
1518
1519   node->value.arg_index  = macro->paramc;
1520   return false;
1521 }
1522
1523 /* Check the syntax of the parameters in a MACRO definition.  Returns
1524    false if an error occurs.  */
1525 static bool
1526 parse_params (cpp_reader *pfile, cpp_macro *macro)
1527 {
1528   unsigned int prev_ident = 0;
1529
1530   for (;;)
1531     {
1532       const cpp_token *token = _cpp_lex_token (pfile);
1533
1534       switch (token->type)
1535         {
1536         default:
1537           /* Allow/ignore comments in parameter lists if we are
1538              preserving comments in macro expansions.  */
1539           if (token->type == CPP_COMMENT
1540               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1541             continue;
1542
1543           cpp_error (pfile, CPP_DL_ERROR,
1544                      "\"%s\" may not appear in macro parameter list",
1545                      cpp_token_as_text (pfile, token));
1546           return false;
1547
1548         case CPP_NAME:
1549           if (prev_ident)
1550             {
1551               cpp_error (pfile, CPP_DL_ERROR,
1552                          "macro parameters must be comma-separated");
1553               return false;
1554             }
1555           prev_ident = 1;
1556
1557           if (_cpp_save_parameter (pfile, macro, token->val.node.node))
1558             return false;
1559           continue;
1560
1561         case CPP_CLOSE_PAREN:
1562           if (prev_ident || macro->paramc == 0)
1563             return true;
1564
1565           /* Fall through to pick up the error.  */
1566         case CPP_COMMA:
1567           if (!prev_ident)
1568             {
1569               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1570               return false;
1571             }
1572           prev_ident = 0;
1573           continue;
1574
1575         case CPP_ELLIPSIS:
1576           macro->variadic = 1;
1577           if (!prev_ident)
1578             {
1579               _cpp_save_parameter (pfile, macro,
1580                                    pfile->spec_nodes.n__VA_ARGS__);
1581               pfile->state.va_args_ok = 1;
1582               if (! CPP_OPTION (pfile, c99)
1583                   && CPP_OPTION (pfile, pedantic)
1584                   && CPP_OPTION (pfile, warn_variadic_macros))
1585                 cpp_error (pfile, CPP_DL_PEDWARN,
1586                            "anonymous variadic macros were introduced in C99");
1587             }
1588           else if (CPP_OPTION (pfile, pedantic)
1589                    && CPP_OPTION (pfile, warn_variadic_macros))
1590             cpp_error (pfile, CPP_DL_PEDWARN,
1591                        "ISO C does not permit named variadic macros");
1592
1593           /* We're at the end, and just expect a closing parenthesis.  */
1594           token = _cpp_lex_token (pfile);
1595           if (token->type == CPP_CLOSE_PAREN)
1596             return true;
1597           /* Fall through.  */
1598
1599         case CPP_EOF:
1600           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1601           return false;
1602         }
1603     }
1604 }
1605
1606 /* Allocate room for a token from a macro's replacement list.  */
1607 static cpp_token *
1608 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1609 {
1610   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1611     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1612
1613   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1614 }
1615
1616 /* Lex a token from the expansion of MACRO, but mark parameters as we
1617    find them and warn of traditional stringification.  */
1618 static cpp_token *
1619 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1620 {
1621   cpp_token *token, *saved_cur_token;
1622
1623   saved_cur_token = pfile->cur_token;
1624   pfile->cur_token = alloc_expansion_token (pfile, macro);
1625   token = _cpp_lex_direct (pfile);
1626   pfile->cur_token = saved_cur_token;
1627
1628   /* Is this a parameter?  */
1629   if (token->type == CPP_NAME
1630       && (token->val.node.node->flags & NODE_MACRO_ARG) != 0)
1631     {
1632       token->type = CPP_MACRO_ARG;
1633       token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
1634     }
1635   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1636            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1637     check_trad_stringification (pfile, macro, &token->val.str);
1638
1639   return token;
1640 }
1641
1642 static bool
1643 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1644 {
1645   cpp_token *token;
1646   const cpp_token *ctoken;
1647   bool following_paste_op = false;
1648   const char *paste_op_error_msg =
1649     N_("'##' cannot appear at either end of a macro expansion");
1650   unsigned int num_extra_tokens = 0;
1651
1652   /* Get the first token of the expansion (or the '(' of a
1653      function-like macro).  */
1654   ctoken = _cpp_lex_token (pfile);
1655
1656   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1657     {
1658       bool ok = parse_params (pfile, macro);
1659       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1660       if (!ok)
1661         return false;
1662
1663       /* Success.  Commit or allocate the parameter array.  */
1664       if (pfile->hash_table->alloc_subobject)
1665         {
1666           cpp_hashnode **params =
1667             (cpp_hashnode **) pfile->hash_table->alloc_subobject
1668             (sizeof (cpp_hashnode *) * macro->paramc);
1669           memcpy (params, macro->params,
1670                   sizeof (cpp_hashnode *) * macro->paramc);
1671           macro->params = params;
1672         }
1673       else
1674         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1675       macro->fun_like = 1;
1676     }
1677   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1678     {
1679       /* While ISO C99 requires whitespace before replacement text
1680          in a macro definition, ISO C90 with TC1 allows there characters
1681          from the basic source character set.  */
1682       if (CPP_OPTION (pfile, c99))
1683         cpp_error (pfile, CPP_DL_PEDWARN,
1684                    "ISO C99 requires whitespace after the macro name");
1685       else
1686         {
1687           int warntype = CPP_DL_WARNING;
1688           switch (ctoken->type)
1689             {
1690             case CPP_ATSIGN:
1691             case CPP_AT_NAME:
1692             case CPP_OBJC_STRING:
1693               /* '@' is not in basic character set.  */
1694               warntype = CPP_DL_PEDWARN;
1695               break;
1696             case CPP_OTHER:
1697               /* Basic character set sans letters, digits and _.  */
1698               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1699                           ctoken->val.str.text[0]) == NULL)
1700                 warntype = CPP_DL_PEDWARN;
1701               break;
1702             default:
1703               /* All other tokens start with a character from basic
1704                  character set.  */
1705               break;
1706             }
1707           cpp_error (pfile, warntype,
1708                      "missing whitespace after the macro name");
1709         }
1710     }
1711
1712   if (macro->fun_like)
1713     token = lex_expansion_token (pfile, macro);
1714   else
1715     {
1716       token = alloc_expansion_token (pfile, macro);
1717       *token = *ctoken;
1718     }
1719
1720   for (;;)
1721     {
1722       /* Check the stringifying # constraint 6.10.3.2.1 of
1723          function-like macros when lexing the subsequent token.  */
1724       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1725         {
1726           if (token->type == CPP_MACRO_ARG)
1727             {
1728               if (token->flags & PREV_WHITE)
1729                 token->flags |= SP_PREV_WHITE;
1730               if (token[-1].flags & DIGRAPH)
1731                 token->flags |= SP_DIGRAPH;
1732               token->flags &= ~PREV_WHITE;
1733               token->flags |= STRINGIFY_ARG;
1734               token->flags |= token[-1].flags & PREV_WHITE;
1735               token[-1] = token[0];
1736               macro->count--;
1737             }
1738           /* Let assembler get away with murder.  */
1739           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1740             {
1741               cpp_error (pfile, CPP_DL_ERROR,
1742                          "'#' is not followed by a macro parameter");
1743               return false;
1744             }
1745         }
1746
1747       if (token->type == CPP_EOF)
1748         {
1749           /* Paste operator constraint 6.10.3.3.1:
1750              Token-paste ##, can appear in both object-like and
1751              function-like macros, but not at the end.  */
1752           if (following_paste_op)
1753             {
1754               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1755               return false;
1756             }
1757           break;
1758         }
1759
1760       /* Paste operator constraint 6.10.3.3.1.  */
1761       if (token->type == CPP_PASTE)
1762         {
1763           /* Token-paste ##, can appear in both object-like and
1764              function-like macros, but not at the beginning.  */
1765           if (macro->count == 1)
1766             {
1767               cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
1768               return false;
1769             }
1770
1771           if (token[-1].flags & PASTE_LEFT)
1772             {
1773               macro->extra_tokens = 1;
1774               num_extra_tokens++;
1775               token->val.token_no = macro->count - 1;
1776             }
1777           else
1778             {
1779               --macro->count;
1780               token[-1].flags |= PASTE_LEFT;
1781               if (token->flags & DIGRAPH)
1782                 token[-1].flags |= SP_DIGRAPH;
1783               if (token->flags & PREV_WHITE)
1784                 token[-1].flags |= SP_PREV_WHITE;
1785             }
1786         }
1787
1788       following_paste_op = (token->type == CPP_PASTE);
1789       token = lex_expansion_token (pfile, macro);
1790     }
1791
1792   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1793   macro->traditional = 0;
1794
1795   /* Don't count the CPP_EOF.  */
1796   macro->count--;
1797
1798   /* Clear whitespace on first token for warn_of_redefinition().  */
1799   if (macro->count)
1800     macro->exp.tokens[0].flags &= ~PREV_WHITE;
1801
1802   /* Commit or allocate the memory.  */
1803   if (pfile->hash_table->alloc_subobject)
1804     {
1805       cpp_token *tokns =
1806         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1807                                                           * macro->count);
1808       if (num_extra_tokens)
1809         {
1810           /* Place second and subsequent ## or %:%: tokens in
1811              sequences of consecutive such tokens at the end of the
1812              list to preserve information about where they appear, how
1813              they are spelt and whether they are preceded by
1814              whitespace without otherwise interfering with macro
1815              expansion.  */
1816           cpp_token *normal_dest = tokns;
1817           cpp_token *extra_dest = tokns + macro->count - num_extra_tokens;
1818           unsigned int i;
1819           for (i = 0; i < macro->count; i++)
1820             {
1821               if (macro->exp.tokens[i].type == CPP_PASTE)
1822                 *extra_dest++ = macro->exp.tokens[i];
1823               else
1824                 *normal_dest++ = macro->exp.tokens[i];
1825             }
1826         }
1827       else
1828         memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1829       macro->exp.tokens = tokns;
1830     }
1831   else
1832     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
1833
1834   return true;
1835 }
1836
1837 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
1838 bool
1839 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1840 {
1841   cpp_macro *macro;
1842   unsigned int i;
1843   bool ok;
1844
1845   if (pfile->hash_table->alloc_subobject)
1846     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1847       (sizeof (cpp_macro));
1848   else
1849     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1850   macro->line = pfile->directive_line;
1851   macro->params = 0;
1852   macro->paramc = 0;
1853   macro->variadic = 0;
1854   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1855   macro->count = 0;
1856   macro->fun_like = 0;
1857   macro->extra_tokens = 0;
1858   /* To suppress some diagnostics.  */
1859   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1860
1861   if (CPP_OPTION (pfile, traditional))
1862     ok = _cpp_create_trad_definition (pfile, macro);
1863   else
1864     {
1865       ok = create_iso_definition (pfile, macro);
1866
1867       /* We set the type for SEEN_EOL() in directives.c.
1868
1869          Longer term we should lex the whole line before coming here,
1870          and just copy the expansion.  */
1871
1872       /* Stop the lexer accepting __VA_ARGS__.  */
1873       pfile->state.va_args_ok = 0;
1874     }
1875
1876   /* Clear the fast argument lookup indices.  */
1877   for (i = macro->paramc; i-- > 0; )
1878     {
1879       struct cpp_hashnode *node = macro->params[i];
1880       node->flags &= ~ NODE_MACRO_ARG;
1881       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1882     }
1883
1884   if (!ok)
1885     return ok;
1886
1887   if (node->type == NT_MACRO)
1888     {
1889       if (CPP_OPTION (pfile, warn_unused_macros))
1890         _cpp_warn_if_unused_macro (pfile, node, NULL);
1891
1892       if (warn_of_redefinition (pfile, node, macro))
1893         {
1894           bool warned;
1895           warned = cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1896                                         pfile->directive_line, 0,
1897                                         "\"%s\" redefined", NODE_NAME (node));
1898
1899           if (warned && node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1900             cpp_error_with_line (pfile, CPP_DL_NOTE,
1901                                  node->value.macro->line, 0,
1902                          "this is the location of the previous definition");
1903         }
1904     }
1905
1906   if (node->type != NT_VOID)
1907     _cpp_free_definition (node);
1908
1909   /* Enter definition in hash table.  */
1910   node->type = NT_MACRO;
1911   node->value.macro = macro;
1912   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
1913       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
1914       /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
1915          in the C standard, as something that one must use in C++.
1916          However DR#593 indicates that these aren't actually mentioned
1917          in the C++ standard.  We special-case them anyway.  */
1918       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
1919       && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
1920     node->flags |= NODE_WARN;
1921
1922   /* If user defines one of the conditional macros, remove the
1923      conditional flag */
1924   node->flags &= ~NODE_CONDITIONAL;
1925
1926   return ok;
1927 }
1928
1929 /* Warn if a token in STRING matches one of a function-like MACRO's
1930    parameters.  */
1931 static void
1932 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1933                             const cpp_string *string)
1934 {
1935   unsigned int i, len;
1936   const uchar *p, *q, *limit;
1937
1938   /* Loop over the string.  */
1939   limit = string->text + string->len - 1;
1940   for (p = string->text + 1; p < limit; p = q)
1941     {
1942       /* Find the start of an identifier.  */
1943       while (p < limit && !is_idstart (*p))
1944         p++;
1945
1946       /* Find the end of the identifier.  */
1947       q = p;
1948       while (q < limit && is_idchar (*q))
1949         q++;
1950
1951       len = q - p;
1952
1953       /* Loop over the function macro arguments to see if the
1954          identifier inside the string matches one of them.  */
1955       for (i = 0; i < macro->paramc; i++)
1956         {
1957           const cpp_hashnode *node = macro->params[i];
1958
1959           if (NODE_LEN (node) == len
1960               && !memcmp (p, NODE_NAME (node), len))
1961             {
1962               cpp_error (pfile, CPP_DL_WARNING,
1963            "macro argument \"%s\" would be stringified in traditional C",
1964                          NODE_NAME (node));
1965               break;
1966             }
1967         }
1968     }
1969 }
1970
1971 /* Returns the name, arguments and expansion of a macro, in a format
1972    suitable to be read back in again, and therefore also for DWARF 2
1973    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1974    Caller is expected to generate the "#define" bit if needed.  The
1975    returned text is temporary, and automatically freed later.  */
1976 const unsigned char *
1977 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1978 {
1979   unsigned int i, len;
1980   const cpp_macro *macro = node->value.macro;
1981   unsigned char *buffer;
1982
1983   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1984     {
1985       cpp_error (pfile, CPP_DL_ICE,
1986                  "invalid hash type %d in cpp_macro_definition", node->type);
1987       return 0;
1988     }
1989
1990   /* Calculate length.  */
1991   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
1992   if (macro->fun_like)
1993     {
1994       len += 4;         /* "()" plus possible final ".." of named
1995                            varargs (we have + 1 below).  */
1996       for (i = 0; i < macro->paramc; i++)
1997         len += NODE_LEN (macro->params[i]) + 1; /* "," */
1998     }
1999
2000   /* This should match below where we fill in the buffer.  */
2001   if (CPP_OPTION (pfile, traditional))
2002     len += _cpp_replacement_text_len (macro);
2003   else
2004     {
2005       unsigned int count = macro_real_token_count (macro);
2006       for (i = 0; i < count; i++)
2007         {
2008           cpp_token *token = &macro->exp.tokens[i];
2009
2010           if (token->type == CPP_MACRO_ARG)
2011             len += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
2012           else
2013             len += cpp_token_len (token);
2014
2015           if (token->flags & STRINGIFY_ARG)
2016             len++;                      /* "#" */
2017           if (token->flags & PASTE_LEFT)
2018             len += 3;           /* " ##" */
2019           if (token->flags & PREV_WHITE)
2020             len++;              /* " " */
2021         }
2022     }
2023
2024   if (len > pfile->macro_buffer_len)
2025     {
2026       pfile->macro_buffer = XRESIZEVEC (unsigned char,
2027                                         pfile->macro_buffer, len);
2028       pfile->macro_buffer_len = len;
2029     }
2030
2031   /* Fill in the buffer.  Start with the macro name.  */
2032   buffer = pfile->macro_buffer;
2033   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
2034   buffer += NODE_LEN (node);
2035
2036   /* Parameter names.  */
2037   if (macro->fun_like)
2038     {
2039       *buffer++ = '(';
2040       for (i = 0; i < macro->paramc; i++)
2041         {
2042           cpp_hashnode *param = macro->params[i];
2043
2044           if (param != pfile->spec_nodes.n__VA_ARGS__)
2045             {
2046               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
2047               buffer += NODE_LEN (param);
2048             }
2049
2050           if (i + 1 < macro->paramc)
2051             /* Don't emit a space after the comma here; we're trying
2052                to emit a Dwarf-friendly definition, and the Dwarf spec
2053                forbids spaces in the argument list.  */
2054             *buffer++ = ',';
2055           else if (macro->variadic)
2056             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
2057         }
2058       *buffer++ = ')';
2059     }
2060
2061   /* The Dwarf spec requires a space after the macro name, even if the
2062      definition is the empty string.  */
2063   *buffer++ = ' ';
2064
2065   if (CPP_OPTION (pfile, traditional))
2066     buffer = _cpp_copy_replacement_text (macro, buffer);
2067   else if (macro->count)
2068   /* Expansion tokens.  */
2069     {
2070       unsigned int count = macro_real_token_count (macro);
2071       for (i = 0; i < count; i++)
2072         {
2073           cpp_token *token = &macro->exp.tokens[i];
2074
2075           if (token->flags & PREV_WHITE)
2076             *buffer++ = ' ';
2077           if (token->flags & STRINGIFY_ARG)
2078             *buffer++ = '#';
2079
2080           if (token->type == CPP_MACRO_ARG)
2081             {
2082               memcpy (buffer,
2083                       NODE_NAME (macro->params[token->val.macro_arg.arg_no - 1]),
2084                       NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]));
2085               buffer += NODE_LEN (macro->params[token->val.macro_arg.arg_no - 1]);
2086             }
2087           else
2088             buffer = cpp_spell_token (pfile, token, buffer, false);
2089
2090           if (token->flags & PASTE_LEFT)
2091             {
2092               *buffer++ = ' ';
2093               *buffer++ = '#';
2094               *buffer++ = '#';
2095               /* Next has PREV_WHITE; see _cpp_create_definition.  */
2096             }
2097         }
2098     }
2099
2100   *buffer = '\0';
2101   return pfile->macro_buffer;
2102 }