dired.c 35.3 KB
Newer Older
Richard M. Stallman's avatar
Richard M. Stallman committed
1
/* Lisp functions for making directory listings.
2
   Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001, 2002, 2003,
Glenn Morris's avatar
Glenn Morris committed
3
                 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Richard M. Stallman's avatar
Richard M. Stallman committed
4 5 6

This file is part of GNU Emacs.

7
GNU Emacs is free software: you can redistribute it and/or modify
Richard M. Stallman's avatar
Richard M. Stallman committed
8
it under the terms of the GNU General Public License as published by
9 10
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Richard M. Stallman's avatar
Richard M. Stallman committed
11 12 13 14 15 16 17

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
18
along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
19 20


21 22
#include <config.h>

Richard M. Stallman's avatar
Richard M. Stallman committed
23 24 25 26
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>

27
#ifdef HAVE_PWD_H
Kenichi Handa's avatar
Kenichi Handa committed
28
#include <pwd.h>
29
#endif
Kenichi Handa's avatar
Kenichi Handa committed
30 31
#include <grp.h>

32
#include <errno.h>
33

Andreas Schwab's avatar
Andreas Schwab committed
34 35 36 37
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

38 39 40 41 42 43 44 45 46 47 48 49
/* The d_nameln member of a struct dirent includes the '\0' character
   on some systems, but not on others.  What's worse, you can't tell
   at compile-time which one it will be, since it really depends on
   the sort of system providing the filesystem you're reading from,
   not the system you are running on.  Paul Eggert
   <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
   SunOS 4.1.2 host, reading a directory that is remote-mounted from a
   Solaris 2.1 host and is in a native Solaris 2.1 filesystem.

   Since applying strlen to the name always works, we'll just do that.  */
#define NAMLEN(p) strlen (p->d_name)

Richard M. Stallman's avatar
Richard M. Stallman committed
50 51 52 53 54
#ifdef SYSV_SYSTEM_DIR

#include <dirent.h>
#define DIRENTRY struct dirent

55
#else /* not SYSV_SYSTEM_DIR */
Richard M. Stallman's avatar
Richard M. Stallman committed
56

57 58 59
#ifdef MSDOS
#include <dirent.h>
#else
Richard M. Stallman's avatar
Richard M. Stallman committed
60
#include <sys/dir.h>
61
#endif
Richard M. Stallman's avatar
Richard M. Stallman committed
62

63 64
#include <sys/stat.h>

65
#ifndef MSDOS
Richard M. Stallman's avatar
Richard M. Stallman committed
66 67 68 69 70
#define DIRENTRY struct direct

extern DIR *opendir ();
extern struct direct *readdir ();

71 72 73
#endif /* not MSDOS */
#endif /* not SYSV_SYSTEM_DIR */

74 75
/* Some versions of Cygwin don't have d_ino in `struct dirent'.  */
#if defined(MSDOS) || defined(__CYGWIN__)
76 77 78
#define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
#else
#define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
Richard M. Stallman's avatar
Richard M. Stallman committed
79 80 81
#endif

#include "lisp.h"
82
#include "systime.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
83 84
#include "buffer.h"
#include "commands.h"
Kenichi Handa's avatar
Kenichi Handa committed
85
#include "character.h"
86 87
#include "charset.h"
#include "coding.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
88
#include "regex.h"
YAMAMOTO Mitsuharu's avatar
YAMAMOTO Mitsuharu committed
89
#include "blockinput.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
90

91 92
/* Returns a search buffer, with a fastmap allocated and ready to go.  */
extern struct re_pattern_buffer *compile_pattern ();
93

94 95 96
/* From filemode.c.  Can't go in Lisp.h because of `stat'.  */
extern void filemodestring P_ ((struct stat *, char *));

Richard M. Stallman's avatar
Richard M. Stallman committed
97 98 99 100 101 102 103
/* if system does not have symbolic links, it does not have lstat.
   In that case, use ordinary stat instead.  */

#ifndef S_IFLNK
#define lstat stat
#endif

104
extern int completion_ignore_case;
105
extern Lisp_Object Qcompletion_ignore_case;
106
extern Lisp_Object Vcompletion_regexp_list;
107
extern Lisp_Object Vw32_get_true_file_attributes;
108

Richard M. Stallman's avatar
Richard M. Stallman committed
109
Lisp_Object Vcompletion_ignored_extensions;
110
Lisp_Object Qdirectory_files;
111
Lisp_Object Qdirectory_files_and_attributes;
112 113
Lisp_Object Qfile_name_completion;
Lisp_Object Qfile_name_all_completions;
Jim Blandy's avatar
Jim Blandy committed
114
Lisp_Object Qfile_attributes;
115
Lisp_Object Qfile_attributes_lessp;
116 117

