(scmp): Function moved from minibuf.c.
[bpt/emacs.git] / src / dired.c
1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22
23 #include <config.h>
24
25 #include <stdio.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28
29 #include "systime.h"
30 #include <errno.h>
31
32 #ifdef VMS
33 #include <string.h>
34 #include <rms.h>
35 #include <rmsdef.h>
36 #endif
37
38 #ifdef HAVE_UNISTD_H
39 #include <unistd.h>
40 #endif
41
42 /* The d_nameln member of a struct dirent includes the '\0' character
43 on some systems, but not on others. What's worse, you can't tell
44 at compile-time which one it will be, since it really depends on
45 the sort of system providing the filesystem you're reading from,
46 not the system you are running on. Paul Eggert
47 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
48 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
49 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
50
51 Since applying strlen to the name always works, we'll just do that. */
52 #define NAMLEN(p) strlen (p->d_name)
53
54 #ifdef SYSV_SYSTEM_DIR
55
56 #include <dirent.h>
57 #define DIRENTRY struct dirent
58
59 #else /* not SYSV_SYSTEM_DIR */
60
61 #ifdef NONSYSTEM_DIR_LIBRARY
62 #include "ndir.h"
63 #else /* not NONSYSTEM_DIR_LIBRARY */
64 #ifdef MSDOS
65 #include <dirent.h>
66 #else
67 #include <sys/dir.h>
68 #endif
69 #endif /* not NONSYSTEM_DIR_LIBRARY */
70
71 #include <sys/stat.h>
72
73 #ifndef MSDOS
74 #define DIRENTRY struct direct
75
76 extern DIR *opendir ();
77 extern struct direct *readdir ();
78
79 #endif /* not MSDOS */
80 #endif /* not SYSV_SYSTEM_DIR */
81
82 #ifdef MSDOS
83 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
84 #else
85 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
86 #endif
87
88 #include "lisp.h"
89 #include "buffer.h"
90 #include "commands.h"
91 #include "charset.h"
92 #include "coding.h"
93 #include "regex.h"
94
95 /* Returns a search buffer, with a fastmap allocated and ready to go. */
96 extern struct re_pattern_buffer *compile_pattern ();
97
98 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
99 extern void filemodestring P_ ((struct stat *, char *));
100
101 /* if system does not have symbolic links, it does not have lstat.
102 In that case, use ordinary stat instead. */
103
104 #ifndef S_IFLNK
105 #define lstat stat
106 #endif
107
108 extern int completion_ignore_case;
109 extern Lisp_Object Vcompletion_regexp_list;
110 extern Lisp_Object Vfile_name_coding_system, Vdefault_file_name_coding_system;
111
112 Lisp_Object Vcompletion_ignored_extensions;
113 Lisp_Object Qcompletion_ignore_case;
114 Lisp_Object Qdirectory_files;
115 Lisp_Object Qdirectory_files_and_attributes;
116 Lisp_Object Qfile_name_completion;
117 Lisp_Object Qfile_name_all_completions;
118 Lisp_Object Qfile_attributes;
119 Lisp_Object Qfile_attributes_lessp;
120
121 static int scmp P_ ((unsigned char *, unsigned char *, int));
122 \f
123
124 Lisp_Object
125 directory_files_internal_unwind (dh)
126 Lisp_Object dh;
127 {
128 DIR *d = (DIR *) ((XINT (XCAR (dh)) << 16) + XINT (XCDR (dh)));
129 closedir (d);
130 return Qnil;
131 }
132
133 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
134 When ATTRS is zero, return a list of directory filenames; when
135 non-zero, return a list of directory filenames and their attributes. */
136
137 Lisp_Object
138 directory_files_internal (directory, full, match, nosort, attrs)
139 Lisp_Object directory, full, match, nosort;
140 int attrs;
141 {
142 DIR *d;
143 int directory_nbytes;
144 Lisp_Object list, dirfilename, encoded_directory;
145 struct re_pattern_buffer *bufp = NULL;
146 int needsep = 0;
147 int count = specpdl_ptr - specpdl;
148 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
149 DIRENTRY *dp;
150 int retry_p;
151
152 /* Because of file name handlers, these functions might call
153 Ffuncall, and cause a GC. */
154 list = encoded_directory = dirfilename = Qnil;
155 GCPRO5 (match, directory, list, dirfilename, encoded_directory);
156 directory = Fexpand_file_name (directory, Qnil);
157 dirfilename = Fdirectory_file_name (directory);
158
159 if (!NILP (match))
160 {
161 CHECK_STRING (match);
162
163 /* MATCH might be a flawed regular expression. Rather than
164 catching and signaling our own errors, we just call
165 compile_pattern to do the work for us. */
166 /* Pass 1 for the MULTIBYTE arg
167 because we do make multibyte strings if the contents warrant. */
168 #ifdef VMS
169 bufp = compile_pattern (match, 0,
170 buffer_defaults.downcase_table, 0, 1);
171 #else
172 bufp = compile_pattern (match, 0, Qnil, 0, 1);
173 #endif
174 }
175
176 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
177 run_pre_post_conversion_on_str which calls Lisp directly and
178 indirectly. */
179 dirfilename = ENCODE_FILE (dirfilename);
180 encoded_directory = ENCODE_FILE (directory);
181
182 /* Now *bufp is the compiled form of MATCH; don't call anything
183 which might compile a new regexp until we're done with the loop! */
184
185 /* Do this opendir after anything which might signal an error; if
186 an error is signaled while the directory stream is open, we
187 have to make sure it gets closed, and setting up an
188 unwind_protect to do so would be a pain. */
189 retry:
190
191 d = opendir (XSTRING (dirfilename)->data);
192 if (d == NULL)
193 report_file_error ("Opening directory", Fcons (directory, Qnil));
194
195 /* Unfortunately, we can now invoke expand-file-name and
196 file-attributes on filenames, both of which can throw, so we must
197 do a proper unwind-protect. */
198 record_unwind_protect (directory_files_internal_unwind,
199 Fcons (make_number (((unsigned long) d) >> 16),
200 make_number (((unsigned long) d) & 0xffff)));
201
202 directory_nbytes = STRING_BYTES (XSTRING (directory));
203 re_match_object = Qt;
204
205 /* Decide whether we need to add a directory separator. */
206 #ifndef VMS
207 if (directory_nbytes == 0
208 || !IS_ANY_SEP (XSTRING (directory)->data[directory_nbytes - 1]))
209 needsep = 1;
210 #endif /* not VMS */
211
212 /* Loop reading blocks until EOF or error. */
213 for (;;)
214 {
215 errno = 0;
216 dp = readdir (d);
217
218 #ifdef EAGAIN
219 if (dp == NULL && errno == EAGAIN)
220 continue;
221 #endif
222
223 if (dp == NULL)
224 break;
225
226 if (DIRENTRY_NONEMPTY (dp))
227 {
228 int len;
229 int wanted = 0;
230 Lisp_Object name, finalname;
231 struct gcpro gcpro1, gcpro2;
232
233 len = NAMLEN (dp);
234 name = finalname = make_unibyte_string (dp->d_name, len);
235 GCPRO2 (finalname, name);
236
237 /* Note: ENCODE_FILE can GC; it should protect its argument,
238 though. */
239 name = DECODE_FILE (name);
240 len = STRING_BYTES (XSTRING (name));
241
242 /* Now that we have unwind_protect in place, we might as well
243 allow matching to be interrupted. */
244 immediate_quit = 1;
245 QUIT;
246
247 if (NILP (match)
248 || (0 <= re_search (bufp, XSTRING (name)->data, len, 0, len, 0)))
249 wanted = 1;
250
251 immediate_quit = 0;
252
253 if (wanted)
254 {
255 if (!NILP (full))
256 {
257 Lisp_Object fullname;
258 int nbytes = len + directory_nbytes + needsep;
259 int nchars;
260
261 fullname = make_uninit_multibyte_string (nbytes, nbytes);
262 bcopy (XSTRING (directory)->data, XSTRING (fullname)->data,
263 directory_nbytes);
264
265 if (needsep)
266 XSTRING (fullname)->data[directory_nbytes] = DIRECTORY_SEP;
267
268 bcopy (XSTRING (name)->data,
269 XSTRING (fullname)->data + directory_nbytes + needsep,
270 len);
271
272 nchars = chars_in_text (XSTRING (fullname)->data, nbytes);
273
274 /* Some bug somewhere. */
275 if (nchars > nbytes)
276 abort ();
277
278 XSTRING (fullname)->size = nchars;
279 if (nchars == nbytes)
280 SET_STRING_BYTES (XSTRING (fullname), -1);
281
282 finalname = fullname;
283 }
284 else
285 finalname = name;
286
287 if (attrs)
288 {
289 /* Construct an expanded filename for the directory entry.
290 Use the decoded names for input to Ffile_attributes. */
291 Lisp_Object decoded_fullname, fileattrs;
292 struct gcpro gcpro1, gcpro2;
293
294 decoded_fullname = fileattrs = Qnil;
295 GCPRO2 (decoded_fullname, fileattrs);
296
297 /* Both Fexpand_file_name and Ffile_attributes can GC. */
298 decoded_fullname = Fexpand_file_name (name, directory);
299 fileattrs = Ffile_attributes (decoded_fullname);
300
301 list = Fcons (Fcons (finalname, fileattrs), list);
302 UNGCPRO;
303 }
304 else
305 list = Fcons (finalname, list);
306 }
307
308 UNGCPRO;
309 }
310 }
311
312 retry_p = 0;
313 #ifdef EINTR
314 retry_p |= errno == EINTR;
315 #endif
316
317 closedir (d);
318
319 /* Discard the unwind protect. */
320 specpdl_ptr = specpdl + count;
321
322 if (retry_p)
323 {
324 list = Qnil;
325 goto retry;
326 }
327
328 if (NILP (nosort))
329 list = Fsort (Fnreverse (list),
330 attrs ? Qfile_attributes_lessp : Qstring_lessp);
331
332 RETURN_UNGCPRO (list);
333 }
334
335
336 DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
337 doc: /* Return a list of names of files in DIRECTORY.
338 There are three optional arguments:
339 If FULL is non-nil, return absolute file names. Otherwise return names
340 that are relative to the specified directory.
341 If MATCH is non-nil, mention only file names that match the regexp MATCH.
342 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
343 NOSORT is useful if you plan to sort the result yourself. */)
344 (directory, full, match, nosort)
345 Lisp_Object directory, full, match, nosort;
346 {
347 Lisp_Object handler;
348
349 /* If the file name has special constructs in it,
350 call the corresponding file handler. */
351 handler = Ffind_file_name_handler (directory, Qdirectory_files);
352 if (!NILP (handler))
353 {
354 Lisp_Object args[6];
355
356 args[0] = handler;
357 args[1] = Qdirectory_files;
358 args[2] = directory;
359 args[3] = full;
360 args[4] = match;
361 args[5] = nosort;
362 return Ffuncall (6, args);
363 }
364
365 return directory_files_internal (directory, full, match, nosort, 0);
366 }
367
368 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes,
369 Sdirectory_files_and_attributes, 1, 4, 0,
370 doc: /* Return a list of names of files and their attributes in DIRECTORY.
371 There are three optional arguments:
372 If FULL is non-nil, return absolute file names. Otherwise return names
373 that are relative to the specified directory.
374 If MATCH is non-nil, mention only file names that match the regexp MATCH.
375 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
376 NOSORT is useful if you plan to sort the result yourself. */)
377 (directory, full, match, nosort)
378 Lisp_Object directory, full, match, nosort;
379 {
380 Lisp_Object handler;
381
382 /* If the file name has special constructs in it,
383 call the corresponding file handler. */
384 handler = Ffind_file_name_handler (directory, Qdirectory_files_and_attributes);
385 if (!NILP (handler))
386 {
387 Lisp_Object args[6];
388
389 args[0] = handler;
390 args[1] = Qdirectory_files_and_attributes;
391 args[2] = directory;
392 args[3] = full;
393 args[4] = match;
394 args[5] = nosort;
395 return Ffuncall (6, args);
396 }
397
398 return directory_files_internal (directory, full, match, nosort, 1);
399 }
400
401 \f
402 Lisp_Object file_name_completion ();
403
404 DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
405 2, 2, 0,
406 doc: /* Complete file name FILE in directory DIRECTORY.
407 Returns the longest string
408 common to all file names in DIRECTORY that start with FILE.
409 If there is only one and FILE matches it exactly, returns t.
410 Returns nil if DIR contains no name starting with FILE.
411
412 This function ignores some of the possible completions as
413 determined by the variable `completion-ignored-extensions', which see. */)
414 (file, directory)
415 Lisp_Object file, directory;
416 {
417 Lisp_Object handler;
418
419 /* If the directory name has special constructs in it,
420 call the corresponding file handler. */
421 handler = Ffind_file_name_handler (directory, Qfile_name_completion);
422 if (!NILP (handler))
423 return call3 (handler, Qfile_name_completion, file, directory);
424
425 /* If the file name has special constructs in it,
426 call the corresponding file handler. */
427 handler = Ffind_file_name_handler (file, Qfile_name_completion);
428 if (!NILP (handler))
429 return call3 (handler, Qfile_name_completion, file, directory);
430
431 return file_name_completion (file, directory, 0, 0);
432 }
433
434 DEFUN ("file-name-all-completions", Ffile_name_all_completions,
435 Sfile_name_all_completions, 2, 2, 0,
436 doc: /* Return a list of all completions of file name FILE in directory DIRECTORY.
437 These are all file names in directory DIRECTORY which begin with FILE. */)
438 (file, directory)
439 Lisp_Object file, directory;
440 {
441 Lisp_Object handler;
442
443 /* If the directory name has special constructs in it,
444 call the corresponding file handler. */
445 handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
446 if (!NILP (handler))
447 return call3 (handler, Qfile_name_all_completions, file, directory);
448
449 /* If the file name has special constructs in it,
450 call the corresponding file handler. */
451 handler = Ffind_file_name_handler (file, Qfile_name_all_completions);
452 if (!NILP (handler))
453 return call3 (handler, Qfile_name_all_completions, file, directory);
454
455 return file_name_completion (file, directory, 1, 0);
456 }
457
458 static int file_name_completion_stat ();
459
460 Lisp_Object
461 file_name_completion (file, dirname, all_flag, ver_flag)
462 Lisp_Object file, dirname;
463 int all_flag, ver_flag;
464 {
465 DIR *d;
466 int bestmatchsize = 0, skip;
467 register int compare, matchsize;
468 unsigned char *p1, *p2;
469 int matchcount = 0;
470 Lisp_Object bestmatch, tem, elt, name;
471 Lisp_Object encoded_file;
472 Lisp_Object encoded_dir;
473 struct stat st;
474 int directoryp;
475 int passcount;
476 int count = specpdl_ptr - specpdl;
477 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
478
479 elt = Qnil;
480
481 #ifdef VMS
482 extern DIRENTRY * readdirver ();
483
484 DIRENTRY *((* readfunc) ());
485
486 /* Filename completion on VMS ignores case, since VMS filesys does. */
487 specbind (Qcompletion_ignore_case, Qt);
488
489 readfunc = readdir;
490 if (ver_flag)
491 readfunc = readdirver;
492 file = Fupcase (file);
493 #else /* not VMS */
494 CHECK_STRING (file);
495 #endif /* not VMS */
496
497 #ifdef FILE_SYSTEM_CASE
498 file = FILE_SYSTEM_CASE (file);
499 #endif
500 bestmatch = Qnil;
501 encoded_file = encoded_dir = Qnil;
502 GCPRO5 (file, dirname, bestmatch, encoded_file, encoded_dir);
503 dirname = Fexpand_file_name (dirname, Qnil);
504
505 /* Do completion on the encoded file name
506 because the other names in the directory are (we presume)
507 encoded likewise. We decode the completed string at the end. */
508 encoded_file = ENCODE_FILE (file);
509
510 encoded_dir = ENCODE_FILE (dirname);
511
512 /* With passcount = 0, ignore files that end in an ignored extension.
513 If nothing found then try again with passcount = 1, don't ignore them.
514 If looking for all completions, start with passcount = 1,
515 so always take even the ignored ones.
516
517 ** It would not actually be helpful to the user to ignore any possible
518 completions when making a list of them.** */
519
520 for (passcount = !!all_flag; NILP (bestmatch) && passcount < 2; passcount++)
521 {
522 d = opendir (XSTRING (Fdirectory_file_name (encoded_dir))->data);
523 if (!d)
524 report_file_error ("Opening directory", Fcons (dirname, Qnil));
525
526 /* Loop reading blocks */
527 /* (att3b compiler bug requires do a null comparison this way) */
528 while (1)
529 {
530 DIRENTRY *dp;
531 int len;
532
533 #ifdef VMS
534 dp = (*readfunc) (d);
535 #else
536 dp = readdir (d);
537 #endif
538 if (!dp) break;
539
540 len = NAMLEN (dp);
541
542 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
543 goto quit;
544 if (! DIRENTRY_NONEMPTY (dp)
545 || len < XSTRING (encoded_file)->size
546 || 0 <= scmp (dp->d_name, XSTRING (encoded_file)->data,
547 XSTRING (encoded_file)->size))
548 continue;
549
550 if (file_name_completion_stat (encoded_dir, dp, &st) < 0)
551 continue;
552
553 directoryp = ((st.st_mode & S_IFMT) == S_IFDIR);
554 tem = Qnil;
555 if (directoryp)
556 {
557 #ifndef TRIVIAL_DIRECTORY_ENTRY
558 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
559 #endif
560 /* "." and ".." are never interesting as completions, but are
561 actually in the way in a directory contains only one file. */
562 if (!passcount && TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
563 continue;
564 if (!passcount && len > XSTRING (encoded_file)->size)
565 /* Ignore directories if they match an element of
566 completion-ignored-extensions which ends in a slash. */
567 for (tem = Vcompletion_ignored_extensions;
568 CONSP (tem); tem = XCDR (tem))
569 {
570 int elt_len;
571
572 elt = XCAR (tem);
573 if (!STRINGP (elt))
574 continue;
575 elt_len = XSTRING (elt)->size - 1; /* -1 for trailing / */
576 if (elt_len <= 0)
577 continue;
578 p1 = XSTRING (elt)->data;
579 if (p1[elt_len] != '/')
580 continue;
581 skip = len - elt_len;
582 if (skip < 0)
583 continue;
584
585 if (0 <= scmp (dp->d_name + skip, p1, elt_len))
586 continue;
587 break;
588 }
589 }
590 else
591 {
592 /* Compare extensions-to-be-ignored against end of this file name */
593 /* if name is not an exact match against specified string */
594 if (!passcount && len > XSTRING (encoded_file)->size)
595 /* and exit this for loop if a match is found */
596 for (tem = Vcompletion_ignored_extensions;
597 CONSP (tem); tem = XCDR (tem))
598 {
599 elt = XCAR (tem);
600 if (!STRINGP (elt)) continue;
601 skip = len - XSTRING (elt)->size;
602 if (skip < 0) continue;
603
604 if (0 <= scmp (dp->d_name + skip,
605 XSTRING (elt)->data,
606 XSTRING (elt)->size))
607 continue;
608 break;
609 }
610 }
611
612 /* If an ignored-extensions match was found,
613 don't process this name as a completion. */
614 if (!passcount && CONSP (tem))
615 continue;
616
617 if (!passcount)
618 {
619 Lisp_Object regexps;
620 Lisp_Object zero;
621 XSETFASTINT (zero, 0);
622
623 /* Ignore this element if it fails to match all the regexps. */
624 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
625 regexps = XCDR (regexps))
626 {
627 tem = Fstring_match (XCAR (regexps),
628 make_string (dp->d_name, len), zero);
629 if (NILP (tem))
630 break;
631 }
632 if (CONSP (regexps))
633 continue;
634 }
635
636 /* Update computation of how much all possible completions match */
637
638 matchcount++;
639
640 if (all_flag || NILP (bestmatch))
641 {
642 /* This is a possible completion */
643 if (directoryp)
644 {
645 /* This completion is a directory; make it end with '/' */
646 name = Ffile_name_as_directory (make_string (dp->d_name, len));
647 }
648 else
649 name = make_string (dp->d_name, len);
650 if (all_flag)
651 {
652 name = DECODE_FILE (name);
653 bestmatch = Fcons (name, bestmatch);
654 }
655 else
656 {
657 bestmatch = name;
658 bestmatchsize = XSTRING (name)->size;
659 }
660 }
661 else
662 {
663 compare = min (bestmatchsize, len);
664 p1 = XSTRING (bestmatch)->data;
665 p2 = (unsigned char *) dp->d_name;
666 matchsize = scmp(p1, p2, compare);
667 if (matchsize < 0)
668 matchsize = compare;
669 if (completion_ignore_case)
670 {
671 /* If this is an exact match except for case,
672 use it as the best match rather than one that is not
673 an exact match. This way, we get the case pattern
674 of the actual match. */
675 /* This tests that the current file is an exact match
676 but BESTMATCH is not (it is too long). */
677 if ((matchsize == len
678 && matchsize + !!directoryp
679 < XSTRING (bestmatch)->size)
680 ||
681 /* If there is no exact match ignoring case,
682 prefer a match that does not change the case
683 of the input. */
684 /* If there is more than one exact match aside from
685 case, and one of them is exact including case,
686 prefer that one. */
687 /* This == checks that, of current file and BESTMATCH,
688 either both or neither are exact. */
689 (((matchsize == len)
690 ==
691 (matchsize + !!directoryp
692 == XSTRING (bestmatch)->size))
693 && !bcmp (p2, XSTRING (encoded_file)->data, XSTRING (encoded_file)->size)
694 && bcmp (p1, XSTRING (encoded_file)->data, XSTRING (encoded_file)->size)))
695 {
696 bestmatch = make_string (dp->d_name, len);
697 if (directoryp)
698 bestmatch = Ffile_name_as_directory (bestmatch);
699 }
700 }
701
702 /* If this dirname all matches, see if implicit following
703 slash does too. */
704 if (directoryp
705 && compare == matchsize
706 && bestmatchsize > matchsize
707 && IS_ANY_SEP (p1[matchsize]))
708 matchsize++;
709 bestmatchsize = matchsize;
710 }
711 }
712 closedir (d);
713 }
714
715 UNGCPRO;
716 bestmatch = unbind_to (count, bestmatch);
717
718 if (all_flag || NILP (bestmatch))
719 {
720 if (STRINGP (bestmatch))
721 bestmatch = DECODE_FILE (bestmatch);
722 return bestmatch;
723 }
724 if (matchcount == 1 && bestmatchsize == XSTRING (file)->size)
725 return Qt;
726 bestmatch = Fsubstring (bestmatch, make_number (0),
727 make_number (bestmatchsize));
728 /* Now that we got the right initial segment of BESTMATCH,
729 decode it from the coding system in use. */
730 bestmatch = DECODE_FILE (bestmatch);
731 return bestmatch;
732
733 quit:
734 if (d) closedir (d);
735 Vquit_flag = Qnil;
736 return Fsignal (Qquit, Qnil);
737 }
738
739 /* Compare exactly LEN chars of strings at S1 and S2,
740 ignoring case if appropriate.
741 Return -1 if strings match,
742 else number of chars that match at the beginning. */
743
744 static int
745 scmp (s1, s2, len)
746 register unsigned char *s1, *s2;
747 int len;
748 {
749 register int l = len;
750
751 if (completion_ignore_case)
752 {
753 while (l && DOWNCASE (*s1++) == DOWNCASE (*s2++))
754 l--;
755 }
756 else
757 {
758 while (l && *s1++ == *s2++)
759 l--;
760 }
761 if (l == 0)
762 return -1;
763 else
764 return len - l;
765 }
766
767 static int
768 file_name_completion_stat (dirname, dp, st_addr)
769 Lisp_Object dirname;
770 DIRENTRY *dp;
771 struct stat *st_addr;
772 {
773 int len = NAMLEN (dp);
774 int pos = XSTRING (dirname)->size;
775 int value;
776 char *fullname = (char *) alloca (len + pos + 2);
777
778 #ifdef MSDOS
779 #if __DJGPP__ > 1
780 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
781 but aren't required here. Avoid computing the following fields:
782 st_inode, st_size and st_nlink for directories, and the execute bits
783 in st_mode for non-directory files with non-standard extensions. */
784
785 unsigned short save_djstat_flags = _djstat_flags;
786
787 _djstat_flags = _STAT_INODE | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
788 #endif /* __DJGPP__ > 1 */
789 #endif /* MSDOS */
790
791 bcopy (XSTRING (dirname)->data, fullname, pos);
792 #ifndef VMS
793 if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
794 fullname[pos++] = DIRECTORY_SEP;
795 #endif
796
797 bcopy (dp->d_name, fullname + pos, len);
798 fullname[pos + len] = 0;
799
800 #ifdef S_IFLNK
801 /* We want to return success if a link points to a nonexistent file,
802 but we want to return the status for what the link points to,
803 in case it is a directory. */
804 value = lstat (fullname, st_addr);
805 stat (fullname, st_addr);
806 return value;
807 #else
808 value = stat (fullname, st_addr);
809 #ifdef MSDOS
810 #if __DJGPP__ > 1
811 _djstat_flags = save_djstat_flags;
812 #endif /* __DJGPP__ > 1 */
813 #endif /* MSDOS */
814 return value;
815 #endif /* S_IFLNK */
816 }
817 \f
818 #ifdef VMS
819
820 DEFUN ("file-name-all-versions", Ffile_name_all_versions,
821 Sfile_name_all_versions, 2, 2, 0,
822 doc: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
823 (file, directory)
824 Lisp_Object file, directory;
825 {
826 return file_name_completion (file, directory, 1, 1);
827 }
828
829 DEFUN ("file-version-limit", Ffile_version_limit, Sfile_version_limit, 1, 1, 0,
830 doc: /* Return the maximum number of versions allowed for FILE.
831 Returns nil if the file cannot be opened or if there is no version limit. */)
832 (filename)
833 Lisp_Object filename;
834 {
835 Lisp_Object retval;
836 struct FAB fab;
837 struct RAB rab;
838 struct XABFHC xabfhc;
839 int status;
840
841 filename = Fexpand_file_name (filename, Qnil);
842 fab = cc$rms_fab;
843 xabfhc = cc$rms_xabfhc;
844 fab.fab$l_fna = XSTRING (filename)->data;
845 fab.fab$b_fns = strlen (fab.fab$l_fna);
846 fab.fab$l_xab = (char *) &xabfhc;
847 status = sys$open (&fab, 0, 0);
848 if (status != RMS$_NORMAL) /* Probably non-existent file */
849 return Qnil;
850 sys$close (&fab, 0, 0);
851 if (xabfhc.xab$w_verlimit == 32767)
852 return Qnil; /* No version limit */
853 else
854 return make_number (xabfhc.xab$w_verlimit);
855 }
856
857 #endif /* VMS */
858 \f
859 Lisp_Object
860 make_time (time)
861 time_t time;
862 {
863 return Fcons (make_number (time >> 16),
864 Fcons (make_number (time & 0177777), Qnil));
865 }
866
867 DEFUN ("file-attributes", Ffile_attributes, Sfile_attributes, 1, 1, 0,
868 doc: /* Return a list of attributes of file FILENAME.
869 Value is nil if specified file cannot be opened.
870 Otherwise, list elements are:
871 0. t for directory, string (name linked to) for symbolic link, or nil.
872 1. Number of links to file.
873 2. File uid.
874 3. File gid.
875 4. Last access time, as a list of two integers.
876 First integer has high-order 16 bits of time, second has low 16 bits.
877 5. Last modification time, likewise.
878 6. Last status change time, likewise.
879 7. Size in bytes.
880 This is a floating point number if the size is too large for an integer.
881 8. File modes, as a string of ten letters or dashes as in ls -l.
882 9. t iff file's gid would change if file were deleted and recreated.
883 10. inode number. If inode number is larger than the Emacs integer,
884 this is a cons cell containing two integers: first the high part,
885 then the low 16 bits.
886 11. Device number. If it is larger than the Emacs integer, this is
887 a cons cell, similar to the inode number.
888
889 If file does not exist, returns nil. */)
890 (filename)
891 Lisp_Object filename;
892 {
893 Lisp_Object values[12];
894 Lisp_Object encoded;
895 struct stat s;
896 #if defined (BSD4_2) || defined (BSD4_3)
897 Lisp_Object dirname;
898 struct stat sdir;
899 #endif
900 char modes[10];
901 Lisp_Object handler;
902
903 filename = Fexpand_file_name (filename, Qnil);
904
905 /* If the file name has special constructs in it,
906 call the corresponding file handler. */
907 handler = Ffind_file_name_handler (filename, Qfile_attributes);
908 if (!NILP (handler))
909 return call2 (handler, Qfile_attributes, filename);
910
911 encoded = ENCODE_FILE (filename);
912
913 if (lstat (XSTRING (encoded)->data, &s) < 0)
914 return Qnil;
915
916 switch (s.st_mode & S_IFMT)
917 {
918 default:
919 values[0] = Qnil; break;
920 case S_IFDIR:
921 values[0] = Qt; break;
922 #ifdef S_IFLNK
923 case S_IFLNK:
924 values[0] = Ffile_symlink_p (filename); break;
925 #endif
926 }
927 values[1] = make_number (s.st_nlink);
928 values[2] = make_number (s.st_uid);
929 values[3] = make_number (s.st_gid);
930 values[4] = make_time (s.st_atime);
931 values[5] = make_time (s.st_mtime);
932 values[6] = make_time (s.st_ctime);
933 values[7] = make_number (s.st_size);
934 /* If the size is out of range for an integer, return a float. */
935 if (XINT (values[7]) != s.st_size)
936 values[7] = make_float ((double)s.st_size);
937 filemodestring (&s, modes);
938 values[8] = make_string (modes, 10);
939 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
940 dirname = Ffile_name_directory (filename);
941 if (! NILP (dirname))
942 encoded = ENCODE_FILE (dirname);
943 if (! NILP (dirname) && stat (XSTRING (encoded)->data, &sdir) == 0)
944 values[9] = (sdir.st_gid != s.st_gid) ? Qt : Qnil;
945 else /* if we can't tell, assume worst */
946 values[9] = Qt;
947 #else /* file gid will be egid */
948 values[9] = (s.st_gid != getegid ()) ? Qt : Qnil;
949 #endif /* BSD4_2 (or BSD4_3) */
950 /* Cast -1 to avoid warning if int is not as wide as VALBITS. */
951 if (FIXNUM_OVERFLOW_P (s.st_ino))
952 /* To allow inode numbers larger than VALBITS, separate the bottom
953 16 bits. */
954 values[10] = Fcons (make_number (s.st_ino >> 16),
955 make_number (s.st_ino & 0xffff));
956 else
957 /* But keep the most common cases as integers. */
958 values[10] = make_number (s.st_ino);
959
960 /* Likewise for device. */
961 if (FIXNUM_OVERFLOW_P (s.st_dev))
962 values[11] = Fcons (make_number (s.st_dev >> 16),
963 make_number (s.st_dev & 0xffff));
964 else
965 values[11] = make_number (s.st_dev);
966
967 return Flist (sizeof(values) / sizeof(values[0]), values);
968 }
969
970 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp, Sfile_attributes_lessp, 2, 2, 0,
971 doc: /* Return t if first arg file attributes list is less than second.
972 Comparison is in lexicographic order and case is significant. */)
973 (f1, f2)
974 Lisp_Object f1, f2;
975 {
976 return Fstring_lessp (Fcar (f1), Fcar (f2));
977 }
978 \f
979 void
980 syms_of_dired ()
981 {
982 Qdirectory_files = intern ("directory-files");
983 Qdirectory_files_and_attributes = intern ("directory-files-and-attributes");
984 Qfile_name_completion = intern ("file-name-completion");
985 Qfile_name_all_completions = intern ("file-name-all-completions");
986 Qfile_attributes = intern ("file-attributes");
987 Qfile_attributes_lessp = intern ("file-attributes-lessp");
988
989 staticpro (&Qdirectory_files);
990 staticpro (&Qdirectory_files_and_attributes);
991 staticpro (&Qfile_name_completion);
992 staticpro (&Qfile_name_all_completions);
993 staticpro (&Qfile_attributes);
994 staticpro (&Qfile_attributes_lessp);
995
996 defsubr (&Sdirectory_files);
997 defsubr (&Sdirectory_files_and_attributes);
998 defsubr (&Sfile_name_completion);
999 #ifdef VMS
1000 defsubr (&Sfile_name_all_versions);
1001 defsubr (&Sfile_version_limit);
1002 #endif /* VMS */
1003 defsubr (&Sfile_name_all_completions);
1004 defsubr (&Sfile_attributes);
1005 defsubr (&Sfile_attributes_lessp);
1006
1007 #ifdef VMS
1008 Qcompletion_ignore_case = intern ("completion-ignore-case");
1009 staticpro (&Qcompletion_ignore_case);
1010 #endif /* VMS */
1011
1012 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions,
1013 doc: /* *Completion ignores filenames ending in any string in this list.
1014 Directories are ignored if they match any string in this list which
1015 ends in a slash.
1016 This variable does not affect lists of possible completions,
1017 but does affect the commands that actually do completions. */);
1018 Vcompletion_ignored_extensions = Qnil;
1019 }