dired.c 35.1 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
#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))
	{
	  /* w32.c:stat will notice these bindings and avoid calling
	     GetDriveType for each file.  */
224
	  if (is_slow_fs (SDATA (dirfilename)))
225 226 227 228 229 230 231
	    Vw32_get_true_file_attributes = Qnil;
	  else
	    Vw32_get_true_file_attributes = Qt;
	}
    }
#endif

232
  directory_nbytes = SBYTES (directory);
233
  re_match_object = Qt;
Richard M. Stallman's avatar
Richard M. Stallman committed
234

235
  /* Decide whether we need to add a directory separator.  */
236
  if (directory_nbytes == 0
237
      || !IS_ANY_SEP (SREF (directory, directory_nbytes - 1)))
238 239
    needsep = 1;

240
  /* Loop reading blocks until EOF or error.  */
241
  for (;;)
Richard M. Stallman's avatar
Richard M. Stallman committed
242
    {
243 244 245
      errno = 0;
      dp = readdir (d);

246
      if (dp == NULL && (0
247
#ifdef EAGAIN
248 249 250 251
			 || errno == EAGAIN
#endif
#ifdef EINTR
			 || errno == EINTR
252
#endif
253 254
			 ))
	{ QUIT; continue; }
255

256 257 258
      if (dp == NULL)
	break;

259
      if (DIRENTRY_NONEMPTY (dp))
Richard M. Stallman's avatar
Richard M. Stallman committed
260
	{
261
	  int len;
262
	  int wanted = 0;
263 264
	  Lisp_Object name, finalname;
	  struct gcpro gcpro1, gcpro2;
265 266

	  len = NAMLEN (dp);
267
	  name = finalname = make_unibyte_string (dp->d_name, len);
268
	  GCPRO2 (finalname, name);
269

270
	  /* Note: DECODE_FILE can GC; it should protect its argument,
271 272
	     though.  */
	  name = DECODE_FILE (name);
273
	  len = SBYTES (name);
274

275 276 277 278 279
	  /* 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
280
	  if (NILP (match)
281
	      || (0 <= re_search (bufp, SDATA (name), len, 0, len, 0)))
282
	    wanted = 1;
283 284 285 286

	  immediate_quit = 0;

	  if (wanted)
Richard M. Stallman's avatar
Richard M. Stallman committed
287
	    {
Jim Blandy's avatar
Jim Blandy committed
288
	      if (!NILP (full))
Richard M. Stallman's avatar
Richard M. Stallman committed
289
		{
290
		  Lisp_Object fullname;
291 292
		  int nbytes = len + directory_nbytes + needsep;
		  int nchars;
293

294
		  fullname = make_uninit_multibyte_string (nbytes, nbytes);
295
		  bcopy (SDATA (directory), SDATA (fullname),
296
			 directory_nbytes);
297

298
		  if (needsep)
299
		    SSET (fullname, directory_nbytes, DIRECTORY_SEP);
300

301 302
		  bcopy (SDATA (name),
			 SDATA (fullname) + directory_nbytes + needsep,
303
			 len);
304

305
		  nchars = chars_in_text (SDATA (fullname), nbytes);
306 307 308 309

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

311
		  STRING_SET_CHARS (fullname, nchars);
312
		  if (nchars == nbytes)
313
		    STRING_SET_UNIBYTE (fullname);
314

315 316
		  finalname = fullname;
		}
317 318
	      else
		finalname = name;
319 320 321 322 323

	      if (attrs)
		{
		  /* Construct an expanded filename for the directory entry.
		     Use the decoded names for input to Ffile_attributes.  */
324 325 326 327 328
		  Lisp_Object decoded_fullname, fileattrs;
		  struct gcpro gcpro1, gcpro2;

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

330
		  /* Both Fexpand_file_name and Ffile_attributes can GC.  */
331
		  decoded_fullname = Fexpand_file_name (name, directory);
Kenichi Handa's avatar
Kenichi Handa committed
332
		  fileattrs = Ffile_attributes (decoded_fullname, id_format);
333 334

		  list = Fcons (Fcons (finalname, fileattrs), list);
335
		  UNGCPRO;
336 337
		}
	      else
338
		list = Fcons (finalname, list);
Richard M. Stallman's avatar
Richard M. Stallman committed
339
	    }