static int scmp P_ ((unsigned char *, unsigned char *, int));
Richard M. Stallman's avatar
Richard M. Stallman committed
118

119 120 121 122 123 124 125 126
#ifdef WINDOWSNT
Lisp_Object
directory_files_internal_w32_unwind (Lisp_Object arg)
{
  Vw32_get_true_file_attributes = arg;
  return Qnil;
}
#endif
127 128 129 130 131

Lisp_Object
directory_files_internal_unwind (dh)
     Lisp_Object dh;
{
132
  DIR *d = (DIR *) XSAVE_VALUE (dh)->pointer;
133
  BLOCK_INPUT;
134
  closedir (d);
135
  UNBLOCK_INPUT;
136 137 138
  return Qnil;
}

139
/* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
140
   When ATTRS is zero, return a list of directory filenames; when
Kenichi Handa's avatar
Kenichi Handa committed
141 142
   non-zero, return a list of directory filenames and their attributes.
   In the latter case, ID_FORMAT is passed to Ffile_attributes.  */
143

144
Lisp_Object
Kenichi Handa's avatar
Kenichi Handa committed
145
directory_files_internal (directory, full, match, nosort, attrs, id_format)
146
     Lisp_Object directory, full, match, nosort;
147
     int attrs;
Kenichi Handa's avatar
Kenichi Handa committed
148
     Lisp_Object id_format;
