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