1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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)
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.
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. */
26 #include <sys/types.h>
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.
51 Since applying strlen to the name always works, we'll just do that. */
52 #define NAMLEN(p) strlen (p->d_name)
54 #ifdef SYSV_SYSTEM_DIR
57 #define DIRENTRY struct dirent
59 #else /* not SYSV_SYSTEM_DIR */
61 #ifdef NONSYSTEM_DIR_LIBRARY
63 #else /* not NONSYSTEM_DIR_LIBRARY */
69 #endif /* not NONSYSTEM_DIR_LIBRARY */
74 #define DIRENTRY struct direct
76 extern DIR *opendir ();
77 extern struct direct
*readdir ();
79 #endif /* not MSDOS */
80 #endif /* not SYSV_SYSTEM_DIR */
83 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
85 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
91 #include "character.h"
96 /* Returns a search buffer, with a fastmap allocated and ready to go. */
97 extern struct re_pattern_buffer
*compile_pattern ();
99 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
100 extern void filemodestring
P_ ((struct stat
*, char *));
102 /* if system does not have symbolic links, it does not have lstat.
103 In that case, use ordinary stat instead. */
109 extern int completion_ignore_case
;
110 extern Lisp_Object Vcompletion_regexp_list
;
111 extern Lisp_Object Vfile_name_coding_system
, Vdefault_file_name_coding_system
;
113 Lisp_Object Vcompletion_ignored_extensions
;
114 Lisp_Object Qcompletion_ignore_case
;
115 Lisp_Object Qdirectory_files
;
116 Lisp_Object Qdirectory_files_and_attributes
;
117 Lisp_Object Qfile_name_completion
;
118 Lisp_Object Qfile_name_all_completions
;
119 Lisp_Object Qfile_attributes
;
120 Lisp_Object Qfile_attributes_lessp
;
122 static int scmp
P_ ((unsigned char *, unsigned char *, int));
126 directory_files_internal_unwind (dh
)
129 DIR *d
= (DIR *) ((XINT (XCAR (dh
)) << 16) + XINT (XCDR (dh
)));
134 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
135 When ATTRS is zero, return a list of directory filenames; when
136 non-zero, return a list of directory filenames and their attributes. */
139 directory_files_internal (directory
, full
, match
, nosort
, attrs
)
140 Lisp_Object directory
, full
, match
, nosort
;
144 int directory_nbytes
;
145 Lisp_Object list
, dirfilename
, encoded_directory
;
146 struct re_pattern_buffer
*bufp
= NULL
;
148 int count
= SPECPDL_INDEX ();
149 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
153 /* Because of file name handlers, these functions might call
154 Ffuncall, and cause a GC. */
155 list
= encoded_directory
= dirfilename
= Qnil
;
156 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
157 dirfilename
= Fdirectory_file_name (directory
);
161 CHECK_STRING (match
);
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. */
169 bufp
= compile_pattern (match
, 0,
170 buffer_defaults
.downcase_table
, 0, 1);
172 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
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
179 dirfilename
= ENCODE_FILE (dirfilename
);
180 encoded_directory
= ENCODE_FILE (directory
);
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! */
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. */
191 d
= opendir (SDATA (dirfilename
));
193 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
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)));
202 directory_nbytes
= SBYTES (directory
);
203 re_match_object
= Qt
;
205 /* Decide whether we need to add a directory separator. */
207 if (directory_nbytes
== 0
208 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
212 /* Loop reading blocks until EOF or error. */
219 if (dp
== NULL
&& errno
== EAGAIN
)
226 if (DIRENTRY_NONEMPTY (dp
))
230 Lisp_Object name
, finalname
;
231 struct gcpro gcpro1
, gcpro2
;
234 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
235 GCPRO2 (finalname
, name
);
237 /* Note: ENCODE_FILE can GC; it should protect its argument,
239 name
= DECODE_FILE (name
);
242 /* Now that we have unwind_protect in place, we might as well
243 allow matching to be interrupted. */
248 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
257 Lisp_Object fullname
;
258 int nbytes
= len
+ directory_nbytes
+ needsep
;
261 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
262 bcopy (SDATA (directory
), SDATA (fullname
),
266 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
269 SDATA (fullname
) + directory_nbytes
+ needsep
,
272 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
274 /* Some bug somewhere. */
278 STRING_SET_CHARS (fullname
, nchars
);
279 if (nchars
== nbytes
)
280 STRING_SET_UNIBYTE (fullname
);
282 finalname
= fullname
;
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
;
294 decoded_fullname
= fileattrs
= Qnil
;
295 GCPRO2 (decoded_fullname
, fileattrs
);
297 /* Both Fexpand_file_name and Ffile_attributes can GC. */
298 decoded_fullname
= Fexpand_file_name (name
, directory
);
299 fileattrs
= Ffile_attributes (decoded_fullname
);
301 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
305 list
= Fcons (finalname
, list
);
314 retry_p
|= errno
== EINTR
;
319 /* Discard the unwind protect. */
320 specpdl_ptr
= specpdl
+ count
;
329 list
= Fsort (Fnreverse (list
),
330 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
332 RETURN_UNGCPRO (list
);
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
;
348 directory
= Fexpand_file_name (directory
, Qnil
);
350 /* If the file name has special constructs in it,
351 call the corresponding file handler. */
352 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
358 args
[1] = Qdirectory_files
;
363 return Ffuncall (6, args
);
366 return directory_files_internal (directory
, full
, match
, nosort
, 0);
369 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
370 Sdirectory_files_and_attributes
, 1, 4, 0,
371 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
372 There are three optional arguments:
373 If FULL is non-nil, return absolute file names. Otherwise return names
374 that are relative to the specified directory.
375 If MATCH is non-nil, mention only file names that match the regexp MATCH.
376 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
377 NOSORT is useful if you plan to sort the result yourself. */)
378 (directory
, full
, match
, nosort
)
379 Lisp_Object directory
, full
, match
, nosort
;
382 directory
= Fexpand_file_name (directory
, Qnil
);
384 /* If the file name has special constructs in it,
385 call the corresponding file handler. */
386 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
392 args
[1] = Qdirectory_files_and_attributes
;
397 return Ffuncall (6, args
);
400 return directory_files_internal (directory
, full
, match
, nosort
, 1);
404 Lisp_Object
file_name_completion ();
406 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
408 doc
: /* Complete file name FILE in directory DIRECTORY.
409 Returns the longest string
410 common to all file names in DIRECTORY that start with FILE.
411 If there is only one and FILE matches it exactly, returns t.
412 Returns nil if DIR contains no name starting with FILE.
414 This function ignores some of the possible completions as
415 determined by the variable `completion-ignored-extensions', which see. */)
417 Lisp_Object file
, directory
;
421 /* If the directory name has special constructs in it,
422 call the corresponding file handler. */
423 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
425 return call3 (handler
, Qfile_name_completion
, file
, directory
);
427 /* If the file name has special constructs in it,
428 call the corresponding file handler. */
429 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
431 return call3 (handler
, Qfile_name_completion
, file
, directory
);
433 return file_name_completion (file
, directory
, 0, 0);
436 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
437 Sfile_name_all_completions
, 2, 2, 0,
438 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
439 These are all file names in directory DIRECTORY which begin with FILE. */)
441 Lisp_Object file
, directory
;
445 /* If the directory name has special constructs in it,
446 call the corresponding file handler. */
447 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
449 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
451 /* If the file name has special constructs in it,
452 call the corresponding file handler. */
453 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
455 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
457 return file_name_completion (file
, directory
, 1, 0);
460 static int file_name_completion_stat ();
463 file_name_completion (file
, dirname
, all_flag
, ver_flag
)
464 Lisp_Object file
, dirname
;
465 int all_flag
, ver_flag
;
468 int bestmatchsize
= 0, skip
;
469 register int compare
, matchsize
;
470 unsigned char *p1
, *p2
;
472 Lisp_Object bestmatch
, tem
, elt
, name
;
473 Lisp_Object encoded_file
;
474 Lisp_Object encoded_dir
;
478 int count
= SPECPDL_INDEX ();
479 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
484 extern DIRENTRY
* readdirver ();
486 DIRENTRY
*((* readfunc
) ());
488 /* Filename completion on VMS ignores case, since VMS filesys does. */
489 specbind (Qcompletion_ignore_case
, Qt
);
493 readfunc
= readdirver
;
494 file
= Fupcase (file
);
499 #ifdef FILE_SYSTEM_CASE
500 file
= FILE_SYSTEM_CASE (file
);
503 encoded_file
= encoded_dir
= Qnil
;
504 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
505 dirname
= Fexpand_file_name (dirname
, Qnil
);
507 /* Do completion on the encoded file name
508 because the other names in the directory are (we presume)
509 encoded likewise. We decode the completed string at the end. */
510 encoded_file
= ENCODE_FILE (file
);
512 encoded_dir
= ENCODE_FILE (dirname
);
514 /* With passcount = 0, ignore files that end in an ignored extension.
515 If nothing found then try again with passcount = 1, don't ignore them.
516 If looking for all completions, start with passcount = 1,
517 so always take even the ignored ones.
519 ** It would not actually be helpful to the user to ignore any possible
520 completions when making a list of them.** */
522 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
524 int inner_count
= SPECPDL_INDEX ();
526 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
528 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
530 record_unwind_protect (directory_files_internal_unwind
,
531 Fcons (make_number (((unsigned long) d
) >> 16),
532 make_number (((unsigned long) d
) & 0xffff)));
534 /* Loop reading blocks */
535 /* (att3b compiler bug requires do a null comparison this way) */
542 dp
= (*readfunc
) (d
);
551 if (! DIRENTRY_NONEMPTY (dp
)
552 || len
< SCHARS (encoded_file
)
553 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
554 SCHARS (encoded_file
)))
557 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
560 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
564 #ifndef TRIVIAL_DIRECTORY_ENTRY
565 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
567 /* "." and ".." are never interesting as completions, but are
568 actually in the way in a directory contains only one file. */
569 if (!passcount
&& TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
571 if (!passcount
&& len
> SCHARS (encoded_file
))
572 /* Ignore directories if they match an element of
573 completion-ignored-extensions which ends in a slash. */
574 for (tem
= Vcompletion_ignored_extensions
;
575 CONSP (tem
); tem
= XCDR (tem
))
582 /* Need to encode ELT, since scmp compares unibyte
584 elt
= ENCODE_FILE (elt
);
585 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
589 if (p1
[elt_len
] != '/')
591 skip
= len
- elt_len
;
595 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
602 /* Compare extensions-to-be-ignored against end of this file name */
603 /* if name is not an exact match against specified string */
604 if (!passcount
&& len
> SCHARS (encoded_file
))
605 /* and exit this for loop if a match is found */
606 for (tem
= Vcompletion_ignored_extensions
;
607 CONSP (tem
); tem
= XCDR (tem
))
610 if (!STRINGP (elt
)) continue;
611 /* Need to encode ELT, since scmp compares unibyte
613 elt
= ENCODE_FILE (elt
);
614 skip
= len
- SCHARS (elt
);
615 if (skip
< 0) continue;
617 if (0 <= scmp (dp
->d_name
+ skip
,
625 /* If an ignored-extensions match was found,
626 don't process this name as a completion. */
627 if (!passcount
&& CONSP (tem
))
634 XSETFASTINT (zero
, 0);
636 /* Ignore this element if it fails to match all the regexps. */
637 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
638 regexps
= XCDR (regexps
))
640 tem
= Fstring_match (XCAR (regexps
),
641 make_string (dp
->d_name
, len
), zero
);
649 /* Update computation of how much all possible completions match */
653 if (all_flag
|| NILP (bestmatch
))
655 /* This is a possible completion */
658 /* This completion is a directory; make it end with '/' */
659 name
= Ffile_name_as_directory (make_string (dp
->d_name
, len
));
662 name
= make_string (dp
->d_name
, len
);
665 name
= DECODE_FILE (name
);
666 bestmatch
= Fcons (name
, bestmatch
);
671 bestmatchsize
= SCHARS (name
);
676 compare
= min (bestmatchsize
, len
);
677 p1
= SDATA (bestmatch
);
678 p2
= (unsigned char *) dp
->d_name
;
679 matchsize
= scmp(p1
, p2
, compare
);
682 if (completion_ignore_case
)
684 /* If this is an exact match except for case,
685 use it as the best match rather than one that is not
686 an exact match. This way, we get the case pattern
687 of the actual match. */
688 /* This tests that the current file is an exact match
689 but BESTMATCH is not (it is too long). */
690 if ((matchsize
== len
691 && matchsize
+ !!directoryp
692 < SCHARS (bestmatch
))
694 /* If there is no exact match ignoring case,
695 prefer a match that does not change the case
697 /* If there is more than one exact match aside from
698 case, and one of them is exact including case,
700 /* This == checks that, of current file and BESTMATCH,
701 either both or neither are exact. */
704 (matchsize
+ !!directoryp
705 == SCHARS (bestmatch
)))
706 && !bcmp (p2
, SDATA (encoded_file
), SCHARS (encoded_file
))
707 && bcmp (p1
, SDATA (encoded_file
), SCHARS (encoded_file
))))
709 bestmatch
= make_string (dp
->d_name
, len
);
711 bestmatch
= Ffile_name_as_directory (bestmatch
);
715 /* If this dirname all matches, see if implicit following
718 && compare
== matchsize
719 && bestmatchsize
> matchsize
720 && IS_ANY_SEP (p1
[matchsize
]))
722 bestmatchsize
= matchsize
;
725 /* This closes the directory. */
726 bestmatch
= unbind_to (inner_count
, bestmatch
);
730 bestmatch
= unbind_to (count
, bestmatch
);
732 if (all_flag
|| NILP (bestmatch
))
734 if (STRINGP (bestmatch
))
735 bestmatch
= DECODE_FILE (bestmatch
);
738 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
740 bestmatch
= Fsubstring (bestmatch
, make_number (0),
741 make_number (bestmatchsize
));
742 /* Now that we got the right initial segment of BESTMATCH,
743 decode it from the coding system in use. */
744 bestmatch
= DECODE_FILE (bestmatch
);
748 /* Compare exactly LEN chars of strings at S1 and S2,
749 ignoring case if appropriate.
750 Return -1 if strings match,
751 else number of chars that match at the beginning. */
755 register unsigned char *s1
, *s2
;
758 register int l
= len
;
760 if (completion_ignore_case
)
762 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
767 while (l
&& *s1
++ == *s2
++)
777 file_name_completion_stat (dirname
, dp
, st_addr
)
780 struct stat
*st_addr
;
782 int len
= NAMLEN (dp
);
783 int pos
= SCHARS (dirname
);
785 char *fullname
= (char *) alloca (len
+ pos
+ 2);
789 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
790 but aren't required here. Avoid computing the following fields:
791 st_inode, st_size and st_nlink for directories, and the execute bits
792 in st_mode for non-directory files with non-standard extensions. */
794 unsigned short save_djstat_flags
= _djstat_flags
;
796 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
797 #endif /* __DJGPP__ > 1 */
800 bcopy (SDATA (dirname
), fullname
, pos
);
802 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
803 fullname
[pos
++] = DIRECTORY_SEP
;
806 bcopy (dp
->d_name
, fullname
+ pos
, len
);
807 fullname
[pos
+ len
] = 0;
810 /* We want to return success if a link points to a nonexistent file,
811 but we want to return the status for what the link points to,
812 in case it is a directory. */
813 value
= lstat (fullname
, st_addr
);
814 stat (fullname
, st_addr
);
817 value
= stat (fullname
, st_addr
);
820 _djstat_flags
= save_djstat_flags
;
821 #endif /* __DJGPP__ > 1 */
829 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
830 Sfile_name_all_versions
, 2, 2, 0,
831 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
833 Lisp_Object file
, directory
;
835 return file_name_completion (file
, directory
, 1, 1);
838 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
839 doc
: /* Return the maximum number of versions allowed for FILE.
840 Returns nil if the file cannot be opened or if there is no version limit. */)
842 Lisp_Object filename
;
847 struct XABFHC xabfhc
;
850 filename
= Fexpand_file_name (filename
, Qnil
);
852 xabfhc
= cc$rms_xabfhc
;
853 fab
.fab$l_fna
= SDATA (filename
);
854 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
855 fab
.fab$l_xab
= (char *) &xabfhc
;
856 status
= sys$
open (&fab
, 0, 0);
857 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
859 sys$
close (&fab
, 0, 0);
860 if (xabfhc
.xab$w_verlimit
== 32767)
861 return Qnil
; /* No version limit */
863 return make_number (xabfhc
.xab$w_verlimit
);
872 return Fcons (make_number (time
>> 16),
873 Fcons (make_number (time
& 0177777), Qnil
));
876 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 1, 0,
877 doc
: /* Return a list of attributes of file FILENAME.
878 Value is nil if specified file cannot be opened.
879 Otherwise, list elements are:
880 0. t for directory, string (name linked to) for symbolic link, or nil.
881 1. Number of links to file.
884 4. Last access time, as a list of two integers.
885 First integer has high-order 16 bits of time, second has low 16 bits.
886 5. Last modification time, likewise.
887 6. Last status change time, likewise.
889 This is a floating point number if the size is too large for an integer.
890 8. File modes, as a string of ten letters or dashes as in ls -l.
891 9. t iff file's gid would change if file were deleted and recreated.
892 10. inode number. If inode number is larger than the Emacs integer,
893 this is a cons cell containing two integers: first the high part,
894 then the low 16 bits.
895 11. Device number. If it is larger than the Emacs integer, this is
896 a cons cell, similar to the inode number.
898 If file does not exist, returns nil. */)
900 Lisp_Object filename
;
902 Lisp_Object values
[12];
905 #if defined (BSD4_2) || defined (BSD4_3)
912 filename
= Fexpand_file_name (filename
, Qnil
);
914 /* If the file name has special constructs in it,
915 call the corresponding file handler. */
916 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
918 return call2 (handler
, Qfile_attributes
, filename
);
920 encoded
= ENCODE_FILE (filename
);
922 if (lstat (SDATA (encoded
), &s
) < 0)
925 switch (s
.st_mode
& S_IFMT
)
928 values
[0] = Qnil
; break;
930 values
[0] = Qt
; break;
933 values
[0] = Ffile_symlink_p (filename
); break;
936 values
[1] = make_number (s
.st_nlink
);
937 values
[2] = make_number (s
.st_uid
);
938 values
[3] = make_number (s
.st_gid
);
939 values
[4] = make_time (s
.st_atime
);
940 values
[5] = make_time (s
.st_mtime
);
941 values
[6] = make_time (s
.st_ctime
);
942 values
[7] = make_number (s
.st_size
);
943 /* If the size is out of range for an integer, return a float. */
944 if (XINT (values
[7]) != s
.st_size
)
945 values
[7] = make_float ((double)s
.st_size
);
946 /* If the size is negative, and its type is long, convert it back to
948 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
949 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
951 filemodestring (&s
, modes
);
952 values
[8] = make_string (modes
, 10);
953 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
954 dirname
= Ffile_name_directory (filename
);
955 if (! NILP (dirname
))
956 encoded
= ENCODE_FILE (dirname
);
957 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
958 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
959 else /* if we can't tell, assume worst */
961 #else /* file gid will be egid */
962 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
963 #endif /* BSD4_2 (or BSD4_3) */
964 if (FIXNUM_OVERFLOW_P (s
.st_ino
))
965 /* To allow inode numbers larger than VALBITS, separate the bottom
967 values
[10] = Fcons (make_number (s
.st_ino
>> 16),
968 make_number (s
.st_ino
& 0xffff));
970 /* But keep the most common cases as integers. */
971 values
[10] = make_number (s
.st_ino
);
973 /* Likewise for device. */
974 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
975 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
976 make_number (s
.st_dev
& 0xffff));
978 values
[11] = make_number (s
.st_dev
);
980 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
983 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
984 doc
: /* Return t if first arg file attributes list is less than second.
985 Comparison is in lexicographic order and case is significant. */)
989 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
995 Qdirectory_files
= intern ("directory-files");
996 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
997 Qfile_name_completion
= intern ("file-name-completion");
998 Qfile_name_all_completions
= intern ("file-name-all-completions");
999 Qfile_attributes
= intern ("file-attributes");
1000 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1002 staticpro (&Qdirectory_files
);
1003 staticpro (&Qdirectory_files_and_attributes
);
1004 staticpro (&Qfile_name_completion
);
1005 staticpro (&Qfile_name_all_completions
);
1006 staticpro (&Qfile_attributes
);
1007 staticpro (&Qfile_attributes_lessp
);
1009 defsubr (&Sdirectory_files
);
1010 defsubr (&Sdirectory_files_and_attributes
);
1011 defsubr (&Sfile_name_completion
);
1013 defsubr (&Sfile_name_all_versions
);
1014 defsubr (&Sfile_version_limit
);
1016 defsubr (&Sfile_name_all_completions
);
1017 defsubr (&Sfile_attributes
);
1018 defsubr (&Sfile_attributes_lessp
);
1021 Qcompletion_ignore_case
= intern ("completion-ignore-case");
1022 staticpro (&Qcompletion_ignore_case
);
1025 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1026 doc
: /* *Completion ignores filenames ending in any string in this list.
1027 Directories are ignored if they match any string in this list which
1029 This variable does not affect lists of possible completions,
1030 but does affect the commands that actually do completions. */);
1031 Vcompletion_ignored_extensions
= Qnil
;