Changeset 3138 for vendor/gnumake/current/dir.c

Timestamp:

Mar 12, 2018, 8:32:29 PM (7 years ago)

Author:

bird

Message:

Imported make 4.2.1 (2e55f5e4abdc0e38c1d64be703b446695e70b3b6) from ​https://git.savannah.gnu.org/git/make.git.

File:

• vendor/gnumake/current/dir.c (modified) (51 diffs)

vendor/gnumake/current/dir.c

@@ -1 +1 @@
 /* Directory hashing for GNU Make.
-Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
-1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-2010 Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 
@@ -17 +15 @@
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-#include "make.h"
+#include "makeint.h"
 #include "hash.h"
-
-#ifdef  HAVE_DIRENT_H
+#include "filedef.h"
+#include "dep.h"
+
+#ifdef  HAVE_DIRENT_H
 # include <dirent.h>
 # define NAMLEN(dirent) strlen((dirent)->d_name)
@@ -88 +88 @@
 
   /* First, transform the name part.  */
-  for (i = 0; *filename != '\0' && i < 8 && *filename != '.'; ++i)
+  for (i = 0; i < 8 && ! STOP_SET (*filename, MAP_DOT|MAP_NUL); ++i)
     *df++ = tolower ((unsigned char)*filename++);
 
   /* Now skip to the next dot.  */
-  while (*filename != '\0' && *filename != '.')
+  while (! STOP_SET (*filename, MAP_DOT|MAP_NUL))
     ++filename;
   if (*filename != '\0')
     {
       *df++ = *filename++;
-      for (i = 0; *filename != '\0' && i < 3 && *filename != '.'; ++i)
-        *df++ = tolower ((unsigned char)*filename++);
+      for (i = 0; i < 3 && ! STOP_SET (*filename, MAP_DOT|MAP_NUL); ++i)
+        *df++ = tolower ((unsigned char)*filename++);
     }
 
   /* Look for more dots.  */
-  while (*filename != '\0' && *filename != '.')
+  while (! STOP_SET (*filename, MAP_DOT|MAP_NUL))
     ++filename;
   if (*filename == '.')
@@ -144 +144 @@
 #ifdef VMS
 
+static char *
+downcase_inplace(char *filename)
+{
+  char *name;
+  name = filename;
+  while (*name != '\0')
+    {
+      *name = tolower ((unsigned char)*name);
+      ++name;
+    }
+  return filename;
+}
+
+#ifndef _USE_STD_STAT
+/* VMS 8.2 fixed the VMS stat output to have unique st_dev and st_ino
+   when _USE_STD_STAT is used on the compile line.
+
+   Prior to _USE_STD_STAT support, the st_dev is a pointer to thread
+   static memory containing the device of the last filename looked up.
+
+   Todo: find out if the ino_t still needs to be faked on a directory.
+ */
+
+/* Define this if the older VMS_INO_T is needed */
+#define VMS_INO_T 1
+
 static int
 vms_hash (const char *name)
 {
   int h = 0;
-  int g;
 
   while (*name)
     {
       unsigned char uc = *name;
+      int g;
 #ifdef HAVE_CASE_INSENSITIVE_FS
       h = (h << 4) + (isupper (uc) ? tolower (uc) : uc);
@@ -161 +187 @@
       g = h & 0xf0000000;
       if (g)
-        {
-          h = h ^ (g >> 24);
-          h = h ^ g;
-        }
+        {
+          h = h ^ (g >> 24);
+          h = h ^ g;
+        }
     }
   return h;
@@ -181 +207 @@
     return -1;
   closedir (dir);
-  s = strchr (name, ':');       /* find device */
+  s = strchr (name, ':');       /* find device */
   if (s)
     {
@@ -202 +228 @@
   return 0;
 }
+
+# define stat(__path, __sbuf) vmsstat_dir (__path, __sbuf)
+
+#endif /* _USE_STD_STAT */
 #endif /* VMS */
 
@@ -207 +237 @@
 /* Hash table of directories.  */
 
-#ifndef DIRECTORY_BUCKETS
+#ifndef DIRECTORY_BUCKETS
 #define DIRECTORY_BUCKETS 199
 #endif
@@ -213 +243 @@
 struct directory_contents
   {
-    dev_t dev;                  /* Device and inode numbers of this dir.  */
+    dev_t dev;                  /* Device and inode numbers of this dir.  */
 #ifdef WINDOWS32
     /* Inode means nothing on WINDOWS32. Even file key information is
@@ -221 +251 @@
      * unreliable. I'm open to suggestion on a better way to emulate inode.  */
     char *path_key;
-    int   ctime;
-    int   mtime;        /* controls check for stale directory cache */
-    int   fs_flags;     /* FS_FAT, FS_NTFS, ... */
+    time_t ctime;
+    time_t mtime;        /* controls check for stale directory cache */
+    int fs_flags;     /* FS_FAT, FS_NTFS, ... */
 # define FS_FAT      0x1
 # define FS_NTFS     0x2
 # define FS_UNKNOWN  0x4
 #else
-# ifdef VMS
+# ifdef VMS_INO_T
     ino_t ino[3];
 # else
@@ -234 +264 @@
 # endif
 #endif /* WINDOWS32 */
-    struct hash_table dirfiles; /* Files in this directory.  */
-    DIR *dirstream;             /* Stream reading this directory.  */
+    struct hash_table dirfiles; /* Files in this directory.  */
+    DIR *dirstream;             /* Stream reading this directory.  */
   };
 
@@ -249 +279 @@
   hash ^= ((unsigned int) key->dev << 4) ^ (unsigned int) key->ctime;
 #else
-# ifdef VMS
+# ifdef VMS_INO_T
   hash = (((unsigned int) key->dev << 4)
-          ^ ((unsigned int) key->ino[0]
-             + (unsigned int) key->ino[1]
-             + (unsigned int) key->ino[2]));
+          ^ ((unsigned int) key->ino[0]
+             + (unsigned int) key->ino[1]
+             + (unsigned int) key->ino[2]));
 # else
   hash = ((unsigned int) key->dev << 4) ^ (unsigned int) key->ino;
