OSDN Git Service

($(OBJC_O)): Also depend on $(GCC_PASSES).
[pf3gnuchains/gcc-fork.git] / gcc / cccp.c
index b434300..5e13227 100644 (file)
@@ -1,5 +1,5 @@
 /* C Compatible Compiler Preprocessor (CCCP)
-   Copyright (C) 1986, 87, 89, 92, 93, 1994 Free Software Foundation, Inc.
+   Copyright (C) 1986, 87, 89, 92-96, 1997 Free Software Foundation, Inc.
    Written by Paul Rubin, June 1986
    Adapted to ANSI C, Richard Stallman, Jan 1987
 
@@ -15,7 +15,8 @@ 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.
+Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
 
  In other words, you are welcome to use, share and improve this program.
  You are forbidden to forbid anyone else to use, share and improve
@@ -43,82 +44,199 @@ typedef unsigned char U_CHAR;
 #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 "pcp.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>
 
-#ifndef VMS
-#ifndef USG
-#include <sys/time.h>          /* for __DATE__ and __TIME__ */
-#include <sys/resource.h>
+/* The following symbols should be autoconfigured:
+       HAVE_FCNTL_H
+       HAVE_STDLIB_H
+       HAVE_SYS_TIME_H
+       HAVE_UNISTD_H
+       STDC_HEADERS
+       TIME_WITH_SYS_TIME
+   In the mean time, we'll get by with approximations based
+   on existing GCC configuration symbols.  */
+
+#ifdef POSIX
+# ifndef HAVE_STDLIB_H
+# define HAVE_STDLIB_H 1
+# endif
+# ifndef HAVE_UNISTD_H
+# define HAVE_UNISTD_H 1
+# endif
+# ifndef STDC_HEADERS
+# define STDC_HEADERS 1
+# endif
+#endif /* defined (POSIX) */
+
+#if defined (POSIX) || (defined (USG) && !defined (VMS))
+# ifndef HAVE_FCNTL_H
+# define HAVE_FCNTL_H 1
+# endif
+#endif
+
+#ifndef RLIMIT_STACK
+# include <time.h>
 #else
-#include <time.h>
-#include <fcntl.h>
-#endif /* USG */
-#endif /* not VMS */
+# if TIME_WITH_SYS_TIME
+#  include <sys/time.h>
+#  include <time.h>
+# else
+#  if HAVE_SYS_TIME_H
+#   include <sys/time.h>
+#  else
+#   include <time.h>
+#  endif
+# endif
+# include <sys/resource.h>
+#endif
+
+#if HAVE_FCNTL_H
+# include <fcntl.h>
+#endif
 
-/* This defines "errno" properly for VMS, and gives us EACCES. */
 #include <errno.h>
 
+#if HAVE_STDLIB_H
+# include <stdlib.h>
+#else
+char *getenv ();
+#endif
+
+#if STDC_HEADERS
+# include <string.h>
+# ifndef bcmp
+# define bcmp(a, b, n) memcmp (a, b, n)
+# endif
+# ifndef bcopy
+# define bcopy(s, d, n) memcpy (d, s, n)
+# endif
+# ifndef bzero
+# define bzero(d, n) memset (d, 0, n)
+# endif
+#else /* !STDC_HEADERS */
+char *index ();
+char *rindex ();
+
+# if !defined (BSTRING) && (defined (USG) || defined (VMS))
+
+#  ifndef bcmp
+#  define bcmp my_bcmp
+static int
+my_bcmp (a, b, n)
+     register char *a;
+     register char *b;
+     register unsigned n;
+{
+   while (n-- > 0)
+     if (*a++ != *b++)
+       return 1;
+
+   return 0;
+}
+#  endif /* !defined (bcmp) */
+
+#  ifndef bcopy
+#  define bcopy my_bcopy
+static void
+my_bcopy (s, d, n)
+     register char *s;
+     register char *d;
+     register unsigned n;
+{
+  while (n-- > 0)
+    *d++ = *s++;
+}
+#  endif /* !defined (bcopy) */
+
+#  ifndef bzero
+#  define bzero my_bzero
+static void
+my_bzero (b, length)
+     register char *b;
+     register unsigned length;
+{
+  while (length-- > 0)
+    *b++ = 0;
+}
+#  endif /* !defined (bzero) */
+
+# endif /* !defined (BSTRING) && (defined (USG) || defined (VMS)) */
+#endif /* ! STDC_HEADERS */
+
+#if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
+# define __attribute__(x)
+#endif
+
+#ifndef PROTO
+# if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+#  define PROTO(ARGS) ARGS
+# else
+#  define PROTO(ARGS) ()
+# endif
+#endif
+
+#if defined (__STDC__) && defined (HAVE_VPRINTF)
+# include <stdarg.h>
+# define VA_START(va_list, var) va_start (va_list, var)
+# define PRINTF_ALIST(msg) char *msg, ...
+# define PRINTF_DCL(msg)
+# define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (__printf__, m, n)))
+#else
+# include <varargs.h>
+# define VA_START(va_list, var) va_start (va_list)
+# define PRINTF_ALIST(msg) msg, va_alist
+# define PRINTF_DCL(msg) char *msg; va_dcl
+# define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (__printf__, m, n)))
+# define vfprintf(file, msg, args) \
+    { \
+      char *a0 = va_arg(args, char *); \
+      char *a1 = va_arg(args, char *); \
+      char *a2 = va_arg(args, char *); \
+      char *a3 = va_arg(args, char *); \
+      fprintf (file, msg, a0, a1, a2, a3); \
+    }
+#endif
+
+#define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
+#define PRINTF_PROTO_2(ARGS) PRINTF_PROTO(ARGS, 2, 3)
+#define PRINTF_PROTO_3(ARGS) PRINTF_PROTO(ARGS, 3, 4)
+
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
 /* VMS-specific definitions */
 #ifdef VMS
-#include <time.h>
 #include <descrip.h>
-#define O_RDONLY       0       /* Open arg for Read/Only  */
-#define O_WRONLY       1       /* Open arg for Write/Only */
-#define read(fd,buf,size)      VMS_read (fd,buf,size)
-#define write(fd,buf,size)     VMS_write (fd,buf,size)
 #define open(fname,mode,prot)  VMS_open (fname,mode,prot)
 #define fopen(fname,mode)      VMS_fopen (fname,mode)
 #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
-#define strncat(dst,src,cnt) VMS_strncat (dst,src,cnt)
-static char * VMS_strncat ();
-static int VMS_read ();
-static int VMS_write ();
+#define fstat(fd,stbuf)                VMS_fstat (fd,stbuf)
+static int VMS_fstat (), VMS_stat ();
 static int VMS_open ();
 static FILE * VMS_fopen ();
 static FILE * VMS_freopen ();
 static void hack_vms_include_specification ();
-typedef struct { unsigned :16, :16, :16; } vms_ino_t;
-#define ino_t vms_ino_t
-#define INCLUDE_LEN_FUDGE 10   /* leave room for VMS syntax conversion */
-#ifdef __GNUC__
-#define BSTRING                        /* VMS/GCC supplies the bstring routines */
-#endif /* __GNUC__ */
+#define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
+#define INO_T_HASH(a) 0
+#define INCLUDE_LEN_FUDGE 12   /* leave room for VMS syntax conversion */
 #endif /* VMS */
-  
-extern char *index ();
-extern char *rindex ();
+
+/* Windows does not natively support inodes */
+#if defined (_WIN32) && ! defined (CYGWIN32)
+#define INO_T_EQ(a, b) 0
+#endif
 
 #ifndef O_RDONLY
 #define O_RDONLY 0
@@ -129,7 +247,8 @@ extern char *rindex ();
 #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.  */
+/* Find the largest host integer type and set its size and type.
+   Don't blindly use `long'; on some crazy hosts it is shorter than `int'.  */
 
 #ifndef HOST_BITS_PER_WIDE_INT
 
@@ -151,6 +270,14 @@ extern char *rindex ();
 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 #endif
 
+#ifndef INO_T_EQ
+#define INO_T_EQ(a, b) ((a) == (b))
+#endif
+
+#ifndef INO_T_HASH
+#define INO_T_HASH(a) (a)
+#endif
+
 /* Define a generic NULL if one hasn't already been defined.  */
 
 #ifndef NULL
@@ -166,179 +293,37 @@ extern char *rindex ();
 #endif
 
 #ifndef NULL_PTR
-#define NULL_PTR ((GENERIC_PTR)0)
+#define NULL_PTR ((GENERIC_PTR) 0)
 #endif
 
 #ifndef INCLUDE_LEN_FUDGE
 #define INCLUDE_LEN_FUDGE 0
 #endif
 
-/* Forward declarations.  */
-
-char *xmalloc ();
-void error ();
-void warning ();
-
 /* External declarations.  */
 
-extern char *getenv ();
-extern FILE *fdopen ();
 extern char *version_string;
-extern struct tm *localtime ();
 #ifndef VMS
 #ifndef HAVE_STRERROR
 extern int sys_nerr;
-#if defined(bsd4_4) || defined(__NetBSD__)
+#if defined(bsd4_4)
 extern const char *const sys_errlist[];
 #else
 extern char *sys_errlist[];
 #endif
-#else  /* HAVE_STERRROR */
+#else  /* HAVE_STRERROR */
 char *strerror ();
 #endif
 #else  /* VMS */
 char *strerror (int,...);
 #endif
-extern int parse_escape ();
-extern HOST_WIDE_INT parse_c_expression ();
+HOST_WIDE_INT parse_escape PROTO((char **, HOST_WIDE_INT));
+HOST_WIDE_INT parse_c_expression PROTO((char *));
 
 #ifndef errno
 extern int errno;
 #endif
-
-/* Forward declarations.  */
-
-struct directive;
-struct file_buf;
-struct arglist;
-struct argdata;
-
-#if defined(USG) || defined(VMS)
-#ifndef BSTRING
-void bcopy ();
-void bzero ();
-int bcmp ();
-#endif
-#endif
-
-/* 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 ();
-
-static void add_import ();
-static void append_include_chain ();
-static void deps_output ();
-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 ();
-static void delete_macro ();
-static void trigraph_pcp ();
-static void rescan ();
-static void finclude ();
-static void validate_else ();
-static int comp_def_part ();
-static void error_from_errno ();
-static void error_with_line ();
-void pedwarn ();
-void pedwarn_with_line ();
-static void pedwarn_with_file_and_line ();
-static void fatal ();
-void fancy_abort ();
-static void pfatal_with_name ();
-static void perror_with_name ();
-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 void write_output ();
-static int check_macro_name ();
-static int compare_defs ();
-static int compare_token_lists ();
-static HOST_WIDE_INT eval_if_expression ();
-static int discard_comments ();
-static int change_newlines ();
-static int line_for_error ();
-static int hashf ();
-static int file_size_and_mode ();
-
-static struct arglist *read_token_list ();
-static void free_token_list ();
-
-static struct hashnode *install ();
-struct hashnode *lookup ();
-
-static struct assertion_hashnode *assertion_install ();
-static struct assertion_hashnode *assertion_lookup ();
-
-static char *xrealloc ();
-static char *xcalloc ();
-static char *savestring ();
-
-static void delete_assertion ();
-static void macroexpand ();
-static void dump_all_macros ();
-static void conditional_skip ();
-static void skip_if_group ();
-static void output_line_command ();
-
-/* Last arg to output_line_command.  */
-enum file_change_code {same_file, enter_file, leave_file};
-
-static int grow_outbuf ();
-static int handle_directive ();
-static void memory_full ();
-
-static U_CHAR *macarg1 ();
-static char *macarg ();
-
-static U_CHAR *skip_to_end_of_comment ();
-static U_CHAR *skip_quoted_string ();
-static U_CHAR *skip_paren_group ();
-static char *quote_string ();
-
-static char *check_precompiled ();
-/* static struct macrodef create_definition ();        [moved below] */
-static void dump_single_macro ();
-static void output_dots ();
 \f
-#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
-
 /* Name under which this program was invoked.  */
 
 static char *progname;
@@ -394,7 +379,7 @@ static int print_include_names = 0;
 
 /* Nonzero means don't output line number information.  */
 
-static int no_line_commands;
+static int no_line_directives;
 
 /* Nonzero means output the text in failing conditionals,
    inside #failed ... #endfailed.  */
@@ -434,7 +419,7 @@ static FILE *pcp_outfile;
 
 /* 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. */
+   uses requiring them.  */
 static int pcp_inside_if;
 
 /* Nonzero means never to include precompiled files.
@@ -454,7 +439,8 @@ static int pedantic_errors;
 
 static int inhibit_warnings = 0;
 
-/* Nonzero means warn if slash-star appears in a comment.  */
+/* Nonzero means warn if slash-star appears in a slash-star comment,
+   or if newline-backslash appears in a slash-slash comment.  */
 
 static int warn_comments;
 
@@ -467,6 +453,10 @@ static int warn_stringify;
 
 static int warn_trigraphs;
 
+/* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
+
+int warn_undef;
+
 /* Nonzero means warn if #import is used.  */
 
 static int warn_import = 1;
@@ -479,6 +469,10 @@ static int warnings_are_errors;
 
 int traditional;
 
+/* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
+
+int c89;
+
 /* Nonzero causes output not to be done,
    but directives such as #define that have side effects
    are still obeyed.  */
@@ -508,8 +502,10 @@ static int multiline_string_line = 0;
 #define INPUT_STACK_MAX 400
 static struct file_buf {
   char *fname;
-  /* Filename specified with #line command.  */
+  /* Filename specified with #line directive.  */
   char *nominal_fname;
+  /* Include file description.  */
+  struct include_file *inc;
   /* Record where in the search path this file was found.
      For #include_next.  */
   struct file_name_list *dir;
@@ -551,7 +547,7 @@ typedef struct file_buf FILE_BUF;
 
 /* The output buffer.  Its LENGTH field is the amount of room allocated
    for the buffer, not the number of chars actually present.  To get
-   that, subtract outbuf.buf from outbuf.bufp. */
+   that, subtract outbuf.buf from outbuf.bufp.  */
 
 #define OUTBUF_SIZE 10 /* initial size of output buffer */
 static FILE_BUF outbuf;
@@ -566,22 +562,24 @@ static FILE_BUF outbuf;
 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
+    /* If the following is 1, 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;
+    /* The include directory status.  */
+    struct stat st;
+    /* The include prefix: "" denotes the working directory,
+       otherwise fname must end in '/'.
+       The actual size is dynamically allocated.  */
+    char fname[1];
   };
 
