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