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 /* Return the next directory entry from DIR; DIR's name is DIRNAME.
124 If there are no more directory entries, return a null pointer.
125 Signal any unrecoverable errors. */
127 static struct dirent
*
128 read_dirent (DIR *dir
, Lisp_Object dirname
)
133 struct dirent
*dp
= readdir (dir
);
134 if (dp
|| errno
== 0)
136 if (! (errno
== EAGAIN
|| errno
== EINTR
))
137 report_file_error ("Reading directory", dirname
);
142 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
143 If not ATTRS, return a list of directory filenames;
144 if ATTRS, return a list of directory filenames and their attributes.
145 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
148 directory_files_internal (Lisp_Object directory
, Lisp_Object full
,
149 Lisp_Object match
, Lisp_Object nosort
, bool attrs
,
150 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! */
203 d
= open_directory (SSDATA (dirfilename
), &fd
);
205 report_file_error ("Opening directory", directory
);
207 /* Unfortunately, we can now invoke expand-file-name and
208 file-attributes on filenames, both of which can throw, so we must
209 do a proper unwind-protect. */
210 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
215 extern int is_slow_fs (const char *);
217 /* Do this only once to avoid doing it (in w32.c:stat) for each
218 file in the directory, when we call Ffile_attributes below. */
219 record_unwind_protect (directory_files_internal_w32_unwind
,
220 Vw32_get_true_file_attributes
);
221 w32_save
= Vw32_get_true_file_attributes
;
222 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
224 /* w32.c:stat will notice these bindings and avoid calling
225 GetDriveType for each file. */
226 if (is_slow_fs (SDATA (dirfilename
)))
227 Vw32_get_true_file_attributes
= Qnil
;
229 Vw32_get_true_file_attributes
= Qt
;
234 directory_nbytes
= SBYTES (directory
);
235 re_match_object
= Qt
;
237 /* Decide whether we need to add a directory separator. */
238 if (directory_nbytes
== 0
239 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
242 /* Loop reading directory entries. */
243 for (struct dirent
*dp
; (dp
= read_dirent (d
, directory
)); )
245 ptrdiff_t len
= dirent_namelen (dp
);
246 Lisp_Object name
= make_unibyte_string (dp
->d_name
, len
);
247 Lisp_Object finalname
= name
;
248 struct gcpro gcpro1
, gcpro2
;
249 GCPRO2 (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
);
317 Vw32_get_true_file_attributes
= w32_save
;
320 /* Discard the unwind protect. */
321 specpdl_ptr
= specpdl
+ count
;
324 list
= Fsort (Fnreverse (list
),
325 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
327 (void) directory_volatile
;
328 RETURN_UNGCPRO (list
);
332 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
333 doc
: /* Return a list of names of files in DIRECTORY.
334 There are three optional arguments:
335 If FULL is non-nil, return absolute file names. Otherwise return names
336 that are relative to the specified directory.
337 If MATCH is non-nil, mention only file names that match the regexp MATCH.
338 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
339 Otherwise, the list returned is sorted with `string-lessp'.
340 NOSORT is useful if you plan to sort the result yourself. */)
341 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
344 directory
= Fexpand_file_name (directory
, Qnil
);
346 /* If the file name has special constructs in it,
347 call the corresponding file handler. */
348 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
350 return call5 (handler
, Qdirectory_files
, directory
,
351 full
, match
, nosort
);
353 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
356 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
357 Sdirectory_files_and_attributes
, 1, 5, 0,
358 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
359 There are four optional arguments:
360 If FULL is non-nil, return absolute file names. Otherwise return names
361 that are relative to the specified directory.
362 If MATCH is non-nil, mention only file names that match the regexp MATCH.
363 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
364 NOSORT is useful if you plan to sort the result yourself.
365 ID-FORMAT specifies the preferred format of attributes uid and gid, see
366 `file-attributes' for further documentation.
367 On MS-Windows, performance depends on `w32-get-true-file-attributes',
369 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
372 directory
= Fexpand_file_name (directory
, Qnil
);
374 /* If the file name has special constructs in it,
375 call the corresponding file handler. */
376 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
378 return call6 (handler
, Qdirectory_files_and_attributes
,
379 directory
, full
, match
, nosort
, id_format
);
381 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
385 static Lisp_Object
file_name_completion (Lisp_Object
, Lisp_Object
, bool,
388 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
390 doc
: /* Complete file name FILE in directory DIRECTORY.
391 Returns the longest string
392 common to all file names in DIRECTORY that start with FILE.
393 If there is only one and FILE matches it exactly, returns t.
394 Returns nil if DIRECTORY contains no name starting with FILE.
396 If PREDICATE is non-nil, call PREDICATE with each possible
397 completion (in absolute form) and ignore it if PREDICATE returns nil.
399 This function ignores some of the possible completions as
400 determined by the variable `completion-ignored-extensions', which see. */)
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. */)
425 (Lisp_Object file
, Lisp_Object directory
)
428 directory
= Fexpand_file_name (directory
, Qnil
);
430 /* If the directory name has special constructs in it,
431 call the corresponding file handler. */
432 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
434 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
436 /* If the file name has special constructs in it,
437 call the corresponding file handler. */
438 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
440 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
442 return file_name_completion (file
, directory
, 1, Qnil
);
445 static int file_name_completion_stat (int, struct dirent
*, struct stat
*);
448 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, bool all_flag
,
449 Lisp_Object predicate
)
453 ptrdiff_t bestmatchsize
= 0;
455 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
456 If ALL_FLAG is 0, BESTMATCH is either nil
457 or the best match so far, not decoded. */
458 Lisp_Object bestmatch
, tem
, elt
, name
;
459 Lisp_Object encoded_file
;
460 Lisp_Object encoded_dir
;
463 /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
464 well as "." and "..". Until shown otherwise, assume we can't exclude
467 ptrdiff_t count
= SPECPDL_INDEX ();
468 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
475 encoded_file
= encoded_dir
= Qnil
;
476 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
477 specbind (Qdefault_directory
, dirname
);
479 /* Do completion on the encoded file name
480 because the other names in the directory are (we presume)
481 encoded likewise. We decode the completed string at the end. */
482 /* Actually, this is not quite true any more: we do most of the completion
483 work with decoded file names, but we still do some filtering based
484 on the encoded file name. */
485 encoded_file
= ENCODE_FILE (file
);
487 encoded_dir
= ENCODE_FILE (Fdirectory_file_name (dirname
));
489 d
= open_directory (SSDATA (encoded_dir
), &fd
);
491 report_file_error ("Opening directory", dirname
);
493 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
495 /* Loop reading directory entries. */
496 for (struct dirent
*dp
; (dp
= read_dirent (d
, dirname
)); )
498 ptrdiff_t len
= dirent_namelen (dp
);
502 if (len
< SCHARS (encoded_file
)
503 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
504 SCHARS (encoded_file
))
508 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
511 directoryp
= S_ISDIR (st
.st_mode
) != 0;
513 /* If all_flag is set, always include all.
514 It would not actually be helpful to the user to ignore any possible
515 completions when making a list of them. */
520 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
521 /* If this entry matches the current bestmatch, the only
522 thing it can do is increase matchcount, so don't bother
523 investigating it any further. */
524 if (!completion_ignore_case
525 /* The return result depends on whether it's the sole match. */
527 && !includeall
/* This match may allow includeall to 0. */
528 && len
>= bestmatchsize
529 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
535 #ifndef TRIVIAL_DIRECTORY_ENTRY
536 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
538 /* "." and ".." are never interesting as completions, and are
539 actually in the way in a directory with only one file. */
540 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
542 else if (len
> SCHARS (encoded_file
))
543 /* Ignore directories if they match an element of
544 completion-ignored-extensions which ends in a slash. */
545 for (tem
= Vcompletion_ignored_extensions
;
546 CONSP (tem
); tem
= XCDR (tem
))
554 /* Need to encode ELT, since scmp compares unibyte
556 elt
= ENCODE_FILE (elt
);
557 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
561 if (p1
[elt_len
] != '/')
563 skip
= len
- elt_len
;
567 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
574 /* Compare extensions-to-be-ignored against end of this file name */
575 /* if name is not an exact match against specified string */
576 if (len
> SCHARS (encoded_file
))
577 /* and exit this for loop if a match is found */
578 for (tem
= Vcompletion_ignored_extensions
;
579 CONSP (tem
); tem
= XCDR (tem
))
582 if (!STRINGP (elt
)) continue;
583 /* Need to encode ELT, since scmp compares unibyte
585 elt
= ENCODE_FILE (elt
);
586 skip
= len
- SCHARS (elt
);
587 if (skip
< 0) continue;
589 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
596 /* If an ignored-extensions match was found,
597 don't process this name as a completion. */
601 if (!includeall
&& canexclude
)
602 /* We're not including all files and this file can be excluded. */
605 if (includeall
&& !canexclude
)
606 { /* If we have one non-excludable file, we want to exclude the
609 /* Throw away any previous excludable match found. */
615 /* FIXME: If we move this `decode' earlier we can eliminate
616 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
617 name
= make_unibyte_string (dp
->d_name
, len
);
618 name
= DECODE_FILE (name
);
621 Lisp_Object regexps
, table
= (completion_ignore_case
622 ? Vascii_canon_table
: Qnil
);
624 /* Ignore this element if it fails to match all the regexps. */
625 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
626 regexps
= XCDR (regexps
))
627 if (fast_string_match_internal (XCAR (regexps
), name
, table
) < 0)
634 /* This is a possible completion */
636 /* This completion is a directory; make it end with '/'. */
637 name
= Ffile_name_as_directory (name
);
639 /* Test the predicate, if any. */
640 if (!NILP (predicate
))
646 val
= call1 (predicate
, name
);
653 /* Suitably record this match. */
655 matchcount
+= matchcount
<= 1;
658 bestmatch
= Fcons (name
, bestmatch
);
659 else if (NILP (bestmatch
))
662 bestmatchsize
= SCHARS (name
);
666 Lisp_Object zero
= make_number (0);
667 /* FIXME: This is a copy of the code in Ftry_completion. */
668 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
670 = Fcompare_strings (bestmatch
, zero
,
671 make_number (compare
),
673 make_number (compare
),
674 completion_ignore_case
? Qt
: Qnil
);
675 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
677 if (completion_ignore_case
)
679 /* If this is an exact match except for case,
680 use it as the best match rather than one that is not
681 an exact match. This way, we get the case pattern
682 of the actual match. */
683 /* This tests that the current file is an exact match
684 but BESTMATCH is not (it is too long). */
685 if ((matchsize
== SCHARS (name
)
686 && matchsize
+ directoryp
< SCHARS (bestmatch
))
688 /* If there is no exact match ignoring case,
689 prefer a match that does not change the case
691 /* If there is more than one exact match aside from
692 case, and one of them is exact including case,
694 /* This == checks that, of current file and BESTMATCH,
695 either both or neither are exact. */
696 (((matchsize
== SCHARS (name
))
698 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
699 && (cmp
= Fcompare_strings (name
, zero
,
700 make_number (SCHARS (file
)),
705 && (cmp
= Fcompare_strings (bestmatch
, zero
,
706 make_number (SCHARS (file
)),
713 bestmatchsize
= matchsize
;
715 /* If the best completion so far is reduced to the string
716 we're trying to complete, then we already know there's no
717 other completion, so there's no point looking any further. */
718 if (matchsize
<= SCHARS (file
)
719 && !includeall
/* A future match may allow includeall to 0. */
720 /* If completion-ignore-case is non-nil, don't
721 short-circuit because we want to find the best
722 possible match *including* case differences. */
723 && (!completion_ignore_case
|| matchsize
== 0)
724 /* The return value depends on whether it's the sole match. */
732 /* This closes the directory. */
733 bestmatch
= unbind_to (count
, bestmatch
);
735 if (all_flag
|| NILP (bestmatch
))
737 /* Return t if the supplied string is an exact match (counting case);
738 it does not require any change to be made. */
739 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
741 bestmatch
= Fsubstring (bestmatch
, make_number (0),
742 make_number (bestmatchsize
));
746 /* Compare exactly LEN chars of strings at S1 and S2,
747 ignoring case if appropriate.
748 Return -1 if strings match,
749 else number of chars that match at the beginning. */
752 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
754 register ptrdiff_t l
= len
;
756 if (completion_ignore_case
)
759 && (downcase ((unsigned char) *s1
++)
760 == downcase ((unsigned char) *s2
++)))
765 while (l
&& *s1
++ == *s2
++)
775 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
780 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
781 but aren't required here. Avoid computing the following fields:
782 st_inode, st_size and st_nlink for directories, and the execute bits
783 in st_mode for non-directory files with non-standard extensions. */
785 unsigned short save_djstat_flags
= _djstat_flags
;
787 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
790 /* We want to return success if a link points to a nonexistent file,
791 but we want to return the status for what the link points to,
792 in case it is a directory. */
793 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
794 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
795 fstatat (fd
, dp
->d_name
, st_addr
, 0);
797 _djstat_flags
= save_djstat_flags
;
803 stat_uname (struct stat
*st
)
808 struct passwd
*pw
= getpwuid (st
->st_uid
);
818 stat_gname (struct stat
*st
)
823 struct group
*gr
= getgrgid (st
->st_gid
);
832 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
833 doc
: /* Return a list of attributes of file FILENAME.
834 Value is nil if specified file cannot be opened.
836 ID-FORMAT specifies the preferred format of attributes uid and gid (see
837 below) - valid values are 'string and 'integer. The latter is the
838 default, but we plan to change that, so you should specify a non-nil value
839 for ID-FORMAT if you use the returned uid or gid.
841 Elements of the attribute list are:
842 0. t for directory, string (name linked to) for symbolic link, or nil.
843 1. Number of links to file.
844 2. File uid as a string or a number. If a string value cannot be
845 looked up, a numeric value, either an integer or a float, is returned.
846 3. File gid, likewise.
847 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
848 same style as (current-time).
849 (See a note below about access time on FAT-based filesystems.)
850 5. Last modification time, likewise. This is the time of the last
851 change to the file's contents.
852 6. Last status change time, likewise. This is the time of last change
853 to the file's attributes: owner and group, access mode bits, etc.
855 This is a floating point number if the size is too large for an integer.
856 8. File modes, as a string of ten letters or dashes as in ls -l.
857 9. An unspecified value, present only for backward compatibility.
858 10. inode number. If it is larger than what an Emacs integer can hold,
859 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
860 If even HIGH is too large for an Emacs integer, this is instead of the form
861 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
862 and finally the low 16 bits.
863 11. Filesystem device number. If it is larger than what the Emacs
864 integer can hold, this is a cons cell, similar to the inode number.
866 On most filesystems, the combination of the inode and the device
867 number uniquely identifies the file.
869 On MS-Windows, performance depends on `w32-get-true-file-attributes',
872 On some FAT-based filesystems, only the date of last access is recorded,
873 so last access time will always be midnight of that day. */)
874 (Lisp_Object filename
, Lisp_Object id_format
)
879 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
881 if (!STRINGP (filename
))
884 /* If the file name has special constructs in it,
885 call the corresponding file handler. */
886 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
888 { /* Only pass the extra arg if it is used to help backward compatibility
889 with old file handlers which do not implement the new arg. --Stef */
890 if (NILP (id_format
))
891 return call2 (handler
, Qfile_attributes
, filename
);
893 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
896 encoded
= ENCODE_FILE (filename
);
897 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
901 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
906 /* An array to hold the mode string generated by filemodestring,
907 including its terminating space and null byte. */
908 char modes
[sizeof "-rwxr-xr-x "];
910 char *uname
= NULL
, *gname
= NULL
;
913 /* We usually don't request accurate owner and group info, because
914 it can be very expensive on Windows to get that, and most callers
915 of 'lstat' don't need that. But here we do want that information
917 w32_stat_get_owner_group
= 1;
920 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
923 w32_stat_get_owner_group
= 0;
926 if (lstat_result
< 0)
929 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
932 uname
= stat_uname (&s
);
933 gname
= stat_gname (&s
);
937 filemodestring (&s
, modes
);
940 (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
941 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
),
942 make_number (s
.st_nlink
),
944 ? DECODE_SYSTEM (build_unibyte_string (uname
))
945 : make_fixnum_or_float (s
.st_uid
)),
947 ? DECODE_SYSTEM (build_unibyte_string (gname
))
948 : make_fixnum_or_float (s
.st_gid
)),
949 make_lisp_time (get_stat_atime (&s
)),
950 make_lisp_time (get_stat_mtime (&s
)),
951 make_lisp_time (get_stat_ctime (&s
)),
953 /* If the file size is a 4-byte type, assume that
954 files of sizes in the 2-4 GiB range wrap around to
955 negative values, as this is a common bug on older
957 make_fixnum_or_float (sizeof (s
.st_size
) == 4
958 ? s
.st_size
& 0xffffffffu
961 make_string (modes
, 10),
963 INTEGER_TO_CONS (s
.st_ino
),
964 INTEGER_TO_CONS (s
.st_dev
));
967 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
968 doc
: /* Return t if first arg file attributes list is less than second.
969 Comparison is in lexicographic order and case is significant. */)
970 (Lisp_Object f1
, Lisp_Object f2
)
972 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
976 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
977 doc
: /* Return a list of user names currently registered in the system.
978 If we don't know how to determine that on this platform, just
979 return a list with one element, taken from `user-real-login-name'. */)
982 Lisp_Object users
= Qnil
;
983 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
986 while ((pw
= getpwent ()))
987 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
991 if (EQ (users
, Qnil
))
992 /* At least current user is always known. */
993 users
= list1 (Vuser_real_login_name
);
997 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
998 doc
: /* Return a list of user group names currently registered in the system.
999 The value may be nil if not supported on this platform. */)
1002 Lisp_Object groups
= Qnil
;
1003 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
1006 while ((gr
= getgrent ()))
1007 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1015 syms_of_dired (void)
1017 DEFSYM (Qdirectory_files
, "directory-files");
1018 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1019 DEFSYM (Qfile_name_completion
, "file-name-completion");
1020 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1021 DEFSYM (Qfile_attributes
, "file-attributes");
1022 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1023 DEFSYM (Qdefault_directory
, "default-directory");
1025 defsubr (&Sdirectory_files
);
1026 defsubr (&Sdirectory_files_and_attributes
);
1027 defsubr (&Sfile_name_completion
);
1028 defsubr (&Sfile_name_all_completions
);
1029 defsubr (&Sfile_attributes
);
1030 defsubr (&Sfile_attributes_lessp
);
1031 defsubr (&Ssystem_users
);
1032 defsubr (&Ssystem_groups
);
1034 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1035 doc
: /* Completion ignores file names ending in any string in this list.
1036 It does not ignore them if all possible completions end in one of
1037 these strings or when displaying a list of completions.
1038 It ignores directory names if they match any string in this list which
1039 ends in a slash. */);
1040 Vcompletion_ignored_extensions
= Qnil
;