cppexp.c: Don't include cpphash.h.

[gcc.git] / gcc / cpplib.c

/* CPP Library.
   Copyright (C) 1986, 87, 89, 92-99, 2000 Free Software Foundation, Inc.
   Contributed by Per Bothner, 1994-95.
   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.  */

#include "config.h"
#include "system.h"

#include "cpplib.h"
#include "cpphash.h"
#include "intl.h"

#define SKIP_WHITE_SPACE(p) do { while (is_hspace(*p)) p++; } while (0)

#define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
#define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
#define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
#define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
/* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
   (Note that it is false while we're expanding macro *arguments*.) */
#define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)

/* ACTIVE_MARK_P is true if there's a live mark in the buffer, in which
   case CPP_BUMP_LINE must not be called.  */
#define ACTIVE_MARK_P() (CPP_BUFFER (pfile)->mark != -1)

/* External declarations.  */

extern HOST_WIDEST_INT cpp_parse_expr PARAMS ((cpp_reader *));

/* `struct directive' defines one #-directive, including how to handle it.  */

struct directive {
  int length;                   /* Length of name */
  int (*func)                   /* Function to handle directive */
    PARAMS ((cpp_reader *, const struct directive *));
  const char *name;             /* Name of directive */
  enum node_type type;          /* Code which describes which directive.  */
};

/* These functions are declared to return int instead of void since they
   are going to be placed in a table and some old compilers have trouble with
   pointers to functions returning void.  */

static int do_define PARAMS ((cpp_reader *, const struct directive *));
static int do_line PARAMS ((cpp_reader *, const struct directive *));
static int do_include PARAMS ((cpp_reader *, const struct directive *));
static int do_undef PARAMS ((cpp_reader *, const struct directive *));
static int do_error PARAMS ((cpp_reader *, const struct directive *));
static int do_pragma PARAMS ((cpp_reader *, const struct directive *));
static int do_ident PARAMS ((cpp_reader *, const struct directive *));
static int do_if PARAMS ((cpp_reader *, const struct directive *));
static int do_xifdef PARAMS ((cpp_reader *, const struct directive *));
static int do_else PARAMS ((cpp_reader *, const struct directive *));
static int do_elif PARAMS ((cpp_reader *, const struct directive *));
static int do_endif PARAMS ((cpp_reader *, const struct directive *));
#ifdef SCCS_DIRECTIVE
static int do_sccs PARAMS ((cpp_reader *, const struct directive *));
#endif
static int do_assert PARAMS ((cpp_reader *, const struct directive *));
static int do_unassert PARAMS ((cpp_reader *, const struct directive *));
static int do_warning PARAMS ((cpp_reader *, const struct directive *));

/* Forward declarations.  */

static void validate_else               PARAMS ((cpp_reader *, const char *));
static HOST_WIDEST_INT eval_if_expression PARAMS ((cpp_reader *));
static void conditional_skip            PARAMS ((cpp_reader *, int,
                                                enum node_type, U_CHAR *));
static void skip_if_group               PARAMS ((cpp_reader *));
static void parse_name                  PARAMS ((cpp_reader *, int));
static void parse_string                PARAMS ((cpp_reader *, int));
static int parse_assertion              PARAMS ((cpp_reader *));
static const char *if_directive_name    PARAMS ((cpp_reader *,
                                                 struct if_stack *));
static enum cpp_token null_underflow    PARAMS ((cpp_reader *));
static int null_cleanup                 PARAMS ((cpp_buffer *, cpp_reader *));
static int skip_comment                 PARAMS ((cpp_reader *, int));
static int copy_comment                 PARAMS ((cpp_reader *, int));
static void copy_rest_of_line           PARAMS ((cpp_reader *));
static void skip_rest_of_line           PARAMS ((cpp_reader *));
static void cpp_skip_hspace             PARAMS ((cpp_reader *));
static int handle_directive             PARAMS ((cpp_reader *));
static void pass_thru_directive         PARAMS ((const U_CHAR *, size_t,
                                                 cpp_reader *,
                                                 const struct directive *));
static int read_line_number             PARAMS ((cpp_reader *, int *));
static U_CHAR *detect_if_not_defined    PARAMS ((cpp_reader *));
static int consider_directive_while_skipping PARAMS ((cpp_reader *,
                                                      IF_STACK_FRAME *));
static void skip_block_comment          PARAMS ((cpp_reader *));
static void skip_line_comment           PARAMS ((cpp_reader *));
static void parse_set_mark              PARAMS ((cpp_reader *));
static void parse_goto_mark             PARAMS ((cpp_reader *));

/* Here is the actual list of #-directives.
   This table is ordered by frequency of occurrence; the numbers
   at the end are directive counts from all the source code I have
   lying around (egcs and libc CVS as of 1999-05-18, plus grub-0.5.91,
   linux-2.2.9, and pcmcia-cs-3.0.9).  */

static const struct directive directive_table[] = {
  /* In C89 */
  {  6, do_define,   "define",       T_DEFINE },        /* 270554 */
  {  7, do_include,  "include",      T_INCLUDE },       /*  52262 */
  {  5, do_endif,    "endif",        T_ENDIF },         /*  45855 */
  {  5, do_xifdef,   "ifdef",        T_IFDEF },         /*  22000 */
  {  2, do_if,       "if",           T_IF },            /*  18162 */
  {  4, do_else,     "else",         T_ELSE },          /*   9863 */
  {  6, do_xifdef,   "ifndef",       T_IFNDEF },        /*   9675 */
  {  5, do_undef,    "undef",        T_UNDEF },         /*   4837 */
  {  4, do_line,     "line",         T_LINE },          /*   2465 */
  {  4, do_elif,     "elif",         T_ELIF },          /*    610 */
  {  5, do_error,    "error",        T_ERROR },         /*    475 */
  {  6, do_pragma,   "pragma",       T_PRAGMA },        /*    195 */

  /* Extensions.  All deprecated except #warning and #include_next.  */
  {  7, do_warning,  "warning",      T_WARNING },       /*     22 - GNU   */
  { 12, do_include,  "include_next", T_INCLUDE_NEXT },  /*     19 - GNU   */
  {  5, do_ident,    "ident",        T_IDENT },         /*     11 - SVR4  */
  {  6, do_include,  "import",       T_IMPORT },        /*      0 - ObjC  */
  {  6, do_assert,   "assert",       T_ASSERT },        /*      0 - SVR4  */
  {  8, do_unassert, "unassert",     T_UNASSERT },      /*      0 - SVR4  */
#ifdef SCCS_DIRECTIVE
  {  4, do_sccs,     "sccs",         T_SCCS },          /*      0 - SVR2? */
#endif
  {  -1, 0, "", T_UNUSED }
};

/* Place into PFILE a quoted string representing the string SRC.
   Caller must reserve enough space in pfile->token_buffer.  */

void
quote_string (pfile, src)
     cpp_reader *pfile;
     const char *src;
{
  U_CHAR c;

  CPP_PUTC_Q (pfile, '\"');
  for (;;)
    switch ((c = *src++))
      {
      default:
        if (ISPRINT (c))
          CPP_PUTC_Q (pfile, c);
        else
          {
            sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o", c);
            CPP_ADJUST_WRITTEN (pfile, 4);
          }
        break;

      case '\"':
      case '\\':
        CPP_PUTC_Q (pfile, '\\');
        CPP_PUTC_Q (pfile, c);
        break;
      
      case '\0':
        CPP_PUTC_Q (pfile, '\"');
        CPP_NUL_TERMINATE_Q (pfile);
        return;
      }
}

/* Re-allocates PFILE->token_buffer so it will hold at least N more chars.  */

void
cpp_grow_buffer (pfile, n)
     cpp_reader *pfile;
     long n;
{
  long old_written = CPP_WRITTEN (pfile);
  pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
  pfile->token_buffer = (U_CHAR *)
    xrealloc(pfile->token_buffer, pfile->token_buffer_size);
  CPP_SET_WRITTEN (pfile, old_written);
}

/* Process the string STR as if it appeared as the body of a #define.
   If STR is just an identifier, define it with value 1.
   If STR has anything after the identifier, then it should
   be identifier=definition. */

void
cpp_define (pfile, str)
     cpp_reader *pfile;
     U_CHAR *str;
{
  U_CHAR *buf, *p;
  size_t count;

  p = strchr (str, '=');
  /* Copy the entire option so we can modify it. 
     Change the first "=" in the string to a space.  If there is none,
     tack " 1" on the end.  Then add a newline and a NUL.  */
  
  if (p)
    {
      count = strlen (str) + 2;
      buf = (U_CHAR *) alloca (count);
      memcpy (buf, str, count - 2);
      buf[p - str] = ' ';
      buf[count - 2] = '\n';
      buf[count - 1] = '\0';
    }
  else
    {
      count = strlen (str) + 4;
      buf = (U_CHAR *) alloca (count);
      memcpy (buf, str, count - 4);
      strcpy (&buf[count-4], " 1\n");
    }

  if (cpp_push_buffer (pfile, buf, count - 1) != NULL)
    {
      do_define (pfile, NULL);
      cpp_pop_buffer (pfile);
    }
}

/* Process the string STR as if it appeared as the body of a #assert. */
void
cpp_assert (pfile, str)
     cpp_reader *pfile;
     U_CHAR *str;
{
  if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
    {
      do_assert (pfile, NULL);
      cpp_pop_buffer (pfile);
    }
}

/* Determine whether the identifier ID, of length LEN, is a defined macro.  */
int
cpp_defined (pfile, id, len)
     cpp_reader *pfile;
     const U_CHAR *id;
     int len;
{
  HASHNODE *hp = cpp_lookup (pfile, id, len);
  if (hp && hp->type == T_POISON)
    {
      cpp_error (pfile, "attempt to use poisoned `%s'", hp->name);
      return 0;
    }
  return (hp != NULL);
}

static enum cpp_token
null_underflow (pfile)
     cpp_reader *pfile ATTRIBUTE_UNUSED;
{
  return CPP_EOF;
}

static int
null_cleanup (pbuf, pfile)
     cpp_buffer *pbuf ATTRIBUTE_UNUSED;
     cpp_reader *pfile ATTRIBUTE_UNUSED;
{
  return 0;
}

/* Skip a C-style block comment.  We know it's a comment, and point is
   at the second character of the starter.  */
static void
skip_block_comment (pfile)
     cpp_reader *pfile;
{
  int c, prev_c = -1;
  long line, col;

  FORWARD(1);
  cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
  for (;;)
    {
      c = GETC ();
      if (c == EOF)
        {
          cpp_error_with_line (pfile, line, col, "unterminated comment");
          return;
        }
      else if (c == '\n' || c == '\r')
        {
          /* \r cannot be a macro escape marker here. */
          if (!ACTIVE_MARK_P())
            CPP_BUMP_LINE (pfile);
        }
      else if (c == '/' && prev_c == '*')
        return;
      else if (c == '*' && prev_c == '/'
               && CPP_OPTIONS (pfile)->warn_comments)
        cpp_warning (pfile, "`/*' within comment");

      prev_c = c;
    }
}

/* Skip a C++/Chill line comment.  We know it's a comment, and point
   is at the second character of the initiator.  */
