gcc/cpptrad.c

   1 /* CPP Library - traditional lexical analysis and macro expansion.
   2    Copyright (C) 2002 Free Software Foundation, Inc.
   3    Contributed by Neil Booth, May 2002
   4
   5 This program is free software; you can redistribute it and/or modify it
   6 under the terms of the GNU General Public License as published by the
   7 Free Software Foundation; either version 2, or (at your option) any
   8 later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18
  19 #include "config.h"
  20 #include "system.h"
  21 #include "cpplib.h"
  22 #include "cpphash.h"
  23
  24 /* The replacement text of a function-like macro is stored as a
  25    contiguous sequence of aligned blocks, each representing the text
  26    between subsequent parameters in that text.
  27
  28    Each block comprises the length of text contained therein, the
  29    one-based index of the argument that immediately follows that text,
  30    and the text itself.  The final block in the macro expansion is
  31    easily recognizable as it has an argument index of zero.  */
  32
  33 struct block
  34 {
  35   unsigned int text_len;
  36   unsigned short arg_index;
  37   uchar text[1];
  38 };
  39
  40 #define BLOCK_HEADER_LEN offsetof (struct block, text)
  41 #define BLOCK_LEN(TEXT_LEN) CPP_ALIGN (BLOCK_HEADER_LEN + (TEXT_LEN))
  42
  43 /* Structure holding information about a function-like macro
  44    invocation.  */
  45 struct fun_macro
  46 {
  47   /* Memory buffer holding the trad_arg array.  */
  48   _cpp_buff *buff;
  49
  50   /* An array of size the number of macro parameters + 1, containing
  51      the offsets of the start of each macro argument in the output
  52      buffer.  The argument continues until the character before the
  53      start of the next one.  */
  54   size_t *args;
  55
  56   /* The hashnode of the macro.  */
  57   cpp_hashnode *node;
  58
  59   /* The offset of the macro name in the output buffer.  */
  60   size_t offset;
  61
  62   /* Zero-based index of argument being currently lexed.  */
  63   unsigned int argc;
  64 };
  65
  66 /* Lexing state.  It is mostly used to prevent macro expansion.  */
  67 enum ls {ls_none = 0,           /* Normal state.  */
  68          ls_fun_open,           /* When looking for '('.  */
  69          ls_fun_close,          /* When looking for ')'.  */
  70          ls_defined,            /* After defined.  */
  71          ls_defined_close,      /* Looking for ')' of defined().  */
  72          ls_hash,               /* After # in preprocessor conditional.  */
  73          ls_predicate,          /* After the predicate, maybe paren?  */
  74          ls_answer};            /* In answer to predicate.  */
  75
  76 /* Lexing TODO: Maybe handle space in escaped newlines.  Stop cpplex.c
  77    from recognizing comments and directives during its lexing pass.  */
  78
  79 static const uchar *handle_newline PARAMS ((cpp_reader *, const uchar *));
  80 static const uchar *skip_escaped_newlines PARAMS ((cpp_reader *,
  81                                                    const uchar *));
  82 static const uchar *skip_whitespace PARAMS ((cpp_reader *, const uchar *,
  83                                              int));
  84 static cpp_hashnode *lex_identifier PARAMS ((cpp_reader *, const uchar *));
  85 static const uchar *copy_comment PARAMS ((cpp_reader *, const uchar *, int));
  86 static void scan_out_logical_line PARAMS ((cpp_reader *pfile, cpp_macro *));
  87 static void check_output_buffer PARAMS ((cpp_reader *, size_t));
  88 static void push_replacement_text PARAMS ((cpp_reader *, cpp_hashnode *));
  89 static bool scan_parameters PARAMS ((cpp_reader *, cpp_macro *));
  90 static bool recursive_macro PARAMS ((cpp_reader *, cpp_hashnode *));
  91 static void save_replacement_text PARAMS ((cpp_reader *, cpp_macro *,
  92                                            unsigned int));
  93 static void maybe_start_funlike PARAMS ((cpp_reader *, cpp_hashnode *,
  94                                          const uchar *, struct fun_macro *));
  95 static void save_argument PARAMS ((struct fun_macro *, size_t));
  96 static void replace_args_and_push PARAMS ((cpp_reader *, struct fun_macro *));
  97 static size_t canonicalize_text PARAMS ((uchar *, const uchar *, size_t,
  98                                          uchar *));
  99
 100 /* Ensures we have N bytes' space in the output buffer, and
 101    reallocates it if not.  */
 102 static void
 103 check_output_buffer (pfile, n)
 104      cpp_reader *pfile;
 105      size_t n;
 106 {
 107   /* We might need two bytes to terminate an unterminated comment, and
 108      one more to terminate the line with a NUL.  */
 109   n += 2 + 1;
 110
 111   if (n > (size_t) (pfile->out.limit - pfile->out.cur))
 112     {
 113       size_t size = pfile->out.cur - pfile->out.base;
 114       size_t new_size = (size + n) * 3 / 2;
 115
 116       pfile->out.base
 117         = (uchar *) xrealloc (pfile->out.base, new_size);
 118       pfile->out.limit = pfile->out.base + new_size;
 119       pfile->out.cur = pfile->out.base + size;
 120     }
 121 }
 122
 123 /* To be called whenever a newline character is encountered in the
 124    input file, at CUR.  Handles DOS, Mac and Unix ends of line, and
 125    increments pfile->line.
 126
 127    Returns a pointer the character after the newline sequence.  */
 128 static const uchar *
 129 handle_newline (pfile, cur)
 130      cpp_reader *pfile;
 131      const uchar *cur;
 132 {
 133   pfile->line++;
 134   if (cur[0] + cur[1] == '\r' + '\n')
 135     cur++;
 136   return cur + 1;
 137 }
 138
 139 /* CUR points to any character in the buffer, not necessarily a
 140    backslash.  Advances CUR until all escaped newlines are skipped,
 141    and returns the new position.
 142
 143    Warns if a file buffer ends in an escaped newline.  */
 144 static const uchar *
 145 skip_escaped_newlines (pfile, cur)
 146      cpp_reader *pfile;
 147      const uchar *cur;
 148 {
 149   const uchar *orig_cur = cur;
 150
 151   while (*cur == '\\' && is_vspace (cur[1]))
 152     cur = handle_newline (pfile, cur + 1);
 153
 154   if (cur != orig_cur && cur == RLIMIT (pfile->context) && pfile->buffer->inc)
 155     cpp_error (pfile, DL_PEDWARN, "backslash-newline at end of file");
 156
 157   return cur;
 158 }
 159
 160 /* CUR points to the asterisk introducing a comment in the input
 161    buffer.  IN_DEFINE is true if we are in the replacement text
 162    of a macro.
 163
 164    The asterisk and following comment is copied to the buffer pointed
 165    to by pfile->out.cur, which must be of sufficient size.
 166    Unterminated comments are diagnosed, and correctly terminated in
 167    the output.  pfile->out.cur is updated depending upon IN_DEFINE,
 168    -C, -CC and pfile->state.in_directive.
 169
 170    Returns a pointer to the first character after the comment in the
 171    input buffer.  */
 172 static const uchar *
 173 copy_comment (pfile, cur, in_define)
 174      cpp_reader *pfile;
 175      const uchar *cur;
 176      int in_define;
 177 {
 178   unsigned int from_line = pfile->line;
 179   const uchar *limit = RLIMIT (pfile->context);
 180   uchar *out = pfile->out.cur;
 181
 182   do
 183     {
 184       unsigned int c = *cur++;
 185       *out++ = c;
 186
 187       if (c == '/')
 188         {
 189           /* An immediate slash does not terminate the comment.  */
 190           if (out[-2] == '*' && out - 2 > pfile->out.cur)
 191             goto done;
 192
 193           if (*cur == '*' && cur[1] != '/'
 194               && CPP_OPTION (pfile, warn_comments))
 195             cpp_error_with_line (pfile, DL_WARNING, pfile->line, 0,
 196                                  "\"/*\" within comment");
 197         }
 198       else if (is_vspace (c))
 199         {
 200           cur = handle_newline (pfile, cur - 1);
 201           /* Canonicalize newline sequences and skip escaped ones.  */
 202           if (out[-2] == '\\')
 203             out -= 2;
 204           else
 205             out[-1] = '\n';
 206         }
 207     }
 208   while (cur < limit);
 209
 210   cpp_error_with_line (pfile, DL_ERROR, from_line, 0, "unterminated comment");
 211   *out++ = '*';
 212   *out++ = '/';
 213
 214  done:
 215   /* Comments in directives become spaces so that tokens are properly
 216      separated when the ISO preprocessor re-lexes the line.  The
 217      exception is #define.  */
 218   if (pfile->state.in_directive)
 219     {
 220       if (in_define)
 221         {
 222           if (CPP_OPTION (pfile, discard_comments_in_macro_exp))
 223             pfile->out.cur--;
 224           else
 225             pfile->out.cur = out;
 226         }
 227       else
 228         pfile->out.cur[-1] = ' ';
 229     }
 230   else if (CPP_OPTION (pfile, discard_comments))
 231     pfile->out.cur--;
 232   else
 233     pfile->out.cur = out;
 234
 235   return cur;
 236 }
 237
 238 /* CUR points to any character in the input buffer.  Skips over all
 239    contiguous horizontal white space and NULs, including comments if
 240    SKIP_COMMENTS, until reaching the first non-horizontal-whitespace
 241    character or the end of the current context.  Escaped newlines are
 242    removed.
 243
 244    The whitespace is copied verbatim to the output buffer, except that
 245    comments are handled as described in copy_comment().
 246    pfile->out.cur is updated.
 247
 248    Returns a pointer to the first character after the whitespace in
 249    the input buffer.  */
 250 static const uchar *
 251 skip_whitespace (pfile, cur, skip_comments)
 252      cpp_reader *pfile;
 253      const uchar *cur;
 254      int skip_comments;
 255 {
 256   uchar *out = pfile->out.cur;
 257
 258   for (;;)
 259     {
 260       unsigned int c = *cur++;
 261       *out++ = c;
 262
 263       if (is_nvspace (c) && c)
 264         continue;
 265
 266       if (!c && cur - 1 != RLIMIT (pfile->context))
 267         continue;
 268
 269       if (*cur == '/' && skip_comments)
 270         {
 271           const uchar *tmp = skip_escaped_newlines (pfile, cur);
 272           if (*tmp == '*')
 273             {
 274               pfile->out.cur = out;
 275               cur = copy_comment (pfile, tmp, false /* in_define */);
 276               out = pfile->out.cur;
 277               continue;
 278             }
 279         }
 280
 281       out--;
 282       if (c == '\\' && is_vspace (*cur))
 283         {
 284           cur = skip_escaped_newlines (pfile, cur);
 285           continue;
 286         }
 287
 288       break;
 289     }
 290
 291   pfile->out.cur = out;
 292   return cur - 1;
 293 }
 294
 295 /* Lexes and outputs an identifier starting at CUR, which is assumed
 296    to point to a valid first character of an identifier.  Returns
 297    the hashnode, and updates out.cur.  */
 298 static cpp_hashnode *
 299 lex_identifier (pfile, cur)
 300      cpp_reader *pfile;
 301      const uchar *cur;
 302 {
 303   size_t len;
 304   uchar *out = pfile->out.cur;
 305   cpp_hashnode *result;
 306
 307   do
 308     {
 309       do
 310         *out++ = *cur++;
 311       while (is_numchar (*cur));
 312       cur = skip_escaped_newlines (pfile, cur);
 313     }
 314   while (is_numchar (*cur));
 315
 316   CUR (pfile->context) = cur;
 317   len = out - pfile->out.cur;
 318   result = (cpp_hashnode *) ht_lookup (pfile->hash_table, pfile->out.cur,
 319                                        len, HT_ALLOC);
 320   pfile->out.cur = out;
 321   return result;
 322 }
 323
 324 /* Overlays the true file buffer temporarily with text of length LEN
 325    starting at START.  The true buffer is restored upon calling
 326    restore_buff().  */
 327 void
 328 _cpp_overlay_buffer (pfile, start, len)
 329      cpp_reader *pfile;
 330      const uchar *start;
 331      size_t len;
 332 {
 333   cpp_buffer *buffer = pfile->buffer;
 334
 335   pfile->overlaid_buffer = buffer;
 336   buffer->saved_cur = buffer->cur;
 337   buffer->saved_rlimit = buffer->rlimit;
 338
 339   buffer->cur = start;
 340   buffer->rlimit = start + len;
 341
 342   pfile->saved_line = pfile->line;
 343 }
 344
 345 /* Restores a buffer overlaid by _cpp_overlay_buffer().  */
 346 void
 347 _cpp_remove_overlay (pfile)
 348      cpp_reader *pfile;
 349 {
 350   cpp_buffer *buffer = pfile->overlaid_buffer;
 351
 352   buffer->cur = buffer->saved_cur;
 353   buffer->rlimit = buffer->saved_rlimit;
 354
 355   pfile->line = pfile->saved_line;
 356 }
 357
 358 /* Reads a logical line into the output buffer.  Returns TRUE if there
 359    is more text left in the buffer.  */
 360 bool
 361 _cpp_read_logical_line_trad (pfile)
 362      cpp_reader *pfile;
 363 {
 364   cpp_buffer *buffer = pfile->buffer;
 365
 366   do
 367     {
 368       if (buffer->cur == buffer->rlimit)
 369         {
 370           bool stop = true;
 371
 372           /* Don't pop the last buffer.  */
 373           if (buffer->prev)
 374             {
 375               stop = buffer->return_at_eof;
 376               _cpp_pop_buffer (pfile);
 377               buffer = pfile->buffer;
 378             }
 379
 380           if (stop)
 381             return false;
 382         }
 383
 384       CUR (pfile->context) = buffer->cur;
 385       RLIMIT (pfile->context) = buffer->rlimit;
 386       scan_out_logical_line (pfile, NULL);
 387       buffer = pfile->buffer;
 388       buffer->cur = CUR (pfile->context);
 389     }
 390   while (pfile->state.skipping);
 391
 392   return true;
 393 }
 394
 395 /* Set up state for finding the opening '(' of a function-like
 396    macro.  */
 397 static void
 398 maybe_start_funlike (pfile, node, start, macro)
 399      cpp_reader *pfile;
 400      cpp_hashnode *node;
 401      const uchar *start;
 402      struct fun_macro *macro;
 403 {
 404   unsigned int n = node->value.macro->paramc + 1;
 405
 406   if (macro->buff)
 407     _cpp_release_buff (pfile, macro->buff);
 408   macro->buff = _cpp_get_buff (pfile, n * sizeof (size_t));
 409   macro->args = (size_t *) BUFF_FRONT (macro->buff);
 410   macro->node = node;
 411   macro->offset = start - pfile->out.base;
 412   macro->argc = 0;
 413 }
 414
 415 /* Save the OFFSET of the start of the next argument to MACRO.  */
 416 static void
 417 save_argument (macro, offset)
 418      struct fun_macro *macro;
 419      size_t offset;
 420 {
 421   macro->argc++;
 422   if (macro->argc <= macro->node->value.macro->paramc)
 423     macro->args[macro->argc] = offset;
 424 }
 425
 426 /* Copies the next logical line in the current buffer to the output
 427    buffer.  The output is guaranteed to terminate with a NUL
 428    character.
 429
 430    If MACRO is non-NULL, then we are scanning the replacement list of
 431    MACRO, and we call save_replacement_text() every time we meet an
 432    argument.  */
 433 static void
 434 scan_out_logical_line (pfile, macro)
 435      cpp_reader *pfile;
 436      cpp_macro *macro;
 437 {
 438   cpp_context *context;
 439   const uchar *cur;
 440   uchar *out;
 441   struct fun_macro fmacro;
 442   unsigned int c, paren_depth = 0, quote = 0;
 443   enum ls lex_state = ls_none;
 444
 445   fmacro.buff = NULL;
 446
 447  start_logical_line:
 448   pfile->out.cur = pfile->out.base;
 449   pfile->out.first_line = pfile->line;
 450  new_context:
 451   context = pfile->context;
 452   cur = CUR (context);
 453   check_output_buffer (pfile, RLIMIT (context) - cur);
 454   out = pfile->out.cur;
 455
 456   for (;;)
 457     {
 458       c = *cur++;
 459       *out++ = c;
 460
 461       /* Whitespace should "continue" out of the switch,
 462          non-whitespace should "break" out of it.  */
 463       switch (c)
 464         {
 465         case ' ':
 466         case '\t':
 467         case '\f':
 468         case '\v':
 469           continue;
 470
 471         case '\0':
 472           if (cur - 1 != RLIMIT (context))
 473             continue;
 474
 475           /* If this is a macro's expansion, pop it.  */
 476           if (context->prev)
 477             {
 478               pfile->out.cur = out - 1;
 479               _cpp_pop_context (pfile);
 480               goto new_context;
 481             }
 482
 483           /* Premature end of file.  Fake a new line.  */
 484           cur--;
 485           if (!pfile->buffer->from_stage3)
 486             cpp_error (pfile, DL_PEDWARN, "no newline at end of file");
 487           pfile->line++;
 488           goto done;
 489
 490         case '\r': case '\n':
 491           cur = handle_newline (pfile, cur - 1);
 492           if ((lex_state == ls_fun_open || lex_state == ls_fun_close)
 493               && !pfile->state.in_directive)
 494             {
 495               /* Newlines in arguments become a space.  */
 496               if (lex_state == ls_fun_close)
 497                 out[-1] = ' ';
 498               continue;
 499             }
 500           goto done;
 501
 502         case '<':
 503           if (pfile->state.angled_headers && !quote)
 504             quote = '>';
 505           break;
 506         case '>':
 507           if (pfile->state.angled_headers && c == quote)
 508             {
 509               pfile->state.angled_headers = false;
 510               quote = 0;
 511             }
 512           break;
 513
 514         case '"':
 515         case '\'':
 516           if (c == quote)
 517             quote = 0;
 518           else if (!quote)
 519             quote = c;
 520           break;
 521
 522         case '\\':
 523           if (is_vspace (*cur))
 524             {
 525               out--;
 526               cur = skip_escaped_newlines (pfile, cur - 1);
 527               continue;
 528             }
 529           else
 530             {
 531               /* Skip escaped quotes here, it's easier than above, but
 532                  take care to first skip escaped newlines.  */
 533               cur = skip_escaped_newlines (pfile, cur);
 534               if (*cur == '\\' || *cur == '"' || *cur == '\'')
 535                 *out++ = *cur++;
 536             }
 537           break;
 538
 539         case '/':
 540           /* Traditional CPP does not recognize comments within
 541              literals.  */
 542           if (!quote)
 543             {
 544               cur = skip_escaped_newlines (pfile, cur);
 545               if (*cur == '*')
 546                 {
 547                   pfile->out.cur = out;
 548                   cur = copy_comment (pfile, cur, macro != 0);
 549                   out = pfile->out.cur;
 550                   continue;
 551                 }
 552             }
 553           break;
 554
 555         case '_':
 556         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 557         case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
 558         case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
 559         case 's': case 't': case 'u': case 'v': case 'w': case 'x':
 560         case 'y': case 'z':
 561         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 562         case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
 563         case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
 564         case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
 565         case 'Y': case 'Z':
 566           if (!pfile->state.skipping && (quote == 0 || macro))
 567             {
 568               cpp_hashnode *node;
 569               uchar *out_start = out - 1;
 570
 571               pfile->out.cur = out_start;
 572               node = lex_identifier (pfile, cur - 1);
 573               out = pfile->out.cur;
 574               cur = CUR (context);
 575
 576               if (node->type == NT_MACRO
 577                   /* Should we expand for ls_answer?  */
 578                   && (lex_state == ls_none || lex_state == ls_fun_open)
 579                   && !pfile->state.prevent_expansion
 580                   && !recursive_macro (pfile, node))
 581                 {
 582                   /* Macros invalidate MI optimization.  */
 583                   pfile->mi_valid = false;
 584                   if (! (node->flags & NODE_BUILTIN)
 585                       && node->value.macro->fun_like)
 586                     {
 587                       maybe_start_funlike (pfile, node, out_start, &fmacro);
 588                       lex_state = ls_fun_open;
 589                       continue;
 590                     }
 591                   else
 592                     {
 593                       /* Remove the object-like macro's name from the
 594                          output, and push its replacement text.  */
 595                       pfile->out.cur = out_start;
 596                       push_replacement_text (pfile, node);
 597                       lex_state = ls_none;
 598                       goto new_context;
 599                     }
 600                 }
 601               else if (macro && node->arg_index)
 602                 {
 603                   /* Found a parameter in the replacement text of a
 604                      #define.  Remove its name from the output.  */
 605                   pfile->out.cur = out_start;
 606                   save_replacement_text (pfile, macro, node->arg_index);
 607                   out = pfile->out.base;
 608                 }
 609               else if (lex_state == ls_hash)
 610                 {
 611                   lex_state = ls_predicate;
 612                   continue;
 613                 }
 614               else if (pfile->state.in_expression
 615                        && node == pfile->spec_nodes.n_defined)
 616                 {
 617                   lex_state = ls_defined;
 618                   continue;
 619                 }
 620             }
 621           break;
 622
 623         case '(':
 624           if (quote == 0)
 625             {
 626               paren_depth++;
 627               if (lex_state == ls_fun_open)
 628                 {
 629                   lex_state = ls_fun_close;
 630                   paren_depth = 1;
 631                   out = pfile->out.base + fmacro.offset;
 632                   fmacro.args[0] = fmacro.offset;
 633                 }
 634               else if (lex_state == ls_predicate)
 635                 lex_state = ls_answer;
 636               else if (lex_state == ls_defined)
 637                 lex_state = ls_defined_close;
 638             }
 639           break;
 640
 641         case ',':
 642           if (quote == 0 && lex_state == ls_fun_close && paren_depth == 1)
 643             save_argument (&fmacro, out - pfile->out.base);
 644           break;
 645
 646         case ')':
 647           if (quote == 0)
 648             {
 649               paren_depth--;
 650               if (lex_state == ls_fun_close && paren_depth == 0)
 651                 {
 652                   cpp_macro *m = fmacro.node->value.macro;
 653
 654                   lex_state = ls_none;
 655                   save_argument (&fmacro, out - pfile->out.base);
 656
 657                   /* A single zero-length argument is no argument.  */
 658                   if (fmacro.argc == 1
 659                       && m->paramc == 0
 660                       && out == pfile->out.base + fmacro.offset + 1)
 661                     fmacro.argc = 0;
 662
 663                   if (_cpp_arguments_ok (pfile, m, fmacro.node, fmacro.argc))
 664                     {
 665                       /* Remove the macro's invocation from the
 666                          output, and push its replacement text.  */
 667                       pfile->out.cur = (pfile->out.base
 668                                              + fmacro.offset);
 669                       CUR (context) = cur;
 670                       replace_args_and_push (pfile, &fmacro);
 671                       goto new_context;
 672                     }
 673                 }
 674               else if (lex_state == ls_answer || lex_state == ls_defined_close)
 675                 lex_state = ls_none;
 676             }
 677           break;
 678
 679         case '#':
 680           /* At start of a line it's a directive.  */
 681           if (out - 1 == pfile->out.base && !pfile->state.in_directive)
 682             {
 683               /* This is a kludge.  We want to have the ISO
 684                  preprocessor lex the next token.  */
 685               pfile->buffer->cur = cur;
 686               if (_cpp_handle_directive (pfile, false /* indented */))
 687                 goto start_logical_line;
 688             }
 689           if (pfile->state.in_expression)
 690             {
 691               lex_state = ls_hash;
 692               continue;
 693             }
 694           break;
 695
 696         default:
 697           break;
 698         }
 699
 700       if (lex_state == ls_none)
 701         continue;
 702
 703       /* Some of these transitions of state are syntax errors.  The
 704          ISO preprocessor will issue errors later.  */
 705       if (lex_state == ls_fun_open)
 706         /* Missing '('.  */
 707         lex_state = ls_none;
 708       else if (lex_state == ls_hash
 709                || lex_state == ls_predicate
 710                || lex_state == ls_defined)
 711         lex_state = ls_none;
 712
 713       /* ls_answer and ls_defined_close keep going until ')'.  */
 714     }
 715
 716  done:
 717   out[-1] = '\0';
 718   CUR (context) = cur;
 719   pfile->out.cur = out - 1;
 720   if (fmacro.buff)
 721     _cpp_release_buff (pfile, fmacro.buff);
 722
 723   if (lex_state == ls_fun_close)
 724     cpp_error (pfile, DL_ERROR,
 725                "unterminated argument list invoking macro \"%s\"",
 726                NODE_NAME (fmacro.node));
 727 }
 728
 729 /* Push a context holding the replacement text of the macro NODE on
 730    the context stack.  NODE is either object-like, or a function-like
 731    macro with no arguments.  */
 732 static void
 733 push_replacement_text (pfile, node)
 734      cpp_reader *pfile;
 735      cpp_hashnode *node;
 736 {
 737   size_t len;
 738   const uchar *text;
 739
 740   if (node->flags & NODE_BUILTIN)
 741     {
 742       text = _cpp_builtin_macro_text (pfile, node);
 743       len = ustrlen (text);
 744     }
 745   else
 746     {
 747       cpp_macro *macro = node->value.macro;
 748       text = macro->exp.text;
 749       len = macro->count;
 750     }
 751
 752   _cpp_push_text_context (pfile, node, text, len);
 753 }
 754
 755 /* Returns TRUE if traditional macro recursion is detected.  */
 756 static bool
 757 recursive_macro (pfile, node)
 758      cpp_reader *pfile;
 759      cpp_hashnode *node;
 760 {
 761   bool recursing = node->flags & NODE_DISABLED;
 762
 763   /* Object-like macros that are already expanding are necessarily
 764      recursive.
 765
 766      However, it is possible to have traditional function-like macros
 767      that are not infinitely recursive but recurse to any given depth.
 768      Further, it is easy to construct examples that get ever longer
 769      until the point they stop recursing.  So there is no easy way to
 770      detect true recursion; instead we assume any expansion more than
 771      20 deep since the first invocation of this macro must be
 772      recursing.  */
 773   if (recursing && node->value.macro->fun_like)
 774     {
 775       size_t depth = 0;
 776       cpp_context *context = pfile->context;
 777
 778       do
 779         {
 780           depth++;
 781           if (context->macro == node && depth > 20)
 782             break;
 783           context = context->prev;
 784         }
 785       while (context);
 786       recursing = context != NULL;
 787     }
 788
 789   if (recursing)
 790     cpp_error (pfile, DL_ERROR,
 791                "detected recursion whilst expanding macro \"%s\"",
 792                NODE_NAME (node));
 793
 794   return recursing;
 795 }
 796
 797 /* Return the length of the replacement text of a function-like or
 798    object-like non-builtin macro.  */
 799 size_t
 800 _cpp_replacement_text_len (macro)
 801      const cpp_macro *macro;
 802 {
 803   size_t len;
 804
 805   if (macro->fun_like)
 806     {
 807       const uchar *exp;
 808
 809       len = 0;
 810       for (exp = macro->exp.text;;)
 811         {
 812           struct block *b = (struct block *) exp;
 813
 814           len += b->text_len;
 815           if (b->arg_index == 0)
 816             break;
 817           len += NODE_LEN (macro->params[b->arg_index - 1]);
 818           exp += BLOCK_LEN (b->text_len);
 819         }
 820     }
 821   else
 822     len = macro->count;
 823
 824   return len;
 825 }
 826
 827 /* Copy the replacement text of MACRO to DEST, which must be of
 828    sufficient size.  It is not NUL-terminated.  The next character is
 829    returned.  */
 830 uchar *
 831 _cpp_copy_replacement_text (macro, dest)
 832      const cpp_macro *macro;
 833      uchar *dest;
 834 {
 835   if (macro->fun_like)
 836     {
 837       const uchar *exp;
 838
 839       for (exp = macro->exp.text;;)
 840         {
 841           struct block *b = (struct block *) exp;
 842           cpp_hashnode *param;
 843
 844           memcpy (dest, b->text, b->text_len);
 845           dest += b->text_len;
 846           if (b->arg_index == 0)
 847             break;
 848           param = macro->params[b->arg_index - 1];
 849           memcpy (dest, NODE_NAME (param), NODE_LEN (param));
 850           dest += NODE_LEN (param);
 851           exp += BLOCK_LEN (b->text_len);
 852         }
 853     }
 854   else
 855     {
 856       memcpy (dest, macro->exp.text, macro->count);
 857       dest += macro->count;
 858     }
 859
 860   return dest;
 861 }
 862
 863 /* Push a context holding the replacement text of the macro NODE on
 864    the context stack.  NODE is either object-like, or a function-like
 865    macro with no arguments.  */
 866 static void
 867 replace_args_and_push (pfile, fmacro)
 868      cpp_reader *pfile;
 869      struct fun_macro *fmacro;
 870 {
 871   cpp_macro *macro = fmacro->node->value.macro;
 872
 873   if (macro->paramc == 0)
 874     push_replacement_text (pfile, fmacro->node);
 875   else
 876     {
 877       const uchar *exp;
 878       uchar *p;
 879       _cpp_buff *buff;
 880       size_t len = 0;
 881
 882       /* Calculate the length of the argument-replaced text.  */
 883       for (exp = macro->exp.text;;)
 884         {
 885           struct block *b = (struct block *) exp;
 886
 887           len += b->text_len;
 888           if (b->arg_index == 0)
 889             break;
 890           len += (fmacro->args[b->arg_index]
 891                   - fmacro->args[b->arg_index - 1] - 1);
 892           exp += BLOCK_LEN (b->text_len);
 893         }
 894
 895       /* Allocate room for the expansion plus NUL.  */
 896       buff = _cpp_get_buff (pfile, len + 1);
 897
 898       /* Copy the expansion and replace arguments.  */
 899       p = BUFF_FRONT (buff);
 900       for (exp = macro->exp.text;;)
 901         {
 902           struct block *b = (struct block *) exp;
 903           size_t arglen;
 904
 905           memcpy (p, b->text, b->text_len);
 906           p += b->text_len;
 907           if (b->arg_index == 0)
 908             break;
 909           arglen = (fmacro->args[b->arg_index]
 910                     - fmacro->args[b->arg_index - 1] - 1);
 911           memcpy (p, pfile->out.base + fmacro->args[b->arg_index - 1],
 912                   arglen);
 913           p += arglen;
 914           exp += BLOCK_LEN (b->text_len);
 915         }
 916
 917       /* NUL-terminate.  */
 918       *p = '\0';
 919       _cpp_push_text_context (pfile, fmacro->node, BUFF_FRONT (buff), len);
 920
 921       /* So we free buffer allocation when macro is left.  */
 922       pfile->context->buff = buff;
 923     }
 924 }
 925
 926 /* Read and record the parameters, if any, of a function-like macro
 927    definition.  Destroys pfile->out.cur.
 928
 929    Returns true on success, false on failure (syntax error or a
 930    duplicate parameter).  On success, CUR (pfile->context) is just
 931    past the closing parenthesis.  */
 932 static bool
 933 scan_parameters (pfile, macro)
 934      cpp_reader *pfile;
 935      cpp_macro *macro;
 936 {
 937   const uchar *cur = CUR (pfile->context) + 1;
 938   bool ok;
 939
 940   for (;;)
 941     {
 942       cur = skip_whitespace (pfile, cur, true /* skip_comments */);
 943
 944       if (is_idstart (*cur))
 945         {
 946           ok = false;
 947           if (_cpp_save_parameter (pfile, macro, lex_identifier (pfile, cur)))
 948             break;
 949           cur = skip_whitespace (pfile, CUR (pfile->context),
 950                                  true /* skip_comments */);
 951           if (*cur == ',')
 952             {
 953               cur++;
 954               continue;
 955             }
 956           ok = (*cur == ')');
 957           break;
 958         }
 959
 960       ok = (*cur == ')' && macro->paramc == 0);
 961       break;
 962     }
 963
 964   CUR (pfile->context) = cur + (*cur == ')');
 965
 966   return ok;
 967 }
 968
 969 /* Save the text from pfile->out.base to pfile->out.cur as
 970    the replacement text for the current macro, followed by argument
 971    ARG_INDEX, with zero indicating the end of the replacement
 972    text.  */
 973 static void
 974 save_replacement_text (pfile, macro, arg_index)
 975      cpp_reader *pfile;
 976      cpp_macro *macro;
 977      unsigned int arg_index;
 978 {
 979   size_t len = pfile->out.cur - pfile->out.base;
 980   uchar *exp;
 981
 982   if (macro->paramc == 0)
 983     {
 984       /* Object-like and function-like macros without parameters
 985          simply store their NUL-terminated replacement text.  */
 986       exp = _cpp_unaligned_alloc (pfile, len + 1);
 987       memcpy (exp, pfile->out.base, len);
 988       exp[len] = '\0';
 989       macro->exp.text = exp;
 990       macro->count = len;
 991     }
 992   else
 993     {
 994       /* Store the text's length (unsigned int), the argument index
 995          (unsigned short, base 1) and then the text.  */
 996       size_t blen = BLOCK_LEN (len);
 997       struct block *block;
 998
 999       if (macro->count + blen > BUFF_ROOM (pfile->a_buff))
1000         _cpp_extend_buff (pfile, &pfile->a_buff, macro->count + blen);
1001
1002       exp = BUFF_FRONT (pfile->a_buff);
1003       block = (struct block *) (exp + macro->count);
1004       macro->exp.text = exp;
1005
1006       /* Write out the block information.  */
1007       block->text_len = len;
1008       block->arg_index = arg_index;
1009       memcpy (block->text, pfile->out.base, len);
1010
1011       /* Lex the rest into the start of the output buffer.  */
1012       pfile->out.cur = pfile->out.base;
1013
1014       macro->count += blen;
1015
1016       /* If we've finished, commit the memory.  */
1017       if (arg_index == 0)
1018         BUFF_FRONT (pfile->a_buff) += macro->count;
1019     }
1020 }
1021
1022 /* Analyze and save the replacement text of a macro.  Returns true on
1023    success.  */
1024 bool
1025 _cpp_create_trad_definition (pfile, macro)
1026      cpp_reader *pfile;
1027      cpp_macro *macro;
1028 {
1029   const uchar *cur;
1030   uchar *limit;
1031
1032   CUR (pfile->context) = pfile->buffer->cur;
1033
1034   /* Is this a function-like macro?  */
1035   if (* CUR (pfile->context) == '(')
1036     {
1037       /* Setting macro to NULL indicates an error occurred, and
1038          prevents unnecessary work in scan_out_logical_line.  */
1039       if (!scan_parameters (pfile, macro))
1040         macro = NULL;
1041       else
1042         {
1043           /* Success.  Commit the parameter array.  */
1044           macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1045           BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1046           macro->fun_like = 1;
1047         }
1048     }
1049
1050   /* Skip leading whitespace in the replacement text.  */
1051   CUR (pfile->context)
1052     = skip_whitespace (pfile, CUR (pfile->context),
1053                        CPP_OPTION (pfile, discard_comments_in_macro_exp));
1054
1055   pfile->state.prevent_expansion++;
1056   scan_out_logical_line (pfile, macro);
1057   pfile->state.prevent_expansion--;
1058
1059   if (!macro)
1060     return false;
1061
1062   /* Skip trailing white space.  */
1063   cur = pfile->out.base;
1064   limit = pfile->out.cur;
1065   while (limit > cur && is_space (limit[-1]))
1066     limit--;
1067   pfile->out.cur = limit;
1068   save_replacement_text (pfile, macro, 0);
1069
1070   return true;
1071 }
1072
1073 /* Copy SRC of length LEN to DEST, but convert all contiguous
1074    whitespace to a single space, provided it is not in quotes.  The
1075    quote currently in effect is pointed to by PQUOTE, and is updated
1076    by the function.  Returns the number of bytes copied.  */
1077 static size_t
1078 canonicalize_text (dest, src, len, pquote)
1079      uchar *dest;
1080      const uchar *src;
1081      size_t len;
1082      uchar *pquote;
1083 {
1084   uchar *orig_dest = dest;
1085   uchar quote = *pquote;
1086
1087   while (len)
1088     {
1089       if (is_space (*src) && !quote)
1090         {
1091           do
1092             src++, len--;
1093           while (len && is_space (*src));
1094           *dest++ = ' ';
1095         }
1096       else
1097         {
1098           if (*src == '\'' || *src == '"')
1099             {
1100               if (!quote)
1101                 quote = *src;
1102               else if (quote == *src)
1103                 quote = 0;
1104             }
1105           *dest++ = *src++, len--;
1106         }
1107     }
1108
1109   *pquote = quote;
1110   return dest - orig_dest;
1111 }
1112
1113 /* Returns true if MACRO1 and MACRO2 have expansions different other
1114    than in the form of their whitespace.  */
1115 bool
1116 _cpp_expansions_different_trad (macro1, macro2)
1117      const cpp_macro *macro1, *macro2;
1118 {
1119   uchar *p1 = xmalloc (macro1->count + macro2->count);
1120   uchar *p2 = p1 + macro1->count;
1121   uchar quote1 = 0, quote2;
1122   bool mismatch;
1123   size_t len1, len2;
1124
1125   if (macro1->paramc > 0)
1126     {
1127       const uchar *exp1 = macro1->exp.text, *exp2 = macro2->exp.text;
1128
1129       mismatch = true;
1130       for (;;)
1131         {
1132           struct block *b1 = (struct block *) exp1;
1133           struct block *b2 = (struct block *) exp2;
1134
1135           if (b1->arg_index != b2->arg_index)
1136             break;
1137
1138           len1 = canonicalize_text (p1, b1->text, b1->text_len, &quote1);
1139           len2 = canonicalize_text (p2, b2->text, b2->text_len, &quote2);
1140           if (len1 != len2 || memcmp (p1, p2, len1))
1141             break;
1142           if (b1->arg_index == 0)
1143             {
1144               mismatch = false;
1145               break;
1146             }
1147           exp1 += BLOCK_LEN (b1->text_len);
1148           exp2 += BLOCK_LEN (b2->text_len);
1149         }
1150     }
1151   else
1152     {
1153       len1 = canonicalize_text (p1, macro1->exp.text, macro1->count, &quote1);
1154       len2 = canonicalize_text (p2, macro2->exp.text, macro2->count, &quote2);
1155       mismatch = (len1 != len2 || memcmp (p1, p2, len1));
1156     }
1157
1158   free (p1);
1159   return mismatch;
1160 }
1161
1162 /* Prepare to be able to scan the current buffer.  */
1163 void
1164 _cpp_set_trad_context (pfile)
1165      cpp_reader *pfile;
1166 {
1167   cpp_buffer *buffer = pfile->buffer;
1168   cpp_context *context = pfile->context;
1169
1170   if (pfile->context->prev)
1171     abort ();
1172
1173   pfile->out.cur = pfile->out.base;
1174   CUR (context) = buffer->cur;
1175   RLIMIT (context) = buffer->rlimit;
1176   check_output_buffer (pfile, RLIMIT (context) - CUR (context));
1177 }