Enlist the FreeBSD-CURRENT users as testers of what is to become Gcc 3.1.0.

These bits are taken from the FSF anoncvs repo on 1-Feb-2002 08:20 PST.

1 files changed, 1363 insertions, 2805 deletions

diff --git a/contrib/gcc/cpplib.c b/contrib/gcc/cpplib.c
index bcf40e1..12baa10 100644
--- a/contrib/gcc/cpplib.c
+++ b/contrib/gcc/cpplib.c
@@ -1,5 +1,6 @@
-/* CPP Library.
-   Copyright (C) 1986, 87, 89, 92-98, 1999 Free Software Foundation, Inc.
+/* CPP Library. (Directive handling.)
+   Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+   1999, 2000, 2001, 2002 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
@@ -23,3253 +24,1810 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "cpplib.h"
 #include "cpphash.h"
-#include "intl.h"
+#include "obstack.h"
 
-#define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
-#define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
+/* Chained list of answers to an assertion.  */
+struct answer
+{
+  struct answer *next;
+  unsigned int count;
+  cpp_token first[1];
+};
 
-#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)
+/* Stack of conditionals currently in progress
+   (including both successful and failing conditionals).  */
+struct if_stack
+{
+  struct if_stack *next;
+  unsigned int line;		/* Line where condition started.  */
+  const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
+  bool skip_elses;		/* Can future #else / #elif be skipped?  */
+  bool was_skipping;		/* If were skipping on entry.  */
+  int type;			/* Most recent conditional, for diagnostics.  */
+};
 
-/* Forward declarations.  */
+/* Contains a registered pragma or pragma namespace.  */
+typedef void (*pragma_cb) PARAMS ((cpp_reader *));
+struct pragma_entry
+{
+  struct pragma_entry *next;
+  const cpp_hashnode *pragma;	/* Name and length.  */
+  int is_nspace;
+  union {
+    pragma_cb handler;
+    struct pragma_entry *space;
+  } u;
+};
 
-static char *my_strerror		PROTO ((int));
-static void validate_else		PROTO ((cpp_reader *, char *));
-static HOST_WIDEST_INT eval_if_expression	PROTO ((cpp_reader *));
+/* Values for the origin field of struct directive.  KANDR directives
+   come from traditional (K&R) C.  STDC89 directives come from the
+   1989 C standard.  EXTENSION directives are extensions.  */
+#define KANDR		0
+#define STDC89		1
+#define EXTENSION	2
+
+/* Values for the flags field of struct directive.  COND indicates a
+   conditional; IF_COND an opening conditional.  INCL means to treat
+   "..." and <...> as q-char and h-char sequences respectively.  IN_I
+   means this directive should be handled even if -fpreprocessed is in
+   effect (these are the directives with callback hooks).  */
+#define COND		(1 << 0)
+#define IF_COND		(1 << 1)
+#define INCL		(1 << 2)
+#define IN_I		(1 << 3)
+
+/* Defines one #-directive, including how to handle it.  */
+typedef void (*directive_handler) PARAMS ((cpp_reader *));
+typedef struct directive directive;
+struct directive
+{
+  directive_handler handler;	/* Function to handle directive.  */
+  const U_CHAR *name;		/* Name of directive.  */
+  unsigned short length;	/* Length of name.  */
+  unsigned char origin;		/* Origin of directive.  */
+  unsigned char flags;	        /* Flags describing this directive.  */
+};
 
-static void conditional_skip		PROTO ((cpp_reader *, int,
-						enum node_type, U_CHAR *));
-static void skip_if_group		PROTO ((cpp_reader *));
+/* Forward declarations.  */
 
-static void parse_name			PARAMS ((cpp_reader *, int));
-static void parse_string		PARAMS ((cpp_reader *, int));
-static int parse_assertion		PARAMS ((cpp_reader *));
+static void skip_rest_of_line	PARAMS ((cpp_reader *));
+static void check_eol		PARAMS ((cpp_reader *));
+static void start_directive	PARAMS ((cpp_reader *));
+static void end_directive	PARAMS ((cpp_reader *, int));
+static void directive_diagnostics
+	PARAMS ((cpp_reader *, const directive *, int));
+static void run_directive	PARAMS ((cpp_reader *, int,
+					 const char *, size_t));
+static const cpp_token *glue_header_name PARAMS ((cpp_reader *));
+static const cpp_token *parse_include PARAMS ((cpp_reader *));
+static void push_conditional	PARAMS ((cpp_reader *, int, int,
+					 const cpp_hashnode *));
+static unsigned int read_flag	PARAMS ((cpp_reader *, unsigned int));
+static int  strtoul_for_line	PARAMS ((const U_CHAR *, unsigned int,
+					 unsigned long *));
+static void do_diagnostic	PARAMS ((cpp_reader *, enum error_type, int));
+static cpp_hashnode *lex_macro_node	PARAMS ((cpp_reader *));
+static void do_include_common	PARAMS ((cpp_reader *, enum include_type));
+static struct pragma_entry *lookup_pragma_entry
+  PARAMS ((struct pragma_entry *, const cpp_hashnode *pragma));
+static struct pragma_entry *insert_pragma_entry
+  PARAMS ((cpp_reader *, struct pragma_entry **, const cpp_hashnode *,
+	   pragma_cb));
+static void do_pragma_once	PARAMS ((cpp_reader *));
+static void do_pragma_poison	PARAMS ((cpp_reader *));
+static void do_pragma_system_header	PARAMS ((cpp_reader *));
+static void do_pragma_dependency	PARAMS ((cpp_reader *));
+static const cpp_token *get_token_no_padding PARAMS ((cpp_reader *));
+static const cpp_token *get__Pragma_string PARAMS ((cpp_reader *));
+static void destringize_and_run PARAMS ((cpp_reader *, const cpp_string *));
+static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
+static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
+					      int));
+static struct answer ** find_answer PARAMS ((cpp_hashnode *,
+					     const struct answer *));
+static void handle_assertion	PARAMS ((cpp_reader *, const char *, int));
+
+/* This is the table of directive handlers.  It 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).  This is no longer important as directive lookup
+   is now O(1).  All extensions other than #warning and #include_next
+   are deprecated.  The name is where the extension appears to have
+   come from.  */
+
+#define DIRECTIVE_TABLE							\
+D(define,	T_DEFINE = 0,	KANDR,     IN_I)	   /* 270554 */ \
+D(include,	T_INCLUDE,	KANDR,     INCL)	   /*  52262 */ \
+D(endif,	T_ENDIF,	KANDR,     COND)	   /*  45855 */ \
+D(ifdef,	T_IFDEF,	KANDR,     COND | IF_COND) /*  22000 */ \
+D(if,		T_IF,		KANDR,     COND | IF_COND) /*  18162 */ \
+D(else,		T_ELSE,		KANDR,     COND)	   /*   9863 */ \
+D(ifndef,	T_IFNDEF,	KANDR,     COND | IF_COND) /*   9675 */ \
+D(undef,	T_UNDEF,	KANDR,     IN_I)	   /*   4837 */ \
+D(line,		T_LINE,		KANDR,     IN_I)	   /*   2465 */ \
+D(elif,		T_ELIF,		STDC89,    COND)	   /*    610 */ \
+D(error,	T_ERROR,	STDC89,    0)		   /*    475 */ \
+D(pragma,	T_PRAGMA,	STDC89,    IN_I)	   /*    195 */ \
+D(warning,	T_WARNING,	EXTENSION, 0)		   /*     22 */ \
+D(include_next,	T_INCLUDE_NEXT,	EXTENSION, INCL)	   /*     19 */ \
+D(ident,	T_IDENT,	EXTENSION, IN_I)	   /*     11 */ \
+D(import,	T_IMPORT,	EXTENSION, INCL)	   /* 0 ObjC */	\
+D(assert,	T_ASSERT,	EXTENSION, 0)		   /* 0 SVR4 */	\
+D(unassert,	T_UNASSERT,	EXTENSION, 0)		   /* 0 SVR4 */	\
+SCCS_ENTRY						   /* 0 SVR4? */
+
+/* #sccs is not always recognized.  */
+#ifdef SCCS_DIRECTIVE
+# define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
+#else
+# define SCCS_ENTRY /* nothing */
+#endif
 
-/* External declarations.  */
+/* Use the table to generate a series of prototypes, an enum for the
+   directive names, and an array of directive handlers.  */
 
-extern HOST_WIDEST_INT cpp_parse_expr PARAMS ((cpp_reader *));
+/* The directive-processing functions are declared to return int
+   instead of void, because some old compilers have trouble with
+   pointers to functions returning void.  */
 
-/* `struct directive' defines one #-directive, including how to handle it.  */
+/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail.  */
+#define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
+DIRECTIVE_TABLE
+#undef D
 
-struct directive {
-  int length;			/* Length of name */
-  int (*func)			/* Function to handle directive */
-    PARAMS ((cpp_reader *, struct directive *));
-  char *name;			/* Name of directive */
-  enum node_type type;		/* Code which describes which directive.  */
+#define D(n, tag, o, f) tag,
+enum
+{
+  DIRECTIVE_TABLE
+  N_DIRECTIVES
 };
+#undef D
 
-/* 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 *, struct directive *));
-static int do_line PARAMS ((cpp_reader *, struct directive *));
-static int do_include PARAMS ((cpp_reader *, struct directive *));
-static int do_undef PARAMS ((cpp_reader *, struct directive *));
-static int do_error PARAMS ((cpp_reader *, struct directive *));
-static int do_pragma PARAMS ((cpp_reader *, struct directive *));
-static int do_ident PARAMS ((cpp_reader *, struct directive *));
-static int do_if PARAMS ((cpp_reader *, struct directive *));
-static int do_xifdef PARAMS ((cpp_reader *, struct directive *));
-static int do_else PARAMS ((cpp_reader *, struct directive *));
-static int do_elif PARAMS ((cpp_reader *, struct directive *));
-static int do_endif PARAMS ((cpp_reader *, struct directive *));
-#ifdef SCCS_DIRECTIVE
-static int do_sccs PARAMS ((cpp_reader *, struct directive *));
-#endif
-static int do_assert PARAMS ((cpp_reader *, struct directive *));
-static int do_unassert PARAMS ((cpp_reader *, struct directive *));
-static int do_warning PARAMS ((cpp_reader *, struct directive *));
-
-#define IS_INCLUDE_DIRECTIVE_TYPE(t) \
-((int) T_INCLUDE <= (int) (t) && (int) (t) <= (int) T_IMPORT)
-
-/* Here is the actual list of #-directives, most-often-used first.
-   The initialize_builtins function assumes #define is the very first.  */
-
-static struct directive directive_table[] = {
-  {  6, do_define,   "define",       T_DEFINE },
-  {  5, do_xifdef,   "ifdef",        T_IFDEF },
-  {  6, do_xifdef,   "ifndef",       T_IFNDEF },
-  {  7, do_include,  "include",      T_INCLUDE },
-  { 12, do_include,  "include_next", T_INCLUDE_NEXT },
-  {  6, do_include,  "import",       T_IMPORT },
-  {  5, do_endif,    "endif",        T_ENDIF },
-  {  4, do_else,     "else",         T_ELSE },
-  {  2, do_if,       "if",           T_IF },
-  {  4, do_elif,     "elif",         T_ELIF },
-  {  5, do_undef,    "undef",        T_UNDEF },
-  {  5, do_error,    "error",        T_ERROR },
-  {  7, do_warning,  "warning",      T_WARNING },
-  {  6, do_pragma,   "pragma",       T_PRAGMA },
-  {  4, do_line,     "line",         T_LINE },
-  {  5, do_ident,    "ident",        T_IDENT },
-#ifdef SCCS_DIRECTIVE
-  {  4, do_sccs,     "sccs",         T_SCCS },
-#endif
-  {  6, do_assert,   "assert",       T_ASSERT },
-  {  8, do_unassert, "unassert",     T_UNASSERT },
-  {  -1, 0, "", T_UNUSED }
+/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail.  */
+#define D(name, t, origin, flags) \
+{ CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
+  sizeof STRINGX(name) - 1, origin, flags },
+static const directive dtable[] =
+{
+DIRECTIVE_TABLE
 };
+#undef D
+#undef DIRECTIVE_TABLE
 
-/* Place into PFILE a quoted string representing the string SRC.
-   Caller must reserve enough space in pfile->token_buffer.  */
+#define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
 
-void
-quote_string (pfile, src)
+/* Skip any remaining tokens in a directive.  */
+static void
+skip_rest_of_line (pfile)
      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;
+  /* Discard all stacked contexts.  */
+  while (pfile->context != &pfile->base_context)
+    _cpp_pop_context (pfile);
 
-      case '\"':
-      case '\\':
-	CPP_PUTC_Q (pfile, '\\');
-	CPP_PUTC_Q (pfile, c);
-	break;
-      
-      case '\0':
-	CPP_PUTC_Q (pfile, '\"');
-	CPP_NUL_TERMINATE_Q (pfile);
-	return;
-      }
+  /* Sweep up all tokens remaining on the line.  */
+  if (! SEEN_EOL ())
+    while (_cpp_lex_token (pfile)->type != CPP_EOF)
+      ;
 }
 
