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 ENOTDIR; we convert it here to ENOENT so
246 that the error message is similar to what happens on
247 Posix hosts in such cases. */
248 if (errno
== ENOTDIR
)
251 report_file_error ("Opening directory", directory
);
257 len
= dirent_namelen (dp
);
258 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
259 GCPRO2 (finalname
, name
);
261 /* Note: DECODE_FILE can GC; it should protect its argument,
263 name
= DECODE_FILE (name
);
266 /* Now that we have unwind_protect in place, we might as well
267 allow matching to be interrupted. */
272 || re_search (bufp
, SSDATA (name
), len
, 0, len
, 0) >= 0)
281 Lisp_Object fullname
;
282 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
285 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
286 memcpy (SDATA (fullname
), SDATA (directory
),
290 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
292 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
295 nchars
= multibyte_chars_in_text (SDATA (fullname
), nbytes
);
297 /* Some bug somewhere. */
301 STRING_SET_CHARS (fullname
, nchars
);
302 if (nchars
== nbytes
)
303 STRING_SET_UNIBYTE (fullname
);
305 finalname
= fullname
;
312 Lisp_Object fileattrs
313 = file_attributes (fd
, dp
->d_name
, id_format
);
314 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
317 list
= Fcons (finalname
, list
);
328 Vw32_get_true_file_attributes
= w32_save
;
331 /* Discard the unwind protect. */
332 specpdl_ptr
= specpdl
+ count
;
335 list
= Fsort (Fnreverse (list
),
336 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
338 (void) directory_volatile
;
339 RETURN_UNGCPRO (list
);
343 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
344 doc
: /* Return a list of names of files in DIRECTORY.
345 There are three optional arguments:
346 If FULL is non-nil, return absolute file names. Otherwise return names
347 that are relative to the specified directory.
348 If MATCH is non-nil, mention only file names that match the regexp MATCH.
349 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
350 Otherwise, the list returned is sorted with `string-lessp'.
351 NOSORT is useful if you plan to sort the result yourself. */)
352 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
355 directory
= Fexpand_file_name (directory
, Qnil
);
357 /* If the file name has special constructs in it,
358 call the corresponding file handler. */
359 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
361 return call5 (handler
, Qdirectory_files
, directory
,
362 full
, match
, nosort
);
364 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
367 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
368 Sdirectory_files_and_attributes
, 1, 5, 0,
369 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
370 There are four optional arguments:
371 If FULL is non-nil, return absolute file names. Otherwise return names
372 that are relative to the specified directory.
373 If MATCH is non-nil, mention only file names that match the regexp MATCH.
374 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
375 NOSORT is useful if you plan to sort the result yourself.
376 ID-FORMAT specifies the preferred format of attributes uid and gid, see
377 `file-attributes' for further documentation.
378 On MS-Windows, performance depends on `w32-get-true-file-attributes',
380 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
383 directory
= Fexpand_file_name (directory
, Qnil
);
385 /* If the file name has special constructs in it,
386 call the corresponding file handler. */
387 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
389 return call6 (handler
, Qdirectory_files_and_attributes
,
390 directory
, full
, match
, nosort
, id_format
);
392 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
396 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
399 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
401 doc
: /* Complete file name FILE in directory DIRECTORY.
402 Returns the longest string
403 common to all file names in DIRECTORY that start with FILE.
404 If there is only one and FILE matches it exactly, returns t.
405 Returns nil if DIRECTORY contains no name starting with FILE.
407 If PREDICATE is non-nil, call PREDICATE with each possible
408 completion (in absolute form) and ignore it if PREDICATE returns nil.
410 This function ignores some of the possible completions as
411 determined by the variable `completion-ignored-extensions', which see. */)
412 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
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_completion
);
421 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
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_completion
);
427 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
429 return file_name_completion (file
, directory
, 0, predicate
);
432 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
433 Sfile_name_all_completions
, 2, 2, 0,
434 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
435 These are all file names in directory DIRECTORY which begin with FILE. */)
436 (Lisp_Object file
, Lisp_Object directory
)
439 directory
= Fexpand_file_name (directory
, Qnil
);
441 /* If the directory name has special constructs in it,
442 call the corresponding file handler. */
443 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
445 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
447 /* If the file name has special constructs in it,
448 call the corresponding file handler. */
449 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
451 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
453 return file_name_completion (file
, directory
, 1, Qnil
);
456 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
459 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
460 Lisp_Object predicate
)
464 ptrdiff_t bestmatchsize
= 0;
466 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
467 If ALL_FLAG is 0, BESTMATCH is either nil
468 or the best match so far, not decoded. */
469 Lisp_Object bestmatch
, tem
, elt
, name
;
470 Lisp_Object encoded_file
;
471 Lisp_Object encoded_dir
;
474 /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
475 well as "." and "..". Until shown otherwise, assume we can't exclude
478 ptrdiff_t count
= SPECPDL_INDEX ();
479 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
486 encoded_file
= encoded_dir
= Qnil
;
487 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
488 specbind (Qdefault_directory
, dirname
);
490 /* Do completion on the encoded file name
491 because the other names in the directory are (we presume)
492 encoded likewise. We decode the completed string at the end. */
493 /* Actually, this is not quite true any more: we do most of the completion
494 work with decoded file names, but we still do some filtering based
495 on the encoded file name. */
496 encoded_file
= ENCODE_FILE (file
);
498 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
500 d
= open_directory (SSDATA (encoded_dir
), &fd
);
502 report_file_error ("Opening directory", dirname
);
504 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
506 /* Loop reading blocks */
507 /* (att3b compiler bug requires do a null comparison this way) */
518 if (errno
== EAGAIN
|| errno
== EINTR
)
526 len
= dirent_namelen (dp
);
529 if (len
< SCHARS (encoded_file
)
530 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
531 SCHARS (encoded_file
))
535 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
538 directoryp
= S_ISDIR (st
.st_mode
) != 0;
540 /* If all_flag is set, always include all.
541 It would not actually be helpful to the user to ignore any possible
542 completions when making a list of them. */
547 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
548 /* If this entry matches the current bestmatch, the only
549 thing it can do is increase matchcount, so don't bother
550 investigating it any further. */
551 if (!completion_ignore_case
552 /* The return result depends on whether it's the sole match. */
554 && !includeall
/* This match may allow includeall to 0. */
555 && len
>= bestmatchsize
556 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
562 #ifndef TRIVIAL_DIRECTORY_ENTRY
563 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
565 /* "." and ".." are never interesting as completions, and are
566 actually in the way in a directory with only one file. */
567 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
569 else if (len
> SCHARS (encoded_file
))
570 /* Ignore directories if they match an element of
571 completion-ignored-extensions which ends in a slash. */
572 for (tem
= Vcompletion_ignored_extensions
;
573 CONSP (tem
); tem
= XCDR (tem
))
581 /* Need to encode ELT, since scmp compares unibyte
583 elt
= ENCODE_FILE (elt
);
584 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
588 if (p1
[elt_len
] != '/')
590 skip
= len
- elt_len
;
594 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
601 /* Compare extensions-to-be-ignored against end of this file name */
602 /* if name is not an exact match against specified string */
603 if (len
> SCHARS (encoded_file
))
604 /* and exit this for loop if a match is found */
605 for (tem
= Vcompletion_ignored_extensions
;
606 CONSP (tem
); tem
= XCDR (tem
))
609 if (!STRINGP (elt
)) continue;
610 /* Need to encode ELT, since scmp compares unibyte
612 elt
= ENCODE_FILE (elt
);
613 skip
= len
- SCHARS (elt
);
614 if (skip
< 0) continue;
616 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
623 /* If an ignored-extensions match was found,
624 don't process this name as a completion. */
628 if (!includeall
&& canexclude
)
629 /* We're not including all files and this file can be excluded. */
632 if (includeall
&& !canexclude
)
633 { /* If we have one non-excludable file, we want to exclude the
636 /* Throw away any previous excludable match found. */
642 /* FIXME: If we move this `decode' earlier we can eliminate
643 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
644 name
= make_unibyte_string (dp
->d_name
, len
);
645 name
= DECODE_FILE (name
);
648 Lisp_Object regexps
, table
= (completion_ignore_case
649 ? Vascii_canon_table
: Qnil
);
651 /* Ignore this element if it fails to match all the regexps. */
652 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
653 regexps
= XCDR (regexps
))
654 if (fast_string_match_internal (XCAR (regexps
), name
, table
) < 0)
661 /* This is a possible completion */
663 /* This completion is a directory; make it end with '/'. */
664 name
= Ffile_name_as_directory (name
);
666 /* Test the predicate, if any. */
667 if (!NILP (predicate
))
673 val
= call1 (predicate
, name
);
680 /* Suitably record this match. */
682 matchcount
+= matchcount
<= 1;
685 bestmatch
= Fcons (name
, bestmatch
);
686 else if (NILP (bestmatch
))
689 bestmatchsize
= SCHARS (name
);
693 Lisp_Object zero
= make_number (0);
694 /* FIXME: This is a copy of the code in Ftry_completion. */
695 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
697 = Fcompare_strings (bestmatch
, zero
,
698 make_number (compare
),
700 make_number (compare
),
701 completion_ignore_case
? Qt
: Qnil
);
702 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
704 if (completion_ignore_case
)
706 /* If this is an exact match except for case,
707 use it as the best match rather than one that is not
708 an exact match. This way, we get the case pattern
709 of the actual match. */
710 /* This tests that the current file is an exact match
711 but BESTMATCH is not (it is too long). */
712 if ((matchsize
== SCHARS (name
)
713 && matchsize
+ directoryp
< SCHARS (bestmatch
))
715 /* If there is no exact match ignoring case,
716 prefer a match that does not change the case
718 /* If there is more than one exact match aside from
719 case, and one of them is exact including case,
721 /* This == checks that, of current file and BESTMATCH,
722 either both or neither are exact. */
723 (((matchsize
== SCHARS (name
))
725 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
726 && (cmp
= Fcompare_strings (name
, zero
,
727 make_number (SCHARS (file
)),
732 && (cmp
= Fcompare_strings (bestmatch
, zero
,
733 make_number (SCHARS (file
)),
740 bestmatchsize
= matchsize
;
742 /* If the best completion so far is reduced to the string
743 we're trying to complete, then we already know there's no
744 other completion, so there's no point looking any further. */
745 if (matchsize
<= SCHARS (file
)
746 && !includeall
/* A future match may allow includeall to 0. */
747 /* If completion-ignore-case is non-nil, don't
748 short-circuit because we want to find the best
749 possible match *including* case differences. */
750 && (!completion_ignore_case
|| matchsize
== 0)
751 /* The return value depends on whether it's the sole match. */
759 /* This closes the directory. */
760 bestmatch
= unbind_to (count
, bestmatch
);
762 if (all_flag
|| NILP (bestmatch
))
764 /* Return t if the supplied string is an exact match (counting case);
765 it does not require any change to be made. */
766 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
768 bestmatch
= Fsubstring (bestmatch
, make_number (0),
769 make_number (bestmatchsize
));
773 /* Compare exactly LEN chars of strings at S1 and S2,
774 ignoring case if appropriate.
775 Return -1 if strings match,
776 else number of chars that match at the beginning. */
779 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
781 register ptrdiff_t l
= len
;
783 if (completion_ignore_case
)
786 && (downcase ((unsigned char) *s1
++)
787 == downcase ((unsigned char) *s2
++)))
792 while (l
&& *s1
++ == *s2
++)
802 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
807 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
808 but aren't required here. Avoid computing the following fields:
809 st_inode, st_size and st_nlink for directories, and the execute bits
810 in st_mode for non-directory files with non-standard extensions. */
812 unsigned short save_djstat_flags
= _djstat_flags
;
814 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
817 /* We want to return success if a link points to a nonexistent file,
818 but we want to return the status for what the link points to,
819 in case it is a directory. */
820 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
821 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
822 fstatat (fd
, dp
->d_name
, st_addr
, 0);
824 _djstat_flags
= save_djstat_flags
;
830 stat_uname (struct stat
*st
)
835 struct passwd
*pw
= getpwuid (st
->st_uid
);
845 stat_gname (struct stat
*st
)
850 struct group
*gr
= getgrgid (st
->st_gid
);
859 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
860 doc
: /* Return a list of attributes of file FILENAME.
861 Value is nil if specified file cannot be opened.
863 ID-FORMAT specifies the preferred format of attributes uid and gid (see
864 below) - valid values are 'string and 'integer. The latter is the
865 default, but we plan to change that, so you should specify a non-nil value
866 for ID-FORMAT if you use the returned uid or gid.
868 Elements of the attribute list are:
869 0. t for directory, string (name linked to) for symbolic link, or nil.
870 1. Number of links to file.
871 2. File uid as a string or a number. If a string value cannot be
872 looked up, a numeric value, either an integer or a float, is returned.
873 3. File gid, likewise.
874 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
875 same style as (current-time).
876 (See a note below about access time on FAT-based filesystems.)
877 5. Last modification time, likewise. This is the time of the last
878 change to the file's contents.
879 6. Last status change time, likewise. This is the time of last change
880 to the file's attributes: owner and group, access mode bits, etc.
882 This is a floating point number if the size is too large for an integer.
883 8. File modes, as a string of ten letters or dashes as in ls -l.
884 9. An unspecified value, present only for backward compatibility.
885 10. inode number. If it is larger than what an Emacs integer can hold,
886 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
887 If even HIGH is too large for an Emacs integer, this is instead of the form
888 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
889 and finally the low 16 bits.
890 11. Filesystem device number. If it is larger than what the Emacs
891 integer can hold, this is a cons cell, similar to the inode number.
893 On most filesystems, the combination of the inode and the device
894 number uniquely identifies the file.
896 On MS-Windows, performance depends on `w32-get-true-file-attributes',
899 On some FAT-based filesystems, only the date of last access is recorded,
900 so last access time will always be midnight of that day. */)
901 (Lisp_Object filename
, Lisp_Object id_format
)
906 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
908 if (!STRINGP (filename
))
911 /* If the file name has special constructs in it,
912 call the corresponding file handler. */
913 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
915 { /* Only pass the extra arg if it is used to help backward compatibility
916 with old file handlers which do not implement the new arg. --Stef */
917 if (NILP (id_format
))
918 return call2 (handler
, Qfile_attributes
, filename
);
920 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
923 encoded
= ENCODE_FILE (filename
);
924 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
928 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
933 /* An array to hold the mode string generated by filemodestring,
934 including its terminating space and null byte. */
935 char modes
[sizeof "-rwxr-xr-x "];
937 char *uname
= NULL
, *gname
= NULL
;
940 /* We usually don't request accurate owner and group info, because
941 it can be very expensive on Windows to get that, and most callers
942 of 'lstat' don't need that. But here we do want that information
944 w32_stat_get_owner_group
= 1;
947 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
950 w32_stat_get_owner_group
= 0;
953 if (lstat_result
< 0)
956 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
959 uname
= stat_uname (&s
);
960 gname
= stat_gname (&s
);
964 filemodestring (&s
, modes
);
967 (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
968 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
),
969 make_number (s
.st_nlink
),
971 ? DECODE_SYSTEM (build_unibyte_string (uname
))
972 : make_fixnum_or_float (s
.st_uid
)),
974 ? DECODE_SYSTEM (build_unibyte_string (gname
))
975 : make_fixnum_or_float (s
.st_gid
)),
976 make_lisp_time (get_stat_atime (&s
)),
977 make_lisp_time (get_stat_mtime (&s
)),
978 make_lisp_time (get_stat_ctime (&s
)),
980 /* If the file size is a 4-byte type, assume that
981 files of sizes in the 2-4 GiB range wrap around to
982 negative values, as this is a common bug on older
984 make_fixnum_or_float (sizeof (s
.st_size
) == 4
985 ? s
.st_size
& 0xffffffffu
988 make_string (modes
, 10),
990 INTEGER_TO_CONS (s
.st_ino
),
991 INTEGER_TO_CONS (s
.st_dev
));
994 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
995 doc
: /* Return t if first arg file attributes list is less than second.
996 Comparison is in lexicographic order and case is significant. */)
997 (Lisp_Object f1
, Lisp_Object f2
)
999 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1003 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
1004 doc
: /* Return a list of user names currently registered in the system.
1005 If we don't know how to determine that on this platform, just
1006 return a list with one element, taken from `user-real-login-name'. */)
1009 Lisp_Object users
= Qnil
;
1010 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
1013 while ((pw
= getpwent ()))
1014 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
1018 if (EQ (users
, Qnil
))
1019 /* At least current user is always known. */
1020 users
= list1 (Vuser_real_login_name
);
1024 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
1025 doc
: /* Return a list of user group names currently registered in the system.
1026 The value may be nil if not supported on this platform. */)
1029 Lisp_Object groups
= Qnil
;
1030 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
1033 while ((gr
= getgrent ()))
1034 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1042 syms_of_dired (void)
1044 DEFSYM (Qdirectory_files
, "directory-files");
1045 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1046 DEFSYM (Qfile_name_completion
, "file-name-completion");
1047 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1048 DEFSYM (Qfile_attributes
, "file-attributes");
1049 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1050 DEFSYM (Qdefault_directory
, "default-directory");
1052 defsubr (&Sdirectory_files
);
1053 defsubr (&Sdirectory_files_and_attributes
);
1054 defsubr (&Sfile_name_completion
);
1055 defsubr (&Sfile_name_all_completions
);
1056 defsubr (&Sfile_attributes
);
1057 defsubr (&Sfile_attributes_lessp
);
1058 defsubr (&Ssystem_users
);
1059 defsubr (&Ssystem_groups
);
1061 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1062 doc
: /* Completion ignores file names ending in any string in this list.
1063 It does not ignore them if all possible completions end in one of
1064 these strings or when displaying a list of completions.
1065 It ignores directory names if they match any string in this list which
1066 ends in a slash. */);
1067 Vcompletion_ignored_extensions
= Qnil
;