static void
skip_line_comment (pfile)
     cpp_reader *pfile;
{
  FORWARD(1);
  for (;;)
    {
      int c = GETC ();

      /* We don't have to worry about EOF in here.  */
      if (c == '\n')
        {
          /* Don't consider final '\n' to be part of comment.  */
          FORWARD(-1);
          return;
        }
      else if (c == '\r')
        {
          /* \r cannot be a macro escape marker here. */
          if (!ACTIVE_MARK_P())
            CPP_BUMP_LINE (pfile);
          if (CPP_OPTIONS (pfile)->warn_comments)
            cpp_warning (pfile, "backslash-newline within line comment");
        }
    }
}

/* Skip a comment - C, C++, or Chill style.  M is the first character
   of the comment marker.  If this really is a comment, skip to its
   end and return ' '.  If this is not a comment, return M (which will
   be '/' or '-').  */

static int
skip_comment (pfile, m)
     cpp_reader *pfile;
     int m;
{
  if (m == '/' && PEEKC() == '*')
    {
      skip_block_comment (pfile);
      return ' ';
    }
  else if (m == '/' && PEEKC() == '/')
    {
      if (CPP_BUFFER (pfile)->system_header_p)
        {
          /* We silently allow C++ comments in system headers, irrespective
             of conformance mode, because lots of busted systems do that
             and trying to clean it up in fixincludes is a nightmare.  */
          skip_line_comment (pfile);
          return ' ';
        }
      else if (CPP_OPTIONS (pfile)->cplusplus_comments)
        {
          if (CPP_OPTIONS (pfile)->c89
              && CPP_PEDANTIC (pfile)
              && ! CPP_BUFFER (pfile)->warned_cplusplus_comments)
            {
              cpp_pedwarn (pfile,
                           "C++ style comments are not allowed in ISO C89");
              cpp_pedwarn (pfile,
                           "(this will be reported only once per input file)");
              CPP_BUFFER (pfile)->warned_cplusplus_comments = 1;
            }
          skip_line_comment (pfile);
          return ' ';
        }
      else
        return m;
    }
  else if (m == '-' && PEEKC() == '-'
           && CPP_OPTIONS (pfile)->chill)
    {
      skip_line_comment (pfile);
      return ' ';
    }
  else
    return m;
}

/* Identical to skip_comment except that it copies the comment into the
   token_buffer.  This is used if !discard_comments.  */
static int
copy_comment (pfile, m)
     cpp_reader *pfile;
     int m;
{
  U_CHAR *start = CPP_BUFFER (pfile)->cur;  /* XXX Layering violation */
  U_CHAR *limit;

  if (skip_comment (pfile, m) == m)
    return m;

  CPP_PUTC (pfile, m);
  for (limit = CPP_BUFFER (pfile)->cur; start <= limit; start++)
    if (*start != '\r')
      CPP_PUTC (pfile, *start);
  return ' ';
}

/* Skip whitespace \-newline and comments.  Does not macro-expand.  */

static void
cpp_skip_hspace (pfile)
     cpp_reader *pfile;
{
  int c;
  while (1)
    {
      c = GETC();
      if (c == EOF)
        return;
      else if (is_hspace(c))
        {
          if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
            cpp_pedwarn (pfile, "%s in preprocessing directive",
                         c == '\f' ? "formfeed" : "vertical tab");
        }
      else if (c == '\r')
        {
          /* \r is a backslash-newline marker if !has_escapes, and
             a deletable-whitespace or no-reexpansion marker otherwise. */
          if (CPP_BUFFER (pfile)->has_escapes)
            {
              if (PEEKC() == ' ')
                FORWARD(1);
              else
                break;
            }
          else
            CPP_BUFFER (pfile)->lineno++;
        }
      else if (c == '/' || c == '-')
        {
          c = skip_comment (pfile, c);
          if (c  != ' ')
            break;
        }
      else
        break;
    }
  FORWARD(-1);
}

/* Read the rest of the current line.
   The line is appended to PFILE's output buffer.  */

static void
copy_rest_of_line (pfile)
     cpp_reader *pfile;
{
  for (;;)
    {
      int c = GETC();
      switch (c)
        {
        case '\n':
          FORWARD(-1);
        case EOF:
          CPP_NUL_TERMINATE (pfile);
          return;

        case '\r':
          if (CPP_BUFFER (pfile)->has_escapes)
            break;
          else
            {
              CPP_BUFFER (pfile)->lineno++;
              continue;
            }
        case '\'':
        case '\"':
          parse_string (pfile, c);
          continue;
        case '/':
          if (PEEKC() == '*')
            {
              if (CPP_TRADITIONAL (pfile))
                CPP_PUTS (pfile, "/**/", 4);
              skip_block_comment (pfile);
              continue;
            }
          /* else fall through */
        case '-':
          c = skip_comment (pfile, c);
          break;

        case '\f':
        case '\v':
          if (CPP_PEDANTIC (pfile))
            cpp_pedwarn (pfile, "%s in preprocessing directive",
                         c == '\f' ? "formfeed" : "vertical tab");
          break;

        }
      CPP_PUTC (pfile, c);
    }
}

/* FIXME: It is almost definitely a performance win to make this do
   the scan itself.  >75% of calls to copy_r_o_l are from here or
   skip_if_group, which means the common case is to copy stuff into the
   token_buffer only to discard it.  */
static void
skip_rest_of_line (pfile)
     cpp_reader *pfile;
{
  long old = CPP_WRITTEN (pfile);
  copy_rest_of_line (pfile);
  CPP_SET_WRITTEN (pfile, old);
}

/* Handle a possible # directive.
   '#' has already been read.  */

static int
handle_directive (pfile)
     cpp_reader *pfile;
{
  int c;
  register const struct directive *kt;
  int ident_length;
  U_CHAR *ident;
  long old_written = CPP_WRITTEN (pfile);

  cpp_skip_hspace (pfile);

  c = PEEKC ();
  /* # followed by a number is equivalent to #line.  Do not recognize
     this form in assembly language source files.  Complain about this
     form if we're being pedantic, but not if this is regurgitated
     input (preprocessed or fed back in by the C++ frontend).  */
  if (c >= '0' && c <= '9')
    {
      if (CPP_OPTIONS (pfile)->lang_asm)
        return 0;

      if (CPP_PEDANTIC (pfile)
          && ! CPP_PREPROCESSED (pfile)
          && ! CPP_BUFFER (pfile)->manual_pop)
        cpp_pedwarn (pfile, "`#' followed by integer");
      do_line (pfile, NULL);
      return 1;
    }

  /* If we are rescanning preprocessed input, don't obey any directives
     other than # nnn.  */
  if (CPP_PREPROCESSED (pfile))
    return 0;

  /* Now find the directive name.  */
  CPP_PUTC (pfile, '#');
  parse_name (pfile, GETC());
  ident = pfile->token_buffer + old_written + 1;
  ident_length = CPP_PWRITTEN (pfile) - ident;
  if (ident_length == 0)
    {
      /* A line of just `#' becomes blank.  A line with something
         other than an identifier after the # is reparsed as a non-
         directive line.  */
      CPP_SET_WRITTEN (pfile, old_written);
      return (PEEKC() == '\n');
    }

  /* Decode the keyword and call the appropriate expansion routine.  */
  for (kt = directive_table; ; kt++)
    {
      if (kt->length <= 0)
        /* # identifier, but not a legit directive.  Pass onward as a
           CPP_DIRECTIVE token anyway - let the consumer worry about it.  */
        return 1;
      if (kt->length == ident_length
          && !strncmp (kt->name, ident, ident_length)) 
        break;
    }

  CPP_SET_WRITTEN (pfile, old_written);

  if (pfile->no_directives)
    {
      cpp_error (pfile, "`#%s' may not be used inside a macro argument",
                 kt->name);
      skip_rest_of_line (pfile);
    }
  else
    (*kt->func) (pfile, kt);

  return 1;
}

/* Pass a directive through to the output file.
   BUF points to the contents of the directive, as a contiguous string.
   LEN is the length of the string pointed to by BUF.
   KEYWORD is the keyword-table entry for the directive.  */

static void
pass_thru_directive (buf, len, pfile, keyword)
     const U_CHAR *buf;
     size_t len;
     cpp_reader *pfile;
     const struct directive *keyword;
{
  register unsigned keyword_length = keyword->length;

  CPP_RESERVE (pfile, 1 + keyword_length + len);
  CPP_PUTC_Q (pfile, '#');
  CPP_PUTS_Q (pfile, keyword->name, keyword_length);
  if (len != 0 && buf[0] != ' ')
    CPP_PUTC_Q (pfile, ' ');
  CPP_PUTS_Q (pfile, buf, len);
}

/* Check a purported macro name SYMNAME, and yield its length.  */

int
check_macro_name (pfile, symname)
     cpp_reader *pfile;
     const U_CHAR *symname;
{
  const U_CHAR *p;
  int sym_length;

  for (p = symname; is_idchar(*p); p++)
    ;
  sym_length = p - symname;
  if (sym_length == 0
      || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
    cpp_error (pfile, "invalid macro name");
  else if (!is_idstart(*symname)
           || (! strncmp (symname, "defined", 7) && sym_length == 7)) {
    U_CHAR *msg;                        /* what pain...  */
    msg = (U_CHAR *) alloca (sym_length + 1);
    bcopy (symname, msg, sym_length);
    msg[sym_length] = 0;
    cpp_error (pfile, "invalid macro name `%s'", msg);
  }
  return sym_length;
}

/* Process a #define command.
   KEYWORD is the keyword-table entry for #define,
   or NULL for a "predefined" macro,
   or the keyword-table entry for #pragma in the case of a #pragma poison.  */

static int
do_define (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword;
{
  MACRODEF mdef;
  HASHNODE *hp;
  long here;
  U_CHAR *macro, *buf, *end;
  enum node_type new_type;

  here = CPP_WRITTEN (pfile);
  copy_rest_of_line (pfile);

  if (keyword == NULL || keyword->type == T_DEFINE)
    new_type = T_MACRO;
  else
    new_type = T_POISON;

  /* Copy out the line so we can pop the token buffer. */
  buf = pfile->token_buffer + here;
  end = CPP_PWRITTEN (pfile);
  macro = (U_CHAR *) alloca (end - buf + 1);
  memcpy (macro, buf, end - buf + 1);
  end = macro + (end - buf);

  CPP_SET_WRITTEN (pfile, here);

  mdef = create_definition (macro, end, pfile);
  if (mdef.defn == 0)
    return 0;

  if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen)) != NULL)
    {
      int ok = 0;
      /* Redefining a poisoned identifier is even worse than `not ok'.  */
      if (hp->type == T_POISON)
        ok = -1;
      /* Redefining a macro is ok if the definitions are the same.  */
      else if (hp->type == T_MACRO)
        ok = ! compare_defs (pfile, mdef.defn, hp->value.defn);
      /* Redefining a constant is ok with -D.  */
      else if (hp->type == T_CONST || hp->type == T_STDC)
        ok = ! CPP_OPTIONS (pfile)->done_initializing;
      /* Print the warning or error if it's not ok.  */
      if (ok <= 0)
        {
          if (hp->type == T_POISON)
            cpp_error (pfile, "redefining poisoned `%.*s'", 
                       mdef.symlen, mdef.symnam);
          else
            cpp_pedwarn (pfile, "`%.*s' redefined", mdef.symlen, mdef.symnam);
          if (hp->type == T_MACRO && CPP_OPTIONS (pfile)->done_initializing)
            cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file,
                                            hp->value.defn->line, -1,
                        "this is the location of the previous definition");
        }
      if (hp->type != T_POISON)
        {
          /* Replace the old definition.  */
          hp->type = new_type;
          free_definition (hp->value.defn);
          hp->value.defn = mdef.defn;
        }
    }
  else
    cpp_install (pfile, mdef.symnam, mdef.symlen, new_type, (char *)mdef.defn);

  if (keyword != NULL && keyword->type == T_DEFINE)
    {
      if (CPP_OPTIONS (pfile)->debug_output
          || CPP_OPTIONS (pfile)->dump_macros == dump_definitions)
        dump_definition (pfile, mdef);
      else if (CPP_OPTIONS (pfile)->dump_macros == dump_names)
        pass_thru_directive (mdef.symnam, mdef.symlen, pfile, keyword);
    }

  return 0;
}


/* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
   If BUFFER != NULL, then use the LENGTH characters in BUFFER
   as the new input buffer.
   Return the new buffer, or NULL on failure.  */

cpp_buffer *
cpp_push_buffer (pfile, buffer, length)
     cpp_reader *pfile;
     U_CHAR *buffer;
     long length;
{
  cpp_buffer *buf = CPP_BUFFER (pfile);
  cpp_buffer *new;
  if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
    {
      cpp_fatal (pfile, "macro or `#include' recursion too deep");
      return NULL;
    }

  new = (cpp_buffer *) xcalloc (1, sizeof (cpp_buffer));

  new->if_stack = pfile->if_stack;
  new->cleanup = null_cleanup;
  new->underflow = null_underflow;
  new->buf = new->cur = buffer;
  new->alimit = new->rlimit = buffer + length;
  new->prev = buf;
  new->mark = -1;

  CPP_BUFFER (pfile) = new;
  return new;
}

cpp_buffer *
cpp_pop_buffer (pfile)
     cpp_reader *pfile;
{
  cpp_buffer *buf = CPP_BUFFER (pfile);
  if (ACTIVE_MARK_P())
    cpp_ice (pfile, "mark active in cpp_pop_buffer");
  (*buf->cleanup) (buf, pfile);
  CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
  free (buf);
  pfile->buffer_stack_depth--;
  return CPP_BUFFER (pfile);
}

/* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
   Pop the buffer when done.  */

void
cpp_scan_buffer (pfile)
     cpp_reader *pfile;
{
  cpp_buffer *buffer = CPP_BUFFER (pfile);
  enum cpp_token token;
  if (CPP_OPTIONS (pfile)->no_output)
    {
      long old_written = CPP_WRITTEN (pfile);
      /* In no-output mode, we can ignore everything but directives.  */
      for (;;)
        {
          if (! pfile->only_seen_white)
            skip_rest_of_line (pfile);
          token = cpp_get_token (pfile);
          if (token == CPP_EOF) /* Should not happen ...  */
            break;
          if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
            {
              if (CPP_PREV_BUFFER (CPP_BUFFER (pfile))
                  != CPP_NULL_BUFFER (pfile))
                cpp_pop_buffer (pfile);
              break;
            }
        }
      CPP_SET_WRITTEN (pfile, old_written);
    }
  else
    {
      for (;;)
        {
          token = cpp_get_token (pfile);
          if (token == CPP_EOF) /* Should not happen ...  */
            break;
          if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
            {
              if (CPP_PREV_BUFFER (CPP_BUFFER (pfile))
                  != CPP_NULL_BUFFER (pfile))
                cpp_pop_buffer (pfile);
              break;
            }
        }
    }
}

/*
 * Rescan a string (which may have escape marks) into pfile's buffer.
 * Place the result in pfile->token_buffer.
 *
 * The input is copied before it is scanned, so it is safe to pass
 * it something from the token_buffer that will get overwritten
 * (because it follows CPP_WRITTEN).  This is used by do_include.
 */

void
cpp_expand_to_buffer (pfile, buf, length)
     cpp_reader *pfile;
     const U_CHAR *buf;
     int length;
{
  register cpp_buffer *ip;
  U_CHAR *buf1;
  int save_no_output;

  if (length < 0)
    {
      cpp_ice (pfile, "length < 0 in cpp_expand_to_buffer");
      return;
    }

  /* Set up the input on the input stack.  */

  buf1 = (U_CHAR *) alloca (length + 1);
  memcpy (buf1, buf, length);
  buf1[length] = 0;

  ip = cpp_push_buffer (pfile, buf1, length);
  if (ip == NULL)
    return;
  ip->has_escapes = 1;

  /* Scan the input, create the output.  */
  save_no_output = CPP_OPTIONS (pfile)->no_output;
  CPP_OPTIONS (pfile)->no_output = 0;
  cpp_scan_buffer (pfile);
  CPP_OPTIONS (pfile)->no_output = save_no_output;

  CPP_NUL_TERMINATE (pfile);
}

void
cpp_buf_line_and_col (pbuf, linep, colp)
     register cpp_buffer *pbuf;
     long *linep, *colp;
{
  if (pbuf)
    {
      *linep = pbuf->lineno;
      if (colp)
        *colp = pbuf->cur - pbuf->line_base;
    }
  else
    {
      *linep = 0;
      if (colp)
        *colp = 0;
    }
}

/* Return the cpp_buffer that corresponds to a file (not a macro).  */

cpp_buffer *
cpp_file_buffer (pfile)
     cpp_reader *pfile;
{
  cpp_buffer *ip = CPP_BUFFER (pfile);

  for ( ; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
    if (ip->fname != NULL)
      return ip;
  return NULL;
}

/*
 * write out a #line command, for instance, after an #include file.
 * FILE_CHANGE says whether we are entering a file, leaving, or neither.
 */

void
output_line_command (pfile, file_change)
     cpp_reader *pfile;
     enum file_change_code file_change;
{
  long line;
  cpp_buffer *ip = CPP_BUFFER (pfile);

  if (ip->fname == NULL)
    return;

  if (CPP_OPTIONS (pfile)->no_line_commands
      || CPP_OPTIONS (pfile)->no_output)
    return;

  cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, NULL);

  /* If the current file has not changed, we omit the #line if it would
     appear to be a no-op, and we output a few newlines instead
     if we want to increase the line number by a small amount.
     We cannot do this if pfile->lineno is zero, because that means we
     haven't output any line commands yet.  (The very first line command
     output is a `same_file' command.)  */
  if (file_change == same_file && pfile->lineno != 0)
    {
      if (line == pfile->lineno)
        return;

      /* If the inherited line number is a little too small,
         output some newlines instead of a #line command.  */
      if (line > pfile->lineno && line < pfile->lineno + 8)
        {
          CPP_RESERVE (pfile, 20);
          while (line > pfile->lineno)
            {
              CPP_PUTC_Q (pfile, '\n');
              pfile->lineno++;
            }
          return;
        }
    }

  CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
  CPP_PUTS_Q (pfile, "# ", 2);

  sprintf ((char *) CPP_PWRITTEN (pfile), "%ld ", line);
  CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));

  quote_string (pfile, ip->nominal_fname); 
  if (file_change != same_file)
    {
      CPP_PUTC_Q (pfile, ' ');
      CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
    }
  /* Tell cc1 if following text comes from a system header file.  */
  if (ip->system_header_p)
    {
      CPP_PUTC_Q (pfile, ' ');
      CPP_PUTC_Q (pfile, '3');
    }
#ifndef NO_IMPLICIT_EXTERN_C
  /* Tell cc1plus if following text should be treated as C.  */
  if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus)
    {
      CPP_PUTC_Q (pfile, ' ');
      CPP_PUTC_Q (pfile, '4');
    }
#endif
  CPP_PUTC_Q (pfile, '\n');
  pfile->lineno = line;
}


/* Like cpp_get_token, except that it does not read past end-of-line.
   Also, horizontal space is skipped, and macros are popped.  */

enum cpp_token
get_directive_token (pfile)
     cpp_reader *pfile;
{
  long old_written = CPP_WRITTEN (pfile);
  enum cpp_token token;

  for (;;)
    {
      cpp_skip_hspace (pfile);
      if (PEEKC () == '\n')
        return CPP_VSPACE;

      token = cpp_get_token (pfile);
      /* token could be hspace at the beginning of a macro.  */
      if (token == CPP_HSPACE || token == CPP_COMMENT)
        {
          CPP_SET_WRITTEN (pfile, old_written);
          continue;
        }

      /* token cannot be vspace, it would have been caught above.  */
      if (token == CPP_VSPACE)
        {
          cpp_ice (pfile, "VSPACE in get_directive_token");
          return token;
        }

      /* token cannot be POP unless the buffer is a macro buffer.  */
      if (token != CPP_POP)
        return token;

      if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
        {
          cpp_ice (pfile, "POP of file buffer in get_directive_token");
          return token;
        }

      /* We must pop the buffer by hand, or else cpp_get_token might
         hand us white space or newline on the next invocation.  */
      cpp_pop_buffer (pfile);
    }
}
\f
/* Handle #include and #import.
   This function expects to see "fname" or <fname> on the input.

   The input is normally in part of the output_buffer following
   CPP_WRITTEN, and will get overwritten by output_line_command.
   I.e. in input file specification has been popped by handle_directive.
   This is safe.  */

