Daily bump.

[official-gcc.git] / gcc / cpphash.c

/* Part of CPP library.  (Macro handling.)
   Copyright (C) 1986, 87, 89, 92-95, 1996, 1998 Free Software Foundation, Inc.
   Written by Per Bothner, 1994.
   Based on CCCP program by Paul Rubin, June 1986
   Adapted to ANSI C, Richard Stallman, Jan 1987

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 In other words, you are welcome to use, share and improve this program.
 You are forbidden to forbid anyone else to use, share and improve
 what you give them.   Help stamp out software-hoarding!  */

#include "config.h"
#include "system.h"
#include "cpplib.h"
#include "cpphash.h"
#undef abort

static int comp_def_part         PARAMS ((int, U_CHAR *, int, U_CHAR *,
                                          int, int));
static int change_newlines       PARAMS ((U_CHAR *, int));
static void push_macro_expansion PARAMS ((cpp_reader *,
                                          U_CHAR *, int, HASHNODE *));
static int unsafe_chars          PARAMS ((int, int));

#define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
#define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
#define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))

extern char *version_string;

/* The arglist structure is built by create_definition to tell
   collect_expansion where the argument names begin.  That
   is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
   would contain pointers to the strings x, y, and z.
   collect_expansion would then build a DEFINITION node,
   with reflist nodes pointing to the places x, y, and z had
   appeared.  So the arglist is just convenience data passed
   between these two routines.  It is not kept around after
   the current #define has been processed and entered into the
   hash table.  */

struct arglist
{
  struct arglist *next;
  U_CHAR *name;
  int length;
  int argno;
  char rest_args;
};

/* This structure represents one parsed argument in a macro call.
   `raw' points to the argument text as written (`raw_length' is its length).
   `expanded' points to the argument's macro-expansion
   (its length is `expand_length').
   `stringified_length' is the length the argument would have
   if stringified.
   `use_count' is the number of times this macro arg is substituted
   into the macro.  If the actual use count exceeds 10, 
   the value stored is 10.  */

/* raw and expanded are relative to ARG_BASE */
#define ARG_BASE ((pfile)->token_buffer)

struct argdata
{
  /* Strings relative to pfile->token_buffer */
  long raw, expanded, stringified;
  int raw_length, expand_length;
  int stringified_length;
  char newlines;
  char use_count;
};


/* Return hash function on name.  must be compatible with the one
   computed a step at a time, elsewhere  */

int
hashf (name, len, hashsize)
     register const U_CHAR *name;
     register int len;
     int hashsize;
{
  register int r = 0;

  while (len--)
    r = HASHSTEP (r, *name++);

  return MAKE_POS (r) % hashsize;
}

/* Find the most recent hash node for name "name" (ending with first
   non-identifier char) installed by cpp_install

   If LEN is >= 0, it is the length of the name.
   Otherwise, compute the length by scanning the entire name.

   If HASH is >= 0, it is the precomputed hash code.
   Otherwise, compute the hash code.  */

HASHNODE *
cpp_lookup (pfile, name, len, hash)
     cpp_reader *pfile ATTRIBUTE_UNUSED;
     const U_CHAR *name;
     int len;
     int hash;
{
  register const U_CHAR *bp;
  register HASHNODE *bucket;

  if (len < 0)
    {
      for (bp = name; is_idchar[*bp]; bp++);
      len = bp - name;
    }

  if (hash < 0)
    hash = hashf (name, len, HASHSIZE);

  bucket = pfile->hashtab[hash];
  while (bucket)
    {
      if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
        return bucket;
      bucket = bucket->next;
    }
  return (HASHNODE *) 0;
}

/*
 * Delete a hash node.  Some weirdness to free junk from macros.
 * More such weirdness will have to be added if you define more hash
 * types that need it.
 */

/* Note that the DEFINITION of a macro is removed from the hash table
   but its storage is not freed.  This would be a storage leak
   except that it is not reasonable to keep undefining and redefining
   large numbers of macros many times.
   In any case, this is necessary, because a macro can be #undef'd
   in the middle of reading the arguments to a call to it.
   If #undef freed the DEFINITION, that would crash.  */

void
delete_macro (hp)
     HASHNODE *hp;
{

  if (hp->prev != NULL)
    hp->prev->next = hp->next;
  if (hp->next != NULL)
    hp->next->prev = hp->prev;

  /* make sure that the bucket chain header that
     the deleted guy was on points to the right thing afterwards.  */
  if (hp == *hp->bucket_hdr)
    *hp->bucket_hdr = hp->next;

  if (hp->type == T_MACRO)
    {
      DEFINITION *d = hp->value.defn;
      struct reflist *ap, *nextap;

      for (ap = d->pattern; ap != NULL; ap = nextap)
        {
          nextap = ap->next;
          free (ap);
        }
      if (d->nargs >= 0)
        free (d->args.argnames);
      free (d);
    }

  free (hp);
}

/* Install a name in the main hash table, even if it is already there.
   Name stops with first non alphanumeric, except leading '#'.
   Caller must check against redefinition if that is desired.
   delete_macro () removes things installed by cpp_install () in fifo order.
   this is important because of the `defined' special symbol used
   in #if, and also if pushdef/popdef directives are ever implemented.

   If LEN is >= 0, it is the length of the name.
   Otherwise, compute the length by scanning the entire name.

   If HASH is >= 0, it is the precomputed hash code.
   Otherwise, compute the hash code.  */

HASHNODE *
cpp_install (pfile, name, len, type, value, hash)
     cpp_reader *pfile;
     U_CHAR *name;
     int len;
     enum node_type type;
     const char *value;
     int hash;
{
  register HASHNODE *hp;
  register int i, bucket;
  register U_CHAR *p;

  if (len < 0)
    {
      p = name;
      while (is_idchar[*p])
        p++;
      len = p - name;
    }

  if (hash < 0)
    hash = hashf (name, len, HASHSIZE);

  i = sizeof (HASHNODE) + len + 1;
  hp = (HASHNODE *) xmalloc (i);
  bucket = hash;
  hp->bucket_hdr = &pfile->hashtab[bucket];
  hp->next = pfile->hashtab[bucket];
  pfile->hashtab[bucket] = hp;
  hp->prev = NULL;
  if (hp->next != NULL)
    hp->next->prev = hp;
  hp->type = type;
  hp->length = len;
  hp->value.cpval = value;
  hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
  bcopy (name, hp->name, len);
  hp->name[len] = 0;
  return hp;
}

