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