static int
do_include (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword;
{
  int importing = (keyword->type == T_IMPORT);
  int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
  int angle_brackets = 0;       /* 0 for "...", 1 for <...> */
  int before;  /* included before? */
  long flen;
  unsigned char *ftok;
  cpp_buffer *fp;

  enum cpp_token token;

  /* Chain of dirs to search */
  struct include_hash *ihash;
  struct file_name_list *search_start;
  
  long old_written = CPP_WRITTEN (pfile);

  int fd;

  if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
    {
      if (importing)
        cpp_pedwarn (pfile, "ANSI C does not allow `#import'");
      if (skip_dirs)
        cpp_pedwarn (pfile, "ANSI C does not allow `#include_next'");
    }

  if (importing && CPP_OPTIONS (pfile)->warn_import
      && !CPP_OPTIONS (pfile)->inhibit_warnings
      && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
    {
      pfile->import_warning = 1;
      cpp_warning (pfile,
           "#import is obsolete, use an #ifndef wrapper in the header file");
    }

  pfile->parsing_include_directive++;
  token = get_directive_token (pfile);
  pfile->parsing_include_directive--;

  if (token == CPP_STRING)
    {
      if (pfile->token_buffer[old_written] == '<')
        angle_brackets = 1;
    }
#ifdef VMS
  else if (token == CPP_NAME)
    {
      /* Support '#include xyz' like VAX-C.  It is taken as
         '#include <xyz.h>' and generates a warning.  */
      cpp_warning (pfile,
               "`#include filename' is obsolete, use `#include <filename.h>'");
      angle_brackets = 1;

      /* Append the missing `.h' to the name. */
      CPP_PUTS (pfile, ".h", 2);
    }
#endif
  else
    {
      cpp_error (pfile,
                 "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
      CPP_SET_WRITTEN (pfile, old_written);
      skip_rest_of_line (pfile);
      return 0;
    }

  flen = CPP_WRITTEN (pfile) - old_written;
  ftok = (unsigned char *) alloca (flen + 1);
  memcpy (ftok, pfile->token_buffer + old_written, flen);
  ftok[flen] = '\0';

  if (get_directive_token (pfile) != CPP_VSPACE)
    {
      cpp_error (pfile, "junk at end of `#include'");
      skip_rest_of_line (pfile);
    }

  CPP_SET_WRITTEN (pfile, old_written);

  if (flen == 0)
    {
      cpp_error (pfile, "empty file name in `#%s'", keyword->name);
      return 0;
    }

  if (CPP_OPTIONS (pfile)->dump_includes)
    pass_thru_directive (ftok,
                         flen
#ifdef VMS
          - ((token == CPP_NAME) ? 2 : 0)
#endif
                         , pfile, keyword);

#ifdef VMS
  if (token == CPP_STRING)
#endif
    {
      ftok++;
      flen -= 2;
      ftok[flen] = '\0';
    }

  search_start = 0;

  for (fp = CPP_BUFFER (pfile);
       fp != CPP_NULL_BUFFER (pfile);
       fp = CPP_PREV_BUFFER (fp))
    if (fp->fname != NULL)
      break;

  if (fp == CPP_NULL_BUFFER (pfile))
    {
      cpp_ice (pfile, "fp == NULL_BUFFER in do_include");
      return 0;
    }
  
  /* For #include_next, skip in the search path past the dir in which the
     containing file was found.  Treat files specified using an absolute path
     as if there are no more directories to search.  Treat the primary source
     file like any other included source, but generate a warning.  */
  if (skip_dirs && CPP_PREV_BUFFER(fp) != CPP_NULL_BUFFER (pfile))
    {
      if (fp->ihash->foundhere != ABSOLUTE_PATH)
        search_start = fp->ihash->foundhere->next;
    }
  else
    {
      if (skip_dirs)
        cpp_warning (pfile, "#include_next in primary source file");
      
      if (angle_brackets)
        search_start = CPP_OPTIONS (pfile)->bracket_include;
      else
        {
          if (!CPP_OPTIONS (pfile)->ignore_srcdir)
            {
              if (fp)
                search_start = fp->actual_dir;
            }
          else
            search_start = CPP_OPTIONS (pfile)->quote_include;
        }
    }

  if (!search_start)
    {
      cpp_error (pfile, "No include path in which to find %s", ftok);
      return 0;
    }

  fd = find_include_file (pfile, ftok, search_start, &ihash, &before);

  if (fd == -2)
    return 0;
  
  if (fd == -1)
    {
      if (CPP_OPTIONS (pfile)->print_deps_missing_files
          && CPP_PRINT_DEPS (pfile) > (angle_brackets ||
                                       (pfile->system_include_depth > 0)))
        {
          if (!angle_brackets)
            deps_output (pfile, ftok, ' ');
          else
            {
              char *p;
              struct file_name_list *ptr;
              /* If requested as a system header, assume it belongs in
                 the first system header directory. */
              if (CPP_OPTIONS (pfile)->bracket_include)
                ptr = CPP_OPTIONS (pfile)->bracket_include;
              else
                ptr = CPP_OPTIONS (pfile)->quote_include;

              p = (char *) alloca (strlen (ptr->name)
                                   + strlen (ftok) + 2);
              if (*ptr->name != '\0')
                {
                  strcpy (p, ptr->name);
                  strcat (p, "/");
                }
              strcat (p, ftok);
              deps_output (pfile, p, ' ');
            }
        }
      /* If -M was specified, and this header file won't be added to
         the dependency list, then don't count this as an error,
         because we can still produce correct output.  Otherwise, we
         can't produce correct output, because there may be
         dependencies we need inside the missing file, and we don't
         know what directory this missing file exists in. */
      else if (CPP_PRINT_DEPS (pfile)
               && (CPP_PRINT_DEPS (pfile)
                   <= (angle_brackets || (pfile->system_include_depth > 0))))
        cpp_warning (pfile, "No include path in which to find %s", ftok);
      else
        cpp_error_from_errno (pfile, ftok);

      return 0;
    }

  /* For -M, add the file to the dependencies on its first inclusion. */
  if (!before && (CPP_PRINT_DEPS (pfile)
                  > (angle_brackets || (pfile->system_include_depth > 0))))
    deps_output (pfile, ihash->name, ' ');

  /* Handle -H option.  */
  if (CPP_OPTIONS(pfile)->print_include_names)
    {
      fp = CPP_BUFFER (pfile);
      while ((fp = CPP_PREV_BUFFER (fp)) != CPP_NULL_BUFFER (pfile))
        putc ('.', stderr);
      fprintf (stderr, " %s\n", ihash->name);
    }

  /* Actually process the file */

  if (importing)
    ihash->control_macro = "";
  
  if (cpp_push_buffer (pfile, NULL, 0) == NULL)
    {
      close (fd);
      return 0;
    }
  
  if (angle_brackets)
    pfile->system_include_depth++;   /* Decremented in file_cleanup. */

  if (finclude (pfile, fd, ihash))
    {
      output_line_command (pfile, enter_file);
      pfile->only_seen_white = 2;
    }

  return 0;
}

/* Subroutine of do_line.  Read next token from PFILE without adding it to
   the output buffer.  If it is a number between 1 and 4, store it in *NUM
   and return 1; otherwise, return 0 and complain if we aren't at the end
   of the directive.  */

static int
read_line_number (pfile, num)
     cpp_reader *pfile;
     int *num;
{
  long save_written = CPP_WRITTEN (pfile);
  U_CHAR *p = pfile->token_buffer + save_written;
  enum cpp_token token = get_directive_token (pfile);
  CPP_SET_WRITTEN (pfile, save_written);

  if (token == CPP_NUMBER && *p >= '1' && *p <= '4' && p[1] == '\0')
    {
      *num = p[0] - '0';
      return 1;
    }
  else
    {
      if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
        cpp_error (pfile, "invalid format `#line' command");
      return 0;
    }
}

/* Interpret #line command.
   Note that the filename string (if any) is treated as if it were an
   include filename.  That means no escape handling.  */

static int
do_line (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  cpp_buffer *ip = CPP_BUFFER (pfile);
  int new_lineno;
  long old_written = CPP_WRITTEN (pfile);
  enum file_change_code file_change = same_file;
  enum cpp_token token;
  char *x;

  token = get_directive_token (pfile);

  if (token != CPP_NUMBER)
    {
      cpp_error (pfile, "token after `#line' is not an integer");
      goto bad_line_directive;
    }

  new_lineno = strtol (pfile->token_buffer + old_written, &x, 10);
  if (x[0] != '\0')
    {
      cpp_error (pfile, "token after `#line' is not an integer");
      goto bad_line_directive;
    }      
  CPP_SET_WRITTEN (pfile, old_written);

  if (CPP_PEDANTIC (pfile) && new_lineno <= 0)
    cpp_pedwarn (pfile, "line number out of range in `#line' command");

  token = get_directive_token (pfile);

  if (token == CPP_STRING)
    {
      U_CHAR *fname = pfile->token_buffer + old_written + 1;
      U_CHAR *end_name = CPP_PWRITTEN (pfile) - 1;
      int action_number = 0;

      if (read_line_number (pfile, &action_number))
        {
          if (CPP_PEDANTIC (pfile))
            cpp_pedwarn (pfile, "garbage at end of `#line' command");

          if (action_number == 1)
            {
              file_change = enter_file;
              read_line_number (pfile, &action_number);
            }
          else if (action_number == 2)
            {
              file_change = leave_file;
              read_line_number (pfile, &action_number);
            }
          if (action_number == 3)
            {
              ip->system_header_p = 1;
              read_line_number (pfile, &action_number);
            }
          if (action_number == 4)
            {
              ip->system_header_p = 2;
              read_line_number (pfile, &action_number);
            }
        }
      
      *end_name = '\0';
      
      if (strcmp (fname, ip->nominal_fname))
        {
          const char *newname, *oldname;
          if (!strcmp (fname, ip->fname))
            newname = ip->fname;
          else if (ip->last_nominal_fname
                   && !strcmp (fname, ip->last_nominal_fname))
            newname = ip->last_nominal_fname;
          else
            newname = xstrdup (fname);

          oldname = ip->nominal_fname;
          ip->nominal_fname = newname;

          if (ip->last_nominal_fname
              && ip->last_nominal_fname != oldname
              && ip->last_nominal_fname != newname
              && ip->last_nominal_fname != ip->fname)
            free ((void *) ip->last_nominal_fname);

          if (newname == ip->fname)
            ip->last_nominal_fname = NULL;
          else
            ip->last_nominal_fname = oldname;
        } 
    }
  else if (token != CPP_VSPACE && token != CPP_EOF)
    {
      cpp_error (pfile, "token after `#line %d' is not a string", new_lineno);
      goto bad_line_directive;
    }

  /* The Newline at the end of this line remains to be processed.
     To put the next line at the specified line number,
     we must store a line number now that is one less.  */
  ip->lineno = new_lineno - 1;
  CPP_SET_WRITTEN (pfile, old_written);
  output_line_command (pfile, file_change);
  return 0;

 bad_line_directive:
  skip_rest_of_line (pfile);
  CPP_SET_WRITTEN (pfile, old_written);
  return 0;
}

/* Remove the definition of a symbol from the symbol table.
   According to the C standard, it is not an error to undef
   something that has no definitions. */
static int
do_undef (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword;
{
  int sym_length;
  HASHNODE *hp;
  U_CHAR *buf, *name, *limit;
  int c;
  long here = CPP_WRITTEN (pfile);
  enum cpp_token token;

  cpp_skip_hspace (pfile);
  c = GETC();
  if (! is_idstart(c))
  {
      cpp_error (pfile, "token after #undef is not an identifier");
      skip_rest_of_line (pfile);
      return 1;
  }

  parse_name (pfile, c);
  buf = pfile->token_buffer + here;
  limit = CPP_PWRITTEN(pfile);

  /* Copy out the token so we can pop the token buffer. */
  name = (U_CHAR *) alloca (limit - buf + 1);
  bcopy(buf, name, limit - buf);
  name[limit - buf] = '\0';

  token = get_directive_token (pfile);
  if (token != CPP_VSPACE && token != CPP_POP)
  {
      cpp_pedwarn (pfile, "junk on line after #undef");
      skip_rest_of_line (pfile);
  }

  CPP_SET_WRITTEN (pfile, here);

  sym_length = check_macro_name (pfile, buf);

  while ((hp = cpp_lookup (pfile, name, sym_length)) != NULL)
    {
      /* If we are generating additional info for debugging (with -g) we
         need to pass through all effective #undef commands.  */
      if (CPP_OPTIONS (pfile)->debug_output && keyword)
        pass_thru_directive (name, sym_length, pfile, keyword);
      if (hp->type == T_POISON)
        cpp_error (pfile, "cannot undefine poisoned `%s'", hp->name);
      else 
        {
          if (hp->type != T_MACRO)
            cpp_warning (pfile, "undefining `%s'", hp->name);
          delete_macro (hp);
        }
    }

  return 0;
}

/* Wrap do_undef for -U processing. */
void
cpp_undef (pfile, macro)
     cpp_reader *pfile;
     U_CHAR *macro;
{
  /* Copy the string so we can append a newline.  */
  size_t len = strlen (macro);
  U_CHAR *buf = alloca (len + 2);
  memcpy (buf, macro, len);
  buf[len]     = '\n';
  buf[len + 1] = '\0';
  if (cpp_push_buffer (pfile, buf, len + 1))
    {
      do_undef (pfile, NULL);
      cpp_pop_buffer (pfile);
    }
}

/*
 * Report an error detected by the program we are processing.
 * Use the text of the line in the error message.
 * (We use error because it prints the filename & line#.)
 */

static int
do_error (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  long here = CPP_WRITTEN (pfile);
  U_CHAR *text;
  copy_rest_of_line (pfile);
  text = pfile->token_buffer + here;
  SKIP_WHITE_SPACE(text);

  cpp_error (pfile, "#error %s", text);
  CPP_SET_WRITTEN (pfile, here);
  return 0;
}

/*
 * Report a warning detected by the program we are processing.
 * Use the text of the line in the warning message, then continue.
 */

static int
do_warning (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  U_CHAR *text;
  long here = CPP_WRITTEN(pfile);
  copy_rest_of_line (pfile);
  text = pfile->token_buffer + here;
  SKIP_WHITE_SPACE(text);

  if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
    cpp_pedwarn (pfile, "ANSI C does not allow `#warning'");

  /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
     if -pedantic-errors is given, #warning should cause an error.  */
  cpp_pedwarn (pfile, "#warning %s", text);
  CPP_SET_WRITTEN (pfile, here);
  return 0;
}

/* Report program identification.
   This is not precisely what cccp does with #ident, however I believe
   it matches `closely enough' (behavior is identical as long as there
   are no macros on the #ident line, which is pathological in my opinion).  */

static int
do_ident (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  /* Allow #ident in system headers, since that's not user's fault.  */
  if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
    cpp_pedwarn (pfile, "ANSI C does not allow `#ident'");

  CPP_PUTS (pfile, "#ident ", 7);
  cpp_skip_hspace (pfile);
  copy_rest_of_line (pfile);

  return 0;
}

/* Just check for some recognized pragmas that need validation here,
   and leave the text in the token buffer to be output. */

static int
do_pragma (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  long here;
  U_CHAR *buf;

  CPP_PUTS (pfile, "#pragma ", 8);
  cpp_skip_hspace (pfile);
  
  here = CPP_WRITTEN (pfile);
  copy_rest_of_line (pfile);
  buf = pfile->token_buffer + here;
  
  if (!strncmp (buf, "once", 4))
    {
      cpp_buffer *ip = NULL;

      /* Allow #pragma once in system headers, since that's not the user's
         fault.  */
      if (!CPP_BUFFER (pfile)->system_header_p)
        cpp_warning (pfile, "`#pragma once' is obsolete");
      
      for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
        {
          if (ip == CPP_NULL_BUFFER (pfile))
            return 0;
          if (ip->fname != NULL)
            break;
        }

      if (CPP_PREV_BUFFER (ip) == CPP_NULL_BUFFER (pfile))
        cpp_warning (pfile, "`#pragma once' outside include file");
      else
        ip->ihash->control_macro = "";  /* never repeat */
    }
  else if (!strncmp (buf, "implementation", 14))
    {
      /* Be quiet about `#pragma implementation' for a file only if it hasn't
         been included yet.  */
      struct include_hash *ptr;
      U_CHAR *p = buf + 14, *fname, *fcopy;
      SKIP_WHITE_SPACE (p);
      if (*p == '\n' || *p != '\"')
        return 0;

      fname = p + 1;
      p = (U_CHAR *) index (fname, '\"');

      fcopy = (U_CHAR *) alloca (p - fname + 1);
      bcopy (fname, fcopy, p - fname);
      fcopy[p-fname] = '\0';

      ptr = include_hash (pfile, fcopy, 0);
      if (ptr)
        cpp_warning (pfile,
          "`#pragma implementation' for `%s' appears after file is included",
                     fcopy);
    }
  else if (!strncmp (buf, "poison", 6))
    {
      /* Poison these symbols so that all subsequent usage produces an
         error message.  */
      U_CHAR *p = buf + 6;
      size_t plen;
      U_CHAR *syms;
      int writeit;

      SKIP_WHITE_SPACE (p);
      plen = strlen(p) + 1;

      syms = (U_CHAR *) alloca (plen);
      memcpy (syms, p, plen);

      /* As a rule, don't include #pragma poison commands in output,  
         unless the user asks for them.  */
      writeit = (CPP_OPTIONS (pfile)->debug_output
                 || CPP_OPTIONS (pfile)->dump_macros == dump_definitions
                 || CPP_OPTIONS (pfile)->dump_macros == dump_names);

      if (writeit)
        CPP_SET_WRITTEN (pfile, here);
      else
        CPP_SET_WRITTEN (pfile, here-8);

      if (writeit)
        {
          CPP_RESERVE (pfile, plen + 7);
          CPP_PUTS_Q (pfile, "poison", 7);
        }

      while (*syms != '\0')
        {
          U_CHAR *end = syms;
          
          while (is_idchar(*end))
            end++;

          if (!is_hspace(*end) && *end != '\0')
            {
              cpp_error (pfile, "invalid #pragma poison directive");
              return 1;
            }

          if (cpp_push_buffer (pfile, syms, end - syms) != NULL)
            {
              do_define (pfile, keyword);
              cpp_pop_buffer (pfile);
            }
          if (writeit)
            {
              CPP_PUTC_Q (pfile, ' ');
              CPP_PUTS_Q (pfile, syms, end - syms);
            }
          syms = end;
          SKIP_WHITE_SPACE (syms);
        }
    }

  return 0;
}

#ifdef SCCS_DIRECTIVE
/* Just ignore #sccs, on systems where we define it at all.  */

static int
do_sccs (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  if (CPP_PEDANTIC (pfile))
    cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'");
  skip_rest_of_line (pfile);
  return 0;
}
#endif
\f

/* We've found an `#if' directive.  If the only thing before it in
   this file is white space, and if it is of the form
   `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
   for inclusion of this file.  (See redundant_include_p in cppfiles.c
   for an explanation of controlling macros.)  If so, return a
   malloc'd copy of SYMBOL.  Otherwise, return NULL.  */

static U_CHAR *
detect_if_not_defined (pfile)
     cpp_reader *pfile;
{
  U_CHAR *control_macro = 0;

  if (pfile->only_seen_white == 2)
    {
      char *ident;
      enum cpp_token token;
      int base_offset;
      int token_offset;
      int need_rparen = 0;

      /* Save state required for restore.  */
      pfile->no_macro_expand++;
      parse_set_mark (pfile);
      base_offset = CPP_WRITTEN (pfile);

      /* Look for `!', */
      if (get_directive_token (pfile) != CPP_OTHER
          || CPP_WRITTEN (pfile) != (size_t) base_offset + 1
          || CPP_PWRITTEN (pfile)[-1] != '!')
        goto restore;

      /* ...then `defined', */
      token_offset = CPP_WRITTEN (pfile);
      token = get_directive_token (pfile);
      if (token != CPP_NAME)
        goto restore;
      ident = pfile->token_buffer + token_offset;
      CPP_NUL_TERMINATE (pfile);
      if (strcmp (ident, "defined"))
        goto restore;

      /* ...then an optional '(' and the name, */
      token_offset = CPP_WRITTEN (pfile);
      token = get_directive_token (pfile);
      if (token == CPP_LPAREN)
        {
          token_offset = CPP_WRITTEN (pfile);
          token = get_directive_token (pfile);
          if (token != CPP_NAME)
            goto restore;
          need_rparen = 1;
        }
      else if (token != CPP_NAME)
        goto restore;

      ident = pfile->token_buffer + token_offset;
      CPP_NUL_TERMINATE (pfile);

      /* ...then the ')', if necessary, */
      if ((!need_rparen || get_directive_token (pfile) == CPP_RPAREN)
          /* ...and make sure there's nothing else on the line.  */
          && get_directive_token (pfile) == CPP_VSPACE)
        control_macro = xstrdup (ident);

    restore:
      CPP_SET_WRITTEN (pfile, base_offset);
      pfile->no_macro_expand--;
      parse_goto_mark (pfile);
    }

  return control_macro;
}

/*
 * handle #if command by
 *   1) inserting special `defined' keyword into the hash table
 *      that gets turned into 0 or 1 by special_symbol (thus,
 *      if the luser has a symbol called `defined' already, it won't
 *      work inside the #if command)
 *   2) rescan the input into a temporary output buffer
 *   3) pass the output buffer to the yacc parser and collect a value
 *   4) clean up the mess left from steps 1 and 2.
 *   5) call conditional_skip to skip til the next #endif (etc.),
 *      or not, depending on the value from step 3.
 */

static int
do_if (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  U_CHAR *control_macro = detect_if_not_defined (pfile);
  HOST_WIDEST_INT value = eval_if_expression (pfile);
  conditional_skip (pfile, value == 0, T_IF, control_macro);
  return 0;
}

/*
 * handle a #elif directive by not changing  if_stack  either.
 * see the comment above do_else.
 */

static int
do_elif (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
    {
      cpp_error (pfile, "`#elif' not within a conditional");
      return 0;
    }
  else
    {
      if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF)
        {
          cpp_error (pfile, "`#elif' after `#else'");
          cpp_error_with_line (pfile, pfile->if_stack->lineno, -1,
                               "the conditional began here");
        }
      pfile->if_stack->type = T_ELIF;
    }

  if (pfile->if_stack->if_succeeded)
    skip_if_group (pfile);
  else
    {
      HOST_WIDEST_INT value = eval_if_expression (pfile);
      if (value == 0)
        skip_if_group (pfile);
      else
        {
          ++pfile->if_stack->if_succeeded;      /* continue processing input */
          output_line_command (pfile, same_file);
        }
    }
  return 0;
}

/*
 * evaluate a #if expression in BUF, of length LENGTH,
 * then parse the result as a C expression and return the value as an int.
 */

static HOST_WIDEST_INT
eval_if_expression (pfile)
     cpp_reader *pfile;
{
  HOST_WIDEST_INT value;
  long old_written = CPP_WRITTEN (pfile);

  /* Work around bug in cpp_get_token where it may mistake an
     assertion for a directive.  */
  pfile->only_seen_white = 0;

  value = cpp_parse_expr (pfile);

  skip_rest_of_line (pfile);
  CPP_SET_WRITTEN (pfile, old_written); /* Pop */

  return value;
}

/*
 * routine to handle ifdef/ifndef.  Try to look up the symbol,
 * then do or don't skip to the #endif/#else/#elif depending
 * on what directive is actually being processed.
 */

static int
do_xifdef (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword;
{
  int skip;
  cpp_buffer *ip = CPP_BUFFER (pfile);
  U_CHAR *ident;
  int ident_length;
  enum cpp_token token;
  int start_of_file = 0;
  U_CHAR *control_macro = 0;
  int old_written = CPP_WRITTEN (pfile);

  /* Detect a #ifndef at start of file (not counting comments).  */
  if (ip->fname != 0 && keyword->type == T_IFNDEF)
    start_of_file = pfile->only_seen_white == 2;

  pfile->no_macro_expand++;
  token = get_directive_token (pfile);
  pfile->no_macro_expand--;

  ident = pfile->token_buffer + old_written;
  ident_length = CPP_WRITTEN (pfile) - old_written;
  CPP_SET_WRITTEN (pfile, old_written); /* Pop */

  if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
    {
      skip = (keyword->type == T_IFDEF);
      if (! CPP_TRADITIONAL (pfile))
        cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
    }
  else if (token == CPP_NAME)
    {
      HASHNODE *hp = cpp_lookup (pfile, ident, ident_length);
      skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
      if (start_of_file && !skip)
        {
          control_macro = (U_CHAR *) xmalloc (ident_length + 1);
          bcopy (ident, control_macro, ident_length + 1);
        }
      if (hp != NULL && hp->type == T_POISON)
        {
          cpp_error (pfile, "attempt to use poisoned `%s'", hp->name);
          skip = !skip;
        }
    }
  else
    {
      skip = (keyword->type == T_IFDEF);
      if (! CPP_TRADITIONAL (pfile))
        cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
    }

  if (!CPP_TRADITIONAL (pfile))
    { int c;
      cpp_skip_hspace (pfile);
      c = PEEKC ();
      if (c != EOF && c != '\n')
        cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
    }
  skip_rest_of_line (pfile);

  conditional_skip (pfile, skip, T_IF, control_macro);
  return 0;
}

/* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
   If this is a #ifndef starting at the beginning of a file,
   CONTROL_MACRO is the macro name tested by the #ifndef.
   Otherwise, CONTROL_MACRO is 0.  */

static void
conditional_skip (pfile, skip, type, control_macro)
     cpp_reader *pfile;
     int skip;
     enum node_type type;
     U_CHAR *control_macro;
{
  IF_STACK_FRAME *temp;

  temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
  temp->fname = CPP_BUFFER (pfile)->nominal_fname;
  temp->lineno = CPP_BUFFER (pfile)->lineno;
  temp->next = pfile->if_stack;
  temp->control_macro = control_macro;
  pfile->if_stack = temp;

  pfile->if_stack->type = type;

  if (skip != 0) {
    skip_if_group (pfile);
    return;
  } else {
    ++pfile->if_stack->if_succeeded;
    output_line_command (pfile, same_file);
  }
}

/* Subroutine of skip_if_group.  Examine one preprocessing directive and
   return 0 if skipping should continue, 1 if it should halt.  Also
   adjusts the if_stack as appropriate.
   The `#' has been read, but not the identifier. */

static int
consider_directive_while_skipping (pfile, stack)
    cpp_reader *pfile;
    IF_STACK_FRAME *stack; 
{
  long ident_len, ident;
  const struct directive *kt;
  IF_STACK_FRAME *temp;
    
  cpp_skip_hspace (pfile);

  ident = CPP_WRITTEN (pfile);
  parse_name (pfile, GETC());
  ident_len = CPP_WRITTEN (pfile) - ident;

  CPP_SET_WRITTEN (pfile, ident);

  for (kt = directive_table; kt->length >= 0; kt++)
    if (kt->length == ident_len
        && strncmp (pfile->token_buffer + ident, kt->name, kt->length) == 0)
      switch (kt->type)
        {
        case T_IF:
        case T_IFDEF:
        case T_IFNDEF:
            temp = (IF_STACK_FRAME *) xmalloc (sizeof (IF_STACK_FRAME));
            temp->next = pfile->if_stack;
            pfile->if_stack = temp;
            temp->fname = CPP_BUFFER(pfile)->nominal_fname;
            temp->type = kt->type;
            return 0;

        case T_ELSE:
            if (pfile->if_stack != stack)
              validate_else (pfile, "#else");
            /* fall through */
        case T_ELIF:
            if (pfile->if_stack == stack)
              return 1;
            else
              {
                pfile->if_stack->type = kt->type;
                return 0;
              }

            case T_ENDIF:
                if (pfile->if_stack != stack)
                  validate_else (pfile, "#endif");

                if (pfile->if_stack == stack)
                  return 1;
                    
                temp = pfile->if_stack;
                pfile->if_stack = temp->next;
                free (temp);
                return 0;

            default:
                return 0;
            }

    /* Don't let erroneous code go by.  */
    if (!CPP_OPTIONS (pfile)->lang_asm && CPP_PEDANTIC (pfile))
        cpp_pedwarn (pfile, "invalid preprocessor directive name");
    return 0;
}

/* skip to #endif, #else, or #elif.  adjust line numbers, etc.
 * leaves input ptr at the sharp sign found.
 */
static void
skip_if_group (pfile)
    cpp_reader *pfile;
{
  int c;
  IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
  U_CHAR *beg_of_line;
  long old_written;

  if (CPP_OPTIONS (pfile)->output_conditionals)
    {
      CPP_PUTS (pfile, "#failed\n", 8);
      pfile->lineno++;
      output_line_command (pfile, same_file);
    }

  old_written = CPP_WRITTEN (pfile);
  
  for (;;)
    {
      beg_of_line = CPP_BUFFER (pfile)->cur;

      if (! CPP_TRADITIONAL (pfile))
        cpp_skip_hspace (pfile);
      c = GETC();
      if (c == '\n')
        {
          if (CPP_OPTIONS (pfile)->output_conditionals)
            CPP_PUTC (pfile, c);
          CPP_BUMP_LINE (pfile);
          continue;
        }
      else if (c == '#')
        {
          if (consider_directive_while_skipping (pfile, save_if_stack))
            break;
        }
      else if (c == EOF)
        return;  /* Caller will issue error. */

      FORWARD(-1);
      if (CPP_OPTIONS (pfile)->output_conditionals)
        {
          CPP_PUTS (pfile, beg_of_line, CPP_BUFFER (pfile)->cur - beg_of_line);
          copy_rest_of_line (pfile);
        }
      else
        {
          copy_rest_of_line (pfile);
          CPP_SET_WRITTEN (pfile, old_written);  /* discard it */
        }

      c = GETC();
      if (c == EOF)
        return;  /* Caller will issue error. */
      else
        {
          /* \n */
          if (CPP_OPTIONS (pfile)->output_conditionals)
            {
              CPP_PUTC (pfile, c);
              pfile->lineno++;
            }
          CPP_BUMP_LINE (pfile);
        }
    }     

  /* Back up to the beginning of this line.  Caller will process the
     directive. */
  CPP_BUFFER (pfile)->cur = beg_of_line;
  pfile->only_seen_white = 1;
  if (CPP_OPTIONS (pfile)->output_conditionals)
    {
      CPP_PUTS (pfile, "#endfailed\n", 11);
      pfile->lineno++;
    }
}

/*
 * handle a #else directive.  Do this by just continuing processing
 * without changing  if_stack ;  this is so that the error message
 * for missing #endif's etc. will point to the original #if.  It
 * is possible that something different would be better.
 */

static int
do_else (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  validate_else (pfile, "#else");
  skip_rest_of_line (pfile);

  if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
    {
      cpp_error (pfile, "`#else' not within a conditional");
      return 0;
    }
  else
    {
      /* #ifndef can't have its special treatment for containing the whole file
         if it has a #else clause.  */
      pfile->if_stack->control_macro = 0;

      if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF)
        {
          cpp_error (pfile, "`#else' after `#else'");
          cpp_error_with_line (pfile, pfile->if_stack->lineno, -1,
                               "the conditional began here");
        }
      pfile->if_stack->type = T_ELSE;
    }

  if (pfile->if_stack->if_succeeded)
    skip_if_group (pfile);
  else
    {
      ++pfile->if_stack->if_succeeded;  /* continue processing input */
      output_line_command (pfile, same_file);
    }
  return 0;
}

/*
 * unstack after #endif command
 */

static int
do_endif (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  validate_else (pfile, "#endif");
  skip_rest_of_line (pfile);

  if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
    cpp_error (pfile, "`#endif' not within a conditional");
  else
    {
      IF_STACK_FRAME *temp = pfile->if_stack;
      pfile->if_stack = temp->next;
      if (temp->control_macro != 0)
        {
          /* This #endif matched a #ifndef at the start of the file.
             See if it is at the end of the file.  */
          int c;

          parse_set_mark (pfile);

          for (;;)
            {
              cpp_skip_hspace (pfile);
              c = GETC ();
              if (c != '\n')
                break;
            }
          parse_goto_mark (pfile);

          if (c == EOF)
            {
              /* This #endif ends a #ifndef
                 that contains all of the file (aside from whitespace).
                 Arrange not to include the file again
                 if the macro that was tested is defined. */
              struct cpp_buffer *ip;
              for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
                if (ip->fname != NULL)
                  break;
              ip->ihash->control_macro = (char *) temp->control_macro;
            }
        }
      free (temp);
      output_line_command (pfile, same_file);
    }
  return 0;
}

/* Issue -pedantic warning for text which is not a comment following
   an #else or #endif.  Do not warn in system headers, as this is harmless
   and very common on old systems.  */

static void
validate_else (pfile, directive)
     cpp_reader *pfile;
     const char *directive;
{
  if (! CPP_PEDANTIC (pfile) || CPP_BUFFER (pfile)->system_header_p)
    return;

  cpp_skip_hspace (pfile);
  if (PEEKC () != '\n')
    cpp_pedwarn (pfile,
                 "text following `%s' violates ANSI standard", directive);
}

/* Convert T_IF, etc. to a string.   Used in error messages.  */
static const char *
if_directive_name (pfile, ifs)
     cpp_reader *pfile;
     struct if_stack *ifs;
{
  switch (ifs->type)
    {
    case T_IF:      return "#if";
    case T_IFDEF:   return "#ifdef";
    case T_IFNDEF:  return "#ifndef";
    case T_ELIF:    return "#elif";
    case T_ELSE:    return "#else";
    default:
      cpp_ice (pfile, "impossible if_stack->type value %d", ifs->type);
      return "unknown";
    }
}

/* Get the next token, and add it to the text in pfile->token_buffer.
   Return the kind of token we got.  */

enum cpp_token
cpp_get_token (pfile)
     cpp_reader *pfile;
{
  register int c, c2, c3;
  enum cpp_token token;
  struct cpp_options *opts = CPP_OPTIONS (pfile);

 get_next:
  c = GETC();
  if (c == EOF)
    {
      if (CPP_BUFFER (pfile)->manual_pop)
        /* If we've been reading from redirected input, the
           frontend will pop the buffer.  */
        return CPP_EOF;
      else if (CPP_BUFFER (pfile)->seen_eof)
        {
          if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)) == CPP_NULL_BUFFER (pfile))
            return CPP_EOF;

          cpp_pop_buffer (pfile);
          goto get_next;
        }
      else
        {
          cpp_buffer *next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
          struct if_stack *ifs, *nifs;

          /* Unwind the conditional stack and generate error messages.  */
          for (ifs = pfile->if_stack;
               ifs != CPP_BUFFER (pfile)->if_stack;
               ifs = nifs)
            {
              cpp_error_with_line (pfile, ifs->lineno, -1,
                                   "unterminated `%s' conditional",
                                   if_directive_name (pfile, ifs));

              nifs = ifs->next;
              free (ifs);
            }
          pfile->if_stack = ifs;

          if (CPP_BUFFER (pfile)->nominal_fname
              && next_buf != CPP_NULL_BUFFER (pfile))
            {
              /* We're about to return from an #include file.
                 Emit #line information now (as part of the CPP_POP) result.
                 But the #line refers to the file we will pop to.  */
              cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
              CPP_BUFFER (pfile) = next_buf;
              pfile->input_stack_listing_current = 0;
              output_line_command (pfile, leave_file);
              CPP_BUFFER (pfile) = cur_buffer;
            }

          CPP_BUFFER (pfile)->seen_eof = 1;
          return CPP_POP;
        }
    }
  else
    {
      switch (c)
        {
        case '/':
          if (PEEKC () == '=')
            goto op2;

        comment:
          if (opts->discard_comments)
            c = skip_comment (pfile, c);
          else
            c = copy_comment (pfile, c);
          if (c != ' ')
            goto randomchar;
          
          /* Comments are equivalent to spaces.
             For -traditional, a comment is equivalent to nothing.  */
          if (opts->traditional || !opts->discard_comments)
            return CPP_COMMENT;
          else
            {
              CPP_PUTC (pfile, c);
              return CPP_HSPACE;
            }

        case '#':
          if (!pfile->only_seen_white)
            goto randomchar;
          /* -traditional directives are recognized only with the # in
             column 1.
             XXX Layering violation.  */
          if (CPP_TRADITIONAL (pfile)
              && CPP_BUFFER (pfile)->cur - CPP_BUFFER (pfile)->line_base != 1)
            goto randomchar;
          if (handle_directive (pfile))
            return CPP_DIRECTIVE;
          pfile->only_seen_white = 0;
          goto randomchar;

        case '\"':
        case '\'':
        string:
          parse_string (pfile, c);
          pfile->only_seen_white = 0;
          return c == '\'' ? CPP_CHAR : CPP_STRING;

        case '$':
          if (!opts->dollars_in_ident)
            goto randomchar;
          goto letter;

        case ':':
          if (opts->cplusplus && PEEKC () == ':')
            goto op2;
          goto randomchar;

        case '&':
        case '+':
        case '|':
          c2 = PEEKC ();
          if (c2 == c || c2 == '=')
            goto op2;
          goto randomchar;

        case '*':
        case '!':
        case '%':
        case '=':
        case '^':
          if (PEEKC () == '=')
            goto op2;
          goto randomchar;

        case '-':
          c2 = PEEKC ();
          if (c2 == '-' && opts->chill)
            goto comment;  /* Chill style comment */
          if (c2 == '-' || c2 == '=')
            goto op2;
          if (c2 == '>')
            {
              if (opts->cplusplus && PEEKN (1) == '*')
                {
                  /* In C++, there's a ->* operator.  */
                  token = CPP_OTHER;
                  pfile->only_seen_white = 0;
                  CPP_RESERVE (pfile, 4);
                  CPP_PUTC_Q (pfile, c);
                  CPP_PUTC_Q (pfile, GETC ());
                  CPP_PUTC_Q (pfile, GETC ());
                  CPP_NUL_TERMINATE_Q (pfile);
                  return token;
                }
              goto op2;
            }
          goto randomchar;

        case '<':
          if (pfile->parsing_include_directive)
            {
              for (;;)
                {
                  CPP_PUTC (pfile, c);
                  if (c == '>')
                    break;
                  c = GETC ();
                  if (c == '\n' || c == EOF)
                    {
                      cpp_error (pfile,
                                 "missing '>' in `#include <FILENAME>'");
                      break;
                    }
                  else if (c == '\r')
                    {
                      if (!CPP_BUFFER (pfile)->has_escapes)
                        {
                          /* Backslash newline is replaced by nothing. */
                          CPP_ADJUST_WRITTEN (pfile, -1);
                          CPP_BUMP_LINE (pfile);
                        }
                      else
                        {
                          /* We might conceivably get \r- or \r<space> in
                             here.  Just delete 'em. */
                          int d = GETC();
                          if (d != '-' && d != ' ')
                            cpp_ice (pfile, "unrecognized escape \\r%c", d);
                          CPP_ADJUST_WRITTEN (pfile, -1);
                        }                         
                    }
                }
              return CPP_STRING;
            }
          /* else fall through */
        case '>':
          c2 = PEEKC ();
          if (c2 == '=')
            goto op2;
          /* GNU C++ supports MIN and MAX operators <? and >?.  */
          if (c2 != c && (!opts->cplusplus || c2 != '?'))
            goto randomchar;
          FORWARD(1);
          CPP_RESERVE (pfile, 4);
          CPP_PUTC (pfile, c);
          CPP_PUTC (pfile, c2);
          c3 = PEEKC ();
          if (c3 == '=')
            CPP_PUTC_Q (pfile, GETC ());
          CPP_NUL_TERMINATE_Q (pfile);
          pfile->only_seen_white = 0;
          return CPP_OTHER;

        case '.':
          c2 = PEEKC ();
          if (ISDIGIT(c2))
            {
              CPP_RESERVE(pfile, 2);
              CPP_PUTC_Q (pfile, '.');
              c = GETC ();
              goto number;
            }

          /* In C++ there's a .* operator.  */
          if (opts->cplusplus && c2 == '*')
            goto op2;

          if (c2 == '.' && PEEKN(1) == '.')
            {
              CPP_RESERVE(pfile, 4);
              CPP_PUTC_Q (pfile, '.');
              CPP_PUTC_Q (pfile, '.');
              CPP_PUTC_Q (pfile, '.');
              FORWARD (2);
              CPP_NUL_TERMINATE_Q (pfile);
              pfile->only_seen_white = 0;
              return CPP_3DOTS;
            }
          goto randomchar;

        op2:
          token = CPP_OTHER;
          pfile->only_seen_white = 0;
          CPP_RESERVE(pfile, 3);
          CPP_PUTC_Q (pfile, c);
          CPP_PUTC_Q (pfile, GETC ());
          CPP_NUL_TERMINATE_Q (pfile);
          return token;

        case 'L':
          c2 = PEEKC ();
          if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
            {
              CPP_PUTC (pfile, c);
              c = GETC ();
              goto string;
            }
          goto letter;

        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
        number:
          c2  = '.';
          for (;;)
            {
              CPP_RESERVE (pfile, 2);
              CPP_PUTC_Q (pfile, c);
              c = PEEKC ();
              if (c == EOF)
                break;
              if (!is_idchar(c) && c != '.'
                  && ((c2 != 'e' && c2 != 'E'
                       && ((c2 != 'p' && c2 != 'P') || CPP_C89 (pfile)))
                      || (c != '+' && c != '-')))
                break;
              FORWARD(1);
              c2= c;
            }
          CPP_NUL_TERMINATE_Q (pfile);
          pfile->only_seen_white = 0;
          return CPP_NUMBER;
        case 'b': case 'c': case 'd': case 'h': case 'o':
        case 'B': case 'C': case 'D': case 'H': case 'O':
          if (opts->chill && PEEKC () == '\'')
            {
              pfile->only_seen_white = 0;
              CPP_RESERVE (pfile, 2);
              CPP_PUTC_Q (pfile, c);
              CPP_PUTC_Q (pfile, '\'');
              FORWARD(1);
              for (;;)
                {
                  c = GETC();
                  if (c == EOF)
                    goto chill_number_eof;
                  if (!is_idchar(c))
                    break;
                  CPP_PUTC (pfile, c);
                }
              if (c == '\'')
                {
                  CPP_RESERVE (pfile, 2);
                  CPP_PUTC_Q (pfile, c);
                  CPP_NUL_TERMINATE_Q (pfile);
                  return CPP_STRING;
                }
              else
                {
                  FORWARD(-1);
                chill_number_eof:
                  CPP_NUL_TERMINATE (pfile);
                  return CPP_NUMBER;
                }
            }
          else
            goto letter;
        case '_':
        case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
        case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
        case 'r': case 's': case 't': case 'u': case 'v': case 'w':
        case 'x': case 'y': case 'z':
        case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
        case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
        case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
        case 'Y': case 'Z':
        letter:
          {
            HASHNODE *hp;
            unsigned char *ident;
            int before_name_written = CPP_WRITTEN (pfile);
            int ident_len;
            parse_name (pfile, c);
            pfile->only_seen_white = 0;
            if (pfile->no_macro_expand)
              return CPP_NAME;
            ident = pfile->token_buffer + before_name_written;
            ident_len = CPP_PWRITTEN (pfile) - ident;
            hp = cpp_lookup (pfile, ident, ident_len);
            if (!hp)
              return CPP_NAME;
            if (hp->type == T_DISABLED)
              {
                if (pfile->output_escapes)
                  { /* Return "\r-IDENT", followed by '\0'.  */
                    int i;
                    CPP_RESERVE (pfile, 3);
                    ident = pfile->token_buffer + before_name_written;
                    CPP_ADJUST_WRITTEN (pfile, 2);
                    for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
                    ident[0] = '\r';
                    ident[1] = '-';
                  }
                return CPP_NAME;
              }

            /* If macro wants an arglist, verify that a '(' follows.  */
            if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
            {
              int macbuf_whitespace = 0;

              while (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
                {
                  U_CHAR *point = CPP_BUFFER (pfile)->cur;
                  for (;;)
                    {
                      cpp_skip_hspace (pfile);
                      c = PEEKC ();
                      if (c == '\n')
                        FORWARD(1);
                      else
                        break;
                    }
                  if (point != CPP_BUFFER (pfile)->cur)
                    macbuf_whitespace = 1;
                  if (c == '(')
                    goto is_macro_call;
                  else if (c != EOF)
                    goto not_macro_call;
                  cpp_pop_buffer (pfile);
                }

              parse_set_mark (pfile);
              for (;;)
                {
                  cpp_skip_hspace (pfile);
                  c = PEEKC ();
                  if (c == '\n')
                    FORWARD(1);
                  else
                    break;
                }
              parse_goto_mark (pfile);

              if (c == '(')
                goto is_macro_call;

            not_macro_call:
              if (macbuf_whitespace)
                CPP_PUTC (pfile, ' ');
              return CPP_NAME;
            }
          is_macro_call:
            /* This is now known to be a macro call.
               Expand the macro, reading arguments as needed,
               and push the expansion on the input stack.  */
            macroexpand (pfile, hp);
            CPP_SET_WRITTEN (pfile, before_name_written);
          }
          goto get_next;

        case ' ':  case '\t':  case '\v':
          for (;;)
            {
              CPP_PUTC (pfile, c);
              c = PEEKC ();
              if (c == EOF || !is_hspace(c))
                break;
              FORWARD(1);
            }
          return CPP_HSPACE;

        case '\r':
          if (CPP_BUFFER (pfile)->has_escapes)
            {
              c = GETC ();
              if (c == '-')
                {
                  if (pfile->output_escapes)
                    CPP_PUTS (pfile, "\r-", 2);
                  parse_name (pfile, GETC ());
                  return CPP_NAME;
                }
              else if (c == ' ')
                {
                  CPP_RESERVE (pfile, 2);
                  if (pfile->output_escapes)
                    CPP_PUTC_Q (pfile, '\r');
                  CPP_PUTC_Q (pfile, c);
                  return CPP_HSPACE;
                }
              else
                {
                  cpp_ice (pfile, "unrecognized escape \\r%c", c);
                  goto get_next;
                }
            }
          else
            {
              /* Backslash newline is ignored. */
              CPP_BUMP_LINE (pfile);
              goto get_next;
            }

        case '\n':
          CPP_PUTC (pfile, c);
          if (pfile->only_seen_white == 0)
            pfile->only_seen_white = 1;
          CPP_BUMP_LINE (pfile);
          if (! CPP_OPTIONS (pfile)->no_line_commands)
            {
              pfile->lineno++;
              if (CPP_BUFFER (pfile)->lineno != pfile->lineno)
                output_line_command (pfile, same_file);
            }
          return CPP_VSPACE;

        case '(': token = CPP_LPAREN;    goto char1;
        case ')': token = CPP_RPAREN;    goto char1;
        case '{': token = CPP_LBRACE;    goto char1;
        case '}': token = CPP_RBRACE;    goto char1;
        case ',': token = CPP_COMMA;     goto char1;
        case ';': token = CPP_SEMICOLON; goto char1;

        randomchar:
        default:
          token = CPP_OTHER;
        char1:
          pfile->only_seen_white = 0;
          CPP_PUTC (pfile, c);
          return token;
        }
    }
}

/* Like cpp_get_token, but skip spaces and comments.  */

enum cpp_token
cpp_get_non_space_token (pfile)
     cpp_reader *pfile;
{
  int old_written = CPP_WRITTEN (pfile);
  for (;;)
    {
      enum cpp_token token = cpp_get_token (pfile);
      if (token != CPP_COMMENT && token != CPP_POP
          && token != CPP_HSPACE && token != CPP_VSPACE)
        return token;
      CPP_SET_WRITTEN (pfile, old_written);
    }
}

/* Parse an identifier starting with C.  */

static void
parse_name (pfile, c)
     cpp_reader *pfile;
     int c;
{
  for (;;)
  {
      if (! is_idchar(c))
      {
          FORWARD (-1);
          break;
      }

      if (c == '$' && CPP_PEDANTIC (pfile))
        cpp_pedwarn (pfile, "`$' in identifier");

      CPP_RESERVE(pfile, 2); /* One more for final NUL.  */
      CPP_PUTC_Q (pfile, c);
      c = GETC();
      if (c == EOF)
        break;
  }
  CPP_NUL_TERMINATE_Q (pfile);
  return;
}

/* Parse a string starting with C.  A single quoted string is treated
   like a double -- some programs (e.g., troff) are perverse this way.
   (However, a single quoted string is not allowed to extend over
   multiple lines.)  */
static void
parse_string (pfile, c)
     cpp_reader *pfile;
     int c;
{
  long start_line, start_column;
  
  cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);

  CPP_PUTC (pfile, c);
  while (1)
    {
      int cc = GETC();
      if (cc == EOF)
        {
          if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
            {
              /* try harder: this string crosses a macro expansion
                 boundary.  This can happen naturally if -traditional.
                 Otherwise, only -D can make a macro with an unmatched
                 quote.  */
              cpp_pop_buffer (pfile);
              continue;
            }

          cpp_error_with_line (pfile, start_line, start_column,
                               "unterminated string or character constant");
          if (pfile->multiline_string_line != start_line
              && pfile->multiline_string_line != 0)
            cpp_error_with_line (pfile,
                                 pfile->multiline_string_line, -1,
                         "possible real start of unterminated constant");
          pfile->multiline_string_line = 0;
          break;
        }
      CPP_PUTC (pfile, cc);
      switch (cc)
        {
        case '\n':
          CPP_BUMP_LINE (pfile);
          pfile->lineno++;

          /* In Fortran and assembly language, silently terminate
             strings of either variety at end of line.  This is a
             kludge around not knowing where comments are in these
             languages.  */
          if (CPP_OPTIONS (pfile)->lang_fortran
              || CPP_OPTIONS (pfile)->lang_asm)
            return;
          /* Character constants may not extend over multiple lines.
             In Standard C, neither may strings.  We accept multiline
             strings as an extension.  */
          if (c == '\'')
            {
              cpp_error_with_line (pfile, start_line, start_column,
                                   "unterminated character constant");
              return;
            }
          if (CPP_PEDANTIC (pfile) && pfile->multiline_string_line == 0)
            cpp_pedwarn_with_line (pfile, start_line, start_column,
                                   "string constant runs past end of line");
          if (pfile->multiline_string_line == 0)
            pfile->multiline_string_line = start_line;
          break;

        case '\r':
          CPP_ADJUST_WRITTEN (pfile, -1);
          if (CPP_BUFFER (pfile)->has_escapes)
            {
              cpp_ice (pfile, "\\r escape inside string constant");
              FORWARD(1);
            }
          else
            /* Backslash newline is replaced by nothing at all.  */
            CPP_BUMP_LINE (pfile);
          break;

        case '\\':
          cc = GETC();
          if (cc != EOF)
            CPP_PUTC (pfile, cc);
          break;

        case '\"':
        case '\'':
          if (cc == c)
            return;
          break;
        }
    }
}