-/* Re-allocates PFILE->token_buffer so it will hold at least N more chars.  */
-
-void
-cpp_grow_buffer (pfile, n)
+/* Ensure there are no stray tokens at the end of a directive.  */
+static void
+check_eol (pfile)
      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);
+  if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
+    cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
+		 pfile->directive->name);
 }
 
-/* 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)
+/* Called when entering a directive, _Pragma or command-line directive.  */
+static void
+start_directive (pfile)
      cpp_reader *pfile;
-     U_CHAR *str;
 {
-  U_CHAR *buf, *p;
-  size_t count;
+  /* Setup in-directive state.  */
+  pfile->state.in_directive = 1;
+  pfile->state.save_comments = 0;
 
-  /* Copy the entire option so we can modify it.  */
-  count = strlen (str) + 3;
-  buf = (U_CHAR *) alloca (count);
-  memcpy (buf, str, count - 2);
-  /* Change the first "=" in the string to a space.  If there is none,
-     tack " 1" on the end. */
-  p = (U_CHAR *) strchr (buf, '=');
-  if (p)
-    {
-      *p = ' ';
-      count -= 2;
-    }
-  else
-      strcpy (&buf[count-3], " 1");
-  
-  if (cpp_push_buffer (pfile, buf, count - 1) != NULL)
-    {
-      do_define (pfile, NULL);
-      cpp_pop_buffer (pfile);
-    }
+  /* Some handlers need the position of the # for diagnostics.  */
+  pfile->directive_line = pfile->line;
 }
 
-/* Process the string STR as if it appeared as the body of a #assert. */
-void
-cpp_assert (pfile, str)
+/* Called when leaving a directive, _Pragma or command-line directive.  */
+static void
+end_directive (pfile, skip_line)
      cpp_reader *pfile;
-     U_CHAR *str;
+     int skip_line;
 {
-  if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
+  /* We don't skip for an assembler #.  */
+  if (skip_line)
     {
-      do_assert (pfile, NULL);
-      cpp_pop_buffer (pfile);
+      skip_rest_of_line (pfile);
+      if (!pfile->keep_tokens)
+	{
+	  pfile->cur_run = &pfile->base_run;
+	  pfile->cur_token = pfile->base_run.base;
+	}
     }
-}
-
 
-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;
+  /* Restore state.  */
+  pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
+  pfile->state.in_directive = 0;
+  pfile->state.angled_headers = 0;
+  pfile->state.line_extension = 0;
+  pfile->directive = 0;
 }
 
-/* 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 we hit end-of-file before end-of-comment,
-   return EOF.  If this is not a comment, return M (which will be
-   '/' or '-').  */
-
-static int
-skip_comment (pfile, m)
+/* Output diagnostics for a directive DIR.  INDENTED is non-zero if
+   the '#' was indented.  */
+static void
+directive_diagnostics (pfile, dir, indented)
      cpp_reader *pfile;
-     int m;
+     const directive *dir;
+     int indented;
 {
-  if (m == '/' && PEEKC() == '*')
+  if (pfile->state.line_extension)
     {
-      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 EOF;
-	    }
-	  else if (c == '\n' || c == '\r')
-	    /* \r cannot be a macro escape marker here. */
-	    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;
-	}
+      if (CPP_PEDANTIC (pfile)
+	  && ! pfile->state.skipping)
+	cpp_pedwarn (pfile, "style of line directive is a GCC extension");
     }
-  else if ((m == '/' && PEEKC() == '/'
-	    && CPP_OPTIONS (pfile)->cplusplus_comments)
-	   || (m == '-' && PEEKC() == '-'
-	       && CPP_OPTIONS (pfile)->chill))
+  else
     {
-      FORWARD(1);
-      for (;;)
+      /* Issue -pedantic warnings for extensions.  */
+      if (CPP_PEDANTIC (pfile)
+	  && ! pfile->state.skipping
+	  && dir->origin == EXTENSION)
+	cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
+
+      /* Traditionally, a directive is ignored unless its # is in
+	 column 1.  Therefore in code intended to work with K+R
+	 compilers, directives added by C89 must have their #
+	 indented, and directives present in traditional C must not.
+	 This is true even of directives in skipped conditional
+	 blocks.  */
+      if (CPP_WTRADITIONAL (pfile))
 	{
-	  int c = GETC ();
-	  if (c == EOF)
-	    return ' '; /* Allow // to be terminated by EOF.  */
-	      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. */
-		CPP_BUMP_LINE (pfile);
+	  if (dir == &dtable[T_ELIF])
+	    cpp_warning (pfile, "suggest not using #elif in traditional C");
+	  else if (indented && dir->origin == KANDR)
+	    cpp_warning (pfile,
+			 "traditional C ignores #%s with the # indented",
+			 dir->name);
+	  else if (!indented && dir->origin != KANDR)
+	    cpp_warning (pfile,
+		 "suggest hiding #%s from traditional C with an indented #",
+			 dir->name);
 	}
     }
-  else
-    return m;
 }
 
-/* Identical to skip_comment except that it copies the comment into the
-   token_buffer.  This is used if put_out_comments.  */
-static int
-copy_comment (pfile, m)
+/* Check if we have a known directive.  INDENTED is non-zero if the
+   '#' of the directive was indented.  This function is in this file
+   to save unnecessarily exporting dtable etc. to cpplex.c.  Returns
+   non-zero if the line of tokens has been handled, zero if we should
+   continue processing the line.  */
+int
+_cpp_handle_directive (pfile, indented)
      cpp_reader *pfile;
-     int m;
+     int indented;
 {
-  if (m == '/' && PEEKC() == '*')
-    {
-      int c, prev_c = -1;
-      long line, col;
-
-      CPP_PUTC (pfile, '/');
-      CPP_PUTC (pfile, '*');
-      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");
-	      /* We must pretend this was a legitimate comment, so that the
-		 output in token_buffer is not passed back tagged CPP_POP. */
-	      return ' ';
-	    }
-	  else if (c == '\r')
-	    {
-	      /* \r cannot be a macro escape marker here. */
-	      CPP_BUMP_LINE (pfile);
-	      continue;
-	    }
+  const directive *dir = 0;
+  const cpp_token *dname;
+  int skip = 1;
 
-	  CPP_PUTC (pfile, c);
-	  if (c == '\n')
-	    {
-	      pfile->lineno++;
-	      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");
+  start_directive (pfile);
+  dname = _cpp_lex_token (pfile);
 
-	  prev_c = c;
-	}
+  if (dname->type == CPP_NAME)
+    {
+      if (dname->val.node->directive_index)
+	dir = &dtable[dname->val.node->directive_index - 1];
     }
-  else if ((m == '/' && PEEKC() == '/'
-	    && CPP_OPTIONS (pfile)->cplusplus_comments)
-	   || (m == '-' && PEEKC() == '-'
-	       && CPP_OPTIONS (pfile)->chill))
+  /* We do not recognise the # followed by a number extension in
+     assembler code.  */
+  else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
     {
-      CPP_PUTC (pfile, m);
-      CPP_PUTC (pfile, m);
-      FORWARD(1);
-      for (;;)
-	{
-	  int c = GETC ();
-	  if (c == EOF)
-	    return ' '; /* Allow line comments to be terminated by EOF. */
-	  else 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. */
-	    CPP_BUMP_LINE (pfile);
-
-	  CPP_PUTC (pfile, c);
-	}
+      dir = &dtable[T_LINE];
+      pfile->state.line_extension = 1;
     }
-  else
-    return m;
-}
 
+  if (dir)
+    {
+      /* If we have a directive that is not an opening conditional,
+	 invalidate any control macro.  */
+      if (! (dir->flags & IF_COND))
+	pfile->mi_valid = false;
 
-/* Skip whitespace \-newline and comments.  Does not macro-expand.  */
+      /* Kluge alert.  In order to be sure that code like this
 
-void
-cpp_skip_hspace (pfile)
-     cpp_reader *pfile;
-{
-  int c;
-  while (1)
-    {
-      c = GETC();
-      if (c == EOF)
-	return;
-      else if (is_hor_space[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')
+	 #define HASH #
+	 HASH define foo bar
+
+	 does not cause '#define foo bar' to get executed when
+	 compiled with -save-temps, we recognize directives in
+	 -fpreprocessed mode only if the # is in column 1.  cppmacro.c
+	 puts a space in front of any '#' at the start of a macro.  */
+      if (CPP_OPTION (pfile, preprocessed)
+	  && (indented || !(dir->flags & IN_I)))
 	{
-	  /* \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++;
+	  skip = 0;
+	  dir = 0;
 	}
-      else if (c == '/' || c == '-')
+      else
 	{
-	  c = skip_comment (pfile, c);
-	  if (c == EOF)
-	    return;
-	  else if (c != ' ')
-	    break;
+	  /* In failed conditional groups, all non-conditional
+	     directives are ignored.  Before doing that, whether
+	     skipping or not, we should lex angle-bracketed headers
+	     correctly, and maybe output some diagnostics.  */
+	  pfile->state.angled_headers = dir->flags & INCL;
+	  if (! CPP_OPTION (pfile, preprocessed))
+	    directive_diagnostics (pfile, dir, indented);
+	  if (pfile->state.skipping && !(dir->flags & COND))
+	    dir = 0;
 	}
-      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 (;;)
+  else if (dname->type == CPP_EOF)
+    ;	/* CPP_EOF is the "null directive".  */
+  else
     {
-      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() == '*' && CPP_TRADITIONAL (pfile))
-	    {
-	      CPP_PUTS (pfile, "/**/", 4);
-	      skip_comment (pfile, c);
-	      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;
+      /* An unknown directive.  Don't complain about it in assembly
+	 source: we don't know where the comments are, and # may
+	 introduce assembler pseudo-ops.  Don't complain about invalid
+	 directives in skipped conditional groups (6.10 p4).  */
+      if (CPP_OPTION (pfile, lang) == CLK_ASM)
+	skip = 0;
+      else if (!pfile->state.skipping)
+	cpp_error (pfile, "invalid preprocessing directive #%s",
+		   cpp_token_as_text (pfile, dname));
+    }
 
-	}
-      CPP_PUTC (pfile, c);
+  if (dir)
+    {
+      pfile->directive = dir;
+      (*pfile->directive->handler) (pfile);
     }
-}
+  else if (skip == 0)
+    _cpp_backup_tokens (pfile, 1);
 
-/* 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.  */
-void
-skip_rest_of_line (pfile)
-     cpp_reader *pfile;
-{
-  long old = CPP_WRITTEN (pfile);
-  copy_rest_of_line (pfile);
-  CPP_SET_WRITTEN (pfile, old);
+  end_directive (pfile, skip);
+  return skip;
 }
 
