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       /* Don't interpret _Pragma within directives.  The standard is
 963          not clear on this, but to me this makes most sense.  */
 964       if (token->val.node != pfile->spec_nodes.n__Pragma
 965           || pfile->state.in_directive)
 966         break;
 967
 968       /* Handle it, and loop back for another token.  MI is cleared
 969          since this token came from either the lexer or a macro.  */
 970       _cpp_do__Pragma (pfile);
 971     }
 972
 973   if (pfile->la_write)
 974     save_lookahead_token (pfile, token);
 975 }
 976
 977 /* Read each token in, until EOF.  Directives are transparently
 978    processed.  */
 979 void
 980 cpp_scan_buffer_nooutput (pfile)
 981      cpp_reader *pfile;
 982 {
 983   cpp_token token;
 984
 985   do
 986     do
 987       cpp_get_token (pfile, &token);
 988     while (token.type != CPP_EOF);
 989   while (cpp_pop_buffer (pfile) != 0);
 990 }
 991
 992 /* Lookahead handling.  */
 993
 994 static void
 995 save_lookahead_token (pfile, token)
 996      cpp_reader *pfile;
 997      const cpp_token *token;
 998 {
 999   if (token->type != CPP_EOF)
1000     {
1001       cpp_lookahead *la = pfile->la_write;
1002       cpp_token_with_pos *twp;
1003
1004       if (la->count == la->cap)
1005         {
1006           la->cap += la->cap + 8;
1007           la->tokens = (cpp_token_with_pos *)
1008             xrealloc (la->tokens, la->cap * sizeof (cpp_token_with_pos));
1009         }
1010
1011       twp = &la->tokens[la->count++];
1012       twp->token = *token;
1013       twp->pos = *cpp_get_line (pfile);
1014     }
1015 }
1016
1017 static void
1018 take_lookahead_token (pfile, token)
1019      cpp_reader *pfile;
1020      cpp_token *token;
1021 {
1022   cpp_lookahead *la = pfile->la_read;
1023   cpp_token_with_pos *twp = &la->tokens[la->cur];
1024
1025   *token = twp->token;
1026   pfile->lexer_pos = twp->pos;
1027
1028   if (++la->cur == la->count)
1029     _cpp_release_lookahead (pfile);
1030 }
1031
1032 /* Moves the lookahead at the front of the read list to the free store.  */
1033 void
1034 _cpp_release_lookahead (pfile)
1035      cpp_reader *pfile;
1036 {
1037   cpp_lookahead *la = pfile->la_read;
1038
1039   pfile->la_read = la->next;
1040   la->next = pfile->la_unused;
1041   pfile->la_unused = la;
1042   unlock_pools (pfile);
1043 }
1044
1045 /* Take a new lookahead from the free store, or allocate one if none.  */
1046 static cpp_lookahead *
1047 alloc_lookahead (pfile)
1048      cpp_reader *pfile;
1049 {
1050   cpp_lookahead *la = pfile->la_unused;
1051
1052   if (la)
1053     pfile->la_unused = la->next;
1054   else
1055     {
1056       la = xnew (cpp_lookahead);
1057       la->tokens = 0;
1058       la->cap = 0;
1059     }
1060
1061   la->cur = la->count = 0;
1062   return la;
1063 }
1064
1065 /* Free memory associated with a lookahead list.  */
1066 static void
1067 free_lookahead (la)
1068      cpp_lookahead *la;
1069 {
1070   if (la->tokens)
1071     free ((PTR) la->tokens);
1072   free ((PTR) la);
1073 }
1074
1075 /* Free all the lookaheads of a cpp_reader.  */
1076 void
1077 _cpp_free_lookaheads (pfile)
1078      cpp_reader *pfile;
1079 {
1080   cpp_lookahead *la, *lan;
1081
1082   if (pfile->la_read)
1083     free_lookahead (pfile->la_read);
1084   if (pfile->la_write)
1085     free_lookahead (pfile->la_write);
1086
1087   for (la = pfile->la_unused; la; la = lan)
1088     {
1089       lan = la->next;
1090       free_lookahead (la);
1091     }
1092 }
1093
1094 /* Allocate a lookahead and move it to the front of the write list.  */
1095 void
1096 cpp_start_lookahead (pfile)
1097      cpp_reader *pfile;
1098 {
1099   cpp_lookahead *la = alloc_lookahead (pfile);
1100
1101   la->next = pfile->la_write;
1102   pfile->la_write = la;
1103
1104   la->pos = *cpp_get_line (pfile);
1105
1106   /* Don't allow memory pools to be re-used whilst we're reading ahead.  */
1107   lock_pools (pfile);
1108 }
1109
1110 /* Stop reading ahead - either step back, or drop the read ahead.  */
1111 void
1112 cpp_stop_lookahead (pfile, drop)
1113      cpp_reader *pfile;
1114      int drop;
1115 {
1116   cpp_lookahead *la = pfile->la_write;
1117
1118   pfile->la_write = la->next;
1119   la->next = pfile->la_read;
1120   pfile->la_read = la;
1121
1122   if (drop || la->count == 0)
1123     _cpp_release_lookahead (pfile);
1124   else
1125     pfile->lexer_pos = la->pos;
1126 }
1127
1128 /* Push a single token back to the front of the queue.  Only to be
1129    used by cpplib, and only then when necessary.  POS is the position
1130    to report for the preceding token.  */
1131 void
1132 _cpp_push_token (pfile, token, pos)
1133      cpp_reader *pfile;
1134      const cpp_token *token;
1135      const cpp_lexer_pos *pos;
1136 {
1137   cpp_start_lookahead (pfile);
1138   save_lookahead_token (pfile, token);
1139   cpp_stop_lookahead (pfile, 0);
1140   pfile->lexer_pos = *pos;
1141 }
1142
1143 /* #define directive parsing and handling.  */
1144
1145 /* Returns non-zero if a macro redefinition is trivial.  */
1146 static int
1147 check_macro_redefinition (pfile, node, macro2)
1148      cpp_reader *pfile;
1149      const cpp_hashnode *node;
1150      const cpp_macro *macro2;
1151 {
1152   const cpp_macro *macro1;
1153   unsigned int i;
1154
1155   if (node->type != NT_MACRO || node->flags & NODE_BUILTIN)
1156     return ! pfile->done_initializing;
1157
1158   macro1 = node->value.macro;
1159
1160   /* The quick failures.  */
1161   if (macro1->count != macro2->count
1162       || macro1->paramc != macro2->paramc
1163       || macro1->fun_like != macro2->fun_like
1164       || macro1->var_args != macro2->var_args)
1165     return 0;
1166
1167   /* Check each token.  */
1168   for (i = 0; i < macro1->count; i++)
1169     if (! _cpp_equiv_tokens (&macro1->expansion[i], &macro2->expansion[i]))
1170       return 0;
1171
1172   /* Check parameter spellings.  */
1173   for (i = 0; i < macro1->paramc; i++)
1174     if (macro1->params[i] != macro2->params[i])
1175       return 0;
1176
1177   return 1;
1178 }
1179
1180 /* Free the definition of hashnode H.  */
1181
1182 void
1183 _cpp_free_definition (h)
1184      cpp_hashnode *h;
1185 {
1186   /* Macros and assertions no longer have anything to free.  */
1187   h->type = NT_VOID;
1188   /* Clear builtin flag in case of redefinition.  */
1189   h->flags &= ~NODE_BUILTIN;
1190 }
1191
1192 static int
1193 save_parameter (pfile, macro, node)
1194      cpp_reader *pfile;
1195      cpp_macro *macro;
1196      cpp_hashnode *node;
1197 {
1198   cpp_hashnode **dest;
1199
1200   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1201   if (node->arg_index)
1202     {
1203       cpp_error (pfile, "duplicate macro parameter \"%s\"", node->name);
1204       return 1;
1205     }
1206
1207   dest = &macro->params[macro->paramc];
1208
1209   /* Check we have room for the parameters.  */
1210   if ((unsigned char *) (dest + 1) >= POOL_LIMIT (&pfile->macro_pool))
1211     {
1212       _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_hashnode *),
1213                        (unsigned char **) &macro->params);
1214       dest = &macro->params[macro->paramc];
1215     }
1216
1217   *dest = node;
1218   node->arg_index = ++macro->paramc;
1219   return 0;
1220 }
1221
1222 static int
1223 parse_params (pfile, macro)
1224      cpp_reader *pfile;
1225      cpp_macro *macro;
1226 {
1227   cpp_token token;
1228   unsigned int prev_ident = 0;
1229
1230   macro->params = (cpp_hashnode **) POOL_FRONT (&pfile->macro_pool);
1231   for (;;)
1232     {
1233       _cpp_lex_token (pfile, &token);
1234
1235       switch (token.type)
1236         {
1237         default:
1238           cpp_error (pfile, "\"%s\" may not appear in macro parameter list",
1239                      cpp_token_as_text (pfile, &token));
1240           return 0;
1241
1242         case CPP_NAME:
1243           if (prev_ident)
1244             {
1245               cpp_error (pfile, "macro parameters must be comma-separated");
1246               return 0;
1247             }
1248           prev_ident = 1;
1249
1250           if (save_parameter (pfile, macro, token.val.node))
1251             return 0;
1252           continue;
1253
1254         case CPP_CLOSE_PAREN:
1255           if (prev_ident || macro->paramc == 0)
1256             break;
1257
1258           /* Fall through to pick up the error.  */
1259         case CPP_COMMA:
1260           if (!prev_ident)
1261             {
1262               cpp_error (pfile, "parameter name missing");
1263               return 0;
1264             }
1265           prev_ident = 0;
1266           continue;
1267
1268         case CPP_ELLIPSIS:
1269           macro->var_args = 1;
1270           if (!prev_ident)
1271             {
1272               save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1273               pfile->state.va_args_ok = 1;
1274               if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1275                 cpp_pedwarn (pfile,
1276                      "C89 does not permit anonymous variable arguments");
1277             }
1278           else if (CPP_OPTION (pfile, pedantic))
1279             cpp_pedwarn (pfile,
1280                          "ISO C does not permit named variable arguments");
1281
1282           /* We're at the end, and just expect a closing parenthesis.  */
1283           _cpp_lex_token (pfile, &token);
1284           if (token.type == CPP_CLOSE_PAREN)
1285             break;
1286           /* Fall through.  */
1287
1288         case CPP_EOF:
1289           cpp_error (pfile, "missing ')' in macro parameter list");
1290           return 0;
1291         }
1292
1293       /* Success.  Commit the parameter array.  */
1294       POOL_COMMIT (&pfile->macro_pool,
1295                    macro->paramc * sizeof (cpp_hashnode *));
1296       return 1;
1297     }
1298 }
1299
1300 /* Lex a token from a macro's replacement list.  Translate it to a
1301    CPP_MACRO_ARG if appropriate.  */
1302 static cpp_token *
1303 lex_expansion_token (pfile, macro)
1304      cpp_reader *pfile;
1305      cpp_macro *macro;
1306 {
1307   cpp_token *token = &macro->expansion[macro->count];
1308
1309   /* Check we have room for the token.  */
1310   if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1311     {
1312       _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1313                        (unsigned char **) &macro->expansion);
1314       token = &macro->expansion[macro->count];
1315     }
1316
1317   macro->count++;
1318   _cpp_lex_token (pfile, token);
1319
1320   /* Is this an argument?  */
1321   if (token->type == CPP_NAME && token->val.node->arg_index)
1322     {
1323       token->type = CPP_MACRO_ARG;
1324       token->val.arg_no = token->val.node->arg_index;
1325     }
1326   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1327            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1328     check_trad_stringification (pfile, macro, &token->val.str);
1329
1330   return token;
1331 }
1332
1333 /* Parse a macro and save its expansion.  Returns non-zero on success.  */
1334 int
1335 _cpp_create_definition (pfile, node)
1336      cpp_reader *pfile;
1337      cpp_hashnode *node;
1338 {
1339   cpp_macro *macro;
1340   cpp_token *token;
1341   unsigned int i, ok = 1;
1342
1343   macro = (cpp_macro *) _cpp_pool_alloc (&pfile->macro_pool,
1344                                          sizeof (cpp_macro));
1345   macro->file = pfile->buffer->nominal_fname;
1346   macro->line = pfile->directive_pos.line;
1347   macro->params = 0;
1348   macro->paramc = 0;
1349   macro->fun_like = 0;
1350   macro->var_args = 0;
1351   macro->count = 0;
1352   macro->expansion = (cpp_token *) POOL_FRONT (&pfile->macro_pool);
1353
1354   /* Get the first token of the expansion (or the '(' of a
1355      function-like macro).  */
1356   token = lex_expansion_token (pfile, macro);
1357   if (token->type == CPP_OPEN_PAREN && !(token->flags & PREV_WHITE))
1358     {
1359       if (!(ok = parse_params (pfile, macro)))
1360         goto cleanup;
1361       macro->count = 0;
1362       macro->fun_like = 1;
1363       /* Some of the pool may have been used for the parameter store.  */
1364       macro->expansion = (cpp_token *) POOL_FRONT (&pfile->macro_pool);
1365       token = lex_expansion_token (pfile, macro);
1366     }
1367   else if (token->type != CPP_EOF && !(token->flags & PREV_WHITE))
1368     cpp_pedwarn (pfile, "ISO C requires whitespace after the macro name");
1369
1370   /* Setting it here means we don't catch leading comments.  */
1371   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
1372
1373   for (;;)
1374     {
1375       /* Check the stringifying # constraint 6.10.3.2.1 of
1376          function-like macros when lexing the subsequent token.  */
1377       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1378         {
1379           if (token->type == CPP_MACRO_ARG)
1380             {
1381               token->flags &= ~PREV_WHITE;
1382               token->flags |= STRINGIFY_ARG;
1383               token->flags |= token[-1].flags & PREV_WHITE;
1384               token[-1] = token[0];
1385               macro->count--;
1386             }
1387           /* Let assembler get away with murder.  */
1388           else if (!CPP_OPTION (pfile, lang_asm))
1389             {
1390               ok = 0;
1391               cpp_error (pfile, "'#' is not followed by a macro parameter");
1392               goto cleanup;
1393             }
1394         }
1395
1396       if (token->type == CPP_EOF)
1397         break;
1398
1399       /* Paste operator constraint 6.10.3.3.1.  */
1400       if (token->type == CPP_PASTE)
1401         {
1402           /* Token-paste ##, can appear in both object-like and
1403              function-like macros, but not at the ends.  */
1404           if (--macro->count > 0)
1405             token = lex_expansion_token (pfile, macro);
1406
1407           if (macro->count == 0 || token->type == CPP_EOF)
1408             {
1409               ok = 0;
1410               cpp_error (pfile,
1411                          "'##' cannot appear at either end of a macro expansion");
1412               goto cleanup;
1413             }
1414
1415           token[-1].flags |= PASTE_LEFT;
1416           /* Give it a PREV_WHITE for -dM etc.  */
1417           token->flags |= PREV_WHITE;
1418         }
1419
1420       token = lex_expansion_token (pfile, macro);
1421     }
1422
1423   /* Don't count the CPP_EOF.  */
1424   macro->count--;
1425
1426   /* Clear the whitespace flag from the leading token.  */
1427   macro->expansion[0].flags &= ~PREV_WHITE;
1428
1429   /* Implement the macro-defined-to-itself optimisation.  */
1430   macro->disabled = (macro->count == 1 && !macro->fun_like
1431                      && macro->expansion[0].type == CPP_NAME
1432                      && macro->expansion[0].val.node == node);
1433
1434   /* Commit the memory.  */
1435   POOL_COMMIT (&pfile->macro_pool, macro->count * sizeof (cpp_token));
1436
1437   /* Redefinition of a macro is allowed if and only if the old and new
1438      definitions are the same.  (6.10.3 paragraph 2). */
1439   if (node->type != NT_VOID)
1440     {
1441       if (CPP_PEDANTIC (pfile)
1442           && !check_macro_redefinition (pfile, node, macro))
1443         {
1444           cpp_pedwarn_with_line (pfile, pfile->directive_pos.line,
1445                                  pfile->directive_pos.col,
1446                                  "\"%s\" redefined", node->name);
1447
1448           if (pfile->done_initializing && node->type == NT_MACRO
1449               && !(node->flags & NODE_BUILTIN))
1450             cpp_pedwarn_with_file_and_line (pfile,
1451                                             node->value.macro->file,
1452                                             node->value.macro->line, 1,
1453                             "this is the location of the previous definition");
1454         }
1455       _cpp_free_definition (node);
1456     }
1457
1458   /* Enter definition in hash table.  */
1459   node->type = NT_MACRO;
1460   node->value.macro = macro;
1461
1462  cleanup:
1463
1464   /* Stop the lexer accepting __VA_ARGS__.  */
1465   pfile->state.va_args_ok = 0;
1466
1467   /* Clear the fast argument lookup indices.  */
1468   for (i = macro->paramc; i-- > 0; )
1469     macro->params[i]->arg_index = 0;
1470
1471   return ok;
1472 }
1473
1474 /* Warn if a token in `string' matches one of the function macro
1475    arguments in `info'.  This function assumes that the macro is a
1476    function macro and not an object macro.  */
1477 static void
1478 check_trad_stringification (pfile, macro, string)
1479      cpp_reader *pfile;
1480      const cpp_macro *macro;
1481      const cpp_string *string;
1482 {
1483   unsigned int i, len;
1484   const U_CHAR *p, *q, *limit = string->text + string->len;
1485
1486   /* Loop over the string.  */
1487   for (p = string->text; p < limit; p = q)
1488     {
1489       /* Find the start of an identifier.  */
1490       while (p < limit && !is_idstart (*p))
1491         p++;
1492
1493       /* Find the end of the identifier.  */
1494       q = p;
1495       while (q < limit && is_idchar (*q))
1496         q++;
1497
1498       len = q - p;
1499
1500       /* Loop over the function macro arguments to see if the
1501          identifier inside the string matches one of them.  */
1502       for (i = 0; i < macro->paramc; i++)
1503         {
1504           const cpp_hashnode *node = macro->params[i];
1505
1506           if (node->length == len && !memcmp (p, node->name, len))
1507             {
1508               cpp_warning (pfile,
1509            "macro argument \"%s\" would be stringified with -traditional.",
1510                            node->name);
1511               break;
1512             }
1513         }
1514     }
1515 }
1516
1517 /* Returns the expansion of a macro, in a format suitable to be read
1518    back in again, and therefore also for DWARF 2 debugging info.
1519    Caller is expected to generate the "#define NAME" bit.  The
1520    returned text is temporary, and automatically freed later.  */
1521
1522 const unsigned char *
1523 cpp_macro_definition (pfile, node)
1524      cpp_reader *pfile;
1525      const cpp_hashnode *node;
1526 {
1527   unsigned int i, len;
1528   const cpp_macro *macro = node->value.macro;
1529   unsigned char *buffer;
1530
1531   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1532     {
1533       cpp_ice (pfile, "invalid hash type %d in dump_definition", node->type);
1534       return 0;
1535     }
1536
1537   /* Calculate length.  */
1538   len = 1;                      /* ' ' */
1539   if (macro->fun_like)
1540     {
1541       len += 3;         /* "()" plus possible final "." of ellipsis.  */
1542       for (i = 0; i < macro->paramc; i++)
1543         len += macro->params[i]->length + 2; /* ", " */
1544     }
1545
1546   for (i = 0; i < macro->count; i++)
1547     {
1548       cpp_token *token = &macro->expansion[i];
1549
1550       if (token->type == CPP_MACRO_ARG)
1551         len += macro->params[token->val.arg_no - 1]->length;
1552       else
1553         len += cpp_token_len (token); /* Includes room for ' '.  */
1554       if (token->flags & STRINGIFY_ARG)
1555         len++;                  /* "#" */
1556       if (token->flags & PASTE_LEFT)
1557         len += 3;               /* " ##" */
1558     }
1559
1560   if (len > pfile->macro_buffer_len)
1561     pfile->macro_buffer = (U_CHAR *) xrealloc (pfile->macro_buffer, len);
1562   buffer = pfile->macro_buffer;
1563
1564   /* Parameter names.  */
1565   if (macro->fun_like)
1566     {
1567       *buffer++ = '(';
1568       for (i = 0; i < macro->paramc; i++)
1569         {
1570           cpp_hashnode *param = macro->params[i];
1571
1572           if (param != pfile->spec_nodes.n__VA_ARGS__)
1573             {
1574               memcpy (buffer, param->name, param->length);
1575               buffer += param->length;
1576             }
1577
1578           if (i + 1 < macro->paramc)
1579             *buffer++ = ',', *buffer++ = ' ';
1580           else if (macro->var_args)
1581             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1582         }
1583       *buffer++ = ')';
1584     }
1585
1586   /* Expansion tokens.  */
1587   if (macro->count)
1588     {
1589       *buffer++ = ' ';
1590       for (i = 0; i < macro->count; i++)
1591         {
1592           cpp_token *token = &macro->expansion[i];
1593
1594           if (token->flags & PREV_WHITE)
1595             *buffer++ = ' ';
1596           if (token->flags & STRINGIFY_ARG)
1597             *buffer++ = '#';
1598
1599           if (token->type == CPP_MACRO_ARG)
1600             {
1601               len = macro->params[token->val.arg_no - 1]->length;
1602               memcpy (buffer, macro->params[token->val.arg_no - 1]->name, len);
1603               buffer += len;
1604             }
1605           else
1606             buffer = cpp_spell_token (pfile, token, buffer);
1607
1608           if (token->flags & PASTE_LEFT)
1609             {
1610               *buffer++ = ' ';
1611               *buffer++ = '#';
1612               *buffer++ = '#';
1613               /* Next has PREV_WHITE; see _cpp_create_definition.  */
1614             }
1615         }
1616     }
1617
1618   *buffer = '\0';
1619   return pfile->macro_buffer;
1620 }