340 341

	  UNGCPRO;
Richard M. Stallman's avatar
Richard M. Stallman committed
342 343
	}
    }
344

345
  BLOCK_INPUT;
Richard M. Stallman's avatar
Richard M. Stallman committed
346
  closedir (d);
347
  UNBLOCK_INPUT;
348 349 350 351
#ifdef WINDOWSNT
  if (attrs)
    Vw32_get_true_file_attributes = w32_save;
#endif
352 353 354 355

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

356 357 358
  if (NILP (nosort))
    list = Fsort (Fnreverse (list),
		  attrs ? Qfile_attributes_lessp : Qstring_lessp);
359

360
  RETURN_UNGCPRO (list);
Richard M. Stallman's avatar
Richard M. Stallman committed
361
}
362 363 364


DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
365 366 367 368 369 370
       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
371 372
  Otherwise, the list returned is sorted with `stringp-lessp'.
  NOSORT is useful if you plan to sort the result yourself.  */)
373
     (directory, full, match, nosort)
374 375 376
     Lisp_Object directory, full, match, nosort;
{
  Lisp_Object handler;
377
  directory = Fexpand_file_name (directory, Qnil);
378 379 380 381 382

  /* 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
383 384
    return call5 (handler, Qdirectory_files, directory,
                  full, match, nosort);
385

Kenichi Handa's avatar
Kenichi Handa committed
386
  return directory_files_internal (directory, full, match, nosort, 0, Qnil);
387 388
}

389
DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes,
Kenichi Handa's avatar
Kenichi Handa committed
390
       Sdirectory_files_and_attributes, 1, 5, 0,
391
       doc: /* Return a list of names of files and their attributes in DIRECTORY.
Kenichi Handa's avatar
Kenichi Handa committed
392
There are four optional arguments:
393 394 395 396
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
397 398
 NOSORT is useful if you plan to sort the result yourself.
ID-FORMAT specifies the preferred format of attributes uid and gid, see
399 400 401
`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
402 403
     (directory, full, match, nosort, id_format)
     Lisp_Object directory, full, match, nosort, id_format;
