dired.c 31.6 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,
3
                 2004, 2005, 2006 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
Karl Heuer's avatar
Karl Heuer committed
9
the Free Software Foundation; either version 2, 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
30
#include <pwd.h>
31 32
#endif
#ifndef VMS
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"
99 100
#include "charset.h"
#include "coding.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
101
#include "regex.h"
YAMAMOTO Mitsuharu's avatar
YAMAMOTO Mitsuharu committed
102
#include "blockinput.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
103

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

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

117
extern int completion_ignore_case;
118
extern Lisp_Object Vcompletion_regexp_list;
119

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	  immediate_quit = 0;

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

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

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

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

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

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

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

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

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

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

313
		  /* Both Fexpand_file_name and Ffile_attributes can GC.  */
314
		  decoded_fullname = Fexpand_file_name (name, directory);
315
		  fileattrs = Ffile_attributes (decoded_fullname, id_format);
316 317

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

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

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

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

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

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


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

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

364
  return directory_files_internal (directory, full, match, nosort, 0, Qnil);
365 366
}

367
DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes,
368
       Sdirectory_files_and_attributes, 1, 5, 0,
369
       doc: /* Return a list of names of files and their attributes in DIRECTORY.
370
There are four optional arguments:
371 372 373 374
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.
375 376 377 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
`file-attributes' for further documentation. */)
     (directory, full, match, nosort, id_format)
     Lisp_Object directory, full, match, nosort, id_format;
