Try harder not to open or stat the same include file twice.

Simplify include file names so that they are more likely to match.
E.g. simplify "./a//b" to "a/b".  Represent directories with simplified
prefixes, e.g. replace "./a//b" with "a/b/", and "." with "".

(absolute_filename): New function.
(do_include): Use it.
(read_name_map): Likewise; this makes things more consistent for DOS.

(main, do_include, open_include_file): -M output now contains operands
of -imacros and -include.

(skip_to_end_of_comment): When copying a // comment, don't try to
change it to a /* comment.
(rescan, skip_if_group, skip_to_end_of_comment, macarg1): Tune.

(rescan, skip_if_group, skip_to_end_of_comment, macarg1):
If warn_comments is nonzero, warn if backslash-newline appears
in a // comment.  Simplify method for finding /* /* */ comment.
(skip_if_group): Optionally warn if /* /* */ appears between # and
a directive inside a skipped if group.
(macarg): Optionally warn if /* /* */ appears in a macro argument.

(strncat, VMS_strncat, vms_ino_t, ino_t): Remove.
(INCLUDE_LEN_FUDGE): Add 2 if VMS, for trailing ".h".
(INO_T_EQ, INO_T_HASH): New macros.

(struct file_buf): New member `inc'.
(expand_to_temp_buffer): Initialize it.

(struct file_name_list): New member `inc'.
(struct file_name_list): New member `st'.
c_system_include_path is now 1 if not 0.
fname is now an array, not a pointer.
(struct include_file): New members `next_ino', `deps_output', `st'.
Remove members `inode' and `dev'; they are now in `st'.

(INCLUDE_HASHSIZE): Rename from INCLUDE_HASH_SIZE.
(include_hashtab): Rename from include_hash_table.
(include_ino_hashtab): New variable.

(main): Store file status in struct stat, not in long and int pieces.
Use base_name to strip prefixes from file names.
When printing directory prefixes, omit trailing / and print "" as ".".
Fatal error if the input file is a directory.
(main, path_include): Regularize operands of -include, -imacros,
-isystem, -iwithprefix, and -iwithprefixbefore.
Regularize default include directories.

(do_include):
Allocate dsp with alloca, since fname is now dynamically allocated.
Use -3 to represent a never-opened file descriptor.
Make copy of file name, and simplify the copy.
Use base_name to identify the end of fname's directory.
Do not prepend dir for "..." if it matches the search list's first dir.
open_include_file now subsumes redundant_include_p and lookup_import.
Use bypass_slot to remember when to skip directories when including
a file that has already been seen.
Instead of using 0 to represent the working directory, and ""
to represent a directory to be ignored, use "" for the former,
and assume the latter has been removed before we get here.
Assume the directory prefixes have already been simplified.
Report as errors all open failures other than ENOENT.
Fatal error if fstat fails.
Use new deps_output member to avoid printing dependencies twice.
(bypass_hashtab): New variable.

(do_include, open_control_file, record_control_macro): New convention:
control_macro is "" if the file was imported or had #pragma once.
(pragma_once_marker): Remove.

(redundant_include_p, include_hash, lookup_include, lookup_import,
add_import, file_size_and_mode): Remove; subsumed by open_include_file.
(skip_redundant_dir_prefix): Remove; subsumed by simplify_filename.

(is_system_include, read_name_map, remap_include_file):
Assume arg is a directory prefix.

(base_name, simplify_filename, remap_include_file,
lookup_ino_include, new_include_prefix): New functions.

(open_include_file): New arguments `importing' and `pinc'.
Move filename mapping into new remap_include_file function.
First try to find file by name in include_hashtab;
if that doesn't work, open and fstat it and try to find it
by inode and dev in include_ino_hashtab.

(finclude): Get file status from inc->st instead of invoking fstat.
Store inc into fp->inc so that record_control_macro doesn't
need to do a table lookup.
(finclude, record_control_macro): Accept struct include_file *
instead of char * to identify include file.  All callers changed.