/* Read an assertion into the token buffer, converting to
   canonical form: `#predicate(a n swe r)'  The next non-whitespace
   character to read should be the first letter of the predicate.
   Returns 0 for syntax error, 1 for bare predicate, 2 for predicate
   with answer (see callers for why). In case of 0, an error has been
   printed. */
static int
parse_assertion (pfile)
     cpp_reader *pfile;
{
  int c, dropwhite;
  cpp_skip_hspace (pfile);
  c = PEEKC();
  if (! is_idstart(c))
    {
      cpp_error (pfile, "assertion predicate is not an identifier");
      return 0;
    }
  CPP_PUTC(pfile, '#');
  FORWARD(1);
  parse_name(pfile, c);

  c = PEEKC();
  if (c != '(')
    {
      if (is_hspace(c) || c == '\r')
        cpp_skip_hspace (pfile);
      c = PEEKC();
    }
  if (c != '(')
    return 1;

  CPP_PUTC(pfile, '(');
  FORWARD(1);
  dropwhite = 1;
  while ((c = GETC()) != ')')
    {
      if (is_space(c))
        {
          if (! dropwhite)
            {
              CPP_PUTC(pfile, ' ');
              dropwhite = 1;
            }
        }
      else if (c == '\n' || c == EOF)
        {
          if (c == '\n') FORWARD(-1);
          cpp_error (pfile, "un-terminated assertion answer");
          return 0;
        }
      else if (c == '\r')
        /* \r cannot be a macro escape here. */
        CPP_BUMP_LINE (pfile);
      else
        {
          CPP_PUTC (pfile, c);
          dropwhite = 0;
        }
    }

  if (pfile->limit[-1] == ' ')
    pfile->limit[-1] = ')';
  else if (pfile->limit[-1] == '(')
    {
      cpp_error (pfile, "empty token sequence in assertion");
      return 0;
    }
  else
    CPP_PUTC (pfile, ')');

  CPP_NUL_TERMINATE (pfile);
  return 2;
}

