Initial revision

From-SVN: r9191

diff --git a/gcc/cppalloc.c b/gcc/cppalloc.c
new file mode 100644 (file)
index 0000000..aa37aac
--- /dev/null
+++ b/gcc/cppalloc.c
@@ -0,0 +1,81 @@
+/* Part of CPP library.  (memory allocation - xmalloc etc)
+   Copyright (C) 1986, 87, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
+   Written by Per Bothner, 1994.
+   Based on CCCP program by by Paul Rubin, June 1986
+   Adapted to ANSI C, Richard Stallman, Jan 1987
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ In other words, you are welcome to use, share and improve this program.
+ You are forbidden to forbid anyone else to use, share and improve
+ what you give them.   Help stamp out software-hoarding!  */
+
+static void
+memory_full ()
+{
+  fatal ("Memory exhausted.");
+}
+
+char *
+xmalloc (size)
+     unsigned size;
+{
+  register char *ptr = (char *) malloc (size);
+  if (ptr != 0) return (ptr);
+  memory_full ();
+  /*NOTREACHED*/
+  return 0;
+}
+
+char *
+xrealloc (old, size)
+     char *old;
+     unsigned size;
+{
+  register char *ptr = (char *) realloc (old, size);
+  if (ptr != 0) return (ptr);
+  memory_full ();
+  /*NOTREACHED*/
+  return 0;
+}
+
+char *
+xcalloc (number, size)
+     unsigned number, size;
+{
+  register unsigned total = number * size;
+  register char *ptr = (char *) malloc (total);
+  if (ptr != 0) {
+    if (total > 100)
+      bzero (ptr, total);
+    else {
+      /* It's not too long, so loop, zeroing by longs.
+        It must be safe because malloc values are always well aligned.  */
+      register long *zp = (long *) ptr;
+      register long *zl = (long *) (ptr + total - 4);
+      register int i = total - 4;
+      while (zp < zl)
+       *zp++ = 0;
+      if (i < 0)
+       i = 0;
+      while (i < total)
+       ptr[i++] = 0;
+    }
+    return ptr;
+  }
+  memory_full ();
+  /*NOTREACHED*/
+  return 0;
+}

diff --git a/gcc/cpperror.c b/gcc/cpperror.c
new file mode 100644 (file)
index 0000000..e552989
--- /dev/null
+++ b/gcc/cpperror.c
@@ -0,0 +1,338 @@
+/* Default error handlers for CPP Library.
+   Copyright (C) 1986, 87, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
+   Written by Per Bothner, 1994.
+   Based on CCCP program by by Paul Rubin, June 1986
+   Adapted to ANSI C, Richard Stallman, Jan 1987
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ In other words, you are welcome to use, share and improve this program.
+ You are forbidden to forbid anyone else to use, share and improve
+ what you give them.   Help stamp out software-hoarding!  */
+
+#include "cpplib.h"
+#include <stdio.h>
+
+/* This defines "errno" properly for VMS, and gives us EACCES. */
+#include <errno.h>
+#ifndef errno
+extern int errno;
+#endif
+
+#ifndef VMS
+#ifndef HAVE_STRERROR
+extern int sys_nerr;
+#if defined(bsd4_4) || defined(__NetBSD__)
+extern const char *const sys_errlist[];
+#else
+extern char *sys_errlist[];
+#endif
+#else  /* HAVE_STERRROR */
+char *strerror ();
+#endif
+#else  /* VMS */
+char *strerror (int,...);
+#endif
+
+/* Print the file names and line numbers of the #include
+   commands which led to the current file.  */
+
+void
+cpp_print_containing_files (pfile)
+     cpp_reader *pfile;
+{
+  cpp_buffer *ip;
+  int i;
+  int first = 1;
+
+  /* If stack of files hasn't changed since we last printed
+     this info, don't repeat it.  */
+  if (pfile->input_stack_listing_current)
+    return;
+
+  ip = cpp_file_buffer (pfile);
+
+  /* Give up if we don't find a source file.  */
+  if (ip == NULL)
+    return;
+
+  /* Find the other, outer source files.  */
+  while ((ip = CPP_PREV_BUFFER (ip)), ip != CPP_NULL_BUFFER (pfile))
+    {
+      long line, col;
+      cpp_buf_line_and_col (ip, &line, &col);
+      if (ip->fname != NULL)
+       {
+         if (first)
+           {
+             first = 0;
+             fprintf (stderr, "In file included");
+           }
+         else
+           fprintf (stderr, ",\n                ");
+       }
+
+/* start-sanitize-mpw */
+#ifdef MPW
+      fprintf (stderr, " File \"%s\"; Line %d  # ", ip->nominal_fname, line);
+#else
+/* end-sanitize-mpw */
+      fprintf (stderr, " from %s:%d", ip->nominal_fname, line);
+/* start-sanitize-mpw */
+#endif /* MPW */
+/* end-sanitize-mpw */
+    }
+  if (! first)
+    fprintf (stderr, ":\n");
+
+  /* Record we have printed the status as of this time.  */
+  pfile->input_stack_listing_current = 1;
+}
+
+void
+cpp_print_file_and_line (pfile)
+     cpp_reader *pfile;
+{
+  cpp_buffer *ip = cpp_file_buffer (pfile);
+
+  if (ip != NULL)
+    {
+      long line, col;
+      cpp_buf_line_and_col (ip, &line, &col);
+      if (pfile->show_column)
+       fprintf (stderr, "%s:%d:%d: ", ip->nominal_fname, line, col);
+      else
+       fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
+    }
+}
+
+void
+cpp_error (pfile, msg, arg1, arg2, arg3)
+     cpp_reader *pfile;
+     char *msg;
+     char *arg1, *arg2, *arg3;
+{
+  cpp_print_containing_files (pfile);
+  cpp_print_file_and_line (pfile);
+  fprintf (stderr, msg, arg1, arg2, arg3);
+  fprintf (stderr, "\n");
+  pfile->errors++;
+}
+
+/* Print error message but don't count it.  */
+
+void
+cpp_warning (pfile, msg, arg1, arg2, arg3)
+     cpp_reader *pfile;
+     char *msg;
+     char *arg1, *arg2, *arg3;
+{
+  if (CPP_OPTIONS (pfile)->inhibit_warnings)
+    return;
+
+  if (CPP_OPTIONS (pfile)->warnings_are_errors)
+    pfile->errors++;
+
+  cpp_print_containing_files (pfile);
+  cpp_print_file_and_line (pfile);
+  fprintf (stderr, "warning: ");
+  fprintf (stderr, msg, arg1, arg2, arg3);
+  fprintf (stderr, "\n");
+}
+
+void
+cpp_error_with_line (pfile, line, msg, arg1, arg2, arg3)
+     cpp_reader *pfile;
+     int line;
+     char *msg;
+     char *arg1, *arg2, *arg3;
+{
+  int i;
+  cpp_buffer *ip = cpp_file_buffer (pfile);
+
+  cpp_print_containing_files (pfile);
+
+  if (ip != NULL)
+    fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
+
+  fprintf (stderr, msg, arg1, arg2, arg3);
+  fprintf (stderr, "\n");
+  pfile->errors++;
+}
+
+void
+cpp_warning_with_line (pfile, line, msg, arg1, arg2, arg3)
+     cpp_reader *pfile;
+     int line;
+     char *msg;
+     char *arg1, *arg2, *arg3;
+{
+  int i;
+  cpp_buffer *ip;
+
+  if (CPP_OPTIONS (pfile)->inhibit_warnings)
+    return;
+
+  if (CPP_OPTIONS (pfile)->warnings_are_errors)
+    pfile->errors++;
+
+  cpp_print_containing_files (pfile);
+
+  ip = cpp_file_buffer (pfile);
+
+  if (ip != NULL)
+    fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
+  fprintf (stderr, "warning: ");
+  fprintf (stderr, msg, arg1, arg2, arg3);
+  fprintf (stderr, "\n");
+}
+
+/* Print an error message and maybe count it.  */
+
+void
+cpp_pedwarn (pfile, msg, arg1, arg2, arg3)
+     cpp_reader *pfile;
+     char *msg;
+     char *arg1, *arg2, *arg3;
+{
+  if (CPP_OPTIONS (pfile)->pedantic_errors)
+    cpp_error (pfile, msg, arg1, arg2, arg3);
+  else
+    cpp_warning (pfile, msg, arg1, arg2, arg3);
+}
+
+void
+cpp_pedwarn_with_line (pfile, line, msg, arg1, arg2, arg3)
+     cpp_reader *pfile;
+     int line;
+     char *msg;
+     char *arg1, *arg2, *arg3;
+{
+  if (CPP_OPTIONS (pfile)->pedantic_errors)
+    cpp_error_with_line (pfile, line, msg, arg1, arg2, arg3);
+  else
+    cpp_warning_with_line (pfile, line, msg, arg1, arg2, arg3);
+}
+
+/* Report a warning (or an error if pedantic_errors)
+   giving specified file name and line number, not current.  */
+
+void
+cpp_pedwarn_with_file_and_line (pfile, file, line, msg, arg1, arg2, arg3)
+     cpp_reader *pfile;
+     char *file;
+     int line;
+     char *msg;
+     char *arg1, *arg2, *arg3;
+{
+  if (!CPP_OPTIONS (pfile)->pedantic_errors
+      && CPP_OPTIONS (pfile)->inhibit_warnings)
+    return;
+  if (file != NULL)
+    fprintf (stderr, "%s:%d: ", file, line);
+  if (CPP_OPTIONS (pfile)->pedantic_errors)
+    pfile->errors++;
+  else
+    fprintf (stderr, "warning: ");
+  fprintf (stderr, msg, arg1, arg2, arg3);
+  fprintf (stderr, "\n");
+}
+
+void
+fatal (str, arg)
+     char *str, *arg;
+{
+  fprintf (stderr, "%s: ", progname);
+  fprintf (stderr, str, arg);
+  fprintf (stderr, "\n");
+  exit (FAILURE_EXIT_CODE);
+}
+
+\f
+/*
+ * my_strerror - return the descriptive text associated with an `errno' code.
+ */
+
+char *
+my_strerror (errnum)
+     int errnum;
+{
+  char *result;
+
+#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
+
+  if (!result)
+    result = "undocumented I/O error";
+
+  return result;
+}
+
+/* Error including a message from `errno'.  */
+
+void
+cpp_error_from_errno (pfile, name)
+     cpp_reader *pfile;
+     char *name;
+{
+  int i;
+  cpp_buffer *ip = cpp_file_buffer (pfile);
+
+  cpp_print_containing_files (pfile);
+
+  if (ip != NULL)
+    fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
+
+  fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
+
+  pfile->errors++;
+}
+
+void
+cpp_perror_with_name (pfile, name)
+     cpp_reader *pfile;
+     char *name;
+{
+  fprintf (stderr, "%s: ", progname);
+  fprintf (stderr, "%s: %s\n", name, my_strerror (errno));
+  pfile->errors++;
+}
+
+void
+cpp_pfatal_with_name (pfile, name)
+     cpp_reader *pfile;
+     char *name;
+{
+  cpp_perror_with_name (pfile, name);
+#ifdef VMS
+  exit (vaxc$errno);
+#else
+  exit (FAILURE_EXIT_CODE);
+#endif
+}

diff --git a/gcc/cppexp.c b/gcc/cppexp.c
new file mode 100644 (file)
index 0000000..11fdfdd
--- /dev/null
+++ b/gcc/cppexp.c
@@ -0,0 +1,988 @@
+/* Parse C expressions for CCCP.
+   Copyright (C) 1987, 1992, 1994, 1995 Free Software Foundation.
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ In other words, you are welcome to use, share and improve this program.
+ You are forbidden to forbid anyone else to use, share and improve
+ what you give them.   Help stamp out software-hoarding!
+
+Written by Per Bothner 1994. */
+
+/* Parse a C expression from text in a string  */
+   
+#include "config.h"
+#include "cpplib.h"
+
+#ifdef MULTIBYTE_CHARS
+#include <stdlib.h>
+#include <locale.h>
+#endif
+
+#include <stdio.h>
+
+/* This is used for communicating lists of keywords with cccp.c.  */
+struct arglist {
+  struct arglist *next;
+  U_CHAR *name;
+  int length;
+  int argno;
+};
+
+/* Define a generic NULL if one hasn't already been defined.  */
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifndef GENERIC_PTR
+#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+#define GENERIC_PTR void *
+#else
+#define GENERIC_PTR char *
+#endif
+#endif
+
+#ifndef NULL_PTR
+#define NULL_PTR ((GENERIC_PTR)0)
+#endif
+
+extern char *xmalloc ();
+
+#ifndef CHAR_TYPE_SIZE
+#define CHAR_TYPE_SIZE BITS_PER_UNIT
+#endif
+
+#ifndef INT_TYPE_SIZE
+#define INT_TYPE_SIZE BITS_PER_WORD
+#endif
+
+#ifndef LONG_TYPE_SIZE
+#define LONG_TYPE_SIZE BITS_PER_WORD
+#endif
+
+#ifndef WCHAR_TYPE_SIZE
+#define WCHAR_TYPE_SIZE INT_TYPE_SIZE
+#endif
+
+#ifndef MAX_CHAR_TYPE_SIZE
+#define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
+#endif
+
+#ifndef MAX_INT_TYPE_SIZE
+#define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
+#endif
+
+#ifndef MAX_LONG_TYPE_SIZE
+#define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
+#endif
+
+#ifndef MAX_WCHAR_TYPE_SIZE
+#define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
+#endif
+
+/* Yield nonzero if adding two numbers with A's and B's signs can yield a
+   number with SUM's sign, where A, B, and SUM are all C integers.  */
+#define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
+
+static void integer_overflow ();
+static long left_shift ();
+static long right_shift ();
+
+#define ERROR 299
+#define OROR 300
+#define ANDAND 301
+#define EQUAL 302
+#define NOTEQUAL 303
+#define LEQ 304
+#define GEQ 305
+#define LSH 306
+#define RSH 307
+#define NAME 308
+#define INT 309
+#define CHAR 310
+
+#define LEFT_OPERAND_REQUIRED 1
+#define RIGHT_OPERAND_REQUIRED 2
+#define HAVE_VALUE 4
+/*#define UNSIGNEDP 8*/
+
+struct operation {
+    short op;
+    char rprio; /* Priority of op (relative to it right operand). */
+    char flags;
+    char unsignedp;    /* true if value should be treated as unsigned */
+    long value;        /* The value logically "right" of op. */
+};
+\f
+/* Take care of parsing a number (anything that starts with a digit).
+   LEN is the number of characters in it.  */
+
+/* maybe needs to actually deal with floating point numbers */
+
+struct operation
+parse_number (pfile, start, olen)
+     cpp_reader *pfile;
+     char *start;
+     int olen;
+{
+  struct operation op;
+  register char *p = start;
+  register int c;
+  register unsigned long n = 0, nd, ULONG_MAX_over_base;
+  register int base = 10;
+  register int len = olen;
+  register int overflow = 0;
+  register int digit, largest_digit = 0;
+  int spec_long = 0;
+
+  op.unsignedp = 0;
+
+  for (c = 0; c < len; c++)
+    if (p[c] == '.') {
+      /* It's a float since it contains a point.  */
+      cpp_error (pfile,
+                "floating point numbers not allowed in #if expressions");
+      op.op = ERROR;
+      return op;
+    }
+
+  if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
+    p += 2;
+    base = 16;
+    len -= 2;
+  }
+  else if (*p == '0')
+    base = 8;
+
+  ULONG_MAX_over_base = (unsigned long) -1 / base;
+/* start-sanitize-mpw */
+  /* Work around yet another MPW C bug. */
+#ifdef MPW_C
+  ULONG_MAX_over_base = ((unsigned long) -1) / ((unsigned long) base);
+#endif /* MPW_C */
+/* end-sanitize-mpw */
+
+  for (; len > 0; len--) {
+    c = *p++;
+
+    if (c >= '0' && c <= '9')
+      digit = c - '0';
+    else if (base == 16 && c >= 'a' && c <= 'f')
+      digit = c - 'a' + 10;
+    else if (base == 16 && c >= 'A' && c <= 'F')
+      digit = c - 'A' + 10;
+    else {
+      /* `l' means long, and `u' means unsigned.  */
+      while (1) {
+       if (c == 'l' || c == 'L')
+         {
+           if (spec_long)
+             cpp_error (pfile, "two `l's in integer constant");
+           spec_long = 1;
+         }
+       else if (c == 'u' || c == 'U')
+         {
+           if (op.unsignedp)
+             cpp_error (pfile, "two `u's in integer constant");
+           op.unsignedp = 1;
+         }
+       else
+         break;
+
+       if (--len == 0)
+         break;
+       c = *p++;
+      }
+      /* Don't look for any more digits after the suffixes.  */
+      break;
+    }
+    if (largest_digit < digit)
+      largest_digit = digit;
+    nd = n * base + digit;
+    overflow |= ULONG_MAX_over_base < n | nd < n;
+    n = nd;
+  }
+
+  if (len != 0)
+    {
+      cpp_error (pfile, "Invalid number in #if expression");
+      op.op = ERROR;
+      return op;
+    }
+
+  if (base <= largest_digit)
+    cpp_warning (pfile, "integer constant contains digits beyond the radix");
+
+  if (overflow)
+    cpp_warning (pfile, "integer constant out of range");
+
+  /* If too big to be signed, consider it unsigned.  */
+  if ((long) n < 0 && ! op.unsignedp)
+    {
+      if (base == 10)
+       cpp_warning (pfile, "integer constant is so large that it is unsigned");
+      op.unsignedp = 1;
+    }
+
+  op.value = n;
+  op.op = INT;
+  return op;
+}
+
+struct token {
+  char *operator;
+  int token;
+};
+
+static struct token tokentab2[] = {
+  {"&&", ANDAND},
+  {"||", OROR},
+  {"<<", LSH},
+  {">>", RSH},
+  {"==", EQUAL},
+  {"!=", NOTEQUAL},
+  {"<=", LEQ},
+  {">=", GEQ},
+  {"++", ERROR},
+  {"--", ERROR},
+  {NULL, ERROR}
+};
+
+/* Read one token. */
+
+struct operation
+cpp_lex (pfile)
+cpp_reader *pfile;
+{
+  register int c;
+  register int namelen;
+  register struct token *toktab;
+  enum cpp_token token;
+  struct operation op;
+  U_CHAR *tok_start, *tok_end;
+  int old_written;
+
+ retry:
+
+  c = CPP_BUF_PEEK (CPP_BUFFER (pfile));
+  if (c == '#')
+    return parse_number (pfile,
+                        cpp_read_check_assertion (pfile) ? "1" : "0", 1);
+
+  old_written = CPP_WRITTEN (pfile);
+  cpp_skip_hspace (pfile);
+  if (c == '\n')
+    {
+      op.op = 0;
+      return op;
+    }
+
+  token = cpp_get_token (pfile);
+  tok_start = pfile->token_buffer + old_written;
+  tok_end = CPP_PWRITTEN (pfile);
+  pfile->limit = tok_start;
+  switch (token)
+  {
+    case CPP_EOF: /* Should not happen ... */
+      op.op = 0;
+      return op;
+    case CPP_VSPACE:
+    case CPP_POP:
+      if (CPP_BUFFER (pfile)->fname != NULL)
+       {
+         op.op = 0;
+         return op;
+       }
+      goto retry;
+    case CPP_HSPACE:   case CPP_COMMENT: 
+      goto retry;
+    case CPP_NUMBER:
+      return parse_number (pfile, tok_start, tok_end - tok_start);
+    case CPP_STRING:
+      cpp_error (pfile, "string constants not allowed in #if expressions");
+      op.op = ERROR;
+      return op;
+    case CPP_CHAR:
+      /* This code for reading a character constant
+        handles multicharacter constants and wide characters.
+        It is mostly copied from c-lex.c.  */
+      {
+        register int result = 0;
+       register num_chars = 0;
+       unsigned width = MAX_CHAR_TYPE_SIZE;
+       int wide_flag = 0;
+       int max_chars;
+       U_CHAR *ptr = tok_start;
+#ifdef MULTIBYTE_CHARS
+       char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + MB_CUR_MAX];
+#else
+       char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + 1];
+#endif
+
+       if (*ptr == 'L')
+         {
+           ptr++;
+           wide_flag = 1;
+           width = MAX_WCHAR_TYPE_SIZE;
+#ifdef MULTIBYTE_CHARS
+           max_chars = MB_CUR_MAX;
+#else
+           max_chars = 1;
+#endif
+         }
+       else
+           max_chars = MAX_LONG_TYPE_SIZE / width;
+
+       while (1)
+         {
+           if (ptr >= CPP_PWRITTEN (pfile) || (c = *ptr++) == '\'')
+             break;
+
+           if (c == '\\')
+             {
+               c = cpp_parse_escape (pfile, &ptr);
+               if (width < HOST_BITS_PER_INT
+                 && (unsigned) c >= (1 << width))
+                   cpp_pedwarn (pfile,
+                                "escape sequence out of range for character");
+             }
+
+           num_chars++;
+
+           /* Merge character into result; ignore excess chars.  */
+           if (num_chars < max_chars + 1)
+             {
+               if (width < HOST_BITS_PER_INT)
+                 result = (result << width) | (c & ((1 << width) - 1));
+               else
+                 result = c;
+               token_buffer[num_chars - 1] = c;
+             }
+         }
+
+       token_buffer[num_chars] = 0;
+
+       if (c != '\'')
+         cpp_error (pfile, "malformatted character constant");
+       else if (num_chars == 0)
+         cpp_error (pfile, "empty character constant");
+       else if (num_chars > max_chars)
+         {
+           num_chars = max_chars;
+           cpp_error (pfile, "character constant too long");
+         }
+       else if (num_chars != 1 && ! CPP_TRADITIONAL (pfile))
+         cpp_warning (pfile, "multi-character character constant");
+
+       /* If char type is signed, sign-extend the constant.  */
+       if (! wide_flag)
+         {
+           int num_bits = num_chars * width;
+
+           if (cpp_lookup (pfile, "__CHAR_UNSIGNED__",
+                           sizeof ("__CHAR_UNSIGNED__")-1, -1)
+               || ((result >> (num_bits - 1)) & 1) == 0)
+               op.value
+                   = result & ((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits));
+           else
+               op.value
+                   = result | ~((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits));
+         }
+       else
+         {
+#ifdef MULTIBYTE_CHARS
+           /* Set the initial shift state and convert the next sequence.  */
+             result = 0;
+             /* In all locales L'\0' is zero and mbtowc will return zero,
+                so don't use it.  */
+             if (num_chars > 1
+                 || (num_chars == 1 && token_buffer[0] != '\0'))
+               {
+                 wchar_t wc;
+                 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
+                 if (mbtowc (& wc, token_buffer, num_chars) == num_chars)
+                   result = wc;
+                 else
+                   cpp_warning (pfile,"Ignoring invalid multibyte character");
+               }
+#endif
+             op.value = result;
+           }
+        }
+
+      /* This is always a signed type.  */
+      op.unsignedp = 0;
+      op.op = CHAR;
+    
+      return op;
+
+    case CPP_NAME:
+      return parse_number (pfile, "0", 0);
+
+    case CPP_OTHER:
+      /* See if it is a special token of length 2.  */
+      if (tok_start + 2 == tok_end)
+        {
+         for (toktab = tokentab2; toktab->operator != NULL; toktab++)
+           if (tok_start[0] == toktab->operator[0]
+               && tok_start[1] == toktab->operator[1])
+               break;
+         if (toktab->token == ERROR)
+           {
+             char *buf = (char *) alloca (40);
+             sprintf (buf, "`%s' not allowed in operand of `#if'", tok_start);
+             cpp_error (pfile, buf);
+           }
+         op.op = toktab->token; 
+         return op;
+       }
+      /* fall through */
+    default:
+      op.op = *tok_start;
+      return op;
+  }
+}
+
+
+/* Parse a C escape sequence.  STRING_PTR points to a variable
+   containing a pointer to the string to parse.  That pointer
+   is updated past the characters we use.  The value of the
+   escape sequence is returned.
+
+   A negative value means the sequence \ newline was seen,
+   which is supposed to be equivalent to nothing at all.
+
+   If \ is followed by a null character, we return a negative
+   value and leave the string pointer pointing at the null character.
+
+   If \ is followed by 000, we return 0 and leave the string pointer
+   after the zeros.  A value of 0 does not mean end of string.  */
+
+int
+cpp_parse_escape (pfile, string_ptr)
+     cpp_reader *pfile;
+     char **string_ptr;
+{
+  register int c = *(*string_ptr)++;
+  switch (c)
+    {
+    case 'a':
+      return TARGET_BELL;
+    case 'b':
+      return TARGET_BS;
+    case 'e':
+    case 'E':
+      if (CPP_PEDANTIC (pfile))
+       cpp_pedwarn (pfile, "non-ANSI-standard escape sequence, `\\%c'", c);
+      return 033;
+    case 'f':
+      return TARGET_FF;
+    case 'n':
+      return TARGET_NEWLINE;
+    case 'r':
+      return TARGET_CR;
+    case 't':
+      return TARGET_TAB;
+    case 'v':
+      return TARGET_VT;
+    case '\n':
+      return -2;
+    case 0:
+      (*string_ptr)--;
+      return 0;
+      
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+      {
+       register int i = c - '0';
+       register int count = 0;
+       while (++count < 3)
+         {
+           c = *(*string_ptr)++;
+           if (c >= '0' && c <= '7')
+             i = (i << 3) + c - '0';
+           else
+             {
+               (*string_ptr)--;
+               break;
+             }
+         }
+       if ((i & ~((1 << MAX_CHAR_TYPE_SIZE) - 1)) != 0)
+         {
+           i &= (1 << MAX_CHAR_TYPE_SIZE) - 1;
+           cpp_warning (pfile,
+                         "octal character constant does not fit in a byte");
+         }
+       return i;
+      }
+    case 'x':
+      {
+       register unsigned i = 0, overflow = 0, digits_found = 0, digit;
+       for (;;)
+         {
+           c = *(*string_ptr)++;
+           if (c >= '0' && c <= '9')
+             digit = c - '0';
+           else if (c >= 'a' && c <= 'f')
+             digit = c - 'a' + 10;
+           else if (c >= 'A' && c <= 'F')
+             digit = c - 'A' + 10;
+           else
+             {
+               (*string_ptr)--;
+               break;
+             }
+           overflow |= i ^ (i << 4 >> 4);
+           i = (i << 4) + digit;
+           digits_found = 1;
+         }
+       if (!digits_found)
+         cpp_error (pfile, "\\x used with no following hex digits");
+       if (overflow | (i & ~((1 << BITS_PER_UNIT) - 1)))
+         {
+           i &= (1 << BITS_PER_UNIT) - 1;
+           cpp_warning (pfile,
+                        "hex character constant does not fit in a byte");
+         }
+       return i;
+      }
+    default:
+      return c;
+    }
+}
+
+static void
+integer_overflow (pfile)
+     cpp_reader *pfile;
+{
+  if (CPP_PEDANTIC (pfile))
+    cpp_pedwarn (pfile, "integer overflow in preprocessor expression");
+}
+
+static long
+left_shift (pfile, a, unsignedp, b)
+     cpp_reader *pfile;
+     long a;
+     int unsignedp;
+     unsigned long b;
+{
+  if (b >= HOST_BITS_PER_LONG)
+    {
+      if (! unsignedp && a != 0)
+       integer_overflow (pfile);
+      return 0;
+    }
+  else if (unsignedp)
+    return (unsigned long) a << b;
+  else
+    {
+      long l = a << b;
+      if (l >> b != a)
+       integer_overflow (pfile);
+      return l;
+    }
+}
+
+static long
+right_shift (pfile, a, unsignedp, b)
+     cpp_reader *pfile;
+     long a;
+     int unsignedp;
+     unsigned long b;
+{
+  if (b >= HOST_BITS_PER_LONG)
+    return unsignedp ? 0 : a >> (HOST_BITS_PER_LONG - 1);
+  else if (unsignedp)
+    return (unsigned long) a >> b;
+  else
+    return a >> b;
+}
+\f
+/* These priorities are all even, so we can handle associatively. */
+#define PAREN_INNER_PRIO 0
+#define COMMA_PRIO 4
+#define COND_PRIO (COMMA_PRIO+2)
+#define OROR_PRIO (COND_PRIO+2)
+#define ANDAND_PRIO (OROR_PRIO+2)
+#define OR_PRIO (ANDAND_PRIO+2)
+#define XOR_PRIO (OR_PRIO+2)
+#define AND_PRIO (XOR_PRIO+2)
+#define EQUAL_PRIO (AND_PRIO+2)
+#define LESS_PRIO (EQUAL_PRIO+2)
+#define SHIFT_PRIO (LESS_PRIO+2)
+#define PLUS_PRIO (SHIFT_PRIO+2)
+#define MUL_PRIO (PLUS_PRIO+2)
+#define UNARY_PRIO (MUL_PRIO+2)
+#define PAREN_OUTER_PRIO (UNARY_PRIO+2)
+
+#define COMPARE(OP) \
+  top->unsignedp = 0;\
+  top->value = (unsigned1 || unsigned2) ? (unsigned long) v1 OP v2 : (v1 OP v2)
+
+/* Parse and evaluate a C expression, reading from PFILE.
+   Returns the value of the expression.  */
+
+long
+cpp_parse_expr (pfile)
+     cpp_reader *pfile;
+{
+  /* The implementation is an operator precedence parser,
+     i.e. a bottom-up parser, using a stack for not-yet-reduced tokens.
+
+     The stack base is 'stack', and the current stack pointer is 'top'.
+     There is a stack element for each operator (only),
+     and the most recently pushed operator is 'top->op'.
+     An operand (value) is stored in the 'value' field of the stack
+     element of the operator that precedes it.
+     In that case the 'flags' field has the HAVE_VALUE flag set.  */
+
+#define INIT_STACK_SIZE 20
+  struct operation init_stack[INIT_STACK_SIZE];
+  struct operation *stack = init_stack;
+  struct operation *limit = stack + INIT_STACK_SIZE;
+  register struct operation *top = stack;
+  int lprio, rprio;
+
+  top->rprio = 0;
+  top->flags = 0;
+  for (;;)
+    {
+      struct operation op;
+      char flags = 0;
+
+      /* Read a token */
+      op =  cpp_lex (pfile);
+
+      /* See if the token is an operand, in which case go to set_value.
+        If the token is an operator, figure out its left and right
+        priorities, and then goto maybe_reduce. */
+
+      switch (op.op)
+       {
+       case NAME:
+         top->value = 0, top->unsignedp = 0;
+         goto set_value;
+       case INT:  case CHAR:
+         top->value = op.value;
+         top->unsignedp = op.unsignedp;
+         goto set_value;
+       case 0:
+         lprio = 0;  goto maybe_reduce;
+       case '+':  case '-':
+         /* Is this correct if unary ? FIXME */
+         flags = RIGHT_OPERAND_REQUIRED;
+         lprio = PLUS_PRIO;  rprio = lprio + 1;  goto maybe_reduce;
+       case '!':  case '~':
+         flags = RIGHT_OPERAND_REQUIRED;
+         rprio = UNARY_PRIO;  lprio = rprio + 1;  goto maybe_reduce;
+       case '*':  case '/':  case '%':
+         lprio = MUL_PRIO;  goto binop;
+       case '<':  case '>':  case LEQ:  case GEQ:
+         lprio = LESS_PRIO;  goto binop;
+       case EQUAL:  case NOTEQUAL:
+         lprio = EQUAL_PRIO;  goto binop;
+       case LSH:  case RSH:
+         lprio = SHIFT_PRIO;  goto binop;
+       case '&':  lprio = AND_PRIO;  goto binop;
+       case '^':  lprio = XOR_PRIO;  goto binop;
+       case '|':  lprio = OR_PRIO;  goto binop;
+       case ANDAND:  lprio = ANDAND_PRIO;  goto binop;
+       case OROR:  lprio = OROR_PRIO;  goto binop;
+       case ',':
+         lprio = COMMA_PRIO;  goto binop;
+       case '(':
+         lprio = PAREN_OUTER_PRIO;  rprio = PAREN_INNER_PRIO;
+         goto maybe_reduce;
+       case ')':
+         lprio = PAREN_INNER_PRIO;  rprio = PAREN_OUTER_PRIO;
+         goto maybe_reduce;
+        case ':':
+         lprio = COND_PRIO;  rprio = COND_PRIO;
+         goto maybe_reduce;
+        case '?':
+         lprio = COND_PRIO + 1;  rprio = COND_PRIO;
+         goto maybe_reduce;
+       binop:
+         flags = LEFT_OPERAND_REQUIRED|RIGHT_OPERAND_REQUIRED;
+         rprio = lprio + 1;
+         goto maybe_reduce;
+       default:
+         cpp_error (pfile, "invalid character in #if");
+         goto syntax_error;
+       }
+
+    set_value:
+      /* Push a value onto the stack. */
+      if (top->flags & HAVE_VALUE)
+       {
+         cpp_error (pfile, "syntax error in #if");
+         goto syntax_error;
+       }
+      top->flags |= HAVE_VALUE;
+      continue;
+
+    maybe_reduce:
+      /* Push an operator, and check if we can reduce now. */
+      while (top->rprio > lprio)
+       {
+         long v1 = top[-1].value, v2 = top[0].value;
+         int unsigned1 = top[-1].unsignedp, unsigned2 = top[0].unsignedp;
+         top--;
+         if ((top[1].flags & LEFT_OPERAND_REQUIRED)
+             && ! (top[0].flags & HAVE_VALUE))
+           {
+             cpp_error (pfile, "syntax error - missing left operand");
+             goto syntax_error;
+           }
+         if ((top[1].flags & RIGHT_OPERAND_REQUIRED)
+             && ! (top[1].flags & HAVE_VALUE))
+           {
+             cpp_error (pfile, "syntax error - missing right operand");
+             goto syntax_error;
+           }
+         /* top[0].value = (top[1].op)(v1, v2);*/
+         switch (top[1].op)
+           {
+           case '+':
+             if (!(top->flags & HAVE_VALUE))
+               { /* Unary '+' */
+                 top->value = v2;
+                 top->unsignedp = unsigned2;
+                 top->flags |= HAVE_VALUE;
+               }
+             else
+               {
+                 top->value = v1 + v2;
+                 top->unsignedp = unsigned1 || unsigned2;
+                 if (! top->unsignedp
+                     && ! possible_sum_sign (v1, v2, top->value))
+                   integer_overflow (pfile);
+               }
+             break;
+           case '-':
+             if (!(top->flags & HAVE_VALUE))
+               { /* Unary '-' */
+                 top->value = - v2;
+                 if ((top->value & v2) < 0 && ! unsigned2)
+                   integer_overflow (pfile);
+                 top->unsignedp = unsigned2;
+                 top->flags |= HAVE_VALUE;
+               }
+             else
+               { /* Binary '-' */
+                 top->value = v1 - v2;
+                 top->unsignedp = unsigned1 || unsigned2;
+                 if (! top->unsignedp
+                     && ! possible_sum_sign (top->value, v2, v1))
+                   integer_overflow (pfile);
+               }
+             break;
+           case '*':
+             top->unsignedp = unsigned1 || unsigned2;
+             if (top->unsignedp)
+               top->value = (unsigned long) v1 * v2;
+             else
+               {
+                 top->value = v1 * v2;
+                 if (v1
+                     && (top->value / v1 != v2
+                         || (top->value & v1 & v2) < 0))
+                   integer_overflow (pfile);
+               }
+             break;
+           case '/':
+             if (v2 == 0)
+               {
+                 cpp_error (pfile, "division by zero in #if");
+                 v2 = 1;
+               }
+             top->unsignedp = unsigned1 || unsigned2;
+             if (top->unsignedp)
+               top->value = (unsigned long) v1 / v2;
+             else
+               {
+                 top->value = v1 / v2;
+                 if ((top->value & v1 & v2) < 0)
+                   integer_overflow (pfile);
+               }
+             break;
+           case '%':
+             if (v2 == 0)
+               {
+                 cpp_error (pfile, "division by zero in #if");
+                 v2 = 1;
+               }
+             top->unsignedp = unsigned1 || unsigned2;
+             if (top->unsignedp)
+               top->value = (unsigned long) v1 % v2;
+             else
+               top->value = v1 % v2;
+             break;
+           case '!':
+             if (top->flags & HAVE_VALUE)
+               {
+                 cpp_error (pfile, "syntax error");
+                 goto syntax_error;
+               }
+             top->value = ! v2;
+             top->unsignedp = 0;
+             top->flags |= HAVE_VALUE;
+             break;
+           case '~':
+             if (top->flags & HAVE_VALUE)
+               {
+                 cpp_error (pfile, "syntax error");
+                 goto syntax_error;
+               }
+             top->value = ~ v2;
+             top->unsignedp = unsigned2;
+             top->flags |= HAVE_VALUE;
+             break;
+           case '<':  COMPARE(<);  break;
+           case '>':  COMPARE(>);  break;
+           case LEQ:  COMPARE(<=); break;
+           case GEQ:  COMPARE(>=); break;
+           case EQUAL:
+             top->value = (v1 == v2);
+             top->unsignedp = 0;
+             break;
+           case NOTEQUAL:
+             top->value = (v1 != v2);
+             top->unsignedp = 0;
+             break;
+           case LSH:
+             top->unsignedp = unsigned1;
+             if (v2 < 0 && ! unsigned2)
+               top->value = right_shift (pfile, v1, unsigned1, -v2);
+             else
+               top->value = left_shift (pfile, v1, unsigned1, v2);
+             break;
+           case RSH:
+             top->unsignedp = unsigned1;
+             if (v2 < 0 && ! unsigned2)
+               top->value = left_shift (pfile, v1, unsigned1, -v2);
+             else
+               top->value = right_shift (pfile, v1, unsigned1, v2);
+             break;
+#define LOGICAL(OP) \
+             top->value = v1 OP v2;\
+             top->unsignedp = unsigned1 || unsigned2;
+           case '&':  LOGICAL(&); break;
+           case '^':  LOGICAL(^);  break;
+           case '|':  LOGICAL(|);  break;
+           case ANDAND:
+             top->value = v1 && v2;  top->unsignedp = 0;  break;
+           case OROR:
+             top->value = v1 || v2;  top->unsignedp = 0;  break;
+           case ',':
+             if (CPP_PEDANTIC (pfile))
+               cpp_pedwarn (pfile, "comma operator in operand of `#if'");
+             top->value = v2;
+             top->unsignedp = unsigned2;
+             break;
+           case '(':  case '?':
+             cpp_error (pfile, "syntax error in #if");
+             goto syntax_error;
+           case ':':
+             if (top[0].op != '?')
+               {
+                 cpp_error (pfile,
+                            "syntax error ':' without preceding '?'");
+                 goto syntax_error;
+               }
+             else if (! (top[1].flags & HAVE_VALUE)
+                      || !(top[-1].flags & HAVE_VALUE)
+                      || !(top[0].flags & HAVE_VALUE))
+               {
+                 cpp_error (pfile, "bad syntax for ?: operator");
+                 goto syntax_error;
+               }
+             else
+               {
+                 top--;
+                 top->value = top->value ? v1 : v2;
+                 top->unsignedp = unsigned1 || unsigned2;
+               }
+             break;
+           case ')':
+             if ((top[1].flags & HAVE_VALUE)
+                 || ! (top[0].flags & HAVE_VALUE)
+                 || top[0].op != '('
+                 || (top[-1].flags & HAVE_VALUE))
+               {
+                 cpp_error (pfile, "mismatched parentheses in #if");
+                 goto syntax_error;
+               }
+             else
+               {
+                 top--;
+                 top->value = v1;
+                 top->unsignedp = unsigned1;
+                 top->flags |= HAVE_VALUE;
+               }
+             break;
+           default:
+             fprintf (stderr,
+                      top[1].op >= ' ' && top[1].op <= '~'
+                      ? "unimplemented operator '%c'\n"
+                      : "unimplemented operator '\\%03o'\n",
+                      top[1].op);
+           }
+       }
+      if (op.op == 0)
+       {
+         if (top != stack)
+           cpp_error (pfile, "internal error in #if expression");
+         if (stack != init_stack)
+           free (stack);
+         return top->value;
+       }
+      top++;
+      
+      /* Check for and handle stack overflow. */
+      if (top == limit)
+       {
+         struct operation *new_stack;
+         int old_size = (char*)limit - (char*)stack;
+         int new_size = 2 * old_size;
+         if (stack != init_stack)
+           new_stack = (struct operation*) xrealloc (stack, new_size);
+         else
+           {
+             new_stack = (struct operation*) xmalloc (new_size);
+             bcopy (stack, new_stack, old_size);
+           }
+         stack = new_stack;
+         top = (struct operation*)((char*) new_stack + old_size);
+         limit = (struct operation*)((char*) new_stack + new_size);
+       }
+      
+      top->flags = flags;
+      top->rprio = rprio;
+      top->op = op.op;
+    }
+ syntax_error:
+  if (stack != init_stack)
+    free (stack);
+  skip_rest_of_line (pfile);
+  return 0;
+}

