1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985-1986, 1993-1994, 1999-2014 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
;
147 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
150 /* Because of file name handlers, these functions might call
151 Ffuncall, and cause a GC. */
152 list
= encoded_directory
= dirfilename
= Qnil
;
153 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
154 dirfilename
= Fdirectory_file_name (directory
);
158 CHECK_STRING (match
);
160 /* MATCH might be a flawed regular expression. Rather than
161 catching and signaling our own errors, we just call
162 compile_pattern to do the work for us. */
163 /* Pass 1 for the MULTIBYTE arg
164 because we do make multibyte strings if the contents warrant. */
166 /* Windows users want case-insensitive wildcards. */
167 bufp
= compile_pattern (match
, 0,
168 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
169 # else /* !WINDOWSNT */
170 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
171 # endif /* !WINDOWSNT */
174 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
175 run_pre_post_conversion_on_str which calls Lisp directly and
177 if (STRING_MULTIBYTE (dirfilename
))
178 dirfilename
= ENCODE_FILE (dirfilename
);
179 encoded_directory
= (STRING_MULTIBYTE (directory
)
180 ? ENCODE_FILE (directory
) : 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 d
= open_directory (SSDATA (dirfilename
), &fd
);
187 report_file_error ("Opening directory", directory
);
189 /* Unfortunately, we can now invoke expand-file-name and
190 file-attributes on filenames, both of which can throw, so we must
191 do a proper unwind-protect. */
192 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
197 extern int is_slow_fs (const char *);
199 /* Do this only once to avoid doing it (in w32.c:stat) for each
200 file in the directory, when we call Ffile_attributes below. */
201 record_unwind_protect (directory_files_internal_w32_unwind
,
202 Vw32_get_true_file_attributes
);
203 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
205 /* w32.c:stat will notice these bindings and avoid calling
206 GetDriveType for each file. */
207 if (is_slow_fs (SDATA (dirfilename
)))
208 Vw32_get_true_file_attributes
= Qnil
;
210 Vw32_get_true_file_attributes
= Qt
;
215 directory_nbytes
= SBYTES (directory
);
216 re_match_object
= Qt
;
218 /* Decide whether we need to add a directory separator. */
219 if (directory_nbytes
== 0
220 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
223 /* Loop reading blocks until EOF or error. */
228 Lisp_Object name
, finalname
;
229 struct gcpro gcpro1
, gcpro2
;
235 if (errno
== EAGAIN
|| errno
== EINTR
)
243 len
= dirent_namelen (dp
);
244 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
245 GCPRO2 (finalname
, name
);
247 /* Note: DECODE_FILE can GC; it should protect its argument,
249 name
= DECODE_FILE (name
);
252 /* Now that we have unwind_protect in place, we might as well
253 allow matching to be interrupted. */
258 || re_search (bufp
, SSDATA (name
), len
, 0, len
, 0) >= 0)
267 Lisp_Object fullname
;
268 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
271 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
272 memcpy (SDATA (fullname
), SDATA (directory
),
276 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
278 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
281 nchars
= multibyte_chars_in_text (SDATA (fullname
), nbytes
);
283 /* Some bug somewhere. */
287 STRING_SET_CHARS (fullname
, nchars
);
288 if (nchars
== nbytes
)
289 STRING_SET_UNIBYTE (fullname
);
291 finalname
= fullname
;
298 Lisp_Object fileattrs
299 = file_attributes (fd
, dp
->d_name
, id_format
);
300 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
303 list
= Fcons (finalname
, list
);
312 list
= Fsort (Fnreverse (list
),
313 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
319 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
320 doc
: /* Return a list of names of files in DIRECTORY.
321 There are three optional arguments:
322 If FULL is non-nil, return absolute file names. Otherwise return names
323 that are relative to the specified directory.
324 If MATCH is non-nil, mention only file names that match the regexp MATCH.
325 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
326 Otherwise, the list returned is sorted with `string-lessp'.
327 NOSORT is useful if you plan to sort the result yourself. */)
328 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
331 directory
= Fexpand_file_name (directory
, Qnil
);
333 /* If the file name has special constructs in it,
334 call the corresponding file handler. */
335 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
337 return call5 (handler
, Qdirectory_files
, directory
,
338 full
, match
, nosort
);
340 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
343 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
344 Sdirectory_files_and_attributes
, 1, 5, 0,
345 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
346 There are four optional arguments:
347 If FULL is non-nil, return absolute file names. Otherwise return names
348 that are relative to the specified directory.
349 If MATCH is non-nil, mention only file names that match the regexp MATCH.
350 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
351 NOSORT is useful if you plan to sort the result yourself.
352 ID-FORMAT specifies the preferred format of attributes uid and gid, see
353 `file-attributes' for further documentation.
354 On MS-Windows, performance depends on `w32-get-true-file-attributes',
356 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
359 directory
= Fexpand_file_name (directory
, Qnil
);
361 /* If the file name has special constructs in it,
362 call the corresponding file handler. */
363 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
365 return call6 (handler
, Qdirectory_files_and_attributes
,
366 directory
, full
, match
, nosort
, id_format
);
368 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
372 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
375 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
377 doc
: /* Complete file name FILE in directory DIRECTORY.
378 Returns the longest string
379 common to all file names in DIRECTORY that start with FILE.
380 If there is only one and FILE matches it exactly, returns t.
381 Returns nil if DIRECTORY contains no name starting with FILE.
383 If PREDICATE is non-nil, call PREDICATE with each possible
384 completion (in absolute form) and ignore it if PREDICATE returns nil.
386 This function ignores some of the possible completions as
387 determined by the variable `completion-ignored-extensions', which see. */)
388 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
391 directory
= Fexpand_file_name (directory
, Qnil
);
393 /* If the directory name has special constructs in it,
394 call the corresponding file handler. */
395 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
397 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
399 /* If the file name has special constructs in it,
400 call the corresponding file handler. */
401 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
403 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
405 return file_name_completion (file
, directory
, 0, predicate
);
408 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
409 Sfile_name_all_completions
, 2, 2, 0,
410 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
411 These are all file names in directory DIRECTORY which begin with FILE. */)
412 (Lisp_Object file
, Lisp_Object directory
)
415 directory
= Fexpand_file_name (directory
, Qnil
);
417 /* If the directory name has special constructs in it,
418 call the corresponding file handler. */
419 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
421 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
423 /* If the file name has special constructs in it,
424 call the corresponding file handler. */
425 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
427 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
429 return file_name_completion (file
, directory
, 1, Qnil
);
432 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
433 static Lisp_Object Qdefault_directory
;
436 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
437 Lisp_Object predicate
)
441 ptrdiff_t bestmatchsize
= 0;
443 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
444 If ALL_FLAG is 0, BESTMATCH is either nil
445 or the best match so far, not decoded. */
446 Lisp_Object bestmatch
, tem
, elt
, name
;
447 Lisp_Object encoded_file
;
448 Lisp_Object encoded_dir
;
451 /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
452 well as "." and "..". Until shown otherwise, assume we can't exclude
456 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
463 encoded_file
= encoded_dir
= Qnil
;
464 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
465 specbind (Qdefault_directory
, dirname
);
467 /* Do completion on the encoded file name
468 because the other names in the directory are (we presume)
469 encoded likewise. We decode the completed string at the end. */
470 /* Actually, this is not quite true any more: we do most of the completion
471 work with decoded file names, but we still do some filtering based
472 on the encoded file name. */
473 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
475 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
477 d
= open_directory (SSDATA (encoded_dir
), &fd
);
479 report_file_error ("Opening directory", dirname
);
481 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
483 /* Loop reading blocks */
484 /* (att3b compiler bug requires do a null comparison this way) */
495 if (errno
== EAGAIN
|| errno
== EINTR
)
503 len
= dirent_namelen (dp
);
506 if (len
< SCHARS (encoded_file
)
507 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
508 SCHARS (encoded_file
))
512 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
515 directoryp
= S_ISDIR (st
.st_mode
) != 0;
517 /* If all_flag is set, always include all.
518 It would not actually be helpful to the user to ignore any possible
519 completions when making a list of them. */
524 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
525 /* If this entry matches the current bestmatch, the only
526 thing it can do is increase matchcount, so don't bother
527 investigating it any further. */
528 if (!completion_ignore_case
529 /* The return result depends on whether it's the sole match. */
531 && !includeall
/* This match may allow includeall to 0. */
532 && len
>= bestmatchsize
533 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
539 #ifndef TRIVIAL_DIRECTORY_ENTRY
540 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
542 /* "." and ".." are never interesting as completions, and are
543 actually in the way in a directory with only one file. */
544 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
546 else if (len
> SCHARS (encoded_file
))
547 /* Ignore directories if they match an element of
548 completion-ignored-extensions which ends in a slash. */
549 for (tem
= Vcompletion_ignored_extensions
;
550 CONSP (tem
); tem
= XCDR (tem
))
558 /* Need to encode ELT, since scmp compares unibyte
560 elt
= ENCODE_FILE (elt
);
561 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
565 if (p1
[elt_len
] != '/')
567 skip
= len
- elt_len
;
571 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
578 /* Compare extensions-to-be-ignored against end of this file name */
579 /* if name is not an exact match against specified string */
580 if (len
> SCHARS (encoded_file
))
581 /* and exit this for loop if a match is found */
582 for (tem
= Vcompletion_ignored_extensions
;
583 CONSP (tem
); tem
= XCDR (tem
))
586 if (!STRINGP (elt
)) continue;
587 /* Need to encode ELT, since scmp compares unibyte
589 elt
= ENCODE_FILE (elt
);
590 skip
= len
- SCHARS (elt
);
591 if (skip
< 0) continue;
593 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
600 /* If an ignored-extensions match was found,
601 don't process this name as a completion. */
605 if (!includeall
&& canexclude
)
606 /* We're not including all files and this file can be excluded. */
609 if (includeall
&& !canexclude
)
610 { /* If we have one non-excludable file, we want to exclude the
613 /* Throw away any previous excludable match found. */
619 /* FIXME: If we move this `decode' earlier we can eliminate
620 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
621 name
= make_unibyte_string (dp
->d_name
, len
);
622 name
= DECODE_FILE (name
);
627 /* Ignore this element if it fails to match all the regexps. */
628 if (completion_ignore_case
)
630 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
631 regexps
= XCDR (regexps
))
632 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
637 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
638 regexps
= XCDR (regexps
))
639 if (fast_string_match (XCAR (regexps
), name
) < 0)
647 /* This is a possible completion */
649 /* This completion is a directory; make it end with '/'. */
650 name
= Ffile_name_as_directory (name
);
652 /* Test the predicate, if any. */
653 if (!NILP (predicate
))
659 val
= call1 (predicate
, name
);
666 /* Suitably record this match. */
668 matchcount
+= matchcount
<= 1;
671 bestmatch
= Fcons (name
, bestmatch
);
672 else if (NILP (bestmatch
))
675 bestmatchsize
= SCHARS (name
);
679 Lisp_Object zero
= make_number (0);
680 /* FIXME: This is a copy of the code in Ftry_completion. */
681 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
683 = Fcompare_strings (bestmatch
, zero
,
684 make_number (compare
),
686 make_number (compare
),
687 completion_ignore_case
? Qt
: Qnil
);
688 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
690 if (completion_ignore_case
)
692 /* If this is an exact match except for case,
693 use it as the best match rather than one that is not
694 an exact match. This way, we get the case pattern
695 of the actual match. */
696 /* This tests that the current file is an exact match
697 but BESTMATCH is not (it is too long). */
698 if ((matchsize
== SCHARS (name
)
699 && matchsize
+ directoryp
< SCHARS (bestmatch
))
701 /* If there is no exact match ignoring case,
702 prefer a match that does not change the case
704 /* If there is more than one exact match aside from
705 case, and one of them is exact including case,
707 /* This == checks that, of current file and BESTMATCH,
708 either both or neither are exact. */
709 (((matchsize
== SCHARS (name
))
711 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
712 && (cmp
= Fcompare_strings (name
, zero
,
713 make_number (SCHARS (file
)),
718 && (cmp
= Fcompare_strings (bestmatch
, zero
,
719 make_number (SCHARS (file
)),
726 bestmatchsize
= matchsize
;
728 /* If the best completion so far is reduced to the string
729 we're trying to complete, then we already know there's no
730 other completion, so there's no point looking any further. */
731 if (matchsize
<= SCHARS (file
)
732 && !includeall
/* A future match may allow includeall to 0. */
733 /* If completion-ignore-case is non-nil, don't
734 short-circuit because we want to find the best
735 possible match *including* case differences. */
736 && (!completion_ignore_case
|| matchsize
== 0)
737 /* The return value depends on whether it's the sole match. */
745 /* This closes the directory. */
748 if (all_flag
|| NILP (bestmatch
))
750 /* Return t if the supplied string is an exact match (counting case);
751 it does not require any change to be made. */
752 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
754 bestmatch
= Fsubstring (bestmatch
, make_number (0),
755 make_number (bestmatchsize
));
759 /* Compare exactly LEN chars of strings at S1 and S2,
760 ignoring case if appropriate.
761 Return -1 if strings match,
762 else number of chars that match at the beginning. */
765 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
767 register ptrdiff_t l
= len
;
769 if (completion_ignore_case
)
772 && (downcase ((unsigned char) *s1
++)
773 == downcase ((unsigned char) *s2
++)))
778 while (l
&& *s1
++ == *s2
++)
788 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
793 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
794 but aren't required here. Avoid computing the following fields:
795 st_inode, st_size and st_nlink for directories, and the execute bits
796 in st_mode for non-directory files with non-standard extensions. */
798 unsigned short save_djstat_flags
= _djstat_flags
;
800 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
803 /* We want to return success if a link points to a nonexistent file,
804 but we want to return the status for what the link points to,
805 in case it is a directory. */
806 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
807 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
808 fstatat (fd
, dp
->d_name
, st_addr
, 0);
810 _djstat_flags
= save_djstat_flags
;
816 stat_uname (struct stat
*st
)
821 struct passwd
*pw
= getpwuid (st
->st_uid
);
831 stat_gname (struct stat
*st
)
836 struct group
*gr
= getgrgid (st
->st_gid
);
845 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
846 doc
: /* Return a list of attributes of file FILENAME.
847 Value is nil if specified file cannot be opened.
849 ID-FORMAT specifies the preferred format of attributes uid and gid (see
850 below) - valid values are 'string and 'integer. The latter is the
851 default, but we plan to change that, so you should specify a non-nil value
852 for ID-FORMAT if you use the returned uid or gid.
854 Elements of the attribute list are:
855 0. t for directory, string (name linked to) for symbolic link, or nil.
856 1. Number of links to file.
857 2. File uid as a string or a number. If a string value cannot be
858 looked up, a numeric value, either an integer or a float, is returned.
859 3. File gid, likewise.
860 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
861 same style as (current-time).
862 (See a note below about access time on FAT-based filesystems.)
863 5. Last modification time, likewise. This is the time of the last
864 change to the file's contents.
865 6. Last status change time, likewise. This is the time of last change
866 to the file's attributes: owner and group, access mode bits, etc.
868 This is a floating point number if the size is too large for an integer.
869 8. File modes, as a string of ten letters or dashes as in ls -l.
870 9. An unspecified value, present only for backward compatibility.
871 10. inode number. If it is larger than what an Emacs integer can hold,
872 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
873 If even HIGH is too large for an Emacs integer, this is instead of the form
874 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
875 and finally the low 16 bits.
876 11. Filesystem device number. If it is larger than what the Emacs
877 integer can hold, this is a cons cell, similar to the inode number.
879 On most filesystems, the combination of the inode and the device
880 number uniquely identifies the file.
882 On MS-Windows, performance depends on `w32-get-true-file-attributes',
885 On some FAT-based filesystems, only the date of last access is recorded,
886 so last access time will always be midnight of that day. */)
887 (Lisp_Object filename
, Lisp_Object id_format
)
892 filename
= Fexpand_file_name (filename
, Qnil
);
894 /* If the file name has special constructs in it,
895 call the corresponding file handler. */
896 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
898 { /* Only pass the extra arg if it is used to help backward compatibility
899 with old file handlers which do not implement the new arg. --Stef */
900 if (NILP (id_format
))
901 return call2 (handler
, Qfile_attributes
, filename
);
903 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
906 encoded
= ENCODE_FILE (filename
);
907 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
911 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
913 Lisp_Object values
[12];
917 /* An array to hold the mode string generated by filemodestring,
918 including its terminating space and null byte. */
919 char modes
[sizeof "-rwxr-xr-x "];
921 char *uname
= NULL
, *gname
= NULL
;
924 /* We usually don't request accurate owner and group info, because
925 it can be very expensive on Windows to get that, and most callers
926 of 'lstat' don't need that. But here we do want that information
928 w32_stat_get_owner_group
= 1;
931 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
934 w32_stat_get_owner_group
= 0;
937 if (lstat_result
< 0)
940 values
[0] = (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
941 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
);
942 values
[1] = make_number (s
.st_nlink
);
944 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
947 uname
= stat_uname (&s
);
948 gname
= stat_gname (&s
);
952 values
[2] = DECODE_SYSTEM (build_unibyte_string (uname
));
954 values
[2] = make_fixnum_or_float (s
.st_uid
);
956 values
[3] = DECODE_SYSTEM (build_unibyte_string (gname
));
958 values
[3] = make_fixnum_or_float (s
.st_gid
);
960 values
[4] = make_lisp_time (get_stat_atime (&s
));
961 values
[5] = make_lisp_time (get_stat_mtime (&s
));
962 values
[6] = make_lisp_time (get_stat_ctime (&s
));
964 /* If the file size is a 4-byte type, assume that files of sizes in
965 the 2-4 GiB range wrap around to negative values, as this is a
966 common bug on older 32-bit platforms. */
967 if (sizeof (s
.st_size
) == 4)
968 values
[7] = make_fixnum_or_float (s
.st_size
& 0xffffffffu
);
970 values
[7] = make_fixnum_or_float (s
.st_size
);
972 filemodestring (&s
, modes
);
973 values
[8] = make_string (modes
, 10);
975 values
[10] = INTEGER_TO_CONS (s
.st_ino
);
976 values
[11] = INTEGER_TO_CONS (s
.st_dev
);
978 return Flist (ARRAYELTS (values
), values
);
981 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
982 doc
: /* Return t if first arg file attributes list is less than second.
983 Comparison is in lexicographic order and case is significant. */)
984 (Lisp_Object f1
, Lisp_Object f2
)
986 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
990 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
991 doc
: /* Return a list of user names currently registered in the system.
992 If we don't know how to determine that on this platform, just
993 return a list with one element, taken from `user-real-login-name'. */)
996 Lisp_Object users
= Qnil
;
997 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
1000 while ((pw
= getpwent ()))
1001 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
1005 if (EQ (users
, Qnil
))
1006 /* At least current user is always known. */
1007 users
= list1 (Vuser_real_login_name
);
1011 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
1012 doc
: /* Return a list of user group names currently registered in the system.
1013 The value may be nil if not supported on this platform. */)
1016 Lisp_Object groups
= Qnil
;
1017 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
1020 while ((gr
= getgrent ()))
1021 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1029 syms_of_dired (void)
1033 DEFSYM (Qdirectory_files
, "directory-files");
1034 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1035 DEFSYM (Qfile_name_completion
, "file-name-completion");
1036 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1037 DEFSYM (Qfile_attributes
, "file-attributes");
1038 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1039 DEFSYM (Qdefault_directory
, "default-directory");
1041 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1042 doc
: /* Completion ignores file names ending in any string in this list.
1043 It does not ignore them if all possible completions end in one of
1044 these strings or when displaying a list of completions.
1045 It ignores directory names if they match any string in this list which
1046 ends in a slash. */);
1047 Vcompletion_ignored_extensions
= Qnil
;