380 381
{
  Lisp_Object handler;
382
  directory = Fexpand_file_name (directory, Qnil);
383 384 385 386 387

  /* 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))
388 389
    return call6 (handler, Qdirectory_files_and_attributes,
                  directory, full, match, nosort, id_format);
390

391
  return directory_files_internal (directory, full, match, nosort, 1, id_format);
392 393
}

Richard M. Stallman's avatar
Richard M. Stallman committed
394 395 396 397

Lisp_Object file_name_completion ();

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

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

412
  /* If the directory name has special constructs in it,
413
     call the corresponding file handler.  */
414
  handler = Ffind_file_name_handler (directory, Qfile_name_completion);
415
  if (!NILP (handler))
416
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
417

418 419 420 421
  /* 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))
422
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
423

424
  return file_name_completion (file, directory, 0, 0, predicate);
Richard M. Stallman's avatar
Richard M. Stallman committed
425 426 427
}

DEFUN ("file-name-all-completions", Ffile_name_all_completions,
428 429 430 431
       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)
432
     Lisp_Object file, directory;
Richard M. Stallman's avatar
Richard M. Stallman committed
433
{
434 435
  Lisp_Object handler;

436
  /* If the directory name has special constructs in it,
437
     call the corresponding file handler.  */
438
  handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
439
  if (!NILP (handler))
440
    return call3 (handler, Qfile_name_all_completions, file, directory);
441

442 443 444 445
  /* 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))
446
    return call3 (handler, Qfile_name_all_completions, file, directory);
447

448
  return file_name_completion (file, directory, 1, 0, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
449 450
}

Andreas Schwab's avatar
Andreas Schwab committed
451 452
static int file_name_completion_stat ();

Richard M. Stallman's avatar
Richard M. Stallman committed
453
Lisp_Object
454
file_name_completion (file, dirname, all_flag, ver_flag, predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
455 456
     Lisp_Object file, dirname;
     int all_flag, ver_flag;
457
     Lisp_Object predicate;
Richard M. Stallman's avatar
Richard M. Stallman committed
458 459
{
  DIR *d;
460
  int bestmatchsize = 0, skip;
Richard M. Stallman's avatar
Richard M. Stallman committed
461 462 463
  register int compare, matchsize;
  unsigned char *p1, *p2;
  int matchcount = 0;
464 465 466
  /* 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
467
  Lisp_Object bestmatch, tem, elt, name;
468 469
  Lisp_Object encoded_file;
  Lisp_Object encoded_dir;
Richard M. Stallman's avatar
Richard M. Stallman committed
470 471 472
  struct stat st;
  int directoryp;
  int passcount;
Juanma Barranquero's avatar
Juanma Barranquero committed
473
  int count = SPECPDL_INDEX ();
474
  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
475

476 477
  elt = Qnil;

Richard M. Stallman's avatar
Richard M. Stallman committed
478 479 480 481 482 483 484 485 486 487 488 489 490
#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 */
491
  CHECK_STRING (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
492 493
#endif /* not VMS */

494 495 496
#ifdef FILE_SYSTEM_CASE
  file = FILE_SYSTEM_CASE (file);
#endif
Richard M. Stallman's avatar
Richard M. Stallman committed
497
  bestmatch = Qnil;
498 499
  encoded_file = encoded_dir = Qnil;
  GCPRO5 (file, dirname, bestmatch, encoded_file, encoded_dir);
500
  dirname = Fexpand_file_name (dirname, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
501

502 503 504 505 506 507 508
  /* 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.  */
  encoded_file = ENCODE_FILE (file);

  encoded_dir = ENCODE_FILE (dirname);

Richard M. Stallman's avatar
Richard M. Stallman committed
509 510 511 512 513 514 515 516
  /* With passcount = 0, ignore files that end in an ignored extension.
     If nothing found then try again with passcount = 1, don't ignore them.
     If looking for all completions, start with passcount = 1,
     so always take even the ignored ones.

     ** It would not actually be helpful to the user to ignore any possible
     completions when making a list of them.**  */

Jim Blandy's avatar
Jim Blandy committed
517
  for (passcount = !!all_flag; NILP (bestmatch) && passcount < 2; passcount++)
Richard M. Stallman's avatar
Richard M. Stallman committed
518
    {
519 520
      int inner_count = SPECPDL_INDEX ();

521
      BLOCK_INPUT;
522
      d = opendir (SDATA (Fdirectory_file_name (encoded_dir)));
523
      UNBLOCK_INPUT;
524
      if (!d)
Richard M. Stallman's avatar
Richard M. Stallman committed
525 526
	report_file_error ("Opening directory", Fcons (dirname, Qnil));

527
      record_unwind_protect (directory_files_internal_unwind,
528
                             make_save_value (d, 0));
529

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

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

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

	  len = NAMLEN (dp);

557
	  QUIT;
558
	  if (! DIRENTRY_NONEMPTY (dp)
559 560 561
	      || len < SCHARS (encoded_file)
	      || 0 <= scmp (dp->d_name, SDATA (encoded_file),
			    SCHARS (encoded_file)))
Richard M. Stallman's avatar
Richard M. Stallman committed
562 563
	    continue;

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

          directoryp = ((st.st_mode & S_IFMT) == S_IFDIR);
	  tem = Qnil;
569 570 571 572 573
          if (directoryp)
	    {
#ifndef TRIVIAL_DIRECTORY_ENTRY
#define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
#endif
574 575
	      /* "." and ".." are never interesting as completions, and are
		 actually in the way in a directory with only one file.  */
576 577
	      if (!passcount && TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
		continue;
578
	      if (!passcount && len > SCHARS (encoded_file))
579 580 581 582 583 584 585 586 587 588
		/* 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;

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

		    if (0 <= scmp (dp->d_name + skip,
625 626
				   SDATA (elt),
				   SCHARS (elt)))
Richard M. Stallman's avatar
Richard M. Stallman committed
627 628 629 630 631
		      continue;
		    break;
		  }
	    }

632 633 634 635 636 637
	  /* If an ignored-extensions match was found,
	     don't process this name as a completion.  */
	  if (!passcount && CONSP (tem))
	    continue;

	  if (!passcount)
Richard M. Stallman's avatar
Richard M. Stallman committed
638
	    {
639 640
	      Lisp_Object regexps;
	      Lisp_Object zero;
641
	      XSETFASTINT (zero, 0);
642 643 644

	      /* Ignore this element if it fails to match all the regexps.  */
	      for (regexps = Vcompletion_regexp_list; CONSP (regexps);
645
		   regexps = XCDR (regexps))
646
		{
647 648
		  tem = Fstring_match (XCAR (regexps),
				       make_string (dp->d_name, len), zero);
649 650 651 652 653 654
		  if (NILP (tem))
		    break;
		}
	      if (CONSP (regexps))
		continue;
	    }
Richard M. Stallman's avatar
Richard M. Stallman committed
655

656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
	  /* This is a possible completion */
	  if (directoryp)
	    {
	      /* This completion is a directory; make it end with '/' */
	      name = Ffile_name_as_directory (make_string (dp->d_name, len));
	    }
	  else
	    name = make_string (dp->d_name, len);

	  /* Test the predicate, if any.  */

	  if (!NILP (predicate))
	    {
	      Lisp_Object decoded;
	      decoded = Fexpand_file_name (DECODE_FILE (name), dirname);
	      if (NILP (call1 (predicate, decoded)))
		continue;
	    }

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

677 678
	  matchcount++;

679
	  if (all_flag)
680
	    {
681 682 683 684 685 686 687
	      name = DECODE_FILE (name);
	      bestmatch = Fcons (name, bestmatch);
	    }
	  else if (NILP (bestmatch))
	    {
	      bestmatch = name;
	      bestmatchsize = SCHARS (name);
688 689 690 691
	    }
	  else
	    {
	      compare = min (bestmatchsize, len);
692
	      p1 = SDATA (bestmatch);
693 694 695 696 697 698 699 700 701 702
	      p2 = (unsigned char *) dp->d_name;
	      matchsize = scmp(p1, p2, compare);
	      if (matchsize < 0)
		matchsize = compare;
	      if (completion_ignore_case)
		{
		  /* 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.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
703 704
		  /* This tests that the current file is an exact match
		     but BESTMATCH is not (it is too long).  */
705
		  if ((matchsize == len
706
		       && matchsize + !!directoryp
707
			  < SCHARS (bestmatch))
708 709 710 711
		      ||
		      /* If there is no exact match ignoring case,
			 prefer a match that does not change the case
			 of the input.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
712 713 714 715 716
		      /* 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.  */
717 718
		      (((matchsize == len)
			==
719
			(matchsize + !!directoryp
720 721 722
			 == SCHARS (bestmatch)))
		       && !bcmp (p2, SDATA (encoded_file), SCHARS (encoded_file))
		       && bcmp (p1, SDATA (encoded_file), SCHARS (encoded_file))))
723
		    bestmatch = name;
Richard M. Stallman's avatar
Richard M. Stallman committed
724
		}
725 726 727 728 729 730

	      /* If this dirname all matches, see if implicit following
		 slash does too.  */
	      if (directoryp
		  && compare == matchsize
		  && bestmatchsize > matchsize
731
		  && IS_ANY_SEP (p1[matchsize]))
732 733
		matchsize++;
	      bestmatchsize = matchsize;
Richard M. Stallman's avatar
Richard M. Stallman committed
734 735
	    }
	}
736 737
      /* This closes the directory.  */
      bestmatch = unbind_to (inner_count, bestmatch);
Richard M. Stallman's avatar
Richard M. Stallman committed
738 739
    }

740
  UNGCPRO;
741
  bestmatch = unbind_to (count, bestmatch);
Richard M. Stallman's avatar
Richard M. Stallman committed
742

Jim Blandy's avatar
Jim Blandy committed
743
  if (all_flag || NILP (bestmatch))
744
    {
745 746
      if (STRINGP (bestmatch))
	bestmatch = DECODE_FILE (bestmatch);
747 748
      return bestmatch;
    }
749
  if (matchcount == 1 && bestmatchsize == SCHARS (file))
Richard M. Stallman's avatar
Richard M. Stallman committed
750
    return Qt;
751 752 753 754
  bestmatch = Fsubstring (bestmatch, make_number (0),
			  make_number (bestmatchsize));
  /* Now that we got the right initial segment of BESTMATCH,
     decode it from the coding system in use.  */
755
  bestmatch = DECODE_FILE (bestmatch);
756
  return bestmatch;
Richard M. Stallman's avatar
Richard M. Stallman committed
757 758
}

759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
/* 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
787
static int
Richard M. Stallman's avatar
Richard M. Stallman committed
788 789 790 791 792 793
file_name_completion_stat (dirname, dp, st_addr)
     Lisp_Object dirname;
     DIRENTRY *dp;
     struct stat *st_addr;
{
  int len = NAMLEN (dp);
794
  int pos = SCHARS (dirname);
795
  int value;
Richard M. Stallman's avatar
Richard M. Stallman committed
796 797
  char *fullname = (char *) alloca (len + pos + 2);

798 799 800 801 802 803 804 805 806 807 808 809 810
#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 */

811
  bcopy (SDATA (dirname), fullname, pos);
Richard M. Stallman's avatar
Richard M. Stallman committed
812
#ifndef VMS
813 814
  if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
    fullname[pos++] = DIRECTORY_SEP;
Richard M. Stallman's avatar
Richard M. Stallman committed
815 816 817 818 819
#endif

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

820
#ifdef S_IFLNK
821 822 823 824 825 826
  /* 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;
827
#else
828 829 830 831 832 833 834 835
  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
836 837
}

838 839 840
#ifdef VMS

DEFUN ("file-name-all-versions", Ffile_name_all_versions,
841 842 843
       Sfile_name_all_versions, 2, 2, 0,
       doc: /* Return a list of all versions of file name FILE in directory DIRECTORY.  */)
     (file, directory)
844
     Lisp_Object file, directory;
845
{
846
  return file_name_completion (file, directory, 1, 1, Qnil);
847 848 849
}

DEFUN ("file-version-limit", Ffile_version_limit, Sfile_version_limit, 1, 1, 0,
850 851 852
       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)
853 854 855 856 857 858 859 860 861 862 863
     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;
864
  fab.fab$l_fna = SDATA (filename);
865 866 867 868 869 870 871 872 873 874 875 876 877 878
  fab.fab$b_fns = strlen (fab.fab$l_fna);
  fab.fab$l_xab = (char *) &xabfhc;
  status = sys$open (&fab, 0, 0);
  if (status != RMS$_NORMAL)	/* Probably non-existent file */
    return Qnil;
  sys$close (&fab, 0, 0);
  if (xabfhc.xab$w_verlimit == 32767)
    return Qnil;		/* No version limit */
  else
    return make_number (xabfhc.xab$w_verlimit);
}

#endif /* VMS */

Richard M. Stallman's avatar
Richard M. Stallman committed
879 880
Lisp_Object
make_time (time)
881
     time_t time;
Richard M. Stallman's avatar
Richard M. Stallman committed
882 883 884 885 886
{
  return Fcons (make_number (time >> 16),
		Fcons (make_number (time & 0177777), Qnil));
}

887