dired.c 34.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, 2010 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
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
26
#include <setjmp.h>
Richard M. Stallman's avatar
Richard M. Stallman committed
27

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

33
#include <errno.h>
34

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

39 40 41 42 43 44 45 46 47 48 49 50
/* 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
51 52 53 54 55
#ifdef SYSV_SYSTEM_DIR

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

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

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

64 65
#include <sys/stat.h>

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

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

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

75 76
/* Some versions of Cygwin don't have d_ino in `struct dirent'.  */
#if defined(MSDOS) || defined(__CYGWIN__)
77 78 79
#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
80 81 82
#endif

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

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

95 96 97
/* 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
98 99 100 101 102 103 104
/* 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

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

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

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

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

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

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

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

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

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

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

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

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

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

210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
#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.  */
225
	  if (is_slow_fs (SDATA (dirfilename)))
226 227 228 229 230 231 232
	    Vw32_get_true_file_attributes = Qnil;
	  else
	    Vw32_get_true_file_attributes = Qt;
	}
    }
#endif

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

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

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

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

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

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

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

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

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

	  immediate_quit = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

506 507
  elt = Qnil;

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

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

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

  encoded_dir = ENCODE_FILE (dirname);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

728
      matchcount++;
729

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

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

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

Jim Blandy's avatar
Jim Blandy committed
811
  if (all_flag || NILP (bestmatch))
812
    return bestmatch;
813 814 815
  /* 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
816
    return Qt;
817 818 819
  bestmatch = Fsubstring (bestmatch, make_number (0),
			  make_number (bestmatchsize));
  return bestmatch;
Richard M. Stallman's avatar
Richard M. Stallman committed
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 849
/* 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
850
static int
Richard M. Stallman's avatar
Richard M. Stallman committed
851 852 853 854 855 856
file_name_completion_stat (dirname, dp, st_addr)
     Lisp_Object dirname;
     DIRENTRY *dp;
     struct stat *st_addr;
{
  int len = NAMLEN (dp);
857
  int pos = SCHARS (dirname);
858
  int value;
Richard M. Stallman's avatar
Richard M. Stallman committed
859 860
  char *fullname = (char *) alloca (len + pos + 2);

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

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

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

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