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 ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
55 static Lisp_Object
file_attributes (int, char const *, Lisp_Object
);
57 /* Return the number of bytes in DP's name. */
59 dirent_namelen (struct dirent
*dp
)
61 #ifdef _D_EXACT_NAMLEN
62 return _D_EXACT_NAMLEN (dp
);
64 return strlen (dp
->d_name
);
69 open_directory (char const *name
, int *fdp
)
72 int fd
, opendir_errno
;
77 /* Directories cannot be opened. The emulation assumes that any
78 file descriptor other than AT_FDCWD corresponds to the most
79 recently opened directory. This hack is good enough for Emacs. */
82 opendir_errno
= errno
;
84 fd
= emacs_open (name
, O_RDONLY
| O_DIRECTORY
, 0);
87 opendir_errno
= errno
;
93 opendir_errno
= errno
;
102 errno
= opendir_errno
;
108 directory_files_internal_w32_unwind (Lisp_Object arg
)
110 Vw32_get_true_file_attributes
= arg
;
115 directory_files_internal_unwind (void *dh
)
123 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
124 If not ATTRS, return a list of directory filenames;
125 if ATTRS, return a list of directory filenames and their attributes.
126 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
129 directory_files_internal (Lisp_Object directory
, Lisp_Object full
,
130 Lisp_Object match
, Lisp_Object nosort
, bool attrs
,
131 Lisp_Object id_format
)
135 ptrdiff_t directory_nbytes
;
136 Lisp_Object list
, dirfilename
, encoded_directory
;
137 struct re_pattern_buffer
*bufp
= NULL
;
139 ptrdiff_t count
= SPECPDL_INDEX ();
140 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
143 Lisp_Object w32_save
= Qnil
;
146 /* Don't let the compiler optimize away all copies of DIRECTORY,
147 which would break GC; see Bug#16986. Although this is required
148 only in the common case where GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS,
149 it shouldn't break anything in the other cases. */
150 Lisp_Object
volatile directory_volatile
= directory
;
152 /* Because of file name handlers, these functions might call
153 Ffuncall, and cause a GC. */
154 list
= encoded_directory
= dirfilename
= Qnil
;
155 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
156 dirfilename
= Fdirectory_file_name (directory
);
160 CHECK_STRING (match
);
162 /* MATCH might be a flawed regular expression. Rather than
163 catching and signaling our own errors, we just call
164 compile_pattern to do the work for us. */
165 /* Pass 1 for the MULTIBYTE arg
166 because we do make multibyte strings if the contents warrant. */
168 /* Windows users want case-insensitive wildcards. */
169 bufp
= compile_pattern (match
, 0,
170 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
171 # else /* !WINDOWSNT */
172 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
173 # endif /* !WINDOWSNT */
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 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 w32_save
= Vw32_get_true_file_attributes
;
204 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
206 /* w32.c:stat will notice these bindings and avoid calling
207 GetDriveType for each file. */
208 if (is_slow_fs (SDATA (dirfilename
)))
209 Vw32_get_true_file_attributes
= Qnil
;
211 Vw32_get_true_file_attributes
= Qt
;
216 directory_nbytes
= SBYTES (directory
);
217 re_match_object
= Qt
;
219 /* Decide whether we need to add a directory separator. */
220 if (directory_nbytes
== 0
221 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
224 /* Loop reading blocks until EOF or error. */
229 Lisp_Object name
, finalname
;
230 struct gcpro gcpro1
, gcpro2
;
236 if (errno
== EAGAIN
|| errno
== EINTR
)
242 /* The MS-Windows implementation of 'opendir' doesn't
243 actually open a directory until the first call to
244 'readdir'. If 'readdir' fails to open the directory, it
245 sets errno to ENOENT or EACCES, see w32.c. */
247 report_file_error ("Opening directory", directory
);
252 len
= dirent_namelen (dp
);
253 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
254 GCPRO2 (finalname
, name
);
256 /* Note: DECODE_FILE can GC; it should protect its argument,
258 name
= DECODE_FILE (name
);
261 /* Now that we have unwind_protect in place, we might as well
262 allow matching to be interrupted. */
267 || re_search (bufp
, SSDATA (name
), len
, 0, len
, 0) >= 0)
276 Lisp_Object fullname
;
277 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
280 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
281 memcpy (SDATA (fullname
), SDATA (directory
),
285 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
287 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
290 nchars
= multibyte_chars_in_text (SDATA (fullname
), nbytes
);
292 /* Some bug somewhere. */
296 STRING_SET_CHARS (fullname
, nchars
);
297 if (nchars
== nbytes
)
298 STRING_SET_UNIBYTE (fullname
);
300 finalname
= fullname
;
307 Lisp_Object fileattrs
308 = file_attributes (fd
, dp
->d_name
, id_format
);
309 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
312 list
= Fcons (finalname
, list
);
323 Vw32_get_true_file_attributes
= w32_save
;
326 /* Discard the unwind protect. */
327 specpdl_ptr
= specpdl
+ count
;
330 list
= Fsort (Fnreverse (list
),
331 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
333 (void) directory_volatile
;
334 RETURN_UNGCPRO (list
);
338 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
339 doc
: /* Return a list of names of files in DIRECTORY.
340 There are three optional arguments:
341 If FULL is non-nil, return absolute file names. Otherwise return names
342 that are relative to the specified directory.
343 If MATCH is non-nil, mention only file names that match the regexp MATCH.
344 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
345 Otherwise, the list returned is sorted with `string-lessp'.
346 NOSORT is useful if you plan to sort the result yourself. */)
347 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
350 directory
= Fexpand_file_name (directory
, Qnil
);
352 /* If the file name has special constructs in it,
353 call the corresponding file handler. */
354 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
356 return call5 (handler
, Qdirectory_files
, directory
,
357 full
, match
, nosort
);
359 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
362 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
363 Sdirectory_files_and_attributes
, 1, 5, 0,
364 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
365 There are four optional arguments:
366 If FULL is non-nil, return absolute file names. Otherwise return names
367 that are relative to the specified directory.
368 If MATCH is non-nil, mention only file names that match the regexp MATCH.
369 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
370 NOSORT is useful if you plan to sort the result yourself.
371 ID-FORMAT specifies the preferred format of attributes uid and gid, see
372 `file-attributes' for further documentation.
373 On MS-Windows, performance depends on `w32-get-true-file-attributes',
375 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
378 directory
= Fexpand_file_name (directory
, Qnil
);
380 /* If the file name has special constructs in it,
381 call the corresponding file handler. */
382 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
384 return call6 (handler
, Qdirectory_files_and_attributes
,
385 directory
, full
, match
, nosort
, id_format
);
387 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
391 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
394 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
396 doc
: /* Complete file name FILE in directory DIRECTORY.
397 Returns the longest string
398 common to all file names in DIRECTORY that start with FILE.
399 If there is only one and FILE matches it exactly, returns t.
400 Returns nil if DIRECTORY contains no name starting with FILE.
402 If PREDICATE is non-nil, call PREDICATE with each possible
403 completion (in absolute form) and ignore it if PREDICATE returns nil.
405 This function ignores some of the possible completions as
406 determined by the variable `completion-ignored-extensions', which see. */)
407 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
410 directory
= Fexpand_file_name (directory
, Qnil
);
412 /* If the directory name has special constructs in it,
413 call the corresponding file handler. */
414 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
416 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
418 /* If the file name has special constructs in it,
419 call the corresponding file handler. */
420 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
422 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
424 return file_name_completion (file
, directory
, 0, predicate
);
427 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
428 Sfile_name_all_completions
, 2, 2, 0,
429 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
430 These are all file names in directory DIRECTORY which begin with FILE. */)
431 (Lisp_Object file
, Lisp_Object directory
)
434 directory
= Fexpand_file_name (directory
, Qnil
);
436 /* If the directory name has special constructs in it,
437 call the corresponding file handler. */
438 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
440 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
442 /* If the file name has special constructs in it,
443 call the corresponding file handler. */
444 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
446 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
448 return file_name_completion (file
, directory
, 1, Qnil
);
451 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
454 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
455 Lisp_Object predicate
)
459 ptrdiff_t bestmatchsize
= 0;
461 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
462 If ALL_FLAG is 0, BESTMATCH is either nil
463 or the best match so far, not decoded. */
464 Lisp_Object bestmatch
, tem
, elt
, name
;
465 Lisp_Object encoded_file
;
466 Lisp_Object encoded_dir
;
469 /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
470 well as "." and "..". Until shown otherwise, assume we can't exclude
473 ptrdiff_t count
= SPECPDL_INDEX ();
474 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
481 encoded_file
= encoded_dir
= Qnil
;
482 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
483 specbind (Qdefault_directory
, dirname
);
485 /* Do completion on the encoded file name
486 because the other names in the directory are (we presume)
487 encoded likewise. We decode the completed string at the end. */
488 /* Actually, this is not quite true any more: we do most of the completion
489 work with decoded file names, but we still do some filtering based
490 on the encoded file name. */
491 encoded_file
= ENCODE_FILE (file
);
493 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
495 d
= open_directory (SSDATA (encoded_dir
), &fd
);
497 report_file_error ("Opening directory", dirname
);
499 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
501 /* Loop reading blocks */
502 /* (att3b compiler bug requires do a null comparison this way) */
513 if (errno
== EAGAIN
|| errno
== EINTR
)
520 report_file_error ("Opening directory", dirname
);
525 len
= dirent_namelen (dp
);
528 if (len
< SCHARS (encoded_file
)
529 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
530 SCHARS (encoded_file
))
534 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
537 directoryp
= S_ISDIR (st
.st_mode
) != 0;
539 /* If all_flag is set, always include all.
540 It would not actually be helpful to the user to ignore any possible
541 completions when making a list of them. */
546 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
547 /* If this entry matches the current bestmatch, the only
548 thing it can do is increase matchcount, so don't bother
549 investigating it any further. */
550 if (!completion_ignore_case
551 /* The return result depends on whether it's the sole match. */
553 && !includeall
/* This match may allow includeall to 0. */
554 && len
>= bestmatchsize
555 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
561 #ifndef TRIVIAL_DIRECTORY_ENTRY
562 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
564 /* "." and ".." are never interesting as completions, and are
565 actually in the way in a directory with only one file. */
566 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
568 else if (len
> SCHARS (encoded_file
))
569 /* Ignore directories if they match an element of
570 completion-ignored-extensions which ends in a slash. */
571 for (tem
= Vcompletion_ignored_extensions
;
572 CONSP (tem
); tem
= XCDR (tem
))
580 /* Need to encode ELT, since scmp compares unibyte
582 elt
= ENCODE_FILE (elt
);
583 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
587 if (p1
[elt_len
] != '/')
589 skip
= len
- elt_len
;
593 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
600 /* Compare extensions-to-be-ignored against end of this file name */
601 /* if name is not an exact match against specified string */
602 if (len
> SCHARS (encoded_file
))
603 /* and exit this for loop if a match is found */
604 for (tem
= Vcompletion_ignored_extensions
;
605 CONSP (tem
); tem
= XCDR (tem
))
608 if (!STRINGP (elt
)) continue;
609 /* Need to encode ELT, since scmp compares unibyte
611 elt
= ENCODE_FILE (elt
);
612 skip
= len
- SCHARS (elt
);
613 if (skip
< 0) continue;
615 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
622 /* If an ignored-extensions match was found,
623 don't process this name as a completion. */
627 if (!includeall
&& canexclude
)
628 /* We're not including all files and this file can be excluded. */
631 if (includeall
&& !canexclude
)
632 { /* If we have one non-excludable file, we want to exclude the
635 /* Throw away any previous excludable match found. */
641 /* FIXME: If we move this `decode' earlier we can eliminate
642 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
643 name
= make_unibyte_string (dp
->d_name
, len
);
644 name
= DECODE_FILE (name
);
647 Lisp_Object regexps
, table
= (completion_ignore_case
648 ? Vascii_canon_table
: Qnil
);
650 /* Ignore this element if it fails to match all the regexps. */
651 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
652 regexps
= XCDR (regexps
))
653 if (fast_string_match_internal (XCAR (regexps
), name
, table
) < 0)
660 /* This is a possible completion */
662 /* This completion is a directory; make it end with '/'. */
663 name
= Ffile_name_as_directory (name
);
665 /* Test the predicate, if any. */
666 if (!NILP (predicate
))
672 val
= call1 (predicate
, name
);
679 /* Suitably record this match. */
681 matchcount
+= matchcount
<= 1;
684 bestmatch
= Fcons (name
, bestmatch
);
685 else if (NILP (bestmatch
))
688 bestmatchsize
= SCHARS (name
);
692 Lisp_Object zero
= make_number (0);
693 /* FIXME: This is a copy of the code in Ftry_completion. */
694 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
696 = Fcompare_strings (bestmatch
, zero
,
697 make_number (compare
),
699 make_number (compare
),
700 completion_ignore_case
? Qt
: Qnil
);
701 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
703 if (completion_ignore_case
)
705 /* If this is an exact match except for case,
706 use it as the best match rather than one that is not
707 an exact match. This way, we get the case pattern
708 of the actual match. */
709 /* This tests that the current file is an exact match
710 but BESTMATCH is not (it is too long). */
711 if ((matchsize
== SCHARS (name
)
712 && matchsize
+ directoryp
< SCHARS (bestmatch
))
714 /* If there is no exact match ignoring case,
715 prefer a match that does not change the case
717 /* If there is more than one exact match aside from
718 case, and one of them is exact including case,
720 /* This == checks that, of current file and BESTMATCH,
721 either both or neither are exact. */
722 (((matchsize
== SCHARS (name
))
724 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
725 && (cmp
= Fcompare_strings (name
, zero
,
726 make_number (SCHARS (file
)),
731 && (cmp
= Fcompare_strings (bestmatch
, zero
,
732 make_number (SCHARS (file
)),
739 bestmatchsize
= matchsize
;
741 /* If the best completion so far is reduced to the string
742 we're trying to complete, then we already know there's no
743 other completion, so there's no point looking any further. */
744 if (matchsize
<= SCHARS (file
)
745 && !includeall
/* A future match may allow includeall to 0. */
746 /* If completion-ignore-case is non-nil, don't
747 short-circuit because we want to find the best
748 possible match *including* case differences. */
749 && (!completion_ignore_case
|| matchsize
== 0)
750 /* The return value depends on whether it's the sole match. */
758 /* This closes the directory. */
759 bestmatch
= unbind_to (count
, bestmatch
);
761 if (all_flag
|| NILP (bestmatch
))
763 /* Return t if the supplied string is an exact match (counting case);
764 it does not require any change to be made. */
765 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
767 bestmatch
= Fsubstring (bestmatch
, make_number (0),
768 make_number (bestmatchsize
));
772 /* Compare exactly LEN chars of strings at S1 and S2,
773 ignoring case if appropriate.
774 Return -1 if strings match,
775 else number of chars that match at the beginning. */
778 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
780 register ptrdiff_t l
= len
;
782 if (completion_ignore_case
)
785 && (downcase ((unsigned char) *s1
++)
786 == downcase ((unsigned char) *s2
++)))
791 while (l
&& *s1
++ == *s2
++)
801 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
806 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
807 but aren't required here. Avoid computing the following fields:
808 st_inode, st_size and st_nlink for directories, and the execute bits
809 in st_mode for non-directory files with non-standard extensions. */
811 unsigned short save_djstat_flags
= _djstat_flags
;
813 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
816 /* We want to return success if a link points to a nonexistent file,
817 but we want to return the status for what the link points to,
818 in case it is a directory. */
819 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
820 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
821 fstatat (fd
, dp
->d_name
, st_addr
, 0);
823 _djstat_flags
= save_djstat_flags
;
829 stat_uname (struct stat
*st
)
834 struct passwd
*pw
= getpwuid (st
->st_uid
);
844 stat_gname (struct stat
*st
)
849 struct group
*gr
= getgrgid (st
->st_gid
);
858 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
859 doc
: /* Return a list of attributes of file FILENAME.
860 Value is nil if specified file cannot be opened.
862 ID-FORMAT specifies the preferred format of attributes uid and gid (see
863 below) - valid values are 'string and 'integer. The latter is the
864 default, but we plan to change that, so you should specify a non-nil value
865 for ID-FORMAT if you use the returned uid or gid.
867 Elements of the attribute list are:
868 0. t for directory, string (name linked to) for symbolic link, or nil.
869 1. Number of links to file.
870 2. File uid as a string or a number. If a string value cannot be
871 looked up, a numeric value, either an integer or a float, is returned.
872 3. File gid, likewise.
873 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
874 same style as (current-time).
875 (See a note below about access time on FAT-based filesystems.)
876 5. Last modification time, likewise. This is the time of the last
877 change to the file's contents.
878 6. Last status change time, likewise. This is the time of last change
879 to the file's attributes: owner and group, access mode bits, etc.
881 This is a floating point number if the size is too large for an integer.
882 8. File modes, as a string of ten letters or dashes as in ls -l.
883 9. An unspecified value, present only for backward compatibility.
884 10. inode number. If it is larger than what an Emacs integer can hold,
885 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
886 If even HIGH is too large for an Emacs integer, this is instead of the form
887 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
888 and finally the low 16 bits.
889 11. Filesystem device number. If it is larger than what the Emacs
890 integer can hold, this is a cons cell, similar to the inode number.
892 On most filesystems, the combination of the inode and the device
893 number uniquely identifies the file.
895 On MS-Windows, performance depends on `w32-get-true-file-attributes',
898 On some FAT-based filesystems, only the date of last access is recorded,
899 so last access time will always be midnight of that day. */)
900 (Lisp_Object filename
, Lisp_Object id_format
)
905 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
907 if (!STRINGP (filename
))
910 /* If the file name has special constructs in it,
911 call the corresponding file handler. */
912 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
914 { /* Only pass the extra arg if it is used to help backward compatibility
915 with old file handlers which do not implement the new arg. --Stef */
916 if (NILP (id_format
))
917 return call2 (handler
, Qfile_attributes
, filename
);
919 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
922 encoded
= ENCODE_FILE (filename
);
923 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
927 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
932 /* An array to hold the mode string generated by filemodestring,
933 including its terminating space and null byte. */
934 char modes
[sizeof "-rwxr-xr-x "];
936 char *uname
= NULL
, *gname
= NULL
;
939 /* We usually don't request accurate owner and group info, because
940 it can be very expensive on Windows to get that, and most callers
941 of 'lstat' don't need that. But here we do want that information
943 w32_stat_get_owner_group
= 1;
946 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
949 w32_stat_get_owner_group
= 0;
952 if (lstat_result
< 0)
955 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
958 uname
= stat_uname (&s
);
959 gname
= stat_gname (&s
);
963 filemodestring (&s
, modes
);
966 (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
967 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
),
968 make_number (s
.st_nlink
),
970 ? DECODE_SYSTEM (build_unibyte_string (uname
))
971 : make_fixnum_or_float (s
.st_uid
)),
973 ? DECODE_SYSTEM (build_unibyte_string (gname
))
974 : make_fixnum_or_float (s
.st_gid
)),
975 make_lisp_time (get_stat_atime (&s
)),
976 make_lisp_time (get_stat_mtime (&s
)),
977 make_lisp_time (get_stat_ctime (&s
)),
979 /* If the file size is a 4-byte type, assume that
980 files of sizes in the 2-4 GiB range wrap around to
981 negative values, as this is a common bug on older
983 make_fixnum_or_float (sizeof (s
.st_size
) == 4
984 ? s
.st_size
& 0xffffffffu
987 make_string (modes
, 10),
989 INTEGER_TO_CONS (s
.st_ino
),
990 INTEGER_TO_CONS (s
.st_dev
));
993 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
994 doc
: /* Return t if first arg file attributes list is less than second.
995 Comparison is in lexicographic order and case is significant. */)
996 (Lisp_Object f1
, Lisp_Object f2
)
998 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1002 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
1003 doc
: /* Return a list of user names currently registered in the system.
1004 If we don't know how to determine that on this platform, just
1005 return a list with one element, taken from `user-real-login-name'. */)
1008 Lisp_Object users
= Qnil
;
1009 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
1012 while ((pw
= getpwent ()))
1013 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
1017 if (EQ (users
, Qnil
))
1018 /* At least current user is always known. */
1019 users
= list1 (Vuser_real_login_name
);
1023 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
1024 doc
: /* Return a list of user group names currently registered in the system.
1025 The value may be nil if not supported on this platform. */)
1028 Lisp_Object groups
= Qnil
;
1029 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
1032 while ((gr
= getgrent ()))
1033 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1041 syms_of_dired (void)
1043 DEFSYM (Qdirectory_files
, "directory-files");
1044 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1045 DEFSYM (Qfile_name_completion
, "file-name-completion");
1046 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1047 DEFSYM (Qfile_attributes
, "file-attributes");
1048 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1049 DEFSYM (Qdefault_directory
, "default-directory");
1051 defsubr (&Sdirectory_files
);
1052 defsubr (&Sdirectory_files_and_attributes
);
1053 defsubr (&Sfile_name_completion
);
1054 defsubr (&Sfile_name_all_completions
);
1055 defsubr (&Sfile_attributes
);
1056 defsubr (&Sfile_attributes_lessp
);
1057 defsubr (&Ssystem_users
);
1058 defsubr (&Ssystem_groups
);
1060 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1061 doc
: /* Completion ignores file names ending in any string in this list.
1062 It does not ignore them if all possible completions end in one of
1063 these strings or when displaying a list of completions.
1064 It ignores directory names if they match any string in this list which
1065 ends in a slash. */);
1066 Vcompletion_ignored_extensions
= Qnil
;