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

This file is part of GNU Emacs.

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

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

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


21 22
#include <config.h>

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

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

32
#include <errno.h>
33

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

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

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

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

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

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

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

63 64
#include <sys/stat.h>

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

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

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

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

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

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

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

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

#ifndef S_IFLNK
#define lstat stat
#endif

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

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

static int scmp P_ ((unsigned char *, unsigned char *, int));
Richard M. Stallman's avatar
Richard M. Stallman committed
117

118 119 120 121 122

Lisp_Object
directory_files_internal_unwind (dh)
     Lisp_Object dh;
{
123
  DIR *d = (DIR *) XSAVE_VALUE (dh)->pointer;
124
  BLOCK_INPUT;
125
  closedir (d);
126
  UNBLOCK_INPUT;
127 128 129
  return Qnil;
}

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

135
Lisp_Object
Kenichi Handa's avatar
Kenichi Handa committed
136
directory_files_internal (directory, full, match, nosort, attrs, id_format)
137
     Lisp_Object directory, full, match, nosort;
138
     int attrs;
Kenichi Handa's avatar
Kenichi Handa committed
139
     Lisp_Object id_format;
Richard M. Stallman's avatar
Richard M. Stallman committed
140 141
{
  DIR *d;
142 143
  int directory_nbytes;
  Lisp_Object list, dirfilename, encoded_directory;
144
  struct re_pattern_buffer *bufp = NULL;
145
  int needsep = 0;
Juanma Barranquero's avatar
Juanma Barranquero committed
146
  int count = SPECPDL_INDEX ();
147
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
148
  DIRENTRY *dp;
149

150
  /* Because of file name handlers, these functions might call
151
     Ffuncall, and cause a GC.  */
152 153
  list = encoded_directory = dirfilename = Qnil;
  GCPRO5 (match, directory, list, dirfilename, encoded_directory);
154
  dirfilename = Fdirectory_file_name (directory);
155

Jim Blandy's avatar
Jim Blandy committed
156
  if (!NILP (match))
Richard M. Stallman's avatar
Richard M. Stallman committed
157
    {
158
      CHECK_STRING (match);
Jim Blandy's avatar
Jim Blandy committed
159 160

      /* MATCH might be a flawed regular expression.  Rather than
Karl Heuer's avatar
Karl Heuer committed
161
	 catching and signaling our own errors, we just call
Jim Blandy's avatar
Jim Blandy committed
162
	 compile_pattern to do the work for us.  */
163 164
      /* Pass 1 for the MULTIBYTE arg
	 because we do make multibyte strings if the contents warrant.  */
165 166 167 168 169
# ifdef WINDOWSNT
      /* Windows users want case-insensitive wildcards.  */
      bufp = compile_pattern (match, 0,
			      buffer_defaults.case_canon_table, 0, 1);
# else	/* !WINDOWSNT */
170
      bufp = compile_pattern (match, 0, Qnil, 0, 1);
171
# endif	 /* !WINDOWSNT */
Richard M. Stallman's avatar
Richard M. Stallman committed
172 173
    }

174
  /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
175 176
     run_pre_post_conversion_on_str which calls Lisp directly and
     indirectly.  */
177 178 179 180
  if (STRING_MULTIBYTE (dirfilename))
    dirfilename = ENCODE_FILE (dirfilename);
  encoded_directory = (STRING_MULTIBYTE (directory)
		       ? ENCODE_FILE (directory) : directory);
181

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

185
  BLOCK_INPUT;
186
  d = opendir (SDATA (dirfilename));
187
  UNBLOCK_INPUT;
188
  if (d == NULL)
189
    report_file_error ("Opening directory", Fcons (directory, Qnil));
Richard M. Stallman's avatar
Richard M. Stallman committed
190

191 192 193 194
  /* 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,
195
			 make_save_value (d, 0));
196

197
  directory_nbytes = SBYTES (directory);
198
  re_match_object = Qt;
Richard M. Stallman's avatar
Richard M. Stallman committed
199

200
  /* Decide whether we need to add a directory separator.  */
201
  if (directory_nbytes == 0
202
      || !IS_ANY_SEP (SREF (directory, directory_nbytes - 1)))
203 204
    needsep = 1;

205
  /* Loop reading blocks until EOF or error.  */
206
  for (;;)
Richard M. Stallman's avatar
Richard M. Stallman committed
207
    {
208 209 210
      errno = 0;
      dp = readdir (d);

211
      if (dp == NULL && (0
212
#ifdef EAGAIN
213 214 215 216
			 || errno == EAGAIN
#endif
#ifdef EINTR
			 || errno == EINTR
217
#endif
218 219
			 ))
	{ QUIT; continue; }
220

221 222 223
      if (dp == NULL)
	break;

224
      if (DIRENTRY_NONEMPTY (dp))
Richard M. Stallman's avatar
Richard M. Stallman committed
225
	{
226
	  int len;
227
	  int wanted = 0;
228 229
	  Lisp_Object name, finalname;
	  struct gcpro gcpro1, gcpro2;
230 231

	  len = NAMLEN (dp);
232
	  name = finalname = make_unibyte_string (dp->d_name, len);
233
	  GCPRO2 (finalname, name);
234

235
	  /* Note: DECODE_FILE can GC; it should protect its argument,
236 237
	     though.  */
	  name = DECODE_FILE (name);
238
	  len = SBYTES (name);
239

240 241 242 243 244
	  /* 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
245
	  if (NILP (match)
246
	      || (0 <= re_search (bufp, SDATA (name), len, 0, len, 0)))
247
	    wanted = 1;
248 249 250 251

	  immediate_quit = 0;

	  if (wanted)
Richard M. Stallman's avatar
Richard M. Stallman committed
252
	    {
Jim Blandy's avatar
Jim Blandy committed
253
	      if (!NILP (full))
Richard M. Stallman's avatar
Richard M. Stallman committed
254
		{
255
		  Lisp_Object fullname;
256 257
		  int nbytes = len + directory_nbytes + needsep;
		  int nchars;
258

259
		  fullname = make_uninit_multibyte_string (nbytes, nbytes);
260
		  bcopy (SDATA (directory), SDATA (fullname),
261
			 directory_nbytes);
262

263
		  if (needsep)
264
		    SSET (fullname, directory_nbytes, DIRECTORY_SEP);
265

266 267
		  bcopy (SDATA (name),
			 SDATA (fullname) + directory_nbytes + needsep,
268
			 len);
269

270
		  nchars = chars_in_text (SDATA (fullname), nbytes);
271 272 273 274

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

276
		  STRING_SET_CHARS (fullname, nchars);
277
		  if (nchars == nbytes)
278
		    STRING_SET_UNIBYTE (fullname);
279

280 281
		  finalname = fullname;
		}
282 283
	      else
		finalname = name;
284 285 286 287 288

	      if (attrs)
		{
		  /* Construct an expanded filename for the directory entry.
		     Use the decoded names for input to Ffile_attributes.  */
289 290 291 292 293
		  Lisp_Object decoded_fullname, fileattrs;
		  struct gcpro gcpro1, gcpro2;

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

295
		  /* Both Fexpand_file_name and Ffile_attributes can GC.  */
296
		  decoded_fullname = Fexpand_file_name (name, directory);
Kenichi Handa's avatar
Kenichi Handa committed
297
		  fileattrs = Ffile_attributes (decoded_fullname, id_format);
298 299

		  list = Fcons (Fcons (finalname, fileattrs), list);
300
		  UNGCPRO;
301 302
		}
	      else
303
		list = Fcons (finalname, list);
Richard M. Stallman's avatar
Richard M. Stallman committed
304
	    }
305 306

	  UNGCPRO;
Richard M. Stallman's avatar
Richard M. Stallman committed
307 308
	}
    }
