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