diff --git a/gcc/cpphash.c b/gcc/cpphash.c
new file mode 100644 (file)
index 0000000..fe7cbbf
--- /dev/null
+++ b/gcc/cpphash.c
@@ -0,0 +1,192 @@
+/* Part of CPP library.  (Macro hash table support.)
+   Copyright (C) 1986, 87, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
+   Written by Per Bothner, 1994.
+   Based on CCCP program by by Paul Rubin, June 1986
+   Adapted to ANSI C, Richard Stallman, Jan 1987
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ In other words, you are welcome to use, share and improve this program.
+ You are forbidden to forbid anyone else to use, share and improve
+ what you give them.   Help stamp out software-hoarding!  */
+
+#include "cpplib.h"
+#include "cpphash.h"
+
+/* Define a generic NULL if one hasn't already been defined.  */
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+/*
+ * return hash function on name.  must be compatible with the one
+ * computed a step at a time, elsewhere
+ */
+int
+hashf (name, len, hashsize)
+     register const U_CHAR *name;
+     register int len;
+     int hashsize;
+{
+  register int r = 0;
+
+  while (len--)
+    r = HASHSTEP (r, *name++);
+
+  return MAKE_POS (r) % hashsize;
+}
+
+/*
+ * find the most recent hash node for name name (ending with first
+ * non-identifier char) installed by install
+ *
+ * If LEN is >= 0, it is the length of the name.
+ * Otherwise, compute the length by scanning the entire name.
+ *
+ * If HASH is >= 0, it is the precomputed hash code.
+ * Otherwise, compute the hash code.
+ */
+HASHNODE *
+cpp_lookup (pfile, name, len, hash)
+     struct parse_file *pfile;
+     const U_CHAR *name;
+     int len;
+     int hash;
+{
+  register const U_CHAR *bp;
+  register HASHNODE *bucket;
+
+  if (len < 0)
+    {
+      for (bp = name; is_idchar[*bp]; bp++) ;
+      len = bp - name;
+    }
+
+  if (hash < 0)
+    hash = hashf (name, len, HASHSIZE);
+
+  bucket = hashtab[hash];
+  while (bucket) {
+    if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
+      return bucket;
+    bucket = bucket->next;
+  }
+  return (HASHNODE*) 0;
+}
+
+/*
+ * Delete a hash node.  Some weirdness to free junk from macros.
+ * More such weirdness will have to be added if you define more hash
+ * types that need it.
+ */
+
+/* Note that the DEFINITION of a macro is removed from the hash table
+   but its storage is not freed.  This would be a storage leak
+   except that it is not reasonable to keep undefining and redefining
+   large numbers of macros many times.
+   In any case, this is necessary, because a macro can be #undef'd
+   in the middle of reading the arguments to a call to it.
+   If #undef freed the DEFINITION, that would crash.  */
+
+void
+delete_macro (hp)
+     HASHNODE *hp;
+{
+
+  if (hp->prev != NULL)
+    hp->prev->next = hp->next;
+  if (hp->next != NULL)
+    hp->next->prev = hp->prev;
+
+  /* make sure that the bucket chain header that
+     the deleted guy was on points to the right thing afterwards. */
+  if (hp == *hp->bucket_hdr)
+    *hp->bucket_hdr = hp->next;
+
+#if 0
+  if (hp->type == T_MACRO) {
+    DEFINITION *d = hp->value.defn;
+    struct reflist *ap, *nextap;
+
+    for (ap = d->pattern; ap != NULL; ap = nextap) {
+      nextap = ap->next;
+      free (ap);
+    }
+    free (d);
+  }
+#endif
+  free (hp);
+}
+/*
+ * install a name in the main hash table, even if it is already there.
+ *   name stops with first non alphanumeric, except leading '#'.
+ * caller must check against redefinition if that is desired.
+ * delete_macro () removes things installed by install () in fifo order.
+ * this is important because of the `defined' special symbol used
+ * in #if, and also if pushdef/popdef directives are ever implemented.
+ *
+ * If LEN is >= 0, it is the length of the name.
+ * Otherwise, compute the length by scanning the entire name.
+ *
+ * If HASH is >= 0, it is the precomputed hash code.
+ * Otherwise, compute the hash code.
+ */
+HASHNODE *
+install (name, len, type, ivalue, value, hash)
+     U_CHAR *name;
+     int len;
+     enum node_type type;
+     int ivalue;
+     char *value;
+     int hash;
+{
+  register HASHNODE *hp;
+  register int i, bucket;
+  register U_CHAR *p, *q;
+
+  if (len < 0) {
+    p = name;
+    while (is_idchar[*p])
+      p++;
+    len = p - name;
+  }
+
+  if (hash < 0)
+    hash = hashf (name, len, HASHSIZE);
+
+  i = sizeof (HASHNODE) + len + 1;
+  hp = (HASHNODE *) xmalloc (i);
+  bucket = hash;
+  hp->bucket_hdr = &hashtab[bucket];
+  hp->next = hashtab[bucket];
+  hashtab[bucket] = hp;
+  hp->prev = NULL;
+  if (hp->next != NULL)
+    hp->next->prev = hp;
+  hp->type = type;
+  hp->length = len;
+  if (hp->type == T_CONST)
+    hp->value.ival = ivalue;
+  else
+    hp->value.cpval = value;
+  hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
+  p = hp->name;
+  q = name;
+  for (i = 0; i < len; i++)
+    *p++ = *q++;
+  hp->name[len] = 0;
+  return hp;
+}

diff --git a/gcc/cpphash.h b/gcc/cpphash.h
new file mode 100644 (file)
index 0000000..b4d7207
--- /dev/null
+++ b/gcc/cpphash.h
@@ -0,0 +1,40 @@
+enum node_type;
+
+/* different kinds of things that can appear in the value field
+   of a hash node.  Actually, this may be useless now. */
+union hashval {
+  int ival;
+  char *cpval;
+  DEFINITION *defn;
+#if 0
+  KEYDEF *keydef;
+#endif
+};
+
+struct hashnode {
+  struct hashnode *next;       /* double links for easy deletion */
+  struct hashnode *prev;
+  struct hashnode **bucket_hdr;        /* also, a back pointer to this node's hash
+                                  chain is kept, in case the node is the head
+                                  of the chain and gets deleted. */
+  enum node_type type;         /* type of special token */
+  int length;                  /* length of token, for quick comparison */
+  U_CHAR *name;                        /* the actual name */
+  union hashval value;         /* pointer to expansion, or whatever */
+};
+
+typedef struct hashnode HASHNODE;
+
+/* Some definitions for the hash table.  The hash function MUST be
+   computed as shown in hashf () below.  That is because the rescan
+   loop computes the hash value `on the fly' for most tokens,
+   in order to avoid the overhead of a lot of procedure calls to
+   the hashf () function.  Hashf () only exists for the sake of
+   politeness, for use when speed isn't so important. */
+
+#define HASHSIZE 1403
+static HASHNODE *hashtab[HASHSIZE];
+#define HASHSTEP(old, c) ((old << 2) + c)
+#define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */
+
+extern HASHNODE* install PARAMS ((U_CHAR*,int,enum node_type, int,char*,int));