Richard M. Stallman's avatar
Richard M. Stallman committed
149 150
{
  DIR *d;
151 152
  int directory_nbytes;
  Lisp_Object list, dirfilename, encoded_directory;
153
  struct re_pattern_buffer *bufp = NULL;
154
  int needsep = 0;
Juanma Barranquero's avatar
Juanma Barranquero committed
155
  int count = SPECPDL_INDEX ();
156
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
157
  DIRENTRY *dp;
158 159 160
#ifdef WINDOWSNT
  Lisp_Object w32_save = Qnil;
#endif
161

162
  /* Because of file name handlers, these functions might call
163
     Ffuncall, and cause a GC.  */
164 165
  list = encoded_directory = dirfilename = Qnil;
  GCPRO5 (match, directory, list, dirfilename, encoded_directory);
166
  dirfilename = Fdirectory_file_name (directory);
167

Jim Blandy's avatar
Jim Blandy committed
168
  if (!NILP (match))
Richard M. Stallman's avatar
Richard M. Stallman committed
169
    {
170
      CHECK_STRING (match);
Jim Blandy's avatar
Jim Blandy committed
171 172

      /* MATCH might be a flawed regular expression.  Rather than
Karl Heuer's avatar
Karl Heuer committed
173
	 catching and signaling our own errors, we just call
Jim Blandy's avatar
Jim Blandy committed
174
	 compile_pattern to do the work for us.  */
175 176
      /* Pass 1 for the MULTIBYTE arg
	 because we do make multibyte strings if the contents warrant.  */
177 178 179 180 181
# ifdef WINDOWSNT
      /* Windows users want case-insensitive wildcards.  */
      bufp = compile_pattern (match, 0,
			      buffer_defaults.case_canon_table, 0, 1);
# else	/* !WINDOWSNT */
182
      bufp = compile_pattern (match, 0, Qnil, 0, 1);
183
# endif	 /* !WINDOWSNT */
Richard M. Stallman's avatar
Richard M. Stallman committed
184 185
    }

186
  /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
187 188
     run_pre_post_conversion_on_str which calls Lisp directly and
     indirectly.  */
189 190 191 192
  if (STRING_MULTIBYTE (dirfilename))
    dirfilename = ENCODE_FILE (dirfilename);
  encoded_directory = (STRING_MULTIBYTE (directory)
		       ? ENCODE_FILE (directory) : directory);
193

194
  /* Now *bufp is the compiled form of MATCH; don't call anything
195 196
     which might compile a new regexp until we're done with the loop!  */

197
  BLOCK_INPUT;
198
  d = opendir (SDATA (dirfilename));
199
  UNBLOCK_INPUT;
200
  if (d == NULL)
201
    report_file_error ("Opening directory", Fcons (directory, Qnil));
Richard M. Stallman's avatar
Richard M. Stallman committed
202

203 204 205 206
  /* 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.  */
  record_unwind_protect (directory_files_internal_unwind,
207
			 make_save_value (d, 0));
208

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
#ifdef WINDOWSNT
  if (attrs)
    {
      extern Lisp_Object Qlocal;
      extern int is_slow_fs (const char *);

      /* Do this only once to avoid doing it (in w32.c:stat) for each
	 file in the directory, when we call Ffile_attributes below.  */
      record_unwind_protect (directory_files_internal_w32_unwind,
			     Vw32_get_true_file_attributes);
      w32_save = Vw32_get_true_file_attributes;
      if (EQ (Vw32_get_true_file_attributes, Qlocal))
	{
	  char *dirnm = SDATA (dirfilename);
	  char *fn = alloca (SBYTES (dirfilename) + 1);

	  strncpy (fn, SDATA (dirfilename), SBYTES (dirfilename));
	  fn[SBYTES (dirfilename)] = '\0';
	  /* w32.c:stat will notice these bindings and avoid calling
	     GetDriveType for each file.  */
	  if (is_slow_fs (fn))
	    Vw32_get_true_file_attributes = Qnil;
	  else
	    Vw32_get_true_file_attributes = Qt;
	}
    }
#endif

237
  directory_nbytes = SBYTES (directory);
238
  re_match_object = Qt;
Richard M. Stallman's avatar
Richard M. Stallman committed
239

240
  /* Decide whether we need to add a directory separator.  */
241
  if (directory_nbytes == 0
242
      || !IS_ANY_SEP (SREF (directory, directory_nbytes - 1)))
243 244
    needsep = 1;

245
  /* Loop reading blocks until EOF or error.  */
246
  for (;;)
Richard M. Stallman's avatar
Richard M. Stallman committed
247
    {
248 249 250
      errno = 0;
      dp = readdir (d);

251
      if (dp == NULL && (0
252
#ifdef EAGAIN
253 254 255 256
			 || errno == EAGAIN
#endif
#ifdef EINTR
			 || errno == EINTR
257
#endif
258 259
			 ))
	{ QUIT; continue; }
260

261 262 263
      if (dp == NULL)
	break;

264
      if (DIRENTRY_NONEMPTY (dp))
Richard M. Stallman's avatar
Richard M. Stallman committed
265
	{
266
	  int len;
267
	  int wanted = 0;
268 269
	  Lisp_Object name, finalname;
	  struct gcpro gcpro1, gcpro2;
270 271

	  len = NAMLEN (dp);
272
	  name = finalname = make_unibyte_string (dp->d_name, len);
273
	  GCPRO2 (finalname, name);
274

275
	  /* Note: DECODE_FILE can GC; it should protect its argument,
276 277
	     though.  */
	  name = DECODE_FILE (name);
278
	  len = SBYTES (name);
279

280 281 282 283 284
	  /* Now that we have unwind_protect in place, we might as well
             allow matching to be interrupted.  */
	  immediate_quit = 1;
	  QUIT;

Jim Blandy's avatar
Jim Blandy committed
285
	  if (NILP (match)
286
	      || (0 <= re_search (bufp, SDATA (name), len, 0, len, 0)))
287
	    wanted = 1;
288 289 290 291

	  immediate_quit = 0;

	  if (wanted)
Richard M. Stallman's avatar
Richard M. Stallman committed
292
	    {
Jim Blandy's avatar
Jim Blandy committed
293
	      if (!NILP (full))
Richard M. Stallman's avatar
Richard M. Stallman committed
294
		{
295
		  Lisp_Object fullname;
296 297
		  int nbytes = len + directory_nbytes + needsep;
		  int nchars;
298

299
		  fullname = make_uninit_multibyte_string (nbytes, nbytes);
300
		  bcopy (SDATA (directory), SDATA (fullname),
301
			 directory_nbytes);
302

303
		  if (needsep)
304
		    SSET (fullname, directory_nbytes, DIRECTORY_SEP);
305

306 307
		  bcopy (SDATA (name),
			 SDATA (fullname) + directory_nbytes + needsep,
308
			 len);
309

310
		  nchars = chars_in_text (SDATA (fullname), nbytes);
311 312 313 314

		  /* Some bug somewhere.  */
		  if (nchars > nbytes)
		    abort ();
315

316
		  STRING_SET_CHARS (fullname, nchars);
317
		  if (nchars == nbytes)
318
		    STRING_SET_UNIBYTE (fullname);
319

320 321
		  finalname = fullname;
		}
322 323
	      else
		finalname = name;
324 325 326 327 328

	      if (attrs)
		{
		  /* Construct an expanded filename for the directory entry.
		     Use the decoded names for input to Ffile_attributes.  */
329 330 331 332 333
		  Lisp_Object decoded_fullname, fileattrs;
		  struct gcpro gcpro1, gcpro2;

		  decoded_fullname = fileattrs = Qnil;
		  GCPRO2 (decoded_fullname, fileattrs);
334

335
		  /* Both Fexpand_file_name and Ffile_attributes can GC.  */
336
		  decoded_fullname = Fexpand_file_name (name, directory);
Kenichi Handa's avatar
Kenichi Handa committed
337
		  fileattrs = Ffile_attributes (decoded_fullname, id_format);
338 339

		  list = Fcons (Fcons (finalname, fileattrs), list);
340
		  UNGCPRO;
341 342
		}
	      else
343
		list = Fcons (finalname, list);
Richard M. Stallman's avatar
Richard M. Stallman committed
344
	    }
345 346

	  UNGCPRO;
Richard M. Stallman's avatar
Richard M. Stallman committed
347 348
	}
    }
349

350
  BLOCK_INPUT;
Richard M. Stallman's avatar
Richard M. Stallman committed
351
  closedir (d);
352
  UNBLOCK_INPUT;
353 354 355 356
#ifdef WINDOWSNT
  if (attrs)
    Vw32_get_true_file_attributes = w32_save;
#endif
357 358 359 360

  /* Discard the unwind protect.  */
  specpdl_ptr = specpdl + count;

361 362 363
  if (NILP (nosort))
    list = Fsort (Fnreverse (list),
		  attrs ? Qfile_attributes_lessp : Qstring_lessp);
364

365
  RETURN_UNGCPRO (list);
Richard M. Stallman's avatar
Richard M. Stallman committed
366
}
367 368 369


DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
370 371 372 373 374 375
       doc: /* Return a list of names of files in DIRECTORY.
There are three optional arguments:
If FULL is non-nil, return absolute file names.  Otherwise return names
 that are relative to the specified directory.
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.
Chong Yidong's avatar
Chong Yidong committed
376 377
  Otherwise, the list returned is sorted with `stringp-lessp'.
  NOSORT is useful if you plan to sort the result yourself.  */)
378
     (directory, full, match, nosort)
379 380 381
     Lisp_Object directory, full, match, nosort;
{
  Lisp_Object handler;
382
  directory = Fexpand_file_name (directory, Qnil);
383 384 385 386 387

  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
  handler = Ffind_file_name_handler (directory, Qdirectory_files);
  if (!NILP (handler))
Kenichi Handa's avatar
Kenichi Handa committed
388 389
    return call5 (handler, Qdirectory_files, directory,
                  full, match, nosort);
390

Kenichi Handa's avatar
Kenichi Handa committed
391
  return directory_files_internal (directory, full, match, nosort, 0, Qnil);
392 393
}

394
DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes,
Kenichi Handa's avatar
Kenichi Handa committed
395
       Sdirectory_files_and_attributes, 1, 5, 0,
396
       doc: /* Return a list of names of files and their attributes in DIRECTORY.
Kenichi Handa's avatar
Kenichi Handa committed
397
There are four optional arguments:
398 399 400 401
If FULL is non-nil, return absolute file names.  Otherwise return names
 that are relative to the specified directory.
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.
Kenichi Handa's avatar
Kenichi Handa committed
402 403
 NOSORT is useful if you plan to sort the result yourself.
ID-FORMAT specifies the preferred format of attributes uid and gid, see
404 405 406
`file-attributes' for further documentation.
On MS-Windows, performance depends on `w32-get-true-file-attributes',
which see.  */)
Kenichi Handa's avatar
Kenichi Handa committed
407 408
     (directory, full, match, nosort, id_format)
     Lisp_Object directory, full, match, nosort, id_format;
409 410
{
  Lisp_Object handler;
411
  directory = Fexpand_file_name (directory, Qnil);
412 413 414 415 416

  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
  handler = Ffind_file_name_handler (directory, Qdirectory_files_and_attributes);
  if (!NILP (handler))
Kenichi Handa's avatar
Kenichi Handa committed
417 418
    return call6 (handler, Qdirectory_files_and_attributes,
                  directory, full, match, nosort, id_format);
419

Kenichi Handa's avatar
Kenichi Handa committed
420
  return directory_files_internal (directory, full, match, nosort, 1, id_format);
421 422
}

Richard M. Stallman's avatar
Richard M. Stallman committed
423 424 425 426

Lisp_Object file_name_completion ();

DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
427
       2, 3, 0,
