1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985-1986, 1993-1994, 1999-2015 Free Software
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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
24 #include <sys/types.h>
38 #include <stat-time.h>
42 #include "character.h"
48 #include "blockinput.h"
51 #include "msdos.h" /* for fstatat */
54 static Lisp_Object Qdirectory_files
;
55 static Lisp_Object Qdirectory_files_and_attributes
;
56 static Lisp_Object Qfile_name_completion
;
57 static Lisp_Object Qfile_name_all_completions
;
58 static Lisp_Object Qfile_attributes
;
59 static Lisp_Object Qfile_attributes_lessp
;
61 static ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
62 static Lisp_Object
file_attributes (int, char const *, Lisp_Object
);
64 /* Return the number of bytes in DP's name. */
66 dirent_namelen (struct dirent
*dp
)
68 #ifdef _D_EXACT_NAMLEN
69 return _D_EXACT_NAMLEN (dp
);
71 return strlen (dp
->d_name
);
76 open_directory (char const *name
, int *fdp
)
79 int fd
, opendir_errno
;
84 /* Directories cannot be opened. The emulation assumes that any
85 file descriptor other than AT_FDCWD corresponds to the most
86 recently opened directory. This hack is good enough for Emacs. */
89 opendir_errno
= errno
;
91 fd
= emacs_open (name
, O_RDONLY
| O_DIRECTORY
, 0);
94 opendir_errno
= errno
;
100 opendir_errno
= errno
;
109 errno
= opendir_errno
;
115 directory_files_internal_w32_unwind (Lisp_Object arg
)
117 Vw32_get_true_file_attributes
= arg
;
122 directory_files_internal_unwind (void *dh
)
130 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
131 If not ATTRS, return a list of directory filenames;
132 if ATTRS, return a list of directory filenames and their attributes.
133 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
136 directory_files_internal (Lisp_Object directory
, Lisp_Object full
,
137 Lisp_Object match
, Lisp_Object nosort
, bool attrs
,
138 Lisp_Object id_format
)
142 ptrdiff_t directory_nbytes
;
143 Lisp_Object list
, dirfilename
, encoded_directory
;
144 struct re_pattern_buffer
*bufp
= NULL
;
146 ptrdiff_t count
= SPECPDL_INDEX ();
147 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
150 Lisp_Object w32_save
= Qnil
;
153 /* Don't let the compiler optimize away all copies of DIRECTORY,
154 which would break GC; see Bug#16986. Although this is required
155 only in the common case where GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS,
156 it shouldn't break anything in the other cases. */
157 Lisp_Object
volatile directory_volatile
= directory
;
159 /* Because of file name handlers, these functions might call
160 Ffuncall, and cause a GC. */
161 list
= encoded_directory
= dirfilename
= Qnil
;
162 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
163 dirfilename
= Fdirectory_file_name (directory
);
167 CHECK_STRING (match
);
169 /* MATCH might be a flawed regular expression. Rather than
170 catching and signaling our own errors, we just call
171 compile_pattern to do the work for us. */
172 /* Pass 1 for the MULTIBYTE arg
173 because we do make multibyte strings if the contents warrant. */
175 /* Windows users want case-insensitive wildcards. */
176 bufp
= compile_pattern (match
, 0,
177 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
178 # else /* !WINDOWSNT */
179 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
180 # endif /* !WINDOWSNT */
183 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
184 run_pre_post_conversion_on_str which calls Lisp directly and
186 if (STRING_MULTIBYTE (dirfilename
))
187 dirfilename
= ENCODE_FILE (dirfilename
);
188 encoded_directory
= (STRING_MULTIBYTE (directory
)
189 ? ENCODE_FILE (directory
) : directory
);
191 /* Now *bufp is the compiled form of MATCH; don't call anything
192 which might compile a new regexp until we're done with the loop! */
194 d
= open_directory (SSDATA (dirfilename
), &fd
);
196 report_file_error ("Opening directory", directory
);
198 /* Unfortunately, we can now invoke expand-file-name and
199 file-attributes on filenames, both of which can throw, so we must
200 do a proper unwind-protect. */
201 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
206 extern int is_slow_fs (const char *);
208 /* Do this only once to avoid doing it (in w32.c:stat) for each
209 file in the directory, when we call Ffile_attributes below. */
210 record_unwind_protect (directory_files_internal_w32_unwind
,
211 Vw32_get_true_file_attributes
);
212 w32_save
= Vw32_get_true_file_attributes
;
213 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
215 /* w32.c:stat will notice these bindings and avoid calling
216 GetDriveType for each file. */
217 if (is_slow_fs (SDATA (dirfilename
)))
218 Vw32_get_true_file_attributes
= Qnil
;
220 Vw32_get_true_file_attributes
= Qt
;
225 directory_nbytes
= SBYTES (directory
);
226 re_match_object
= Qt
;
228 /* Decide whether we need to add a directory separator. */
229 if (directory_nbytes
== 0
230 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
233 /* Loop reading blocks until EOF or error. */
238 Lisp_Object name
, finalname
;
239 struct gcpro gcpro1
, gcpro2
;
245 if (errno
== EAGAIN
|| errno
== EINTR
)
251 /* The MS-Windows implementation of 'opendir' doesn't
252 actually open a directory until the first call to
253 'readdir'. If 'readdir' fails to open the directory, it
254 sets errno to ENOTDIR; we convert it here to ENOENT so
255 that the error message is similar to what happens on
256 Posix hosts in such cases. */
257 if (errno
== ENOTDIR
)
260 report_file_error ("Opening directory", directory
);
266 len
= dirent_namelen (dp
);
267 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
268 GCPRO2 (finalname
, name
);
270 /* Note: DECODE_FILE can GC; it should protect its argument,
272 name
= DECODE_FILE (name
);
275 /* Now that we have unwind_protect in place, we might as well
276 allow matching to be interrupted. */
281 || re_search (bufp
, SSDATA (name
), len
, 0, len
, 0) >= 0)
290 Lisp_Object fullname
;
291 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
294 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
295 memcpy (SDATA (fullname
), SDATA (directory
),
299 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
301 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
304 nchars
= multibyte_chars_in_text (SDATA (fullname
), nbytes
);
306 /* Some bug somewhere. */
310 STRING_SET_CHARS (fullname
, nchars
);
311 if (nchars
== nbytes
)
312 STRING_SET_UNIBYTE (fullname
);
314 finalname
= fullname
;
321 Lisp_Object fileattrs
322 = file_attributes (fd
, dp
->d_name
, id_format
);
323 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
326 list
= Fcons (finalname
, list
);
337 Vw32_get_true_file_attributes
= w32_save
;
340 /* Discard the unwind protect. */
341 specpdl_ptr
= specpdl
+ count
;
344 list
= Fsort (Fnreverse (list
),
345 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
347 (void) directory_volatile
;
348 RETURN_UNGCPRO (list
);
352 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
353 doc
: /* Return a list of names of files in DIRECTORY.
354 There are three optional arguments:
355 If FULL is non-nil, return absolute file names. Otherwise return names
356 that are relative to the specified directory.
357 If MATCH is non-nil, mention only file names that match the regexp MATCH.
358 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
359 Otherwise, the list returned is sorted with `string-lessp'.
360 NOSORT is useful if you plan to sort the result yourself. */)
361 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
364 directory
= Fexpand_file_name (directory
, Qnil
);
366 /* If the file name has special constructs in it,
367 call the corresponding file handler. */
368 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
370 return call5 (handler
, Qdirectory_files
, directory
,
371 full
, match
, nosort
);
373 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
376 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
377 Sdirectory_files_and_attributes
, 1, 5, 0,
378 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
379 There are four optional arguments:
380 If FULL is non-nil, return absolute file names. Otherwise return names
381 that are relative to the specified directory.
382 If MATCH is non-nil, mention only file names that match the regexp MATCH.
383 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
384 NOSORT is useful if you plan to sort the result yourself.
385 ID-FORMAT specifies the preferred format of attributes uid and gid, see
386 `file-attributes' for further documentation.
387 On MS-Windows, performance depends on `w32-get-true-file-attributes',
389 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
392 directory
= Fexpand_file_name (directory
, Qnil
);
394 /* If the file name has special constructs in it,
395 call the corresponding file handler. */
396 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
398 return call6 (handler
, Qdirectory_files_and_attributes
,
399 directory
, full
, match
, nosort
, id_format
);
401 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
405 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
408 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
410 doc
: /* Complete file name FILE in directory DIRECTORY.
411 Returns the longest string
412 common to all file names in DIRECTORY that start with FILE.
413 If there is only one and FILE matches it exactly, returns t.
414 Returns nil if DIRECTORY contains no name starting with FILE.
416 If PREDICATE is non-nil, call PREDICATE with each possible
417 completion (in absolute form) and ignore it if PREDICATE returns nil.
419 This function ignores some of the possible completions as
420 determined by the variable `completion-ignored-extensions', which see. */)
421 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
424 directory
= Fexpand_file_name (directory
, Qnil
);
426 /* If the directory name has special constructs in it,
427 call the corresponding file handler. */
428 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
430 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
432 /* If the file name has special constructs in it,
433 call the corresponding file handler. */
434 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
436 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
438 return file_name_completion (file
, directory
, 0, predicate
);
441 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
442 Sfile_name_all_completions
, 2, 2, 0,
443 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
444 These are all file names in directory DIRECTORY which begin with FILE. */)
445 (Lisp_Object file
, Lisp_Object directory
)
448 directory
= Fexpand_file_name (directory
, Qnil
);
450 /* If the directory name has special constructs in it,
451 call the corresponding file handler. */
452 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
454 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
456 /* If the file name has special constructs in it,
457 call the corresponding file handler. */
458 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
460 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
462 return file_name_completion (file
, directory
, 1, Qnil
);
465 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
466 static Lisp_Object Qdefault_directory
;
469 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
470 Lisp_Object predicate
)
474 ptrdiff_t bestmatchsize
= 0;
476 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
477 If ALL_FLAG is 0, BESTMATCH is either nil
478 or the best match so far, not decoded. */
479 Lisp_Object bestmatch
, tem
, elt
, name
;
480 Lisp_Object encoded_file
;
481 Lisp_Object encoded_dir
;
484 /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
485 well as "." and "..". Until shown otherwise, assume we can't exclude
488 ptrdiff_t count
= SPECPDL_INDEX ();
489 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
496 encoded_file
= encoded_dir
= Qnil
;
497 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
498 specbind (Qdefault_directory
, dirname
);
500 /* Do completion on the encoded file name
501 because the other names in the directory are (we presume)
502 encoded likewise. We decode the completed string at the end. */
503 /* Actually, this is not quite true any more: we do most of the completion
504 work with decoded file names, but we still do some filtering based
505 on the encoded file name. */
506 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
508 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
510 d
= open_directory (SSDATA (encoded_dir
), &fd
);
512 report_file_error ("Opening directory", dirname
);
514 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
516 /* Loop reading blocks */
517 /* (att3b compiler bug requires do a null comparison this way) */
528 if (errno
== EAGAIN
|| errno
== EINTR
)
536 len
= dirent_namelen (dp
);
539 if (len
< SCHARS (encoded_file
)
540 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
541 SCHARS (encoded_file
))
545 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
548 directoryp
= S_ISDIR (st
.st_mode
) != 0;
550 /* If all_flag is set, always include all.
551 It would not actually be helpful to the user to ignore any possible
552 completions when making a list of them. */
557 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
558 /* If this entry matches the current bestmatch, the only
559 thing it can do is increase matchcount, so don't bother
560 investigating it any further. */
561 if (!completion_ignore_case
562 /* The return result depends on whether it's the sole match. */
564 && !includeall
/* This match may allow includeall to 0. */
565 && len
>= bestmatchsize
566 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
572 #ifndef TRIVIAL_DIRECTORY_ENTRY
573 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
575 /* "." and ".." are never interesting as completions, and are
576 actually in the way in a directory with only one file. */
577 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
579 else if (len
> SCHARS (encoded_file
))
580 /* Ignore directories if they match an element of
581 completion-ignored-extensions which ends in a slash. */
582 for (tem
= Vcompletion_ignored_extensions
;
583 CONSP (tem
); tem
= XCDR (tem
))
591 /* Need to encode ELT, since scmp compares unibyte
593 elt
= ENCODE_FILE (elt
);
594 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
598 if (p1
[elt_len
] != '/')
600 skip
= len
- elt_len
;
604 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
611 /* Compare extensions-to-be-ignored against end of this file name */
612 /* if name is not an exact match against specified string */
613 if (len
> SCHARS (encoded_file
))
614 /* and exit this for loop if a match is found */
615 for (tem
= Vcompletion_ignored_extensions
;
616 CONSP (tem
); tem
= XCDR (tem
))
619 if (!STRINGP (elt
)) continue;
620 /* Need to encode ELT, since scmp compares unibyte
622 elt
= ENCODE_FILE (elt
);
623 skip
= len
- SCHARS (elt
);
624 if (skip
< 0) continue;
626 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
633 /* If an ignored-extensions match was found,
634 don't process this name as a completion. */
638 if (!includeall
&& canexclude
)
639 /* We're not including all files and this file can be excluded. */
642 if (includeall
&& !canexclude
)
643 { /* If we have one non-excludable file, we want to exclude the
646 /* Throw away any previous excludable match found. */
652 /* FIXME: If we move this `decode' earlier we can eliminate
653 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
654 name
= make_unibyte_string (dp
->d_name
, len
);
655 name
= DECODE_FILE (name
);
660 /* Ignore this element if it fails to match all the regexps. */
661 if (completion_ignore_case
)
663 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
664 regexps
= XCDR (regexps
))
665 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
670 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
671 regexps
= XCDR (regexps
))
672 if (fast_string_match (XCAR (regexps
), name
) < 0)
680 /* This is a possible completion */
682 /* This completion is a directory; make it end with '/'. */
683 name
= Ffile_name_as_directory (name
);
685 /* Test the predicate, if any. */
686 if (!NILP (predicate
))
692 val
= call1 (predicate
, name
);
699 /* Suitably record this match. */
701 matchcount
+= matchcount
<= 1;
704 bestmatch
= Fcons (name
, bestmatch
);
705 else if (NILP (bestmatch
))
708 bestmatchsize
= SCHARS (name
);
712 Lisp_Object zero
= make_number (0);
713 /* FIXME: This is a copy of the code in Ftry_completion. */
714 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
716 = Fcompare_strings (bestmatch
, zero
,
717 make_number (compare
),
719 make_number (compare
),
720 completion_ignore_case
? Qt
: Qnil
);
721 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
723 if (completion_ignore_case
)
725 /* If this is an exact match except for case,
726 use it as the best match rather than one that is not
727 an exact match. This way, we get the case pattern
728 of the actual match. */
729 /* This tests that the current file is an exact match
730 but BESTMATCH is not (it is too long). */
731 if ((matchsize
== SCHARS (name
)
732 && matchsize
+ directoryp
< SCHARS (bestmatch
))
734 /* If there is no exact match ignoring case,
735 prefer a match that does not change the case
737 /* If there is more than one exact match aside from
738 case, and one of them is exact including case,
740 /* This == checks that, of current file and BESTMATCH,
741 either both or neither are exact. */
742 (((matchsize
== SCHARS (name
))
744 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
745 && (cmp
= Fcompare_strings (name
, zero
,
746 make_number (SCHARS (file
)),
751 && (cmp
= Fcompare_strings (bestmatch
, zero
,
752 make_number (SCHARS (file
)),
759 bestmatchsize
= matchsize
;
761 /* If the best completion so far is reduced to the string
762 we're trying to complete, then we already know there's no
763 other completion, so there's no point looking any further. */
764 if (matchsize
<= SCHARS (file
)
765 && !includeall
/* A future match may allow includeall to 0. */
766 /* If completion-ignore-case is non-nil, don't
767 short-circuit because we want to find the best
768 possible match *including* case differences. */
769 && (!completion_ignore_case
|| matchsize
== 0)
770 /* The return value depends on whether it's the sole match. */
778 /* This closes the directory. */
779 bestmatch
= unbind_to (count
, bestmatch
);
781 if (all_flag
|| NILP (bestmatch
))
783 /* Return t if the supplied string is an exact match (counting case);
784 it does not require any change to be made. */
785 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
787 bestmatch
= Fsubstring (bestmatch
, make_number (0),
788 make_number (bestmatchsize
));
792 /* Compare exactly LEN chars of strings at S1 and S2,
793 ignoring case if appropriate.
794 Return -1 if strings match,
795 else number of chars that match at the beginning. */
798 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
800 register ptrdiff_t l
= len
;
802 if (completion_ignore_case
)
805 && (downcase ((unsigned char) *s1
++)
806 == downcase ((unsigned char) *s2
++)))
811 while (l
&& *s1
++ == *s2
++)
821 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
826 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
827 but aren't required here. Avoid computing the following fields:
828 st_inode, st_size and st_nlink for directories, and the execute bits
829 in st_mode for non-directory files with non-standard extensions. */
831 unsigned short save_djstat_flags
= _djstat_flags
;
833 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
836 /* We want to return success if a link points to a nonexistent file,
837 but we want to return the status for what the link points to,
838 in case it is a directory. */
839 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
840 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
841 fstatat (fd
, dp
->d_name
, st_addr
, 0);
843 _djstat_flags
= save_djstat_flags
;
849 stat_uname (struct stat
*st
)
854 struct passwd
*pw
= getpwuid (st
->st_uid
);
864 stat_gname (struct stat
*st
)
869 struct group
*gr
= getgrgid (st
->st_gid
);
878 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
879 doc
: /* Return a list of attributes of file FILENAME.
880 Value is nil if specified file cannot be opened.
882 ID-FORMAT specifies the preferred format of attributes uid and gid (see
883 below) - valid values are 'string and 'integer. The latter is the
884 default, but we plan to change that, so you should specify a non-nil value
885 for ID-FORMAT if you use the returned uid or gid.
887 Elements of the attribute list are:
888 0. t for directory, string (name linked to) for symbolic link, or nil.
889 1. Number of links to file.
890 2. File uid as a string or a number. If a string value cannot be
891 looked up, a numeric value, either an integer or a float, is returned.
892 3. File gid, likewise.
893 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
894 same style as (current-time).
895 (See a note below about access time on FAT-based filesystems.)
896 5. Last modification time, likewise. This is the time of the last
897 change to the file's contents.
898 6. Last status change time, likewise. This is the time of last change
899 to the file's attributes: owner and group, access mode bits, etc.
901 This is a floating point number if the size is too large for an integer.
902 8. File modes, as a string of ten letters or dashes as in ls -l.
903 9. An unspecified value, present only for backward compatibility.
904 10. inode number. If it is larger than what an Emacs integer can hold,
905 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
906 If even HIGH is too large for an Emacs integer, this is instead of the form
907 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
908 and finally the low 16 bits.
909 11. Filesystem device number. If it is larger than what the Emacs
910 integer can hold, this is a cons cell, similar to the inode number.
912 On most filesystems, the combination of the inode and the device
913 number uniquely identifies the file.
915 On MS-Windows, performance depends on `w32-get-true-file-attributes',
918 On some FAT-based filesystems, only the date of last access is recorded,
919 so last access time will always be midnight of that day. */)
920 (Lisp_Object filename
, Lisp_Object id_format
)
925 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
927 if (!STRINGP (filename
))
930 /* If the file name has special constructs in it,
931 call the corresponding file handler. */
932 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
934 { /* Only pass the extra arg if it is used to help backward compatibility
935 with old file handlers which do not implement the new arg. --Stef */
936 if (NILP (id_format
))
937 return call2 (handler
, Qfile_attributes
, filename
);
939 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
942 encoded
= ENCODE_FILE (filename
);
943 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
947 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
949 Lisp_Object values
[12];
953 /* An array to hold the mode string generated by filemodestring,
954 including its terminating space and null byte. */
955 char modes
[sizeof "-rwxr-xr-x "];
957 char *uname
= NULL
, *gname
= NULL
;
960 /* We usually don't request accurate owner and group info, because
961 it can be very expensive on Windows to get that, and most callers
962 of 'lstat' don't need that. But here we do want that information
964 w32_stat_get_owner_group
= 1;
967 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
970 w32_stat_get_owner_group
= 0;
973 if (lstat_result
< 0)
976 values
[0] = (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
977 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
);
978 values
[1] = make_number (s
.st_nlink
);
980 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
983 uname
= stat_uname (&s
);
984 gname
= stat_gname (&s
);
988 values
[2] = DECODE_SYSTEM (build_unibyte_string (uname
));
990 values
[2] = make_fixnum_or_float (s
.st_uid
);
992 values
[3] = DECODE_SYSTEM (build_unibyte_string (gname
));
994 values
[3] = make_fixnum_or_float (s
.st_gid
);
996 values
[4] = make_lisp_time (get_stat_atime (&s
));
997 values
[5] = make_lisp_time (get_stat_mtime (&s
));
998 values
[6] = make_lisp_time (get_stat_ctime (&s
));
1000 /* If the file size is a 4-byte type, assume that files of sizes in
1001 the 2-4 GiB range wrap around to negative values, as this is a
1002 common bug on older 32-bit platforms. */
1003 if (sizeof (s
.st_size
) == 4)
1004 values
[7] = make_fixnum_or_float (s
.st_size
& 0xffffffffu
);
1006 values
[7] = make_fixnum_or_float (s
.st_size
);
1008 filemodestring (&s
, modes
);
1009 values
[8] = make_string (modes
, 10);
1011 values
[10] = INTEGER_TO_CONS (s
.st_ino
);
1012 values
[11] = INTEGER_TO_CONS (s
.st_dev
);
1014 return Flist (sizeof (values
) / sizeof (values
[0]), values
);
1017 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1018 doc
: /* Return t if first arg file attributes list is less than second.
1019 Comparison is in lexicographic order and case is significant. */)
1020 (Lisp_Object f1
, Lisp_Object f2
)
1022 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1026 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
1027 doc
: /* Return a list of user names currently registered in the system.
1028 If we don't know how to determine that on this platform, just
1029 return a list with one element, taken from `user-real-login-name'. */)
1032 Lisp_Object users
= Qnil
;
1033 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
1036 while ((pw
= getpwent ()))
1037 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
1041 if (EQ (users
, Qnil
))
1042 /* At least current user is always known. */
1043 users
= list1 (Vuser_real_login_name
);
1047 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
1048 doc
: /* Return a list of user group names currently registered in the system.
1049 The value may be nil if not supported on this platform. */)
1052 Lisp_Object groups
= Qnil
;
1053 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
1056 while ((gr
= getgrent ()))
1057 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1065 syms_of_dired (void)
1067 DEFSYM (Qdirectory_files
, "directory-files");
1068 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1069 DEFSYM (Qfile_name_completion
, "file-name-completion");
1070 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1071 DEFSYM (Qfile_attributes
, "file-attributes");
1072 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1073 DEFSYM (Qdefault_directory
, "default-directory");
1075 defsubr (&Sdirectory_files
);
1076 defsubr (&Sdirectory_files_and_attributes
);
1077 defsubr (&Sfile_name_completion
);
1078 defsubr (&Sfile_name_all_completions
);
1079 defsubr (&Sfile_attributes
);
1080 defsubr (&Sfile_attributes_lessp
);
1081 defsubr (&Ssystem_users
);
1082 defsubr (&Ssystem_groups
);
1084 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1085 doc
: /* Completion ignores file names ending in any string in this list.
1086 It does not ignore them if all possible completions end in one of
1087 these strings or when displaying a list of completions.
1088 It ignores directory names if they match any string in this list which
1089 ends in a slash. */);
1090 Vcompletion_ignored_extensions
= Qnil
;