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. FIRST_ENTRY true means this is
128 the first call after open_directory. */
130 static struct dirent
*
131 read_dirent (DIR *dir
, Lisp_Object dirname
, bool first_entry
)
136 struct dirent
*dp
= readdir (dir
);
137 if (dp
|| errno
== 0)
139 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 (first_entry
&& (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 ();
169 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
171 Lisp_Object w32_save
= Qnil
;
174 /* Don't let the compiler optimize away all copies of DIRECTORY,
175 which would break GC; see Bug#16986. Although this is required
176 only in the common case where GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS,
177 it shouldn't break anything in the other cases. */
178 Lisp_Object
volatile directory_volatile
= directory
;
180 /* Because of file name handlers, these functions might call
181 Ffuncall, and cause a GC. */
182 list
= encoded_directory
= dirfilename
= Qnil
;
183 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
184 dirfilename
= Fdirectory_file_name (directory
);
188 CHECK_STRING (match
);
190 /* MATCH might be a flawed regular expression. Rather than
191 catching and signaling our own errors, we just call
192 compile_pattern to do the work for us. */
193 /* Pass 1 for the MULTIBYTE arg
194 because we do make multibyte strings if the contents warrant. */
196 /* Windows users want case-insensitive wildcards. */
197 bufp
= compile_pattern (match
, 0,
198 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
199 # else /* !WINDOWSNT */
200 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
201 # endif /* !WINDOWSNT */
204 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
205 run_pre_post_conversion_on_str which calls Lisp directly and
207 dirfilename
= ENCODE_FILE (dirfilename
);
208 encoded_directory
= ENCODE_FILE (directory
);
210 /* Now *bufp is the compiled form of MATCH; don't call anything
211 which might compile a new regexp until we're done with the loop! */
214 DIR *d
= open_directory (dirfilename
, &fd
);
216 /* Unfortunately, we can now invoke expand-file-name and
217 file-attributes on filenames, both of which can throw, so we must
218 do a proper unwind-protect. */
219 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
224 extern int is_slow_fs (const char *);
226 /* Do this only once to avoid doing it (in w32.c:stat) for each
227 file in the directory, when we call Ffile_attributes below. */
228 record_unwind_protect (directory_files_internal_w32_unwind
,
229 Vw32_get_true_file_attributes
);
230 w32_save
= Vw32_get_true_file_attributes
;
231 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
233 /* w32.c:stat will notice these bindings and avoid calling
234 GetDriveType for each file. */
235 if (is_slow_fs (SDATA (dirfilename
)))
236 Vw32_get_true_file_attributes
= Qnil
;
238 Vw32_get_true_file_attributes
= Qt
;
243 directory_nbytes
= SBYTES (directory
);
244 re_match_object
= Qt
;
246 /* Decide whether we need to add a directory separator. */
247 if (directory_nbytes
== 0
248 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
251 /* Loop reading directory entries. */
252 bool first_entry
= true;
253 for (struct dirent
*dp
; (dp
= read_dirent (d
, directory
, first_entry
)); )
255 ptrdiff_t len
= dirent_namelen (dp
);
256 Lisp_Object name
= make_unibyte_string (dp
->d_name
, len
);
257 Lisp_Object finalname
= name
;
258 struct gcpro gcpro1
, gcpro2
;
259 GCPRO2 (finalname
, name
);
263 /* Note: DECODE_FILE can GC; it should protect its argument,
265 name
= DECODE_FILE (name
);
268 /* Now that we have unwind_protect in place, we might as well
269 allow matching to be interrupted. */
273 bool wanted
= (NILP (match
)
274 || re_search (bufp
, SSDATA (name
), len
, 0, len
, 0) >= 0);
282 Lisp_Object fullname
;
283 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
286 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
287 memcpy (SDATA (fullname
), SDATA (directory
),
291 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
293 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
296 nchars
= multibyte_chars_in_text (SDATA (fullname
), nbytes
);
298 /* Some bug somewhere. */
302 STRING_SET_CHARS (fullname
, nchars
);
303 if (nchars
== nbytes
)
304 STRING_SET_UNIBYTE (fullname
);
306 finalname
= fullname
;
313 Lisp_Object fileattrs
314 = file_attributes (fd
, dp
->d_name
, id_format
);
315 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
318 list
= Fcons (finalname
, list
);
329 Vw32_get_true_file_attributes
= w32_save
;
332 /* Discard the unwind protect. */
333 specpdl_ptr
= specpdl
+ count
;
336 list
= Fsort (Fnreverse (list
),
337 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
339 (void) directory_volatile
;
340 RETURN_UNGCPRO (list
);
344 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
345 doc
: /* Return a list of names of files in DIRECTORY.
346 There are three optional arguments:
347 If FULL is non-nil, return absolute file names. Otherwise return names
348 that are relative to the specified directory.
349 If MATCH is non-nil, mention only file names that match the regexp MATCH.
350 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
351 Otherwise, the list returned is sorted with `string-lessp'.
352 NOSORT is useful if you plan to sort the result yourself. */)
353 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
356 directory
= Fexpand_file_name (directory
, Qnil
);
358 /* If the file name has special constructs in it,
359 call the corresponding file handler. */
360 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
362 return call5 (handler
, Qdirectory_files
, directory
,
363 full
, match
, nosort
);
365 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
368 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
369 Sdirectory_files_and_attributes
, 1, 5, 0,
370 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
371 There are four optional arguments:
372 If FULL is non-nil, return absolute file names. Otherwise return names
373 that are relative to the specified directory.
374 If MATCH is non-nil, mention only file names that match the regexp MATCH.
375 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
376 NOSORT is useful if you plan to sort the result yourself.
377 ID-FORMAT specifies the preferred format of attributes uid and gid, see
378 `file-attributes' for further documentation.
379 On MS-Windows, performance depends on `w32-get-true-file-attributes',
381 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
384 directory
= Fexpand_file_name (directory
, Qnil
);
386 /* If the file name has special constructs in it,
387 call the corresponding file handler. */
388 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
390 return call6 (handler
, Qdirectory_files_and_attributes
,
391 directory
, full
, match
, nosort
, id_format
);
393 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
397 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
400 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
402 doc
: /* Complete file name FILE in directory DIRECTORY.
403 Returns the longest string
404 common to all file names in DIRECTORY that start with FILE.
405 If there is only one and FILE matches it exactly, returns t.
406 Returns nil if DIRECTORY contains no name starting with FILE.
408 If PREDICATE is non-nil, call PREDICATE with each possible
409 completion (in absolute form) and ignore it if PREDICATE returns nil.
411 This function ignores some of the possible completions as
412 determined by the variable `completion-ignored-extensions', which see. */)
413 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
416 directory
= Fexpand_file_name (directory
, Qnil
);
418 /* If the directory name has special constructs in it,
419 call the corresponding file handler. */
420 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
422 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
424 /* If the file name has special constructs in it,
425 call the corresponding file handler. */
426 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
428 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
430 return file_name_completion (file
, directory
, 0, predicate
);
433 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
434 Sfile_name_all_completions
, 2, 2, 0,
435 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
436 These are all file names in directory DIRECTORY which begin with FILE. */)
437 (Lisp_Object file
, Lisp_Object directory
)
440 directory
= Fexpand_file_name (directory
, Qnil
);
442 /* If the directory name has special constructs in it,
443 call the corresponding file handler. */
444 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
446 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
448 /* If the file name has special constructs in it,
449 call the corresponding file handler. */
450 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
452 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
454 return file_name_completion (file
, directory
, 1, Qnil
);
457 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
460 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
461 Lisp_Object predicate
)
463 ptrdiff_t bestmatchsize
= 0;
465 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
466 If ALL_FLAG is 0, BESTMATCH is either nil
467 or the best match so far, not decoded. */
468 Lisp_Object bestmatch
, tem
, elt
, name
;
469 Lisp_Object encoded_file
;
470 Lisp_Object encoded_dir
;
473 /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
474 well as "." and "..". Until shown otherwise, assume we can't exclude
477 ptrdiff_t count
= SPECPDL_INDEX ();
478 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
485 encoded_file
= encoded_dir
= Qnil
;
486 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
487 specbind (Qdefault_directory
, dirname
);
489 /* Do completion on the encoded file name
490 because the other names in the directory are (we presume)
491 encoded likewise. We decode the completed string at the end. */
492 /* Actually, this is not quite true any more: we do most of the completion
493 work with decoded file names, but we still do some filtering based
494 on the encoded file name. */
495 encoded_file
= ENCODE_FILE (file
);
496 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
498 DIR *d
= open_directory (encoded_dir
, &fd
);
499 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
501 /* Loop reading directory entries. */
502 bool first_entry
= true;
503 for (struct dirent
*dp
; (dp
= read_dirent (d
, dirname
, first_entry
)); )
505 ptrdiff_t len
= dirent_namelen (dp
);
510 if (len
< SCHARS (encoded_file
)
511 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
512 SCHARS (encoded_file
))
516 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
519 directoryp
= S_ISDIR (st
.st_mode
) != 0;
521 /* If all_flag is set, always include all.
522 It would not actually be helpful to the user to ignore any possible
523 completions when making a list of them. */
528 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
529 /* If this entry matches the current bestmatch, the only
530 thing it can do is increase matchcount, so don't bother
531 investigating it any further. */
532 if (!completion_ignore_case
533 /* The return result depends on whether it's the sole match. */
535 && !includeall
/* This match may allow includeall to 0. */
536 && len
>= bestmatchsize
537 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
543 #ifndef TRIVIAL_DIRECTORY_ENTRY
544 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
546 /* "." and ".." are never interesting as completions, and are
547 actually in the way in a directory with only one file. */
548 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
550 else if (len
> SCHARS (encoded_file
))
551 /* Ignore directories if they match an element of
552 completion-ignored-extensions which ends in a slash. */
553 for (tem
= Vcompletion_ignored_extensions
;
554 CONSP (tem
); tem
= XCDR (tem
))
562 /* Need to encode ELT, since scmp compares unibyte
564 elt
= ENCODE_FILE (elt
);
565 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
569 if (p1
[elt_len
] != '/')
571 skip
= len
- elt_len
;
575 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
582 /* Compare extensions-to-be-ignored against end of this file name */
583 /* if name is not an exact match against specified string */
584 if (len
> SCHARS (encoded_file
))
585 /* and exit this for loop if a match is found */
586 for (tem
= Vcompletion_ignored_extensions
;
587 CONSP (tem
); tem
= XCDR (tem
))
590 if (!STRINGP (elt
)) continue;
591 /* Need to encode ELT, since scmp compares unibyte
593 elt
= ENCODE_FILE (elt
);
594 skip
= len
- SCHARS (elt
);
595 if (skip
< 0) continue;
597 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
604 /* If an ignored-extensions match was found,
605 don't process this name as a completion. */
609 if (!includeall
&& canexclude
)
610 /* We're not including all files and this file can be excluded. */
613 if (includeall
&& !canexclude
)
614 { /* If we have one non-excludable file, we want to exclude the
617 /* Throw away any previous excludable match found. */
623 /* FIXME: If we move this `decode' earlier we can eliminate
624 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
625 name
= make_unibyte_string (dp
->d_name
, len
);
626 name
= DECODE_FILE (name
);
629 Lisp_Object regexps
, table
= (completion_ignore_case
630 ? Vascii_canon_table
: Qnil
);
632 /* Ignore this element if it fails to match all the regexps. */
633 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
634 regexps
= XCDR (regexps
))
635 if (fast_string_match_internal (XCAR (regexps
), name
, table
) < 0)
642 /* This is a possible completion */
644 /* This completion is a directory; make it end with '/'. */
645 name
= Ffile_name_as_directory (name
);
647 /* Test the predicate, if any. */
648 if (!NILP (predicate
))
654 val
= call1 (predicate
, name
);
661 /* Suitably record this match. */
663 matchcount
+= matchcount
<= 1;
666 bestmatch
= Fcons (name
, bestmatch
);
667 else if (NILP (bestmatch
))
670 bestmatchsize
= SCHARS (name
);
674 Lisp_Object zero
= make_number (0);
675 /* FIXME: This is a copy of the code in Ftry_completion. */
676 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
678 = Fcompare_strings (bestmatch
, zero
,
679 make_number (compare
),
681 make_number (compare
),
682 completion_ignore_case
? Qt
: Qnil
);
683 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
685 if (completion_ignore_case
)
687 /* If this is an exact match except for case,
688 use it as the best match rather than one that is not
689 an exact match. This way, we get the case pattern
690 of the actual match. */
691 /* This tests that the current file is an exact match
692 but BESTMATCH is not (it is too long). */
693 if ((matchsize
== SCHARS (name
)
694 && matchsize
+ directoryp
< SCHARS (bestmatch
))
696 /* If there is no exact match ignoring case,
697 prefer a match that does not change the case
699 /* If there is more than one exact match aside from
700 case, and one of them is exact including case,
702 /* This == checks that, of current file and BESTMATCH,
703 either both or neither are exact. */
704 (((matchsize
== SCHARS (name
))
706 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
707 && (cmp
= Fcompare_strings (name
, zero
,
708 make_number (SCHARS (file
)),
713 && (cmp
= Fcompare_strings (bestmatch
, zero
,
714 make_number (SCHARS (file
)),
721 bestmatchsize
= matchsize
;
723 /* If the best completion so far is reduced to the string
724 we're trying to complete, then we already know there's no
725 other completion, so there's no point looking any further. */
726 if (matchsize
<= SCHARS (file
)
727 && !includeall
/* A future match may allow includeall to 0. */
728 /* If completion-ignore-case is non-nil, don't
729 short-circuit because we want to find the best
730 possible match *including* case differences. */
731 && (!completion_ignore_case
|| matchsize
== 0)
732 /* The return value depends on whether it's the sole match. */
740 /* This closes the directory. */
741 bestmatch
= unbind_to (count
, bestmatch
);
743 if (all_flag
|| NILP (bestmatch
))
745 /* Return t if the supplied string is an exact match (counting case);
746 it does not require any change to be made. */
747 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
749 bestmatch
= Fsubstring (bestmatch
, make_number (0),
750 make_number (bestmatchsize
));
754 /* Compare exactly LEN chars of strings at S1 and S2,
755 ignoring case if appropriate.
756 Return -1 if strings match,
757 else number of chars that match at the beginning. */
760 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
762 register ptrdiff_t l
= len
;
764 if (completion_ignore_case
)
767 && (downcase ((unsigned char) *s1
++)
768 == downcase ((unsigned char) *s2
++)))
773 while (l
&& *s1
++ == *s2
++)
783 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
788 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
789 but aren't required here. Avoid computing the following fields:
790 st_inode, st_size and st_nlink for directories, and the execute bits
791 in st_mode for non-directory files with non-standard extensions. */
793 unsigned short save_djstat_flags
= _djstat_flags
;
795 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
798 /* We want to return success if a link points to a nonexistent file,
799 but we want to return the status for what the link points to,
800 in case it is a directory. */
801 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
802 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
803 fstatat (fd
, dp
->d_name
, st_addr
, 0);
805 _djstat_flags
= save_djstat_flags
;
811 stat_uname (struct stat
*st
)
816 struct passwd
*pw
= getpwuid (st
->st_uid
);
826 stat_gname (struct stat
*st
)
831 struct group
*gr
= getgrgid (st
->st_gid
);
840 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
841 doc
: /* Return a list of attributes of file FILENAME.
842 Value is nil if specified file cannot be opened.
844 ID-FORMAT specifies the preferred format of attributes uid and gid (see
845 below) - valid values are 'string and 'integer. The latter is the
846 default, but we plan to change that, so you should specify a non-nil value
847 for ID-FORMAT if you use the returned uid or gid.
849 Elements of the attribute list are:
850 0. t for directory, string (name linked to) for symbolic link, or nil.
851 1. Number of links to file.
852 2. File uid as a string or a number. If a string value cannot be
853 looked up, a numeric value, either an integer or a float, is returned.
854 3. File gid, likewise.
855 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
856 same style as (current-time).
857 (See a note below about access time on FAT-based filesystems.)
858 5. Last modification time, likewise. This is the time of the last
859 change to the file's contents.
860 6. Last status change time, likewise. This is the time of last change
861 to the file's attributes: owner and group, access mode bits, etc.
863 This is a floating point number if the size is too large for an integer.
864 8. File modes, as a string of ten letters or dashes as in ls -l.
865 9. An unspecified value, present only for backward compatibility.
866 10. inode number. If it is larger than what an Emacs integer can hold,
867 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
868 If even HIGH is too large for an Emacs integer, this is instead of the form
869 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
870 and finally the low 16 bits.
871 11. Filesystem device number. If it is larger than what the Emacs
872 integer can hold, this is a cons cell, similar to the inode number.
874 On most filesystems, the combination of the inode and the device
875 number uniquely identifies the file.
877 On MS-Windows, performance depends on `w32-get-true-file-attributes',
880 On some FAT-based filesystems, only the date of last access is recorded,
881 so last access time will always be midnight of that day. */)
882 (Lisp_Object filename
, Lisp_Object id_format
)
887 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
889 if (!STRINGP (filename
))
892 /* If the file name has special constructs in it,
893 call the corresponding file handler. */
894 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
896 { /* Only pass the extra arg if it is used to help backward compatibility
897 with old file handlers which do not implement the new arg. --Stef */
898 if (NILP (id_format
))
899 return call2 (handler
, Qfile_attributes
, filename
);
901 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
904 encoded
= ENCODE_FILE (filename
);
905 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
909 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
914 /* An array to hold the mode string generated by filemodestring,
915 including its terminating space and null byte. */
916 char modes
[sizeof "-rwxr-xr-x "];
918 char *uname
= NULL
, *gname
= NULL
;
921 /* We usually don't request accurate owner and group info, because
922 it can be very expensive on Windows to get that, and most callers
923 of 'lstat' don't need that. But here we do want that information
925 w32_stat_get_owner_group
= 1;
928 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
931 w32_stat_get_owner_group
= 0;
934 if (lstat_result
< 0)
937 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
940 uname
= stat_uname (&s
);
941 gname
= stat_gname (&s
);
945 filemodestring (&s
, modes
);
948 (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
949 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
),
950 make_number (s
.st_nlink
),
952 ? DECODE_SYSTEM (build_unibyte_string (uname
))
953 : make_fixnum_or_float (s
.st_uid
)),
955 ? DECODE_SYSTEM (build_unibyte_string (gname
))
956 : make_fixnum_or_float (s
.st_gid
)),
957 make_lisp_time (get_stat_atime (&s
)),
958 make_lisp_time (get_stat_mtime (&s
)),
959 make_lisp_time (get_stat_ctime (&s
)),
961 /* If the file size is a 4-byte type, assume that
962 files of sizes in the 2-4 GiB range wrap around to
963 negative values, as this is a common bug on older
965 make_fixnum_or_float (sizeof (s
.st_size
) == 4
966 ? s
.st_size
& 0xffffffffu
969 make_string (modes
, 10),
971 INTEGER_TO_CONS (s
.st_ino
),
972 INTEGER_TO_CONS (s
.st_dev
));
975 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
976 doc
: /* Return t if first arg file attributes list is less than second.
977 Comparison is in lexicographic order and case is significant. */)
978 (Lisp_Object f1
, Lisp_Object f2
)
980 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
984 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
985 doc
: /* Return a list of user names currently registered in the system.
986 If we don't know how to determine that on this platform, just
987 return a list with one element, taken from `user-real-login-name'. */)
990 Lisp_Object users
= Qnil
;
991 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
994 while ((pw
= getpwent ()))
995 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
999 if (EQ (users
, Qnil
))
1000 /* At least current user is always known. */
1001 users
= list1 (Vuser_real_login_name
);
1005 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
1006 doc
: /* Return a list of user group names currently registered in the system.
1007 The value may be nil if not supported on this platform. */)
1010 Lisp_Object groups
= Qnil
;
1011 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
1014 while ((gr
= getgrent ()))
1015 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1023 syms_of_dired (void)
1025 DEFSYM (Qdirectory_files
, "directory-files");
1026 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1027 DEFSYM (Qfile_name_completion
, "file-name-completion");
1028 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1029 DEFSYM (Qfile_attributes
, "file-attributes");
1030 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1031 DEFSYM (Qdefault_directory
, "default-directory");
1033 defsubr (&Sdirectory_files
);
1034 defsubr (&Sdirectory_files_and_attributes
);
1035 defsubr (&Sfile_name_completion
);
1036 defsubr (&Sfile_name_all_completions
);
1037 defsubr (&Sfile_attributes
);
1038 defsubr (&Sfile_attributes_lessp
);
1039 defsubr (&Ssystem_users
);
1040 defsubr (&Ssystem_groups
);
1042 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1043 doc
: /* Completion ignores file names ending in any string in this list.
1044 It does not ignore them if all possible completions end in one of
1045 these strings or when displaying a list of completions.
1046 It ignores directory names if they match any string in this list which
1047 ends in a slash. */);
1048 Vcompletion_ignored_extensions
= Qnil
;