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