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