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 (Lisp_Object dirname
, int *fdp
)
71 char *name
= SSDATA (dirname
);
73 int fd
, opendir_errno
;
78 /* Directories cannot be opened. The emulation assumes that any
79 file descriptor other than AT_FDCWD corresponds to the most
80 recently opened directory. This hack is good enough for Emacs. */
83 opendir_errno
= errno
;
85 fd
= emacs_open (name
, O_RDONLY
| O_DIRECTORY
, 0);
88 opendir_errno
= errno
;
94 opendir_errno
= errno
;
103 report_file_errno ("Opening directory", dirname
, opendir_errno
);
110 directory_files_internal_w32_unwind (Lisp_Object arg
)
112 Vw32_get_true_file_attributes
= arg
;
117 directory_files_internal_unwind (void *dh
)
125 /* Return the next directory entry from DIR; DIR's name is DIRNAME.
126 If there are no more directory entries, return a null pointer.
127 Signal any unrecoverable errors. */
129 static struct dirent
*
130 read_dirent (DIR *dir
, Lisp_Object dirname
)
135 struct dirent
*dp
= readdir (dir
);
136 if (dp
|| errno
== 0)
138 if (! (errno
== EAGAIN
|| errno
== EINTR
))
141 /* The MS-Windows implementation of 'opendir' doesn't
142 actually open a directory until the first call to
143 'readdir'. If 'readdir' fails to open the directory, it
144 sets errno to ENOENT or EACCES, see w32.c. */
145 if (errno
== ENOENT
|| errno
== EACCES
)
146 report_file_error ("Opening directory", dirname
);
148 report_file_error ("Reading directory", dirname
);
154 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
155 If not ATTRS, return a list of directory filenames;
156 if ATTRS, return a list of directory filenames and their attributes.
157 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
160 directory_files_internal (Lisp_Object directory
, Lisp_Object full
,
161 Lisp_Object match
, Lisp_Object nosort
, bool attrs
,
162 Lisp_Object id_format
)
164 ptrdiff_t directory_nbytes
;
165 Lisp_Object list
, dirfilename
, encoded_directory
;
166 struct re_pattern_buffer
*bufp
= NULL
;
168 ptrdiff_t count
= SPECPDL_INDEX ();
170 Lisp_Object w32_save
= Qnil
;
173 /* Don't let the compiler optimize away all copies of DIRECTORY,
174 which would break GC; see Bug#16986. */
175 Lisp_Object
volatile directory_volatile
= directory
;
177 /* Because of file name handlers, these functions might call
178 Ffuncall, and cause a GC. */
179 list
= encoded_directory
= dirfilename
= Qnil
;
180 dirfilename
= Fdirectory_file_name (directory
);
184 CHECK_STRING (match
);
186 /* MATCH might be a flawed regular expression. Rather than
187 catching and signaling our own errors, we just call
188 compile_pattern to do the work for us. */
189 /* Pass 1 for the MULTIBYTE arg
190 because we do make multibyte strings if the contents warrant. */
192 /* Windows users want case-insensitive wildcards. */
193 bufp
= compile_pattern (match
, 0,
194 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
195 # else /* !WINDOWSNT */
196 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
197 # endif /* !WINDOWSNT */
200 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
201 run_pre_post_conversion_on_str which calls Lisp directly and
203 dirfilename
= ENCODE_FILE (dirfilename
);
204 encoded_directory
= ENCODE_FILE (directory
);
206 /* Now *bufp is the compiled form of MATCH; don't call anything
207 which might compile a new regexp until we're done with the loop! */
210 DIR *d
= open_directory (dirfilename
, &fd
);
212 /* Unfortunately, we can now invoke expand-file-name and
213 file-attributes on filenames, both of which can throw, so we must
214 do a proper unwind-protect. */
215 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
220 extern int is_slow_fs (const char *);
222 /* Do this only once to avoid doing it (in w32.c:stat) for each
223 file in the directory, when we call Ffile_attributes below. */
224 record_unwind_protect (directory_files_internal_w32_unwind
,
225 Vw32_get_true_file_attributes
);
226 w32_save
= Vw32_get_true_file_attributes
;
227 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
229 /* w32.c:stat will notice these bindings and avoid calling
230 GetDriveType for each file. */
231 if (is_slow_fs (SDATA (dirfilename
)))
232 Vw32_get_true_file_attributes
= Qnil
;
234 Vw32_get_true_file_attributes
= Qt
;
239 directory_nbytes
= SBYTES (directory
);
240 re_match_object
= Qt
;
242 /* Decide whether we need to add a directory separator. */
243 if (directory_nbytes
== 0
244 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
247 /* Loop reading directory entries. */
248 for (struct dirent
*dp
; (dp
= read_dirent (d
, directory
)); )
250 ptrdiff_t len
= dirent_namelen (dp
);
251 Lisp_Object name
= make_unibyte_string (dp
->d_name
, len
);
252 Lisp_Object finalname
= name
;
254 /* Note: DECODE_FILE can GC; it should protect its argument,
256 name
= DECODE_FILE (name
);
259 /* Now that we have unwind_protect in place, we might as well
260 allow matching to be interrupted. */
264 bool wanted
= (NILP (match
)
265 || re_search (bufp
, SSDATA (name
), len
, 0, len
, 0) >= 0);
273 Lisp_Object fullname
;
274 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
277 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
278 memcpy (SDATA (fullname
), SDATA (directory
),
282 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
284 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
287 nchars
= multibyte_chars_in_text (SDATA (fullname
), nbytes
);
289 /* Some bug somewhere. */
293 STRING_SET_CHARS (fullname
, nchars
);
294 if (nchars
== nbytes
)
295 STRING_SET_UNIBYTE (fullname
);
297 finalname
= fullname
;
304 Lisp_Object fileattrs
305 = file_attributes (fd
, dp
->d_name
, id_format
);
306 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
309 list
= Fcons (finalname
, list
);
318 Vw32_get_true_file_attributes
= w32_save
;
321 /* Discard the unwind protect. */
322 specpdl_ptr
= specpdl
+ count
;
325 list
= Fsort (Fnreverse (list
),
326 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
328 (void) directory_volatile
;
333 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
334 doc
: /* Return a list of names of files in DIRECTORY.
335 There are three optional arguments:
336 If FULL is non-nil, return absolute file names. Otherwise return names
337 that are relative to the specified directory.
338 If MATCH is non-nil, mention only file names that match the regexp MATCH.
339 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
340 Otherwise, the list returned is sorted with `string-lessp'.
341 NOSORT is useful if you plan to sort the result yourself. */)
342 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
345 directory
= Fexpand_file_name (directory
, Qnil
);
347 /* If the file name has special constructs in it,
348 call the corresponding file handler. */
349 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
351 return call5 (handler
, Qdirectory_files
, directory
,
352 full
, match
, nosort
);
354 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
357 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
358 Sdirectory_files_and_attributes
, 1, 5, 0,
359 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
360 There are four optional arguments:
361 If FULL is non-nil, return absolute file names. Otherwise return names
362 that are relative to the specified directory.
363 If MATCH is non-nil, mention only file names that match the regexp MATCH.
364 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
365 NOSORT is useful if you plan to sort the result yourself.
366 ID-FORMAT specifies the preferred format of attributes uid and gid, see
367 `file-attributes' for further documentation.
368 On MS-Windows, performance depends on `w32-get-true-file-attributes',
370 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
373 directory
= Fexpand_file_name (directory
, Qnil
);
375 /* If the file name has special constructs in it,
376 call the corresponding file handler. */
377 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
379 return call6 (handler
, Qdirectory_files_and_attributes
,
380 directory
, full
, match
, nosort
, id_format
);
382 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
386 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
389 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
391 doc
: /* Complete file name FILE in directory DIRECTORY.
392 Returns the longest string
393 common to all file names in DIRECTORY that start with FILE.
394 If there is only one and FILE matches it exactly, returns t.
395 Returns nil if DIRECTORY contains no name starting with FILE.
397 If PREDICATE is non-nil, call PREDICATE with each possible
398 completion (in absolute form) and ignore it if PREDICATE returns nil.
400 This function ignores some of the possible completions as determined
401 by the variables `completion-regexp-list' and
402 `completion-ignored-extensions', which see. `completion-regexp-list'
403 is matched against file and directory names relative to DIRECTORY. */)
404 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
407 directory
= Fexpand_file_name (directory
, Qnil
);
409 /* If the directory name has special constructs in it,
410 call the corresponding file handler. */
411 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
413 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
415 /* If the file name has special constructs in it,
416 call the corresponding file handler. */
417 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
419 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
421 return file_name_completion (file
, directory
, 0, predicate
);
424 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
425 Sfile_name_all_completions
, 2, 2, 0,
426 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
427 These are all file names in directory DIRECTORY which begin with FILE.
429 This function ignores some of the possible completions as determined
430 by the variables `completion-regexp-list' and
431 `completion-ignored-extensions', which see. `completion-regexp-list'
432 is matched against file and directory names relative to DIRECTORY. */)
433 (Lisp_Object file
, Lisp_Object directory
)
436 directory
= Fexpand_file_name (directory
, Qnil
);
438 /* If the directory name has special constructs in it,
439 call the corresponding file handler. */
440 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
442 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
444 /* If the file name has special constructs in it,
445 call the corresponding file handler. */
446 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
448 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
450 return file_name_completion (file
, directory
, 1, Qnil
);
453 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
456 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
457 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 ();
480 encoded_file
= encoded_dir
= Qnil
;
481 specbind (Qdefault_directory
, dirname
);
483 /* Do completion on the encoded file name
484 because the other names in the directory are (we presume)
485 encoded likewise. We decode the completed string at the end. */
486 /* Actually, this is not quite true any more: we do most of the completion
487 work with decoded file names, but we still do some filtering based
488 on the encoded file name. */
489 encoded_file
= ENCODE_FILE (file
);
490 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
492 DIR *d
= open_directory (encoded_dir
, &fd
);
493 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
495 /* Loop reading directory entries. */
496 for (struct dirent
*dp
; (dp
= read_dirent (d
, dirname
)); )
498 ptrdiff_t len
= dirent_namelen (dp
);
502 if (len
< SCHARS (encoded_file
)
503 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
504 SCHARS (encoded_file
))
508 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
511 directoryp
= S_ISDIR (st
.st_mode
) != 0;
513 /* If all_flag is set, always include all.
514 It would not actually be helpful to the user to ignore any possible
515 completions when making a list of them. */
520 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
521 /* If this entry matches the current bestmatch, the only
522 thing it can do is increase matchcount, so don't bother
523 investigating it any further. */
524 if (!completion_ignore_case
525 /* The return result depends on whether it's the sole match. */
527 && !includeall
/* This match may allow includeall to 0. */
528 && len
>= bestmatchsize
529 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
535 #ifndef TRIVIAL_DIRECTORY_ENTRY
536 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
538 /* "." and ".." are never interesting as completions, and are
539 actually in the way in a directory with only one file. */
540 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
542 else if (len
> SCHARS (encoded_file
))
543 /* Ignore directories if they match an element of
544 completion-ignored-extensions which ends in a slash. */
545 for (tem
= Vcompletion_ignored_extensions
;
546 CONSP (tem
); tem
= XCDR (tem
))
554 /* Need to encode ELT, since scmp compares unibyte
556 elt
= ENCODE_FILE (elt
);
557 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
561 if (p1
[elt_len
] != '/')
563 skip
= len
- elt_len
;
567 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
574 /* Compare extensions-to-be-ignored against end of this file name */
575 /* if name is not an exact match against specified string */
576 if (len
> SCHARS (encoded_file
))
577 /* and exit this for loop if a match is found */
578 for (tem
= Vcompletion_ignored_extensions
;
579 CONSP (tem
); tem
= XCDR (tem
))
582 if (!STRINGP (elt
)) continue;
583 /* Need to encode ELT, since scmp compares unibyte
585 elt
= ENCODE_FILE (elt
);
586 skip
= len
- SCHARS (elt
);
587 if (skip
< 0) continue;
589 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
596 /* If an ignored-extensions match was found,
597 don't process this name as a completion. */
601 if (!includeall
&& canexclude
)
602 /* We're not including all files and this file can be excluded. */
605 if (includeall
&& !canexclude
)
606 { /* If we have one non-excludable file, we want to exclude the
609 /* Throw away any previous excludable match found. */
615 /* FIXME: If we move this `decode' earlier we can eliminate
616 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
617 name
= make_unibyte_string (dp
->d_name
, len
);
618 name
= DECODE_FILE (name
);
621 Lisp_Object regexps
, table
= (completion_ignore_case
622 ? Vascii_canon_table
: Qnil
);
624 /* Ignore this element if it fails to match all the regexps. */
625 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
626 regexps
= XCDR (regexps
))
627 if (fast_string_match_internal (XCAR (regexps
), name
, table
) < 0)
634 /* This is a possible completion */
636 /* This completion is a directory; make it end with '/'. */
637 name
= Ffile_name_as_directory (name
);
639 /* Test the predicate, if any. */
640 if (!NILP (predicate
) && NILP (call1 (predicate
, name
)))
643 /* Suitably record this match. */
645 matchcount
+= matchcount
<= 1;
648 bestmatch
= Fcons (name
, bestmatch
);
649 else if (NILP (bestmatch
))
652 bestmatchsize
= SCHARS (name
);
656 Lisp_Object zero
= make_number (0);
657 /* FIXME: This is a copy of the code in Ftry_completion. */
658 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
660 = Fcompare_strings (bestmatch
, zero
,
661 make_number (compare
),
663 make_number (compare
),
664 completion_ignore_case
? Qt
: Qnil
);
665 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
667 if (completion_ignore_case
)
669 /* If this is an exact match except for case,
670 use it as the best match rather than one that is not
671 an exact match. This way, we get the case pattern
672 of the actual match. */
673 /* This tests that the current file is an exact match
674 but BESTMATCH is not (it is too long). */
675 if ((matchsize
== SCHARS (name
)
676 && matchsize
+ directoryp
< SCHARS (bestmatch
))
678 /* If there is no exact match ignoring case,
679 prefer a match that does not change the case
681 /* If there is more than one exact match aside from
682 case, and one of them is exact including case,
684 /* This == checks that, of current file and BESTMATCH,
685 either both or neither are exact. */
686 (((matchsize
== SCHARS (name
))
688 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
689 && (cmp
= Fcompare_strings (name
, zero
,
690 make_number (SCHARS (file
)),
695 && (cmp
= Fcompare_strings (bestmatch
, zero
,
696 make_number (SCHARS (file
)),
703 bestmatchsize
= matchsize
;
705 /* If the best completion so far is reduced to the string
706 we're trying to complete, then we already know there's no
707 other completion, so there's no point looking any further. */
708 if (matchsize
<= SCHARS (file
)
709 && !includeall
/* A future match may allow includeall to 0. */
710 /* If completion-ignore-case is non-nil, don't
711 short-circuit because we want to find the best
712 possible match *including* case differences. */
713 && (!completion_ignore_case
|| matchsize
== 0)
714 /* The return value depends on whether it's the sole match. */
721 /* This closes the directory. */
722 bestmatch
= unbind_to (count
, bestmatch
);
724 if (all_flag
|| NILP (bestmatch
))
726 /* Return t if the supplied string is an exact match (counting case);
727 it does not require any change to be made. */
728 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
730 bestmatch
= Fsubstring (bestmatch
, make_number (0),
731 make_number (bestmatchsize
));
735 /* Compare exactly LEN chars of strings at S1 and S2,
736 ignoring case if appropriate.
737 Return -1 if strings match,
738 else number of chars that match at the beginning. */
741 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
743 register ptrdiff_t l
= len
;
745 if (completion_ignore_case
)
748 && (downcase ((unsigned char) *s1
++)
749 == downcase ((unsigned char) *s2
++)))
754 while (l
&& *s1
++ == *s2
++)
764 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
769 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
770 but aren't required here. Avoid computing the following fields:
771 st_inode, st_size and st_nlink for directories, and the execute bits
772 in st_mode for non-directory files with non-standard extensions. */
774 unsigned short save_djstat_flags
= _djstat_flags
;
776 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
779 /* We want to return success if a link points to a nonexistent file,
780 but we want to return the status for what the link points to,
781 in case it is a directory. */
782 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
783 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
784 fstatat (fd
, dp
->d_name
, st_addr
, 0);
786 _djstat_flags
= save_djstat_flags
;
792 stat_uname (struct stat
*st
)
797 struct passwd
*pw
= getpwuid (st
->st_uid
);
807 stat_gname (struct stat
*st
)
812 struct group
*gr
= getgrgid (st
->st_gid
);
821 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
822 doc
: /* Return a list of attributes of file FILENAME.
823 Value is nil if specified file cannot be opened.
825 ID-FORMAT specifies the preferred format of attributes uid and gid (see
826 below) - valid values are `string' and `integer'. The latter is the
827 default, but we plan to change that, so you should specify a non-nil value
828 for ID-FORMAT if you use the returned uid or gid.
830 Elements of the attribute list are:
831 0. t for directory, string (name linked to) for symbolic link, or nil.
832 1. Number of links to file.
833 2. File uid as a string or a number. If a string value cannot be
834 looked up, a numeric value, either an integer or a float, is returned.
835 3. File gid, likewise.
836 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
837 same style as (current-time).
838 (See a note below about access time on FAT-based filesystems.)
839 5. Last modification time, likewise. This is the time of the last
840 change to the file's contents.
841 6. Last status change time, likewise. This is the time of last change
842 to the file's attributes: owner and group, access mode bits, etc.
844 This is a floating point number if the size is too large for an integer.
845 8. File modes, as a string of ten letters or dashes as in ls -l.
846 9. An unspecified value, present only for backward compatibility.
847 10. inode number. If it is larger than what an Emacs integer can hold,
848 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
849 If even HIGH is too large for an Emacs integer, this is instead of the form
850 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
851 and finally the low 16 bits.
852 11. Filesystem device number. If it is larger than what the Emacs
853 integer can hold, this is a cons cell, similar to the inode number.
855 On most filesystems, the combination of the inode and the device
856 number uniquely identifies the file.
858 On MS-Windows, performance depends on `w32-get-true-file-attributes',
861 On some FAT-based filesystems, only the date of last access is recorded,
862 so last access time will always be midnight of that day. */)
863 (Lisp_Object filename
, Lisp_Object id_format
)
868 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
870 if (!STRINGP (filename
))
873 /* If the file name has special constructs in it,
874 call the corresponding file handler. */
875 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
877 { /* Only pass the extra arg if it is used to help backward compatibility
878 with old file handlers which do not implement the new arg. --Stef */
879 if (NILP (id_format
))
880 return call2 (handler
, Qfile_attributes
, filename
);
882 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
885 encoded
= ENCODE_FILE (filename
);
886 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
890 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
895 /* An array to hold the mode string generated by filemodestring,
896 including its terminating space and null byte. */
897 char modes
[sizeof "-rwxr-xr-x "];
899 char *uname
= NULL
, *gname
= NULL
;
902 /* We usually don't request accurate owner and group info, because
903 it can be very expensive on Windows to get that, and most callers
904 of 'lstat' don't need that. But here we do want that information
906 w32_stat_get_owner_group
= 1;
909 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
912 w32_stat_get_owner_group
= 0;
915 if (lstat_result
< 0)
918 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
921 uname
= stat_uname (&s
);
922 gname
= stat_gname (&s
);
926 filemodestring (&s
, modes
);
929 (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
930 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
),
931 make_number (s
.st_nlink
),
933 ? DECODE_SYSTEM (build_unibyte_string (uname
))
934 : make_fixnum_or_float (s
.st_uid
)),
936 ? DECODE_SYSTEM (build_unibyte_string (gname
))
937 : make_fixnum_or_float (s
.st_gid
)),
938 make_lisp_time (get_stat_atime (&s
)),
939 make_lisp_time (get_stat_mtime (&s
)),
940 make_lisp_time (get_stat_ctime (&s
)),
942 /* If the file size is a 4-byte type, assume that
943 files of sizes in the 2-4 GiB range wrap around to
944 negative values, as this is a common bug on older
946 make_fixnum_or_float (sizeof (s
.st_size
) == 4
947 ? s
.st_size
& 0xffffffffu
950 make_string (modes
, 10),
952 INTEGER_TO_CONS (s
.st_ino
),
953 INTEGER_TO_CONS (s
.st_dev
));
956 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
957 doc
: /* Return t if first arg file attributes list is less than second.
958 Comparison is in lexicographic order and case is significant. */)
959 (Lisp_Object f1
, Lisp_Object f2
)
961 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
965 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
966 doc
: /* Return a list of user names currently registered in the system.
967 If we don't know how to determine that on this platform, just
968 return a list with one element, taken from `user-real-login-name'. */)
971 Lisp_Object users
= Qnil
;
972 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
975 while ((pw
= getpwent ()))
976 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
980 if (EQ (users
, Qnil
))
981 /* At least current user is always known. */
982 users
= list1 (Vuser_real_login_name
);
986 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
987 doc
: /* Return a list of user group names currently registered in the system.
988 The value may be nil if not supported on this platform. */)
991 Lisp_Object groups
= Qnil
;
992 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
995 while ((gr
= getgrent ()))
996 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1004 syms_of_dired (void)
1006 DEFSYM (Qdirectory_files
, "directory-files");
1007 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1008 DEFSYM (Qfile_name_completion
, "file-name-completion");
1009 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1010 DEFSYM (Qfile_attributes
, "file-attributes");
1011 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1012 DEFSYM (Qdefault_directory
, "default-directory");
1014 defsubr (&Sdirectory_files
);
1015 defsubr (&Sdirectory_files_and_attributes
);
1016 defsubr (&Sfile_name_completion
);
1017 defsubr (&Sfile_name_all_completions
);
1018 defsubr (&Sfile_attributes
);
1019 defsubr (&Sfile_attributes_lessp
);
1020 defsubr (&Ssystem_users
);
1021 defsubr (&Ssystem_groups
);
1023 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1024 doc
: /* Completion ignores file names ending in any string in this list.
1025 It does not ignore them if all possible completions end in one of
1026 these strings or when displaying a list of completions.
1027 It ignores directory names if they match any string in this list which
1028 ends in a slash. */);
1029 Vcompletion_ignored_extensions
= Qnil
;