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