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