static int
do_assert (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  char *sym;
  int ret, c;
  HASHNODE *base, *this;
  int baselen, thislen;

  if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
      && !CPP_BUFFER (pfile)->system_header_p)
    cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");

  cpp_skip_hspace (pfile);
  sym = (char *) CPP_PWRITTEN (pfile);  /* remember where it starts */
  ret = parse_assertion (pfile);
  if (ret == 0)
    goto error;
  else if (ret == 1)
    {
      cpp_error (pfile, "missing token-sequence in `#assert'");
      goto error;
    }

  cpp_skip_hspace (pfile);
  c = PEEKC();
  if (c != EOF && c != '\n')
    {
      cpp_error (pfile, "junk at end of `#assert'");
      goto error;
    }

  thislen = strlen (sym);
  baselen = index (sym, '(') - sym;
  this = cpp_lookup (pfile, sym, thislen);
  if (this)
    {
      cpp_warning (pfile, "`%s' re-asserted", sym);
      goto error;
    }

  base = cpp_lookup (pfile, sym, baselen);
  if (! base)
    base = cpp_install (pfile, sym, baselen, T_ASSERT, 0);
  else if (base->type != T_ASSERT)
  {
    /* Token clash - but with what?! */
    cpp_ice (pfile, "base->type != T_ASSERT in do_assert");
    goto error;
  }

  this = cpp_install (pfile, sym, thislen, T_ASSERT,
                      (char *)base->value.aschain);
  base->value.aschain = this;
  
  pfile->limit = (unsigned char *) sym; /* Pop */
  return 0;

 error:
  skip_rest_of_line (pfile);
  pfile->limit = (unsigned char *) sym; /* Pop */
  return 0;
}

