xemacs-beta: src/dired.c comparison

comparison src/dired.c @ 398:74fd4e045ea6 r21-2-29

Import from CVS: tag r21-2-29

author	cvs
date	Mon, 13 Aug 2007 11:13:30 +0200
parents	6719134a07c2
children	2f8bb876ab1d

comparison

equal deleted inserted replaced

-:f4aeb21a5bad
+:74fd4e045ea6
 #include "regex.h"
 #include "opaque.h"
 #include "sysfile.h"
 #include "sysdir.h"
 #include "systime.h"
+#include "sysdep.h"
 #include "syspwd.h"
 Lisp_Object Vcompletion_ignored_extensions;
 Lisp_Object Qdirectory_files;
 Lisp_Object Qfile_name_completion;
 	  && (NILP (match)
 	      || (0 <= re_search (bufp, dp->d_name, len, 0, len, 0))))
 	{
 	  if (!NILP (files_only))
 	    {
-	      int dir_p;
 	      struct stat st;
-	      char *cur_statbuf = statbuf;
+	      int dir_p = 0;
-	      char *cur_statbuf_tail = statbuf_tail;
+	      memcpy (statbuf_tail, dp->d_name, len);
-	      /* #### I don't think the code under `if' is necessary
+	      statbuf_tail[len] = 0;
-		 anymore.  The crashes in this function were reported
-		 because MAXNAMLEN was used to remember the *whole*
+	      if (stat (statbuf, &st) == 0
-		 statbuf, instead of using MAXPATHLEN.  This should be
+		  && (st.st_mode & S_IFMT) == S_IFDIR)
-		 tested after 21.0 is released.  */
+		dir_p = 1;
-	      /* We normally use the buffer created by alloca.
-		 However, if the file name we get too big, we'll use a
-		 malloced buffer, and free it.  It is undefined how
-		 stat() will react to this, but we avoid a buffer
-		 overrun.  */
-	      if (len > MAXNAMLEN)
-		{
-		  cur_statbuf = (char *)xmalloc (directorylen + len + 1);
-		  memcpy (cur_statbuf, statbuf, directorylen);
-		  cur_statbuf_tail = cur_statbuf + directorylen;
-		}
-	      memcpy (cur_statbuf_tail, dp->d_name, len);
-	      cur_statbuf_tail[len] = 0;
-	      if (stat (cur_statbuf, &st) < 0)
-		dir_p = 0;
-	      else
-		dir_p = ((st.st_mode & S_IFMT) == S_IFDIR);
-	      if (cur_statbuf != statbuf)
-		xfree (cur_statbuf);
 	      if (EQ (files_only, Qt) && dir_p)
 		continue;
 	      else if (!EQ (files_only, Qt) && !dir_p)
 		continue;
 if and only if the completion returned in the car was unique.
 */
 (user))
 {
 int uniq;
-Lisp_Object completed;
+Lisp_Object completed = user_name_completion (user, 0, &uniq);
-completed = user_name_completion (user, 0, &uniq);
 return Fcons (completed, uniq ? Qt : Qnil);
 }
 DEFUN ("user-name-all-completions", Fuser_name_all_completions, 1, 1, 0, /*
 Return a list of all completions of user name USER.
 (user))
 {
 return user_name_completion (user, 1, NULL);
 }
+struct user_name
+{
+Bufbyte *ptr;
+size_t len;
+};
+struct user_cache
+{
+struct user_name *user_names;
+int length;
+int size;
+EMACS_TIME last_rebuild_time;
+};
+static struct user_cache user_cache;
+static void
+free_user_cache (struct user_cache *cache)
+{
+int i;
+for (i = 0; i < cache->length; i++)
+xfree (cache->user_names[i].ptr);
+xfree (cache->user_names);
+xzero (*cache);
+}
 static Lisp_Object
-user_name_completion_unwind (Lisp_Object locative)
+user_name_completion_unwind (Lisp_Object cache_incomplete_p)
 {
-Lisp_Object obj1 = XCAR (locative);
-Lisp_Object obj2 = XCDR (locative);
-char **cache;
-int clen, i;
-if (!NILP (obj1) && !NILP (obj2))
-{
-/* clean up if interrupted building cache */
-cache = *(char ***)get_opaque_ptr (obj1);
-clen  = *(int *)get_opaque_ptr (obj2);
-free_opaque_ptr (obj1);
-free_opaque_ptr (obj2);
-for (i = 0; i < clen; i++)
-free (cache[i]);
-free (cache);
-}
-free_cons (XCONS (locative));
 endpwent ();
+speed_up_interrupts ();
+if (! NILP (XCAR (cache_incomplete_p)))
+free_user_cache (&user_cache);
+free_cons (XCONS (cache_incomplete_p));
 return Qnil;
 }
