dired.c 33.8 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 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 30
#endif
#ifndef VMS
Kenichi Handa's avatar
Kenichi Handa committed
31 32 33
#include <grp.h>
#endif

34
#include <errno.h>
35

36 37 38 39 40 41
#ifdef VMS
#include <string.h>
#include <rms.h>
#include <rmsdef.h>
#endif

Andreas Schwab's avatar
Andreas Schwab committed
42 43 44 45
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

46 47 48 49 50 51 52 53 54 55 56 57
/* 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
58 59 60 61 62
#ifdef SYSV_SYSTEM_DIR

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

63
#else /* not SYSV_SYSTEM_DIR */
Richard M. Stallman's avatar
Richard M. Stallman committed
64 65 66 67

#ifdef NONSYSTEM_DIR_LIBRARY
#include "ndir.h"
#else /* not NONSYSTEM_DIR_LIBRARY */
68 69 70
#ifdef MSDOS
#include <dirent.h>
#else
Richard M. Stallman's avatar
Richard M. Stallman committed
71
#include <sys/dir.h>
72
#endif
Richard M. Stallman's avatar
Richard M. Stallman committed
73 74
#endif /* not NONSYSTEM_DIR_LIBRARY */

75 76
#include <sys/stat.h>

77
#ifndef MSDOS
Richard M. Stallman's avatar
Richard M. Stallman committed
78 79 80 81 82
#define DIRENTRY struct direct

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

83 84 85
#endif /* not MSDOS */
#endif /* not SYSV_SYSTEM_DIR */

86 87
/* Some versions of Cygwin don't have d_ino in `struct dirent'.  */
#if defined(MSDOS) || defined(__CYGWIN__)
88 89 90
#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
91 92 93
#endif

#include "lisp.h"
94
#include "systime.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
95 96
#include "buffer.h"
#include "commands.h"
Kenichi Handa's avatar
Kenichi Handa committed
97
#include "character.h"
98 99
#include "charset.h"
#include "coding.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
100
#include "regex.h"
YAMAMOTO Mitsuharu's avatar
YAMAMOTO Mitsuharu committed
101
#include "blockinput.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
102

103 104
/* Returns a search buffer, with a fastmap allocated and ready to go.  */
extern struct re_pattern_buffer *compile_pattern ();
105

106 107 108
/* 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
109 110 111 112 113 114 115
/* 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

116
extern int completion_ignore_case;
117
extern Lisp_Object Qcompletion_ignore_case;
118
extern Lisp_Object Vcompletion_regexp_list;
119

Richard M. Stallman's avatar
Richard M. Stallman committed
120
Lisp_Object Vcompletion_ignored_extensions;
121
Lisp_Object Qdirectory_files;
122
Lisp_Object Qdirectory_files_and_attributes;
123 124
Lisp_Object Qfile_name_completion;
Lisp_Object Qfile_name_all_completions;
Jim Blandy's avatar
Jim Blandy committed
125
Lisp_Object Qfile_attributes;
126
Lisp_Object Qfile_attributes_lessp;
127 128

static int scmp P_ ((unsigned char *, unsigned char *, int));
Richard M. Stallman's avatar
Richard M. Stallman committed
129

130 131 132 133 134

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

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

147
Lisp_Object
Kenichi Handa's avatar
Kenichi Handa committed
148
directory_files_internal (directory, full, match, nosort, attrs, id_format)
149
     Lisp_Object directory, full, match, nosort;
150
     int attrs;
Kenichi Handa's avatar
Kenichi Handa committed
151
     Lisp_Object id_format;
Richard M. Stallman's avatar
Richard M. Stallman committed
152 153
{
  DIR *d;
154 155
  int directory_nbytes;
  Lisp_Object list, dirfilename, encoded_directory;
156
  struct re_pattern_buffer *bufp = NULL;
157
  int needsep = 0;
Juanma Barranquero's avatar
Juanma Barranquero committed
158
  int count = SPECPDL_INDEX ();
159
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
160
  DIRENTRY *dp;
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.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
177
#ifdef VMS
178
      bufp = compile_pattern (match, 0,
179
			      buffer_defaults.downcase_table, 0, 1);
180 181 182 183 184 185
#else  /* !VMS */
# ifdef WINDOWSNT
      /* Windows users want case-insensitive wildcards.  */
      bufp = compile_pattern (match, 0,
			      buffer_defaults.case_canon_table, 0, 1);