static int
macro_cleanup (pbuf, pfile)
     cpp_buffer *pbuf;
     cpp_reader *pfile ATTRIBUTE_UNUSED;
{
  HASHNODE *macro = (HASHNODE *) pbuf->data;
  if (macro->type == T_DISABLED)
    macro->type = T_MACRO;
  if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
    free (pbuf->buf);
  return 0;
}


/* Read a replacement list for a macro with parameters.
   Build the DEFINITION structure.
   Reads characters of text starting at BUF until END.
   ARGLIST specifies the formal parameters to look for
   in the text of the definition; NARGS is the number of args
   in that list, or -1 for a macro name that wants no argument list.
   MACRONAME is the macro name itself (so we can avoid recursive expansion)
   and NAMELEN is its length in characters.
   
   Note that comments, backslash-newlines, and leading white space
   have already been deleted from the argument.  */

static DEFINITION *
collect_expansion (pfile, buf, limit, nargs, arglist)
     cpp_reader *pfile;
     U_CHAR *buf, *limit;
     int nargs;
     struct arglist *arglist;
{
  DEFINITION *defn;
  register U_CHAR *p, *lastp, *exp_p;
  struct reflist *endpat = NULL;
  /* Pointer to first nonspace after last ## seen.  */
  U_CHAR *concat = 0;
  /* Pointer to first nonspace after last single-# seen.  */
  U_CHAR *stringify = 0;
  int maxsize;
  int expected_delimiter = '\0';

  /* Scan thru the replacement list, ignoring comments and quoted
     strings, picking up on the macro calls.  It does a linear search
     thru the arg list on every potential symbol.  Profiling might say
     that something smarter should happen.  */

  if (limit < buf)
    {
      cpp_fatal (pfile, "internal error: limit < buf in collect_expansion");
      limit = buf; /* treat it like a null defn */
    }

  /* Find the beginning of the trailing whitespace.  */
  p = buf;
  while (p < limit && is_space[limit[-1]])
    limit--;

  /* Allocate space for the text in the macro definition.
     Leading and trailing whitespace chars need 2 bytes each.
     Each other input char may or may not need 1 byte,
     so this is an upper bound.  The extra 5 are for invented
     leading and trailing newline-marker and final null.  */
  maxsize = (sizeof (DEFINITION)
             + (limit - p) + 5);
  defn = (DEFINITION *) xcalloc (1, maxsize);

  defn->nargs = nargs;
  exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
  lastp = exp_p;

  p = buf;

  /* Add one initial space escape-marker to prevent accidental
     token-pasting (often removed by macroexpand).  */
  *exp_p++ = '\r';
  *exp_p++ = ' ';

  if (limit - p >= 2 && p[0] == '#' && p[1] == '#')
    {
      cpp_error (pfile, "`##' at start of macro definition");
      p += 2;
    }

  /* Process the main body of the definition.  */
  while (p < limit)
    {
      int skipped_arg = 0;
      register U_CHAR c = *p++;

      *exp_p++ = c;

      if (!CPP_TRADITIONAL (pfile))
        {
          switch (c)
            {
            case '\'':
            case '\"':
              if (expected_delimiter != '\0')
                {
                  if (c == expected_delimiter)
                    expected_delimiter = '\0';
                }
              else
                expected_delimiter = c;
              break;

            case '\\':
              if (p < limit && expected_delimiter)
                {
                  /* In a string, backslash goes through
                     and makes next char ordinary.  */
                  *exp_p++ = *p++;
                }
              break;

            case '#':
              /* # is ordinary inside a string.  */
              if (expected_delimiter)
                break;
              if (p < limit && *p == '#')
                {
                  /* ##: concatenate preceding and following tokens.  */
                  /* Take out the first #, discard preceding whitespace.  */
                  exp_p--;
                  while (exp_p > lastp && is_hor_space[exp_p[-1]])
                    --exp_p;
                  /* Skip the second #.  */
                  p++;
                  /* Discard following whitespace.  */
                  SKIP_WHITE_SPACE (p);
                  concat = p;
                  if (p == limit)
                    cpp_error (pfile, "`##' at end of macro definition");
                }
              else if (nargs >= 0)
                {
                  /* Single #: stringify following argument ref.
                     Don't leave the # in the expansion.  */
                  exp_p--;
                  SKIP_WHITE_SPACE (p);
                  if (p == limit || !is_idstart[*p]
                      || (*p == 'L' && p + 1 < limit && (p[1] == '\'' ||
                                                         p[1] == '"')))
                    cpp_error (pfile,
                "`#' operator is not followed by a macro argument name");
                  else
                    stringify = p;
                }
              break;
            }
        }
      else
        {
          /* In -traditional mode, recognize arguments inside strings and
             character constants, and ignore special properties of #.
             Arguments inside strings are considered "stringified", but no
             extra quote marks are supplied.  */
          switch (c)
            {
            case '\'':
            case '\"':
              if (expected_delimiter != '\0')
                {
                  if (c == expected_delimiter)
                    expected_delimiter = '\0';
                }
              else
                expected_delimiter = c;
              break;

            case '\\':
              /* Backslash quotes delimiters and itself,
                 but not macro args.  */
              if (expected_delimiter != 0 && p < limit
                  && (*p == expected_delimiter || *p == '\\'))
                {
                  *exp_p++ = *p++;
                  continue;
                }
              break;

            case '/':
              if (expected_delimiter != '\0')
                /* No comments inside strings.  */
                break;
              if (*p == '*')
                {
                  /* If we find a comment that wasn't removed by
                     handle_directive, this must be -traditional.
                     So replace the comment with nothing at all.  */
                  exp_p--;
                  p += 1;
                  while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
                    p++;
#if 0
                  /* Mark this as a concatenation-point,
                     as if it had been ##.  */
                  concat = p;
#endif
                }
              break;
            }
        }

      /* Handle the start of a symbol.  */
      if (is_idchar[c] && nargs > 0)
        {
          U_CHAR *id_beg = p - 1;
          int id_len;

          --exp_p;
          while (p != limit && is_idchar[*p])
            p++;
          id_len = p - id_beg;

          if (is_idstart[c]
              && !(id_len == 1 && c == 'L' && (*p == '\'' || *p == '"')))
            {
              register struct arglist *arg;

              for (arg = arglist; arg != NULL; arg = arg->next)
                {
                  struct reflist *tpat;

                  if (arg->name[0] == c
                      && arg->length == id_len
                      && strncmp (arg->name, id_beg, id_len) == 0)
                    {
                      if (expected_delimiter && CPP_OPTIONS
                        (pfile)->warn_stringify)
                        {
                          if (CPP_TRADITIONAL (pfile))
                            {
                              cpp_warning (pfile,
                                       "macro argument `%.*s' is stringified.",
                                           id_len, arg->name);
                            }
                          else
                            {
                              cpp_warning (pfile,
                    "macro arg `%.*s' would be stringified with -traditional.",
                                           id_len, arg->name);
                            }
                        }
                      /* If ANSI, don't actually substitute
                         inside a string.  */
                      if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
                        break;
                      /* make a pat node for this arg and append it
                         to the end of the pat list */
                      tpat = (struct reflist *)
                        xmalloc (sizeof (struct reflist));
                      tpat->next = NULL;
                      tpat->raw_before = concat == id_beg;
                      tpat->raw_after = 0;
                      tpat->rest_args = arg->rest_args;
                      tpat->stringify = (CPP_TRADITIONAL (pfile)
                                         ? expected_delimiter != '\0'
                                         : stringify == id_beg);

                      if (endpat == NULL)
                        defn->pattern = tpat;
                      else
                        endpat->next = tpat;
                      endpat = tpat;

                      tpat->argno = arg->argno;
                      tpat->nchars = exp_p - lastp;
                      {
                        register U_CHAR *p1 = p;
                        SKIP_WHITE_SPACE (p1);
                        if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
                          tpat->raw_after = 1;
                      }
                      lastp = exp_p;
                      skipped_arg = 1;
                      break;
                    }
                }
            }

          /* If this was not a macro arg, copy it into the expansion.  */
          if (!skipped_arg)
            {
              register U_CHAR *lim1 = p;
              p = id_beg;
              while (p != lim1)
                *exp_p++ = *p++;
              if (stringify == id_beg)
                cpp_error (pfile,
                "`#' operator should be followed by a macro argument name");
            }
        }
    }