(check_precompiled): Get file status from new argument `st'.

(do_pragma): Output at most one warning about #pragma implementation.
Always return 0 instead of returning garbage sometimes.
(do_pragma, hack_vms_include_specification):
Use base_name for consistency, and remove redundant code.

From Per Bothner:
Unify the 3 separate mechanisms for avoiding processing
of redundant include files: #import, #pragma once, and
redundant_include_p to use a single more efficient data structure.
(struct file_name_list):  Remove no-longer needed field control_macro.
(dont_repeat_files, all_include_files):  Remove, no longer used.
(struct import_file):  Renmed to struct include_file, moved earlier
in file, renamed field name to fname, and added control_macro field.
(pragma_once_marker):  New constant.
(import_hash_table):  Renamed to include_hash_table.
(import_hash):  Renamed to include_hash.
(IMPORT_HASH_SIZE):  Renamed to INCLUDE_HASH_SIZE.
(main, path_include):  Don't clear removed control_macro field.
(lookup_include):  New function - look up fname in include_hash_table.
(redundant_include_p):  Re-write to use lookup_include.
(lookup_import, record_control_macro):  Likewise.
(add_import):  Defer fstat to caller.  Combine two xmallocs into one.
(do_once):  Use pragma_once_marker in include_hash_table.
(do_pragma):  Re-implement to scan include_hash_table.
(do_include):  Use new lookup_include and add_import.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@10784 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 706 insertions, 824 deletions

diff --git a/gcc/cccp.c b/gcc/cccp.c
index 12d86edfc74..8338f6d25c5 100644
--- a/gcc/cccp.c
+++ b/gcc/cccp.c
@@ -117,7 +117,6 @@ typedef unsigned char U_CHAR;
 # include <fcntl.h>
 #endif
 
-/* This defines "errno" properly for VMS, and gives us EACCES. */
 #include <errno.h>
 
 #if HAVE_STDLIB_H
@@ -239,19 +238,17 @@ my_bzero (b, length)
 #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)
 #define fstat(fd,stbuf)		VMS_fstat (fd,stbuf)
 static int VMS_fstat (), VMS_stat ();
-static char * VMS_strncat ();
 static int VMS_read ();
 static int VMS_write ();
 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 */
+#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 */
 #ifdef __GNUC__
 #define BSTRING			/* VMS/GCC supplies the bstring routines */
 #endif /* __GNUC__ */
@@ -288,6 +285,14 @@ typedef struct { unsigned :16, :16, :16; } vms_ino_t;
 #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
@@ -449,7 +454,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;
 
@@ -505,6 +511,8 @@ static struct file_buf {
   char *fname;
   /* 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;
@@ -561,17 +569,19 @@ 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. */
@@ -643,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
@@ -1081,22 +1106,21 @@ 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 redundant_include_p PROTO((char *));
 static int is_system_include PROTO((char *));
-static char *skip_redundant_dir_prefix 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 *));
-
-static void finclude PROTO((int, char *, FILE_BUF *, int, struct file_name_list *));
-static void record_control_macro PROTO((char *, U_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 int import_hash PROTO((char *));
-static int lookup_import PROTO((char *, struct file_name_list *));
-static void add_import PROTO((int, char *));
+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, char *, 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 *));
@@ -1185,6 +1209,7 @@ 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));
@@ -1200,8 +1225,6 @@ 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 *));
-
-static int file_size_and_mode PROTO((int, int *, long int *));
 
 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
    retrying if necessary.  Return a negative value if an error occurs,
@@ -1262,8 +1285,7 @@ main (argc, argv)
      int argc;
      char **argv;
 {
-  int st_mode;
-  long st_size;
+  struct stat st;
   char *in_fname;
   char *cp;
   int f, i;
@@ -1315,25 +1337,14 @@ main (argc, argv)
   signal (SIGPIPE, pipe_closed);
 #endif
 
-  cp = argv[0] + strlen (argv[0]);
-  while (cp != argv[0] && cp[-1] != '/'
-#ifdef DIR_SEPARATOR
-	 && cp[-1] != DIR_SEPARATOR
-#endif
-	 )
-    --cp;
-  progname = cp;
+  progname = base_name (argv[0]);
 
 #ifdef VMS
   {
-    /* Remove directories from PROGNAME.  */
+    /* Remove extension from PROGNAME.  */
     char *p;
-    char *s = progname;
+    char *s = progname = savestring (progname);
 
-    if ((p = rindex (s, ':')) != 0) s = p + 1;	/* skip device */
-    if ((p = rindex (s, ']')) != 0) s = p + 1;	/* skip directory */
-    if ((p = rindex (s, '>')) != 0) s = p + 1;	/* alternate (int'n'l) dir */
-    s = progname = savestring (s);
     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')
@@ -1383,13 +1394,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)
@@ -1403,17 +1414,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 = xmalloc (strlen (argv[i+1]) + 1);
-	  strcpy (dirtmp->fname, argv[++i]);
-	  dirtmp->got_name_map = 0;
 
 	  if (before_system == 0)
 	    before_system = dirtmp;
@@ -1436,18 +1439,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 = 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;
@@ -1470,35 +1463,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 = 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;
@@ -1759,18 +1732,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);
 	  }
 	}
@@ -1959,7 +1922,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;
 
@@ -1973,30 +1935,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,
@@ -2030,18 +1981,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 = 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;
+	    }
 	  }
 	}
       }
@@ -2050,14 +1997,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;
+	}
       }
     }
   }
@@ -2074,37 +2020,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 FATAL_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.  */
@@ -2166,15 +2092,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);
@@ -2217,12 +2135,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.  */
@@ -2230,6 +2176,9 @@ 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);
@@ -2244,9 +2193,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, (char *) 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;
@@ -2281,12 +2230,13 @@ main (argc, argv)
   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 FATAL_EXIT_CODE;
       }
-      finclude (fd, pend_includes[i], &outbuf, 0, NULL_PTR);
+      finclude (fd, inc, &outbuf, 0, NULL_PTR);
     }
   no_record_file--;
 
@@ -2353,38 +2303,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 = xmalloc (2);
-	name[0] = '.';
-	name[1] = 0;
-      } else {
-	/* Otherwise use the directory that is named.  */
-	name = 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++;
     }
 }
 
@@ -3012,6 +2946,8 @@ do { ip = &instack[indepth];		\
 		}
 		break;
 	      }
+	      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
@@ -3080,18 +3016,17 @@ do { ip = &instack[indepth];		\
       {
 	U_CHAR *before_bp = ibp;
 
-	while (ibp < limit) {
+	for (;;) {
 	  switch (*ibp++) {
-	  case '/':
-	    if (warn_comments && *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
@@ -3100,19 +3035,23 @@ 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;
@@ -3251,6 +3190,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--;
@@ -3615,6 +3555,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;
@@ -4254,20 +4195,22 @@ 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;
   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*/
@@ -4276,7 +4219,6 @@ do_include (buf, limit, op, keyword)
   char *pcfbuf;
   char *pcfbuflimit;
   int pcfnum;
-  f= -1;			/* JF we iz paranoid! */
 
   if (importing && warn_import && !inhibit_warnings
       && !instack[indepth].system_header_p && !import_warning) {
@@ -4296,21 +4238,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++;
@@ -4326,7 +4266,6 @@ 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. */
@@ -4337,37 +4276,25 @@ get_filename:
       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, '/');
-#ifdef DIR_SEPARATOR
-	    if (ep == NULL) ep = rindex (nam, DIR_SEPARATOR);
-	    else {
-	      char *tmp = rindex (nam, DIR_SEPARATOR);
-	      if (tmp != NULL && tmp > ep) ep = tmp;
-	    }
-#endif
-#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;
@@ -4377,13 +4304,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;
@@ -4396,15 +4322,14 @@ get_filename:
      * code from case '<' is repeated here) and generates a warning.
      * (Note: macro expansion of `xyz' takes precedence.)
      */