static int
do_unassert (pfile, keyword)
     cpp_reader *pfile;
     const struct directive *keyword ATTRIBUTE_UNUSED;
{
  int c, ret;
  char *sym;
  long baselen, thislen;
  HASHNODE *base, *this, *next;
  
  if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
      && !CPP_BUFFER (pfile)->system_header_p)
    cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");

  cpp_skip_hspace (pfile);

  sym = (char *) CPP_PWRITTEN (pfile);  /* remember where it starts */
  ret = parse_assertion (pfile);
  if (ret == 0)
    goto error;
  
  cpp_skip_hspace (pfile);
  c = PEEKC ();
  if (c != EOF && c != '\n')
      cpp_error (pfile, "junk at end of `#unassert'");

  thislen = strlen (sym);
  if (ret == 1)
    {
      base = cpp_lookup (pfile, sym, thislen);
      if (! base)
        goto error;  /* It isn't an error to #undef what isn't #defined,
                        so it isn't an error to #unassert what isn't
                        #asserted either. */
      
      for (this = base->value.aschain; this; this = next)
        {
          next = this->value.aschain;
          delete_macro (this);
        }
      delete_macro (base);
    }
  else
    {
      baselen = index (sym, '(') - sym;
      base = cpp_lookup (pfile, sym, baselen);
      if (! base) goto error;
      this = cpp_lookup (pfile, sym, thislen);
      if (! this) goto error;

      next = base;
      while (next->value.aschain != this)
        next = next->value.aschain;

      next->value.aschain = this->value.aschain;
      delete_macro (this);

      if (base->value.aschain == NULL)
        delete_macro (base);  /* Last answer for this predicate deleted. */
    }
  
  pfile->limit = (unsigned char *) sym; /* Pop */
  return 0;
 error:
  skip_rest_of_line (pfile);
  pfile->limit = (unsigned char *) sym; /* Pop */
  return 0;
}