diff --git a/gcc/cpplib.c b/gcc/cpplib.c
new file mode 100644 (file)
index 0000000..6c4e555
--- /dev/null
+++ b/gcc/cpplib.c
@@ -0,0 +1,7288 @@
+/* CPP Library.
+   Copyright (C) 1986, 87, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
+   Written by Per Bothner, 1994-95.
+   Based on CCCP program by by Paul Rubin, June 1986
+   Adapted to ANSI C, Richard Stallman, Jan 1987
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ In other words, you are welcome to use, share and improve this program.
+ You are forbidden to forbid anyone else to use, share and improve
+ what you give them.   Help stamp out software-hoarding!  */
+
+#ifdef EMACS
+#define NO_SHORTNAMES
+#include "../src/config.h"
+#ifdef open
+#undef open
+#undef read
+#undef write
+#endif /* open */
+#endif /* EMACS */
+
+/* The macro EMACS is defined when cpp is distributed as part of Emacs,
+   for the sake of machines with limited C compilers.  */
+#ifndef EMACS
+#include "config.h"
+#endif /* not EMACS */
+
+#ifndef STANDARD_INCLUDE_DIR
+#define STANDARD_INCLUDE_DIR "/usr/include"
+#endif
+
+#ifndef LOCAL_INCLUDE_DIR
+#define LOCAL_INCLUDE_DIR "/usr/local/include"
+#endif
+
+#if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE.  */
+#ifdef __STDC__
+#define PTR_INT_TYPE ptrdiff_t
+#else
+#define PTR_INT_TYPE long
+#endif
+#endif /* 0 */
+
+#include "cpplib.h"
+#include "cpphash.h"
+
+#ifndef STDC_VALUE
+#define STDC_VALUE 1
+#endif
+
+/* By default, colon separates directories in a path.  */
+#ifndef PATH_SEPARATOR
+#define PATH_SEPARATOR ':'
+#endif
+
+/* In case config.h defines these.  */
+#undef bcopy
+#undef bzero
+#undef bcmp
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <signal.h>
+#ifdef __STDC__
+#include <string.h>
+#include <stdlib.h>
+#endif
+
+#ifndef VMS
+#ifndef USG
+#include <sys/time.h>          /* for __DATE__ and __TIME__ */
+#include <sys/resource.h>
+#else
+#include <sys/param.h>                 /* CYGNUS LOCAL: shebs -noquiet */
+#include <sys/times.h>
+#include <time.h>
+#include <fcntl.h>
+#endif /* USG */
+#endif /* not VMS */
+
+/* This defines "errno" properly for VMS, and gives us EACCES. */
+#include <errno.h>
+
+extern char *index ();
+extern char *rindex ();
+
+#ifndef O_RDONLY
+#define O_RDONLY 0
+#endif
+
+#undef MIN
+#undef MAX
+#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
+#define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
+
+/* Find the largest host integer type and set its size and type.  */
+
+#ifndef HOST_BITS_PER_WIDE_INT
+
+#if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
+#define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
+#define HOST_WIDE_INT long
+#else
+#define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
+#define HOST_WIDE_INT int
+#endif
+
+#endif
+
+#ifndef S_ISREG
+#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#endif
+
+#ifndef S_ISDIR
+#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
+#endif
+
+/* Define a generic NULL if one hasn't already been defined.  */
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifndef GENERIC_PTR
+#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+#define GENERIC_PTR void *
+#else
+#define GENERIC_PTR char *
+#endif
+#endif
+
+#ifndef NULL_PTR
+#define NULL_PTR ((GENERIC_PTR)0)
+#endif
+
+#ifndef INCLUDE_LEN_FUDGE
+#define INCLUDE_LEN_FUDGE 0
+#endif
+
+/* Symbols to predefine.  */
+
+#ifdef CPP_PREDEFINES
+static char *predefs = CPP_PREDEFINES;
+#else
+static char *predefs = "";
+#endif
+\f
+/* We let tm.h override the types used here, to handle trivial differences
+   such as the choice of unsigned int or long unsigned int for size_t.
+   When machines start needing nontrivial differences in the size type,
+   it would be best to do something here to figure out automatically
+   from other information what type to use.  */
+
+/* The string value for __SIZE_TYPE__.  */
+
+#ifndef SIZE_TYPE
+#define SIZE_TYPE "long unsigned int"
+#endif
+
+/* The string value for __PTRDIFF_TYPE__.  */
+
+#ifndef PTRDIFF_TYPE
+#define PTRDIFF_TYPE "long int"
+#endif
+
+/* The string value for __WCHAR_TYPE__.  */
+
+#ifndef WCHAR_TYPE
+#define WCHAR_TYPE "int"
+#endif
+#define CPP_WCHAR_TYPE(PFILE) \
+       (CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
+
+/* The string value for __USER_LABEL_PREFIX__ */
+
+#ifndef USER_LABEL_PREFIX
+#define USER_LABEL_PREFIX ""
+#endif
+
+/* The string value for __REGISTER_PREFIX__ */
+
+#ifndef REGISTER_PREFIX
+#define REGISTER_PREFIX ""
+#endif
+\f
+/* In the definition of a #assert name, this structure forms
+   a list of the individual values asserted.
+   Each value is itself a list of "tokens".
+   These are strings that are compared by name.  */
+
+struct tokenlist_list {
+  struct tokenlist_list *next;
+  struct arglist *tokens;
+};
+
+struct assertion_hashnode {
+  struct assertion_hashnode *next;     /* double links for easy deletion */
+  struct assertion_hashnode *prev;
+  /* also, a back pointer to this node's hash
+     chain is kept, in case the node is the head
+     of the chain and gets deleted. */
+  struct assertion_hashnode **bucket_hdr;
+  int length;                  /* length of token, for quick comparison */
+  U_CHAR *name;                        /* the actual name */
+  /* List of token-sequences.  */
+  struct tokenlist_list *value;
+};
+\f
+#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)
+
+#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 marco *arguments*.) */
+#define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->cleanup == macro_cleanup)
+
+/* Move all backslash-newline pairs out of embarrassing places.
+   Exchange all such pairs following BP
+   with any potentially-embarrassing characters that follow them.
+   Potentially-embarrassing characters are / and *
+   (because a backslash-newline inside a comment delimiter
+   would cause it not to be recognized).  */
+
+#define NEWLINE_FIX \
+  do {while (PEEKC() == '\\' && PEEKN(1) == '\n') FORWARD(2); } while(0)
+
+/* Same, but assume we've already read the potential '\\' into C. */
+#define NEWLINE_FIX1(C) do { \
+    while ((C) == '\\' && PEEKC() == '\n') { FORWARD(1); (C) = GETC(); }\
+  } while(0)
+
+/* Name under which this program was invoked.  */
+
+char *progname;
+
+struct cpp_pending {
+  struct cpp_pending *next;
+  char *cmd;
+  char *arg;
+};
+
+/* Forward declarations.  */
+
+extern char *xmalloc ();
+
+static void add_import ();
+static void append_include_chain ();
+static void make_undef ();
+static void make_definition ();
+static void make_assertion ();
+static void path_include ();
+static void initialize_builtins ();
+static void initialize_char_syntax ();
+static void dump_arg_n ();
+static void dump_defn_1 ();
+extern void delete_macro ();
+static void trigraph_pcp ();
+static int finclude ();
+static void validate_else ();
+static int comp_def_part ();
+extern void fancy_abort ();
+static void pipe_closed ();
+static void print_containing_files ();
+static int lookup_import ();
+static int redundant_include_p ();
+static is_system_include ();
+static struct file_name_map *read_name_map ();
+static char *read_filename_string ();
+static int open_include_file ();
+static int check_preconditions ();
+static void pcfinclude ();
+static void pcstring_used ();
+static int check_macro_name ();
+static int compare_defs ();
+static int compare_token_lists ();
+static int eval_if_expression ();
+static int change_newlines ();
+static int line_for_error ();
+extern int hashf ();
+static int file_size_and_mode ();
+static struct arglist *read_token_list ();
+static void free_token_list ();
+static int safe_read ();
+static void push_macro_expansion PARAMS ((cpp_reader *,
+                                         U_CHAR*, int, HASHNODE*));
+extern char *xrealloc ();
+extern char *xcalloc ();
+static char *savestring ();
+
+static void conditional_skip ();
+static void skip_if_group ();
+
+/* Last arg to output_line_command.  */
+enum file_change_code {same_file, enter_file, leave_file};
+
+/* External declarations.  */
+
+extern char *getenv ();
+extern FILE *fdopen ();
+extern char *version_string;
+extern struct tm *localtime ();
+
+/* 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 ();
+static int do_line ();
+static int do_include ();
+static int do_undef ();
+static int do_error ();
+static int do_pragma ();
+static int do_ident ();
+static int do_if ();
+static int do_xifdef ();
+static int do_else ();
+static int do_elif ();
+static int do_endif ();
+static int do_sccs ();
+static int do_once ();
+static int do_assert ();
+static int do_unassert ();
+static int do_warning ();
+\f
+struct file_name_list
+  {
+    struct file_name_list *next;
+    char *fname;
+    /* If the following is nonzero, it is a macro name.
+       Don't include the file again if that macro is defined.  */
+    U_CHAR *control_macro;
+    /* If the following is nonzero, it is a C-language system include
+       directory.  */
+    int c_system_include_path;
+    /* Mapping of file names for this directory.  */
+    struct file_name_map *name_map;
+    /* Non-zero if name_map is valid.  */
+    int got_name_map;
+  };
+
+/* #include "file" looks in source file dir, then stack. */
+/* #include <file> just looks in the stack. */
+/* -I directories are added to the end, then the defaults are added. */
+/* The */
+static struct default_include {
+  char *fname;                 /* The name of the directory.  */
+  int cplusplus;               /* Only look here if we're compiling C++.  */
+  int cxx_aware;               /* Includes in this directory don't need to
+                                  be wrapped in extern "C" when compiling
+                                  C++.  */
+} include_defaults_array[]
+#ifdef INCLUDE_DEFAULTS
+  = INCLUDE_DEFAULTS;
+#else
+  = {
+    /* Pick up GNU C++ specific include files.  */
+    { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
+#ifdef CROSS_COMPILE
+    /* This is the dir for fixincludes.  Put it just before
+       the files that we fix.  */
+    { GCC_INCLUDE_DIR, 0, 0 },
+    /* For cross-compilation, this dir name is generated
+       automatically in Makefile.in.  */
+    { CROSS_INCLUDE_DIR, 0, 0 },
+    /* This is another place that the target system's headers might be.  */
+    { TOOL_INCLUDE_DIR, 0, 1 },
+#else /* not CROSS_COMPILE */
+    /* This should be /usr/local/include and should come before
+       the fixincludes-fixed header files.  */
+    { LOCAL_INCLUDE_DIR, 0, 1 },
+    /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
+       Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h.  */
+    { TOOL_INCLUDE_DIR, 0, 1 },
+    /* This is the dir for fixincludes.  Put it just before
+       the files that we fix.  */
+    { GCC_INCLUDE_DIR, 0, 0 },
+    /* Some systems have an extra dir of include files.  */
+#ifdef SYSTEM_INCLUDE_DIR
+    { SYSTEM_INCLUDE_DIR, 0, 0 },
+#endif
+    { STANDARD_INCLUDE_DIR, 0, 0 },
+#endif /* not CROSS_COMPILE */
+    { 0, 0, 0 }
+    };
+#endif /* no INCLUDE_DEFAULTS */
+
+/* `struct directive' defines one #-directive, including how to handle it.  */
+
+struct directive {
+  int length;                  /* Length of name */
+  int (*func)();               /* Function to handle directive */
+  char *name;                  /* Name of directive */
+  enum node_type type;         /* Code which describes which directive. */
+  char command_reads_line;      /* One if rest of line is read by func. */
+  char traditional_comments;   /* Nonzero: keep comments if -traditional.  */
+  char pass_thru;              /* Copy preprocessed directive to output file.*/
+};
+
+/* 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, 0, 1},
+  {  5, do_xifdef, "ifdef", T_IFDEF, 1},
+  {  6, do_xifdef, "ifndef", T_IFNDEF, 1},
+  {  7, do_include, "include", T_INCLUDE, 1},
+  { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
+  {  6, do_include, "import", T_IMPORT, 1},
+  {  5, do_endif, "endif", T_ENDIF, 1},
+  {  4, do_else, "else", T_ELSE, 1},
+  {  2, do_if, "if", T_IF, 1},
+  {  4, do_elif, "elif", T_ELIF, 1},
+  {  5, do_undef, "undef", T_UNDEF},
+  {  5, do_error, "error", T_ERROR},
+  {  7, do_warning, "warning", T_WARNING},
+  {  6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
+  {  4, do_line, "line", T_LINE, 1},
+  {  5, do_ident, "ident", T_IDENT, 1, 0, 1},
+#ifdef SCCS_DIRECTIVE
+  {  4, do_sccs, "sccs", T_SCCS},
+#endif
+  {  6, do_assert, "assert", T_ASSERT, 1},
+  {  8, do_unassert, "unassert", T_UNASSERT, 1},
+  {  -1, 0, "", T_UNUSED},
+};
+\f
+/* table to tell if char can be part of a C identifier. */
+U_CHAR is_idchar[256];
+/* table to tell if char can be first char of a c identifier. */
+U_CHAR is_idstart[256];
+/* table to tell if c is horizontal space.  */
+U_CHAR is_hor_space[256];
+/* table to tell if c is horizontal or vertical space.  */
+static U_CHAR is_space[256];
+
+/* Initialize syntactic classifications of characters.  */
+
+static void
+initialize_char_syntax (opts)
+     struct cpp_options *opts;
+{
+  register int i;
+
+  /*
+   * Set up is_idchar and is_idstart tables.  These should be
+   * faster than saying (is_alpha (c) || c == '_'), etc.
+   * Set up these things before calling any routines tthat
+   * refer to them.
+   */
+  for (i = 'a'; i <= 'z'; i++) {
+    is_idchar[i - 'a' + 'A'] = 1;
+    is_idchar[i] = 1;
+    is_idstart[i - 'a' + 'A'] = 1;
+    is_idstart[i] = 1;
+  }
+  for (i = '0'; i <= '9'; i++)
+    is_idchar[i] = 1;
+  is_idchar['_'] = 1;
+  is_idstart['_'] = 1;
+  is_idchar['$'] = opts->dollars_in_ident;
+  is_idstart['$'] = opts->dollars_in_ident;
+
+  /* horizontal space table */
+  is_hor_space[' '] = 1;
+  is_hor_space['\t'] = 1;
+  is_hor_space['\v'] = 1;
+  is_hor_space['\f'] = 1;
+  is_hor_space['\r'] = 1;
+
+  is_space[' '] = 1;
+  is_space['\t'] = 1;
+  is_space['\v'] = 1;
+  is_space['\f'] = 1;
+  is_space['\n'] = 1;
+  is_space['\r'] = 1;
+}
+
+/*
+ * Skip over a quoted string.  BP points to the opening quote.
+ * Returns a pointer after the closing quote.  Don't go past LIMIT.
+ * START_LINE is the line number of the starting point (but it need
+ * not be valid if the starting point is inside a macro expansion).
+ *
+ * The input stack state is not changed.
+ */
+static U_CHAR *
+skip_quoted_string (pfile, first, start_line)
+     cpp_reader *pfile;
+     int first;
+     int start_line;
+{
+  int c;
+
+  while (1)
+    {
+      c = GETC ();
+      if (c == EOF)
+       {
+         cpp_error_with_line (pfile, line_for_error (start_line),
+                              "unterminated string or character constant");
+#if 0
+         cpp_error_with_line (pfile, multiline_string_line,
+                              "possible real start of unterminated constant");
+         multiline_string_line = 0;
+#endif
+         break;
+       }
+      if (c == '\\')
+       {
+         c = GETC ();
+         NEWLINE_FIX1(c);
+       }
+      else if (c == '\n')
+       {
+         if (CPP_TRADITIONAL (pfile))
+           {
+             /* Unterminated strings and character constants are 'legal'.  */
+             FORWARD(-1);      /* Don't consume the newline. */
+             break;
+           }
+         if (CPP_PEDANTIC (pfile) || first == '\'')
+           {
+             cpp_error_with_line (pfile, line_for_error (start_line),
+                                  "unterminated string or character constant");
+             FORWARD(-1);
+             break;
+           }
+         /* If not traditional, then allow newlines inside strings.  */
+#if 0
+         if (multiline_string_line == 0)
+           multiline_string_line = start_line;
+#endif
+      }
+      else if (c == first)
+       break;
+    }
+}
+
+/* Place into PFILE a quoted string representing the string SRC.
+   Caller must reserve enough space in pfile->token_buffer. */
+static void
+quote_string (pfile, src)
+     cpp_reader *pfile;
+     char *src;
+{
+  U_CHAR c;
+
+  CPP_PUTC_Q (pfile, '\"');
+  for (;;)
+    switch ((c = *src++))
+      {
+      default:
+        if (isprint (c))
+         CPP_PUTC_Q (pfile, c);
+       else
+         {
+           sprintf (CPP_PWRITTEN (pfile), "\\%03o", c);
+           CPP_ADJUST_WRITTEN (pfile, 4);
+         }
+       break;
+
+      case '\"':
+      case '\\':
+       CPP_PUTC_Q (pfile, '\\');
+       CPP_PUTC_Q (pfile, c);
+       break;
+      
+      case '\0':
+       CPP_PUTC_Q (pfile, '\"');
+       CPP_NUL_TERMINATE_Q (pfile);
+       return;
+      }
+}
+
+/* Make sure PFILE->token_buffer will hold at least N more chars. */
+
+void
+cpp_grow_buffer (pfile, n)
+     cpp_reader *pfile;
+     long n;
+{
+  long old_written = CPP_WRITTEN (pfile);
+  pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
+  pfile->token_buffer = (char*)
+    xrealloc(pfile->token_buffer, pfile->token_buffer_size);
+  CPP_SET_WRITTEN (pfile, old_written);
+}
+
+\f
+/*
+ * process a given definition string, for initialization
+ * If STR is just an identifier, define it with value 1.
+ * If STR has anything after the identifier, then it should
+ * be identifier=definition.
+ */
+
+static void
+make_definition (pfile, str)
+     cpp_reader *pfile;
+     U_CHAR *str;
+{
+  U_CHAR *buf, *p;
+
+  buf = str;
+  p = str;
+  if (!is_idstart[*p])
+    {
+      cpp_error (pfile, "malformed option `-D %s'", str);
+      return;
+    }
+  while (is_idchar[*++p])
+    ;
+  if (*p == 0)
+    {
+      buf = (U_CHAR *) alloca (p - buf + 4);
+      strcpy ((char *)buf, str);
+      strcat ((char *)buf, " 1");
+    }
+  else if (*p != '=')
+    {
+      cpp_error (pfile, "malformed option `-D %s'", str);
+      return;
+    }
+  else
+    {
+      U_CHAR *q;
+      /* Copy the entire option so we can modify it.  */
+      buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
+      strncpy (buf, str, p - str);
+      /* Change the = to a space.  */
+      buf[p - str] = ' ';
+      /* Scan for any backslash-newline and remove it.  */
+      p++;
+      q = &buf[p - str];
+      while (*p)
+       {
+      if (*p == '\\' && p[1] == '\n')
+       p += 2;
+      else
+       *q++ = *p++;
+    }
+    *q = 0;
+  }
+  
+  do_define (pfile, NULL, buf, buf + strlen (buf));
+}
+\f
+/* Process the string STR as if it appeared as the body of a #assert.
+   OPTION is the option name for which STR was the argument.  */
+
+static void
+make_assertion (pfile, option, str)
+     cpp_reader *pfile;
+     char *option;
+     U_CHAR *str;
+{
+  cpp_buffer *ip;
+  struct directive *kt;
+  U_CHAR *buf, *p, *q;
+
+  /* Copy the entire option so we can modify it.  */
+  buf = (U_CHAR *) alloca (strlen (str) + 1);
+  strcpy ((char *) buf, str);
+  /* Scan for any backslash-newline and remove it.  */
+  p = q = buf;
+  while (*p) {
+#if 0
+    if (*p == '\\' && p[1] == '\n')
+      p += 2;
+    else
+#endif
+      *q++ = *p++;
+  }
+  *q = 0;
+
+  p = buf;
+  if (!is_idstart[*p]) {
+    cpp_error (pfile, "malformed option `%s %s'", option, str);
+    return;
+  }
+  while (is_idchar[*++p])
+    ;
+  while (*p == ' ' || *p == '\t') p++;
+  if (! (*p == 0 || *p == '(')) {
+    cpp_error (pfile, "malformed option `%s %s'", option, str);
+    return;
+  }
+  
+  ip = cpp_push_buffer (pfile, buf, strlen (buf));
+  do_assert (pfile, NULL, NULL, NULL);
+  cpp_pop_buffer (pfile);
+}
+\f
+/* Append a chain of `struct file_name_list's
+   to the end of the main include chain.
+   FIRST is the beginning of the chain to append, and LAST is the end.  */
+
+static void
+append_include_chain (pfile, first, last)
+     cpp_reader *pfile;
+     struct file_name_list *first, *last;
+{
+  struct cpp_options *opts = CPP_OPTIONS (pfile);
+  struct file_name_list *dir;
+
+  if (!first || !last)
+    return;
+
+  if (opts->include == 0)
+    opts->include = first;
+  else
+    opts->last_include->next = first;
+
+  if (opts->first_bracket_include == 0)
+    opts->first_bracket_include = first;
+
+  for (dir = first; ; dir = dir->next) {
+    int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
+    if (len > pfile->max_include_len)
+      pfile->max_include_len = len;
+    if (dir == last)
+      break;
+  }
+
+  last->next = NULL;
+  opts->last_include = last;
+}
+\f
+/* Add output to `deps_buffer' for the -M switch.
+   STRING points to the text to be output.
+   SPACER is ':' for targets, ' ' for dependencies, zero for text
+   to be inserted literally.  */
+
+static void
+deps_output (pfile, string, spacer)
+     cpp_reader *pfile;
+     char *string;
+     int spacer;
+{
+  int size = strlen (string);
+
+  if (size == 0)
+    return;
+
+#ifndef MAX_OUTPUT_COLUMNS
+#define MAX_OUTPUT_COLUMNS 72
+#endif
+  if (spacer
+      && pfile->deps_column > 0
+      && (pfile->deps_column + size) > MAX_OUTPUT_COLUMNS)
+    {
+      deps_output (pfile, " \\\n  ", 0);
+      pfile->deps_column = 0;
+    }
+
+  if (pfile->deps_size + size + 8 > pfile->deps_allocated_size)
+    {
+      pfile->deps_allocated_size = (pfile->deps_size + size + 50) * 2;
+      pfile->deps_buffer = (char *) xrealloc (pfile->deps_buffer,
+                                             pfile->deps_allocated_size);
+    }
+  if (spacer == ' ' && pfile->deps_column > 0)
+    pfile->deps_buffer[pfile->deps_size++] = ' ';
+  bcopy (string, &pfile->deps_buffer[pfile->deps_size], size);
+  pfile->deps_size += size;
+  pfile->deps_column += size;
+  if (spacer == ':')
+    pfile->deps_buffer[pfile->deps_size++] = ':';
+  pfile->deps_buffer[pfile->deps_size] = 0;
+}
+\f
+/* Given a colon-separated list of file names PATH,
+   add all the names to the search path for include files.  */
+
+static void
+path_include (pfile, path)
+     cpp_reader *pfile;
+     char *path;
+{
+  char *p;
+
+  p = path;
+
+  if (*p)
+    while (1) {
+      char *q = p;
+      char *name;
+      struct file_name_list *dirtmp;
+
+      /* Find the end of this name.  */
+      while (*q != 0 && *q != PATH_SEPARATOR) q++;
+      if (p == q) {
+       /* An empty name in the path stands for the current directory.  */
+       name = (char *) xmalloc (2);
+       name[0] = '.';
+       name[1] = 0;
+      } else {
+       /* Otherwise use the directory that is named.  */
+       name = (char *) xmalloc (q - p + 1);
+       bcopy (p, name, q - p);
+       name[q - p] = 0;
+      }
+
+      dirtmp = (struct file_name_list *)
+       xmalloc (sizeof (struct file_name_list));
+      dirtmp->next = 0;                /* New one goes on the end */
+      dirtmp->control_macro = 0;
+      dirtmp->c_system_include_path = 0;
+      dirtmp->fname = name;
+      dirtmp->got_name_map = 0;
+      append_include_chain (pfile, dirtmp, dirtmp);
+
+      /* Advance past this name.  */
+      p = q;
+      if (*p == 0)
+       break;
+      /* Skip the colon.  */
+      p++;
+    }
+}
+\f
+void
+init_parse_options (opts)
+     struct cpp_options *opts;
+{
+  bzero (opts, sizeof *opts);
+  opts->in_fname = NULL;
+  opts->out_fname = NULL;
+
+  /* Initialize is_idchar to allow $.  */
+  opts->dollars_in_ident = 1;
+  initialize_char_syntax (opts);
+  opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
+
+  opts->no_line_commands = 0;
+  opts->no_trigraphs = 1;
+  opts->put_out_comments = 0;
+  opts->print_include_names = 0;
+  opts->dump_macros = dump_none;
+  opts->no_output = 0;
+  opts->cplusplus = 0;
+  opts->cplusplus_comments = 0;
+
+  opts->verbose = 0;
+  opts->objc = 0;
+  opts->lang_asm = 0;
+  opts->for_lint = 0;
+  opts->chill = 0;
+  opts->pedantic_errors = 0;
+  opts->inhibit_warnings = 0;
+  opts->warn_comments = 0;
+  opts->warn_import = 1;
+  opts->warnings_are_errors = 0;
+}
+
+enum cpp_token
+null_underflow (pfile)
+     cpp_reader *pfile;
+{
+  return CPP_EOF;
+}
+
+int
+null_cleanup (pbuf, pfile)
+     cpp_buffer *pbuf;
+     cpp_reader *pfile;
+{
+  return 0;
+}
+
+int
+macro_cleanup (pbuf, pfile)
+     cpp_buffer *pbuf;
+     cpp_reader *pfile;
+{
+  HASHNODE *macro = (HASHNODE*)pbuf->data;
+  if (macro->type == T_DISABLED)
+    macro->type = T_MACRO;
+  if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
+    free (pbuf->buf);
+  return 0;
+}
+
+int
+file_cleanup (pbuf, pfile)
+     cpp_buffer *pbuf;
+     cpp_reader *pfile;
+{
+  return 0;
+}
+
+static void
+newline_fix (pfile)
+     cpp_reader *pfile;
+{
+#if 1
+  NEWLINE_FIX;
+#else
+  register U_CHAR *p = bp;
+
+  /* First count the backslash-newline pairs here.  */
+
+  while (p[0] == '\\' && p[1] == '\n')
+    p += 2;
+
+  /* What follows the backslash-newlines is not embarrassing.  */
+
+  if (*p != '/' && *p != '*')
+    return;
+
+  /* Copy all potentially embarrassing characters
+     that follow the backslash-newline pairs
+     down to where the pairs originally started.  */
+
+  while (*p == '*' || *p == '/')
+    *bp++ = *p++;
+
+  /* Now write the same number of pairs after the embarrassing chars.  */
+  while (bp < p) {
+    *bp++ = '\\';
+    *bp++ = '\n';
+  }
+#endif
+}
+
+/* Assuming we have read '/'.
+   If this is the start of a comment (followed by '*' or '/'),
+   skip to the end of the comment, and return ' '.
+   Return EOF if we reached the end of file before the end of the comment.
+   If not the start of a comment, return '/'. */
+
+static int
+skip_comment (pfile, linep)
+     cpp_reader *pfile;
+     long *linep;
+{
+  int c;
+  while (PEEKC() == '\\' && PEEKN(1) == '\n')
+    {
+      if (linep)
+       (*linep)++;
+      FORWARD(2);
+    }
+  if (PEEKC() == '*')
+    {
+      FORWARD(1);
+      for (;;)
+       {
+         int prev_c = c;
+         c = GETC ();
+         if (c == EOF)
+           return EOF;
+         while (c == '\\' && PEEKC() == '\n')
+           {
+             if (linep)
+               (*linep)++;
+             FORWARD(1), c = GETC();
+           }
+         if (prev_c == '*' && c == '/')
+           return ' ';
+         if (c == '\n' && linep)
+           (*linep)++;
+       }
+    }
+  else if (PEEKC() == '/' && CPP_OPTIONS (pfile)->cplusplus_comments)
+    {
+      FORWARD(1);
+      for (;;)
+       {
+         c = GETC ();
+         if (c == EOF)
+           return ' '; /* Allow // to be terminated by EOF. */
+         while (c == '\\' && PEEKC() == '\n')
+           {
+             FORWARD(1);
+             c = GETC();
+             if (linep)
+               (*linep)++;
+           }
+         if (c == '\n')
+           {
+             /* Don't consider final '\n' to be part of comment. */
+             FORWARD(-1);
+             return ' ';
+           }
+       }
+    }
+  else
+    return '/';
+}     
+
+/* Skip whitespace \-newline and comments.  Does not macro-expand.  */
+void
+cpp_skip_hspace (pfile)
+     cpp_reader *pfile;
+{
+  while (1)
+    {
+      int c = PEEKC();
+      if (c == EOF)
+       return; /* FIXME */
+      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");
+         FORWARD(1);
+       }
+      else if (c == '/')
+       {
+         FORWARD (1);
+         c = skip_comment (pfile, NULL);
+         if (c == '/')
+           FORWARD(-1);
+         if (c == EOF || c == '/')
+           return;
+       }
+      else if (c == '\\' && PEEKN(1) == '\n') {
+       FORWARD(2);
+      }
+      else return;
+    }
+}
+
+/* Read the rest of the current line.
+   The line is appended to PFILE's output buffer. */
+
+void
+copy_rest_of_line (pfile)
+     cpp_reader *pfile;
+{
+  struct cpp_options *opts = CPP_OPTIONS (pfile);
+  for (;;)
+    {
+      int c = GETC();
+      int nextc;
+      switch (c)
+       {
+       case EOF:
+         goto end_directive;
+       case '\\':
+         if (PEEKC() == '\n')
+           {
+             FORWARD (1);
+             continue;
+           }
+       case '\'':
+       case '\"':
+         goto scan_directive_token;
+         break;
+       case '/':
+         nextc = PEEKC();
+         if (nextc == '*' || (opts->cplusplus_comments && nextc == '*'))
+           goto scan_directive_token;
+         break;
+       case '\f':
+       case '\v':
+         if (CPP_PEDANTIC (pfile))
+           cpp_pedwarn (pfile, "%s in preprocessing directive",
+                        c == '\f' ? "formfeed" : "vertical tab");
+         break;
+
+       case '\n':
+         FORWARD(-1);
+         goto end_directive;
+       scan_directive_token:
+         FORWARD(-1);
+         cpp_get_token (pfile);
+         continue;
+       }
+      CPP_PUTC (pfile, c);
+    }
+ end_directive: ;
+  CPP_NUL_TERMINATE (pfile);
+}
+
+void
+skip_rest_of_line (pfile)
+     cpp_reader *pfile;
+{
+  long old = CPP_WRITTEN (pfile);
+  copy_rest_of_line (pfile);
+  CPP_SET_WRITTEN (pfile, old);
+}
+
+/* Handle a possible # directive.
+   '#' has already been read.  */
+
+int
+handle_directive (pfile)
+     cpp_reader *pfile;
+{ int c;
+  register struct directive *kt;
+  int ident_length;
+  long after_ident;
+  U_CHAR *ident, *line_end;
+  long old_written = CPP_WRITTEN (pfile);
+
+  cpp_skip_hspace (pfile);
+
+  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);
+      goto done_a_directive;
+    }
+
+  /* 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 && PEEKC() == '\n')
+    {
+      /* A line of just `#' becomes blank.  */
+      goto done_a_directive;
+    }
+
+#if 0
+  if (ident_length == 0 || !is_idstart[*ident]) {
+    U_CHAR *p = ident;
+    while (is_idchar[*p]) {
+      if (*p < '0' || *p > '9')
+       break;
+      p++;
+    }
+    /* Avoid error for `###' and similar cases unless -pedantic.  */
+    if (p == ident) {
+      while (*p == '#' || is_hor_space[*p]) p++;
+      if (*p == '\n') {
+       if (pedantic && !lang_asm)
+         cpp_warning (pfile, "invalid preprocessor directive");
+       return 0;
+      }
+    }
+
+    if (!lang_asm)
+      cpp_error (pfile, "invalid preprocessor directive name");
+
+    return 0;
+  }
+#endif
+  /*
+   * 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 (kt->length <= 0)
+      goto not_a_directive;
+    if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length)) 
+      break;
+  }
+
+  if (! kt->command_reads_line)
+    {
+      /* Nonzero means do not delete comments within the directive.
+         #define needs this when -traditional.  */
+       int comments = CPP_TRADITIONAL (pfile) && kt->traditional_comments; 
+       int save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
+       CPP_OPTIONS (pfile)->put_out_comments = comments;
+       after_ident = CPP_WRITTEN (pfile);
+       copy_rest_of_line (pfile);
+       CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
+    }
+
+  /* For #pragma and #define, we may want to pass through the directive.
+     Other directives may create output, but we don't want the directive
+     itself out, so we pop it now.  For example #include may write a #line
+     command (see comment in do_include), and conditionals may emit
+     #failed ... #endfailed stuff.  But note that popping the buffer
+     means the parameters to kt->func may point after pfile->limit
+     so these parameters are invalid as soon as something gets appended
+     to the token_buffer.  */
+
+  line_end = CPP_PWRITTEN (pfile);
+  if (!kt->pass_thru && kt->type != T_DEFINE)
+    CPP_SET_WRITTEN (pfile, old_written);
+
+  (*kt->func) (pfile, kt, pfile->token_buffer + after_ident, line_end);
+  if (kt->pass_thru
+      || (kt->type == T_DEFINE
+         && CPP_OPTIONS (pfile)->dump_macros == dump_definitions))
+    {
+      /* Just leave the entire #define in the output stack. */
+    }
+  else if (kt->type == T_DEFINE
+          && CPP_OPTIONS (pfile)->dump_macros == dump_names)
+    {
+      U_CHAR *p = pfile->token_buffer + old_written + 7;  /* Skip "#define". */
+      SKIP_WHITE_SPACE (p);
+      while (is_idchar[*p]) p++;
+      pfile->limit = p;
+      CPP_PUTC (pfile, '\n');
+    }
+  else if (kt->type == T_DEFINE)
+    CPP_SET_WRITTEN (pfile, old_written);
+ done_a_directive:
+  return 1;
+
+ not_a_directive:
+  return 0;
+}
+
+/* Pass a directive through to the output file.
+   BUF points to the contents of the directive, as a contiguous string.
+   LIMIT points to the first character past the end of the directive.
+   KEYWORD is the keyword-table entry for the directive.  */
+
+static void
+pass_thru_directive (buf, limit, pfile, keyword)
+     U_CHAR *buf, *limit;
+     cpp_reader *pfile;
+     struct directive *keyword;
+{
+  register unsigned keyword_length = keyword->length;
+
+  CPP_RESERVE (pfile, 1 + keyword_length + (limit - buf));
+  CPP_PUTC_Q (pfile, '#');
+  CPP_PUTS_Q (pfile, keyword->name, keyword_length);
+  if (limit != buf && buf[0] != ' ')
+    CPP_PUTC_Q (pfile, ' ');
+  CPP_PUTS_Q (pfile, buf, limit - buf);
+#if 0
+  CPP_PUTS_Q (pfile, '\n');
+  /* Count the line we have just made in the output,
+     to get in sync properly.  */
+  pfile->lineno++;
+#endif
+}
+\f
+/* The arglist structure is built by do_define to tell
+   collect_definition where the argument names begin.  That
+   is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
+   would contain pointers to the strings x, y, and z.
+   Collect_definition would then build a DEFINITION node,
+   with reflist nodes pointing to the places x, y, and z had
+   appeared.  So the arglist is just convenience data passed
+   between these two routines.  It is not kept around after
+   the current #define has been processed and entered into the
+   hash table. */
+
+struct arglist {
+  struct arglist *next;
+  U_CHAR *name;
+  int length;
+  int argno;
+  char rest_args;
+};
+
+/* Read a replacement list for a macro with parameters.
+   Build the DEFINITION structure.
+   Reads characters of text starting at BUF until END.
+   ARGLIST specifies the formal parameters to look for
+   in the text of the definition; NARGS is the number of args
+   in that list, or -1 for a macro name that wants no argument list.
+   MACRONAME is the macro name itself (so we can avoid recursive expansion)
+   and NAMELEN is its length in characters.
+   
+Note that comments and backslash-newlines have already been deleted
+from the argument.  */
+
+static DEFINITION *
+collect_expansion (pfile, buf, end, nargs, arglist)
+     cpp_reader *pfile;
+     U_CHAR *buf, *end;
+     int nargs;
+     struct arglist *arglist;
+{
+  DEFINITION *defn;
+  register U_CHAR *p, *limit, *lastp, *exp_p;
+  struct reflist *endpat = NULL;
+  /* Pointer to first nonspace after last ## seen.  */
+  U_CHAR *concat = 0;
+  /* Pointer to first nonspace after last single-# seen.  */
+  U_CHAR *stringify = 0;
+  int maxsize;
+  int expected_delimiter = '\0';
+
+  /* Scan thru the replacement list, ignoring comments and quoted
+     strings, picking up on the macro calls.  It does a linear search
+     thru the arg list on every potential symbol.  Profiling might say
+     that something smarter should happen. */
+
+  if (end < buf)
+    abort ();
+
+  /* Find the beginning of the trailing whitespace.  */
+  /* Find end of leading whitespace.  */
+  limit = end;
+  p = buf;
+  while (p < limit && is_space[limit[-1]]) limit--;
+  while (p < limit && is_space[*p]) p++;
+
+  /* Allocate space for the text in the macro definition.
+     Leading and trailing whitespace chars need 2 bytes each.
+     Each other input char may or may not need 1 byte,
+     so this is an upper bound.
+     The extra 2 are for invented trailing newline-marker and final null.  */
+  maxsize = (sizeof (DEFINITION)
+            + 2 * (end - limit) + 2 * (p - buf)
+            + (limit - p) + 3);
+  defn = (DEFINITION *) xcalloc (1, maxsize);
+
+  defn->nargs = nargs;
+  exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
+  lastp = exp_p;
+
+  p = buf;
+
+  /* Add one initial space (often removed by macroexpand). */
+  *exp_p++ = ' ';
+
+  if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
+    cpp_error (pfile, "`##' at start of macro definition");
+    p += 2;
+  }
+
+  /* Process the main body of the definition.  */
+  while (p < limit) {
+    int skipped_arg = 0;
+    register U_CHAR c = *p++;
+
+    *exp_p++ = c;
+
+    if (!CPP_TRADITIONAL (pfile)) {
+      switch (c) {
+      case '\'':
+      case '\"':
+        if (expected_delimiter != '\0') {
+          if (c == expected_delimiter)
+            expected_delimiter = '\0';
+        } else
+          expected_delimiter = c;
+       break;
+
+       /* Special hack: if a \# is written in the #define
+          include a # in the definition.  This is useless for C code
+          but useful for preprocessing other things.  */
+
+      case '\\':
+       /* \# quotes a # even outside of strings.  */
+       if (p < limit && *p == '#' && !expected_delimiter) {
+         exp_p--;
+         *exp_p++ = *p++;
+       } else if (p < limit && expected_delimiter) {
+         /* In a string, backslash goes through
+            and makes next char ordinary.  */
+         *exp_p++ = *p++;
+       }
+       break;
+
+      case '@':
+       *exp_p++ = c;
+       break;
+
+      case '#':
+       /* # is ordinary inside a string.  */
+       if (expected_delimiter)
+         break;
+       if (p < limit && *p == '#') {
+         /* ##: concatenate preceding and following tokens.  */
+         /* Take out the first #, discard preceding whitespace.  */
+         exp_p--;
+         while (exp_p > lastp && is_hor_space[exp_p[-1]])
+           --exp_p;
+         /* Skip the second #.  */
+         p++;
+         /* Discard following whitespace.  */
+         SKIP_WHITE_SPACE (p);
+         concat = p;
+         if (p == limit)
+           cpp_error (pfile, "`##' at end of macro definition");
+       } else if (nargs >= 0) {
+         /* Single #: stringify following argument ref.
+            Don't leave the # in the expansion.  */
+         exp_p--;
+         SKIP_WHITE_SPACE (p);
+         if (p == limit || ! is_idstart[*p])
+           cpp_error (pfile,
+                    "`#' operator is not followed by a macro argument name");
+         else
+           stringify = p;
+       }
+       break;
+      }
+    } else {
+      /* In -traditional mode, recognize arguments inside strings and
+        and character constants, and ignore special properties of #.
+        Arguments inside strings are considered "stringified", but no
+        extra quote marks are supplied.  */
+      switch (c) {
+      case '\'':
+      case '\"':
+       if (expected_delimiter != '\0') {
+         if (c == expected_delimiter)
+           expected_delimiter = '\0';
+       } else
+         expected_delimiter = c;
+       break;
+
+      case '\\':
+       /* Backslash quotes delimiters and itself, but not macro args.  */
+       if (expected_delimiter != 0 && p < limit
+           && (*p == expected_delimiter || *p == '\\')) {
+         *exp_p++ = *p++;
+         continue;
+       }
+       break;
+
+      case '/':
+       if (expected_delimiter != '\0') /* No comments inside strings.  */
+         break;
+       if (*p == '*') {
+         /* If we find a comment that wasn't removed by handle_directive,
+            this must be -traditional.  So replace the comment with
+            nothing at all.  */
+         exp_p--;
+         p += 1;
+         while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
+           p++;
+#if 0
+         /* Mark this as a concatenation-point, as if it had been ##.  */
+         concat = p;
+#endif
+       }
+       break;
+      }
+    }
+
+    /* Handle the start of a symbol.  */
+    if (is_idchar[c] && nargs > 0) {
+      U_CHAR *id_beg = p - 1;
+      int id_len;
+
+      --exp_p;
+      while (p != limit && is_idchar[*p]) p++;
+      id_len = p - id_beg;
+
+      if (is_idstart[c]) {
+       register struct arglist *arg;
+
+       for (arg = arglist; arg != NULL; arg = arg->next) {
+         struct reflist *tpat;
+
+         if (arg->name[0] == c
+             && arg->length == id_len
+             && strncmp (arg->name, id_beg, id_len) == 0) {
+           if (expected_delimiter && CPP_OPTIONS (pfile)->warn_stringify) {
+             if (CPP_TRADITIONAL (pfile)) {
+               cpp_warning (pfile, "macro argument `%.*s' is stringified.",
+                            id_len, arg->name);
+             } else {
+               cpp_warning (pfile,
+                   "macro arg `%.*s' would be stringified with -traditional.",
+                            id_len, arg->name);
+             }
+           }
+           /* If ANSI, don't actually substitute inside a string.  */
+           if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
+             break;
+           /* make a pat node for this arg and append it to the end of
+              the pat list */
+           tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
+           tpat->next = NULL;
+           tpat->raw_before = concat == id_beg;
+           tpat->raw_after = 0;
+           tpat->rest_args = arg->rest_args;
+           tpat->stringify = (CPP_TRADITIONAL (pfile)
+                              ? expected_delimiter != '\0'
+                              : stringify == id_beg);
+
+           if (endpat == NULL)
+             defn->pattern = tpat;
+           else
+             endpat->next = tpat;
+           endpat = tpat;
+
+           tpat->argno = arg->argno;
+           tpat->nchars = exp_p - lastp;
+           {
+             register U_CHAR *p1 = p;
+             SKIP_WHITE_SPACE (p1);
+             if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
+               tpat->raw_after = 1;
+           }
+           lastp = exp_p;      /* place to start copying from next time */
+           skipped_arg = 1;
+           break;
+         }
+       }
+      }
+
+      /* If this was not a macro arg, copy it into the expansion.  */
+      if (! skipped_arg) {
+       register U_CHAR *lim1 = p;
+       p = id_beg;
+       while (p != lim1)
+         *exp_p++ = *p++;
+       if (stringify == id_beg)
+         cpp_error (pfile,
+                  "`#' operator should be followed by a macro argument name");
+      }
+    }
+  }
+
+  if (limit < end) {
+    while (limit < end && is_space[*limit]) {
+      *exp_p++ = *limit++;
+    }
+  } else if (!CPP_TRADITIONAL (pfile) && expected_delimiter == 0) {
+    /* There is no trailing whitespace, so invent some in ANSI mode.
+       But not if "inside a string" (which in ANSI mode
+       happens only for -D option).  */
+    *exp_p++ = ' ';
+  }
+
+  *exp_p = '\0';
+
+  defn->length = exp_p - defn->expansion;
+
+  /* Crash now if we overrun the allocated size.  */
+  if (defn->length + 1 > maxsize)
+    abort ();
+
+#if 0
+/* This isn't worth the time it takes.  */
+  /* give back excess storage */
+  defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
+#endif
+
+  return defn;
+}
+
+/*
+ * special extension string that can be added to the last macro argument to 
+ * allow it to absorb the "rest" of the arguments when expanded.  Ex:
+ *             #define wow(a, b...)            process (b, a, b)
+ *             { wow (1, 2, 3); }      ->      { process (2, 3, 1, 2, 3); }
+ *             { wow (one, two); }     ->      { process (two, one, two); }
+ * if this "rest_arg" is used with the concat token '##' and if it is not
+ * supplied then the token attached to with ## will not be outputted.  Ex:
+ *             #define wow (a, b...)           process (b ## , a, ## b)
+ *             { wow (1, 2); }         ->      { process (2, 1, 2); }
+ *             { wow (one); }          ->      { process (one); {
+ */
+static char rest_extension[] = "...";
+#define REST_EXTENSION_LENGTH  (sizeof (rest_extension) - 1)
+
+/* Create a DEFINITION node from a #define directive.  Arguments are 
+   as for do_define. */
+static MACRODEF
+create_definition (buf, limit, pfile, predefinition)
+     U_CHAR *buf, *limit;
+     cpp_reader *pfile;
+     int predefinition;
+{
+  U_CHAR *bp;                  /* temp ptr into input buffer */
+  U_CHAR *symname;             /* remember where symbol name starts */
+  int sym_length;              /* and how long it is */
+  int rest_args = 0;
+  long line, col;
+  char *file = CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
+  DEFINITION *defn;
+  int arglengths = 0;          /* Accumulate lengths of arg names
+                                  plus number of args.  */
+  MACRODEF mdef;
+  cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
+
+  bp = buf;
+
+  while (is_hor_space[*bp])
+    bp++;
+
+  symname = bp;                        /* remember where it starts */
+
+  sym_length = check_macro_name (pfile, bp, "macro");
+  bp += sym_length;
+
+  /* Lossage will occur if identifiers or control keywords are broken
+     across lines using backslash.  This is not the right place to take
+     care of that. */
+
+  if (*bp == '(') {
+    struct arglist *arg_ptrs = NULL;
+    int argno = 0;
+
+    bp++;                      /* skip '(' */
+    SKIP_WHITE_SPACE (bp);
+
+    /* Loop over macro argument names.  */
+    while (*bp != ')') {
+      struct arglist *temp;
+
+      temp = (struct arglist *) alloca (sizeof (struct arglist));
+      temp->name = bp;
+      temp->next = arg_ptrs;
+      temp->argno = argno++;
+      temp->rest_args = 0;
+      arg_ptrs = temp;
+
+      if (rest_args)
+       cpp_pedwarn (pfile, "another parameter follows `%s'", rest_extension);
+
+      if (!is_idstart[*bp])
+       cpp_pedwarn (pfile, "invalid character in macro parameter name");
+      
+      /* Find the end of the arg name.  */
+      while (is_idchar[*bp]) {
+       bp++;
+       /* do we have a "special" rest-args extension here? */
+       if (limit - bp > REST_EXTENSION_LENGTH &&
+           strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
+         rest_args = 1;
+         temp->rest_args = 1;
+         break;
+       }
+      }
+      temp->length = bp - temp->name;
+      if (rest_args == 1)
+       bp += REST_EXTENSION_LENGTH;
+      arglengths += temp->length + 2;
+      SKIP_WHITE_SPACE (bp);
+      if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
+       cpp_error (pfile, "badly punctuated parameter list in `#define'");
+       goto nope;
+      }
+      if (*bp == ',') {
+       bp++;
+       SKIP_WHITE_SPACE (bp);
+      }
+      if (bp >= limit) {
+       cpp_error (pfile, "unterminated parameter list in `#define'");
+       goto nope;
+      }
+      {
+       struct arglist *otemp;
+
+       for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
+         if (temp->length == otemp->length &&
+           strncmp (temp->name, otemp->name, temp->length) == 0) {
+             U_CHAR *name;
+
+             name = (U_CHAR *) alloca (temp->length + 1);
+             (void) strncpy (name, temp->name, temp->length);
+             name[temp->length] = '\0';
+             cpp_error (pfile,
+                        "duplicate argument name `%s' in `#define'", name);
+             goto nope;
+         }
+      }
+    }
+
+    ++bp;                      /* skip paren */
+    /* Skip exactly one space or tab if any.  */
+    if (bp < limit && (*bp == ' ' || *bp == '\t')) ++bp;
+    /* now everything from bp before limit is the definition. */
+    defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
+    defn->rest_args = rest_args;
+
+    /* Now set defn->args.argnames to the result of concatenating
+       the argument names in reverse order
+       with comma-space between them.  */
+    defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
+    {
+      struct arglist *temp;
+      int i = 0;
+      for (temp = arg_ptrs; temp; temp = temp->next) {
+       bcopy (temp->name, &defn->args.argnames[i], temp->length);
+       i += temp->length;
+       if (temp->next != 0) {
+         defn->args.argnames[i++] = ',';
+         defn->args.argnames[i++] = ' ';
+       }
+      }
+      defn->args.argnames[i] = 0;
+    }
+  } else {
+    /* simple expansion or empty definition; gobble it */
+    if (is_hor_space[*bp])
+      ++bp;            /* skip exactly one blank/tab char */
+    /* now everything from bp before limit is the definition. */
+    defn = collect_expansion (pfile, bp, limit, -1, NULL_PTR);
+    defn->args.argnames = (U_CHAR *) "";
+  }
+
+  defn->line = line;
+  defn->file = file;
+
+  /* OP is null if this is a predefinition */
+  defn->predefined = predefinition;
+  mdef.defn = defn;
+  mdef.symnam = symname;
+  mdef.symlen = sym_length;
+
+  return mdef;
+
+ nope:
+  mdef.defn = 0;
+  return mdef;
+}
+
+/* Check a purported macro name SYMNAME, and yield its length.
+   USAGE is the kind of name this is intended for.  */
+
+static int
+check_macro_name (pfile, symname, usage)
+     cpp_reader *pfile;
+     U_CHAR *symname;
+     char *usage;
+{
+  U_CHAR *p;
+  int sym_length;
+
+  for (p = symname; is_idchar[*p]; p++)
+    ;
+  sym_length = p - symname;
+  if (sym_length == 0)
+    cpp_error (pfile, "invalid %s name", usage);
+  else if (!is_idstart[*symname]) {
+    U_CHAR *msg;                       /* what pain... */
+    msg = (U_CHAR *) alloca (sym_length + 1);
+    bcopy (symname, msg, sym_length);
+    msg[sym_length] = 0;
+    cpp_error (pfile, "invalid %s name `%s'", usage, msg);
+  } else {
+    if (! strncmp (symname, "defined", 7) && sym_length == 7)
+      cpp_error (pfile, "invalid %s name `defined'", usage);
+  }
+  return sym_length;
+}
+
+/*
+ * return zero if two DEFINITIONs are isomorphic
+ */
+static int
+compare_defs (d1, d2)
+     DEFINITION *d1, *d2;
+{
+  register struct reflist *a1, *a2;
+  register U_CHAR *p1 = d1->expansion;
+  register U_CHAR *p2 = d2->expansion;
+  int first = 1;
+
+  if (d1->nargs != d2->nargs)
+    return 1;
+  if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
+    return 1;
+  for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
+       a1 = a1->next, a2 = a2->next) {
+    if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars))
+         || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
+       || a1->argno != a2->argno
+       || a1->stringify != a2->stringify
+       || a1->raw_before != a2->raw_before
+       || a1->raw_after != a2->raw_after)
+      return 1;
+    first = 0;
+    p1 += a1->nchars;
+    p2 += a2->nchars;
+  }
+  if (a1 != a2)
+    return 1;
+  if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
+                    p2, d2->length - (p2 - d2->expansion), 1))
+    return 1;
+  return 0;
+}
+
+/* Return 1 if two parts of two macro definitions are effectively different.
+   One of the parts starts at BEG1 and has LEN1 chars;
+   the other has LEN2 chars at BEG2.
+   Any sequence of whitespace matches any other sequence of whitespace.
+   FIRST means these parts are the first of a macro definition;
+    so ignore leading whitespace entirely.
+   LAST means these parts are the last of a macro definition;
+    so ignore trailing whitespace entirely.  */
+
+static int
+comp_def_part (first, beg1, len1, beg2, len2, last)
+     int first;
+     U_CHAR *beg1, *beg2;
+     int len1, len2;
+     int last;
+{
+  register U_CHAR *end1 = beg1 + len1;
+  register U_CHAR *end2 = beg2 + len2;
+  if (first) {
+    while (beg1 != end1 && is_space[*beg1]) beg1++;
+    while (beg2 != end2 && is_space[*beg2]) beg2++;
+  }
+  if (last) {
+    while (beg1 != end1 && is_space[end1[-1]]) end1--;
+    while (beg2 != end2 && is_space[end2[-1]]) end2--;
+  }
+  while (beg1 != end1 && beg2 != end2) {
+    if (is_space[*beg1] && is_space[*beg2]) {
+      while (beg1 != end1 && is_space[*beg1]) beg1++;
+      while (beg2 != end2 && is_space[*beg2]) beg2++;
+    } else if (*beg1 == *beg2) {
+      beg1++; beg2++;
+    } else break;
+  }
+  return (beg1 != end1) || (beg2 != end2);
+}
+
+/* Process a #define command.
+BUF points to the contents of the #define command, as a contiguous string.
+LIMIT points to the first character past the end of the definition.
+KEYWORD is the keyword-table entry for #define,
+or NULL for a "predefined" macro.  */
+
+static int
+do_define (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  int hashcode;
+  MACRODEF mdef;
+  HASHNODE *hp;
+
+#if 0
+  /* If this is a precompiler run (with -pcp) pass thru #define commands.  */
+  if (pcp_outfile && keyword)
+    pass_thru_directive (buf, limit, pfile, keyword);
+#endif
+
+  mdef = create_definition (buf, limit, pfile, keyword == NULL);
+  if (mdef.defn == 0)
+    goto nope;
+
+  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 (mdef.defn, hp->value.defn);
+      /* Redefining a constant is ok with -D.  */
+      else if (hp->type == T_CONST)
+        ok = ! CPP_OPTIONS (pfile)->done_initializing;
+      /* Print the warning if it's not ok.  */
+      if (!ok)
+       {
+         U_CHAR *msg;          /* what pain... */
+
+         /* If we are passing through #define and #undef directives, do
+            that for this re-definition now.  */
+         if (CPP_OPTIONS (pfile)->debug_output && keyword)
+           pass_thru_directive (buf, limit, pfile, keyword);
+
+         msg = (U_CHAR *) alloca (mdef.symlen + 22);
+         *msg = '`';
+         bcopy (mdef.symnam, msg + 1, mdef.symlen);
+         strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
+         cpp_pedwarn (pfile, msg);
+         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
+    {
+      /* If we are passing through #define and #undef directives, do
+        that for this new definition now.  */
+      if (CPP_OPTIONS (pfile)->debug_output && keyword)
+       pass_thru_directive (buf, limit, pfile, keyword);
+      install (mdef.symnam, mdef.symlen, T_MACRO, 0,
+              (char *) mdef.defn, hashcode);
+    }
+
+  return 0;
+
+nope:
+
+  return 1;
+}
+
+/* This structure represents one parsed argument in a macro call.
+   `raw' points to the argument text as written (`raw_length' is its length).
+   `expanded' points to the argument's macro-expansion
+   (its length is `expand_length').
+   `stringified_length' is the length the argument would have
+   if stringified.
+   `use_count' is the number of times this macro arg is substituted
+   into the macro.  If the actual use count exceeds 10, 
+   the value stored is 10. */
+
+/* raw and expanded are relative to ARG_BASE */
+#define ARG_BASE ((pfile)->token_buffer)
+
+struct argdata {
+  /* Strings relative to pfile->token_buffer */
+  long raw, expanded, stringified;
+  int raw_length, expand_length;
+  int stringified_length;
+  char newlines;
+  char comments;
+  char use_count;
+};
+
+
+cpp_buffer*
+cpp_push_buffer (pfile, buffer, length)
+     cpp_reader *pfile;
+     U_CHAR *buffer;
+     long length;
+{
+#ifdef STATIC_BUFFERS
+  register cpp_buffer *buf;
+  if (buf == pfile->buffer_stack)
+    fatal ("macro or `#include' recursion too deep");
+  buf = CPP_BUFFER (pfile) - 1;
+  bzero ((char *) buf, sizeof (cpp_buffer));
+  CPP_BUFFER (pfile) = buf;
+#else
+  register cpp_buffer *buf = (cpp_buffer*) xmalloc (sizeof(cpp_buffer));
+  bzero ((char *) buf, sizeof (cpp_buffer));
+  CPP_PREV_BUFFER (buf) = CPP_BUFFER (pfile);
+  CPP_BUFFER (pfile) = buf;
+#endif
+  buf->if_stack = pfile->if_stack;
+  buf->cleanup = null_cleanup;
+  buf->underflow = null_underflow;
+  buf->buf = buf->cur = buffer;
+  buf->alimit = buf->rlimit = buffer + length;
+  
+  return buf;
+}
+
+cpp_buffer*
+cpp_pop_buffer (pfile)
+     cpp_reader *pfile;
+{
+  cpp_buffer *buf = CPP_BUFFER (pfile);
+#ifdef STATIC_BUFFERS
+  (*buf->cleanup) (buf, pfile);
+  return ++CPP_BUFFER (pfile);
+#else
+  cpp_buffer *next_buf = CPP_PREV_BUFFER (buf);
+  (*buf->cleanup) (buf, pfile);
+  CPP_BUFFER (pfile) = next_buf;
+  free (buf);
+  return next_buf;
+#endif
+}
+
+/* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
+   Pop the buffer when done. */
+
+void
+cpp_scan_buffer (pfile)
+     cpp_reader *pfile;
+{
+  cpp_buffer *buffer = CPP_BUFFER (pfile);
+  for (;;)
+    {
+      enum cpp_token token = cpp_get_token (pfile);
+      if (token == CPP_EOF) /* Should not happen ... */
+       break;
+      if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
+       {
+         cpp_pop_buffer (pfile);
+         break;
+       }
+    }
+}
+
+/*
+ * Rescan a string 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.
+ *
+ * OUTPUT_MARKS nonzero means keep Newline markers found in the input
+ * and insert such markers when appropriate.  See `rescan' for details.
+ * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
+ * before substitution; it is 0 for other uses.
+ */
+
+void
+cpp_expand_to_buffer (pfile, buf, length)
+     cpp_reader *pfile;
+     U_CHAR *buf;
+     int length;
+{
+  register cpp_buffer *ip;
+  cpp_buffer obuf;
+  U_CHAR *limit = buf + length;
+  U_CHAR *buf1;
+#if 0
+  int odepth = indepth;
+#endif
+
+  if (length < 0)
+    abort ();
+
+  /* Set up the input on the input stack.  */
+
+  buf1 = (U_CHAR *) alloca (length + 1);
+  {
+    register U_CHAR *p1 = buf;
+    register U_CHAR *p2 = buf1;
+
+    while (p1 != limit)
+      *p2++ = *p1++;
+  }
+  buf1[length] = 0;
+
+  ip = cpp_push_buffer (pfile, buf1, length);
+#if 0
+  ip->lineno = obuf.lineno = 1;
+#endif
+
+  /* Scan the input, create the output.  */
+  cpp_scan_buffer (pfile);
+
+#if 0
+  if (indepth != odepth)
+    abort ();
+#endif
+
+  CPP_NUL_TERMINATE (pfile);
+}
+
+\f
+static void
+adjust_position (buf, limit, linep, colp)
+     U_CHAR *buf;
+     U_CHAR *limit;
+     long *linep;
+     long *colp;
+{
+  while (buf < limit)
+    {
+      U_CHAR ch = *buf++;
+      if (ch == '\n')
+       (*linep)++, (*colp) = 1;
+      else
+       (*colp)++;
+    }
+}
+
+/* Move line_base forward, updating lineno and colno. */
+
+static void
+update_position (pbuf)
+     register cpp_buffer *pbuf;
+{
+  unsigned char *old_pos = pbuf->buf + pbuf->line_base;
+  unsigned char *new_pos = pbuf->cur;
+  register struct parse_marker *mark;
+  for (mark = pbuf->marks;  mark != NULL; mark = mark->next)
+    {
+      if (pbuf->buf + mark->position < new_pos)
+       new_pos = pbuf->buf + mark->position;
+    }
+  pbuf->line_base += new_pos - old_pos;
+  adjust_position (old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
+}
+
+void
+cpp_buf_line_and_col (pbuf, linep, colp)
+     register cpp_buffer *pbuf;
+     long *linep, *colp;
+{
+  long dummy;
+  if (colp == NULL)
+    colp = &dummy;
+  if (pbuf)
+    {
+      *linep = pbuf->lineno;
+      *colp = pbuf->colno;
+      adjust_position (pbuf->buf + pbuf->line_base, pbuf->cur, linep, colp);
+    }
+  else
+    {
+      *linep = 0;
+      *colp = 0;
+    }
+}
+
+/* Return the cpp_buffer that corresponds to a file (not a macro). */
+
+cpp_buffer*
+cpp_file_buffer (pfile)
+     cpp_reader *pfile;
+{
+  cpp_buffer *ip;
+
+  for (ip = CPP_BUFFER (pfile); ip != NULL; ip = CPP_PREV_BUFFER (ip))
+    if (ip->fname != NULL)
+      return ip;
+  return NULL;
+}
+
+static long
+count_newlines (buf, limit)
+     register U_CHAR *buf;
+     register U_CHAR *limit;
+{
+  register long count = 0;
+  while (buf < limit)
+    {
+      U_CHAR ch = *buf++;
+      if (ch == '\n')
+       count++;
+    }
+  return count;
+}
+
+/*
+ * write out a #line command, for instance, after an #include file.
+ * If CONDITIONAL is nonzero, we can omit the #line if it would
+ * appear to be a no-op, and we can output a few newlines instead
+ * if we want to increase the line number by a small amount.
+ * FILE_CHANGE says whether we are entering a file, leaving, or neither.
+ */
+
+static void
+output_line_command (pfile, conditional, file_change)
+     cpp_reader *pfile;
+     int conditional;
+     enum file_change_code file_change;
+{
+  int len;
+  char *line_cmd_buf, *line_end;
+  long line, col;
+  cpp_buffer *ip = CPP_BUFFER (pfile);
+
+  if (CPP_OPTIONS (pfile)->no_line_commands
+      || ip->fname == NULL || CPP_OPTIONS (pfile)->no_output) {
+    return;
+  }
+
+  update_position (ip);
+  line = CPP_BUFFER (pfile)->lineno;
+  col = CPP_BUFFER (pfile)->colno;
+  adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
+
+  if (conditional) {
+    if (line == pfile->lineno)
+      return;
+
+    /* If the inherited line number is a little too small,
+       output some newlines instead of a #line command.  */
+    if (line > pfile->lineno && line < pfile->lineno + 8) {
+      CPP_RESERVE (pfile, 20);
+      while (line > pfile->lineno) {
+       CPP_PUTC_Q (pfile, '\n');
+       pfile->lineno++;
+      }
+      return;
+    }
+  }
+
+#if 0
+  /* Don't output a line number of 0 if we can help it.  */
+  if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
+      && *ip->bufp == '\n') {
+    ip->lineno++;
+    ip->bufp++;
+  }
+#endif
+
+  CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
+  {
+#ifdef OUTPUT_LINE_COMMANDS
+    static char sharp_line[] = "#line ";
+#else
+    static char sharp_line[] = "# ";
+#endif
+    CPP_PUTS_Q (pfile, sharp_line, sizeof(sharp_line)-1);
+  }
+
+  sprintf (CPP_PWRITTEN (pfile), "%d ", line);
+  CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
+
+  quote_string (pfile, ip->nominal_fname); 
+  if (file_change != same_file) {
+    CPP_PUTC_Q (pfile, ' ');
+    CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
+  }
+  /* Tell cc1 if following text comes from a system header file.  */
+  if (ip->system_header_p) {
+    CPP_PUTC_Q (pfile, ' ');
+    CPP_PUTC_Q (pfile, '3');
+  }
+#ifndef NO_IMPLICIT_EXTERN_C
+  /* Tell cc1plus if following text should be treated as C.  */
+  if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus) {
+    CPP_PUTC_Q (pfile, ' ');
+    CPP_PUTC_Q (pfile, '4');
+  }
+#endif
+  CPP_PUTC_Q (pfile, '\n');
+  pfile->lineno = line;
+}
+\f
+/*
+ * Parse a macro argument and store the info on it into *ARGPTR.
+ * REST_ARGS means to absorb the rest of the args.
+ * Return nonzero to indicate a syntax error.
+ */
+
+static enum cpp_token
+macarg (pfile, rest_args)
+     cpp_reader *pfile;
+     int rest_args;
+{
+  int paren = 0;
+  enum cpp_token token;
+  long arg_start = CPP_WRITTEN (pfile);
+  char save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
+  CPP_OPTIONS (pfile)->put_out_comments = 0;
+
+  /* Try to parse as much of the argument as exists at this
+     input stack level.  */
+  pfile->no_macro_expand++;
+  for (;;)
+    {
+      token = cpp_get_token (pfile);
+      switch (token)
+       {
+       case CPP_EOF:
+         goto done;
+       case CPP_POP:
+         /* If we've hit end of file, it's an error (reported by caller).
+            Ditto if it's the end of cpp_expand_to_buffer text.
+            If we've hit end of macro, just continue.  */
+         if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+           goto done;
+         break;
+       case CPP_LPAREN:
+         paren++;
+         break;
+       case CPP_RPAREN:
+         if (--paren < 0)
+           goto found;
+         break;
+       case CPP_COMMA:
+         /* if we've returned to lowest level and
+            we aren't absorbing all args */
+         if (paren == 0 && rest_args == 0)
+           goto found;
+         break;
+       found:
+         /* Remove ',' or ')' from argument buffer. */
+         CPP_ADJUST_WRITTEN (pfile, -1);
+         goto done;
+      default: ;
+       }
+    }
+
+ done:
+  CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
+  pfile->no_macro_expand--;
+
+  return token;
+}
+\f
+/* Turn newlines to spaces in the string of length LENGTH at START,
+   except inside of string constants.
+   The string is copied into itself with its beginning staying fixed.  */
+
+static int
+change_newlines (start, length)
+     U_CHAR *start;
+     int length;
+{
+  register U_CHAR *ibp;
+  register U_CHAR *obp;
+  register U_CHAR *limit;
+  register int c;
+
+  ibp = start;
+  limit = start + length;
+  obp = start;
+
+  while (ibp < limit) {
+    *obp++ = c = *ibp++;
+    switch (c) {
+
+    case '\'':
+    case '\"':
+      /* Notice and skip strings, so that we don't delete newlines in them.  */
+      {
+       int quotec = c;
+       while (ibp < limit) {
+         *obp++ = c = *ibp++;
+         if (c == quotec)
+           break;
+         if (c == '\n' && quotec == '\'')
+           break;
+       }
+      }
+      break;
+    }
+  }
+
+  return obp - start;
+}
+
+\f
+static struct tm *
+timestamp (pfile)
+     cpp_reader *pfile;
+{
+  if (!pfile->timebuf) {
+    time_t t = time ((time_t *)0);
+    pfile->timebuf = localtime (&t);
+  }
+  return pfile->timebuf;
+}
+
+static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                            "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+                           };
+
+/*
+ * expand things like __FILE__.  Place the expansion into the output
+ * buffer *without* rescanning.
+ */
+
+static void
+special_symbol (hp, pfile)
+     HASHNODE *hp;
+     cpp_reader *pfile;
+{
+  char *buf;
+  int i, len;
+  int true_indepth;
+  cpp_buffer *ip = NULL;
+  struct tm *timebuf;
+
+  int paren = 0;               /* For special `defined' keyword */
+
+#if 0
+  if (pcp_outfile && pcp_inside_if
+      && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
+    cpp_error (pfile,
+              "Predefined macro `%s' used inside `#if' during precompilation",
+              hp->name);
+#endif
+    
+  for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
+    {
+      if (ip == NULL)
+       {
+         cpp_error (pfile, "cccp error: not in any file?!");
+         return;                       /* the show must go on */
+       }
+      if (ip->fname != NULL)
+       break;
+    }
+
+  switch (hp->type)
+    {
+    case T_FILE:
+    case T_BASE_FILE:
+      {
+       char *string;
+       if (hp->type == T_BASE_FILE)
+         {
+           while (CPP_PREV_BUFFER (ip))
+             ip = CPP_PREV_BUFFER (ip);
+         }
+       string = ip->nominal_fname;
+
+       if (!string)
+         string = "";
+       CPP_RESERVE (pfile, 3 + 4 * strlen (string));
+       quote_string (pfile, string);
+       return;
+      }
+
+    case T_INCLUDE_LEVEL:
+      true_indepth = 0;
+      for (ip = CPP_BUFFER (pfile);  ip != NULL; ip = CPP_PREV_BUFFER (ip))
+       if (ip->fname != NULL)
+         true_indepth++;
+
+      buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
+      sprintf (buf, "%d", true_indepth - 1);
+      break;
+
+  case T_VERSION:
+      buf = (char *) alloca (3 + strlen (version_string));
+      sprintf (buf, "\"%s\"", version_string);
+      break;
+
+#ifndef NO_BUILTIN_SIZE_TYPE
+    case T_SIZE_TYPE:
+      buf = SIZE_TYPE;
+      break;
+#endif
+
+#ifndef NO_BUILTIN_PTRDIFF_TYPE
+    case T_PTRDIFF_TYPE:
+      buf = PTRDIFF_TYPE;
+      break;
+#endif
+
+    case T_WCHAR_TYPE:
+      buf = CPP_WCHAR_TYPE (pfile);
+    break;
+
+    case T_USER_LABEL_PREFIX_TYPE:
+      buf = USER_LABEL_PREFIX;
+      break;
+
+    case T_REGISTER_PREFIX_TYPE:
+      buf = REGISTER_PREFIX;
+      break;
+
+  case T_CONST:
+      buf = (char *) alloca (4 * sizeof (int));
+      sprintf (buf, "%d", hp->value.ival);
+#if 0
+      if (pcp_inside_if && pcp_outfile)
+       /* Output a precondition for this macro use */
+       fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
+#endif
+      break;
+
+    case T_SPECLINE:
+      {
+       long line = CPP_BUFFER (pfile)->lineno;
+       long col = CPP_BUFFER (pfile)->colno;
+       cpp_buffer *ip = CPP_BUFFER (pfile);
+       adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
+
+       buf = (char *) alloca (10);
+       sprintf (buf, "%d", line);
+      }
+      break;
+
+    case T_DATE:
+    case T_TIME:
+      buf = (char *) alloca (20);
+      timebuf = timestamp (pfile);
+      if (hp->type == T_DATE)
+       sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
+                timebuf->tm_mday, timebuf->tm_year + 1900);
+      else
+       sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
+                timebuf->tm_sec);
+      break;
+
+    case T_SPEC_DEFINED:
+      buf = " 0 ";             /* Assume symbol is not defined */
+      ip = CPP_BUFFER (pfile);
+      SKIP_WHITE_SPACE (ip->cur);
+      if (*ip->cur == '(')
+       {
+         paren++;
+         ip->cur++;                    /* Skip over the paren */
+         SKIP_WHITE_SPACE (ip->cur);
+       }
+
+      if (!is_idstart[*ip->cur])
+       goto oops;
+      if (hp = cpp_lookup (pfile, ip->cur, -1, -1))
+       {
+#if 0
+         if (pcp_outfile && pcp_inside_if
+             && (hp->type == T_CONST
+                 || (hp->type == T_MACRO && hp->value.defn->predefined)))
+           /* Output a precondition for this macro use. */
+           fprintf (pcp_outfile, "#define %s\n", hp->name);
+#endif
+         buf = " 1 ";
+       }
+#if 0
+      else
+       if (pcp_outfile && pcp_inside_if)
+         {
+           /* Output a precondition for this macro use */
+           U_CHAR *cp = ip->bufp;
+           fprintf (pcp_outfile, "#undef ");
+           while (is_idchar[*cp]) /* Ick! */
+             fputc (*cp++, pcp_outfile);
+           putc ('\n', pcp_outfile);
+         }
+#endif
+      while (is_idchar[*ip->cur])
+       ++ip->cur;
+      SKIP_WHITE_SPACE (ip->cur);
+      if (paren)
+       {
+         if (*ip->cur != ')')
+           goto oops;
+         ++ip->cur;
+       }
+      break;
+
+    oops:
+
+      cpp_error (pfile, "`defined' without an identifier");
+      break;
+
+    default:
+      cpp_error (pfile, "cccp error: invalid special hash type"); /* time for gdb */
+      abort ();
+    }
+  len = strlen (buf);
+  CPP_RESERVE (pfile, len + 1);
+  CPP_PUTS_Q (pfile, buf, len);
+  CPP_NUL_TERMINATE_Q (pfile);
+
+  return;
+}
+
+/* Initialize the built-in macros.  */
+
+static void
+initialize_builtins (pfile)
+     cpp_reader *pfile;
+{
+  install ("__LINE__", -1, T_SPECLINE, 0, 0, -1);
+  install ("__DATE__", -1, T_DATE, 0, 0, -1);
+  install ("__FILE__", -1, T_FILE, 0, 0, -1);
+  install ("__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1);
+  install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1);
+  install ("__VERSION__", -1, T_VERSION, 0, 0, -1);
+#ifndef NO_BUILTIN_SIZE_TYPE
+  install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1);
+#endif
+#ifndef NO_BUILTIN_PTRDIFF_TYPE
+  install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1);
+#endif
+  install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1);
+  install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE, 0, 0, -1);
+  install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1);
+  install ("__TIME__", -1, T_TIME, 0, 0, -1);
+  if (!CPP_TRADITIONAL (pfile))
+    install ("__STDC__", -1, T_CONST, STDC_VALUE, 0, -1);
+  if (CPP_OPTIONS (pfile)->objc)
+    install ("__OBJC__", -1, T_CONST, 1, 0, -1);
+/*  This is supplied using a -D by the compiler driver
+    so that it is present only when truly compiling with GNU C.  */
+/*  install ("__GNUC__", -1, T_CONST, 2, 0, -1);  */
+
+  if (CPP_OPTIONS (pfile)->debug_output)
+    {
+      char directive[2048];
+      register struct directive *dp = &directive_table[0];
+      struct tm *timebuf = timestamp ();
+      cpp_buffer *pbuffer = CPP_BUFFER (pfile);
+
+      while (CPP_PREV_BUFFER (pbuffer))
+       pbuffer = CPP_PREV_BUFFER (pbuffer);
+      sprintf (directive, " __BASE_FILE__ \"%s\"\n",
+              pbuffer->nominal_fname);
+      output_line_command (pfile, 0, same_file);
+      pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
+
+      sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
+      output_line_command (pfile, 0, same_file);
+      pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
+
+#ifndef NO_BUILTIN_SIZE_TYPE
+      sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
+      output_line_command (pfile, 0, same_file);
+      pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
+#endif
+
+#ifndef NO_BUILTIN_PTRDIFF_TYPE
+      sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
+      output_line_command (pfile, 0, same_file);
+      pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
+#endif
+
+      sprintf (directive, " __WCHAR_TYPE__ %s\n", CPP_WCHAR_TYPE (pfile));
+      output_line_command (pfile, 0, same_file);
+      pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
+
+      sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
+              monthnames[timebuf->tm_mon],
+              timebuf->tm_mday, timebuf->tm_year + 1900);
+      output_line_command (pfile, 0, same_file);
+      pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
+
+      sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
+              timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
+      output_line_command (pfile, 0, same_file);
+      pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
+
+      if (!CPP_TRADITIONAL (pfile))
+       {
+          sprintf (directive, " __STDC__ 1");
+          output_line_command (pfile, 0, same_file);
+          pass_thru_directive (directive, &directive[strlen (directive)],
+                              pfile, dp);
+       }
+      if (CPP_OPTIONS (pfile)->objc)
+       {
+          sprintf (directive, " __OBJC__ 1");
+          output_line_command (pfile, 0, same_file);
+          pass_thru_directive (directive, &directive[strlen (directive)],
+                              pfile, dp);
+       }
+    }
+}
+\f
+/* Return 1 iff a token ending in C1 followed directly by a token C2
+   could cause mis-tokenization. */
+
+static int
+unsafe_chars (c1, c2)
+     int c1, c2;
+{
+  switch (c1)
+    {
+    case '+': case '-':
+      if (c2 == c1 || c2 == '=')
+       return 1;
+      goto letter;
+    case '.':
+    case '0': case '1': case '2': case '3': case '4':
+    case '5': case '6': case '7': case '8': case '9':
+    case 'e': case 'E':
+      if (c2 == '-' || c2 == '+')
+       return 1; /* could extend a pre-processing number */
+      goto letter;
+    case 'L':
+      if (c2 == '\'' || c2 == '\"')
+       return 1;   /* Could turn into L"xxx" or L'xxx'. */
+      goto letter;
+    letter:
+    case '_':
+    case 'a': case 'b': case 'c': case 'd':           case 'f':
+    case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
+    case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
+    case 's': case 't': case 'u': case 'v': case 'w': case 'x':
+    case 'y': case 'z':
+    case 'A': case 'B': case 'C': case 'D':           case 'F':
+    case 'G': case 'H': case 'I': case 'J': case 'K':
+    case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
+    case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
+    case 'Y': case 'Z':
+      /* We're in the middle of either a name or a pre-processing number. */
+      return (is_idchar[c2] || c2 == '.');
+    case '<': case '>': case '!': case '%': case '#': case ':':
+    case '^': case '&': case '|': case '*': case '/': case '=':
+      return (c2 == c1 || c2 == '=');
+    }
+  return 0;
+}
+
+/* Expand a macro call.
+   HP points to the symbol that is the macro being called.
+   Put the result of expansion onto the input stack
+   so that subsequent input by our caller will use it.
+
+   If macro wants arguments, caller has already verified that
+   an argument list follows; arguments come from the input stack.  */
+
+static void
+macroexpand (pfile, hp)
+     cpp_reader *pfile;
+     HASHNODE *hp;
+{
+  int nargs;
+  DEFINITION *defn = hp->value.defn;
+  register U_CHAR *xbuf;
+  int xbuf_len;
+  struct argdata *args;
+  long old_written = CPP_WRITTEN (pfile);
+#if 0
+  int start_line = instack[indepth].lineno;
+#endif
+  int rest_args, rest_zero;
+      register int i;
+
+#if 0
+  CHECK_DEPTH (return;);
+#endif
+
+#if 0
+  /* This macro is being used inside a #if, which means it must be */
+  /* recorded as a precondition.  */
+  if (pcp_inside_if && pcp_outfile && defn->predefined)
+    dump_single_macro (hp, pcp_outfile);
+#endif
+
+  nargs = defn->nargs;
+
+  if (nargs >= 0)
+    {
+      char *parse_error = 0;
+      enum cpp_token token;
+
+      args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
+
+      for (i = 0; i < nargs; i++)
+       {
+         args[i].raw = args[i].expanded = 0;
+         args[i].raw_length = 0; 
+         args[i].expand_length = args[i].stringified_length = -1;
+         args[i].use_count = 0;
+       }
+
+      /* Parse all the macro args that are supplied.  I counts them.
+        The first NARGS args are stored in ARGS.
+        The rest are discarded.  If rest_args is set then we assume
+        macarg absorbed the rest of the args. */
+      i = 0;
+      rest_args = 0;
+      rest_args = 0;
+      FORWARD(1); /* Discard the open-parenthesis before the first arg.  */
+      do
+       {
+         if (rest_args)
+           continue;
+         if (i < nargs || (nargs == 0 && i == 0))
+           {
+             /* if we are working on last arg which absorbs rest of args... */
+             if (i == nargs - 1 && defn->rest_args)
+               rest_args = 1;
+             args[i].raw = CPP_WRITTEN (pfile);
+             token = macarg (pfile, rest_args);
+             args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
+             args[i].newlines = 0; /* FIXME */
+           }
+         else
+           token = macarg (pfile, 0);
+         if (token == CPP_EOF || token == CPP_POP)
+           {
+             parse_error = "unterminated macro call";
+#if 1
+             cpp_error_with_line (pfile, line_for_error (0), parse_error);
+#else
+             cpp_error_with_line (pfile, line_for_error (start_line), parse_error);
+#endif
+             break;
+           }
+         i++;
+       } while (token == CPP_COMMA);
+
+      /* If we got one arg but it was just whitespace, call that 0 args.  */
+      if (i == 1)
+       {
+         register U_CHAR *bp = ARG_BASE + args[0].raw;
+         register U_CHAR *lim = bp + args[0].raw_length;
+         /* cpp.texi says for foo ( ) we provide one argument.
+            However, if foo wants just 0 arguments, treat this as 0.  */
+         if (nargs == 0)
+           while (bp != lim && is_space[*bp]) bp++;
+         if (bp == lim)
+           i = 0;
+       }
+
+      /* Don't output an error message if we have already output one for
+        a parse error above.  */
+      rest_zero = 0;
+      if (nargs == 0 && i > 0)
+       {
+         if (! parse_error)
+           cpp_error (pfile, "arguments given to macro `%s'", hp->name);
+       }
+      else if (i < nargs)
+       {
+         /* traditional C allows foo() if foo wants one argument.  */
+         if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
+           ;
+         /* the rest args token is allowed to absorb 0 tokens */
+         else if (i == nargs - 1 && defn->rest_args)
+           rest_zero = 1;
+         else if (parse_error)
+           ;
+         else if (i == 0)
+           cpp_error (pfile, "macro `%s' used without args", hp->name);
+         else if (i == 1)
+           cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
+         else
+           cpp_error (pfile, "macro `%s' used with only %d args",
+                      hp->name, i);
+      }
+      else if (i > nargs)
+       {
+         if (! parse_error)
+           cpp_error (pfile,
+                      "macro `%s' used with too many (%d) args", hp->name, i);
+       }
+    }
+
+  /* If macro wants zero args, we parsed the arglist for checking only.
+     Read directly from the macro definition.  */
+  if (nargs <= 0)
+    {
+      xbuf = defn->expansion;
+      xbuf_len = defn->length;
+    }
+  else
+    {
+      register U_CHAR *exp = defn->expansion;
+      register int offset;     /* offset in expansion,
+                                  copied a piece at a time */
+      register int totlen;     /* total amount of exp buffer filled so far */
+
+      register struct reflist *ap, *last_ap;
+
+      /* Macro really takes args.  Compute the expansion of this call.  */
+
+      /* Compute length in characters of the macro's expansion.
+        Also count number of times each arg is used.  */
+      xbuf_len = defn->length;
+      for (ap = defn->pattern; ap != NULL; ap = ap->next)
+       {
+         if (ap->stringify)
+           {
+             register struct argdata *arg = &args[ap->argno];
+             /* Stringify it it hasn't already been */
+             if (arg->stringified_length < 0)
+               {
+                 int arglen = arg->raw_length;
+                 int escaped = 0;
+                 int in_string = 0;
+                 int c;
+                 /* Initially need_space is -1.  Otherwise, 1 means the
+                    previous character was a space, but we suppressed it;
+                    0 means the previous character was a non-space. */
+                 int need_space = -1;
+                 i = 0;
+                 arg->stringified = CPP_WRITTEN (pfile);
+                 if (!CPP_TRADITIONAL (pfile))
+                   CPP_PUTC (pfile, '\"'); /* insert beginning quote */
+                 for (; i < arglen; i++)
+                   {
+                     c = (ARG_BASE + arg->raw)[i];
+
+                     if (! in_string)
+                       {
+                         /* Internal sequences of whitespace are replaced by
+                            one space except within an string or char token.*/
+                         if (is_space[c])
+                           {
+                             if (need_space == 0)
+                               need_space = 1;
+                             continue;
+                           }
+                         else if (need_space > 0)
+                           CPP_PUTC (pfile, ' ');
+                         need_space = 0;
+                       }
+
+                     if (escaped)
+                       escaped = 0;
+                     else
+                       {
+                         if (c == '\\')
+                           escaped = 1;
+                         if (in_string)
+                           {
+                             if (c == in_string)
+                               in_string = 0;
+                           }
+                         else if (c == '\"' || c == '\'')
+                           in_string = c;
+                       }
+
+                     /* Escape these chars */
+                     if (c == '\"' || (in_string && c == '\\'))
+                       CPP_PUTC (pfile, '\\');
+                     if (isprint (c))
+                       CPP_PUTC (pfile, c);
+                     else
+                       {
+                         CPP_RESERVE (pfile, 4);
+                         sprintf (CPP_PWRITTEN (pfile), "\\%03o",
+                                  (unsigned int) c);
+                         CPP_ADJUST_WRITTEN (pfile, 4);
+                       }
+                   }
+                 if (!CPP_TRADITIONAL (pfile))
+                   CPP_PUTC (pfile, '\"'); /* insert ending quote */
+                 arg->stringified_length
+                   = CPP_WRITTEN (pfile) - arg->stringified;
+               }
+             xbuf_len += args[ap->argno].stringified_length;
+           }
+         else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
+           /* Add 4 for two newline-space markers to prevent
+              token concatenation.  */
+           xbuf_len += args[ap->argno].raw_length + 4;
+         else
+           {
+             /* We have an ordinary (expanded) occurrence of the arg.
+                So compute its expansion, if we have not already.  */
+             if (args[ap->argno].expand_length < 0)
+               {
+                 args[ap->argno].expanded = CPP_WRITTEN (pfile);
+                 pfile->output_escapes++;
+                 cpp_expand_to_buffer (pfile,
+                                       ARG_BASE + args[ap->argno].raw,
+                                       args[ap->argno].raw_length);
+
+                 pfile->output_escapes--;
+                 args[ap->argno].expand_length
+                   = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
+               }
+
+             /* Add 4 for two newline-space markers to prevent
+                token concatenation.  */
+             xbuf_len += args[ap->argno].expand_length + 4;
+           }
+         if (args[ap->argno].use_count < 10)
+           args[ap->argno].use_count++;
+       }
+
+      xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
+
+      /* Generate in XBUF the complete expansion
+        with arguments substituted in.
+        TOTLEN is the total size generated so far.
+        OFFSET is the index in the definition
+        of where we are copying from.  */
+      offset = totlen = 0;
+      for (last_ap = NULL, ap = defn->pattern; ap != NULL;
+          last_ap = ap, ap = ap->next)
+       {
+         register struct argdata *arg = &args[ap->argno];
+         int count_before = totlen;
+
+         /* Add chars to XBUF.  */
+         for (i = 0; i < ap->nchars; i++, offset++)
+           xbuf[totlen++] = exp[offset];
+
+         /* If followed by an empty rest arg with concatenation,
+            delete the last run of nonwhite chars.  */
+         if (rest_zero && totlen > count_before
+             && ((ap->rest_args && ap->raw_before)
+                 || (last_ap != NULL && last_ap->rest_args
+                     && last_ap->raw_after)))
+           {
+             /* Delete final whitespace.  */
+             while (totlen > count_before && is_space[xbuf[totlen - 1]])
+               totlen--;
+
+             /* Delete the nonwhites before them.  */
+             while (totlen > count_before && ! is_space[xbuf[totlen - 1]])
+               totlen--;
+           }
+
+         if (ap->stringify != 0)
+           {
+             bcopy (ARG_BASE + arg->stringified,
+                    xbuf + totlen, arg->stringified_length);
+             totlen += arg->stringified_length;
+           }
+         else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
+           {
+             U_CHAR *p1 = ARG_BASE + arg->raw;
+             U_CHAR *l1 = p1 + arg->raw_length;
+             if (ap->raw_before)
+               {
+                 while (p1 != l1 && is_space[*p1]) p1++;
+                 while (p1 != l1 && is_idchar[*p1])
+                   xbuf[totlen++] = *p1++;
+               }
+             if (ap->raw_after)
+               {
+                 /* Arg is concatenated after: delete trailing whitespace,
+                    whitespace markers, and no-reexpansion markers.  */
+                 while (p1 != l1)
+                   {
+                     if (is_space[l1[-1]]) l1--;
+                     else if (l1[-1] == '-')
+                       {
+                         U_CHAR *p2 = l1 - 1;
+                         /* If a `-' is preceded by an odd number of newlines then it
+                            and the last newline are a no-reexpansion marker.  */
+                         while (p2 != p1 && p2[-1] == '\n') p2--;
+                         if ((l1 - 1 - p2) & 1) {
+                           l1 -= 2;
+                         }
+                         else break;
+                       }
+                     else break;
+                   }
+               }
+
+             bcopy (p1, xbuf + totlen, l1 - p1);
+             totlen += l1 - p1;
+           }
+         else
+           {
+             U_CHAR *expanded = ARG_BASE + arg->expanded;
+             if (!ap->raw_before && totlen > 0 && arg->expand_length
+                 && !CPP_TRADITIONAL(pfile)
+                 && unsafe_chars (xbuf[totlen-1], expanded[0]))
+               xbuf[totlen++] = ' ';
+
+             bcopy (expanded, xbuf + totlen, arg->expand_length);
+             totlen += arg->expand_length;
+
+             if (!ap->raw_after && totlen > 0 && offset < defn->length
+                 && !CPP_TRADITIONAL(pfile)
+                 && unsafe_chars (xbuf[totlen-1], exp[offset]))
+               xbuf[totlen++] = ' ';
+
+             /* If a macro argument with newlines is used multiple times,
+                then only expand the newlines once.  This avoids creating
+                output lines which don't correspond to any input line,
+                which confuses gdb and gcov.  */
+             if (arg->use_count > 1 && arg->newlines > 0)
+               {
+                 /* Don't bother doing change_newlines for subsequent
+                    uses of arg.  */
+                 arg->use_count = 1;
+                 arg->expand_length
+                   = change_newlines (expanded, arg->expand_length);
+               }
+           }
+
+         if (totlen > xbuf_len)
+           abort ();
+      }
+
+      /* if there is anything left of the definition
+        after handling the arg list, copy that in too. */
+
+      for (i = offset; i < defn->length; i++)
+       {
+         /* if we've reached the end of the macro */
+         if (exp[i] == ')')
+           rest_zero = 0;
+         if (! (rest_zero && last_ap != NULL && last_ap->rest_args
+                && last_ap->raw_after))
+           xbuf[totlen++] = exp[i];
+       }
+
+      xbuf[totlen] = 0;
+      xbuf_len = totlen;
+
+    }
+
+  /* Now put the expansion on the input stack
+     so our caller will commence reading from it.  */
+  push_macro_expansion (pfile, xbuf, xbuf_len, hp);
+  CPP_BUFFER (pfile)->has_escapes = 1;
+
+  /* Pop the space we've used in the token_buffer for argument expansion. */
+  CPP_SET_WRITTEN (pfile, old_written);
+    
+  /* Recursive macro use sometimes works traditionally.
+     #define foo(x,y) bar (x (y,0), y)
+     foo (foo, baz)  */
+  
+  if (!CPP_TRADITIONAL (pfile))
+    hp->type = T_DISABLED;
+}
+
+static void
+push_macro_expansion (pfile, xbuf, xbuf_len, hp)
+     cpp_reader *pfile;
+     register U_CHAR *xbuf;
+     int xbuf_len;
+     HASHNODE *hp;
+{
+  register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
+  mbuf->cleanup = macro_cleanup;
+  mbuf->data = hp;
+
+  /* The first char of the expansion should be a ' ' added by
+     collect_expansion.  This is to prevent accidental token-pasting
+     between the text preceding the macro invocation, and the macro
+     expansion text.
+
+     We would like to avoid adding unneeded spaces (for the sake of
+     tools that use cpp, such as imake).  In some common cases we can
+     tell that it is safe to omit the space.
+
+     The character before the macro invocation cannot have been an
+     idchar (or else it would have been pasted with the idchars of
+     the macro name).  Therefore, if the first non-space character
+     of the expansion is an idchar, we do not need the extra space
+     to prevent token pasting.
+
+     Also, we don't need the extra space if the first char is '(',
+     or some other (less common) characters.  */
+
+  if (xbuf[0] == ' '
+      && (is_idchar[xbuf[1]] || xbuf[1] == '(' || xbuf[1] == '\''
+         || xbuf[1] == '\"'))
+    mbuf->cur++;
+}
+\f
+/* 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 (;;)
+    {
+      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;
+      }
+    }
+}
+\f
+/* Handle #include and #import.
+   This function expects to see "fname" or <fname> on the input.
+
+   The input is normally in part of the output_buffer following
+   CPP_WRITTEN, and will get overwriiten by output_line_command.
+   I.e. in input file specification has been popped by handle_directive.
+   This is safe. */
+
+static int
+do_include (pfile, keyword, unused1, unused2)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *unused1, *unused2;
+{
+  int importing = (keyword->type == T_IMPORT);
+  int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
+  char *fname;         /* Dynamically allocated fname buffer */
+  char *pcftry;
+  char *pcfname;
+  U_CHAR *fbeg, *fend;         /* Beginning and end of fname */
+  enum cpp_token token;
+
+  /* Chain of dirs to search */
+  struct file_name_list *search_start = CPP_OPTIONS (pfile)->include;
+  struct file_name_list dsp[1];        /* First in chain, if #include "..." */
+  struct file_name_list *searchptr = 0;
+  long old_written = CPP_WRITTEN (pfile);
+
+  int flen;
+
+  int f;                       /* file number */
+
+  int retried = 0;             /* Have already tried macro
+                                  expanding the include line*/
+  int angle_brackets = 0;      /* 0 for "...", 1 for <...> */
+  int pcf = -1;
+  char *pcfbuf;
+  int pcfbuflimit;
+  int pcfnum;
+  f= -1;                       /* JF we iz paranoid! */
+
+  if (importing && CPP_OPTIONS (pfile)->warn_import
+      && !CPP_OPTIONS (pfile)->inhibit_warnings
+      && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
+    {
+      pfile->import_warning = 1;
+      cpp_warning (pfile, "using `#import' is not recommended");
+      fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
+      fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
+      fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
+      fprintf (stderr, "  #ifndef _FOO_H_INCLUDED\n");
+      fprintf (stderr, "  #define _FOO_H_INCLUDED\n");
+      fprintf (stderr, "  ... <real contents of file> ...\n");
+      fprintf (stderr, "  #endif /* Not _FOO_H_INCLUDED */\n\n");
+      fprintf (stderr, "Then users can use `#include' any number of times.\n");
+      fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
+      fprintf (stderr, "when it is equipped with such a conditional.\n");
+    }
+
+  pfile->parsing_include_directive++;
+  token = get_directive_token (pfile);
+  pfile->parsing_include_directive--;
+
+  if (token == CPP_STRING)
+    {
+      /* FIXME - check no trailing garbage */
+      fbeg = pfile->token_buffer + old_written + 1;
+      fend = CPP_PWRITTEN (pfile) - 1;
+      if (fbeg[-1] == '<')
+       {
+         angle_brackets = 1;
+         /* If -I-, start with the first -I dir after the -I-.  */
+         if (CPP_OPTIONS (pfile)->first_bracket_include)
+           search_start = CPP_OPTIONS (pfile)->first_bracket_include;
+       }
+      /* If -I- was specified, don't search current dir, only spec'd ones. */
+      else if (! CPP_OPTIONS (pfile)->ignore_srcdir)
+       {
+         cpp_buffer *fp;
+         /* We have "filename".  Figure out directory this source
+            file is coming from and put it on the front of the list. */
+
+         for (fp = CPP_BUFFER (pfile); fp != NULL; fp = CPP_PREV_BUFFER (fp))
+           {
+             int n;
+             char *ep,*nam;
+
+             if ((nam = fp->nominal_fname) != NULL)
+               {
+                 /* Found a named file.  Figure out dir of the file,
+                    and put it in front of the search list.  */
+                 dsp[0].next = search_start;
+                 search_start = dsp;
+#ifndef VMS
+                 ep = rindex (nam, '/');
+#else                          /* VMS */
+                 ep = rindex (nam, ']');
+                 if (ep == NULL) ep = rindex (nam, '>');
+                 if (ep == NULL) ep = rindex (nam, ':');
+                 if (ep != NULL) ep++;
+#endif                         /* VMS */
+                 if (ep != NULL)
+                   {
+                     n = ep - nam;
+                     dsp[0].fname = (char *) alloca (n + 1);
+                     strncpy (dsp[0].fname, nam, n);
+                     dsp[0].fname[n] = '\0';
+                     if (n + INCLUDE_LEN_FUDGE > pfile->max_include_len)
+                       pfile->max_include_len = n + INCLUDE_LEN_FUDGE;
+                   }
+                 else
+                   {
+                     dsp[0].fname = 0; /* Current directory */
+                   }
+                 dsp[0].got_name_map = 0;
+                 break;
+               }
+           }
+       }
+    }
+#ifdef VMS
+  else if (token == CPP_NAME)
+    {
+      /*
+       * Support '#include xyz' like VAX-C to allow for easy use of all the
+       * decwindow include files. It defaults to '#include <xyz.h>' (so the
+       * code from case '<' is repeated here) and generates a warning.
+       */
+      cpp_warning (pfile,
+                  "VAX-C-style include specification found, use '#include <filename.h>' !");
+      angle_brackets = 1;
+      /* If -I-, start with the first -I dir after the -I-.  */
+      if (CPP_OPTIONS (pfile)->first_bracket_include)
+       search_start = CPP_OPTIONS (pfile)->first_bracket_include;
+      fbeg = pfile->token_buffer + old_written;
+      fend = CPP_PWRITTEN (pfile);
+    }
+#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;
+    }
+
+  *fend = 0;
+
+  token = get_directive_token (pfile);
+  if (token != CPP_VSPACE)
+    {
+      cpp_error (pfile, "junk at end of `#include'");
+      while (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
+       token = get_directive_token (pfile);
+    }
+
+  /* For #include_next, skip in the search path
+     past the dir in which the containing file was found.  */
+  if (skip_dirs)
+    {
+      cpp_buffer *fp;
+      for (fp = CPP_BUFFER (pfile); fp != NULL; fp = CPP_PREV_BUFFER (fp))
+       if (fp->fname != NULL)
+         {
+           /* fp->dir is null if the containing file was specified with
+              an absolute file name.  In that case, don't skip anything.  */
+           if (fp->dir)
+             search_start = fp->dir->next;
+           break;
+         }
+    }
+
+  CPP_SET_WRITTEN (pfile, old_written);
+
+  flen = fend - fbeg;
+
+  if (flen == 0)
+    {
+      cpp_error (pfile, "empty file name in `#%s'", keyword->name);
+      return 0;
+    }
+
+  /* Allocate this permanently, because it gets stored in the definitions
+     of macros.  */
+  fname = (char *) xmalloc (pfile->max_include_len + flen + 4);
+  /* + 2 above for slash and terminating null.  */
+  /* + 2 added for '.h' on VMS (to support '#include filename') */
+
+  /* If specified file name is absolute, just open it.  */
+
+  if (*fbeg == '/') {
+    strncpy (fname, fbeg, flen);
+    fname[flen] = 0;
+    if (redundant_include_p (pfile, fname))
+      return 0;
+    if (importing)
+      f = lookup_import (pfile, fname, NULL_PTR);
+    else
+      f = open_include_file (fname, NULL_PTR);
+    if (f == -2)
+      return 0;                /* Already included this file */
+  } else {
+    /* Search directory path, trying to open the file.
+       Copy each filename tried into FNAME.  */
+
+    for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
+      if (searchptr->fname) {
+       /* The empty string in a search path is ignored.
+          This makes it possible to turn off entirely
+          a standard piece of the list.  */
+       if (searchptr->fname[0] == 0)
+         continue;
+       strcpy (fname, searchptr->fname);
+       strcat (fname, "/");
+       fname[strlen (fname) + flen] = 0;
+      } else {
+       fname[0] = 0;
+      }
+      strncat (fname, fbeg, flen);
+#ifdef VMS
+      /* Change this 1/2 Unix 1/2 VMS file specification into a
+         full VMS file specification */
+      if (searchptr->fname && (searchptr->fname[0] != 0)) {
+       /* Fix up the filename */
+       hack_vms_include_specification (fname);
+      } else {
+       /* This is a normal VMS filespec, so use it unchanged.  */
+       strncpy (fname, fbeg, flen);
+       fname[flen] = 0;
+       /* if it's '#include filename', add the missing .h */
+       if (index(fname,'.')==NULL) {
+         strcat (fname, ".h");
+       }
+      }
+#endif /* VMS */
+      if (importing)
+       f = lookup_import (pfile, fname, searchptr);
+      else
+       f = open_include_file (fname, searchptr);
+      if (f == -2)
+       return 0;                       /* Already included this file */
+#ifdef EACCES
+      else if (f == -1 && errno == EACCES)
+       cpp_warning (pfile, "Header file %s exists, but is not readable",
+                    fname);
+#endif
+      if (redundant_include_p (pfile, fname)) {
+       close (f);
+       return 0;
+      }
+      if (f >= 0)
+       break;
+    }
+  }
+
+  if (f < 0)
+    {
+      /* A file that was not found.  */
+      strncpy (fname, fbeg, flen);
+      fname[flen] = 0;
+      /* If generating dependencies and -MG was specified, we assume missing
+        files are leaf files, living in the same directory as the source file
+        or other similar place; these missing files may be generated from
+        other files and may not exist yet (eg: y.tab.h).  */
+
+      if (CPP_OPTIONS(pfile)->print_deps_missing_files
+         && CPP_PRINT_DEPS (pfile)
+         > (angle_brackets || (pfile->system_include_depth > 0)))
+       {
+         /* If it was requested as a system header file,
+            then assume it belongs in the first place to look for such.  */
+         if (angle_brackets)
+           {
+             for (searchptr = search_start; searchptr;
+                  searchptr = searchptr->next)
+               {
+                 if (searchptr->fname)
+                   {
+                     char *p;
+
+                     if (searchptr->fname[0] == 0)
+                       continue;
+                     p = xmalloc (strlen (searchptr->fname)
+                                  + strlen (fname) + 2);
+                     strcpy (p, searchptr->fname);
+                     strcat (p, "/");
+                     strcat (p, fname);
+                     deps_output (pfile, p, ' ');
+                     break;
+                   }
+               }
+           }
+         else
+           {
+             /* Otherwise, omit the directory, as if the file existed
+                in the directory with the source.  */
+             deps_output (pfile, fname, ' ');
+           }
+       }
+      /* 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", fname);
+      else if (search_start)
+       cpp_error_from_errno (pfile, fname);
+      else
+       cpp_error (pfile, "No include path in which to find %s", fname);
+    }
+  else {
+    struct stat stat_f;
+
+    /* Check to see if this include file is a once-only include file.
+       If so, give up.  */
+
+    struct file_name_list* ptr;
+
+    for (ptr = pfile->dont_repeat_files; ptr; ptr = ptr->next) {
+      if (!strcmp (ptr->fname, fname)) {
+       close (f);
+        return 0;                              /* This file was once'd. */
+      }
+    }
+
+    for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
+      if (!strcmp (ptr->fname, fname))
+        break;                         /* This file was included before. */
+    }
+
+    if (ptr == 0) {
+      /* This is the first time for this file.  */
+      /* Add it to list of files included.  */
+
+      ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
+      ptr->control_macro = 0;
+      ptr->c_system_include_path = 0;
+      ptr->next = pfile->all_include_files;
+      pfile->all_include_files = ptr;
+      ptr->fname = savestring (fname);
+      ptr->got_name_map = 0;
+
+      /* For -M, add this file to the dependencies.  */
+      if (CPP_PRINT_DEPS (pfile)
+         > (angle_brackets || (pfile->system_include_depth > 0)))
+       deps_output (pfile, fname, ' ');
+    }   
+
+    /* Handle -H option.  */
+    if (CPP_OPTIONS(pfile)->print_include_names)
+      {
+       cpp_buffer *buf = CPP_BUFFER (pfile);
+       while ((buf = CPP_PREV_BUFFER (buf)) != NULL)
+         putc ('.', stderr);
+       fprintf (stderr, "%s\n", fname);
+      }
+
+    if (angle_brackets)
+      pfile->system_include_depth++;
+
+    /* Actually process the file.  */
+
+    /* Record file on "seen" list for #import. */
+    add_import (pfile, f, fname);
+
+    pcftry = (char *) alloca (strlen (fname) + 30);
+    pcfbuf = 0;
+    pcfnum = 0;
+
+    fstat (f, &stat_f);
+
+#if 0
+    if (!no_precomp)
+      do {
+       sprintf (pcftry, "%s%d", fname, pcfnum++);
+       
+       pcf = open (pcftry, O_RDONLY, 0666);
+       if (pcf != -1)
+         {
+           struct stat s;
+
+           fstat (pcf, &s);
+           if (bcmp (&stat_f.st_ino, &s.st_ino, sizeof (s.st_ino))
+               || stat_f.st_dev != s.st_dev)
+             {
+               pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
+               /* Don't need it any more.  */
+               close (pcf);
+             }
+           else
+             {
+               /* Don't need it at all.  */
+               close (pcf);
+               break;
+             }
+         }
+      } while (pcf != -1 && !pcfbuf);
+#endif
+    
+    /* Actually process the file */
+    if (finclude (pfile, f, fname, is_system_include (pfile, fname),
+                 searchptr))
+      {
+       output_line_command (pfile, 0, enter_file);
+       pfile->only_seen_white = 2;
+      }
+
+    if (angle_brackets)
+      pfile->system_include_depth--;
+  }
+  return 0;
+}
+
+/* Return nonzero if there is no need to include file NAME
+   because it has already been included and it contains a conditional
+   to make a repeated include do nothing.  */
+
+static int
+redundant_include_p (pfile, name)
+     cpp_reader *pfile;
+     char *name;
+{
+  struct file_name_list *l = pfile->all_include_files;
+  for (; l; l = l->next)
+    if (! strcmp (name, l->fname)
+       && l->control_macro
+       && cpp_lookup (pfile, l->control_macro, -1, -1))
+      return 1;
+  return 0;
+}
+
+/* Return nonzero if the given FILENAME is an absolute pathname which
+   designates a file within one of the known "system" include file
+   directories.  We assume here that if the given FILENAME looks like
+   it is the name of a file which resides either directly in a "system"
+   include file directory, or within any subdirectory thereof, then the
+   given file must be a "system" include file.  This function tells us
+   if we should suppress pedantic errors/warnings for the given FILENAME.
+
+   The value is 2 if the file is a C-language system header file
+   for which C++ should (on most systems) assume `extern "C"'.  */
+
+static int
+is_system_include (pfile, filename)
+     cpp_reader *pfile;
+     register char *filename;
+{
+  struct file_name_list *searchptr;
+
+  for (searchptr = CPP_OPTIONS (pfile)->first_system_include; searchptr;
+       searchptr = searchptr->next)
+    if (searchptr->fname) {
+      register char *sys_dir = searchptr->fname;
+      register unsigned length = strlen (sys_dir);
+
+      if (! strncmp (sys_dir, filename, length) && filename[length] == '/')
+       {
+         if (searchptr->c_system_include_path)
+           return 2;
+         else
+           return 1;
+       }
+    }
+  return 0;
+}
+
+\f
+/*
+ * Install a name in the assertion hash table.
+ *
+ * If LEN is >= 0, it is the length of the name.
+ * Otherwise, compute the length by scanning the entire name.
+ *
+ * If HASH is >= 0, it is the precomputed hash code.
+ * Otherwise, compute the hash code.
+ */
+static ASSERTION_HASHNODE *
+assertion_install (pfile, name, len, hash)
+     cpp_reader *pfile;
+     U_CHAR *name;
+     int len;
+     int hash;
+{
+  register ASSERTION_HASHNODE *hp;
+  register int i, bucket;
+  register U_CHAR *p, *q;
+
+  i = sizeof (ASSERTION_HASHNODE) + len + 1;
+  hp = (ASSERTION_HASHNODE *) xmalloc (i);
+  bucket = hash;
+  hp->bucket_hdr = &pfile->assertion_hashtab[bucket];
+  hp->next = pfile->assertion_hashtab[bucket];
+  pfile->assertion_hashtab[bucket] = hp;
+  hp->prev = NULL;
+  if (hp->next != NULL)
+    hp->next->prev = hp;
+  hp->length = len;
+  hp->value = 0;
+  hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
+  p = hp->name;
+  q = name;
+  for (i = 0; i < len; i++)
+    *p++ = *q++;
+  hp->name[len] = 0;
+  return hp;
+}
+/*
+ * find the most recent hash node for name name (ending with first
+ * non-identifier char) installed by install
+ *
+ * If LEN is >= 0, it is the length of the name.
+ * Otherwise, compute the length by scanning the entire name.
+ *
+ * If HASH is >= 0, it is the precomputed hash code.
+ * Otherwise, compute the hash code.
+ */
+
+static ASSERTION_HASHNODE *
+assertion_lookup (pfile, name, len, hash)
+     cpp_reader *pfile;
+     U_CHAR *name;
+     int len;
+     int hash;
+{
+  register ASSERTION_HASHNODE *bucket;
+
+  bucket = pfile->assertion_hashtab[hash];
+  while (bucket) {
+    if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
+      return bucket;
+    bucket = bucket->next;
+  }
+  return NULL;
+}
+
+static void
+delete_assertion (hp)
+     ASSERTION_HASHNODE *hp;
+{
+
+  if (hp->prev != NULL)
+    hp->prev->next = hp->next;
+  if (hp->next != NULL)
+    hp->next->prev = hp->prev;
+
+  /* make sure that the bucket chain header that
+     the deleted guy was on points to the right thing afterwards. */
+  if (hp == *hp->bucket_hdr)
+    *hp->bucket_hdr = hp->next;
+
+  free (hp);
+}
+\f
+/* Convert a character string literal into a nul-terminated string.
+   The input string is [IN ... LIMIT).
+   The result is placed in RESULT.  RESULT can be the same as IN.
+   The value returned in the end of the string written to RESULT,
+   or NULL on error.  */
+
+static U_CHAR*
+convert_string (pfile, result, in, limit, handle_escapes)
+     cpp_reader *pfile;
+     register U_CHAR *result, *in, *limit;
+     int handle_escapes;
+{
+  U_CHAR c;
+  c = *in++;
+  if (c != '\"')
+    return NULL;
+  while (in < limit)
+    {
+      U_CHAR c = *in++;
+      switch (c)
+       {
+       case '\0':
+         return NULL;
+       case '\"':
+         limit = in;
+         break;
+       case '\\':
+         if (handle_escapes)
+           {
+             char *bpc = (char *) in;
+             int i = (U_CHAR) cpp_parse_escape (pfile, &bpc);
+             in = (U_CHAR *) bpc;
+             if (i >= 0)
+               *result++ = (U_CHAR)c;
+             break;
+           }
+         /* else fall through */
+       default:
+         *result++ = c;
+       }
+    }
+  *result = 0;
+  return result;
+}
+
+/*
+ * interpret #line command.  Remembers previously seen fnames
+ * in its very own hash table.
+ */
+#define FNAME_HASHSIZE 37
+
+static int
+do_line (pfile, keyword)
+     cpp_reader *pfile;
+     struct directive *keyword;
+{
+  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;
+  int i;
+
+  token = get_directive_token (pfile);
+
+  if (token != CPP_NUMBER
+      || !isdigit(pfile->token_buffer[old_written]))
+    {
+      cpp_error (pfile, "invalid format `#line' command");
+      goto bad_line_directive;
+    }
+
+  /* The Newline at the end of this line remains to be processed.
+     To put the next line at the specified line number,
+     we must store a line number now that is one less.  */
+  new_lineno = atoi (pfile->token_buffer + old_written) - 1;
+  CPP_SET_WRITTEN (pfile, old_written);
+
+  /* NEW_LINENO is one less than the actual line number here.  */
+  if (CPP_PEDANTIC (pfile) && new_lineno < 0)
+    cpp_pedwarn (pfile, "line number out of range in `#line' command");
+
+#if 0 /* #line 10"foo.c" is supposed to be allowed.  */
+  if (PEEKC() && !is_space[PEEKC()]) {
+    cpp_error (pfile, "invalid format `#line' command");
+    goto bad_line_directive;
+  }
+#endif
+
+  token = get_directive_token (pfile);
+
+  if (token == CPP_STRING) {
+    U_CHAR *fname = pfile->token_buffer + old_written;
+    U_CHAR *end_name;
+    static HASHNODE *fname_table[FNAME_HASHSIZE];
+    HASHNODE *hp, **hash_bucket;
+    U_CHAR *p;
+    long num_start;
+    int fname_length;
+
+    /* Turn the file name, which is a character string literal,
+       into a null-terminated string.  Do this in place.  */
+    end_name = convert_string (pfile, fname, fname, CPP_PWRITTEN (pfile), 1);
+    if (end_name == NULL)
+    {
+       cpp_error (pfile, "invalid format `#line' command");
+       goto bad_line_directive;
+    }
+
+    fname_length = end_name - fname;
+
+    num_start = CPP_WRITTEN (pfile);
+    token = get_directive_token (pfile);
+    if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) {
+      p = pfile->token_buffer + num_start;
+      if (CPP_PEDANTIC (pfile))
+       cpp_pedwarn (pfile, "garbage at end of `#line' command");
+
+      if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
+      {
+       cpp_error (pfile, "invalid format `#line' command");
+       goto bad_line_directive;
+      }
+      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')) {
+       ip->system_header_p = *p == 3 ? 1 : 2;
+       token = get_directive_token (pfile);
+      }
+      if (token != CPP_VSPACE) {
+       cpp_error (pfile, "invalid format `#line' command");
+       goto bad_line_directive;
+      }
+    }
+
+    hash_bucket =
+      &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
+    for (hp = *hash_bucket; hp != NULL; hp = hp->next)
+      if (hp->length == fname_length &&
+         strncmp (hp->value.cpval, fname, fname_length) == 0) {
+       ip->nominal_fname = hp->value.cpval;
+       break;
+      }
+    if (hp == 0) {
+      /* Didn't find it; cons up a new one.  */
+      hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
+      hp->next = *hash_bucket;
+      *hash_bucket = hp;
+
+      hp->length = fname_length;
+      ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
+      bcopy (fname, hp->value.cpval, fname_length);
+    }
+  }
+  else if (token != CPP_VSPACE && token != CPP_EOF) {
+    cpp_error (pfile, "invalid format `#line' command");
+    goto bad_line_directive;
+  }
+
+  ip->lineno = new_lineno;
+ bad_line_directive:
+  skip_rest_of_line (pfile);
+  CPP_SET_WRITTEN (pfile, old_written);
+  output_line_command (pfile, 0, file_change);
+  return 0;
+}
+
+/*
+ * remove the definition of a symbol from the symbol table.
+ * according to un*x /lib/cpp, it is not an error to undef
+ * something that has no definitions, so it isn't one here either.
+ */
+
+static int
+do_undef (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  int sym_length;
+  HASHNODE *hp;
+  U_CHAR *orig_buf = buf;
+
+#if 0
+  /* If this is a precompiler run (with -pcp) pass thru #undef commands.  */
+  if (pcp_outfile && keyword)
+    pass_thru_directive (buf, limit, pfile, keyword);
+#endif
+
+  SKIP_WHITE_SPACE (buf);
+  sym_length = check_macro_name (pfile, buf, "macro");
+
+  while ((hp = cpp_lookup (pfile, buf, 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 (orig_buf, limit, pfile, keyword);
+      if (hp->type != T_MACRO)
+       cpp_warning (pfile, "undefining `%s'", hp->name);
+      delete_macro (hp);
+    }
+
+  if (CPP_PEDANTIC (pfile)) {
+    buf += sym_length;
+    SKIP_WHITE_SPACE (buf);
+    if (buf != limit)
+      cpp_pedwarn (pfile, "garbage after `#undef' directive");
+  }
+  return 0;
+}
+\f
+/*
+ * 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, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  int length = limit - buf;
+  U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
+  bcopy (buf, copy, length);
+  copy[length] = 0;
+  SKIP_WHITE_SPACE (copy);
+  cpp_error (pfile, "#error %s", copy);
+  return 0;
+}
+
+/*
+ * Report a warning detected by the program we are processing.
+ * Use the text of the line in the warning message, then continue.
+ * (We use error because it prints the filename & line#.)
+ */
+
+static int
+do_warning (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  int length = limit - buf;
+  U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
+  bcopy (buf, copy, length);
+  copy[length] = 0;
+  SKIP_WHITE_SPACE (copy);
+  cpp_warning (pfile, "#warning %s", copy);
+  return 0;
+}
+
+/* Remember the name of the current file being read from so that we can
+   avoid ever including it again.  */
+
+static int
+do_once (pfile)
+     cpp_reader *pfile;
+{
+  cpp_buffer *ip = NULL;
+  struct file_name_list *new;
+
+  for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
+    {
+      if (ip == NULL)
+       return 0;
+      if (ip->fname != NULL)
+       break;
+    }
+
+    
+  new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
+  new->next = pfile->dont_repeat_files;
+  pfile->dont_repeat_files = new;
+  new->fname = savestring (ip->fname);
+  new->control_macro = 0;
+  new->got_name_map = 0;
+  new->c_system_include_path = 0;
+
+  return 0;
+}
+
+/* #ident has already been copied to the output file, so just ignore it.  */
+
+static int
+do_ident (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+/*  long old_written = CPP_WRITTEN (pfile);*/
+  int len;
+
+  /* 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'");
+
+  /* Leave rest of line to be read by later calls to cpp_get_token. */
+
+  return 0;
+}
+
+/* #pragma and its argument line have already been copied to the output file.
+   Just check for some recognized pragmas that need validation here.  */
+
+static int
+do_pragma (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  while (*buf == ' ' || *buf == '\t')
+    buf++;
+  if (!strncmp (buf, "once", 4)) {
+    /* 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");
+    do_once (pfile);
+  }
+
+  if (!strncmp (buf, "implementation", 14)) {
+    /* Be quiet about `#pragma implementation' for a file only if it hasn't
+       been included yet.  */
+    struct file_name_list *ptr;
+    U_CHAR *p = buf + 14, *fname, *inc_fname;
+    int fname_len;
+    SKIP_WHITE_SPACE (p);
+    if (*p == '\n' || *p != '\"')
+      return 0;
+
+    fname = p + 1;
+    p = (U_CHAR *) index (fname, '\"');
+    fname_len = p != NULL ? p - fname : strlen (fname);
+    
+    for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
+      inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
+      inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
+      if (inc_fname && !strncmp (inc_fname, fname, fname_len))
+       cpp_warning (pfile,
+          "`#pragma implementation' for `%s' appears after file is included",
+                    fname);
+    }
+  }
+
+  return 0;
+}
+
+#if 0
+/* This was a fun hack, but #pragma seems to start to be useful.
+   By failing to recognize it, we pass it through unchanged to cc1.  */
+
+/*
+ * the behavior of the #pragma directive is implementation defined.
+ * this implementation defines it as follows.
+ */
+
+static int
+do_pragma ()
+{
+  close (0);
+  if (open ("/dev/tty", O_RDONLY, 0666) != 0)
+    goto nope;
+  close (1);
+  if (open ("/dev/tty", O_WRONLY, 0666) != 1)
+    goto nope;
+  execl ("/usr/games/hack", "#pragma", 0);
+  execl ("/usr/games/rogue", "#pragma", 0);
+  execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
+  execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
+nope:
+  fatal ("You are in a maze of twisty compiler features, all different");
+}
+#endif
+
+/* Just ignore #sccs, on systems where we define it at all.  */
+
+static int
+do_sccs (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  if (CPP_PEDANTIC (pfile))
+    cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'");
+  return 0;
+}
+\f
+/*
+ * 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, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  int value;
+
+  value = eval_if_expression (pfile, buf, limit - buf);
+  conditional_skip (pfile, value == 0, T_IF, NULL_PTR);
+  return 0;
+}
+
+/*
+ * handle a #elif directive by not changing  if_stack  either.
+ * see the comment above do_else.
+ */
+
+static int
+do_elif (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  int value;
+
+  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, 0);
+  else {
+    value = eval_if_expression (pfile, buf, limit - buf);
+    if (value == 0)
+      skip_if_group (pfile, 0);
+    else {
+      ++pfile->if_stack->if_succeeded; /* continue processing input */
+      output_line_command (pfile, 1, same_file);
+    }
+  }
+  return 0;
+}
+
+/*
+ * evaluate a #if expression in BUF, of length LENGTH,
+ * then parse the result as a C expression and return the value as an int.
+ */
+static int
+eval_if_expression (pfile, buf, length)
+     cpp_reader *pfile;
+     U_CHAR *buf;
+     int length;
+{
+  HASHNODE *save_defined;
+  int value;
+  long old_written = CPP_WRITTEN (pfile);
+
+  save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, 0, -1);
+  pfile->pcp_inside_if = 1;
+
+  value = cpp_parse_expr (pfile);
+  pfile->pcp_inside_if = 0;
+  delete_macro (save_defined); /* clean up special symbol */
+
+  CPP_SET_WRITTEN (pfile, old_written); /* Pop */
+
+  return value;
+}
+
+/*
+ * routine to handle ifdef/ifndef.  Try to look up the symbol,
+ * then do or don't skip to the #endif/#else/#elif depending
+ * on what directive is actually being processed.
+ */
+
+static int
+do_xifdef (pfile, keyword, unused1, unused2)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *unused1, *unused2;
+{
+  int skip;
+  cpp_buffer *ip = CPP_BUFFER (pfile);
+  U_CHAR* ident;
+  int ident_length;
+  enum cpp_token token;
+  int start_of_file = 0;
+  U_CHAR *control_macro = 0;
+  int old_written = CPP_WRITTEN (pfile);
+
+  /* Detect a #ifndef at start of file (not counting comments).  */
+  if (ip->fname != 0 && keyword->type == T_IFNDEF)
+    start_of_file = pfile->only_seen_white == 2;
+
+  pfile->no_macro_expand++;
+  token = get_directive_token (pfile);
+  pfile->no_macro_expand--;
+
+  ident = pfile->token_buffer + old_written;
+  ident_length = CPP_WRITTEN (pfile) - old_written;
+  CPP_SET_WRITTEN (pfile, old_written); /* Pop */
+
+  if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
+    {
+      skip = (keyword->type == T_IFDEF);
+      if (! CPP_TRADITIONAL (pfile))
+       cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
+    }
+  else if (token == CPP_NAME)
+    {
+      HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
+      skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
+      if (start_of_file && !skip)
+       {
+         control_macro = (U_CHAR *) xmalloc (ident_length + 1);
+         bcopy (ident, control_macro, ident_length + 1);
+       }
+    }
+  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);
+
+#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
+
+  conditional_skip (pfile, skip, T_IF, control_macro);
+  return 0;
+}
+
+/* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
+   If this is a #ifndef starting at the beginning of a file,
+   CONTROL_MACRO is the macro name tested by the #ifndef.
+   Otherwise, CONTROL_MACRO is 0.  */
+
+static void
+conditional_skip (pfile, skip, type, control_macro)
+     cpp_reader *pfile;
+     int skip;
+     enum node_type type;
+     U_CHAR *control_macro;
+{
+  IF_STACK_FRAME *temp;
+
+  temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
+  temp->fname = CPP_BUFFER (pfile)->nominal_fname;
+#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;
+
+  if (skip != 0) {
+    skip_if_group (pfile, 0);
+    return;
+  } else {
+    ++pfile->if_stack->if_succeeded;
+    output_line_command (pfile, 1, same_file);
+  }
+}
+
+/*
+ * skip to #endif, #else, or #elif.  adjust line numbers, etc.
+ * leaves input ptr at the sharp sign found.
+ * If ANY is nonzero, return at next directive of any sort.
+ */
+static void
+skip_if_group (pfile, any)
+     cpp_reader *pfile;
+     int any;
+{
+  int c;
+  int at_beg_of_line = 1;
+  struct directive *kt;
+  IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
+#if 0
+  U_CHAR *beg_of_line = bp;
+#endif
+  register int ident_length;
+  U_CHAR *ident, *after_ident;
+  struct parse_marker line_start_mark;
+
+  parse_set_mark (&line_start_mark, pfile);
+
+  if (CPP_OPTIONS (pfile)->output_conditionals) {
+    static char failed[] = "#failed\n";
+    CPP_PUTS (pfile, failed, sizeof(failed)-1);
+    pfile->lineno++;
+    output_line_command (pfile, 1, same_file);
+  }
+
+ beg_of_line:
+  if (CPP_OPTIONS (pfile)->output_conditionals)
+    {
+      cpp_buffer *pbuf = CPP_BUFFER (pfile);
+      U_CHAR *start_line = pbuf->buf + line_start_mark.position;
+      CPP_PUTS (pfile, start_line, pbuf->cur - start_line);
+    }
+  parse_move_mark (&line_start_mark, pfile);
+  if (!CPP_TRADITIONAL (pfile))
+      cpp_skip_hspace (pfile);
+  c  = GETC();
+  if (c == '#')
+    {
+      int old_written = CPP_WRITTEN (pfile);
+      cpp_skip_hspace (pfile);
+
+      parse_name (pfile, GETC());
+      ident_length = CPP_WRITTEN (pfile) - old_written;
+      ident = pfile->token_buffer + old_written;
+      pfile->limit = ident;
+#if 0
+      if (ident_length == 0)
+       goto not_a_directive;
+
+      /* Handle # followed by a line number.  */
+
+      /* Avoid error for `###' and similar cases unless -pedantic.  */
+#endif
+
+      for (kt = directive_table; kt->length >= 0; kt++)
+       {
+         IF_STACK_FRAME *temp;
+         if (ident_length == kt->length
+             && strncmp (ident, kt->name, kt->length) == 0)
+           {
+             /* If we are asked to return on next directive, do so now.  */
+             if (any)
+               goto done;
+
+             switch (kt->type)
+               {
+               case T_IF:
+               case T_IFDEF:
+               case T_IFNDEF:
+                 temp
+                   = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
+                 temp->next = pfile->if_stack;
+                 pfile->if_stack = temp;
+#if 0
+                 temp->lineno = CPP_BUFFER(pfile)->lineno;
+#endif
+                 temp->fname = CPP_BUFFER(pfile)->nominal_fname;
+                 temp->type = kt->type;
+                 break;
+               case T_ELSE:
+               case T_ENDIF:
+                 if (CPP_PEDANTIC (pfile) && pfile->if_stack != save_if_stack)
+                   validate_else (pfile,
+                                  kt->type == T_ELSE ? "#else" : "#endif");
+               case T_ELIF:
+                 if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
+                   {
+                     cpp_error (pfile,
+                                "`#%s' not within a conditional", kt->name);
+                     break;
+                   }
+                 else if (pfile->if_stack == save_if_stack)
+                   goto done;          /* found what we came for */
+
+                 if (kt->type != T_ENDIF)
+                   {
+                     if (pfile->if_stack->type == T_ELSE)
+                       cpp_error (pfile, "`#else' or `#elif' after `#else'");
+                     pfile->if_stack->type = kt->type;
+                     break;
+                   }
+
+                 temp = pfile->if_stack;
+                 pfile->if_stack = temp->next;
+                 free (temp);
+                 break;
+             default: ;
+               }
+             break;
+           }
+         /* Don't let erroneous code go by.  */
+         if (kt->length < 0 && !CPP_OPTIONS (pfile)->lang_asm
+             && CPP_PEDANTIC (pfile))
+           cpp_pedwarn (pfile, "invalid preprocessor directive name");
+       }
+      c = GETC ();
+    }
+  /* We're in the middle of a line.  Skip the rest of it. */
+  for (;;) {
+    switch (c)
+      {
+      case EOF:
+       goto done;
+      case '/':                        /* possible comment */
+       c = skip_comment (pfile, NULL);
+       if (c == EOF)
+         goto done;
+       break;
+      case '\"':
+      case '\'':
+       skip_quoted_string (pfile, c, 0 /* FIXME */);
+       break;
+      case '\\':
+       /* Char after backslash loses its special meaning.  */
+       if (PEEKC() == '\n')
+         FORWARD (1);
+       break;
+      case '\n':
+       goto beg_of_line;
+       break;
+      }
+    c = GETC ();
+  }
+ done:
+  if (CPP_OPTIONS (pfile)->output_conditionals) {
+    static char end_failed[] = "#endfailed\n";
+    CPP_PUTS (pfile, end_failed, sizeof(end_failed)-1);
+    pfile->lineno++;
+  }
+  pfile->only_seen_white = 1;
+  parse_goto_mark (&line_start_mark, pfile);
+  parse_clear_mark (&line_start_mark);
+}
+
+/*
+ * 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, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  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");
+    }
+    pfile->if_stack->type = T_ELSE;
+  }
+
+  if (pfile->if_stack->if_succeeded)
+    skip_if_group (pfile, 0);
+  else {
+    ++pfile->if_stack->if_succeeded;   /* continue processing input */
+    output_line_command (pfile, 1, same_file);
+  }
+  return 0;
+}
+
+/*
+ * unstack after #endif command
+ */
+
+static int
+do_endif (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  if (CPP_PEDANTIC (pfile))
+    validate_else (pfile, "#endif");
+  skip_rest_of_line (pfile);
+
+  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.  */
+         struct parse_marker start_mark;
+         int c;
+
+         parse_set_mark (&start_mark, pfile);
+
+         for (;;)
+           {
+             cpp_skip_hspace (pfile);
+             c = GETC ();
+             if (c != '\n')
+               break;
+           }
+         parse_goto_mark (&start_mark, pfile);
+         parse_clear_mark (&start_mark);
+
+         if (c == EOF)
+           {
+             /* If we get here, 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.
+
+                Do not do this for the top-level file in a -include or any
+                file in a -imacros.  */
+#if 0
+FIXME!
+             if (indepth != 0
+                 && ! (indepth == 1 && pfile->no_record_file)
+                 && ! (pfile->no_record_file && no_output))
+#endif
+               {
+                 struct file_name_list *ifile = pfile->all_include_files;
+                 
+                 for ( ; ifile != NULL; ifile = ifile->next)
+                   {
+                     if (!strcmp (ifile->fname, CPP_BUFFER (pfile)->fname))
+                       {
+                         ifile->control_macro = temp->control_macro;
+                         break;
+                       }
+                   }
+               }
+           }
+        }
+      free (temp);
+      output_line_command (pfile, 1, same_file);
+    }
+  return 0;
+}
+
+/* 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.  */
+
+static void
+validate_else (pfile, directive)
+     cpp_reader *pfile;
+     char *directive;
+{
+  int c;
+  cpp_skip_hspace (pfile);
+  c = PEEKC ();
+  if (c != EOF && c != '\n')
+    cpp_pedwarn (pfile,
+                "text following `%s' violates ANSI standard", directive);
+}
+
+/* Get the next token, and add it to the tex in pfile->token_buffer.
+   Return the kind of token we got. */
+  
+
+enum cpp_token
+cpp_get_token (pfile)
+     cpp_reader *pfile;
+{
+  register int c, c2, c3;
+  long old_written;
+  enum cpp_token token;
+  struct cpp_options *opts = CPP_OPTIONS (pfile);
+  CPP_BUFFER (pfile)->prev = CPP_BUFFER (pfile)->cur;
+ get_next:
+  c = GETC();
+  if (c == EOF)
+    {
+    handle_eof:
+      if (CPP_BUFFER (pfile)->seen_eof)
+       {
+         if (cpp_pop_buffer (pfile) != CPP_NULL_BUFFER (pfile))
+           goto get_next;
+         else
+           return CPP_EOF;
+       }
+      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 != 0)
+           {
+             /* We're about to return from an #include file.
+                Emit #line information now (as part of the CPP_POP) restult.
+                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, 0, leave_file);
+             CPP_BUFFER (pfile) = cur_buffer;
+           }
+         return CPP_POP;
+       }
+    }
+  else
+    {
+      switch (c)
+       {
+         long newlines;
+         struct parse_marker start_mark;
+       case '/':
+         if (PEEKC () == '=')
+           goto op2;
+         if (opts->put_out_comments)
+           parse_set_mark (&start_mark, pfile);
+         newlines = 0;
+         c = skip_comment (pfile, &newlines);
+         if (opts->put_out_comments && (c == '/' || c == EOF))
+           parse_clear_mark (&start_mark);
+         if (c == '/')
+           goto randomchar;
+         if (c == EOF)
+           {
+             cpp_error_with_line (pfile, line_for_error (pfile->start_line),
+                                  "unterminated comment");
+             goto handle_eof;
+           }
+         c = '/';  /* Initial letter of comment. */
+       return_comment:
+         /* Comments are equivalent to spaces.
+            For -traditional, a comment is equivalent to nothing.  */
+         if (opts->put_out_comments)
+           {
+             cpp_buffer *pbuf = CPP_BUFFER (pfile);
+             long dummy;
+             U_CHAR *start = pbuf->buf + start_mark.position;
+             int len = pbuf->cur - start;
+             CPP_RESERVE(pfile, 1 + len);
+             CPP_PUTC_Q (pfile, c);
+             CPP_PUTS_Q (pfile, start, len);
+             pfile->lineno += newlines;
+             parse_clear_mark (&start_mark);
+             return CPP_COMMENT;
+           }
+         else if (CPP_TRADITIONAL (pfile))
+           goto get_next;
+         else
+           {
+#if 0
+             /* This may not work if cpp_get_token is called recursively,
+                since many places look for horizontal space. */
+             if (newlines)
+               {
+                 /* Copy the newlines into the output buffer, in order to
+                    avoid the pain of a #line every time a multiline comment
+                    is seen.  */
+                 CPP_RESERVE(pfile, newlines);
+                 while (--newlines >= 0)
+                   {
+                     CPP_PUTC_Q (pfile, '\n');
+                     pfile->lineno++;
+                   }
+                 return CPP_VSPACE;
+               }
+#endif
+             CPP_RESERVE(pfile, 1);
+             CPP_PUTC_Q (pfile, ' ');
+             return CPP_HSPACE;
+           }
+         if (opts->for_lint) {
+#if 0
+           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 b/c the newline for the pragma
+                could fuck things up. */
+             output_line_command (pfile, 0, same_file);
+             *(obp++) = ' ';   /* just in case, if comments are copied thru */
+             *(obp++) = '/';
+           }
+#endif
+         }
+
+       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;
+#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 '\'':
+         /* A single quoted string is treated like a double -- some
+            programs (e.g., troff) are perverse this way */
+#if 0
+         start_line = pfile->lineno;
+#endif
+         old_written = CPP_WRITTEN (pfile);
+       string:
+         CPP_PUTC (pfile, c);
+         while (1)
+           {
+             int cc = GETC();
+             if (cc == EOF)
+               {
+                 if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+                   {
+                     /* try harder: this string crosses a macro expansion
+                        boundary.  This can happen naturally if -traditional.
+                        Otherwise, only -D can make a macro with an unmatched
+                        quote.  */
+                       cpp_buffer *next_buf
+                           = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
+                       (*CPP_BUFFER (pfile)->cleanup)
+                           (CPP_BUFFER (pfile), pfile);
+                       CPP_BUFFER (pfile) = next_buf;
+                       continue;
+                   }
+#if 0
+                 if (!CPP_TRADITIONAL (pfile))
+                   {
+                     cpp_error_with_line (pfile, line_for_error (start_line),
+                             "unterminated string or character constant");
+                     cpp_error_with_line (pfile, multiline_string_line,
+                                "possible real start of unterminated constant");
+                     multiline_string_line = 0;
+                   }
+#endif
+                 break;
+               }
+             CPP_PUTC (pfile, cc);
+             switch (cc)
+               {
+               case '\n':
+                 /* Traditionally, end of line ends a string constant with
+                no error.  So exit the loop and record the new line.  */
+                 if (CPP_TRADITIONAL (pfile))
+                   goto while2end;
+#if 0
+                 if (c == '\'')
+                   {
+                     cpp_error_with_line (pfile, line_for_error (start_line),
+                                    "unterminated character constant");
+                     goto while2end;
+                   }
+                 if (CPP_PEDANTIC (pfile) && multiline_string_line == 0)
+                   {
+                     cpp_pedwarn_with_line (pfile,
+                                            line_for_error (start_line),
+                              "string constant runs past end of line");
+                   }
+                 if (multiline_string_line == 0)
+                   multiline_string_line = ip->lineno - 1;
+#endif
+                 break;
+               
+               case '\\':
+                 cc = GETC();
+                 if (cc == '\n')
+                   {
+                     /* Backslash newline is replaced by nothing at all. */
+                     CPP_ADJUST_WRITTEN (pfile, -1);
+                     pfile->lineno++;
+                   }
+                 else
+                   {
+                     /* ANSI stupidly requires that in \\ the second \
+                        is *not* prevented from combining with a newline.  */
+                     NEWLINE_FIX1(cc);
+                     if (cc != EOF)
+                       CPP_PUTC (pfile, cc);
+                   }
+                 break;
+
+               case '\"':
+               case '\'':
+                 if (cc == c)
+                   goto while2end;
+                 break;
+               }
+           }
+       while2end:
+         pfile->lineno += count_newlines (pfile->token_buffer + old_written,
+                                          CPP_PWRITTEN (pfile));
+         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 '|':
+         NEWLINE_FIX;
+         c2 = PEEKC ();
+         if (c2 == c || c2 == '=')
+           goto op2;
+         goto randomchar;
+
+       case '*':
+       case '!':
+       case '%':
+       case '=':
+       case '^':
+         NEWLINE_FIX;
+         if (PEEKC () == '=')
+           goto op2;
+         goto randomchar;
+
+       case '-':
+         NEWLINE_FIX;
+         c2 = PEEKC ();
+         if (c2 == '-' && opts->chill)
+           {
+             /* Chill style comment */
+             if (opts->put_out_comments)
+               parse_set_mark (&start_mark, pfile);
+             FORWARD(1);  /* Skip second '-'. */
+             for (;;)
+               {
+                 c = GETC ();
+                 if (c == EOF)
+                   break;
+                 if (c == '\n')
+                   {
+                     /* Don't consider final '\n' to be part of comment. */
+                     FORWARD(-1);
+                     break;
+                   }
+               }
+             c = '-';
+             goto return_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 ();
+                 NEWLINE_FIX1 (c);
+                 if (c == '\n' || c == EOF)
+                   {
+                     cpp_error (pfile,
+                                "missing '>' in `#include <FILENAME>'");
+                     break;
+                   }
+               }
+             return CPP_STRING;
+           }
+         /* else fall through */
+       case '>':
+         NEWLINE_FIX;
+         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);
+         NEWLINE_FIX;
+         c3 = PEEKC ();
+         if (c3 == '=')
+           CPP_PUTC_Q (pfile, GETC ());
+         CPP_NUL_TERMINATE_Q (pfile);
+         pfile->only_seen_white = 0;
+         return CPP_OTHER;
+
+       case '@':
+         if (CPP_BUFFER (pfile)->has_escapes)
+           {
+             c = GETC ();
+             if (c == '-')
+               {
+                 if (pfile->output_escapes)
+                   CPP_PUTS (pfile, "@-", 2);
+                 parse_name (pfile, GETC ());
+                 return CPP_NAME;
+               }
+           }
+         if (pfile->output_escapes)
+           {
+             CPP_PUTS (pfile, "@@", 2);
+             return CPP_OTHER;
+           }
+         goto randomchar;
+
+       case '.':
+         NEWLINE_FIX;
+         c2 = PEEKC ();
+         if (isdigit(c2))
+           {
+             CPP_RESERVE(pfile, 2);
+             CPP_PUTC_Q (pfile, '.');
+             c = GETC ();
+             goto number;
+           }
+         /* FIXME - misses the case "..\\\n." */
+         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;
+        op2any:
+         CPP_RESERVE(pfile, 3);
+         CPP_PUTC_Q (pfile, c);
+         CPP_PUTC_Q (pfile, GETC ());
+         CPP_NUL_TERMINATE_Q (pfile);
+         return token;
+
+       case 'L':
+         NEWLINE_FIX;
+         c2 = PEEKC ();
+         if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
+           {
+             CPP_PUTC (pfile, c);
+             c = GETC ();
+             goto string;
+           }
+         goto letter;
+
+       case '0': case '1': case '2': case '3': case '4':
+       case '5': case '6': case '7': case '8': case '9':
+       number:
+         c2  = '.';
+         for (;;)
+           {
+             CPP_RESERVE (pfile, 2);
+             CPP_PUTC_Q (pfile, c);
+             NEWLINE_FIX;
+             c = PEEKC ();
+             if (c == EOF)
+               break;
+             if (!is_idchar[c] && c != '.'
+                 && ((c2 != 'e' && c2 != 'E') || (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])
+                   {
+                     if (c == '\\' && PEEKC() == '\n')
+                       {
+                         FORWARD(2);
+                         continue;
+                       }
+                     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 "@-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] = '@';
+                   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)
+           {
+             struct parse_marker macro_mark;
+             int is_macro_call;
+             while (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+               {
+                 cpp_buffer *next_buf;
+                 cpp_skip_hspace (pfile);
+                 if (PEEKC () != EOF)
+                   break;
+                 next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
+                 (*CPP_BUFFER (pfile)->cleanup) (CPP_BUFFER (pfile), pfile);
+                 CPP_BUFFER (pfile) = next_buf;
+               }
+             parse_set_mark (&macro_mark, pfile);
+             for (;;)
+               {
+                 cpp_skip_hspace (pfile);
+                 c = PEEKC ();
+                 is_macro_call = c == '(';
+                 if (c != '\n')
+                   break;
+                 FORWARD (1);
+               }
+             if (!is_macro_call)
+               parse_goto_mark (&macro_mark, pfile);
+             parse_clear_mark (&macro_mark);
+             if (!is_macro_call)
+               return CPP_NAME;
+           }
+           /* This is now known to be a macro call. */
+
+           /* it might not actually be a macro.  */
+           if (hp->type != T_MACRO) {
+             int xbuf_len;  U_CHAR *xbuf;
+             CPP_SET_WRITTEN (pfile, before_name_written);
+             special_symbol (hp, pfile);
+             xbuf_len = CPP_WRITTEN (pfile) - before_name_written;
+             xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
+             CPP_SET_WRITTEN (pfile, before_name_written);
+             bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
+             push_macro_expansion (pfile, xbuf, xbuf_len, hp);
+           }
+           else
+             {
+               /* 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);
+             }
+
+           /* An extra space is added to the end of a macro expansion
+              to prevent accidental token pasting.  We prefer to avoid
+              unneeded extra spaces (for the sake of cpp-using tools like
+              imake).  Here we remove the space if it is safe to do so. */
+           if (pfile->buffer->rlimit - pfile->buffer->cur >= 2
+               && pfile->buffer->cur[-1] == ' ')
+             {
+               int c1 = pfile->buffer->rlimit[-2];
+               int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
+               if (c2 == EOF || ! unsafe_chars (c1, c2))
+                 pfile->buffer->rlimit--;
+             }
+
+           goto get_next;
+         }
+         return CPP_NAME;
+
+       case ' ':  case '\t':  case '\v':  case '\r':
+         for (;;)
+           {
+             CPP_PUTC (pfile, c);
+             c = PEEKC ();
+             if (c == EOF || !is_hor_space[c])
+               break;
+             FORWARD(1);
+           }
+         return CPP_HSPACE;
+
+        case '\\':
+         c2 = PEEKC ();
+         if (c2 != '\n')
+           goto randomchar;
+         token = CPP_HSPACE;
+         goto op2any;
+
+       case '\n':
+         CPP_PUTC (pfile, c);
+         if (pfile->only_seen_white == 0)
+           pfile->only_seen_white = 1;
+         pfile->lineno++;
+         output_line_command (pfile, 1, same_file);
+         return CPP_VSPACE;
+
+       case '(': token = CPP_LPAREN;    goto char1;
+       case ')': token = CPP_RPAREN;    goto char1;
+       case '{': token = CPP_LBRACE;    goto char1;
+       case '}': token = CPP_RBRACE;    goto char1;
+       case ',': token = CPP_COMMA;     goto char1;
+       case ';': token = CPP_SEMICOLON; goto char1;
+
+       randomchar:
+       default:
+         token = CPP_OTHER;
+       char1:
+         pfile->only_seen_white = 0;
+         CPP_PUTC (pfile, c);
+         return token;
+       }
+    }
+}
+
+/* Like cpp_get_token, but skip spaces and comments. */
+enum cpp_token
+cpp_get_non_space_token (pfile)
+     cpp_reader *pfile;
+{
+  int old_written = CPP_WRITTEN (pfile);
+  for (;;)
+    {
+      enum cpp_token token = cpp_get_token (pfile);
+      if (token != CPP_COMMENT && token != CPP_POP
+         && token != CPP_HSPACE && token != CPP_VSPACE)
+       return token;
+      CPP_SET_WRITTEN (pfile, old_written);
+    }
+}
+
+/* Parse an identifier starting with C. */
+
+int
+parse_name (pfile, c)
+     cpp_reader *pfile; int c;
+{
+  for (;;)
+  {
+      if (! is_idchar[c])
+      {
+         if (c == '\\' && PEEKC() == '\n')
+         {
+             FORWARD(2);
+             continue;
+         }
+         FORWARD (-1);
+         break;
+      }
+
+      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 1;
+}
+
+\f
+/* Maintain and search list of included files, for #import.  */
+
+/* Hash a file name for import_hash_table.  */
+
+static int 
+import_hash (f)
+     char *f;
+{
+  int val = 0;
+
+  while (*f) val += *f++;
+  return (val%IMPORT_HASH_SIZE);
+}
+
+/* Search for file FILENAME in import_hash_table.
+   Return -2 if found, either a matching name or a matching inode.
+   Otherwise, open the file and return a file descriptor if successful
+   or -1 if unsuccessful.  */
+
+static int
+lookup_import (pfile, filename, searchptr)
+cpp_reader *pfile;
+     char *filename;
+     struct file_name_list *searchptr;
+{
+  struct import_file *i;
+  int h;
+  int hashval;
+  struct stat sb;
+  int fd;
+
+  hashval = import_hash (filename);
+
+  /* Attempt to find file in list of already included files */
+  i = pfile->import_hash_table[hashval];
+
+  while (i) {
+    if (!strcmp (filename, i->name))
+      return -2;               /* return found */
+    i = i->next;
+  }
+  /* Open it and try a match on inode/dev */
+  fd = open_include_file (filename, searchptr);
+  if (fd < 0)
+    return fd;
+  fstat (fd, &sb);
+  for (h = 0; h < IMPORT_HASH_SIZE; h++) {
+    i = pfile->import_hash_table[h];
+    while (i) {
+      /* Compare the inode and the device.
+        Supposedly on some systems the inode is not a scalar.  */
+      if (!bcmp (&i->inode, &sb.st_ino, sizeof (sb.st_ino))
+         && i->dev == sb.st_dev) {
+        close (fd);
+        return -2;             /* return found */
+      }
+      i = i->next;
+    }
+  }
+  return fd;                   /* Not found, return open file */
+}
+
+/* Add the file FNAME, open on descriptor FD, to import_hash_table.  */
+
+static void
+add_import (pfile, fd, fname)
+     cpp_reader *pfile;
+     int fd;
+     char *fname;
+{
+  struct import_file *i;
+  int hashval;
+  struct stat sb;
+
+  hashval = import_hash (fname);
+  fstat (fd, &sb);
+  i = (struct import_file *)xmalloc (sizeof (struct import_file));
+  i->name = (char *)xmalloc (strlen (fname)+1);
+  strcpy (i->name, fname);
+  bcopy (&sb.st_ino, &i->inode, sizeof (sb.st_ino));
+  i->dev = sb.st_dev;
+  i->next = pfile->import_hash_table[hashval];
+  pfile->import_hash_table[hashval] = i;
+}
+\f
+/* The file_name_map structure holds a mapping of file names for a
+   particular directory.  This mapping is read from the file named
+   FILE_NAME_MAP_FILE in that directory.  Such a file can be used to
+   map filenames on a file system with severe filename restrictions,
+   such as DOS.  The format of the file name map file is just a series
+   of lines with two tokens on each line.  The first token is the name
+   to map, and the second token is the actual name to use.  */
+
+struct file_name_map
+{
+  struct file_name_map *map_next;
+  char *map_from;
+  char *map_to;
+};
+
+#define FILE_NAME_MAP_FILE "header.gcc"
+
+/* Read a space delimited string of unlimited length from a stdio
+   file.  */
+
+static char *
+read_filename_string (ch, f)
+     int ch;
+     FILE *f;
+{
+  char *alloc, *set;
+  int len;
+
+  len = 20;
+  set = alloc = xmalloc (len + 1);
+  if (! is_space[ch])
+    {
+      *set++ = ch;
+      while ((ch = getc (f)) != EOF && ! is_space[ch])
+       {
+         if (set - alloc == len)
+           {
+             len *= 2;
+             alloc = xrealloc (alloc, len + 1);
+             set = alloc + len / 2;
+           }
+         *set++ = ch;
+       }
+    }
+  *set = '\0';
+  ungetc (ch, f);
+  return alloc;
+}
+
+/* Read the file name map file for DIRNAME.  */
+
+static struct file_name_map *
+read_name_map (dirname)
+     char *dirname;
+{
+  /* This structure holds a linked list of file name maps, one per
+     directory.  */
+  struct file_name_map_list
+    {
+      struct file_name_map_list *map_list_next;
+      char *map_list_name;
+      struct file_name_map *map_list_map;
+    };
+  static struct file_name_map_list *map_list;
+  register struct file_name_map_list *map_list_ptr;
+  char *name;
+  FILE *f;
+
+  for (map_list_ptr = map_list; map_list_ptr;
+       map_list_ptr = map_list_ptr->map_list_next)
+    if (! strcmp (map_list_ptr->map_list_name, dirname))
+      return map_list_ptr->map_list_map;
+
+  map_list_ptr = ((struct file_name_map_list *)
+                 xmalloc (sizeof (struct file_name_map_list)));
+  map_list_ptr->map_list_name = savestring (dirname);
+  map_list_ptr->map_list_map = NULL;
+
+  name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
+  strcpy (name, dirname);
+  if (*dirname)
+    strcat (name, "/");
+  strcat (name, FILE_NAME_MAP_FILE);
+  f = fopen (name, "r");
+  if (!f)
+    map_list_ptr->map_list_map = NULL;
+  else
+    {
+      int ch;
+      int dirlen = strlen (dirname);
+
+      while ((ch = getc (f)) != EOF)
+       {
+         char *from, *to;
+         struct file_name_map *ptr;
+
+         if (is_space[ch])
+           continue;
+         from = read_filename_string (ch, f);
+         while ((ch = getc (f)) != EOF && is_hor_space[ch])
+           ;
+         to = read_filename_string (ch, f);
+
+         ptr = ((struct file_name_map *)
+                xmalloc (sizeof (struct file_name_map)));
+         ptr->map_from = from;
+
+         /* Make the real filename absolute.  */
+         if (*to == '/')
+           ptr->map_to = to;
+         else
+           {
+             ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
+             strcpy (ptr->map_to, dirname);
+             ptr->map_to[dirlen] = '/';
+             strcpy (ptr->map_to + dirlen + 1, to);
+             free (to);
+           }         
+
+         ptr->map_next = map_list_ptr->map_list_map;
+         map_list_ptr->map_list_map = ptr;
+
+         while ((ch = getc (f)) != '\n')
+           if (ch == EOF)
+             break;
+       }
+      fclose (f);
+    }
+  
+  map_list_ptr->map_list_next = map_list;
+  map_list = map_list_ptr;
+
+  return map_list_ptr->map_list_map;
+}  
+
+/* Try to open include file FILENAME.  SEARCHPTR is the directory
+   being tried from the include file search path.  This function maps
+   filenames on file systems based on information read by
+   read_name_map.  */
+
+static int
+open_include_file (filename, searchptr)
+     char *filename;
+     struct file_name_list *searchptr;
+{
+  register struct file_name_map *map;
+  register char *from;
+  char *p, *dir;
+
+  if (searchptr && ! searchptr->got_name_map)
+    {
+      searchptr->name_map = read_name_map (searchptr->fname
+                                          ? searchptr->fname : ".");
+      searchptr->got_name_map = 1;
+    }
+
+  /* First check the mapping for the directory we are using.  */
+  if (searchptr && searchptr->name_map)
+    {
+      from = filename;
+      if (searchptr->fname)
+       from += strlen (searchptr->fname) + 1;
+      for (map = searchptr->name_map; map; map = map->map_next)
+       {
+         if (! strcmp (map->map_from, from))
+           {
+             /* Found a match.  */
+             return open (map->map_to, O_RDONLY, 0666);
+           }
+       }
+    }
+
+  /* Try to find a mapping file for the particular directory we are
+     looking in.  Thus #include <sys/types.h> will look up sys/types.h
+     in /usr/include/header.gcc and look up types.h in
+     /usr/include/sys/header.gcc.  */
+  p = rindex (filename, '/');
+  if (! p)
+    p = filename;
+  if (searchptr
+      && searchptr->fname
+      && strlen (searchptr->fname) == p - filename
+      && ! strncmp (searchptr->fname, filename, p - filename))
+    {
+      /* FILENAME is in SEARCHPTR, which we've already checked.  */
+      return open (filename, O_RDONLY, 0666);
+    }
+
+  if (p == filename)
+    {
+      dir = ".";
+      from = filename;
+    }
+  else
+    {
+      dir = (char *) alloca (p - filename + 1);
+      bcopy (filename, dir, p - filename);
+      dir[p - filename] = '\0';
+      from = p + 1;
+    }
+  for (map = read_name_map (dir); map; map = map->map_next)
+    if (! strcmp (map->map_from, from))
+      return open (map->map_to, O_RDONLY, 0666);
+
+  return open (filename, O_RDONLY, 0666);
+}
+
+/* Process the contents of include file FNAME, already open on descriptor F,
+   with output to OP.
+   SYSTEM_HEADER_P is 1 if this file resides in any one of the known
+   "system" include directories (as decided by the `is_system_include'
+   function above).
+   DIRPTR is the link in the dir path through which this file was found,
+   or 0 if the file name was absolute.
+   Return 1 on success, 0 on failure. */
+
+static int
+finclude (pfile, f, fname, system_header_p, dirptr)
+     cpp_reader *pfile;
+     int f;
+     char *fname;
+     int system_header_p;
+     struct file_name_list *dirptr;
+{
+  int st_mode;
+  long st_size;
+  long i;
+  int length;
+  cpp_buffer *fp;                      /* For input stack frame */
+  int missing_newline = 0;
+
+#if 0
+  CHECK_DEPTH (return 0;);
+#endif
+
+  if (file_size_and_mode (f, &st_mode, &st_size) < 0)
+    {
+      cpp_perror_with_name (pfile, fname);
+      close (f);
+      return 0;
+    }
+
+  fp = cpp_push_buffer (pfile, NULL, 0);
+  fp->nominal_fname = fp->fname = fname;
+#if 0
+  fp->length = 0;
+#endif
+  fp->dir = dirptr;
+  fp->system_header_p = system_header_p;
+  fp->lineno = 1;
+  fp->colno = 1;
+  fp->cleanup = file_cleanup;
+
+  if (S_ISREG (st_mode)) {
+    fp->buf = (U_CHAR *) xmalloc (st_size + 2);
+    fp->alimit = fp->buf + st_size + 2;
+    fp->cur = fp->buf;
+
+    /* Read the file contents, knowing that st_size is an upper bound
+       on the number of bytes we can read.  */
+    length = safe_read (f, fp->buf, st_size);
+    fp->rlimit = fp->buf + length;
+    if (length < 0) goto nope;
+  }
+  else if (S_ISDIR (st_mode)) {
+    cpp_error (pfile, "directory `%s' specified in #include", fname);
+    close (f);
+    return 0;
+  } else {
+    /* Cannot count its file size before reading.
+       First read the entire file into heap and
+       copy them into buffer on stack. */
+
+    int bsize = 2000;
+
+    st_size = 0;
+    fp->buf = (U_CHAR *) xmalloc (bsize + 2);
+
+    for (;;) {
+      i = safe_read (f, fp->buf + st_size, bsize - st_size);
+      if (i < 0)
+       goto nope;      /* error! */
+      st_size += i;
+      if (st_size != bsize)
+       break;  /* End of file */
+      bsize *= 2;
+      fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
+    }
+    length = st_size;
+  }
+
+  if ((length > 0 && fp->buf[length - 1] != '\n')
+      /* Backslash-newline at end is not good enough.  */
+      || (length > 1 && fp->buf[length - 2] == '\\')) {
+    fp->buf[length++] = '\n';
+#if 0
+    missing_newline = 1;
+#endif
+  }
+  fp->buf[length] = '\0';
+  fp->rlimit = fp->buf + length;
+
+  /* Close descriptor now, so nesting does not use lots of descriptors.  */
+  close (f);
+
+  /* Must do this before calling trigraph_pcp, so that the correct file name
+     will be printed in warning messages.  */
+
+  pfile->input_stack_listing_current = 0;
+
+#if 0
+  if (!no_trigraphs)
+    trigraph_pcp (fp);
+#endif
+
+#if 0
+  rescan (op, 0);
+
+  if (missing_newline)
+    fp->lineno--;
+
+  if (CPP_PEDANTIC (pfile) && missing_newline)
+    pedwarn ("file does not end in newline");
+
+  indepth--;
+  input_file_stack_tick++;
+  free (fp->buf);
+#endif
+  return 1;
+
+ nope:
+
+  cpp_perror_with_name (pfile, fname);
+  close (f);
+  free (fp->buf);
+  return 1;
+}
+
+int
+push_parse_file (pfile, fname)
+     cpp_reader *pfile;
+     char *fname;
+{
+  struct cpp_options *opts = CPP_OPTIONS (pfile);
+  struct cpp_pending *pend;
+  char *p;
+  int f;
+
+  /* The code looks at the defaults through this pointer, rather than through
+     the constant structure above.  This pointer gets changed if an environment
+     variable specifies other defaults.  */
+  struct default_include *include_defaults = include_defaults_array;
+
+  /* Add dirs from CPATH after dirs from -I.  */
+  /* There seems to be confusion about what CPATH should do,
+     so for the moment it is not documented.  */
+  /* Some people say that CPATH should replace the standard include dirs,
+     but that seems pointless: it comes before them, so it overrides them
+     anyway.  */
+  p = (char *) getenv ("CPATH");
+  if (p != 0 && ! opts->no_standard_includes)
+    path_include (pfile, p);
+
+  /* Now that dollars_in_ident is known, initialize is_idchar.  */
+  initialize_char_syntax (opts);
+
+#if 0
+  /* Do partial setup of input buffer for the sake of generating
+     early #line directives (when -g is in effect).  */
+
+  fp = &instack[++indepth];
+  if (in_fname == NULL)
+    in_fname = "";
+  fp->nominal_fname = fp->fname = in_fname;
+  fp->lineno = 0;
+#endif
+
+  /* Install __LINE__, etc.  Must follow initialize_char_syntax
+     and option processing.  */
+  initialize_builtins (pfile);
+
+  /* Do standard #defines and assertions
+     that identify system and machine type.  */
+
+  if (!opts->inhibit_predefs) {
+    char *p = (char *) alloca (strlen (predefs) + 1);
+    strcpy (p, predefs);
+    while (*p) {
+      char *q;
+      while (*p == ' ' || *p == '\t')
+       p++;
+      /* Handle -D options.  */ 
+      if (p[0] == '-' && p[1] == 'D') {
+       q = &p[2];
+       while (*p && *p != ' ' && *p != '\t')
+         p++;
+       if (*p != 0)
+         *p++= 0;
+       if (opts->debug_output)
+         output_line_command (pfile, 0, same_file);
+       make_definition (pfile, q);
+       while (*p == ' ' || *p == '\t')
+         p++;
+      } else if (p[0] == '-' && p[1] == 'A') {
+       /* Handle -A options (assertions).  */ 
+       char *assertion;
+       char *past_name;
+       char *value;
+       char *past_value;
+       char *termination;
+       int save_char;
+
+       assertion = &p[2];
+       past_name = assertion;
+       /* Locate end of name.  */
+       while (*past_name && *past_name != ' '
+              && *past_name != '\t' && *past_name != '(')
+         past_name++;
+       /* Locate `(' at start of value.  */
+       value = past_name;
+       while (*value && (*value == ' ' || *value == '\t'))
+         value++;
+       if (*value++ != '(')
+         abort ();
+       while (*value && (*value == ' ' || *value == '\t'))
+         value++;
+       past_value = value;
+       /* Locate end of value.  */
+       while (*past_value && *past_value != ' '
+              && *past_value != '\t' && *past_value != ')')
+         past_value++;
+       termination = past_value;
+       while (*termination && (*termination == ' ' || *termination == '\t'))
+         termination++;
+       if (*termination++ != ')')
+         abort ();
+       if (*termination && *termination != ' ' && *termination != '\t')
+         abort ();
+       /* Temporarily null-terminate the value.  */
+       save_char = *termination;
+       *termination = '\0';
+       /* Install the assertion.  */
+       make_assertion (pfile, "-A", assertion);
+       *termination = (char) save_char;
+       p = termination;
+       while (*p == ' ' || *p == '\t')
+         p++;
+      } else {
+       abort ();
+      }
+    }
+  }
+
+  /* Now handle the command line options.  */
+
+  /* Do -U's, -D's and -A's in the order they were seen.  */
+  /* First reverse the list. */
+  {
+    struct cpp_pending *prev = 0, *next;
+    for (pend = opts->pending;  pend;  pend = next)
+      {
+       next = pend->next;
+       pend->next = prev;
+       prev = pend;
+      }
+    opts->pending = prev;
+
+    for (pend = opts->pending;  pend;  pend = pend->next)
+      {
+       if (pend->cmd != NULL && pend->cmd[0] == '-')
+         {
+           switch (pend->cmd[1])
+             {
+             case 'U':
+               if (opts->debug_output)
+                 output_line_command (pfile, 0, same_file);
+               do_undef (pfile, NULL, pend->arg, pend->arg + strlen (pend->arg));
+               break;
+             case 'D':
+               if (opts->debug_output)
+                 output_line_command (pfile, 0, same_file);
+               make_definition (pfile, pend->arg);
+               break;
+             case 'A':
+               make_assertion (pfile, "-A", pend->arg);
+               break;
+             }
+         }
+      }
+    opts->pending = NULL;
+  }
+
+  opts->done_initializing = 1;
+
+  { /* read the appropriate environment variable and if it exists
+       replace include_defaults with the listed path. */
+    char *epath = 0;
+    switch ((opts->objc << 1) + opts->cplusplus)
+      {
+      case 0:
+       epath = getenv ("C_INCLUDE_PATH");
+       break;
+      case 1:
+       epath = getenv ("CPLUS_INCLUDE_PATH");
+       break;
+      case 2:
+       epath = getenv ("OBJC_INCLUDE_PATH");
+       break;
+      case 3:
+       epath = getenv ("OBJCPLUS_INCLUDE_PATH");
+       break;
+      }
+    /* If the environment var for this language is set,
+       add to the default list of include directories.  */
+    if (epath) {
+      char *nstore = (char *) alloca (strlen (epath) + 2);
+      int num_dirs;
+      char *startp, *endp;
+
+      for (num_dirs = 1, startp = epath; *startp; startp++)
+       if (*startp == PATH_SEPARATOR)
+         num_dirs++;
+      include_defaults
+       = (struct default_include *) xmalloc ((num_dirs
+                                              * sizeof (struct default_include))
+                                             + sizeof (include_defaults_array));
+      startp = endp = epath;
+      num_dirs = 0;
+      while (1) {
+        /* Handle cases like c:/usr/lib:d:/gcc/lib */
+        if ((*endp == PATH_SEPARATOR)
+            || *endp == 0) {
+         strncpy (nstore, startp, endp-startp);
+         if (endp == startp)
+           strcpy (nstore, ".");
+         else
+           nstore[endp-startp] = '\0';
+
+         include_defaults[num_dirs].fname = savestring (nstore);
+         include_defaults[num_dirs].cplusplus = opts->cplusplus;
+         include_defaults[num_dirs].cxx_aware = 1;
+         num_dirs++;
+         if (*endp == '\0')
+           break;
+         endp = startp = endp + 1;
+       } else
+         endp++;
+      }
+      /* Put the usual defaults back in at the end.  */
+      bcopy (include_defaults_array, &include_defaults[num_dirs],
+            sizeof (include_defaults_array));
+    }
+  }
+
+  append_include_chain (pfile, opts->before_system, opts->last_before_system);
+  opts->first_system_include = opts->before_system;
+
+  /* Unless -fnostdinc,
+     tack on the standard include file dirs to the specified list */
+  if (!opts->no_standard_includes) {
+    struct default_include *p = include_defaults;
+    char *specd_prefix = opts->include_prefix;
+    char *default_prefix = savestring (GCC_INCLUDE_DIR);
+    int default_len = 0;
+    /* Remove the `include' from /usr/local/lib/gcc.../include.  */
+    if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
+      default_len = strlen (default_prefix) - 7;
+      default_prefix[default_len] = 0;
+    }
+    /* Search "translated" versions of GNU directories.
+       These have /usr/local/lib/gcc... replaced by specd_prefix.  */
+    if (specd_prefix != 0 && default_len != 0)
+      for (p = include_defaults; p->fname; p++) {
+       /* Some standard dirs are only for C++.  */
+       if (!p->cplusplus
+           || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
+         /* Does this dir start with the prefix?  */
+         if (!strncmp (p->fname, default_prefix, default_len)) {
+           /* Yes; change prefix and add to search list.  */
+           struct file_name_list *new
+             = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
+           int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
+           char *str = (char *) xmalloc (this_len + 1);
+           strcpy (str, specd_prefix);
+           strcat (str, p->fname + default_len);
+           new->fname = str;
+           new->control_macro = 0;
+           new->c_system_include_path = !p->cxx_aware;
+           new->got_name_map = 0;
+           append_include_chain (pfile, new, new);
+           if (opts->first_system_include == 0)
+             opts->first_system_include = new;
+         }
+       }
+      }
+    /* Search ordinary names for GNU include directories.  */
+    for (p = include_defaults; p->fname; p++) {
+      /* Some standard dirs are only for C++.  */
+      if (!p->cplusplus
+         || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
+       struct file_name_list *new
+         = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
+       new->control_macro = 0;
+       new->c_system_include_path = !p->cxx_aware;
+       new->fname = p->fname;
+       new->got_name_map = 0;
+       append_include_chain (pfile, new, new);
+       if (opts->first_system_include == 0)
+         opts->first_system_include = new;
+      }
+    }
+  }
+
+  /* Tack the after_include chain at the end of the include chain.  */
+  append_include_chain (pfile, opts->after_include, opts->last_after_include);
+  if (opts->first_system_include == 0)
+    opts->first_system_include = opts->after_include;
+
+  /* With -v, print the list of dirs to search.  */
+  if (opts->verbose) {
+    struct file_name_list *p;
+    fprintf (stderr, "#include \"...\" search starts here:\n");
+    for (p = opts->include; p; p = p->next) {
+      if (p == opts->first_bracket_include)
+       fprintf (stderr, "#include <...> search starts here:\n");
+      fprintf (stderr, " %s\n", p->fname);
+    }
+    fprintf (stderr, "End of search list.\n");
+  }
+
+  /* Scan the -imacros files before the main input.
+     Much like #including them, but with no_output set
+     so that only their macro definitions matter.  */
+
+  opts->no_output++; pfile->no_record_file++;
+  for (pend = opts->pending;  pend;  pend = pend->next)
+    {
+      if (pend->cmd != NULL && strcmp (pend->cmd, "-imacros") == 0)
+       {
+         int fd = open (pend->arg, O_RDONLY, 0666);
+         if (fd < 0)
+           {
+             cpp_perror_with_name (pfile, pend->arg);
+             return FAILURE_EXIT_CODE;
+           }
+         finclude (pfile, fd, pend->arg, 0, NULL_PTR);
+         cpp_scan_buffer (pfile);
+       }
+    }
+  opts->no_output--; pfile->no_record_file--;
+
+  /* Copy the entire contents of the main input file into
+     the stacked input buffer previously allocated for it.  */
+  if (fname == NULL || *fname == 0) {
+    fname = "";
+    f = 0;
+  } else if ((f = open (fname, O_RDONLY, 0666)) < 0)
+    cpp_pfatal_with_name (pfile, fname);
+
+  /* -MG doesn't select the form of output and must be specified with one of
+     -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
+     inhibit compilation.  */
+  if (opts->print_deps_missing_files
+      && (opts->print_deps == 0 || !opts->no_output))
+    fatal (pfile, "-MG must be specified with one of -M or -MM");
+
+  /* Either of two environment variables can specify output of deps.
+     Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
+     where OUTPUT_FILE is the file to write deps info to
+     and DEPS_TARGET is the target to mention in the deps.  */
+
+  if (opts->print_deps == 0
+      && (getenv ("SUNPRO_DEPENDENCIES") != 0
+         || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
+    char *spec = getenv ("DEPENDENCIES_OUTPUT");
+    char *s;
+    char *output_file;
+
+    if (spec == 0)
+      {
+       spec = getenv ("SUNPRO_DEPENDENCIES");
+       opts->print_deps = 2;
+      }
+    else
+      opts->print_deps = 1;
+
+    s = spec;
+    /* Find the space before the DEPS_TARGET, if there is one.  */
+    /* This should use index.  (mrs) */
+    while (*s != 0 && *s != ' ') s++;
+    if (*s != 0)
+      {
+       opts->deps_target = s + 1;
+       output_file = (char *) xmalloc (s - spec + 1);
+       bcopy (spec, output_file, s - spec);
+       output_file[s - spec] = 0;
+      }
+    else
+      {
+       opts->deps_target = 0;
+       output_file = spec;
+      }
+
+    opts->deps_file = output_file;
+    opts->print_deps_append = 1;
+  }
+
+  /* For -M, print the expected object file name
+     as the target of this Make-rule.  */
+  if (opts->print_deps)
+    {
+      pfile->deps_allocated_size = 200;
+      pfile->deps_buffer = (char *) xmalloc (pfile->deps_allocated_size);
+      pfile->deps_buffer[0] = 0;
+      pfile->deps_size = 0;
+      pfile->deps_column = 0;
+
+      if (opts->deps_target)
+       deps_output (pfile, opts->deps_target, ':');
+      else if (*opts->in_fname == 0)
+       deps_output (pfile, "-", ':');
+      else
+       {
+         char *p, *q;
+         int len;
+
+         /* Discard all directory prefixes from filename.  */
+         if ((q = rindex (opts->in_fname, '/')) != NULL
+#ifdef DIR_SEPARATOR
+             && (q = rindex (opts->in_fname, DIR_SEPARATOR)) != NULL
+#endif
+             )
+           ++q;
+         else
+           q = opts->in_fname;
+
+         /* Copy remainder to mungable area.  */
+         p = (char *) alloca (strlen(q) + 8);
+         strcpy (p, q);
+
+         /* Output P, but remove known suffixes.  */
+         len = strlen (p);
+         q = p + len;
+         if (len >= 2
+             && p[len - 2] == '.'
+             && index("cCsSm", p[len - 1]))
+           q = p + (len - 2);
+         else if (len >= 3
+                  && p[len - 3] == '.'
+                  && p[len - 2] == 'c'
+                  && p[len - 1] == 'c')
+           q = p + (len - 3);
+         else if (len >= 4
+                  && p[len - 4] == '.'
+                  && p[len - 3] == 'c'
+                  && p[len - 2] == 'x'
+                  && p[len - 1] == 'x')
+           q = p + (len - 4);
+         else if (len >= 4
+                  && p[len - 4] == '.'
+                  && p[len - 3] == 'c'
+                  && p[len - 2] == 'p'
+                  && p[len - 1] == 'p')
+           q = p + (len - 4);
+
+         /* Supply our own suffix.  */
+#ifndef VMS
+         strcpy (q, ".o");
+#else
+         strcpy (q, ".obj");
+#endif
+
+         deps_output (pfile, p, ':');
+         deps_output (pfile, opts->in_fname, ' ');
+       }
+    }
+
+#if 0
+  /* Make sure data ends with a newline.  And put a null after it.  */
+
+  if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
+      /* Backslash-newline at end is not good enough.  */
+      || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
+    fp->buf[fp->length++] = '\n';
+    missing_newline = 1;
+  }
+  fp->buf[fp->length] = '\0';
+
+  /* Unless inhibited, convert trigraphs in the input.  */
+
+  if (!no_trigraphs)
+    trigraph_pcp (fp);
+#endif
+
+  /* Scan the -include files before the main input.  */
+
+  pfile->no_record_file++;
+  for (pend = opts->pending;  pend;  pend = pend->next)
+    {
+      if (pend->cmd != NULL && strcmp (pend->cmd, "-include") == 0)
+       {
+         int fd = open (pend->arg, O_RDONLY, 0666);
+         if (fd < 0)
+           {
+             cpp_perror_with_name (pfile, pend->arg);
+             return FAILURE_EXIT_CODE;
+           }
+         finclude (pfile, fd, pend->arg, 0, NULL_PTR);
+         cpp_scan_buffer (pfile);
+       }
+    }
+  pfile->no_record_file--;
+
+  /* Free the pending list. */
+  for (pend = opts->pending;  pend; )
+    {
+      struct cpp_pending *next = pend->next;
+      free (pend);
+      pend = next;
+    }
+  opts->pending = NULL;
+
+#if 0
+  /* Scan the input, processing macros and directives.  */
+
+  rescan (&outbuf, 0);
+
+  if (missing_newline)
+    fp->lineno--;
+
+  if (CPP_PEDANTIC (pfile) && missing_newline)
+    pedwarn ("file does not end in newline");
+
+#endif
+  if (finclude (pfile, f, fname, 0, 0))
+    output_line_command (pfile, 0, same_file);
+  return SUCCESS_EXIT_CODE;
+}
+
+void
+init_parse_file (pfile)
+     cpp_reader *pfile;
+{
+  bzero (pfile, sizeof (cpp_reader));
+  pfile->get_token = cpp_get_token;
+
+  pfile->token_buffer_size = 200;
+  pfile->token_buffer = (char*)xmalloc (pfile->token_buffer_size);
+  CPP_SET_WRITTEN (pfile, 0);
+
+  pfile->system_include_depth = 0;
+  pfile->dont_repeat_files = 0;
+  pfile->all_include_files = 0;
+  pfile->max_include_len = 0;
+  pfile->timebuf = NULL;
+  pfile->only_seen_white = 1;
+  pfile->buffer = CPP_NULL_BUFFER(pfile);
+}
+
+static void
+push_pending (pfile, cmd, arg)
+     cpp_reader *pfile;
+     char *cmd;
+     char *arg;
+{
+  struct cpp_pending *pend
+    = (struct cpp_pending*)xmalloc (sizeof (struct cpp_pending));
+  pend->cmd = cmd;
+  pend->arg = arg;
+  pend->next = CPP_OPTIONS (pfile)->pending;
+  CPP_OPTIONS (pfile)->pending = pend;
+}
+
+/* Handle command-line options in (argc, argv).
+   Can be called multiple times, to handle multiple sets of options.
+   Returns if an unrecognized option is seen.
+   Returns number of handled arguments.  */
+
+int
+cpp_handle_options (pfile, argc, argv)
+     cpp_reader *pfile;
+     int argc;
+     char **argv;
+{
+  int i;
+  struct cpp_options *opts = CPP_OPTIONS (pfile);
+  for (i = 0; i < argc; i++) {
+    if (argv[i][0] != '-') {
+      if (opts->out_fname != NULL)
+       fatal ("Usage: %s [switches] input output", argv[0]);
+      else if (opts->in_fname != NULL)
+       opts->out_fname = argv[i];
+      else
+       opts->in_fname = argv[i];
+    } else {
+      switch (argv[i][1]) {
+
+      case 'i':
+       if (!strcmp (argv[i], "-include")
+           || !strcmp (argv[i], "-imacros")) {
+         if (i + 1 == argc)
+           fatal ("Filename missing after `%s' option", argv[i]);
+         else
+           push_pending (pfile, argv[i], argv[i+1]), i++;
+       }
+       if (!strcmp (argv[i], "-iprefix")) {
+         if (i + 1 == argc)
+           fatal ("Filename missing after `-iprefix' option");
+         else
+           opts->include_prefix = argv[++i];
+       }
+       if (!strcmp (argv[i], "-ifoutput")) {
+         opts->output_conditionals = 1;
+       }
+       if (!strcmp (argv[i], "-isystem")) {
+         struct file_name_list *dirtmp;
+
+         if (i + 1 == argc)
+           fatal ("Filename missing after `-isystem' option");
+
+         dirtmp = (struct file_name_list *)
+           xmalloc (sizeof (struct file_name_list));
+         dirtmp->next = 0;
+         dirtmp->control_macro = 0;
+         dirtmp->c_system_include_path = 1;
+         dirtmp->fname = (char *) xmalloc (strlen (argv[i+1]) + 1);
+         strcpy (dirtmp->fname, argv[++i]);
+         dirtmp->got_name_map = 0;
+
+         if (opts->before_system == 0)
+           opts->before_system = dirtmp;
+         else
+           opts->last_before_system->next = dirtmp;
+         opts->last_before_system = dirtmp; /* Tail follows the last one */
+       }
+       /* Add directory to end of path for includes,
+          with the default prefix at the front of its name.  */
+       if (!strcmp (argv[i], "-iwithprefix")) {
+         struct file_name_list *dirtmp;
+         char *prefix;
+
+         if (opts->include_prefix != 0)
+           prefix = opts->include_prefix;
+         else {
+           prefix = savestring (GCC_INCLUDE_DIR);
+           /* Remove the `include' from /usr/local/lib/gcc.../include.  */
+           if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
+             prefix[strlen (prefix) - 7] = 0;
+         }
+
+         dirtmp = (struct file_name_list *)
+           xmalloc (sizeof (struct file_name_list));
+         dirtmp->next = 0;     /* New one goes on the end */
+         dirtmp->control_macro = 0;
+         dirtmp->c_system_include_path = 0;
+         if (i + 1 == argc)
+           fatal ("Directory name missing after `-iwithprefix' option");
+
+         dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
+                                           + strlen (prefix) + 1);
+         strcpy (dirtmp->fname, prefix);
+         strcat (dirtmp->fname, argv[++i]);
+         dirtmp->got_name_map = 0;
+
+         if (opts->after_include == 0)
+           opts->after_include = dirtmp;
+         else
+           opts->last_after_include->next = dirtmp;
+         opts->last_after_include = dirtmp; /* Tail follows the last one */
+       }
+       /* Add directory to main path for includes,
+          with the default prefix at the front of its name.  */
+       if (!strcmp (argv[i], "-iwithprefixbefore")) {
+         struct file_name_list *dirtmp;
+         char *prefix;
+
+         if (opts->include_prefix != 0)
+           prefix = opts->include_prefix;
+         else {
+           prefix = savestring (GCC_INCLUDE_DIR);
+           /* Remove the `include' from /usr/local/lib/gcc.../include.  */
+           if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
+             prefix[strlen (prefix) - 7] = 0;
+         }
+
+         dirtmp = (struct file_name_list *)
+           xmalloc (sizeof (struct file_name_list));
+         dirtmp->next = 0;     /* New one goes on the end */
+         dirtmp->control_macro = 0;
+         dirtmp->c_system_include_path = 0;
+         if (i + 1 == argc)
+           fatal ("Directory name missing after `-iwithprefixbefore' option");
+
+         dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
+                                           + strlen (prefix) + 1);
+         strcpy (dirtmp->fname, prefix);
+         strcat (dirtmp->fname, argv[++i]);
+         dirtmp->got_name_map = 0;
+
+         append_include_chain (pfile, dirtmp, dirtmp);
+       }
+       /* Add directory to end of path for includes.  */
+       if (!strcmp (argv[i], "-idirafter")) {
+         struct file_name_list *dirtmp;
+
+         dirtmp = (struct file_name_list *)
+           xmalloc (sizeof (struct file_name_list));
+         dirtmp->next = 0;     /* New one goes on the end */
+         dirtmp->control_macro = 0;
+         dirtmp->c_system_include_path = 0;
+         if (i + 1 == argc)
+           fatal ("Directory name missing after `-idirafter' option");
+         else
+           dirtmp->fname = argv[++i];
+         dirtmp->got_name_map = 0;
+
+         if (opts->after_include == 0)
+           opts->after_include = dirtmp;
+         else
+           opts->last_after_include->next = dirtmp;
+         opts->last_after_include = dirtmp; /* Tail follows the last one */
+       }
+       break;
+
+      case 'o':
+       if (opts->out_fname != NULL)
+         fatal ("Output filename specified twice");
+       if (i + 1 == argc)
+         fatal ("Filename missing after -o option");
+       opts->out_fname = argv[++i];
+       if (!strcmp (opts->out_fname, "-"))
+         opts->out_fname = "";
+       break;
+
+      case 'p':
+       if (!strcmp (argv[i], "-pedantic"))
+         CPP_PEDANTIC (pfile) = 1;
+       else if (!strcmp (argv[i], "-pedantic-errors")) {
+         CPP_PEDANTIC (pfile) = 1;
+         opts->pedantic_errors = 1;
+       }
+#if 0
+       else if (!strcmp (argv[i], "-pcp")) {
+         char *pcp_fname = argv[++i];
+         pcp_outfile = 
+           ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
+            ? fopen (pcp_fname, "w")
+            : fdopen (dup (fileno (stdout)), "w"));
+         if (pcp_outfile == 0)
+           cpp_pfatal_with_name (pfile, pcp_fname);
+         no_precomp = 1;
+       }
+#endif
+       break;
+
+      case 't':
+       if (!strcmp (argv[i], "-traditional")) {
+         opts->traditional = 1;
+         if (opts->dollars_in_ident > 0)
+           opts->dollars_in_ident = 1;
+       } else if (!strcmp (argv[i], "-trigraphs")) {
+         if (!opts->chill)
+           opts->no_trigraphs = 0;
+       }
+       break;
+
+      case 'l':
+       if (! strcmp (argv[i], "-lang-c"))
+         opts->cplusplus = 0, opts->cplusplus_comments = 0, opts->objc = 0;
+       if (! strcmp (argv[i], "-lang-c++"))
+         opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->objc = 0;
+       if (! strcmp (argv[i], "-lang-c-c++-comments"))
+         opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->objc = 0;
+       if (! strcmp (argv[i], "-lang-objc"))
+         opts->objc = 1, opts->cplusplus = 0, opts->cplusplus_comments = 1;
+       if (! strcmp (argv[i], "-lang-objc++"))
+         opts->objc = 1, opts->cplusplus = 1, opts->cplusplus_comments = 1;
+       if (! strcmp (argv[i], "-lang-asm"))
+         opts->lang_asm = 1;
+       if (! strcmp (argv[i], "-lint"))
+         opts->for_lint = 1;
+       if (! strcmp (argv[i], "-lang-chill"))
+         opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
+         opts->traditional = 1, opts->no_trigraphs = 1;
+       break;
+
+      case '+':
+       opts->cplusplus = 1, opts->cplusplus_comments = 1;
+       break;
+
+      case 'w':
+       opts->inhibit_warnings = 1;
+       break;
+
+      case 'W':
+       if (!strcmp (argv[i], "-Wtrigraphs"))
+         opts->warn_trigraphs = 1;
+       else if (!strcmp (argv[i], "-Wno-trigraphs"))
+         opts->warn_trigraphs = 0;
+       else if (!strcmp (argv[i], "-Wcomment"))
+         opts->warn_comments = 1;
+       else if (!strcmp (argv[i], "-Wno-comment"))
+         opts->warn_comments = 0;
+       else if (!strcmp (argv[i], "-Wcomments"))
+         opts->warn_comments = 1;
+       else if (!strcmp (argv[i], "-Wno-comments"))
+         opts->warn_comments = 0;
+       else if (!strcmp (argv[i], "-Wtraditional"))
+         opts->warn_stringify = 1;
+       else if (!strcmp (argv[i], "-Wno-traditional"))
+         opts->warn_stringify = 0;
+       else if (!strcmp (argv[i], "-Wimport"))
+         opts->warn_import = 1;
+       else if (!strcmp (argv[i], "-Wno-import"))
+         opts->warn_import = 0;
+       else if (!strcmp (argv[i], "-Werror"))
+         opts->warnings_are_errors = 1;
+       else if (!strcmp (argv[i], "-Wno-error"))
+         opts->warnings_are_errors = 0;
+       else if (!strcmp (argv[i], "-Wall"))
+         {
+           opts->warn_trigraphs = 1;
+           opts->warn_comments = 1;
+         }
+       break;
+
+      case 'M':
+       /* The style of the choices here is a bit mixed.
+          The chosen scheme is a hybrid of keeping all options in one string
+          and specifying each option in a separate argument:
+          -M|-MM|-MD file|-MMD file [-MG].  An alternative is:
+          -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
+          -M[M][G][D file].  This is awkward to handle in specs, and is not
+          as extensible.  */
+       /* ??? -MG must be specified in addition to one of -M or -MM.
+          This can be relaxed in the future without breaking anything.
+          The converse isn't true.  */
+
+       /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
+       if (!strcmp (argv[i], "-MG"))
+         {
+           opts->print_deps_missing_files = 1;
+           break;
+         }
+       if (!strcmp (argv[i], "-M"))
+         opts->print_deps = 2;
+       else if (!strcmp (argv[i], "-MM"))
+         opts->print_deps = 1;
+       else if (!strcmp (argv[i], "-MD"))
+         opts->print_deps = 2;
+       else if (!strcmp (argv[i], "-MMD"))
+         opts->print_deps = 1;
+       /* For -MD and -MMD options, write deps on file named by next arg.  */
+       if (!strcmp (argv[i], "-MD") || !strcmp (argv[i], "-MMD"))
+         {
+           if (i+1 == argc)
+             fatal ("Filename missing after %s option", argv[i]);
+           opts->deps_file = argv[++i];
+         }
+       else
+         {
+           /* For -M and -MM, write deps on standard output
+              and suppress the usual output.  */
+           opts->no_output = 1;
+         }       
+       break;
+
+      case 'd':
+       {
+         char *p = argv[i] + 2;
+         char c;
+         while ((c = *p++) != 0) {
+           /* Arg to -d specifies what parts of macros to dump */
+           switch (c) {
+           case 'M':
+             opts->dump_macros = dump_only;
+             opts->no_output = 1;
+             break;
+           case 'N':
+             opts->dump_macros = dump_names;
+             break;
+           case 'D':
+             opts->dump_macros = dump_definitions;
+             break;
+           }
+         }
+       }
+       break;
+
+      case 'g':
+       if (argv[i][2] == '3')
+         opts->debug_output = 1;
+       break;
+
+      case 'v':
+       fprintf (stderr, "GNU CPP version %s", version_string);
+#ifdef TARGET_VERSION
+       TARGET_VERSION;
+#endif
+       fprintf (stderr, "\n");
+       opts->verbose = 1;
+       break;
+
+      case 'H':
+       opts->print_include_names = 1;
+       break;
+
+      case 'D':
+       if (argv[i][2] != 0)
+         push_pending (pfile, "-D", argv[i] + 2);
+       else if (i + 1 == argc)
+         fatal ("Macro name missing after -D option");
+       else
+         i++, push_pending (pfile, "-D", argv[i]);
+       break;
+
+      case 'A':
+       {
+         char *p;
+
+         if (argv[i][2] != 0)
+           p = argv[i] + 2;
+         else if (i + 1 == argc)
+           fatal ("Assertion missing after -A option");
+         else
+           p = argv[++i];
+
+         if (!strcmp (p, "-")) {
+           struct cpp_pending **ptr;
+           /* -A- eliminates all predefined macros and assertions.
+              Let's include also any that were specified earlier
+              on the command line.  That way we can get rid of any
+              that were passed automatically in from GCC.  */
+           int j;
+           opts->inhibit_predefs = 1;
+           for (ptr = &opts->pending; *ptr != NULL; )
+             {
+               struct cpp_pending *pend = *ptr;
+               if (pend->cmd && pend->cmd[0] == '-'
+                   && (pend->cmd[1] == 'D' || pend->cmd[1] == 'A'))
+                 {
+                   *ptr = pend->next;
+                   free (pend);
+                 }
+               else
+                 ptr = &pend->next;
+             }
+         } else {
+           push_pending (pfile, "-A", p);
+         }
+       }
+       break;
+
+      case 'U':                /* JF #undef something */
+       if (argv[i][2] != 0)
+         push_pending (pfile, "-U", argv[i] + 2);
+       else if (i + 1 == argc)
+         fatal ("Macro name missing after -U option");
+       else
+         push_pending (pfile, "-U", argv[i+1]), i++;
+       break;
+
+      case 'C':
+       opts->put_out_comments = 1;
+       break;
+
+      case 'E':                        /* -E comes from cc -E; ignore it.  */
+       break;
+
+      case 'P':
+       opts->no_line_commands = 1;
+       break;
+
+      case '$':                        /* Don't include $ in identifiers.  */
+       opts->dollars_in_ident = 0;
+       break;
+
+      case 'I':                        /* Add directory to path for includes.  */
+       {
+         struct file_name_list *dirtmp;
+
+         if (! CPP_OPTIONS(pfile)->ignore_srcdir
+             && !strcmp (argv[i] + 2, "-")) {
+           CPP_OPTIONS (pfile)->ignore_srcdir = 1;
+           /* Don't use any preceding -I directories for #include <...>.  */
+           CPP_OPTIONS (pfile)->first_bracket_include = 0;
+         }
+         else {
+           dirtmp = (struct file_name_list *)
+             xmalloc (sizeof (struct file_name_list));
+           dirtmp->next = 0;           /* New one goes on the end */
+           dirtmp->control_macro = 0;
+           dirtmp->c_system_include_path = 0;
+           if (argv[i][2] != 0)
+             dirtmp->fname = argv[i] + 2;
+           else if (i + 1 == argc)
+             fatal ("Directory name missing after -I option");
+           else
+             dirtmp->fname = argv[++i];
+           dirtmp->got_name_map = 0;
+           append_include_chain (pfile, dirtmp, dirtmp);
+         }
+       }
+       break;
+
+      case 'n':
+       if (!strcmp (argv[i], "-nostdinc"))
+         /* -nostdinc causes no default include directories.
+            You must specify all include-file directories with -I.  */
+         opts->no_standard_includes = 1;
+       else if (!strcmp (argv[i], "-nostdinc++"))
+         /* -nostdinc++ causes no default C++-specific include directories. */
+         opts->no_standard_cplusplus_includes = 1;
+#if 0
+       else if (!strcmp (argv[i], "-noprecomp"))
+         no_precomp = 1;
+#endif
+       break;
+
+      case 'u':
+       /* Sun compiler passes undocumented switch "-undef".
+          Let's assume it means to inhibit the predefined symbols.  */
+       opts->inhibit_predefs = 1;
+       break;
+
+      case '\0': /* JF handle '-' as file name meaning stdin or stdout */
+       if (opts->in_fname == NULL) {
+         opts->in_fname = "";
+         break;
+       } else if (opts->out_fname == NULL) {
+         opts->out_fname = "";
+         break;
+       }       /* else fall through into error */
+
+      default:
+       return i;
+      }
+    }
+  }
+  return i;
+}
+\f
+void
+cpp_finish (pfile)
+     cpp_reader *pfile;
+{
+  struct cpp_options *opts = CPP_OPTIONS (pfile);
+  
+  if (opts->print_deps)
+    {
+      /* Stream on which to print the dependency information.  */
+      FILE *deps_stream;
+
+      /* Don't actually write the deps file if compilation has failed.  */
+      if (pfile->errors == 0)
+       {
+         char *deps_mode = opts->print_deps_append ? "a" : "w";
+         if (opts->deps_file == 0)
+           deps_stream = stdout;
+         else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
+           cpp_pfatal_with_name (pfile, opts->deps_file);
+         fputs (pfile->deps_buffer, deps_stream);
+         putc ('\n', deps_stream);
+         if (opts->deps_file)
+           {
+             if (ferror (deps_stream) || fclose (deps_stream) != 0)
+               fatal ("I/O error on output");
+           }
+       }
+    }
+}
+\f
+static int
+do_assert (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  long symstart;               /* remember where symbol name starts */
+  int c;
+  int sym_length;              /* and how long it is */
+  struct arglist *tokens = NULL;
+
+  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);
+  symstart = CPP_WRITTEN (pfile);      /* remember where it starts */
+  parse_name (pfile, GETC());
+  sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
+                                "assertion");
+
+  cpp_skip_hspace (pfile);
+  if (PEEKC() != '(') {
+    cpp_error (pfile, "missing token-sequence in `#assert'");
+    goto error;
+  }
+
+  {
+    int error_flag = 0;
+    tokens = read_token_list (pfile, &error_flag);
+    if (error_flag)
+      goto error;
+    if (tokens == 0) {
+      cpp_error (pfile, "empty token-sequence in `#assert'");
+      goto error;
+    }
+  cpp_skip_hspace (pfile);
+  c = PEEKC ();
+  if (c != EOF && c != '\n')
+      cpp_pedwarn (pfile, "junk at end of `#assert'");
+  skip_rest_of_line (pfile);
+  }
+
+  /* If this name isn't already an assertion name, make it one.
+     Error if it was already in use in some other way.  */
+
+  {
+    ASSERTION_HASHNODE *hp;
+    U_CHAR *symname = pfile->token_buffer + symstart;
+    int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
+    struct tokenlist_list *value
+      = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
+
+    hp = assertion_lookup (pfile, symname, sym_length, hashcode);
+    if (hp == NULL) {
+      if (sym_length == 7 && ! strncmp (symname, "defined", sym_length))
+       cpp_error (pfile, "`defined' redefined as assertion");
+      hp = assertion_install (pfile, symname, sym_length, hashcode);
+    }
+
+    /* Add the spec'd token-sequence to the list of such.  */
+    value->tokens = tokens;
+    value->next = hp->value;
+    hp->value = value;
+  }
+  CPP_SET_WRITTEN (pfile, symstart); /* Pop */
+  return 0;
+ error:
+  CPP_SET_WRITTEN (pfile, symstart); /* Pop */
+  skip_rest_of_line (pfile);
+  return 1;
+}
+\f
+static int
+do_unassert (pfile, keyword, buf, limit)
+     cpp_reader *pfile;
+     struct directive *keyword;
+     U_CHAR *buf, *limit;
+{
+  long symstart;               /* remember where symbol name starts */
+  int sym_length;      /* and how long it is */
+  int c;
+
+  struct arglist *tokens = NULL;
+  int tokens_specified = 0;
+
+  if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
+      && !CPP_BUFFER (pfile)->system_header_p)
+    cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");
+
+  cpp_skip_hspace (pfile);
+
+  symstart = CPP_WRITTEN (pfile);      /* remember where it starts */
+  parse_name (pfile, GETC());
+  sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
+                                "assertion");
+
+  cpp_skip_hspace (pfile);
+  if (PEEKC() == '(') {
+    int error_flag = 0;
+
+    tokens = read_token_list (pfile, &error_flag);
+    if (error_flag)
+      goto error;
+    if (tokens == 0) {
+      cpp_error (pfile, "empty token list in `#unassert'");
+      goto error;
+    }
+
+    tokens_specified = 1;
+  }
+
+  cpp_skip_hspace (pfile);
+  c = PEEKC ();
+  if (c != EOF && c != '\n')
+      cpp_error (pfile, "junk at end of `#unassert'");
+  skip_rest_of_line (pfile);
+
+  {
+    ASSERTION_HASHNODE *hp;
+    U_CHAR *symname = pfile->token_buffer + symstart;
+    int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
+    struct tokenlist_list *tail, *prev;
+
+    hp = assertion_lookup (pfile, symname, sym_length, hashcode);
+    if (hp == NULL)
+      return 1;
+
+    /* If no token list was specified, then eliminate this assertion
+       entirely.  */
+    if (! tokens_specified) {
+      struct tokenlist_list *next;
+      for (tail = hp->value; tail; tail = next) {
+       next = tail->next;
+       free_token_list (tail->tokens);
+       free (tail);
+      }
+      delete_assertion (hp);
+    } else {
+      /* If a list of tokens was given, then delete any matching list.  */
+
+      tail = hp->value;
+      prev = 0;
+      while (tail) {
+       struct tokenlist_list *next = tail->next;
+       if (compare_token_lists (tail->tokens, tokens)) {
+         if (prev)
+           prev->next = next;
+         else
+           hp->value = tail->next;
+         free_token_list (tail->tokens);
+         free (tail);
+       } else {
+         prev = tail;
+       }
+       tail = next;
+      }
+    }
+  }
+
+  CPP_SET_WRITTEN (pfile, symstart); /* Pop */
+  return 0;
+ error:
+  CPP_SET_WRITTEN (pfile, symstart); /* Pop */
+  skip_rest_of_line (pfile);
+  return 1;
+}
+\f
+/* Test whether there is an assertion named NAME
+   and optionally whether it has an asserted token list TOKENS.
+   NAME is not null terminated; its length is SYM_LENGTH.
+   If TOKENS_SPECIFIED is 0, then don't check for any token list.  */
+
+int
+check_assertion (pfile, name, sym_length, tokens_specified, tokens)
+     cpp_reader *pfile;
+     U_CHAR *name;
+     int sym_length;
+     int tokens_specified;
+     struct arglist *tokens;
+{
+  ASSERTION_HASHNODE *hp;
+  int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
+
+  if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
+    cpp_pedwarn (pfile, "ANSI C does not allow testing assertions");
+
+  hp = assertion_lookup (pfile, name, sym_length, hashcode);
+  if (hp == NULL)
+    /* It is not an assertion; just return false.  */
+    return 0;
+
+  /* If no token list was specified, then value is 1.  */
+  if (! tokens_specified)
+    return 1;
+
+  {
+    struct tokenlist_list *tail;
+
+    tail = hp->value;
+
+    /* If a list of tokens was given,
+       then succeed if the assertion records a matching list.  */
+
+    while (tail) {
+      if (compare_token_lists (tail->tokens, tokens))
+       return 1;
+      tail = tail->next;
+    }
+
+    /* Fail if the assertion has no matching list.  */
+    return 0;
+  }
+}
+
+/* Compare two lists of tokens for equality including order of tokens.  */
+
+static int
+compare_token_lists (l1, l2)
+     struct arglist *l1, *l2;
+{
+  while (l1 && l2) {
+    if (l1->length != l2->length)
+      return 0;
+    if (strncmp (l1->name, l2->name, l1->length))
+      return 0;
+    l1 = l1->next;
+    l2 = l2->next;
+  }
+
+  /* Succeed if both lists end at the same time.  */
+  return l1 == l2;
+}
+\f
+struct arglist *
+reverse_token_list (tokens)
+     struct arglist *tokens;
+{
+  register struct arglist *prev = 0, *this, *next;
+  for (this = tokens; this; this = next)
+    {
+      next = this->next;
+      this->next = prev;
+      prev = this;
+    }
+  return prev;
+}
+
+/* Read a space-separated list of tokens ending in a close parenthesis.
+   Return a list of strings, in the order they were written.
+   (In case of error, return 0 and store -1 in *ERROR_FLAG.) */
+
+static struct arglist *
+read_token_list (pfile, error_flag)
+     cpp_reader *pfile;
+     int *error_flag;
+{
+  struct arglist *token_ptrs = 0;
+  int depth = 1;
+  int length;
+
+  *error_flag = 0;
+  FORWARD (1);  /* Skip '(' */
+
+  /* Loop over the assertion value tokens.  */
+  while (depth > 0)
+    {
+      struct arglist *temp;
+      long name_written = CPP_WRITTEN (pfile);
+      int eofp = 0;  int c;
+
+      cpp_skip_hspace (pfile);
+
+      c = GETC ();
+         
+      /* Find the end of the token.  */
+      if (c == '(')
+        {
+         CPP_PUTC (pfile, c);
+         depth++;
+        }
+      else if (c == ')')
+        {
+         depth--;
+         if (depth == 0)
+           break;
+         CPP_PUTC (pfile, c);
+        }
+      else if (c == '"' || c == '\'')
+        {
+         FORWARD(-1);
+         cpp_get_token (pfile);
+        }
+      else if (c == '\n')
+       break;
+      else
+        {
+         while (c != EOF && ! is_space[c] && c != '(' && c != ')'
+                && c != '"' && c != '\'')
+           {
+             CPP_PUTC (pfile, c);
+             c = GETC();
+           }
+         if (c != EOF)  FORWARD(-1);
+        }
+
+      length = CPP_WRITTEN (pfile) - name_written;
+      temp = (struct arglist *)
+         xmalloc (sizeof (struct arglist) + length + 1);
+      temp->name = (U_CHAR *) (temp + 1);
+      bcopy ((char *) (pfile->token_buffer + name_written),
+            (char *) temp->name, length);
+      temp->name[length] = 0;
+      temp->next = token_ptrs;
+      token_ptrs = temp;
+      temp->length = length;
+
+      CPP_ADJUST_WRITTEN (pfile, -length); /* pop */
+
+      if (c == EOF || c == '\n')
+        { /* FIXME */
+         cpp_error (pfile,
+                    "unterminated token sequence following  `#' operator");
+         return 0;
+       }
+    }
+
+  /* We accumulated the names in reverse order.
+     Now reverse them to get the proper order.  */
+  return reverse_token_list (token_ptrs);
+}
+
+static void
+free_token_list (tokens)
+     struct arglist *tokens;
+{
+  while (tokens) {
+    struct arglist *next = tokens->next;
+    free (tokens->name);
+    free (tokens);
+    tokens = next;
+  }
+}
+\f
+/* Get the file-mode and data size of the file open on FD
+   and store them in *MODE_POINTER and *SIZE_POINTER.  */
+
+static int
+file_size_and_mode (fd, mode_pointer, size_pointer)
+     int fd;
+     int *mode_pointer;
+     long int *size_pointer;
+{
+  struct stat sbuf;
+
+  if (fstat (fd, &sbuf) < 0) return (-1);
+  if (mode_pointer) *mode_pointer = sbuf.st_mode;
+  if (size_pointer) *size_pointer = sbuf.st_size;
+  return 0;
+}
+
+/* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
+   retrying if necessary.  Return a negative value if an error occurs,
+   otherwise return the actual number of bytes read,
+   which must be LEN unless end-of-file was reached.  */
+
+static int
+safe_read (desc, ptr, len)
+     int desc;
+     char *ptr;
+     int len;
+{
+  int left = len;
+  while (left > 0) {
+    int nchars = read (desc, ptr, left);
+    if (nchars < 0)
+      {
+#ifdef EINTR
+       if (errno == EINTR)
+         continue;
+#endif
+       return nchars;
+      }
+    if (nchars == 0)
+      break;
+    ptr += nchars;
+    left -= nchars;
+  }
+  return len - left;
+}
+
+static char *
+savestring (input)
+     char *input;
+{
+  unsigned size = strlen (input);
+  char *output = xmalloc (size + 1);
+  strcpy (output, input);
+  return output;
+}
+\f
+/* Return the line at which an error occurred.
+   The error is not necessarily associated with the current spot
+   in the input stack, so LINE says where.  LINE will have been
+   copied from ip->lineno for the current input level.
+   If the current level is for a file, we return LINE.
+   But if the current level is not for a file, LINE is meaningless.
+   In that case, we return the lineno of the innermost file.  */
+
+static int
+line_for_error (line)
+     int line;
+{
+#if 0
+  int i;
+  int line1 = line;
+
+  for (i = indepth; i >= 0; ) {
+    if (instack[i].fname != 0)
+      return line1;
+    i--;
+    if (i < 0)
+      return 0;
+    line1 = instack[i].lineno;
+  }
+  abort ();
+  /*NOTREACHED*/
+#endif
+  return 0;
+}
+\f
+/* Initialize PMARK to remember the current position of PFILE. */
+void
+parse_set_mark (pmark, pfile)
+     struct parse_marker *pmark;
+     cpp_reader *pfile;
+{
+  cpp_buffer *pbuf = CPP_BUFFER (pfile);
+  pmark->next = pbuf->marks;
+  pbuf->marks = pmark;
+  pmark->buf = pbuf;
+  pmark->position = pbuf->cur - pbuf->buf;
+}
+
+/* Cleanup PMARK - we no longer need it. */
+void
+parse_clear_mark (pmark)
+     struct parse_marker *pmark;
+{
+  struct parse_marker **pp = &pmark->buf->marks;
+  for (; ; pp = &(*pp)->next) {
+    if (*pp == NULL) fatal ("internal error", "in parse_set_mark");
+    if (*pp == pmark) break;
+  }
+  *pp = pmark->next;
+}
+
+/* Backup the current position of PFILE to that saved in PMARK. */
+
+void
+parse_goto_mark (pmark, pfile)
+     struct parse_marker *pmark;
+     cpp_reader *pfile;
+{
+  cpp_buffer *pbuf = CPP_BUFFER (pfile);
+  if (pbuf != pmark->buf)
+    fatal ("internal error %s", "parse_goto_mark");
+  pbuf->cur = pbuf->buf + pmark->position;
+}
+
+/* Reset PMARK to point to the current position of PFILE.  (Same
+   as parse_clear_mark (PMARK), parse_set_mark (PMARK, PFILE) but faster. */
+
+void
+parse_move_mark (pmark, pfile)
+     struct parse_marker *pmark;
+     cpp_reader *pfile;
+{
+  cpp_buffer *pbuf = CPP_BUFFER (pfile);
+  if (pbuf != pmark->buf)
+    fatal ("internal error %s", "parse_move_mark");
+  pmark->position = pbuf->cur - pbuf->buf;
+}
+
+int
+cpp_read_check_assertion (pfile)
+     cpp_reader *pfile;
+{
+  int name_start = CPP_WRITTEN (pfile);
+  int name_length, name_written;
+  int result;
+  FORWARD (1);  /* Skip '#' */
+  cpp_skip_hspace (pfile);
+  parse_name (pfile, GETC ());
+  name_written = CPP_WRITTEN (pfile);
+  name_length = name_written - name_start;
+  cpp_skip_hspace (pfile);
+  if (CPP_BUF_PEEK (CPP_BUFFER (pfile)) == '(')
+    {
+      int error_flag;
+      struct arglist *token_ptrs = read_token_list (pfile, &error_flag);
+      result = check_assertion (pfile,
+                               pfile->token_buffer + name_start, name_length,
+                               1, token_ptrs);
+    }
+  else
+    result = check_assertion (pfile,
+                             pfile->token_buffer + name_start, name_length,
+                             0, NULL_PTR);
+  CPP_ADJUST_WRITTEN (pfile, - name_length);  /* pop */
+  return result;
+}
+
+/* TODO:
+ * No pre-compiled header file support.
+ *
+ * Possibly different enum token codes for each C/C++ token.
+ *
+ * Better error messages for non-terminated strings and comments.
+ *
+ * Should clean up remaining directives to that do_XXX functions
+ *   only take two arguments and all have command_reads_line.
+ *
+ * Find and cleanup remaining uses of static variables,
+ *
+ * Support for trigraphs.
+ *
+ * Support -dM flag (dump_all_macros).
+ *
+ * -include should be made to returns results incrementally.
+ *    (current implementation only works when cpp is used as main program)
+ *
+ */