-/* Handle a possible # directive.
-   '#' has already been read.  */
-
-static int
-handle_directive (pfile)
+/* Directive handler wrapper used by the command line option
+   processor.  */
+static void
+run_directive (pfile, dir_no, buf, count)
+     cpp_reader *pfile;
+     int dir_no;
+     const char *buf;
+     size_t count;
+{
+  cpp_push_buffer (pfile, (const U_CHAR *) buf, count,
+		   /* from_stage3 */ true, 1);
+  start_directive (pfile);
+  /* We don't want a leading # to be interpreted as a directive.  */
+  pfile->buffer->saved_flags = 0;
+  pfile->directive = &dtable[dir_no];
+  (void) (*pfile->directive->handler) (pfile);
+  end_directive (pfile, 1);
+  _cpp_pop_buffer (pfile);
+}
+
+/* Checks for validity the macro name in #define, #undef, #ifdef and
+   #ifndef directives.  */
+static cpp_hashnode *
+lex_macro_node (pfile)
      cpp_reader *pfile;
 {
-  int c;
-  register struct directive *kt;
-  int ident_length;
-  U_CHAR *ident;
-  long old_written = CPP_WRITTEN (pfile);
-
-  cpp_skip_hspace (pfile);
+  cpp_hashnode *node;
+  const cpp_token *token = _cpp_lex_token (pfile);
+
+  /* The token immediately after #define must be an identifier.  That
+     identifier may not be "defined", per C99 6.10.8p4.
+     In C++, it may not be any of the "named operators" either,
+     per C++98 [lex.digraph], [lex.key].
+     Finally, the identifier may not have been poisoned.  (In that case
+     the lexer has issued the error message for us.)  */
+
+  if (token->type != CPP_NAME)
+    {
+      if (token->type == CPP_EOF)
+	cpp_error (pfile, "no macro name given in #%s directive",
+		   pfile->directive->name);
+      else if (token->flags & NAMED_OP)
+	cpp_error (pfile,
+	   "\"%s\" cannot be used as a macro name as it is an operator in C++",
+		   NODE_NAME (token->val.node));
+      else
+	cpp_error (pfile, "macro names must be identifiers");
 
-  c = PEEKC ();
-  if (c >= '0' && c <= '9')
-    {
-      /* Handle # followed by a line number.  */
-      if (CPP_PEDANTIC (pfile))
-	cpp_pedwarn (pfile, "`#' followed by integer");
-      do_line (pfile, NULL);
-      return 1;
+      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.  */
-      if (PEEKC() == '\n')
-	return 1;
-      else
-	return 0;
-    }
+  node = token->val.node;
+  if (node->flags & NODE_POISONED)
+    return 0;
 
-  /*
-   * Decode the keyword and call the appropriate expansion
-   * routine, after moving the input pointer up to the next line.
-   */
-  for (kt = directive_table; ; kt++)
+  if (node == pfile->spec_nodes.n_defined)
     {
-      if (kt->length <= 0)
-	return 0;
-      if (kt->length == ident_length
-	  && !strncmp (kt->name, ident, ident_length)) 
-	break;
+      cpp_error (pfile, "\"%s\" cannot be used as a macro name",
+		 NODE_NAME (node));
+      return 0;
     }
 
-  CPP_SET_WRITTEN (pfile, old_written);
-  (*kt->func) (pfile, kt);
-
-  return 1;
+  return node;
 }
 
-/* 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.  */
-
+/* Process a #define directive.  Most work is done in cppmacro.c.  */
 static void
-pass_thru_directive (buf, len, pfile, keyword)
-     U_CHAR *buf;
-     size_t len;
-     cpp_reader *pfile;
-     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.
-   ASSERTION is nonzero if this is really for an assertion name.  */
-
-int
-check_macro_name (pfile, symname, assertion)
-     cpp_reader *pfile;
-     U_CHAR *symname;
-     int assertion;
-{
-  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,
-	       assertion ? "invalid assertion name" : "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,
-	       (assertion
-		? "invalid assertion name `%s'"
-		: "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.  */
-
-static int
-do_define (pfile, keyword)
+do_define (pfile)
      cpp_reader *pfile;
-     struct directive *keyword;
 {
-  int hashcode;
-  MACRODEF mdef;
-  HASHNODE *hp;
-  long here;
-  U_CHAR *macro, *buf, *end;
-
-  here = CPP_WRITTEN (pfile);
-  copy_rest_of_line (pfile);
-
-  /* Copy out the line so we can pop the token buffer. */
-  buf = pfile->token_buffer + here;
-  end = CPP_PWRITTEN (pfile);
-  macro = alloca (end - buf + 1);
-  bcopy (buf, macro, end - buf + 1);
-  end = macro + (end - buf);
-
-  CPP_SET_WRITTEN (pfile, here);
-
-  mdef = create_definition (macro, end, pfile, keyword == NULL);
-  if (mdef.defn == 0)
-    return 0;
-
-  hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
-
-  if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
-    {
-      int ok = 0;
-      /* Redefining a precompiled key is ok.  */
-      if (hp->type == T_PCSTRING)
-	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 if it's not ok.  */
-      if (!ok)
-	{
-	  cpp_pedwarn (pfile, "`%.*s' redefined", mdef.symlen, mdef.symnam);
-	  if (hp->type == T_MACRO)
-	    cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file,
-					    hp->value.defn->line,
-			"this is the location of the previous definition");
-	}
-      /* Replace the old definition.  */
-      hp->type = T_MACRO;
-      hp->value.defn = mdef.defn;
-    }
-  else
-    cpp_install (pfile, mdef.symnam, mdef.symlen, T_MACRO,
-		 (char *) mdef.defn, hashcode);
+  cpp_hashnode *node = lex_macro_node (pfile);
 
-  if (keyword)
+  if (node)
     {
-      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);
+      if (_cpp_create_definition (pfile, node))
+	if (pfile->cb.define)
+	  (*pfile->cb.define) (pfile, pfile->directive_line, node);
     }
-
-  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)
+/* Handle #undef.  Mark the identifier NT_VOID in the hash table.  */
+static void
+do_undef (pfile)
      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;
-    }
+  cpp_hashnode *node = lex_macro_node (pfile);  
 
-  new = (cpp_buffer *) xcalloc (sizeof (cpp_buffer), 1);
+  /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
+     is not currently defined as a macro name.  */
+  if (node && node->type == NT_MACRO)
+    {
+      if (pfile->cb.undef)
+	(*pfile->cb.undef) (pfile, pfile->directive_line, node);
 
-  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;
+      if (node->flags & NODE_WARN)
+	cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
 
-  CPP_BUFFER (pfile) = new;
-  return new;
+      _cpp_free_definition (node);
+    }
+  check_eol (pfile);
 }
 
-cpp_buffer *
-cpp_pop_buffer (pfile)
+/* Helper routine used by parse_include.  Reinterpret the current line
+   as an h-char-sequence (< ... >); we are looking at the first token
+   after the <.  Returns the header as a token, or NULL on failure.  */
+static const cpp_token *
+glue_header_name (pfile)
      cpp_reader *pfile;
 {
-  cpp_buffer *buf = CPP_BUFFER (pfile);
-  (*buf->cleanup) (buf, pfile);
-  CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
-  free (buf);
-  pfile->buffer_stack_depth--;
-  return CPP_BUFFER (pfile);
-}
+  cpp_token *header = NULL;
+  const cpp_token *token;
+  unsigned char *dest;
+  size_t len;
 
-/* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
-   Pop the buffer when done.  */
+  /* To avoid lexed tokens overwriting our glued name, we can only
+     allocate from the string pool once we've lexed everything.  */
 
-void
-cpp_scan_buffer (pfile)
-     cpp_reader *pfile;
-{
-  cpp_buffer *buffer = CPP_BUFFER (pfile);
+  dest = BUFF_FRONT (pfile->u_buff);
   for (;;)
     {
-      enum cpp_token token = cpp_get_token (pfile);
-      if (token == CPP_EOF) /* Should not happen ...  */
+      token = cpp_get_token (pfile);
+
+      if (token->type == CPP_GREATER || token->type == CPP_EOF)
 	break;
-      if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
+
+      /* + 1 for terminating NUL.  */
+      len = cpp_token_len (token) + 1;
+      if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
 	{
-	  cpp_pop_buffer (pfile);
-	  break;
+	  size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
+	  _cpp_extend_buff (pfile, &pfile->u_buff, len);
+	  dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
 	}
-    }
-}
 
-/*
- * 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;
-     U_CHAR *buf;
-     int length;
-{
-  register cpp_buffer *ip;
-#if 0
-  cpp_buffer obuf;
-#endif
-  U_CHAR *buf1;
-#if 0
-  int odepth = indepth;
-#endif
+      if (token->flags & PREV_WHITE)
+	*dest++ = ' ';
 
-  if (length < 0)
-    {
-      cpp_fatal (pfile, "internal error: length < 0 in cpp_expand_to_buffer");
-      return;
+      dest = cpp_spell_token (pfile, token, dest);
     }
 
-  /* 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;
-#if 0
-  ip->lineno = obuf.lineno = 1;
-#endif
-
-  /* Scan the input, create the output.  */
-  cpp_scan_buffer (pfile);
-
-  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;
-    }
+  if (token->type == CPP_EOF)
+    cpp_error (pfile, "missing terminating > character");
   else
     {
-      *linep = 0;
-      if (colp)
-	*colp = 0;
+      header = _cpp_temp_token (pfile);
+      header->type = CPP_HEADER_NAME;
+      header->flags = 0;
+      header->val.str.len = dest - BUFF_FRONT (pfile->u_buff);
+      header->val.str.text = BUFF_FRONT (pfile->u_buff);
+      *dest++ = '\0';
+      BUFF_FRONT (pfile->u_buff) = dest;
     }
-}
-
-/* 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;
+  return header;
 }
 
-/*
- * 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)
+/* Returns the header string of #include, #include_next, #import and
+   #pragma dependency.  Returns NULL on error.  */
+static const cpp_token *
+parse_include (pfile)
      cpp_reader *pfile;
-     enum file_change_code file_change;
 {
-  long line;
-  cpp_buffer *ip = CPP_BUFFER (pfile);
-
-  if (ip->fname == NULL)
-    return;
+  const unsigned char *dir;
+  const cpp_token *header;
 
-  if (CPP_OPTIONS (pfile)->no_line_commands
-      || CPP_OPTIONS (pfile)->no_output)
-    return;
-
-  cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, NULL);
+  if (pfile->directive == &dtable[T_PRAGMA])
+    dir = U"pragma dependency";
+  else
+    dir = pfile->directive->name;
 
-  /* 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)
+  /* Allow macro expansion.  */
+  header = cpp_get_token (pfile);
+  if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
     {
-      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)
+      if (header->type != CPP_LESS)
 	{
-	  CPP_RESERVE (pfile, 20);
-	  while (line > pfile->lineno)
-	    {
-	      CPP_PUTC_Q (pfile, '\n');
-	      pfile->lineno++;
-	    }
-	  return;
+	  cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
+	  return NULL;
 	}
-    }
 
-  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');
+      header = glue_header_name (pfile);
+      if (header == NULL)
+	return header;
     }
-  /* 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.  */
-
-static enum cpp_token
-get_directive_token (pfile)
-     cpp_reader *pfile;
-{
-  for (;;)
+  if (header->val.str.len == 0)
     {
-      long old_written = CPP_WRITTEN (pfile);
-      enum cpp_token token;
-      cpp_skip_hspace (pfile);
-      if (PEEKC () == '\n')
-	  return CPP_VSPACE;
-      token = cpp_get_token (pfile);
-      switch (token)
-      {
-      case CPP_POP:
-	  if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
-	      return token;
-	  /* ... else fall though ...  */
-      case CPP_HSPACE:  case CPP_COMMENT:
-	  CPP_SET_WRITTEN (pfile, old_written);
-	  break;
-      default:
-	  return token;
-      }
+      cpp_error (pfile, "empty file name in #%s", dir);
+      return NULL;
     }
-}
-
-/* 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.  */
+  return header;
+}
 
-static int
-do_include (pfile, keyword)
+/* Handle #include, #include_next and #import.  */
+static void
+do_include_common (pfile, type)
      cpp_reader *pfile;
-     struct directive *keyword;
+     enum include_type type;
 {
-  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;
+  const cpp_token *header;
 
-  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)
+  /* For #include_next, if this is the primary source file, warn and
+     use the normal search logic.  */
+  if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
     {
-      if (importing)
-	cpp_pedwarn (pfile, "ANSI C does not allow `#import'");
-      if (skip_dirs)
-	cpp_pedwarn (pfile, "ANSI C does not allow `#include_next'");
+      cpp_warning (pfile, "#include_next in primary source file");
+      type = IT_INCLUDE;
     }
-
-  if (importing && CPP_OPTIONS (pfile)->warn_import
-      && !CPP_OPTIONS (pfile)->inhibit_warnings
-      && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
+  else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
     {
-      pfile->import_warning = 1;
+      CPP_OPTION (pfile, warn_import) = 0;
       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 = 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)
+  header = parse_include (pfile);
+  if (header)
     {
-      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_fatal (pfile, "cpp internal error: 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;
+      /* Prevent #include recursion.  */
+      if (pfile->line_maps.depth >= CPP_STACK_MAX)
+	cpp_fatal (pfile, "#include nested too deeply");
       else
-        {
-	  if (!CPP_OPTIONS (pfile)->ignore_srcdir)
-	    {
-	      if (fp)
-		search_start = fp->actual_dir;
-	    }
-	  else
-	    search_start = CPP_OPTIONS (pfile)->quote_include;
+	{
+	  check_eol (pfile);
+	  /* Get out of macro context, if we are.  */
+	  skip_rest_of_line (pfile);
+	  if (pfile->cb.include)
+	    (*pfile->cb.include) (pfile, pfile->directive_line,
+				  pfile->directive->name, header);
+
+	  _cpp_execute_include (pfile, header, type);
 	}
     }
+}
 
-  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);
+static void
+do_include (pfile)
+     cpp_reader *pfile;
+{
+  do_include_common (pfile, IT_INCLUDE);
+}
 
-  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);
+static void
+do_import (pfile)
+     cpp_reader *pfile;
+{
+  do_include_common (pfile, IT_IMPORT);
+}
 
-      return 0;
-    }
+static void
+do_include_next (pfile)
+     cpp_reader *pfile;
+{
+  do_include_common (pfile, IT_INCLUDE_NEXT);
+}
 
