gcc/cppmacro.c

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