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