  if (!CPP_TRADITIONAL (pfile) && expected_delimiter == 0)
    {
      /* If ANSI, put in a "\r " marker to prevent token pasting.
         But not if "inside a string" (which in ANSI mode
         happens only for -D option).  */
      *exp_p++ = '\r';
      *exp_p++ = ' ';
    }

  *exp_p = '\0';

  defn->length = exp_p - defn->expansion;

  /* Crash now if we overrun the allocated size.  */
  if (defn->length + 1 > maxsize)
    abort ();

#if 0
/* This isn't worth the time it takes.  */
  /* give back excess storage */
  defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
#endif

  return defn;
}

/*
 * special extension string that can be added to the last macro argument to 
 * allow it to absorb the "rest" of the arguments when expanded.  Ex:
 *              #define wow(a, b...)            process (b, a, b)
 *              { wow (1, 2, 3); }      ->      { process (2, 3, 1, 2, 3); }
 *              { wow (one, two); }     ->      { process (two, one, two); }
 * if this "rest_arg" is used with the concat token '##' and if it is not
 * supplied then the token attached to with ## will not be outputted.  Ex:
 *              #define wow (a, b...)           process (b ## , a, ## b)
 *              { wow (1, 2); }         ->      { process (2, 1, 2); }
 *              { wow (one); }          ->      { process (one); {
 */
static char rest_extension[] = "...";
#define REST_EXTENSION_LENGTH   (sizeof (rest_extension) - 1)

/* Create a DEFINITION node from a #define directive.  Arguments are 
   as for do_define.  */

MACRODEF
create_definition (buf, limit, pfile, predefinition)
     U_CHAR *buf, *limit;
     cpp_reader *pfile;
     int predefinition;
{
  U_CHAR *bp;                   /* temp ptr into input buffer */
  U_CHAR *symname;              /* remember where symbol name starts */
  int sym_length;               /* and how long it is */
  int rest_args = 0;
  long line, col;
  char *file = CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
  DEFINITION *defn;
  int arglengths = 0;           /* Accumulate lengths of arg names
                                   plus number of args.  */
  MACRODEF mdef;
  cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);

  bp = buf;

  while (is_hor_space[*bp])
    bp++;

  symname = bp;                 /* remember where it starts */

  sym_length = check_macro_name (pfile, bp, 0);
  bp += sym_length;

  /* Lossage will occur if identifiers or control keywords are broken
     across lines using backslash.  This is not the right place to take
     care of that.  */

  if (*bp == '(')
    {
      struct arglist *arg_ptrs = NULL;
      int argno = 0;

      bp++;                     /* skip '(' */
      SKIP_WHITE_SPACE (bp);

      /* Loop over macro argument names.  */
      while (*bp != ')')
        {
          struct arglist *temp;

          temp = (struct arglist *) alloca (sizeof (struct arglist));
          temp->name = bp;
          temp->next = arg_ptrs;
          temp->argno = argno++;
          temp->rest_args = 0;
          arg_ptrs = temp;

          if (rest_args)
            cpp_pedwarn (pfile, "another parameter follows `%s'",
                         rest_extension);

          if (!is_idstart[*bp])
            cpp_pedwarn (pfile, "invalid character in macro parameter name");

          /* Find the end of the arg name.  */
          while (is_idchar[*bp])
            {
              bp++;
              /* do we have a "special" rest-args extension here? */
              if ((size_t) (limit - bp) > REST_EXTENSION_LENGTH
                  && !strncmp (rest_extension, bp, REST_EXTENSION_LENGTH))
                {
                  rest_args = 1;
                  temp->rest_args = 1;
                  break;
                }
            }
          temp->length = bp - temp->name;
          if (rest_args == 1)
            bp += REST_EXTENSION_LENGTH;
          arglengths += temp->length + 2;
          SKIP_WHITE_SPACE (bp);
          if (temp->length == 0 || (*bp != ',' && *bp != ')'))
            {
              cpp_error (pfile,
                         "badly punctuated parameter list in `#define'");
              goto nope;
            }
          if (*bp == ',')
            {
              bp++;
              SKIP_WHITE_SPACE (bp);
            }
          if (bp >= limit)
            {
              cpp_error (pfile, "unterminated parameter list in `#define'");
              goto nope;
            }
          {
            struct arglist *otemp;

            for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
              if (temp->length == otemp->length
                  && strncmp (temp->name, otemp->name, temp->length) == 0)
                {
                  U_CHAR *name;

                  name = (U_CHAR *) alloca (temp->length + 1);
                  (void) strncpy (name, temp->name, temp->length);
                  name[temp->length] = '\0';
                  cpp_error (pfile,
                             "duplicate argument name `%s' in `#define'",
                             name);
                  goto nope;
                }
          }
        }

      ++bp;                     /* skip paren */
      SKIP_WHITE_SPACE (bp);
      /* now everything from bp before limit is the definition.  */
      defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
      defn->rest_args = rest_args;

      /* Now set defn->args.argnames to the result of concatenating
         the argument names in reverse order
         with comma-space between them.  */
      defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
      {
        struct arglist *temp;
        int i = 0;
        for (temp = arg_ptrs; temp; temp = temp->next)
          {
            bcopy (temp->name, &defn->args.argnames[i], temp->length);
            i += temp->length;
            if (temp->next != 0)
              {
                defn->args.argnames[i++] = ',';
                defn->args.argnames[i++] = ' ';
              }
          }
        defn->args.argnames[i] = 0;
      }
    }
  else
    {
      /* Simple expansion or empty definition.  */

      if (bp < limit)
        {
          if (is_hor_space[*bp])
            {
              bp++;
              SKIP_WHITE_SPACE (bp);
            }
          else
            /* Per C9x, missing white space after the name in a #define
               of an object-like macro is always a constraint violation. */
            cpp_pedwarn (pfile,
                         "missing white space after `#define %.*s'",
                         sym_length, symname);
        }
      /* now everything from bp before limit is the definition.  */
      defn = collect_expansion (pfile, bp, limit, -1, NULL_PTR);
      defn->args.argnames = (U_CHAR *) "";
    }

  defn->line = line;
  defn->file = file;

  /* OP is null if this is a predefinition */
  defn->predefined = predefinition;
  mdef.defn = defn;
  mdef.symnam = symname;
  mdef.symlen = sym_length;

  return mdef;

