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 end of the current file.  Directives are
1078    transparently processed.  */
1079 void
1080 cpp_scan_nooutput (pfile)
1081      cpp_reader *pfile;
1082 {
1083   /* Request a CPP_EOF token at the end of this file, rather than
1084      transparently continuing with the including file.  */
1085   pfile->buffer->return_at_eof = true;
1086
1087   while (cpp_get_token (pfile)->type != CPP_EOF)
1088     ;
1089 }
1090
1091 /* Step back one (or more) tokens.  Can only step mack more than 1 if
1092    they are from the lexer, and not from macro expansion.  */
1093 void
1094 _cpp_backup_tokens (pfile, count)
1095      cpp_reader *pfile;
1096      unsigned int count;
1097 {
1098   if (pfile->context->prev == NULL)
1099     {
1100       pfile->lookaheads += count;
1101       while (count--)
1102         {
1103           pfile->cur_token--;
1104           if (pfile->cur_token == pfile->cur_run->base
1105               /* Possible with -fpreprocessed and no leading #line.  */
1106               && pfile->cur_run->prev != NULL)
1107             {
1108               pfile->cur_run = pfile->cur_run->prev;
1109               pfile->cur_token = pfile->cur_run->limit;
1110             }
1111         }
1112     }
1113   else
1114     {
1115       if (count != 1)
1116         abort ();
1117       if (pfile->context->direct_p)
1118         pfile->context->first.token--;
1119       else
1120         pfile->context->first.ptoken--;
1121     }
1122 }
1123
1124 /* #define directive parsing and handling.  */
1125
1126 /* Returns non-zero if a macro redefinition warning is required.  */
1127 static int
1128 warn_of_redefinition (node, macro2)
1129      const cpp_hashnode *node;
1130      const cpp_macro *macro2;
1131 {
1132   const cpp_macro *macro1;
1133   unsigned int i;
1134
1135   /* Some redefinitions need to be warned about regardless.  */
1136   if (node->flags & NODE_WARN)
1137     return 1;
1138
1139   /* Redefinition of a macro is allowed if and only if the old and new
1140      definitions are the same.  (6.10.3 paragraph 2).  */
1141   macro1 = node->value.macro;
1142
1143   /* The quick failures.  */
1144   if (macro1->count != macro2->count
1145       || macro1->paramc != macro2->paramc
1146       || macro1->fun_like != macro2->fun_like
1147       || macro1->variadic != macro2->variadic)
1148     return 1;
1149
1150   /* Check each token.  */
1151   for (i = 0; i < macro1->count; i++)
1152     if (! _cpp_equiv_tokens (&macro1->expansion[i], &macro2->expansion[i]))
1153       return 1;
1154
1155   /* Check parameter spellings.  */
1156   for (i = 0; i < macro1->paramc; i++)
1157     if (macro1->params[i] != macro2->params[i])
1158       return 1;
1159
1160   return 0;
1161 }
1162
1163 /* Free the definition of hashnode H.  */
1164 void
1165 _cpp_free_definition (h)
1166      cpp_hashnode *h;
1167 {
1168   /* Macros and assertions no longer have anything to free.  */
1169   h->type = NT_VOID;
1170   /* Clear builtin flag in case of redefinition.  */
1171   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1172 }
1173
1174 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1175    zero on success, non-zero if the parameter is a duplicate.  */
1176 static int
1177 save_parameter (pfile, macro, node)
1178      cpp_reader *pfile;
1179      cpp_macro *macro;
1180      cpp_hashnode *node;
1181 {
1182   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1183   if (node->arg_index)
1184     {
1185       cpp_error (pfile, DL_ERROR, "duplicate macro parameter \"%s\"",
1186                  NODE_NAME (node));
1187       return 1;
1188     }
1189
1190   if (BUFF_ROOM (pfile->a_buff)
1191       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1192     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1193
1194   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1195   node->arg_index = macro->paramc;
1196   return 0;
1197 }
1198
1199 /* Check the syntax of the parameters in a MACRO definition.  */
1200 static int
1201 parse_params (pfile, macro)
1202      cpp_reader *pfile;
1203      cpp_macro *macro;
1204 {
1205   unsigned int prev_ident = 0;
1206
1207   for (;;)
1208     {
1209       const cpp_token *token = _cpp_lex_token (pfile);
1210
1211       switch (token->type)
1212         {
1213         default:
1214           /* Allow/ignore comments in parameter lists if we are
1215              preserving comments in macro expansions.  */
1216           if (token->type == CPP_COMMENT
1217               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1218             continue;
1219
1220           cpp_error (pfile, DL_ERROR,
1221                      "\"%s\" may not appear in macro parameter list",
1222                      cpp_token_as_text (pfile, token));
1223           return 0;
1224
1225         case CPP_NAME:
1226           if (prev_ident)
1227             {
1228               cpp_error (pfile, DL_ERROR,
1229                          "macro parameters must be comma-separated");
1230               return 0;
1231             }
1232           prev_ident = 1;
1233
1234           if (save_parameter (pfile, macro, token->val.node))
1235             return 0;
1236           continue;
1237
1238         case CPP_CLOSE_PAREN:
1239           if (prev_ident || macro->paramc == 0)
1240             return 1;
1241
1242           /* Fall through to pick up the error.  */
1243         case CPP_COMMA:
1244           if (!prev_ident)
1245             {
1246               cpp_error (pfile, DL_ERROR, "parameter name missing");
1247               return 0;
1248             }
1249           prev_ident = 0;
1250           continue;
1251
1252         case CPP_ELLIPSIS:
1253           macro->variadic = 1;
1254           if (!prev_ident)
1255             {
1256               save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
1257               pfile->state.va_args_ok = 1;
1258               if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
1259                 cpp_error (pfile, DL_PEDWARN,
1260                            "anonymous variadic macros were introduced in C99");
1261             }
1262           else if (CPP_OPTION (pfile, pedantic))
1263             cpp_error (pfile, DL_PEDWARN,
1264                        "ISO C does not permit named variadic macros");
1265
1266           /* We're at the end, and just expect a closing parenthesis.  */
1267           token = _cpp_lex_token (pfile);
1268           if (token->type == CPP_CLOSE_PAREN)
1269             return 1;
1270           /* Fall through.  */
1271
1272         case CPP_EOF:
1273           cpp_error (pfile, DL_ERROR, "missing ')' in macro parameter list");
1274           return 0;
1275         }
1276     }
1277 }
1278
1279 /* Allocate room for a token from a macro's replacement list.  */
1280 static cpp_token *
1281 alloc_expansion_token (pfile, macro)
1282      cpp_reader *pfile;
1283      cpp_macro *macro;
1284 {
1285   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1286     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1287
1288   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1289 }
1290
1291 /* Lex a token from the expansion of MACRO, but mark parameters as we
1292    find them and warn of traditional stringification.  */
1293 static cpp_token *
1294 lex_expansion_token (pfile, macro)
1295      cpp_reader *pfile;
1296      cpp_macro *macro;
1297 {
1298   cpp_token *token;
1299
1300   pfile->cur_token = alloc_expansion_token (pfile, macro);
1301   token = _cpp_lex_direct (pfile);
1302
1303   /* Is this a parameter?  */
1304   if (token->type == CPP_NAME && token->val.node->arg_index)
1305     {
1306       token->type = CPP_MACRO_ARG;
1307       token->val.arg_no = token->val.node->arg_index;
1308     }
1309   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1310            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1311     check_trad_stringification (pfile, macro, &token->val.str);
1312
1313   return token;
1314 }
1315
1316 /* Parse a macro and save its expansion.  Returns non-zero on success.  */
1317 int
1318 _cpp_create_definition (pfile, node)
1319      cpp_reader *pfile;
1320      cpp_hashnode *node;
1321 {
1322   cpp_macro *macro;
1323   cpp_token *token, *saved_cur_token;
1324   const cpp_token *ctoken;
1325   unsigned int i, ok = 1;
1326
1327   macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1328   macro->line = pfile->directive_line;
1329   macro->params = 0;
1330   macro->paramc = 0;
1331   macro->variadic = 0;
1332   macro->count = 0;
1333   macro->fun_like = 0;
1334
1335   /* Get the first token of the expansion (or the '(' of a
1336      function-like macro).  */
1337   ctoken = _cpp_lex_token (pfile);
1338
1339   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1340     {
1341       ok = parse_params (pfile, macro);
1342       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1343       if (!ok)
1344         goto cleanup2;
1345
1346       /* Success.  Commit the parameter array.  */
1347       BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1348       macro->fun_like = 1;
1349     }
1350   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1351     cpp_error (pfile, DL_PEDWARN,
1352                "ISO C requires whitespace after the macro name");
1353
1354   saved_cur_token = pfile->cur_token;
1355
1356   if (macro->fun_like)
1357     token = lex_expansion_token (pfile, macro);
1358   else
1359     {
1360       token = alloc_expansion_token (pfile, macro);
1361       *token = *ctoken;
1362     }
1363
1364   for (;;)
1365     {
1366       /* Check the stringifying # constraint 6.10.3.2.1 of
1367          function-like macros when lexing the subsequent token.  */
1368       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1369         {
1370           if (token->type == CPP_MACRO_ARG)
1371             {
1372               token->flags &= ~PREV_WHITE;
1373               token->flags |= STRINGIFY_ARG;
1374               token->flags |= token[-1].flags & PREV_WHITE;
1375               token[-1] = token[0];
1376               macro->count--;
1377             }
1378           /* Let assembler get away with murder.  */
1379           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1380             {
1381               ok = 0;
1382               cpp_error (pfile, DL_ERROR,
1383                          "'#' is not followed by a macro parameter");
1384               goto cleanup1;
1385             }
1386         }
1387
1388       if (token->type == CPP_EOF)
1389         break;
1390
1391       /* Paste operator constraint 6.10.3.3.1.  */
1392       if (token->type == CPP_PASTE)
1393         {
1394           /* Token-paste ##, can appear in both object-like and
1395              function-like macros, but not at the ends.  */
1396           if (--macro->count > 0)
1397             token = lex_expansion_token (pfile, macro);
1398
1399           if (macro->count == 0 || token->type == CPP_EOF)
1400             {
1401               ok = 0;
1402               cpp_error (pfile, DL_ERROR,
1403                          "'##' cannot appear at either end of a macro expansion");
1404               goto cleanup1;
1405             }
1406
1407           token[-1].flags |= PASTE_LEFT;
1408         }
1409
1410       token = lex_expansion_token (pfile, macro);
1411     }
1412
1413   macro->expansion = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1414
1415   /* Don't count the CPP_EOF.  */
1416   macro->count--;
1417
1418   /* Clear whitespace on first token for warn_of_redefinition().  */
1419   if (macro->count)
1420     macro->expansion[0].flags &= ~PREV_WHITE;
1421
1422   /* Commit the memory.  */
1423   BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->expansion[macro->count];
1424
1425   /* Implement the macro-defined-to-itself optimisation.  */
1426   if (macro->count == 1 && !macro->fun_like
1427       && macro->expansion[0].type == CPP_NAME
1428       && macro->expansion[0].val.node == node)
1429     node->flags |= NODE_DISABLED;
1430
1431   /* To suppress some diagnostics.  */
1432   macro->syshdr = pfile->map->sysp != 0;
1433
1434   if (node->type != NT_VOID)
1435     {
1436       if (warn_of_redefinition (node, macro))
1437         {
1438           cpp_error_with_line (pfile, DL_PEDWARN, pfile->directive_line, 0,
1439                                "\"%s\" redefined", NODE_NAME (node));
1440
1441           if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1442             cpp_error_with_line (pfile, DL_PEDWARN, node->value.macro->line, 0,
1443                             "this is the location of the previous definition");
1444         }
1445       _cpp_free_definition (node);
1446     }
1447
1448   /* Enter definition in hash table.  */
1449   node->type = NT_MACRO;
1450   node->value.macro = macro;
1451   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1452     node->flags |= NODE_WARN;
1453
1454  cleanup1:
1455
1456   /* Set type for SEEN_EOL() in cpplib.c, restore the lexer position.  */
1457   saved_cur_token[-1].type = pfile->cur_token[-1].type;
1458   pfile->cur_token = saved_cur_token;
1459
1460  cleanup2:
1461
1462   /* Stop the lexer accepting __VA_ARGS__.  */
1463   pfile->state.va_args_ok = 0;
1464
1465   /* Clear the fast argument lookup indices.  */
1466   for (i = macro->paramc; i-- > 0; )
1467     macro->params[i]->arg_index = 0;
1468
1469   return ok;
1470 }
1471
1472 /* Warn if a token in STRING matches one of a function-like MACRO's
1473    parameters.  */
1474 static void
1475 check_trad_stringification (pfile, macro, string)
1476      cpp_reader *pfile;
1477      const cpp_macro *macro;
1478      const cpp_string *string;
1479 {
1480   unsigned int i, len;
1481   const uchar *p, *q, *limit = string->text + string->len;
1482
1483   /* Loop over the string.  */
1484   for (p = string->text; p < limit; p = q)
1485     {
1486       /* Find the start of an identifier.  */
1487       while (p < limit && !is_idstart (*p))
1488         p++;
1489
1490       /* Find the end of the identifier.  */
1491       q = p;
1492       while (q < limit && is_idchar (*q))
1493         q++;
1494
1495       len = q - p;
1496
1497       /* Loop over the function macro arguments to see if the
1498          identifier inside the string matches one of them.  */
1499       for (i = 0; i < macro->paramc; i++)
1500         {
1501           const cpp_hashnode *node = macro->params[i];
1502
1503           if (NODE_LEN (node) == len
1504               && !memcmp (p, NODE_NAME (node), len))
1505             {
1506               cpp_error (pfile, DL_WARNING,
1507            "macro argument \"%s\" would be stringified in traditional C",
1508                          NODE_NAME (node));
1509               break;
1510             }
1511         }
1512     }
1513 }
1514
1515 /* Returns the name, arguments and expansion of a macro, in a format
1516    suitable to be read back in again, and therefore also for DWARF 2
1517    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1518    Caller is expected to generate the "#define" bit if needed.  The
1519    returned text is temporary, and automatically freed later.  */
1520 const unsigned char *
1521 cpp_macro_definition (pfile, node)
1522      cpp_reader *pfile;
1523      const cpp_hashnode *node;
1524 {
1525   unsigned int i, len;
1526   const cpp_macro *macro = node->value.macro;
1527   unsigned char *buffer;
1528
1529   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1530     {
1531       cpp_error (pfile, DL_ICE,
1532                  "invalid hash type %d in cpp_macro_definition", node->type);
1533       return 0;
1534     }
1535
1536   /* Calculate length.  */
1537   len = NODE_LEN (node) + 1;                    /* ' ' */
1538   if (macro->fun_like)
1539     {
1540       len += 4;         /* "()" plus possible final ".." of named
1541                            varargs (we have + 1 below).  */
1542       for (i = 0; i < macro->paramc; i++)
1543         len += NODE_LEN (macro->params[i]) + 1; /* "," */
1544     }
1545
1546   for (i = 0; i < macro->count; i++)
1547     {
1548       cpp_token *token = &macro->expansion[i];
1549
1550       if (token->type == CPP_MACRO_ARG)
1551         len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1552       else
1553         len += cpp_token_len (token); /* Includes room for ' '.  */
1554       if (token->flags & STRINGIFY_ARG)
1555         len++;                  /* "#" */
1556       if (token->flags & PASTE_LEFT)
1557         len += 3;               /* " ##" */
1558     }
1559
1560   if (len > pfile->macro_buffer_len)
1561     {
1562       pfile->macro_buffer = (uchar *) xrealloc (pfile->macro_buffer, len);
1563       pfile->macro_buffer_len = len;
1564     }
1565
1566   /* Fill in the buffer.  Start with the macro name.  */
1567   buffer = pfile->macro_buffer;
1568   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1569   buffer += NODE_LEN (node);
1570
1571   /* Parameter names.  */
1572   if (macro->fun_like)
1573     {
1574       *buffer++ = '(';
1575       for (i = 0; i < macro->paramc; i++)
1576         {
1577           cpp_hashnode *param = macro->params[i];
1578
1579           if (param != pfile->spec_nodes.n__VA_ARGS__)
1580             {
1581               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1582               buffer += NODE_LEN (param);
1583             }
1584
1585           if (i + 1 < macro->paramc)
1586             /* Don't emit a space after the comma here; we're trying
1587                to emit a Dwarf-friendly definition, and the Dwarf spec
1588                forbids spaces in the argument list.  */
1589             *buffer++ = ',';
1590           else if (macro->variadic)
1591             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1592         }
1593       *buffer++ = ')';
1594     }
1595
1596   /* The Dwarf spec requires a space after the macro name, even if the
1597      definition is the empty string.  */
1598   *buffer++ = ' ';
1599
1600   /* Expansion tokens.  */
1601   if (macro->count)
1602     {
1603       for (i = 0; i < macro->count; i++)
1604         {
1605           cpp_token *token = &macro->expansion[i];
1606
1607           if (token->flags & PREV_WHITE)
1608             *buffer++ = ' ';
1609           if (token->flags & STRINGIFY_ARG)
1610             *buffer++ = '#';
1611
1612           if (token->type == CPP_MACRO_ARG)
1613             {
1614               len = NODE_LEN (macro->params[token->val.arg_no - 1]);
1615               memcpy (buffer,
1616                       NODE_NAME (macro->params[token->val.arg_no - 1]), len);
1617               buffer += len;
1618             }
1619           else
1620             buffer = cpp_spell_token (pfile, token, buffer);
1621
1622           if (token->flags & PASTE_LEFT)
1623             {
1624               *buffer++ = ' ';
1625               *buffer++ = '#';
1626               *buffer++ = '#';
1627               /* Next has PREV_WHITE; see _cpp_create_definition.  */
1628             }
1629         }
1630     }
1631
1632   *buffer = '\0';
1633   return pfile->macro_buffer;
1634 }