309

310
  BLOCK_INPUT;
Richard M. Stallman's avatar
Richard M. Stallman committed
311
  closedir (d);
312
  UNBLOCK_INPUT;
313 314 315 316

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

317 318 319
  if (NILP (nosort))
    list = Fsort (Fnreverse (list),
		  attrs ? Qfile_attributes_lessp : Qstring_lessp);
320

321
  RETURN_UNGCPRO (list);
Richard M. Stallman's avatar
Richard M. Stallman committed
322
}
323 324 325


DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
326 327 328 329 330 331
       doc: /* Return a list of names of files in DIRECTORY.
There are three optional arguments:
If FULL is non-nil, return absolute file names.  Otherwise return names
 that are relative to the specified directory.
If MATCH is non-nil, mention only file names that match the regexp MATCH.
If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
Chong Yidong's avatar
Chong Yidong committed
332 333
  Otherwise, the list returned is sorted with `stringp-lessp'.
  NOSORT is useful if you plan to sort the result yourself.  */)
334
     (directory, full, match, nosort)
335 336 337
     Lisp_Object directory, full, match, nosort;
{
  Lisp_Object handler;
338
  directory = Fexpand_file_name (directory, Qnil);
339 340 341 342 343

  /* 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
344 345
    return call5 (handler, Qdirectory_files, directory,
                  full, match, nosort);
346

Kenichi Handa's avatar
Kenichi Handa committed
347
  return directory_files_internal (directory, full, match, nosort, 0, Qnil);
348 349
}

350
DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes,
Kenichi Handa's avatar
Kenichi Handa committed
351
       Sdirectory_files_and_attributes, 1, 5, 0,
352
       doc: /* Return a list of names of files and their attributes in DIRECTORY.
Kenichi Handa's avatar
Kenichi Handa committed
353
There are four optional arguments:
354 355 356 357
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
358 359
 NOSORT is useful if you plan to sort the result yourself.
ID-FORMAT specifies the preferred format of attributes uid and gid, see
360 361 362
`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
363 364
     (directory, full, match, nosort, id_format)
     Lisp_Object directory, full, match, nosort, id_format;
365 366
{
  Lisp_Object handler;
367
  directory = Fexpand_file_name (directory, Qnil);
368 369 370 371 372

  /* 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
373 374
    return call6 (handler, Qdirectory_files_and_attributes,
                  directory, full, match, nosort, id_format);
375

Kenichi Handa's avatar
Kenichi Handa committed
376
  return directory_files_internal (directory, full, match, nosort, 1, id_format);
377 378
}

Richard M. Stallman's avatar
Richard M. Stallman committed
379 380 381 382

Lisp_Object file_name_completion ();

DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
383
       2, 3, 0,
384 385 386 387
       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.
388
Returns nil if DIRECTORY contains no name starting with FILE.
389

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

393 394
This function ignores some of the possible completions as
determined by the variable `completion-ignored-extensions', which see.  */)
395 396
     (file, directory, predicate)
     Lisp_Object file, directory, predicate;