# else	/* !WINDOWSNT */
186
      bufp = compile_pattern (match, 0, Qnil, 0, 1);
187 188
# endif	 /* !WINDOWSNT */
#endif	 /* !VMS */
Richard M. Stallman's avatar
Richard M. Stallman committed
189 190
    }

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

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

202
  BLOCK_INPUT;
203
  d = opendir (SDATA (dirfilename));
204
  UNBLOCK_INPUT;
205
  if (d == NULL)
206
    report_file_error ("Opening directory", Fcons (directory, Qnil));
Richard M. Stallman's avatar
Richard M. Stallman committed
207

208 209 210 211
  /* 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,
212
			 make_save_value (d, 0));
213

214
  directory_nbytes = SBYTES (directory);
215
  re_match_object = Qt;
Richard M. Stallman's avatar
Richard M. Stallman committed
216

217 218
  /* Decide whether we need to add a directory separator.  */
#ifndef VMS
219
  if (directory_nbytes == 0
220
      || !IS_ANY_SEP (SREF (directory, directory_nbytes - 1)))
221
    needsep = 1;
222
#endif /* not VMS */
223

224
  /* Loop reading blocks until EOF or error.  */
225
  for (;;)
Richard M. Stallman's avatar
Richard M. Stallman committed
226
    {
227 228 229
      errno = 0;
      dp = readdir (d);

230
      if (dp == NULL && (0
231
#ifdef EAGAIN
232 233 234 235
			 || errno == EAGAIN
#endif
#ifdef EINTR
			 || errno == EINTR
236
#endif
237 238
			 ))
	{ QUIT; continue; }
239

240 241 242
      if (dp == NULL)
	break;

243
      if (DIRENTRY_NONEMPTY (dp))
Richard M. Stallman's avatar
Richard M. Stallman committed
244
	{
245
	  int len;
246
	  int wanted = 0;
247 248
	  Lisp_Object name, finalname;
	  struct gcpro gcpro1, gcpro2;
249 250

	  len = NAMLEN (dp);
251
	  name = finalname = make_unibyte_string (dp->d_name, len);
252
	  GCPRO2 (finalname, name);
253

254
	  /* Note: DECODE_FILE can GC; it should protect its argument,
255 256
	     though.  */
	  name = DECODE_FILE (name);
257
	  len = SBYTES (name);
258

259 260 261 262 263
	  /* 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
264
	  if (NILP (match)
265
	      || (0 <= re_search (bufp, SDATA (name), len, 0, len, 0)))
266
	    wanted = 1;
267 268 269 270

	  immediate_quit = 0;

	  if (wanted)
Richard M. Stallman's avatar
Richard M. Stallman committed
271
	    {
Jim Blandy's avatar
Jim Blandy committed
272
	      if (!NILP (full))
Richard M. Stallman's avatar
Richard M. Stallman committed
273
		{
274
		  Lisp_Object fullname;
275 276
		  int nbytes = len + directory_nbytes + needsep;
		  int nchars;
277

278
		  fullname = make_uninit_multibyte_string (nbytes, nbytes);
279
		  bcopy (SDATA (directory), SDATA (fullname),
280
			 directory_nbytes);
281

282
		  if (needsep)
283
		    SSET (fullname, directory_nbytes, DIRECTORY_SEP);
284

285 286
		  bcopy (SDATA (name),
			 SDATA (fullname) + directory_nbytes + needsep,
287
			 len);
288

289
		  nchars = chars_in_text (SDATA (fullname), nbytes);
290 291 292 293

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

295
		  STRING_SET_CHARS (fullname, nchars);
296
		  if (nchars == nbytes)
297
		    STRING_SET_UNIBYTE (fullname);
298

299 300
		  finalname = fullname;
		}
301 302
	      else
		finalname = name;
303 304 305 306 307

	      if (attrs)
		{
		  /* Construct an expanded filename for the directory entry.
		     Use the decoded names for input to Ffile_attributes.  */
308 309 310 311 312
		  Lisp_Object decoded_fullname, fileattrs;
		  struct gcpro gcpro1, gcpro2;

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

314
		  /* Both Fexpand_file_name and Ffile_attributes can GC.  */
315
		  decoded_fullname = Fexpand_file_name (name, directory);
Kenichi Handa's avatar
Kenichi Handa committed
316
		  fileattrs = Ffile_attributes (decoded_fullname, id_format);
317 318

		  list = Fcons (Fcons (finalname, fileattrs), list);
319
		  UNGCPRO;
320 321
		}
	      else
322
		list = Fcons (finalname, list);
Richard M. Stallman's avatar
Richard M. Stallman committed
323
	    }