nope:
  mdef.defn = 0;
  return mdef;
}

/*
 * Parse a macro argument and append the info on PFILE's token_buffer.
 * REST_ARGS means to absorb the rest of the args.
 * Return nonzero to indicate a syntax error.
 */

static enum cpp_token
macarg (pfile, rest_args)
     cpp_reader *pfile;
     int rest_args;
{
  int paren = 0;
  enum cpp_token token;
  char save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
  CPP_OPTIONS (pfile)->put_out_comments = 0;

  /* Try to parse as much of the argument as exists at this
     input stack level.  */
  pfile->no_macro_expand++;
  CPP_OPTIONS (pfile)->no_line_commands++;
  for (;;)
    {
      token = cpp_get_token (pfile);
      switch (token)
        {
        case CPP_EOF:
          goto done;
        case CPP_POP:
          /* If we've hit end of file, it's an error (reported by caller).
             Ditto if it's the end of cpp_expand_to_buffer text.
             If we've hit end of macro, just continue.  */
          if (!CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
            goto done;
          break;
        case CPP_LPAREN:
          paren++;
          break;
        case CPP_RPAREN:
          if (--paren < 0)
            goto found;
          break;
        case CPP_COMMA:
          /* if we've returned to lowest level and
             we aren't absorbing all args */
          if (paren == 0 && rest_args == 0)
            goto found;
          break;
        found:
          /* Remove ',' or ')' from argument buffer.  */
          CPP_ADJUST_WRITTEN (pfile, -1);
          goto done;
        default:;
        }
    }

done:
  CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
  CPP_OPTIONS (pfile)->no_line_commands--;
  pfile->no_macro_expand--;

  return token;
}
\f
/* Turn newlines to spaces in the string of length LENGTH at START,
   except inside of string constants.
   The string is copied into itself with its beginning staying fixed.  */

static int
change_newlines (start, length)
     U_CHAR *start;
     int length;
{
  register U_CHAR *ibp;
  register U_CHAR *obp;
  register U_CHAR *limit;
  register int c;

  ibp = start;
  limit = start + length;
  obp = start;

  while (ibp < limit)
    {
      *obp++ = c = *ibp++;
      switch (c)
        {

        case '\'':
        case '\"':
          /* Notice and skip strings, so that we don't
             delete newlines in them.  */
          {
            int quotec = c;
            while (ibp < limit)
              {
                *obp++ = c = *ibp++;
                if (c == quotec)
                  break;
                if (c == '\n' && quotec == '\'')
                  break;
              }
          }
          break;
        }
    }

  return obp - start;
}
\f

static struct tm *
timestamp (pfile)
     cpp_reader *pfile;
{
  if (!pfile->timebuf)
    {
      time_t t = time ((time_t *) 0);
      pfile->timebuf = localtime (&t);
    }
  return pfile->timebuf;
}

static char *monthnames[] =
{
  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
};

/*
 * expand things like __FILE__.  Place the expansion into the output
 * buffer *without* rescanning.
 */

static void
special_symbol (hp, pfile)
     HASHNODE *hp;
     cpp_reader *pfile;
{
  const char *buf;
  int len;
  cpp_buffer *ip;

  switch (hp->type)
    {
    case T_FILE:
    case T_BASE_FILE:
      {
        ip = CPP_BUFFER (pfile);
        if (hp->type == T_BASE_FILE)
          {
            while (CPP_PREV_BUFFER (ip) != CPP_NULL_BUFFER (pfile))
              ip = CPP_PREV_BUFFER (ip);
          }
        else
          {
            ip = CPP_BUFFER (pfile);
            while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
              ip = CPP_PREV_BUFFER (ip);
          }

        buf = ip->nominal_fname;

        if (!buf)
          buf = "";
        CPP_RESERVE (pfile, 3 + 4 * strlen (buf));
        quote_string (pfile, buf);
        return;
      }

    case T_INCLUDE_LEVEL:
      {
        int true_indepth = 0;
        ip = CPP_BUFFER (pfile);
        for (; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
          if (ip->fname != NULL)
            true_indepth++;

        CPP_RESERVE (pfile, 10);
        sprintf (CPP_PWRITTEN (pfile), "%d", true_indepth);
        CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
        return;
      }

    case T_VERSION:
      len = strlen (version_string);
      CPP_RESERVE (pfile, 3 + len);
      CPP_PUTC_Q (pfile, '"');
      CPP_PUTS_Q (pfile, version_string, len);
      CPP_PUTC_Q (pfile, '"');
      CPP_NUL_TERMINATE_Q (pfile);
      return;

    case T_CONST:
      buf = hp->value.cpval;
      if (!buf)
        return;
      if (*buf == '\0')
        buf = "\r ";

      len = strlen (buf);
      CPP_RESERVE (pfile, len + 1);
      CPP_PUTS_Q (pfile, buf, len);
      CPP_NUL_TERMINATE_Q (pfile);
      return;

    case T_STDC:
      CPP_RESERVE (pfile, 2);
#ifdef STDC_0_IN_SYSTEM_HEADERS
      ip = CPP_BUFFER (pfile);
      while (!ip->nominal_fname && ip != CPP_NULL_BUFFER (pfile))
        ip = CPP_PREV_BUFFER (ip);
      if (ip->system_header_p
          && !cpp_lookup (pfile, (U_CHAR *) "__STRICT_ANSI__", 15, -1))
        CPP_PUTC_Q (pfile, '0');
      else
#endif
        CPP_PUTC_Q (pfile, '1');
      CPP_NUL_TERMINATE_Q (pfile);
      return;

    case T_SPECLINE:
      {
        long line;
        cpp_buf_line_and_col (cpp_file_buffer (pfile), &line, NULL);

        CPP_RESERVE (pfile, 10);
        sprintf (CPP_PWRITTEN (pfile), "%ld", line);
        CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
        return;
      }

    case T_DATE:
    case T_TIME:
      {
        struct tm *timebuf;

        CPP_RESERVE (pfile, 20);
        timebuf = timestamp (pfile);
        if (hp->type == T_DATE)
          sprintf (CPP_PWRITTEN (pfile), "\"%s %2d %4d\"",
                   monthnames[timebuf->tm_mon],
                   timebuf->tm_mday, timebuf->tm_year + 1900);
        else
          sprintf (CPP_PWRITTEN (pfile), "\"%02d:%02d:%02d\"",
                   timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);

        CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
        return;
      }

    default:
      cpp_fatal (pfile, "cpplib internal error: invalid special hash type");
      return;
    }
}

/* Expand a macro call.
   HP points to the symbol that is the macro being called.
   Put the result of expansion onto the input stack
   so that subsequent input by our caller will use it.

   If macro wants arguments, caller has already verified that
   an argument list follows; arguments come from the input stack.  */

void
macroexpand (pfile, hp)
     cpp_reader *pfile;
     HASHNODE *hp;
{
  int nargs;
  DEFINITION *defn;
  register U_CHAR *xbuf;
  long start_line, start_column;
  int xbuf_len;
  struct argdata *args;
  long old_written = CPP_WRITTEN (pfile);
#if 0
  int start_line = instack[indepth].lineno;
#endif
  int rest_args, rest_zero;
  register int i;

#if 0
  /* This macro is being used inside a #if, which means it must be */
  /* recorded as a precondition.  */
  if (pcp_inside_if && pcp_outfile && defn->predefined)
    dump_single_macro (hp, pcp_outfile);
#endif

  cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);

  /* Check for and handle special symbols. */
  if (hp->type != T_MACRO)
    {
      special_symbol (hp, pfile);
      xbuf_len = CPP_WRITTEN (pfile) - old_written;
      xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
      CPP_SET_WRITTEN (pfile, old_written);
      bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
      push_macro_expansion (pfile, xbuf, xbuf_len, hp);
      CPP_BUFFER (pfile)->has_escapes = 1;
      return;
    }

  defn = hp->value.defn;
  nargs = defn->nargs;
  pfile->output_escapes++;

  if (nargs >= 0)
    {
      enum cpp_token token = CPP_EOF;

      args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));

      for (i = 0; i < nargs; i++)
        {
          args[i].raw = args[i].expanded = 0;
          args[i].raw_length = 0;
          args[i].expand_length = args[i].stringified_length = -1;
          args[i].use_count = 0;
        }

      /* Parse all the macro args that are supplied.  I counts them.
         The first NARGS args are stored in ARGS.
         The rest are discarded.  If rest_args is set then we assume
         macarg absorbed the rest of the args.  */
      i = 0;
      rest_args = 0;
      rest_args = 0;
      FORWARD (1);      /* Discard open-parenthesis before first arg.  */
      do
        {
          if (rest_args)
            continue;
          if (i < nargs || (nargs == 0 && i == 0))
            {
              /* if we are working on last arg which absorbs rest of args... */
              if (i == nargs - 1 && defn->rest_args)
                rest_args = 1;
              args[i].raw = CPP_WRITTEN (pfile);
              token = macarg (pfile, rest_args);
              args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
              args[i].newlines = 0;     /* FIXME */
            }
          else
            token = macarg (pfile, 0);
          if (token == CPP_EOF || token == CPP_POP)
            {
              cpp_error_with_line (pfile, start_line, start_column,
                                   "unterminated macro call");
              return;
            }
          i++;
        }
      while (token == CPP_COMMA);

      /* If we got one arg but it was just whitespace, call that 0 args.  */
      if (i == 1)
        {
          register U_CHAR *bp = ARG_BASE + args[0].raw;
          register U_CHAR *lim = bp + args[0].raw_length;
          /* cpp.texi says for foo ( ) we provide one argument.
             However, if foo wants just 0 arguments, treat this as 0.  */
          if (nargs == 0)
            while (bp != lim && is_space[*bp])
              bp++;
          if (bp == lim)
            i = 0;
        }

      /* Don't output an error message if we have already output one for
         a parse error above.  */
      rest_zero = 0;
      if (nargs == 0 && i > 0)
        {
          cpp_error (pfile, "arguments given to macro `%s'", hp->name);
        }
      else if (i < nargs)
        {
          /* traditional C allows foo() if foo wants one argument.  */
          if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
            ;
          /* the rest args token is allowed to absorb 0 tokens */
          else if (i == nargs - 1 && defn->rest_args)
            rest_zero = 1;
          else if (i == 0)
            cpp_error (pfile, "macro `%s' used without args", hp->name);
          else if (i == 1)
            cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
          else
            cpp_error (pfile, "macro `%s' used with only %d args",
                       hp->name, i);
        }
      else if (i > nargs)
        {
          cpp_error (pfile,
                     "macro `%s' used with too many (%d) args", hp->name, i);
        }
    }

  /* If macro wants zero args, we parsed the arglist for checking only.
     Read directly from the macro definition.  */
  if (nargs <= 0)
    {
      xbuf = defn->expansion;
      xbuf_len = defn->length;
    }
  else
    {
      register U_CHAR *exp = defn->expansion;
      register int offset;      /* offset in expansion,
                                   copied a piece at a time */
      register int totlen;      /* total amount of exp buffer filled so far */

      register struct reflist *ap, *last_ap;

      /* Macro really takes args.  Compute the expansion of this call.  */

      /* Compute length in characters of the macro's expansion.
         Also count number of times each arg is used.  */
      xbuf_len = defn->length;
      for (ap = defn->pattern; ap != NULL; ap = ap->next)
        {
          if (ap->stringify)
            {
              register struct argdata *arg = &args[ap->argno];
              /* Stringify if it hasn't already been */
              if (arg->stringified_length < 0)
                {
                  int arglen = arg->raw_length;
                  int escaped = 0;
                  int in_string = 0;
                  int c;
                  /* Initially need_space is -1.  Otherwise, 1 means the
                     previous character was a space, but we suppressed it;
                     0 means the previous character was a non-space.  */
                  int need_space = -1;
                  i = 0;
                  arg->stringified = CPP_WRITTEN (pfile);
                  if (!CPP_TRADITIONAL (pfile))
                    CPP_PUTC (pfile, '\"');     /* insert beginning quote */
                  for (; i < arglen; i++)
                    {
                      c = (ARG_BASE + arg->raw)[i];

                      if (!in_string)
                        {
                          /* Internal sequences of whitespace are
                             replaced by one space except within
                             a string or char token. */
                          if (is_space[c])
                            {
                              if (CPP_WRITTEN (pfile) > (unsigned) arg->stringified
                                  && (CPP_PWRITTEN (pfile))[-1] == '\r')
                                {
                                  /* "\r " escape markers are removed */
                                  CPP_ADJUST_WRITTEN (pfile, -1);
                                  continue;
                                }
                              if (need_space == 0)
                                need_space = 1;
                              continue;
                            }
                          else if (need_space > 0)
                            CPP_PUTC (pfile, ' ');
                          need_space = 0;
                        }

                      if (escaped)
                        escaped = 0;
                      else
                        {
                          if (c == '\\')
                            escaped = 1;
                          if (in_string)
                            {
                              if (c == in_string)
                                in_string = 0;
                            }
                          else if (c == '\"' || c == '\'')
                            in_string = c;
                        }

                      /* Escape these chars */
                      if (c == '\"' || (in_string && c == '\\'))
                        CPP_PUTC (pfile, '\\');
                      if (ISPRINT (c))
                        CPP_PUTC (pfile, c);
                      else
                        {
                          CPP_RESERVE (pfile, 4);
                          sprintf ((char *) CPP_PWRITTEN (pfile), "\\%03o",
                                   (unsigned int) c);
                          CPP_ADJUST_WRITTEN (pfile, 4);
                        }
                    }
                  if (!CPP_TRADITIONAL (pfile))
                    CPP_PUTC (pfile, '\"');     /* insert ending quote */
                  arg->stringified_length
                    = CPP_WRITTEN (pfile) - arg->stringified;
                }
              xbuf_len += args[ap->argno].stringified_length;
            }
          else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
            /* Add 4 for two newline-space markers to prevent
               token concatenation.  */
            xbuf_len += args[ap->argno].raw_length + 4;
          else
            {
              /* We have an ordinary (expanded) occurrence of the arg.
                 So compute its expansion, if we have not already.  */
              if (args[ap->argno].expand_length < 0)
                {
                  args[ap->argno].expanded = CPP_WRITTEN (pfile);
                  cpp_expand_to_buffer (pfile,
                                        ARG_BASE + args[ap->argno].raw,
                                        args[ap->argno].raw_length);

                  args[ap->argno].expand_length
                    = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
                }

              /* Add 4 for two newline-space markers to prevent
                 token concatenation.  */
              xbuf_len += args[ap->argno].expand_length + 4;
            }
          if (args[ap->argno].use_count < 10)
            args[ap->argno].use_count++;
        }

      xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);

      /* Generate in XBUF the complete expansion
         with arguments substituted in.
         TOTLEN is the total size generated so far.
         OFFSET is the index in the definition
         of where we are copying from.  */
      offset = totlen = 0;
      for (last_ap = NULL, ap = defn->pattern; ap != NULL;
           last_ap = ap, ap = ap->next)
        {
          register struct argdata *arg = &args[ap->argno];
          int count_before = totlen;

          /* Add chars to XBUF.  */
          for (i = 0; i < ap->nchars; i++, offset++)
            xbuf[totlen++] = exp[offset];

          /* If followed by an empty rest arg with concatenation,
             delete the last run of nonwhite chars.  */
          if (rest_zero && totlen > count_before
              && ((ap->rest_args && ap->raw_before)
                  || (last_ap != NULL && last_ap->rest_args
                      && last_ap->raw_after)))
            {
              /* Delete final whitespace.  */
              while (totlen > count_before && is_space[xbuf[totlen - 1]])
                totlen--;

              /* Delete the nonwhites before them.  */
              while (totlen > count_before && !is_space[xbuf[totlen - 1]])
                totlen--;
            }

          if (ap->stringify != 0)
            {
              bcopy (ARG_BASE + arg->stringified,
                     xbuf + totlen, arg->stringified_length);
              totlen += arg->stringified_length;
            }
          else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
            {
              U_CHAR *p1 = ARG_BASE + arg->raw;
              U_CHAR *l1 = p1 + arg->raw_length;
              if (ap->raw_before)
                {
                  while (p1 != l1 && is_space[*p1])
                    p1++;
                  while (p1 != l1 && is_idchar[*p1])
                    xbuf[totlen++] = *p1++;
                }
              if (ap->raw_after)
                {
                  /* Arg is concatenated after: delete trailing whitespace,
                     whitespace markers, and no-reexpansion markers.  */
                  while (p1 != l1)
                    {
                      if (is_space[l1[-1]])
                        l1--;
                      else if (l1[-1] == '\r')
                        l1--;
                      else if (l1[-1] == '-')
                        {
                          if (l1 != p1 + 1 && l1[-2] == '\r')
                            l1 -= 2;
                          else
                            break;
                        }
                      else
                        break;
                    }
                }

              /* Delete any no-reexpansion marker that precedes
                 an identifier at the beginning of the argument. */
              if (p1[0] == '\r' && p1[1] == '-')
                p1 += 2;

              bcopy (p1, xbuf + totlen, l1 - p1);
              totlen += l1 - p1;
            }
          else
            {
              U_CHAR *expanded = ARG_BASE + arg->expanded;
              if (!ap->raw_before && totlen > 0 && arg->expand_length
                  && !CPP_TRADITIONAL (pfile)
                  && unsafe_chars (xbuf[totlen - 1], expanded[0]))
                {
                  xbuf[totlen++] = '\r';
                  xbuf[totlen++] = ' ';
                }

              bcopy (expanded, xbuf + totlen, arg->expand_length);
              totlen += arg->expand_length;

              if (!ap->raw_after && totlen > 0 && offset < defn->length
                  && !CPP_TRADITIONAL (pfile)
                  && unsafe_chars (xbuf[totlen - 1], exp[offset]))
                {
                  xbuf[totlen++] = '\r';
                  xbuf[totlen++] = ' ';
                }

              /* If a macro argument with newlines is used multiple times,
                 then only expand the newlines once.  This avoids creating
                 output lines which don't correspond to any input line,
                 which confuses gdb and gcov.  */
              if (arg->use_count > 1 && arg->newlines > 0)
                {
                  /* Don't bother doing change_newlines for subsequent
                     uses of arg.  */
                  arg->use_count = 1;
                  arg->expand_length
                    = change_newlines (expanded, arg->expand_length);
                }
            }

          if (totlen > xbuf_len)
            {
              cpp_fatal (pfile, "internal_error: buffer overrun in macroexpand");
              return;
            }
        }

      /* if there is anything left of the definition
         after handling the arg list, copy that in too.  */

      for (i = offset; i < defn->length; i++)
        {
          /* if we've reached the end of the macro */
          if (exp[i] == ')')
            rest_zero = 0;
          if (!(rest_zero && last_ap != NULL && last_ap->rest_args
                && last_ap->raw_after))
            xbuf[totlen++] = exp[i];
        }

      xbuf[totlen] = 0;
      xbuf_len = totlen;

    }

  pfile->output_escapes--;

  /* Now put the expansion on the input stack
     so our caller will commence reading from it.  */
  push_macro_expansion (pfile, xbuf, xbuf_len, hp);
  CPP_BUFFER (pfile)->has_escapes = 1;

  /* Pop the space we've used in the token_buffer for argument expansion.  */
  CPP_SET_WRITTEN (pfile, old_written);

  /* Recursive macro use sometimes works traditionally.
     #define foo(x,y) bar (x (y,0), y)
     foo (foo, baz)  */

  if (!CPP_TRADITIONAL (pfile))
    hp->type = T_DISABLED;
}