-    if (retried && 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) {
+      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;
       }
     }
@@ -4463,7 +4388,8 @@ get_filename:
       }
   }
 
-  flen = fend - fbeg;
+  *fend = 0;
+  flen = simplify_filename (fbeg);
 
   if (flen == 0)
     {
@@ -4473,129 +4399,110 @@ get_filename:
 
   /* Allocate this permanently, because it gets stored in the definitions
      of macros.  */
-  fname = 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 == '/'
-#ifdef DIR_SEPARATOR
-      || *fbeg == DIR_SEPARATOR
-#endif
-#if defined (__MSDOS__) || defined (_WIN32)
-      || (isalpha (fbeg[0]) && fbeg[1] == ':'
-	  && (fbeg[2] == '/'
-#ifdef DIR_SEPARATOR
-	      || fbeg[2] == DIR_SEPARATOR
-#endif
-	      ))
-#endif
-      ) {
-    strncpy (fname, (char *) 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, skip_redundant_dir_prefix (searchptr->fname));
-	if (fname[0] && fname[strlen (fname) - 1] != '/')
-	  strcat (fname, "/");
-      } 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, (char *) 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);
       } else {
       	/* This is a normal VMS filespec, so use it unchanged.  */
-	strncpy (fname, fbeg, flen);
-	fname[flen] = 0;
+	strcpy (fname, fbeg);
 	/* if it's '#include filename', add the missing .h */
 	if (index(fname,'.')==NULL) {
 	  strcat (fname, ".h");
 	}
       }
 #endif /* VMS */