@@ -272 +302 @@
   hash ^= ((unsigned int) key->dev << 4) ^ (unsigned int) ~key->ctime;
 #else
-# ifdef VMS
+# ifdef VMS_INO_T
   hash = (((unsigned int) key->dev << 4)
-          ^ ~((unsigned int) key->ino[0]
-              + (unsigned int) key->ino[1]
-              + (unsigned int) key->ino[2]));
+          ^ ~((unsigned int) key->ino[0]
+              + (unsigned int) key->ino[1]
+              + (unsigned int) key->ino[2]));
 # else
   hash = ((unsigned int) key->dev << 4) ^ (unsigned int) ~key->ino;
@@ -311 +341 @@
     return result;
 #else
-# ifdef VMS
+# ifdef VMS_INO_T
   result = MAKECMP(x->ino[0], y->ino[0]);
   if (result)
@@ -336 +366 @@
 struct directory
   {
-    const char *name;                   /* Name of the directory.  */
+    const char *name;                   /* Name of the directory.  */
 
     /* The directory's contents.  This data may be shared by several
        entries in the hash table, which refer to the same directory
-       (identified uniquely by `dev' and `ino') under different names.  */
+       (identified uniquely by 'dev' and 'ino') under different names.  */
     struct directory_contents *contents;
   };
@@ -360 +390 @@
 {
   return_ISTRING_COMPARE (((const struct directory *) x)->name,
-                          ((const struct directory *) y)->name);
+                          ((const struct directory *) y)->name);
 }
 
@@ -377 +407 @@
 struct dirfile
   {
-    const char *name;           /* Name of the file.  */
-    short length;
-    short impossible;           /* This file is impossible.  */
+    const char *name;           /* Name of the file.  */
+    size_t length;
+    short impossible;           /* This file is impossible.  */
   };
 
@@ -405 +435 @@
 }
 
-#ifndef DIRFILE_BUCKETS
+#ifndef DIRFILE_BUCKETS
 #define DIRFILE_BUCKETS 107
 #endif
@@ -414 +444 @@
 static struct directory *find_directory (const char *name);
 
