1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985-1986, 1993-1994, 1999-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/types.h>
35 /* The d_nameln member of a struct dirent includes the '\0' character
36 on some systems, but not on others. What's worse, you can't tell
37 at compile-time which one it will be, since it really depends on
38 the sort of system providing the filesystem you're reading from,
39 not the system you are running on. Paul Eggert
40 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
41 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
42 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
44 Since applying strlen to the name always works, we'll just do that. */
45 #define NAMLEN(p) strlen (p->d_name)
50 #define DIRENTRY struct dirent
52 #else /* not HAVE_DIRENT_H */
57 #define DIRENTRY struct direct
59 extern DIR *opendir (char *);
60 extern struct direct
*readdir (DIR *);
62 #endif /* HAVE_DIRENT_H */
67 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
69 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
76 #include "character.h"
80 #include "blockinput.h"
82 Lisp_Object Qdirectory_files
;
83 Lisp_Object Qdirectory_files_and_attributes
;
84 Lisp_Object Qfile_name_completion
;
85 Lisp_Object Qfile_name_all_completions
;
86 Lisp_Object Qfile_attributes
;
87 Lisp_Object Qfile_attributes_lessp
;
89 static int scmp (const char *, const char *, int);
93 directory_files_internal_w32_unwind (Lisp_Object arg
)
95 Vw32_get_true_file_attributes
= arg
;
101 directory_files_internal_unwind (Lisp_Object dh
)
103 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
110 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
111 When ATTRS is zero, return a list of directory filenames; when
112 non-zero, return a list of directory filenames and their attributes.
113 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
116 directory_files_internal (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, int attrs
, Lisp_Object id_format
)
119 int directory_nbytes
;
120 Lisp_Object list
, dirfilename
, encoded_directory
;
121 struct re_pattern_buffer
*bufp
= NULL
;
123 int count
= SPECPDL_INDEX ();
124 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
127 Lisp_Object w32_save
= Qnil
;
130 /* Because of file name handlers, these functions might call
131 Ffuncall, and cause a GC. */
132 list
= encoded_directory
= dirfilename
= Qnil
;
133 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
134 dirfilename
= Fdirectory_file_name (directory
);
138 CHECK_STRING (match
);
140 /* MATCH might be a flawed regular expression. Rather than
141 catching and signaling our own errors, we just call
142 compile_pattern to do the work for us. */
143 /* Pass 1 for the MULTIBYTE arg
144 because we do make multibyte strings if the contents warrant. */
146 /* Windows users want case-insensitive wildcards. */
147 bufp
= compile_pattern (match
, 0,
148 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
149 # else /* !WINDOWSNT */
150 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
151 # endif /* !WINDOWSNT */
154 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
155 run_pre_post_conversion_on_str which calls Lisp directly and
157 if (STRING_MULTIBYTE (dirfilename
))
158 dirfilename
= ENCODE_FILE (dirfilename
);
159 encoded_directory
= (STRING_MULTIBYTE (directory
)
160 ? ENCODE_FILE (directory
) : directory
);
162 /* Now *bufp is the compiled form of MATCH; don't call anything
163 which might compile a new regexp until we're done with the loop! */
166 d
= opendir (SSDATA (dirfilename
));
169 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
171 /* Unfortunately, we can now invoke expand-file-name and
172 file-attributes on filenames, both of which can throw, so we must
173 do a proper unwind-protect. */
174 record_unwind_protect (directory_files_internal_unwind
,
175 make_save_value (d
, 0));
180 extern int is_slow_fs (const char *);
182 /* Do this only once to avoid doing it (in w32.c:stat) for each
183 file in the directory, when we call Ffile_attributes below. */
184 record_unwind_protect (directory_files_internal_w32_unwind
,
185 Vw32_get_true_file_attributes
);
186 w32_save
= Vw32_get_true_file_attributes
;
187 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
189 /* w32.c:stat will notice these bindings and avoid calling
190 GetDriveType for each file. */
191 if (is_slow_fs (SDATA (dirfilename
)))
192 Vw32_get_true_file_attributes
= Qnil
;
194 Vw32_get_true_file_attributes
= Qt
;
199 directory_nbytes
= SBYTES (directory
);
200 re_match_object
= Qt
;
202 /* Decide whether we need to add a directory separator. */
203 if (directory_nbytes
== 0
204 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
207 /* Loop reading blocks until EOF or error. */
226 if (DIRENTRY_NONEMPTY (dp
))
230 Lisp_Object name
, finalname
;
231 struct gcpro inner_gcpro1
, inner_gcpro2
;
234 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
235 GCPRO2_VAR (finalname
, name
, inner_gcpro
);
237 /* Note: DECODE_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
, SSDATA (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 memcpy (SDATA (fullname
), SDATA (directory
),
266 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
268 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
271 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
273 /* Some bug somewhere. */
277 STRING_SET_CHARS (fullname
, nchars
);
278 if (nchars
== nbytes
)
279 STRING_SET_UNIBYTE (fullname
);
281 finalname
= fullname
;
288 /* Construct an expanded filename for the directory entry.
289 Use the decoded names for input to Ffile_attributes. */
290 Lisp_Object decoded_fullname
, fileattrs
;
291 struct gcpro innermost_gcpro1
, innermost_gcpro2
;
293 decoded_fullname
= fileattrs
= Qnil
;
294 GCPRO2_VAR (decoded_fullname
, fileattrs
, innermost_gcpro
);
296 /* Both Fexpand_file_name and Ffile_attributes can GC. */
297 decoded_fullname
= Fexpand_file_name (name
, directory
);
298 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
300 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
301 UNGCPRO_VAR (innermost_gcpro
);
304 list
= Fcons (finalname
, list
);
307 UNGCPRO_VAR (inner_gcpro
);
316 Vw32_get_true_file_attributes
= w32_save
;
319 /* Discard the unwind protect. */
320 specpdl_ptr
= specpdl
+ count
;
323 list
= Fsort (Fnreverse (list
),
324 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
326 RETURN_UNGCPRO (list
);
330 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
331 doc
: /* Return a list of names of files in DIRECTORY.
332 There are three optional arguments:
333 If FULL is non-nil, return absolute file names. Otherwise return names
334 that are relative to the specified directory.
335 If MATCH is non-nil, mention only file names that match the regexp MATCH.
336 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
337 Otherwise, the list returned is sorted with `string-lessp'.
338 NOSORT is useful if you plan to sort the result yourself. */)
339 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
342 directory
= Fexpand_file_name (directory
, Qnil
);
344 /* If the file name has special constructs in it,
345 call the corresponding file handler. */
346 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
348 return call5 (handler
, Qdirectory_files
, directory
,
349 full
, match
, nosort
);
351 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
354 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
355 Sdirectory_files_and_attributes
, 1, 5, 0,
356 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
357 There are four optional arguments:
358 If FULL is non-nil, return absolute file names. Otherwise return names
359 that are relative to the specified directory.
360 If MATCH is non-nil, mention only file names that match the regexp MATCH.
361 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
362 NOSORT is useful if you plan to sort the result yourself.
363 ID-FORMAT specifies the preferred format of attributes uid and gid, see
364 `file-attributes' for further documentation.
365 On MS-Windows, performance depends on `w32-get-true-file-attributes',
367 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
370 directory
= Fexpand_file_name (directory
, Qnil
);
372 /* If the file name has special constructs in it,
373 call the corresponding file handler. */
374 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
376 return call6 (handler
, Qdirectory_files_and_attributes
,
377 directory
, full
, match
, nosort
, id_format
);
379 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
383 Lisp_Object
file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
);
385 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
387 doc
: /* Complete file name FILE in directory DIRECTORY.
388 Returns the longest string
389 common to all file names in DIRECTORY that start with FILE.
390 If there is only one and FILE matches it exactly, returns t.
391 Returns nil if DIRECTORY contains no name starting with FILE.
393 If PREDICATE is non-nil, call PREDICATE with each possible
394 completion (in absolute form) and ignore it if PREDICATE returns nil.
396 This function ignores some of the possible completions as
397 determined by the variable `completion-ignored-extensions', which see. */)
398 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
402 /* If the directory name has special constructs in it,
403 call the corresponding file handler. */
404 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
406 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
408 /* If the file name has special constructs in it,
409 call the corresponding file handler. */
410 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
412 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
414 return file_name_completion (file
, directory
, 0, 0, predicate
);
417 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
418 Sfile_name_all_completions
, 2, 2, 0,
419 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
420 These are all file names in directory DIRECTORY which begin with FILE. */)
421 (Lisp_Object file
, Lisp_Object directory
)
425 /* If the directory name has special constructs in it,
426 call the corresponding file handler. */
427 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
429 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
431 /* If the file name has special constructs in it,
432 call the corresponding file handler. */
433 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
435 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
437 return file_name_completion (file
, directory
, 1, 0, Qnil
);
440 static int file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
);
441 Lisp_Object Qdefault_directory
;
444 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
)
447 int bestmatchsize
= 0;
449 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
450 If ALL_FLAG is 0, BESTMATCH is either nil
451 or the best match so far, not decoded. */
452 Lisp_Object bestmatch
, tem
, elt
, name
;
453 Lisp_Object encoded_file
;
454 Lisp_Object encoded_dir
;
457 /* If includeall is zero, exclude files in completion-ignored-extensions as
458 well as "." and "..". Until shown otherwise, assume we can't exclude
461 int count
= SPECPDL_INDEX ();
462 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
468 #ifdef FILE_SYSTEM_CASE
469 file
= FILE_SYSTEM_CASE (file
);
472 encoded_file
= encoded_dir
= Qnil
;
473 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
474 dirname
= Fexpand_file_name (dirname
, Qnil
);
475 specbind (Qdefault_directory
, dirname
);
477 /* Do completion on the encoded file name
478 because the other names in the directory are (we presume)
479 encoded likewise. We decode the completed string at the end. */
480 /* Actually, this is not quite true any more: we do most of the completion
481 work with decoded file names, but we still do some filtering based
482 on the encoded file name. */
483 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
485 encoded_dir
= ENCODE_FILE (dirname
);
488 d
= opendir (SSDATA (Fdirectory_file_name (encoded_dir
)));
491 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
493 record_unwind_protect (directory_files_internal_unwind
,
494 make_save_value (d
, 0));
496 /* Loop reading blocks */
497 /* (att3b compiler bug requires do a null comparison this way) */
521 if (! DIRENTRY_NONEMPTY (dp
)
522 || len
< SCHARS (encoded_file
)
523 || 0 <= scmp (dp
->d_name
, SSDATA (encoded_file
),
524 SCHARS (encoded_file
)))
527 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
530 directoryp
= S_ISDIR (st
.st_mode
);
532 /* If all_flag is set, always include all.
533 It would not actually be helpful to the user to ignore any possible
534 completions when making a list of them. */
539 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
540 /* If this entry matches the current bestmatch, the only
541 thing it can do is increase matchcount, so don't bother
542 investigating it any further. */
543 if (!completion_ignore_case
544 /* The return result depends on whether it's the sole match. */
546 && !includeall
/* This match may allow includeall to 0. */
547 && len
>= bestmatchsize
548 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
554 #ifndef TRIVIAL_DIRECTORY_ENTRY
555 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
557 /* "." and ".." are never interesting as completions, and are
558 actually in the way in a directory with only one file. */
559 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
561 else if (len
> SCHARS (encoded_file
))
562 /* Ignore directories if they match an element of
563 completion-ignored-extensions which ends in a slash. */
564 for (tem
= Vcompletion_ignored_extensions
;
565 CONSP (tem
); tem
= XCDR (tem
))
573 /* Need to encode ELT, since scmp compares unibyte
575 elt
= ENCODE_FILE (elt
);
576 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
580 if (p1
[elt_len
] != '/')
582 skip
= len
- elt_len
;
586 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
593 /* Compare extensions-to-be-ignored against end of this file name */
594 /* if name is not an exact match against specified string */
595 if (len
> SCHARS (encoded_file
))
596 /* and exit this for loop if a match is found */
597 for (tem
= Vcompletion_ignored_extensions
;
598 CONSP (tem
); tem
= XCDR (tem
))
601 if (!STRINGP (elt
)) continue;
602 /* Need to encode ELT, since scmp compares unibyte
604 elt
= ENCODE_FILE (elt
);
605 skip
= len
- SCHARS (elt
);
606 if (skip
< 0) continue;
608 if (0 <= scmp (dp
->d_name
+ skip
,
616 /* If an ignored-extensions match was found,
617 don't process this name as a completion. */
621 if (!includeall
&& canexclude
)
622 /* We're not including all files and this file can be excluded. */
625 if (includeall
&& !canexclude
)
626 { /* If we have one non-excludable file, we want to exclude the
629 /* Throw away any previous excludable match found. */
635 /* FIXME: If we move this `decode' earlier we can eliminate
636 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
637 name
= make_unibyte_string (dp
->d_name
, len
);
638 name
= DECODE_FILE (name
);
643 XSETFASTINT (zero
, 0);
645 /* Ignore this element if it fails to match all the regexps. */
646 if (completion_ignore_case
)
648 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
649 regexps
= XCDR (regexps
))
650 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
655 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
656 regexps
= XCDR (regexps
))
657 if (fast_string_match (XCAR (regexps
), name
) < 0)
665 /* This is a possible completion */
667 /* This completion is a directory; make it end with '/'. */
668 name
= Ffile_name_as_directory (name
);
670 /* Test the predicate, if any. */
671 if (!NILP (predicate
))
674 struct gcpro inner_gcpro1
;
676 GCPRO1_VAR (name
, inner_gcpro
);
677 val
= call1 (predicate
, name
);
678 UNGCPRO_VAR (inner_gcpro
);
684 /* Suitably record this match. */
689 bestmatch
= Fcons (name
, bestmatch
);
690 else if (NILP (bestmatch
))
693 bestmatchsize
= SCHARS (name
);
697 Lisp_Object zero
= make_number (0);
698 /* FIXME: This is a copy of the code in Ftry_completion. */
699 int compare
= min (bestmatchsize
, SCHARS (name
));
701 = Fcompare_strings (bestmatch
, zero
,
702 make_number (compare
),
704 make_number (compare
),
705 completion_ignore_case
? Qt
: Qnil
);
707 = (EQ (cmp
, Qt
) ? compare
708 : XINT (cmp
) < 0 ? - XINT (cmp
) - 1
711 if (completion_ignore_case
)
713 /* If this is an exact match except for case,
714 use it as the best match rather than one that is not
715 an exact match. This way, we get the case pattern
716 of the actual match. */
717 /* This tests that the current file is an exact match
718 but BESTMATCH is not (it is too long). */
719 if ((matchsize
== SCHARS (name
)
720 && matchsize
+ !!directoryp
< SCHARS (bestmatch
))
722 /* If there is no exact match ignoring case,
723 prefer a match that does not change the case
725 /* If there is more than one exact match aside from
726 case, and one of them is exact including case,
728 /* This == checks that, of current file and BESTMATCH,
729 either both or neither are exact. */
730 (((matchsize
== SCHARS (name
))
732 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
733 && (cmp
= Fcompare_strings (name
, zero
,
734 make_number (SCHARS (file
)),
739 && (cmp
= Fcompare_strings (bestmatch
, zero
,
740 make_number (SCHARS (file
)),
747 bestmatchsize
= matchsize
;
749 /* If the best completion so far is reduced to the string
750 we're trying to complete, then we already know there's no
751 other completion, so there's no point looking any further. */
752 if (matchsize
<= SCHARS (file
)
753 && !includeall
/* A future match may allow includeall to 0. */
754 /* If completion-ignore-case is non-nil, don't
755 short-circuit because we want to find the best
756 possible match *including* case differences. */
757 && (!completion_ignore_case
|| matchsize
== 0)
758 /* The return value depends on whether it's the sole match. */
766 /* This closes the directory. */
767 bestmatch
= unbind_to (count
, bestmatch
);
769 if (all_flag
|| NILP (bestmatch
))
771 /* Return t if the supplied string is an exact match (counting case);
772 it does not require any change to be made. */
773 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
775 bestmatch
= Fsubstring (bestmatch
, make_number (0),
776 make_number (bestmatchsize
));
780 /* Compare exactly LEN chars of strings at S1 and S2,
781 ignoring case if appropriate.
782 Return -1 if strings match,
783 else number of chars that match at the beginning. */
786 scmp (const char *s1
, const char *s2
, int len
)
788 register int l
= len
;
790 if (completion_ignore_case
)
793 && (DOWNCASE ((unsigned char) *s1
++)
794 == DOWNCASE ((unsigned char) *s2
++)))
799 while (l
&& *s1
++ == *s2
++)
809 file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
)
811 int len
= NAMLEN (dp
);
812 int pos
= SCHARS (dirname
);
814 char *fullname
= (char *) alloca (len
+ pos
+ 2);
817 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
818 but aren't required here. Avoid computing the following fields:
819 st_inode, st_size and st_nlink for directories, and the execute bits
820 in st_mode for non-directory files with non-standard extensions. */
822 unsigned short save_djstat_flags
= _djstat_flags
;
824 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
827 memcpy (fullname
, SDATA (dirname
), pos
);
828 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
829 fullname
[pos
++] = DIRECTORY_SEP
;
831 memcpy (fullname
+ pos
, dp
->d_name
, len
);
832 fullname
[pos
+ len
] = 0;
834 /* We want to return success if a link points to a nonexistent file,
835 but we want to return the status for what the link points to,
836 in case it is a directory. */
837 value
= lstat (fullname
, st_addr
);
838 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
839 stat (fullname
, st_addr
);
841 _djstat_flags
= save_djstat_flags
;
847 stat_uname (struct stat
*st
)
852 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
862 stat_gname (struct stat
*st
)
867 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
876 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
877 doc
: /* Return a list of attributes of file FILENAME.
878 Value is nil if specified file cannot be opened.
880 ID-FORMAT specifies the preferred format of attributes uid and gid (see
881 below) - valid values are 'string and 'integer. The latter is the
882 default, but we plan to change that, so you should specify a non-nil value
883 for ID-FORMAT if you use the returned uid or gid.
885 Elements of the attribute list are:
886 0. t for directory, string (name linked to) for symbolic link, or nil.
887 1. Number of links to file.
888 2. File uid as a string or a number. If a string value cannot be
889 looked up, a numeric value, either an integer or a float, is returned.
890 3. File gid, likewise.
891 4. Last access time, as a list of two integers.
892 First integer has high-order 16 bits of time, second has low 16 bits.
893 (See a note below about access time on FAT-based filesystems.)
894 5. Last modification time, likewise. This is the time of the last
895 change to the file's contents.
896 6. Last status change time, likewise. This is the time of last change
897 to the file's attributes: owner and group, access mode bits, etc.
899 This is a floating point number if the size is too large for an integer.
900 8. File modes, as a string of ten letters or dashes as in ls -l.
901 9. t if file's gid would change if file were deleted and recreated.
902 10. inode number. If inode number is larger than what Emacs integer
903 can hold, but still fits into a 32-bit number, this is a cons cell
904 containing two integers: first the high part, then the low 16 bits.
905 If the inode number is wider than 32 bits, this is of the form
906 (HIGH MIDDLE . LOW): first the high 24 bits, then middle 24 bits,
907 and finally the low 16 bits.
908 11. Filesystem device number. If it is larger than what the Emacs
909 integer can hold, this is a cons cell, similar to the inode number.
911 On most filesystems, the combination of the inode and the device
912 number uniquely identifies the file.
914 On MS-Windows, performance depends on `w32-get-true-file-attributes',
917 On some FAT-based filesystems, only the date of last access is recorded,
918 so last access time will always be midnight of that day. */)
919 (Lisp_Object filename
, Lisp_Object id_format
)
921 Lisp_Object values
[12];
929 /* An array to hold the mode string generated by filemodestring,
930 including its terminating space and null byte. */
931 char modes
[sizeof "-rwxr-xr-x "];
935 char *uname
= NULL
, *gname
= NULL
;
937 filename
= Fexpand_file_name (filename
, Qnil
);
939 /* If the file name has special constructs in it,
940 call the corresponding file handler. */
941 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
943 { /* Only pass the extra arg if it is used to help backward compatibility
944 with old file handlers which do not implement the new arg. --Stef */
945 if (NILP (id_format
))
946 return call2 (handler
, Qfile_attributes
, filename
);
948 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
952 encoded
= ENCODE_FILE (filename
);
955 if (lstat (SSDATA (encoded
), &s
) < 0)
958 values
[0] = (S_ISLNK (s
.st_mode
) ? Ffile_symlink_p (filename
)
959 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
);
960 values
[1] = make_number (s
.st_nlink
);
962 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
965 uname
= stat_uname (&s
);
966 gname
= stat_gname (&s
);
970 values
[2] = DECODE_SYSTEM (build_string (uname
));
972 values
[2] = make_fixnum_or_float (s
.st_uid
);
974 values
[3] = DECODE_SYSTEM (build_string (gname
));
976 values
[3] = make_fixnum_or_float (s
.st_gid
);
978 values
[4] = make_time (s
.st_atime
);
979 values
[5] = make_time (s
.st_mtime
);
980 values
[6] = make_time (s
.st_ctime
);
981 values
[7] = make_fixnum_or_float (s
.st_size
);
982 /* If the size is negative, and its type is long, convert it back to
984 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
985 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
987 filemodestring (&s
, modes
);
988 values
[8] = make_string (modes
, 10);
989 #ifdef BSD4_2 /* file gid will be dir gid */
990 dirname
= Ffile_name_directory (filename
);
991 if (! NILP (dirname
))
992 encoded
= ENCODE_FILE (dirname
);
993 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
994 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
995 else /* if we can't tell, assume worst */
997 #else /* file gid will be egid */
998 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
999 #endif /* not BSD4_2 */
1000 if (!FIXNUM_OVERFLOW_P (s
.st_ino
))
1001 /* Keep the most common cases as integers. */
1002 values
[10] = make_number (s
.st_ino
);
1003 else if (!FIXNUM_OVERFLOW_P (s
.st_ino
>> 16))
1004 /* To allow inode numbers larger than VALBITS, separate the bottom
1006 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1007 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1010 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1011 high parts and a 16-bit bottom part.
1012 The code on the next line avoids a compiler warning on
1013 systems where st_ino is 32 bit wide. (bug#766). */
1014 EMACS_INT high_ino
= s
.st_ino
>> 31 >> 1;
1015 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1017 values
[10] = Fcons (make_number (high_ino
>> 8),
1018 Fcons (make_number (((high_ino
& 0xff) << 16)
1020 make_number (low_ino
& 0xffff)));
1023 /* Likewise for device. */
1024 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1025 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1026 make_number (s
.st_dev
& 0xffff));
1028 values
[11] = make_number (s
.st_dev
);
1030 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1033 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1034 doc
: /* Return t if first arg file attributes list is less than second.
1035 Comparison is in lexicographic order and case is significant. */)
1036 (Lisp_Object f1
, Lisp_Object f2
)
1038 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1042 syms_of_dired (void)
1044 Qdirectory_files
= intern_c_string ("directory-files");
1045 Qdirectory_files_and_attributes
= intern_c_string ("directory-files-and-attributes");
1046 Qfile_name_completion
= intern_c_string ("file-name-completion");
1047 Qfile_name_all_completions
= intern_c_string ("file-name-all-completions");
1048 Qfile_attributes
= intern_c_string ("file-attributes");
1049 Qfile_attributes_lessp
= intern_c_string ("file-attributes-lessp");
1050 Qdefault_directory
= intern_c_string ("default-directory");
1052 staticpro (&Qdirectory_files
);
1053 staticpro (&Qdirectory_files_and_attributes
);
1054 staticpro (&Qfile_name_completion
);
1055 staticpro (&Qfile_name_all_completions
);
1056 staticpro (&Qfile_attributes
);
1057 staticpro (&Qfile_attributes_lessp
);
1058 staticpro (&Qdefault_directory
);
1060 defsubr (&Sdirectory_files
);
1061 defsubr (&Sdirectory_files_and_attributes
);
1062 defsubr (&Sfile_name_completion
);
1063 defsubr (&Sfile_name_all_completions
);
1064 defsubr (&Sfile_attributes
);
1065 defsubr (&Sfile_attributes_lessp
);
1067 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1068 doc
: /* Completion ignores file names ending in any string in this list.
1069 It does not ignore them if all possible completions end in one of
1070 these strings or when displaying a list of completions.
1071 It ignores directory names if they match any string in this list which
1072 ends in a slash. */);
1073 Vcompletion_ignored_extensions
= Qnil
;