-/* #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. */
+/* #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.  */
@@ -596,6 +594,7 @@ static struct default_include {
   = {
     /* Pick up GNU C++ specific include files.  */
     { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
+    { OLD_GPLUSPLUS_INCLUDE_DIR, 1, 1 },
 #ifdef CROSS_COMPILE
     /* This is the dir for fixincludes.  Put it just before
        the files that we fix.  */
@@ -603,15 +602,21 @@ static struct default_include {
     /* For cross-compilation, this dir name is generated
        automatically in Makefile.in.  */
     { CROSS_INCLUDE_DIR, 0, 0 },
+#ifdef TOOL_INCLUDE_DIR
     /* This is another place that the target system's headers might be.  */
-    { TOOL_INCLUDE_DIR, 0, 1 },
+    { TOOL_INCLUDE_DIR, 0, 0 },
+#endif
 #else /* not CROSS_COMPILE */
+#ifdef LOCAL_INCLUDE_DIR
     /* This should be /usr/local/include and should come before
        the fixincludes-fixed header files.  */
     { LOCAL_INCLUDE_DIR, 0, 1 },
+#endif
+#ifdef TOOL_INCLUDE_DIR
     /* 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 },
+    { TOOL_INCLUDE_DIR, 0, 0 },
+#endif
     /* This is the dir for fixincludes.  Put it just before
        the files that we fix.  */
     { GCC_INCLUDE_DIR, 0, 0 },
@@ -648,18 +653,33 @@ static struct file_name_list *last_after_include = 0;     /* Last in chain */
 static struct file_name_list *before_system = 0;
 static struct file_name_list *last_before_system = 0;  /* Last in chain */
 
-/* List of included files that contained #pragma once.  */
-static struct file_name_list *dont_repeat_files = 0;
-
-/* 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.  */
-static struct file_name_list *all_include_files = 0;
-
 /* Directory prefix that should replace `/usr' in the standard
    include file directories.  */
 static char *include_prefix;
 
+/* Maintain and search list of included files.  */
+
+struct include_file {
+  struct include_file *next; /* for include_hashtab */
+  struct include_file *next_ino; /* for include_ino_hashtab */
+  char *fname;
+  /* If the following is the empty string, it means #pragma once
+     was seen in this include file, or #import was applied to the file.
+     Otherwise, if it is nonzero, it is a macro name.
+     Don't include the file again if that macro is defined.  */
+  U_CHAR *control_macro;
+  /* Nonzero if the dependency on this include file has been output.  */
+  int deps_output;
+  struct stat st;
+};
+
+/* Hash tables of files already included with #include or #import.
+   include_hashtab is by full name; include_ino_hashtab is by inode number.  */
+
+#define INCLUDE_HASHSIZE 61
+static struct include_file *include_hashtab[INCLUDE_HASHSIZE];
+static struct include_file *include_ino_hashtab[INCLUDE_HASHSIZE];
+
 /* Global list of strings read in from precompiled files.  This list
    is kept in the order the strings are read in, with new strings being
    added at the end through stringlist_tailp.  We use this list to output
@@ -677,10 +697,17 @@ struct macrodef
   U_CHAR *symnam;
   int symlen;
 };
+\f
+enum sharp_token_type {
+  NO_SHARP_TOKEN = 0,          /* token not present */
 
-static struct macrodef create_definition ();
+  SHARP_TOKEN = '#',           /* token spelled with # only */
+  WHITE_SHARP_TOKEN,           /* token spelled with # and white space */
+
+  PERCENT_COLON_TOKEN = '%',   /* token spelled with %: only */
+  WHITE_PERCENT_COLON_TOKEN    /* token spelled with %: and white space */
+};
 
-\f
 /* Structure allocated for every #define.  For a simple replacement
    such as
        #define foo bar ,
@@ -700,7 +727,7 @@ static struct macrodef create_definition ();
    #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). */
+   where (x, y) means (nchars, argno).  */
 
 typedef struct definition DEFINITION;
 struct definition {
@@ -714,10 +741,11 @@ struct 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. */
+
+    enum sharp_token_type stringify;   /* set if a # operator before arg */
+    enum sharp_token_type raw_before;  /* set if a ## operator before arg */
+    enum sharp_token_type raw_after;   /* set 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.  */
@@ -733,9 +761,8 @@ struct definition {
 };
 
 /* different kinds of things that can appear in the value field
-   of a hash node.  Actually, this may be useless now. */
+   of a hash node.  Actually, this may be useless now.  */
 union hashval {
-  int ival;
   char *cpval;
   DEFINITION *defn;
   KEYDEF *keydef;
@@ -757,11 +784,11 @@ static char rest_extension[] = "...";
 #define REST_EXTENSION_LENGTH  (sizeof (rest_extension) - 1)
 
 /* The structure of a node in the hash table.  The hash table
-   has entries for all tokens defined by #define commands (type T_MACRO),
+   has entries for all tokens defined by #define directives (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. */
+   by a separate piece of code.  */
 
 /* different flavors of hash nodes --- also used in keyword table */
 enum node_type {
@@ -795,6 +822,7 @@ enum node_type {
  T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
  T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
  T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
+ T_IMMEDIATE_PREFIX_TYPE,  /* `__IMMEDIATE_PREFIX__' */
  T_TIME,       /* `__TIME__' */
  T_CONST,      /* Constant value, used by `__STDC__' */
  T_MACRO,      /* macro defined by `#define' */
@@ -809,7 +837,7 @@ struct hashnode {
   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. */
+                                  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 */
@@ -823,7 +851,7 @@ typedef struct hashnode HASHNODE;
    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. */
+   politeness, for use when speed isn't so important.  */
 
 #define HASHSIZE 1403
 static HASHNODE *hashtab[HASHSIZE];
@@ -875,6 +903,12 @@ char * wchar_type = WCHAR_TYPE;
 #ifndef REGISTER_PREFIX
 #define REGISTER_PREFIX ""
 #endif
+
+/* The string value for __IMMEDIATE_PREFIX__ */
+
+#ifndef IMMEDIATE_PREFIX
+#define IMMEDIATE_PREFIX ""
+#endif
 \f
 /* In the definition of a #assert name, this structure forms
    a list of the individual values asserted.
@@ -891,7 +925,7 @@ struct assertion_hashnode {
   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. */
+     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 */
@@ -906,7 +940,7 @@ typedef struct assertion_hashnode ASSERTION_HASHNODE;
    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. */
+   politeness, for use when speed isn't so important.  */
 
 #define ASSERTION_HASHSIZE 37
 static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
@@ -917,20 +951,47 @@ static int assertions_flag;
 \f
 /* `struct directive' defines one #-directive, including how to handle it.  */
 
+#define DO_PROTO PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *))
+
 struct directive {
   int length;                  /* Length of name */
-  int (*func)();               /* Function to handle directive */
+  int (*func) DO_PROTO;        /* Function to handle directive */
   char *name;                  /* Name of directive */
-  enum node_type type;         /* Code which describes which directive. */
+  enum node_type type;         /* Code which describes which directive.  */
   char angle_brackets;         /* Nonzero => <...> is special.  */
   char traditional_comments;   /* Nonzero: keep comments if -traditional.  */
-  char pass_thru;              /* Copy preprocessed directive to output file.  */
+  char pass_thru;              /* Copy directive to output:
+                                  if 1, copy if dumping definitions;
+                                  if 2, always copy, after preprocessing.  */
 };
 
+/* These functions are declared to return int instead of void since they
+   are going to be placed in the table and some old compilers have trouble with
+   pointers to functions returning void.  */
+
+static int do_assert DO_PROTO;
+static int do_define DO_PROTO;
+static int do_elif DO_PROTO;
+static int do_else DO_PROTO;
+static int do_endif DO_PROTO;
+static int do_error DO_PROTO;
+static int do_ident DO_PROTO;
+static int do_if DO_PROTO;
+static int do_include DO_PROTO;
+static int do_line DO_PROTO;
+static int do_pragma DO_PROTO;
+#ifdef SCCS_DIRECTIVE
+static int do_sccs DO_PROTO;
+#endif
+static int do_unassert DO_PROTO;
+static int do_undef DO_PROTO;
+static int do_warning DO_PROTO;
+static int do_xifdef DO_PROTO;
+
 /* Here is the actual list of #-directives, most-often-used first.  */
 
 static struct directive directive_table[] = {
-  {  6, do_define, "define", T_DEFINE, 0, 1},
+  {  6, do_define, "define", T_DEFINE, 0, 1, 1},
   {  2, do_if, "if", T_IF},
   {  5, do_xifdef, "ifdef", T_IFDEF},
   {  6, do_xifdef, "ifndef", T_IFNDEF},
@@ -947,7 +1008,7 @@ static struct directive directive_table[] = {
 #ifdef SCCS_DIRECTIVE
   {  4, do_sccs, "sccs", T_SCCS},
 #endif
-  {  6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
+  {  6, do_pragma, "pragma", T_PRAGMA, 0, 0, 2},
   {  5, do_ident, "ident", T_IDENT},
   {  6, do_assert, "assert", T_ASSERT},
   {  8, do_unassert, "unassert", T_UNASSERT},
@@ -955,17 +1016,19 @@ static struct directive directive_table[] = {
 };
 
 /* When a directive handler is called,
-   this points to the # that started the directive.  */
+   this points to the # (or the : of the %:) that started the directive.  */
 U_CHAR *directive_start;
 
-/* table to tell if char can be part of a C identifier. */
+/* 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. */
+/* 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];
+static U_CHAR is_hor_space[256];
 /* table to tell if c is horizontal or vertical space.  */
-static U_CHAR is_space[256];
+U_CHAR is_space[256];
+/* names of some characters */
+static char *char_name[256];
 
 #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)
@@ -975,21 +1038,6 @@ static int errors = 0;                    /* Error counter for exit code */
 /* Name of output file, for error messages.  */
 static char *out_fname;
 
-/* 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)     */
-static int dollars_in_ident;
-#ifndef DOLLARS_IN_IDENTIFIERS
-#define DOLLARS_IN_IDENTIFIERS 1
-#endif
-
-static FILE_BUF expand_to_temp_buffer ();
-
-static DEFINITION *collect_expansion ();
 
 /* Stack of conditionals currently in progress
    (including both successful and failing conditionals).  */
@@ -1023,8 +1071,154 @@ static int deps_column;
    so don't look for #include "foo" the source-file directory.  */
 static int ignore_srcdir;
 \f
+static int safe_read PROTO((int, char *, int));
+static void safe_write PROTO((int, char *, int));
+
+int main PROTO((int, char **));
+
+static void path_include PROTO((char *));
+
+static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
+
+static void trigraph_pcp PROTO((FILE_BUF *));
+
+static void newline_fix PROTO((U_CHAR *));
+static void name_newline_fix PROTO((U_CHAR *));
+
+static char *get_lintcmd PROTO((U_CHAR *, U_CHAR *, U_CHAR **, int *, int *));
+
+static void rescan PROTO((FILE_BUF *, int));
+
+static FILE_BUF expand_to_temp_buffer PROTO((U_CHAR *, U_CHAR *, int, int));
+
+static int handle_directive PROTO((FILE_BUF *, FILE_BUF *));
+
+static struct tm *timestamp PROTO((void));
+static void special_symbol PROTO((HASHNODE *, FILE_BUF *));
+
+static int is_system_include PROTO((char *));
+static char *base_name PROTO((char *));
+static int absolute_filename PROTO((char *));
+static size_t simplify_filename PROTO((char *));
+
+static char *read_filename_string PROTO((int, FILE *));
+static struct file_name_map *read_name_map PROTO((char *));
+static int open_include_file PROTO((char *, struct file_name_list *, U_CHAR *, struct include_file **));
+static char *remap_include_file PROTO((char *, struct file_name_list *));
+static int lookup_ino_include PROTO((struct include_file *));
+
+static void finclude PROTO((int, struct include_file *, FILE_BUF *, int, struct file_name_list *));
+static void record_control_macro PROTO((struct include_file *, U_CHAR *));
+
+static char *check_precompiled PROTO((int, struct stat *, char *, char **));
+static int check_preconditions PROTO((char *));
+static void pcfinclude PROTO((U_CHAR *, U_CHAR *, U_CHAR *, FILE_BUF *));
+static void pcstring_used PROTO((HASHNODE *));
+static void write_output PROTO((void));
+static void pass_thru_directive PROTO((U_CHAR *, U_CHAR *, FILE_BUF *, struct directive *));
+
+static MACRODEF create_definition PROTO((U_CHAR *, U_CHAR *, FILE_BUF *));
+
+static int check_macro_name PROTO((U_CHAR *, char *));
+static int compare_defs PROTO((DEFINITION *, DEFINITION *));
+static int comp_def_part PROTO((int, U_CHAR *, int, U_CHAR *, int, int));
+
+static DEFINITION *collect_expansion  PROTO((U_CHAR *, U_CHAR *, int, struct arglist *));
+
+int check_assertion PROTO((U_CHAR *, int, int, struct arglist *));
+static int compare_token_lists PROTO((struct arglist *, struct arglist *));
+
+static struct arglist *read_token_list PROTO((U_CHAR **, U_CHAR *, int *));
+static void free_token_list PROTO((struct arglist *));
+
+static ASSERTION_HASHNODE *assertion_install PROTO((U_CHAR *, int, int));
+static ASSERTION_HASHNODE *assertion_lookup PROTO((U_CHAR *, int, int));
+static void delete_assertion PROTO((ASSERTION_HASHNODE *));
+
+static void do_once PROTO((void));
+
+static HOST_WIDE_INT eval_if_expression PROTO((U_CHAR *, int));
+static void conditional_skip PROTO((FILE_BUF *, int, enum node_type, U_CHAR *, FILE_BUF *));
+static void skip_if_group PROTO((FILE_BUF *, int, FILE_BUF *));
+static void validate_else PROTO((U_CHAR *, U_CHAR *));
+
+static U_CHAR *skip_to_end_of_comment PROTO((FILE_BUF *, int *, int));
+static U_CHAR *skip_quoted_string PROTO((U_CHAR *, U_CHAR *, int, int *, int *, int *));
+static char *quote_string PROTO((char *, char *));
+static U_CHAR *skip_paren_group PROTO((FILE_BUF *));
+
+/* Last arg to output_line_directive.  */
+enum file_change_code {same_file, enter_file, leave_file};
+static void output_line_directive PROTO((FILE_BUF *, FILE_BUF *, int, enum file_change_code));
+
+static void macroexpand PROTO((HASHNODE *, FILE_BUF *));
+
+struct argdata;
+static char *macarg PROTO((struct argdata *, int));
+
+static U_CHAR *macarg1 PROTO((U_CHAR *, U_CHAR *, int *, int *, int *, int));
+
+static int discard_comments PROTO((U_CHAR *, int, int));
+
+static int change_newlines PROTO((U_CHAR *, int));
+
+char *my_strerror PROTO((int));
+void error PRINTF_PROTO_1((char *, ...));
+static void verror PROTO((char *, va_list));
+static void error_from_errno PROTO((char *));
+void warning PRINTF_PROTO_1((char *, ...));
+static void vwarning PROTO((char *, va_list));
+static void error_with_line PRINTF_PROTO_2((int, char *, ...));
+static void verror_with_line PROTO((int, char *, va_list));
+static void vwarning_with_line PROTO((int, char *, va_list));
+static void warning_with_line PRINTF_PROTO_2((int, char *, ...));
+void pedwarn PRINTF_PROTO_1((char *, ...));
+void pedwarn_with_line PRINTF_PROTO_2((int, char *, ...));
+static void pedwarn_with_file_and_line PRINTF_PROTO_3((char *, int, char *, ...));
+
+static void print_containing_files PROTO((void));
+
+static int line_for_error PROTO((int));
+static int grow_outbuf PROTO((FILE_BUF *, int));
+
+static HASHNODE *install PROTO((U_CHAR *, int, enum node_type, char *, int));
+HASHNODE *lookup PROTO((U_CHAR *, int, int));
+static void delete_macro PROTO((HASHNODE *));
+static int hashf PROTO((U_CHAR *, int, int));
+
+static void dump_single_macro PROTO((HASHNODE *, FILE *));
+static void dump_all_macros PROTO((void));
+static void dump_defn_1 PROTO((U_CHAR *, int, int, FILE *));
+static void dump_arg_n PROTO((DEFINITION *, int, FILE *));
+
+static void initialize_char_syntax PROTO((void));
+static void initialize_builtins PROTO((FILE_BUF *, FILE_BUF *));
+
+static void make_definition PROTO((char *, FILE_BUF *));
+static void make_undef PROTO((char *, FILE_BUF *));
+
+static void make_assertion PROTO((char *, char *));
+
+static struct file_name_list *new_include_prefix PROTO((struct file_name_list *, char *, char *));
+static void append_include_chain PROTO((struct file_name_list *, struct file_name_list *));
+
+static void deps_output PROTO((char *, int));
+
+static void fatal PRINTF_PROTO_1((char *, ...)) __attribute__ ((noreturn));
+void fancy_abort PROTO((void)) __attribute__ ((noreturn));
+static void perror_with_name PROTO((char *));
+static void pfatal_with_name PROTO((char *)) __attribute__ ((noreturn));
+static void pipe_closed PROTO((int)) __attribute__ ((noreturn));
+
+static void memory_full PROTO((void)) __attribute__ ((noreturn));
+GENERIC_PTR xmalloc PROTO((size_t));
+static GENERIC_PTR xrealloc PROTO((GENERIC_PTR, size_t));
+static GENERIC_PTR xcalloc PROTO((size_t, size_t));
+static char *savestring PROTO((char *));
+\f
 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
-   retrying if necessary.  Return a negative value if an error occurs,
+   retrying if necessary.  If MAX_READ_LEN is defined, read at most
+   that bytes at a time.  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.  */
 
@@ -1034,9 +1228,16 @@ safe_read (desc, ptr, len)
      char *ptr;
      int len;
 {
-  int left = len;
+  int left, rcount, nchars;
+
+  left = len;
   while (left > 0) {
-    int nchars = read (desc, ptr, left);
+    rcount = left;
+#ifdef MAX_READ_LEN
+    if (rcount > MAX_READ_LEN)
+      rcount = MAX_READ_LEN;
+#endif
+    nchars = read (desc, ptr, rcount);
     if (nchars < 0)
       {
 #ifdef EINTR
@@ -1054,7 +1255,8 @@ safe_read (desc, ptr, len)
 }
 
 /* Write LEN bytes at PTR to descriptor DESC,
-   retrying if necessary, and treating any real error as fatal.  */
+   retrying if necessary, and treating any real error as fatal.
+   If MAX_WRITE_LEN is defined, write at most that many bytes at a time.  */
 
 static void
 safe_write (desc, ptr, len)
@@ -1062,8 +1264,15 @@ safe_write (desc, ptr, len)
      char *ptr;
      int len;
 {
+  int wcount, written;
+
   while (len > 0) {
-    int written = write (desc, ptr, len);
+    wcount = len;
+#ifdef MAX_WRITE_LEN
+    if (wcount > MAX_WRITE_LEN)
+      wcount = MAX_WRITE_LEN;
+#endif
+    written = write (desc, ptr, wcount);
     if (written < 0)
       {
 #ifdef EINTR
@@ -1082,10 +1291,9 @@ main (argc, argv)
      int argc;
      char **argv;
 {
-  int st_mode;
-  long st_size;
+  struct stat st;
   char *in_fname;
-  char *p;
+  char *cp;
   int f, i;
   FILE_BUF *fp;
   char **pend_files = (char **) xmalloc (argc * sizeof (char *));
@@ -1124,7 +1332,7 @@ main (argc, argv)
     struct rlimit rlim;
 
     /* Set the stack limit huge so that alloca (particularly stringtab
-     * in dbxread.c) does not fail. */
+       in dbxread.c) does not fail.  */
     getrlimit (RLIMIT_STACK, &rlim);
     rlim.rlim_cur = rlim.rlim_max;
     setrlimit (RLIMIT_STACK, &rlim);
@@ -1135,45 +1343,36 @@ main (argc, argv)
   signal (SIGPIPE, pipe_closed);
 #endif
 
-  p = argv[0] + strlen (argv[0]);
-  while (p != argv[0] && p[-1] != '/'
-#ifdef DIR_SEPARATOR
-        && p[-1] != DIR_SEPARATOR
-#endif
-        )
-    --p;
-  progname = p;
+  progname = base_name (argv[0]);
 
 #ifdef VMS
   {
-    /* Remove directories from PROGNAME.  */
-    char *s;
-
-    progname = savestring (argv[0]);
-
-    if (!(s = rindex (progname, ']')))
-      s = rindex (progname, ':');
-    if (s)
-      strcpy (progname, s+1);
-    if (s = rindex (progname, '.'))
-      *s = '\0';
+    /* Remove extension from PROGNAME.  */
+    char *p;
+    char *s = progname = savestring (progname);
+
+    if ((p = rindex (s, ';')) != 0) *p = '\0'; /* strip version number */
+    if ((p = rindex (s, '.')) != 0             /* strip type iff ".exe" */
+       && (p[1] == 'e' || p[1] == 'E')
+       && (p[2] == 'x' || p[2] == 'X')
+       && (p[3] == 'e' || p[3] == 'E')
+       && !p[4])
+      *p = '\0';
   }
 #endif
 
   in_fname = NULL;
   out_fname = NULL;
 
-  /* Initialize is_idchar to allow $.  */
-  dollars_in_ident = 1;
+  /* Initialize is_idchar.  */
   initialize_char_syntax ();
-  dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
 
-  no_line_commands = 0;
+  no_line_directives = 0;
   no_trigraphs = 1;
   dump_macros = dump_none;
   no_output = 0;
   cplusplus = 0;
-  cplusplus_comments = 0;
+  cplusplus_comments = 1;
 
   bzero ((char *) pend_files, argc * sizeof (char *));
   bzero ((char *) pend_defs, argc * sizeof (char *));
@@ -1199,13 +1398,13 @@ main (argc, argv)
          if (i + 1 == argc)
            fatal ("Filename missing after `-include' option");
          else
-           pend_includes[i] = argv[i+1], i++;
+           simplify_filename (pend_includes[i] = argv[++i]);
        }
        if (!strcmp (argv[i], "-imacros")) {
          if (i + 1 == argc)
            fatal ("Filename missing after `-imacros' option");
          else
-           pend_files[i] = argv[i+1], i++;
+           simplify_filename (pend_files[i] = argv[++i]);
        }
        if (!strcmp (argv[i], "-iprefix")) {
          if (i + 1 == argc)
@@ -1219,17 +1418,9 @@ main (argc, argv)
        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;
+         if (! (dirtmp = new_include_prefix (NULL_PTR, "", argv[++i])))
+           break;
          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 (before_system == 0)
            before_system = dirtmp;
@@ -1252,19 +1443,8 @@ main (argc, argv)
              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 (! (dirtmp = new_include_prefix (NULL_PTR, prefix, argv[++i])))
+           break;
 
          if (after_include == 0)
            after_include = dirtmp;
@@ -1287,36 +1467,15 @@ main (argc, argv)
              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;
-
+         dirtmp = new_include_prefix (NULL_PTR, prefix, argv[++i]);
          append_include_chain (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 (! (dirtmp = new_include_prefix (NULL_PTR, "", argv[++i])))
+           break;
 
          if (after_include == 0)
            after_include = dirtmp;
@@ -1347,10 +1506,10 @@ main (argc, argv)
          if (i + 1 == argc)
            fatal ("Filename missing after -pcp option");
          pcp_fname = argv[++i];
-         pcp_outfile = 
-           ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
-            ? fopen (pcp_fname, "w")
-            : fdopen (dup (fileno (stdout)), "w"));
+         pcp_outfile
+           ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
+              ? fopen (pcp_fname, "w")
+              : stdout);
          if (pcp_outfile == 0)
            pfatal_with_name (pcp_fname);
          no_precomp = 1;
@@ -1360,8 +1519,7 @@ main (argc, argv)
       case 't':
        if (!strcmp (argv[i], "-traditional")) {
          traditional = 1;
-         if (dollars_in_ident > 0)
-           dollars_in_ident = 1;
+         cplusplus_comments = 0;
        } else if (!strcmp (argv[i], "-trigraphs")) {
          no_trigraphs = 0;
        }
@@ -1369,15 +1527,15 @@ main (argc, argv)
 
       case 'l':
        if (! strcmp (argv[i], "-lang-c"))
-         cplusplus = 0, cplusplus_comments = 0, objc = 0;
+         cplusplus = 0, cplusplus_comments = 1, c89 = 0, objc = 0;
+       if (! strcmp (argv[i], "-lang-c89"))
+         cplusplus = 0, cplusplus_comments = 0, c89 = 1, objc = 0;
        if (! strcmp (argv[i], "-lang-c++"))
-         cplusplus = 1, cplusplus_comments = 1, objc = 0;
-       if (! strcmp (argv[i], "-lang-c-c++-comments"))
-         cplusplus = 0, cplusplus_comments = 1, objc = 0;
+         cplusplus = 1, cplusplus_comments = 1, c89 = 0, objc = 0;
        if (! strcmp (argv[i], "-lang-objc"))
-         objc = 1, cplusplus = 0, cplusplus_comments = 1;
+         cplusplus = 0, cplusplus_comments = 1, c89 = 0, objc = 1;
        if (! strcmp (argv[i], "-lang-objc++"))
-         objc = 1, cplusplus = 1, cplusplus_comments = 1;
+         cplusplus = 1, cplusplus_comments = 1, c89 = 0, objc = 1;
        if (! strcmp (argv[i], "-lang-asm"))
          lang_asm = 1;
        if (! strcmp (argv[i], "-lint"))
@@ -1409,6 +1567,10 @@ main (argc, argv)
          warn_stringify = 1;
        else if (!strcmp (argv[i], "-Wno-traditional"))
          warn_stringify = 0;
+       else if (!strcmp (argv[i], "-Wundef"))
+         warn_undef = 1;
+       else if (!strcmp (argv[i], "-Wno-undef"))
+         warn_undef = 0;
        else if (!strcmp (argv[i], "-Wimport"))
          warn_import = 1;
        else if (!strcmp (argv[i], "-Wno-import"))
@@ -1470,7 +1632,7 @@ main (argc, argv)
        {
          char *p = argv[i] + 2;
          char c;
-         while (c = *p++) {
+         while ((c = *p++)) {
            /* Arg to -d specifies what parts of macros to dump */
            switch (c) {
            case 'M':
@@ -1559,11 +1721,11 @@ main (argc, argv)
        break;
 
       case 'P':
-       no_line_commands = 1;
+       no_line_directives = 1;
        break;
 
       case '$':                        /* Don't include $ in identifiers.  */
-       dollars_in_ident = 0;
+       is_idchar['$'] = is_idstart['$'] = 0;
        break;
 
       case 'I':                        /* Add directory to path for includes.  */
@@ -1576,18 +1738,8 @@ main (argc, argv)
            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;
+           dirtmp = new_include_prefix (last_include, "",
+                                        argv[i][2] ? argv[i] + 2 : argv[++i]);
            append_include_chain (dirtmp, dirtmp);
          }
        }
@@ -1632,16 +1784,9 @@ main (argc, argv)
   /* Some people say that CPATH should replace the standard include dirs,
      but that seems pointless: it comes before them, so it overrides them
      anyway.  */
-#ifdef WINNT
-  p = (char *) getenv ("Include");
-#else
-  p = (char *) getenv ("CPATH");
-#endif
-  if (p != 0 && ! no_standard_includes)
-    path_include (p);
-
-  /* Now that dollars_in_ident is known, initialize is_idchar.  */
-  initialize_char_syntax ();
+  cp = getenv ("CPATH");
+  if (cp && ! no_standard_includes)
+    path_include (cp);
 
   /* Initialize output buffer */
 
@@ -1685,7 +1830,7 @@ main (argc, argv)
        if (*p != 0)
          *p++= 0;
        if (debug_output)
-         output_line_command (fp, &outbuf, 0, same_file);
+         output_line_directive (fp, &outbuf, 0, same_file);
        make_definition (q, &outbuf);
        while (*p == ' ' || *p == '\t')
          p++;
@@ -1745,12 +1890,12 @@ main (argc, argv)
   for (i = 1; i < argc; i++) {
     if (pend_undefs[i]) {
       if (debug_output)
-        output_line_command (fp, &outbuf, 0, same_file);
+        output_line_directive (fp, &outbuf, 0, same_file);
       make_undef (pend_undefs[i], &outbuf);
     }
     if (pend_defs[i]) {
       if (debug_output)
-        output_line_command (fp, &outbuf, 0, same_file);
+        output_line_directive (fp, &outbuf, 0, same_file);
       make_definition (pend_defs[i], &outbuf);
     }
     if (pend_assertions[i])
@@ -1759,8 +1904,8 @@ main (argc, argv)
 
   done_initializing = 1;
 
-  { /* read the appropriate environment variable and if it exists
-       replace include_defaults with the listed path. */
+  { /* Read the appropriate environment variable and if it exists
+       replace include_defaults with the listed path.  */
     char *epath = 0;
     switch ((objc << 1) + cplusplus)
       {
@@ -1780,7 +1925,6 @@ main (argc, argv)
     /* 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;
 
@@ -1794,30 +1938,19 @@ main (argc, argv)
       startp = endp = epath;
       num_dirs = 0;
       while (1) {
-        /* Handle cases like c:/usr/lib:d:/gcc/lib */
-        if ((*endp == PATH_SEPARATOR
-#if 0 /* Obsolete, now that we use semicolons as the path separator.  */
-#ifdef __MSDOS__
-            && (endp-startp != 1 || !isalpha (*startp))
-#endif
-#endif
-            )
-            || *endp == 0) {
-         strncpy (nstore, startp, endp-startp);
-         if (endp == startp)
-           strcpy (nstore, ".");
-         else
-           nstore[endp-startp] = '\0';
-
-         include_defaults[num_dirs].fname = savestring (nstore);
+       char c = *endp++;
+       if (c == PATH_SEPARATOR || !c) {
+         endp[-1] = 0;
+         include_defaults[num_dirs].fname
+           = startp == endp ? "." : savestring (startp);
+         endp[-1] = c;
          include_defaults[num_dirs].cplusplus = cplusplus;
          include_defaults[num_dirs].cxx_aware = 1;
          num_dirs++;
-         if (*endp == '\0')
+         if (!c)
            break;
-         endp = startp = endp + 1;
-       } else
-         endp++;
+         startp = endp;
+       }
       }
       /* Put the usual defaults back in at the end.  */
       bcopy ((char *) include_defaults_array,
@@ -1851,18 +1984,14 @@ main (argc, argv)
          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 (new, new);
-           if (first_system_include == 0)
-             first_system_include = new;
+             = new_include_prefix (NULL_PTR, specd_prefix,
+                                   p->fname + default_len);
+           if (new) {
+             new->c_system_include_path = !p->cxx_aware;
+             append_include_chain (new, new);
+             if (first_system_include == 0)
+               first_system_include = new;
+           }
          }
        }
       }
@@ -1871,14 +2000,13 @@ main (argc, argv)
       /* Some standard dirs are only for C++.  */
       if (!p->cplusplus || (cplusplus && !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 (new, new);
-       if (first_system_include == 0)
-         first_system_include = new;
+         = new_include_prefix (NULL_PTR, "", p->fname);
+       if (new) {
+         new->c_system_include_path = !p->cxx_aware;
+         append_include_chain (new, new);
+         if (first_system_include == 0)
+           first_system_include = new;
+       }
       }
     }
   }
@@ -1895,37 +2023,17 @@ main (argc, argv)
     for (p = include; p; p = p->next) {
       if (p == first_bracket_include)
        fprintf (stderr, "#include <...> search starts here:\n");
-      fprintf (stderr, " %s\n", p->fname);
+      if (!p->fname[0])
+       fprintf (stderr, " .\n");
+      else if (!strcmp (p->fname, "/") || !strcmp (p->fname, "//"))
+       fprintf (stderr, " %s\n", p->fname);
+      else
+       /* Omit trailing '/'.  */
+       fprintf (stderr, " %.*s\n", (int) strlen (p->fname) - 1, 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.  */
-
-  no_output++; no_record_file++;
-  for (i = 1; i < argc; i++)
-    if (pend_files[i]) {
-      int fd = open (pend_files[i], O_RDONLY, 0666);
-      if (fd < 0) {
-       perror_with_name (pend_files[i]);
-       return FAILURE_EXIT_CODE;
-      }
-      finclude (fd, pend_files[i], &outbuf, 0, NULL_PTR);
-    }
-  no_output--; no_record_file--;
-
-  /* Copy the entire contents of the main input file into
-     the stacked input buffer previously allocated for it.  */
-
-  /* JF check for stdin */
-  if (in_fname == NULL || *in_fname == 0) {
-    in_fname = "";
-    f = 0;
-  } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
-    goto perror;
-
   /* -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.  */
@@ -1957,7 +2065,7 @@ main (argc, argv)
     while (*s != 0 && *s != ' ') s++;
     if (*s != 0) {
       deps_target = s + 1;
-      output_file = (char *) xmalloc (s - spec + 1);
+      output_file = xmalloc (s - spec + 1);
       bcopy (spec, output_file, s - spec);
       output_file[s - spec] = 0;
     }
@@ -1974,7 +2082,7 @@ main (argc, argv)
      as the target of this Make-rule.  */
   if (print_deps) {
     deps_allocated_size = 200;
-    deps_buffer = (char *) xmalloc (deps_allocated_size);
+    deps_buffer = xmalloc (deps_allocated_size);
     deps_buffer[0] = 0;
     deps_size = 0;
     deps_column = 0;
@@ -1987,15 +2095,7 @@ main (argc, argv)
       char *p, *q;
       int len;
 
-      /* Discard all directory prefixes from filename.  */
-      if ((q = rindex (in_fname, '/')) != NULL
-#ifdef DIR_SEPARATOR
-         && (q = rindex (in_fname, DIR_SEPARATOR)) != NULL
-#endif
-         )
-       ++q;
-      else
-       q = in_fname;
+      q = base_name (in_fname);
 
       /* Copy remainder to mungable area.  */
       p = (char *) alloca (strlen(q) + 8);
@@ -2038,12 +2138,40 @@ main (argc, argv)
     }
   }
 
-  file_size_and_mode (f, &st_mode, &st_size);
+  /* Scan the -imacros files before the main input.
+     Much like #including them, but with no_output set
+     so that only their macro definitions matter.  */
+
+  no_output++; no_record_file++;
+  for (i = 1; i < argc; i++)
+    if (pend_files[i]) {
+      struct include_file *inc;
+      int fd = open_include_file (pend_files[i], NULL_PTR, NULL_PTR, &inc);
+      if (fd < 0) {
+       perror_with_name (pend_files[i]);
+       return FATAL_EXIT_CODE;
+      }
+      finclude (fd, inc, &outbuf, 0, NULL_PTR);
+    }
+  no_output--; no_record_file--;
+
+  /* Copy the entire contents of the main input file into
+     the stacked input buffer previously allocated for it.  */
+
+  /* JF check for stdin */
+  if (in_fname == NULL || *in_fname == 0) {
+    in_fname = "";
+    f = 0;
+  } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
+    goto perror;
+
+  if (fstat (f, &st) != 0)
+    pfatal_with_name (in_fname);
   fp->nominal_fname = fp->fname = in_fname;
   fp->lineno = 1;
   fp->system_header_p = 0;
   /* JF all this is mine about reading pipes and ttys */
-  if (! S_ISREG (st_mode)) {
+  if (! S_ISREG (st.st_mode)) {
     /* Read input from a file that is not a normal disk file.
        We cannot preallocate a buffer with the correct size,
        so we must read in the file a piece at the time and make it bigger.  */
@@ -2051,11 +2179,14 @@ main (argc, argv)
     int bsize;
     int cnt;
 
+    if (S_ISDIR (st.st_mode))
+      fatal ("Input file `%s' is a directory", in_fname);
+
     bsize = 2000;
     size = 0;
     fp->buf = (U_CHAR *) xmalloc (bsize + 2);
     for (;;) {
-      cnt = safe_read (f, fp->buf + size, bsize - size);
+      cnt = safe_read (f, (char *) fp->buf + size, bsize - size);
       if (cnt < 0) goto perror;        /* error! */
       size += cnt;
       if (size != bsize) break;        /* End of file */
@@ -2065,9 +2196,9 @@ main (argc, argv)
     fp->length = size;
   } else {
     /* Read a file whose size we can determine in advance.
-       For the sake of VMS, st_size is just an upper bound.  */
-    fp->buf = (U_CHAR *) xmalloc (st_size + 2);
-    fp->length = safe_read (f, fp->buf, st_size);
+       For the sake of VMS, st.st_size is just an upper bound.  */
+    fp->buf = (U_CHAR *) xmalloc (st.st_size + 2);
+    fp->length = safe_read (f, (char *) fp->buf, st.st_size);
     if (fp->length < 0) goto perror;
   }
   fp->bufp = fp->buf;
@@ -2095,19 +2226,20 @@ main (argc, argv)
   else if (! freopen (out_fname, "w", stdout))
     pfatal_with_name (out_fname);
 
-  output_line_command (fp, &outbuf, 0, same_file);
+  output_line_directive (fp, &outbuf, 0, same_file);
 
   /* Scan the -include files before the main input.  */
 
   no_record_file++;
   for (i = 1; i < argc; i++)
     if (pend_includes[i]) {
-      int fd = open (pend_includes[i], O_RDONLY, 0666);
+      struct include_file *inc;
+      int fd = open_include_file (pend_includes[i], NULL_PTR, NULL_PTR, &inc);
       if (fd < 0) {
        perror_with_name (pend_includes[i]);
-       return FAILURE_EXIT_CODE;
+       return FATAL_EXIT_CODE;
       }
-      finclude (fd, pend_includes[i], &outbuf, 0, NULL_PTR);
+      finclude (fd, inc, &outbuf, 0, NULL_PTR);
     }
   no_record_file--;
 
@@ -2152,7 +2284,7 @@ main (argc, argv)
     fatal ("I/O error on output");
 
   if (errors)
-    exit (FAILURE_EXIT_CODE);
+    exit (FATAL_EXIT_CODE);
   exit (SUCCESS_EXIT_CODE);
 
  perror:
@@ -2174,38 +2306,22 @@ path_include (path)
   if (*p)
     while (1) {
       char *q = p;
-      char *name;
+      char c;
       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;
-      }
+      while ((c = *q++) != PATH_SEPARATOR && c)
+       continue;
 
-      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;
+      q[-1] = 0;
+      dirtmp = new_include_prefix (last_include, "", p == q ? "." : p);
+      q[-1] = c;
       append_include_chain (dirtmp, dirtmp);
 
       /* Advance past this name.  */
       p = q;
-      if (*p == 0)
+      if (! c)
        break;
-      /* Skip the colon.  */
-      p++;
     }
 }
 \f
@@ -2219,18 +2335,19 @@ static U_CHAR *
 index0 (s, c, n)
      U_CHAR *s;
      int c;
-     int n;
+     size_t n;
 {
+  char *p = (char *) s;
   for (;;) {
-    char *q = index (s, c);
+    char *q = index (p, c);
     if (q)
       return (U_CHAR *) q;
     else {
-      int l = strlen (s);
+      size_t l = strlen (p);
       if (l == n)
        return 0;
       l++;
-      s += l;
+      p += l;
       n -= l;
     }
   }
@@ -2243,7 +2360,7 @@ index0 (s, c, n)
    Using an extra pass through the buffer takes a little extra time,
    but is infinitely less hairy than trying to handle trigraphs inside
    strings, etc. everywhere, and also makes sure that trigraphs are
-   only translated in the top level of processing. */
+   only translated in the top level of processing.  */
 
 static void
 trigraph_pcp (buf)
@@ -2254,7 +2371,7 @@ trigraph_pcp (buf)
 
   fptr = bptr = sptr = buf->buf;
   lptr = fptr + buf->length;
-  while ((sptr = (U_CHAR *) index0 (sptr, '?', lptr - sptr)) != NULL) {
+  while ((sptr = index0 (sptr, '?', (size_t) (lptr - sptr))) != NULL) {
     if (*++sptr != '?')
       continue;
     switch (*++sptr) {
@@ -2294,7 +2411,7 @@ trigraph_pcp (buf)
     len = sptr - fptr - 2;
 
     /* BSD doc says bcopy () works right for overlapping strings.  In ANSI
-       C, this will be memmove (). */
+       C, this will be memmove ().  */
     if (bptr != fptr && len > 0)
       bcopy ((char *) fptr, (char *) bptr, len);
 
@@ -2308,7 +2425,8 @@ trigraph_pcp (buf)
   buf->length -= fptr - bptr;
   buf->buf[buf->length] = '\0';
   if (warn_trigraphs && fptr != bptr)
-    warning ("%d trigraph(s) encountered", (fptr - bptr) / 2);
+    warning_with_line (0, "%lu trigraph(s) encountered",
+                      (unsigned long) (fptr - bptr) / 2);
 }
 \f
 /* Move all backslash-newline pairs out of embarrassing places.
@@ -2388,8 +2506,7 @@ name_newline_fix (bp)
 
    Upon return, any arg will be pointed to with argstart and will be
    arglen long.  Note that we don't parse that arg since it will just
-   be printed out again.
-*/
+   be printed out again.  */
 
 static char *
 get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
@@ -2398,7 +2515,7 @@ get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
      U_CHAR **argstart;                /* point to command arg */
      int *arglen, *cmdlen;     /* how long they are */
 {
-  long linsize;
+  HOST_WIDE_INT linsize;
   register U_CHAR *numptr;     /* temp for arg parsing */
 
   *arglen = 0;
@@ -2410,19 +2527,19 @@ get_lintcmd (ibp, limit, argstart, arglen, cmdlen)
   linsize = limit - ibp;
   
   /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */
-  if ((linsize >= 10) && !strncmp (ibp, "NOTREACHED", 10)) {
+  if ((linsize >= 10) && !bcmp (ibp, "NOTREACHED", 10)) {
     *cmdlen = 10;
     return "NOTREACHED";
   }
-  if ((linsize >= 8) && !strncmp (ibp, "ARGSUSED", 8)) {
+  if ((linsize >= 8) && !bcmp (ibp, "ARGSUSED", 8)) {
     *cmdlen = 8;
     return "ARGSUSED";
   }
-  if ((linsize >= 11) && !strncmp (ibp, "LINTLIBRARY", 11)) {
+  if ((linsize >= 11) && !bcmp (ibp, "LINTLIBRARY", 11)) {
     *cmdlen = 11;
     return "LINTLIBRARY";
   }
-  if ((linsize >= 7) && !strncmp (ibp, "VARARGS", 7)) {
+  if ((linsize >= 7) && !bcmp (ibp, "VARARGS", 7)) {
     *cmdlen = 7;
     ibp += 7; linsize -= 7;
     if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS";
@@ -2576,9 +2693,24 @@ do { ip = &instack[indepth];             \
        *obp++ = *ibp++;
       break;
 
+    case '%':
+      if (ident_length || ip->macro || traditional)
+       goto randomchar;
+      while (*ibp == '\\' && ibp[1] == '\n') {
+       ibp += 2;
+       ++ip->lineno;
+      }
+      if (*ibp != ':')
+       break;
+      /* Treat this %: digraph as if it were #.  */
+      /* Fall through.  */
+
     case '#':
       if (assertions_flag) {
+       if (ident_length)
+         goto specialchar;
        /* Copy #foo (bar lose) without macro expansion.  */
+       obp[-1] = '#';  /* In case it was '%'.  */
        SKIP_WHITE_SPACE (ibp);
        while (is_idchar[*ibp])
          *obp++ = *ibp++;
@@ -2590,17 +2722,22 @@ do { ip = &instack[indepth];            \
          obp += ip->bufp - ibp;
          ibp = ip->bufp;
        }
+       break;
       }
 
       /* If this is expanding a macro definition, don't recognize
-        preprocessor directives.  */
+        preprocessing directives.  */
       if (ip->macro != 0)
        goto randomchar;
-      /* If this is expand_into_temp_buffer, recognize them
+      /* If this is expand_into_temp_buffer,
+        don't recognize them either.  Warn about 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)
+      if (! ip->fname) {
+       if (ip->buf != beg_of_line)
+         warning ("preprocessing directive not recognized within macro arg");
        goto randomchar;
+      }
       if (ident_length)
        goto specialchar;
 
@@ -2616,7 +2753,7 @@ do { ip = &instack[indepth];              \
           If not, this # is not special.  */
        bp = beg_of_line;
        /* If -traditional, require # to be at beginning of line.  */
-       if (!traditional)
+       if (!traditional) {
          while (1) {
            if (is_hor_space[*bp])
              bp++;
@@ -2633,6 +2770,18 @@ do { ip = &instack[indepth];             \
               comment and we would never reach here.  */
            else break;
          }
+         if (c == '%') {
+           if (bp[0] != '%')
+             break;
+           while (bp[1] == '\\' && bp[2] == '\n')
+             bp += 2;
+           if (bp + 1 != ibp)
+             break;
+           /* %: appears at start of line; skip past the ':' too.  */
+           bp++;
+           ibp++;
+         }
+       }
        if (bp + 1 != ibp)
          goto randomchar;
       }
@@ -2658,7 +2807,7 @@ do { ip = &instack[indepth];              \
          beg_of_line = ibp;
          break;
        }
-       ++obp;          /* Copy the '#' after all */
+       *obp++ = '#';   /* Copy # (even if it was originally %:).  */
        /* Don't expand an identifier that could be a macro directive.
           (Section 3.8.3 of the ANSI C standard)                       */
        SKIP_WHITE_SPACE (ibp);
@@ -2688,7 +2837,10 @@ do { ip = &instack[indepth];             \
       /* A single quoted string is treated like a double -- some
         programs (e.g., troff) are perverse this way */
 
-      if (ident_length)
+      /* Handle any pending identifier;
+        but the L in L'...' or L"..." is not an identifier.  */
+      if (ident_length
+         && ! (ident_length == 1 && hash == HASHSTEP (0, 'L')))
        goto specialchar;
 
       start_line = ip->lineno;
@@ -2730,12 +2882,12 @@ do { ip = &instack[indepth];            \
                             "unterminated character constant");
            goto while2end;
          }
-         if (pedantic && multiline_string_line == 0) {
-           pedwarn_with_line (line_for_error (start_line),
-                              "string constant runs past end of line");
-         }
-         if (multiline_string_line == 0)
+         if (multiline_string_line == 0) {
+           if (pedantic)
+             pedwarn_with_line (line_for_error (start_line),
+                                "string constant runs past end of line");
            multiline_string_line = ip->lineno - 1;
+         }
          break;
 
        case '\\':
@@ -2781,41 +2933,34 @@ do { ip = &instack[indepth];            \
        goto specialchar;
 
       if (*ibp == '/') {
-       /* C++ style comment... */
+       /* C++ style comment...  */
        start_line = ip->lineno;
 
-       --ibp;                  /* Back over the slash */
-       --obp;
-
-       /* Comments are equivalent to spaces. */
+       /* Comments are equivalent to spaces.  */
        if (! put_out_comments)
-         *obp++ = ' ';
-       else {
-         /* must fake up a comment here */
-         *obp++ = '/';
-         *obp++ = '/';
-       }
-       {
-         U_CHAR *before_bp = ibp+2;
+         obp[-1] = ' ';
 
-         while (ibp < limit) {
-           if (ibp[-1] != '\\' && *ibp == '\n') {
-             if (put_out_comments) {
-               bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
-               obp += ibp - before_bp;
-             }
-             break;
-           } else {
-             if (*ibp == '\n') {
-               ++ip->lineno;
-               /* Copy the newline into the output buffer, in order to
-                  avoid the pain of a #line every time a multiline comment
-                  is seen.  */
-               if (!put_out_comments)
-                 *obp++ = '\n';
-               ++op->lineno;
+       {
+         U_CHAR *before_bp = ibp;
+
+         while (++ibp < limit) {
+           if (*ibp == '\n') {
+             if (ibp[-1] != '\\') {
+               if (put_out_comments) {
+                 bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
+                 obp += ibp - before_bp;
+               }
+               break;
              }
-             ibp++;
+             if (warn_comments)
+               warning ("multiline `//' comment");
+             ++ip->lineno;
+             /* Copy the newline into the output buffer, in order to
+                avoid the pain of a #line every time a multiline comment
+                is seen.  */
+             if (!put_out_comments)
+               *obp++ = '\n';
+             ++op->lineno;
            }
          }
          break;
@@ -2826,7 +2971,7 @@ do { ip = &instack[indepth];              \
 
       start_line = ip->lineno;
 
-      ++ibp;                   /* Skip the star. */
+      ++ibp;                   /* Skip the star.  */
 
       /* If this cpp is for lint, we peek inside the comments: */
       if (for_lint) {
@@ -2855,7 +3000,7 @@ do { ip = &instack[indepth];              \
             this branch.  We need #line because the #pragma's newline always
             messes up the line count.  */
          op->bufp = obp;
-         output_line_command (ip, op, 0, same_file);
+         output_line_directive (ip, op, 0, same_file);
          check_expand (op, limit - ibp + 2);
          obp = op->bufp;
          *(obp++) = '/';
@@ -2877,18 +3022,17 @@ do { ip = &instack[indepth];            \
       {
        U_CHAR *before_bp = ibp;
 
-       while (ibp < limit) {
+       for (;;) {
          switch (*ibp++) {
-         case '/':
-           if (warn_comments && ibp < limit && *ibp == '*')
-             warning ("`/*' within comment");
-           break;
          case '*':
+           if (ibp[-2] == '/' && warn_comments)
+             warning ("`/*' within comment");
            if (*ibp == '\\' && ibp[1] == '\n')
              newline_fix (ibp);
-           if (ibp >= limit || *ibp == '/')
+           if (*ibp == '/')
              goto comment_end;
            break;
+
          case '\n':
            ++ip->lineno;
            /* Copy the newline into the output buffer, in order to
@@ -2897,26 +3041,32 @@ do { ip = &instack[indepth];            \
            if (!put_out_comments)
              *obp++ = '\n';
            ++op->lineno;
+           break;
+
+         case 0:
+           if (limit < ibp) {
+             error_with_line (line_for_error (start_line),
+                              "unterminated comment");
+             goto limit_reached;
+           }
+           break;
          }
        }
       comment_end:
 
-       if (ibp >= limit)
-         error_with_line (line_for_error (start_line),
-                          "unterminated comment");
-       else {
-         ibp++;
-         if (put_out_comments) {
-           bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
-           obp += ibp - before_bp;
-         }
+       ibp++;
+       if (put_out_comments) {
+         bcopy ((char *) before_bp, (char *) obp, ibp - before_bp);
+         obp += ibp - before_bp;
        }
       }
       break;
 
     case '$':
-      if (!dollars_in_ident)
+      if (! is_idchar['$'])
        goto randomchar;
+      if (pedantic)
+       pedwarn ("`$' in identifier");
       goto letter;
 
     case '0': case '1': case '2': case '3': case '4':
@@ -2928,30 +3078,29 @@ do { ip = &instack[indepth];            \
         as an identifier.  Periods also, for sake of "3.e7".  */
 
       if (ident_length == 0) {
-       while (ibp < limit) {
-         while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
+       for (;;) {
+         while (ibp[0] == '\\' && ibp[1] == '\n') {
            ++ip->lineno;
            ibp += 2;
          }
          c = *ibp++;
-         /* ".." terminates a preprocessing number.  This is useless for C
-            code but useful for preprocessing other things.  */
-         if (!isalnum (c) && (c != '.' || *ibp == '.') && c != '_') {
+         if (!is_idchar[c] && c != '.') {
            --ibp;
            break;
          }
          *obp++ = c;
          /* A sign can be part of a preprocessing number
-            if it follows an e.  */
-         if (c == 'e' || c == 'E') {
-           while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') {
+            if it follows an `e' or `p'.  */
+         if (c == 'e' || c == 'E' || c == 'p' || c == 'P') {
+           while (ibp[0] == '\\' && ibp[1] == '\n') {
              ++ip->lineno;
              ibp += 2;
            }
-           if (ibp < limit && (*ibp == '+' || *ibp == '-')) {
+           if (*ibp == '+' || *ibp == '-') {
              *obp++ = *ibp++;
-             /* But traditional C does not let the token go past the sign.  */
-             if (traditional)
+             /* But traditional C does not let the token go past the sign,
+                and C89 does not allow `p'.  */
+             if (traditional || (c89 && (c == 'p' || c == 'P')))
                break;
            }
          }
@@ -3037,7 +3186,7 @@ do { ip = &instack[indepth];              \
       ++op->lineno;
       if (ip->lineno != op->lineno) {
        op->bufp = obp;
-       output_line_command (ip, op, 1, same_file);
+       output_line_directive (ip, op, 1, same_file);
        check_expand (op, limit - ibp);
        obp = op->bufp;
       }
@@ -3050,6 +3199,7 @@ do { ip = &instack[indepth];              \
        /* Our input really contains a null character.  */
        goto randomchar;
 
+    limit_reached:
       /* At end of a macro-expansion level, pop it and read next level.  */
       if (ip->macro != 0) {
        obp--;
@@ -3117,7 +3267,6 @@ randomchar:
           backed over.  OBP-IDENT_LENGTH points to the identifier.  */
 
        if (!pcp_outfile || pcp_inside_if) {
-startagain:
          for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
               hp = hp->next) {
            
@@ -3206,7 +3355,7 @@ startagain:
                      old_oln = op->lineno;
                    }
                    /* A comment: copy it unchanged or discard it.  */
-                   else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') {
+                   else if (*ibp == '/' && ibp[1] == '*') {
                      if (put_out_comments) {
                        *obp++ = '/';
                        *obp++ = '*';
@@ -3276,21 +3425,33 @@ startagain:
              
              /* This is now known to be a macro call.
                 Discard the macro name from the output,
-                along with any following whitespace just copied.  */
+                along with any following whitespace just copied,
+                but preserve newlines if not outputting marks since this
+                is more likely to do the right thing with line numbers.  */
              obp = op->buf + obufp_before_macroname;
-             op->lineno = op_lineno_before_macroname;
+             if (output_marks)
+               op->lineno = op_lineno_before_macroname;
+             else {
+               int newlines = op->lineno - op_lineno_before_macroname;
+               while (0 < newlines--)
+                 *obp++ = '\n';
+             }
 
              /* Prevent accidental token-pasting with a character
                 before the macro call.  */
-             if (!traditional && obp != op->buf
-                 && (obp[-1] == '-' || obp[1] == '+' || obp[1] == '&'
-                     || obp[-1] == '|' || obp[1] == '<' || obp[1] == '>')) {
-               /* If we are expanding a macro arg, make a newline marker
-                  to separate the tokens.  If we are making real output,
-                  a plain space will do.  */
-               if (output_marks)
-                 *obp++ = '\n';
-               *obp++ = ' ';
+             if (!traditional && obp != op->buf) {
+               switch (obp[-1]) {
+               case '!':  case '%':  case '&':  case '*':
+               case '+':  case '-':  case '.':  case '/':
+               case ':':  case '<':  case '=':  case '>':
+               case '^':  case '|':
+                 /* If we are expanding a macro arg, make a newline marker
+                    to separate the tokens.  If we are making real output,
+                    a plain space will do.  */
+                 if (output_marks)
+                   *obp++ = '\n';
+                 *obp++ = ' ';
+               }
              }
 
              /* Expand the macro, reading arguments as needed,
@@ -3321,7 +3482,7 @@ hashcollision:
  ending:
   if (if_stack != ip->if_stack)
     {
-      char *str = "unknown";
+      char *str;
 
       switch (if_stack->type)
        {
@@ -3340,6 +3501,8 @@ hashcollision:
        case T_ELIF:
          str = "elif";
          break;
+       default:
+         abort ();
        }
 
       error_with_line (line_for_error (if_stack->lineno),
@@ -3401,6 +3564,7 @@ expand_to_temp_buffer (buf, limit, output_marks, assertions)
   ip = &instack[indepth];
   ip->fname = 0;
   ip->nominal_fname = 0;
+  ip->inc = 0;
   ip->system_header_p = 0;
   ip->macro = 0;
   ip->free_ptr = 0;
@@ -3428,12 +3592,12 @@ expand_to_temp_buffer (buf, limit, output_marks, assertions)
 \f
 /*
  * Process a # directive.  Expects IP->bufp to point after the '#', as in
- * `#define foo bar'.  Passes to the command handler
+ * `#define foo bar'.  Passes to the directive handler
  * (do_define, do_include, etc.): the addresses of the 1st and
- * last chars of the command (starting immediately after the #
- * keyword), plus op and the keyword table pointer.  If the command
+ * last chars of the directive (starting immediately after the #
+ * keyword), plus op and the keyword table pointer.  If the directive
  * contains comments it is copied into a temporary buffer sans comments
- * and the temporary buffer is passed to the command handler instead.
+ * and the temporary buffer is passed to the directive handler instead.
  * Likewise for backslash-newlines.
  *
  * Returns nonzero if this was a known # directive.
@@ -3449,9 +3613,9 @@ handle_directive (ip, op)
   register int ident_length;
   U_CHAR *resume_p;
 
-  /* Nonzero means we must copy the entire command
+  /* Nonzero means we must copy the entire directive
      to get rid of comments or backslash-newlines.  */
-  int copy_command = 0;
+  int copy_directive = 0;
 
   U_CHAR *ident, *after_ident;
 
@@ -3463,9 +3627,8 @@ handle_directive (ip, op)
   /* Skip whitespace and \-newline.  */
   while (1) {
     if (is_hor_space[*bp]) {
-      if ((*bp == '\f' || *bp == '\v') && pedantic)
-       pedwarn ("%s in preprocessing directive",
-                *bp == '\f' ? "formfeed" : "vertical tab");
+      if (*bp != ' ' && *bp != '\t' && pedantic)
+       pedwarn ("%s in preprocessing directive", char_name[*bp]);
       bp++;
     } else if (*bp == '/' && (bp[1] == '*'
                              || (cplusplus_comments && bp[1] == '/'))) {
@@ -3528,13 +3691,13 @@ handle_directive (ip, op)
       while (*p == '#' || is_hor_space[*p]) p++;
       if (*p == '\n') {
        if (pedantic && !lang_asm)
-         warning ("invalid preprocessor directive");
+         warning ("invalid preprocessing directive");
        return 0;
       }
     }
 
     if (!lang_asm)
-      error ("invalid preprocessor directive name");
+      error ("invalid preprocessing directive name");
 
     return 0;
   }
@@ -3544,7 +3707,7 @@ handle_directive (ip, op)
    * routine, after moving the input pointer up to the next line.
    */
   for (kt = directive_table; kt->length > 0; kt++) {
-    if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length)) {
+    if (kt->length == ident_length && !bcmp (kt->name, ident, ident_length)) {
       register U_CHAR *buf;
       register U_CHAR *limit;
       int unterminated;
@@ -3562,12 +3725,13 @@ handle_directive (ip, op)
       already_output = 0;
       keep_comments = traditional && kt->traditional_comments;
       /* #import is defined only in Objective C, or when on the NeXT.  */
-      if (kt->type == T_IMPORT && !(objc || lookup ("__NeXT__", -1, -1)))
+      if (kt->type == T_IMPORT
+         && !(objc || lookup ((U_CHAR *) "__NeXT__", -1, -1)))
        break;
 
-      /* Find the end of this command (first newline not backslashed
+      /* Find the end of this directive (first newline not backslashed
         and not in a string or comment).
-        Set COPY_COMMAND if the command must be copied
+        Set COPY_DIRECTIVE if the directive must be copied
         (it contains a backslash-newline or a comment).  */
 
       buf = bp = after_ident;
@@ -3578,7 +3742,7 @@ handle_directive (ip, op)
          if (bp < limit) {
            if (*bp == '\n') {
              ip->lineno++;
-             copy_command = 1;
+             copy_directive = 1;
              bp++;
            } else if (traditional)
              bp++;
@@ -3587,7 +3751,7 @@ handle_directive (ip, op)
 
        case '\'':
        case '\"':
-         bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, &copy_command, &unterminated);
+         bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, &copy_directive, &unterminated);
          /* Don't bother calling the directive if we already got an error
             message due to unterminated string.  Skip everything and pretend
             we called the directive.  */
@@ -3609,7 +3773,7 @@ handle_directive (ip, op)
          while (bp < limit && *bp != '>' && *bp != '\n') {
            if (*bp == '\\' && bp[1] == '\n') {
              ip->lineno++;
-             copy_command = 1;
+             copy_directive = 1;
              bp++;
            }
            bp++;
@@ -3625,23 +3789,28 @@ handle_directive (ip, op)
            ip->bufp = bp + 1;
            skip_to_end_of_comment (ip, &ip->lineno, 0);
            bp = ip->bufp;
-           /* No need to copy the command because of a comment at the end;
+           /* No need to copy the directive because of a comment at the end;
               just don't include the comment in the directive.  */
-           if (bp == limit || *bp == '\n') {
-             bp = obp;
-             goto endloop1;
+           if (!put_out_comments) {
+             U_CHAR *p;
+             for (p = bp;  *p == ' ' || *p == '\t';  p++)
+               continue;
+             if (*p == '\n') {
+               bp = obp;
+               goto endloop1;
+             }
            }
            /* Don't remove the comments if -traditional.  */
            if (! keep_comments)
-             copy_command++;
+             copy_directive++;
          }
          break;
 
        case '\f':
+       case '\r':
        case '\v':
          if (pedantic)
-           pedwarn ("%s in preprocessing directive",
-                    c == '\f' ? "formfeed" : "vertical tab");
+           pedwarn ("%s in preprocessing directive", char_name[c]);
          break;
 
        case '\n':
@@ -3660,7 +3829,8 @@ handle_directive (ip, op)
 
       /* If a directive should be copied through, and -E was given,
         pass it through before removing comments.  */
-      if (!no_output && kt->pass_thru && put_out_comments) {
+      if (!no_output && put_out_comments
+         && (dump_macros != dump_definitions) < kt->pass_thru) {
         int len;
 
        /* Output directive name.  */
@@ -3687,11 +3857,11 @@ handle_directive (ip, op)
        already_output = &junk;
       }                                /* Don't we need a newline or #line? */
 
-      if (copy_command) {
+      if (copy_directive) {
        register U_CHAR *xp = buf;
-       /* Need to copy entire command into temp buffer before dispatching */
+       /* Need to copy entire directive into temp buffer before dispatching */
 
-       cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
+       cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
                                                  some slop */
        buf = cp;
 
@@ -3724,15 +3894,15 @@ handle_directive (ip, op)
            if (*xp == '\n') {
              xp++;
              cp--;
-             if (cp != buf && is_space[cp[-1]]) {
-               while (cp != buf && is_space[cp[-1]]) cp--;
-               cp++;
+             if (cp != buf && is_hor_space[cp[-1]]) {
+               while (cp - 1 != buf && is_hor_space[cp[-2]])
+                 cp--;
                SKIP_WHITE_SPACE (xp);
-             } else if (is_space[*xp]) {
+             } else if (is_hor_space[*xp]) {
                *cp++ = *xp++;
                SKIP_WHITE_SPACE (xp);
              }
-           } else {
+           } else if (traditional && xp < bp) {
              *cp++ = *xp++;
            }
            break;
@@ -3758,7 +3928,7 @@ handle_directive (ip, op)
            if (*xp == '*'
                || (cplusplus_comments && *xp == '/')) {
              ip->bufp = xp + 1;
-             /* If we already copied the command through,
+             /* If we already copied the directive through,
                 already_output != 0 prevents outputting comment now.  */
              skip_to_end_of_comment (ip, already_output, 0);
              if (keep_comments)
@@ -3787,10 +3957,7 @@ handle_directive (ip, op)
         definitions through.  */
 
       if (!no_output && already_output == 0
-         && (kt->pass_thru
-             || (kt->type == T_DEFINE
-                 && (dump_macros == dump_names
-                     || dump_macros == dump_definitions)))) {
+         && (dump_macros < dump_names) < kt->pass_thru) {
         int len;
 
        /* Output directive name.  */
@@ -3799,7 +3966,7 @@ handle_directive (ip, op)
         bcopy (kt->name, (char *) op->bufp, kt->length);
         op->bufp += kt->length;
 
-       if (kt->pass_thru || dump_macros == dump_definitions) {
+       if ((dump_macros != dump_definitions) < kt->pass_thru) {
          /* Output arguments.  */
          len = (cp - buf);
          check_expand (op, len);
@@ -3819,11 +3986,11 @@ handle_directive (ip, op)
        }
       }                                /* Don't we need a newline or #line? */
 
-      /* Call the appropriate command handler.  buf now points to
+      /* Call the appropriate directive handler.  buf now points to
         either the appropriate place in the input buffer, or to
         the temp buffer if it was necessary to make one.  cp
         points to the first char after the contents of the (possibly
-        copied) command, in either case. */
+        copied) directive, in either case.  */
       (*kt->func) (buf, cp, op, kt);
       check_expand (op, ip->length - (ip->bufp - ip->buf));
 
@@ -3841,7 +4008,7 @@ timestamp ()
 {
   static struct tm *timebuf;
   if (!timebuf) {
-    time_t t = time ((time_t *)0);
+    time_t t = time ((time_t *) 0);
     timebuf = localtime (&t);
   }
   return timebuf;
@@ -3944,12 +4111,15 @@ special_symbol (hp, op)
     buf = REGISTER_PREFIX;
     break;
 
+  case T_IMMEDIATE_PREFIX_TYPE:
+    buf = IMMEDIATE_PREFIX;
+    break;
+
   case T_CONST:
-    buf = (char *) alloca (4 * sizeof (int));
-    sprintf (buf, "%d", hp->value.ival);
+    buf = hp->value.cpval;
     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);
+      fprintf (pcp_outfile, "#define %s %s\n", hp->name, buf);
     break;
 
   case T_SPECLINE:
@@ -3981,11 +4151,13 @@ special_symbol (hp, op)
 
     if (!is_idstart[*ip->bufp])
       goto oops;
-    if (hp = lookup (ip->bufp, -1, -1)) {
+    if (ip->bufp[0] == 'L' && (ip->bufp[1] == '\'' || ip->bufp[1] == '"'))
+      goto oops;
+    if ((hp = lookup (ip->bufp, -1, -1))) {
       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. */
+       /* Output a precondition for this macro use.  */
        fprintf (pcp_outfile, "#define %s\n", hp->name);
       buf = " 1 ";
     }
@@ -4037,30 +4209,41 @@ do_include (buf, limit, op, keyword)
      FILE_BUF *op;
      struct directive *keyword;
 {
-  int importing = (keyword->type == T_IMPORT);
+  U_CHAR *importing = keyword->type == T_IMPORT ? (U_CHAR *) "" : (U_CHAR *) 0;
   int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
   static int import_warning = 0;
   char *fname;         /* Dynamically allocated fname buffer */
   char *pcftry;
   char *pcfname;
-  U_CHAR *fbeg, *fend;         /* Beginning and end of fname */
+  char *fbeg, *fend;           /* Beginning and end of fname */
+  U_CHAR *fin;
 
   struct file_name_list *search_start = include; /* Chain of dirs to search */
-  struct file_name_list dsp[1];        /* First in chain, if #include "..." */
+  struct file_name_list *dsp;  /* First in chain, if #include "..." */
   struct file_name_list *searchptr = 0;
-  int flen;
+  size_t flen;
 
-  int f;                       /* file number */
+  int f = -3;                  /* file number */
+  struct include_file *inc = 0;
 
   int retried = 0;             /* Have already tried macro
                                   expanding the include line*/
-  FILE_BUF trybuf;             /* It got expanded into here */
   int angle_brackets = 0;      /* 0 for "...", 1 for <...> */
+#ifdef VMS
+  int vaxc_include = 0;                /* 1 for token without punctuation */
+#endif
   int pcf = -1;
   char *pcfbuf;
-  int pcfbuflimit;
+  char *pcfbuflimit;
   int pcfnum;
-  f= -1;                       /* JF we iz paranoid! */
+
+  if (pedantic && !instack[indepth].system_header_p)
+    {
+      if (importing)
+       pedwarn ("ANSI C does not allow `#import'");
+      if (skip_dirs)
+       pedwarn ("ANSI C does not allow `#include_next'");
+    }
 
   if (importing && warn_import && !inhibit_warnings
       && !instack[indepth].system_header_p && !import_warning) {
@@ -4080,21 +4263,19 @@ do_include (buf, limit, op, keyword)
 
 get_filename:
 
-  fbeg = buf;
-  SKIP_WHITE_SPACE (fbeg);
+  fin = buf;
+  SKIP_WHITE_SPACE (fin);
   /* Discard trailing whitespace so we can easily see
      if we have parsed all the significant chars we were given.  */
-  while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
+  while (limit != fin && is_hor_space[limit[-1]]) limit--;
+  fbeg = fend = (char *) alloca (limit - fin);
 
-  switch (*fbeg++) {
+  switch (*fin++) {
   case '\"':
     {
       FILE_BUF *fp;
       /* Copy the operand text, concatenating the strings.  */
       {
-       U_CHAR *fin = fbeg;
-       fbeg = (U_CHAR *) alloca (limit - fbeg + 1);
-       fend = fbeg;
        while (fin != limit) {
          while (fin != limit && *fin != '\"')
            *fend++ = *fin++;
@@ -4110,41 +4291,35 @@ get_filename:
            goto fail;
        }
       }
-      *fend = 0;
 
       /* We have "filename".  Figure out directory this source
-        file is coming from and put it on the front of the list. */
+        file is coming from and put it on the front of the list.  */
 
-      /* If -I- was specified, don't search current dir, only spec'd ones. */
+      /* If -I- was specified, don't search current dir, only spec'd ones.  */
       if (ignore_srcdir) break;
 
       for (fp = &instack[indepth]; fp >= instack; fp--)
        {
          int n;
-         char *ep,*nam;
+         char *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';
+           dsp = ((struct file_name_list *)
+                  alloca (sizeof (struct file_name_list) + strlen (nam)));
+           strcpy (dsp->fname, nam);
+           simplify_filename (dsp->fname);
+           nam = base_name (dsp->fname);
+           *nam = 0;
+           /* But for efficiency's sake, do not insert the dir
+              if it matches the search list's first dir.  */
+           dsp->next = search_start;
+           if (!search_start || strcmp (dsp->fname, search_start->fname)) {
+             search_start = dsp;
+             n = nam - dsp->fname;
              if (n + INCLUDE_LEN_FUDGE > max_include_len)
                max_include_len = n + INCLUDE_LEN_FUDGE;
-           } else {
-             dsp[0].fname = 0; /* Current directory */
            }
            dsp[0].got_name_map = 0;
            break;
@@ -4154,13 +4329,12 @@ get_filename:
     }
 
   case '<':
-    fend = fbeg;
-    while (fend != limit && *fend != '>') fend++;
-    if (*fend == '>' && fend + 1 == limit) {
+    while (fin != limit && *fin != '>')
+      *fend++ = *fin++;
+    if (*fin == '>' && fin + 1 == limit) {
       angle_brackets = 1;
       /* If -I-, start with the first -I dir after the -I-.  */
-      if (first_bracket_include)
-       search_start = first_bracket_include;
+      search_start = first_bracket_include;
       break;
     }
     goto fail;
@@ -4171,16 +4345,17 @@ get_filename:
      * 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.
+     * (Note: macro expansion of `xyz' takes precedence.)
      */
-    if (isalpha(*(--fbeg))) {
-      fend = fbeg;
-      while (fend != limit && (!isspace(*fend))) fend++;
+    if (retried && isalpha(*(U_CHAR *) (--fbeg))) {
+      while (fin != limit && (!isspace(*fin)))
+       *fend++ = *fin++;
       warning ("VAX-C-style include specification found, use '#include <filename.h>' !");
-      if (fend  == limit) {
+      vaxc_include = 1;
+      if (fin == limit) {
        angle_brackets = 1;
        /* If -I-, start with the first -I dir after the -I-.  */
-       if (first_bracket_include)
-         search_start = first_bracket_include;
+       search_start = first_bracket_include;
        break;
       }
     }
@@ -4191,10 +4366,34 @@ get_filename:
       error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
       return 0;
     } else {
-      trybuf = expand_to_temp_buffer (buf, limit, 0, 0);
+      /* Expand buffer and then remove any newline markers.
+        We can't just tell expand_to_temp_buffer to omit the markers,
+        since it would put extra spaces in include file names.  */
+      FILE_BUF trybuf;
+      U_CHAR *src;
+      trybuf = expand_to_temp_buffer (buf, limit, 1, 0);
+      src = trybuf.buf;
       buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
-      bcopy ((char *) trybuf.buf, (char *) buf, trybuf.bufp - trybuf.buf);
-      limit = buf + (trybuf.bufp - trybuf.buf);
+      limit = buf;
+      while (src != trybuf.bufp) {
+       switch ((*limit++ = *src++)) {
+         case '\n':
+           limit--;
+           src++;
+           break;
+
+         case '\'':
+         case '\"':
+           {
+             U_CHAR *src1 = skip_quoted_string (src - 1, trybuf.bufp, 0,
+                                                NULL_PTR, NULL_PTR, NULL_PTR);
+             while (src != src1)
+               *limit++ = *src++;
+           }
+           break;
+       }
+      }
+      *limit = 0;
       free (trybuf.buf);
       retried++;
       goto get_filename;
@@ -4215,7 +4414,8 @@ get_filename:
       }
   }
 
-  flen = fend - fbeg;
+  *fend = 0;
+  flen = simplify_filename (fbeg);
 
   if (flen == 0)
     {
@@ -4225,115 +4425,117 @@ get_filename:
 
   /* Allocate this permanently, because it gets stored in the definitions
      of macros.  */
-  fname = (char *) xmalloc (max_include_len + flen + 4);
-  /* + 2 above for slash and terminating null.  */
-  /* + 2 added for '.h' on VMS (to support '#include filename') */
+  fname = xmalloc (max_include_len + flen + 1);
+  /* + 1 above for terminating null.  */
+
+  system_include_depth += angle_brackets;
 
   /* If specified file name is absolute, just open it.  */
 
-  if (*fbeg == '/') {
-    strncpy (fname, fbeg, flen);
-    fname[flen] = 0;
-    if (redundant_include_p (fname))
-      return 0;
-    if (importing)
-      f = lookup_import (fname, NULL_PTR);
-    else
-      f = open_include_file (fname, NULL_PTR);
-    if (f == -2)
-      return 0;                /* Already included this file */
+  if (absolute_filename (fbeg)) {
+    strcpy (fname, fbeg);
+    f = open_include_file (fname, NULL_PTR, importing, &inc);
   } else {
+
+    struct bypass_dir {
+      struct bypass_dir *next;
+      char *fname;
+      struct file_name_list *searchptr;
+    } **bypass_slot = 0;
+
     /* 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;
+
+      if (searchptr == first_bracket_include) {
+       /* Go to bypass directory if we know we've seen this file before.  */
+       static struct bypass_dir *bypass_hashtab[INCLUDE_HASHSIZE];
+       struct bypass_dir *p;
+       bypass_slot = &bypass_hashtab[hashf ((U_CHAR *) fbeg, flen,
+                                            INCLUDE_HASHSIZE)];
+       for (p = *bypass_slot; p; p = p->next)
+         if (!strcmp (fbeg, p->fname)) {
+           searchptr = p->searchptr;
+           bypass_slot = 0;
+           break;
+         }
       }
-      strncat (fname, fbeg, flen);
+
+      strcpy (fname, searchptr->fname);
+      strcat (fname, fbeg);
 #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)) {
+      if (searchptr->fname[0]) {
        /* Fix up the filename */
-       hack_vms_include_specification (fname);
+       hack_vms_include_specification (fname, vaxc_include);
       } else {
-       /* This is a normal VMS filespec, so use it unchanged.  */
-       strncpy (fname, fbeg, flen);
-       fname[flen] = 0;
+       /* This is a normal VMS filespec, so use it unchanged.  */
+       strcpy (fname, fbeg);
        /* if it's '#include filename', add the missing .h */
-       if (index(fname,'.')==NULL) {
+       if (vaxc_include && index(fname,'.')==NULL) {
          strcat (fname, ".h");
        }
       }
 #endif /* VMS */
-      if (importing)
-       f = lookup_import (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)
-       warning ("Header file %s exists, but is not readable", fname);
-#endif
-      if (redundant_include_p (fname)) {
-       close (f);
-       return 0;
+      f = open_include_file (fname, searchptr, importing, &inc);
+      if (f != -1) {
+       if (bypass_slot && searchptr != first_bracket_include) {
+         /* This is the first time we found this include file,
+            and we found it after first_bracket_include.
+            Record its location so that we can bypass to here next time.  */
+         struct bypass_dir *p
+           = (struct bypass_dir *) xmalloc (sizeof (struct bypass_dir));
+         p->next = *bypass_slot;
+         p->fname = fname + strlen (searchptr->fname);
+         p->searchptr = searchptr;
+         *bypass_slot = p;
+       }
+       break;
       }
-      if (f >= 0)
+#ifdef VMS
+      /* Our VMS hacks can produce invalid filespecs, so don't worry
+        about errors other than EACCES.  */
+      if (errno == EACCES)
+       break;
+#else
+      if (errno != ENOENT && errno != ENOTDIR)
        break;
+#endif
     }
   }
 
+
   if (f < 0) {
-    /* A file that was not found.  */
 
-    strncpy (fname, fbeg, flen);
-    fname[flen] = 0;
+    if (f == -2) {
+      /* The file was already included.  */
+
     /* 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 (print_deps_missing_files
-       && print_deps > (angle_brackets || (system_include_depth > 0)))
+    } else if (print_deps_missing_files
+              && (system_include_depth != 0) < print_deps)
       {
        /* 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 (p, ' ');
-                   break;
-                 }
-             }
+           if (search_start) {
+             char *p = (char *) alloca (strlen (search_start->fname)
+                                        + strlen (fbeg) + 1);
+             strcpy (p, search_start->fname);
+             strcat (p, fbeg);
+             deps_output (p, ' ');
+           }
          }
        else
          {
            /* Otherwise, omit the directory, as if the file existed
               in the directory with the source.  */
-           deps_output (fname, ' ');
+           deps_output (fbeg, ' ');
          }
       }
     /* If -M was specified, and this header file won't be added to the
@@ -4341,124 +4543,63 @@ get_filename:
        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 (print_deps
-       && (print_deps <= (angle_brackets || (system_include_depth > 0))))
-      warning ("No include path in which to find %s", fname);
-    else if (search_start)
-      error_from_errno (fname);
+    else if (0 < print_deps  &&  print_deps <= (system_include_depth != 0))
+      warning ("No include path in which to find %s", fbeg);
+    else if (f != -3)
+      error_from_errno (fbeg);
     else
-      error ("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.  */
+      error ("No include path in which to find %s", fbeg);
 
-    struct file_name_list* ptr;
-
-    for (ptr = dont_repeat_files; ptr; ptr = ptr->next) {
-      if (!strcmp (ptr->fname, fname)) {
-       close (f);
-        return 0;                              /* This file was once'd. */
-      }
-    }
-
-    for (ptr = 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 = all_include_files;
-      all_include_files = ptr;
-      ptr->fname = savestring (fname);
-      ptr->got_name_map = 0;
-
-      /* For -M, add this file to the dependencies.  */
-      if (print_deps > (angle_brackets || (system_include_depth > 0)))
-       deps_output (fname, ' ');
-    }   
-
-    /* Handle -H option.  */
-    if (print_include_names) {
-      output_dots (stderr, indepth);
-      fprintf (stderr, "%s\n", fname);
-    }
-
-    if (angle_brackets)
-      system_include_depth++;
+  } else {
 
     /* Actually process the file.  */
-    add_import (f, fname);     /* Record file on "seen" list for #import. */
 
     pcftry = (char *) alloca (strlen (fname) + 30);
     pcfbuf = 0;
     pcfnum = 0;
 
-    fstat (f, &stat_f);
-
     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 ((char *) &stat_f.st_ino, (char *) &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);
+      {
+       do {
+         sprintf (pcftry, "%s%d", fname, pcfnum++);
+
+         pcf = open (pcftry, O_RDONLY, 0666);
+         if (pcf != -1)
+           {
+             struct stat s;
+
+             if (fstat (pcf, &s) != 0)
+               pfatal_with_name (pcftry);
+             if (! INO_T_EQ (inc->st.st_ino, s.st_ino)
+                 || inc->st.st_dev != s.st_dev)
+               {
+                 pcfbuf = check_precompiled (pcf, &s, fname, &pcfbuflimit);
+                 /* Don't need it any more.  */
+                 close (pcf);
+               }
+             else
+               {
+                 /* Don't need it at all.  */
+                 close (pcf);
+                 break;
+               }
+           }
+       } while (pcf != -1 && !pcfbuf);
+      }
     
     /* Actually process the file */
     if (pcfbuf) {
       pcfname = xmalloc (strlen (pcftry) + 1);
       strcpy (pcfname, pcftry);
-      pcfinclude (pcfbuf, pcfbuflimit, fname, op);
+      pcfinclude ((U_CHAR *) pcfbuf, (U_CHAR *) pcfbuflimit,
+                 (U_CHAR *) fname, op);
     }
     else
-      finclude (f, fname, op, is_system_include (fname), searchptr);
-
-    if (angle_brackets)
-      system_include_depth--;
+      finclude (f, inc, op, is_system_include (fname), searchptr);
   }
-  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.  */
+  system_include_depth -= angle_brackets;
 
-static int
-redundant_include_p (name)
-     char *name;
-{
-  struct file_name_list *l = all_include_files;
-  for (; l; l = l->next)
-    if (! strcmp (name, l->fname)
-       && l->control_macro
-       && lookup (l->control_macro, -1, -1))
-      return 1;
   return 0;
 }
 
@@ -4481,19 +4622,121 @@ is_system_include (filename)
 
   for (searchptr = first_system_include; searchptr;
        searchptr = searchptr->next)
-    if (searchptr->fname) {
-      register char *sys_dir = searchptr->fname;
-      register unsigned length = strlen (sys_dir);
+    if (! strncmp (searchptr->fname, filename, strlen (searchptr->fname)))
+      return searchptr->c_system_include_path + 1;
+  return 0;
+}
+\f
+/* Yield the non-directory suffix of a file name.  */
 
-      if (! strncmp (sys_dir, filename, length) && filename[length] == '/')
-       {
-         if (searchptr->c_system_include_path)
-           return 2;
-         else
-           return 1;
+static char *
+base_name (fname)
+     char *fname;
+{
+  char *s = fname;
+  char *p;
+#if defined (__MSDOS__) || defined (_WIN32)
+  if (isalpha (s[0]) && s[1] == ':') s += 2;
+#endif
+#ifdef VMS
+  if ((p = rindex (s, ':'))) s = p + 1;        /* Skip device.  */
+  if ((p = rindex (s, ']'))) s = p + 1;        /* Skip directory.  */
+  if ((p = rindex (s, '>'))) s = p + 1;        /* Skip alternate (int'n'l) dir.  */
+  if (s != fname)
+    return s;
+#endif
+  if ((p = rindex (s, '/'))) s = p + 1;
+#ifdef DIR_SEPARATOR
+  if ((p = rindex (s, DIR_SEPARATOR))) s = p + 1;
+#endif
+  return s;
+}
+
+/* Yield nonzero if FILENAME is absolute (i.e. not relative).  */
+
+static int
+absolute_filename (filename)
+     char *filename;
+{
+#if defined (__MSDOS__) || (defined (_WIN32) && !defined (__CYGWIN32__))
+  if (isalpha (filename[0]) && filename[1] == ':') filename += 2;
+#endif
+#if defined (__CYGWIN32__)
+  /* At present, any path that begins with a drive spec is absolute.  */
+  if (isalpha (filename[0]) && filename[1] == ':') return 1;
+#endif
+  if (filename[0] == '/') return 1;
+#ifdef DIR_SEPARATOR
+  if (filename[0] == DIR_SEPARATOR) return 1;
+#endif
+  return 0;
+}
+
+/* Remove unnecessary characters from FILENAME in place,
+   to avoid unnecessary filename aliasing.
+   Return the length of the resulting string.
+
+   Do only the simplifications allowed by Posix.
+   It is OK to miss simplifications on non-Posix hosts,
+   since this merely leads to suboptimial results.  */
+
+static size_t
+simplify_filename (filename)
+     char *filename;
+{
+  register char *from = filename;
+  register char *to = filename;
+  char *to0;
+
+  /* Remove redundant initial /s.  */
+  if (*from == '/') {
+    *to++ = '/';
+    if (*++from == '/') {
+      if (*++from == '/') {
+       /* 3 or more initial /s are equivalent to 1 /.  */
+       while (*++from == '/')
+         continue;
+      } else {
+       /* On some hosts // differs from /; Posix allows this.  */
+       static int slashslash_vs_slash;
+       if (slashslash_vs_slash == 0) {
+         struct stat s1, s2;
+         slashslash_vs_slash = ((stat ("/", &s1) == 0 && stat ("//", &s2) == 0
+                                 && INO_T_EQ (s1.st_ino, s2.st_ino)
+                                 && s1.st_dev == s2.st_dev)
+                                ? 1 : -1);
        }
+       if (slashslash_vs_slash < 0)
+         *to++ = '/';
+      }
     }
-  return 0;
+  }
+  to0 = to;
+
+  for (;;) {
+    if (from[0] == '.' && from[1] == '/')
+      from += 2;
+    else {
+      /* Copy this component and trailing /, if any.  */
+      while ((*to++ = *from++) != '/') {
+       if (!to[-1]) {
+         /* Trim . component at end of nonempty name.  */
+         to -= filename <= to - 3 && to[-3] == '/' && to[-2] == '.';
+
+         /* Trim unnecessary trailing /s.  */
+         while (to0 < --to && to[-1] == '/')
+           continue;
+
+         *to = 0;
+         return to - filename;
+       }
+      }
+    }
+
+    /* Skip /s after a /.  */
+    while (*from == '/')
+      from++;
+  }
 }
 \f
 /* The file_name_map structure holds a mapping of file names for a
@@ -4545,7 +4788,9 @@ read_filename_string (ch, f)
   return alloc;
 }
 
-/* Read the file name map file for DIRNAME.  */
+/* Read the file name map file for DIRNAME.
+   If DIRNAME is empty, read the map file for the working directory;
+   otherwise DIRNAME must end in '/'.  */
 
 static struct file_name_map *
 read_name_map (dirname)
@@ -4563,6 +4808,7 @@ read_name_map (dirname)
   register struct file_name_map_list *map_list_ptr;
   char *name;
   FILE *f;
+  size_t dirlen;
 
   for (map_list_ptr = map_list; map_list_ptr;
        map_list_ptr = map_list_ptr->map_list_next)
@@ -4574,10 +4820,9 @@ read_name_map (dirname)
   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);
+  dirlen = strlen (dirname);
+  name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 1);
   strcpy (name, dirname);
-  if (*dirname)
-    strcat (name, "/");
   strcat (name, FILE_NAME_MAP_FILE);
   f = fopen (name, "r");
   if (!f)
@@ -4585,12 +4830,12 @@ read_name_map (dirname)
   else
     {
       int ch;
-      int dirlen = strlen (dirname);
 
       while ((ch = getc (f)) != EOF)
        {
          char *from, *to;
          struct file_name_map *ptr;
+         size_t tolen;
 
          if (is_space[ch])
            continue;
@@ -4599,19 +4844,21 @@ read_name_map (dirname)
            ;
          to = read_filename_string (ch, f);
 
+         simplify_filename (from);
+         tolen = simplify_filename (to);
+
          ptr = ((struct file_name_map *)
                 xmalloc (sizeof (struct file_name_map)));
          ptr->map_from = from;
 
          /* Make the real filename absolute.  */
-         if (*to == '/')
+         if (absolute_filename (to))
            ptr->map_to = to;
          else
            {
-             ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
+             ptr->map_to = xmalloc (dirlen + tolen + 1);
              strcpy (ptr->map_to, dirname);
-             ptr->map_to[dirlen] = '/';
-             strcpy (ptr->map_to + dirlen + 1, to);
+             strcat (ptr->map_to, to);
              free (to);
            }         
 
@@ -4632,78 +4879,153 @@ read_name_map (dirname)
 }  
 
 /* 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
+   being tried from the include file search path.
+   IMPORTING is "" if we are importing, null otherwise.
+   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.
+   Unless unsuccessful, put a descriptor of the included file into *PINC.
+   This function maps filenames on file systems based on information read by
    read_name_map.  */
 
 static int
-open_include_file (filename, searchptr)
+open_include_file (filename, searchptr, importing, pinc)
+     char *filename;
+     struct file_name_list *searchptr;
+     U_CHAR *importing;
+     struct include_file **pinc;
+{
+  char *fname = remap_include_file (filename, searchptr);
+  int fd = -2;
+
+  /* Look up FNAME in include_hashtab.  */
+  struct include_file **phead = &include_hashtab[hashf ((U_CHAR *) fname,
+                                                       strlen (fname),
+                                                       INCLUDE_HASHSIZE)];
+  struct include_file *inc, *head = *phead;
+  for (inc = head; inc; inc = inc->next)
+    if (!strcmp (fname, inc->fname))
+      break;
+
+  if (!inc
+      || ! inc->control_macro
+      || (inc->control_macro[0] && ! lookup (inc->control_macro, -1, -1))) {
+
+    fd = open (fname, O_RDONLY, 0);
+
+    if (fd < 0)
+      return fd;
+
+    if (!inc) {
+      /* FNAME was not in include_hashtab; insert a new entry.  */
+      inc = (struct include_file *) xmalloc (sizeof (struct include_file));
+      inc->next = head;
+      inc->fname = fname;
+      inc->control_macro = 0;
+      inc->deps_output = 0;
+      if (fstat (fd, &inc->st) != 0)
+       pfatal_with_name (fname);
+      *phead = inc;
+
+      /* Look for another file with the same inode and device.  */
+      if (lookup_ino_include (inc)
+         && inc->control_macro
+         && (!inc->control_macro[0] || lookup (inc->control_macro, -1, -1))) {
+       close (fd);
+       fd = -2;
+      }
+    }
+
+    /* For -M, add this file to the dependencies.  */
+    if (! inc->deps_output  &&  (system_include_depth != 0) < print_deps) {
+      inc->deps_output = 1;
+      deps_output (fname, ' ');
+    }   
+
+    /* Handle -H option.  */
+    if (print_include_names)
+      fprintf (stderr, "%*s%s\n", indepth, "", fname);
+  }
+
+  if (importing)
+    inc->control_macro = importing;
+
+  *pinc = inc;
+  return fd;
+}
+
+/* Return the remapped name of the the include file FILENAME.
+   SEARCHPTR is the directory being tried from the include file path.  */
+
+static char *
+remap_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)
+  if (searchptr)
     {
-      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 (! searchptr->got_name_map)
        {
-         if (! strcmp (map->map_from, from))
-           {
-             /* Found a match.  */
-             return open (map->map_to, O_RDONLY, 0666);
-           }
+         searchptr->name_map = read_name_map (searchptr->fname);
+         searchptr->got_name_map = 1;
        }
-    }
 
-  /* 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);
+      /* Check the mapping for the directory we are using.  */
+      from = filename + strlen (searchptr->fname);
+      for (map = searchptr->name_map; map; map = map->map_next)
+       if (! strcmp (map->map_from, from))
+         return map->map_to;
     }
 
-  if (p == filename)
+  from = base_name (filename);
+
+  if (from != filename || !searchptr)
     {
-      dir = ".";
-      from = filename;
+      /* 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.  */
+
+      char *dir = (char *) alloca (from - filename + 1);
+      bcopy (filename, dir, from - filename);
+      dir[from - filename] = '\0';
+
+      for (map = read_name_map (dir); map; map = map->map_next)
+       if (! strcmp (map->map_from, from))
+         return map->map_to;
     }
-  else
-    {
-      dir = (char *) alloca (p - filename + 1);
-      bcopy (filename, dir, p - filename);
-      dir[p - filename] = '\0';
-      from = p + 1;
+
+  return filename;
+}
+
+/* Insert INC into the include file table, hashed by device and inode number.
+   If a file with different name but same dev+ino was already in the table,
+   return 1 and set INC's control macro to the already-known macro.  */
+
+static int
+lookup_ino_include (inc)
+     struct include_file *inc;
+{
+  int hash = ((unsigned) (inc->st.st_dev + INO_T_HASH (inc->st.st_ino))
+             % INCLUDE_HASHSIZE);
+  struct include_file *i = include_ino_hashtab[hash];
+  inc->next_ino = i;
+  include_ino_hashtab[hash] = inc;
+
+  for (; i; i = i->next_ino)
+    if (INO_T_EQ (inc->st.st_ino, i->st.st_ino)
+       && inc->st.st_dev == i->st.st_dev) {
+      inc->control_macro = i->control_macro;
+      return 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);
+  return 0;
 }
 \f
-/* Process the contents of include file FNAME, already open on descriptor F,
+/* Process file descriptor F, which corresponds to include file INC,
    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'
@@ -4712,62 +5034,55 @@ open_include_file (filename, searchptr)
    or 0 if the file name was absolute.  */
 
 static void
-finclude (f, fname, op, system_header_p, dirptr)
+finclude (f, inc, op, system_header_p, dirptr)
      int f;
-     char *fname;
+     struct include_file *inc;
      FILE_BUF *op;
      int system_header_p;
      struct file_name_list *dirptr;
 {
-  int st_mode;
-  long st_size;
-  long i;
+  char *fname = inc->fname;
+  int i;
   FILE_BUF *fp;                        /* For input stack frame */
   int missing_newline = 0;
 
   CHECK_DEPTH (return;);
 
-  if (file_size_and_mode (f, &st_mode, &st_size) < 0)
-    {
-      perror_with_name (fname);
-      close (f);
-      return;
-    }
-
   fp = &instack[indepth + 1];
   bzero ((char *) fp, sizeof (FILE_BUF));
   fp->nominal_fname = fp->fname = fname;
+  fp->inc = inc;
   fp->length = 0;
   fp->lineno = 1;
   fp->if_stack = if_stack;
   fp->system_header_p = system_header_p;
   fp->dir = dirptr;
 
-  if (S_ISREG (st_mode)) {
-    fp->buf = (U_CHAR *) xmalloc (st_size + 2);
+  if (S_ISREG (inc->st.st_mode)) {
+    fp->buf = (U_CHAR *) xmalloc (inc->st.st_size + 2);
     fp->bufp = fp->buf;
 
-    /* Read the file contents, knowing that st_size is an upper bound
+    /* Read the file contents, knowing that inc->st.st_size is an upper bound
        on the number of bytes we can read.  */
-    fp->length = safe_read (f, fp->buf, st_size);
+    fp->length = safe_read (f, (char *) fp->buf, inc->st.st_size);
     if (fp->length < 0) goto nope;
   }
-  else if (S_ISDIR (st_mode)) {
+  else if (S_ISDIR (inc->st.st_mode)) {
     error ("directory `%s' specified in #include", fname);
     close (f);
     return;
   } else {
     /* Cannot count its file size before reading.
        First read the entire file into heap and
-       copy them into buffer on stack. */
+       copy them into buffer on stack.  */
 
     int bsize = 2000;
+    int st_size = 0;
 
-    st_size = 0;
     fp->buf = (U_CHAR *) xmalloc (bsize + 2);
 
     for (;;) {
-      i = safe_read (f, fp->buf + st_size, bsize - st_size);
+      i = safe_read (f, (char *) fp->buf + st_size, bsize - st_size);
       if (i < 0)
        goto nope;      /* error! */
       st_size += i;
@@ -4800,7 +5115,7 @@ finclude (f, fname, op, system_header_p, dirptr)
   if (!no_trigraphs)
     trigraph_pcp (fp);
 
-  output_line_command (fp, op, 0, enter_file);
+  output_line_directive (fp, op, 0, enter_file);
   rescan (op, 0);
 
   if (missing_newline)
@@ -4811,7 +5126,7 @@ finclude (f, fname, op, system_header_p, dirptr)
 
   indepth--;
   input_file_stack_tick++;
-  output_line_command (&instack[indepth], op, 0, leave_file);
+  output_line_directive (&instack[indepth], op, 0, leave_file);
   free (fp->buf);
   return;
 
@@ -4822,158 +5137,50 @@ finclude (f, fname, op, system_header_p, dirptr)
   free (fp->buf);
 }
 
-/* Record that inclusion of the file named FILE
+/* Record that inclusion of the include file INC
    should be controlled by the macro named MACRO_NAME.
    This means that trying to include the file again
    will do something if that macro is defined.  */
 
 static void
-record_control_macro (file, macro_name)
-     char *file;
+record_control_macro (inc, macro_name)
+     struct include_file *inc;
      U_CHAR *macro_name;
 {
-  struct file_name_list *new;
-
-  for (new = all_include_files; new; new = new->next) {
-    if (!strcmp (new->fname, file)) {
-      new->control_macro = macro_name;
-      return;
-    }
-  }
-
-  /* If the file is not in all_include_files, something's wrong.  */
-  abort ();
-}
-\f
-/* 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;
-};
-
-/* Hash table of files already included with #include or #import.  */
-
-static struct import_file *import_hash_table[IMPORT_HASH_SIZE];
-
-/* 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 (filename, searchptr)
-     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 = 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 = import_hash_table[h];
-    while (i) {
-      /* Compare the inode and the device.
-        Supposedly on some systems the inode is not a scalar.  */
-      if (!bcmp ((char *) &i->inode, (char *) &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 (fd, fname)
-     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 ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
-  i->dev = sb.st_dev;
-  i->next = import_hash_table[hashval];
-  import_hash_table[hashval] = i;
+  if (!inc->control_macro || inc->control_macro[0])
+    inc->control_macro = macro_name;
 }
 \f
 /* Load the specified precompiled header into core, and verify its
    preconditions.  PCF indicates the file descriptor to read, which must
-   be a regular file.  FNAME indicates the file name of the original 
-   header.  *LIMIT will be set to an address one past the end of the file.
+   be a regular file.  *ST is its file status.
+   FNAME indicates the file name of the original header.
+   *LIMIT will be set to an address one past the end of the file.
    If the preconditions of the file are not satisfied, the buffer is 
    freed and we return 0.  If the preconditions are satisfied, return
    the address of the buffer following the preconditions.  The buffer, in
    this case, should never be freed because various pieces of it will
    be referred to until all precompiled strings are output at the end of
-   the run.
-*/
+   the run.  */
+
 static char *
-check_precompiled (pcf, fname, limit)
+check_precompiled (pcf, st, fname, limit)
      int pcf;
+     struct stat *st;
      char *fname;
      char **limit;
 {
-  int st_mode;
-  long st_size;
   int length = 0;
   char *buf;
   char *cp;
 
   if (pcp_outfile)
     return 0;
-  
-  if (file_size_and_mode (pcf, &st_mode, &st_size) < 0)
-    return 0;
 
-  if (S_ISREG (st_mode))
+  if (S_ISREG (st->st_mode))
     {
-      buf = xmalloc (st_size + 2);
-      length = safe_read (pcf, buf, st_size);
+      buf = xmalloc (st->st_size + 2);
+      length = safe_read (pcf, buf, st->st_size);
       if (length < 0)
        goto nope;
     }
@@ -4986,7 +5193,7 @@ check_precompiled (pcf, fname, limit)
   
   *limit = buf + length;
 
-  /* File is in core.  Check the preconditions. */
+  /* File is in core.  Check the preconditions.  */
   if (!check_preconditions (buf))
     goto nope;
   for (cp = buf; *cp; cp++)
@@ -5008,6 +5215,7 @@ check_precompiled (pcf, fname, limit)
    precompiled header.  These are a series of #define and #undef
    lines which must match the current contents of the hash
    table.  */
+
 static int 
 check_preconditions (prec)
      char *prec;
@@ -5016,7 +5224,7 @@ check_preconditions (prec)
   char *lineend;
   
   while (*prec) {
-    lineend = (char *) index (prec, '\n');
+    lineend = index (prec, '\n');
     
     if (*prec++ != '#') {
       error ("Bad format encountered while reading precompiled file");
@@ -5026,7 +5234,7 @@ check_preconditions (prec)
       HASHNODE *hp;
       
       prec += 6;
-      mdef = create_definition (prec, lineend, NULL_PTR);
+      mdef = create_definition ((U_CHAR *) prec, (U_CHAR *) lineend, NULL_PTR);
 
       if (mdef.defn == 0)
        abort ();
@@ -5051,7 +5259,7 @@ check_preconditions (prec)
        prec++;
       len = prec - name;
       
-      if (lookup (name, len, -1))
+      if (lookup ((U_CHAR *) name, len, -1))
        return 0;
     } else {
       error ("Bad format encountered while reading precompiled file");
@@ -5066,7 +5274,8 @@ check_preconditions (prec)
 /* Process the main body of a precompiled file.  BUF points to the
    string section of the file, following the preconditions.  LIMIT is one
    character past the end.  NAME is the name of the file being read
-   in.  OP is the main output buffer */
+   in.  OP is the main output buffer.  */
+
 static void
 pcfinclude (buf, limit, name, op)
      U_CHAR *buf, *limit, *name;
@@ -5083,7 +5292,7 @@ pcfinclude (buf, limit, name, op)
   nstrings = (nstrings << 8) | *cp++;
   nstrings = (nstrings << 8) | *cp++;
   
-  /* Looping over each string... */
+  /* Looping over each string...  */
   while (nstrings--) {
     U_CHAR *string_start;
     U_CHAR *endofthiskey;
@@ -5102,8 +5311,8 @@ pcfinclude (buf, limit, name, op)
     if ((HOST_WIDE_INT) cp & 3)
       cp += 4 - ((HOST_WIDE_INT) cp & 3);
     
-    /* Now get the string. */
-    str = (STRINGDEF *) cp;
+    /* Now get the string.  */
+    str = (STRINGDEF *) (GENERIC_PTR) cp;
     string_start = cp += sizeof (STRINGDEF);
     
     for (; *cp; cp++)          /* skip the string */
@@ -5112,7 +5321,7 @@ pcfinclude (buf, limit, name, op)
     /* We need to macro expand the string here to ensure that the
        proper definition environment is in place.  If it were only
        expanded when we find out it is needed, macros necessary for
-       its proper expansion might have had their definitions changed. */
+       its proper expansion might have had their definitions changed.  */
     tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
     /* Lineno is already set in the precompiled file */
     str->contents = tmpbuf.buf;
@@ -5125,31 +5334,31 @@ pcfinclude (buf, limit, name, op)
     *stringlist_tailp = str;
     stringlist_tailp = &str->chain;
     
-    /* Next comes a fourbyte number indicating the number of keys */
-    /* for this string. */
+    /* Next comes a fourbyte number indicating the number of keys
+       for this string.  */
     nkeys = *cp++;
     nkeys = (nkeys << 8) | *cp++;
     nkeys = (nkeys << 8) | *cp++;
     nkeys = (nkeys << 8) | *cp++;
 
-    /* If this number is -1, then the string is mandatory. */
+    /* If this number is -1, then the string is mandatory.  */
     if (nkeys == -1)
       str->writeflag = 1;
     else
       /* Otherwise, for each key, */
       for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
-       KEYDEF *kp = (KEYDEF *) cp;
+       KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
        HASHNODE *hp;
        
        /* It starts with a KEYDEF structure */
        cp += sizeof (KEYDEF);
        
        /* Find the end of the key.  At the end of this for loop we
-          advance CP to the start of the next key using this variable. */
-       endofthiskey = cp + strlen (cp);
+          advance CP to the start of the next key using this variable.  */
+       endofthiskey = cp + strlen ((char *) cp);
        kp->str = str;
        
-       /* Expand the key, and enter it into the hash table. */
+       /* Expand the key, and enter it into the hash table.  */
        tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
        tmpbuf.bufp = tmpbuf.buf;
        
@@ -5164,7 +5373,7 @@ pcfinclude (buf, limit, name, op)
        hp = lookup (tmpbuf.bufp, -1, -1);
        if (hp == NULL) {
          kp->chain = 0;
-         install (tmpbuf.bufp, -1, T_PCSTRING, 0, (char *) kp, -1);
+         install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
        }
        else if (hp->type == T_PCSTRING) {
          kp->chain = hp->value.keydef;
@@ -5174,14 +5383,15 @@ pcfinclude (buf, limit, name, op)
          str->writeflag = 1;
       }
   }
-  /* This output_line_command serves to switch us back to the current
+  /* This output_line_directive serves to switch us back to the current
      input file in case some of these strings get output (which will 
-     result in line commands for the header file being output). */
-  output_line_command (&instack[indepth], op, 0, enter_file);
+     result in line directives for the header file being output).   */
+  output_line_directive (&instack[indepth], op, 0, enter_file);
 }
 
-/* Called from rescan when it hits a key for strings.  Mark them all */
- /* used and clean up. */
+/* Called from rescan when it hits a key for strings.  Mark them all
+   used and clean up.  */
+
 static void
 pcstring_used (hp)
      HASHNODE *hp;
@@ -5193,21 +5403,22 @@ pcstring_used (hp)
   delete_macro (hp);
 }
 
-/* Write the output, interspersing precompiled strings in their */
- /* appropriate places. */
+/* Write the output, interspersing precompiled strings in their
+   appropriate places.  */
+
 static void
 write_output ()
 {
   STRINGDEF *next_string;
   U_CHAR *cur_buf_loc;
-  int line_command_len = 80;
-  char *line_command = xmalloc (line_command_len);
+  int line_directive_len = 80;
+  char *line_directive = xmalloc (line_directive_len);
   int len;
 
-  /* In each run through the loop, either cur_buf_loc == */
-  /* next_string_loc, in which case we print a series of strings, or */
-  /* it is less than next_string_loc, in which case we write some of */
-  /* the buffer. */
+  /* In each run through the loop, either cur_buf_loc ==
+     next_string_loc, in which case we print a series of strings, or
+     it is less than next_string_loc, in which case we write some of
+     the buffer.  */
   cur_buf_loc = outbuf.buf; 
   next_string = stringlist;
   
@@ -5215,16 +5426,17 @@ write_output ()
     if (next_string
        && cur_buf_loc - outbuf.buf == next_string->output_mark) {
       if (next_string->writeflag) {
-       len = 4 * strlen (next_string->filename) + 32;
-       while (len > line_command_len)
-         line_command = xrealloc (line_command
-                                  line_command_len *= 2);
-       sprintf (line_command, "\n# %d ", next_string->lineno);
-       strcpy (quote_string (line_command + strlen (line_command),
-                             next_string->filename),
+       len = 4 * strlen ((char *) next_string->filename) + 32;
+       while (len > line_directive_len)
+         line_directive = xrealloc (line_directive
+                                    line_directive_len *= 2);
+       sprintf (line_directive, "\n# %d ", next_string->lineno);
+       strcpy (quote_string (line_directive + strlen (line_directive),
+                             (char *) next_string->filename),
                "\n");
-       safe_write (fileno (stdout), line_command, strlen (line_command));
-       safe_write (fileno (stdout), next_string->contents, next_string->len);
+       safe_write (fileno (stdout), line_directive, strlen (line_directive));
+       safe_write (fileno (stdout),
+                   (char *) next_string->contents, next_string->len);
       }              
       next_string = next_string->chain;
     }
@@ -5234,11 +5446,11 @@ write_output ()
                - (cur_buf_loc - outbuf.buf))
             : outbuf.bufp - cur_buf_loc);
       
-      safe_write (fileno (stdout), cur_buf_loc, len);
+      safe_write (fileno (stdout), (char *) cur_buf_loc, len);
       cur_buf_loc += len;
     }
   }
-  free (line_command);
+  free (line_directive);
 }
 
 /* Pass a directive through to the output file.
@@ -5279,7 +5491,7 @@ pass_thru_directive (buf, limit, op, keyword)
    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. */
+   hash table.  */
 
 struct arglist {
   struct arglist *next;
@@ -5290,7 +5502,8 @@ struct arglist {
 };
 
 /* Create a DEFINITION node from a #define directive.  Arguments are 
-   as for do_define. */
+   as for do_define.  */
+
 static MACRODEF
 create_definition (buf, limit, op)
      U_CHAR *buf, *limit;
@@ -5319,7 +5532,7 @@ create_definition (buf, limit, op)
 
   /* 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. */
+     care of that.  */
 
   if (*bp == '(') {
     struct arglist *arg_ptrs = NULL;
@@ -5350,8 +5563,8 @@ create_definition (buf, limit, op)
       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) {
+       if (limit - bp > REST_EXTENSION_LENGTH
+           && bcmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
          rest_args = 1;
          temp->rest_args = 1;
          break;
@@ -5369,6 +5582,11 @@ create_definition (buf, limit, op)
       if (*bp == ',') {
        bp++;
        SKIP_WHITE_SPACE (bp);
+       /* A comma at this point can only be followed by an identifier.  */
+       if (!is_idstart[*bp]) {
+         error ("badly punctuated parameter list in `#define'");
+         goto nope;
+       }
       }
       if (bp >= limit) {
        error ("unterminated parameter list in `#define'");
@@ -5378,24 +5596,18 @@ create_definition (buf, limit, op)
        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';
-             error ("duplicate argument name `%s' in `#define'", name);
+         if (temp->length == otemp->length
+             && bcmp (temp->name, otemp->name, temp->length) == 0) {
+             error ("duplicate argument name `%.*s' in `#define'",
+                    temp->length, temp->name);
              goto nope;
          }
       }
     }
 
     ++bp;                      /* skip paren */
-    /* Skip spaces and tabs if any.  */
-    while (bp < limit && (*bp == ' ' || *bp == '\t'))
-      ++bp;
-    /* now everything from bp before limit is the definition. */
+    SKIP_WHITE_SPACE (bp);
+    /* now everything from bp before limit is the definition.  */
     defn = collect_expansion (bp, limit, argno, arg_ptrs);
     defn->rest_args = rest_args;
 
@@ -5421,14 +5633,11 @@ create_definition (buf, limit, op)
 
     if (bp < limit)
       {
-       switch (*bp)
-         {
-           case '\t': case ' ':
-             /* Skip spaces and tabs.  */
-             while (++bp < limit && (*bp == ' ' || *bp == '\t'))
-               continue;
-             break;
-
+       if (is_hor_space[*bp]) {
+         bp++;
+         SKIP_WHITE_SPACE (bp);
+       } else if (sym_length) {
+         switch (*bp) {
            case '!':  case '"':  case '#':  case '%':  case '&':  case '\'':
            case ')':  case '*':  case '+':  case ',':  case '-':  case '.':
            case '/':  case ':':  case ';':  case '<':  case '=':  case '>':
@@ -5443,8 +5652,9 @@ create_definition (buf, limit, op)
                       sym_length, symname);
              break;
          }
+       }
       }
-    /* Now everything from bp before limit is the definition. */
+    /* Now everything from bp before limit is the definition.  */
     defn = collect_expansion (bp, limit, -1, NULL_PTR);
     defn->args.argnames = (U_CHAR *) "";
   }
@@ -5465,8 +5675,8 @@ create_definition (buf, limit, op)
   return mdef;
 }
  
-/* Process a #define command.
-BUF points to the contents of the #define command, as a contiguous string.
+/* Process a #define directive.
+BUF points to the contents of the #define directive, as a contiguous string.
 LIMIT points to the first character past the end of the definition.
 KEYWORD is the keyword-table entry for #define.  */
 
@@ -5479,7 +5689,7 @@ do_define (buf, limit, op, keyword)
   int hashcode;
   MACRODEF mdef;
 
-  /* If this is a precompiler run (with -pcp) pass thru #define commands.  */
+  /* If this is a precompiler run (with -pcp) pass thru #define directives.  */
   if (pcp_outfile && op)
     pass_thru_directive (buf, limit, op, keyword);
 
@@ -5504,18 +5714,12 @@ do_define (buf, limit, op, keyword)
         ok = ! 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 (debug_output && op)
          pass_thru_directive (buf, limit, op, keyword);
 
-       msg = (U_CHAR *) alloca (mdef.symlen + 22);
-       *msg = '`';
-       bcopy ((char *) mdef.symnam, (char *) (msg + 1), mdef.symlen);
-       strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
-       pedwarn (msg);
+       pedwarn ("`%.*s' redefined", mdef.symlen, mdef.symnam);
        if (hp->type == T_MACRO)
          pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line,
                                      "this is the location of the previous definition");
@@ -5528,7 +5732,7 @@ do_define (buf, limit, op, keyword)
         that for this new definition now.  */
       if (debug_output && op)
        pass_thru_directive (buf, limit, op, keyword);
-      install (mdef.symnam, mdef.symlen, T_MACRO, 0,
+      install (mdef.symnam, mdef.symlen, T_MACRO,
               (char *) mdef.defn, hashcode);
     }
   }
@@ -5554,24 +5758,17 @@ check_macro_name (symname, usage)
   for (p = symname; is_idchar[*p]; p++)
     ;
   sym_length = p - symname;
-  if (sym_length == 0)
+  if (sym_length == 0
+      || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
     error ("invalid %s name", usage);
-  else if (!is_idstart[*symname]) {
-    U_CHAR *msg;                       /* what pain... */
-    msg = (U_CHAR *) alloca (sym_length + 1);
-    bcopy ((char *) symname, (char *) msg, sym_length);
-    msg[sym_length] = 0;
-    error ("invalid %s name `%s'", usage, msg);
-  } else {
-    if (! strncmp (symname, "defined", 7) && sym_length == 7)
-      error ("invalid %s name `defined'", usage);
-  }
+  else if (!is_idstart[*symname]
+          || (sym_length == 7 && ! bcmp (symname, "defined", 7)))
+    error ("invalid %s name `%.*s'", usage, sym_length, symname);
   return sym_length;
 }
 
-/*
- * return zero if two DEFINITIONs are isomorphic
- */
+/* Return zero if two DEFINITIONs are isomorphic.  */
+     
 static int
 compare_defs (d1, d2)
      DEFINITION *d1, *d2;
@@ -5587,7 +5784,7 @@ compare_defs (d1, d2)
     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))
+    if (!((a1->nchars == a2->nchars && ! bcmp (p1, p2, a1->nchars))
          || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
        || a1->argno != a2->argno
        || a1->stringify != a2->stringify
@@ -5652,16 +5849,10 @@ comp_def_part (first, beg1, len1, beg2, len2, last)
    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.  */
-
-/* Leading and trailing Space, Tab, etc. are converted to markers
-   Newline Space, Newline Tab, etc.
-   Newline Space makes a space in the final output
-   but is discarded if stringified.  (Newline Tab is similar but
-   makes a Tab instead.)
+Note that comments, backslash-newlines, and leading white space
+have already been deleted from the argument.  */
 
-   If there is no trailing whitespace, a Newline Space is added at the end
+/* If there is no trailing whitespace, a Newline Space is added at the end
    to prevent concatenation that would be contrary to the standard.  */
 
 static DEFINITION *
@@ -5677,31 +5868,30 @@ collect_expansion (buf, end, nargs, arglist)
   U_CHAR *concat = 0;
   /* Pointer to first nonspace after last single-# seen.  */
   U_CHAR *stringify = 0;
+  /* How those tokens were spelled.  */
+  enum sharp_token_type concat_sharp_token_type = NO_SHARP_TOKEN;
+  enum sharp_token_type stringify_sharp_token_type = NO_SHARP_TOKEN;
   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. */
+     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,
+     Each 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.  */
+     The extra 3 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);
 
@@ -5709,17 +5899,11 @@ collect_expansion (buf, end, nargs, arglist)
   exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
   lastp = exp_p;
 
-  p = buf;
-
-  /* Convert leading whitespace to Newline-markers.  */
-  while (p < limit && is_space[*p]) {
-    *exp_p++ = '\n';
-    *exp_p++ = *p++;
-  }
-
-  if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
+  if (p[0] == '#'
+      ? p[1] == '#'
+      : p[0] == '%' && p[1] == ':' && p[2] == '%' && p[3] == ':') {
     error ("`##' at start of macro definition");
-    p += 2;
+    p += p[0] == '#' ? 2 : 4;
   }
 
   /* Process the main body of the definition.  */
@@ -5748,11 +5932,32 @@ collect_expansion (buf, end, nargs, arglist)
        }
        break;
 
+      case '%':
+       if (!expected_delimiter && *p == ':') {
+         /* %: is not a digraph if preceded by an odd number of '<'s.  */
+         U_CHAR *p0 = p - 1;
+         while (buf < p0 && p0[-1] == '<')
+           p0--;
+         if ((p - p0) & 1) {
+           /* Treat %:%: as ## and %: as #.  */
+           if (p[1] == '%' && p[2] == ':') {
+             p += 2;
+             goto sharp_sharp_token;
+           }
+           if (nargs >= 0) {
+             p++;
+             goto sharp_token;
+           }
+         }
+       }
+       break;
+
       case '#':
        /* # is ordinary inside a string.  */
        if (expected_delimiter)
          break;
-       if (p < limit && *p == '#') {
+       if (*p == '#') {
+       sharp_sharp_token:
          /* ##: concatenate preceding and following tokens.  */
          /* Take out the first #, discard preceding whitespace.  */
          exp_p--;
@@ -5760,17 +5965,28 @@ collect_expansion (buf, end, nargs, arglist)
            --exp_p;
          /* Skip the second #.  */
          p++;
-         /* Discard following whitespace.  */
-         SKIP_WHITE_SPACE (p);
+         concat_sharp_token_type = c;
+         if (is_hor_space[*p]) {
+           concat_sharp_token_type = c + 1;
+           p++;
+           SKIP_WHITE_SPACE (p);
+         }
          concat = p;
          if (p == limit)
            error ("`##' at end of macro definition");
        } else if (nargs >= 0) {
          /* Single #: stringify following argument ref.
             Don't leave the # in the expansion.  */
+       sharp_token:
          exp_p--;
-         SKIP_WHITE_SPACE (p);
-         if (p == limit || ! is_idstart[*p])
+         stringify_sharp_token_type = c;
+         if (is_hor_space[*p]) {
+           stringify_sharp_token_type = c + 1;
+           p++;
+           SKIP_WHITE_SPACE (p);
+         }
+         if (! is_idstart[*p] || nargs == 0
+             || (*p == 'L' && (p[1] == '\'' || p[1] == '"')))
            error ("`#' operator is not followed by a macro argument name");
          else
            stringify = p;
@@ -5809,9 +6025,12 @@ collect_expansion (buf, end, nargs, arglist)
             this must be -traditional.  So replace the comment with
             nothing at all.  */
          exp_p--;
-         p += 1;
-         while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
-           p++;
+         while (++p < limit) {
+           if (p[0] == '*' && p[1] == '/') {
+             p += 2;
+             break;
+           }
+         }
 #if 0
          /* Mark this as a concatenation-point, as if it had been ##.  */
          concat = p;
@@ -5830,7 +6049,8 @@ collect_expansion (buf, end, nargs, arglist)
       while (p != limit && is_idchar[*p]) p++;
       id_len = p - id_beg;
 
-      if (is_idstart[c]) {
+      if (is_idstart[c]
+         && ! (id_len == 1 && c == 'L' && (*p == '\'' || *p == '"'))) {
        register struct arglist *arg;
 
        for (arg = arglist; arg != NULL; arg = arg->next) {
@@ -5838,28 +6058,36 @@ collect_expansion (buf, end, nargs, arglist)
 
          if (arg->name[0] == c
              && arg->length == id_len
-             && strncmp (arg->name, id_beg, id_len) == 0) {
-           if (expected_delimiter && warn_stringify) {
-             if (traditional) {
-               warning ("macro argument `%.*s' is stringified.",
-                        id_len, arg->name);
-             } else {
-               warning ("macro arg `%.*s' would be stringified with -traditional.",
-                        id_len, arg->name);
+             && bcmp (arg->name, id_beg, id_len) == 0) {
+           enum sharp_token_type tpat_stringify;
+           if (expected_delimiter) {
+             if (warn_stringify) {
+               if (traditional) {
+                 warning ("macro argument `%.*s' is stringified.",
+                          id_len, arg->name);
+               } else {
+                 warning ("macro arg `%.*s' would be stringified with -traditional.",
+                          id_len, arg->name);
+               }
              }
+             /* If ANSI, don't actually substitute inside a string.  */
+             if (!traditional)
+               break;
+             tpat_stringify = SHARP_TOKEN;
+           } else {
+             tpat_stringify
+               = (stringify == id_beg
+                  ? stringify_sharp_token_type : NO_SHARP_TOKEN);
            }
-           /* If ANSI, don't actually substitute inside a string.  */
-           if (!traditional && 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->raw_before
+             = concat == id_beg ? concat_sharp_token_type : NO_SHARP_TOKEN;
+           tpat->raw_after = NO_SHARP_TOKEN;
            tpat->rest_args = arg->rest_args;
-           tpat->stringify = (traditional ? expected_delimiter != '\0'
-                              : stringify == id_beg);
+           tpat->stringify = tpat_stringify;
 
            if (endpat == NULL)
              defn->pattern = tpat;
@@ -5872,8 +6100,10 @@ collect_expansion (buf, end, nargs, arglist)
            {
              register U_CHAR *p1 = p;
              SKIP_WHITE_SPACE (p1);
-             if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
-               tpat->raw_after = 1;
+             if (p1[0]=='#'
+                 ? p1[1]=='#'
+                 : p1[0]=='%' && p1[1]==':' && p1[2]=='%' && p1[3]==':')
+               tpat->raw_after = p1[0] + (p != p1);
            }
            lastp = exp_p;      /* place to start copying from next time */
            skipped_arg = 1;
@@ -5895,9 +6125,9 @@ collect_expansion (buf, end, nargs, arglist)
   }
 
   if (!traditional && 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).  */
+    /* If ANSI, put in a newline-space marker to prevent token pasting.
+       But not if "inside a string" (which in ANSI mode happens only for
+       -D option).  */
     *exp_p++ = '\n';
     *exp_p++ = ' ';
   }
@@ -5946,7 +6176,7 @@ do_assert (buf, limit, op, keyword)
 
   /* Lossage will occur if identifiers or control tokens are broken
      across lines using backslash.  This is not the right place to take
-     care of that. */
+     care of that.  */
 
   if (*bp != '(') {
     error ("missing token-sequence in `#assert'");
@@ -5982,7 +6212,7 @@ do_assert (buf, limit, op, keyword)
 
     hp = assertion_lookup (symname, sym_length, hashcode);
     if (hp == NULL) {
-      if (sym_length == 7 && ! strncmp (symname, "defined", sym_length))
+      if (sym_length == 7 && ! bcmp (symname, "defined", 7))
        error ("`defined' redefined as assertion");
       hp = assertion_install (symname, sym_length, hashcode);
     }
@@ -6025,7 +6255,7 @@ do_unassert (buf, limit, op, keyword)
 
   /* Lossage will occur if identifiers or control tokens are broken
      across lines using backslash.  This is not the right place to take
-     care of that. */
+     care of that.  */
 
   if (*bp == '(') {
     int error_flag = 0;
@@ -6146,7 +6376,7 @@ compare_token_lists (l1, l2)
   while (l1 && l2) {
     if (l1->length != l2->length)
       return 0;
-    if (strncmp (l1->name, l2->name, l1->length))
+    if (bcmp (l1->name, l2->name, l1->length))
       return 0;
     l1 = l1->next;
     l2 = l2->next;
@@ -6239,15 +6469,14 @@ free_token_list (tokens)
   }
 }
 \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.
- */
+/* 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 (name, len, hash)
      U_CHAR *name;
@@ -6278,16 +6507,15 @@ assertion_install (name, len, hash)
   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.
- */
+/* 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 (name, len, hash)
      U_CHAR *name;
@@ -6298,7 +6526,7 @@ assertion_lookup (name, len, hash)
 
   bucket = assertion_hashtab[hash];
   while (bucket) {
-    if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
+    if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
       return bucket;
     bucket = bucket->next;
   }
@@ -6315,8 +6543,8 @@ delete_assertion (hp)
   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. */
+  /* 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;
 
@@ -6324,7 +6552,7 @@ delete_assertion (hp)
 }
 \f
 /*
- * interpret #line command.  Remembers previously seen fnames
+ * interpret #line directive.  Remembers previously seen fnames
  * in its very own hash table.
  */
 #define FNAME_HASHSIZE 37
@@ -6349,18 +6577,18 @@ do_line (buf, limit, op, keyword)
   SKIP_WHITE_SPACE (bp);
 
   if (!isdigit (*bp)) {
-    error ("invalid format `#line' command");
+    error ("invalid format `#line' directive");
     return 0;
   }
 
   /* 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 (bp) - 1;
+  new_lineno = atoi ((char *) bp) - 1;
 
   /* NEW_LINENO is one less than the actual line number here.  */
   if (pedantic && new_lineno < 0)
-    pedwarn ("line number out of range in `#line' command");
+    pedwarn ("line number out of range in `#line' directive");
 
   /* skip over the line number.  */
   while (isdigit (*bp))
@@ -6368,7 +6596,7 @@ do_line (buf, limit, op, keyword)
 
 #if 0 /* #line 10"foo.c" is supposed to be allowed.  */
   if (*bp && !is_space[*bp]) {
-    error ("invalid format `#line' command");
+    error ("invalid format `#line' directive");
     return;
   }
 #endif
@@ -6389,13 +6617,13 @@ do_line (buf, limit, op, keyword)
     for (;;)
       switch ((*p++ = *bp++)) {
       case '\0':
-       error ("invalid format `#line' command");
+       error ("invalid format `#line' directive");
        return 0;
 
       case '\\':
        {
          char *bpc = (char *) bp;
-         int c = parse_escape (&bpc);
+         HOST_WIDE_INT c = parse_escape (&bpc, (HOST_WIDE_INT) (U_CHAR) (-1));
          bp = (U_CHAR *) bpc;
          if (c < 0)
            p--;
@@ -6414,7 +6642,7 @@ do_line (buf, limit, op, keyword)
     SKIP_WHITE_SPACE (bp);
     if (*bp) {
       if (pedantic)
-       pedwarn ("garbage at end of `#line' command");
+       pedwarn ("garbage at end of `#line' directive");
       if (*bp == '1')
        file_change = enter_file;
       else if (*bp == '2')
@@ -6424,7 +6652,7 @@ do_line (buf, limit, op, keyword)
       else if (*bp == '4')
        ip->system_header_p = 2;
       else {
-       error ("invalid format `#line' command");
+       error ("invalid format `#line' directive");
        return 0;
       }
 
@@ -6441,16 +6669,15 @@ do_line (buf, limit, op, keyword)
        SKIP_WHITE_SPACE (bp);
       }
       if (*bp) {
-       error ("invalid format `#line' command");
+       error ("invalid format `#line' directive");
        return 0;
       }
     }
 
-    hash_bucket =
-      &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
+    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) {
+         bcmp (hp->value.cpval, fname, fname_length) == 0) {
        ip->nominal_fname = hp->value.cpval;
        break;
       }
@@ -6465,21 +6692,19 @@ do_line (buf, limit, op, keyword)
       bcopy (fname, hp->value.cpval, fname_length);
     }
   } else if (*bp) {
-    error ("invalid format `#line' command");
+    error ("invalid format `#line' directive");
     return 0;
   }
 
   ip->lineno = new_lineno;
-  output_line_command (ip, op, 0, file_change);
+  output_line_directive (ip, op, 0, file_change);
   check_expand (op, ip->length - (ip->bufp - ip->buf));
   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.
- */
+/* 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 (buf, limit, op, keyword)
@@ -6491,7 +6716,7 @@ do_undef (buf, limit, op, keyword)
   HASHNODE *hp;
   U_CHAR *orig_buf = buf;
 
-  /* If this is a precompiler run (with -pcp) pass thru #undef commands.  */
+  /* If this is a precompiler run (with -pcp) pass thru #undef directives.  */
   if (pcp_outfile && op)
     pass_thru_directive (buf, limit, op, keyword);
 
@@ -6500,7 +6725,7 @@ do_undef (buf, limit, op, keyword)
 
   while ((hp = lookup (buf, sym_length, -1)) != NULL) {
     /* If we are generating additional info for debugging (with -g) we
-       need to pass through all effective #undef commands.  */
+       need to pass through all effective #undef directives.  */
     if (debug_output && op)
       pass_thru_directive (orig_buf, limit, op, keyword);
     if (hp->type != T_MACRO)
@@ -6517,11 +6742,9 @@ do_undef (buf, limit, op, keyword)
   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#.)
- */
+/* 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 (buf, limit, op, keyword)
@@ -6530,7 +6753,7 @@ do_error (buf, limit, op, keyword)
      struct directive *keyword;
 {
   int length = limit - buf;
-  U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
+  U_CHAR *copy = (U_CHAR *) alloca (length + 1);
   bcopy ((char *) buf, (char *) copy, length);
   copy[length] = 0;
   SKIP_WHITE_SPACE (copy);
@@ -6538,11 +6761,9 @@ do_error (buf, limit, op, keyword)
   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#.)
- */
+/* 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 (buf, limit, op, keyword)
@@ -6551,52 +6772,41 @@ do_warning (buf, limit, op, keyword)
      struct directive *keyword;
 {
   int length = limit - buf;
-  U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
+  U_CHAR *copy = (U_CHAR *) alloca (length + 1);
   bcopy ((char *) buf, (char *) copy, length);
   copy[length] = 0;
   SKIP_WHITE_SPACE (copy);
-  warning ("#warning %s", copy);
+  /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
+     if -pedantic-errors is given, #warning should cause an error.  */
+  pedwarn ("#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
+static void
 do_once ()
 {
   int i;
-  FILE_BUF *ip = NULL;
 
   for (i = indepth; i >= 0; i--)
-    if (instack[i].fname != NULL) {
-      ip = &instack[i];
+    if (instack[i].inc) {
+      record_control_macro (instack[i].inc, (U_CHAR *) "");
       break;
     }
-
-  if (ip != NULL) {
-    struct file_name_list *new;
-    
-    new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
-    new->next = dont_repeat_files;
-    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 (buf, limit)
+do_ident (buf, limit, op, keyword)
      U_CHAR *buf, *limit;
+     FILE_BUF *op;
+     struct directive *keyword;
 {
   FILE_BUF trybuf;
   int len;
-  FILE_BUF *op = &outbuf;
 
   /* Allow #ident in system headers, since that's not user's fault.  */
   if (pedantic && !instack[indepth].system_header_p)
@@ -6626,12 +6836,13 @@ do_ident (buf, limit)
    Just check for some recognized pragmas that need validation here.  */
 
 static int
-do_pragma (buf, limit)
+do_pragma (buf, limit, op, keyword)
      U_CHAR *buf, *limit;
+     FILE_BUF *op;
+     struct directive *keyword;
 {
-  while (*buf == ' ' || *buf == '\t')
-    buf++;
-  if (!strncmp (buf, "once", 4)) {
+  SKIP_WHITE_SPACE (buf);
+  if (!strncmp ((char *) buf, "once", 4)) {
     /* Allow #pragma once in system headers, since that's not the user's
        fault.  */
     if (!instack[indepth].system_header_p)
@@ -6639,28 +6850,30 @@ do_pragma (buf, limit)
     do_once ();
   }
 
-  if (!strncmp (buf, "implementation", 14)) {
+  if (!strncmp ((char *) 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 h;
+    U_CHAR *p = buf + 14, *fname;
     SKIP_WHITE_SPACE (p);
     if (*p == '\n' || *p != '\"')
       return 0;
 
     fname = p + 1;
-    if (p = (U_CHAR *) index (fname, '\"'))
+    if ((p = (U_CHAR *) index ((char *) fname, '\"')))
       *p = '\0';
     
-    for (ptr = 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 && !strcmp (inc_fname, fname))
-       warning ("`#pragma implementation' for `%s' appears after file is included",
-                fname);
+    for (h = 0; h < INCLUDE_HASHSIZE; h++) {
+      struct include_file *inc;
+      for (inc = include_hashtab[h]; inc; inc = inc->next) {
+       if (!strcmp (base_name (inc->fname), (char *) fname)) {
+         warning ("`#pragma implementation' for \"%s\" appears after its #include",fname);
+         return 0;
+       }
+      }
     }
   }
-
   return 0;
 }
 
@@ -6668,10 +6881,8 @@ do_pragma (buf, limit)
 /* 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.
- */
+/* The behavior of the #pragma directive is implementation defined.
+   this implementation defines it as follows.  */
 
 static int
 do_pragma ()
@@ -6691,28 +6902,33 @@ nope:
 }
 #endif
 
+#ifdef SCCS_DIRECTIVE
+
 /* Just ignore #sccs, on systems where we define it at all.  */
 
 static int
-do_sccs ()
+do_sccs (buf, limit, op, keyword)
+     U_CHAR *buf, *limit;
+     FILE_BUF *op;
+     struct directive *keyword;
 {
   if (pedantic)
     pedwarn ("ANSI C does not allow `#sccs'");
   return 0;
 }
+
+#endif /* defined (SCCS_DIRECTIVE) */
 \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.
- */
+/* Handle #if directive 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 directive)
+     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 (buf, limit, op, keyword)
@@ -6728,10 +6944,8 @@ do_if (buf, limit, op, keyword)
   return 0;
 }
 
-/*
- * handle a #elif directive by not changing  if_stack  either.
- * see the comment above do_else.
- */
+/* Handle a #elif directive by not changing  if_stack  either.
+   see the comment above do_else.  */
 
 static int
 do_elif (buf, limit, op, keyword)
@@ -6749,8 +6963,8 @@ do_elif (buf, limit, op, keyword)
     if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
       error ("`#elif' after `#else'");
       fprintf (stderr, " (matches line %d", if_stack->lineno);
-      if (if_stack->fname != NULL && ip->fname != NULL &&
-         strcmp (if_stack->fname, ip->nominal_fname) != 0)
+      if (if_stack->fname != NULL && ip->fname != NULL
+         && strcmp (if_stack->fname, ip->nominal_fname) != 0)
        fprintf (stderr, ", file %s", if_stack->fname);
       fprintf (stderr, ")\n");
     }
@@ -6765,16 +6979,15 @@ do_elif (buf, limit, op, keyword)
       skip_if_group (ip, 0, op);
     else {
       ++if_stack->if_succeeded;        /* continue processing input */
-      output_line_command (ip, op, 1, same_file);
+      output_line_directive (ip, op, 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.
- */
+/* Evaluate a #if expression in BUF, of length LENGTH, then parse the
+   result as a C expression and return the value as an int.  */
+
 static HOST_WIDE_INT
 eval_if_expression (buf, length)
      U_CHAR *buf;
@@ -6784,24 +6997,24 @@ eval_if_expression (buf, length)
   HASHNODE *save_defined;
   HOST_WIDE_INT value;
 
-  save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, NULL_PTR, -1);
+  save_defined = install ((U_CHAR *) "defined", -1, T_SPEC_DEFINED,
+                         NULL_PTR, -1);
   pcp_inside_if = 1;
   temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1);
   pcp_inside_if = 0;
   delete_macro (save_defined); /* clean up special symbol */
 
-  value = parse_c_expression (temp_obuf.buf);
+  temp_obuf.buf[temp_obuf.length] = '\n';
+  value = parse_c_expression ((char *) temp_obuf.buf);
 
   free (temp_obuf.buf);
 
   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.
- */
+/* 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 (buf, limit, op, keyword)
@@ -6822,7 +7035,11 @@ do_xifdef (buf, limit, op, keyword)
       U_CHAR c = *p++;
       if (is_space[c])
        ;
-      else if (c == '/' && p != ip->bufp && *p == '*') {
+      /* Make no special provision for backslash-newline here; this is
+        slower if backslash-newlines are present, but it's correct,
+        and it's not worth it to tune for the rare backslash-newline.  */
+      else if (c == '/'
+              && (*p == '*' || (cplusplus_comments && *p == '/'))) {
        /* Skip this comment.  */
        int junk = 0;
        U_CHAR *save_bufp = ip->bufp;
@@ -6854,18 +7071,20 @@ do_xifdef (buf, limit, op, keyword)
   } else {
     HASHNODE *hp;
 
-    if (pedantic && buf[0] >= '0' && buf[0] <= '9')
-      pedwarn ("`#%s' argument starts with a digit", keyword->name);
-    else if (end != limit && !traditional)
-      pedwarn ("garbage at end of `#%s' argument", keyword->name);
+    if (! traditional) {
+      if (isdigit (buf[0]))
+       pedwarn ("`#%s' argument starts with a digit", keyword->name);
+      else if (end != limit)
+       pedwarn ("garbage at end of `#%s' argument", keyword->name);
+    }
 
     hp = lookup (buf, end-buf, -1);
 
     if (pcp_outfile) {
       /* Output a precondition for this macro.  */
-      if (hp &&
-         (hp->type == T_CONST
-          || (hp->type == T_MACRO && hp->value.defn->predefined)))
+      if (hp
+         && (hp->type == T_CONST
+             || (hp->type == T_MACRO && hp->value.defn->predefined)))
        fprintf (pcp_outfile, "#define %s\n", hp->name);
       else {
        U_CHAR *cp = buf;
@@ -6917,15 +7136,14 @@ conditional_skip (ip, skip, type, control_macro, op)
     return;
   } else {
     ++if_stack->if_succeeded;
-    output_line_command (ip, &outbuf, 1, same_file);
+    output_line_directive (ip, &outbuf, 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.
- */
+/* 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 (ip, any, op)
      FILE_BUF *ip;
@@ -6956,7 +7174,7 @@ skip_if_group (ip, any, op)
     bcopy (ptr, (char *) op->bufp, len);
     op->bufp += len;
     op->lineno++;
-    output_line_command (ip, op, 1, 0);
+    output_line_directive (ip, op, 1, 0);
   }
 
   while (bp < endb) {
@@ -6987,18 +7205,27 @@ skip_if_group (ip, any, op)
       ++ip->lineno;
       beg_of_line = bp;
       break;
-    case '#':
+    case '%':
+      if (beg_of_line == 0 || traditional)
+       break;
       ip->bufp = bp - 1;
-
+      while (bp[0] == '\\' && bp[1] == '\n')
+       bp += 2;
+      if (*bp == ':')
+       goto sharp_token;
+      break;
+    case '#':
       /* # keyword: a # must be first nonblank char on the line */
       if (beg_of_line == 0)
        break;
+      ip->bufp = bp - 1;
+    sharp_token:
       /* Scan from start of line, skipping whitespace, comments
         and backslash-newlines, and see if we reach this #.
         If not, this # is not special.  */
       bp = beg_of_line;
       /* If -traditional, require # to be at beginning of line.  */
-      if (!traditional)
+      if (!traditional) {
        while (1) {
          if (is_hor_space[*bp])
            bp++;
@@ -7015,12 +7242,21 @@ skip_if_group (ip, any, op)
             comment and we would never reach here.  */
          else break;
        }
+      }
       if (bp != ip->bufp) {
        bp = ip->bufp + 1;      /* Reset bp to after the #.  */
        break;
       }
 
       bp = ip->bufp + 1;       /* Point after the '#' */
+      if (ip->bufp[0] == '%') {
+       /* Skip past the ':' again.  */
+       while (*bp == '\\') {
+         ip->lineno++;
+         bp += 2;
+       }
+       bp++;
+      }
 
       /* Skip whitespace and \-newline.  */
       while (1) {
@@ -7028,23 +7264,33 @@ skip_if_group (ip, any, op)
          bp++;
        else if (*bp == '\\' && bp[1] == '\n')
          bp += 2;
-       else if (*bp == '/' && bp[1] == '*') {
-         bp += 2;
-         while (!(*bp == '*' && bp[1] == '/')) {
-           if (*bp == '\n')
-             ip->lineno++;
-           bp++;
-         }
-         bp += 2;
-       } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') {
-         bp += 2;
-         while (bp[-1] == '\\' || *bp != '\n') {
-           if (*bp == '\n')
-             ip->lineno++;
-           bp++;
-         }
-        }
-       else break;
+       else if (*bp == '/') {
+         if (bp[1] == '*') {
+           for (bp += 2; ; bp++) {
+             if (*bp == '\n')
+               ip->lineno++;
+             else if (*bp == '*') {
+               if (bp[-1] == '/' && warn_comments)
+                 warning ("`/*' within comment");
+               if (bp[1] == '/')
+                 break;
+             }
+           }
+           bp += 2;
+         } else if (bp[1] == '/' && cplusplus_comments) {
+           for (bp += 2; ; bp++) {
+             if (*bp == '\n') {
+               if (bp[-1] != '\\')
+                 break;
+               if (warn_comments)
+                 warning ("multiline `//' comment");
+               ip->lineno++;
+             }
+           }
+         } else
+           break;
+        } else
+         break;
       }
 
       cp = bp;
@@ -7093,20 +7339,20 @@ skip_if_group (ip, any, op)
          while (*p == '#' || is_hor_space[*p]) p++;
          if (*p == '\n') {
            if (pedantic && !lang_asm)
-             pedwarn ("invalid preprocessor directive");
+             pedwarn ("invalid preprocessing directive");
            continue;
          }
        }
 
        if (!lang_asm && pedantic)
-         pedwarn ("invalid preprocessor directive name");
+         pedwarn ("invalid preprocessing directive name");
        continue;
       }
 
       for (kt = directive_table; kt->length >= 0; kt++) {
        IF_STACK_FRAME *temp;
        if (ident_length == kt->length
-           && strncmp (cp, kt->name, kt->length) == 0) {
+           && bcmp (cp, kt->name, kt->length) == 0) {
          /* If we are asked to return on next directive, do so now.  */
          if (any)
            goto done;
@@ -7125,7 +7371,7 @@ skip_if_group (ip, any, op)
          case T_ELSE:
          case T_ENDIF:
            if (pedantic && if_stack != save_if_stack)
-             validate_else (bp);
+             validate_else (bp, endb);
          case T_ELIF:
            if (if_stack == instack[indepth].if_stack) {
              error ("`#%s' not within a conditional", kt->name);
@@ -7145,13 +7391,16 @@ skip_if_group (ip, any, op)
            if_stack = if_stack->next;
            free (temp);
            break;
+
+          default:
+           break;
          }
          break;
        }
       }
       /* Don't let erroneous code go by.  */
       if (kt->length < 0 && !lang_asm && pedantic)
-       pedwarn ("invalid preprocessor directive name");
+       pedwarn ("invalid preprocessing directive name");
     }
   }
 
@@ -7182,12 +7431,10 @@ skip_if_group (ip, any, op)
   }
 }
 
-/*
- * 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.
- */
+/* 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 (buf, limit, op, keyword)
@@ -7225,14 +7472,12 @@ do_else (buf, limit, op, keyword)
     skip_if_group (ip, 0, op);
   else {
     ++if_stack->if_succeeded;  /* continue processing input */
-    output_line_command (ip, op, 1, same_file);
+    output_line_directive (ip, op, 1, same_file);
   }
   return 0;
 }
 
-/*
- * unstack after #endif command
- */
+/* Unstack after #endif directive.  */
 
 static int
 do_endif (buf, limit, op, keyword)
@@ -7260,23 +7505,17 @@ do_endif (buf, limit, op, keyword)
 
       while (p != ep) {
        U_CHAR c = *p++;
-       switch (c) {
-       case ' ':
-       case '\t':
-       case '\n':
-         break;
-       case '/':
-         if (p != ep && *p == '*') {
+       if (!is_space[c]) {
+         if (c == '/'
+             && (*p == '*' || (cplusplus_comments && *p == '/'))) {
            /* Skip this comment.  */
            int junk = 0;
            U_CHAR *save_bufp = ip->bufp;
            ip->bufp = p + 1;
            p = skip_to_end_of_comment (ip, &junk, 1);
            ip->bufp = save_bufp;
-         }
-         break;
-       default:
-         goto fail;
+         } else
+           goto fail;
        }
       }
       /* If we get here, this #endif ends a #ifndef
@@ -7289,54 +7528,56 @@ do_endif (buf, limit, op, keyword)
       if (indepth != 0
          && ! (indepth == 1 && no_record_file)
          && ! (no_record_file && no_output))
-       record_control_macro (ip->fname, temp->control_macro);
+       record_control_macro (ip->inc, temp->control_macro);
     fail: ;
     }
     free (temp);
-    output_line_command (&instack[indepth], op, 1, same_file);
+    output_line_directive (&instack[indepth], op, 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.  */
+   the directive name.  P points to the first char after the directive
+   name.  */
 
 static void
-validate_else (p)
+validate_else (p, limit)
      register U_CHAR *p;
+     register U_CHAR *limit;
 {
   /* Advance P over whitespace and comments.  */
   while (1) {
-    if (*p == '\\' && p[1] == '\n')
+    while (*p == '\\' && p[1] == '\n')
       p += 2;
     if (is_hor_space[*p])
       p++;
     else if (*p == '/') {
-      if (p[1] == '\\' && p[2] == '\n')
-       newline_fix (p + 1);
-      if (p[1] == '*') {
+      while (p[1] == '\\' && p[2] == '\n')
        p += 2;
+      if (p[1] == '*') {
        /* Don't bother warning about unterminated comments
           since that will happen later.  Just be sure to exit.  */
-       while (*p) {
-         if (p[1] == '\\' && p[2] == '\n')
-           newline_fix (p + 1);
-         if (*p == '*' && p[1] == '/') {
-           p += 2;
-           break;
+       for (p += 2; ; p++) {
+         if (p == limit)
+           return;
+         if (*p == '*') {
+           while (p[1] == '\\' && p[2] == '\n')
+             p += 2;
+           if (p[1] == '/') {
+             p += 2;
+             break;
+           }
          }
-         p++;
        }
       }
-      else if (cplusplus_comments && p[1] == '/') {
-       p += 2;
-       while (*p && (*p != '\n' || p[-1] == '\\'))
-         p++;
-      }
+      else if (cplusplus_comments && p[1] == '/')
+       return;
+      else break;
     } else break;
   }
-  if (*p && *p != '\n')
+  if (*p != '\n')
     pedwarn ("text following `#else' or `#endif' violates ANSI standard");
 }
 \f
@@ -7347,9 +7588,10 @@ validate_else (p)
    counter is not sufficient to deal with newlines in the string.
 
    If NOWARN is nonzero, don't warn about slash-star inside a comment.
-   This feature is useful when processing a comment that is going to be
-   processed or was processed at another point in the preprocessor,
-   to avoid a duplicate warning.  Likewise for unterminated comment errors.  */
+   This feature is useful when processing a comment that is going to
+   be processed or was processed at another point in the preprocessor,
+   to avoid a duplicate warning.  Likewise for unterminated comment
+   errors.  */
 
 static U_CHAR *
 skip_to_end_of_comment (ip, line_counter, nowarn)
@@ -7359,54 +7601,38 @@ skip_to_end_of_comment (ip, line_counter, nowarn)
 {
   register U_CHAR *limit = ip->buf + ip->length;
   register U_CHAR *bp = ip->bufp;
-  FILE_BUF *op = &outbuf;      /* JF */
-  int output = put_out_comments && !line_counter;
+  FILE_BUF *op = put_out_comments && !line_counter ? &outbuf : (FILE_BUF *) 0;
   int start_line = line_counter ? *line_counter : 0;
 
        /* JF this line_counter stuff is a crock to make sure the
           comment is only put out once, no matter how many times
           the comment is skipped.  It almost works */
-  if (output) {
+  if (op) {
     *op->bufp++ = '/';
-    *op->bufp++ = '*';
+    *op->bufp++ = bp[-1];
   }
   if (cplusplus_comments && bp[-1] == '/') {
-    if (output) {
-      while (bp < limit) {
-       *op->bufp++ = *bp;
-       if (*bp == '\n' && bp[-1] != '\\')
+    for (; bp < limit; bp++) {
+      if (*bp == '\n') {
+       if (bp[-1] != '\\')
          break;
-       if (*bp == '\n') {
+       if (!nowarn && warn_comments)
+         warning ("multiline `//' comment");
+       if (line_counter)
          ++*line_counter;
+       if (op)
          ++op->lineno;
-       }
-       bp++;
-      }
-      op->bufp[-1] = '*';
-      *op->bufp++ = '/';
-      *op->bufp++ = '\n';
-    } else {
-      while (bp < limit) {
-       if (bp[-1] != '\\' && *bp == '\n') {
-         break;
-       } else {
-         if (*bp == '\n' && line_counter)
-           ++*line_counter;
-         bp++;
-       }
       }
+      if (op)
+       *op->bufp++ = *bp;
     }
     ip->bufp = bp;
     return bp;
   }
   while (bp < limit) {
-    if (output)
+    if (op)
       *op->bufp++ = *bp;
     switch (*bp++) {
-    case '/':
-      if (warn_comments && !nowarn && bp < limit && *bp == '*')
-       warning ("`/*' within comment");
-      break;
     case '\n':
       /* If this is the end of the file, we have an unterminated comment.
         Don't swallow the newline.  We are guaranteed that there will be a
@@ -7419,14 +7645,16 @@ skip_to_end_of_comment (ip, line_counter, nowarn)
        }
       if (line_counter != NULL)
        ++*line_counter;
-      if (output)
+      if (op)
        ++op->lineno;
       break;
     case '*':
+      if (bp[-2] == '/' && !nowarn && warn_comments)
+       warning ("`/*' within comment");
       if (*bp == '\\' && bp[1] == '\n')
        newline_fix (bp);
       if (*bp == '/') {
-        if (output)
+        if (op)
          *op->bufp++ = '/';
        ip->bufp = ++bp;
        return bp;
@@ -7441,22 +7669,21 @@ skip_to_end_of_comment (ip, line_counter, nowarn)
   return bp;
 }
 
-/*
- * 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.
- *
- * If COUNT_NEWLINES is nonzero, it points to an int to increment
- * for each newline passed.
- *
- * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
- * if we pass a backslash-newline.
- *
- * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
- */
+/* 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.
+
+   If COUNT_NEWLINES is nonzero, it points to an int to increment
+   for each newline passed.
+
+   If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
+   if we pass a backslash-newline.
+
+   If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.  */
+
 static U_CHAR *
 skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
      register U_CHAR *bp;
@@ -7497,13 +7724,13 @@ skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p,
       bp++;
     } else if (c == '\n') {
       if (traditional) {
-       /* Unterminated strings and character constants are 'legal'.  */
-       bp--;   /* Don't consume the newline. */
+       /* Unterminated strings and character constants are 'valid'.  */
+       bp--;   /* Don't consume the newline.  */
        if (eofp)
          *eofp = 1;
        break;
       }
-      if (pedantic || match == '\'') {
+      if (match == '\'') {
        error_with_line (line_for_error (start_line),
                         "unterminated string or character constant");
        bp--;
@@ -7514,8 +7741,12 @@ skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p,
       /* If not traditional, then allow newlines inside strings.  */
       if (count_newlines)
        ++*count_newlines;
-      if (multiline_string_line == 0)
+      if (multiline_string_line == 0) {
+       if (pedantic)
+         pedwarn_with_line (line_for_error (start_line),
+                            "string constant runs past end of line");
        multiline_string_line = start_line;
+      }
     } else if (c == match)
       break;
   }
@@ -7524,6 +7755,7 @@ skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p,
 
 /* Place into DST a quoted string representing the string SRC.
    Return the address of DST's terminating null.  */
+
 static char *
 quote_string (dst, src)
      char *dst, *src;
@@ -7608,24 +7840,22 @@ skip_paren_group (ip)
   return p;
 }
 \f
-/*
- * 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.
- */
+/* Write out a #line directive, 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 (ip, op, conditional, file_change)
+output_line_directive (ip, op, conditional, file_change)
      FILE_BUF *ip, *op;
      int conditional;
      enum file_change_code file_change;
 {
   int len;
-  char *line_cmd_buf, *line_end;
+  char *line_directive_buf, *line_end;
 
-  if (no_line_commands
+  if (no_line_directives
       || ip->fname == NULL
       || no_output) {
     op->lineno = ip->lineno;
@@ -7637,7 +7867,7 @@ output_line_command (ip, op, conditional, file_change)
       return;
 
     /* If the inherited line number is a little too small,
-       output some newlines instead of a #line command.  */
+       output some newlines instead of a #line directive.  */
     if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
       check_expand (op, 10);
       while (ip->lineno > op->lineno) {
@@ -7648,20 +7878,16 @@ output_line_command (ip, op, conditional, file_change)
     }
   }
 
-  /* 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') {
+  /* Output a positive line number if possible.  */
+  while (ip->lineno <= 0 && ip->bufp - ip->buf < ip->length
+        && *ip->bufp == '\n') {
     ip->lineno++;
     ip->bufp++;
   }
 
-  line_cmd_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
-#ifdef OUTPUT_LINE_COMMANDS
-  sprintf (line_cmd_buf, "#line %d ", ip->lineno);
-#else
-  sprintf (line_cmd_buf, "# %d ", ip->lineno);
-#endif
-  line_end = quote_string (line_cmd_buf + strlen (line_cmd_buf),
+  line_directive_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100);
+  sprintf (line_directive_buf, "# %d ", ip->lineno);
+  line_end = quote_string (line_directive_buf + strlen (line_directive_buf),
                           ip->nominal_fname);
   if (file_change != same_file) {
     *line_end++ = ' ';
@@ -7680,11 +7906,11 @@ output_line_command (ip, op, conditional, file_change)
   }
 #endif
   *line_end++ = '\n';
-  len = line_end - line_cmd_buf;
+  len = line_end - line_directive_buf;
   check_expand (op, len + 1);
   if (op->bufp > op->buf && op->bufp[-1] != '\n')
     *op->bufp++ = '\n';
-  bcopy ((char *) line_cmd_buf, (char *) op->bufp, len);
+  bcopy ((char *) line_directive_buf, (char *) op->bufp, len);
   op->bufp += len;
   op->lineno = ip->lineno;
 }
@@ -7707,7 +7933,6 @@ struct argdata {
   int stringified_length;
   U_CHAR *free1, *free2;
   char newlines;
-  char comments;
   char use_count;
 };
 
@@ -7775,7 +8000,7 @@ macroexpand (hp, op)
       if (rest_args)
        continue;
       if (i < nargs || (nargs == 0 && i == 0)) {
-       /* if we are working on last arg which absorbs rest of args... */
+       /* If we are working on last arg which absorbs rest of args...  */
        if (i == nargs - 1 && defn->rest_args)
          rest_args = 1;
        parse_error = macarg (&args[i], rest_args);
@@ -7851,7 +8076,7 @@ macroexpand (hp, op)
       for (ap = defn->pattern; ap != NULL; ap = ap->next) {
        if (ap->stringify)
          xbuf_len += args[ap->argno].stringified_length;
-       else if (ap->raw_before || ap->raw_after || traditional)
+       else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
          /* Add 4 for two newline-space markers to prevent
             token concatenation.  */
          xbuf_len += args[ap->argno].raw_length + 4;
@@ -7897,9 +8122,9 @@ macroexpand (hp, op)
        /* 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)
+           && ((ap->rest_args && ap->raw_before != 0)
                || (last_ap != NULL && last_ap->rest_args
-                   && last_ap->raw_after))) {
+                   && last_ap->raw_after != 0))) {
          /* Delete final whitespace.  */
          while (totlen > count_before && is_space[xbuf[totlen - 1]]) {
            totlen--;
@@ -7977,10 +8202,10 @@ macroexpand (hp, op)
          }
          if (!traditional)
            xbuf[totlen++] = '\"'; /* insert ending quote */
-       } else if (ap->raw_before || ap->raw_after || traditional) {
+       } else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional) {
          U_CHAR *p1 = arg->raw;
          U_CHAR *l1 = p1 + arg->raw_length;
-         if (ap->raw_before) {
+         if (ap->raw_before != 0) {
            while (p1 != l1 && is_space[*p1]) p1++;
            while (p1 != l1 && is_idchar[*p1])
              xbuf[totlen++] = *p1++;
@@ -7995,7 +8220,7 @@ macroexpand (hp, op)
            xbuf[totlen++] = '\n';
            xbuf[totlen++] = ' ';
          }
-         if (ap->raw_after) {
+         if (ap->raw_after != 0) {
            /* Arg is concatenated after: delete trailing whitespace,
               whitespace markers, and no-reexpansion markers.  */
            while (p1 != l1) {
@@ -8016,7 +8241,7 @@ macroexpand (hp, op)
 
          bcopy ((char *) p1, (char *) (xbuf + totlen), l1 - p1);
          totlen += l1 - p1;
-         if (!traditional && !ap->raw_after) {
+         if (!traditional && ap->raw_after == 0) {
            /* Ordinary expanded use of the argument.
               Put in newline-space markers to prevent token pasting.  */
            xbuf[totlen++] = '\n';
@@ -8053,15 +8278,15 @@ macroexpand (hp, op)
          abort ();
       }
 
-      /* if there is anything left of the definition
-        after handling the arg list, copy that in too. */
+      /* 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))
+              && last_ap->raw_after != 0))
          xbuf[totlen++] = exp[i];
       }
 
@@ -8089,6 +8314,7 @@ macroexpand (hp, op)
 
     ip2->fname = 0;
     ip2->nominal_fname = 0;
+    ip2->inc = 0;
     /* This may not be exactly correct, but will give much better error
        messages for nested macro calls than using a line number of zero.  */
     ip2->lineno = start_line;
@@ -8109,11 +8335,9 @@ macroexpand (hp, op)
   }
 }
 \f
-/*
- * Parse a macro argument and store the info on it into *ARGPTR.
- * REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
- * Return nonzero to indicate a syntax error.
- */
+/* Parse a macro argument and store the info on it into *ARGPTR.
+   REST_ARGS is passed to macarg1 to make it absorb the rest of the args.
+   Return nonzero to indicate a syntax error.  */
 
 static char *
 macarg (argptr, rest_args)
@@ -8124,6 +8348,7 @@ macarg (argptr, rest_args)
   int paren = 0;
   int newlines = 0;
   int comments = 0;
+  char *result = 0;
 
   /* Try to parse as much of the argument as exists at this
      input stack level.  */
@@ -8156,8 +8381,8 @@ macarg (argptr, rest_args)
 
     while (bp == ip->buf + ip->length) {
       if (instack[indepth].macro == 0) {
-       free (buffer);
-       return "unterminated macro call";
+       result = "unterminated macro call";
+       break;
       }
       ip->macro->type = T_MACRO;
       if (ip->free_ptr)
@@ -8187,7 +8412,6 @@ macarg (argptr, rest_args)
       argptr->raw_length = bufsize;
       argptr->free1 = buffer;
       argptr->newlines = newlines;
-      argptr->comments = comments;
       if ((newlines || comments) && ip->fname != 0)
        argptr->raw_length
          = final_start +
@@ -8234,7 +8458,7 @@ macarg (argptr, rest_args)
     }
     argptr->stringified_length = totlen;
   }
-  return 0;
+  return result;
 }
 \f
 /* Scan text from START (inclusive) up to LIMIT (exclusive),
@@ -8284,27 +8508,33 @@ macarg1 (start, limit, depthptr, newlines, comments, rest_args)
     case '/':
       if (bp[1] == '\\' && bp[2] == '\n')
        newline_fix (bp + 1);
-      if (cplusplus_comments && bp[1] == '/') {
+      if (bp[1] == '*') {
        *comments = 1;
-       bp += 2;
-       while (bp < limit && (*bp != '\n' || bp[-1] == '\\')) {
-         if (*bp == '\n') ++*newlines;
-         bp++;
+       for (bp += 2; bp < limit; bp++) {
+         if (*bp == '\n')
+           ++*newlines;
+         else if (*bp == '*') {
+           if (bp[-1] == '/' && warn_comments)
+             warning ("`/*' within comment");
+           if (bp[1] == '\\' && bp[2] == '\n')
+             newline_fix (bp + 1);
+           if (bp[1] == '/') {
+             bp++;
+             break;
+           }
+         }
+       }
+      } else if (bp[1] == '/' && cplusplus_comments) {
+       *comments = 1;
+       for (bp += 2; bp < limit; bp++) {
+         if (*bp == '\n') {
+           ++*newlines;
+           if (bp[-1] != '\\')
+             break;
+           if (warn_comments)
+             warning ("multiline `//' comment");
+         }
        }
-       break;
-      }
-      if (bp[1] != '*' || bp + 1 >= limit)
-       break;
-      *comments = 1;
-      bp += 2;
-      while (bp + 1 < limit) {
-       if (bp[0] == '*'
-           && bp[1] == '\\' && bp[2] == '\n')
-         newline_fix (bp + 1);
-       if (bp[0] == '*' && bp[1] == '/')
-         break;
-       if (*bp == '\n') ++*newlines;
-       bp++;
       }
       break;
     case '\'':
@@ -8407,8 +8637,12 @@ discard_comments (start, length, newlines)
       }
       if (ibp[0] != '*' || ibp + 1 >= limit)
        break;
-      /* Comments are equivalent to spaces.  */
-      obp[-1] = ' ';
+      /* Comments are equivalent to spaces.
+        For -traditional, a comment is equivalent to nothing.  */
+      if (traditional)
+       obp--;
+      else
+       obp[-1] = ' ';
       ibp++;
       while (ibp + 1 < limit) {
        if (ibp[0] == '*'
@@ -8501,9 +8735,8 @@ change_newlines (start, length)
   return obp - start;
 }
 \f
-/*
- * my_strerror - return the descriptive text associated with an `errno' code.
- */
+/* my_strerror - return the descriptive text associated with an
+   `errno' code.  */
 
 char *
 my_strerror (errnum)
@@ -8534,14 +8767,23 @@ my_strerror (errnum)
   return result;
 }
 
-/*
- * error - print error message and increment count of errors.
- */
+/* error - print error message and increment count of errors.  */
 
 void
-error (msg, arg1, arg2, arg3)
+error (PRINTF_ALIST (msg))
+     PRINTF_DCL (msg)
+{
+  va_list args;
+
+  VA_START (args, msg);
+  verror (msg, args);
+  va_end (args);
+}
+
+static void
+verror (msg, args)
      char *msg;
-     char *arg1, *arg2, *arg3;
+     va_list args;
 {
   int i;
   FILE_BUF *ip = NULL;
@@ -8556,7 +8798,7 @@ error (msg, arg1, arg2, arg3)
 
   if (ip != NULL)
     fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
-  fprintf (stderr, msg, arg1, arg2, arg3);
+  vfprintf (stderr, msg, args);
   fprintf (stderr, "\n");
   errors++;
 }
@@ -8589,9 +8831,20 @@ error_from_errno (name)
 /* Print error message but don't count it.  */
 
 void
-warning (msg, arg1, arg2, arg3)
+warning (PRINTF_ALIST (msg))
+     PRINTF_DCL (msg)
+{
+  va_list args;
+
+  VA_START (args, msg);
+  vwarning (msg, args);
+  va_end (args);
+}
+
+static void
+vwarning (msg, args)
      char *msg;
-     char *arg1, *arg2, *arg3;
+     va_list args;
 {
   int i;
   FILE_BUF *ip = NULL;
@@ -8613,15 +8866,31 @@ warning (msg, arg1, arg2, arg3)
   if (ip != NULL)
     fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno);
   fprintf (stderr, "warning: ");
-  fprintf (stderr, msg, arg1, arg2, arg3);
+  vfprintf (stderr, msg, args);
   fprintf (stderr, "\n");
 }
 
 static void
-error_with_line (line, msg, arg1, arg2, arg3)
+#if defined (__STDC__) && defined (HAVE_VPRINTF)
+error_with_line (int line, PRINTF_ALIST (msg))
+#else
+error_with_line (line, PRINTF_ALIST (msg))
+     int line;
+     PRINTF_DCL (msg)
+#endif
+{
+  va_list args;
+
+  VA_START (args, msg);
+  verror_with_line (line, msg, args);
+  va_end (args);
+}
+
+static void
+verror_with_line (line, msg, args)
      int line;
      char *msg;
-     char *arg1, *arg2, *arg3;
+     va_list args;
 {
   int i;
   FILE_BUF *ip = NULL;
@@ -8636,16 +8905,32 @@ error_with_line (line, msg, arg1, arg2, arg3)
 
   if (ip != NULL)
     fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
-  fprintf (stderr, msg, arg1, arg2, arg3);
+  vfprintf (stderr, msg, args);
   fprintf (stderr, "\n");
   errors++;
 }
 
 static void
-warning_with_line (line, msg, arg1, arg2, arg3)
+#if defined (__STDC__) && defined (HAVE_VPRINTF)
+warning_with_line (int line, PRINTF_ALIST (msg))
+#else
+warning_with_line (line, PRINTF_ALIST (msg))
+     int line;
+     PRINTF_DCL (msg)
+#endif
+{
+  va_list args;
+
+  VA_START (args, msg);
+  vwarning_with_line (line, msg, args);
+  va_end (args);
+}
+
+static void
+vwarning_with_line (line, msg, args)
      int line;
      char *msg;
-     char *arg1, *arg2, *arg3;
+     va_list args;
 {
   int i;
   FILE_BUF *ip = NULL;
@@ -8665,47 +8950,62 @@ warning_with_line (line, msg, arg1, arg2, arg3)
     }
 
   if (ip != NULL)
-    fprintf (stderr, "%s:%d: ", ip->nominal_fname, line);
+    fprintf (stderr, line ? "%s:%d: " : "%s: ", ip->nominal_fname, line);
   fprintf (stderr, "warning: ");
-  fprintf (stderr, msg, arg1, arg2, arg3);
+  vfprintf (stderr, msg, args);
   fprintf (stderr, "\n");
 }
 
-/* print an error message and maybe count it.  */
+/* Print an error message and maybe count it.  */
 
 void
-pedwarn (msg, arg1, arg2, arg3)
-     char *msg;
-     char *arg1, *arg2, *arg3;
+pedwarn (PRINTF_ALIST (msg))
+     PRINTF_DCL (msg)
 {
+  va_list args;
+
+  VA_START (args, msg);
   if (pedantic_errors)
-    error (msg, arg1, arg2, arg3);
+    verror (msg, args);
   else
-    warning (msg, arg1, arg2, arg3);
+    vwarning (msg, args);
+  va_end (args);
 }
 
 void
-pedwarn_with_line (line, msg, arg1, arg2, arg3)
+#if defined (__STDC__) && defined (HAVE_VPRINTF)
+pedwarn_with_line (int line, PRINTF_ALIST (msg))
+#else
+pedwarn_with_line (line, PRINTF_ALIST (msg))
      int line;
-     char *msg;
-     char *arg1, *arg2, *arg3;
+     PRINTF_DCL (msg)
+#endif
 {
+  va_list args;
+
+  VA_START (args, msg);
   if (pedantic_errors)
-    error_with_line (line, msg, arg1, arg2, arg3);
+    verror_with_line (line, msg, args);
   else
-    warning_with_line (line, msg, arg1, arg2, arg3);
+    vwarning_with_line (line, msg, args);
+  va_end (args);
 }
 
 /* Report a warning (or an error if pedantic_errors)
    giving specified file name and line number, not current.  */
 
 static void
-pedwarn_with_file_and_line (file, line, msg, arg1, arg2, arg3)
+#if defined (__STDC__) && defined (HAVE_VPRINTF)
+pedwarn_with_file_and_line (char *file, int line, PRINTF_ALIST (msg))
+#else
+pedwarn_with_file_and_line (file, line, PRINTF_ALIST (msg))
      char *file;
      int line;
-     char *msg;
-     char *arg1, *arg2, *arg3;
+     PRINTF_DCL (msg)
+#endif
 {
+  va_list args;
+
   if (!pedantic_errors && inhibit_warnings)
     return;
   if (file != NULL)
@@ -8714,12 +9014,14 @@ pedwarn_with_file_and_line (file, line, msg, arg1, arg2, arg3)
     errors++;
   if (!pedantic_errors)
     fprintf (stderr, "warning: ");
-  fprintf (stderr, msg, arg1, arg2, arg3);
+  VA_START (args, msg);
+  vfprintf (stderr, msg, args);
+  va_end (args);
   fprintf (stderr, "\n");
 }
 \f
 /* Print the file names and line numbers of the #include
-   commands which led to the current file.  */
+   directives which led to the current file.  */
 
 static void
 print_containing_files ()
@@ -8802,6 +9104,7 @@ line_for_error (line)
 
 /* You might think void was cleaner for the return type,
    but that would get type mismatch in check_expand in strict ANSI.  */
+
 static int
 grow_outbuf (obuf, needed)
      register FILE_BUF *obuf;
@@ -8843,14 +9146,14 @@ grow_outbuf (obuf, needed)
  * Otherwise, compute the length by scanning the entire name.
  *
  * If HASH is >= 0, it is the precomputed hash code.
- * Otherwise, compute the hash code.
+ * Otherwise, compute the hash code. 
  */
+
 static HASHNODE *
-install (name, len, type, ivalue, value, hash)
+install (name, len, type, value, hash)
      U_CHAR *name;
      int len;
      enum node_type type;
-     int ivalue;
      char *value;
      int hash;
 {
@@ -8879,10 +9182,7 @@ install (name, len, type, ivalue, value, hash)
     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->value.cpval = value;
   hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
   p = hp->name;
   q = name;
@@ -8902,6 +9202,7 @@ install (name, len, type, ivalue, value, hash)
  * If HASH is >= 0, it is the precomputed hash code.
  * Otherwise, compute the hash code.
  */
+
 HASHNODE *
 lookup (name, len, hash)
      U_CHAR *name;
@@ -8921,7 +9222,7 @@ lookup (name, len, hash)
 
   bucket = hashtab[hash];
   while (bucket) {
-    if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
+    if (bucket->length == len && bcmp (bucket->name, name, len) == 0)
       return bucket;
     bucket = bucket->next;
   }
@@ -8952,8 +9253,8 @@ delete_macro (hp)
   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. */
+  /* 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;
 
@@ -8976,6 +9277,7 @@ delete_macro (hp)
  * return hash function on name.  must be compatible with the one
  * computed a step at a time, elsewhere
  */
+
 static int
 hashf (name, len, hashsize)
      register U_CHAR *name;
@@ -8992,6 +9294,7 @@ hashf (name, len, hashsize)
 \f
 
 /* Dump the definition of a single macro HP to OF.  */
+
 static void
 dump_single_macro (hp, of)
      register HASHNODE *hp;
@@ -9025,17 +9328,50 @@ dump_single_macro (hp, of)
   concat = 0;
   for (ap = defn->pattern; ap != NULL; ap = ap->next) {
     dump_defn_1 (defn->expansion, offset, ap->nchars, of);
-    if (ap->nchars != 0)
-      concat = 0;
     offset += ap->nchars;
-    if (ap->stringify)
-      fprintf (of, " #");
-    if (ap->raw_before && !concat)
-      fprintf (of, " ## ");
-    concat = 0;
+    if (!traditional) {
+      if (ap->nchars != 0)
+       concat = 0;
+      if (ap->stringify) {
+       switch (ap->stringify) {
+        case SHARP_TOKEN: fprintf (of, "#"); break;
+        case WHITE_SHARP_TOKEN: fprintf (of, "# "); break;
+        case PERCENT_COLON_TOKEN: fprintf (of, "%%:"); break;
+        case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%: "); break;
+        default: abort ();
+       }
+      }
+      if (ap->raw_before != 0) {
+       if (concat) {
+         switch (ap->raw_before) {
+          case WHITE_SHARP_TOKEN:
+          case WHITE_PERCENT_COLON_TOKEN:
+           fprintf (of, " ");
+           break;
+          default:
+           break;
+         }
+       } else {
+         switch (ap->raw_before) {
+          case SHARP_TOKEN: fprintf (of, "##"); break;
+          case WHITE_SHARP_TOKEN: fprintf (of, "## "); break;
+          case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
+          case WHITE_PERCENT_COLON_TOKEN: fprintf (of, "%%:%%: "); break;
+          default: abort ();
+         }
+       }
+      }
+      concat = 0;
+    }
     dump_arg_n (defn, ap->argno, of);
-    if (ap->raw_after) {
-      fprintf (of, " ## ");
+    if (!traditional && ap->raw_after != 0) {
+      switch (ap->raw_after) {
+       case SHARP_TOKEN: fprintf (of, "##"); break;
+       case WHITE_SHARP_TOKEN: fprintf (of, " ##"); break;
+       case PERCENT_COLON_TOKEN: fprintf (of, "%%:%%:"); break;
+       case WHITE_PERCENT_COLON_TOKEN: fprintf (of, " %%:%%:"); break;
+       default: abort ();
+      }
       concat = 1;
     }
   }
@@ -9063,7 +9399,7 @@ dump_all_macros ()
 /* Output to OF a substring of a macro definition.
    BASE is the beginning of the definition.
    Output characters START thru LENGTH.
-   Discard newlines outside of strings, thus
+   Unless traditional, discard newlines outside of strings, thus
    converting funny-space markers to ordinary spaces.  */
 
 static void
@@ -9076,16 +9412,20 @@ dump_defn_1 (base, start, length, of)
   U_CHAR *p = base + start;
   U_CHAR *limit = base + start + length;
 
-  while (p < limit) {
-    if (*p == '\"' || *p =='\'') {
-      U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
-                                      NULL_PTR, NULL_PTR);
-      fwrite (p, p1 - p, 1, of);
-      p = p1;
-    } else {
-      if (*p != '\n')
-       putc (*p, of);
-      p++;
+  if (traditional)
+    fwrite (p, sizeof (*p), length, of);
+  else {
+    while (p < limit) {
+      if (*p == '\"' || *p =='\'') {
+       U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR,
+                                        NULL_PTR, NULL_PTR);
+       fwrite (p, sizeof (*p), p1 - p, of);
+       p = p1;
+      } else {
+       if (*p != '\n')
+         putc (*p, of);
+       p++;
+      }
     }
   }
 }
@@ -9103,7 +9443,7 @@ dump_arg_n (defn, argnum, of)
 {
   register U_CHAR *p = defn->args.argnames;
   while (argnum + 1 < defn->nargs) {
-    p = (U_CHAR *) index (p, ' ') + 1;
+    p = (U_CHAR *) index ((char *) p, ' ') + 1;
     argnum++;
   }
 
@@ -9136,8 +9476,8 @@ initialize_char_syntax ()
     is_idchar[i] = 1;
   is_idchar['_'] = 1;
   is_idstart['_'] = 1;
-  is_idchar['$'] = dollars_in_ident;
-  is_idstart['$'] = dollars_in_ident;
+  is_idchar['$'] = 1;
+  is_idstart['$'] = 1;
 
   /* horizontal space table */
   is_hor_space[' '] = 1;
@@ -9152,6 +9492,10 @@ initialize_char_syntax ()
   is_space['\f'] = 1;
   is_space['\n'] = 1;
   is_space['\r'] = 1;
+
+  char_name['\v'] = "vertical tab";
+  char_name['\f'] = "formfeed";
+  char_name['\r'] = "carriage return";
 }
 
 /* Initialize the built-in macros.  */
@@ -9161,84 +9505,99 @@ initialize_builtins (inp, outp)
      FILE_BUF *inp;
      FILE_BUF *outp;
 {
-  install ("__LINE__", -1, T_SPECLINE, 0, NULL_PTR, -1);
-  install ("__DATE__", -1, T_DATE, 0, NULL_PTR, -1);
-  install ("__FILE__", -1, T_FILE, 0, NULL_PTR, -1);
-  install ("__BASE_FILE__", -1, T_BASE_FILE, 0, NULL_PTR, -1);
-  install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, NULL_PTR, -1);
-  install ("__VERSION__", -1, T_VERSION, 0, NULL_PTR, -1);
+  install ((U_CHAR *) "__LINE__", -1, T_SPECLINE, NULL_PTR, -1);
+  install ((U_CHAR *) "__DATE__", -1, T_DATE, NULL_PTR, -1);
+  install ((U_CHAR *) "__FILE__", -1, T_FILE, NULL_PTR, -1);
+  install ((U_CHAR *) "__BASE_FILE__", -1, T_BASE_FILE, NULL_PTR, -1);
+  install ((U_CHAR *) "__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, NULL_PTR, -1);
+  install ((U_CHAR *) "__VERSION__", -1, T_VERSION, NULL_PTR, -1);
 #ifndef NO_BUILTIN_SIZE_TYPE
-  install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, NULL_PTR, -1);
+  install ((U_CHAR *) "__SIZE_TYPE__", -1, T_SIZE_TYPE, NULL_PTR, -1);
 #endif
 #ifndef NO_BUILTIN_PTRDIFF_TYPE
-  install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, NULL_PTR, -1);
+  install ((U_CHAR *) "__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, NULL_PTR, -1);
 #endif
-  install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, NULL_PTR, -1);
-  install ("__USER_LABEL_PREFIX__",-1,T_USER_LABEL_PREFIX_TYPE,0,NULL_PTR, -1);
-  install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, NULL_PTR, -1);
-  install ("__TIME__", -1, T_TIME, 0, NULL_PTR, -1);
-  if (!traditional)
-    install ("__STDC__", -1, T_CONST, STDC_VALUE, NULL_PTR, -1);
+  install ((U_CHAR *) "__WCHAR_TYPE__", -1, T_WCHAR_TYPE, NULL_PTR, -1);
+  install ((U_CHAR *) "__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE,
+          NULL_PTR, -1);
+  install ((U_CHAR *) "__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE,
+          NULL_PTR, -1);
+  install ((U_CHAR *) "__IMMEDIATE_PREFIX__", -1, T_IMMEDIATE_PREFIX_TYPE,
+          NULL_PTR, -1);
+  install ((U_CHAR *) "__TIME__", -1, T_TIME, NULL_PTR, -1);
+  if (!traditional) {
+    install ((U_CHAR *) "__STDC__", -1, T_CONST, "1", -1);
+    install ((U_CHAR *) "__STDC_VERSION__", -1, T_CONST, "199409L", -1);
+  }
   if (objc)
-    install ("__OBJC__", -1, T_CONST, 1, NULL_PTR, -1);
+    install ((U_CHAR *) "__OBJC__", -1, T_CONST, "1", -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, NULL_PTR, -1);  */
+/*  install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1);  */
+  install ((U_CHAR *) "__HAVE_BUILTIN_SETJMP__", -1, T_CONST, "1", -1);
 
   if (debug_output)
     {
       char directive[2048];
+      U_CHAR *udirective = (U_CHAR *) directive;
       register struct directive *dp = &directive_table[0];
       struct tm *timebuf = timestamp ();
 
       sprintf (directive, " __BASE_FILE__ \"%s\"\n",
               instack[0].nominal_fname);
-      output_line_command (inp, outp, 0, same_file);
-      pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
+      output_line_directive (inp, outp, 0, same_file);
+      pass_thru_directive (udirective, &udirective[strlen (directive)],
+                          outp, dp);
 
       sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
-      output_line_command (inp, outp, 0, same_file);
-      pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
+      output_line_directive (inp, outp, 0, same_file);
+      pass_thru_directive (udirective, &udirective[strlen (directive)],
+                          outp, dp);
 
 #ifndef NO_BUILTIN_SIZE_TYPE
       sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
-      output_line_command (inp, outp, 0, same_file);
-      pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
+      output_line_directive (inp, outp, 0, same_file);
+      pass_thru_directive (udirective, &udirective[strlen (directive)],
+                          outp, dp);
 #endif
 
 #ifndef NO_BUILTIN_PTRDIFF_TYPE
       sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
-      output_line_command (inp, outp, 0, same_file);
-      pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
+      output_line_directive (inp, outp, 0, same_file);
+      pass_thru_directive (udirective, &udirective[strlen (directive)],
+                          outp, dp);
 #endif
 
       sprintf (directive, " __WCHAR_TYPE__ %s\n", wchar_type);
-      output_line_command (inp, outp, 0, same_file);
-      pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
+      output_line_directive (inp, outp, 0, same_file);
+      pass_thru_directive (udirective, &udirective[strlen (directive)],
+                          outp, dp);
 
       sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
               monthnames[timebuf->tm_mon],
               timebuf->tm_mday, timebuf->tm_year + 1900);
-      output_line_command (inp, outp, 0, same_file);
-      pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
+      output_line_directive (inp, outp, 0, same_file);
+      pass_thru_directive (udirective, &udirective[strlen (directive)],
+                          outp, dp);
 
       sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
               timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
-      output_line_command (inp, outp, 0, same_file);
-      pass_thru_directive (directive, &directive[strlen (directive)], outp, dp);
+      output_line_directive (inp, outp, 0, same_file);
+      pass_thru_directive (udirective, &udirective[strlen (directive)],
+                          outp, dp);
 
       if (!traditional)
        {
           sprintf (directive, " __STDC__ 1");
-          output_line_command (inp, outp, 0, same_file);
-          pass_thru_directive (directive, &directive[strlen (directive)],
+          output_line_directive (inp, outp, 0, same_file);
+          pass_thru_directive (udirective, &udirective[strlen (directive)],
                               outp, dp);
        }
       if (objc)
        {
           sprintf (directive, " __OBJC__ 1");
-          output_line_command (inp, outp, 0, same_file);
-          pass_thru_directive (directive, &directive[strlen (directive)],
+          output_line_directive (inp, outp, 0, same_file);
+          pass_thru_directive (udirective, &udirective[strlen (directive)],
                               outp, dp);
        }
     }
@@ -9253,15 +9612,14 @@ initialize_builtins (inp, outp)
 
 static void
 make_definition (str, op)
-     U_CHAR *str;
+     char *str;
      FILE_BUF *op;
 {
   FILE_BUF *ip;
   struct directive *kt;
   U_CHAR *buf, *p;
 
-  buf = str;
-  p = str;
+  p = buf = (U_CHAR *) str;
   if (!is_idstart[*p]) {
     error ("malformed option `-D %s'", str);
     return;
@@ -9272,7 +9630,7 @@ make_definition (str, op)
     while (is_idchar[*++p] || *p == ',' || is_hor_space[*p])
       ;
     if (*p++ != ')')
-      p = str;                 /* Error */
+      p = (U_CHAR *) str;                      /* Error */
   }
   if (*p == 0) {
     buf = (U_CHAR *) alloca (p - buf + 4);
@@ -9285,16 +9643,16 @@ make_definition (str, op)
     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);
+    strncpy ((char *) buf, str, p - (U_CHAR *) str);
     /* Change the = to a space.  */
-    buf[p - str] = ' ';
+    buf[p - (U_CHAR *) str] = ' ';
     /* Scan for any backslash-newline and remove it.  */
     p++;
-    q = &buf[p - str];
+    q = &buf[p - (U_CHAR *) str];
     while (*p) {
       if (*p == '\"' || *p == '\'') {
        int unterminated = 0;
-       U_CHAR *p1 = skip_quoted_string (p, p + strlen (p), 0,
+       U_CHAR *p1 = skip_quoted_string (p, p + strlen ((char *) p), 0,
                                         NULL_PTR, NULL_PTR, &unterminated);
        if (unterminated)
          return;
@@ -9322,7 +9680,7 @@ make_definition (str, op)
   ip->nominal_fname = ip->fname = "*Initialization*";
 
   ip->buf = ip->bufp = buf;
-  ip->length = strlen (buf);
+  ip->length = strlen ((char *) buf);
   ip->lineno = 1;
   ip->macro = 0;
   ip->free_ptr = 0;
@@ -9333,7 +9691,7 @@ make_definition (str, op)
     ;
 
   /* Pass NULL instead of OP, since this is a "predefined" macro.  */
-  do_define (buf, buf + strlen (buf), NULL_PTR, kt);
+  do_define (buf, buf + strlen ((char *) buf), NULL_PTR, kt);
   --indepth;
 }
 
@@ -9341,7 +9699,7 @@ make_definition (str, op)
 
 static void
 make_undef (str, op)
-     U_CHAR *str;
+     char *str;
      FILE_BUF *op;
 {
   FILE_BUF *ip;
@@ -9350,7 +9708,7 @@ make_undef (str, op)
   ip = &instack[++indepth];
   ip->nominal_fname = ip->fname = "*undef*";
 
-  ip->buf = ip->bufp = str;
+  ip->buf = ip->bufp = (U_CHAR *) str;
   ip->length = strlen (str);
   ip->lineno = 1;
   ip->macro = 0;
@@ -9361,7 +9719,7 @@ make_undef (str, op)
   for (kt = directive_table; kt->type != T_UNDEF; kt++)
     ;
 
-  do_undef (str, str + strlen (str), op, kt);
+  do_undef ((U_CHAR *) str, (U_CHAR *) str + strlen (str), op, kt);
   --indepth;
 }
 \f
@@ -9371,7 +9729,7 @@ make_undef (str, op)
 static void
 make_assertion (option, str)
      char *option;
-     U_CHAR *str;
+     char *str;
 {
   FILE_BUF *ip;
   struct directive *kt;
@@ -9397,7 +9755,7 @@ make_assertion (option, str)
   }
   while (is_idchar[*++p])
     ;
-  while (*p == ' ' || *p == '\t') p++;
+  SKIP_WHITE_SPACE (p);
   if (! (*p == 0 || *p == '(')) {
     error ("malformed option `%s %s'", option, str);
     return;
@@ -9407,7 +9765,7 @@ make_assertion (option, str)
   ip->nominal_fname = ip->fname = "*Initialization*";
 
   ip->buf = ip->bufp = buf;
-  ip->length = strlen (buf);
+  ip->length = strlen ((char *) buf);
   ip->lineno = 1;
   ip->macro = 0;
   ip->free_ptr = 0;
@@ -9417,12 +9775,90 @@ make_assertion (option, str)
   for (kt = directive_table; kt->type != T_ASSERT; kt++)
     ;
 
-  /* pass NULL as output ptr to do_define since we KNOW it never
-     does any output.... */
-  do_assert (buf, buf + strlen (buf) , NULL_PTR, kt);
+  /* Pass NULL as output ptr to do_define since we KNOW it never does
+     any output....  */
+  do_assert (buf, buf + strlen ((char *) buf) , NULL_PTR, kt);
   --indepth;
 }
 \f
+/* The previous include prefix, if any, is PREV_FILE_NAME.
+   Allocate a new include prefix whose name is the
+   simplified concatenation of PREFIX and NAME,
+   with a trailing / added if needed.
+   But return 0 if the include prefix should be ignored,
+   e.g. because it is a duplicate of PREV_FILE_NAME.  */
+
+static struct file_name_list *
+new_include_prefix (prev_file_name, prefix, name)
+     struct file_name_list *prev_file_name;
+     char *prefix;
+     char *name;
+{
+  if (!name)
+    fatal ("Directory name missing after command line option");
+
+  if (!*name)
+    /* Ignore the empty string.  */
+    return 0;
+  else {
+    struct file_name_list *dir
+      = ((struct file_name_list *)
+        xmalloc (sizeof (struct file_name_list)
+                 + strlen (prefix) + strlen (name) + 1 /* for trailing / */));
+    size_t len;
+    strcpy (dir->fname, prefix);
+    strcat (dir->fname, name);
+    len = simplify_filename (dir->fname);
+
+    /* Convert directory name to a prefix.  */
+    if (dir->fname[len - 1] != '/') {
+      if (len == 1 && dir->fname[len - 1] == '.')
+       len = 0;
+      else
+       dir->fname[len++] = '/';
+      dir->fname[len] = 0;
+    }
+
+    /* Ignore a directory whose name matches the previous one.  */
+    if (prev_file_name && !strcmp (prev_file_name->fname, dir->fname)) {
+      /* But treat `-Idir -I- -Idir' as `-I- -Idir'.  */
+      if (!first_bracket_include)
+       first_bracket_include = prev_file_name;
+      free (dir);
+      return 0;
+    }
+
+#ifndef VMS
+    /* VMS can't stat dir prefixes, so skip these optimizations in VMS.  */
+
+    /* Ignore a nonexistent directory.  */
+    if (stat (len ? dir->fname : ".", &dir->st) != 0) {
+      if (errno != ENOENT && errno != ENOTDIR)
+       error_from_errno (dir->fname);
+      free (dir);
+      return 0;
+    }
+
+    /* Ignore a directory whose identity matches the previous one.  */
+    if (prev_file_name
+       && INO_T_EQ (prev_file_name->st.st_ino, dir->st.st_ino)
+       && prev_file_name->st.st_dev == dir->st.st_dev) {
+      /* But treat `-Idir -I- -Idir' as `-I- -Idir'.  */
+      if (!first_bracket_include)
+       first_bracket_include = prev_file_name;
+      free (dir);
+      return 0;
+    }
+#endif /* ! VMS */
+
+    dir->next = 0;
+    dir->c_system_include_path = 0;
+    dir->got_name_map = 0;
+
+    return dir;
+  }
+}
+
 /* 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.  */
@@ -9458,8 +9894,7 @@ append_include_chain (first, 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.  */
+   SPACER is ':' for targets, ' ' for dependencies.  */
 
 static void
 deps_output (string, spacer)
@@ -9474,74 +9909,45 @@ deps_output (string, spacer)
 #ifndef MAX_OUTPUT_COLUMNS
 #define MAX_OUTPUT_COLUMNS 72
 #endif
-  if (spacer
-      && deps_column > 0
-      && (deps_column + size) > MAX_OUTPUT_COLUMNS)
-  {
-    deps_output (" \\\n  ", 0);
-    deps_column = 0;
+  if (MAX_OUTPUT_COLUMNS - 1 /*spacer*/ - 2 /*` \'*/ < deps_column + size
+      && 1 < deps_column) {
+    bcopy (" \\\n ", &deps_buffer[deps_size], 4);
+    deps_size += 4;
+    deps_column = 1;
+    if (spacer == ' ')
+      spacer = 0;
   }
 
   if (deps_size + size + 8 > deps_allocated_size) {
     deps_allocated_size = (deps_size + size + 50) * 2;
-    deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
+    deps_buffer = xrealloc (deps_buffer, deps_allocated_size);
   }
-  if (spacer == ' ' && deps_column > 0)
+  if (spacer == ' ') {
     deps_buffer[deps_size++] = ' ';
+    deps_column++;
+  }
   bcopy (string, &deps_buffer[deps_size], size);
   deps_size += size;
   deps_column += size;
-  if (spacer == ':')
+  if (spacer == ':') {
     deps_buffer[deps_size++] = ':';
+    deps_column++;
+  }
   deps_buffer[deps_size] = 0;
 }
 \f
-#if defined(USG) || defined(VMS)
-#ifndef BSTRING
-
-void
-bzero (b, length)
-     register char *b;
-     register unsigned length;
-{
-  while (length-- > 0)
-    *b++ = 0;
-}
-
-void
-bcopy (b1, b2, length)
-     register char *b1;
-     register char *b2;
-     register unsigned length;
-{
-  while (length-- > 0)
-    *b2++ = *b1++;
-}
-
-int
-bcmp (b1, b2, length)  /* This could be a macro! */
-     register char *b1;
-     register char *b2;
-     register unsigned length;
-{
-   while (length-- > 0)
-     if (*b1++ != *b2++)
-       return 1;
-
-   return 0;
-}
-#endif /* not BSTRING */
-#endif /* USG or VMS */
-
-\f
 static void
-fatal (str, arg)
-     char *str, *arg;
+fatal (PRINTF_ALIST (msg))
+     PRINTF_DCL (msg)
 {
+  va_list args;
+
   fprintf (stderr, "%s: ", progname);
-  fprintf (stderr, str, arg);
+  VA_START (args, msg);
+  vfprintf (stderr, msg, args);
+  va_end (args);
   fprintf (stderr, "\n");
-  exit (FAILURE_EXIT_CODE);
+  exit (FATAL_EXIT_CODE);
 }
 
 /* More 'friendly' abort that prints the line and file.
@@ -9570,7 +9976,7 @@ pfatal_with_name (name)
 #ifdef VMS
   exit (vaxc$errno);
 #else
-  exit (FAILURE_EXIT_CODE);
+  exit (FATAL_EXIT_CODE);
 #endif
 }
 
@@ -9591,140 +9997,74 @@ memory_full ()
 }
 
 
-char *
+GENERIC_PTR
 xmalloc (size)
-     unsigned size;
+     size_t size;
 {
-  register char *ptr = (char *) malloc (size);
-  if (ptr != 0) return (ptr);
-  memory_full ();
-  /*NOTREACHED*/
-  return 0;
+  register GENERIC_PTR ptr = (GENERIC_PTR) malloc (size);
+  if (!ptr)
+    memory_full ();
+  return ptr;
 }
 
-static char *
+static GENERIC_PTR
 xrealloc (old, size)
-     char *old;
-     unsigned size;
+     GENERIC_PTR old;
+     size_t size;
 {
-  register char *ptr = (char *) realloc (old, size);
-  if (ptr != 0) return (ptr);
-  memory_full ();
-  /*NOTREACHED*/
-  return 0;
+  register GENERIC_PTR ptr = (GENERIC_PTR) realloc (old, size);
+  if (!ptr)
+    memory_full ();
+  return ptr;
 }
 
-static char *
+static GENERIC_PTR
 xcalloc (number, size)
-     unsigned number, size;
+     size_t 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;
+  register size_t total = number * size;
+  register GENERIC_PTR ptr = (GENERIC_PTR) malloc (total);
+  if (!ptr)
+    memory_full ();
+  bzero (ptr, total);
+  return ptr;
 }
 
 static char *
 savestring (input)
      char *input;
 {
-  unsigned size = strlen (input);
+  size_t size = strlen (input);
   char *output = xmalloc (size + 1);
   strcpy (output, input);
   return output;
 }
 \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;
-}
-
-static void
-output_dots (fd, depth)
-     FILE* fd;
-     int depth;
-{
-  while (depth > 0) {
-    putc ('.', fd);
-    depth--;
-  }
-}
-  
-\f
 #ifdef VMS
 
-/* Under VMS we need to fix up the "include" specification
-   filename so that everything following the 1st slash is
-   changed into its correct VMS file specification. */
+/* Under VMS we need to fix up the "include" specification filename so
+   that everything following the 1st slash is changed into its correct
+   VMS file specification.  */
 
 static void
-hack_vms_include_specification (fname)
+hack_vms_include_specification (fname, vaxc_include)
      char *fname;
+     int vaxc_include;
 {
   register char *cp, *cp1, *cp2;
-  int f, check_filename_before_returning, no_prefix_seen;
+  int f, check_filename_before_returning;
   char Local[512];
 
   check_filename_before_returning = 0;
-  no_prefix_seen = 0;
-
-  /* Ignore leading "./"s */
-  while (fname[0] == '.' && fname[1] == '/') {
-    strcpy (fname, fname+2);
-    no_prefix_seen = 1;                /* mark this for later */
-  }
-  /* Look for the boundary between the VMS and UNIX filespecs */
-  cp = rindex (fname, ']');    /* Look for end of dirspec. */
-  if (cp == 0) cp = rindex (fname, '>'); /* ... Ditto              */
-  if (cp == 0) cp = rindex (fname, ':'); /* Look for end of devspec. */
-  if (cp) {
-    cp++;
-  } else {
-    cp = index (fname, '/');   /* Look for the "/" */
-  }
+
+  cp = base_name (fname);
 
   /*
    * Check if we have a vax-c style '#include filename'
    * and add the missing .h
    */
-  if (cp == 0) {
-    if (index(fname,'.') == 0)
-      strcat(fname, ".h");
-  } else {
-    if (index(cp,'.') == 0)
-      strcat(cp, ".h");
-  }
+  if (vaxc_include && !index (cp,'.'))
+    strcat (cp, ".h");
 
   cp2 = Local;                 /* initialize */
 
@@ -9737,7 +10077,7 @@ hack_vms_include_specification (fname)
      needed to get things working properly.
      
      If no device is specified, then the first directory name is taken to be
-     a device name (or a rooted logical). */
+     a device name (or a rooted logical).  */
 
   /* See if we found that 1st slash */
   if (cp == 0) return;         /* Nothing to do!!! */
@@ -9787,14 +10127,14 @@ hack_vms_include_specification (fname)
 
   /* If there are no other slashes then the filename will be
      in the "root" directory.  Otherwise, we need to add
-     directory specifications. */
+     directory specifications.  */
   if (index (cp1, '/') == 0) {
     /* Just add "000000]" as the directory string */
     strcpy (cp2, "000000]");
     cp2 += strlen (cp2);
     check_filename_before_returning = 1; /* we might need to fool with this later */
   } else {
-    /* As long as there are still subdirectories to add, do them. */
+    /* As long as there are still subdirectories to add, do them.  */
     while (index (cp1, '/') != 0) {
       /* If this token is "." we can ignore it */
       if ((cp1[0] == '.') && (cp1[1] == '/')) {
@@ -9823,7 +10163,7 @@ hack_vms_include_specification (fname)
   /* Now add the filename */
   while (*cp1) *cp2++ = *cp1++;
   *cp2 = 0;
-  /* Now append it to the original VMS spec. */
+  /* Now append it to the original VMS spec.  */
   strcpy (cp, Local);
 
   /* If we put a [000000] in the filename, try to open it first. If this fails,
@@ -9831,7 +10171,7 @@ hack_vms_include_specification (fname)
      to the user in that they can use both rooted and non-rooted logical names
      to point to the location of the file.  */
 
-  if (check_filename_before_returning && no_prefix_seen) {
+  if (check_filename_before_returning) {
     f = open (fname, O_RDONLY, 0666);
     if (f >= 0) {
       /* The file name is OK as it is, so return it as is.  */
@@ -9850,67 +10190,13 @@ hack_vms_include_specification (fname)
 \f
 #ifdef VMS
 
-/* These are the read/write replacement routines for
-   VAX-11 "C".  They make read/write behave enough
-   like their UNIX counterparts that CCCP will work */
-
-static int
-read (fd, buf, size)
-     int fd;
-     char *buf;
-     int size;
-{
-#undef read    /* Get back the REAL read routine */
-  register int i;
-  register int total = 0;
-
-  /* Read until the buffer is exhausted */
-  while (size > 0) {
-    /* Limit each read to 32KB */
-    i = (size > (32*1024)) ? (32*1024) : size;
-    i = read (fd, buf, i);
-    if (i <= 0) {
-      if (i == 0) return (total);
-      return (i);
-    }
-    /* Account for this read */
-    total += i;
-    buf += i;
-    size -= i;
-  }
-  return (total);
-}
-
-static int
-write (fd, buf, size)
-     int fd;
-     char *buf;
-     int size;
-{
-#undef write   /* Get back the REAL write routine */
-  int i;
-  int j;
-
-  /* Limit individual writes to 32Kb */
-  i = size;
-  while (i > 0) {
-    j = (i > (32*1024)) ? (32*1024) : i;
-    if (write (fd, buf, j) < 0) return (-1);
-    /* Account for the data written */
-    buf += j;
-    i -= j;
-  }
-  return (size);
-}
-
 /* The following wrapper functions supply additional arguments to the VMS
    I/O routines to optimize performance with file handling.  The arguments
    are:
      "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer).
      "deq=64" - When extending the file, extend it in chunks of 32Kbytes.
      "fop=tef"- Truncate unused portions of file when closing file.
-     "shr=nil"- Disallow file sharing while file is open.
- */
+     "shr=nil"- Disallow file sharing while file is open.  */
 
 static FILE *
 freopen (fname, type, oldfile)
@@ -9930,9 +10216,16 @@ fopen (fname, type)
      char *type;
 {
 #undef fopen   /* Get back the REAL fopen routine */
-  if (strcmp (type, "w") == 0)
-    return fopen (fname, type, "mbc=16", "deq=64", "fop=tef", "shr=nil");
-  return fopen (fname, type, "mbc=16");
+  /* The gcc-vms-1.42 distribution's header files prototype fopen with two
+     fixed arguments, which matches ANSI's specification but not VAXCRTL's
+     pre-ANSI implementation.  This hack circumvents the mismatch problem.  */
+  FILE *(*vmslib_fopen)() = (FILE *(*)()) fopen;
+
+  if (*type == 'w')
+    return (*vmslib_fopen) (fname, type, "mbc=32",
+                           "deq=64", "fop=tef", "shr=nil");
+  else
+    return (*vmslib_fopen) (fname, type, "mbc=32");
 }
 
 static int 
@@ -9944,24 +10237,83 @@ open (fname, flags, prot)
 #undef open    /* Get back the REAL open routine */
   return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
 }
+\f
+/* more VMS hackery */
+#include <fab.h>
+#include <nam.h>
 
-/* Avoid run-time library bug, where copying M out of N+M characters with
-   N >= 65535 results in VAXCRTL's strncat falling into an infinite loop.
-   gcc-cpp exercises this particular bug.  */
+extern unsigned long sys$parse(), sys$search();
 
-static char *
-strncat (dst, src, cnt)
-     char *dst;
-     const char *src;
-     unsigned cnt;
-{
-  register char *d = dst, *s = (char *) src;
-  register int n = cnt;        /* convert to _signed_ type */
-
-  while (*d) d++;      /* advance to end */
-  while (--n >= 0)
-    if (!(*d++ = *s++)) break;
-  if (n < 0) *d = '\0';
-  return dst;
+/* Work around another library bug.  If a file is located via a searchlist,
+   and if the device it's on is not the same device as the one specified
+   in the first element of that searchlist, then both stat() and fstat()
+   will fail to return info about it.  `errno' will be set to EVMSERR, and
+   `vaxc$errno' will be set to SS$_NORMAL due yet another bug in stat()!
+   We can get around this by fully parsing the filename and then passing
+   that absolute name to stat().
+
+   Without this fix, we can end up failing to find header files, which is
+   bad enough, but then compounding the problem by reporting the reason for
+   failure as "normal successful completion."  */
+
+#undef fstat   /* get back to library version */
+
+static int
+VMS_fstat (fd, statbuf)
+     int fd;
+     struct stat *statbuf;
+{
+  int result = fstat (fd, statbuf);
+
+  if (result < 0)
+    {
+      FILE *fp;
+      char nambuf[NAM$C_MAXRSS+1];
+
+      if ((fp = fdopen (fd, "r")) != 0 && fgetname (fp, nambuf) != 0)
+       result = VMS_stat (nambuf, statbuf);
+      /* No fclose(fp) here; that would close(fd) as well.  */
+    }
+
+  return result;
+}
+
+static int
+VMS_stat (name, statbuf)
+     const char *name;
+     struct stat *statbuf;
+{
+  int result = stat (name, statbuf);
+
+  if (result < 0)
+    {
+      struct FAB fab;
+      struct NAM nam;
+      char exp_nam[NAM$C_MAXRSS+1],  /* expanded name buffer for sys$parse */
+          res_nam[NAM$C_MAXRSS+1];  /* resultant name buffer for sys$search */
+
+      fab = cc$rms_fab;
+      fab.fab$l_fna = (char *) name;
+      fab.fab$b_fns = (unsigned char) strlen (name);
+      fab.fab$l_nam = (void *) &nam;
+      nam = cc$rms_nam;
+      nam.nam$l_esa = exp_nam,  nam.nam$b_ess = sizeof exp_nam - 1;
+      nam.nam$l_rsa = res_nam,  nam.nam$b_rss = sizeof res_nam - 1;
+      nam.nam$b_nop = NAM$M_PWD | NAM$M_NOCONCEAL;
+      if (sys$parse (&fab) & 1)
+       {
+         if (sys$search (&fab) & 1)
+           {
+             res_nam[nam.nam$b_rsl] = '\0';
+             result = stat (res_nam, statbuf);
+           }
+         /* Clean up searchlist context cached by the system.  */
+         nam.nam$b_nop = NAM$M_SYNCHK;
+         fab.fab$l_fna = 0,  fab.fab$b_fns = 0;
+         (void) sys$parse (&fab);
+       }
+    }
+
+  return result;
 }
 #endif /* VMS */