/* Process STR as if it appeared as the body of an #unassert. */
void
cpp_unassert (pfile, str)
     cpp_reader *pfile;
     unsigned char *str;
{
  if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
    {
      do_assert (pfile, NULL);
      cpp_pop_buffer (pfile);
    }
}  

int
cpp_read_check_assertion (pfile)
     cpp_reader *pfile;
{
  U_CHAR *name;
  int result;
  long written = CPP_WRITTEN (pfile);
  
  FORWARD (1);  /* Skip '#' */
  cpp_skip_hspace (pfile);
  if (! parse_assertion (pfile))
    result = 0;
  else
    {
      name = pfile->token_buffer + written;
      result = cpp_defined (pfile, name, CPP_PWRITTEN (pfile) - name);
    }

  CPP_SET_WRITTEN (pfile, written);
  return result;
}

/* Remember the current position of PFILE so it may be returned to
   after looking ahead a bit.

   Note that when you set a mark, you _must_ return to that mark.  You
   may not forget about it and continue parsing.  You may not pop a
   buffer with an active mark.  You may not call CPP_BUMP_LINE while a
   mark is active.  */

static void
parse_set_mark (pfile)
     cpp_reader *pfile;
{
  cpp_buffer *ip = CPP_BUFFER (pfile);
  if (ACTIVE_MARK_P())
      cpp_ice (pfile, "mark active in parse_set_mark");

  ip->mark = ip->cur - ip->buf;
}

/* Backup the current position of PFILE to that saved in its mark,
   and clear the mark.  */

static void
parse_goto_mark (pfile)
     cpp_reader *pfile;
{
  cpp_buffer *ip = CPP_BUFFER (pfile);
  if (!ACTIVE_MARK_P())
      cpp_ice (pfile, "mark not active in parse_goto_mark");

  ip->cur = ip->buf + ip->mark;
  ip->mark = -1;
}