-static char **user_cache;
+#define  USER_CACHE_TTL  (24*60*60)  /* Time to live: 1 day, in seconds */
-static int user_cache_len;
-static int user_cache_max;
-static long user_cache_time;
-#define  USER_CACHE_REBUILD  (24*60*60)  /* 1 day, in seconds */
 static Lisp_Object
 user_name_completion (Lisp_Object user, int all_flag, int *uniq)
 {
 /* This function can GC */
-struct passwd *pw;
 int matchcount = 0;
 Lisp_Object bestmatch = Qnil;
 Charcount bestmatchsize = 0;
-int speccount = specpdl_depth ();
-int i, cmax, clen;
-char **cache;
 Charcount user_name_length;
-Lisp_Object locative;
 EMACS_TIME t;
+int i;
 struct gcpro gcpro1, gcpro2;
 GCPRO2 (user, bestmatch);
 CHECK_STRING (user);
 user_name_length = XSTRING_CHAR_LENGTH (user);
 /* Cache user name lookups because it tends to be quite slow.
 * Rebuild the cache occasionally to catch changes */
 EMACS_GET_TIME (t);
-if (user_cache  &&
+if (user_cache.user_names &&
-EMACS_SECS (t) - user_cache_time > USER_CACHE_REBUILD)
+(EMACS_SECS (t) - EMACS_SECS (user_cache.last_rebuild_time)
-{
+> USER_CACHE_TTL))
-for (i = 0; i < user_cache_len; i++)
+free_user_cache (&user_cache);
-free (user_cache[i]);
-free (user_cache);
+if (!user_cache.user_names)
-user_cache = NULL;
+{
-user_cache_len = 0;
+struct passwd *pwd;
-user_cache_max = 0;
+Lisp_Object cache_incomplete_p = noseeum_cons (Qt, Qnil);
-}
+int speccount = specpdl_depth ();
-if (user_cache == NULL || user_cache_max <= 0)
+slow_down_interrupts ();
-{
-cmax  = 200;
-clen  = 0;
-cache = (char **) malloc (cmax*sizeof (char *));
 setpwent ();
-locative = noseeum_cons (Qnil, Qnil);
+record_unwind_protect (user_name_completion_unwind, cache_incomplete_p);
-XCAR (locative) = make_opaque_ptr ((void *) &cache);
+while ((pwd = getpwent ()))
-XCDR (locative) = make_opaque_ptr ((void *) &clen);
-record_unwind_protect (user_name_completion_unwind, locative);
-/* #### may need to slow down interrupts around call to getpwent
-* below.  at least the call to getpwnam in Fuser_full_name
-* is documented as needing it on irix. */
-while ((pw = getpwent ()))
 {
-if (clen >= cmax)
-{
-cmax *= 2;
-cache = (char **) realloc (cache, cmax*sizeof (char *));
-}
 QUIT;
+	  DO_REALLOC (user_cache.user_names, user_cache.size,
-cache[clen++] = strdup (pw->pw_name);
+		      user_cache.length + 1, struct user_name);
+	  TO_INTERNAL_FORMAT (C_STRING, pwd->pw_name,
+			      MALLOC,
+			      (user_cache.user_names[user_cache.length].ptr,
+			       user_cache.user_names[user_cache.length].len),
+			      Qnative);
+	  user_cache.length++;
 }
-free_opaque_ptr (XCAR (locative));
+XCAR (cache_incomplete_p) = Qnil;
-free_opaque_ptr (XCDR (locative));
+unbind_to (speccount, Qnil);
-XCAR (locative) = Qnil;
-XCDR (locative) = Qnil;
+EMACS_GET_TIME (user_cache.last_rebuild_time);
+}
-unbind_to (speccount, Qnil); /* free locative cons, endpwent() */
+for (i = 0; i < user_cache.length; i++)
-user_cache_max = cmax;
+{
-user_cache_len = clen;
+Bufbyte *u_name = user_cache.user_names[i].ptr;
-user_cache = cache;
+Bytecount len   = user_cache.user_names[i].len;
-user_cache_time = EMACS_SECS (t);
-}
-for (i = 0; i < user_cache_len; i++)
-{
-Bufbyte *d_name = (Bufbyte *) user_cache[i];
-Bytecount len = strlen ((char *) d_name);
 /* scmp() works in chars, not bytes, so we have to compute this: */
-Charcount cclen = bytecount_to_charcount (d_name, len);
+Charcount cclen = bytecount_to_charcount (u_name, len);
 QUIT;
-if (cclen < user_name_length   ||
+if (cclen < user_name_length
-0 <= scmp (d_name, XSTRING_DATA (user), user_name_length))
+	  || 0 <= scmp_1 (u_name, XSTRING_DATA (user), user_name_length, 0))
 continue;
 matchcount++;    /* count matching completions */
 if (all_flag || NILP (bestmatch))
 {
 Lisp_Object name = Qnil;
 struct gcpro ngcpro1;
 NGCPRO1 (name);
 /* This is a possible completion */
-name = make_string (d_name, len);
+name = make_string (u_name, len);
 if (all_flag)
 {
 bestmatch = Fcons (name, bestmatch);
 }
 else
 }
 else
 {
 Charcount compare = min (bestmatchsize, cclen);
 Bufbyte *p1 = XSTRING_DATA (bestmatch);
-Bufbyte *p2 = d_name;
+Bufbyte *p2 = u_name;
-Charcount matchsize = scmp (p1, p2, compare);
+Charcount matchsize = scmp_1 (p1, p2, compare, 0);
 if (matchsize < 0)
 matchsize = compare;
-if (completion_ignore_case)
-{
-/* If this is an exact match except for case,
-use it as the best match rather than one that is not
-an exact match.  This way, we get the case pattern
-of the actual match.  */
-if ((matchsize == cclen
-&& matchsize < XSTRING_CHAR_LENGTH (bestmatch))
-||
-/* If there is no exact match ignoring case,
-prefer a match that does not change the case
-of the input.  */
-(((matchsize == cclen)
-==
-(matchsize == XSTRING_CHAR_LENGTH (bestmatch)))
-/* If there is more than one exact match aside from
-case, and one of them is exact including case,
-prefer that one.  */
-&& 0 > scmp_1 (p2, XSTRING_DATA (user),
-user_name_length, 0)
-&& 0 <= scmp_1 (p1, XSTRING_DATA (user),
-user_name_length, 0)))
-{
-bestmatch = make_string (d_name, len);
-}
-}
 bestmatchsize = matchsize;
 }
 }
 }
 #endif   /* ! defined WINDOWSNT */
 Lisp_Object
-make_directory_hash_table (CONST char *path)
+make_directory_hash_table (const char *path)
 {
 DIR *d;
-Lisp_Object hash =
-make_lisp_hash_table (100, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
 if ((d = opendir (path)))
 {
 DIRENTRY *dp;
+Lisp_Object hash =
+	make_lisp_hash_table (20, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
 while ((dp = readdir (d)))
 	{
 	  Bytecount len = NAMLEN (dp);
 	  if (DIRENTRY_NONEMPTY (dp))
 	    /* Cast to Bufbyte* is OK, as readdir() Mule-encapsulates.  */
 	    Fputhash (make_string ((Bufbyte *) dp->d_name, len), Qt, hash);
 	}
 closedir (d);
-}
+return hash;
-return hash;
+}
+else
+return Qnil;
 }
 Lisp_Object
 wasteful_word_to_lisp (unsigned int item)
 {
 but does affect the commands that actually do completions.
 It is used by the functions `file-name-completion' and
 `file-name-all-completions'.
 */ );
 Vcompletion_ignored_extensions = Qnil;
+}
-#ifndef  WINDOWSNT
-user_cache = NULL;
-user_cache_len = 0;
-user_cache_max = 0;
-#endif
-}

Mercurial > hg > xemacs-beta

comparison src/dired.c @ 398:74fd4e045ea6 r21-2-29