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.
  27
  28    Each block comprises the text between its surrounding parameters,
  29    the length of that text, and the one-based index of the following
  30    parameter.  The final block in the replacement text is easily
  31    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 current context, not necessarily
 143    a backslash.  Advances CUR until all escaped newlines are skipped,
 144    and returns the new position without updating the context.
 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 current
 164    context.  IN_DEFINE is true if we are in the replacement text of a
 165    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 - 1);
 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   do
 368     {
 369       if (pfile->buffer->cur == pfile->buffer->rlimit)
 370         {
 371           bool stop = true;
 372
 373           /* Don't pop the last buffer.  */
 374           if (pfile->buffer->prev)
 375             {
 376               stop = pfile->buffer->return_at_eof;
 377               _cpp_pop_buffer (pfile);
 378             }
 379
 380           if (stop)
 381             return false;
 382         }
 383
 384       scan_out_logical_line (pfile, NULL);
 385     }
 386   while (pfile->state.skipping);
 387
 388   return true;
 389 }
 390
 391 /* Set up state for finding the opening '(' of a function-like
 392    macro.  */
 393 static void
 394 maybe_start_funlike (pfile, node, start, macro)
 395      cpp_reader *pfile;
 396      cpp_hashnode *node;
 397      const uchar *start;
 398      struct fun_macro *macro;
 399 {
 400   unsigned int n = node->value.macro->paramc + 1;
 401
 402   if (macro->buff)
 403     _cpp_release_buff (pfile, macro->buff);
 404   macro->buff = _cpp_get_buff (pfile, n * sizeof (size_t));
 405   macro->args = (size_t *) BUFF_FRONT (macro->buff);
 406   macro->node = node;
 407   macro->offset = start - pfile->out.base;
 408   macro->argc = 0;
 409 }
 410
 411 /* Save the OFFSET of the start of the next argument to MACRO.  */
 412 static void
 413 save_argument (macro, offset)
 414      struct fun_macro *macro;
 415      size_t offset;
 416 {
 417   macro->argc++;
 418   if (macro->argc <= macro->node->value.macro->paramc)
 419     macro->args[macro->argc] = offset;
 420 }
 421
 422 /* Copies the next logical line in the current buffer (starting at
 423    buffer->cur) to the output buffer.  The output is guaranteed to
 424    terminate with a NUL character.  buffer->cur is updated.
 425
 426    If MACRO is non-NULL, then we are scanning the replacement list of
 427    MACRO, and we call save_replacement_text() every time we meet an
 428    argument.  */
 429 static void
 430 scan_out_logical_line (pfile, macro)
 431      cpp_reader *pfile;
 432      cpp_macro *macro;
 433 {
 434   cpp_context *context;
 435   const uchar *cur;
 436   uchar *out;
 437   struct fun_macro fmacro;
 438   unsigned int c, paren_depth = 0, quote;
 439   enum ls lex_state = ls_none;
 440   bool header_ok;
 441
 442   fmacro.buff = NULL;
 443
 444  start_logical_line:
 445   quote = 0;
 446   header_ok = pfile->state.angled_headers;
 447   CUR (pfile->context) = pfile->buffer->cur;
 448   RLIMIT (pfile->context) = pfile->buffer->rlimit;
 449   pfile->out.cur = pfile->out.base;
 450   pfile->out.first_line = pfile->line;
 451  new_context:
 452   context = pfile->context;
 453   cur = CUR (context);
 454   check_output_buffer (pfile, RLIMIT (context) - cur);
 455   out = pfile->out.cur;
 456
 457   for (;;)
 458     {
 459       c = *cur++;
 460       *out++ = c;
 461
 462       /* Whitespace should "continue" out of the switch,
 463          non-whitespace should "break" out of it.  */
 464       switch (c)
 465         {
 466         case ' ':
 467         case '\t':
 468         case '\f':
 469         case '\v':
 470           continue;
 471
 472         case '\0':
 473           if (cur - 1 != RLIMIT (context))
 474             continue;
 475
 476           /* If this is a macro's expansion, pop it.  */
 477           if (context->prev)
 478             {
 479               pfile->out.cur = out - 1;
 480               _cpp_pop_context (pfile);
 481               goto new_context;
 482             }
 483
 484           /* Premature end of file.  Fake a new line.  */
 485           cur--;
 486           if (!pfile->buffer->from_stage3)
 487             cpp_error (pfile, DL_PEDWARN, "no newline at end of file");
 488           pfile->line++;
 489           goto done;
 490
 491         case '\r': case '\n':
 492           cur = handle_newline (pfile, cur - 1);
 493           if ((lex_state == ls_fun_open || lex_state == ls_fun_close)
 494               && !pfile->state.in_directive)
 495             {
 496               /* Newlines in arguments become a space, but we don't
 497                  clear any in-progress quote.  */
 498               if (lex_state == ls_fun_close)
 499                 out[-1] = ' ';
 500               continue;
 501             }
 502           goto done;
 503
 504         case '<':
 505           if (header_ok)
 506             quote = '>';
 507           break;
 508         case '>':
 509           if (c == quote)
 510             quote = 0;
 511           break;
 512
 513         case '"':
 514         case '\'':
 515           if (c == quote)
 516             quote = 0;
 517           else if (!quote)
 518             quote = c;
 519           break;
 520
 521         case '\\':
 522           if (is_vspace (*cur))
 523             {
 524               out--;
 525               cur = skip_escaped_newlines (pfile, cur - 1);
 526               continue;
 527             }
 528           else
 529             {
 530               /* Skip escaped quotes here, it's easier than above, but
 531                  take care to first skip escaped newlines.  */
 532               cur = skip_escaped_newlines (pfile, cur);
 533               if (*cur == '\\' || *cur == '"' || *cur == '\'')
 534                 *out++ = *cur++;
 535             }
 536           break;
 537
 538         case '/':
 539           /* Traditional CPP does not recognize comments within
 540              literals.  */
 541           if (!quote)
 542             {
 543               cur = skip_escaped_newlines (pfile, cur);
 544               if (*cur == '*')
 545                 {
 546                   pfile->out.cur = out;
 547                   cur = copy_comment (pfile, cur, macro != 0);
 548                   out = pfile->out.cur;
 549                   continue;
 550                 }
 551             }
 552           break;
 553
 554         case '_':
 555         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 556         case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
 557         case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
 558         case 's': case 't': case 'u': case 'v': case 'w': case 'x':
 559         case 'y': case 'z':
 560         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 561         case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
 562         case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
 563         case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
 564         case 'Y': case 'Z':
 565           if (!pfile->state.skipping && (quote == 0 || macro))
 566             {
 567               cpp_hashnode *node;
 568               uchar *out_start = out - 1;
 569
 570               pfile->out.cur = out_start;
 571               node = lex_identifier (pfile, cur - 1);
 572               out = pfile->out.cur;
 573               cur = CUR (context);
 574
 575               if (node->type == NT_MACRO
 576                   /* Should we expand for ls_answer?  */
 577                   && (lex_state == ls_none || lex_state == ls_fun_open)
 578                   && !pfile->state.prevent_expansion)
 579                 {
 580                   /* Macros invalidate MI optimization.  */
 581                   pfile->mi_valid = false;
 582                   if (! (node->flags & NODE_BUILTIN)
 583                       && node->value.macro->fun_like)
 584                     {
 585                       maybe_start_funlike (pfile, node, out_start, &fmacro);
 586                       lex_state = ls_fun_open;
 587                       fmacro.line = pfile->line;
 588                       continue;
 589                     }
 590                   else if (!recursive_macro (pfile, node))
 591                     {
 592                       /* Remove the object-like macro's name from the
 593                          output, and push its replacement text.  */
 594                       pfile->out.cur = out_start;
 595                       push_replacement_text (pfile, node);
 596                       lex_state = ls_none;
 597                       goto new_context;
 598                     }
 599                 }
 600               else if (macro && node->arg_index)
 601                 {
 602                   /* Found a parameter in the replacement text of a
 603                      #define.  Remove its name from the output.  */
 604                   pfile->out.cur = out_start;
 605                   save_replacement_text (pfile, macro, node->arg_index);
 606                   out = pfile->out.base;
 607                 }
 608               else if (lex_state == ls_hash)
 609                 {
 610                   lex_state = ls_predicate;
 611                   continue;
 612                 }
 613               else if (pfile->state.in_expression
 614                        && node == pfile->spec_nodes.n_defined)
 615                 {
 616                   lex_state = ls_defined;
 617                   continue;
 618                 }
 619             }
 620           break;
 621
 622         case '(':
 623           if (quote == 0)
 624             {
 625               paren_depth++;
 626               if (lex_state == ls_fun_open)
 627                 {
 628                   if (recursive_macro (pfile, fmacro.node))
 629                     lex_state = ls_none;
 630                   else
 631                     {
 632                       lex_state = ls_fun_close;
 633                       paren_depth = 1;
 634                       out = pfile->out.base + fmacro.offset;
 635                       fmacro.args[0] = fmacro.offset;
 636                     }
 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                   m->used = 1;
 659                   lex_state = ls_none;
 660                   save_argument (&fmacro, out - pfile->out.base);
 661
 662                   /* A single zero-length argument is no argument.  */
 663                   if (fmacro.argc == 1
 664                       && m->paramc == 0
 665                       && out == pfile->out.base + fmacro.offset + 1)
 666                     fmacro.argc = 0;
 667
 668                   if (_cpp_arguments_ok (pfile, m, fmacro.node, fmacro.argc))
 669                     {
 670                       /* Remove the macro's invocation from the
 671                          output, and push its replacement text.  */
 672                       pfile->out.cur = (pfile->out.base
 673                                              + fmacro.offset);
 674                       CUR (context) = cur;
 675                       replace_args_and_push (pfile, &fmacro);
 676                       goto new_context;
 677                     }
 678                 }
 679               else if (lex_state == ls_answer || lex_state == ls_defined_close)
 680                 lex_state = ls_none;
 681             }
 682           break;
 683
 684         case '#':
 685           if (out - 1 == pfile->out.base
 686               /* A '#' from a macro doesn't start a directive.  */
 687               && !pfile->context->prev
 688               && !pfile->state.in_directive)
 689             {
 690               /* A directive.  With the way _cpp_handle_directive
 691                  currently works, we only want to call it if either we
 692                  know the directive is OK, or we want it to fail and
 693                  be removed from the output.  If we want it to be
 694                  passed through (the assembler case) then we must not
 695                  call _cpp_handle_directive.  */
 696               pfile->out.cur = out;
 697               cur = skip_whitespace (pfile, cur, true /* skip_comments */);
 698               out = pfile->out.cur;
 699
 700               if (is_vspace (*cur))
 701                 {
 702                   /* Null directive.  Ignore it and don't invalidate
 703                      the MI optimization.  */
 704                   out = pfile->out.base;
 705                   continue;
 706                 }
 707               else
 708                 {
 709                   bool do_it = false;
 710
 711                   if (is_numstart (*cur)
 712                       && CPP_OPTION (pfile, lang) != CLK_ASM)
 713                     do_it = true;
 714                   else if (is_idstart (*cur))
 715                     /* Check whether we know this directive, but don't
 716                        advance.  */
 717                     do_it = lex_identifier (pfile, cur)->directive_index != 0;
 718
 719                   if (do_it || CPP_OPTION (pfile, lang) != CLK_ASM)
 720                     {
 721                       /* This is a kludge.  We want to have the ISO
 722                          preprocessor lex the next token.  */
 723                       pfile->buffer->cur = cur;
 724                       _cpp_handle_directive (pfile, false /* indented */);
 725                       /* #include changes pfile->buffer so we need to
 726                          update the limits of the current context.  */
 727                       goto start_logical_line;
 728                     }
 729                 }
 730             }
 731
 732           if (pfile->state.in_expression)
 733             {
 734               lex_state = ls_hash;
 735               continue;
 736             }
 737           break;
 738
 739         default:
 740           break;
 741         }
 742
 743       /* Non-whitespace disables MI optimization and stops treating
 744          '<' as a quote in #include.  */
 745       header_ok = false;
 746       if (!pfile->state.in_directive)
 747         pfile->mi_valid = false;
 748
 749       if (lex_state == ls_none)
 750         continue;
 751
 752       /* Some of these transitions of state are syntax errors.  The
 753          ISO preprocessor will issue errors later.  */
 754       if (lex_state == ls_fun_open)
 755         /* Missing '('.  */
 756         lex_state = ls_none;
 757       else if (lex_state == ls_hash
 758                || lex_state == ls_predicate
 759                || lex_state == ls_defined)
 760         lex_state = ls_none;
 761
 762       /* ls_answer and ls_defined_close keep going until ')'.  */
 763     }
 764
 765  done:
 766   out[-1] = '\0';
 767   pfile->buffer->cur = cur;
 768   pfile->out.cur = out - 1;
 769   if (fmacro.buff)
 770     _cpp_release_buff (pfile, fmacro.buff);
 771
 772   if (lex_state == ls_fun_close)
 773     cpp_error_with_line (pfile, DL_ERROR, fmacro.line, 0,
 774                          "unterminated argument list invoking macro \"%s\"",
 775                          NODE_NAME (fmacro.node));
 776 }
 777
 778 /* Push a context holding the replacement text of the macro NODE on
 779    the context stack.  NODE is either object-like, or a function-like
 780    macro with no arguments.  */
 781 static void
 782 push_replacement_text (pfile, node)
 783      cpp_reader *pfile;
 784      cpp_hashnode *node;
 785 {
 786   size_t len;
 787   const uchar *text;
 788
 789   if (node->flags & NODE_BUILTIN)
 790     {
 791       text = _cpp_builtin_macro_text (pfile, node);
 792       len = ustrlen (text);
 793     }
 794   else
 795     {
 796       cpp_macro *macro = node->value.macro;
 797       macro->used = 1;
 798       text = macro->exp.text;
 799       len = macro->count;
 800     }
 801
 802   _cpp_push_text_context (pfile, node, text, len);
 803 }
 804
 805 /* Returns TRUE if traditional macro recursion is detected.  */
 806 static bool
 807 recursive_macro (pfile, node)
 808      cpp_reader *pfile;
 809      cpp_hashnode *node;
 810 {
 811   bool recursing = !!(node->flags & NODE_DISABLED);
 812
 813   /* Object-like macros that are already expanding are necessarily
 814      recursive.
 815
 816      However, it is possible to have traditional function-like macros
 817      that are not infinitely recursive but recurse to any given depth.
 818      Further, it is easy to construct examples that get ever longer
 819      until the point they stop recursing.  So there is no easy way to
 820      detect true recursion; instead we assume any expansion more than
 821      20 deep since the first invocation of this macro must be
 822      recursing.  */
 823   if (recursing && node->value.macro->fun_like)
 824     {
 825       size_t depth = 0;
 826       cpp_context *context = pfile->context;
 827
 828       do
 829         {
 830           depth++;
 831           if (context->macro == node && depth > 20)
 832             break;
 833           context = context->prev;
 834         }
 835       while (context);
 836       recursing = context != NULL;
 837     }
 838
 839   if (recursing)
 840     cpp_error (pfile, DL_ERROR,
 841                "detected recursion whilst expanding macro \"%s\"",
 842                NODE_NAME (node));
 843
 844   return recursing;
 845 }
 846
 847 /* Return the length of the replacement text of a function-like or
 848    object-like non-builtin macro.  */
 849 size_t
 850 _cpp_replacement_text_len (macro)
 851      const cpp_macro *macro;
 852 {
 853   size_t len;
 854
 855   if (macro->fun_like)
 856     {
 857       const uchar *exp;
 858
 859       len = 0;
 860       for (exp = macro->exp.text;;)
 861         {
 862           struct block *b = (struct block *) exp;
 863
 864           len += b->text_len;
 865           if (b->arg_index == 0)
 866             break;
 867           len += NODE_LEN (macro->params[b->arg_index - 1]);
 868           exp += BLOCK_LEN (b->text_len);
 869         }
 870     }
 871   else
 872     len = macro->count;
 873
 874   return len;
 875 }
 876
 877 /* Copy the replacement text of MACRO to DEST, which must be of
 878    sufficient size.  It is not NUL-terminated.  The next character is
 879    returned.  */
 880 uchar *
 881 _cpp_copy_replacement_text (macro, dest)
 882      const cpp_macro *macro;
 883      uchar *dest;
 884 {
 885   if (macro->fun_like)
 886     {
 887       const uchar *exp;
 888
 889       for (exp = macro->exp.text;;)
 890         {
 891           struct block *b = (struct block *) exp;
 892           cpp_hashnode *param;
 893
 894           memcpy (dest, b->text, b->text_len);
 895           dest += b->text_len;
 896           if (b->arg_index == 0)
 897             break;
 898           param = macro->params[b->arg_index - 1];
 899           memcpy (dest, NODE_NAME (param), NODE_LEN (param));
 900           dest += NODE_LEN (param);
 901           exp += BLOCK_LEN (b->text_len);
 902         }
 903     }
 904   else
 905     {
 906       memcpy (dest, macro->exp.text, macro->count);
 907       dest += macro->count;
 908     }
 909
 910   return dest;
 911 }
 912
 913 /* Push a context holding the replacement text of the macro NODE on
 914    the context stack.  NODE is either object-like, or a function-like
 915    macro with no arguments.  */
 916 static void
 917 replace_args_and_push (pfile, fmacro)
 918      cpp_reader *pfile;
 919      struct fun_macro *fmacro;
 920 {
 921   cpp_macro *macro = fmacro->node->value.macro;
 922
 923   if (macro->paramc == 0)
 924     push_replacement_text (pfile, fmacro->node);
 925   else
 926     {
 927       const uchar *exp;
 928       uchar *p;
 929       _cpp_buff *buff;
 930       size_t len = 0;
 931
 932       /* Calculate the length of the argument-replaced text.  */
 933       for (exp = macro->exp.text;;)
 934         {
 935           struct block *b = (struct block *) exp;
 936
 937           len += b->text_len;
 938           if (b->arg_index == 0)
 939             break;
 940           len += (fmacro->args[b->arg_index]
 941                   - fmacro->args[b->arg_index - 1] - 1);
 942           exp += BLOCK_LEN (b->text_len);
 943         }
 944
 945       /* Allocate room for the expansion plus NUL.  */
 946       buff = _cpp_get_buff (pfile, len + 1);
 947
 948       /* Copy the expansion and replace arguments.  */
 949       p = BUFF_FRONT (buff);
 950       for (exp = macro->exp.text;;)
 951         {
 952           struct block *b = (struct block *) exp;
 953           size_t arglen;
 954
 955           memcpy (p, b->text, b->text_len);
 956           p += b->text_len;
 957           if (b->arg_index == 0)
 958             break;
 959           arglen = (fmacro->args[b->arg_index]
 960                     - fmacro->args[b->arg_index - 1] - 1);
 961           memcpy (p, pfile->out.base + fmacro->args[b->arg_index - 1],
 962                   arglen);
 963           p += arglen;
 964           exp += BLOCK_LEN (b->text_len);
 965         }
 966
 967       /* NUL-terminate.  */
 968       *p = '\0';
 969       _cpp_push_text_context (pfile, fmacro->node, BUFF_FRONT (buff), len);
 970
 971       /* So we free buffer allocation when macro is left.  */
 972       pfile->context->buff = buff;
 973     }
 974 }
 975
 976 /* Read and record the parameters, if any, of a function-like macro
 977    definition.  Destroys pfile->out.cur.
 978
 979    Returns true on success, false on failure (syntax error or a
 980    duplicate parameter).  On success, CUR (pfile->context) is just
 981    past the closing parenthesis.  */
 982 static bool
 983 scan_parameters (pfile, macro)
 984      cpp_reader *pfile;
 985      cpp_macro *macro;
 986 {
 987   const uchar *cur = CUR (pfile->context) + 1;
 988   bool ok;
 989
 990   for (;;)
 991     {
 992       cur = skip_whitespace (pfile, cur, true /* skip_comments */);
 993
 994       if (is_idstart (*cur))
 995         {
 996           ok = false;
 997           if (_cpp_save_parameter (pfile, macro, lex_identifier (pfile, cur)))
 998             break;
 999           cur = skip_whitespace (pfile, CUR (pfile->context),
1000                                  true /* skip_comments */);
1001           if (*cur == ',')
1002             {
1003               cur++;
1004               continue;
1005             }
1006           ok = (*cur == ')');
1007           break;
1008         }
1009
1010       ok = (*cur == ')' && macro->paramc == 0);
1011       break;
1012     }
1013
1014   CUR (pfile->context) = cur + (*cur == ')');
1015
1016   return ok;
1017 }
1018
1019 /* Save the text from pfile->out.base to pfile->out.cur as
1020    the replacement text for the current macro, followed by argument
1021    ARG_INDEX, with zero indicating the end of the replacement
1022    text.  */
1023 static void
1024 save_replacement_text (pfile, macro, arg_index)
1025      cpp_reader *pfile;
1026      cpp_macro *macro;
1027      unsigned int arg_index;
1028 {
1029   size_t len = pfile->out.cur - pfile->out.base;
1030   uchar *exp;
1031
1032   if (macro->paramc == 0)
1033     {
1034       /* Object-like and function-like macros without parameters
1035          simply store their NUL-terminated replacement text.  */
1036       exp = _cpp_unaligned_alloc (pfile, len + 1);
1037       memcpy (exp, pfile->out.base, len);
1038       exp[len] = '\0';
1039       macro->exp.text = exp;
1040       macro->count = len;
1041     }
1042   else
1043     {
1044       /* Store the text's length (unsigned int), the argument index
1045          (unsigned short, base 1) and then the text.  */
1046       size_t blen = BLOCK_LEN (len);
1047       struct block *block;
1048
1049       if (macro->count + blen > BUFF_ROOM (pfile->a_buff))
1050         _cpp_extend_buff (pfile, &pfile->a_buff, macro->count + blen);
1051
1052       exp = BUFF_FRONT (pfile->a_buff);
1053       block = (struct block *) (exp + macro->count);
1054       macro->exp.text = exp;
1055
1056       /* Write out the block information.  */
1057       block->text_len = len;
1058       block->arg_index = arg_index;
1059       memcpy (block->text, pfile->out.base, len);
1060
1061       /* Lex the rest into the start of the output buffer.  */
1062       pfile->out.cur = pfile->out.base;
1063
1064       macro->count += blen;
1065
1066       /* If we've finished, commit the memory.  */
1067       if (arg_index == 0)
1068         BUFF_FRONT (pfile->a_buff) += macro->count;
1069     }
1070 }
1071
1072 /* Analyze and save the replacement text of a macro.  Returns true on
1073    success.  */
1074 bool
1075 _cpp_create_trad_definition (pfile, macro)
1076      cpp_reader *pfile;
1077      cpp_macro *macro;
1078 {
1079   const uchar *cur;
1080   uchar *limit;
1081   cpp_context *context = pfile->context;
1082
1083   /* The context has not been set up for command line defines, and CUR
1084      has not been updated for the macro name for in-file defines.  */
1085   pfile->out.cur = pfile->out.base;
1086   CUR (context) = pfile->buffer->cur;
1087   RLIMIT (context) = pfile->buffer->rlimit;
1088   check_output_buffer (pfile, RLIMIT (context) - CUR (context));
1089
1090   /* Is this a function-like macro?  */
1091   if (* CUR (context) == '(')
1092     {
1093       /* Setting macro to NULL indicates an error occurred, and
1094          prevents unnecessary work in scan_out_logical_line.  */
1095       if (!scan_parameters (pfile, macro))
1096         macro = NULL;
1097       else
1098         {
1099           /* Success.  Commit the parameter array.  */
1100           macro->params = (cpp_hashnode **) BUFF_FRONT (pfile->a_buff);
1101           BUFF_FRONT (pfile->a_buff) = (uchar *) &macro->params[macro->paramc];
1102           macro->fun_like = 1;
1103         }
1104     }
1105
1106   /* Skip leading whitespace in the replacement text.  */
1107   pfile->buffer->cur
1108     = skip_whitespace (pfile, CUR (context),
1109                        CPP_OPTION (pfile, discard_comments_in_macro_exp));
1110
1111   pfile->state.prevent_expansion++;
1112   scan_out_logical_line (pfile, macro);
1113   pfile->state.prevent_expansion--;
1114
1115   if (!macro)
1116     return false;
1117
1118   /* Skip trailing white space.  */
1119   cur = pfile->out.base;
1120   limit = pfile->out.cur;
1121   while (limit > cur && is_space (limit[-1]))
1122     limit--;
1123   pfile->out.cur = limit;
1124   save_replacement_text (pfile, macro, 0);
1125
1126   return true;
1127 }
1128
1129 /* Copy SRC of length LEN to DEST, but convert all contiguous
1130    whitespace to a single space, provided it is not in quotes.  The
1131    quote currently in effect is pointed to by PQUOTE, and is updated
1132    by the function.  Returns the number of bytes copied.  */
1133 static size_t
1134 canonicalize_text (dest, src, len, pquote)
1135      uchar *dest;
1136      const uchar *src;
1137      size_t len;
1138      uchar *pquote;
1139 {
1140   uchar *orig_dest = dest;
1141   uchar quote = *pquote;
1142
1143   while (len)
1144     {
1145       if (is_space (*src) && !quote)
1146         {
1147           do
1148             src++, len--;
1149           while (len && is_space (*src));
1150           *dest++ = ' ';
1151         }
1152       else
1153         {
1154           if (*src == '\'' || *src == '"')
1155             {
1156               if (!quote)
1157                 quote = *src;
1158               else if (quote == *src)
1159                 quote = 0;
1160             }
1161           *dest++ = *src++, len--;
1162         }
1163     }
1164
1165   *pquote = quote;
1166   return dest - orig_dest;
1167 }
1168
1169 /* Returns true if MACRO1 and MACRO2 have expansions different other
1170    than in the form of their whitespace.  */
1171 bool
1172 _cpp_expansions_different_trad (macro1, macro2)
1173      const cpp_macro *macro1, *macro2;
1174 {
1175   uchar *p1 = xmalloc (macro1->count + macro2->count);
1176   uchar *p2 = p1 + macro1->count;
1177   uchar quote1 = 0, quote2 = 0;
1178   bool mismatch;
1179   size_t len1, len2;
1180
1181   if (macro1->paramc > 0)
1182     {
1183       const uchar *exp1 = macro1->exp.text, *exp2 = macro2->exp.text;
1184
1185       mismatch = true;
1186       for (;;)
1187         {
1188           struct block *b1 = (struct block *) exp1;
1189           struct block *b2 = (struct block *) exp2;
1190
1191           if (b1->arg_index != b2->arg_index)
1192             break;
1193
1194           len1 = canonicalize_text (p1, b1->text, b1->text_len, &quote1);
1195           len2 = canonicalize_text (p2, b2->text, b2->text_len, &quote2);
1196           if (len1 != len2 || memcmp (p1, p2, len1))
1197             break;
1198           if (b1->arg_index == 0)
1199             {
1200               mismatch = false;
1201               break;
1202             }
1203           exp1 += BLOCK_LEN (b1->text_len);
1204           exp2 += BLOCK_LEN (b2->text_len);
1205         }
1206     }
1207   else
1208     {
1209       len1 = canonicalize_text (p1, macro1->exp.text, macro1->count, &quote1);
1210       len2 = canonicalize_text (p2, macro2->exp.text, macro2->count, &quote2);
1211       mismatch = (len1 != len2 || memcmp (p1, p2, len1));
1212     }
1213
1214   free (p1);
1215   return mismatch;
1216 }