-  /* 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, ' ');
+/* Subroutine of do_line.  Read possible flags after file name.  LAST
+   is the last flag seen; 0 if this is the first flag. Return the flag
+   if it is valid, 0 at the end of the directive. Otherwise complain.  */
+static unsigned int
+read_flag (pfile, last)
+     cpp_reader *pfile;
+     unsigned int last;
+{
+  const cpp_token *token = _cpp_lex_token (pfile);
 
-  /* Handle -H option.  */
-  if (CPP_OPTIONS(pfile)->print_include_names)
+  if (token->type == CPP_NUMBER && token->val.str.len == 1)
     {
-      fp = CPP_BUFFER (pfile);
-      while ((fp = CPP_PREV_BUFFER (fp)) != CPP_NULL_BUFFER (pfile))
-	putc ('.', stderr);
-      fprintf (stderr, " %s\n", ihash->name);
-    }
+      unsigned int flag = token->val.str.text[0] - '0';
 
-  /* Actually process the file */
-
-  if (importing)
-    ihash->control_macro = "";
-  
-  if (cpp_push_buffer (pfile, NULL, 0) == NULL)
-    {
-      close (fd);
-      return 0;
+      if (flag > last && flag <= 4
+	  && (flag != 4 || last == 3)
+	  && (flag != 2 || last == 0))
+	return flag;
     }
-  
-  if (angle_brackets)
-    pfile->system_include_depth++;   /* Decremented in file_cleanup. */
 
-  if (finclude (pfile, fd, ihash))
+  if (token->type != CPP_EOF)
+    cpp_error (pfile, "invalid flag \"%s\" in line directive",
+	       cpp_token_as_text (pfile, token));
+  return 0;
+}
+
+/* Another subroutine of do_line.  Convert a number in STR, of length
+   LEN, to binary; store it in NUMP, and return 0 if the number was
+   well-formed, 1 if not.  Temporary, hopefully.  */
+static int
+strtoul_for_line (str, len, nump)
+     const U_CHAR *str;
+     unsigned int len;
+     unsigned long *nump;
+{
+  unsigned long reg = 0;
+  U_CHAR c;
+  while (len--)
     {
-      output_line_command (pfile, enter_file);
-      pfile->only_seen_white = 2;
+      c = *str++;
+      if (!ISDIGIT (c))
+	return 1;
+      reg *= 10;
+      reg += c - '0';
     }
-
+  *nump = reg;
   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)
+static void
+do_line (pfile)
      cpp_reader *pfile;
-     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;
+  const cpp_token *token;
+  const char *new_file = pfile->map->to_file;
+  unsigned long new_lineno;
+  unsigned int cap, new_sysp = pfile->map->sysp;
+  enum lc_reason reason = LC_RENAME;
 
-  token = get_directive_token (pfile);
+  /* C99 raised the minimum limit on #line numbers.  */
+  cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
 
-  if (token != CPP_NUMBER)
-    {
-      cpp_error (pfile, "token after `#line' is not an integer");
-      goto bad_line_directive;
-    }
+  /* Putting this in _cpp_handle_directive risks two calls to
+     _cpp_backup_tokens in some circumstances, which can segfault.  */
+  if (pfile->state.line_extension)
+    _cpp_backup_tokens (pfile, 1);
 
-  new_lineno = strtol (pfile->token_buffer + old_written, &x, 10);
-  if (x[0] != '\0')
+  /* #line commands expand macros.  */
+  token = cpp_get_token (pfile);
+  if (token->type != CPP_NUMBER
+      || strtoul_for_line (token->val.str.text, token->val.str.len,
+			   &new_lineno))
     {
-      cpp_error (pfile, "token after `#line' is not an integer");
-      goto bad_line_directive;
+      cpp_error (pfile, "\"%s\" after #line is not a positive integer",
+		 cpp_token_as_text (pfile, token));
+      return;
     }      
-  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 (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension
+      && (new_lineno == 0 || new_lineno > cap))
+    cpp_pedwarn (pfile, "line number out of range");
 
-  if (token == CPP_STRING)
+  token = cpp_get_token (pfile);
+  if (token->type == CPP_STRING)
     {
-      U_CHAR *fname = pfile->token_buffer + old_written + 1;
-      U_CHAR *end_name = CPP_PWRITTEN (pfile) - 1;
-      long num_start = CPP_WRITTEN (pfile);
+      new_file = (const char *) token->val.str.text;
 
-      token = get_directive_token (pfile);
-      if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
+      /* Only accept flags for the # 55 form.  */
+      if (pfile->state.line_extension)
 	{
-	  U_CHAR *p = pfile->token_buffer + num_start;
-	  if (CPP_PEDANTIC (pfile))
-	    cpp_pedwarn (pfile, "garbage at end of `#line' command");
+	  int flag;
 
-	  if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
+	  new_sysp = 0;
+	  flag = read_flag (pfile, 0);
+	  if (flag == 1)
 	    {
-	      cpp_error (pfile, "invalid format `#line' command");
-	      goto bad_line_directive;
+	      reason = LC_ENTER;
+	      /* Fake an include for cpp_included ().  */
+	      _cpp_fake_include (pfile, new_file);
+	      flag = read_flag (pfile, flag);
 	    }
-	  if (*p == '1')
-	    file_change = enter_file;
-	  else if (*p == '2')
-	    file_change = leave_file;
-	  else if (*p == '3')
-	    ip->system_header_p = 1;
-	  else /* if (*p == '4') */
-	    ip->system_header_p = 2;
-
-	  CPP_SET_WRITTEN (pfile, num_start);
-	  token = get_directive_token (pfile);
-	  p = pfile->token_buffer + num_start;
-	  if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4'))
+	  else if (flag == 2)
 	    {
-	      ip->system_header_p = *p == '3' ? 1 : 2;
-	      token = get_directive_token (pfile);
+	      reason = LC_LEAVE;
+	      flag = read_flag (pfile, flag);
 	    }
-	  if (token != CPP_VSPACE)
+	  if (flag == 3)
 	    {
-	      cpp_error (pfile, "invalid format `#line' command");
-	      goto bad_line_directive;
+	      new_sysp = 1;
+	      flag = read_flag (pfile, flag);
+	      if (flag == 4)
+		new_sysp = 2;
 	    }
 	}
-      
-      *end_name = '\0';
-      
-      if (strcmp (fname, ip->nominal_fname))
-	{
-	  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 (ip->last_nominal_fname);
-
-	  if (newname == ip->fname)
-	    ip->last_nominal_fname = NULL;
-	  else
-	    ip->last_nominal_fname = oldname;
-	} 
+      check_eol (pfile);
     }
-  else if (token != CPP_VSPACE && token != CPP_EOF)
+  else if (token->type != CPP_EOF)
     {
-      cpp_error (pfile, "token after `#line %d' is not a string", new_lineno);
-      goto bad_line_directive;
+      cpp_error (pfile, "\"%s\" is not a valid filename",
+		 cpp_token_as_text (pfile, token));
+      return;
     }
 
-  /* 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;
+  _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
 }
 
-/* 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)
+/* Arrange the file_change callback.  pfile->line has changed to
+   FILE_LINE of TO_FILE, for reason REASON.  SYSP is 1 for a system
+   header, 2 for a system header that needs to be extern "C" protected,
+   and zero otherwise.  */
+void
+_cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
      cpp_reader *pfile;
-     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 = 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, 0);
-
-  while ((hp = cpp_lookup (pfile, name, sym_length, -1)) != 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_MACRO)
-	cpp_warning (pfile, "undefining `%s'", hp->name);
-      delete_macro (hp);
-    }
+     enum lc_reason reason;
+     const char *to_file;
+     unsigned int file_line;
+     unsigned int sysp;
+{
+  pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
+			     pfile->line, to_file, file_line);
 
-  return 0;
+  if (pfile->cb.file_change)
+    (*pfile->cb.file_change) (pfile, pfile->map);
 }
 
-/* Wrap do_undef for -U processing. */
-void
-cpp_undef (pfile, macro)
+/* Report a warning or error detected by the program we are
+   processing.  Use the directive's tokens in the error message.  */
+static void
+do_diagnostic (pfile, code, print_dir)
      cpp_reader *pfile;
-     U_CHAR *macro;
+     enum error_type code;
+     int print_dir;
 {
-  if (cpp_push_buffer (pfile, macro, strlen (macro)))
+  if (_cpp_begin_message (pfile, code, 0, 0))
     {
-      do_undef (pfile, NULL);
-      cpp_pop_buffer (pfile);
+      if (print_dir)
+	fprintf (stderr, "#%s ", pfile->directive->name);
+      pfile->state.prevent_expansion++;
+      cpp_output_line (pfile, stderr);
+      pfile->state.prevent_expansion--;
     }
 }
 
-
-/*
- * 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)
+static void
+do_error (pfile)
      cpp_reader *pfile;
-     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;
+  do_diagnostic (pfile, ERROR, 1);
 }
 
-/*
- * 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)
+static void
+do_warning (pfile)
      cpp_reader *pfile;
-     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;
+  /* We want #warning diagnostics to be emitted in system headers too.  */
+  do_diagnostic (pfile, WARNING_SYSHDR, 1);
 }
 
-/* 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)
+/* Report program identification.  */
+static void
+do_ident (pfile)
      cpp_reader *pfile;
-     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'");
+  const cpp_token *str = cpp_get_token (pfile);
 
-  CPP_PUTS (pfile, "#ident ", 7);
-  cpp_skip_hspace (pfile);
-  copy_rest_of_line (pfile);
+  if (str->type != CPP_STRING)
+    cpp_error (pfile, "invalid #ident directive");
+  else if (pfile->cb.ident)
+    (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
 
-  return 0;
+  check_eol (pfile);
 }
 
-/* Just check for some recognized pragmas that need validation here,
-   and leave the text in the token buffer to be output. */
+/* Lookup a PRAGMA name in a singly-linked CHAIN.  Returns the
+   matching entry, or NULL if none is found.  The returned entry could
+   be the start of a namespace chain, or a pragma.  */
+static struct pragma_entry *
+lookup_pragma_entry (chain, pragma)
+     struct pragma_entry *chain;
+     const cpp_hashnode *pragma;
+{
+  while (chain && chain->pragma != pragma)
+    chain = chain->next;
 
-static int
-do_pragma (pfile, keyword)
+  return chain;
+}
+
+/* Create and insert a pragma entry for NAME at the beginning of a
+   singly-linked CHAIN.  If handler is NULL, it is a namespace,
+   otherwise it is a pragma and its handler.  */
+static struct pragma_entry *
+insert_pragma_entry (pfile, chain, pragma, handler)
      cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+     struct pragma_entry **chain;
+     const cpp_hashnode *pragma;
+     pragma_cb handler;
 {
-  long here;
-  U_CHAR *buf;
+  struct pragma_entry *new;
 
-  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))
+  new = (struct pragma_entry *)
+    _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
+  new->pragma = pragma;
+  if (handler)
     {
-      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 */
+      new->is_nspace = 0;
+      new->u.handler = handler;
     }
-  else if (!strncmp (buf, "implementation", 14))
+  else
     {
-      /* 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 = 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);
+      new->is_nspace = 1;
+      new->u.space = NULL;
     }
 
-  return 0;
+  new->next = *chain;
+  *chain = new;
+  return new;
 }
 
-#ifdef SCCS_DIRECTIVE
-/* Just ignore #sccs, on systems where we define it at all.  */
-
-static int
-do_sccs (pfile, keyword)
+/* Register a pragma NAME in namespace SPACE.  If SPACE is null, it
+   goes in the global namespace.  HANDLER is the handler it will call,
+   which must be non-NULL.  */
+void
+cpp_register_pragma (pfile, space, name, handler)
      cpp_reader *pfile;
-     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;
+     const char *space;
+     const char *name;
+     pragma_cb handler;
+{
+  struct pragma_entry **chain = &pfile->pragmas;
+  struct pragma_entry *entry;
+  const cpp_hashnode *node;
+
+  if (!handler)
+    abort ();
+
+  if (space)
+    {
+      node = cpp_lookup (pfile, U space, strlen (space));
+      entry = lookup_pragma_entry (*chain, node);
+      if (!entry)
+	entry = insert_pragma_entry (pfile, chain, node, NULL);
+      else if (!entry->is_nspace)
+	goto clash;
+      chain = &entry->u.space;
+    }
+
+  /* Check for duplicates.  */
+  node = cpp_lookup (pfile, U name, strlen (name));
+  entry = lookup_pragma_entry (*chain, node);
+  if (entry)
+    {
+      if (entry->is_nspace)
+	clash:
+	cpp_ice (pfile,
+		 "registering \"%s\" as both a pragma and a pragma namespace",
+		 NODE_NAME (node));
+      else if (space)
+	cpp_ice (pfile, "#pragma %s %s is already registered", space, name);
+      else
+	cpp_ice (pfile, "#pragma %s is already registered", name);
+    }
+  else
+    insert_pragma_entry (pfile, chain, node, handler);
 }
-#endif
-
-/*
- * 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)
+/* Register the pragmas the preprocessor itself handles.  */
+void
+_cpp_init_internal_pragmas (pfile)
      cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
 {
-  HOST_WIDEST_INT value = eval_if_expression (pfile);
-  conditional_skip (pfile, value == 0, T_IF, NULL_PTR);
-  return 0;
-}
+  /* Pragmas in the global namespace.  */
+  cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
+  cpp_register_pragma (pfile, 0, "once", do_pragma_once);
 
-/*
- * 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;
-     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'");
-#if 0
-      fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
-#endif
-      if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL
-	  && strcmp (pfile->if_stack->fname,
-		     CPP_BUFFER (pfile)->nominal_fname) != 0)
-	fprintf (stderr, ", file %s", pfile->if_stack->fname);
-      fprintf (stderr, ")\n");
-    }
-    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;
+  /* New GCC-specific pragmas should be put in the GCC namespace.  */
+  cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
+  cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
+  cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
 }
 