/* Return 1 iff a token ending in C1 followed directly by a token C2
   could cause mis-tokenization.  */

static int
unsafe_chars (c1, c2)
     int c1, c2;
{
  switch (c1)
    {
    case '+':
    case '-':
      if (c2 == c1 || c2 == '=')
        return 1;
      goto letter;

    case '.':    case '0':    case '1':    case '2':    case '3':
    case '4':    case '5':    case '6':    case '7':    case '8':
    case '9':    case 'e':    case 'E':    case 'p':    case 'P':
      if (c2 == '-' || c2 == '+')
        return 1;               /* could extend a pre-processing number */
      goto letter;

    case 'L':
      if (c2 == '\'' || c2 == '\"')
        return 1;               /* Could turn into L"xxx" or L'xxx'.  */
      goto letter;

    case '_':  case 'a':  case 'b':  case 'c':  case 'd':  case 'f':
    case 'g':  case 'h':  case 'i':  case 'j':  case 'k':  case 'l':
    case 'm':  case 'n':  case 'o':  case 'q':  case 'r':  case 's':
    case 't':  case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
    case 'z':  case 'A':  case 'B':  case 'C':  case 'D':  case 'F':
    case 'G':  case 'H':  case 'I':  case 'J':  case 'K':  case 'M':
    case 'N':  case 'O':  case 'Q':  case 'R':  case 'S':  case 'T':
    case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':  case 'Z':
    letter:
    /* We're in the middle of either a name or a pre-processing number.  */
      return (is_idchar[c2] || c2 == '.');

    case '<':  case '>':  case '!':  case '%':  case '#':  case ':':
    case '^':  case '&':  case '|':  case '*':  case '/':  case '=':
      return (c2 == c1 || c2 == '=');
    }
  return 0;
}

