directory-files cleanup and speed tweaking

* src/dired.c (directory_files_internal):
Check ‘match’ before doing anything heavyweight.
Move decls closer to use.
Remove obsolete comments about GC.
No need to encode ‘directory’ or to call multibyte_chars_in_text.
Remove no-longer-needed bug check.
Skip finalname construction if file_attributes fails.

1 files changed, 49 insertions, 80 deletions

diff --git a/src/dired.c b/src/dired.c
index cec79ab46be..5fc6ccd3ead 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -167,28 +167,19 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
                           Lisp_Object match, Lisp_Object nosort, bool attrs,
                           Lisp_Object id_format)
 {
-  ptrdiff_t directory_nbytes;
-  Lisp_Object list, dirfilename, encoded_directory;
-  bool needsep = 0;
-  ptrdiff_t count = SPECPDL_INDEX ();
-#ifdef WINDOWSNT
-  Lisp_Object w32_save = Qnil;
-#endif
+  if (!NILP (match))
+    CHECK_STRING (match);
 
   /* Don't let the compiler optimize away all copies of DIRECTORY,
      which would break GC; see Bug#16986.  */
   Lisp_Object volatile directory_volatile = directory;
 
-  /* Because of file name handlers, these functions might call
-     Ffuncall, and cause a GC.  */
-  list = encoded_directory = dirfilename = Qnil;
-  dirfilename = Fdirectory_file_name (directory);
+  Lisp_Object dirfilename = Fdirectory_file_name (directory);
 
   /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
      run_pre_post_conversion_on_str which calls Lisp directly and
      indirectly.  */
   Lisp_Object encoded_dirfilename = ENCODE_FILE (dirfilename);
-  encoded_directory = ENCODE_FILE (directory);
 
   int fd;
   DIR *d = open_directory (dirfilename, encoded_dirfilename, &fd);
@@ -196,9 +187,11 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
   /* Unfortunately, we can now invoke expand-file-name and
      file-attributes on filenames, both of which can throw, so we must
      do a proper unwind-protect.  */
+  ptrdiff_t count = SPECPDL_INDEX ();
   record_unwind_protect_ptr (directory_files_internal_unwind, d);
 
 #ifdef WINDOWSNT
+  Lisp_Object w32_save = Qnil;
   if (attrs)
     {
       /* Do this only once to avoid doing it (in w32.c:stat) for each
@@ -218,89 +211,63 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
     }
 #endif
 
-  directory_nbytes = SBYTES (directory);
+  ptrdiff_t directory_nbytes = SBYTES (directory);
   re_match_object = Qt;
 
   /* Decide whether we need to add a directory separator.  */
-  if (directory_nbytes == 0
-      || !IS_ANY_SEP (SREF (directory, directory_nbytes - 1)))
-    needsep = 1;
+  bool needsep = (directory_nbytes == 0
+                  || !IS_ANY_SEP (SREF (directory, directory_nbytes - 1)));
 
   /* Windows users want case-insensitive wildcards.  */
-  Lisp_Object case_table =
+  Lisp_Object case_table = Qnil;
 #ifdef WINDOWSNT
-    BVAR (&buffer_defaults, case_canon_table)
-#else
-    Qnil
+  case_table = BVAR (&buffer_defaults, case_canon_table);
 #endif
-    ;
 
-  if (!NILP (match))
-    CHECK_STRING (match);
-
-  /* Loop reading directory entries.  */
+  /* Read directory entries and accumulate them into LIST.  */
+  Lisp_Object list = Qnil;
   for (struct dirent *dp; (dp = read_dirent (d, directory)); )
     {
       ptrdiff_t len = dirent_namelen (dp);
       Lisp_Object name = make_unibyte_string (dp->d_name, len);
       Lisp_Object finalname = name;
 
-      /* Note: DECODE_FILE can GC; it should protect its argument,
-         though.  */
+      /* This can GC.  */
       name = DECODE_FILE (name);
-      len = SBYTES (name);
 
-      /* Now that we have unwind_protect in place, we might as well
-         allow matching to be interrupted.  */
       maybe_quit ();
 
-      bool wanted = (NILP (match) ||
-                     fast_string_match_internal (
-                       match, name, case_table) >= 0);
+      if (!NILP (match)
+          && fast_string_match_internal (match, name, case_table) < 0)
+        continue;
 
-      if (wanted)
+      Lisp_Object fileattrs;
+      if (attrs)
         {
-          if (!NILP (full))
-            {
-              Lisp_Object fullname;
-              ptrdiff_t nbytes = len + directory_nbytes + needsep;
-              ptrdiff_t nchars;
-
-              fullname = make_uninit_multibyte_string (nbytes, nbytes);
-              memcpy (SDATA (fullname), SDATA (directory),
-                      directory_nbytes);
-
-              if (needsep)
-                SSET (fullname, directory_nbytes, DIRECTORY_SEP);
-
-              memcpy (SDATA (fullname) + directory_nbytes + needsep,
-                      SDATA (name), len);
-
-              nchars = multibyte_chars_in_text (SDATA (fullname), nbytes);
-
-              /* Some bug somewhere.  */
-              if (nchars > nbytes)
-                emacs_abort ();
-
-              STRING_SET_CHARS (fullname, nchars);
-              if (nchars == nbytes)
-                STRING_SET_UNIBYTE (fullname);
-
-              finalname = fullname;
-            }
-          else
-            finalname = name;
+          fileattrs = file_attributes (fd, dp->d_name, directory, name,
+                                       id_format);
+          if (NILP (fileattrs))
+            continue;
+        }
 
-          if (attrs)
-            {
-              Lisp_Object fileattrs
-                = file_attributes (fd, dp->d_name, directory, name, id_format);
-              if (!NILP (fileattrs))
-                list = Fcons (Fcons (finalname, fileattrs), list);
-            }
-          else
-            list = Fcons (finalname, list);
+      if (!NILP (full))
+        {
+          ptrdiff_t name_nbytes = SBYTES (name);
+          ptrdiff_t nbytes = directory_nbytes + needsep + name_nbytes;
+          ptrdiff_t nchars = SCHARS (directory) + needsep + SCHARS (name);
+          finalname = make_uninit_multibyte_string (nchars, nbytes);
+          if (nchars == nbytes)
+            STRING_SET_UNIBYTE (finalname);
+          memcpy (SDATA (finalname), SDATA (directory), directory_nbytes);
+          if (needsep)
+            SSET (finalname, directory_nbytes, DIRECTORY_SEP);
+          memcpy (SDATA (finalname) + directory_nbytes + needsep,
+                  SDATA (name), name_nbytes);
         }
+      else
+        finalname = name;
+
+      list = Fcons (attrs ? Fcons (finalname, fileattrs) : finalname, list);
     }
 
   closedir (d);
@@ -330,14 +297,14 @@ If MATCH is non-nil, mention only file names that match the regexp MATCH.
 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
  Otherwise, the list returned is sorted with `string-lessp'.
  NOSORT is useful if you plan to sort the result yourself.  */)
-  (Lisp_Object directory, Lisp_Object full, Lisp_Object match, Lisp_Object nosort)
+  (Lisp_Object directory, Lisp_Object full, Lisp_Object match,
+   Lisp_Object nosort)
 {
-  Lisp_Object handler;
   directory = Fexpand_file_name (directory, Qnil);
 
   /* If the file name has special constructs in it,
      call the corresponding file name handler.  */
-  handler = Ffind_file_name_handler (directory, Qdirectory_files);
+  Lisp_Object handler = Ffind_file_name_handler (directory, Qdirectory_files);
   if (!NILP (handler))
     return call5 (handler, Qdirectory_files, directory,
                   full, match, nosort);
@@ -365,14 +332,15 @@ ID-FORMAT specifies the preferred format of attributes uid and gid, see
 `file-attributes' for further documentation.
 On MS-Windows, performance depends on `w32-get-true-file-attributes',
 which see.  */)
-  (Lisp_Object directory, Lisp_Object full, Lisp_Object match, Lisp_Object nosort, Lisp_Object id_format)
+  (Lisp_Object directory, Lisp_Object full, Lisp_Object match,
+   Lisp_Object nosort, Lisp_Object id_format)
 {
-  Lisp_Object handler;
   directory = Fexpand_file_name (directory, Qnil);
 
   /* If the file name has special constructs in it,
      call the corresponding file name handler.  */
-  handler = Ffind_file_name_handler (directory, Qdirectory_files_and_attributes);
+  Lisp_Object handler
+    = Ffind_file_name_handler (directory, Qdirectory_files_and_attributes);
   if (!NILP (handler))
     return call6 (handler, Qdirectory_files_and_attributes,
                   directory, full, match, nosort, id_format);
@@ -1032,7 +1000,8 @@ file_attributes (int fd, char const *name,
                 INT_TO_INTEGER (s.st_dev));
 }
 
-DEFUN ("file-attributes-lessp", Ffile_attributes_lessp, Sfile_attributes_lessp, 2, 2, 0,
+DEFUN ("file-attributes-lessp", Ffile_attributes_lessp,
+       Sfile_attributes_lessp, 2, 2, 0,
        doc: /* Return t if first arg file attributes list is less than second.
 Comparison is in lexicographic order and case is significant.  */)
   (Lisp_Object f1, Lisp_Object f2)