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>
45 #include "blockinput.h"
48 #include "msdos.h" /* for fstatat */
51 static ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
52 static Lisp_Object
file_attributes (int, char const *, Lisp_Object
);
54 /* Return the number of bytes in DP's name. */
56 dirent_namelen (struct dirent
*dp
)
58 #ifdef _D_EXACT_NAMLEN
59 return _D_EXACT_NAMLEN (dp
);
61 return strlen (dp
->d_name
);
66 open_directory (Lisp_Object dirname
, int *fdp
)
68 char *name
= SSDATA (dirname
);
70 int fd
, opendir_errno
;
75 /* Directories cannot be opened. The emulation assumes that any
76 file descriptor other than AT_FDCWD corresponds to the most
77 recently opened directory. This hack is good enough for Emacs. */
80 opendir_errno
= errno
;
82 fd
= emacs_open (name
, O_RDONLY
| O_DIRECTORY
, 0);
85 opendir_errno
= errno
;
91 opendir_errno
= errno
;
100 report_file_errno ("Opening directory", dirname
, opendir_errno
);
107 directory_files_internal_w32_unwind (Lisp_Object arg
)
109 Vw32_get_true_file_attributes
= arg
;
114 directory_files_internal_unwind (void *dh
)
122 /* Return the next directory entry from DIR; DIR's name is DIRNAME.
123 If there are no more directory entries, return a null pointer.
124 Signal any unrecoverable errors. */
126 static struct dirent
*
127 read_dirent (DIR *dir
, Lisp_Object dirname
)
132 struct dirent
*dp
= readdir (dir
);
133 if (dp
|| errno
== 0)
135 if (! (errno
== EAGAIN
|| errno
== EINTR
))
138 /* The MS-Windows implementation of 'opendir' doesn't
139 actually open a directory until the first call to
140 'readdir'. If 'readdir' fails to open the directory, it
141 sets errno to ENOENT or EACCES, see w32.c. */
142 if (errno
== ENOENT
|| errno
== EACCES
)
143 report_file_error ("Opening directory", dirname
);
145 report_file_error ("Reading directory", dirname
);
151 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
152 If not ATTRS, return a list of directory filenames;
153 if ATTRS, return a list of directory filenames and their attributes.
154 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
157 directory_files_internal (Lisp_Object directory
, Lisp_Object full
,
158 Lisp_Object match
, Lisp_Object nosort
, bool attrs
,
159 Lisp_Object id_format
)
161 ptrdiff_t directory_nbytes
;
162 Lisp_Object list
, dirfilename
, encoded_directory
;
163 struct re_pattern_buffer
*bufp
= NULL
;
165 ptrdiff_t count
= SPECPDL_INDEX ();
167 Lisp_Object w32_save
= Qnil
;
170 /* Don't let the compiler optimize away all copies of DIRECTORY,
171 which would break GC; see Bug#16986. */
172 Lisp_Object
volatile directory_volatile
= directory
;
174 /* Because of file name handlers, these functions might call
175 Ffuncall, and cause a GC. */
176 list
= encoded_directory
= dirfilename
= Qnil
;
177 dirfilename
= Fdirectory_file_name (directory
);
181 CHECK_STRING (match
);
183 /* MATCH might be a flawed regular expression. Rather than
184 catching and signaling our own errors, we just call
185 compile_pattern to do the work for us. */
186 /* Pass 1 for the MULTIBYTE arg
187 because we do make multibyte strings if the contents warrant. */
189 /* Windows users want case-insensitive wildcards. */
190 bufp
= compile_pattern (match
, 0,
191 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
192 # else /* !WINDOWSNT */
193 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
194 # endif /* !WINDOWSNT */
197 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
198 run_pre_post_conversion_on_str which calls Lisp directly and
200 dirfilename
= ENCODE_FILE (dirfilename
);
201 encoded_directory
= ENCODE_FILE (directory
);
203 /* Now *bufp is the compiled form of MATCH; don't call anything
204 which might compile a new regexp until we're done with the loop! */
207 DIR *d
= open_directory (dirfilename
, &fd
);
209 /* Unfortunately, we can now invoke expand-file-name and
210 file-attributes on filenames, both of which can throw, so we must
211 do a proper unwind-protect. */
212 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
217 extern int is_slow_fs (const char *);
219 /* Do this only once to avoid doing it (in w32.c:stat) for each
220 file in the directory, when we call Ffile_attributes below. */
221 record_unwind_protect (directory_files_internal_w32_unwind
,
222 Vw32_get_true_file_attributes
);
223 w32_save
= Vw32_get_true_file_attributes
;
224 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
226 /* w32.c:stat will notice these bindings and avoid calling
227 GetDriveType for each file. */
228 if (is_slow_fs (SDATA (dirfilename
)))
229 Vw32_get_true_file_attributes
= Qnil
;
231 Vw32_get_true_file_attributes
= Qt
;
236 directory_nbytes
= SBYTES (directory
);
237 re_match_object
= Qt
;
239 /* Decide whether we need to add a directory separator. */
240 if (directory_nbytes
== 0
241 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
244 /* Loop reading directory entries. */
245 for (struct dirent
*dp
; (dp
= read_dirent (d
, directory
)); )
247 ptrdiff_t len
= dirent_namelen (dp
);
248 Lisp_Object name
= make_unibyte_string (dp
->d_name
, len
);
249 Lisp_Object finalname
= name
;
251 /* Note: DECODE_FILE can GC; it should protect its argument,
253 name
= DECODE_FILE (name
);
256 /* Now that we have unwind_protect in place, we might as well
257 allow matching to be interrupted. */
261 bool wanted
= (NILP (match
)
262 || re_search (bufp
, SSDATA (name
), len
, 0, len
, 0) >= 0);
270 Lisp_Object fullname
;
271 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
274 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
275 memcpy (SDATA (fullname
), SDATA (directory
),
279 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
281 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
284 nchars
= multibyte_chars_in_text (SDATA (fullname
), nbytes
);
286 /* Some bug somewhere. */
290 STRING_SET_CHARS (fullname
, nchars
);
291 if (nchars
== nbytes
)
292 STRING_SET_UNIBYTE (fullname
);
294 finalname
= fullname
;
301 Lisp_Object fileattrs
302 = file_attributes (fd
, dp
->d_name
, id_format
);
303 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
306 list
= Fcons (finalname
, list
);
315 Vw32_get_true_file_attributes
= w32_save
;
318 /* Discard the unwind protect. */
319 specpdl_ptr
= specpdl
+ count
;
322 list
= Fsort (Fnreverse (list
),
323 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
325 (void) directory_volatile
;
330 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
331 doc
: /* Return a list of names of files in DIRECTORY.
332 There are three optional arguments:
333 If FULL is non-nil, return absolute file names. Otherwise return names
334 that are relative to the specified directory.
335 If MATCH is non-nil, mention only file names that match the regexp MATCH.
336 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
337 Otherwise, the list returned is sorted with `string-lessp'.
338 NOSORT is useful if you plan to sort the result yourself. */)
339 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
342 directory
= Fexpand_file_name (directory
, Qnil
);
344 /* If the file name has special constructs in it,
345 call the corresponding file handler. */
346 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
348 return call5 (handler
, Qdirectory_files
, directory
,
349 full
, match
, nosort
);
351 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
354 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
355 Sdirectory_files_and_attributes
, 1, 5, 0,
356 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
357 There are four optional arguments:
358 If FULL is non-nil, return absolute file names. Otherwise return names
359 that are relative to the specified directory.
360 If MATCH is non-nil, mention only file names that match the regexp MATCH.
361 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
362 NOSORT is useful if you plan to sort the result yourself.
363 ID-FORMAT specifies the preferred format of attributes uid and gid, see
364 `file-attributes' for further documentation.
365 On MS-Windows, performance depends on `w32-get-true-file-attributes',
367 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
370 directory
= Fexpand_file_name (directory
, Qnil
);
372 /* If the file name has special constructs in it,
373 call the corresponding file handler. */
374 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
376 return call6 (handler
, Qdirectory_files_and_attributes
,
377 directory
, full
, match
, nosort
, id_format
);
379 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
383 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
386 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
388 doc
: /* Complete file name FILE in directory DIRECTORY.
389 Returns the longest string
390 common to all file names in DIRECTORY that start with FILE.
391 If there is only one and FILE matches it exactly, returns t.
392 Returns nil if DIRECTORY contains no name starting with FILE.
394 If PREDICATE is non-nil, call PREDICATE with each possible
395 completion (in absolute form) and ignore it if PREDICATE returns nil.
397 This function ignores some of the possible completions as determined
398 by the variables `completion-regexp-list' and
399 `completion-ignored-extensions', which see. `completion-regexp-list'
400 is matched against file and directory names relative to DIRECTORY. */)
401 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
404 directory
= Fexpand_file_name (directory
, Qnil
);
406 /* If the directory name has special constructs in it,
407 call the corresponding file handler. */
408 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
410 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
412 /* If the file name has special constructs in it,
413 call the corresponding file handler. */
414 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
416 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
418 return file_name_completion (file
, directory
, 0, predicate
);
421 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
422 Sfile_name_all_completions
, 2, 2, 0,
423 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
424 These are all file names in directory DIRECTORY which begin with FILE.
426 This function ignores some of the possible completions as determined
427 by the variables `completion-regexp-list' and
428 `completion-ignored-extensions', which see. `completion-regexp-list'
429 is matched against file and directory names relative to DIRECTORY. */)
430 (Lisp_Object file
, Lisp_Object directory
)
433 directory
= Fexpand_file_name (directory
, Qnil
);
435 /* If the directory name has special constructs in it,
436 call the corresponding file handler. */
437 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
439 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
441 /* If the file name has special constructs in it,
442 call the corresponding file handler. */
443 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
445 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
447 return file_name_completion (file
, directory
, 1, Qnil
);
450 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
453 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
454 Lisp_Object predicate
)
456 ptrdiff_t bestmatchsize
= 0;
458 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
459 If ALL_FLAG is 0, BESTMATCH is either nil
460 or the best match so far, not decoded. */
461 Lisp_Object bestmatch
, tem
, elt
, name
;
462 Lisp_Object encoded_file
;
463 Lisp_Object encoded_dir
;
466 /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
467 well as "." and "..". Until shown otherwise, assume we can't exclude
470 ptrdiff_t count
= SPECPDL_INDEX ();
477 encoded_file
= encoded_dir
= Qnil
;
478 specbind (Qdefault_directory
, dirname
);
480 /* Do completion on the encoded file name
481 because the other names in the directory are (we presume)
482 encoded likewise. We decode the completed string at the end. */
483 /* Actually, this is not quite true any more: we do most of the completion
484 work with decoded file names, but we still do some filtering based
485 on the encoded file name. */
486 encoded_file
= ENCODE_FILE (file
);
487 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
489 DIR *d
= open_directory (encoded_dir
, &fd
);
490 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
492 /* Loop reading directory entries. */
493 for (struct dirent
*dp
; (dp
= read_dirent (d
, dirname
)); )
495 ptrdiff_t len
= dirent_namelen (dp
);
499 if (len
< SCHARS (encoded_file
)
500 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
501 SCHARS (encoded_file
))
505 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
508 directoryp
= S_ISDIR (st
.st_mode
) != 0;
510 /* If all_flag is set, always include all.
511 It would not actually be helpful to the user to ignore any possible
512 completions when making a list of them. */
517 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
518 /* If this entry matches the current bestmatch, the only
519 thing it can do is increase matchcount, so don't bother
520 investigating it any further. */
521 if (!completion_ignore_case
522 /* The return result depends on whether it's the sole match. */
524 && !includeall
/* This match may allow includeall to 0. */
525 && len
>= bestmatchsize
526 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
532 #ifndef TRIVIAL_DIRECTORY_ENTRY
533 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
535 /* "." and ".." are never interesting as completions, and are
536 actually in the way in a directory with only one file. */
537 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
539 else if (len
> SCHARS (encoded_file
))
540 /* Ignore directories if they match an element of
541 completion-ignored-extensions which ends in a slash. */
542 for (tem
= Vcompletion_ignored_extensions
;
543 CONSP (tem
); tem
= XCDR (tem
))
551 /* Need to encode ELT, since scmp compares unibyte
553 elt
= ENCODE_FILE (elt
);
554 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
558 if (p1
[elt_len
] != '/')
560 skip
= len
- elt_len
;
564 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
571 /* Compare extensions-to-be-ignored against end of this file name */
572 /* if name is not an exact match against specified string */
573 if (len
> SCHARS (encoded_file
))
574 /* and exit this for loop if a match is found */
575 for (tem
= Vcompletion_ignored_extensions
;
576 CONSP (tem
); tem
= XCDR (tem
))
579 if (!STRINGP (elt
)) continue;
580 /* Need to encode ELT, since scmp compares unibyte
582 elt
= ENCODE_FILE (elt
);
583 skip
= len
- SCHARS (elt
);
584 if (skip
< 0) continue;
586 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
593 /* If an ignored-extensions match was found,
594 don't process this name as a completion. */
598 if (!includeall
&& canexclude
)
599 /* We're not including all files and this file can be excluded. */
602 if (includeall
&& !canexclude
)
603 { /* If we have one non-excludable file, we want to exclude the
606 /* Throw away any previous excludable match found. */
612 /* FIXME: If we move this `decode' earlier we can eliminate
613 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
614 name
= make_unibyte_string (dp
->d_name
, len
);
615 name
= DECODE_FILE (name
);
618 Lisp_Object regexps
, table
= (completion_ignore_case
619 ? Vascii_canon_table
: Qnil
);
621 /* Ignore this element if it fails to match all the regexps. */
622 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
623 regexps
= XCDR (regexps
))
624 if (fast_string_match_internal (XCAR (regexps
), name
, table
) < 0)
631 /* This is a possible completion */
633 /* This completion is a directory; make it end with '/'. */
634 name
= Ffile_name_as_directory (name
);
636 /* Test the predicate, if any. */
637 if (!NILP (predicate
) && NILP (call1 (predicate
, name
)))
640 /* Suitably record this match. */
642 matchcount
+= matchcount
<= 1;
645 bestmatch
= Fcons (name
, bestmatch
);
646 else if (NILP (bestmatch
))
649 bestmatchsize
= SCHARS (name
);
653 Lisp_Object zero
= make_number (0);
654 /* FIXME: This is a copy of the code in Ftry_completion. */
655 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
657 = Fcompare_strings (bestmatch
, zero
,
658 make_number (compare
),
660 make_number (compare
),
661 completion_ignore_case
? Qt
: Qnil
);
662 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
664 if (completion_ignore_case
)
666 /* If this is an exact match except for case,
667 use it as the best match rather than one that is not
668 an exact match. This way, we get the case pattern
669 of the actual match. */
670 /* This tests that the current file is an exact match
671 but BESTMATCH is not (it is too long). */
672 if ((matchsize
== SCHARS (name
)
673 && matchsize
+ directoryp
< SCHARS (bestmatch
))
675 /* If there is no exact match ignoring case,
676 prefer a match that does not change the case
678 /* If there is more than one exact match aside from
679 case, and one of them is exact including case,
681 /* This == checks that, of current file and BESTMATCH,
682 either both or neither are exact. */
683 (((matchsize
== SCHARS (name
))
685 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
686 && (cmp
= Fcompare_strings (name
, zero
,
687 make_number (SCHARS (file
)),
692 && (cmp
= Fcompare_strings (bestmatch
, zero
,
693 make_number (SCHARS (file
)),
700 bestmatchsize
= matchsize
;
702 /* If the best completion so far is reduced to the string
703 we're trying to complete, then we already know there's no
704 other completion, so there's no point looking any further. */
705 if (matchsize
<= SCHARS (file
)
706 && !includeall
/* A future match may allow includeall to 0. */
707 /* If completion-ignore-case is non-nil, don't
708 short-circuit because we want to find the best
709 possible match *including* case differences. */
710 && (!completion_ignore_case
|| matchsize
== 0)
711 /* The return value depends on whether it's the sole match. */
718 /* This closes the directory. */
719 bestmatch
= unbind_to (count
, bestmatch
);
721 if (all_flag
|| NILP (bestmatch
))
723 /* Return t if the supplied string is an exact match (counting case);
724 it does not require any change to be made. */
725 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
727 bestmatch
= Fsubstring (bestmatch
, make_number (0),
728 make_number (bestmatchsize
));
732 /* Compare exactly LEN chars of strings at S1 and S2,
733 ignoring case if appropriate.
734 Return -1 if strings match,
735 else number of chars that match at the beginning. */
738 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
740 register ptrdiff_t l
= len
;
742 if (completion_ignore_case
)
745 && (downcase ((unsigned char) *s1
++)
746 == downcase ((unsigned char) *s2
++)))
751 while (l
&& *s1
++ == *s2
++)
761 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
766 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
767 but aren't required here. Avoid computing the following fields:
768 st_inode, st_size and st_nlink for directories, and the execute bits
769 in st_mode for non-directory files with non-standard extensions. */
771 unsigned short save_djstat_flags
= _djstat_flags
;
773 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
776 /* We want to return success if a link points to a nonexistent file,
777 but we want to return the status for what the link points to,
778 in case it is a directory. */
779 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
780 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
781 fstatat (fd
, dp
->d_name
, st_addr
, 0);
783 _djstat_flags
= save_djstat_flags
;
789 stat_uname (struct stat
*st
)
794 struct passwd
*pw
= getpwuid (st
->st_uid
);
804 stat_gname (struct stat
*st
)
809 struct group
*gr
= getgrgid (st
->st_gid
);
818 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
819 doc
: /* Return a list of attributes of file FILENAME.
820 Value is nil if specified file cannot be opened.
822 ID-FORMAT specifies the preferred format of attributes uid and gid (see
823 below) - valid values are `string' and `integer'. The latter is the
824 default, but we plan to change that, so you should specify a non-nil value
825 for ID-FORMAT if you use the returned uid or gid.
827 Elements of the attribute list are:
828 0. t for directory, string (name linked to) for symbolic link, or nil.
829 1. Number of links to file.
830 2. File uid as a string or a number. If a string value cannot be
831 looked up, a numeric value, either an integer or a float, is returned.
832 3. File gid, likewise.
833 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
834 same style as (current-time).
835 (See a note below about access time on FAT-based filesystems.)
836 5. Last modification time, likewise. This is the time of the last
837 change to the file's contents.
838 6. Last status change time, likewise. This is the time of last change
839 to the file's attributes: owner and group, access mode bits, etc.
841 This is a floating point number if the size is too large for an integer.
842 8. File modes, as a string of ten letters or dashes as in ls -l.
843 9. An unspecified value, present only for backward compatibility.
844 10. inode number. If it is larger than what an Emacs integer can hold,
845 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
846 If even HIGH is too large for an Emacs integer, this is instead of the form
847 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
848 and finally the low 16 bits.
849 11. Filesystem device number. If it is larger than what the Emacs
850 integer can hold, this is a cons cell, similar to the inode number.
852 On most filesystems, the combination of the inode and the device
853 number uniquely identifies the file.
855 On MS-Windows, performance depends on `w32-get-true-file-attributes',
858 On some FAT-based filesystems, only the date of last access is recorded,
859 so last access time will always be midnight of that day. */)
860 (Lisp_Object filename
, Lisp_Object id_format
)
865 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
867 if (!STRINGP (filename
))
870 /* If the file name has special constructs in it,
871 call the corresponding file handler. */
872 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
874 { /* Only pass the extra arg if it is used to help backward compatibility
875 with old file handlers which do not implement the new arg. --Stef */
876 if (NILP (id_format
))
877 return call2 (handler
, Qfile_attributes
, filename
);
879 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
882 encoded
= ENCODE_FILE (filename
);
883 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
887 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
892 /* An array to hold the mode string generated by filemodestring,
893 including its terminating space and null byte. */
894 char modes
[sizeof "-rwxr-xr-x "];
896 char *uname
= NULL
, *gname
= NULL
;
899 /* We usually don't request accurate owner and group info, because
900 it can be very expensive on Windows to get that, and most callers
901 of 'lstat' don't need that. But here we do want that information
903 w32_stat_get_owner_group
= 1;
906 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
909 w32_stat_get_owner_group
= 0;
912 if (lstat_result
< 0)
915 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
918 uname
= stat_uname (&s
);
919 gname
= stat_gname (&s
);
923 filemodestring (&s
, modes
);
926 (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
927 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
),
928 make_number (s
.st_nlink
),
930 ? DECODE_SYSTEM (build_unibyte_string (uname
))
931 : make_fixnum_or_float (s
.st_uid
)),
933 ? DECODE_SYSTEM (build_unibyte_string (gname
))
934 : make_fixnum_or_float (s
.st_gid
)),
935 make_lisp_time (get_stat_atime (&s
)),
936 make_lisp_time (get_stat_mtime (&s
)),
937 make_lisp_time (get_stat_ctime (&s
)),
939 /* If the file size is a 4-byte type, assume that
940 files of sizes in the 2-4 GiB range wrap around to
941 negative values, as this is a common bug on older
943 make_fixnum_or_float (sizeof (s
.st_size
) == 4
944 ? s
.st_size
& 0xffffffffu
947 make_string (modes
, 10),
949 INTEGER_TO_CONS (s
.st_ino
),
950 INTEGER_TO_CONS (s
.st_dev
));
953 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
954 doc
: /* Return t if first arg file attributes list is less than second.
955 Comparison is in lexicographic order and case is significant. */)
956 (Lisp_Object f1
, Lisp_Object f2
)
958 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
962 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
963 doc
: /* Return a list of user names currently registered in the system.
964 If we don't know how to determine that on this platform, just
965 return a list with one element, taken from `user-real-login-name'. */)
968 Lisp_Object users
= Qnil
;
969 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
972 while ((pw
= getpwent ()))
973 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
977 if (EQ (users
, Qnil
))
978 /* At least current user is always known. */
979 users
= list1 (Vuser_real_login_name
);
983 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
984 doc
: /* Return a list of user group names currently registered in the system.
985 The value may be nil if not supported on this platform. */)
988 Lisp_Object groups
= Qnil
;
989 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
992 while ((gr
= getgrent ()))
993 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1001 syms_of_dired (void)
1003 DEFSYM (Qdirectory_files
, "directory-files");
1004 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1005 DEFSYM (Qfile_name_completion
, "file-name-completion");
1006 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1007 DEFSYM (Qfile_attributes
, "file-attributes");
1008 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1009 DEFSYM (Qdefault_directory
, "default-directory");
1011 defsubr (&Sdirectory_files
);
1012 defsubr (&Sdirectory_files_and_attributes
);
1013 defsubr (&Sfile_name_completion
);
1014 defsubr (&Sfile_name_all_completions
);
1015 defsubr (&Sfile_attributes
);
1016 defsubr (&Sfile_attributes_lessp
);
1017 defsubr (&Ssystem_users
);
1018 defsubr (&Ssystem_groups
);
1020 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1021 doc
: /* Completion ignores file names ending in any string in this list.
1022 It does not ignore them if all possible completions end in one of
1023 these strings or when displaying a list of completions.
1024 It ignores directory names if they match any string in this list which
1025 ends in a slash. */);
1026 Vcompletion_ignored_extensions
= Qnil
;