-/*
- * 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)
+/* Pragmata handling.  We handle some, and pass the rest on to the
+   front end.  C99 defines three pragmas and says that no macro
+   expansion is to be performed on them; whether or not macro
+   expansion happens for other pragmas is implementation defined.
+   This implementation never macro-expands the text after #pragma.  */
+static void
+do_pragma (pfile)
      cpp_reader *pfile;
 {
-  HOST_WIDEST_INT value;
-  long old_written = CPP_WRITTEN (pfile);
-
-  pfile->pcp_inside_if = 1;
-  value = cpp_parse_expr (pfile);
-  pfile->pcp_inside_if = 0;
+  const struct pragma_entry *p = NULL;
+  const cpp_token *token;
+  unsigned int count = 1;
 
-  CPP_SET_WRITTEN (pfile, old_written); /* Pop */
+  pfile->state.prevent_expansion++;
 
-  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;
-     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)
+  token = cpp_get_token (pfile);
+  if (token->type == CPP_NAME)
     {
-      HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
-      skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
-      if (start_of_file && !skip)
+      p = lookup_pragma_entry (pfile->pragmas, token->val.node);
+      if (p && p->is_nspace)
 	{
-	  control_macro = (U_CHAR *) xmalloc (ident_length + 1);
-	  bcopy (ident, control_macro, ident_length + 1);
+	  count = 2;
+	  token = cpp_get_token (pfile);
+	  if (token->type == CPP_NAME)
+	    p = lookup_pragma_entry (p->u.space, token->val.node);
+	  else
+	    p = NULL;
 	}
     }
-  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);
+  /* FIXME.  This is an awful kludge to get the front ends to update
+     their notion of line number for diagnostic purposes.  The line
+     number should be passed to the handler and they should do it
+     themselves.  Stand-alone CPP must ignore us, otherwise it will
+     prefix the directive with spaces, hence the 1.  Ugh.  */
+  if (pfile->cb.line_change)
+    (*pfile->cb.line_change)(pfile, token, 1);
 
-#if 0
-    if (pcp_outfile) {
-      /* Output a precondition for this macro.  */
-      if (hp && hp->value.defn->predefined)
-	fprintf (pcp_outfile, "#define %s\n", hp->name);
-      else {
-	U_CHAR *cp = buf;
-	fprintf (pcp_outfile, "#undef ");
-	while (is_idchar[*cp]) /* Ick! */
-	  fputc (*cp++, pcp_outfile);
-	putc ('\n', pcp_outfile);
-      }
-#endif
+  if (p)
+    (*p->u.handler) (pfile);
+  else if (pfile->cb.def_pragma)
+    {
+      _cpp_backup_tokens (pfile, count);
+      (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
+    }
 
-  conditional_skip (pfile, skip, T_IF, control_macro);
-  return 0;
+  pfile->state.prevent_expansion--;
 }
 
-/* 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.  */
-
+/* Handle #pragma once.  */
 static void
-conditional_skip (pfile, skip, type, control_macro)
+do_pragma_once (pfile)
      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;
-#if 0
-  temp->lineno = CPP_BUFFER (pfile)->lineno;
-#endif
-  temp->next = pfile->if_stack;
-  temp->control_macro = control_macro;
-  pfile->if_stack = temp;
-
-  pfile->if_stack->type = type;
+  cpp_warning (pfile, "#pragma once is obsolete");
+ 
+  if (pfile->buffer->prev == NULL)
+    cpp_warning (pfile, "#pragma once in main file");
+  else
+    _cpp_never_reread (pfile->buffer->inc);
 
-  if (skip != 0) {
-    skip_if_group (pfile);
-    return;
-  } else {
-    ++pfile->if_stack->if_succeeded;
-    output_line_command (pfile, same_file);
-  }
+  check_eol (pfile);
 }
 
-/* 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. */
+/* Handle #pragma poison, to poison one or more identifiers so that
+   the lexer produces a hard error for each subsequent usage.  */
+static void
+do_pragma_poison (pfile)
+     cpp_reader *pfile;
+{
+  const cpp_token *tok;
+  cpp_hashnode *hp;
 
-static int
-consider_directive_while_skipping (pfile, stack)
-    cpp_reader *pfile;
-    IF_STACK_FRAME *stack; 
-{
-  long ident_len, ident;
-  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)
+  pfile->state.poisoned_ok = 1;
+  for (;;)
+    {
+      tok = _cpp_lex_token (pfile);
+      if (tok->type == CPP_EOF)
+	break;
+      if (tok->type != CPP_NAME)
 	{
-	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 (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
-	      validate_else (pfile, "#else");
-	    /* fall through */
-	case T_ELIF:
-	    if (pfile->if_stack->type == T_ELSE)
-	      cpp_error (pfile, "`%s' after `#else'", kt->name);
-	    
-	    if (pfile->if_stack == stack)
-	      return 1;
-	    else
-	      {
-		pfile->if_stack->type = kt->type;
-		return 0;
-	      }
-
-	    case T_ENDIF:
-		if (CPP_PEDANTIC (pfile) && 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;
-	    }
+	  cpp_error (pfile, "invalid #pragma GCC poison directive");
+	  break;
+	}
 
-    /* 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;
+      hp = tok->val.node;
+      if (hp->flags & NODE_POISONED)
+	continue;
+
+      if (hp->type == NT_MACRO)
+	cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
+      _cpp_free_definition (hp);
+      hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
+    }
+  pfile->state.poisoned_ok = 0;
 }
 
-/* skip to #endif, #else, or #elif.  adjust line numbers, etc.
- * leaves input ptr at the sharp sign found.
- */
+/* Mark the current header as a system header.  This will suppress
+   some categories of warnings (notably those from -pedantic).  It is
+   intended for use in system libraries that cannot be implemented in
+   conforming C, but cannot be certain that their headers appear in a
+   system include directory.  To prevent abuse, it is rejected in the
+   primary source file.  */
 static void
-skip_if_group (pfile)
-    cpp_reader *pfile;
+do_pragma_system_header (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;
+  cpp_buffer *buffer = pfile->buffer;
 
-  if (CPP_OPTIONS (pfile)->output_conditionals)
+  if (buffer->prev == 0)
+    cpp_warning (pfile, "#pragma system_header ignored outside include file");
+  else
     {
-      CPP_PUTS (pfile, "#failed\n", 8);
-      pfile->lineno++;
-      output_line_command (pfile, same_file);
+      check_eol (pfile);
+      skip_rest_of_line (pfile);
+      cpp_make_system_header (pfile, 1, 0);
     }
+}
 
-  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 */
-	}
+/* Check the modified date of the current include file against a specified
+   file. Issue a diagnostic, if the specified file is newer. We use this to
+   determine if a fixed header should be refixed.  */
+static void
+do_pragma_dependency (pfile)
+     cpp_reader *pfile;
+{
+  const cpp_token *header;
+  int ordering;
+ 
+  header = parse_include (pfile);
+  if (!header)
+    return;
 
-      c = GETC();
-      if (c == EOF)
-	return;	 /* Caller will issue error. */
-      else
+  ordering = _cpp_compare_file_date (pfile, header);
+  if (ordering < 0)
+    cpp_warning (pfile, "cannot find source %s",
+		 cpp_token_as_text (pfile, header));
+  else if (ordering > 0)
+    {
+      cpp_warning (pfile, "current file is older than %s",
+		   cpp_token_as_text (pfile, header));
+      if (cpp_get_token (pfile)->type != CPP_EOF)
 	{
-	  /* \n */
-	  if (CPP_OPTIONS (pfile)->output_conditionals)
-	    {
-	      CPP_PUTC (pfile, c);
-	      pfile->lineno++;
-	    }
-	  CPP_BUMP_LINE (pfile);
+	  _cpp_backup_tokens (pfile, 1);
+	  do_diagnostic (pfile, WARNING, 0);
 	}
-    }	  
-
-  /* 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)
+/* Get a token but skip padding.  */
+static const cpp_token *
+get_token_no_padding (pfile)
      cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
 {
-  cpp_buffer *ip = CPP_BUFFER (pfile);
-
-  if (CPP_PEDANTIC (pfile))
-    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'");
-      fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
-      if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0)
-	fprintf (stderr, ", file %s", pfile->if_stack->fname);
-      fprintf (stderr, ")\n");
+  for (;;)
+    {
+      const cpp_token *result = cpp_get_token (pfile);
+      if (result->type != CPP_PADDING)
+	return result;
     }
-    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)
+/* Check syntax is "(string-literal)".  Returns the string on success,
+   or NULL on failure.  */
+static const cpp_token *
+get__Pragma_string (pfile)
      cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
 {
-  if (CPP_PEDANTIC (pfile))
-    validate_else (pfile, "#endif");
-  skip_rest_of_line (pfile);
+  const cpp_token *string;
 
-  if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
-    cpp_error (pfile, "unbalanced `#endif'");
-  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;
+  if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
+    return NULL;
 
-	  parse_set_mark (pfile);
+  string = get_token_no_padding (pfile);
+  if (string->type != CPP_STRING && string->type != CPP_WSTRING)
+    return NULL;
 
-	  for (;;)
-	    {
-	      cpp_skip_hspace (pfile);
-	      c = GETC ();
-	      if (c != '\n')
-		break;
-	    }
-	  parse_goto_mark (pfile);
+  if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
+    return NULL;
 
-	  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;
+  return string;
 }
 
-/* When an #else or #endif is found while skipping failed conditional,
-   if -pedantic was specified, this is called to warn about text after
-   the command name.  P points to the first char after the command name.  */
-
+/* Destringize IN into a temporary buffer, by removing the first \ of
+   \" and \\ sequences, and process the result as a #pragma directive.  */
 static void
-validate_else (pfile, directive)
+destringize_and_run (pfile, in)
      cpp_reader *pfile;
-     char *directive;
+     const cpp_string *in;
 {
-  int c;
-  cpp_skip_hspace (pfile);
-  c = PEEKC ();
-  if (c != EOF && c != '\n')
-    cpp_pedwarn (pfile,
-		 "text following `%s' violates ANSI standard", directive);
+  const unsigned char *src, *limit;
+  char *dest, *result;
+
+  dest = result = alloca (in->len + 1);
+  for (src = in->text, limit = src + in->len; src < limit;)
+    {
+      /* We know there is a character following the backslash.  */
+      if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
+	src++;
+      *dest++ = *src++;
+    }
+  *dest = '\0';
+
+  run_directive (pfile, T_PRAGMA, result, dest - result);
 }
 
-/* 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)
+/* Handle the _Pragma operator.  */
+void
+_cpp_do__Pragma (pfile)
      cpp_reader *pfile;
 {
-  register int c, c2, c3;
-  enum cpp_token token;
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
+  const cpp_token *string = get__Pragma_string (pfile);
 
- get_next:
-  c = GETC();
-  if (c == EOF)
-    {
-    handle_eof:
-      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));
-	  CPP_BUFFER (pfile)->seen_eof = 1;
-	  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;
-	    }
-	  return CPP_POP;
-	}
-    }
+  if (!string)
+    cpp_error (pfile, "_Pragma takes a parenthesized string literal");
   else
     {
-      switch (c)
-	{
-	case '/':
-	  if (PEEKC () == '=')
-	    goto op2;
+      /* Ideally, we'd like
+			token1 _Pragma ("foo") token2
+	 to be output as
+			token1
+			# 7 "file.c"
+			#pragma foo
+			# 7 "file.c"
+					       token2
+	 Getting these correct line markers is a little tricky.  */
 
-	comment:
-	  if (opts->put_out_comments)
-	    c = copy_comment (pfile, c);
-	  else
-	    c = skip_comment (pfile, c);
-	  if (c == EOF)
-	    goto handle_eof;
-	  else if (c != ' ')
-	    goto randomchar;
-	  
-	  /* Comments are equivalent to spaces.
-	     For -traditional, a comment is equivalent to nothing.  */
-	  if (opts->traditional || opts->put_out_comments)
-	    return CPP_COMMENT;
-	  else
-	    {
-	      CPP_PUTC (pfile, c);
-	      return CPP_HSPACE;
-	    }
-#if 0
-	  if (opts->for_lint) {
-	    U_CHAR *argbp;
-	    int cmdlen, arglen;
-	    char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
-	    
-	    if (lintcmd != NULL) {
-	      /* I believe it is always safe to emit this newline: */
-	      obp[-1] = '\n';
-	      bcopy ("#pragma lint ", (char *) obp, 13);
-	      obp += 13;
-	      bcopy (lintcmd, (char *) obp, cmdlen);
-	      obp += cmdlen;
-
-	      if (arglen != 0) {
-		*(obp++) = ' ';
-		bcopy (argbp, (char *) obp, arglen);
-		obp += arglen;
-	      }
-
-	      /* OK, now bring us back to the state we were in before we entered
-		 this branch.  We need #line because the newline for the pragma
-		 could mess things up.  */
-	      output_line_command (pfile, same_file);
-	      *(obp++) = ' ';	/* just in case, if comments are copied thru */
-	      *(obp++) = '/';
-	    }
-	  }
-#endif
+      unsigned int orig_line = pfile->line;
+      destringize_and_run (pfile, &string->val.str);
+      pfile->line = orig_line;
+      pfile->buffer->saved_flags = BOL;
+    }
+}
 