static void
push_macro_expansion (pfile, xbuf, xbuf_len, hp)
     cpp_reader *pfile;
     register U_CHAR *xbuf;
     int xbuf_len;
     HASHNODE *hp;
{
  register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
  if (mbuf == NULL)
    return;
  mbuf->cleanup = macro_cleanup;
  mbuf->data = hp;

  /* The first chars of the expansion should be a "\r " added by
     collect_expansion.  This is to prevent accidental token-pasting
     between the text preceding the macro invocation, and the macro
     expansion text.

     We would like to avoid adding unneeded spaces (for the sake of
     tools that use cpp, such as imake).  In some common cases we can
     tell that it is safe to omit the space.

     The character before the macro invocation cannot have been an
     idchar (or else it would have been pasted with the idchars of
     the macro name).  Therefore, if the first non-space character
     of the expansion is an idchar, we do not need the extra space
     to prevent token pasting.

     Also, we don't need the extra space if the first char is '(',
     or some other (less common) characters.  */

  if (xbuf[0] == '\r' && xbuf[1] == ' '
      && (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
          || xbuf[2] == '\"'))
    mbuf->cur += 2;

  /* Likewise, avoid the extra space at the end of the macro expansion
     if this is safe.  We can do a better job here since we can know
     what the next char will be.  */
  if (xbuf_len >= 3
      && mbuf->rlimit[-2] == '\r'
      && mbuf->rlimit[-1] == ' ')
    {
      int c1 = mbuf->rlimit[-3];
      int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
      if (c2 == EOF || !unsafe_chars (c1, c2))
        mbuf->rlimit -= 2;
    }
}