404 405
{
  Lisp_Object handler;
406
  directory = Fexpand_file_name (directory, Qnil);
407 408 409 410 411

  /* 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
412 413
    return call6 (handler, Qdirectory_files_and_attributes,
                  directory, full, match, nosort, id_format);
414

Kenichi Handa's avatar
Kenichi Handa committed
415
  return directory_files_internal (directory, full, match, nosort, 1, id_format);
416 417
}

Richard M. Stallman's avatar
Richard M. Stallman committed
418 419 420 421

Lisp_Object file_name_completion ();

DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
422
       2, 3, 0,
423 424 425 426
       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.
427
Returns nil if DIRECTORY contains no name starting with FILE.
428

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

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

439
  /* If the directory name has special constructs in it,
440
     call the corresponding file handler.  */
441
  handler = Ffind_file_name_handler (directory, Qfile_name_completion);
442
  if (!NILP (handler))
443
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
444

445 446 447 448
  /* 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))
449
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
450

451
  return file_name_completion (file, directory, 0, 0, predicate);
Richard M. Stallman's avatar
Richard M. Stallman committed
452 453 454
}

DEFUN ("file-name-all-completions", Ffile_name_all_completions,
455 456 457 458
       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)
459
     Lisp_Object file, directory;
Richard M. Stallman's avatar
Richard M. Stallman committed
460
{
461 462
  Lisp_Object handler;

463
  /* If the directory name has special constructs in it,
464
     call the corresponding file handler.  */
465
  handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
466
  if (!NILP (handler))
467
    return call3 (handler, Qfile_name_all_completions, file, directory);
468

469 470 471 472
  /* 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))
473
    return call3 (handler, Qfile_name_all_completions, file, directory);
474

475
  return file_name_completion (file, directory, 1, 0, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
476 477
}

Andreas Schwab's avatar
Andreas Schwab committed
478
static int file_name_completion_stat ();
479
Lisp_Object Qdefault_directory;
Andreas Schwab's avatar
Andreas Schwab committed
480

Richard M. Stallman's avatar
Richard M. Stallman committed
481
Lisp_Object
482
file_name_completion (file, dirname, all_flag, ver_flag, predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
483 484
     Lisp_Object file, dirname;
     int all_flag, ver_flag;
485
     Lisp_Object predicate;
Richard M. Stallman's avatar
Richard M. Stallman committed
486 487
{
  DIR *d;
488
  int bestmatchsize = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
489
  int matchcount = 0;
490 491 492
  /* 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
493
  Lisp_Object bestmatch, tem, elt, name;
494 495
  Lisp_Object encoded_file;
  Lisp_Object encoded_dir;
Richard M. Stallman's avatar
Richard M. Stallman committed
496 497
  struct stat st;
  int directoryp;
498 499 500 501
  /* 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
502
  int count = SPECPDL_INDEX ();
503
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
504

505 506
  elt = Qnil;

507
  CHECK_STRING (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
508

509 510 511
#ifdef FILE_SYSTEM_CASE
  file = FILE_SYSTEM_CASE (file);
#endif
Richard M. Stallman's avatar
Richard M. Stallman committed
512
  bestmatch = Qnil;
513 514
  encoded_file = encoded_dir = Qnil;
  GCPRO5 (file, dirname, bestmatch, encoded_file, encoded_dir);
515
  dirname = Fexpand_file_name (dirname, Qnil);
516
  specbind (Qdefault_directory, dirname);
Richard M. Stallman's avatar
Richard M. Stallman committed
517

518 519 520
  /* 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.  */
521 522 523
  /* 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.  */
524
  encoded_file = STRING_MULTIBYTE (file) ? ENCODE_FILE (file) : file;
525 526 527

  encoded_dir = ENCODE_FILE (dirname);

528 529 530 531 532
  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
533

534 535
  record_unwind_protect (directory_files_internal_unwind,
			 make_save_value (d, 0));
Richard M. Stallman's avatar
Richard M. Stallman committed
536

537 538 539
  /* Loop reading blocks */
  /* (att3b compiler bug requires do a null comparison this way) */
  while (1)
Richard M. Stallman's avatar
Richard M. Stallman committed
540
    {
541 542 543
      DIRENTRY *dp;
      int len;
      int canexclude = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
544

545 546 547
      errno = 0;
      dp = readdir (d);
      if (dp == NULL && (0
548
# ifdef EAGAIN
549
			 || errno == EAGAIN
550 551
# endif
# ifdef EINTR
552
			 || errno == EINTR
553
# endif
554 555
			 ))
	{ QUIT; continue; }
556

557
      if (!dp) break;
Richard M. Stallman's avatar
Richard M. Stallman committed
558

559
      len = NAMLEN (dp);
Richard M. Stallman's avatar
Richard M. Stallman committed
560

561 562 563 564 565 566
      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
567

568 569
      if (file_name_completion_stat (encoded_dir, dp, &st) < 0)
	continue;
Richard M. Stallman's avatar
Richard M. Stallman committed
570

571 572 573 574 575 576 577 578
      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;
579

580
#if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
581 582 583 584 585 586 587 588 589 590
	  /* 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;
591
#endif
592

593
	  if (directoryp)
594 595 596 597
	    {
#ifndef TRIVIAL_DIRECTORY_ENTRY
#define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
#endif
598 599
	      /* "." and ".." are never interesting as completions, and are
		 actually in the way in a directory with only one file.  */
600 601 602
	      if (TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
		canexclude = 1;
	      else if (len > SCHARS (encoded_file))
603 604 605 606 607 608
		/* 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;
609
		    unsigned char *p1;
610 611 612 613

		    elt = XCAR (tem);
		    if (!STRINGP (elt))
		      continue;
614 615 616
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
617
		    elt_len = SCHARS (elt) - 1; /* -1 for trailing / */
618
		    if (elt_len <= 0)
619
		      continue;
620
		    p1 = SDATA (elt);
621 622 623 624 625 626 627 628 629 630
		    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;
		  }
631 632
	    }
	  else
633
	    {
Richard M. Stallman's avatar
Richard M. Stallman committed
634 635
	      /* Compare extensions-to-be-ignored against end of this file name */
	      /* if name is not an exact match against specified string */
636
	      if (len > SCHARS (encoded_file))
Richard M. Stallman's avatar
Richard M. Stallman committed
637 638
		/* and exit this for loop if a match is found */
		for (tem = Vcompletion_ignored_extensions;
639
		     CONSP (tem); tem = XCDR (tem))
Richard M. Stallman's avatar
Richard M. Stallman committed
640
		  {
641
		    elt = XCAR (tem);
642
		    if (!STRINGP (elt)) continue;
643 644 645
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
646
		    skip = len - SCHARS (elt);
Richard M. Stallman's avatar
Richard M. Stallman committed
647 648 649
		    if (skip < 0) continue;

		    if (0 <= scmp (dp->d_name + skip,
650 651
				   SDATA (elt),
				   SCHARS (elt)))
Richard M. Stallman's avatar
Richard M. Stallman committed
652 653 654 655 656
		      continue;
		    break;
		  }
	    }

657 658
	  /* If an ignored-extensions match was found,
	     don't process this name as a completion.  */
659 660
	  if (CONSP (tem))
	    canexclude = 1;
661

662 663 664
	  if (!includeall && canexclude)
	    /* We're not including all files and this file can be excluded.  */
	    continue;
665

666 667 668 669 670 671 672 673
	  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;
674
	    }
