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