-      /* ??? There are currently 3 separate mechanisms for avoiding processing
-	 of redundant include files: #import, #pragma once, and
-	 redundant_include_p.  It would be nice if they were unified.  */
-      if (redundant_include_p (fname))
-	return 0;
-      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 (f >= 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 (errno != ENOENT)
 	break;
     }
   }
 
+
   if (f < 0) {
-    /* A file that was not found.  */
 
-    strncpy (fname, (char *) 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 = (char *) alloca (strlen (searchptr->fname)
-					 + strlen (fname) + 2);
-		    strcpy (p, skip_redundant_dir_prefix (searchptr->fname));
-		    if (p[0] && p[strlen (p) - 1] != '/')
-		      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
@@ -4603,57 +4510,16 @@ 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 {
-    /* Check to see if this include file is a once-only include file.
-       If so, give up.  */
-
-    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. */
-    }
+      error ("No include path in which to find %s", fbeg);
 
-    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)
-      fprintf (stderr, "%*s%s\n", indepth, "", 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;
@@ -4661,10 +4527,6 @@ get_filename:
 
     if (!no_precomp)
       {
-	struct stat stat_f;
-
-	fstat (f, &stat_f);
-
 	do {
 	  sprintf (pcftry, "%s%d", fname, pcfnum++);
 
@@ -4673,12 +4535,12 @@ get_filename:
 	    {
 	      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)
+	      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, fname, &pcfbuflimit);
+		  pcfbuf = check_precompiled (pcf, &s, fname, &pcfbuflimit);
 		  /* Don't need it any more.  */
 		  close (pcf);
 		}
@@ -4700,28 +4562,11 @@ get_filename:
 		  (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;
 }
 
@@ -4744,38 +4589,116 @@ is_system_include (filename)
 
   for (searchptr = first_system_include; searchptr;
        searchptr = searchptr->next)
-    if (searchptr->fname) {
-      register char *sys_dir = skip_redundant_dir_prefix (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;
+}
+
+/* Yield the non-directory suffix of a file name.  */
 
-      if (! strncmp (sys_dir, filename, length)
-	  && (filename[length] == '/'
+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
-	      || filename[length] == 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)
+  if (isalpha (filename[0]) && filename[1] == ':') filename += 2;
+#endif
+  if (filename[0] == '/') return 1;
+#ifdef DIR_SEPARATOR
+  if (filename[0] == DIR_SEPARATOR) return 1;
 #endif
-	      )) {
-	if (searchptr->c_system_include_path)
-	  return 2;
-	else
-	  return 1;
-      }
-    }
   return 0;
 }
-
-/* Skip leading "./" from a directory name.
-   This may yield the empty string, which represents the current directory.  */
 