324 325

	  UNGCPRO;
Richard M. Stallman's avatar
Richard M. Stallman committed
326 327
	}
    }
328

329
  BLOCK_INPUT;
Richard M. Stallman's avatar
Richard M. Stallman committed
330
  closedir (d);
331
  UNBLOCK_INPUT;
332 333 334 335

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

336 337 338
  if (NILP (nosort))
    list = Fsort (Fnreverse (list),
		  attrs ? Qfile_attributes_lessp : Qstring_lessp);
339

340
  RETURN_UNGCPRO (list);
Richard M. Stallman's avatar
Richard M. Stallman committed
341
}
342 343 344


DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
345 346 347 348 349 350 351 352
       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.
 NOSORT is useful if you plan to sort the result yourself.  */)
     (directory, full, match, nosort)
353 354 355
     Lisp_Object directory, full, match, nosort;
{
  Lisp_Object handler;
356
  directory = Fexpand_file_name (directory, Qnil);
357 358 359 360 361

  /* 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
362 363
    return call5 (handler, Qdirectory_files, directory,
                  full, match, nosort);
364

Kenichi Handa's avatar
Kenichi Handa committed
365
  return directory_files_internal (directory, full, match, nosort, 0, Qnil);
366 367
}

368
DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes,
Kenichi Handa's avatar
Kenichi Handa committed
369
       Sdirectory_files_and_attributes, 1, 5, 0,
370
       doc: /* Return a list of names of files and their attributes in DIRECTORY.
Kenichi Handa's avatar
Kenichi Handa committed
371
There are four optional arguments:
372 373 374 375
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
376 377
 NOSORT is useful if you plan to sort the result yourself.
ID-FORMAT specifies the preferred format of attributes uid and gid, see
378 379 380
`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
381 382
     (directory, full, match, nosort, id_format)
     Lisp_Object directory, full, match, nosort, id_format;
383 384
{
  Lisp_Object handler;
385
  directory = Fexpand_file_name (directory, Qnil);
386 387 388 389 390

  /* 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
391 392
    return call6 (handler, Qdirectory_files_and_attributes,
                  directory, full, match, nosort, id_format);
393

Kenichi Handa's avatar
Kenichi Handa committed
394
  return directory_files_internal (directory, full, match, nosort, 1, id_format);
395 396
}

Richard M. Stallman's avatar
Richard M. Stallman committed
397 398 399 400

Lisp_Object file_name_completion ();

DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
401
       2, 3, 0,
402 403 404 405
       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.
406
Returns nil if DIRECTORY contains no name starting with FILE.
407

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

411 412
This function ignores some of the possible completions as
determined by the variable `completion-ignored-extensions', which see.  */)
413 414
     (file, directory, predicate)
     Lisp_Object file, directory, predicate;
