gcc/cpphash.c

   1 /* Part of CPP library.  (Macro handling.)
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4    Written by Per Bothner, 1994.
   5    Based on CCCP program by Paul Rubin, June 1986
   6    Adapted to ANSI C, Richard Stallman, Jan 1987
   7
   8 This program is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21
  22  In other words, you are welcome to use, share and improve this program.
  23  You are forbidden to forbid anyone else to use, share and improve
  24  what you give them.   Help stamp out software-hoarding!  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "cpplib.h"
  29 #include "cpphash.h"
  30 #include "version.h"
  31 #undef abort
  32
  33 static unsigned int hashf         PARAMS ((const U_CHAR *, int));
  34 static int comp_def_part         PARAMS ((int, U_CHAR *, int, U_CHAR *,
  35                                           int, int));
  36 static void push_macro_expansion PARAMS ((cpp_reader *,
  37                                           U_CHAR *, int, HASHNODE *));
  38 static int unsafe_chars          PARAMS ((cpp_reader *, int, int));
  39 static int macro_cleanup         PARAMS ((cpp_buffer *, cpp_reader *));
  40 static enum cpp_token macarg     PARAMS ((cpp_reader *, int));
  41 static struct tm *timestamp      PARAMS ((cpp_reader *));
  42 static void special_symbol       PARAMS ((HASHNODE *, cpp_reader *));
  43
  44 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
  45 #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
  46 #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
  47
  48 /* The arglist structure is built by create_definition to tell
  49    collect_expansion where the argument names begin.  That
  50    is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
  51    would contain pointers to the strings x, y, and z.
  52    collect_expansion would then build a DEFINITION node,
  53    with reflist nodes pointing to the places x, y, and z had
  54    appeared.  So the arglist is just convenience data passed
  55    between these two routines.  It is not kept around after
  56    the current #define has been processed and entered into the
  57    hash table.  */
  58
  59 struct arg
  60 {
  61   U_CHAR *name;
  62   int len;
  63   char rest_arg;
  64 };
  65
  66 struct arglist
  67 {
  68   U_CHAR *namebuf;
  69   struct arg *argv;
  70   int argc;
  71 };
  72
  73
  74 static DEFINITION *collect_expansion PARAMS ((cpp_reader *, struct arglist *));
  75 static struct arglist *collect_formal_parameters PARAMS ((cpp_reader *));
  76
  77 /* This structure represents one parsed argument in a macro call.
  78    `raw' points to the argument text as written (`raw_length' is its length).
  79    `expanded' points to the argument's macro-expansion
  80    (its length is `expand_length').
  81    `stringified_length' is the length the argument would have
  82    if stringified.  */
  83
  84 /* raw and expanded are relative to ARG_BASE */
  85 #define ARG_BASE ((pfile)->token_buffer)
  86
  87 struct argdata
  88 {
  89   /* Strings relative to pfile->token_buffer */
  90   long raw, expanded, stringified;
  91   int raw_length, expand_length;
  92   int stringified_length;
  93 };
  94
  95
  96 /* Calculate hash function on a string.  */
  97
  98 static unsigned int
  99 hashf (s, len)
 100      register const U_CHAR *s;
 101      register int len;
 102 {
 103   unsigned int n = len;
 104   unsigned int r = 0;
 105
 106   do
 107     r = r * 67 + (*s++ - 113);
 108   while (--n);
 109   return r + len;
 110 }
 111
 112 /* Find the most recent hash node for name "name" (ending with first
 113    non-identifier char) installed by cpp_install
 114
 115    If LEN is >= 0, it is the length of the name.
 116    Otherwise, compute the length by scanning the entire name.  */
 117
 118 HASHNODE *
 119 cpp_lookup (pfile, name, len)
 120      cpp_reader *pfile;
 121      const U_CHAR *name;
 122      int len;
 123 {
 124   register const U_CHAR *bp;
 125   register HASHNODE *bucket;
 126   register unsigned int hash;
 127
 128   if (len < 0)
 129     {
 130       for (bp = name; is_idchar (*bp); bp++);
 131       len = bp - name;
 132     }
 133
 134   hash = hashf (name, len) % HASHSIZE;
 135
 136   bucket = pfile->hashtab[hash];
 137   while (bucket)
 138     {
 139       if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
 140         return bucket;
 141       bucket = bucket->next;
 142     }
 143   return (HASHNODE *) 0;
 144 }
 145
 146 /* Free a DEFINITION structure.  Used by delete_macro, and by
 147    do_define when redefining macros.  */
 148
 149 void
 150 free_definition (d)
 151      DEFINITION *d;
 152 {
 153   struct reflist *ap, *nextap;
 154
 155   for (ap = d->pattern; ap != NULL; ap = nextap)
 156     {
 157       nextap = ap->next;
 158       free (ap);
 159     }
 160   if (d->nargs >= 0)
 161     free (d->argnames);
 162   free (d);
 163 }
 164
 165 /*
 166  * Delete a hash node.  Some weirdness to free junk from macros.
 167  * More such weirdness will have to be added if you define more hash
 168  * types that need it.
 169  */
 170
 171 void
 172 delete_macro (hp)
 173      HASHNODE *hp;
 174 {
 175   if (hp->prev != NULL)
 176     hp->prev->next = hp->next;
 177   if (hp->next != NULL)
 178     hp->next->prev = hp->prev;
 179
 180   /* make sure that the bucket chain header that
 181      the deleted guy was on points to the right thing afterwards.  */
 182   if (hp == *hp->bucket_hdr)
 183     *hp->bucket_hdr = hp->next;
 184
 185   if (hp->type == T_MACRO)
 186     free_definition (hp->value.defn);
 187
 188   free (hp);
 189 }
 190
 191 /* Install a name in the main hash table, even if it is already there.
 192    Name stops with first non alphanumeric, except leading '#'.
 193    Caller must check against redefinition if that is desired.
 194    delete_macro () removes things installed by cpp_install () in fifo order.
 195    this is important because of the `defined' special symbol used
 196    in #if, and also if pushdef/popdef directives are ever implemented.
 197
 198    If LEN is >= 0, it is the length of the name.
 199    Otherwise, compute the length by scanning the entire name.
 200
 201    If HASH is >= 0, it is the precomputed hash code.
 202    Otherwise, compute the hash code.  */
 203
 204 HASHNODE *
 205 cpp_install (pfile, name, len, type, value)
 206      cpp_reader *pfile;
 207      const U_CHAR *name;
 208      int len;
 209      enum node_type type;
 210      const char *value;
 211 {
 212   register HASHNODE *hp;
 213   register int i, bucket;
 214   register const U_CHAR *p;
 215   unsigned int hash;
 216
 217   if (len < 0)
 218     {
 219       p = name;
 220       while (is_idchar(*p))
 221         p++;
 222       len = p - name;
 223     }
 224
 225   hash = hashf (name, len) % HASHSIZE;
 226
 227   i = sizeof (HASHNODE) + len + 1;
 228   hp = (HASHNODE *) xmalloc (i);
 229   bucket = hash;
 230   hp->bucket_hdr = &pfile->hashtab[bucket];
 231   hp->next = pfile->hashtab[bucket];
 232   pfile->hashtab[bucket] = hp;
 233   hp->prev = NULL;
 234   if (hp->next != NULL)
 235     hp->next->prev = hp;
 236   hp->type = type;
 237   hp->length = len;
 238   hp->value.cpval = value;
 239   hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
 240   bcopy (name, hp->name, len);
 241   hp->name[len] = 0;
 242   return hp;
 243 }
 244
 245 static int
 246 macro_cleanup (pbuf, pfile)
 247      cpp_buffer *pbuf;
 248      cpp_reader *pfile ATTRIBUTE_UNUSED;
 249 {
 250   HASHNODE *macro = (HASHNODE *) pbuf->data;
 251   if (macro->type == T_DISABLED)
 252     macro->type = T_MACRO;
 253   if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
 254     free (pbuf->buf);
 255   return 0;
 256 }
 257
 258
 259 /* Read a replacement list for a macro, and build the DEFINITION
 260    structure.  ARGLIST specifies the formal parameters to look for in
 261    the text of the definition.  If ARGLIST is null, this is an
 262    object-like macro; if it points to an empty arglist, this is a
 263    function-like macro with no arguments.
 264
 265    A good half of this is devoted to supporting -traditional.
 266    Kill me now.  */
 267
 268 static DEFINITION *
 269 collect_expansion (pfile, arglist)
 270      cpp_reader *pfile;
 271      struct arglist *arglist;
 272 {
 273   DEFINITION *defn;
 274   struct reflist *pat = 0, *endpat = 0;
 275   enum cpp_token token;
 276   long start, here, last;
 277   int i;
 278   int argc;
 279   size_t len;
 280   struct arg *argv;
 281   U_CHAR *tok, *exp;
 282   enum { START = 0, NORM, ARG, STRIZE, PASTE } last_token = START;
 283
 284   if (arglist)
 285     {
 286       argv = arglist->argv;
 287       argc = arglist->argc;
 288     }
 289   else
 290     {
 291       argv = 0;
 292       argc = 0;
 293     }
 294
 295   last = start = CPP_WRITTEN (pfile);
 296   last -= 2;  /* two extra chars for the leading escape */
 297   for (;;)
 298     {
 299       /* We use cpp_get_token because get_directive_token would
 300          discard whitespace and we can't cope with that yet.  Macro
 301          expansion is off, so we are guaranteed not to see POP or EOF.  */
 302
 303       while (PEEKC () == '\r')
 304         {
 305           FORWARD (1);
 306           CPP_BUMP_LINE (pfile);
 307         }
 308       if (PEEKC () == '\n')
 309         goto done;
 310       here = CPP_WRITTEN (pfile);
 311       token = cpp_get_token (pfile);
 312       tok = pfile->token_buffer + here;
 313       switch (token)
 314         {
 315         case CPP_POP:
 316         case CPP_EOF:
 317         case CPP_VSPACE:
 318           cpp_ice (pfile, "EOF or VSPACE in collect_expansion");
 319           goto done;
 320
 321         case CPP_HSPACE:
 322           if (last_token == STRIZE || last_token == PASTE
 323               || last_token == START)
 324             CPP_SET_WRITTEN (pfile, here);
 325           break;
 326
 327         case CPP_STRINGIZE:
 328           if (last_token == PASTE)
 329             /* Not really a stringifier.  */
 330             goto norm;
 331           last_token = STRIZE;
 332           CPP_SET_WRITTEN (pfile, here);  /* delete from replacement text */
 333           break;
 334
 335         case CPP_TOKPASTE:
 336           /* If the last token was an argument, discard this token and
 337              any hspace between it and the argument's position.  Then
 338              mark the arg raw_after.  */
 339           if (last_token == ARG)
 340             {
 341               endpat->raw_after = 1;
 342               last_token = PASTE;
 343               CPP_SET_WRITTEN (pfile, last);
 344               break;
 345             }
 346           else if (last_token == PASTE)
 347             /* ## ## - the second ## is ordinary.  */
 348             goto norm;
 349
 350           /* Discard the token and any hspace before it.  */
 351           while (is_hspace (pfile->token_buffer[here-1]))
 352             here--;
 353           CPP_SET_WRITTEN (pfile, here);
 354
 355           if (last_token == STRIZE)
 356             /* Oops - that wasn't a stringify operator.  */
 357             CPP_PUTC (pfile, '#');
 358           last_token = PASTE;
 359           break;
 360
 361         case CPP_COMMENT:
 362           /* We must be in -traditional mode.  Pretend this was a
 363              token paste, but only if there was no leading or
 364              trailing space.  */
 365           CPP_SET_WRITTEN (pfile, here);
 366           if (is_hspace (pfile->token_buffer[here-1]))
 367             break;
 368           if (is_hspace (PEEKC ()))
 369             break;
 370           if (last_token == ARG)
 371             endpat->raw_after = 1;
 372           last_token = PASTE;
 373           break;
 374
 375         case CPP_STRING:
 376         case CPP_CHAR:
 377           if (last_token == STRIZE)
 378             cpp_error (pfile, "`#' is not followed by a macro argument name");
 379
 380           if (CPP_TRADITIONAL (pfile) || CPP_OPTIONS (pfile)->warn_stringify)
 381             goto maybe_trad_stringify;
 382           else
 383             goto norm;
 384
 385         case CPP_NAME:
 386           for (i = 0; i < argc; i++)
 387             if (!strncmp (tok, argv[i].name, argv[i].len)
 388                 && ! is_idchar (tok[argv[i].len]))
 389               goto addref;
 390
 391           /* fall through */
 392         default:
 393         norm:
 394           if (last_token == STRIZE)
 395             cpp_error (pfile, "`#' is not followed by a macro argument name");
 396           last_token = NORM;
 397           break;
 398         }
 399       continue;
 400
 401     addref:
 402       {
 403         struct reflist *tpat;
 404
 405         /* Make a pat node for this arg and add it to the pat list */
 406         tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
 407         tpat->next = NULL;
 408         tpat->raw_before = (last_token == PASTE);
 409         tpat->raw_after = 0;
 410         tpat->stringify = (last_token == STRIZE);
 411         tpat->rest_args = argv[i].rest_arg;
 412         tpat->argno = i;
 413         tpat->nchars = here - last;
 414
 415         if (endpat == NULL)
 416           pat = tpat;
 417         else
 418           endpat->next = tpat;
 419         endpat = tpat;
 420         last = here;
 421       }
 422       CPP_SET_WRITTEN (pfile, here);  /* discard arg name */
 423       last_token = ARG;
 424       continue;
 425
 426     maybe_trad_stringify:
 427       last_token = NORM;
 428       {
 429         U_CHAR *base, *p, *limit;
 430         struct reflist *tpat;
 431
 432         base = p = pfile->token_buffer + here;
 433         limit = CPP_PWRITTEN (pfile);
 434
 435         while (++p < limit)
 436           {
 437             if (is_idstart (*p))
 438               continue;
 439             for (i = 0; i < argc; i++)
 440               if (!strncmp (tok, argv[i].name, argv[i].len)
 441                   && ! is_idchar (tok[argv[i].len]))
 442                 goto mts_addref;
 443             continue;
 444
 445           mts_addref:
 446             if (!CPP_TRADITIONAL (pfile))
 447               {
 448                 /* Must have got here because of -Wtraditional.  */
 449                 cpp_warning (pfile,
 450              "macro argument `%.*s' would be stringified with -traditional",
 451                              (int) argv[i].len, argv[i].name);
 452                 continue;
 453               }
 454             if (CPP_OPTIONS (pfile)->warn_stringify)
 455               cpp_warning (pfile, "macro argument `%.*s' is stringified",
 456                              (int) argv[i].len, argv[i].name);
 457
 458             /* Remove the argument from the string.  */
 459             memmove (p, p + argv[i].len, limit - (p + argv[i].len));
 460             limit -= argv[i].len;
 461
 462             /* Make a pat node for this arg and add it to the pat list */
 463             tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
 464             tpat->next = NULL;
 465
 466             /* Don't attempt to paste this with anything.  */
 467             tpat->raw_before = 0;
 468             tpat->raw_after = 0;
 469             tpat->stringify = 1;
 470             tpat->rest_args = argv[i].rest_arg;
 471             tpat->argno = i;
 472             tpat->nchars = (p - base) + here - last;
 473
 474             if (endpat == NULL)
 475               pat = tpat;
 476             else
 477               endpat->next = tpat;
 478             endpat = tpat;
 479             last = (p - base) + here;
 480           }
 481         CPP_ADJUST_WRITTEN (pfile, CPP_PWRITTEN (pfile) - limit);
 482       }
 483     }
 484  done:
 485
 486   if (last_token == STRIZE)
 487     cpp_error (pfile, "`#' is not followed by a macro argument name");
 488   else if (last_token == PASTE)
 489     cpp_error (pfile, "`##' at end of macro definition");
 490
 491   if (last_token == START)
 492     {
 493       /* Empty macro definition.  */
 494       exp = xstrdup ("\r \r ");
 495       len = 1;
 496     }
 497   else
 498     {
 499       /* Trim trailing white space from definition.  */
 500       here = CPP_WRITTEN (pfile);
 501       while (here > last && is_hspace (pfile->token_buffer [here-1]))
 502         here--;
 503       CPP_SET_WRITTEN (pfile, here);
 504
 505       CPP_NUL_TERMINATE (pfile);
 506       len = CPP_WRITTEN (pfile) - start + 1;
 507       exp = xmalloc (len + 4); /* space for no-concat markers at either end */
 508       exp[0] = '\r';
 509       exp[1] = ' ';
 510       exp[len + 1] = '\r';
 511       exp[len + 2] = ' ';
 512       exp[len + 3] = '\0';
 513       memcpy (&exp[2], pfile->token_buffer + start, len - 1);
 514     }
 515
 516   CPP_SET_WRITTEN (pfile, start);
 517
 518   defn = (DEFINITION *) xmalloc (sizeof (DEFINITION));
 519   defn->length = len + 3;
 520   defn->expansion = exp;
 521   defn->pattern = pat;
 522   defn->rest_args = 0;
 523   if (arglist)
 524     {
 525       defn->nargs = argc;
 526       defn->argnames = arglist->namebuf;
 527       if (argv)
 528         {
 529           defn->rest_args = argv[argc - 1].rest_arg;
 530           free (argv);
 531         }
 532       free (arglist);
 533     }
 534   else
 535     {
 536       defn->nargs = -1;
 537       defn->argnames = 0;
 538       defn->rest_args = 0;
 539     }
 540   return defn;
 541 }
 542
 543 static struct arglist *
 544 collect_formal_parameters (pfile)
 545      cpp_reader *pfile;
 546 {
 547   struct arglist *result = 0;
 548   struct arg *argv = 0;
 549   U_CHAR *namebuf = xstrdup ("");
 550
 551   U_CHAR *name, *tok;
 552   size_t argslen = 1;
 553   int len;
 554   int argc = 0;
 555   int i;
 556   enum cpp_token token;
 557   long old_written;
 558
 559   old_written = CPP_WRITTEN (pfile);
 560   token = get_directive_token (pfile);
 561   if (token != CPP_LPAREN)
 562     {
 563       cpp_ice (pfile, "first token = %d not %d in collect_formal_parameters",
 564                token, CPP_LPAREN);
 565       goto invalid;
 566     }
 567
 568   argv = (struct arg *) xmalloc (sizeof (struct arg));
 569   argv[argc].len = 0;
 570   argv[argc].rest_arg = 0;
 571   for (;;)
 572     {
 573       CPP_SET_WRITTEN (pfile, old_written);
 574       token = get_directive_token (pfile);
 575       switch (token)
 576         {
 577         case CPP_NAME:
 578           tok = pfile->token_buffer + old_written;
 579           len = CPP_PWRITTEN (pfile) - tok;
 580           if (namebuf
 581               && (name = strstr (namebuf, tok))
 582               && name[len] == ','
 583               && (name == namebuf || name[-1] == ','))
 584             {
 585               cpp_error (pfile, "duplicate macro argument name `%s'", tok);
 586               continue;
 587             }
 588           namebuf = xrealloc (namebuf, argslen + len + 1);
 589           name = &namebuf[argslen - 1];
 590           argslen += len + 1;
 591
 592           memcpy (name, tok, len);
 593           name[len] = ',';
 594           name[len+1] = '\0';
 595           argv[argc].len = len;
 596           argv[argc].rest_arg = 0;
 597           break;
 598
 599         case CPP_COMMA:
 600           argc++;
 601           argv = xrealloc (argv, (argc + 1)*sizeof(struct arg));
 602           argv[argc].len = 0;
 603           break;
 604
 605         case CPP_RPAREN:
 606           goto done;
 607
 608         case CPP_3DOTS:
 609           goto rest_arg;
 610
 611         case CPP_VSPACE:
 612           cpp_error (pfile, "missing right paren in macro argument list");
 613           goto invalid;
 614
 615         default:
 616           cpp_error (pfile, "syntax error in #define");
 617           goto invalid;
 618         }
 619     }
 620
 621  rest_arg:
 622   /* There are two possible styles for a vararg macro:
 623      the C99 way:  #define foo(a, ...) a, __VA_ARGS__
 624      the gnu way:  #define foo(a, b...) a, b
 625      The C99 way can be considered a special case of the gnu way.
 626      There are also some constraints to worry about, but we'll handle
 627      those elsewhere.  */
 628   if (argv[argc].len == 0)
 629     {
 630       if (CPP_PEDANTIC (pfile) && ! CPP_OPTIONS (pfile)->c99)
 631         cpp_pedwarn (pfile, "C89 does not permit varargs macros");
 632
 633       len = sizeof "__VA_ARGS__" - 1;
 634       namebuf = xrealloc (namebuf, argslen + len + 1);
 635       name = &namebuf[argslen - 1];
 636       argslen += len;
 637       memcpy (name, "__VA_ARGS__", len);
 638
 639       argslen += len + 1;
 640       argv[argc].len = len;
 641     }
 642   else
 643     if (CPP_PEDANTIC (pfile))
 644       cpp_pedwarn (pfile, "ISO C does not permit named varargs macros");
 645
 646   argv[argc].rest_arg = 1;
 647   namebuf = xrealloc (namebuf, argslen + 3);
 648   memcpy (&namebuf[argslen - 1], "...", 4);
 649   argslen += 3;
 650
 651   token = get_directive_token (pfile);
 652   if (token != CPP_RPAREN)
 653     {
 654       cpp_error (pfile, "another parameter follows `...'");
 655       goto invalid;
 656     }
 657
 658  done:
 659   /* Go through argv and fix up the pointers.  */
 660   len = 0;
 661   for (i = 0; i <= argc; i++)
 662     {
 663       argv[i].name = namebuf + len;
 664       len += argv[i].len + 1;
 665     }
 666
 667   CPP_SET_WRITTEN (pfile, old_written);
 668
 669   result = (struct arglist *) xmalloc (sizeof (struct arglist));
 670   if (namebuf[0] != '\0')
 671     {
 672       result->namebuf = namebuf;
 673       result->argc = argc + 1;
 674       result->argv = argv;
 675     }
 676   else
 677     {
 678       free (namebuf);
 679       result->namebuf = 0;
 680       result->argc = 0;
 681       result->argv = 0;
 682     }
 683
 684   return result;
 685
 686  invalid:
 687   if (argv)
 688     free (argv);
 689   if (namebuf)
 690     free (namebuf);
 691   return 0;
 692 }
 693
 694 /* Create a DEFINITION node for a macro.  The reader's point is just
 695    after the macro name.  If FUNLIKE is true, this is a function-like
 696    macro.  */
 697
 698 DEFINITION *
 699 create_definition (pfile, funlike)
 700      cpp_reader *pfile;
 701      int funlike;
 702 {
 703   struct arglist *args = 0;
 704   long line, col;
 705   const char *file;
 706   DEFINITION *defn;
 707
 708   cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
 709   file = CPP_BUFFER (pfile)->nominal_fname;
 710
 711   pfile->no_macro_expand++;
 712   pfile->parsing_define_directive++;
 713   CPP_OPTIONS (pfile)->discard_comments++;
 714   CPP_OPTIONS (pfile)->no_line_commands++;
 715
 716   if (funlike)
 717     {
 718       args = collect_formal_parameters (pfile);
 719       if (args == 0)
 720         goto err;
 721     }
 722
 723   defn = collect_expansion (pfile, args);
 724   if (defn == 0)
 725     goto err;
 726
 727   defn->line = line;
 728   defn->file = file;
 729   defn->col  = col;
 730
 731   pfile->no_macro_expand--;
 732   pfile->parsing_define_directive--;
 733   CPP_OPTIONS (pfile)->discard_comments--;
 734   CPP_OPTIONS (pfile)->no_line_commands--;
 735   return defn;
 736
 737  err:
 738   pfile->no_macro_expand--;
 739   pfile->parsing_define_directive--;
 740   CPP_OPTIONS (pfile)->discard_comments--;
 741   CPP_OPTIONS (pfile)->no_line_commands--;
 742   return 0;
 743 }
 744
 745 /*
 746  * Parse a macro argument and append the info on PFILE's token_buffer.
 747  * REST_ARGS means to absorb the rest of the args.
 748  * Return nonzero to indicate a syntax error.
 749  */
 750
 751 static enum cpp_token
 752 macarg (pfile, rest_args)
 753      cpp_reader *pfile;
 754      int rest_args;
 755 {
 756   int paren = 0;
 757   enum cpp_token token;
 758
 759   /* Try to parse as much of the argument as exists at this
 760      input stack level.  */
 761   for (;;)
 762     {
 763       token = cpp_get_token (pfile);
 764       switch (token)
 765         {
 766         case CPP_EOF:
 767           return token;
 768         case CPP_POP:
 769           /* If we've hit end of file, it's an error (reported by caller).
 770              Ditto if it's the end of cpp_expand_to_buffer text.
 771              If we've hit end of macro, just continue.  */
 772           if (!CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
 773             return token;
 774           break;
 775         case CPP_LPAREN:
 776           paren++;
 777           break;
 778         case CPP_RPAREN:
 779           if (--paren < 0)
 780             goto found;
 781           break;
 782         case CPP_COMMA:
 783           /* if we've returned to lowest level and
 784              we aren't absorbing all args */
 785           if (paren == 0 && rest_args == 0)
 786             goto found;
 787           break;
 788         found:
 789           /* Remove ',' or ')' from argument buffer.  */
 790           CPP_ADJUST_WRITTEN (pfile, -1);
 791           return token;
 792         default:;
 793         }
 794     }
 795 }
 796 \f
 797
 798 static struct tm *
 799 timestamp (pfile)
 800      cpp_reader *pfile;
 801 {
 802   if (!pfile->timebuf)
 803     {
 804       time_t t = time ((time_t *) 0);
 805       pfile->timebuf = localtime (&t);
 806     }
 807   return pfile->timebuf;
 808 }
 809
 810 static const char * const monthnames[] =
 811 {
 812   "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 813   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
 814 };
 815
 816 /*
 817  * expand things like __FILE__.  Place the expansion into the output
 818  * buffer *without* rescanning.
 819  */
 820
 821 static void
 822 special_symbol (hp, pfile)
 823      HASHNODE *hp;
 824      cpp_reader *pfile;
 825 {
 826   const char *buf;
 827   int len;
 828   cpp_buffer *ip;
 829
 830   switch (hp->type)
 831     {
 832     case T_FILE:
 833     case T_BASE_FILE:
 834       {
 835         ip = CPP_BUFFER (pfile);
 836         if (hp->type == T_BASE_FILE)
 837           {
 838             while (CPP_PREV_BUFFER (ip) != CPP_NULL_BUFFER (pfile))
 839               ip = CPP_PREV_BUFFER (ip);
 840           }
 841         else
 842           {
 843             ip = CPP_BUFFER (pfile);
 844             while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
 845               ip = CPP_PREV_BUFFER (ip);
 846           }
 847
 848         buf = ip->nominal_fname;
 849
 850         if (!buf)
 851           buf = "";
 852         CPP_RESERVE (pfile, 3 + 4 * strlen (buf));
 853         quote_string (pfile, buf);
 854         return;
 855       }
 856
 857     case T_INCLUDE_LEVEL:
 858       {
 859         int true_indepth = 0;
 860         ip = CPP_BUFFER (pfile);
 861         for (; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
 862           if (ip->fname != NULL)
 863             true_indepth++;
 864
 865         CPP_RESERVE (pfile, 10);
 866         sprintf (CPP_PWRITTEN (pfile), "%d", true_indepth);
 867         CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
 868         return;
 869       }
 870
 871     case T_VERSION:
 872       len = strlen (version_string);
 873       CPP_RESERVE (pfile, 3 + len);
 874       CPP_PUTC_Q (pfile, '"');
 875       CPP_PUTS_Q (pfile, version_string, len);
 876       CPP_PUTC_Q (pfile, '"');
 877       CPP_NUL_TERMINATE_Q (pfile);
 878       return;
 879
 880     case T_CONST:
 881       buf = hp->value.cpval;
 882       if (!buf)
 883         return;
 884       if (*buf == '\0')
 885         buf = "\r ";
 886
 887       len = strlen (buf);
 888       CPP_RESERVE (pfile, len + 1);
 889       CPP_PUTS_Q (pfile, buf, len);
 890       CPP_NUL_TERMINATE_Q (pfile);
 891       return;
 892
 893     case T_STDC:
 894       CPP_RESERVE (pfile, 2);
 895 #ifdef STDC_0_IN_SYSTEM_HEADERS
 896       ip = CPP_BUFFER (pfile);
 897       while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
 898         ip = CPP_PREV_BUFFER (ip);
 899       if (ip->system_header_p
 900           && !cpp_lookup (pfile, (const U_CHAR *) "__STRICT_ANSI__", 15))
 901         CPP_PUTC_Q (pfile, '0');
 902       else
 903 #endif
 904         CPP_PUTC_Q (pfile, '1');
 905       CPP_NUL_TERMINATE_Q (pfile);
 906       return;
 907
 908     case T_SPECLINE:
 909       {
 910         long line;
 911         cpp_buf_line_and_col (cpp_file_buffer (pfile), &line, NULL);
 912
 913         CPP_RESERVE (pfile, 10);
 914         sprintf (CPP_PWRITTEN (pfile), "%ld", line);
 915         CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
 916         return;
 917       }
 918
 919     case T_DATE:
 920     case T_TIME:
 921       {
 922         struct tm *timebuf;
 923
 924         CPP_RESERVE (pfile, 20);
 925         timebuf = timestamp (pfile);
 926         if (hp->type == T_DATE)
 927           sprintf (CPP_PWRITTEN (pfile), "\"%s %2d %4d\"",
 928                    monthnames[timebuf->tm_mon],
 929                    timebuf->tm_mday, timebuf->tm_year + 1900);
 930         else
 931           sprintf (CPP_PWRITTEN (pfile), "\"%02d:%02d:%02d\"",
 932                    timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
 933
 934         CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
 935         return;
 936       }
 937
 938     case T_POISON:
 939       cpp_error (pfile, "attempt to use poisoned `%s'.", hp->name);
 940       CPP_RESERVE (pfile, 1);
 941       CPP_PUTC_Q (pfile, '0');
 942       CPP_NUL_TERMINATE_Q (pfile);
 943       break;
 944
 945     default:
 946       cpp_ice (pfile, "invalid special hash type");
 947       return;
 948     }
 949 }
 950
 951 /* Expand a macro call.
 952    HP points to the symbol that is the macro being called.
 953    Put the result of expansion onto the input stack
 954    so that subsequent input by our caller will use it.
 955
 956    If macro wants arguments, caller has already verified that
 957    an argument list follows; arguments come from the input stack.  */
 958
 959 void
 960 macroexpand (pfile, hp)
 961      cpp_reader *pfile;
 962      HASHNODE *hp;
 963 {
 964   int nargs;
 965   DEFINITION *defn;
 966   register U_CHAR *xbuf;
 967   long start_line, start_column;
 968   int xbuf_len;
 969   struct argdata *args = 0;
 970   long old_written = CPP_WRITTEN (pfile);
 971   int rest_args, rest_zero = 0;
 972   register int i;
 973
 974   cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
 975
 976   /* Check for and handle special symbols. */
 977   if (hp->type != T_MACRO)
 978     {
 979       special_symbol (hp, pfile);
 980       xbuf_len = CPP_WRITTEN (pfile) - old_written;
 981       xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
 982       CPP_SET_WRITTEN (pfile, old_written);
 983       memcpy (xbuf, CPP_PWRITTEN (pfile), xbuf_len + 1);
 984       push_macro_expansion (pfile, xbuf, xbuf_len, hp);
 985       CPP_BUFFER (pfile)->has_escapes = 1;
 986       return;
 987     }
 988
 989   defn = hp->value.defn;
 990   nargs = defn->nargs;
 991   pfile->output_escapes++;
 992
 993   if (nargs >= 0)
 994     {
 995       enum cpp_token token;
 996
 997       args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
 998
 999       for (i = 0; i < nargs; i++)
1000         {
1001           args[i].raw = args[i].expanded = 0;
1002           args[i].raw_length = 0;
1003           args[i].expand_length = args[i].stringified_length = -1;
1004         }
1005
1006       /* Parse all the macro args that are supplied.  I counts them.
1007          The first NARGS args are stored in ARGS.
1008          The rest are discarded.  If rest_args is set then we assume
1009          macarg absorbed the rest of the args.  */
1010       i = 0;
1011       rest_args = 0;
1012
1013       /* Skip over the opening parenthesis.  */
1014       CPP_OPTIONS (pfile)->discard_comments++;
1015       CPP_OPTIONS (pfile)->no_line_commands++;
1016       pfile->no_macro_expand++;
1017       pfile->no_directives++;
1018
1019       token = cpp_get_non_space_token (pfile);
1020       if (token != CPP_LPAREN)
1021         cpp_ice (pfile, "macroexpand: unexpected token %d (wanted LPAREN)",
1022                  token);
1023       CPP_ADJUST_WRITTEN (pfile, -1);
1024
1025       token = CPP_EOF;
1026       do
1027         {
1028           if (rest_args)
1029             continue;
1030           if (i < nargs || (nargs == 0 && i == 0))
1031             {
1032               /* if we are working on last arg which absorbs rest of args... */
1033               if (i == nargs - 1 && defn->rest_args)
1034                 rest_args = 1;
1035               args[i].raw = CPP_WRITTEN (pfile);
1036               token = macarg (pfile, rest_args);
1037               args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
1038             }
1039           else
1040             token = macarg (pfile, 0);
1041           if (token == CPP_EOF || token == CPP_POP)
1042             cpp_error_with_line (pfile, start_line, start_column,
1043                                  "unterminated macro call");
1044           i++;
1045         }
1046       while (token == CPP_COMMA);
1047       CPP_OPTIONS (pfile)->discard_comments--;
1048       CPP_OPTIONS (pfile)->no_line_commands--;
1049       pfile->no_macro_expand--;
1050       pfile->no_directives--;
1051       if (token != CPP_RPAREN)
1052         return;
1053
1054       /* If we got one arg but it was just whitespace, call that 0 args.  */
1055       if (i == 1)
1056         {
1057           register U_CHAR *bp = ARG_BASE + args[0].raw;
1058           register U_CHAR *lim = bp + args[0].raw_length;
1059           /* cpp.texi says for foo ( ) we provide one argument.
1060              However, if foo wants just 0 arguments, treat this as 0.  */
1061           if (nargs == 0)
1062             while (bp != lim && is_space(*bp))
1063               bp++;
1064           if (bp == lim)
1065             i = 0;
1066         }
1067
1068       /* Don't output an error message if we have already output one for
1069          a parse error above.  */
1070       rest_zero = 0;
1071       if (nargs == 0 && i > 0)
1072         {
1073           cpp_error (pfile, "arguments given to macro `%s'", hp->name);
1074         }
1075       else if (i < nargs)
1076         {
1077           /* traditional C allows foo() if foo wants one argument.  */
1078           if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
1079             ;
1080           /* the rest args token is allowed to absorb 0 tokens */
1081           else if (i == nargs - 1 && defn->rest_args)
1082             rest_zero = 1;
1083           else if (i == 0)
1084             cpp_error (pfile, "macro `%s' used without args", hp->name);
1085           else if (i == 1)
1086             cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
1087           else
1088             cpp_error (pfile, "macro `%s' used with only %d args",
1089                        hp->name, i);
1090         }
1091       else if (i > nargs)
1092         {
1093           cpp_error (pfile,
1094                      "macro `%s' used with too many (%d) args", hp->name, i);
1095         }
1096     }
1097
1098   /* If macro wants zero args, we parsed the arglist for checking only.
1099      Read directly from the macro definition.  */
1100   if (nargs <= 0)
1101     {
1102       xbuf = defn->expansion;
1103       xbuf_len = defn->length;
1104     }
1105   else
1106     {
1107       register U_CHAR *exp = defn->expansion;
1108       register int offset;      /* offset in expansion,
1109                                    copied a piece at a time */
1110       register int totlen;      /* total amount of exp buffer filled so far */
1111
1112       register struct reflist *ap, *last_ap;
1113
1114       /* Macro really takes args.  Compute the expansion of this call.  */
1115
1116       /* Compute length in characters of the macro's expansion.
1117          Also count number of times each arg is used.  */
1118       xbuf_len = defn->length;
1119       for (ap = defn->pattern; ap != NULL; ap = ap->next)
1120         {
1121           if (ap->stringify)
1122             {
1123               register struct argdata *arg = &args[ap->argno];
1124               /* Stringify if it hasn't already been */
1125               if (arg->stringified_length < 0)
1126                 {
1127                   int arglen = arg->raw_length;
1128                   int escaped = 0;
1129                   int in_string = 0;
1130                   int c;
1131                   /* Initially need_space is -1.  Otherwise, 1 means the
1132                      previous character was a space, but we suppressed it;
1133                      0 means the previous character was a non-space.  */
1134                   int need_space = -1;
1135                   i = 0;
1136                   arg->stringified = CPP_WRITTEN (pfile);
1137                   if (!CPP_TRADITIONAL (pfile))
1138                     CPP_PUTC (pfile, '\"');     /* insert beginning quote */
1139                   for (; i < arglen; i++)
1140                     {
1141                       c = (ARG_BASE + arg->raw)[i];
1142
1143                       if (!in_string)
1144                         {
1145                           /* Delete "\r " and "\r-" escapes.  */
1146                           if (c == '\r')
1147                             {
1148                               i++;
1149                               continue;
1150                             }
1151                           /* Internal sequences of whitespace are
1152                              replaced by one space except within
1153                              a string or char token. */
1154                           else if (is_space(c))
1155                             {
1156                               if (need_space == 0)
1157                                 need_space = 1;
1158                               continue;
1159                             }
1160                           else if (need_space > 0)
1161                             CPP_PUTC (pfile, ' ');
1162                           need_space = 0;
1163                         }
1164
1165                       if (escaped)
1166                         escaped = 0;
1167                       else
1168                         {
1169                           if (c == '\\')
1170                             escaped = 1;
1171                           if (in_string)
1172                             {
1173                               if (c == in_string)
1174                                 in_string = 0;
1175                             }
1176                           else if (c == '\"' || c == '\'')
1177                             in_string = c;
1178                         }
1179
1180                       /* Escape these chars */
1181                       if (c == '\"' || (in_string && c == '\\'))
1182                         CPP_PUTC (pfile, '\\');
1183                       if (ISPRINT (c))
1184                         CPP_PUTC (pfile, c);
1185                       else
1186                         {
1187                           CPP_RESERVE (pfile, 4);
1188                           sprintf ((char *) CPP_PWRITTEN (pfile), "\\%03o",
1189                                    (unsigned int) c);
1190                           CPP_ADJUST_WRITTEN (pfile, 4);
1191                         }
1192                     }
1193                   if (!CPP_TRADITIONAL (pfile))
1194                     CPP_PUTC (pfile, '\"');     /* insert ending quote */
1195                   arg->stringified_length
1196                     = CPP_WRITTEN (pfile) - arg->stringified;
1197                 }
1198               xbuf_len += args[ap->argno].stringified_length;
1199             }
1200           else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
1201             /* Add 4 for two \r-space markers to prevent
1202                token concatenation.  */
1203             xbuf_len += args[ap->argno].raw_length + 4;
1204           else
1205             {
1206               /* We have an ordinary (expanded) occurrence of the arg.
1207                  So compute its expansion, if we have not already.  */
1208               if (args[ap->argno].expand_length < 0)
1209                 {
1210                   args[ap->argno].expanded = CPP_WRITTEN (pfile);
1211                   cpp_expand_to_buffer (pfile,
1212                                         ARG_BASE + args[ap->argno].raw,
1213                                         args[ap->argno].raw_length);
1214
1215                   args[ap->argno].expand_length
1216                     = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
1217                 }
1218
1219               /* Add 4 for two \r-space markers to prevent
1220                  token concatenation.  */
1221               xbuf_len += args[ap->argno].expand_length + 4;
1222             }
1223         }
1224
1225       xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
1226
1227       /* Generate in XBUF the complete expansion
1228          with arguments substituted in.
1229          TOTLEN is the total size generated so far.
1230          OFFSET is the index in the definition
1231          of where we are copying from.  */
1232       offset = totlen = 0;
1233       for (last_ap = NULL, ap = defn->pattern; ap != NULL;
1234            last_ap = ap, ap = ap->next)
1235         {
1236           register struct argdata *arg = &args[ap->argno];
1237           int count_before = totlen;
1238
1239           /* Add chars to XBUF.  */
1240           i = ap->nchars;
1241           memcpy (&xbuf[totlen], &exp[offset], i);
1242           totlen += i;
1243           offset += i;
1244
1245           /* If followed by an empty rest arg with concatenation,
1246              delete the last run of nonwhite chars.  */
1247           if (rest_zero && totlen > count_before
1248               && ((ap->rest_args && ap->raw_before)
1249                   || (last_ap != NULL && last_ap->rest_args
1250                       && last_ap->raw_after)))
1251             {
1252               /* Delete final whitespace.  */
1253               while (totlen > count_before && is_space(xbuf[totlen - 1]))
1254                 totlen--;
1255
1256               /* Delete the nonwhites before them.  */
1257               while (totlen > count_before && !is_space(xbuf[totlen - 1]))
1258                 totlen--;
1259             }
1260
1261           if (ap->stringify != 0)
1262             {
1263               memcpy (xbuf + totlen, ARG_BASE + arg->stringified,
1264                       arg->stringified_length);
1265               totlen += arg->stringified_length;
1266             }
1267           else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
1268             {
1269               U_CHAR *p1 = ARG_BASE + arg->raw;
1270               U_CHAR *l1 = p1 + arg->raw_length;
1271               if (ap->raw_before)
1272                 {
1273                   /* Arg is concatenated before: delete leading whitespace,
1274                      whitespace markers, and no-reexpansion markers.  */
1275                   while (p1 != l1)
1276                     {
1277                       if (is_space(p1[0]))
1278                         p1++;
1279                       else if (p1[0] == '\r')
1280                         p1 += 2;
1281                       else
1282                         break;
1283                     }
1284                 }
1285               if (ap->raw_after)
1286                 {
1287                   /* Arg is concatenated after: delete trailing whitespace,
1288                      whitespace markers, and no-reexpansion markers.  */
1289                   while (p1 != l1)
1290                     {
1291                       if (is_space(l1[-1]))
1292                         l1--;
1293                       else if (l1[-1] == '\r')
1294                         l1--;
1295                       else if (l1[-1] == '-')
1296                         {
1297                           if (l1 != p1 + 1 && l1[-2] == '\r')
1298                             l1 -= 2;
1299                           else
1300                             break;
1301                         }
1302                       else
1303                         break;
1304                     }
1305                 }
1306
1307               /* Delete any no-reexpansion marker that precedes
1308                  an identifier at the beginning of the argument. */
1309               if (p1[0] == '\r' && p1[1] == '-')
1310                 p1 += 2;
1311
1312               memcpy (xbuf + totlen, p1, l1 - p1);
1313               totlen += l1 - p1;
1314             }
1315           else
1316             {
1317               U_CHAR *expanded = ARG_BASE + arg->expanded;
1318               if (!ap->raw_before && totlen > 0 && arg->expand_length
1319                   && !CPP_TRADITIONAL (pfile)
1320                   && unsafe_chars (pfile, xbuf[totlen - 1], expanded[0]))
1321                 {
1322                   xbuf[totlen++] = '\r';
1323                   xbuf[totlen++] = ' ';
1324                 }
1325
1326               memcpy (xbuf + totlen, expanded, arg->expand_length);
1327               totlen += arg->expand_length;
1328
1329               if (!ap->raw_after && totlen > 0 && offset < defn->length
1330                   && !CPP_TRADITIONAL (pfile)
1331                   && unsafe_chars (pfile, xbuf[totlen - 1], exp[offset]))
1332                 {
1333                   xbuf[totlen++] = '\r';
1334                   xbuf[totlen++] = ' ';
1335                 }
1336             }
1337
1338           if (totlen > xbuf_len)
1339             {
1340               cpp_ice (pfile, "buffer overrun in macroexpand");
1341               return;
1342             }
1343         }
1344
1345       /* if there is anything left of the definition
1346          after handling the arg list, copy that in too.  */
1347
1348       for (i = offset; i < defn->length; i++)
1349         {
1350           /* if we've reached the end of the macro */
1351           if (exp[i] == ')')
1352             rest_zero = 0;
1353           if (!(rest_zero && last_ap != NULL && last_ap->rest_args
1354                 && last_ap->raw_after))
1355             xbuf[totlen++] = exp[i];
1356         }
1357
1358       xbuf[totlen] = 0;
1359       xbuf_len = totlen;
1360
1361     }
1362
1363   pfile->output_escapes--;
1364
1365   /* Now put the expansion on the input stack
1366      so our caller will commence reading from it.  */
1367   push_macro_expansion (pfile, xbuf, xbuf_len, hp);
1368   CPP_BUFFER (pfile)->has_escapes = 1;
1369
1370   /* Pop the space we've used in the token_buffer for argument expansion.  */
1371   CPP_SET_WRITTEN (pfile, old_written);
1372
1373   /* Recursive macro use sometimes works traditionally.
1374      #define foo(x,y) bar (x (y,0), y)
1375      foo (foo, baz)  */
1376
1377   if (!CPP_TRADITIONAL (pfile))
1378     hp->type = T_DISABLED;
1379 }
1380
1381 /* Return 1 iff a token ending in C1 followed directly by a token C2
1382    could cause mis-tokenization.  */
1383
1384 static int
1385 unsafe_chars (pfile, c1, c2)
1386      cpp_reader *pfile;
1387      int c1, c2;
1388 {
1389   switch (c1)
1390     {
1391     case '+':  case '-':
1392       if (c2 == c1 || c2 == '=')
1393         return 1;
1394       goto letter;
1395
1396     case 'e':  case 'E':  case 'p':  case 'P':
1397       if (c2 == '-' || c2 == '+')
1398         return 1;               /* could extend a pre-processing number */
1399       goto letter;
1400
1401     case '$':
1402       if (CPP_OPTIONS (pfile)->dollars_in_ident)
1403         goto letter;
1404       return 0;
1405
1406     case 'L':
1407       if (c2 == '\'' || c2 == '\"')
1408         return 1;               /* Could turn into L"xxx" or L'xxx'.  */
1409       goto letter;
1410
1411     case '.':  case '0':  case '1':  case '2':  case '3':
1412     case '4':  case '5':  case '6':  case '7':  case '8':  case '9':
1413     case '_':  case 'a':  case 'b':  case 'c':  case 'd':  case 'f':
1414     case 'g':  case 'h':  case 'i':  case 'j':  case 'k':  case 'l':
1415     case 'm':  case 'n':  case 'o':  case 'q':  case 'r':  case 's':
1416     case 't':  case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
1417     case 'z':  case 'A':  case 'B':  case 'C':  case 'D':  case 'F':
1418     case 'G':  case 'H':  case 'I':  case 'J':  case 'K':  case 'M':
1419     case 'N':  case 'O':  case 'Q':  case 'R':  case 'S':  case 'T':
1420     case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':  case 'Z':
1421     letter:
1422     /* We're in the middle of either a name or a pre-processing number.  */
1423       return (is_idchar(c2) || c2 == '.');
1424
1425     case '<':  case '>':  case '!':  case '%':  case '#':  case ':':
1426     case '^':  case '&':  case '|':  case '*':  case '/':  case '=':
1427       return (c2 == c1 || c2 == '=');
1428     }
1429   return 0;
1430 }
1431
1432 static void
1433 push_macro_expansion (pfile, xbuf, xbuf_len, hp)
1434      cpp_reader *pfile;
1435      register U_CHAR *xbuf;
1436      int xbuf_len;
1437      HASHNODE *hp;
1438 {
1439   register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
1440   if (mbuf == NULL)
1441     return;
1442   mbuf->cleanup = macro_cleanup;
1443   mbuf->data = hp;
1444
1445   /* The first chars of the expansion should be a "\r " added by
1446      collect_expansion.  This is to prevent accidental token-pasting
1447      between the text preceding the macro invocation, and the macro
1448      expansion text.
1449
1450      We would like to avoid adding unneeded spaces (for the sake of
1451      tools that use cpp, such as imake).  In some common cases we can
1452      tell that it is safe to omit the space.
1453
1454      The character before the macro invocation cannot have been an
1455      idchar (or else it would have been pasted with the idchars of
1456      the macro name).  Therefore, if the first non-space character
1457      of the expansion is an idchar, we do not need the extra space
1458      to prevent token pasting.
1459
1460      Also, we don't need the extra space if the first char is '(',
1461      or some other (less common) characters.  */
1462
1463   if (xbuf[0] == '\r' && xbuf[1] == ' '
1464       && (is_idchar(xbuf[2]) || xbuf[2] == '(' || xbuf[2] == '\''
1465           || xbuf[2] == '\"'))
1466     mbuf->cur += 2;
1467
1468   /* Likewise, avoid the extra space at the end of the macro expansion
1469      if this is safe.  We can do a better job here since we can know
1470      what the next char will be.  */
1471   if (xbuf_len >= 3
1472       && mbuf->rlimit[-2] == '\r'
1473       && mbuf->rlimit[-1] == ' ')
1474     {
1475       int c1 = mbuf->rlimit[-3];
1476       int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
1477       if (c2 == EOF || !unsafe_chars (pfile, c1, c2))
1478         mbuf->rlimit -= 2;
1479     }
1480 }
1481
1482 /* Return zero if two DEFINITIONs are isomorphic.  */
1483
1484 int
1485 compare_defs (pfile, d1, d2)
1486      cpp_reader *pfile;
1487      DEFINITION *d1, *d2;
1488 {
1489   register struct reflist *a1, *a2;
1490   register U_CHAR *p1 = d1->expansion;
1491   register U_CHAR *p2 = d2->expansion;
1492   int first = 1;
1493
1494   if (d1->nargs != d2->nargs)
1495     return 1;
1496   if (CPP_PEDANTIC (pfile)
1497       && d1->argnames && d2->argnames
1498       && strcmp ((char *) d1->argnames, (char *) d2->argnames))
1499     return 1;
1500   for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1501        a1 = a1->next, a2 = a2->next)
1502     {
1503       if (!((a1->nchars == a2->nchars && !strncmp (p1, p2, a1->nchars))
1504             || !comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
1505           || a1->argno != a2->argno
1506           || a1->stringify != a2->stringify
1507           || a1->raw_before != a2->raw_before
1508           || a1->raw_after != a2->raw_after)
1509         return 1;
1510       first = 0;
1511       p1 += a1->nchars;
1512       p2 += a2->nchars;
1513     }
1514   if (a1 != a2)
1515     return 1;
1516
1517   return comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
1518                         p2, d2->length - (p2 - d2->expansion), 1);
1519 }
1520
1521 /* Return 1 if two parts of two macro definitions are effectively different.
1522    One of the parts starts at BEG1 and has LEN1 chars;
1523    the other has LEN2 chars at BEG2.
1524    Any sequence of whitespace matches any other sequence of whitespace.
1525    FIRST means these parts are the first of a macro definition;
1526     so ignore leading whitespace entirely.
1527    LAST means these parts are the last of a macro definition;
1528     so ignore trailing whitespace entirely.  */
1529
1530 static int
1531 comp_def_part (first, beg1, len1, beg2, len2, last)
1532      int first;
1533      U_CHAR *beg1, *beg2;
1534      int len1, len2;
1535      int last;
1536 {
1537   register U_CHAR *end1 = beg1 + len1;
1538   register U_CHAR *end2 = beg2 + len2;
1539   if (first)
1540     {
1541       while (beg1 != end1 && is_space(*beg1))
1542         beg1++;
1543       while (beg2 != end2 && is_space(*beg2))
1544         beg2++;
1545     }
1546   if (last)
1547     {
1548       while (beg1 != end1 && is_space(end1[-1]))
1549         end1--;
1550       while (beg2 != end2 && is_space(end2[-1]))
1551         end2--;
1552     }
1553   while (beg1 != end1 && beg2 != end2)
1554     {
1555       if (is_space(*beg1) && is_space(*beg2))
1556         {
1557           while (beg1 != end1 && is_space(*beg1))
1558             beg1++;
1559           while (beg2 != end2 && is_space(*beg2))
1560             beg2++;
1561         }
1562       else if (*beg1 == *beg2)
1563         {
1564           beg1++;
1565           beg2++;
1566         }
1567       else
1568         break;
1569     }
1570   return (beg1 != end1) || (beg2 != end2);
1571 }
1572
1573 /* Dump the definition of macro MACRO on stdout.  The format is suitable
1574    to be read back in again. */
1575
1576 void
1577 dump_definition (pfile, sym, len, defn)
1578      cpp_reader *pfile;
1579      const U_CHAR *sym;
1580      long len;
1581      DEFINITION *defn;
1582 {
1583   if (pfile->lineno == 0)
1584     output_line_command (pfile, same_file);
1585
1586   CPP_RESERVE (pfile, len + sizeof "#define ");
1587   CPP_PUTS_Q (pfile, "#define ", sizeof "#define " -1);
1588   CPP_PUTS_Q (pfile, sym, len);
1589
1590   if (defn->nargs == -1)
1591     {
1592       CPP_PUTC_Q (pfile, ' ');
1593
1594       /* The first and last two characters of a macro expansion are
1595          always "\r "; this needs to be trimmed out.
1596          So we need length-4 chars of space, plus one for the NUL.  */
1597       CPP_RESERVE (pfile, defn->length - 4 + 1);
1598       CPP_PUTS_Q (pfile, defn->expansion + 2, defn->length - 4);
1599     }
1600   else
1601     {
1602       struct reflist *r;
1603       unsigned char *argnames = (unsigned char *) xstrdup (defn->argnames);
1604       unsigned char **argv = (unsigned char **) alloca (defn->nargs *
1605                                                         sizeof(char *));
1606       int *argl = (int *) alloca (defn->nargs * sizeof(int));
1607       unsigned char *x;
1608       int i;
1609
1610       /* First extract the argument list. */
1611       x = argnames;
1612       i = defn->nargs;
1613       while (i--)
1614         {
1615           argv[i] = x;
1616           while (*x != ',' && *x != '\0') x++;
1617           argl[i] = x - argv[i];
1618           if (*x == ',')
1619             {
1620               *x = '\0';
1621               x += 2;  /* skip the space after the comma */
1622             }
1623         }
1624
1625       /* Now print out the argument list. */
1626       CPP_PUTC_Q (pfile, '(');
1627       for (i = 0; i < defn->nargs; i++)
1628         {
1629           CPP_RESERVE (pfile, argl[i] + 2);
1630           CPP_PUTS_Q (pfile, argv[i], argl[i]);
1631           if (i < defn->nargs-1)
1632             CPP_PUTS_Q (pfile, ", ", 2);
1633         }
1634
1635       if (defn->rest_args)
1636         CPP_PUTS (pfile, "...) ", 5);
1637       else
1638         CPP_PUTS (pfile, ") ", 2);
1639
1640       /* Now the definition. */
1641       x = defn->expansion;
1642       for (r = defn->pattern; r; r = r->next)
1643       {
1644         i = r->nchars;
1645         if (*x == '\r') x += 2, i -= 2;
1646         /* i chars for macro text, plus the length of the macro
1647            argument name, plus one for a stringify marker, plus two for
1648            each concatenation marker. */
1649         CPP_RESERVE (pfile,
1650                      i + argl[r->argno] + r->stringify
1651                      + (r->raw_before + r->raw_after) * 2);
1652
1653         if (i > 0) CPP_PUTS_Q (pfile, x, i);
1654         if (r->raw_before)
1655           CPP_PUTS_Q (pfile, "##", 2);
1656         if (r->stringify)
1657           CPP_PUTC_Q (pfile, '#');
1658         CPP_PUTS_Q (pfile, argv[r->argno], argl[r->argno]);
1659         if (r->raw_after && !(r->next && r->next->nchars == 0
1660                               && r->next->raw_before))
1661           CPP_PUTS_Q (pfile, "##", 2);
1662
1663         x += i;
1664       }
1665
1666       i = defn->length - (x - defn->expansion) - 2;
1667       if (*x == '\r') x += 2, i -= 2;
1668       if (i > 0) CPP_PUTS (pfile, x, i);
1669     }
1670
1671   if (pfile->lineno == 0)
1672     CPP_PUTC (pfile, '\n');
1673   CPP_NUL_TERMINATE (pfile);
1674 }