Richard M. Stallman's avatar
Richard M. Stallman committed
397
{
398 399
  Lisp_Object handler;

400
  /* If the directory name has special constructs in it,
401
     call the corresponding file handler.  */
402
  handler = Ffind_file_name_handler (directory, Qfile_name_completion);
403
  if (!NILP (handler))
404
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
405

406 407 408 409
  /* 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))
410
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
411

412
  return file_name_completion (file, directory, 0, 0, predicate);
Richard M. Stallman's avatar
Richard M. Stallman committed
413 414 415
}

DEFUN ("file-name-all-completions", Ffile_name_all_completions,
416 417 418 419
       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)
420
     Lisp_Object file, directory;
Richard M. Stallman's avatar
Richard M. Stallman committed
421
{
422 423
  Lisp_Object handler;

424
  /* If the directory name has special constructs in it,
425
     call the corresponding file handler.  */
426
  handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
427
  if (!NILP (handler))
428
    return call3 (handler, Qfile_name_all_completions, file, directory);
429

430 431 432 433
  /* 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))
434
    return call3 (handler, Qfile_name_all_completions, file, directory);
435

436
  return file_name_completion (file, directory, 1, 0, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
437 438
}

Andreas Schwab's avatar
Andreas Schwab committed
439
static int file_name_completion_stat ();
440
Lisp_Object Qdefault_directory;
Andreas Schwab's avatar
Andreas Schwab committed
441

Richard M. Stallman's avatar
Richard M. Stallman committed
442
Lisp_Object
443
file_name_completion (file, dirname, all_flag, ver_flag, predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
444 445
     Lisp_Object file, dirname;
     int all_flag, ver_flag;
446
     Lisp_Object predicate;
Richard M. Stallman's avatar
Richard M. Stallman committed
447 448
{
  DIR *d;
449
  int bestmatchsize = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
450
  int matchcount = 0;
451 452 453
  /* 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
454
  Lisp_Object bestmatch, tem, elt, name;
455 456
  Lisp_Object encoded_file;
  Lisp_Object encoded_dir;
Richard M. Stallman's avatar
Richard M. Stallman committed
457 458
  struct stat st;
  int directoryp;
459 460 461 462
  /* 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
463
  int count = SPECPDL_INDEX ();
464
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
465

466 467
  elt = Qnil;

468
  CHECK_STRING (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
469

470 471 472
#ifdef FILE_SYSTEM_CASE
  file = FILE_SYSTEM_CASE (file);
#endif
Richard M. Stallman's avatar
Richard M. Stallman committed
473
  bestmatch = Qnil;
474 475
  encoded_file = encoded_dir = Qnil;
  GCPRO5 (file, dirname, bestmatch, encoded_file, encoded_dir);
476
  dirname = Fexpand_file_name (dirname, Qnil);
477
  specbind (Qdefault_directory, dirname);
Richard M. Stallman's avatar
Richard M. Stallman committed
478

479 480 481
  /* 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.  */
482 483 484
  /* 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.  */
485
  encoded_file = STRING_MULTIBYTE (file) ? ENCODE_FILE (file) : file;
486 487 488

  encoded_dir = ENCODE_FILE (dirname);

489 490 491 492 493
  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
494

495 496
  record_unwind_protect (directory_files_internal_unwind,
			 make_save_value (d, 0));
Richard M. Stallman's avatar
Richard M. Stallman committed
497

498 499 500
  /* Loop reading blocks */
  /* (att3b compiler bug requires do a null comparison this way) */
  while (1)
Richard M. Stallman's avatar
Richard M. Stallman committed
501
    {
502 503 504
      DIRENTRY *dp;
      int len;
      int canexclude = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
505

506 507 508
      errno = 0;
      dp = readdir (d);
      if (dp == NULL && (0
509
# ifdef EAGAIN
510
			 || errno == EAGAIN
511 512
# endif
# ifdef EINTR
513
			 || errno == EINTR
514
# endif
515 516
			 ))
	{ QUIT; continue; }
517

518
      if (!dp) break;
Richard M. Stallman's avatar
Richard M. Stallman committed
519

520
      len = NAMLEN (dp);
Richard M. Stallman's avatar
Richard M. Stallman committed
521

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

529 530
      if (file_name_completion_stat (encoded_dir, dp, &st) < 0)
	continue;
Richard M. Stallman's avatar
Richard M. Stallman committed
531

532 533 534 535 536 537 538 539
      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;
540 541 542 543 544 545 546 547 548 549 550 551

	  /* 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;

552
	  if (directoryp)
553 554 555 556
	    {
#ifndef TRIVIAL_DIRECTORY_ENTRY
#define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
#endif
557 558
	      /* "." and ".." are never interesting as completions, and are
		 actually in the way in a directory with only one file.  */
559 560 561
	      if (TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
		canexclude = 1;
	      else if (len > SCHARS (encoded_file))
562 563 564 565 566 567
		/* 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;
568
		    unsigned char *p1;
569 570 571 572

		    elt = XCAR (tem);
		    if (!STRINGP (elt))
		      continue;
573 574 575
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
576
		    elt_len = SCHARS (elt) - 1; /* -1 for trailing / */
577
		    if (elt_len <= 0)
578
		      continue;
579
		    p1 = SDATA (elt);
580 581 582 583 584 585 586 587 588 589
		    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;
		  }
590 591
	    }
	  else
592
	    {
Richard M. Stallman's avatar
Richard M. Stallman committed
593 594
	      /* Compare extensions-to-be-ignored against end of this file name */
	      /* if name is not an exact match against specified string */
595
	      if (len > SCHARS (encoded_file))
Richard M. Stallman's avatar
Richard M. Stallman committed
596 597
		/* and exit this for loop if a match is found */
		for (tem = Vcompletion_ignored_extensions;
598
		     CONSP (tem); tem = XCDR (tem))
Richard M. Stallman's avatar
Richard M. Stallman committed
599
		  {
600
		    elt = XCAR (tem);
601
		    if (!STRINGP (elt)) continue;
602 603 604
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
605
		    skip = len - SCHARS (elt);
Richard M. Stallman's avatar
Richard M. Stallman committed
606 607 608
		    if (skip < 0) continue;

		    if (0 <= scmp (dp->d_name + skip,
609 610
				   SDATA (elt),
				   SCHARS (elt)))
Richard M. Stallman's avatar
Richard M. Stallman committed
611 612 613 614 615
		      continue;
		    break;
		  }
	    }

616 617
	  /* If an ignored-extensions match was found,
	     don't process this name as a completion.  */
618 619
	  if (CONSP (tem))
	    canexclude = 1;
620

621 622 623
	  if (!includeall && canexclude)
	    /* We're not including all files and this file can be excluded.  */
	    continue;
624

625 626 627 628 629 630 631 632
	  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;
633
	    }
