1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985-1986, 1993-1994, 1999-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/types.h>
35 /* The d_nameln member of a struct dirent includes the '\0' character
36 on some systems, but not on others. What's worse, you can't tell
37 at compile-time which one it will be, since it really depends on
38 the sort of system providing the filesystem you're reading from,
39 not the system you are running on. Paul Eggert
40 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
41 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
42 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
44 Since applying strlen to the name always works, we'll just do that. */
45 #define NAMLEN(p) strlen (p->d_name)
50 #define DIRENTRY struct dirent
52 #else /* not HAVE_DIRENT_H */
57 #define DIRENTRY struct direct
59 extern DIR *opendir (char *);
60 extern struct direct
*readdir (DIR *);
62 #endif /* HAVE_DIRENT_H */
67 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
69 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
76 #include "character.h"
80 #include "blockinput.h"
82 Lisp_Object Qdirectory_files
;
83 Lisp_Object Qdirectory_files_and_attributes
;
84 Lisp_Object Qfile_name_completion
;
85 Lisp_Object Qfile_name_all_completions
;
86 Lisp_Object Qfile_attributes
;
87 Lisp_Object Qfile_attributes_lessp
;
89 static int scmp (const char *, const char *, int);
90 INFUN (Ffile_attributes
, 2);
94 directory_files_internal_w32_unwind (Lisp_Object arg
)
96 Vw32_get_true_file_attributes
= arg
;
102 directory_files_internal_unwind (Lisp_Object dh
)
104 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
111 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
112 When ATTRS is zero, return a list of directory filenames; when
113 non-zero, return a list of directory filenames and their attributes.
114 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
117 directory_files_internal (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, int attrs
, Lisp_Object id_format
)
120 int directory_nbytes
;
121 Lisp_Object list
, dirfilename
, encoded_directory
;
122 struct re_pattern_buffer
*bufp
= NULL
;
124 int count
= SPECPDL_INDEX ();
125 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
128 Lisp_Object w32_save
= Qnil
;
131 /* Because of file name handlers, these functions might call
132 Ffuncall, and cause a GC. */
133 list
= encoded_directory
= dirfilename
= Qnil
;
134 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
135 dirfilename
= Fdirectory_file_name (directory
);
139 CHECK_STRING (match
);
141 /* MATCH might be a flawed regular expression. Rather than
142 catching and signaling our own errors, we just call
143 compile_pattern to do the work for us. */
144 /* Pass 1 for the MULTIBYTE arg
145 because we do make multibyte strings if the contents warrant. */
147 /* Windows users want case-insensitive wildcards. */
148 bufp
= compile_pattern (match
, 0,
149 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
150 # else /* !WINDOWSNT */
151 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
152 # endif /* !WINDOWSNT */
155 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
156 run_pre_post_conversion_on_str which calls Lisp directly and
158 if (STRING_MULTIBYTE (dirfilename
))
159 dirfilename
= ENCODE_FILE (dirfilename
);
160 encoded_directory
= (STRING_MULTIBYTE (directory
)
161 ? ENCODE_FILE (directory
) : directory
);
163 /* Now *bufp is the compiled form of MATCH; don't call anything
164 which might compile a new regexp until we're done with the loop! */
167 d
= opendir (SSDATA (dirfilename
));
170 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
172 /* Unfortunately, we can now invoke expand-file-name and
173 file-attributes on filenames, both of which can throw, so we must
174 do a proper unwind-protect. */
175 record_unwind_protect (directory_files_internal_unwind
,
176 make_save_value (d
, 0));
181 extern int is_slow_fs (const char *);
183 /* Do this only once to avoid doing it (in w32.c:stat) for each
184 file in the directory, when we call Ffile_attributes below. */
185 record_unwind_protect (directory_files_internal_w32_unwind
,
186 Vw32_get_true_file_attributes
);
187 w32_save
= Vw32_get_true_file_attributes
;
188 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
190 /* w32.c:stat will notice these bindings and avoid calling
191 GetDriveType for each file. */
192 if (is_slow_fs (SDATA (dirfilename
)))
193 Vw32_get_true_file_attributes
= Qnil
;
195 Vw32_get_true_file_attributes
= Qt
;
200 directory_nbytes
= SBYTES (directory
);
201 re_match_object
= Qt
;
203 /* Decide whether we need to add a directory separator. */
204 if (directory_nbytes
== 0
205 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
208 /* Loop reading blocks until EOF or error. */
227 if (DIRENTRY_NONEMPTY (dp
))
231 Lisp_Object name
, finalname
;
232 struct gcpro inner_gcpro1
, inner_gcpro2
;
235 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
236 GCPRO2_VAR (finalname
, name
, inner_gcpro
);
238 /* Note: DECODE_FILE can GC; it should protect its argument,
240 name
= DECODE_FILE (name
);
243 /* Now that we have unwind_protect in place, we might as well
244 allow matching to be interrupted. */
249 || (0 <= re_search (bufp
, SSDATA (name
), len
, 0, len
, 0)))
258 Lisp_Object fullname
;
259 int nbytes
= len
+ directory_nbytes
+ needsep
;
262 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
263 memcpy (SDATA (fullname
), SDATA (directory
),
267 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
269 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
272 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
274 /* Some bug somewhere. */
278 STRING_SET_CHARS (fullname
, nchars
);
279 if (nchars
== nbytes
)
280 STRING_SET_UNIBYTE (fullname
);
282 finalname
= fullname
;
289 /* Construct an expanded filename for the directory entry.
290 Use the decoded names for input to Ffile_attributes. */
291 Lisp_Object decoded_fullname
, fileattrs
;
292 struct gcpro innermost_gcpro1
, innermost_gcpro2
;
294 decoded_fullname
= fileattrs
= Qnil
;
295 GCPRO2_VAR (decoded_fullname
, fileattrs
, innermost_gcpro
);
297 /* Both Fexpand_file_name and Ffile_attributes can GC. */
298 decoded_fullname
= Fexpand_file_name (name
, directory
);
299 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
301 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
302 UNGCPRO_VAR (innermost_gcpro
);
305 list
= Fcons (finalname
, list
);
308 UNGCPRO_VAR (inner_gcpro
);
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 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 Lisp_Object
file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
);
386 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
388 doc
: /* Complete file name FILE in directory DIRECTORY.
389 Returns the longest string
390 common to all file names in DIRECTORY that start with FILE.
391 If there is only one and FILE matches it exactly, returns t.
392 Returns nil if DIRECTORY contains no name starting with FILE.
394 If PREDICATE is non-nil, call PREDICATE with each possible
395 completion (in absolute form) and ignore it if PREDICATE returns nil.
397 This function ignores some of the possible completions as
398 determined by the variable `completion-ignored-extensions', which see. */)
399 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
403 /* If the directory name has special constructs in it,
404 call the corresponding file handler. */
405 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
407 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
409 /* If the file name has special constructs in it,
410 call the corresponding file handler. */
411 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
413 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
415 return file_name_completion (file
, directory
, 0, 0, predicate
);
418 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
419 Sfile_name_all_completions
, 2, 2, 0,
420 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
421 These are all file names in directory DIRECTORY which begin with FILE. */)
422 (Lisp_Object file
, Lisp_Object directory
)
426 /* If the directory name has special constructs in it,
427 call the corresponding file handler. */
428 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
430 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
432 /* If the file name has special constructs in it,
433 call the corresponding file handler. */
434 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
436 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
438 return file_name_completion (file
, directory
, 1, 0, Qnil
);
441 static int file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
);
442 Lisp_Object Qdefault_directory
;
445 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
)
448 int bestmatchsize
= 0;
450 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
451 If ALL_FLAG is 0, BESTMATCH is either nil
452 or the best match so far, not decoded. */
453 Lisp_Object bestmatch
, tem
, elt
, name
;
454 Lisp_Object encoded_file
;
455 Lisp_Object encoded_dir
;
458 /* If includeall is zero, exclude files in completion-ignored-extensions as
459 well as "." and "..". Until shown otherwise, assume we can't exclude
462 int count
= SPECPDL_INDEX ();
463 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
469 #ifdef FILE_SYSTEM_CASE
470 file
= FILE_SYSTEM_CASE (file
);
473 encoded_file
= encoded_dir
= Qnil
;
474 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
475 dirname
= Fexpand_file_name (dirname
, Qnil
);
476 specbind (Qdefault_directory
, dirname
);
478 /* Do completion on the encoded file name
479 because the other names in the directory are (we presume)
480 encoded likewise. We decode the completed string at the end. */
481 /* Actually, this is not quite true any more: we do most of the completion
482 work with decoded file names, but we still do some filtering based
483 on the encoded file name. */
484 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
486 encoded_dir
= ENCODE_FILE (dirname
);
489 d
= opendir (SSDATA (Fdirectory_file_name (encoded_dir
)));
492 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
494 record_unwind_protect (directory_files_internal_unwind
,
495 make_save_value (d
, 0));
497 /* Loop reading blocks */
498 /* (att3b compiler bug requires do a null comparison this way) */
522 if (! DIRENTRY_NONEMPTY (dp
)
523 || len
< SCHARS (encoded_file
)
524 || 0 <= scmp (dp
->d_name
, SSDATA (encoded_file
),
525 SCHARS (encoded_file
)))
528 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
531 directoryp
= S_ISDIR (st
.st_mode
);
533 /* If all_flag is set, always include all.
534 It would not actually be helpful to the user to ignore any possible
535 completions when making a list of them. */
540 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
541 /* If this entry matches the current bestmatch, the only
542 thing it can do is increase matchcount, so don't bother
543 investigating it any further. */
544 if (!completion_ignore_case
545 /* The return result depends on whether it's the sole match. */
547 && !includeall
/* This match may allow includeall to 0. */
548 && len
>= bestmatchsize
549 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
555 #ifndef TRIVIAL_DIRECTORY_ENTRY
556 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
558 /* "." and ".." are never interesting as completions, and are
559 actually in the way in a directory with only one file. */
560 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
562 else if (len
> SCHARS (encoded_file
))
563 /* Ignore directories if they match an element of
564 completion-ignored-extensions which ends in a slash. */
565 for (tem
= Vcompletion_ignored_extensions
;
566 CONSP (tem
); tem
= XCDR (tem
))
574 /* Need to encode ELT, since scmp compares unibyte
576 elt
= ENCODE_FILE (elt
);
577 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
581 if (p1
[elt_len
] != '/')
583 skip
= len
- elt_len
;
587 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
594 /* Compare extensions-to-be-ignored against end of this file name */
595 /* if name is not an exact match against specified string */
596 if (len
> SCHARS (encoded_file
))
597 /* and exit this for loop if a match is found */
598 for (tem
= Vcompletion_ignored_extensions
;
599 CONSP (tem
); tem
= XCDR (tem
))
602 if (!STRINGP (elt
)) continue;
603 /* Need to encode ELT, since scmp compares unibyte
605 elt
= ENCODE_FILE (elt
);
606 skip
= len
- SCHARS (elt
);
607 if (skip
< 0) continue;
609 if (0 <= scmp (dp
->d_name
+ skip
,
617 /* If an ignored-extensions match was found,
618 don't process this name as a completion. */
622 if (!includeall
&& canexclude
)
623 /* We're not including all files and this file can be excluded. */
626 if (includeall
&& !canexclude
)
627 { /* If we have one non-excludable file, we want to exclude the
630 /* Throw away any previous excludable match found. */
636 /* FIXME: If we move this `decode' earlier we can eliminate
637 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
638 name
= make_unibyte_string (dp
->d_name
, len
);
639 name
= DECODE_FILE (name
);
644 /* Ignore this element if it fails to match all the regexps. */
645 if (completion_ignore_case
)
647 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
648 regexps
= XCDR (regexps
))
649 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
654 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
655 regexps
= XCDR (regexps
))
656 if (fast_string_match (XCAR (regexps
), name
) < 0)
664 /* This is a possible completion */
666 /* This completion is a directory; make it end with '/'. */
667 name
= Ffile_name_as_directory (name
);
669 /* Test the predicate, if any. */
670 if (!NILP (predicate
))
673 struct gcpro inner_gcpro1
;
675 GCPRO1_VAR (name
, inner_gcpro
);
676 val
= call1 (predicate
, name
);
677 UNGCPRO_VAR (inner_gcpro
);
683 /* Suitably record this match. */
688 bestmatch
= Fcons (name
, bestmatch
);
689 else if (NILP (bestmatch
))
692 bestmatchsize
= SCHARS (name
);
696 Lisp_Object zero
= make_number (0);
697 /* FIXME: This is a copy of the code in Ftry_completion. */
698 int compare
= min (bestmatchsize
, SCHARS (name
));
700 = Fcompare_strings (bestmatch
, zero
,
701 make_number (compare
),
703 make_number (compare
),
704 completion_ignore_case
? Qt
: Qnil
);
706 = (EQ (cmp
, Qt
) ? compare
707 : XINT (cmp
) < 0 ? - XINT (cmp
) - 1
710 if (completion_ignore_case
)
712 /* If this is an exact match except for case,
713 use it as the best match rather than one that is not
714 an exact match. This way, we get the case pattern
715 of the actual match. */
716 /* This tests that the current file is an exact match
717 but BESTMATCH is not (it is too long). */
718 if ((matchsize
== SCHARS (name
)
719 && matchsize
+ !!directoryp
< SCHARS (bestmatch
))
721 /* If there is no exact match ignoring case,
722 prefer a match that does not change the case
724 /* If there is more than one exact match aside from
725 case, and one of them is exact including case,
727 /* This == checks that, of current file and BESTMATCH,
728 either both or neither are exact. */
729 (((matchsize
== SCHARS (name
))
731 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
732 && (cmp
= Fcompare_strings (name
, zero
,
733 make_number (SCHARS (file
)),
738 && (cmp
= Fcompare_strings (bestmatch
, zero
,
739 make_number (SCHARS (file
)),
746 bestmatchsize
= matchsize
;
748 /* If the best completion so far is reduced to the string
749 we're trying to complete, then we already know there's no
750 other completion, so there's no point looking any further. */
751 if (matchsize
<= SCHARS (file
)
752 && !includeall
/* A future match may allow includeall to 0. */
753 /* If completion-ignore-case is non-nil, don't
754 short-circuit because we want to find the best
755 possible match *including* case differences. */
756 && (!completion_ignore_case
|| matchsize
== 0)
757 /* The return value depends on whether it's the sole match. */
765 /* This closes the directory. */
766 bestmatch
= unbind_to (count
, bestmatch
);
768 if (all_flag
|| NILP (bestmatch
))
770 /* Return t if the supplied string is an exact match (counting case);
771 it does not require any change to be made. */
772 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
774 bestmatch
= Fsubstring (bestmatch
, make_number (0),
775 make_number (bestmatchsize
));
779 /* Compare exactly LEN chars of strings at S1 and S2,
780 ignoring case if appropriate.
781 Return -1 if strings match,
782 else number of chars that match at the beginning. */
785 scmp (const char *s1
, const char *s2
, int len
)
787 register int l
= len
;
789 if (completion_ignore_case
)
792 && (downcase ((unsigned char) *s1
++)
793 == downcase ((unsigned char) *s2
++)))
798 while (l
&& *s1
++ == *s2
++)
808 file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
)
810 int len
= NAMLEN (dp
);
811 int pos
= SCHARS (dirname
);
813 char *fullname
= (char *) alloca (len
+ pos
+ 2);
816 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
817 but aren't required here. Avoid computing the following fields:
818 st_inode, st_size and st_nlink for directories, and the execute bits
819 in st_mode for non-directory files with non-standard extensions. */
821 unsigned short save_djstat_flags
= _djstat_flags
;
823 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
826 memcpy (fullname
, SDATA (dirname
), pos
);
827 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
828 fullname
[pos
++] = DIRECTORY_SEP
;
830 memcpy (fullname
+ pos
, dp
->d_name
, len
);
831 fullname
[pos
+ len
] = 0;
833 /* We want to return success if a link points to a nonexistent file,
834 but we want to return the status for what the link points to,
835 in case it is a directory. */
836 value
= lstat (fullname
, st_addr
);
837 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
838 stat (fullname
, st_addr
);
840 _djstat_flags
= save_djstat_flags
;
846 stat_uname (struct stat
*st
)
851 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
861 stat_gname (struct stat
*st
)
866 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
875 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
876 doc
: /* Return a list of attributes of file FILENAME.
877 Value is nil if specified file cannot be opened.
879 ID-FORMAT specifies the preferred format of attributes uid and gid (see
880 below) - valid values are 'string and 'integer. The latter is the
881 default, but we plan to change that, so you should specify a non-nil value
882 for ID-FORMAT if you use the returned uid or gid.
884 Elements of the attribute list are:
885 0. t for directory, string (name linked to) for symbolic link, or nil.
886 1. Number of links to file.
887 2. File uid as a string or a number. If a string value cannot be
888 looked up, a numeric value, either an integer or a float, is returned.
889 3. File gid, likewise.
890 4. Last access time, as a list of two integers.
891 First integer has high-order 16 bits of time, second has low 16 bits.
892 (See a note below about access time on FAT-based filesystems.)
893 5. Last modification time, likewise. This is the time of the last
894 change to the file's contents.
895 6. Last status change time, likewise. This is the time of last change
896 to the file's attributes: owner and group, access mode bits, etc.
898 This is a floating point number if the size is too large for an integer.
899 8. File modes, as a string of ten letters or dashes as in ls -l.
900 9. t if file's gid would change if file were deleted and recreated.
901 10. inode number. If inode number is larger than what Emacs integer
902 can hold, but still fits into a 32-bit number, this is a cons cell
903 containing two integers: first the high part, then the low 16 bits.
904 If the inode number is wider than 32 bits, this is of the form
905 (HIGH MIDDLE . LOW): first the high 24 bits, then middle 24 bits,
906 and finally the low 16 bits.
907 11. Filesystem device number. If it is larger than what the Emacs
908 integer can hold, this is a cons cell, similar to the inode number.
910 On most filesystems, the combination of the inode and the device
911 number uniquely identifies the file.
913 On MS-Windows, performance depends on `w32-get-true-file-attributes',
916 On some FAT-based filesystems, only the date of last access is recorded,
917 so last access time will always be midnight of that day. */)
918 (Lisp_Object filename
, Lisp_Object id_format
)
920 Lisp_Object values
[12];
928 /* An array to hold the mode string generated by filemodestring,
929 including its terminating space and null byte. */
930 char modes
[sizeof "-rwxr-xr-x "];
934 char *uname
= NULL
, *gname
= NULL
;
936 filename
= Fexpand_file_name (filename
, Qnil
);
938 /* If the file name has special constructs in it,
939 call the corresponding file handler. */
940 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
942 { /* Only pass the extra arg if it is used to help backward compatibility
943 with old file handlers which do not implement the new arg. --Stef */
944 if (NILP (id_format
))
945 return call2 (handler
, Qfile_attributes
, filename
);
947 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
951 encoded
= ENCODE_FILE (filename
);
954 if (lstat (SSDATA (encoded
), &s
) < 0)
957 values
[0] = (S_ISLNK (s
.st_mode
) ? Ffile_symlink_p (filename
)
958 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
);
959 values
[1] = make_number (s
.st_nlink
);
961 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
964 uname
= stat_uname (&s
);
965 gname
= stat_gname (&s
);
969 values
[2] = DECODE_SYSTEM (build_string (uname
));
971 values
[2] = make_fixnum_or_float (s
.st_uid
);
973 values
[3] = DECODE_SYSTEM (build_string (gname
));
975 values
[3] = make_fixnum_or_float (s
.st_gid
);
977 values
[4] = make_time (s
.st_atime
);
978 values
[5] = make_time (s
.st_mtime
);
979 values
[6] = make_time (s
.st_ctime
);
980 values
[7] = make_fixnum_or_float (s
.st_size
);
981 /* If the size is negative, and its type is long, convert it back to
983 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
984 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
986 filemodestring (&s
, modes
);
987 values
[8] = make_string (modes
, 10);
988 #ifdef BSD4_2 /* file gid will be dir gid */
989 dirname
= Ffile_name_directory (filename
);
990 if (! NILP (dirname
))
991 encoded
= ENCODE_FILE (dirname
);
992 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
993 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
994 else /* if we can't tell, assume worst */
996 #else /* file gid will be egid */
997 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
998 #endif /* not BSD4_2 */
999 if (!FIXNUM_OVERFLOW_P (s
.st_ino
))
1000 /* Keep the most common cases as integers. */
1001 values
[10] = make_number (s
.st_ino
);
1002 else if (!FIXNUM_OVERFLOW_P (s
.st_ino
>> 16))
1003 /* To allow inode numbers larger than VALBITS, separate the bottom
1005 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1006 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1009 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1010 high parts and a 16-bit bottom part.
1011 The code on the next line avoids a compiler warning on
1012 systems where st_ino is 32 bit wide. (bug#766). */
1013 EMACS_INT high_ino
= s
.st_ino
>> 31 >> 1;
1014 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1016 values
[10] = Fcons (make_number (high_ino
>> 8),
1017 Fcons (make_number (((high_ino
& 0xff) << 16)
1019 make_number (low_ino
& 0xffff)));
1022 /* Likewise for device. */
1023 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1024 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1025 make_number (s
.st_dev
& 0xffff));
1027 values
[11] = make_number (s
.st_dev
);
1029 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1032 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1033 doc
: /* Return t if first arg file attributes list is less than second.
1034 Comparison is in lexicographic order and case is significant. */)
1035 (Lisp_Object f1
, Lisp_Object f2
)
1037 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1041 syms_of_dired (void)
1043 Qdirectory_files
= intern_c_string ("directory-files");
1044 Qdirectory_files_and_attributes
= intern_c_string ("directory-files-and-attributes");
1045 Qfile_name_completion
= intern_c_string ("file-name-completion");
1046 Qfile_name_all_completions
= intern_c_string ("file-name-all-completions");
1047 Qfile_attributes
= intern_c_string ("file-attributes");
1048 Qfile_attributes_lessp
= intern_c_string ("file-attributes-lessp");
1049 Qdefault_directory
= intern_c_string ("default-directory");
1051 staticpro (&Qdirectory_files
);
1052 staticpro (&Qdirectory_files_and_attributes
);
1053 staticpro (&Qfile_name_completion
);
1054 staticpro (&Qfile_name_all_completions
);
1055 staticpro (&Qfile_attributes
);
1056 staticpro (&Qfile_attributes_lessp
);
1057 staticpro (&Qdefault_directory
);
1059 defsubr (&Sdirectory_files
);
1060 defsubr (&Sdirectory_files_and_attributes
);
1061 defsubr (&Sfile_name_completion
);
1062 defsubr (&Sfile_name_all_completions
);
1063 defsubr (&Sfile_attributes
);
1064 defsubr (&Sfile_attributes_lessp
);
1066 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1067 doc
: /* Completion ignores file names ending in any string in this list.
1068 It does not ignore them if all possible completions end in one of
1069 these strings or when displaying a list of completions.
1070 It ignores directory names if they match any string in this list which
1071 ends in a slash. */);
1072 Vcompletion_ignored_extensions
= Qnil
;