-	case '#':
-#if 0
-	  /* If this is expanding a macro definition, don't recognize
-	     preprocessor directives.  */
-	  if (ip->macro != 0)
-	    goto randomchar;
-	  /* If this is expand_into_temp_buffer, recognize them
-	     only after an actual newline at this level,
-	     not at the beginning of the input level.  */
-	  if (ip->fname == 0 && beg_of_line == ip->buf)
-	    goto randomchar;
-	  if (ident_length)
-	    goto specialchar;
+/* Just ignore #sccs, on systems where we define it at all.  */
+#ifdef SCCS_DIRECTIVE
+static void
+do_sccs (pfile)
+     cpp_reader *pfile ATTRIBUTE_UNUSED;
+{
+}
 #endif
 
-	  if (!pfile->only_seen_white)
-	    goto randomchar;
-	  if (handle_directive (pfile))
-	    return CPP_DIRECTIVE;
-	  pfile->only_seen_white = 0;
-	  return CPP_OTHER;
-
-	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 == '=' || c2 == '>')
-	    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_fatal (pfile,
-				  "internal error: unrecognized escape \\r%c",
-				       d);
-			  CPP_ADJUST_WRITTEN (pfile, -1);
-			}			  
-		    }
-		}
-	      return CPP_STRING;
-	    }
-	  /* else fall through */
-	case '>':
-	  c2 = PEEKC ();
-	  if (c2 == '=')
-	    goto op2;
-	  if (c2 != c)
-	    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;
-	    }
-	  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;
+/* Handle #ifdef.  */
+static void
+do_ifdef (pfile)
+     cpp_reader *pfile;
+{
+  int skip = 1;
 
-	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, -1);
-	    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.
-	       first skip all whitespace, copying it to the output
-	       after the macro name.  Then, if there is no '(',
-	       decide this is not a macro call and leave things that way.  */
-	    if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
-	    {
-	      int is_macro_call, macbuf_whitespace = 0;
-
-	      parse_set_mark (pfile);
-	      for (;;)
-		{
-		  cpp_skip_hspace (pfile);
-		  c = PEEKC ();
-		  is_macro_call = c == '(';
-		  if (c != EOF)
-		    {
-		      if (c != '\n')
-		        break;
-		      FORWARD (1);
-		    }
-                  else
-                    {
-                      if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
-                        {
-                          if (CPP_BUFFER (pfile)->mark !=
-                              (CPP_BUFFER (pfile)->cur
-                               - CPP_BUFFER (pfile)->buf))
-                             macbuf_whitespace = 1;
-
-			  /* The mark goes away automatically when
-			     the buffer is popped. */
-                          cpp_pop_buffer (pfile);
-                          parse_set_mark (pfile);
-                        }
-                      else
-                        break;
-                    }
-		}
-	      if (!is_macro_call)
-                {
-                  parse_goto_mark (pfile);
-                  if (macbuf_whitespace)
-                    CPP_PUTC (pfile, ' ');
-                }
-	      else
-		parse_clear_mark (pfile);
-	      if (!is_macro_call)
-		return CPP_NAME;
-	    }
-	    /* 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_hor_space[c])
-		break;
-	      FORWARD(1);
-	    }
-	  return CPP_HSPACE;
+  if (! pfile->state.skipping)
+    {
+      const cpp_hashnode *node = lex_macro_node (pfile);
 
-	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_fatal (pfile,
-			     "internal error: unrecognized escape \\r%c", c);
-		  goto get_next;
-		}
-	    }
-	  else
-	    {
-	      /* Backslash newline is ignored. */
-	      CPP_BUMP_LINE (pfile);
-	      goto get_next;
-	    }
+      if (node)
+	skip = node->type != NT_MACRO;
 
-	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;
-	}
+      if (node)
+	check_eol (pfile);
     }
-}
 
-/* Like cpp_get_token, but skip spaces and comments.  */
+  push_conditional (pfile, skip, T_IFDEF, 0);
+}
 
-enum cpp_token
-cpp_get_non_space_token (pfile)
+/* Handle #ifndef.  */
+static void
+do_ifndef (pfile)
      cpp_reader *pfile;
 {
-  int old_written = CPP_WRITTEN (pfile);
-  for (;;)
+  int skip = 1;
+  const cpp_hashnode *node = 0;
+
+  if (! pfile->state.skipping)
     {
-      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);
+      node = lex_macro_node (pfile);
+      if (node)
+	skip = node->type == NT_MACRO;
+
+      if (node)
+	check_eol (pfile);
     }
-}
 
-/* Parse an identifier starting with C.  */
+  push_conditional (pfile, skip, T_IFNDEF, node);
+}
 
+/* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
+   pfile->mi_ind_cmacro so we can handle multiple-include
+   optimisations.  If macro expansion occurs in the expression, we
+   cannot treat it as a controlling conditional, since the expansion
+   could change in the future.  That is handled by cpp_get_token.  */
 static void
-parse_name (pfile, c)
+do_if (pfile)
      cpp_reader *pfile;
-     int c;
 {
-  for (;;)
-  {
-      if (! is_idchar[c])
-      {
-	  FORWARD (-1);
-	  break;
-      }
+  int skip = 1;
 
-      if (c == '$' && CPP_PEDANTIC (pfile))
-	cpp_pedwarn (pfile, "`$' in identifier");
+  if (! pfile->state.skipping)
+    skip = _cpp_parse_expr (pfile) == 0;
 
-      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;
+  push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
 }
 
-/* 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.  */
+/* Flip skipping state if appropriate and continue without changing
+   if_stack; this is so that the error message for missing #endif's
+   etc. will point to the original #if.  */
 static void
-parse_string (pfile, c)
+do_else (pfile)
      cpp_reader *pfile;
-     int c;
 {
-  long start_line, start_column;
-  
-  cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
+  cpp_buffer *buffer = pfile->buffer;
+  struct if_stack *ifs = buffer->if_stack;
 
-  CPP_PUTC (pfile, c);
-  while (1)
+  if (ifs == NULL)
+    cpp_error (pfile, "#else without #if");
+  else
     {
-      int cc = GETC();
-      if (cc == EOF)
+      if (ifs->type == T_ELSE)
 	{
-	  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;
-	    }
-	  if (!CPP_TRADITIONAL (pfile))
-	    {
-	      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_error (pfile, "#else after #else");
+	  cpp_error_with_line (pfile, ifs->line, 0,
+			       "the conditional began here");
 	}
-      CPP_PUTC (pfile, cc);
-      switch (cc)
-	{
-	case '\n':
-	  CPP_BUMP_LINE (pfile);
-	  pfile->lineno++;
-	  /* Traditionally, end of line ends a string constant with
-	     no error.  */
-	  if (CPP_TRADITIONAL (pfile))
-	    return;
-	  /* Character constants may not extend over multiple lines.  */
-	  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;
+      ifs->type = T_ELSE;
 
-	case '\r':
-	  CPP_ADJUST_WRITTEN (pfile, -1);
-	  if (CPP_BUFFER (pfile)->has_escapes)
-	    {
-	      cpp_fatal (pfile,
-			 "internal error: \\r escape inside string constant");
-	      FORWARD(1);
-	    }
-	  else
-	    /* Backslash newline is replaced by nothing at all.  */
-	    CPP_BUMP_LINE (pfile);
-	  break;
+      /* Skip any future (erroneous) #elses or #elifs.  */
+      pfile->state.skipping = ifs->skip_elses;
+      ifs->skip_elses = true;
 
-	case '\\':
-	  cc = GETC();
-	  if (cc != EOF)
-	    CPP_PUTC (pfile, cc);
-	  break;
+      /* Invalidate any controlling macro.  */
+      ifs->mi_cmacro = 0;
 
-	case '\"':
-	case '\'':
-	  if (cc == c)
-	    return;
-	  break;
-	}
+      /* Only check EOL if was not originally skipping.  */
+      if (!ifs->was_skipping)
+	check_eol (pfile);
     }
 }
 
-/* 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)
+/* Handle a #elif directive by not changing if_stack either.  See the
+   comment above do_else.  */
+static void
+do_elif (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_hor_space[c] || c == '\r')
-	cpp_skip_hspace (pfile);
-      c = PEEKC();
-    }
-  if (c != '(')
-    return 1;
+  cpp_buffer *buffer = pfile->buffer;
+  struct if_stack *ifs = buffer->if_stack;
 
-  CPP_PUTC(pfile, '(');
-  FORWARD(1);
-  dropwhite = 1;
-  while ((c = GETC()) != ')')
+  if (ifs == NULL)
+    cpp_error (pfile, "#elif without #if");
+  else
     {
-      if (is_hor_space[c])
+      if (ifs->type == T_ELSE)
 	{
-	  if (! dropwhite)
-	    {
-	      CPP_PUTC(pfile, ' ');
-	      dropwhite = 1;
-	    }
+	  cpp_error (pfile, "#elif after #else");
+	  cpp_error_with_line (pfile, ifs->line, 0,
+			       "the conditional began here");
 	}
-      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);
+      ifs->type = T_ELIF;
+
+      /* Only evaluate this if we aren't skipping elses.  During
+	 evaluation, set skipping to false to get lexer warnings.  */
+      if (ifs->skip_elses)
+	pfile->state.skipping = 1;
       else
 	{
-	  CPP_PUTC (pfile, c);
-	  dropwhite = 0;
+	  pfile->state.skipping = 0;
+	  pfile->state.skipping = ! _cpp_parse_expr (pfile);
+	  ifs->skip_elses = ! pfile->state.skipping;
 	}
-    }
 
-  if (pfile->limit[-1] == ' ')
-    pfile->limit[-1] = ')';
-  else if (pfile->limit[-1] == '(')
-    {
-      cpp_error (pfile, "empty token sequence in assertion");
-      return 0;
+      /* Invalidate any controlling macro.  */
+      ifs->mi_cmacro = 0;
     }
-  else
-    CPP_PUTC (pfile, ')');
-
-  CPP_NUL_TERMINATE (pfile);
-  return 2;
 }
 
-static int
-do_assert (pfile, keyword)
+/* #endif pops the if stack and resets pfile->state.skipping.  */
+static void
+do_endif (pfile)
      cpp_reader *pfile;
-     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_buffer *buffer = pfile->buffer;
+  struct if_stack *ifs = buffer->if_stack;
 
-  cpp_skip_hspace (pfile);
-  c = PEEKC();
-  if (c != EOF && c != '\n')
+  if (ifs == NULL)
+    cpp_error (pfile, "#endif without #if");
+  else
     {
-      cpp_error (pfile, "junk at end of `#assert'");
-      goto error;
-    }
+      /* Only check EOL if was not originally skipping.  */
+      if (!ifs->was_skipping)
+	check_eol (pfile);
 
