contrib/gcclibs/libcpp/macro.c

   1 /* Part of CPP library.  (Macro and #define handling.)
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005,
   4    2006 Free Software Foundation, Inc.
   5    Written by Per Bothner, 1994.
   6    Based on CCCP program by Paul Rubin, June 1986
   7    Adapted to ANSI C, Richard Stallman, Jan 1987
   8
   9 This program is free software; you can redistribute it and/or modify it
  10 under the terms of the GNU General Public License as published by the
  11 Free Software Foundation; either version 2, or (at your option) any
  12 later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  22
  23  In other words, you are welcome to use, share and improve this program.
  24  You are forbidden to forbid anyone else to use, share and improve
  25  what you give them.   Help stamp out software-hoarding!  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "cpplib.h"
  30 #include "internal.h"
  31
  32 typedef struct macro_arg macro_arg;
  33 struct macro_arg
  34 {
  35   const cpp_token **first;      /* First token in unexpanded argument.  */
  36   const cpp_token **expanded;   /* Macro-expanded argument.  */
  37   const cpp_token *stringified; /* Stringified argument.  */
  38   unsigned int count;           /* # of tokens in argument.  */
  39   unsigned int expanded_count;  /* # of tokens in expanded argument.  */
  40 };
  41
  42 /* Macro expansion.  */
  43
  44 static int enter_macro_context (cpp_reader *, cpp_hashnode *);
  45 static int builtin_macro (cpp_reader *, cpp_hashnode *);
  46 static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
  47                                  const cpp_token **, unsigned int);
  48 static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *);
  49 static cpp_context *next_context (cpp_reader *);
  50 static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
  51 static void expand_arg (cpp_reader *, macro_arg *);
  52 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
  53 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
  54 static void paste_all_tokens (cpp_reader *, const cpp_token *);
  55 static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);
  56 static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
  57                           macro_arg *);
  58 static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *);
  59 static bool create_iso_definition (cpp_reader *, cpp_macro *);
  60
  61 /* #define directive parsing and handling.  */
  62
  63 static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);
  64 static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);
  65 static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,
  66                                   const cpp_macro *);
  67 static bool parse_params (cpp_reader *, cpp_macro *);
  68 static void check_trad_stringification (cpp_reader *, const cpp_macro *,
  69                                         const cpp_string *);
  70
  71 /* Emits a warning if NODE is a macro defined in the main file that
  72    has not been used.  */
  73 int
  74 _cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,
  75                            void *v ATTRIBUTE_UNUSED)
  76 {
  77   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
  78     {
  79       cpp_macro *macro = node->value.macro;
  80
  81       if (!macro->used
  82           && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))
  83         cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,
  84                              "macro \"%s\" is not used", NODE_NAME (node));
  85     }
  86
  87   return 1;
  88 }
  89
  90 /* Allocates and returns a CPP_STRING token, containing TEXT of length
  91    LEN, after null-terminating it.  TEXT must be in permanent storage.  */
  92 static const cpp_token *
  93 new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
  94 {
  95   cpp_token *token = _cpp_temp_token (pfile);
  96
  97   text[len] = '\0';
  98   token->type = CPP_STRING;
  99   token->val.str.len = len;
 100   token->val.str.text = text;
 101   token->flags = 0;
 102   return token;
 103 }
 104
 105 static const char * const monthnames[] =
 106 {
 107   "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 108   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 109 };
 110
 111 /* Helper function for builtin_macro.  Returns the text generated by
 112    a builtin macro. */
 113 const uchar *
 114 _cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)
 115 {
 116   const struct line_map *map;
 117   const uchar *result = NULL;
 118   unsigned int number = 1;
 119
 120   switch (node->value.builtin)
 121     {
 122     default:
 123       cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
 124                  NODE_NAME (node));
 125       break;
 126
 127     case BT_TIMESTAMP:
 128       {
 129         cpp_buffer *pbuffer = cpp_get_buffer (pfile);
 130         if (pbuffer->timestamp == NULL)
 131           {
 132             /* Initialize timestamp value of the assotiated file. */
 133             struct _cpp_file *file = cpp_get_file (pbuffer);
 134             if (file)
 135               {
 136                 /* Generate __TIMESTAMP__ string, that represents
 137                    the date and time of the last modification
 138                    of the current source file. The string constant
 139                    looks like "Sun Sep 16 01:03:52 1973".  */
 140                 struct tm *tb = NULL;
 141                 struct stat *st = _cpp_get_file_stat (file);
 142                 if (st)
 143                   tb = localtime (&st->st_mtime);
 144                 if (tb)
 145                   {
 146                     char *str = asctime (tb);
 147                     size_t len = strlen (str);
 148                     unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);
 149                     buf[0] = '"';
 150                     strcpy ((char *) buf + 1, str);
 151                     buf[len] = '"';
 152                     pbuffer->timestamp = buf;
 153                   }
 154                 else
 155                   {
 156                     cpp_errno (pfile, CPP_DL_WARNING,
 157                         "could not determine file timestamp");
 158                     pbuffer->timestamp = U"\"??? ??? ?? ??:??:?? ????\"";
 159                   }
 160               }
 161           }
 162         result = pbuffer->timestamp;
 163       }
 164       break;
 165     case BT_FILE:
 166     case BT_BASE_FILE:
 167       {
 168         unsigned int len;
 169         const char *name;
 170         uchar *buf;
 171         map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);
 172
 173         if (node->value.builtin == BT_BASE_FILE)
 174           while (! MAIN_FILE_P (map))
 175             map = INCLUDED_FROM (pfile->line_table, map);
 176
 177         name = map->to_file;
 178         len = strlen (name);
 179         buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);
 180         result = buf;
 181         *buf = '"';
 182         buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);
 183         *buf++ = '"';
 184         *buf = '\0';
 185       }
 186       break;
 187
 188     case BT_INCLUDE_LEVEL:
 189       /* The line map depth counts the primary source as level 1, but
 190          historically __INCLUDE_DEPTH__ has called the primary source
 191          level 0.  */
 192       number = pfile->line_table->depth - 1;
 193       break;
 194
 195     case BT_SPECLINE:
 196       map = &pfile->line_table->maps[pfile->line_table->used-1];
 197       /* If __LINE__ is embedded in a macro, it must expand to the
 198          line of the macro's invocation, not its definition.
 199          Otherwise things like assert() will not work properly.  */
 200       if (CPP_OPTION (pfile, traditional))
 201         number = pfile->line_table->highest_line;
 202       else
 203         number = pfile->cur_token[-1].src_loc;
 204       number = SOURCE_LINE (map, number);
 205       break;
 206
 207       /* __STDC__ has the value 1 under normal circumstances.
 208          However, if (a) we are in a system header, (b) the option
 209          stdc_0_in_system_headers is true (set by target config), and
 210          (c) we are not in strictly conforming mode, then it has the
 211          value 0.  (b) and (c) are already checked in cpp_init_builtins.  */
 212     case BT_STDC:
 213       if (cpp_in_system_header (pfile))
 214         number = 0;
 215       else
 216         number = 1;
 217       break;
 218
 219     case BT_DATE:
 220     case BT_TIME:
 221       if (pfile->date == NULL)
 222         {
 223           /* Allocate __DATE__ and __TIME__ strings from permanent
 224              storage.  We only do this once, and don't generate them
 225              at init time, because time() and localtime() are very
 226              slow on some systems.  */
 227           time_t tt;
 228           struct tm *tb = NULL;
 229
 230           /* (time_t) -1 is a legitimate value for "number of seconds
 231              since the Epoch", so we have to do a little dance to
 232              distinguish that from a genuine error.  */
 233           errno = 0;
 234           tt = time(NULL);
 235           if (tt != (time_t)-1 || errno == 0)
 236             tb = localtime (&tt);
 237
 238           if (tb)
 239             {
 240               pfile->date = _cpp_unaligned_alloc (pfile,
 241                                                   sizeof ("\"Oct 11 1347\""));
 242               sprintf ((char *) pfile->date, "\"%s %2d %4d\"",
 243                        monthnames[tb->tm_mon], tb->tm_mday,
 244                        tb->tm_year + 1900);
 245
 246               pfile->time = _cpp_unaligned_alloc (pfile,
 247                                                   sizeof ("\"12:34:56\""));
 248               sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",
 249                        tb->tm_hour, tb->tm_min, tb->tm_sec);
 250             }
 251           else
 252             {
 253               cpp_errno (pfile, CPP_DL_WARNING,
 254                          "could not determine date and time");
 255
 256               pfile->date = U"\"??? ?? ????\"";
 257               pfile->time = U"\"??:??:??\"";
 258             }
 259         }
 260
 261       if (node->value.builtin == BT_DATE)
 262         result = pfile->date;
 263       else
 264         result = pfile->time;
 265       break;
 266
 267     case BT_COUNTER:
 268       if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)
 269         cpp_error (pfile, CPP_DL_ERROR,
 270             "__COUNTER__ expanded inside directive with -fdirectives-only");
 271       number = pfile->nextcounter++;
 272       break;
 273     }
 274
 275   if (result == NULL)
 276     {
 277       /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers.  */
 278       result = _cpp_unaligned_alloc (pfile, 21);
 279       sprintf ((char *) result, "%u", number);
 280     }
 281
 282   return result;
 283 }
 284
 285 /* Convert builtin macros like __FILE__ to a token and push it on the
 286    context stack.  Also handles _Pragma, for which a new token may not
 287    be created.  Returns 1 if it generates a new token context, 0 to
 288    return the token to the caller.  */
 289 static int
 290 builtin_macro (cpp_reader *pfile, cpp_hashnode *node)
 291 {
 292   const uchar *buf;
 293   size_t len;
 294   char *nbuf;
 295
 296   if (node->value.builtin == BT_PRAGMA)
 297     {
 298       /* Don't interpret _Pragma within directives.  The standard is
 299          not clear on this, but to me this makes most sense.  */
 300       if (pfile->state.in_directive)
 301         return 0;
 302
 303       _cpp_do__Pragma (pfile);
 304       return 1;
 305     }
 306
 307   buf = _cpp_builtin_macro_text (pfile, node);
 308   len = ustrlen (buf);
 309   nbuf = (char *) alloca (len + 1);
 310   memcpy (nbuf, buf, len);
 311   nbuf[len]='\n';
 312
 313   cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);
 314   _cpp_clean_line (pfile);
 315
 316   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
 317   pfile->cur_token = _cpp_temp_token (pfile);
 318   _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);
 319   if (pfile->buffer->cur != pfile->buffer->rlimit)
 320     cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",
 321                NODE_NAME (node));
 322   _cpp_pop_buffer (pfile);
 323
 324   return 1;
 325 }
 326
 327 /* Copies SRC, of length LEN, to DEST, adding backslashes before all
 328    backslashes and double quotes. DEST must be of sufficient size.
 329    Returns a pointer to the end of the string.  */
 330 uchar *
 331 cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)
 332 {
 333   while (len--)
 334     {
 335       uchar c = *src++;
 336
 337       if (c == '\\' || c == '"')
 338         {
 339           *dest++ = '\\';
 340           *dest++ = c;
 341         }
 342       else
 343           *dest++ = c;
 344     }
 345
 346   return dest;
 347 }
 348
 349 /* Convert a token sequence ARG to a single string token according to
 350    the rules of the ISO C #-operator.  */
 351 static const cpp_token *
 352 stringify_arg (cpp_reader *pfile, macro_arg *arg)
 353 {
 354   unsigned char *dest;
 355   unsigned int i, escape_it, backslash_count = 0;
 356   const cpp_token *source = NULL;
 357   size_t len;
 358
 359   if (BUFF_ROOM (pfile->u_buff) < 3)
 360     _cpp_extend_buff (pfile, &pfile->u_buff, 3);
 361   dest = BUFF_FRONT (pfile->u_buff);
 362   *dest++ = '"';
 363
 364   /* Loop, reading in the argument's tokens.  */
 365   for (i = 0; i < arg->count; i++)
 366     {
 367       const cpp_token *token = arg->first[i];
 368
 369       if (token->type == CPP_PADDING)
 370         {
 371           if (source == NULL)
 372             source = token->val.source;
 373           continue;
 374         }
 375
 376       escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
 377                    || token->type == CPP_CHAR || token->type == CPP_WCHAR);
 378
 379       /* Room for each char being written in octal, initial space and
 380          final quote and NUL.  */
 381       len = cpp_token_len (token);
 382       if (escape_it)
 383         len *= 4;
 384       len += 3;
 385
 386       if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
 387         {
 388           size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
 389           _cpp_extend_buff (pfile, &pfile->u_buff, len);
 390           dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
 391         }
 392
 393       /* Leading white space?  */
 394       if (dest - 1 != BUFF_FRONT (pfile->u_buff))
 395         {
 396           if (source == NULL)
 397             source = token;
 398           if (source->flags & PREV_WHITE)
 399             *dest++ = ' ';
 400         }
 401       source = NULL;
 402
 403       if (escape_it)
 404         {
 405           _cpp_buff *buff = _cpp_get_buff (pfile, len);
 406           unsigned char *buf = BUFF_FRONT (buff);
 407           len = cpp_spell_token (pfile, token, buf, true) - buf;
 408           dest = cpp_quote_string (dest, buf, len);
 409           _cpp_release_buff (pfile, buff);
 410         }
 411       else
 412         dest = cpp_spell_token (pfile, token, dest, true);
 413
 414       if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')
 415         backslash_count++;
 416       else
 417         backslash_count = 0;
 418     }
 419
 420   /* Ignore the final \ of invalid string literals.  */
 421   if (backslash_count & 1)
 422     {
 423       cpp_error (pfile, CPP_DL_WARNING,
 424                  "invalid string literal, ignoring final '\\'");
 425       dest--;
 426     }
 427
 428   /* Commit the memory, including NUL, and return the token.  */
 429   *dest++ = '"';
 430   len = dest - BUFF_FRONT (pfile->u_buff);
 431   BUFF_FRONT (pfile->u_buff) = dest + 1;
 432   return new_string_token (pfile, dest - len, len);
 433 }
 434
 435 /* Try to paste two tokens.  On success, return nonzero.  In any
 436    case, PLHS is updated to point to the pasted token, which is
 437    guaranteed to not have the PASTE_LEFT flag set.  */
 438 static bool
 439 paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)
 440 {
 441   unsigned char *buf, *end, *lhsend;
 442   cpp_token *lhs;
 443   unsigned int len;
 444
 445   len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;
 446   buf = (unsigned char *) alloca (len);
 447   end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);
 448
 449   /* Avoid comment headers, since they are still processed in stage 3.
 450      It is simpler to insert a space here, rather than modifying the
 451      lexer to ignore comments in some circumstances.  Simply returning
 452      false doesn't work, since we want to clear the PASTE_LEFT flag.  */
 453   if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
 454     *end++ = ' ';
 455   end = cpp_spell_token (pfile, rhs, end, false);
 456   *end = '\n';
 457
 458   cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);
 459   _cpp_clean_line (pfile);
 460
 461   /* Set pfile->cur_token as required by _cpp_lex_direct.  */
 462   pfile->cur_token = _cpp_temp_token (pfile);
 463   lhs = _cpp_lex_direct (pfile);
 464   if (pfile->buffer->cur != pfile->buffer->rlimit)
 465     {
 466       source_location saved_loc = lhs->src_loc;
 467
 468       _cpp_pop_buffer (pfile);
 469       _cpp_backup_tokens (pfile, 1);
 470       *lhsend = '\0';
 471
 472       /* We have to remove the PASTE_LEFT flag from the old lhs, but
 473          we want to keep the new location.  */
 474       *lhs = **plhs;
 475       *plhs = lhs;
 476       lhs->src_loc = saved_loc;
 477       lhs->flags &= ~PASTE_LEFT;
 478
 479       /* Mandatory error for all apart from assembler.  */
 480       if (CPP_OPTION (pfile, lang) != CLK_ASM)
 481         cpp_error (pfile, CPP_DL_ERROR,
 482          "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
 483                    buf, cpp_token_as_text (pfile, rhs));
 484       return false;
 485     }
 486
 487   *plhs = lhs;
 488   _cpp_pop_buffer (pfile);
 489   return true;
 490 }
 491
 492 /* Handles an arbitrarily long sequence of ## operators, with initial
 493    operand LHS.  This implementation is left-associative,
 494    non-recursive, and finishes a paste before handling succeeding
 495    ones.  If a paste fails, we back up to the RHS of the failing ##
 496    operator before pushing the context containing the result of prior
 497    successful pastes, with the effect that the RHS appears in the
 498    output stream after the pasted LHS normally.  */
 499 static void
 500 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
 501 {
 502   const cpp_token *rhs;
 503   cpp_context *context = pfile->context;
 504
 505   do
 506     {
 507       /* Take the token directly from the current context.  We can do
 508          this, because we are in the replacement list of either an
 509          object-like macro, or a function-like macro with arguments
 510          inserted.  In either case, the constraints to #define
 511          guarantee we have at least one more token.  */
 512       if (context->direct_p)
 513         rhs = FIRST (context).token++;
 514       else
 515         rhs = *FIRST (context).ptoken++;
 516
 517       if (rhs->type == CPP_PADDING)
 518         abort ();
 519
 520       if (!paste_tokens (pfile, &lhs, rhs))
 521         break;
 522     }
 523   while (rhs->flags & PASTE_LEFT);
 524
 525   /* Put the resulting token in its own context.  */
 526   _cpp_push_token_context (pfile, NULL, lhs, 1);
 527 }
 528
 529 /* Returns TRUE if the number of arguments ARGC supplied in an
 530    invocation of the MACRO referenced by NODE is valid.  An empty
 531    invocation to a macro with no parameters should pass ARGC as zero.
 532
 533    Note that MACRO cannot necessarily be deduced from NODE, in case
 534    NODE was redefined whilst collecting arguments.  */
 535 bool
 536 _cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)
 537 {
 538   if (argc == macro->paramc)
 539     return true;
 540
 541   if (argc < macro->paramc)
 542     {
 543       /* As an extension, a rest argument is allowed to not appear in
 544          the invocation at all.
 545          e.g. #define debug(format, args...) something
 546          debug("string");
 547
 548          This is exactly the same as if there had been an empty rest
 549          argument - debug("string", ).  */
 550
 551       if (argc + 1 == macro->paramc && macro->variadic)
 552         {
 553           if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
 554             cpp_error (pfile, CPP_DL_PEDWARN,
 555                        "ISO C99 requires rest arguments to be used");
 556           return true;
 557         }
 558
 559       cpp_error (pfile, CPP_DL_ERROR,
 560                  "macro \"%s\" requires %u arguments, but only %u given",
 561                  NODE_NAME (node), macro->paramc, argc);
 562     }
 563   else
 564     cpp_error (pfile, CPP_DL_ERROR,
 565                "macro \"%s\" passed %u arguments, but takes just %u",
 566                NODE_NAME (node), argc, macro->paramc);
 567
 568   return false;
 569 }
 570
 571 /* Reads and returns the arguments to a function-like macro
 572    invocation.  Assumes the opening parenthesis has been processed.
 573    If there is an error, emits an appropriate diagnostic and returns
 574    NULL.  Each argument is terminated by a CPP_EOF token, for the
 575    future benefit of expand_arg().  */
 576 static _cpp_buff *
 577 collect_args (cpp_reader *pfile, const cpp_hashnode *node)
 578 {
 579   _cpp_buff *buff, *base_buff;
 580   cpp_macro *macro;
 581   macro_arg *args, *arg;
 582   const cpp_token *token;
 583   unsigned int argc;
 584
 585   macro = node->value.macro;
 586   if (macro->paramc)
 587     argc = macro->paramc;
 588   else
 589     argc = 1;
 590   buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)
 591                                        + sizeof (macro_arg)));
 592   base_buff = buff;
 593   args = (macro_arg *) buff->base;
 594   memset (args, 0, argc * sizeof (macro_arg));
 595   buff->cur = (unsigned char *) &args[argc];
 596   arg = args, argc = 0;
 597
 598   /* Collect the tokens making up each argument.  We don't yet know
 599      how many arguments have been supplied, whether too many or too
 600      few.  Hence the slightly bizarre usage of "argc" and "arg".  */
 601   do
 602     {
 603       unsigned int paren_depth = 0;
 604       unsigned int ntokens = 0;
 605
 606       argc++;
 607       arg->first = (const cpp_token **) buff->cur;
 608
 609       for (;;)
 610         {
 611           /* Require space for 2 new tokens (including a CPP_EOF).  */
 612           if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
 613             {
 614               buff = _cpp_append_extend_buff (pfile, buff,
 615                                               1000 * sizeof (cpp_token *));
 616               arg->first = (const cpp_token **) buff->cur;
 617             }
 618
 619           token = cpp_get_token (pfile);
 620
 621           if (token->type == CPP_PADDING)
 622             {
 623               /* Drop leading padding.  */
 624               if (ntokens == 0)
 625                 continue;
 626             }
 627           else if (token->type == CPP_OPEN_PAREN)
 628             paren_depth++;
 629           else if (token->type == CPP_CLOSE_PAREN)
 630             {
 631               if (paren_depth-- == 0)
 632                 break;
 633             }
 634           else if (token->type == CPP_COMMA)
 635             {
 636               /* A comma does not terminate an argument within
 637                  parentheses or as part of a variable argument.  */
 638               if (paren_depth == 0
 639                   && ! (macro->variadic && argc == macro->paramc))
 640                 break;
 641             }
 642           else if (token->type == CPP_EOF
 643                    || (token->type == CPP_HASH && token->flags & BOL))
 644             break;
 645
 646           arg->first[ntokens++] = token;
 647         }
 648
 649       /* Drop trailing padding.  */
 650       while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
 651         ntokens--;
 652
 653       arg->count = ntokens;
 654       arg->first[ntokens] = &pfile->eof;
 655
 656       /* Terminate the argument.  Excess arguments loop back and
 657          overwrite the final legitimate argument, before failing.  */
 658       if (argc <= macro->paramc)
 659         {
 660           buff->cur = (unsigned char *) &arg->first[ntokens + 1];
 661           if (argc != macro->paramc)
 662             arg++;
 663         }
 664     }
 665   while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
 666
 667   if (token->type == CPP_EOF)
 668     {
 669       /* We still need the CPP_EOF to end directives, and to end
 670          pre-expansion of a macro argument.  Step back is not
 671          unconditional, since we don't want to return a CPP_EOF to our
 672          callers at the end of an -include-d file.  */
 673       if (pfile->context->prev || pfile->state.in_directive)
 674         _cpp_backup_tokens (pfile, 1);
 675       cpp_error (pfile, CPP_DL_ERROR,
 676                  "unterminated argument list invoking macro \"%s\"",
 677                  NODE_NAME (node));
 678     }
 679   else
 680     {
 681       /* A single empty argument is counted as no argument.  */
 682       if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
 683         argc = 0;
 684       if (_cpp_arguments_ok (pfile, macro, node, argc))
 685         {
 686           /* GCC has special semantics for , ## b where b is a varargs
 687              parameter: we remove the comma if b was omitted entirely.
 688              If b was merely an empty argument, the comma is retained.
 689              If the macro takes just one (varargs) parameter, then we
 690              retain the comma only if we are standards conforming.
 691
 692              If FIRST is NULL replace_args () swallows the comma.  */
 693           if (macro->variadic && (argc < macro->paramc
 694                                   || (argc == 1 && args[0].count == 0
 695                                       && !CPP_OPTION (pfile, std))))
 696             args[macro->paramc - 1].first = NULL;
 697           return base_buff;
 698         }
 699     }
 700
 701   /* An error occurred.  */
 702   _cpp_release_buff (pfile, base_buff);
 703   return NULL;
 704 }
 705
 706 /* Search for an opening parenthesis to the macro of NODE, in such a
 707    way that, if none is found, we don't lose the information in any
 708    intervening padding tokens.  If we find the parenthesis, collect
 709    the arguments and return the buffer containing them.  */
 710 static _cpp_buff *
 711 funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node)
 712 {
 713   const cpp_token *token, *padding = NULL;
 714
 715   for (;;)
 716     {
 717       token = cpp_get_token (pfile);
 718       if (token->type != CPP_PADDING)
 719         break;
 720       if (padding == NULL
 721           || (!(padding->flags & PREV_WHITE) && token->val.source == NULL))
 722         padding = token;
 723     }
 724
 725   if (token->type == CPP_OPEN_PAREN)
 726     {
 727       pfile->state.parsing_args = 2;
 728       return collect_args (pfile, node);
 729     }
 730
 731   /* CPP_EOF can be the end of macro arguments, or the end of the
 732      file.  We mustn't back up over the latter.  Ugh.  */
 733   if (token->type != CPP_EOF || token == &pfile->eof)
 734     {
 735       /* Back up.  We may have skipped padding, in which case backing
 736          up more than one token when expanding macros is in general
 737          too difficult.  We re-insert it in its own context.  */
 738       _cpp_backup_tokens (pfile, 1);
 739       if (padding)
 740         _cpp_push_token_context (pfile, NULL, padding, 1);
 741     }
 742
 743   return NULL;
 744 }
 745
 746 /* Push the context of a macro with hash entry NODE onto the context
 747    stack.  If we can successfully expand the macro, we push a context
 748    containing its yet-to-be-rescanned replacement list and return one.
 749    Otherwise, we don't push a context and return zero.  */
 750 static int
 751 enter_macro_context (cpp_reader *pfile, cpp_hashnode *node)
 752 {
 753   /* The presence of a macro invalidates a file's controlling macro.  */
 754   pfile->mi_valid = false;
 755
 756   pfile->state.angled_headers = false;
 757
 758   /* Handle standard macros.  */
 759   if (! (node->flags & NODE_BUILTIN))
 760     {
 761       cpp_macro *macro = node->value.macro;
 762
 763       if (macro->fun_like)
 764         {
 765           _cpp_buff *buff;
 766
 767           pfile->state.prevent_expansion++;
 768           pfile->keep_tokens++;
 769           pfile->state.parsing_args = 1;
 770           buff = funlike_invocation_p (pfile, node);
 771           pfile->state.parsing_args = 0;
 772           pfile->keep_tokens--;
 773           pfile->state.prevent_expansion--;
 774
 775           if (buff == NULL)
 776             {
 777               if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
 778                 cpp_error (pfile, CPP_DL_WARNING,
 779  "function-like macro \"%s\" must be used with arguments in traditional C",
 780                            NODE_NAME (node));
 781
 782               return 0;
 783             }
 784
 785           if (macro->paramc > 0)
 786             replace_args (pfile, node, macro, (macro_arg *) buff->base);
 787           _cpp_release_buff (pfile, buff);
 788         }
 789
 790       /* Disable the macro within its expansion.  */
 791       node->flags |= NODE_DISABLED;
 792
 793       macro->used = 1;
 794
 795       if (macro->paramc == 0)
 796         _cpp_push_token_context (pfile, node, macro->exp.tokens, macro->count);
 797
 798       return 1;
 799     }
 800
 801   /* Handle built-in macros and the _Pragma operator.  */
 802   return builtin_macro (pfile, node);
 803 }
 804
 805 /* Replace the parameters in a function-like macro of NODE with the
 806    actual ARGS, and place the result in a newly pushed token context.
 807    Expand each argument before replacing, unless it is operated upon
 808    by the # or ## operators.  */
 809 static void
 810 replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, macro_arg *args)
 811 {
 812   unsigned int i, total;
 813   const cpp_token *src, *limit;
 814   const cpp_token **dest, **first;
 815   macro_arg *arg;
 816   _cpp_buff *buff;
 817
 818   /* First, fully macro-expand arguments, calculating the number of
 819      tokens in the final expansion as we go.  The ordering of the if
 820      statements below is subtle; we must handle stringification before
 821      pasting.  */
 822   total = macro->count;
 823   limit = macro->exp.tokens + macro->count;
 824
 825   for (src = macro->exp.tokens; src < limit; src++)
 826     if (src->type == CPP_MACRO_ARG)
 827       {
 828         /* Leading and trailing padding tokens.  */
 829         total += 2;
 830
 831         /* We have an argument.  If it is not being stringified or
 832            pasted it is macro-replaced before insertion.  */
 833         arg = &args[src->val.arg_no - 1];
 834
 835         if (src->flags & STRINGIFY_ARG)
 836           {
 837             if (!arg->stringified)
 838               arg->stringified = stringify_arg (pfile, arg);
 839           }
 840         else if ((src->flags & PASTE_LEFT)
 841                  || (src > macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
 842           total += arg->count - 1;
 843         else
 844           {
 845             if (!arg->expanded)
 846               expand_arg (pfile, arg);
 847             total += arg->expanded_count - 1;
 848           }
 849       }
 850
 851   /* Now allocate space for the expansion, copy the tokens and replace
 852      the arguments.  */
 853   buff = _cpp_get_buff (pfile, total * sizeof (cpp_token *));
 854   first = (const cpp_token **) buff->base;
 855   dest = first;
 856
 857   for (src = macro->exp.tokens; src < limit; src++)
 858     {
 859       unsigned int count;
 860       const cpp_token **from, **paste_flag;
 861
 862       if (src->type != CPP_MACRO_ARG)
 863         {
 864           *dest++ = src;
 865           continue;
 866         }
 867
 868       paste_flag = 0;
 869       arg = &args[src->val.arg_no - 1];
 870       if (src->flags & STRINGIFY_ARG)
 871         count = 1, from = &arg->stringified;
 872       else if (src->flags & PASTE_LEFT)
 873         count = arg->count, from = arg->first;
 874       else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
 875         {
 876           count = arg->count, from = arg->first;
 877           if (dest != first)
 878             {
 879               if (dest[-1]->type == CPP_COMMA
 880                   && macro->variadic
 881                   && src->val.arg_no == macro->paramc)
 882                 {
 883                   /* Swallow a pasted comma if from == NULL, otherwise
 884                      drop the paste flag.  */
 885                   if (from == NULL)
 886                     dest--;
 887                   else
 888                     paste_flag = dest - 1;
 889                 }
 890               /* Remove the paste flag if the RHS is a placemarker.  */
 891               else if (count == 0)
 892                 paste_flag = dest - 1;
 893             }
 894         }
 895       else
 896         count = arg->expanded_count, from = arg->expanded;
 897
 898       /* Padding on the left of an argument (unless RHS of ##).  */
 899       if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
 900           && src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
 901         *dest++ = padding_token (pfile, src);
 902
 903       if (count)
 904         {
 905           memcpy (dest, from, count * sizeof (cpp_token *));
 906           dest += count;
 907
 908           /* With a non-empty argument on the LHS of ##, the last
 909              token should be flagged PASTE_LEFT.  */
 910           if (src->flags & PASTE_LEFT)
 911             paste_flag = dest - 1;
 912         }
 913
 914       /* Avoid paste on RHS (even case count == 0).  */
 915       if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
 916         *dest++ = &pfile->avoid_paste;
 917
 918       /* Add a new paste flag, or remove an unwanted one.  */
 919       if (paste_flag)
 920         {
 921           cpp_token *token = _cpp_temp_token (pfile);
 922           token->type = (*paste_flag)->type;
 923           token->val = (*paste_flag)->val;
 924           if (src->flags & PASTE_LEFT)
 925             token->flags = (*paste_flag)->flags | PASTE_LEFT;
 926           else
 927             token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
 928           *paste_flag = token;
 929         }
 930     }
 931
 932   /* Free the expanded arguments.  */
 933   for (i = 0; i < macro->paramc; i++)
 934     if (args[i].expanded)
 935       free (args[i].expanded);
 936
 937   push_ptoken_context (pfile, node, buff, first, dest - first);
 938 }
 939
 940 /* Return a special padding token, with padding inherited from SOURCE.  */
 941 static const cpp_token *
 942 padding_token (cpp_reader *pfile, const cpp_token *source)
 943 {
 944   cpp_token *result = _cpp_temp_token (pfile);
 945
 946   result->type = CPP_PADDING;
 947
 948   /* Data in GCed data structures cannot be made const so far, so we
 949      need a cast here.  */
 950   result->val.source = (cpp_token *) source;
 951   result->flags = 0;
 952   return result;
 953 }
 954
 955 /* Get a new uninitialized context.  Create a new one if we cannot
 956    re-use an old one.  */
 957 static cpp_context *
 958 next_context (cpp_reader *pfile)
 959 {
 960   cpp_context *result = pfile->context->next;
 961
 962   if (result == 0)
 963     {
 964       result = XNEW (cpp_context);
 965       result->prev = pfile->context;
 966       result->next = 0;
 967       pfile->context->next = result;
 968     }
 969
 970   pfile->context = result;
 971   return result;
 972 }
 973
 974 /* Push a list of pointers to tokens.  */
 975 static void
 976 push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
 977                      const cpp_token **first, unsigned int count)
 978 {
 979   cpp_context *context = next_context (pfile);
 980
 981   context->direct_p = false;
 982   context->macro = macro;
 983   context->buff = buff;
 984   FIRST (context).ptoken = first;
 985   LAST (context).ptoken = first + count;
 986 }
 987
 988 /* Push a list of tokens.  */
 989 void
 990 _cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
 991                          const cpp_token *first, unsigned int count)
 992 {
 993   cpp_context *context = next_context (pfile);
 994
 995   context->direct_p = true;
 996   context->macro = macro;
 997   context->buff = NULL;
 998   FIRST (context).token = first;
 999   LAST (context).token = first + count;
1000 }
1001
1002 /* Push a traditional macro's replacement text.  */
1003 void
1004 _cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
1005                         const uchar *start, size_t len)
1006 {
1007   cpp_context *context = next_context (pfile);
1008
1009   context->direct_p = true;
1010   context->macro = macro;
1011   context->buff = NULL;
1012   CUR (context) = start;
1013   RLIMIT (context) = start + len;
1014   macro->flags |= NODE_DISABLED;
1015 }
1016
1017 /* Expand an argument ARG before replacing parameters in a
1018    function-like macro.  This works by pushing a context with the
1019    argument's tokens, and then expanding that into a temporary buffer
1020    as if it were a normal part of the token stream.  collect_args()
1021    has terminated the argument's tokens with a CPP_EOF so that we know
1022    when we have fully expanded the argument.  */
1023 static void
1024 expand_arg (cpp_reader *pfile, macro_arg *arg)
1025 {
1026   unsigned int capacity;
1027   bool saved_warn_trad;
1028
1029   if (arg->count == 0)
1030     return;
1031
1032   /* Don't warn about funlike macros when pre-expanding.  */
1033   saved_warn_trad = CPP_WTRADITIONAL (pfile);
1034   CPP_WTRADITIONAL (pfile) = 0;
1035
1036   /* Loop, reading in the arguments.  */
1037   capacity = 256;
1038   arg->expanded = XNEWVEC (const cpp_token *, capacity);
1039
1040   push_ptoken_context (pfile, NULL, NULL, arg->first, arg->count + 1);
1041   for (;;)
1042     {
1043       const cpp_token *token;
1044
1045       if (arg->expanded_count + 1 >= capacity)
1046         {
1047           capacity *= 2;
1048           arg->expanded = XRESIZEVEC (const cpp_token *, arg->expanded,
1049                                       capacity);
1050         }
1051
1052       token = cpp_get_token (pfile);
1053
1054       if (token->type == CPP_EOF)
1055         break;
1056
1057       arg->expanded[arg->expanded_count++] = token;
1058     }
1059
1060   _cpp_pop_context (pfile);
1061
1062   CPP_WTRADITIONAL (pfile) = saved_warn_trad;
1063 }
1064
1065 /* Pop the current context off the stack, re-enabling the macro if the
1066    context represented a macro's replacement list.  The context
1067    structure is not freed so that we can re-use it later.  */
1068 void
1069 _cpp_pop_context (cpp_reader *pfile)
1070 {
1071   cpp_context *context = pfile->context;
1072
1073   if (context->macro)
1074     context->macro->flags &= ~NODE_DISABLED;
1075
1076   if (context->buff)
1077     _cpp_release_buff (pfile, context->buff);
1078
1079   pfile->context = context->prev;
1080 }
1081
1082 /* External routine to get a token.  Also used nearly everywhere
1083    internally, except for places where we know we can safely call
1084    _cpp_lex_token directly, such as lexing a directive name.
1085
1086    Macro expansions and directives are transparently handled,
1087    including entering included files.  Thus tokens are post-macro
1088    expansion, and after any intervening directives.  External callers
1089    see CPP_EOF only at EOF.  Internal callers also see it when meeting
1090    a directive inside a macro call, when at the end of a directive and
1091    state.in_directive is still 1, and at the end of argument
1092    pre-expansion.  */
1093 const cpp_token *
1094 cpp_get_token (cpp_reader *pfile)
1095 {
1096   const cpp_token *result;
1097
1098   for (;;)
1099     {
1100       cpp_hashnode *node;
1101       cpp_context *context = pfile->context;
1102
1103       /* Context->prev == 0 <=> base context.  */
1104       if (!context->prev)
1105         result = _cpp_lex_token (pfile);
1106       else if (FIRST (context).token != LAST (context).token)
1107         {
1108           if (context->direct_p)
1109             result = FIRST (context).token++;
1110           else
1111             result = *FIRST (context).ptoken++;
1112
1113           if (result->flags & PASTE_LEFT)
1114             {
1115               paste_all_tokens (pfile, result);
1116               if (pfile->state.in_directive)
1117                 continue;
1118               return padding_token (pfile, result);
1119             }
1120         }
1121       else
1122         {
1123           _cpp_pop_context (pfile);
1124           if (pfile->state.in_directive)
1125             continue;
1126           return &pfile->avoid_paste;
1127         }
1128
1129       if (pfile->state.in_directive && result->type == CPP_COMMENT)
1130         continue;
1131
1132       if (result->type != CPP_NAME)
1133         break;
1134
1135       node = result->val.node;
1136
1137       if (node->type != NT_MACRO || (result->flags & NO_EXPAND))
1138         break;
1139
1140       if (!(node->flags & NODE_DISABLED))
1141         {
1142           if (!pfile->state.prevent_expansion
1143               && enter_macro_context (pfile, node))
1144             {
1145               if (pfile->state.in_directive)
1146                 continue;
1147               return padding_token (pfile, result);
1148             }
1149         }
1150       else
1151         {
1152           /* Flag this token as always unexpandable.  FIXME: move this
1153              to collect_args()?.  */
1154           cpp_token *t = _cpp_temp_token (pfile);
1155           t->type = result->type;
1156           t->flags = result->flags | NO_EXPAND;
1157           t->val = result->val;
1158           result = t;
1159         }
1160
1161       break;
1162     }
1163
1164   return result;
1165 }
1166
1167 /* Returns true if we're expanding an object-like macro that was
1168    defined in a system header.  Just checks the macro at the top of
1169    the stack.  Used for diagnostic suppression.  */
1170 int
1171 cpp_sys_macro_p (cpp_reader *pfile)
1172 {
1173   cpp_hashnode *node = pfile->context->macro;
1174
1175   return node && node->value.macro && node->value.macro->syshdr;
1176 }
1177
1178 /* Read each token in, until end of the current file.  Directives are
1179    transparently processed.  */
1180 void
1181 cpp_scan_nooutput (cpp_reader *pfile)
1182 {
1183   /* Request a CPP_EOF token at the end of this file, rather than
1184      transparently continuing with the including file.  */
1185   pfile->buffer->return_at_eof = true;
1186
1187   pfile->state.discarding_output++;
1188   pfile->state.prevent_expansion++;
1189
1190   if (CPP_OPTION (pfile, traditional))
1191     while (_cpp_read_logical_line_trad (pfile))
1192       ;
1193   else
1194     while (cpp_get_token (pfile)->type != CPP_EOF)
1195       ;
1196
1197   pfile->state.discarding_output--;
1198   pfile->state.prevent_expansion--;
1199 }
1200
1201 /* Step back one (or more) tokens.  Can only step back more than 1 if
1202    they are from the lexer, and not from macro expansion.  */
1203 void
1204 _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
1205 {
1206   if (pfile->context->prev == NULL)
1207     {
1208       pfile->lookaheads += count;
1209       while (count--)
1210         {
1211           pfile->cur_token--;
1212           if (pfile->cur_token == pfile->cur_run->base
1213               /* Possible with -fpreprocessed and no leading #line.  */
1214               && pfile->cur_run->prev != NULL)
1215             {
1216               pfile->cur_run = pfile->cur_run->prev;
1217               pfile->cur_token = pfile->cur_run->limit;
1218             }
1219         }
1220     }
1221   else
1222     {
1223       if (count != 1)
1224         abort ();
1225       if (pfile->context->direct_p)
1226         FIRST (pfile->context).token--;
1227       else
1228         FIRST (pfile->context).ptoken--;
1229     }
1230 }
1231
1232 /* #define directive parsing and handling.  */
1233
1234 /* Returns nonzero if a macro redefinition warning is required.  */
1235 static bool
1236 warn_of_redefinition (cpp_reader *pfile, const cpp_hashnode *node,
1237                       const cpp_macro *macro2)
1238 {
1239   const cpp_macro *macro1;
1240   unsigned int i;
1241
1242   /* Some redefinitions need to be warned about regardless.  */
1243   if (node->flags & NODE_WARN)
1244     return true;
1245
1246   /* Redefinition of a macro is allowed if and only if the old and new
1247      definitions are the same.  (6.10.3 paragraph 2).  */
1248   macro1 = node->value.macro;
1249
1250   /* Don't check count here as it can be different in valid
1251      traditional redefinitions with just whitespace differences.  */
1252   if (macro1->paramc != macro2->paramc
1253       || macro1->fun_like != macro2->fun_like
1254       || macro1->variadic != macro2->variadic)
1255     return true;
1256
1257   /* Check parameter spellings.  */
1258   for (i = 0; i < macro1->paramc; i++)
1259     if (macro1->params[i] != macro2->params[i])
1260       return true;
1261
1262   /* Check the replacement text or tokens.  */
1263   if (CPP_OPTION (pfile, traditional))
1264     return _cpp_expansions_different_trad (macro1, macro2);
1265
1266   if (macro1->count != macro2->count)
1267     return true;
1268
1269   for (i = 0; i < macro1->count; i++)
1270     if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
1271       return true;
1272
1273   return false;
1274 }
1275
1276 /* Free the definition of hashnode H.  */
1277 void
1278 _cpp_free_definition (cpp_hashnode *h)
1279 {
1280   /* Macros and assertions no longer have anything to free.  */
1281   h->type = NT_VOID;
1282   /* Clear builtin flag in case of redefinition.  */
1283   h->flags &= ~(NODE_BUILTIN | NODE_DISABLED);
1284 }
1285
1286 /* Save parameter NODE to the parameter list of macro MACRO.  Returns
1287    zero on success, nonzero if the parameter is a duplicate.  */
1288 bool
1289 _cpp_save_parameter (cpp_reader *pfile, cpp_macro *macro, cpp_hashnode *node)
1290 {
1291   unsigned int len;
1292   /* Constraint 6.10.3.6 - duplicate parameter names.  */
1293   if (node->flags & NODE_MACRO_ARG)
1294     {
1295       cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
1296                  NODE_NAME (node));
1297       return true;
1298     }
1299
1300   if (BUFF_ROOM (pfile->a_buff)
1301       < (macro->paramc + 1) * sizeof (cpp_hashnode *))
1302     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_hashnode *));
1303
1304   ((cpp_hashnode **) BUFF_FRONT (pfile->a_buff))[macro->paramc++] = node;
1305   node->flags |= NODE_MACRO_ARG;
1306   len = macro->paramc * sizeof (union _cpp_hashnode_value);
1307   if (len > pfile->macro_buffer_len)
1308     {
1309       pfile->macro_buffer = XRESIZEVEC (unsigned char, pfile->macro_buffer,
1310                                         len);
1311       pfile->macro_buffer_len = len;
1312     }
1313   ((union _cpp_hashnode_value *) pfile->macro_buffer)[macro->paramc - 1]
1314     = node->value;
1315
1316   node->value.arg_index  = macro->paramc;
1317   return false;
1318 }
1319
1320 /* Check the syntax of the parameters in a MACRO definition.  Returns
1321    false if an error occurs.  */
1322 static bool
1323 parse_params (cpp_reader *pfile, cpp_macro *macro)
1324 {
1325   unsigned int prev_ident = 0;
1326
1327   for (;;)
1328     {
1329       const cpp_token *token = _cpp_lex_token (pfile);
1330
1331       switch (token->type)
1332         {
1333         default:
1334           /* Allow/ignore comments in parameter lists if we are
1335              preserving comments in macro expansions.  */
1336           if (token->type == CPP_COMMENT
1337               && ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
1338             continue;
1339
1340           cpp_error (pfile, CPP_DL_ERROR,
1341                      "\"%s\" may not appear in macro parameter list",
1342                      cpp_token_as_text (pfile, token));
1343           return false;
1344
1345         case CPP_NAME:
1346           if (prev_ident)
1347             {
1348               cpp_error (pfile, CPP_DL_ERROR,
1349                          "macro parameters must be comma-separated");
1350               return false;
1351             }
1352           prev_ident = 1;
1353
1354           if (_cpp_save_parameter (pfile, macro, token->val.node))
1355             return false;
1356           continue;
1357
1358         case CPP_CLOSE_PAREN:
1359           if (prev_ident || macro->paramc == 0)
1360             return true;
1361
1362           /* Fall through to pick up the error.  */
1363         case CPP_COMMA:
1364           if (!prev_ident)
1365             {
1366               cpp_error (pfile, CPP_DL_ERROR, "parameter name missing");
1367               return false;
1368             }
1369           prev_ident = 0;
1370           continue;
1371
1372         case CPP_ELLIPSIS:
1373           macro->variadic = 1;
1374           if (!prev_ident)
1375             {
1376               _cpp_save_parameter (pfile, macro,
1377                                    pfile->spec_nodes.n__VA_ARGS__);
1378               pfile->state.va_args_ok = 1;
1379               if (! CPP_OPTION (pfile, c99)
1380                   && CPP_OPTION (pfile, pedantic)
1381                   && CPP_OPTION (pfile, warn_variadic_macros))
1382                 cpp_error (pfile, CPP_DL_PEDWARN,
1383                            "anonymous variadic macros were introduced in C99");
1384             }
1385           else if (CPP_OPTION (pfile, pedantic)
1386                    && CPP_OPTION (pfile, warn_variadic_macros))
1387             cpp_error (pfile, CPP_DL_PEDWARN,
1388                        "ISO C does not permit named variadic macros");
1389
1390           /* We're at the end, and just expect a closing parenthesis.  */
1391           token = _cpp_lex_token (pfile);
1392           if (token->type == CPP_CLOSE_PAREN)
1393             return true;
1394           /* Fall through.  */
1395
1396         case CPP_EOF:
1397           cpp_error (pfile, CPP_DL_ERROR, "missing ')' in macro parameter list");
1398           return false;
1399         }
1400     }
1401 }
1402
1403 /* Allocate room for a token from a macro's replacement list.  */
1404 static cpp_token *
1405 alloc_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1406 {
1407   if (BUFF_ROOM (pfile->a_buff) < (macro->count + 1) * sizeof (cpp_token))
1408     _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (cpp_token));
1409
1410   return &((cpp_token *) BUFF_FRONT (pfile->a_buff))[macro->count++];
1411 }
1412
1413 /* Lex a token from the expansion of MACRO, but mark parameters as we
1414    find them and warn of traditional stringification.  */
1415 static cpp_token *
1416 lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
1417 {
1418   cpp_token *token, *saved_cur_token;
1419
1420   saved_cur_token = pfile->cur_token;
1421   pfile->cur_token = alloc_expansion_token (pfile, macro);
1422   token = _cpp_lex_direct (pfile);
1423   pfile->cur_token = saved_cur_token;
1424
1425   /* Is this a parameter?  */
1426   if (token->type == CPP_NAME
1427       && (token->val.node->flags & NODE_MACRO_ARG) != 0)
1428     {
1429       token->type = CPP_MACRO_ARG;
1430       token->val.arg_no = token->val.node->value.arg_index;
1431     }
1432   else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
1433            && (token->type == CPP_STRING || token->type == CPP_CHAR))
1434     check_trad_stringification (pfile, macro, &token->val.str);
1435
1436   return token;
1437 }
1438
1439 static bool
1440 create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
1441 {
1442   cpp_token *token;
1443   const cpp_token *ctoken;
1444
1445   /* Get the first token of the expansion (or the '(' of a
1446      function-like macro).  */
1447   ctoken = _cpp_lex_token (pfile);
1448
1449   if (ctoken->type == CPP_OPEN_PAREN && !(ctoken->flags & PREV_WHITE))
1450     {
1451       bool ok = parse_params (pfile, macro);
1452       macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1453       if (!ok)
1454         return false;
1455
1456       /* Success.  Commit or allocate the parameter array.  */
1457       if (pfile->hash_table->alloc_subobject)
1458         {
1459           cpp_hashnode **params =
1460             (cpp_hashnode **) pfile->hash_table->alloc_subobject
1461             (sizeof (cpp_hashnode *) * macro->paramc);
1462           memcpy (params, macro->params,
1463                   sizeof (cpp_hashnode *) * macro->paramc);
1464           macro->params = params;
1465         }
1466       else
1467         BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1468       macro->fun_like = 1;
1469     }
1470   else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
1471     {
1472       /* While ISO C99 requires whitespace before replacement text
1473          in a macro definition, ISO C90 with TC1 allows there characters
1474          from the basic source character set.  */
1475       if (CPP_OPTION (pfile, c99))
1476         cpp_error (pfile, CPP_DL_PEDWARN,
1477                    "ISO C99 requires whitespace after the macro name");
1478       else
1479         {
1480           int warntype = CPP_DL_WARNING;
1481           switch (ctoken->type)
1482             {
1483             case CPP_ATSIGN:
1484             case CPP_AT_NAME:
1485             case CPP_OBJC_STRING:
1486               /* '@' is not in basic character set.  */
1487               warntype = CPP_DL_PEDWARN;
1488               break;
1489             case CPP_OTHER:
1490               /* Basic character set sans letters, digits and _.  */
1491               if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
1492                           ctoken->val.str.text[0]) == NULL)
1493                 warntype = CPP_DL_PEDWARN;
1494               break;
1495             default:
1496               /* All other tokens start with a character from basic
1497                  character set.  */
1498               break;
1499             }
1500           cpp_error (pfile, warntype,
1501                      "missing whitespace after the macro name");
1502         }
1503     }
1504
1505   if (macro->fun_like)
1506     token = lex_expansion_token (pfile, macro);
1507   else
1508     {
1509       token = alloc_expansion_token (pfile, macro);
1510       *token = *ctoken;
1511     }
1512
1513   for (;;)
1514     {
1515       /* Check the stringifying # constraint 6.10.3.2.1 of
1516          function-like macros when lexing the subsequent token.  */
1517       if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
1518         {
1519           if (token->type == CPP_MACRO_ARG)
1520             {
1521               token->flags &= ~PREV_WHITE;
1522               token->flags |= STRINGIFY_ARG;
1523               token->flags |= token[-1].flags & PREV_WHITE;
1524               token[-1] = token[0];
1525               macro->count--;
1526             }
1527           /* Let assembler get away with murder.  */
1528           else if (CPP_OPTION (pfile, lang) != CLK_ASM)
1529             {
1530               cpp_error (pfile, CPP_DL_ERROR,
1531                          "'#' is not followed by a macro parameter");
1532               return false;
1533             }
1534         }
1535
1536       if (token->type == CPP_EOF)
1537         break;
1538
1539       /* Paste operator constraint 6.10.3.3.1.  */
1540       if (token->type == CPP_PASTE)
1541         {
1542           /* Token-paste ##, can appear in both object-like and
1543              function-like macros, but not at the ends.  */
1544           if (--macro->count > 0)
1545             token = lex_expansion_token (pfile, macro);
1546
1547           if (macro->count == 0 || token->type == CPP_EOF)
1548             {
1549               cpp_error (pfile, CPP_DL_ERROR,
1550                  "'##' cannot appear at either end of a macro expansion");
1551               return false;
1552             }
1553
1554           token[-1].flags |= PASTE_LEFT;
1555         }
1556
1557       token = lex_expansion_token (pfile, macro);
1558     }
1559
1560   macro->exp.tokens = (cpp_token *) BUFF_FRONT (pfile->a_buff);
1561   macro->traditional = 0;
1562
1563   /* Don't count the CPP_EOF.  */
1564   macro->count--;
1565
1566   /* Clear whitespace on first token for warn_of_redefinition().  */
1567   if (macro->count)
1568     macro->exp.tokens[0].flags &= ~PREV_WHITE;
1569
1570   /* Commit or allocate the memory.  */
1571   if (pfile->hash_table->alloc_subobject)
1572     {
1573       cpp_token *tokns =
1574         (cpp_token *) pfile->hash_table->alloc_subobject (sizeof (cpp_token)
1575                                                           * macro->count);
1576       memcpy (tokns, macro->exp.tokens, sizeof (cpp_token) * macro->count);
1577       macro->exp.tokens = tokns;
1578     }
1579   else
1580     BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->exp.tokens[macro->count];
1581
1582   return true;
1583 }
1584
1585 /* Parse a macro and save its expansion.  Returns nonzero on success.  */
1586 bool
1587 _cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
1588 {
1589   cpp_macro *macro;
1590   unsigned int i;
1591   bool ok;
1592
1593   if (pfile->hash_table->alloc_subobject)
1594     macro = (cpp_macro *) pfile->hash_table->alloc_subobject
1595       (sizeof (cpp_macro));
1596   else
1597     macro = (cpp_macro *) _cpp_aligned_alloc (pfile, sizeof (cpp_macro));
1598   macro->line = pfile->directive_line;
1599   macro->params = 0;
1600   macro->paramc = 0;
1601   macro->variadic = 0;
1602   macro->used = !CPP_OPTION (pfile, warn_unused_macros);
1603   macro->count = 0;
1604   macro->fun_like = 0;
1605   /* To suppress some diagnostics.  */
1606   macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
1607
1608   if (CPP_OPTION (pfile, traditional))
1609     ok = _cpp_create_trad_definition (pfile, macro);
1610   else
1611     {
1612       ok = create_iso_definition (pfile, macro);
1613
1614       /* We set the type for SEEN_EOL() in directives.c.
1615
1616          Longer term we should lex the whole line before coming here,
1617          and just copy the expansion.  */
1618
1619       /* Stop the lexer accepting __VA_ARGS__.  */
1620       pfile->state.va_args_ok = 0;
1621     }
1622
1623   /* Clear the fast argument lookup indices.  */
1624   for (i = macro->paramc; i-- > 0; )
1625     {
1626       struct cpp_hashnode *node = macro->params[i];
1627       node->flags &= ~ NODE_MACRO_ARG;
1628       node->value = ((union _cpp_hashnode_value *) pfile->macro_buffer)[i];
1629     }
1630
1631   if (!ok)
1632     return ok;
1633
1634   if (node->type == NT_MACRO)
1635     {
1636       if (CPP_OPTION (pfile, warn_unused_macros))
1637         _cpp_warn_if_unused_macro (pfile, node, NULL);
1638
1639       if (warn_of_redefinition (pfile, node, macro))
1640         {
1641           cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->directive_line, 0,
1642                                "\"%s\" redefined", NODE_NAME (node));
1643
1644           if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
1645             cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1646                                  node->value.macro->line, 0,
1647                          "this is the location of the previous definition");
1648         }
1649     }
1650
1651   if (node->type != NT_VOID)
1652     _cpp_free_definition (node);
1653
1654   /* Enter definition in hash table.  */
1655   node->type = NT_MACRO;
1656   node->value.macro = macro;
1657   if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_")))
1658     node->flags |= NODE_WARN;
1659
1660   return ok;
1661 }
1662
1663 /* Warn if a token in STRING matches one of a function-like MACRO's
1664    parameters.  */
1665 static void
1666 check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
1667                             const cpp_string *string)
1668 {
1669   unsigned int i, len;
1670   const uchar *p, *q, *limit;
1671
1672   /* Loop over the string.  */
1673   limit = string->text + string->len - 1;
1674   for (p = string->text + 1; p < limit; p = q)
1675     {
1676       /* Find the start of an identifier.  */
1677       while (p < limit && !is_idstart (*p))
1678         p++;
1679
1680       /* Find the end of the identifier.  */
1681       q = p;
1682       while (q < limit && is_idchar (*q))
1683         q++;
1684
1685       len = q - p;
1686
1687       /* Loop over the function macro arguments to see if the
1688          identifier inside the string matches one of them.  */
1689       for (i = 0; i < macro->paramc; i++)
1690         {
1691           const cpp_hashnode *node = macro->params[i];
1692
1693           if (NODE_LEN (node) == len
1694               && !memcmp (p, NODE_NAME (node), len))
1695             {
1696               cpp_error (pfile, CPP_DL_WARNING,
1697            "macro argument \"%s\" would be stringified in traditional C",
1698                          NODE_NAME (node));
1699               break;
1700             }
1701         }
1702     }
1703 }
1704
1705 /* Returns the name, arguments and expansion of a macro, in a format
1706    suitable to be read back in again, and therefore also for DWARF 2
1707    debugging info.  e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
1708    Caller is expected to generate the "#define" bit if needed.  The
1709    returned text is temporary, and automatically freed later.  */
1710 const unsigned char *
1711 cpp_macro_definition (cpp_reader *pfile, const cpp_hashnode *node)
1712 {
1713   unsigned int i, len;
1714   const cpp_macro *macro = node->value.macro;
1715   unsigned char *buffer;
1716
1717   if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
1718     {
1719       cpp_error (pfile, CPP_DL_ICE,
1720                  "invalid hash type %d in cpp_macro_definition", node->type);
1721       return 0;
1722     }
1723
1724   /* Calculate length.  */
1725   len = NODE_LEN (node) + 2;                    /* ' ' and NUL.  */
1726   if (macro->fun_like)
1727     {
1728       len += 4;         /* "()" plus possible final ".." of named
1729                            varargs (we have + 1 below).  */
1730       for (i = 0; i < macro->paramc; i++)
1731         len += NODE_LEN (macro->params[i]) + 1; /* "," */
1732     }
1733
1734   /* This should match below where we fill in the buffer.  */
1735   if (CPP_OPTION (pfile, traditional))
1736     len += _cpp_replacement_text_len (macro);
1737   else
1738     {
1739       for (i = 0; i < macro->count; i++)
1740         {
1741           cpp_token *token = &macro->exp.tokens[i];
1742
1743           if (token->type == CPP_MACRO_ARG)
1744             len += NODE_LEN (macro->params[token->val.arg_no - 1]);
1745           else
1746             len += cpp_token_len (token);
1747
1748           if (token->flags & STRINGIFY_ARG)
1749             len++;                      /* "#" */
1750           if (token->flags & PASTE_LEFT)
1751             len += 3;           /* " ##" */
1752           if (token->flags & PREV_WHITE)
1753             len++;              /* " " */
1754         }
1755     }
1756
1757   if (len > pfile->macro_buffer_len)
1758     {
1759       pfile->macro_buffer = XRESIZEVEC (unsigned char,
1760                                         pfile->macro_buffer, len);
1761       pfile->macro_buffer_len = len;
1762     }
1763
1764   /* Fill in the buffer.  Start with the macro name.  */
1765   buffer = pfile->macro_buffer;
1766   memcpy (buffer, NODE_NAME (node), NODE_LEN (node));
1767   buffer += NODE_LEN (node);
1768
1769   /* Parameter names.  */
1770   if (macro->fun_like)
1771     {
1772       *buffer++ = '(';
1773       for (i = 0; i < macro->paramc; i++)
1774         {
1775           cpp_hashnode *param = macro->params[i];
1776
1777           if (param != pfile->spec_nodes.n__VA_ARGS__)
1778             {
1779               memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
1780               buffer += NODE_LEN (param);
1781             }
1782
1783           if (i + 1 < macro->paramc)
1784             /* Don't emit a space after the comma here; we're trying
1785                to emit a Dwarf-friendly definition, and the Dwarf spec
1786                forbids spaces in the argument list.  */
1787             *buffer++ = ',';
1788           else if (macro->variadic)
1789             *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
1790         }
1791       *buffer++ = ')';
1792     }
1793
1794   /* The Dwarf spec requires a space after the macro name, even if the
1795      definition is the empty string.  */
1796   *buffer++ = ' ';
1797
1798   if (CPP_OPTION (pfile, traditional))
1799     buffer = _cpp_copy_replacement_text (macro, buffer);
1800   else if (macro->count)
1801   /* Expansion tokens.  */
1802     {
1803       for (i = 0; i < macro->count; i++)
1804         {
1805           cpp_token *token = &macro->exp.tokens[i];
1806
1807           if (token->flags & PREV_WHITE)
1808             *buffer++ = ' ';
1809           if (token->flags & STRINGIFY_ARG)
1810             *buffer++ = '#';
1811
1812           if (token->type == CPP_MACRO_ARG)
1813             {
1814               memcpy (buffer,
1815                       NODE_NAME (macro->params[token->val.arg_no - 1]),
1816                       NODE_LEN (macro->params[token->val.arg_no - 1]));
1817               buffer += NODE_LEN (macro->params[token->val.arg_no - 1]);
1818             }
1819           else
1820             buffer = cpp_spell_token (pfile, token, buffer, false);
1821
1822           if (token->flags & PASTE_LEFT)
1823             {
1824               *buffer++ = ' ';
1825               *buffer++ = '#';
1826               *buffer++ = '#';
1827               /* Next has PREV_WHITE; see _cpp_create_definition.  */
1828             }
1829         }
1830     }
1831
1832   *buffer = '\0';
1833   return pfile->macro_buffer;
1834 }