Richard M. Stallman's avatar
Richard M. Stallman committed
415
{
416 417
  Lisp_Object handler;

418
  /* If the directory name has special constructs in it,
419
     call the corresponding file handler.  */
420
  handler = Ffind_file_name_handler (directory, Qfile_name_completion);
421
  if (!NILP (handler))
422
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
423

424 425 426 427
  /* 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))
428
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
429

430
  return file_name_completion (file, directory, 0, 0, predicate);
Richard M. Stallman's avatar
Richard M. Stallman committed
431 432 433
}

DEFUN ("file-name-all-completions", Ffile_name_all_completions,
434 435 436 437
       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)
438
     Lisp_Object file, directory;
Richard M. Stallman's avatar
Richard M. Stallman committed
439
{
440 441
  Lisp_Object handler;

442
  /* If the directory name has special constructs in it,
443
     call the corresponding file handler.  */
444
  handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
445
  if (!NILP (handler))
446
    return call3 (handler, Qfile_name_all_completions, file, directory);
447

448 449 450 451
  /* 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))
452
    return call3 (handler, Qfile_name_all_completions, file, directory);
453

454
  return file_name_completion (file, directory, 1, 0, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
455 456
}

Andreas Schwab's avatar
Andreas Schwab committed
457
static int file_name_completion_stat ();
458
Lisp_Object Qdefault_directory;
Andreas Schwab's avatar
Andreas Schwab committed
459

Richard M. Stallman's avatar
Richard M. Stallman committed
460
Lisp_Object
461
file_name_completion (file, dirname, all_flag, ver_flag, predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
462 463
     Lisp_Object file, dirname;
     int all_flag, ver_flag;
464
     Lisp_Object predicate;
Richard M. Stallman's avatar
Richard M. Stallman committed
465 466
{
  DIR *d;
467
  int bestmatchsize = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
468
  int matchcount = 0;
469 470 471
  /* 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
472
  Lisp_Object bestmatch, tem, elt, name;
473 474
  Lisp_Object encoded_file;
  Lisp_Object encoded_dir;
Richard M. Stallman's avatar
Richard M. Stallman committed
475 476
  struct stat st;
  int directoryp;
477 478 479 480
  /* 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
481
  int count = SPECPDL_INDEX ();
482
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
483

484 485
  elt = Qnil;

Richard M. Stallman's avatar
Richard M. Stallman committed
486 487 488 489 490 491 492 493 494 495 496 497 498
#ifdef VMS
  extern DIRENTRY * readdirver ();

  DIRENTRY *((* readfunc) ());

  /* Filename completion on VMS ignores case, since VMS filesys does.  */
  specbind (Qcompletion_ignore_case, Qt);

  readfunc = readdir;
  if (ver_flag)
    readfunc = readdirver;
  file = Fupcase (file);
#else  /* not VMS */
499
  CHECK_STRING (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
500 501
#endif /* not VMS */

502 503 504
#ifdef FILE_SYSTEM_CASE
  file = FILE_SYSTEM_CASE (file);
#endif
Richard M. Stallman's avatar
Richard M. Stallman committed
505
  bestmatch = Qnil;
506 507
  encoded_file = encoded_dir = Qnil;
  GCPRO5 (file, dirname, bestmatch, encoded_file, encoded_dir);
508
  dirname = Fexpand_file_name (dirname, Qnil);
509
  specbind (Qdefault_directory, dirname);
Richard M. Stallman's avatar
Richard M. Stallman committed
510

511 512 513
  /* 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.  */
514 515 516
  /* 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.  */
517
  encoded_file = STRING_MULTIBYTE (file) ? ENCODE_FILE (file) : file;
518 519 520

  encoded_dir = ENCODE_FILE (dirname);

521 522 523 524 525
  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
526

527 528
  record_unwind_protect (directory_files_internal_unwind,
			 make_save_value (d, 0));
Richard M. Stallman's avatar
Richard M. Stallman committed
529

530 531 532
  /* Loop reading blocks */
  /* (att3b compiler bug requires do a null comparison this way) */
  while (1)
Richard M. Stallman's avatar
Richard M. Stallman committed
533
    {
534 535 536
      DIRENTRY *dp;
      int len;
      int canexclude = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
537 538

#ifdef VMS
539
      dp = (*readfunc) (d);
Richard M. Stallman's avatar
Richard M. Stallman committed
540
#else
541 542 543
      errno = 0;
      dp = readdir (d);
      if (dp == NULL && (0
544
# ifdef EAGAIN
545
			 || errno == EAGAIN
546 547
# endif
# ifdef EINTR
548
			 || errno == EINTR
549
# endif
550 551
			 ))
	{ QUIT; continue; }
Richard M. Stallman's avatar
Richard M. Stallman committed
552
#endif
553

554
      if (!dp) break;
Richard M. Stallman's avatar
Richard M. Stallman committed
555

556
      len = NAMLEN (dp);
Richard M. Stallman's avatar
Richard M. Stallman committed
557

558 559 560 561 562 563
      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
564

565 566
      if (file_name_completion_stat (encoded_dir, dp, &st) < 0)
	continue;
Richard M. Stallman's avatar
Richard M. Stallman committed
567

568 569 570 571 572 573 574 575 576
      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;
	  if (directoryp)
577 578 579 580
	    {
#ifndef TRIVIAL_DIRECTORY_ENTRY
#define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
#endif
581 582
	      /* "." and ".." are never interesting as completions, and are
		 actually in the way in a directory with only one file.  */
583 584 585
	      if (TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
		canexclude = 1;
	      else if (len > SCHARS (encoded_file))
586 587 588 589 590 591
		/* 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;
592
		    unsigned char *p1;
593 594 595 596

		    elt = XCAR (tem);
		    if (!STRINGP (elt))
		      continue;
597 598 599
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
600
		    elt_len = SCHARS (elt) - 1; /* -1 for trailing / */
601
		    if (elt_len <= 0)
602
		      continue;
603
		    p1 = SDATA (elt);
604 605 606 607 608 609 610 611 612 613
		    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;
		  }
614 615
	    }
	  else
616
	    {
Richard M. Stallman's avatar
Richard M. Stallman committed
617 618
	      /* Compare extensions-to-be-ignored against end of this file name */
	      /* if name is not an exact match against specified string */
619
	      if (len > SCHARS (encoded_file))
Richard M. Stallman's avatar
Richard M. Stallman committed
620 621
		/* and exit this for loop if a match is found */
		for (tem = Vcompletion_ignored_extensions;
622
		     CONSP (tem); tem = XCDR (tem))
Richard M. Stallman's avatar
Richard M. Stallman committed
623
		  {
624
		    elt = XCAR (tem);
625
		    if (!STRINGP (elt)) continue;
626 627 628
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
629
		    skip = len - SCHARS (elt);
Richard M. Stallman's avatar
Richard M. Stallman committed
630 631 632
		    if (skip < 0) continue;

		    if (0 <= scmp (dp->d_name + skip,
633 634
				   SDATA (elt),
				   SCHARS (elt)))
Richard M. Stallman's avatar
Richard M. Stallman committed
635 636 637 638 639
		      continue;
		    break;
		  }
	    }

640 641
	  /* If an ignored-extensions match was found,
	     don't process this name as a completion.  */
642 643
	  if (CONSP (tem))
	    canexclude = 1;
644

645 646 647
	  if (!includeall && canexclude)
	    /* We're not including all files and this file can be excluded.  */
	    continue;
648

649 650 651 652 653 654 655 656
	  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;
657
	    }
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 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.  */
	for (regexps = Vcompletion_regexp_list; CONSP (regexps);
	     regexps = XCDR (regexps))
	  if (fast_string_match (XCAR (regexps), name) < 0)
	    break;
	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
688

689 690 691
	  GCPRO1 (name);
	  val = call1 (predicate, name);
	  UNGCPRO;
692

693 694 695
	  if (NILP (val))
	    continue;
	}
696

697
      /* Suitably record this match.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
698

699
      matchcount++;
700

701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
      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)
725
	    {
726 727 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 753 754 755 756 757 758 759
	      /* 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)
		   && matchsize + !!directoryp
		   < SCHARS (bestmatch))
		  ||
		  /* 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
760
	    }
761
	  bestmatchsize = matchsize;
Richard M. Stallman's avatar
Richard M. Stallman committed
762 763 764
	}
    }

765
  UNGCPRO;
766
  /* This closes the directory.  */
767
  bestmatch = unbind_to (count, bestmatch);
Richard M. Stallman's avatar
Richard M. Stallman committed
768

Jim Blandy's avatar
Jim Blandy committed
769
  if (all_flag || NILP (bestmatch))
770 771
    return bestmatch;
  if (matchcount == 1 && bestmatchsize == SCHARS (file))
Richard M. Stallman's avatar
Richard M. Stallman committed
772
    return Qt;
773 774 775
  bestmatch = Fsubstring (bestmatch, make_number (0),
			  make_number (bestmatchsize));
  return bestmatch;
Richard M. Stallman's avatar
Richard M. Stallman committed
776 777
}