/* Return zero if two DEFINITIONs are isomorphic.  */

int
compare_defs (pfile, d1, d2)
     cpp_reader *pfile;
     DEFINITION *d1, *d2;
{
  register struct reflist *a1, *a2;
  register U_CHAR *p1 = d1->expansion;
  register U_CHAR *p2 = d2->expansion;
  int first = 1;

  if (d1->nargs != d2->nargs)
    return 1;
  if (CPP_PEDANTIC (pfile)
      && strcmp ((char *) d1->args.argnames, (char *) d2->args.argnames))
    return 1;
  for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
       a1 = a1->next, a2 = a2->next)
    {
      if (!((a1->nchars == a2->nchars && !strncmp (p1, p2, a1->nchars))
            || !comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
          || a1->argno != a2->argno
          || a1->stringify != a2->stringify
          || a1->raw_before != a2->raw_before
          || a1->raw_after != a2->raw_after)
        return 1;
      first = 0;
      p1 += a1->nchars;
      p2 += a2->nchars;
    }
  if (a1 != a2)
    return 1;

  return comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
                        p2, d2->length - (p2 - d2->expansion), 1);
}

/* Return 1 if two parts of two macro definitions are effectively different.
   One of the parts starts at BEG1 and has LEN1 chars;
   the other has LEN2 chars at BEG2.
   Any sequence of whitespace matches any other sequence of whitespace.
   FIRST means these parts are the first of a macro definition;
    so ignore leading whitespace entirely.
   LAST means these parts are the last of a macro definition;
    so ignore trailing whitespace entirely.  */