diff --git a/gcc/cpplib.h b/gcc/cpplib.h
new file mode 100644 (file)
index 0000000..ae4757a
--- /dev/null
+++ b/gcc/cpplib.h
@@ -0,0 +1,657 @@
+/* Definitions for CPP library.
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Written by Per Bothner, 1994-95.
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ In other words, you are welcome to use, share and improve this program.
+ You are forbidden to forbid anyone else to use, share and improve
+ what you give them.   Help stamp out software-hoarding!  */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define STATIC_BUFFERS
+
+typedef unsigned char U_CHAR;
+
+#ifndef FAILURE_EXIT_CODE
+#define FAILURE_EXIT_CODE 33   /* gnu cc command understands this */
+#endif
+
+#ifndef SUCCESS_EXIT_CODE
+#define SUCCESS_EXIT_CODE 0    /* 0 means success on Unix.  */
+#endif
+
+struct parse_file;
+typedef struct cpp_reader cpp_reader;
+typedef struct cpp_buffer cpp_buffer;
+typedef struct cpp_options cpp_options;
+typedef struct hashnode cpp_hashnode;
+
+enum cpp_token {
+  CPP_EOF = -1,
+  CPP_OTHER = 0,
+  CPP_COMMENT = 1,
+  CPP_HSPACE,
+  CPP_VSPACE, /* newlines and #line directives */
+  CPP_NAME,
+  CPP_NUMBER,
+  CPP_CHAR,
+  CPP_STRING,
+  CPP_DIRECTIVE,
+  CPP_LPAREN,   /* "(" */
+  CPP_RPAREN,   /* ")" */
+  CPP_LBRACE,   /* "{" */
+  CPP_RBRACE,   /* "}" */
+  CPP_COMMA,    /* "," */
+  CPP_SEMICOLON,/* ";" */
+  CPP_3DOTS,    /* "..." */
+#if 0
+  CPP_ANDAND, /* "&&" */
+  CPP_OROR,   /* "||" */
+  CPP_LSH,    /* "<<" */
+  CPP_RSH,    /* ">>" */
+  CPP_EQL,    /* "==" */
+  CPP_NEQ,    /* "!=" */
+  CPP_LEQ,    /* "<=" */
+  CPP_GEQ,    /* ">=" */
+  CPP_PLPL,   /* "++" */
+  CPP_MINMIN, /* "--" */
+#endif
+  /* POP_TOKEN is returned when we've popped a cpp_buffer. */
+  CPP_POP
+};
+
+#ifndef PARAMS
+#ifdef __STDC
+#define PARAMS(P) P
+#else
+#define PARAMS(P) ()
+#endif
+#endif /* !PARAMS */
+
+typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader*));
+typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader*));
+
+/* A parse_marker indicates a previous position,
+   which we can backtrack to. */
+
+struct parse_marker {
+  cpp_buffer *buf;
+  struct parse_marker *next;
+  int position;
+};
+
+extern void parse_set_mark PARAMS ((struct parse_marker*, cpp_reader*));
+extern void parse_clear_mark PARAMS ((struct parse_marker*));
+extern void parse_goto_mark PARAMS((struct parse_marker*, cpp_reader*));
+extern void parse_move_mark PARAMS((struct parse_marker*, cpp_reader*));
+
+extern int cpp_handle_options PARAMS ((cpp_reader*, int, char**));
+extern enum cpp_token cpp_get_token PARAMS ((struct parse_marker*));
+extern void cpp_skip_hspace PARAMS((cpp_reader*));
+extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *));
+
+
+/* Maintain and search list of included files, for #import.  */
+
+#define IMPORT_HASH_SIZE 31
+
+struct import_file {
+  char *name;
+  ino_t inode;
+  dev_t dev;
+  struct import_file *next;
+};
+
+/* If we have a huge buffer, may need to cache more recent counts */
+#define CPP_LINE_BASE(BUF) ((BUF)->buf + (BUF)->line_base)
+
+struct cpp_buffer {
+  unsigned char *buf;
+  unsigned char *cur;
+  unsigned char *rlimit; /* end of valid data */
+  unsigned char *alimit; /* end of allocated buffer */
+  unsigned char *prev;  /* start of current token */
+
+  char *fname;
+  /* Filename specified with #line command.  */
+  char *nominal_fname;
+
+  /* Record where in the search path this file was found.
+     For #include_next.  */
+  struct file_name_list *dir;
+
+  long line_base;
+  long lineno; /* Line number at CPP_LINE_BASE. */
+  long colno; /* Column number at CPP_LINE_BASE. */
+#ifndef STATIC_BUFFERS
+  cpp_buffer *chain;
+#endif
+  parse_underflow_t underflow;
+  parse_cleanup_t cleanup;
+  void *data;
+  struct parse_marker *marks;
+  /* Value of if_stack at start of this file.
+     Used to prohibit unmatched #endif (etc) in an include file.  */
+  struct if_stack *if_stack;
+
+  /* True if this is a header file included using <FILENAME>.  */
+  char system_header_p;
+  char seen_eof;
+
+  /* True if buffer contains escape sequences.
+     Currently there are are only two kind:
+     "@-" means following identifier should not be macro-expanded.
+     "@@" means a normal '@'. */
+  char has_escapes;
+};
+
+struct cpp_pending;  /* Forward declaration - for C++. */
+
+typedef struct assertion_hashnode ASSERTION_HASHNODE;
+#define ASSERTION_HASHSIZE 37
+
+#ifdef STATIC_BUFFERS
+/* Maximum nesting of cpp_buffers.  We use a static limit, partly for
+   efficiency, and partly to limit runaway recursion.  */
+#define CPP_STACK_MAX 200
+#endif
+
+struct cpp_reader {
+  unsigned char *limit;
+  parse_underflow_t get_token;
+  cpp_buffer *buffer;
+#ifdef STATIC_BUFFERS
+  cpp_buffer buffer_stack[CPP_STACK_MAX];
+#endif
+
+  int errors;                  /* Error counter for exit code */
+  /* While scanning a comment or a string constant,
+     this records the line it started on, for error messages.  */
+  int start_line;
+  void *data;
+
+  U_CHAR *token_buffer;
+  int token_buffer_size;
+
+  /* Current depth in #include directives that use <...>.  */
+  int system_include_depth;
+
+  /* List of included files that contained #pragma once.  */
+  struct file_name_list *dont_repeat_files;
+
+  /* List of other included files.
+     If ->control_macro if nonzero, the file had a #ifndef
+     around the entire contents, and ->control_macro gives the macro name.  */
+  struct file_name_list *all_include_files;
+
+  /* Current maximum length of directory names in the search path
+     for include files.  (Altered as we get more of them.)  */
+  int max_include_len;
+
+  /* Hash table of files already included with #include or #import.  */
+  struct import_file *import_hash_table[IMPORT_HASH_SIZE];
+
+  struct if_stack *if_stack;
+
+  /* Nonzero means we are inside an IF during a -pcp run.  In this mode
+     macro expansion is done, and preconditions are output for all macro
+     uses requiring them. */
+  char pcp_inside_if;
+
+  /* Nonzero means we have printed (while error reporting) a list of
+     containing files that matches the current status. */
+  char input_stack_listing_current;
+
+  /* If non-zero, macros are not expanded. */
+  char no_macro_expand;
+
+  /* Print column number in error messages. */
+  char show_column;
+
+  /* We're printed a warning recommending against using #import. */
+  char import_warning;
+
+  /* If true, character between '<' and '>' are a single (string) token. */
+  char parsing_include_directive;
+
+  /* True if escape sequences (as described for has_escapes in
+     parse_buffer) should be emitted. */
+  char output_escapes;
+
+  /* 0: Have seen non-white-space on this line.
+     1: Only seen white space so far on this line.
+     2: Only seen white space so far in this file. */
+   char only_seen_white;
+
+  /* Nonzero means this file was included with a -imacros or -include
+     command line and should not be recorded as an include file.  */
+
+  int no_record_file;
+
+  long lineno;
+
+  struct tm *timebuf;
+
+  ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
+
+  /* Buffer of -M output.  */
+  char *deps_buffer;
+
+  /* Number of bytes allocated in above.  */
+  int deps_allocated_size;
+
+  /* Number of bytes used.  */
+  int deps_size;
+
+  /* Number of bytes since the last newline.  */
+  int deps_column;
+};
+
+#define CPP_BUF_PEEK(BUFFER) \
+  ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF)
+#define CPP_BUF_GET(BUFFER) \
+  ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF)
+#define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N))
+
+/* Number of characters currently in PFILE's output buffer. */
+#define CPP_WRITTEN(PFILE) ((PFILE)->limit - (PFILE)->token_buffer)
+#define CPP_PWRITTEN(PFILE) ((PFILE)->limit)
+
+/* Make sure PFILE->token_buffer has space for at least N more characters. */
+#define CPP_RESERVE(PFILE, N) \
+  (CPP_WRITTEN (PFILE) + N > (PFILE)->token_buffer_size \
+   && (cpp_grow_buffer (PFILE, N), 0))
+
+/* Append string STR (of length N) to PFILE's output buffer.
+   Assume there is enough space. */
+#define CPP_PUTS_Q(PFILE, STR, N) \
+  (bcopy (STR, (PFILE)->limit, (N)), (PFILE)->limit += (N))
+/* Append string STR (of length N) to PFILE's output buffer.  Make space. */
+#define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N)
+/* Append character CH to PFILE's output buffer.  Assume sufficient space. */
+#define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH))
+/* Append character CH to PFILE's output buffer.  Make space if need be. */
+#define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH))
+/* Make sure PFILE->limit is followed by '\0'. */
+#define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0)
+#define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0)
+#define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
+#define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
+
+#define CPP_OPTIONS(PFILE) ((cpp_options*)(PFILE)->data)
+#define CPP_BUFFER(PFILE) ((PFILE)->buffer)
+#ifdef STATIC_BUFFERS
+#define CPP_PREV_BUFFER(BUFFER) ((BUFFER)+1)
+#define CPP_NULL_BUFFER(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX])
+#else
+#define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->chain)
+#define CPP_NULL_BUFFER(PFILE) ((cpp_buffer*)0)
+#endif
+
+/* Pointed to by parse_file::data. */
+struct cpp_options {
+  char *in_fname;
+
+  /* Name of output file, for error messages.  */
+  char *out_fname;
+
+  /* Non-0 means -v, so print the full set of include dirs.  */
+  char verbose;
+
+  /* Nonzero means use extra default include directories for C++.  */
+
+  char cplusplus;
+
+  /* Nonzero means handle cplusplus style comments */
+
+  char cplusplus_comments;
+
+  /* Nonzero means handle #import, for objective C.  */
+
+  char objc;
+
+  /* Nonzero means this is an assembly file, and allow
+     unknown directives, which could be comments.  */
+
+  int lang_asm;
+
+  /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
+
+  char for_lint;
+
+  /* Nonzero means handle CHILL comment syntax
+     and output CHILL string delimeter for __DATE___ etc. */
+
+  char chill;
+
+  /* Nonzero means copy comments into the output file.  */
+
+  char put_out_comments;
+
+  /* Nonzero means don't process the ANSI trigraph sequences.  */
+
+  char no_trigraphs;
+
+  /* Nonzero means print the names of included files rather than
+     the preprocessed output.  1 means just the #include "...",
+     2 means #include <...> as well.  */
+
+  char print_deps;
+
+  /* Nonzero if missing .h files in -M output are assumed to be generated
+     files and not errors.  */
+
+  char print_deps_missing_files;
+
+  /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
+  char print_deps_append;
+
+  /* Nonzero means print names of header files (-H).  */
+
+  char print_include_names;
+
+  /* Nonzero means try to make failure to fit ANSI C an error.  */
+
+  char pedantic_errors;
+
+  /* Nonzero means don't print warning messages.  -w.  */
+
+  char inhibit_warnings;
+
+  /* Nonzero means warn if slash-star appears in a comment.  */
+
+  char warn_comments;
+
+  /* Nonzero means warn if there are any trigraphs.  */
+
+  char warn_trigraphs;
+
+  /* Nonzero means warn if #import is used.  */
+
+  char warn_import;
+
+  /* Nonzero means warn if a macro argument is (or would be)
+     stringified with -traditional.  */
+
+  char warn_stringify;
+
+  /* Nonzero means turn warnings into errors.  */
+
+  char warnings_are_errors;
+
+  /* Nonzero causes output not to be done,
+     but directives such as #define that have side effects
+     are still obeyed.  */
+
+  char no_output;
+
+  /* Nonzero means don't output line number information.  */
+
+  char no_line_commands;
+
+/* Nonzero means output the text in failing conditionals,
+   inside #failed ... #endfailed.  */
+
+  char output_conditionals;
+
+  /* Nonzero means -I- has been seen,
+     so don't look for #include "foo" the source-file directory.  */
+  char ignore_srcdir;
+
+/* Zero means dollar signs are punctuation.
+   -$ stores 0; -traditional may store 1.  Default is 1 for VMS, 0 otherwise.
+   This must be 0 for correct processing of this ANSI C program:
+       #define foo(a) #a
+       #define lose(b) foo (b)
+       #define test$
+       lose (test)     */
+  char dollars_in_ident;
+#ifndef DOLLARS_IN_IDENTIFIERS
+#define DOLLARS_IN_IDENTIFIERS 1
+#endif
+
+  /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
+  char traditional;
+
+  /* Nonzero means give all the error messages the ANSI standard requires.  */
+  char pedantic;
+
+  char done_initializing;
+
+  struct file_name_list *include;      /* First dir to search */
+  /* First dir to search for <file> */
+  /* This is the first element to use for #include <...>.
+     If it is 0, use the entire chain for such includes.  */
+  struct file_name_list *first_bracket_include;
+  /* This is the first element in the chain that corresponds to
+     a directory of system header files.  */
+  struct file_name_list *first_system_include;
+  struct file_name_list *last_include; /* Last in chain */
+
+  /* Chain of include directories to put at the end of the other chain.  */
+  struct file_name_list *after_include;
+  struct file_name_list *last_after_include;   /* Last in chain */
+
+  /* Chain to put at the start of the system include files.  */
+  struct file_name_list *before_system;
+  struct file_name_list *last_before_system;   /* Last in chain */
+
+  /* Directory prefix that should replace `/usr' in the standard
+     include file directories.  */
+  char *include_prefix;
+
+  char inhibit_predefs;
+  char no_standard_includes;
+  char no_standard_cplusplus_includes;
+
+/* dump_only means inhibit output of the preprocessed text
+             and instead output the definitions of all user-defined
+             macros in a form suitable for use as input to cccp.
+   dump_names means pass #define and the macro name through to output.
+   dump_definitions means pass the whole definition (plus #define) through
+*/
+
+  enum {dump_none = 0, dump_only, dump_names, dump_definitions}
+     dump_macros;
+
+/* Nonzero means pass all #define and #undef directives which we actually
+   process through to the output stream.  This feature is used primarily
+   to allow cc1 to record the #defines and #undefs for the sake of
+   debuggers which understand about preprocessor macros, but it may
+   also be useful with -E to figure out how symbols are defined, and
+   where they are defined.  */
+  int debug_output;
+
+  /* Pending -D, -U and -A options, in reverse order. */
+  struct cpp_pending *pending;
+
+  /* File name which deps are being written to.
+     This is 0 if deps are being written to stdout.  */
+  char *deps_file;
+
+  /* Target-name to write with the dependency information.  */
+  char *deps_target;
+};
+
+#define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional)
+#define CPP_PEDANTIC(PFILE) (CPP_OPTIONS (PFILE)->pedantic)
+#define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps)
+
+#define PARSE_GETC(IN) ((IN)-> cur < (IN)->limit || ((IN)->cur = (IN)->token_buffer, (IN)->underflow (IN) != EOF_TOKEN) ? *(IN)->cur++ : EOF)
+
+/* Name under which this program was invoked.  */
+
+extern char *progname;
+
+/* The structure of a node in the hash table.  The hash table
+   has entries for all tokens defined by #define commands (type T_MACRO),
+   plus some special tokens like __LINE__ (these each have their own
+   type, and the appropriate code is run when that type of node is seen.
+   It does not contain control words like "#define", which are recognized
+   by a separate piece of code. */
+
+/* different flavors of hash nodes --- also used in keyword table */
+enum node_type {
+ T_DEFINE = 1, /* the `#define' keyword */
+ T_INCLUDE,    /* the `#include' keyword */
+ T_INCLUDE_NEXT, /* the `#include_next' keyword */
+ T_IMPORT,      /* the `#import' keyword */
+ T_IFDEF,      /* the `#ifdef' keyword */
+ T_IFNDEF,     /* the `#ifndef' keyword */
+ T_IF,         /* the `#if' keyword */
+ T_ELSE,       /* `#else' */
+ T_PRAGMA,     /* `#pragma' */
+ T_ELIF,       /* `#elif' */
+ T_UNDEF,      /* `#undef' */
+ T_LINE,       /* `#line' */
+ T_ERROR,      /* `#error' */
+ T_WARNING,    /* `#warning' */
+ T_ENDIF,      /* `#endif' */
+ T_SCCS,       /* `#sccs', used on system V.  */
+ T_IDENT,      /* `#ident', used on system V.  */
+ T_ASSERT,     /* `#assert', taken from system V.  */
+ T_UNASSERT,   /* `#unassert', taken from system V.  */
+ T_SPECLINE,   /* special symbol `__LINE__' */
+ T_DATE,       /* `__DATE__' */
+ T_FILE,       /* `__FILE__' */
+ T_BASE_FILE,  /* `__BASE_FILE__' */
+ T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
+ T_VERSION,    /* `__VERSION__' */
+ T_SIZE_TYPE,   /* `__SIZE_TYPE__' */
+ T_PTRDIFF_TYPE,   /* `__PTRDIFF_TYPE__' */
+ T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
+ T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
+ T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
+ T_TIME,       /* `__TIME__' */
+ T_CONST,      /* Constant value, used by `__STDC__' */
+ T_MACRO,      /* macro defined by `#define' */
+ T_DISABLED,   /* macro temporarily turned off for rescan */
+ T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
+ T_PCSTRING,   /* precompiled string (hashval is KEYDEF *) */
+ T_UNUSED      /* Used for something not defined.  */
+ };
+
+/* Structure returned by create_definition */
+typedef struct macrodef MACRODEF;
+struct macrodef
+{
+  struct definition *defn;
+  U_CHAR *symnam;
+  int symlen;
+};
+
+/* Structure allocated for every #define.  For a simple replacement
+   such as
+       #define foo bar ,
+   nargs = -1, the `pattern' list is null, and the expansion is just
+   the replacement text.  Nargs = 0 means a functionlike macro with no args,
+   e.g.,
+       #define getchar() getc (stdin) .
+   When there are args, the expansion is the replacement text with the
+   args squashed out, and the reflist is a list describing how to
+   build the output from the input: e.g., "3 chars, then the 1st arg,
+   then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
+   The chars here come from the expansion.  Whatever is left of the
+   expansion after the last arg-occurrence is copied after that arg.
+   Note that the reflist can be arbitrarily long---
+   its length depends on the number of times the arguments appear in
+   the replacement text, not how many args there are.  Example:
+   #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
+   pattern list
+     { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
+   where (x, y) means (nchars, argno). */
+
+typedef struct definition DEFINITION;
+struct definition {
+  int nargs;
+  int length;                  /* length of expansion string */
+  int predefined;              /* True if the macro was builtin or */
+                               /* came from the command line */
+  U_CHAR *expansion;
+  int line;                    /* Line number of definition */
+  char *file;                  /* File of definition */
+  char rest_args;              /* Nonzero if last arg. absorbs the rest */
+  struct reflist {
+    struct reflist *next;
+    char stringify;            /* nonzero if this arg was preceded by a
+                                  # operator. */
+    char raw_before;           /* Nonzero if a ## operator before arg. */
+    char raw_after;            /* Nonzero if a ## operator after arg. */
+    char rest_args;            /* Nonzero if this arg. absorbs the rest */
+    int nchars;                        /* Number of literal chars to copy before
+                                  this arg occurrence.  */
+    int argno;                 /* Number of arg to substitute (origin-0) */
+  } *pattern;
+  union {
+    /* Names of macro args, concatenated in reverse order
+       with comma-space between them.
+       The only use of this is that we warn on redefinition
+       if this differs between the old and new definitions.  */
+    U_CHAR *argnames;
+  } args;
+};
+
+extern U_CHAR is_idchar[256];
+
+/* Stack of conditionals currently in progress
+   (including both successful and failing conditionals).  */
+
+struct if_stack {
+  struct if_stack *next;       /* for chaining to the next stack frame */
+  char *fname;         /* copied from input when frame is made */
+  int lineno;                  /* similarly */
+  int if_succeeded;            /* true if a leg of this if-group
+                                   has been passed through rescan */
+  U_CHAR *control_macro;       /* For #ifndef at start of file,
+                                  this is the macro name tested.  */
+  enum node_type type;         /* type of last directive seen in this group */
+};
+typedef struct if_stack IF_STACK_FRAME;
+
+extern void cpp_buf_line_and_col PARAMS((cpp_buffer*, long*, long*));
+extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader*));
+
+extern void cpp_error ();
+extern void cpp_warning ();
+extern void cpp_pedwarn ();
+extern void cpp_error_with_line ();
+extern void cpp_warning_with_line ();
+extern void cpp_pedwarn_with_line ();
+extern void cpp_pedwarn_with_file_and_line ();
+extern void fatal ();
+extern void cpp_error_from_errno ();
+extern void cpp_perror_with_name ();
+extern void cpp_pfatal_with_name ();
+
+extern void cpp_grow_buffer PARAMS ((cpp_reader*, long));
+extern int cpp_parse_escape PARAMS ((cpp_reader*, char**));
+extern cpp_buffer* cpp_push_buffer PARAMS ((cpp_reader *, U_CHAR*, long));
+extern cpp_buffer* cpp_pop_buffer PARAMS ((cpp_reader *));
+
+extern cpp_hashnode* cpp_lookup PARAMS ((cpp_reader*, const U_CHAR*,
+                                        int, int));
+
+extern long cpp_parse_expr PARAMS ((cpp_reader*));
+
+#ifdef __cplusplus
+}
+#endif

