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