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 ((cpp_reader *, 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 builtin 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
 384   cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true, 1);
 385
 386   /* Tweak the column number the lexer will report.  */
 387   pfile->buffer->col_adjust = pfile->cur_token[-1].col - 1;
 388
 389   /* We don't want a leading # to be interpreted as a directive.  */
 390   pfile->buffer->saved_flags = 0;
 391
 392   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
 393   pfile->cur_token = _cpp_temp_token (pfile);
 394   *plhs = _cpp_lex_direct (pfile);
 395   valid = (pfile->buffer->cur == pfile->buffer->rlimit
 396            && pfile->buffer->read_ahead == EOF);
 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             {
1094               pfile->cur_run = pfile->cur_run->prev;
1095               pfile->cur_token = pfile->cur_run->limit;
1096             }
1097         }
1098     }
1099   else
1100     {
1101       if (count != 1)
1102         abort ();
1103       if (pfile->context->direct_p)
1104         pfile->context->first.token--;
1105       else
1106         pfile->context->first.ptoken--;
1107     }
1108 }
1109
1110 /* #define directive parsing and handling.  */
1111
1112 /* Returns non-zero if a macro redefinition warning is required.  */
1113 static int
1114 warn_of_redefinition (pfile, node, macro2)
1115      cpp_reader *pfile;
1116      const cpp_hashnode *node;
1117      const cpp_macro *macro2;
1118 {
1119   const cpp_macro *macro1;
1120   unsigned int i;
1121
1122   /* Some redefinitions need to be warned about regardless.  */
1123   if (node->flags & NODE_WARN)
1124     return 1;
1125
1126   if (! CPP_PEDANTIC (pfile))
1127     return 0;
1128
1129   /* Redefinition of a macro is allowed if and only if the old and new
1130      definitions are the same.  (6.10.3 paragraph 2).  */
1131   macro1 = node->value.macro;
1132
1133   /* The quick failures.  */
1134   if (macro1->count != macro2->count
1135       || macro1->paramc != macro2->paramc
1136       || macro1->fun_like != macro2->fun_like
1137       || macro1->variadic != macro2->variadic)
1138     return 1;
1139
1140   /* Check each token.  */
1141   for (i = 0; i < macro1->count; i++)
1142     if (! _cpp_equiv_tokens (&macro1->expansion[i], &macro2->expansion[i]))
1143       return 1;
1144
1145   /* Check parameter spellings.  */
1146   for (i = 0; i < macro1->paramc; i++)
1147     if (macro1->params[i] != macro2->params[i])
1148       return 1;
1149
1150   return 0;
1151 }
1152
1153 /* Free the definition of hashnode H.  */
1154
1155 void
1156 _cpp_free_definition (h)
1157      cpp_hashnode *h;
1158 {
1159   /* Macros and assertions no longer have anything to free.  */
1160   h->type = NT_VOID;
1161   /* Clear builtin flag in case of redefinition.  */
1162   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1163 }
1164
1165 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1166    zero on success, non-zero if the paramter is a duplicate.  */
1167 static int
1168 save_parameter (pfile, macro, node)
1169      cpp_reader *pfile;
1170      cpp_macro *macro;
1171      cpp_hashnode *node;
1172 {
1173   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1174   if (node->arg_index)
1175     {
1176       cpp_error (pfile, "duplicate macro parameter \"%s\"", NODE_NAME (node));
1177       return 1;
1178     }
1179
1180   if (BUFF_ROOM (pfile->a_buff)
1181       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1182     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1183
1184   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1185   node->arg_index = macro->paramc;
1186   return 0;
1187 }
1188
1189 /* Check the syntax of the parameters in a MACRO definition.  */
1190 static int
1191 parse_params (pfile, macro)
1192      cpp_reader *pfile;
1193      cpp_macro *macro;
1194 {
1195   unsigned int prev_ident = 0;
1196
1197   for (;;)
1198     {
1199       const cpp_token *token = _cpp_lex_token (pfile);
1200
1201       switch (token->type)
1202         {
1203         default:
1204           cpp_error (pfile, "\"%s\" may not appear in macro parameter list",
1205                      cpp_token_as_text (pfile, token));
1206           return 0;
1207
1208         case CPP_NAME:
1209           if (prev_ident)
1210             {
1211               cpp_error (pfile, "macro parameters must be comma-separated");
1212               return 0;
1213             }
1214           prev_ident = 1;
1215
1216           if (save_parameter (pfile, macro, token->val.node))
1217             return 0;
1218           continue;
1219
1220         case CPP_CLOSE_PAREN:
1221           if (prev_ident || macro->paramc == 0)
1222             return 1;
1223
1224           /* Fall through to pick up the error.  */
1225         case CPP_COMMA:
1226           if (!prev_ident)
1227             {
1228               cpp_error (pfile, "parameter name missing");
1229               return 0;
1230             }
1231           prev_ident = 0;
1232           continue;
1233
1234         case CPP_ELLIPSIS:
1235           macro->variadic = 1;
1236           if (!prev_ident)
1237             {
1238               save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1239               pfile->state.va_args_ok = 1;
1240               if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1241                 cpp_pedwarn (pfile,
1242                      "anonymous variadic macros were introduced in C99");
1243             }
1244           else if (CPP_OPTION (pfile, pedantic))
1245             cpp_pedwarn (pfile, "ISO C does not permit named variadic macros");
1246
1247           /* We're at the end, and just expect a closing parenthesis.  */
1248           token = _cpp_lex_token (pfile);
1249           if (token->type == CPP_CLOSE_PAREN)
1250             return 1;
1251           /* Fall through.  */
1252
1253         case CPP_EOF:
1254           cpp_error (pfile, "missing ')' in macro parameter list");
1255           return 0;
1256         }
1257     }
1258 }
1259
1260 /* Allocate room for a token from a macro's replacement list.  */
1261 static cpp_token *
1262 alloc_expansion_token (pfile, macro)
1263      cpp_reader *pfile;
1264      cpp_macro *macro;
1265 {
1266   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1267     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1268
1269   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1270 }
1271
1272 static cpp_token *
1273 lex_expansion_token (pfile, macro)
1274      cpp_reader *pfile;
1275      cpp_macro *macro;
1276 {
1277   cpp_token *token;
1278
1279   pfile->cur_token = alloc_expansion_token (pfile, macro);
1280   token = _cpp_lex_direct (pfile);
1281
1282   /* Is this an argument?  */
1283   if (token->type == CPP_NAME && token->val.node->arg_index)
1284     {
1285       token->type = CPP_MACRO_ARG;
1286       token->val.arg_no = token->val.node->arg_index;
1287     }
1288   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1289            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1290     check_trad_stringification (pfile, macro, &token->val.str);
1291
1292   return token;
1293 }
1294
1295 /* Parse a macro and save its expansion.  Returns non-zero on success.  */
1296 int
1297 _cpp_create_definition (pfile, node)
1298      cpp_reader *pfile;
1299      cpp_hashnode *node;
1300 {
1301   cpp_macro *macro;
1302   cpp_token *token, *saved_cur_token;
1303   const cpp_token *ctoken;
1304   unsigned int i, ok = 1;
1305
1306   macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1307   macro->line = pfile->directive_line;
1308   macro->params = 0;
1309   macro->paramc = 0;
1310   macro->variadic = 0;
1311   macro->count = 0;
1312   macro->fun_like = 0;
1313
1314   /* Get the first token of the expansion (or the '(' of a
1315      function-like macro).  */
1316   ctoken = _cpp_lex_token (pfile);
1317
1318   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1319     {
1320       ok = parse_params (pfile, macro);
1321       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1322       if (!ok)
1323         goto cleanup2;
1324
1325       /* Success.  Commit the parameter array.  */
1326       BUFF_FRONT (pfile->a_buff) = (U_CHAR *) &macro->params[macro->paramc];
1327       macro->fun_like = 1;
1328     }
1329   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1330     cpp_pedwarn (pfile, "ISO C requires whitespace after the macro name");
1331
1332   saved_cur_token = pfile->cur_token;
1333
1334   if (macro->fun_like)
1335     token = lex_expansion_token (pfile, macro);
1336   else
1337     {
1338       token = alloc_expansion_token (pfile, macro);
1339       *token = *ctoken;
1340     }
1341
1342   for (;;)
1343     {
1344       /* Check the stringifying # constraint 6.10.3.2.1 of
1345          function-like macros when lexing the subsequent token.  */
1346       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1347         {
1348           if (token->type == CPP_MACRO_ARG)
1349             {
1350               token->flags &= ~PREV_WHITE;
1351               token->flags |= STRINGIFY_ARG;
1352               token->flags |= token[-1].flags & PREV_WHITE;
1353               token[-1] = token[0];
1354               macro->count--;
1355             }
1356           /* Let assembler get away with murder.  */
1357           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1358             {
1359               ok = 0;
1360               cpp_error (pfile, "'#' is not followed by a macro parameter");
1361               goto cleanup1;
1362             }
1363         }
1364
1365       if (token->type == CPP_EOF)
1366         break;
1367
1368       /* Paste operator constraint 6.10.3.3.1.  */
1369       if (token->type == CPP_PASTE)
1370         {
1371           /* Token-paste ##, can appear in both object-like and
1372              function-like macros, but not at the ends.  */
1373           if (--macro->count > 0)
1374             token = lex_expansion_token (pfile, macro);
1375
1376           if (macro->count == 0 || token->type == CPP_EOF)
1377             {
1378               ok = 0;
1379               cpp_error (pfile,
1380                          "'##' cannot appear at either end of a macro expansion");
1381               goto cleanup1;
1382             }
1383
1384           token[-1].flags |= PASTE_LEFT;
1385         }
1386
1387       token = lex_expansion_token (pfile, macro);
1388     }
1389
1390   macro->expansion = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1391
1392   /* Don't count the CPP_EOF.  */
1393   macro->count--;
1394
1395   /* Clear whitespace on first token for macro equivalence purposes.  */
1396   if (macro->count)
1397     macro->expansion[0].flags &= ~PREV_WHITE;
1398
1399   /* Commit the memory.  */
1400   BUFF_FRONT (pfile->a_buff) = (U_CHAR *) &macro->expansion[macro->count];
1401
1402   /* Implement the macro-defined-to-itself optimisation.  */
1403   if (macro->count == 1 && !macro->fun_like
1404       && macro->expansion[0].type == CPP_NAME
1405       && macro->expansion[0].val.node == node)
1406     node->flags |= NODE_DISABLED;
1407
1408   /* To suppress some diagnostics.  */
1409   macro->syshdr = pfile->map->sysp != 0;
1410
1411   if (node->type != NT_VOID)
1412     {
1413       if (warn_of_redefinition (pfile, node, macro))
1414         {
1415           cpp_pedwarn_with_line (pfile, pfile->directive_line, 0,
1416                                  "\"%s\" redefined", NODE_NAME (node));
1417
1418           if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1419             cpp_pedwarn_with_line (pfile, node->value.macro->line, 0,
1420                             "this is the location of the previous definition");
1421         }
1422       _cpp_free_definition (node);
1423     }
1424
1425   /* Enter definition in hash table.  */
1426   node->type = NT_MACRO;
1427   node->value.macro = macro;
1428   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1429     node->flags |= NODE_WARN;
1430
1431  cleanup1:
1432
1433   /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position.  */
1434   saved_cur_token[-1].type = pfile->cur_token[-1].type;
1435   pfile->cur_token = saved_cur_token;
1436
1437  cleanup2:
1438
1439   /* Stop the lexer accepting __VA_ARGS__.  */
1440   pfile->state.va_args_ok = 0;
1441
1442   /* Clear the fast argument lookup indices.  */
1443   for (i = macro->paramc; i-- > 0; )
1444     macro->params[i]->arg_index = 0;
1445
1446   return ok;
1447 }
1448
1449 /* Warn if a token in `string' matches one of the function macro
1450    arguments in `info'.  This function assumes that the macro is a
1451    function macro and not an object macro.  */
1452 static void
1453 check_trad_stringification (pfile, macro, string)
1454      cpp_reader *pfile;
1455      const cpp_macro *macro;
1456      const cpp_string *string;
1457 {
1458   unsigned int i, len;
1459   const U_CHAR *p, *q, *limit = string->text + string->len;
1460
1461   /* Loop over the string.  */
1462   for (p = string->text; p < limit; p = q)
1463     {
1464       /* Find the start of an identifier.  */
1465       while (p < limit && !is_idstart (*p))
1466         p++;
1467
1468       /* Find the end of the identifier.  */
1469       q = p;
1470       while (q < limit && is_idchar (*q))
1471         q++;
1472
1473       len = q - p;
1474
1475       /* Loop over the function macro arguments to see if the
1476          identifier inside the string matches one of them.  */
1477       for (i = 0; i < macro->paramc; i++)
1478         {
1479           const cpp_hashnode *node = macro->params[i];
1480
1481           if (NODE_LEN (node) == len
1482               && !memcmp (p, NODE_NAME (node), len))
1483             {
1484               cpp_warning (pfile,
1485            "macro argument \"%s\" would be stringified with -traditional.",
1486                            NODE_NAME (node));
1487               break;
1488             }
1489         }
1490     }
1491 }
1492
1493 /* Returns the name, arguments and expansion of a macro, in a format
1494    suitable to be read back in again, and therefore also for DWARF 2
1495    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1496    Caller is expected to generate the "#define" bit if needed.  The
1497    returned text is temporary, and automatically freed later.  */
1498
1499 const unsigned char *
1500 cpp_macro_definition (pfile, node)
1501      cpp_reader *pfile;
1502      const cpp_hashnode *node;
1503 {
1504   unsigned int i, len;
1505   const cpp_macro *macro = node->value.macro;
1506   unsigned char *buffer;
1507
1508   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1509     {
1510       cpp_ice (pfile, "invalid hash type %d in cpp_macro_definition", node->type);
1511       return 0;
1512     }
1513
1514   /* Calculate length.  */
1515   len = NODE_LEN (node) + 1;                    /* ' ' */
1516   if (macro->fun_like)
1517     {
1518       len += 3;         /* "()" plus possible final "." of named
1519                            varargs (we have + 2 below).  */
1520       for (i = 0; i < macro->paramc; i++)
1521         len += NODE_LEN (macro->params[i]) + 2; /* ", " */
1522     }
1523
1524   for (i = 0; i < macro->count; i++)
1525     {
1526       cpp_token *token = &macro->expansion[i];
1527
1528       if (token->type == CPP_MACRO_ARG)
1529         len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1530       else
1531         len += cpp_token_len (token); /* Includes room for ' '.  */
1532       if (token->flags & STRINGIFY_ARG)
1533         len++;                  /* "#" */
1534       if (token->flags & PASTE_LEFT)
1535         len += 3;               /* " ##" */
1536     }
1537
1538   if (len > pfile->macro_buffer_len)
1539     {
1540       pfile->macro_buffer = (U_CHAR *) xrealloc (pfile->macro_buffer, len);
1541       pfile->macro_buffer_len = len;
1542     }
1543
1544   /* Fill in the buffer.  Start with the macro name.  */
1545   buffer = pfile->macro_buffer;
1546   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1547   buffer += NODE_LEN (node);
1548
1549   /* Parameter names.  */
1550   if (macro->fun_like)
1551     {
1552       *buffer++ = '(';
1553       for (i = 0; i < macro->paramc; i++)
1554         {
1555           cpp_hashnode *param = macro->params[i];
1556
1557           if (param != pfile->spec_nodes.n__VA_ARGS__)
1558             {
1559               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1560               buffer += NODE_LEN (param);
1561             }
1562
1563           if (i + 1 < macro->paramc)
1564             *buffer++ = ',', *buffer++ = ' ';
1565           else if (macro->variadic)
1566             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1567         }
1568       *buffer++ = ')';
1569     }
1570
1571   /* Expansion tokens.  */
1572   if (macro->count)
1573     {
1574       *buffer++ = ' ';
1575       for (i = 0; i < macro->count; i++)
1576         {
1577           cpp_token *token = &macro->expansion[i];
1578
1579           if (token->flags & PREV_WHITE)
1580             *buffer++ = ' ';
1581           if (token->flags & STRINGIFY_ARG)
1582             *buffer++ = '#';
1583
1584           if (token->type == CPP_MACRO_ARG)
1585             {
1586               len = NODE_LEN (macro->params[token->val.arg_no - 1]);
1587               memcpy (buffer,
1588                       NODE_NAME (macro->params[token->val.arg_no - 1]), len);
1589               buffer += len;
1590             }
1591           else
1592             buffer = cpp_spell_token (pfile, token, buffer);
1593
1594           if (token->flags & PASTE_LEFT)
1595             {
1596               *buffer++ = ' ';
1597               *buffer++ = '#';
1598               *buffer++ = '#';
1599               /* Next has PREV_WHITE; see _cpp_create_definition.  */
1600             }
1601         }
1602     }
1603
1604   *buffer = '\0';
1605   return pfile->macro_buffer;
1606 }