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
))
139 report_file_error ("Reading directory", dirname
);
144 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
145 If not ATTRS, return a list of directory filenames;
146 if ATTRS, return a list of directory filenames and their attributes.
147 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
150 directory_files_internal (Lisp_Object directory
, Lisp_Object full
,
151 Lisp_Object match
, Lisp_Object nosort
, bool attrs
,
152 Lisp_Object id_format
)
154 ptrdiff_t directory_nbytes
;
155 Lisp_Object list
, dirfilename
, encoded_directory
;
156 struct re_pattern_buffer
*bufp
= NULL
;
158 ptrdiff_t count
= SPECPDL_INDEX ();
159 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
161 Lisp_Object w32_save
= Qnil
;
164 /* Don't let the compiler optimize away all copies of DIRECTORY,
165 which would break GC; see Bug#16986. Although this is required
166 only in the common case where GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS,
167 it shouldn't break anything in the other cases. */
168 Lisp_Object
volatile directory_volatile
= directory
;
170 /* Because of file name handlers, these functions might call
171 Ffuncall, and cause a GC. */
172 list
= encoded_directory
= dirfilename
= Qnil
;
173 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
174 dirfilename
= Fdirectory_file_name (directory
);
178 CHECK_STRING (match
);
180 /* MATCH might be a flawed regular expression. Rather than
181 catching and signaling our own errors, we just call
182 compile_pattern to do the work for us. */
183 /* Pass 1 for the MULTIBYTE arg
184 because we do make multibyte strings if the contents warrant. */
186 /* Windows users want case-insensitive wildcards. */
187 bufp
= compile_pattern (match
, 0,
188 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
189 # else /* !WINDOWSNT */
190 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
191 # endif /* !WINDOWSNT */
194 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
195 run_pre_post_conversion_on_str which calls Lisp directly and
197 dirfilename
= ENCODE_FILE (dirfilename
);
198 encoded_directory
= ENCODE_FILE (directory
);
200 /* Now *bufp is the compiled form of MATCH; don't call anything
201 which might compile a new regexp until we're done with the loop! */
204 DIR *d
= open_directory (dirfilename
, &fd
);
206 /* Unfortunately, we can now invoke expand-file-name and
207 file-attributes on filenames, both of which can throw, so we must
208 do a proper unwind-protect. */
209 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
214 extern int is_slow_fs (const char *);
216 /* Do this only once to avoid doing it (in w32.c:stat) for each
217 file in the directory, when we call Ffile_attributes below. */
218 record_unwind_protect (directory_files_internal_w32_unwind
,
219 Vw32_get_true_file_attributes
);
220 w32_save
= Vw32_get_true_file_attributes
;
221 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
223 /* w32.c:stat will notice these bindings and avoid calling
224 GetDriveType for each file. */
225 if (is_slow_fs (SDATA (dirfilename
)))
226 Vw32_get_true_file_attributes
= Qnil
;
228 Vw32_get_true_file_attributes
= Qt
;
233 directory_nbytes
= SBYTES (directory
);
234 re_match_object
= Qt
;
236 /* Decide whether we need to add a directory separator. */
237 if (directory_nbytes
== 0
238 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
241 /* Loop reading directory entries. */
242 for (struct dirent
*dp
; (dp
= read_dirent (d
, directory
)); )
244 ptrdiff_t len
= dirent_namelen (dp
);
245 Lisp_Object name
= make_unibyte_string (dp
->d_name
, len
);
246 Lisp_Object finalname
= name
;
247 struct gcpro gcpro1
, gcpro2
;
248 GCPRO2 (finalname
, name
);
250 /* Note: DECODE_FILE can GC; it should protect its argument,
252 name
= DECODE_FILE (name
);
255 /* Now that we have unwind_protect in place, we might as well
256 allow matching to be interrupted. */
260 bool wanted
= (NILP (match
)
261 || re_search (bufp
, SSDATA (name
), len
, 0, len
, 0) >= 0);
269 Lisp_Object fullname
;
270 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
273 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
274 memcpy (SDATA (fullname
), SDATA (directory
),
278 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
280 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
283 nchars
= multibyte_chars_in_text (SDATA (fullname
), nbytes
);
285 /* Some bug somewhere. */
289 STRING_SET_CHARS (fullname
, nchars
);
290 if (nchars
== nbytes
)
291 STRING_SET_UNIBYTE (fullname
);
293 finalname
= fullname
;
300 Lisp_Object fileattrs
301 = file_attributes (fd
, dp
->d_name
, id_format
);
302 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
305 list
= Fcons (finalname
, list
);
316 Vw32_get_true_file_attributes
= w32_save
;
319 /* Discard the unwind protect. */
320 specpdl_ptr
= specpdl
+ count
;
323 list
= Fsort (Fnreverse (list
),
324 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
326 (void) directory_volatile
;
327 RETURN_UNGCPRO (list
);
331 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
332 doc
: /* Return a list of names of files in DIRECTORY.
333 There are three optional arguments:
334 If FULL is non-nil, return absolute file names. Otherwise return names
335 that are relative to the specified directory.
336 If MATCH is non-nil, mention only file names that match the regexp MATCH.
337 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
338 Otherwise, the list returned is sorted with `string-lessp'.
339 NOSORT is useful if you plan to sort the result yourself. */)
340 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
343 directory
= Fexpand_file_name (directory
, Qnil
);
345 /* If the file name has special constructs in it,
346 call the corresponding file handler. */
347 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
349 return call5 (handler
, Qdirectory_files
, directory
,
350 full
, match
, nosort
);
352 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
355 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
356 Sdirectory_files_and_attributes
, 1, 5, 0,
357 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
358 There are four optional arguments:
359 If FULL is non-nil, return absolute file names. Otherwise return names
360 that are relative to the specified directory.
361 If MATCH is non-nil, mention only file names that match the regexp MATCH.
362 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
363 NOSORT is useful if you plan to sort the result yourself.
364 ID-FORMAT specifies the preferred format of attributes uid and gid, see
365 `file-attributes' for further documentation.
366 On MS-Windows, performance depends on `w32-get-true-file-attributes',
368 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
371 directory
= Fexpand_file_name (directory
, Qnil
);
373 /* If the file name has special constructs in it,
374 call the corresponding file handler. */
375 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
377 return call6 (handler
, Qdirectory_files_and_attributes
,
378 directory
, full
, match
, nosort
, id_format
);
380 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
384 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
387 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
389 doc
: /* Complete file name FILE in directory DIRECTORY.
390 Returns the longest string
391 common to all file names in DIRECTORY that start with FILE.
392 If there is only one and FILE matches it exactly, returns t.
393 Returns nil if DIRECTORY contains no name starting with FILE.
395 If PREDICATE is non-nil, call PREDICATE with each possible
396 completion (in absolute form) and ignore it if PREDICATE returns nil.
398 This function ignores some of the possible completions as
399 determined by the variable `completion-ignored-extensions', which see. */)
400 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
403 directory
= Fexpand_file_name (directory
, Qnil
);
405 /* If the directory name has special constructs in it,
406 call the corresponding file handler. */
407 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
409 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
411 /* If the file name has special constructs in it,
412 call the corresponding file handler. */
413 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
415 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
417 return file_name_completion (file
, directory
, 0, predicate
);
420 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
421 Sfile_name_all_completions
, 2, 2, 0,
422 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
423 These are all file names in directory DIRECTORY which begin with FILE. */)
424 (Lisp_Object file
, Lisp_Object directory
)
427 directory
= Fexpand_file_name (directory
, Qnil
);
429 /* If the directory name has special constructs in it,
430 call the corresponding file handler. */
431 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
433 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
435 /* If the file name has special constructs in it,
436 call the corresponding file handler. */
437 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
439 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
441 return file_name_completion (file
, directory
, 1, Qnil
);
444 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
447 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
448 Lisp_Object predicate
)
450 ptrdiff_t bestmatchsize
= 0;
452 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
453 If ALL_FLAG is 0, BESTMATCH is either nil
454 or the best match so far, not decoded. */
455 Lisp_Object bestmatch
, tem
, elt
, name
;
456 Lisp_Object encoded_file
;
457 Lisp_Object encoded_dir
;
460 /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
461 well as "." and "..". Until shown otherwise, assume we can't exclude
464 ptrdiff_t count
= SPECPDL_INDEX ();
465 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
472 encoded_file
= encoded_dir
= Qnil
;
473 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
474 specbind (Qdefault_directory
, dirname
);
476 /* Do completion on the encoded file name
477 because the other names in the directory are (we presume)
478 encoded likewise. We decode the completed string at the end. */
479 /* Actually, this is not quite true any more: we do most of the completion
480 work with decoded file names, but we still do some filtering based
481 on the encoded file name. */
482 encoded_file
= ENCODE_FILE (file
);
483 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
485 DIR *d
= open_directory (encoded_dir
, &fd
);
486 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
488 /* Loop reading directory entries. */
489 for (struct dirent
*dp
; (dp
= read_dirent (d
, dirname
)); )
491 ptrdiff_t len
= dirent_namelen (dp
);
495 if (len
< SCHARS (encoded_file
)
496 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
497 SCHARS (encoded_file
))
501 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
504 directoryp
= S_ISDIR (st
.st_mode
) != 0;
506 /* If all_flag is set, always include all.
507 It would not actually be helpful to the user to ignore any possible
508 completions when making a list of them. */
513 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
514 /* If this entry matches the current bestmatch, the only
515 thing it can do is increase matchcount, so don't bother
516 investigating it any further. */
517 if (!completion_ignore_case
518 /* The return result depends on whether it's the sole match. */
520 && !includeall
/* This match may allow includeall to 0. */
521 && len
>= bestmatchsize
522 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
528 #ifndef TRIVIAL_DIRECTORY_ENTRY
529 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
531 /* "." and ".." are never interesting as completions, and are
532 actually in the way in a directory with only one file. */
533 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
535 else if (len
> SCHARS (encoded_file
))
536 /* Ignore directories if they match an element of
537 completion-ignored-extensions which ends in a slash. */
538 for (tem
= Vcompletion_ignored_extensions
;
539 CONSP (tem
); tem
= XCDR (tem
))
547 /* Need to encode ELT, since scmp compares unibyte
549 elt
= ENCODE_FILE (elt
);
550 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
554 if (p1
[elt_len
] != '/')
556 skip
= len
- elt_len
;
560 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
567 /* Compare extensions-to-be-ignored against end of this file name */
568 /* if name is not an exact match against specified string */
569 if (len
> SCHARS (encoded_file
))
570 /* and exit this for loop if a match is found */
571 for (tem
= Vcompletion_ignored_extensions
;
572 CONSP (tem
); tem
= XCDR (tem
))
575 if (!STRINGP (elt
)) continue;
576 /* Need to encode ELT, since scmp compares unibyte
578 elt
= ENCODE_FILE (elt
);
579 skip
= len
- SCHARS (elt
);
580 if (skip
< 0) continue;
582 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
589 /* If an ignored-extensions match was found,
590 don't process this name as a completion. */
594 if (!includeall
&& canexclude
)
595 /* We're not including all files and this file can be excluded. */
598 if (includeall
&& !canexclude
)
599 { /* If we have one non-excludable file, we want to exclude the
602 /* Throw away any previous excludable match found. */
608 /* FIXME: If we move this `decode' earlier we can eliminate
609 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
610 name
= make_unibyte_string (dp
->d_name
, len
);
611 name
= DECODE_FILE (name
);
614 Lisp_Object regexps
, table
= (completion_ignore_case
615 ? Vascii_canon_table
: Qnil
);
617 /* Ignore this element if it fails to match all the regexps. */
618 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
619 regexps
= XCDR (regexps
))
620 if (fast_string_match_internal (XCAR (regexps
), name
, table
) < 0)
627 /* This is a possible completion */
629 /* This completion is a directory; make it end with '/'. */
630 name
= Ffile_name_as_directory (name
);
632 /* Test the predicate, if any. */
633 if (!NILP (predicate
))
639 val
= call1 (predicate
, name
);
646 /* Suitably record this match. */
648 matchcount
+= matchcount
<= 1;
651 bestmatch
= Fcons (name
, bestmatch
);
652 else if (NILP (bestmatch
))
655 bestmatchsize
= SCHARS (name
);
659 Lisp_Object zero
= make_number (0);
660 /* FIXME: This is a copy of the code in Ftry_completion. */
661 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
663 = Fcompare_strings (bestmatch
, zero
,
664 make_number (compare
),
666 make_number (compare
),
667 completion_ignore_case
? Qt
: Qnil
);
668 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
670 if (completion_ignore_case
)
672 /* If this is an exact match except for case,
673 use it as the best match rather than one that is not
674 an exact match. This way, we get the case pattern
675 of the actual match. */
676 /* This tests that the current file is an exact match
677 but BESTMATCH is not (it is too long). */
678 if ((matchsize
== SCHARS (name
)
679 && matchsize
+ directoryp
< SCHARS (bestmatch
))
681 /* If there is no exact match ignoring case,
682 prefer a match that does not change the case
684 /* If there is more than one exact match aside from
685 case, and one of them is exact including case,
687 /* This == checks that, of current file and BESTMATCH,
688 either both or neither are exact. */
689 (((matchsize
== SCHARS (name
))
691 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
692 && (cmp
= Fcompare_strings (name
, zero
,
693 make_number (SCHARS (file
)),
698 && (cmp
= Fcompare_strings (bestmatch
, zero
,
699 make_number (SCHARS (file
)),
706 bestmatchsize
= matchsize
;
708 /* If the best completion so far is reduced to the string
709 we're trying to complete, then we already know there's no
710 other completion, so there's no point looking any further. */
711 if (matchsize
<= SCHARS (file
)
712 && !includeall
/* A future match may allow includeall to 0. */
713 /* If completion-ignore-case is non-nil, don't
714 short-circuit because we want to find the best
715 possible match *including* case differences. */
716 && (!completion_ignore_case
|| matchsize
== 0)
717 /* The return value depends on whether it's the sole match. */
725 /* This closes the directory. */
726 bestmatch
= unbind_to (count
, bestmatch
);
728 if (all_flag
|| NILP (bestmatch
))
730 /* Return t if the supplied string is an exact match (counting case);
731 it does not require any change to be made. */
732 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
734 bestmatch
= Fsubstring (bestmatch
, make_number (0),
735 make_number (bestmatchsize
));
739 /* Compare exactly LEN chars of strings at S1 and S2,
740 ignoring case if appropriate.
741 Return -1 if strings match,
742 else number of chars that match at the beginning. */
745 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
747 register ptrdiff_t l
= len
;
749 if (completion_ignore_case
)
752 && (downcase ((unsigned char) *s1
++)
753 == downcase ((unsigned char) *s2
++)))
758 while (l
&& *s1
++ == *s2
++)
768 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
773 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
774 but aren't required here. Avoid computing the following fields:
775 st_inode, st_size and st_nlink for directories, and the execute bits
776 in st_mode for non-directory files with non-standard extensions. */
778 unsigned short save_djstat_flags
= _djstat_flags
;
780 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
783 /* We want to return success if a link points to a nonexistent file,
784 but we want to return the status for what the link points to,
785 in case it is a directory. */
786 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
787 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
788 fstatat (fd
, dp
->d_name
, st_addr
, 0);
790 _djstat_flags
= save_djstat_flags
;
796 stat_uname (struct stat
*st
)
801 struct passwd
*pw
= getpwuid (st
->st_uid
);
811 stat_gname (struct stat
*st
)
816 struct group
*gr
= getgrgid (st
->st_gid
);
825 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
826 doc
: /* Return a list of attributes of file FILENAME.
827 Value is nil if specified file cannot be opened.
829 ID-FORMAT specifies the preferred format of attributes uid and gid (see
830 below) - valid values are 'string and 'integer. The latter is the
831 default, but we plan to change that, so you should specify a non-nil value
832 for ID-FORMAT if you use the returned uid or gid.
834 Elements of the attribute list are:
835 0. t for directory, string (name linked to) for symbolic link, or nil.
836 1. Number of links to file.
837 2. File uid as a string or a number. If a string value cannot be
838 looked up, a numeric value, either an integer or a float, is returned.
839 3. File gid, likewise.
840 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
841 same style as (current-time).
842 (See a note below about access time on FAT-based filesystems.)
843 5. Last modification time, likewise. This is the time of the last
844 change to the file's contents.
845 6. Last status change time, likewise. This is the time of last change
846 to the file's attributes: owner and group, access mode bits, etc.
848 This is a floating point number if the size is too large for an integer.
849 8. File modes, as a string of ten letters or dashes as in ls -l.
850 9. An unspecified value, present only for backward compatibility.
851 10. inode number. If it is larger than what an Emacs integer can hold,
852 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
853 If even HIGH is too large for an Emacs integer, this is instead of the form
854 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
855 and finally the low 16 bits.
856 11. Filesystem device number. If it is larger than what the Emacs
857 integer can hold, this is a cons cell, similar to the inode number.
859 On most filesystems, the combination of the inode and the device
860 number uniquely identifies the file.
862 On MS-Windows, performance depends on `w32-get-true-file-attributes',
865 On some FAT-based filesystems, only the date of last access is recorded,
866 so last access time will always be midnight of that day. */)
867 (Lisp_Object filename
, Lisp_Object id_format
)
872 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
874 if (!STRINGP (filename
))
877 /* If the file name has special constructs in it,
878 call the corresponding file handler. */
879 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
881 { /* Only pass the extra arg if it is used to help backward compatibility
882 with old file handlers which do not implement the new arg. --Stef */
883 if (NILP (id_format
))
884 return call2 (handler
, Qfile_attributes
, filename
);
886 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
889 encoded
= ENCODE_FILE (filename
);
890 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
894 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
899 /* An array to hold the mode string generated by filemodestring,
900 including its terminating space and null byte. */
901 char modes
[sizeof "-rwxr-xr-x "];
903 char *uname
= NULL
, *gname
= NULL
;
906 /* We usually don't request accurate owner and group info, because
907 it can be very expensive on Windows to get that, and most callers
908 of 'lstat' don't need that. But here we do want that information
910 w32_stat_get_owner_group
= 1;
913 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
916 w32_stat_get_owner_group
= 0;
919 if (lstat_result
< 0)
922 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
925 uname
= stat_uname (&s
);
926 gname
= stat_gname (&s
);
930 filemodestring (&s
, modes
);
933 (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
934 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
),
935 make_number (s
.st_nlink
),
937 ? DECODE_SYSTEM (build_unibyte_string (uname
))
938 : make_fixnum_or_float (s
.st_uid
)),
940 ? DECODE_SYSTEM (build_unibyte_string (gname
))
941 : make_fixnum_or_float (s
.st_gid
)),
942 make_lisp_time (get_stat_atime (&s
)),
943 make_lisp_time (get_stat_mtime (&s
)),
944 make_lisp_time (get_stat_ctime (&s
)),
946 /* If the file size is a 4-byte type, assume that
947 files of sizes in the 2-4 GiB range wrap around to
948 negative values, as this is a common bug on older
950 make_fixnum_or_float (sizeof (s
.st_size
) == 4
951 ? s
.st_size
& 0xffffffffu
954 make_string (modes
, 10),
956 INTEGER_TO_CONS (s
.st_ino
),
957 INTEGER_TO_CONS (s
.st_dev
));
960 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
961 doc
: /* Return t if first arg file attributes list is less than second.
962 Comparison is in lexicographic order and case is significant. */)
963 (Lisp_Object f1
, Lisp_Object f2
)
965 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
969 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
970 doc
: /* Return a list of user names currently registered in the system.
971 If we don't know how to determine that on this platform, just
972 return a list with one element, taken from `user-real-login-name'. */)
975 Lisp_Object users
= Qnil
;
976 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
979 while ((pw
= getpwent ()))
980 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
984 if (EQ (users
, Qnil
))
985 /* At least current user is always known. */
986 users
= list1 (Vuser_real_login_name
);
990 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
991 doc
: /* Return a list of user group names currently registered in the system.
992 The value may be nil if not supported on this platform. */)
995 Lisp_Object groups
= Qnil
;
996 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
999 while ((gr
= getgrent ()))
1000 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1008 syms_of_dired (void)
1010 DEFSYM (Qdirectory_files
, "directory-files");
1011 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1012 DEFSYM (Qfile_name_completion
, "file-name-completion");
1013 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1014 DEFSYM (Qfile_attributes
, "file-attributes");
1015 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1016 DEFSYM (Qdefault_directory
, "default-directory");
1018 defsubr (&Sdirectory_files
);
1019 defsubr (&Sdirectory_files_and_attributes
);
1020 defsubr (&Sfile_name_completion
);
1021 defsubr (&Sfile_name_all_completions
);
1022 defsubr (&Sfile_attributes
);
1023 defsubr (&Sfile_attributes_lessp
);
1024 defsubr (&Ssystem_users
);
1025 defsubr (&Ssystem_groups
);
1027 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1028 doc
: /* Completion ignores file names ending in any string in this list.
1029 It does not ignore them if all possible completions end in one of
1030 these strings or when displaying a list of completions.
1031 It ignores directory names if they match any string in this list which
1032 ends in a slash. */);
1033 Vcompletion_ignored_extensions
= Qnil
;