diff --git a/gcc/cppmain.c b/gcc/cppmain.c
new file mode 100644 (file)
index 0000000..3213172
--- /dev/null
+++ b/gcc/cppmain.c
@@ -0,0 +1,102 @@
+/* CPP main program, using CPP Library.
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Written by Per Bothner, 1994-95.
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ In other words, you are welcome to use, share and improve this program.
+ You are forbidden to forbid anyone else to use, share and improve
+ what you give them.   Help stamp out software-hoarding!  */
+
+#include "cpplib.h"
+#include <stdio.h>
+
+extern char *getenv ();
+
+cpp_reader parse_in;
+cpp_options options;
+
+/* More 'friendly' abort that prints the line and file.
+   config.h can #define abort fancy_abort if you like that sort of thing.  */
+
+void
+fancy_abort ()
+{
+  fatal ("Internal gcc abort.");
+}
+
+\f
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  char *p;
+  int i;
+  int argi = 1;  /* Next argument to handle. */
+  struct cpp_options *opts = &options;
+
+  p = argv[0] + strlen (argv[0]);
+  while (p != argv[0] && p[-1] != '/') --p;
+  progname = p;
+
+  init_parse_file (&parse_in);
+  parse_in.data = opts;
+
+  init_parse_options (opts);
+  
+  argi += cpp_handle_options (&parse_in, argc - argi , argv + argi);
+  if (argi < argc)
+    fatal ("Invalid option `%s'", argv[argi]);
+  parse_in.show_column = 1;
+
+  i = push_parse_file (&parse_in, opts->in_fname);
+  if (i != SUCCESS_EXIT_CODE)
+    return i;
+
+  /* Now that we know the input file is valid, open the output.  */
+
+  if (!opts->out_fname || !strcmp (opts->out_fname, ""))
+    opts->out_fname = "stdout";
+  else if (! freopen (opts->out_fname, "w", stdout))
+    cpp_pfatal_with_name (&parse_in, opts->out_fname);
+
+  for (;;)
+    {
+#if 0
+      int ch = PARSE_GETC (&parse_in);
+      if (ch < 0)
+       break;
+      if (! opts->no_output)
+       putchar (ch);
+#else
+      enum cpp_token kind;
+      if (! opts->no_output)
+       {
+         fwrite (parse_in.token_buffer, 1, CPP_WRITTEN (&parse_in), stdout);
+       }
+      parse_in.limit = parse_in.token_buffer;
+      kind = cpp_get_token (&parse_in);
+      if (kind == CPP_EOF)
+       break;
+#endif
+    }
+
+  cpp_finish (&parse_in);
+
+  if (parse_in.errors)
+    exit (FAILURE_EXIT_CODE);
+  exit (SUCCESS_EXIT_CODE);
+}