-/* Find the directory named NAME and return its `struct directory'.  */
+/* Find the directory named NAME and return its 'struct directory'.  */
 
 static struct directory *
 find_directory (const char *name)
 {
-  const char *p;
   struct directory *dir;
   struct directory **dir_slot;
   struct directory dir_key;
-  int r;
-#ifdef WINDOWS32
-  char* w32_path;
-  char  fs_label[BUFSIZ];
-  char  fs_type[BUFSIZ];
-  unsigned long  fs_serno;
-  unsigned long  fs_flags;
-  unsigned long  fs_len;
-#endif
-#ifdef VMS
-  if ((*name == '.') && (*(name+1) == 0))
-    name = "[]";
-  else
-    name = vmsify (name,1);
-#endif
 
   dir_key.name = name;
@@ -445 +459 @@
   if (HASH_VACANT (dir))
     {
+      /* The directory was not found.  Create a new entry for it.  */
+      const char *p = name + strlen (name);
       struct stat st;
-
-      /* The directory was not found.  Create a new entry for it.  */
-
-      p = name + strlen (name);
+      int r;
+
       dir = xmalloc (sizeof (struct directory));
 #if defined(HAVE_CASE_INSENSITIVE_FS) && defined(VMS)
-      dir->name = strcache_add_len (downcase(name), p - name);
+      /* Todo: Why is this only needed on VMS? */
+      {
+        char *lname = downcase_inplace (xstrdup (name));
+        dir->name = strcache_add_len (lname, p - name);
+        free (lname);
+      }
 #else
       dir->name = strcache_add_len (name, p - name);
@@ -458 +477 @@
       hash_insert_at (&directories, dir, dir_slot);
       /* The directory is not in the name hash table.
-         Find its device and inode numbers, and look it up by them.  */
-
-#ifdef VMS
-      r = vmsstat_dir (name, &st);
-#elif defined(WINDOWS32)
+         Find its device and inode numbers, and look it up by them.  */
+
+#if defined(WINDOWS32)
       {
         char tem[MAXPATHLEN], *tstart, *tend;
@@ -485 +502 @@
       if (r < 0)
         {
-        /* Couldn't stat the directory.  Mark this by
-           setting the `contents' member to a nil pointer.  */
-          dir->contents = 0;
-        }
+        /* Couldn't stat the directory.  Mark this by
+           setting the 'contents' member to a nil pointer.  */
+          dir->contents = 0;
+        }
       else
-        {
-          /* Search the contents hash table; device and inode are the key.  */
-
-          struct directory_contents *dc;
-          struct directory_contents **dc_slot;
-          struct directory_contents dc_key;
-
-          dc_key.dev = st.st_dev;
-#ifdef WINDOWS32
-          dc_key.path_key = w32_path = w32ify (name, 1);
-          dc_key.ctime = st.st_ctime;
-#else
-# ifdef VMS
-          dc_key.ino[0] = st.st_ino[0];
-          dc_key.ino[1] = st.st_ino[1];
-          dc_key.ino[2] = st.st_ino[2];
+        {
+          /* Search the contents hash table; device and inode are the key.  */
+
+#ifdef WINDOWS32
+          char *w32_path;
+#endif
+          struct directory_contents *dc;
+          struct directory_contents **dc_slot;
+          struct directory_contents dc_key;
+
+          dc_key.dev = st.st_dev;
+#ifdef WINDOWS32
+          dc_key.path_key = w32_path = w32ify (name, 1);
+          dc_key.ctime = st.st_ctime;
+#else
+# ifdef VMS_INO_T
+          dc_key.ino[0] = st.st_ino[0];
+          dc_key.ino[1] = st.st_ino[1];
+          dc_key.ino[2] = st.st_ino[2];
 # else
-          dc_key.ino = st.st_ino;
+          dc_key.ino = st.st_ino;
 # endif
 #endif
-          dc_slot = (struct directory_contents **) hash_find_slot (&directory_contents, &dc_key);
-          dc = *dc_slot;
-
-          if (HASH_VACANT (dc))
-            {
-              /* Nope; this really is a directory we haven't seen before.  */
-
-              dc = (struct directory_contents *)
-                xmalloc (sizeof (struct directory_contents));
-
-              /* Enter it in the contents hash table.  */
-              dc->dev = st.st_dev;
+          dc_slot = (struct directory_contents **) hash_find_slot (&directory_contents, &dc_key);
+          dc = *dc_slot;
+
+          if (HASH_VACANT (dc))
+            {
+              /* Nope; this really is a directory we haven't seen before.  */
+#ifdef WINDOWS32
+              char  fs_label[BUFSIZ];
+              char  fs_type[BUFSIZ];
+              unsigned long  fs_serno;
+              unsigned long  fs_flags;
+              unsigned long  fs_len;
+#endif
+              dc = (struct directory_contents *)
+                xmalloc (sizeof (struct directory_contents));
+
+              /* Enter it in the contents hash table.  */
+              dc->dev = st.st_dev;
 #ifdef WINDOWS32
               dc->path_key = xstrdup (w32_path);
-              dc->ctime = st.st_ctime;
+              dc->ctime = st.st_ctime;
               dc->mtime = st.st_mtime;
 
-              /*
-               * NTFS is the only WINDOWS32 filesystem that bumps mtime
-               * on a directory when files are added/deleted from
-               * a directory.
-               */
+              /* NTFS is the only WINDOWS32 filesystem that bumps mtime on a
+                 directory when files are added/deleted from a directory.  */
               w32_path[3] = '\0';
-              if (GetVolumeInformation(w32_path,
-                     fs_label, sizeof (fs_label),
-                     &fs_serno, &fs_len,
-                     &fs_flags, fs_type, sizeof (fs_type)) == FALSE)
+              if (GetVolumeInformation (w32_path, fs_label, sizeof (fs_label),
+                                        &fs_serno, &fs_len, &fs_flags, fs_type,
+                                        sizeof (fs_type)) == FALSE)
                 dc->fs_flags = FS_UNKNOWN;
-              else if (!strcmp(fs_type, "FAT"))
+              else if (!strcmp (fs_type, "FAT"))
                 dc->fs_flags = FS_FAT;
-              else if (!strcmp(fs_type, "NTFS"))
+              else if (!strcmp (fs_type, "NTFS"))
                 dc->fs_flags = FS_NTFS;
               else
                 dc->fs_flags = FS_UNKNOWN;
 #else
-# ifdef VMS
-              dc->ino[0] = st.st_ino[0];
-              dc->ino[1] = st.st_ino[1];
-              dc->ino[2] = st.st_ino[2];
+# ifdef VMS_INO_T
+              dc->ino[0] = st.st_ino[0];
+              dc->ino[1] = st.st_ino[1];
+              dc->ino[2] = st.st_ino[2];
 # else
-              dc->ino = st.st_ino;
+              dc->ino = st.st_ino;
 # endif
 #endif /* WINDOWS32 */
-              hash_insert_at (&directory_contents, dc, dc_slot);
-              ENULLLOOP (dc->dirstream, opendir (name));
-              if (dc->dirstream == 0)
+              hash_insert_at (&directory_contents, dc, dc_slot);
+              ENULLLOOP (dc->dirstream, opendir (name));
+              if (dc->dirstream == 0)
                 /* Couldn't open the directory.  Mark this by setting the
-                   `files' member to a nil pointer.  */
+                   'files' member to a nil pointer.  */
                 dc->dirfiles.ht_vec = 0;
-              else
-                {
-                  hash_init (&dc->dirfiles, DIRFILE_BUCKETS,
-                             dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp);
-                  /* Keep track of how many directories are open.  */
-                  ++open_directories;
-                  if (open_directories == MAX_OPEN_DIRECTORIES)
-                    /* We have too many directories open already.
-                       Read the entire directory and then close it.  */
-                    dir_contents_file_exists_p (dc, 0);
-                }
-            }
-
-          /* Point the name-hashed entry for DIR at its contents data.  */
-          dir->contents = dc;
-        }
+              else
+                {
+                  hash_init (&dc->dirfiles, DIRFILE_BUCKETS,
+                             dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp);
+                  /* Keep track of how many directories are open.  */
+                  ++open_directories;
+                  if (open_directories == MAX_OPEN_DIRECTORIES)
+                    /* We have too many directories open already.
+                       Read the entire directory and then close it.  */
+                    dir_contents_file_exists_p (dc, 0);
+                }
+            }
+
+          /* Point the name-hashed entry for DIR at its contents data.  */
+          dir->contents = dc;
+        }
     }
 
@@ -588 +610 @@
                             const char *filename)
 {
-  unsigned int hash;
   struct dirfile *df;
   struct dirent *d;
@@ -612 +633 @@
     _fnlwr (filename); /* lower case for FAT drives */
 #endif
-
-#ifdef VMS
-  filename = vmsify (filename,0);
-#endif
-
-  hash = 0;
   if (filename != 0)
     {
@@ -623 +638 @@
 
       if (*filename == '\0')
-        {
-          /* Checking if the directory exists.  */
-          return 1;
-        }
+        {
+          /* Checking if the directory exists.  */
+          return 1;
+        }
       dirfile_key.name = filename;
       dirfile_key.length = strlen (filename);
@@ -646 +661 @@
        */
       if (dir->path_key)
-        {
+        {
           if ((dir->fs_flags & FS_FAT) != 0)
-            {
-              dir->mtime = time ((time_t *) 0);
-              rehash = 1;
-            }
-          else if (stat (dir->path_key, &st) == 0 && st.st_mtime > dir->mtime)
-            {
-              /* reset date stamp to show most recent re-process.  */
-              dir->mtime = st.st_mtime;
-              rehash = 1;
-            }
+            {
+              dir->mtime = time ((time_t *) 0);
+              rehash = 1;
+            }
+          else if (stat (dir->path_key, &st) == 0 && st.st_mtime > dir->mtime)
+            {
+              /* reset date stamp to show most recent re-process.  */
+              dir->mtime = st.st_mtime;
+              rehash = 1;
+            }
 
           /* If it has been already read in, all done.  */
-          if (!rehash)
-            return 0;
+          if (!rehash)
+            return 0;
 
           /* make sure directory can still be opened; if not return.  */
@@ -667 +682 @@
           if (!dir->dirstream)
             return 0;
-        }
+        }
       else
 #endif
-        /* The directory has been all read in.  */
-        return 0;
+        /* The directory has been all read in.  */
+        return 0;
     }
 
@@ -685 +700 @@
         {
           if (errno)
-            fatal (NILF, "INTERNAL: readdir: %s\n", strerror (errno));
+            pfatal_with_name ("INTERNAL: readdir");
           break;
         }
 
 #if defined(VMS) && defined(HAVE_DIRENT_H)
-      /* In VMS we get file versions too, which have to be stripped off */
+      /* In VMS we get file versions too, which have to be stripped off.
+         Some versions of VMS return versions on Unix files even when
+         the feature option to strip them is set.  */
       {
         char *p = strrchr (d->d_name, ';');
@@ -698 +715 @@
 #endif
       if (!REAL_DIR_ENTRY (d))
-        continue;
+        continue;
 
       len = NAMLEN (d);
@@ -711 +728 @@
       if (! rehash || HASH_VACANT (*dirfile_slot))
 #endif
-        {
-          df = xmalloc (sizeof (struct dirfile));
+        {
+          df = xmalloc (sizeof (struct dirfile));
 #if defined(HAVE_CASE_INSENSITIVE_FS) && defined(VMS)
-          df->name = strcache_add_len (downcase(d->d_name), len);
-#else
-          df->name = strcache_add_len (d->d_name, len);
-#endif
-          df->length = len;
-          df->impossible = 0;
-          hash_insert_at (&dir->dirfiles, df, dirfile_slot);
-        }
+          /* TODO: Why is this only needed on VMS? */
+          df->name = strcache_add_len (downcase_inplace (d->d_name), len);
+#else
+          df->name = strcache_add_len (d->d_name, len);
+#endif
+          df->length = len;
+          df->impossible = 0;
+          hash_insert_at (&dir->dirfiles, df, dirfile_slot);
+        }
       /* Check if the name matches the one we're searching for.  */
       if (filename != 0 && patheq (d->d_name, filename))
@@ -745 +763 @@
 dir_file_exists_p (const char *dirname, const char *filename)
 {
+#ifdef VMS
+  if ((filename != NULL) && (dirname != NULL))
+    {
+      int want_vmsify;
+      want_vmsify = (strpbrk (dirname, ":<[") != NULL);
+      if (want_vmsify)
+        filename = vmsify (filename, 0);
+    }
+#endif
   return dir_contents_file_exists_p (find_directory (dirname)->contents,
-                                     filename);
+                                     filename);
 }
 
@@ -759 +786 @@
   const char *slash;
 
-#ifndef NO_ARCHIVES
+#ifndef NO_ARCHIVES
   if (ar_name (name))
     return ar_member_date (name) != (time_t) -1;
 #endif
 
+  dirend = strrchr (name, '/');
 #ifdef VMS
-  dirend = strrchr (name, ']');
   if (dirend == 0)
-    dirend = strrchr (name, ':');
+    {
+      dirend = strrchr (name, ']');
+      dirend == NULL ? dirend : dirend++;
+    }
   if (dirend == 0)
-    return dir_file_exists_p ("[]", name);
-#else /* !VMS */
-  dirend = strrchr (name, '/');
+    {
+      dirend = strrchr (name, '>');
+      dirend == NULL ? dirend : dirend++;
+    }
+  if (dirend == 0)
+    {
+      dirend = strrchr (name, ':');
+      dirend == NULL ? dirend : dirend++;
+    }
+#endif /* VMS */
 #ifdef HAVE_DOS_PATHS
   /* Forward and backslashes might be mixed.  We need the rightmost one.  */
   {
-    const char *bslash = strrchr(name, '\\');
+    const char *bslash = strrchr (name, '\\');
     if (!dirend || bslash > dirend)
       dirend = bslash;
@@ -786 +823 @@
 #ifndef _AMIGA
     return dir_file_exists_p (".", name);
-#else /* !VMS && !AMIGA */
+#else /* !AMIGA */
     return dir_file_exists_p ("", name);
 #endif /* AMIGA */
-#endif /* VMS */
 
   slash = dirend;
@@ -800 +836 @@
   /* d:/ and d: are *very* different...  */
       if (dirend < name + 3 && name[1] == ':' &&
-          (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
-        dirend++;
+          (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
+        dirend++;
 #endif
       p = alloca (dirend - name + 1);
@@ -808 +844 @@
       dirname = p;
     }
-  return dir_file_exists_p (dirname, slash + 1);
-}
-
-
-/* Mark FILENAME as `impossible' for `file_impossible_p'.
+#ifdef VMS
+  if (*slash == '/')
+    slash++;
+#else
+  slash++;
+#endif
+  return dir_file_exists_p (dirname, slash);
+}
+
+
+/* Mark FILENAME as 'impossible' for 'file_impossible_p'.
    This means an attempt has been made to search for FILENAME
    as an intermediate file, and it has failed.  */
@@ -824 +866 @@
   struct dirfile *new;
 
+  dirend = strrchr (p, '/');
 #ifdef VMS
-  dirend = strrchr (p, ']');
-  if (dirend == 0)
-    dirend = strrchr (p, ':');
-  dirend++;
-  if (dirend == (char *)1)
-    dir = find_directory ("[]");
-#else
-  dirend = strrchr (p, '/');
-# ifdef HAVE_DOS_PATHS
+  if (dirend == NULL)
+    {
+      dirend = strrchr (p, ']');
+      dirend == NULL ? dirend : dirend++;
+    }
+  if (dirend == NULL)
+    {
+      dirend = strrchr (p, '>');
+      dirend == NULL ? dirend : dirend++;
+    }
+  if (dirend == NULL)
+    {
+      dirend = strrchr (p, ':');
+      dirend == NULL ? dirend : dirend++;
+    }
+#endif
+#ifdef HAVE_DOS_PATHS
   /* Forward and backslashes might be mixed.  We need the rightmost one.  */
   {
-    const char *bslash = strrchr(p, '\\');
+    const char *bslash = strrchr (p, '\\');
     if (!dirend || bslash > dirend)
       dirend = bslash;
@@ -843 +894 @@
       dirend = p + 1;
   }
-# endif /* HAVE_DOS_PATHS */
+#endif /* HAVE_DOS_PATHS */
   if (dirend == 0)
-# ifdef _AMIGA
+#ifdef _AMIGA
     dir = find_directory ("");
-# else /* !VMS && !AMIGA */
+#else /* !AMIGA */
     dir = find_directory (".");
-# endif /* AMIGA */
-#endif /* VMS */
+#endif /* AMIGA */
   else
     {
@@ -856 +906 @@
       const char *slash = dirend;
       if (dirend == p)
-        dirname = "/";
+        dirname = "/";
       else
-        {
+        {
           char *cp;
 #ifdef HAVE_DOS_PATHS
-          /* d:/ and d: are *very* different...  */
-          if (dirend < p + 3 && p[1] == ':' &&
-              (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
-            dirend++;
-#endif
-          cp = alloca (dirend - p + 1);
-          memcpy (cp, p, dirend - p);
-          cp[dirend - p] = '\0';
+          /* d:/ and d: are *very* different...  */
+          if (dirend < p + 3 && p[1] == ':' &&
+              (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
+            dirend++;
+#endif
+          cp = alloca (dirend - p + 1);
+          memcpy (cp, p, dirend - p);
+          cp[dirend - p] = '\0';
           dirname = cp;
-        }
+        }
       dir = find_directory (dirname);
+#ifdef VMS
+      if (*slash == '/')
+        filename = p = slash + 1;
+      else
+        filename = p = slash;
+#else
       filename = p = slash + 1;
+#endif
     }
 
@@ -883 +940 @@
     {
       hash_init (&dir->contents->dirfiles, DIRFILE_BUCKETS,
-                 dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp);
+                 dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp);
     }
 
@@ -891 +948 @@
   new->length = strlen (filename);
 #if defined(HAVE_CASE_INSENSITIVE_FS) && defined(VMS)
-  new->name = strcache_add_len (downcase(filename), new->length);
+  /* todo: Why is this only needed on VMS? */
+  new->name = strcache_add_len (downcase (filename), new->length);
 #else
   new->name = strcache_add_len (filename, new->length);
@@ -906 +964 @@
 {
   const char *dirend;
-  const char *p = filename;
   struct directory_contents *dir;
   struct dirfile *dirfile;
   struct dirfile dirfile_key;
-
 #ifdef VMS
-  dirend = strrchr (filename, ']');
-  if (dirend == 0)
-    dir = find_directory ("[]")->contents;
-#else
+  int want_vmsify = 0;
+#endif
+
   dirend = strrchr (filename, '/');
+#ifdef VMS
+  if (dirend == NULL)
+    {
+      want_vmsify = (strpbrk (filename, "]>:^") != NULL);
+      dirend = strrchr (filename, ']');
+    }
+  if (dirend == NULL && want_vmsify)
+    dirend = strrchr (filename, '>');
+  if (dirend == NULL && want_vmsify)
+    dirend = strrchr (filename, ':');
+#endif
 #ifdef HAVE_DOS_PATHS
   /* Forward and backslashes might be mixed.  We need the rightmost one.  */
   {
-    const char *bslash = strrchr(filename, '\\');
+    const char *bslash = strrchr (filename, '\\');
     if (!dirend || bslash > dirend)
       dirend = bslash;
@@ -931 +997 @@
 #ifdef _AMIGA
     dir = find_directory ("")->contents;
-#else /* !VMS && !AMIGA */
+#else /* !AMIGA */
     dir = find_directory (".")->contents;
 #endif /* AMIGA */
-#endif /* VMS */
   else
     {
@@ -940 +1005 @@
       const char *slash = dirend;
       if (dirend == filename)
-        dirname = "/";
+        dirname = "/";
       else
-        {
+        {
           char *cp;
 #ifdef HAVE_DOS_PATHS
-          /* d:/ and d: are *very* different...  */
-          if (dirend < filename + 3 && filename[1] == ':' &&
-              (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
-            dirend++;
-#endif
-          cp = alloca (dirend - filename + 1);
-          memcpy (cp, p, dirend - p);
-          cp[dirend - p] = '\0';
+          /* d:/ and d: are *very* different...  */
+          if (dirend < filename + 3 && filename[1] == ':' &&
+              (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
+            dirend++;
+#endif
+          cp = alloca (dirend - filename + 1);
+          memcpy (cp, filename, dirend - filename);
+          cp[dirend - filename] = '\0';
           dirname = cp;
-        }
+        }
       dir = find_directory (dirname)->contents;
-      p = filename = slash + 1;
+#ifdef VMS
+      if (*slash == '/')
+        filename = slash + 1;
+      else
+        filename = slash;
+#else
+      filename = slash + 1;
+#endif
     }
 
@@ -964 +1036 @@
 
 #ifdef __MSDOS__
-  filename = dosify (p);
+  filename = dosify (filename);
 #endif
 #ifdef HAVE_CASE_INSENSITIVE_FS
-  filename = downcase (p);
+  filename = downcase (filename);
 #endif
 #ifdef VMS
-  filename = vmsify (p, 1);
+  if (want_vmsify)
+    filename = vmsify (filename, 1);
 #endif
 
@@ -1013 +1086 @@
       struct directory *dir = *dir_slot;
       if (! HASH_VACANT (dir))
-        {
-          if (dir->contents == 0)
-            printf (_("# %s: could not be stat'd.\n"), dir->name);
-          else if (dir->contents->dirfiles.ht_vec == 0)
-            {
-#ifdef WINDOWS32
-              printf (_("# %s (key %s, mtime %d): could not be opened.\n"),
-                      dir->name, dir->contents->path_key,dir->contents->mtime);
+        {
+          if (dir->contents == 0)
+            printf (_("# %s: could not be stat'd.\n"), dir->name);
+          else if (dir->contents->dirfiles.ht_vec == 0)
+            {
+#ifdef WINDOWS32
+              printf (_("# %s (key %s, mtime %I64u): could not be opened.\n"),
+                      dir->name, dir->contents->path_key,
+                      (unsigned long long)dir->contents->mtime);
 #else  /* WINDOWS32 */
-#ifdef VMS
-              printf (_("# %s (device %d, inode [%d,%d,%d]): could not be opened.\n"),
-                      dir->name, dir->contents->dev,
-                      dir->contents->ino[0], dir->contents->ino[1],
-                      dir->contents->ino[2]);
-#else
-              printf (_("# %s (device %ld, inode %ld): could not be opened.\n"),
-                      dir->name, (long int) dir->contents->dev,
-                      (long int) dir->contents->ino);
+#ifdef VMS_INO_T
+              printf (_("# %s (device %d, inode [%d,%d,%d]): could not be opened.\n"),
+                      dir->name, dir->contents->dev,
+                      dir->contents->ino[0], dir->contents->ino[1],
+                      dir->contents->ino[2]);
+#else
+              printf (_("# %s (device %ld, inode %ld): could not be opened.\n"),
+                      dir->name, (long int) dir->contents->dev,
+                      (long int) dir->contents->ino);
 #endif
 #endif /* WINDOWS32 */
-            }
-          else
-            {
-              unsigned int f = 0;
-              unsigned int im = 0;
-              struct dirfile **files_slot;
-              struct dirfile **files_end;
-
-              files_slot = (struct dirfile **) dir->contents->dirfiles.ht_vec;
-              files_end = files_slot + dir->contents->dirfiles.ht_size;
-              for ( ; files_slot < files_end; files_slot++)
-                {
-                  struct dirfile *df = *files_slot;
-                  if (! HASH_VACANT (df))
-                    {
-                      if (df->impossible)
-                        ++im;
-                      else
-                        ++f;
-                    }
-                }
-#ifdef WINDOWS32
-              printf (_("# %s (key %s, mtime %d): "),
-                      dir->name, dir->contents->path_key, dir->contents->mtime);
+            }
+          else
+            {
+              unsigned int f = 0;
+              unsigned int im = 0;
+              struct dirfile **files_slot;
+              struct dirfile **files_end;
+
+              files_slot = (struct dirfile **) dir->contents->dirfiles.ht_vec;
+              files_end = files_slot + dir->contents->dirfiles.ht_size;
+              for ( ; files_slot < files_end; files_slot++)
+                {
+                  struct dirfile *df = *files_slot;
+                  if (! HASH_VACANT (df))
+                    {
+                      if (df->impossible)
+                        ++im;
+                      else
+                        ++f;
+                    }
+                }
+#ifdef WINDOWS32
+              printf (_("# %s (key %s, mtime %I64u): "),
+                      dir->name, dir->contents->path_key,
+                      (unsigned long long)dir->contents->mtime);
 #else  /* WINDOWS32 */
-#ifdef VMS
-              printf (_("# %s (device %d, inode [%d,%d,%d]): "),
-                      dir->name, dir->contents->dev,
-                      dir->contents->ino[0], dir->contents->ino[1],
-                      dir->contents->ino[2]);
-#else
-              printf (_("# %s (device %ld, inode %ld): "),
-                      dir->name,
-                      (long)dir->contents->dev, (long)dir->contents->ino);
+#ifdef VMS_INO_T
+              printf (_("# %s (device %d, inode [%d,%d,%d]): "),
+                      dir->name, dir->contents->dev,
+                      dir->contents->ino[0], dir->contents->ino[1],
+                      dir->contents->ino[2]);
+#else
+              printf (_("# %s (device %ld, inode %ld): "),
+                      dir->name,
+                      (long)dir->contents->dev, (long)dir->contents->ino);
 #endif
 #endif /* WINDOWS32 */
-              if (f == 0)
-                fputs (_("No"), stdout);
-              else
-                printf ("%u", f);
-              fputs (_(" files, "), stdout);
-              if (im == 0)
-                fputs (_("no"), stdout);
-              else
-                printf ("%u", im);
-              fputs (_(" impossibilities"), stdout);
-              if (dir->contents->dirstream == 0)
-                puts (".");
-              else
-                puts (_(" so far."));
-              files += f;
-              impossible += im;
-            }
-        }
+              if (f == 0)
+                fputs (_("No"), stdout);
+              else
+                printf ("%u", f);
+              fputs (_(" files, "), stdout);
+              if (im == 0)
+                fputs (_("no"), stdout);
+              else
+                printf ("%u", im);
+              fputs (_(" impossibilities"), stdout);
+              if (dir->contents->dirstream == 0)
+                puts (".");
+              else
+                puts (_(" so far."));
+              files += f;
+              impossible += im;
+            }
+        }
     }
 
@@ -1105 +1180 @@
 /* Hooks for globbing.  */
 
-#include <glob.h>
-
 /* Structure describing state of iterating through a directory hash table.  */
 
@@ -1156 +1229 @@
       struct dirfile *df = *ds->dirfile_slot++;
       if (! HASH_VACANT (df) && !df->impossible)
-        {
-          /* The glob interface wants a `struct dirent', so mock one up.  */
-          struct dirent *d;
-          unsigned int len = df->length + 1;
+        {
+          /* The glob interface wants a 'struct dirent', so mock one up.  */
+          struct dirent *d;
+          unsigned int len = df->length + 1;
           unsigned int sz = sizeof (*d) - sizeof (d->d_name) + len;
-          if (sz > bufsz)
-            {
-              bufsz *= 2;
-              if (sz > bufsz)
-                bufsz = sz;
-              buf = xrealloc (buf, bufsz);
-            }
-          d = (struct dirent *) buf;
+          if (sz > bufsz)
+            {
+              bufsz *= 2;
+              if (sz > bufsz)
+                bufsz = sz;
+              buf = xrealloc (buf, bufsz);
+            }
+          d = (struct dirent *) buf;
 #ifdef __MINGW32__
 # if __MINGW32_MAJOR_VERSION < 3 || (__MINGW32_MAJOR_VERSION == 3 && \
-                                     __MINGW32_MINOR_VERSION == 0)
-          d->d_name = xmalloc(len);
+                                     __MINGW32_MINOR_VERSION == 0)
+          d->d_name = xmalloc (len);
 # endif
 #endif
-          FAKE_DIR_ENTRY (d);
+          FAKE_DIR_ENTRY (d);
 #ifdef _DIRENT_HAVE_D_NAMLEN
-          d->d_namlen = len - 1;
+          d->d_namlen = len - 1;
 #endif
 #ifdef _DIRENT_HAVE_D_TYPE
-          d->d_type = DT_UNKNOWN;
-#endif
-          memcpy (d->d_name, df->name, len);
-          return d;
-        }
+          d->d_type = DT_UNKNOWN;
+#endif
+          memcpy (d->d_name, df->name, len);
+          return d;
+        }
     }
 
   return 0;
-}
-
-static void
-ansi_free (void *p)
-{
-  if (p)
-    free(p);
 }
 
@@ -1200 +1266 @@
  * macro for stat64().  If stat is a macro, make a local wrapper function to
  * invoke it.
+ *
+ * On MS-Windows, stat() "succeeds" for foo/bar/. where foo/bar is a
+ * regular file; fix that here.
  */
-#ifndef stat
+#if !defined(stat) && !defined(WINDOWS32) || defined(VMS)
 # ifndef VMS
+#  ifndef HAVE_SYS_STAT_H
 int stat (const char *path, struct stat *sbuf);
+#  endif
+# else
+    /* We are done with the fake stat.  Go back to the real stat */
+#   ifdef stat
+#     undef stat
+#   endif
 # endif
 # define local_stat stat
@@ -1211 +1287 @@
 {
   int e;
+#ifdef WINDOWS32
+  size_t plen = strlen (path);
+
+  /* Make sure the parent of "." exists and is a directory, not a
+     file.  This is because 'stat' on Windows normalizes the argument
+     foo/. => foo without checking first that foo is a directory.  */
+  if (plen > 1 && path[plen - 1] == '.'
+      && (path[plen - 2] == '/' || path[plen - 2] == '\\'))
+    {
+      char parent[MAXPATHLEN];
+
+      strncpy (parent, path, plen - 2);
+      parent[plen - 2] = '\0';
+      if (stat (parent, buf) < 0 || !_S_ISDIR (buf->st_mode))
+        return -1;
+    }
+#endif
 
   EINTRLOOP (e, stat (path, buf));
@@ -1222 +1315 @@
   gl->gl_opendir = open_dirstream;
   gl->gl_readdir = read_dirstream;
-  gl->gl_closedir = ansi_free;
+  gl->gl_closedir = free;
   gl->gl_stat = local_stat;
   /* We don't bother setting gl_lstat, since glob never calls it.
@@ -1232 +1325 @@
 {
   hash_init (&directories, DIRECTORY_BUCKETS,
-             directory_hash_1, directory_hash_2, directory_hash_cmp);
+             directory_hash_1, directory_hash_2, directory_hash_cmp);
   hash_init (&directory_contents, DIRECTORY_BUCKETS,
-             directory_contents_hash_1, directory_contents_hash_2,
+             directory_contents_hash_1, directory_contents_hash_2,
              directory_contents_hash_cmp);
 }