428 429 430 431
       doc: /* Complete file name FILE in directory DIRECTORY.
Returns the longest string
common to all file names in DIRECTORY that start with FILE.
If there is only one and FILE matches it exactly, returns t.
432
Returns nil if DIRECTORY contains no name starting with FILE.
433

Richard M. Stallman's avatar
Richard M. Stallman committed
434 435 436
If PREDICATE is non-nil, call PREDICATE with each possible
completion (in absolute form) and ignore it if PREDICATE returns nil.

437 438
This function ignores some of the possible completions as
determined by the variable `completion-ignored-extensions', which see.  */)
439 440
     (file, directory, predicate)
     Lisp_Object file, directory, predicate;
Richard M. Stallman's avatar
Richard M. Stallman committed
441
{
442 443
  Lisp_Object handler;

444
  /* If the directory name has special constructs in it,
445
     call the corresponding file handler.  */
446
  handler = Ffind_file_name_handler (directory, Qfile_name_completion);
447
  if (!NILP (handler))
448
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
449

450 451 452 453
  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
  handler = Ffind_file_name_handler (file, Qfile_name_completion);
  if (!NILP (handler))
454
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
455

456
  return file_name_completion (file, directory, 0, 0, predicate);
Richard M. Stallman's avatar
Richard M. Stallman committed
457 458 459
}

DEFUN ("file-name-all-completions", Ffile_name_all_completions,
460 461 462 463
       Sfile_name_all_completions, 2, 2, 0,
       doc: /* Return a list of all completions of file name FILE in directory DIRECTORY.
These are all file names in directory DIRECTORY which begin with FILE.  */)
     (file, directory)
464
     Lisp_Object file, directory;
