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);
93 directory_files_internal_w32_unwind (Lisp_Object arg
)
95 Vw32_get_true_file_attributes
= arg
;
101 directory_files_internal_unwind (Lisp_Object dh
)
103 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
110 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
111 When ATTRS is zero, return a list of directory filenames; when
112 non-zero, return a list of directory filenames and their attributes.
113 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
116 directory_files_internal (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, int attrs
, Lisp_Object id_format
)
119 int directory_nbytes
;
120 Lisp_Object list
, dirfilename
, encoded_directory
;
121 struct re_pattern_buffer
*bufp
= NULL
;
123 int count
= SPECPDL_INDEX ();
124 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
127 Lisp_Object w32_save
= Qnil
;
130 /* Because of file name handlers, these functions might call
131 Ffuncall, and cause a GC. */
132 list
= encoded_directory
= dirfilename
= Qnil
;
133 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
134 dirfilename
= Fdirectory_file_name (directory
);
138 CHECK_STRING (match
);
140 /* MATCH might be a flawed regular expression. Rather than
141 catching and signaling our own errors, we just call
142 compile_pattern to do the work for us. */
143 /* Pass 1 for the MULTIBYTE arg
144 because we do make multibyte strings if the contents warrant. */
146 /* Windows users want case-insensitive wildcards. */
147 bufp
= compile_pattern (match
, 0,
148 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
149 # else /* !WINDOWSNT */
150 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
151 # endif /* !WINDOWSNT */
154 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
155 run_pre_post_conversion_on_str which calls Lisp directly and
157 if (STRING_MULTIBYTE (dirfilename
))
158 dirfilename
= ENCODE_FILE (dirfilename
);
159 encoded_directory
= (STRING_MULTIBYTE (directory
)
160 ? ENCODE_FILE (directory
) : directory
);
162 /* Now *bufp is the compiled form of MATCH; don't call anything
163 which might compile a new regexp until we're done with the loop! */
166 d
= opendir (SSDATA (dirfilename
));
169 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
171 /* Unfortunately, we can now invoke expand-file-name and
172 file-attributes on filenames, both of which can throw, so we must
173 do a proper unwind-protect. */
174 record_unwind_protect (directory_files_internal_unwind
,
175 make_save_value (d
, 0));
180 extern int is_slow_fs (const char *);
182 /* Do this only once to avoid doing it (in w32.c:stat) for each
183 file in the directory, when we call Ffile_attributes below. */
184 record_unwind_protect (directory_files_internal_w32_unwind
,
185 Vw32_get_true_file_attributes
);
186 w32_save
= Vw32_get_true_file_attributes
;
187 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
189 /* w32.c:stat will notice these bindings and avoid calling
190 GetDriveType for each file. */
191 if (is_slow_fs (SDATA (dirfilename
)))
192 Vw32_get_true_file_attributes
= Qnil
;
194 Vw32_get_true_file_attributes
= Qt
;
199 directory_nbytes
= SBYTES (directory
);
200 re_match_object
= Qt
;
202 /* Decide whether we need to add a directory separator. */
203 if (directory_nbytes
== 0
204 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
207 /* Loop reading blocks until EOF or error. */
226 if (DIRENTRY_NONEMPTY (dp
))
230 Lisp_Object name
, finalname
;
231 struct gcpro inner_gcpro1
, inner_gcpro2
;
234 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
235 GCPRO2_VAR (finalname
, name
, inner_gcpro
);
237 /* Note: DECODE_FILE can GC; it should protect its argument,
239 name
= DECODE_FILE (name
);
242 /* Now that we have unwind_protect in place, we might as well
243 allow matching to be interrupted. */
248 || (0 <= re_search (bufp
, SSDATA (name
), len
, 0, len
, 0)))
257 Lisp_Object fullname
;
258 int nbytes
= len
+ directory_nbytes
+ needsep
;
261 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
262 memcpy (SDATA (fullname
), SDATA (directory
),
266 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
268 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
271 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
273 /* Some bug somewhere. */
277 STRING_SET_CHARS (fullname
, nchars
);
278 if (nchars
== nbytes
)
279 STRING_SET_UNIBYTE (fullname
);
281 finalname
= fullname
;
288 /* Construct an expanded filename for the directory entry.
289 Use the decoded names for input to Ffile_attributes. */
290 Lisp_Object decoded_fullname
, fileattrs
;
291 struct gcpro innermost_gcpro1
, innermost_gcpro2
;
293 decoded_fullname
= fileattrs
= Qnil
;
294 GCPRO2_VAR (decoded_fullname
, fileattrs
, innermost_gcpro
);
296 /* Both Fexpand_file_name and Ffile_attributes can GC. */
297 decoded_fullname
= Fexpand_file_name (name
, directory
);
298 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
300 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
301 UNGCPRO_VAR (innermost_gcpro
);
304 list
= Fcons (finalname
, list
);
307 UNGCPRO_VAR (inner_gcpro
);
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 RETURN_UNGCPRO (list
);
330 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
331 doc
: /* Return a list of names of files in DIRECTORY.
332 There are three optional arguments:
333 If FULL is non-nil, return absolute file names. Otherwise return names
334 that are relative to the specified directory.
335 If MATCH is non-nil, mention only file names that match the regexp MATCH.
336 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
337 Otherwise, the list returned is sorted with `string-lessp'.
338 NOSORT is useful if you plan to sort the result yourself. */)
339 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
342 directory
= Fexpand_file_name (directory
, Qnil
);
344 /* If the file name has special constructs in it,
345 call the corresponding file handler. */
346 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
348 return call5 (handler
, Qdirectory_files
, directory
,
349 full
, match
, nosort
);
351 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
354 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
355 Sdirectory_files_and_attributes
, 1, 5, 0,
356 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
357 There are four optional arguments:
358 If FULL is non-nil, return absolute file names. Otherwise return names
359 that are relative to the specified directory.
360 If MATCH is non-nil, mention only file names that match the regexp MATCH.
361 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
362 NOSORT is useful if you plan to sort the result yourself.
363 ID-FORMAT specifies the preferred format of attributes uid and gid, see
364 `file-attributes' for further documentation.
365 On MS-Windows, performance depends on `w32-get-true-file-attributes',
367 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
370 directory
= Fexpand_file_name (directory
, Qnil
);
372 /* If the file name has special constructs in it,
373 call the corresponding file handler. */
374 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
376 return call6 (handler
, Qdirectory_files_and_attributes
,
377 directory
, full
, match
, nosort
, id_format
);
379 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
383 Lisp_Object
file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
);
385 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
387 doc
: /* Complete file name FILE in directory DIRECTORY.
388 Returns the longest string
389 common to all file names in DIRECTORY that start with FILE.
390 If there is only one and FILE matches it exactly, returns t.
391 Returns nil if DIRECTORY contains no name starting with FILE.
393 If PREDICATE is non-nil, call PREDICATE with each possible
394 completion (in absolute form) and ignore it if PREDICATE returns nil.
396 This function ignores some of the possible completions as
397 determined by the variable `completion-ignored-extensions', which see. */)
398 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
402 /* If the directory name has special constructs in it,
403 call the corresponding file handler. */
404 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
406 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
408 /* If the file name has special constructs in it,
409 call the corresponding file handler. */
410 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
412 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
414 return file_name_completion (file
, directory
, 0, 0, predicate
);
417 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
418 Sfile_name_all_completions
, 2, 2, 0,
419 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
420 These are all file names in directory DIRECTORY which begin with FILE. */)
421 (Lisp_Object file
, Lisp_Object directory
)
425 /* If the directory name has special constructs in it,
426 call the corresponding file handler. */
427 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
429 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
431 /* If the file name has special constructs in it,
432 call the corresponding file handler. */
433 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
435 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
437 return file_name_completion (file
, directory
, 1, 0, Qnil
);
440 static int file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
);
441 Lisp_Object Qdefault_directory
;
444 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
)
447 int bestmatchsize
= 0;
449 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
450 If ALL_FLAG is 0, BESTMATCH is either nil
451 or the best match so far, not decoded. */
452 Lisp_Object bestmatch
, tem
, elt
, name
;
453 Lisp_Object encoded_file
;
454 Lisp_Object encoded_dir
;
457 /* If includeall is zero, exclude files in completion-ignored-extensions as
458 well as "." and "..". Until shown otherwise, assume we can't exclude
461 int count
= SPECPDL_INDEX ();
462 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
468 #ifdef FILE_SYSTEM_CASE
469 file
= FILE_SYSTEM_CASE (file
);
472 encoded_file
= encoded_dir
= Qnil
;
473 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
474 dirname
= Fexpand_file_name (dirname
, Qnil
);
475 specbind (Qdefault_directory
, dirname
);
477 /* Do completion on the encoded file name
478 because the other names in the directory are (we presume)
479 encoded likewise. We decode the completed string at the end. */
480 /* Actually, this is not quite true any more: we do most of the completion
481 work with decoded file names, but we still do some filtering based
482 on the encoded file name. */
483 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
485 encoded_dir
= ENCODE_FILE (dirname
);
488 d
= opendir (SSDATA (Fdirectory_file_name (encoded_dir
)));
491 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
493 record_unwind_protect (directory_files_internal_unwind
,
494 make_save_value (d
, 0));
496 /* Loop reading blocks */
497 /* (att3b compiler bug requires do a null comparison this way) */
521 if (! DIRENTRY_NONEMPTY (dp
)
522 || len
< SCHARS (encoded_file
)
523 || 0 <= scmp (dp
->d_name
, SSDATA (encoded_file
),
524 SCHARS (encoded_file
)))
527 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
530 directoryp
= S_ISDIR (st
.st_mode
);
532 /* If all_flag is set, always include all.
533 It would not actually be helpful to the user to ignore any possible
534 completions when making a list of them. */
539 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
540 /* If this entry matches the current bestmatch, the only
541 thing it can do is increase matchcount, so don't bother
542 investigating it any further. */
543 if (!completion_ignore_case
544 /* The return result depends on whether it's the sole match. */
546 && !includeall
/* This match may allow includeall to 0. */
547 && len
>= bestmatchsize
548 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
554 #ifndef TRIVIAL_DIRECTORY_ENTRY
555 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
557 /* "." and ".." are never interesting as completions, and are
558 actually in the way in a directory with only one file. */
559 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
561 else if (len
> SCHARS (encoded_file
))
562 /* Ignore directories if they match an element of
563 completion-ignored-extensions which ends in a slash. */
564 for (tem
= Vcompletion_ignored_extensions
;
565 CONSP (tem
); tem
= XCDR (tem
))
573 /* Need to encode ELT, since scmp compares unibyte
575 elt
= ENCODE_FILE (elt
);
576 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
580 if (p1
[elt_len
] != '/')
582 skip
= len
- elt_len
;
586 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
593 /* Compare extensions-to-be-ignored against end of this file name */
594 /* if name is not an exact match against specified string */
595 if (len
> SCHARS (encoded_file
))
596 /* and exit this for loop if a match is found */
597 for (tem
= Vcompletion_ignored_extensions
;
598 CONSP (tem
); tem
= XCDR (tem
))
601 if (!STRINGP (elt
)) continue;
602 /* Need to encode ELT, since scmp compares unibyte
604 elt
= ENCODE_FILE (elt
);
605 skip
= len
- SCHARS (elt
);
606 if (skip
< 0) continue;
608 if (0 <= scmp (dp
->d_name
+ skip
,
616 /* If an ignored-extensions match was found,
617 don't process this name as a completion. */
621 if (!includeall
&& canexclude
)
622 /* We're not including all files and this file can be excluded. */
625 if (includeall
&& !canexclude
)
626 { /* If we have one non-excludable file, we want to exclude the
629 /* Throw away any previous excludable match found. */
635 /* FIXME: If we move this `decode' earlier we can eliminate
636 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
637 name
= make_unibyte_string (dp
->d_name
, len
);
638 name
= DECODE_FILE (name
);
643 /* Ignore this element if it fails to match all the regexps. */
644 if (completion_ignore_case
)
646 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
647 regexps
= XCDR (regexps
))
648 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
653 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
654 regexps
= XCDR (regexps
))
655 if (fast_string_match (XCAR (regexps
), name
) < 0)
663 /* This is a possible completion */
665 /* This completion is a directory; make it end with '/'. */
666 name
= Ffile_name_as_directory (name
);
668 /* Test the predicate, if any. */
669 if (!NILP (predicate
))
672 struct gcpro inner_gcpro1
;
674 GCPRO1_VAR (name
, inner_gcpro
);
675 val
= call1 (predicate
, name
);
676 UNGCPRO_VAR (inner_gcpro
);
682 /* Suitably record this match. */
687 bestmatch
= Fcons (name
, bestmatch
);
688 else if (NILP (bestmatch
))
691 bestmatchsize
= SCHARS (name
);
695 Lisp_Object zero
= make_number (0);
696 /* FIXME: This is a copy of the code in Ftry_completion. */
697 int compare
= min (bestmatchsize
, SCHARS (name
));
699 = Fcompare_strings (bestmatch
, zero
,
700 make_number (compare
),
702 make_number (compare
),
703 completion_ignore_case
? Qt
: Qnil
);
705 = (EQ (cmp
, Qt
) ? compare
706 : XINT (cmp
) < 0 ? - XINT (cmp
) - 1
709 if (completion_ignore_case
)
711 /* If this is an exact match except for case,
712 use it as the best match rather than one that is not
713 an exact match. This way, we get the case pattern
714 of the actual match. */
715 /* This tests that the current file is an exact match
716 but BESTMATCH is not (it is too long). */
717 if ((matchsize
== SCHARS (name
)
718 && matchsize
+ !!directoryp
< SCHARS (bestmatch
))
720 /* If there is no exact match ignoring case,
721 prefer a match that does not change the case
723 /* If there is more than one exact match aside from
724 case, and one of them is exact including case,
726 /* This == checks that, of current file and BESTMATCH,
727 either both or neither are exact. */
728 (((matchsize
== SCHARS (name
))
730 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
731 && (cmp
= Fcompare_strings (name
, zero
,
732 make_number (SCHARS (file
)),
737 && (cmp
= Fcompare_strings (bestmatch
, zero
,
738 make_number (SCHARS (file
)),
745 bestmatchsize
= matchsize
;
747 /* If the best completion so far is reduced to the string
748 we're trying to complete, then we already know there's no
749 other completion, so there's no point looking any further. */
750 if (matchsize
<= SCHARS (file
)
751 && !includeall
/* A future match may allow includeall to 0. */
752 /* If completion-ignore-case is non-nil, don't
753 short-circuit because we want to find the best
754 possible match *including* case differences. */
755 && (!completion_ignore_case
|| matchsize
== 0)
756 /* The return value depends on whether it's the sole match. */
764 /* This closes the directory. */
765 bestmatch
= unbind_to (count
, bestmatch
);
767 if (all_flag
|| NILP (bestmatch
))
769 /* Return t if the supplied string is an exact match (counting case);
770 it does not require any change to be made. */
771 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
773 bestmatch
= Fsubstring (bestmatch
, make_number (0),
774 make_number (bestmatchsize
));
778 /* Compare exactly LEN chars of strings at S1 and S2,
779 ignoring case if appropriate.
780 Return -1 if strings match,
781 else number of chars that match at the beginning. */
784 scmp (const char *s1
, const char *s2
, int len
)
786 register int l
= len
;
788 if (completion_ignore_case
)
791 && (downcase ((unsigned char) *s1
++)
792 == downcase ((unsigned char) *s2
++)))
797 while (l
&& *s1
++ == *s2
++)
807 file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
)
809 int len
= NAMLEN (dp
);
810 int pos
= SCHARS (dirname
);
812 char *fullname
= (char *) alloca (len
+ pos
+ 2);
815 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
816 but aren't required here. Avoid computing the following fields:
817 st_inode, st_size and st_nlink for directories, and the execute bits
818 in st_mode for non-directory files with non-standard extensions. */
820 unsigned short save_djstat_flags
= _djstat_flags
;
822 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
825 memcpy (fullname
, SDATA (dirname
), pos
);
826 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
827 fullname
[pos
++] = DIRECTORY_SEP
;
829 memcpy (fullname
+ pos
, dp
->d_name
, len
);
830 fullname
[pos
+ len
] = 0;
832 /* We want to return success if a link points to a nonexistent file,
833 but we want to return the status for what the link points to,
834 in case it is a directory. */
835 value
= lstat (fullname
, st_addr
);
836 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
837 stat (fullname
, st_addr
);
839 _djstat_flags
= save_djstat_flags
;
845 stat_uname (struct stat
*st
)
850 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
860 stat_gname (struct stat
*st
)
865 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
874 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
875 doc
: /* Return a list of attributes of file FILENAME.
876 Value is nil if specified file cannot be opened.
878 ID-FORMAT specifies the preferred format of attributes uid and gid (see
879 below) - valid values are 'string and 'integer. The latter is the
880 default, but we plan to change that, so you should specify a non-nil value
881 for ID-FORMAT if you use the returned uid or gid.
883 Elements of the attribute list are:
884 0. t for directory, string (name linked to) for symbolic link, or nil.
885 1. Number of links to file.
886 2. File uid as a string or a number. If a string value cannot be
887 looked up, a numeric value, either an integer or a float, is returned.
888 3. File gid, likewise.
889 4. Last access time, as a list of two integers.
890 First integer has high-order 16 bits of time, second has low 16 bits.
891 (See a note below about access time on FAT-based filesystems.)
892 5. Last modification time, likewise. This is the time of the last
893 change to the file's contents.
894 6. Last status change time, likewise. This is the time of last change
895 to the file's attributes: owner and group, access mode bits, etc.
897 This is a floating point number if the size is too large for an integer.
898 8. File modes, as a string of ten letters or dashes as in ls -l.
899 9. t if file's gid would change if file were deleted and recreated.
900 10. inode number. If inode number is larger than what Emacs integer
901 can hold, but still fits into a 32-bit number, this is a cons cell
902 containing two integers: first the high part, then the low 16 bits.
903 If the inode number is wider than 32 bits, this is of the form
904 (HIGH MIDDLE . LOW): first the high 24 bits, then middle 24 bits,
905 and finally the low 16 bits.
906 11. Filesystem device number. If it is larger than what the Emacs
907 integer can hold, this is a cons cell, similar to the inode number.
909 On most filesystems, the combination of the inode and the device
910 number uniquely identifies the file.
912 On MS-Windows, performance depends on `w32-get-true-file-attributes',
915 On some FAT-based filesystems, only the date of last access is recorded,
916 so last access time will always be midnight of that day. */)
917 (Lisp_Object filename
, Lisp_Object id_format
)
919 Lisp_Object values
[12];
927 /* An array to hold the mode string generated by filemodestring,
928 including its terminating space and null byte. */
929 char modes
[sizeof "-rwxr-xr-x "];
933 char *uname
= NULL
, *gname
= NULL
;
935 filename
= Fexpand_file_name (filename
, Qnil
);
937 /* If the file name has special constructs in it,
938 call the corresponding file handler. */
939 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
941 { /* Only pass the extra arg if it is used to help backward compatibility
942 with old file handlers which do not implement the new arg. --Stef */
943 if (NILP (id_format
))
944 return call2 (handler
, Qfile_attributes
, filename
);
946 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
950 encoded
= ENCODE_FILE (filename
);
953 if (lstat (SSDATA (encoded
), &s
) < 0)
956 values
[0] = (S_ISLNK (s
.st_mode
) ? Ffile_symlink_p (filename
)
957 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
);
958 values
[1] = make_number (s
.st_nlink
);
960 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
963 uname
= stat_uname (&s
);
964 gname
= stat_gname (&s
);
968 values
[2] = DECODE_SYSTEM (build_string (uname
));
970 values
[2] = make_fixnum_or_float (s
.st_uid
);
972 values
[3] = DECODE_SYSTEM (build_string (gname
));
974 values
[3] = make_fixnum_or_float (s
.st_gid
);
976 values
[4] = make_time (s
.st_atime
);
977 values
[5] = make_time (s
.st_mtime
);
978 values
[6] = make_time (s
.st_ctime
);
979 values
[7] = make_fixnum_or_float (s
.st_size
);
980 /* If the size is negative, and its type is long, convert it back to
982 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
983 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
985 filemodestring (&s
, modes
);
986 values
[8] = make_string (modes
, 10);
987 #ifdef BSD4_2 /* file gid will be dir gid */
988 dirname
= Ffile_name_directory (filename
);
989 if (! NILP (dirname
))
990 encoded
= ENCODE_FILE (dirname
);
991 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
992 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
993 else /* if we can't tell, assume worst */
995 #else /* file gid will be egid */
996 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
997 #endif /* not BSD4_2 */
998 if (!FIXNUM_OVERFLOW_P (s
.st_ino
))
999 /* Keep the most common cases as integers. */
1000 values
[10] = make_number (s
.st_ino
);
1001 else if (!FIXNUM_OVERFLOW_P (s
.st_ino
>> 16))
1002 /* To allow inode numbers larger than VALBITS, separate the bottom
1004 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1005 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1008 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1009 high parts and a 16-bit bottom part.
1010 The code on the next line avoids a compiler warning on
1011 systems where st_ino is 32 bit wide. (bug#766). */
1012 EMACS_INT high_ino
= s
.st_ino
>> 31 >> 1;
1013 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1015 values
[10] = Fcons (make_number (high_ino
>> 8),
1016 Fcons (make_number (((high_ino
& 0xff) << 16)
1018 make_number (low_ino
& 0xffff)));
1021 /* Likewise for device. */
1022 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1023 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1024 make_number (s
.st_dev
& 0xffff));
1026 values
[11] = make_number (s
.st_dev
);
1028 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1031 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1032 doc
: /* Return t if first arg file attributes list is less than second.
1033 Comparison is in lexicographic order and case is significant. */)
1034 (Lisp_Object f1
, Lisp_Object f2
)
1036 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1040 syms_of_dired (void)
1042 Qdirectory_files
= intern_c_string ("directory-files");
1043 Qdirectory_files_and_attributes
= intern_c_string ("directory-files-and-attributes");
1044 Qfile_name_completion
= intern_c_string ("file-name-completion");
1045 Qfile_name_all_completions
= intern_c_string ("file-name-all-completions");
1046 Qfile_attributes
= intern_c_string ("file-attributes");
1047 Qfile_attributes_lessp
= intern_c_string ("file-attributes-lessp");
1048 Qdefault_directory
= intern_c_string ("default-directory");
1050 staticpro (&Qdirectory_files
);
1051 staticpro (&Qdirectory_files_and_attributes
);
1052 staticpro (&Qfile_name_completion
);
1053 staticpro (&Qfile_name_all_completions
);
1054 staticpro (&Qfile_attributes
);
1055 staticpro (&Qfile_attributes_lessp
);
1056 staticpro (&Qdefault_directory
);
1058 defsubr (&Sdirectory_files
);
1059 defsubr (&Sdirectory_files_and_attributes
);
1060 defsubr (&Sfile_name_completion
);
1061 defsubr (&Sfile_name_all_completions
);
1062 defsubr (&Sfile_attributes
);
1063 defsubr (&Sfile_attributes_lessp
);
1065 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1066 doc
: /* Completion ignores file names ending in any string in this list.
1067 It does not ignore them if all possible completions end in one of
1068 these strings or when displaying a list of completions.
1069 It ignores directory names if they match any string in this list which
1070 ends in a slash. */);
1071 Vcompletion_ignored_extensions
= Qnil
;