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