Richard M. Stallman's avatar
Richard M. Stallman committed
465
{
466 467
  Lisp_Object handler;

468
  /* If the directory name has special constructs in it,
469
     call the corresponding file handler.  */
470
  handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
471
  if (!NILP (handler))
472
    return call3 (handler, Qfile_name_all_completions, file, directory);
473

474 475 476 477
  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
  handler = Ffind_file_name_handler (file, Qfile_name_all_completions);
  if (!NILP (handler))
478
    return call3 (handler, Qfile_name_all_completions, file, directory);
479

480
  return file_name_completion (file, directory, 1, 0, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
481 482
}

Andreas Schwab's avatar
Andreas Schwab committed
483
static int file_name_completion_stat ();
484
Lisp_Object Qdefault_directory;
Andreas Schwab's avatar
Andreas Schwab committed
485

Richard M. Stallman's avatar
Richard M. Stallman committed
486
Lisp_Object
487
file_name_completion (file, dirname, all_flag, ver_flag, predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
488 489
     Lisp_Object file, dirname;
     int all_flag, ver_flag;
490
     Lisp_Object predicate;
Richard M. Stallman's avatar
Richard M. Stallman committed
491 492
{
  DIR *d;
493
  int bestmatchsize = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
494
  int matchcount = 0;
495 496 497
  /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
     If ALL_FLAG is 0, BESTMATCH is either nil
     or the best match so far, not decoded.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
498
  Lisp_Object bestmatch, tem, elt, name;
499 500
  Lisp_Object encoded_file;
  Lisp_Object encoded_dir;
Richard M. Stallman's avatar
Richard M. Stallman committed
501 502
  struct stat st;
  int directoryp;
503 504 505 506
  /* If includeall is zero, exclude files in completion-ignored-extensions as
     well as "." and "..".  Until shown otherwise, assume we can't exclude
     anything.  */
  int includeall = 1;
Juanma Barranquero's avatar
Juanma Barranquero committed
507
  int count = SPECPDL_INDEX ();
508
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
509

510 511
  elt = Qnil;

512
  CHECK_STRING (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
513

514 515 516
#ifdef FILE_SYSTEM_CASE
  file = FILE_SYSTEM_CASE (file);
#endif
Richard M. Stallman's avatar
Richard M. Stallman committed
517
  bestmatch = Qnil;
518 519
  encoded_file = encoded_dir = Qnil;
  GCPRO5 (file, dirname, bestmatch, encoded_file, encoded_dir);
520
  dirname = Fexpand_file_name (dirname, Qnil);
521
  specbind (Qdefault_directory, dirname);
Richard M. Stallman's avatar
Richard M. Stallman committed
522

523 524 525
  /* Do completion on the encoded file name
     because the other names in the directory are (we presume)
     encoded likewise.  We decode the completed string at the end.  */
526 527 528
  /* Actually, this is not quite true any more: we do most of the completion
     work with decoded file names, but we still do some filtering based
     on the encoded file name.  */
529
  encoded_file = STRING_MULTIBYTE (file) ? ENCODE_FILE (file) : file;
530 531 532

  encoded_dir = ENCODE_FILE (dirname);

533 534 535 536 537
  BLOCK_INPUT;
  d = opendir (SDATA (Fdirectory_file_name (encoded_dir)));
  UNBLOCK_INPUT;
  if (!d)
    report_file_error ("Opening directory", Fcons (dirname, Qnil));
Richard M. Stallman's avatar
Richard M. Stallman committed
538

539 540
  record_unwind_protect (directory_files_internal_unwind,
			 make_save_value (d, 0));
Richard M. Stallman's avatar
Richard M. Stallman committed
541

542 543 544
  /* Loop reading blocks */
  /* (att3b compiler bug requires do a null comparison this way) */
  while (1)
Richard M. Stallman's avatar
Richard M. Stallman committed
545
    {
546 547 548
      DIRENTRY *dp;
      int len;
      int canexclude = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
549

550 551 552
      errno = 0;
      dp = readdir (d);
      if (dp == NULL && (0
553
# ifdef EAGAIN
554
			 || errno == EAGAIN
555 556
# endif
# ifdef EINTR
557
			 || errno == EINTR
558
# endif
559 560
			 ))
	{ QUIT; continue; }
561

562
      if (!dp) break;
Richard M. Stallman's avatar
Richard M. Stallman committed
563

564
      len = NAMLEN (dp);
Richard M. Stallman's avatar
Richard M. Stallman committed
565

566 567 568 569 570 571
      QUIT;
      if (! DIRENTRY_NONEMPTY (dp)
	  || len < SCHARS (encoded_file)
	  || 0 <= scmp (dp->d_name, SDATA (encoded_file),
			SCHARS (encoded_file)))
	continue;
Richard M. Stallman's avatar
Richard M. Stallman committed
572

573 574
      if (file_name_completion_stat (encoded_dir, dp, &st) < 0)
	continue;
Richard M. Stallman's avatar
Richard M. Stallman committed
575

576 577 578 579 580 581 582 583
      directoryp = ((st.st_mode & S_IFMT) == S_IFDIR);
      tem = Qnil;
      /* If all_flag is set, always include all.
	 It would not actually be helpful to the user to ignore any possible
	 completions when making a list of them.  */
      if (!all_flag)
	{
	  int skip;
584

585
#if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
586 587 588 589 590 591 592 593 594 595
	  /* If this entry matches the current bestmatch, the only
	     thing it can do is increase matchcount, so don't bother
	     investigating it any further.  */
	  if (!completion_ignore_case
	      /* The return result depends on whether it's the sole match.  */
	      && matchcount > 1
	      && !includeall /* This match may allow includeall to 0.  */
	      && len >= bestmatchsize
	      && 0 > scmp (dp->d_name, SDATA (bestmatch), bestmatchsize))
	    continue;
596
#endif
597

598
	  if (directoryp)
599 600 601 602
	    {
#ifndef TRIVIAL_DIRECTORY_ENTRY
#define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
#endif
603 604
	      /* "." and ".." are never interesting as completions, and are
		 actually in the way in a directory with only one file.  */
605 606 607
	      if (TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
		canexclude = 1;
	      else if (len > SCHARS (encoded_file))
608 609 610 611 612 613
		/* Ignore directories if they match an element of
		   completion-ignored-extensions which ends in a slash.  */
		for (tem = Vcompletion_ignored_extensions;
		     CONSP (tem); tem = XCDR (tem))
		  {
		    int elt_len;
614
		    unsigned char *p1;
615 616 617 618

		    elt = XCAR (tem);
		    if (!STRINGP (elt))
		      continue;
619 620 621
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
622
		    elt_len = SCHARS (elt) - 1; /* -1 for trailing / */
623
		    if (elt_len <= 0)
624
		      continue;
625
		    p1 = SDATA (elt);
626 627 628 629 630 631 632 633 634 635
		    if (p1[elt_len] != '/')
		      continue;
		    skip = len - elt_len;
		    if (skip < 0)
		      continue;

		    if (0 <= scmp (dp->d_name + skip, p1, elt_len))
		      continue;
		    break;
		  }
636 637
	    }
	  else
638
	    {
Richard M. Stallman's avatar
Richard M. Stallman committed
639 640
	      /* Compare extensions-to-be-ignored against end of this file name */
	      /* if name is not an exact match against specified string */
641
	      if (len > SCHARS (encoded_file))
Richard M. Stallman's avatar
Richard M. Stallman committed
642 643
		/* and exit this for loop if a match is found */
		for (tem = Vcompletion_ignored_extensions;
644
		     CONSP (tem); tem = XCDR (tem))
Richard M. Stallman's avatar
Richard M. Stallman committed
645
		  {
646
		    elt = XCAR (tem);
647
		    if (!STRINGP (elt)) continue;
648 649 650
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
651
		    skip = len - SCHARS (elt);
Richard M. Stallman's avatar
Richard M. Stallman committed
652 653 654
		    if (skip < 0) continue;

		    if (0 <= scmp (dp->d_name + skip,
655 656
				   SDATA (elt),
				   SCHARS (elt)))
Richard M. Stallman's avatar
Richard M. Stallman committed
657 658 659 660 661
		      continue;
		    break;
		  }
	    }

662 663
	  /* If an ignored-extensions match was found,
	     don't process this name as a completion.  */
664 665
	  if (CONSP (tem))
	    canexclude = 1;
666

667 668 669
	  if (!includeall && canexclude)
	    /* We're not including all files and this file can be excluded.  */
	    continue;
670

671 672 673 674 675 676 677 678
	  if (includeall && !canexclude)
	    { /* If we have one non-excludable file, we want to exclude the
		 excudable files.  */
	      includeall = 0;
	      /* Throw away any previous excludable match found.  */
	      bestmatch = Qnil;
	      bestmatchsize = 0;
	      matchcount = 0;
679
	    }
680 681 682 683 684 685 686 687 688 689 690 691
	}
      /* FIXME: If we move this `decode' earlier we can eliminate
	 the repeated ENCODE_FILE on Vcompletion_ignored_extensions.  */
      name = make_unibyte_string (dp->d_name, len);
      name = DECODE_FILE (name);

      {
	Lisp_Object regexps;
	Lisp_Object zero;
	XSETFASTINT (zero, 0);

	/* Ignore this element if it fails to match all the regexps.  */
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
	if (completion_ignore_case)
	  {
	    for (regexps = Vcompletion_regexp_list; CONSP (regexps);
		 regexps = XCDR (regexps))
	      if (fast_string_match_ignore_case (XCAR (regexps), name) < 0)
		break;
	  }
	else
	  {
	    for (regexps = Vcompletion_regexp_list; CONSP (regexps);
		 regexps = XCDR (regexps))
	      if (fast_string_match (XCAR (regexps), name) < 0)
		break;
	  }

707 708 709 710 711 712 713 714 715 716 717 718 719 720
	if (CONSP (regexps))
	  continue;
      }

      /* This is a possible completion */
      if (directoryp)
	/* This completion is a directory; make it end with '/'.  */
	name = Ffile_name_as_directory (name);

      /* Test the predicate, if any.  */
      if (!NILP (predicate))
	{
	  Lisp_Object val;
	  struct gcpro gcpro1;
Richard M. Stallman's avatar
Richard M. Stallman committed
721

722 723 724
	  GCPRO1 (name);
	  val = call1 (predicate, name);
	  UNGCPRO;
725

726 727 728
	  if (NILP (val))
	    continue;
	}
729

730
      /* Suitably record this match.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
731

732
      matchcount++;
733

734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
      if (all_flag)
	bestmatch = Fcons (name, bestmatch);
      else if (NILP (bestmatch))
	{
	  bestmatch = name;
	  bestmatchsize = SCHARS (name);
	}
      else
	{
	  Lisp_Object zero = make_number (0);
	  /* FIXME: This is a copy of the code in Ftry_completion.  */
	  int compare = min (bestmatchsize, SCHARS (name));
	  Lisp_Object tem
	    = Fcompare_strings (bestmatch, zero,
				make_number (compare),
				name, zero,
				make_number (compare),
				completion_ignore_case ? Qt : Qnil);
	  int matchsize
	    = (EQ (tem, Qt)     ? compare
	       : XINT (tem) < 0 ? - XINT (tem) - 1
	       :                  XINT (tem) - 1);

	  if (completion_ignore_case)
758
	    {
759 760 761 762 763 764 765
	      /* 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.  */
	      /* This tests that the current file is an exact match
		 but BESTMATCH is not (it is too long).  */
	      if ((matchsize == SCHARS (name)
766
		   && matchsize + !!directoryp < SCHARS (bestmatch))
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
		  ||
		  /* If there is no exact match ignoring case,
		     prefer a match that does not change the case
		     of the input.  */
		  /* If there is more than one exact match aside from
		     case, and one of them is exact including case,
		     prefer that one.  */
		  /* This == checks that, of current file and BESTMATCH,
		     either both or neither are exact.  */
		  (((matchsize == SCHARS (name))
		    ==
		    (matchsize + !!directoryp == SCHARS (bestmatch)))
		   && (tem = Fcompare_strings (name, zero,
					       make_number (SCHARS (file)),
					       file, zero,
					       Qnil,
					       Qnil),
		       EQ (Qt, tem))
		   && (tem = Fcompare_strings (bestmatch, zero,
					       make_number (SCHARS (file)),
					       file, zero,
					       Qnil,
					       Qnil),
		       ! EQ (Qt, tem))))
		bestmatch = name;
Richard M. Stallman's avatar
Richard M. Stallman committed
792
	    }
793
	  bestmatchsize = matchsize;
794 795 796 797 798 799 800 801 802 803 804 805 806 807

	  /* If the best completion so far is reduced to the string
	     we're trying to complete, then we already know there's no
	     other completion, so there's no point looking any further.  */
	  if (matchsize <= SCHARS (file)
	      && !includeall /* A future match may allow includeall to 0.  */
	      /* If completion-ignore-case is non-nil, don't
		 short-circuit because we want to find the best
		 possible match *including* case differences.  */
	      && (!completion_ignore_case || matchsize == 0)
	      /* The return value depends on whether it's the sole match.  */
	      && matchcount > 1)
	    break;

Richard M. Stallman's avatar
Richard M. Stallman committed
808 809 810
	}
    }

811
  UNGCPRO;
812
  /* This closes the directory.  */
813
  bestmatch = unbind_to (count, bestmatch);
Richard M. Stallman's avatar
Richard M. Stallman committed
814

Jim Blandy's avatar
Jim Blandy committed
815
  if (all_flag || NILP (bestmatch))
816
    return bestmatch;
817 818 819
  /* Return t if the supplied string is an exact match (counting case);
     it does not require any change to be made.  */
  if (matchcount == 1 && !NILP (Fequal (bestmatch, file)))
Richard M. Stallman's avatar
Richard M. Stallman committed
820
    return Qt;
821 822 823
  bestmatch = Fsubstring (bestmatch, make_number (0),
			  make_number (bestmatchsize));
  return bestmatch;
Richard M. Stallman's avatar
Richard M. Stallman committed
824 825
}

826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
/* Compare exactly LEN chars of strings at S1 and S2,
   ignoring case if appropriate.
   Return -1 if strings match,
   else number of chars that match at the beginning.  */

static int
scmp (s1, s2, len)
     register unsigned char *s1, *s2;
     int len;
{
  register int l = len;

  if (completion_ignore_case)
    {
      while (l && DOWNCASE (*s1++) == DOWNCASE (*s2++))
	l--;
    }
  else
    {
      while (l && *s1++ == *s2++)
	l--;
    }
  if (l == 0)
    return -1;
  else
    return len - l;
}

Andreas Schwab's avatar
Andreas Schwab committed
854
static int
Richard M. Stallman's avatar
Richard M. Stallman committed
855 856 857 858 859 860
file_name_completion_stat (dirname, dp, st_addr)
     Lisp_Object dirname;
     DIRENTRY *dp;
     struct stat *st_addr;
{
  int len = NAMLEN (dp);
861
  int pos = SCHARS (dirname);
862
  int value;
Richard M. Stallman's avatar
Richard M. Stallman committed
863 864
  char *fullname = (char *) alloca (len + pos + 2);

865 866 867 868 869 870 871 872 873 874 875 876 877
#ifdef MSDOS
#if __DJGPP__ > 1
  /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
     but aren't required here.  Avoid computing the following fields:
     st_inode, st_size and st_nlink for directories, and the execute bits
     in st_mode for non-directory files with non-standard extensions.  */

  unsigned short save_djstat_flags = _djstat_flags;

  _djstat_flags = _STAT_INODE | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
#endif /* __DJGPP__ > 1 */
#endif /* MSDOS */

878
  bcopy (SDATA (dirname), fullname, pos);
879 880
  if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
    fullname[pos++] = DIRECTORY_SEP;
Richard M. Stallman's avatar
Richard M. Stallman committed
881 882 883 884

  bcopy (dp->d_name, fullname + pos, len);
  fullname[pos + len] = 0;

885
#ifdef S_IFLNK
886 887 888 889 890 891
  /* We want to return success if a link points to a nonexistent file,
     but we want to return the status for what the link points to,
     in case it is a directory.  */
  value = lstat (fullname, st_addr);
  stat (fullname, st_addr);
  return value;
892
#else
893 894 895 896