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