675 676 677 678 679 680 681 682 683 684 685 686
	}
      /* 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.  */
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
	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;
	  }

702 703 704 705 706 707 708 709 710 711 712 713 714 715
	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
716

717 718 719
	  GCPRO1 (name);
	  val = call1 (predicate, name);
	  UNGCPRO;
720

721 722 723
	  if (NILP (val))
	    continue;
	}
724

725
      /* Suitably record this match.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
726

727
      matchcount++;
728

729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
      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)
753
	    {
754 755 756 757 758 759 760
	      /* 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)
761
		   && matchsize + !!directoryp < SCHARS (bestmatch))
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
		  ||
		  /* 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
787
	    }
788
	  bestmatchsize = matchsize;
789 790 791 792 793 794 795 796 797 798 799 800 801 802

	  /* 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
803 804 805
	}
    }

806
  UNGCPRO;
807
  /* This closes the directory.  */
808
  bestmatch = unbind_to (count, bestmatch);
Richard M. Stallman's avatar
Richard M. Stallman committed
809

Jim Blandy's avatar
Jim Blandy committed
810
  if (all_flag || NILP (bestmatch))
811
    return bestmatch;
812 813 814
  /* 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
815
    return Qt;
816 817 818
  bestmatch = Fsubstring (bestmatch, make_number (0),
			  make_number (bestmatchsize));
  return bestmatch;
Richard M. Stallman's avatar
Richard M. Stallman committed
819 820
}

821 822 823 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
/* 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
849
static int
Richard M. Stallman's avatar
Richard M. Stallman committed
850 851 852 853 854 855
file_name_completion_stat (dirname, dp, st_addr)
     Lisp_Object dirname;
     DIRENTRY *dp;
     struct stat *st_addr;
{
  int len = NAMLEN (dp);
856
  int pos = SCHARS (dirname);
857
  int value;
Richard M. Stallman's avatar
Richard M. Stallman committed
858 859
  char *fullname = (char *) alloca (len + pos + 2);

860 861 862 863 864 865 866 867 868 869 870 871 872
#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 */

873
  bcopy (SDATA (dirname), fullname, pos);
874 875
  if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
    fullname[pos++] = DIRECTORY_SEP;
Richard M. Stallman's avatar
Richard M. Stallman committed
876 877 878 879

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

880
#ifdef S_IFLNK
881 882 883 884 885 886
  /* 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;
887
#else
888 889 890