1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
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>
36 /* The d_nameln member of a struct dirent includes the '\0' character
37 on some systems, but not on others. What's worse, you can't tell
38 at compile-time which one it will be, since it really depends on
39 the sort of system providing the filesystem you're reading from,
40 not the system you are running on. Paul Eggert
41 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
42 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
43 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
45 Since applying strlen to the name always works, we'll just do that. */
46 #define NAMLEN(p) strlen (p->d_name)
51 #define DIRENTRY struct dirent
53 #else /* not HAVE_DIRENT_H */
58 #define DIRENTRY struct direct
60 extern DIR *opendir (char *);
61 extern struct direct
*readdir (DIR *);
63 #endif /* HAVE_DIRENT_H */
66 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
68 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
75 #include "character.h"
79 #include "blockinput.h"
81 /* Returns a search buffer, with a fastmap allocated and ready to go. */
82 extern struct re_pattern_buffer
*compile_pattern (Lisp_Object
,
83 struct re_registers
*,
84 Lisp_Object
, int, int);
86 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
87 extern void filemodestring (struct stat
*, char *);
89 /* if system does not have symbolic links, it does not have lstat.
90 In that case, use ordinary stat instead. */
96 extern Lisp_Object Vw32_get_true_file_attributes
;
98 Lisp_Object Vcompletion_ignored_extensions
;
99 Lisp_Object Qdirectory_files
;
100 Lisp_Object Qdirectory_files_and_attributes
;
101 Lisp_Object Qfile_name_completion
;
102 Lisp_Object Qfile_name_all_completions
;
103 Lisp_Object Qfile_attributes
;
104 Lisp_Object Qfile_attributes_lessp
;
106 static int scmp (const unsigned char *, const unsigned char *, int);
110 directory_files_internal_w32_unwind (Lisp_Object arg
)
112 Vw32_get_true_file_attributes
= arg
;
118 directory_files_internal_unwind (Lisp_Object dh
)
120 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
127 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
128 When ATTRS is zero, return a list of directory filenames; when
129 non-zero, return a list of directory filenames and their attributes.
130 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
133 directory_files_internal (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, int attrs
, Lisp_Object id_format
)
136 int directory_nbytes
;
137 Lisp_Object list
, dirfilename
, encoded_directory
;
138 struct re_pattern_buffer
*bufp
= NULL
;
140 int count
= SPECPDL_INDEX ();
141 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
144 Lisp_Object w32_save
= Qnil
;
147 /* Because of file name handlers, these functions might call
148 Ffuncall, and cause a GC. */
149 list
= encoded_directory
= dirfilename
= Qnil
;
150 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
151 dirfilename
= Fdirectory_file_name (directory
);
155 CHECK_STRING (match
);
157 /* MATCH might be a flawed regular expression. Rather than
158 catching and signaling our own errors, we just call
159 compile_pattern to do the work for us. */
160 /* Pass 1 for the MULTIBYTE arg
161 because we do make multibyte strings if the contents warrant. */
163 /* Windows users want case-insensitive wildcards. */
164 bufp
= compile_pattern (match
, 0,
165 buffer_defaults
.case_canon_table
, 0, 1);
166 # else /* !WINDOWSNT */
167 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
168 # endif /* !WINDOWSNT */
171 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
172 run_pre_post_conversion_on_str which calls Lisp directly and
174 if (STRING_MULTIBYTE (dirfilename
))
175 dirfilename
= ENCODE_FILE (dirfilename
);
176 encoded_directory
= (STRING_MULTIBYTE (directory
)
177 ? ENCODE_FILE (directory
) : directory
);
179 /* Now *bufp is the compiled form of MATCH; don't call anything
180 which might compile a new regexp until we're done with the loop! */
183 d
= opendir (SDATA (dirfilename
));
186 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
188 /* Unfortunately, we can now invoke expand-file-name and
189 file-attributes on filenames, both of which can throw, so we must
190 do a proper unwind-protect. */
191 record_unwind_protect (directory_files_internal_unwind
,
192 make_save_value (d
, 0));
197 extern int is_slow_fs (const char *);
199 /* Do this only once to avoid doing it (in w32.c:stat) for each
200 file in the directory, when we call Ffile_attributes below. */
201 record_unwind_protect (directory_files_internal_w32_unwind
,
202 Vw32_get_true_file_attributes
);
203 w32_save
= Vw32_get_true_file_attributes
;
204 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
206 /* w32.c:stat will notice these bindings and avoid calling
207 GetDriveType for each file. */
208 if (is_slow_fs (SDATA (dirfilename
)))
209 Vw32_get_true_file_attributes
= Qnil
;
211 Vw32_get_true_file_attributes
= Qt
;
216 directory_nbytes
= SBYTES (directory
);
217 re_match_object
= Qt
;
219 /* Decide whether we need to add a directory separator. */
220 if (directory_nbytes
== 0
221 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
224 /* Loop reading blocks until EOF or error. */
243 if (DIRENTRY_NONEMPTY (dp
))
247 Lisp_Object name
, finalname
;
248 struct gcpro gcpro1
, gcpro2
;
251 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
252 GCPRO2 (finalname
, name
);
254 /* Note: DECODE_FILE can GC; it should protect its argument,
256 name
= DECODE_FILE (name
);
259 /* Now that we have unwind_protect in place, we might as well
260 allow matching to be interrupted. */
265 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
274 Lisp_Object fullname
;
275 int nbytes
= len
+ directory_nbytes
+ needsep
;
278 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
279 memcpy (SDATA (fullname
), SDATA (directory
),
283 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
285 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
288 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
290 /* Some bug somewhere. */
294 STRING_SET_CHARS (fullname
, nchars
);
295 if (nchars
== nbytes
)
296 STRING_SET_UNIBYTE (fullname
);
298 finalname
= fullname
;
305 /* Construct an expanded filename for the directory entry.
306 Use the decoded names for input to Ffile_attributes. */
307 Lisp_Object decoded_fullname
, fileattrs
;
308 struct gcpro gcpro1
, gcpro2
;
310 decoded_fullname
= fileattrs
= Qnil
;
311 GCPRO2 (decoded_fullname
, fileattrs
);
313 /* Both Fexpand_file_name and Ffile_attributes can GC. */
314 decoded_fullname
= Fexpand_file_name (name
, directory
);
315 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
317 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
321 list
= Fcons (finalname
, list
);
333 Vw32_get_true_file_attributes
= w32_save
;
336 /* Discard the unwind protect. */
337 specpdl_ptr
= specpdl
+ count
;
340 list
= Fsort (Fnreverse (list
),
341 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
343 RETURN_UNGCPRO (list
);
347 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
348 doc
: /* Return a list of names of files in DIRECTORY.
349 There are three optional arguments:
350 If FULL is non-nil, return absolute file names. Otherwise return names
351 that are relative to the specified directory.
352 If MATCH is non-nil, mention only file names that match the regexp MATCH.
353 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
354 Otherwise, the list returned is sorted with `string-lessp'.
355 NOSORT is useful if you plan to sort the result yourself. */)
356 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
359 directory
= Fexpand_file_name (directory
, Qnil
);
361 /* If the file name has special constructs in it,
362 call the corresponding file handler. */
363 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
365 return call5 (handler
, Qdirectory_files
, directory
,
366 full
, match
, nosort
);
368 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
371 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
372 Sdirectory_files_and_attributes
, 1, 5, 0,
373 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
374 There are four optional arguments:
375 If FULL is non-nil, return absolute file names. Otherwise return names
376 that are relative to the specified directory.
377 If MATCH is non-nil, mention only file names that match the regexp MATCH.
378 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
379 NOSORT is useful if you plan to sort the result yourself.
380 ID-FORMAT specifies the preferred format of attributes uid and gid, see
381 `file-attributes' for further documentation.
382 On MS-Windows, performance depends on `w32-get-true-file-attributes',
384 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
387 directory
= Fexpand_file_name (directory
, Qnil
);
389 /* If the file name has special constructs in it,
390 call the corresponding file handler. */
391 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
393 return call6 (handler
, Qdirectory_files_and_attributes
,
394 directory
, full
, match
, nosort
, id_format
);
396 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
400 Lisp_Object
file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
);
402 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
404 doc
: /* Complete file name FILE in directory DIRECTORY.
405 Returns the longest string
406 common to all file names in DIRECTORY that start with FILE.
407 If there is only one and FILE matches it exactly, returns t.
408 Returns nil if DIRECTORY contains no name starting with FILE.
410 If PREDICATE is non-nil, call PREDICATE with each possible
411 completion (in absolute form) and ignore it if PREDICATE returns nil.
413 This function ignores some of the possible completions as
414 determined by the variable `completion-ignored-extensions', which see. */)
415 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
419 /* If the directory name has special constructs in it,
420 call the corresponding file handler. */
421 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
423 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
425 /* If the file name has special constructs in it,
426 call the corresponding file handler. */
427 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
429 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
431 return file_name_completion (file
, directory
, 0, 0, predicate
);
434 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
435 Sfile_name_all_completions
, 2, 2, 0,
436 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
437 These are all file names in directory DIRECTORY which begin with FILE. */)
438 (Lisp_Object file
, Lisp_Object directory
)
442 /* If the directory name has special constructs in it,
443 call the corresponding file handler. */
444 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
446 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
448 /* If the file name has special constructs in it,
449 call the corresponding file handler. */
450 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
452 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
454 return file_name_completion (file
, directory
, 1, 0, Qnil
);
457 static int file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
);
458 Lisp_Object Qdefault_directory
;
461 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
)
464 int bestmatchsize
= 0;
466 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
467 If ALL_FLAG is 0, BESTMATCH is either nil
468 or the best match so far, not decoded. */
469 Lisp_Object bestmatch
, tem
, elt
, name
;
470 Lisp_Object encoded_file
;
471 Lisp_Object encoded_dir
;
474 /* If includeall is zero, exclude files in completion-ignored-extensions as
475 well as "." and "..". Until shown otherwise, assume we can't exclude
478 int count
= SPECPDL_INDEX ();
479 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
485 #ifdef FILE_SYSTEM_CASE
486 file
= FILE_SYSTEM_CASE (file
);
489 encoded_file
= encoded_dir
= Qnil
;
490 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
491 dirname
= Fexpand_file_name (dirname
, Qnil
);
492 specbind (Qdefault_directory
, dirname
);
494 /* Do completion on the encoded file name
495 because the other names in the directory are (we presume)
496 encoded likewise. We decode the completed string at the end. */
497 /* Actually, this is not quite true any more: we do most of the completion
498 work with decoded file names, but we still do some filtering based
499 on the encoded file name. */
500 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
502 encoded_dir
= ENCODE_FILE (dirname
);
505 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
508 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
510 record_unwind_protect (directory_files_internal_unwind
,
511 make_save_value (d
, 0));
513 /* Loop reading blocks */
514 /* (att3b compiler bug requires do a null comparison this way) */
538 if (! DIRENTRY_NONEMPTY (dp
)
539 || len
< SCHARS (encoded_file
)
540 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
541 SCHARS (encoded_file
)))
544 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
547 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
549 /* If all_flag is set, always include all.
550 It would not actually be helpful to the user to ignore any possible
551 completions when making a list of them. */
556 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
557 /* If this entry matches the current bestmatch, the only
558 thing it can do is increase matchcount, so don't bother
559 investigating it any further. */
560 if (!completion_ignore_case
561 /* The return result depends on whether it's the sole match. */
563 && !includeall
/* This match may allow includeall to 0. */
564 && len
>= bestmatchsize
565 && 0 > scmp (dp
->d_name
, SDATA (bestmatch
), bestmatchsize
))
571 #ifndef TRIVIAL_DIRECTORY_ENTRY
572 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
574 /* "." and ".." are never interesting as completions, and are
575 actually in the way in a directory with only one file. */
576 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
578 else if (len
> SCHARS (encoded_file
))
579 /* Ignore directories if they match an element of
580 completion-ignored-extensions which ends in a slash. */
581 for (tem
= Vcompletion_ignored_extensions
;
582 CONSP (tem
); tem
= XCDR (tem
))
590 /* Need to encode ELT, since scmp compares unibyte
592 elt
= ENCODE_FILE (elt
);
593 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
597 if (p1
[elt_len
] != '/')
599 skip
= len
- elt_len
;
603 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
610 /* Compare extensions-to-be-ignored against end of this file name */
611 /* if name is not an exact match against specified string */
612 if (len
> SCHARS (encoded_file
))
613 /* and exit this for loop if a match is found */
614 for (tem
= Vcompletion_ignored_extensions
;
615 CONSP (tem
); tem
= XCDR (tem
))
618 if (!STRINGP (elt
)) continue;
619 /* Need to encode ELT, since scmp compares unibyte
621 elt
= ENCODE_FILE (elt
);
622 skip
= len
- SCHARS (elt
);
623 if (skip
< 0) continue;
625 if (0 <= scmp (dp
->d_name
+ skip
,
633 /* If an ignored-extensions match was found,
634 don't process this name as a completion. */
638 if (!includeall
&& canexclude
)
639 /* We're not including all files and this file can be excluded. */
642 if (includeall
&& !canexclude
)
643 { /* If we have one non-excludable file, we want to exclude the
646 /* Throw away any previous excludable match found. */
652 /* FIXME: If we move this `decode' earlier we can eliminate
653 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
654 name
= make_unibyte_string (dp
->d_name
, len
);
655 name
= DECODE_FILE (name
);
660 XSETFASTINT (zero
, 0);
662 /* Ignore this element if it fails to match all the regexps. */
663 if (completion_ignore_case
)
665 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
666 regexps
= XCDR (regexps
))
667 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
672 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
673 regexps
= XCDR (regexps
))
674 if (fast_string_match (XCAR (regexps
), name
) < 0)
682 /* This is a possible completion */
684 /* This completion is a directory; make it end with '/'. */
685 name
= Ffile_name_as_directory (name
);
687 /* Test the predicate, if any. */
688 if (!NILP (predicate
))
694 val
= call1 (predicate
, name
);
701 /* Suitably record this match. */
706 bestmatch
= Fcons (name
, bestmatch
);
707 else if (NILP (bestmatch
))
710 bestmatchsize
= SCHARS (name
);
714 Lisp_Object zero
= make_number (0);
715 /* FIXME: This is a copy of the code in Ftry_completion. */
716 int compare
= min (bestmatchsize
, SCHARS (name
));
718 = Fcompare_strings (bestmatch
, zero
,
719 make_number (compare
),
721 make_number (compare
),
722 completion_ignore_case
? Qt
: Qnil
);
724 = (EQ (tem
, Qt
) ? compare
725 : XINT (tem
) < 0 ? - XINT (tem
) - 1
728 if (completion_ignore_case
)
730 /* If this is an exact match except for case,
731 use it as the best match rather than one that is not
732 an exact match. This way, we get the case pattern
733 of the actual match. */
734 /* This tests that the current file is an exact match
735 but BESTMATCH is not (it is too long). */
736 if ((matchsize
== SCHARS (name
)
737 && matchsize
+ !!directoryp
< SCHARS (bestmatch
))
739 /* If there is no exact match ignoring case,
740 prefer a match that does not change the case
742 /* If there is more than one exact match aside from
743 case, and one of them is exact including case,
745 /* This == checks that, of current file and BESTMATCH,
746 either both or neither are exact. */
747 (((matchsize
== SCHARS (name
))
749 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
750 && (tem
= Fcompare_strings (name
, zero
,
751 make_number (SCHARS (file
)),
756 && (tem
= Fcompare_strings (bestmatch
, zero
,
757 make_number (SCHARS (file
)),
764 bestmatchsize
= matchsize
;
766 /* If the best completion so far is reduced to the string
767 we're trying to complete, then we already know there's no
768 other completion, so there's no point looking any further. */
769 if (matchsize
<= SCHARS (file
)
770 && !includeall
/* A future match may allow includeall to 0. */
771 /* If completion-ignore-case is non-nil, don't
772 short-circuit because we want to find the best
773 possible match *including* case differences. */
774 && (!completion_ignore_case
|| matchsize
== 0)
775 /* The return value depends on whether it's the sole match. */
783 /* This closes the directory. */
784 bestmatch
= unbind_to (count
, bestmatch
);
786 if (all_flag
|| NILP (bestmatch
))
788 /* Return t if the supplied string is an exact match (counting case);
789 it does not require any change to be made. */
790 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
792 bestmatch
= Fsubstring (bestmatch
, make_number (0),
793 make_number (bestmatchsize
));
797 /* Compare exactly LEN chars of strings at S1 and S2,
798 ignoring case if appropriate.
799 Return -1 if strings match,
800 else number of chars that match at the beginning. */
803 scmp (const unsigned char *s1
, const unsigned char *s2
, int len
)
805 register int l
= len
;
807 if (completion_ignore_case
)
809 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
814 while (l
&& *s1
++ == *s2
++)
824 file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
)
826 int len
= NAMLEN (dp
);
827 int pos
= SCHARS (dirname
);
829 char *fullname
= (char *) alloca (len
+ pos
+ 2);
832 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
833 but aren't required here. Avoid computing the following fields:
834 st_inode, st_size and st_nlink for directories, and the execute bits
835 in st_mode for non-directory files with non-standard extensions. */
837 unsigned short save_djstat_flags
= _djstat_flags
;
839 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
842 memcpy (fullname
, SDATA (dirname
), pos
);
843 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
844 fullname
[pos
++] = DIRECTORY_SEP
;
846 memcpy (fullname
+ pos
, dp
->d_name
, len
);
847 fullname
[pos
+ len
] = 0;
850 /* We want to return success if a link points to a nonexistent file,
851 but we want to return the status for what the link points to,
852 in case it is a directory. */
853 value
= lstat (fullname
, st_addr
);
854 stat (fullname
, st_addr
);
857 value
= stat (fullname
, st_addr
);
859 _djstat_flags
= save_djstat_flags
;
866 make_time (time_t time
)
868 return Fcons (make_number (time
>> 16),
869 Fcons (make_number (time
& 0177777), Qnil
));
873 stat_uname (struct stat
*st
)
878 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
888 stat_gname (struct stat
*st
)
893 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
902 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
903 doc
: /* Return a list of attributes of file FILENAME.
904 Value is nil if specified file cannot be opened.
906 ID-FORMAT specifies the preferred format of attributes uid and gid (see
907 below) - valid values are 'string and 'integer. The latter is the
908 default, but we plan to change that, so you should specify a non-nil value
909 for ID-FORMAT if you use the returned uid or gid.
911 Elements of the attribute list are:
912 0. t for directory, string (name linked to) for symbolic link, or nil.
913 1. Number of links to file.
914 2. File uid as a string or a number. If a string value cannot be
915 looked up, a numeric value, either an integer or a float, is returned.
916 3. File gid, likewise.
917 4. Last access time, as a list of two integers.
918 First integer has high-order 16 bits of time, second has low 16 bits.
919 (See a note below about access time on FAT-based filesystems.)
920 5. Last modification time, likewise. This is the time of the last
921 change to the file's contents.
922 6. Last status change time, likewise. This is the time of last change
923 to the file's attributes: owner and group, access mode bits, etc.
925 This is a floating point number if the size is too large for an integer.
926 8. File modes, as a string of ten letters or dashes as in ls -l.
927 9. t if file's gid would change if file were deleted and recreated.
928 10. inode number. If inode number is larger than what Emacs integer
929 can hold, but still fits into a 32-bit number, this is a cons cell
930 containing two integers: first the high part, then the low 16 bits.
931 If the inode number is wider than 32 bits, this is of the form
932 (HIGH MIDDLE . LOW): first the high 24 bits, then middle 24 bits,
933 and finally the low 16 bits.
934 11. Filesystem device number. If it is larger than what the Emacs
935 integer can hold, this is a cons cell, similar to the inode number.
937 On most filesystems, the combination of the inode and the device
938 number uniquely identifies the file.
940 On MS-Windows, performance depends on `w32-get-true-file-attributes',
943 On some FAT-based filesystems, only the date of last access is recorded,
944 so last access time will always be midnight of that day. */)
945 (Lisp_Object filename
, Lisp_Object id_format
)
947 Lisp_Object values
[12];
957 char *uname
= NULL
, *gname
= NULL
;
959 filename
= Fexpand_file_name (filename
, Qnil
);
961 /* If the file name has special constructs in it,
962 call the corresponding file handler. */
963 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
965 { /* Only pass the extra arg if it is used to help backward compatibility
966 with old file handlers which do not implement the new arg. --Stef */
967 if (NILP (id_format
))
968 return call2 (handler
, Qfile_attributes
, filename
);
970 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
974 encoded
= ENCODE_FILE (filename
);
977 if (lstat (SDATA (encoded
), &s
) < 0)
980 switch (s
.st_mode
& S_IFMT
)
983 values
[0] = Qnil
; break;
985 values
[0] = Qt
; break;
988 values
[0] = Ffile_symlink_p (filename
); break;
991 values
[1] = make_number (s
.st_nlink
);
993 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
996 uname
= stat_uname (&s
);
997 gname
= stat_gname (&s
);
1001 values
[2] = DECODE_SYSTEM (build_string (uname
));
1003 values
[2] = make_fixnum_or_float (s
.st_uid
);
1005 values
[3] = DECODE_SYSTEM (build_string (gname
));
1007 values
[3] = make_fixnum_or_float (s
.st_gid
);
1009 values
[4] = make_time (s
.st_atime
);
1010 values
[5] = make_time (s
.st_mtime
);
1011 values
[6] = make_time (s
.st_ctime
);
1012 values
[7] = make_fixnum_or_float (s
.st_size
);
1013 /* If the size is negative, and its type is long, convert it back to
1015 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
1016 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
1018 filemodestring (&s
, modes
);
1019 values
[8] = make_string (modes
, 10);
1020 #ifdef BSD4_2 /* file gid will be dir gid */
1021 dirname
= Ffile_name_directory (filename
);
1022 if (! NILP (dirname
))
1023 encoded
= ENCODE_FILE (dirname
);
1024 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
1025 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
1026 else /* if we can't tell, assume worst */
1028 #else /* file gid will be egid */
1029 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1030 #endif /* not BSD4_2 */
1031 if (!FIXNUM_OVERFLOW_P (s
.st_ino
))
1032 /* Keep the most common cases as integers. */
1033 values
[10] = make_number (s
.st_ino
);
1034 else if (!FIXNUM_OVERFLOW_P (s
.st_ino
>> 16))
1035 /* To allow inode numbers larger than VALBITS, separate the bottom
1037 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1038 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1041 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1042 high parts and a 16-bit bottom part.
1043 The code on the next line avoids a compiler warning on
1044 systems where st_ino is 32 bit wide. (bug#766). */
1045 EMACS_INT high_ino
= s
.st_ino
>> 31 >> 1;
1046 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1048 values
[10] = Fcons (make_number (high_ino
>> 8),
1049 Fcons (make_number (((high_ino
& 0xff) << 16)
1051 make_number (low_ino
& 0xffff)));
1054 /* Likewise for device. */
1055 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1056 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1057 make_number (s
.st_dev
& 0xffff));
1059 values
[11] = make_number (s
.st_dev
);
1061 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1064 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1065 doc
: /* Return t if first arg file attributes list is less than second.
1066 Comparison is in lexicographic order and case is significant. */)
1067 (Lisp_Object f1
, Lisp_Object f2
)
1069 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1073 syms_of_dired (void)
1075 Qdirectory_files
= intern_c_string ("directory-files");
1076 Qdirectory_files_and_attributes
= intern_c_string ("directory-files-and-attributes");
1077 Qfile_name_completion
= intern_c_string ("file-name-completion");
1078 Qfile_name_all_completions
= intern_c_string ("file-name-all-completions");
1079 Qfile_attributes
= intern_c_string ("file-attributes");
1080 Qfile_attributes_lessp
= intern_c_string ("file-attributes-lessp");
1081 Qdefault_directory
= intern_c_string ("default-directory");
1083 staticpro (&Qdirectory_files
);
1084 staticpro (&Qdirectory_files_and_attributes
);
1085 staticpro (&Qfile_name_completion
);
1086 staticpro (&Qfile_name_all_completions
);
1087 staticpro (&Qfile_attributes
);
1088 staticpro (&Qfile_attributes_lessp
);
1089 staticpro (&Qdefault_directory
);
1091 defsubr (&Sdirectory_files
);
1092 defsubr (&Sdirectory_files_and_attributes
);
1093 defsubr (&Sfile_name_completion
);
1094 defsubr (&Sfile_name_all_completions
);
1095 defsubr (&Sfile_attributes
);
1096 defsubr (&Sfile_attributes_lessp
);
1098 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1099 doc
: /* Completion ignores file names ending in any string in this list.
1100 It does not ignore them if all possible completions end in one of
1101 these strings or when displaying a list of completions.
1102 It ignores directory names if they match any string in this list which
1103 ends in a slash. */);
1104 Vcompletion_ignored_extensions
= Qnil
;
1107 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1108 (do not change this comment) */