-static char *
-skip_redundant_dir_prefix (dir)
-     char *dir;
+/* 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;
 {
-  while (dir[0] == '.' && dir[1] == '/')
-    for (dir += 2; *dir == '/'; dir++)
-      continue;
-  if (dir[0] == '.' && !dir[1])
-    dir++;
-  return dir;
+  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++ = '/';
+      }
+    }
+  }
+  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++;
+  }
 }
 
 /* The file_name_map structure holds a mapping of file names for a
@@ -4827,7 +4750,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)
@@ -4846,9 +4771,6 @@ read_name_map (dirname)
   char *name;
   FILE *f;
   size_t dirlen;
-  int separator_needed;
-
-  dirname = skip_redundant_dir_prefix (dirname);
 
   for (map_list_ptr = map_list; map_list_ptr;
        map_list_ptr = map_list_ptr->map_list_next)
@@ -4861,11 +4783,9 @@ read_name_map (dirname)
   map_list_ptr->map_list_map = NULL;
 
   dirlen = strlen (dirname);
-  separator_needed = dirlen != 0 && dirname[dirlen - 1] != '/';
-  name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 2);
+  name = (char *) alloca (dirlen + strlen (FILE_NAME_MAP_FILE) + 1);
   strcpy (name, dirname);
-  name[dirlen] = '/';
-  strcpy (name + dirlen + separator_needed, FILE_NAME_MAP_FILE);
+  strcat (name, FILE_NAME_MAP_FILE);
   f = fopen (name, "r");
   if (!f)
     map_list_ptr->map_list_map = NULL;
@@ -4877,6 +4797,7 @@ read_name_map (dirname)
 	{
 	  char *from, *to;
 	  struct file_name_map *ptr;
+	  size_t tolen;
 
 	  if (is_space[ch])
 	    continue;
@@ -4885,19 +4806,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 + separator_needed, to);
+	      strcat (ptr->map_to, to);
 	      free (to);
 	    }	      
 
@@ -4918,85 +4841,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, '/');
-#ifdef DIR_SEPARATOR
-  if (! p) p = rindex (filename, DIR_SEPARATOR);
-  else {
-    char *tmp = rindex (filename, DIR_SEPARATOR);
-    if (tmp != NULL && tmp > p) p = tmp;
-  }
-#endif
-  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;
 }
 
-/* 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'
@@ -5005,47 +4996,40 @@ 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, (char *) 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;
@@ -5055,8 +5039,8 @@ finclude (f, fname, op, system_header_p, dirptr)
        copy them into buffer on stack. */
 
     int bsize = 2000;
+    int st_size = 0;
 
-    st_size = 0;
     fp->buf = (U_CHAR *) xmalloc (bsize + 2);
 
     for (;;) {
@@ -5115,129 +5099,25 @@ 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 ();
-}
-
-/* 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 = 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;
 }
 
 /* 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
@@ -5246,27 +5126,23 @@ add_import (fd, fname)
    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;
     }
@@ -6872,25 +6748,12 @@ 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;
-  }
 }
 
 /* #ident has already been copied to the output file, so just ignore it.  */
@@ -6949,8 +6812,9 @@ do_pragma (buf, limit, op, keyword)
   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;
@@ -6959,15 +6823,16 @@ do_pragma (buf, limit, op, keyword)
     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 ((char *) inc_fname, (char *) 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;
 }
 
@@ -7365,23 +7230,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;
@@ -7623,7 +7498,7 @@ 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);
@@ -7693,54 +7568,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) {
+    for (; bp < limit; bp++) {
+      if (op)
 	*op->bufp++ = *bp;
-	if (*bp == '\n' && bp[-1] != '\\')
+      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++;
-	}
       }
     }
     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
@@ -7753,14 +7612,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;
@@ -8418,6 +8279,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;
@@ -8613,29 +8475,31 @@ 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] == '/')
+	      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");
+	  }
 	}
-	/* Now count the newline that we are about to skip.  */
-	++*newlines;
-	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 '\'':
@@ -9879,6 +9743,80 @@ make_assertion (option, str)
   --indepth;
 }
 
+/* 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;
+    }
+
+    /* Ignore a nonexistent directory.  */
+    if (stat (len ? dir->fname : ".", &dir->st) != 0) {
+      if (errno != ENOENT)
+	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;
+    }
+
+    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.  */
@@ -10060,23 +9998,6 @@ savestring (input)
   return output;
 }
 
-/* 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;
-}
-
 #ifdef VMS
 
 /* Under VMS we need to fix up the "include" specification
@@ -10088,38 +10009,19 @@ hack_vms_include_specification (fname)
      char *fname;
 {
   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 (!index (cp,'.'))
+    strcat (cp, ".h");
 
   cp2 = Local;			/* initialize */
 
@@ -10226,7 +10128,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.  */
@@ -10346,26 +10248,6 @@ open (fname, flags, prot)
 #undef open	/* Get back the REAL open routine */
   return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef");
 }
-
-/* 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.  [Fixed in V5.5-2's VAXCRTL.]  */
-
-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;
-}
 
 /* more VMS hackery */
 #include <fab.h>