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