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