634 635 636 637 638 639 640 641 642 643 644 645
	}
      /* 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.  */
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
	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;
	  }

661 662 663 664 665 666 667 668 669 670 671 672 673 674
	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
675

676 677 678
	  GCPRO1 (name);
	  val = call1 (predicate, name);
	  UNGCPRO;
679

680 681 682
	  if (NILP (val))
	    continue;
	}
683

684
      /* Suitably record this match.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
685

686
      matchcount++;
687

688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711
      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)
712
	    {
713 714 715 716 717 718 719
	      /* 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)
720
		   && matchsize + !!directoryp < SCHARS (bestmatch))
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
		  ||
		  /* 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
746
	    }
747
	  bestmatchsize = matchsize;
748 749 750 751 752 753 754 755 756 757 758 759 760 761

	  /* 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
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
    return bestmatch;
771 772 773
  /* 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
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);
833 834
  if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
    fullname[pos++] = DIRECTORY_SEP;
Richard M. Stallman's avatar
Richard M. Stallman committed
835 836 837 838

  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
}

Lisp_Object
make_time (time)
859
     time_t time;
Richard M. Stallman's avatar
Richard M. Stallman committed
860 861 862 863 864
{
  return Fcons (make_number (time >> 16),
		Fcons (make_number (time & 0177777), Qnil));
}

865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
static char *
stat_uname (struct stat *st)
{
#ifdef WINDOWSNT
  return st->st_uname;
#else
  struct passwd *pw = (struct passwd *) getpwuid (st->st_uid);

  if (pw)
    return pw->pw_name;
  else
    return NULL;
#endif
}

static char *
stat_gname (struct stat *st)
{
#ifdef WINDOWSNT
  return st->st_gname;
#else
  struct group *gr = (struct group *) getgrgid (st->st_gid);

  if (gr)
    return gr->gr_name;
  else
    return NULL;
#endif
}

Kenichi Handa's avatar
Kenichi Handa committed
895
DEFUN ("file-attributes", Ffile_attributes, Sfile_attributes, 1, 2, 0,
896 897
       doc: /* Return a list of attributes of file FILENAME.
Value is nil if specified file cannot be opened.
Kenichi Handa's avatar
Kenichi Handa committed
898 899 900 901 902 903 904

ID-FORMAT specifies the preferred format of