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 7 8

This file is part of GNU Emacs.

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

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
along with GNU Emacs; see the file COPYING.  If not, write to
Lute Kamstra's avatar
Lute Kamstra committed
19 20
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
21 22


23 24
#include <config.h>

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

29
#ifdef HAVE_PWD_H
Kenichi Handa's avatar
Kenichi Handa committed
30
#include <pwd.h>
31 32
#endif
#ifndef VMS
Kenichi Handa's avatar
Kenichi Handa committed
33 34 35
#include <grp.h>
#endif

36
#include <errno.h>
37

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

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

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

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

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

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

77 78
#include <sys/stat.h>

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

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

85 86 87
#endif /* not MSDOS */
#endif /* not SYSV_SYSTEM_DIR */

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

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

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

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

118
extern int completion_ignore_case;
119
extern Lisp_Object Qcompletion_ignore_case;
120
extern Lisp_Object Vcompletion_regexp_list;
121

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

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

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

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

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

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

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

      /* MATCH might be a flawed regular expression.  Rather than
Karl Heuer's avatar
Karl Heuer committed
175
	 catching and signaling our own errors, we just call
Jim Blandy's avatar
Jim Blandy committed
176
	 compile_pattern to do the work for us.  */
177 178
      /* 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
179
#ifdef VMS
180
      bufp = compile_pattern (match, 0,
181
			      buffer_defaults.downcase_table, 0, 1);
182 183 184 185 186 187
#else  /* !VMS */
# ifdef WINDOWSNT
      /* Windows users want case-insensitive wildcards.  */
      bufp = compile_pattern (match, 0,
			      buffer_defaults.case_canon_table, 0, 1);
# else	/* !WINDOWSNT */
188
      bufp = compile_pattern (match, 0, Qnil, 0, 1);
189 190
# endif	 /* !WINDOWSNT */
#endif	 /* !VMS */
Richard M. Stallman's avatar
Richard M. Stallman committed
191 192
    }

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

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

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

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

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

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

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

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

242 243 244
      if (dp == NULL)
	break;

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

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

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

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

	  immediate_quit = 0;

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

280
		  fullname = make_uninit_multibyte_string (nbytes, nbytes);
281
		  bcopy (SDATA (directory), SDATA (fullname),
282
			 directory_nbytes);
283

284
		  if (needsep)
285
		    SSET (fullname, directory_nbytes, DIRECTORY_SEP);
286

287 288
		  bcopy (SDATA (name),
			 SDATA (fullname) + directory_nbytes + needsep,
289
			 len);
290

291
		  nchars = chars_in_text (SDATA (fullname), nbytes);
292 293 294 295

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

297
		  STRING_SET_CHARS (fullname, nchars);
298
		  if (nchars == nbytes)
299
		    STRING_SET_UNIBYTE (fullname);
300

301 302
		  finalname = fullname;
		}
303 304
	      else
		finalname = name;
305 306 307 308 309

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

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

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

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

	  UNGCPRO;
Richard M. Stallman's avatar
Richard M. Stallman committed
328 329
	}
    }
330

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

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

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

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


DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
347 348 349 350 351 352 353 354
       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)
355 356 357
     Lisp_Object directory, full, match, nosort;
{
  Lisp_Object handler;
358
  directory = Fexpand_file_name (directory, Qnil);
359 360 361 362 363

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

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

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

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

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

Richard M. Stallman's avatar
Richard M. Stallman committed
399 400 401 402

Lisp_Object file_name_completion ();

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

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

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

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

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

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

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

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

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

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

Andreas Schwab's avatar
Andreas Schwab committed
459
static int file_name_completion_stat ();
460
Lisp_Object Qdefault_directory;
Andreas Schwab's avatar
Andreas Schwab committed
461

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

486 487
  elt = Qnil;

Richard M. Stallman's avatar
Richard M. Stallman committed
488 489 490 491 492 493 494 495 496 497 498 499 500
#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 */
501
  CHECK_STRING (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
502 503
#endif /* not VMS */

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

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

  encoded_dir = ENCODE_FILE (dirname);

523 524 525 526 527
  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
528

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

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

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

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

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

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

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

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

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

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

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

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

651 652 653 654 655 656 657 658
	  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;
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 688 689
	}
      /* 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
690

691 692 693
	  GCPRO1 (name);
	  val = call1 (predicate, name);
	  UNGCPRO;
694

695 696 697
	  if (NILP (val))
	    continue;
	}
698

699
      /* Suitably record this match.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
700

701
      matchcount++;
702

703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
      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)
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 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)
		   && 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
762
	    }
763
	  bestmatchsize = matchsize;
Richard M. Stallman's avatar
Richard M. Stallman committed
764 765 766
	}
    }

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

Jim Blandy's avatar
Jim Blandy committed
771
  if (all_flag || NILP (bestmatch))
772 773
    return bestmatch;
  if (matchcount == 1 && bestmatchsize == SCHARS (file))
Richard M. Stallman's avatar
Richard M. Stallman committed
774
    return Qt;
775 776 777
  bestmatch = Fsubstring (bestmatch, make_number (0),
			  make_number (bestmatchsize));
  return bestmatch;
Richard M. Stallman's avatar
Richard M. Stallman committed
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 806 807
/* 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
808
static int
Richard M. Stallman's avatar
Richard M. Stallman committed
809 810 811 812 813 814
file_name_completion_stat (dirname, dp, st_addr)
     Lisp_Object dirname;
     DIRENTRY *dp;
     struct stat *st_addr;
{
  int len = NAMLEN (dp);
815
  int pos = SCHARS (dirname);
816
  int value;
Richard M. Stallman's avatar
Richard M. Stallman committed
817 818
  char *fullname = (char *) alloca (len + pos + 2);

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

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

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

841
#ifdef S_IFLNK
842 843 844 845 846 847
  /* 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;
848
#else
849 850 851 852 853 854 855 856
  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
857 858
}

859 860 861
#ifdef VMS

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

DEFUN ("file-version-limit", Ffile_version_limit, Sfile_version_limit, 1, 1, 0,
871 872 873
       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)
874 875 876 877 878 879 880 881 882 883 884
     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;
885
  fab.fab$l_fna = SDATA (filename);
886 887 888 889 890 891 892 893 894 895 896 897 898