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 if (STRING_MULTIBYTE (dirfilename
))
180 dirfilename
= ENCODE_FILE (dirfilename
);
181 encoded_directory
= (STRING_MULTIBYTE (directory
)
182 ? ENCODE_FILE (directory
) : directory
);
184 /* Now *bufp is the compiled form of MATCH; don't call anything
185 which might compile a new regexp until we're done with the loop! */
187 d
= open_directory (SSDATA (dirfilename
), &fd
);
189 report_file_error ("Opening directory", directory
);
191 /* Unfortunately, we can now invoke expand-file-name and
192 file-attributes on filenames, both of which can throw, so we must
193 do a proper unwind-protect. */
194 record_unwind_protect_ptr (directory_files_internal_unwind
, d
);
199 extern int is_slow_fs (const char *);
201 /* Do this only once to avoid doing it (in w32.c:stat) for each
202 file in the directory, when we call Ffile_attributes below. */
203 record_unwind_protect (directory_files_internal_w32_unwind
,
204 Vw32_get_true_file_attributes
);
205 w32_save
= Vw32_get_true_file_attributes
;
206 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
208 /* w32.c:stat will notice these bindings and avoid calling
209 GetDriveType for each file. */
210 if (is_slow_fs (SDATA (dirfilename
)))
211 Vw32_get_true_file_attributes
= Qnil
;
213 Vw32_get_true_file_attributes
= Qt
;
218 directory_nbytes
= SBYTES (directory
);
219 re_match_object
= Qt
;
221 /* Decide whether we need to add a directory separator. */
222 if (directory_nbytes
== 0
223 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
226 /* Loop reading blocks until EOF or error. */
231 Lisp_Object name
, finalname
;
232 struct gcpro gcpro1
, gcpro2
;
238 if (errno
== EAGAIN
|| errno
== EINTR
)
246 len
= dirent_namelen (dp
);
247 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
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. */
261 || 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
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (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 blocks */
496 /* (att3b compiler bug requires do a null comparison this way) */
507 if (errno
== EAGAIN
|| errno
== EINTR
)
515 len
= dirent_namelen (dp
);
518 if (len
< SCHARS (encoded_file
)
519 || (scmp (dp
->d_name
, SSDATA (encoded_file
),
520 SCHARS (encoded_file
))
524 if (file_name_completion_stat (fd
, dp
, &st
) < 0)
527 directoryp
= S_ISDIR (st
.st_mode
) != 0;
529 /* If all_flag is set, always include all.
530 It would not actually be helpful to the user to ignore any possible
531 completions when making a list of them. */
536 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
537 /* If this entry matches the current bestmatch, the only
538 thing it can do is increase matchcount, so don't bother
539 investigating it any further. */
540 if (!completion_ignore_case
541 /* The return result depends on whether it's the sole match. */
543 && !includeall
/* This match may allow includeall to 0. */
544 && len
>= bestmatchsize
545 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
551 #ifndef TRIVIAL_DIRECTORY_ENTRY
552 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
554 /* "." and ".." are never interesting as completions, and are
555 actually in the way in a directory with only one file. */
556 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
558 else if (len
> SCHARS (encoded_file
))
559 /* Ignore directories if they match an element of
560 completion-ignored-extensions which ends in a slash. */
561 for (tem
= Vcompletion_ignored_extensions
;
562 CONSP (tem
); tem
= XCDR (tem
))
570 /* Need to encode ELT, since scmp compares unibyte
572 elt
= ENCODE_FILE (elt
);
573 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
577 if (p1
[elt_len
] != '/')
579 skip
= len
- elt_len
;
583 if (scmp (dp
->d_name
+ skip
, p1
, elt_len
) >= 0)
590 /* Compare extensions-to-be-ignored against end of this file name */
591 /* if name is not an exact match against specified string */
592 if (len
> SCHARS (encoded_file
))
593 /* and exit this for loop if a match is found */
594 for (tem
= Vcompletion_ignored_extensions
;
595 CONSP (tem
); tem
= XCDR (tem
))
598 if (!STRINGP (elt
)) continue;
599 /* Need to encode ELT, since scmp compares unibyte
601 elt
= ENCODE_FILE (elt
);
602 skip
= len
- SCHARS (elt
);
603 if (skip
< 0) continue;
605 if (scmp (dp
->d_name
+ skip
, SSDATA (elt
), SCHARS (elt
))
612 /* If an ignored-extensions match was found,
613 don't process this name as a completion. */
617 if (!includeall
&& canexclude
)
618 /* We're not including all files and this file can be excluded. */
621 if (includeall
&& !canexclude
)
622 { /* If we have one non-excludable file, we want to exclude the
625 /* Throw away any previous excludable match found. */
631 /* FIXME: If we move this `decode' earlier we can eliminate
632 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
633 name
= make_unibyte_string (dp
->d_name
, len
);
634 name
= DECODE_FILE (name
);
637 Lisp_Object regexps
, table
= (completion_ignore_case
638 ? Vascii_canon_table
: Qnil
);
640 /* Ignore this element if it fails to match all the regexps. */
641 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
642 regexps
= XCDR (regexps
))
643 if (fast_string_match_internal (XCAR (regexps
), name
, table
) < 0)
650 /* This is a possible completion */
652 /* This completion is a directory; make it end with '/'. */
653 name
= Ffile_name_as_directory (name
);
655 /* Test the predicate, if any. */
656 if (!NILP (predicate
))
662 val
= call1 (predicate
, name
);
669 /* Suitably record this match. */
671 matchcount
+= matchcount
<= 1;
674 bestmatch
= Fcons (name
, bestmatch
);
675 else if (NILP (bestmatch
))
678 bestmatchsize
= SCHARS (name
);
682 Lisp_Object zero
= make_number (0);
683 /* FIXME: This is a copy of the code in Ftry_completion. */
684 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
686 = Fcompare_strings (bestmatch
, zero
,
687 make_number (compare
),
689 make_number (compare
),
690 completion_ignore_case
? Qt
: Qnil
);
691 ptrdiff_t matchsize
= EQ (cmp
, Qt
) ? compare
: eabs (XINT (cmp
)) - 1;
693 if (completion_ignore_case
)
695 /* If this is an exact match except for case,
696 use it as the best match rather than one that is not
697 an exact match. This way, we get the case pattern
698 of the actual match. */
699 /* This tests that the current file is an exact match
700 but BESTMATCH is not (it is too long). */
701 if ((matchsize
== SCHARS (name
)
702 && matchsize
+ directoryp
< SCHARS (bestmatch
))
704 /* If there is no exact match ignoring case,
705 prefer a match that does not change the case
707 /* If there is more than one exact match aside from
708 case, and one of them is exact including case,
710 /* This == checks that, of current file and BESTMATCH,
711 either both or neither are exact. */
712 (((matchsize
== SCHARS (name
))
714 (matchsize
+ directoryp
== SCHARS (bestmatch
)))
715 && (cmp
= Fcompare_strings (name
, zero
,
716 make_number (SCHARS (file
)),
721 && (cmp
= Fcompare_strings (bestmatch
, zero
,
722 make_number (SCHARS (file
)),
729 bestmatchsize
= matchsize
;
731 /* If the best completion so far is reduced to the string
732 we're trying to complete, then we already know there's no
733 other completion, so there's no point looking any further. */
734 if (matchsize
<= SCHARS (file
)
735 && !includeall
/* A future match may allow includeall to 0. */
736 /* If completion-ignore-case is non-nil, don't
737 short-circuit because we want to find the best
738 possible match *including* case differences. */
739 && (!completion_ignore_case
|| matchsize
== 0)
740 /* The return value depends on whether it's the sole match. */
748 /* This closes the directory. */
749 bestmatch
= unbind_to (count
, bestmatch
);
751 if (all_flag
|| NILP (bestmatch
))
753 /* Return t if the supplied string is an exact match (counting case);
754 it does not require any change to be made. */
755 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
757 bestmatch
= Fsubstring (bestmatch
, make_number (0),
758 make_number (bestmatchsize
));
762 /* Compare exactly LEN chars of strings at S1 and S2,
763 ignoring case if appropriate.
764 Return -1 if strings match,
765 else number of chars that match at the beginning. */
768 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
770 register ptrdiff_t l
= len
;
772 if (completion_ignore_case
)
775 && (downcase ((unsigned char) *s1
++)
776 == downcase ((unsigned char) *s2
++)))
781 while (l
&& *s1
++ == *s2
++)
791 file_name_completion_stat (int fd
, struct dirent
*dp
, struct stat
*st_addr
)
796 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
797 but aren't required here. Avoid computing the following fields:
798 st_inode, st_size and st_nlink for directories, and the execute bits
799 in st_mode for non-directory files with non-standard extensions. */
801 unsigned short save_djstat_flags
= _djstat_flags
;
803 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
806 /* We want to return success if a link points to a nonexistent file,
807 but we want to return the status for what the link points to,
808 in case it is a directory. */
809 value
= fstatat (fd
, dp
->d_name
, st_addr
, AT_SYMLINK_NOFOLLOW
);
810 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
811 fstatat (fd
, dp
->d_name
, st_addr
, 0);
813 _djstat_flags
= save_djstat_flags
;
819 stat_uname (struct stat
*st
)
824 struct passwd
*pw
= getpwuid (st
->st_uid
);
834 stat_gname (struct stat
*st
)
839 struct group
*gr
= getgrgid (st
->st_gid
);
848 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
849 doc
: /* Return a list of attributes of file FILENAME.
850 Value is nil if specified file cannot be opened.
852 ID-FORMAT specifies the preferred format of attributes uid and gid (see
853 below) - valid values are 'string and 'integer. The latter is the
854 default, but we plan to change that, so you should specify a non-nil value
855 for ID-FORMAT if you use the returned uid or gid.
857 Elements of the attribute list are:
858 0. t for directory, string (name linked to) for symbolic link, or nil.
859 1. Number of links to file.
860 2. File uid as a string or a number. If a string value cannot be
861 looked up, a numeric value, either an integer or a float, is returned.
862 3. File gid, likewise.
863 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
864 same style as (current-time).
865 (See a note below about access time on FAT-based filesystems.)
866 5. Last modification time, likewise. This is the time of the last
867 change to the file's contents.
868 6. Last status change time, likewise. This is the time of last change
869 to the file's attributes: owner and group, access mode bits, etc.
871 This is a floating point number if the size is too large for an integer.
872 8. File modes, as a string of ten letters or dashes as in ls -l.
873 9. An unspecified value, present only for backward compatibility.
874 10. inode number. If it is larger than what an Emacs integer can hold,
875 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
876 If even HIGH is too large for an Emacs integer, this is instead of the form
877 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
878 and finally the low 16 bits.
879 11. Filesystem device number. If it is larger than what the Emacs
880 integer can hold, this is a cons cell, similar to the inode number.
882 On most filesystems, the combination of the inode and the device
883 number uniquely identifies the file.
885 On MS-Windows, performance depends on `w32-get-true-file-attributes',
888 On some FAT-based filesystems, only the date of last access is recorded,
889 so last access time will always be midnight of that day. */)
890 (Lisp_Object filename
, Lisp_Object id_format
)
895 filename
= internal_condition_case_2 (Fexpand_file_name
, filename
, Qnil
,
897 if (!STRINGP (filename
))
900 /* If the file name has special constructs in it,
901 call the corresponding file handler. */
902 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
904 { /* Only pass the extra arg if it is used to help backward compatibility
905 with old file handlers which do not implement the new arg. --Stef */
906 if (NILP (id_format
))
907 return call2 (handler
, Qfile_attributes
, filename
);
909 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
912 encoded
= ENCODE_FILE (filename
);
913 return file_attributes (AT_FDCWD
, SSDATA (encoded
), id_format
);
917 file_attributes (int fd
, char const *name
, Lisp_Object id_format
)
919 Lisp_Object values
[12];
923 /* An array to hold the mode string generated by filemodestring,
924 including its terminating space and null byte. */
925 char modes
[sizeof "-rwxr-xr-x "];
927 char *uname
= NULL
, *gname
= NULL
;
930 /* We usually don't request accurate owner and group info, because
931 it can be very expensive on Windows to get that, and most callers
932 of 'lstat' don't need that. But here we do want that information
934 w32_stat_get_owner_group
= 1;
937 lstat_result
= fstatat (fd
, name
, &s
, AT_SYMLINK_NOFOLLOW
);
940 w32_stat_get_owner_group
= 0;
943 if (lstat_result
< 0)
946 values
[0] = (S_ISLNK (s
.st_mode
) ? emacs_readlinkat (fd
, name
)
947 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
);
948 values
[1] = make_number (s
.st_nlink
);
950 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
953 uname
= stat_uname (&s
);
954 gname
= stat_gname (&s
);
958 values
[2] = DECODE_SYSTEM (build_unibyte_string (uname
));
960 values
[2] = make_fixnum_or_float (s
.st_uid
);
962 values
[3] = DECODE_SYSTEM (build_unibyte_string (gname
));
964 values
[3] = make_fixnum_or_float (s
.st_gid
);
966 values
[4] = make_lisp_time (get_stat_atime (&s
));
967 values
[5] = make_lisp_time (get_stat_mtime (&s
));
968 values
[6] = make_lisp_time (get_stat_ctime (&s
));
970 /* If the file size is a 4-byte type, assume that files of sizes in
971 the 2-4 GiB range wrap around to negative values, as this is a
972 common bug on older 32-bit platforms. */
973 if (sizeof (s
.st_size
) == 4)
974 values
[7] = make_fixnum_or_float (s
.st_size
& 0xffffffffu
);
976 values
[7] = make_fixnum_or_float (s
.st_size
);
978 filemodestring (&s
, modes
);
979 values
[8] = make_string (modes
, 10);
981 values
[10] = INTEGER_TO_CONS (s
.st_ino
);
982 values
[11] = INTEGER_TO_CONS (s
.st_dev
);
984 return Flist (ARRAYELTS (values
), values
);
987 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
988 doc
: /* Return t if first arg file attributes list is less than second.
989 Comparison is in lexicographic order and case is significant. */)
990 (Lisp_Object f1
, Lisp_Object f2
)
992 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
996 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
997 doc
: /* Return a list of user names currently registered in the system.
998 If we don't know how to determine that on this platform, just
999 return a list with one element, taken from `user-real-login-name'. */)
1002 Lisp_Object users
= Qnil
;
1003 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
1006 while ((pw
= getpwent ()))
1007 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
1011 if (EQ (users
, Qnil
))
1012 /* At least current user is always known. */
1013 users
= list1 (Vuser_real_login_name
);
1017 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
1018 doc
: /* Return a list of user group names currently registered in the system.
1019 The value may be nil if not supported on this platform. */)
1022 Lisp_Object groups
= Qnil
;
1023 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
1026 while ((gr
= getgrent ()))
1027 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1035 syms_of_dired (void)
1037 DEFSYM (Qdirectory_files
, "directory-files");
1038 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1039 DEFSYM (Qfile_name_completion
, "file-name-completion");
1040 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1041 DEFSYM (Qfile_attributes
, "file-attributes");
1042 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1043 DEFSYM (Qdefault_directory
, "default-directory");
1045 defsubr (&Sdirectory_files
);
1046 defsubr (&Sdirectory_files_and_attributes
);
1047 defsubr (&Sfile_name_completion
);
1048 defsubr (&Sfile_name_all_completions
);
1049 defsubr (&Sfile_attributes
);
1050 defsubr (&Sfile_attributes_lessp
);
1051 defsubr (&Ssystem_users
);
1052 defsubr (&Ssystem_groups
);
1054 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1055 doc
: /* Completion ignores file names ending in any string in this list.
1056 It does not ignore them if all possible completions end in one of
1057 these strings or when displaying a list of completions.
1058 It ignores directory names if they match any string in this list which
1059 ends in a slash. */);
1060 Vcompletion_ignored_extensions
= Qnil
;