778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
/* 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
806
static int
Richard M. Stallman's avatar
Richard M. Stallman committed
807 808 809 810 811 812
file_name_completion_stat (dirname, dp, st_addr)
     Lisp_Object dirname;
     DIRENTRY *dp;
     struct stat *st_addr;
{
  int len = NAMLEN (dp);
813
  int pos = SCHARS (dirname);
814
  int value;
Richard M. Stallman's avatar
Richard M. Stallman committed
815 816
  char *fullname = (char *) alloca (len + pos + 2);

817 818 819 820 821 822 823 824 825 826 827 828 829
#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 */

830
  bcopy (SDATA (dirname), fullname, pos);
Richard M. Stallman's avatar
Richard M. Stallman committed
831
#ifndef VMS
832 833
  if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
    fullname[pos++] = DIRECTORY_SEP;
Richard M. Stallman's avatar
Richard M. Stallman committed
834 835 836 837 838
#endif

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

839
#ifdef S_IFLNK
840 841 842 843 844 845
  /* 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;
846
#else
847 848 849 850 851 852 853 854
  value = stat (fullname, st_addr);
#ifdef MSDOS
#if __DJGPP__ > 1
  _djstat_flags = save_djstat_flags;
#endif /* __DJGPP__ > 1 */
#endif /* MSDOS */
  return value;
#endif /* S_IFLNK */
Richard M. Stallman's avatar
Richard M. Stallman committed
855 856
}

857 858 859
#ifdef VMS

DEFUN ("file-name-all-versions", Ffile_name_all_versions,
860 861 862
       Sfile_name_all_versions, 2, 2, 0,
       doc: /* Return a list of all versions of file name FILE in directory DIRECTORY.  */)
     (file, directory)
863
     Lisp_Object file, directory;
864
{
865
  return file_name_completion (file, directory, 1, 1, Qnil);
866 867 868
}

DEFUN ("file-version-limit", Ffile_version_limit, Sfile_version_limit, 1, 1, 0,
869 870 871
       doc: /* Return the maximum number of versions allowed for FILE.
Returns nil if the file cannot be opened or if there is no version limit.  */)
     (filename)
872 873 874 875 876 877 878 879 880 881 882
     Lisp_Object filename;
{
  Lisp_Object retval;
  struct FAB    fab;
  struct RAB    rab;
  struct XABFHC xabfhc;
  int status;

  filename = Fexpand_file_name (filename, Qnil);
  fab      = cc$rms_fab;
  xabfhc   = cc$rms_xabfhc;
883
  fab.fab$l_fna = SDATA (filename);
884 885 886 887 888