-  thislen = strlen (sym);
-  baselen = index (sym, '(') - sym;
-  this = cpp_lookup (pfile, sym, thislen, -1);
-  if (this)
-    {
-      cpp_warning (pfile, "`%s' re-asserted", sym);
-      goto error;
+      /* If potential control macro, we go back outside again.  */
+      if (ifs->next == 0 && ifs->mi_cmacro)
+	{
+	  pfile->mi_valid = true;
+	  pfile->mi_cmacro = ifs->mi_cmacro;
+	}
+
+      buffer->if_stack = ifs->next;
+      pfile->state.skipping = ifs->was_skipping;
+      obstack_free (&pfile->buffer_ob, ifs);
     }
+}
 
-  base = cpp_lookup (pfile, sym, baselen, -1);
-  if (! base)
-    base = cpp_install (pfile, sym, baselen, T_ASSERT, 0, -1);
-  else if (base->type != T_ASSERT)
-  {
-    /* Token clash - but with what?! */
-    cpp_fatal (pfile,
-	       "cpp internal error: base->type != T_ASSERT in do_assert");
-    goto error;
-  }
-
-  this = cpp_install (pfile, sym, thislen, T_ASSERT,
-		      (char *)base->value.aschain, -1);
-  base->value.aschain = this;
-  
-  pfile->limit = (unsigned char *) sym; /* Pop */
-  return 0;
+/* Push an if_stack entry for a preprocessor conditional, and set
+   pfile->state.skipping to SKIP.  If TYPE indicates the conditional
+   is #if or #ifndef, CMACRO is a potentially controlling macro, and
+   we need to check here that we are at the top of the file.  */
+static void
+push_conditional (pfile, skip, type, cmacro)
+     cpp_reader *pfile;
+     int skip;
+     int type;
+     const cpp_hashnode *cmacro;
+{
+  struct if_stack *ifs;
+  cpp_buffer *buffer = pfile->buffer;
+
+  ifs = xobnew (&pfile->buffer_ob, struct if_stack);
+  ifs->line = pfile->directive_line;
+  ifs->next = buffer->if_stack;
+  ifs->skip_elses = pfile->state.skipping || !skip;
+  ifs->was_skipping = pfile->state.skipping;
+  ifs->type = type;
+  /* This condition is effectively a test for top-of-file.  */
+  if (pfile->mi_valid && pfile->mi_cmacro == 0)
+    ifs->mi_cmacro = cmacro;
+  else
+    ifs->mi_cmacro = 0;
 
- error:
-  skip_rest_of_line (pfile);
-  pfile->limit = (unsigned char *) sym; /* Pop */
-  return 0;
+  pfile->state.skipping = skip;
+  buffer->if_stack = ifs;
 }
 
+/* Read the tokens of the answer into the macro pool, in a directive
+   of type TYPE.  Only commit the memory if we intend it as permanent
+   storage, i.e. the #assert case.  Returns 0 on success, and sets
+   ANSWERP to point to the answer.  */
 static int
-do_unassert (pfile, keyword)
+parse_answer (pfile, answerp, type)
      cpp_reader *pfile;
-     struct directive *keyword ATTRIBUTE_UNUSED;
+     struct answer **answerp;
+     int type;
 {
-  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'");
+  const cpp_token *paren;
+  struct answer *answer;
+  unsigned int acount;
 
-  cpp_skip_hspace (pfile);
+  /* In a conditional, it is legal to not have an open paren.  We
+     should save the following token in this case.  */
+  paren = cpp_get_token (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)
+  /* If not a paren, see if we're OK.  */
+  if (paren->type != CPP_OPEN_PAREN)
     {
-      base = cpp_lookup (pfile, sym, thislen, -1);
-      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);
+      /* In a conditional no answer is a test for any answer.  It
+         could be followed by any token.  */
+      if (type == T_IF)
+	{
+	  _cpp_backup_tokens (pfile, 1);
+	  return 0;
 	}
-      delete_macro (base);
+
+      /* #unassert with no answer is valid - it removes all answers.  */
+      if (type == T_UNASSERT && paren->type == CPP_EOF)
+	return 0;
+
+      cpp_error (pfile, "missing '(' after predicate");
+      return 1;
     }
-  else
+
+  for (acount = 0;; acount++)
     {
-      baselen = index (sym, '(') - sym;
-      base = cpp_lookup (pfile, sym, baselen, -1);
-      if (! base) goto error;
-      this = cpp_lookup (pfile, sym, thislen, -1);
-      if (! this) goto error;
+      size_t room_needed;
+      const cpp_token *token = cpp_get_token (pfile);
+      cpp_token *dest;
+
+      if (token->type == CPP_CLOSE_PAREN)
+	break;
+
+      if (token->type == CPP_EOF)
+	{
+	  cpp_error (pfile, "missing ')' to complete answer");
+	  return 1;
+	}
+
+      /* struct answer includes the space for one token.  */
+      room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
 
-      next = base;
-      while (next->value.aschain != this)
-	next = next->value.aschain;
+      if (BUFF_ROOM (pfile->a_buff) < room_needed)
+	_cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
 
-      next->value.aschain = this->value.aschain;
-      delete_macro (this);
+      dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
+      *dest = *token;
 
-      if (base->value.aschain == NULL)
-	delete_macro (base);  /* Last answer for this predicate deleted. */
+      /* Drop whitespace at start, for answer equivalence purposes.  */
+      if (acount == 0)
+	dest->flags &= ~PREV_WHITE;
     }
-  
-  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)
+  if (acount == 0)
     {
-      do_assert (pfile, NULL);
-      cpp_pop_buffer (pfile);
+      cpp_error (pfile, "predicate's answer is empty");
+      return 1;
     }
-}  
 
-int
-cpp_read_check_assertion (pfile)
+  answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
+  answer->count = acount;
+  answer->next = NULL;
+  *answerp = answer;
+
+  return 0;
+}
+
+/* Parses an assertion directive of type TYPE, returning a pointer to
+   the hash node of the predicate, or 0 on error.  If an answer was
+   supplied, it is placed in ANSWERP, otherwise it is set to 0.  */
+static cpp_hashnode *
+parse_assertion (pfile, answerp, type)
      cpp_reader *pfile;
+     struct answer **answerp;
+     int type;
 {
-  U_CHAR *name = CPP_PWRITTEN (pfile);
-  int result;
-  HASHNODE *hp;
-  
-  FORWARD (1);  /* Skip '#' */
-  cpp_skip_hspace (pfile);
-  if (! parse_assertion (pfile))
-    result = 0;
-  else
+  cpp_hashnode *result = 0;
+  const cpp_token *predicate;
+
+  /* We don't expand predicates or answers.  */
+  pfile->state.prevent_expansion++;
+
+  *answerp = 0;
+  predicate = cpp_get_token (pfile);
+  if (predicate->type == CPP_EOF)
+    cpp_error (pfile, "assertion without predicate");
+  else if (predicate->type != CPP_NAME)
+    cpp_error (pfile, "predicate must be an identifier");
+  else if (parse_answer (pfile, answerp, type) == 0)
     {
-      hp = cpp_lookup (pfile, name, CPP_PWRITTEN (pfile) - name, -1);
-      result = (hp != 0);
+      unsigned int len = NODE_LEN (predicate->val.node);
+      unsigned char *sym = alloca (len + 1);
+
+      /* Prefix '#' to get it out of macro namespace.  */
+      sym[0] = '#';
+      memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
+      result = cpp_lookup (pfile, sym, len + 1);
     }
 
-  pfile->limit = name;
+  pfile->state.prevent_expansion--;
   return result;
 }
 
-/* Remember the current position of PFILE.  */
-
-void
-parse_set_mark (pfile)
-     cpp_reader *pfile;
+/* Returns a pointer to the pointer to CANDIDATE in the answer chain,
+   or a pointer to NULL if the answer is not in the chain.  */
+static struct answer **
+find_answer (node, candidate)
+     cpp_hashnode *node;
+     const struct answer *candidate;
 {
-  cpp_buffer *ip = CPP_BUFFER (pfile);
-  if (ip->mark != -1)
-      cpp_fatal (pfile,
-		 "cpp internal error: ip->mark != -1 in parse_set_mark");
+  unsigned int i;
+  struct answer **result;
 
-  ip->mark = ip->cur - ip->buf;
-}
+  for (result = &node->value.answers; *result; result = &(*result)->next)
+    {
+      struct answer *answer = *result;
 
-/* Clear the current mark - we no longer need it.  */
+      if (answer->count == candidate->count)
+	{
+	  for (i = 0; i < answer->count; i++)
+	    if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
+	      break;
 
-void
-parse_clear_mark (pfile)
-     cpp_reader *pfile;
-{
-  cpp_buffer *ip = CPP_BUFFER (pfile);
-  if (ip->mark == -1)
-      cpp_fatal (pfile,
-		 "cpp internal error: ip->mark == -1 in parse_clear_mark");
+	  if (i == answer->count)
+	    break;
+	}
+    }
 
-  ip->mark = -1;
+  return result;
 }
 
-/* Backup the current position of PFILE to that saved in its mark,
-   and clear the mark.  */
-
-void
-parse_goto_mark (pfile)
+/* Test an assertion within a preprocessor conditional.  Returns
+   non-zero on failure, zero on success.  On success, the result of
+   the test is written into VALUE.  */
+int
+_cpp_test_assertion (pfile, value)
      cpp_reader *pfile;
+     int *value;
 {
-  cpp_buffer *ip = CPP_BUFFER (pfile);
-  if (ip->mark == -1)
-      cpp_fatal (pfile,
-		 "cpp internal error: ip->mark == -1 in parse_goto_mark");
+  struct answer *answer;
+  cpp_hashnode *node;
 
-  ip->cur = ip->buf + ip->mark;
-  ip->mark = -1;
+  node = parse_assertion (pfile, &answer, T_IF);
+  if (node)
+    *value = (node->type == NT_ASSERTION &&
+	      (answer == 0 || *find_answer (node, answer) != 0));
+
+  /* We don't commit the memory for the answer - it's temporary only.  */
+  return node == 0;
 }
 
-void
-cpp_print_file_and_line (pfile)
+/* Handle #assert.  */
+static void
+do_assert (pfile)
      cpp_reader *pfile;
 {
-  cpp_buffer *ip = cpp_file_buffer (pfile);
-
-  if (ip != NULL)
+  struct answer *new_answer;
+  cpp_hashnode *node;
+  
+  node = parse_assertion (pfile, &new_answer, T_ASSERT);
+  if (node)
     {
-      long line, col;
-      cpp_buf_line_and_col (ip, &line, &col);
-      cpp_file_line_for_message (pfile, ip->nominal_fname,
-				 line, pfile->show_column ? col : -1);
+      /* Place the new answer in the answer list.  First check there
+         is not a duplicate.  */
+      new_answer->next = 0;
+      if (node->type == NT_ASSERTION)
+	{
+	  if (*find_answer (node, new_answer))
+	    {
+	      cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
+	      return;
+	    }
+	  new_answer->next = node->value.answers;
+	}
+
+      node->type = NT_ASSERTION;
+      node->value.answers = new_answer;
+      BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
+				     + (new_answer->count - 1)
+				     * sizeof (cpp_token));
+      check_eol (pfile);
     }
 }
 
+/* Handle #unassert.  */
 static void
-v_cpp_error (pfile, msgid, ap)
-  cpp_reader *pfile;
-  const char *msgid;
-  va_list ap;
+do_unassert (pfile)
+     cpp_reader *pfile;
 {
-  cpp_print_containing_files (pfile);
-  cpp_print_file_and_line (pfile);
-  v_cpp_message (pfile, 1, msgid, ap);
-}
+  cpp_hashnode *node;
+  struct answer *answer;
+  
+  node = parse_assertion (pfile, &answer, T_UNASSERT);
+  /* It isn't an error to #unassert something that isn't asserted.  */
+  if (node && node->type == NT_ASSERTION)
+    {
+      if (answer)
+	{
+	  struct answer **p = find_answer (node, answer), *temp;
 
-void
-cpp_error VPROTO ((cpp_reader * pfile, const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
-  cpp_reader *pfile;
-  const char *msgid;
-#endif
-  va_list ap;
+	  /* Remove the answer from the list.  */
+	  temp = *p;
+	  if (temp)
+	    *p = temp->next;
 
-  VA_START(ap, msgid);
-  
-#ifndef ANSI_PROTOTYPES
-  pfile = va_arg (ap, cpp_reader *);
-  msgid = va_arg (ap, const char *);
-#endif
+	  /* Did we free the last answer?  */
+	  if (node->value.answers == 0)
+	    node->type = NT_VOID;
 
-  v_cpp_error (pfile, msgid, ap);
-  va_end(ap);
+	  check_eol (pfile);
+	}
+      else
+	_cpp_free_definition (node);
+    }
+
+  /* We don't commit the memory for the answer - it's temporary only.  */
 }
 
-/* Print error message but don't count it.  */
+/* These are for -D, -U, -A.  */
 
-static void
-v_cpp_warning (pfile, msgid, ap)
-  cpp_reader *pfile;
-  const char *msgid;
-  va_list ap;
+/* 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;
+     const char *str;
 {
-  if (CPP_OPTIONS (pfile)->inhibit_warnings)
-    return;
+  char *buf, *p;
+  size_t count;
 
-  if (CPP_OPTIONS (pfile)->warnings_are_errors)
-    pfile->errors++;
+  /* 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.  */
+
+  count = strlen (str);
+  buf = (char *) alloca (count + 3);
+  memcpy (buf, str, count);
+
+  p = strchr (str, '=');
+  if (p)
+    buf[p - str] = ' ';
+  else
+    {
+      buf[count++] = ' ';
+      buf[count++] = '1';
+    }
+  buf[count] = '\0';
 
-  cpp_print_containing_files (pfile);
-  cpp_print_file_and_line (pfile);
-  v_cpp_message (pfile, 0, msgid, ap);
+  run_directive (pfile, T_DEFINE, buf, count);
 }
 