static int
comp_def_part (first, beg1, len1, beg2, len2, last)
     int first;
     U_CHAR *beg1, *beg2;
     int len1, len2;
     int last;
{
  register U_CHAR *end1 = beg1 + len1;
  register U_CHAR *end2 = beg2 + len2;
  if (first)
    {
      while (beg1 != end1 && is_space[*beg1])
        beg1++;
      while (beg2 != end2 && is_space[*beg2])
        beg2++;
    }
  if (last)
    {
      while (beg1 != end1 && is_space[end1[-1]])
        end1--;
      while (beg2 != end2 && is_space[end2[-1]])
        end2--;
    }
  while (beg1 != end1 && beg2 != end2)
    {
      if (is_space[*beg1] && is_space[*beg2])
        {
          while (beg1 != end1 && is_space[*beg1])
            beg1++;
          while (beg2 != end2 && is_space[*beg2])
            beg2++;
        }
      else if (*beg1 == *beg2)
        {
          beg1++;
          beg2++;
        }
      else
        break;
    }
  return (beg1 != end1) || (beg2 != end2);
}

/* Dump the definition of macro MACRO on stdout.  The format is suitable
   to be read back in again. */

void
dump_definition (pfile, macro)
     cpp_reader *pfile;
     MACRODEF macro;
{
  DEFINITION *defn = macro.defn;

  CPP_RESERVE (pfile, macro.symlen + sizeof "#define ");
  CPP_PUTS_Q (pfile, "#define ", sizeof "#define " -1);
  CPP_PUTS_Q (pfile, macro.symnam, macro.symlen);

  if (defn->nargs == -1)
    {
      CPP_PUTC_Q (pfile, ' ');

      /* The first and last two characters of a macro expansion are
         always "\r "; this needs to be trimmed out.
         So we need length-4 chars of space, plus one for the NUL.  */
      CPP_RESERVE (pfile, defn->length - 4 + 1);
      CPP_PUTS_Q (pfile, defn->expansion + 2, defn->length - 4);
      CPP_NUL_TERMINATE_Q (pfile);
    }
  else
    {
      struct reflist *r;
      unsigned char *argnames = (unsigned char *) xstrdup (defn->args.argnames);
      unsigned char **argv = (unsigned char **) alloca (defn->nargs *
                                                        sizeof(char *));
      int *argl = (int *) alloca (defn->nargs * sizeof(int));
      unsigned char *x;
      int i;

      /* First extract the argument list. */
      x = argnames;
      i = defn->nargs;
      while (i--)
        {
          argv[i] = x;
          while (*x != ',' && *x != '\0') x++;
          argl[i] = x - argv[i];
          if (*x == ',')
            {
              *x = '\0';
              x += 2;  /* skip the space after the comma */
            }
        }
      
      /* Now print out the argument list. */
      CPP_PUTC_Q (pfile, '(');
      for (i = 0; i < defn->nargs; i++)
        {
          CPP_RESERVE (pfile, argl[i] + 2);
          CPP_PUTS_Q (pfile, argv[i], argl[i]);
          if (i < defn->nargs-1)
            CPP_PUTS_Q (pfile, ", ", 2);
        }

      if (defn->rest_args)
        CPP_PUTS (pfile, "...) ", 5);
      else
        CPP_PUTS (pfile, ") ", 2);

      /* Now the definition. */
      x = defn->expansion;
      for (r = defn->pattern; r; r = r->next)
      {
        i = r->nchars;
        if (*x == '\r') x += 2, i -= 2;
        /* i chars for macro text, plus the length of the macro
           argument name, plus one for a stringify marker, plus two for
           each concatenation marker. */
        CPP_RESERVE (pfile,
                     i + argl[r->argno] + r->stringify
                     + (r->raw_before + r->raw_after) * 2);

        if (i > 0) CPP_PUTS_Q (pfile, x, i);
        if (r->raw_before)
          CPP_PUTS_Q (pfile, "##", 2);
        if (r->stringify)
          CPP_PUTC_Q (pfile, '#');
        CPP_PUTS_Q (pfile, argv[r->argno], argl[r->argno]);
        if (r->raw_after && !(r->next && r->next->nchars == 0
                              && r->next->raw_before))
          CPP_PUTS_Q (pfile, "##", 2);

        x += i;
      }

      i = defn->length - (x - defn->expansion) - 2;
      if (*x == '\r') x += 2, i -= 2;
      if (i > 0) CPP_PUTS (pfile, x, i);
      CPP_NUL_TERMINATE (pfile);
    }
}