+/* Slight variant of the above for use by initialize_builtins.  */
 void
-cpp_warning VPROTO ((cpp_reader * pfile, const char *msgid, ...))
+_cpp_define_builtin (pfile, str)
+     cpp_reader *pfile;
+     const char *str;
 {
-#ifndef ANSI_PROTOTYPES
-  cpp_reader *pfile;
-  const char *msgid;
-#endif
-  va_list ap;
-  
-  VA_START (ap, msgid);
-  
-#ifndef ANSI_PROTOTYPES
-  pfile = va_arg (ap, cpp_reader *);
-  msgid = va_arg (ap, const char *);
-#endif
-
-  v_cpp_warning (pfile, msgid, ap);
-  va_end(ap);
+  run_directive (pfile, T_DEFINE, str, strlen (str));
 }
 
-/* Print an error message and maybe count it.  */
-
+/* Process MACRO as if it appeared as the body of an #undef.  */
 void
-cpp_pedwarn VPROTO ((cpp_reader * pfile, const char *msgid, ...))
+cpp_undef (pfile, macro)
+     cpp_reader *pfile;
+     const char *macro;
 {
-#ifndef ANSI_PROTOTYPES
-  cpp_reader *pfile;
-  const char *msgid;
-#endif
-  va_list ap;
-  
-  VA_START (ap, msgid);
-  
-#ifndef ANSI_PROTOTYPES
-  pfile = va_arg (ap, cpp_reader *);
-  msgid = va_arg (ap, const char *);
-#endif
-
-  if (CPP_OPTIONS (pfile)->pedantic_errors)
-    v_cpp_error (pfile, msgid, ap);
-  else
-    v_cpp_warning (pfile, msgid, ap);
-  va_end(ap);
+  run_directive (pfile, T_UNDEF, macro, strlen (macro));
 }
 
-static void
-v_cpp_error_with_line (pfile, line, column, msgid, ap)
-  cpp_reader * pfile;
-  int line;
-  int column;
-  const char * msgid;
-  va_list ap;
+/* Process the string STR as if it appeared as the body of a #assert.  */
+void
+cpp_assert (pfile, str)
+     cpp_reader *pfile;
+     const char *str;
 {
-  cpp_buffer *ip = cpp_file_buffer (pfile);
-
-  cpp_print_containing_files (pfile);
-
-  if (ip != NULL)
-    cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
-
-  v_cpp_message (pfile, 1, msgid, ap);
+  handle_assertion (pfile, str, T_ASSERT);
 }
 
+/* Process STR as if it appeared as the body of an #unassert.  */
 void
-cpp_error_with_line VPROTO ((cpp_reader * pfile, int line, int column,
-			     const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
-  cpp_reader *pfile;
-  int line;
-  int column;
-  const char *msgid;
-#endif
-  va_list ap;
-  
-  VA_START (ap, msgid);
-  
-#ifndef ANSI_PROTOTYPES
-  pfile = va_arg (ap, cpp_reader *);
-  line = va_arg (ap, int);
-  column = va_arg (ap, int);
-  msgid = va_arg (ap, const char *);
-#endif
-
-  v_cpp_error_with_line(pfile, line, column, msgid, ap);
-  va_end(ap);
-}
+cpp_unassert (pfile, str)
+     cpp_reader *pfile;
+     const char *str;
+{
+  handle_assertion (pfile, str, T_UNASSERT);
+}  
 
+/* Common code for cpp_assert (-A) and cpp_unassert (-A-).  */
 static void
-v_cpp_warning_with_line (pfile, line, column, msgid, ap)
-  cpp_reader * pfile;
-  int line;
-  int column;
-  const char *msgid;
-  va_list ap;
+handle_assertion (pfile, str, type)
+     cpp_reader *pfile;
+     const char *str;
+     int type;
 {
-  cpp_buffer *ip;
-
-  if (CPP_OPTIONS (pfile)->inhibit_warnings)
-    return;
-
-  if (CPP_OPTIONS (pfile)->warnings_are_errors)
-    pfile->errors++;
-
-  cpp_print_containing_files (pfile);
+  size_t count = strlen (str);
+  const char *p = strchr (str, '=');
 
-  ip = cpp_file_buffer (pfile);
-
-  if (ip != NULL)
-    cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
+  if (p)
+    {
+      /* Copy the entire option so we can modify it.  Change the first
+	 "=" in the string to a '(', and tack a ')' on the end.  */
+      char *buf = (char *) alloca (count + 2);
 
-  v_cpp_message (pfile, 0, msgid, ap);
-}  
+      memcpy (buf, str, count);
+      buf[p - str] = '(';
+      buf[count++] = ')';
+      buf[count] = '\0';
+      str = buf;
+    }
 
-void
-cpp_warning_with_line VPROTO ((cpp_reader * pfile, int line, int column,
-			       const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
-  cpp_reader *pfile;
-  int line;
-  int column;
-  const char *msgid;
-#endif
-  va_list ap;
-  
-  VA_START (ap, msgid);
-  
-#ifndef ANSI_PROTOTYPES
-  pfile = va_arg (ap, cpp_reader *);
-  line = va_arg (ap, int);
-  column = va_arg (ap, int);
-  msgid = va_arg (ap, const char *);
-#endif
+  run_directive (pfile, type, str, count);
+}
 
-  v_cpp_warning_with_line (pfile, line, column, msgid, ap);
-  va_end(ap);
+/* The number of errors for a given reader.  */
+unsigned int
+cpp_errors (pfile)
+     cpp_reader *pfile;
+{
+  return pfile->errors;
 }
 
-void
-cpp_pedwarn_with_line VPROTO ((cpp_reader * pfile, int line, int column,
-			       const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
-  cpp_reader *pfile;
-  int line;
-  int column;
-  const char *msgid;
-#endif
-  va_list ap;
-  
-  VA_START (ap, msgid);
-  
-#ifndef ANSI_PROTOTYPES
-  pfile = va_arg (ap, cpp_reader *);
-  line = va_arg (ap, int);
-  column = va_arg (ap, int);
-  msgid = va_arg (ap, const char *);
-#endif
+/* The options structure.  */
+cpp_options *
+cpp_get_options (pfile)
+     cpp_reader *pfile;
+{
+  return &pfile->opts;
+}
 
-  if (CPP_OPTIONS (pfile)->pedantic_errors)
-    v_cpp_error_with_line (pfile, column, line, msgid, ap);
-  else
-    v_cpp_warning_with_line (pfile, line, column, msgid, ap);
-  va_end(ap);
+/* The callbacks structure.  */
+cpp_callbacks *
+cpp_get_callbacks (pfile)
+     cpp_reader *pfile;
+{
+  return &pfile->cb;
 }
 
-/* Report a warning (or an error if pedantic_errors)
-   giving specified file name and line number, not current.  */
+/* The line map set.  */
+const struct line_maps *
+cpp_get_line_maps (pfile)
+     cpp_reader *pfile;
+{
+  return &pfile->line_maps;
+}
 
+/* Copy the given callbacks structure to our own.  */
 void
-cpp_pedwarn_with_file_and_line VPROTO ((cpp_reader *pfile, char *file, int line,
-					const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
-  cpp_reader *pfile;
-  char *file;
-  int line;
-  const char *msgid;
-#endif
-  va_list ap;
-  
-  VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
-  pfile = va_arg (ap, cpp_reader *);
-  file = va_arg (ap, char *);
-  line = va_arg (ap, int);
-  msgid = va_arg (ap, const char *);
-#endif
-
-  if (!CPP_OPTIONS (pfile)->pedantic_errors
-      && CPP_OPTIONS (pfile)->inhibit_warnings)
-    return;
-  if (file != NULL)
-    cpp_file_line_for_message (pfile, file, line, -1);
-  v_cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors, msgid, ap);
-  va_end(ap);
+cpp_set_callbacks (pfile, cb)
+     cpp_reader *pfile;
+     cpp_callbacks *cb;
+{
+  pfile->cb = *cb;
 }
 
-/* my_strerror - return the descriptive text associated with an
-   `errno' code.  */
-
-static char *
-my_strerror (errnum)
-     int errnum;
+/* Push a new buffer on the buffer stack.  Returns the new buffer; it
+   doesn't fail.  It does not generate a file change call back; that
+   is the responsibility of the caller.  */
+cpp_buffer *
+cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
+     cpp_reader *pfile;
+     const U_CHAR *buffer;
+     size_t len;
+     int from_stage3;
+     int return_at_eof;
 {
-  char *result;
+  cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
 
-#ifndef VMS
-#ifndef HAVE_STRERROR
-  result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
-#else
-  result = strerror (errnum);
-#endif
-#else	/* VMS */
-  /* VAXCRTL's strerror() takes an optional second argument, which only
-     matters when the first argument is EVMSERR.  However, it's simplest
-     just to pass it unconditionally.  `vaxc$errno' is declared in
-     <errno.h>, and maintained by the library in parallel with `errno'.
-     We assume that caller's `errnum' either matches the last setting of
-     `errno' by the library or else does not have the value `EVMSERR'.  */
-
-  result = strerror (errnum, vaxc$errno);
-#endif
+  /* Clears, amongst other things, if_stack and mi_cmacro.  */
+  memset (new, 0, sizeof (cpp_buffer));
 
-  if (!result)
-    result = "errno = ?";
-
-  return result;
-}
+  new->line_base = new->buf = new->cur = buffer;
+  new->rlimit = buffer + len;
+  new->from_stage3 = from_stage3;
+  new->prev = pfile->buffer;
+  new->return_at_eof = return_at_eof;
+  new->saved_flags = BOL;
 
-/* Error including a message from `errno'.  */
+  pfile->buffer = new;
 
-void
-cpp_error_from_errno (pfile, name)
-     cpp_reader *pfile;
-     const char *name;
-{
-  cpp_message_from_errno (pfile, 1, name);
+  return new;
 }
 
+/* If called from do_line, pops a single buffer.  Otherwise pops all
+   buffers until a real file is reached.  Generates appropriate
+   call-backs.  */
 void
-cpp_message_from_errno (pfile, is_error, name)
+_cpp_pop_buffer (pfile)
      cpp_reader *pfile;
-     int is_error;
-     const char *name;
 {
-  int e = errno;
-  cpp_buffer *ip = cpp_file_buffer (pfile);
+  cpp_buffer *buffer = pfile->buffer;
+  struct if_stack *ifs;
+  bool pushed = false;
+
+  /* Walk back up the conditional stack till we reach its level at
+     entry to this file, issuing error messages.  */
+  for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
+    cpp_error_with_line (pfile, ifs->line, 0,
+			 "unterminated #%s", dtable[ifs->type].name);
 
-  cpp_print_containing_files (pfile);
+  /* In case of a missing #endif.  */
+  pfile->state.skipping = 0;
 
-  if (ip != NULL)
-    cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1);
+  /* Update the reader's buffer before _cpp_do_file_change.  */
+  pfile->buffer = buffer->prev;
 
-  cpp_message (pfile, is_error, "%s: %s", name, my_strerror (e));
+  if (buffer->inc)
+    pushed = _cpp_pop_file_buffer (pfile, buffer->inc);
+
+  if (!pushed)
+    obstack_free (&pfile->buffer_ob, buffer);
 }
 
+/* Enter all recognised directives in the hash table.  */
 void
-cpp_perror_with_name (pfile, name)
+_cpp_init_directives (pfile)
      cpp_reader *pfile;
-     const char *name;
 {
-  cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno));
-}
+  unsigned int i;
+  cpp_hashnode *node;
 
-/* TODO:
- * No pre-compiled header file support.
- *
- * Possibly different enum token codes for each C/C++ token.
- *
- * Find and cleanup remaining uses of static variables,
- *
- * Support -dM flag (dump_all_macros).
- *
- * Support for_lint flag.
- */
+  for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
+    {
+      node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
+      node->directive_index = i + 1;
+    }
+}