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 Lisp_Object Qdirectory_files
;
97 Lisp_Object Qdirectory_files_and_attributes
;
98 Lisp_Object Qfile_name_completion
;
99 Lisp_Object Qfile_name_all_completions
;
100 Lisp_Object Qfile_attributes
;
101 Lisp_Object Qfile_attributes_lessp
;
103 static int scmp (const unsigned char *, const unsigned char *, int);
107 directory_files_internal_w32_unwind (Lisp_Object arg
)
109 Vw32_get_true_file_attributes
= arg
;
115 directory_files_internal_unwind (Lisp_Object dh
)
117 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
124 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
125 When ATTRS is zero, return a list of directory filenames; when
126 non-zero, return a list of directory filenames and their attributes.
127 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
130 directory_files_internal (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, int attrs
, Lisp_Object id_format
)
133 int directory_nbytes
;
134 Lisp_Object list
, dirfilename
, encoded_directory
;
135 struct re_pattern_buffer
*bufp
= NULL
;
137 int count
= SPECPDL_INDEX ();
138 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
141 Lisp_Object w32_save
= Qnil
;
144 /* Because of file name handlers, these functions might call
145 Ffuncall, and cause a GC. */
146 list
= encoded_directory
= dirfilename
= Qnil
;
147 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
148 dirfilename
= Fdirectory_file_name (directory
);
152 CHECK_STRING (match
);
154 /* MATCH might be a flawed regular expression. Rather than
155 catching and signaling our own errors, we just call
156 compile_pattern to do the work for us. */
157 /* Pass 1 for the MULTIBYTE arg
158 because we do make multibyte strings if the contents warrant. */
160 /* Windows users want case-insensitive wildcards. */
161 bufp
= compile_pattern (match
, 0,
162 buffer_defaults
.case_canon_table
, 0, 1);
163 # else /* !WINDOWSNT */
164 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
165 # endif /* !WINDOWSNT */
168 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
169 run_pre_post_conversion_on_str which calls Lisp directly and
171 if (STRING_MULTIBYTE (dirfilename
))
172 dirfilename
= ENCODE_FILE (dirfilename
);
173 encoded_directory
= (STRING_MULTIBYTE (directory
)
174 ? ENCODE_FILE (directory
) : directory
);
176 /* Now *bufp is the compiled form of MATCH; don't call anything
177 which might compile a new regexp until we're done with the loop! */
180 d
= opendir (SDATA (dirfilename
));
183 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
185 /* Unfortunately, we can now invoke expand-file-name and
186 file-attributes on filenames, both of which can throw, so we must
187 do a proper unwind-protect. */
188 record_unwind_protect (directory_files_internal_unwind
,
189 make_save_value (d
, 0));
194 extern int is_slow_fs (const char *);
196 /* Do this only once to avoid doing it (in w32.c:stat) for each
197 file in the directory, when we call Ffile_attributes below. */
198 record_unwind_protect (directory_files_internal_w32_unwind
,
199 Vw32_get_true_file_attributes
);
200 w32_save
= Vw32_get_true_file_attributes
;
201 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
203 /* w32.c:stat will notice these bindings and avoid calling
204 GetDriveType for each file. */
205 if (is_slow_fs (SDATA (dirfilename
)))
206 Vw32_get_true_file_attributes
= Qnil
;
208 Vw32_get_true_file_attributes
= Qt
;
213 directory_nbytes
= SBYTES (directory
);
214 re_match_object
= Qt
;
216 /* Decide whether we need to add a directory separator. */
217 if (directory_nbytes
== 0
218 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
221 /* Loop reading blocks until EOF or error. */
240 if (DIRENTRY_NONEMPTY (dp
))
244 Lisp_Object name
, finalname
;
245 struct gcpro gcpro1
, gcpro2
;
248 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
249 GCPRO2 (finalname
, name
);
251 /* Note: DECODE_FILE can GC; it should protect its argument,
253 name
= DECODE_FILE (name
);
256 /* Now that we have unwind_protect in place, we might as well
257 allow matching to be interrupted. */
262 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
271 Lisp_Object fullname
;
272 int nbytes
= len
+ directory_nbytes
+ needsep
;
275 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
276 memcpy (SDATA (fullname
), SDATA (directory
),
280 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
282 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
285 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
287 /* Some bug somewhere. */
291 STRING_SET_CHARS (fullname
, nchars
);
292 if (nchars
== nbytes
)
293 STRING_SET_UNIBYTE (fullname
);
295 finalname
= fullname
;
302 /* Construct an expanded filename for the directory entry.
303 Use the decoded names for input to Ffile_attributes. */
304 Lisp_Object decoded_fullname
, fileattrs
;
305 struct gcpro gcpro1
, gcpro2
;
307 decoded_fullname
= fileattrs
= Qnil
;
308 GCPRO2 (decoded_fullname
, fileattrs
);
310 /* Both Fexpand_file_name and Ffile_attributes can GC. */
311 decoded_fullname
= Fexpand_file_name (name
, directory
);
312 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
314 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
318 list
= Fcons (finalname
, list
);
330 Vw32_get_true_file_attributes
= w32_save
;
333 /* Discard the unwind protect. */
334 specpdl_ptr
= specpdl
+ count
;
337 list
= Fsort (Fnreverse (list
),
338 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
340 RETURN_UNGCPRO (list
);
344 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
345 doc
: /* Return a list of names of files in DIRECTORY.
346 There are three optional arguments:
347 If FULL is non-nil, return absolute file names. Otherwise return names
348 that are relative to the specified directory.
349 If MATCH is non-nil, mention only file names that match the regexp MATCH.
350 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
351 Otherwise, the list returned is sorted with `string-lessp'.
352 NOSORT is useful if you plan to sort the result yourself. */)
353 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
356 directory
= Fexpand_file_name (directory
, Qnil
);
358 /* If the file name has special constructs in it,
359 call the corresponding file handler. */
360 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
362 return call5 (handler
, Qdirectory_files
, directory
,
363 full
, match
, nosort
);
365 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
368 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
369 Sdirectory_files_and_attributes
, 1, 5, 0,
370 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
371 There are four optional arguments:
372 If FULL is non-nil, return absolute file names. Otherwise return names
373 that are relative to the specified directory.
374 If MATCH is non-nil, mention only file names that match the regexp MATCH.
375 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
376 NOSORT is useful if you plan to sort the result yourself.
377 ID-FORMAT specifies the preferred format of attributes uid and gid, see
378 `file-attributes' for further documentation.
379 On MS-Windows, performance depends on `w32-get-true-file-attributes',
381 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
384 directory
= Fexpand_file_name (directory
, Qnil
);
386 /* If the file name has special constructs in it,
387 call the corresponding file handler. */
388 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
390 return call6 (handler
, Qdirectory_files_and_attributes
,
391 directory
, full
, match
, nosort
, id_format
);
393 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
397 Lisp_Object
file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
);
399 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
401 doc
: /* Complete file name FILE in directory DIRECTORY.
402 Returns the longest string
403 common to all file names in DIRECTORY that start with FILE.
404 If there is only one and FILE matches it exactly, returns t.
405 Returns nil if DIRECTORY contains no name starting with FILE.
407 If PREDICATE is non-nil, call PREDICATE with each possible
408 completion (in absolute form) and ignore it if PREDICATE returns nil.
410 This function ignores some of the possible completions as
411 determined by the variable `completion-ignored-extensions', which see. */)
412 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
416 /* If the directory name has special constructs in it,
417 call the corresponding file handler. */
418 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
420 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
422 /* If the file name has special constructs in it,
423 call the corresponding file handler. */
424 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
426 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
428 return file_name_completion (file
, directory
, 0, 0, predicate
);
431 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
432 Sfile_name_all_completions
, 2, 2, 0,
433 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
434 These are all file names in directory DIRECTORY which begin with FILE. */)
435 (Lisp_Object file
, Lisp_Object directory
)
439 /* If the directory name has special constructs in it,
440 call the corresponding file handler. */
441 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
443 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
445 /* If the file name has special constructs in it,
446 call the corresponding file handler. */
447 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
449 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
451 return file_name_completion (file
, directory
, 1, 0, Qnil
);
454 static int file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
);
455 Lisp_Object Qdefault_directory
;
458 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
)
461 int bestmatchsize
= 0;
463 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
464 If ALL_FLAG is 0, BESTMATCH is either nil
465 or the best match so far, not decoded. */
466 Lisp_Object bestmatch
, tem
, elt
, name
;
467 Lisp_Object encoded_file
;
468 Lisp_Object encoded_dir
;
471 /* If includeall is zero, exclude files in completion-ignored-extensions as
472 well as "." and "..". Until shown otherwise, assume we can't exclude
475 int count
= SPECPDL_INDEX ();
476 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
482 #ifdef FILE_SYSTEM_CASE
483 file
= FILE_SYSTEM_CASE (file
);
486 encoded_file
= encoded_dir
= Qnil
;
487 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
488 dirname
= Fexpand_file_name (dirname
, Qnil
);
489 specbind (Qdefault_directory
, dirname
);
491 /* Do completion on the encoded file name
492 because the other names in the directory are (we presume)
493 encoded likewise. We decode the completed string at the end. */
494 /* Actually, this is not quite true any more: we do most of the completion
495 work with decoded file names, but we still do some filtering based
496 on the encoded file name. */
497 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
499 encoded_dir
= ENCODE_FILE (dirname
);
502 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
505 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
507 record_unwind_protect (directory_files_internal_unwind
,
508 make_save_value (d
, 0));
510 /* Loop reading blocks */
511 /* (att3b compiler bug requires do a null comparison this way) */
535 if (! DIRENTRY_NONEMPTY (dp
)
536 || len
< SCHARS (encoded_file
)
537 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
538 SCHARS (encoded_file
)))
541 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
544 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
546 /* If all_flag is set, always include all.
547 It would not actually be helpful to the user to ignore any possible
548 completions when making a list of them. */
553 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
554 /* If this entry matches the current bestmatch, the only
555 thing it can do is increase matchcount, so don't bother
556 investigating it any further. */
557 if (!completion_ignore_case
558 /* The return result depends on whether it's the sole match. */
560 && !includeall
/* This match may allow includeall to 0. */
561 && len
>= bestmatchsize
562 && 0 > scmp (dp
->d_name
, SDATA (bestmatch
), bestmatchsize
))
568 #ifndef TRIVIAL_DIRECTORY_ENTRY
569 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
571 /* "." and ".." are never interesting as completions, and are
572 actually in the way in a directory with only one file. */
573 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
575 else if (len
> SCHARS (encoded_file
))
576 /* Ignore directories if they match an element of
577 completion-ignored-extensions which ends in a slash. */
578 for (tem
= Vcompletion_ignored_extensions
;
579 CONSP (tem
); tem
= XCDR (tem
))
587 /* Need to encode ELT, since scmp compares unibyte
589 elt
= ENCODE_FILE (elt
);
590 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
594 if (p1
[elt_len
] != '/')
596 skip
= len
- elt_len
;
600 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
607 /* Compare extensions-to-be-ignored against end of this file name */
608 /* if name is not an exact match against specified string */
609 if (len
> SCHARS (encoded_file
))
610 /* and exit this for loop if a match is found */
611 for (tem
= Vcompletion_ignored_extensions
;
612 CONSP (tem
); tem
= XCDR (tem
))
615 if (!STRINGP (elt
)) continue;
616 /* Need to encode ELT, since scmp compares unibyte
618 elt
= ENCODE_FILE (elt
);
619 skip
= len
- SCHARS (elt
);
620 if (skip
< 0) continue;
622 if (0 <= scmp (dp
->d_name
+ skip
,
630 /* If an ignored-extensions match was found,
631 don't process this name as a completion. */
635 if (!includeall
&& canexclude
)
636 /* We're not including all files and this file can be excluded. */
639 if (includeall
&& !canexclude
)
640 { /* If we have one non-excludable file, we want to exclude the
643 /* Throw away any previous excludable match found. */
649 /* FIXME: If we move this `decode' earlier we can eliminate
650 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
651 name
= make_unibyte_string (dp
->d_name
, len
);
652 name
= DECODE_FILE (name
);
657 XSETFASTINT (zero
, 0);
659 /* Ignore this element if it fails to match all the regexps. */
660 if (completion_ignore_case
)
662 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
663 regexps
= XCDR (regexps
))
664 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
669 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
670 regexps
= XCDR (regexps
))
671 if (fast_string_match (XCAR (regexps
), name
) < 0)
679 /* This is a possible completion */
681 /* This completion is a directory; make it end with '/'. */
682 name
= Ffile_name_as_directory (name
);
684 /* Test the predicate, if any. */
685 if (!NILP (predicate
))
691 val
= call1 (predicate
, name
);
698 /* Suitably record this match. */
703 bestmatch
= Fcons (name
, bestmatch
);
704 else if (NILP (bestmatch
))
707 bestmatchsize
= SCHARS (name
);
711 Lisp_Object zero
= make_number (0);
712 /* FIXME: This is a copy of the code in Ftry_completion. */
713 int compare
= min (bestmatchsize
, SCHARS (name
));
715 = Fcompare_strings (bestmatch
, zero
,
716 make_number (compare
),
718 make_number (compare
),
719 completion_ignore_case
? Qt
: Qnil
);
721 = (EQ (tem
, Qt
) ? compare
722 : XINT (tem
) < 0 ? - XINT (tem
) - 1
725 if (completion_ignore_case
)
727 /* If this is an exact match except for case,
728 use it as the best match rather than one that is not
729 an exact match. This way, we get the case pattern
730 of the actual match. */
731 /* This tests that the current file is an exact match
732 but BESTMATCH is not (it is too long). */
733 if ((matchsize
== SCHARS (name
)
734 && matchsize
+ !!directoryp
< SCHARS (bestmatch
))
736 /* If there is no exact match ignoring case,
737 prefer a match that does not change the case
739 /* If there is more than one exact match aside from
740 case, and one of them is exact including case,
742 /* This == checks that, of current file and BESTMATCH,
743 either both or neither are exact. */
744 (((matchsize
== SCHARS (name
))
746 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
747 && (tem
= Fcompare_strings (name
, zero
,
748 make_number (SCHARS (file
)),
753 && (tem
= Fcompare_strings (bestmatch
, zero
,
754 make_number (SCHARS (file
)),
761 bestmatchsize
= matchsize
;
763 /* If the best completion so far is reduced to the string
764 we're trying to complete, then we already know there's no
765 other completion, so there's no point looking any further. */
766 if (matchsize
<= SCHARS (file
)
767 && !includeall
/* A future match may allow includeall to 0. */
768 /* If completion-ignore-case is non-nil, don't
769 short-circuit because we want to find the best
770 possible match *including* case differences. */
771 && (!completion_ignore_case
|| matchsize
== 0)
772 /* The return value depends on whether it's the sole match. */
780 /* This closes the directory. */
781 bestmatch
= unbind_to (count
, bestmatch
);
783 if (all_flag
|| NILP (bestmatch
))
785 /* Return t if the supplied string is an exact match (counting case);
786 it does not require any change to be made. */
787 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
789 bestmatch
= Fsubstring (bestmatch
, make_number (0),
790 make_number (bestmatchsize
));
794 /* Compare exactly LEN chars of strings at S1 and S2,
795 ignoring case if appropriate.
796 Return -1 if strings match,
797 else number of chars that match at the beginning. */
800 scmp (const unsigned char *s1
, const unsigned char *s2
, int len
)
802 register int l
= len
;
804 if (completion_ignore_case
)
806 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
811 while (l
&& *s1
++ == *s2
++)
821 file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
)
823 int len
= NAMLEN (dp
);
824 int pos
= SCHARS (dirname
);
826 char *fullname
= (char *) alloca (len
+ pos
+ 2);
829 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
830 but aren't required here. Avoid computing the following fields:
831 st_inode, st_size and st_nlink for directories, and the execute bits
832 in st_mode for non-directory files with non-standard extensions. */
834 unsigned short save_djstat_flags
= _djstat_flags
;
836 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
839 memcpy (fullname
, SDATA (dirname
), pos
);
840 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
841 fullname
[pos
++] = DIRECTORY_SEP
;
843 memcpy (fullname
+ pos
, dp
->d_name
, len
);
844 fullname
[pos
+ len
] = 0;
847 /* We want to return success if a link points to a nonexistent file,
848 but we want to return the status for what the link points to,
849 in case it is a directory. */
850 value
= lstat (fullname
, st_addr
);
851 stat (fullname
, st_addr
);
854 value
= stat (fullname
, st_addr
);
856 _djstat_flags
= save_djstat_flags
;
863 make_time (time_t time
)
865 return Fcons (make_number (time
>> 16),
866 Fcons (make_number (time
& 0177777), Qnil
));
870 stat_uname (struct stat
*st
)
875 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
885 stat_gname (struct stat
*st
)
890 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
899 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
900 doc
: /* Return a list of attributes of file FILENAME.
901 Value is nil if specified file cannot be opened.
903 ID-FORMAT specifies the preferred format of attributes uid and gid (see
904 below) - valid values are 'string and 'integer. The latter is the
905 default, but we plan to change that, so you should specify a non-nil value
906 for ID-FORMAT if you use the returned uid or gid.
908 Elements of the attribute list are:
909 0. t for directory, string (name linked to) for symbolic link, or nil.
910 1. Number of links to file.
911 2. File uid as a string or a number. If a string value cannot be
912 looked up, a numeric value, either an integer or a float, is returned.
913 3. File gid, likewise.
914 4. Last access time, as a list of two integers.
915 First integer has high-order 16 bits of time, second has low 16 bits.
916 (See a note below about access time on FAT-based filesystems.)
917 5. Last modification time, likewise. This is the time of the last
918 change to the file's contents.
919 6. Last status change time, likewise. This is the time of last change
920 to the file's attributes: owner and group, access mode bits, etc.
922 This is a floating point number if the size is too large for an integer.
923 8. File modes, as a string of ten letters or dashes as in ls -l.
924 9. t if file's gid would change if file were deleted and recreated.
925 10. inode number. If inode number is larger than what Emacs integer
926 can hold, but still fits into a 32-bit number, this is a cons cell
927 containing two integers: first the high part, then the low 16 bits.
928 If the inode number is wider than 32 bits, this is of the form
929 (HIGH MIDDLE . LOW): first the high 24 bits, then middle 24 bits,
930 and finally the low 16 bits.
931 11. Filesystem device number. If it is larger than what the Emacs
932 integer can hold, this is a cons cell, similar to the inode number.
934 On most filesystems, the combination of the inode and the device
935 number uniquely identifies the file.
937 On MS-Windows, performance depends on `w32-get-true-file-attributes',
940 On some FAT-based filesystems, only the date of last access is recorded,
941 so last access time will always be midnight of that day. */)
942 (Lisp_Object filename
, Lisp_Object id_format
)
944 Lisp_Object values
[12];
954 char *uname
= NULL
, *gname
= NULL
;
956 filename
= Fexpand_file_name (filename
, Qnil
);
958 /* If the file name has special constructs in it,
959 call the corresponding file handler. */
960 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
962 { /* Only pass the extra arg if it is used to help backward compatibility
963 with old file handlers which do not implement the new arg. --Stef */
964 if (NILP (id_format
))
965 return call2 (handler
, Qfile_attributes
, filename
);
967 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
971 encoded
= ENCODE_FILE (filename
);
974 if (lstat (SDATA (encoded
), &s
) < 0)
977 switch (s
.st_mode
& S_IFMT
)
980 values
[0] = Qnil
; break;
982 values
[0] = Qt
; break;
985 values
[0] = Ffile_symlink_p (filename
); break;
988 values
[1] = make_number (s
.st_nlink
);
990 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
993 uname
= stat_uname (&s
);
994 gname
= stat_gname (&s
);
998 values
[2] = DECODE_SYSTEM (build_string (uname
));
1000 values
[2] = make_fixnum_or_float (s
.st_uid
);
1002 values
[3] = DECODE_SYSTEM (build_string (gname
));
1004 values
[3] = make_fixnum_or_float (s
.st_gid
);
1006 values
[4] = make_time (s
.st_atime
);
1007 values
[5] = make_time (s
.st_mtime
);
1008 values
[6] = make_time (s
.st_ctime
);
1009 values
[7] = make_fixnum_or_float (s
.st_size
);
1010 /* If the size is negative, and its type is long, convert it back to
1012 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
1013 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
1015 filemodestring (&s
, modes
);
1016 values
[8] = make_string (modes
, 10);
1017 #ifdef BSD4_2 /* file gid will be dir gid */
1018 dirname
= Ffile_name_directory (filename
);
1019 if (! NILP (dirname
))
1020 encoded
= ENCODE_FILE (dirname
);
1021 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
1022 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
1023 else /* if we can't tell, assume worst */
1025 #else /* file gid will be egid */
1026 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1027 #endif /* not BSD4_2 */
1028 if (!FIXNUM_OVERFLOW_P (s
.st_ino
))
1029 /* Keep the most common cases as integers. */
1030 values
[10] = make_number (s
.st_ino
);
1031 else if (!FIXNUM_OVERFLOW_P (s
.st_ino
>> 16))
1032 /* To allow inode numbers larger than VALBITS, separate the bottom
1034 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1035 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1038 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1039 high parts and a 16-bit bottom part.
1040 The code on the next line avoids a compiler warning on
1041 systems where st_ino is 32 bit wide. (bug#766). */
1042 EMACS_INT high_ino
= s
.st_ino
>> 31 >> 1;
1043 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1045 values
[10] = Fcons (make_number (high_ino
>> 8),
1046 Fcons (make_number (((high_ino
& 0xff) << 16)
1048 make_number (low_ino
& 0xffff)));
1051 /* Likewise for device. */
1052 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1053 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1054 make_number (s
.st_dev
& 0xffff));
1056 values
[11] = make_number (s
.st_dev
);
1058 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1061 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1062 doc
: /* Return t if first arg file attributes list is less than second.
1063 Comparison is in lexicographic order and case is significant. */)
1064 (Lisp_Object f1
, Lisp_Object f2
)
1066 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1070 syms_of_dired (void)
1072 Qdirectory_files
= intern_c_string ("directory-files");
1073 Qdirectory_files_and_attributes
= intern_c_string ("directory-files-and-attributes");
1074 Qfile_name_completion
= intern_c_string ("file-name-completion");
1075 Qfile_name_all_completions
= intern_c_string ("file-name-all-completions");
1076 Qfile_attributes
= intern_c_string ("file-attributes");
1077 Qfile_attributes_lessp
= intern_c_string ("file-attributes-lessp");
1078 Qdefault_directory
= intern_c_string ("default-directory");
1080 staticpro (&Qdirectory_files
);
1081 staticpro (&Qdirectory_files_and_attributes
);
1082 staticpro (&Qfile_name_completion
);
1083 staticpro (&Qfile_name_all_completions
);
1084 staticpro (&Qfile_attributes
);
1085 staticpro (&Qfile_attributes_lessp
);
1086 staticpro (&Qdefault_directory
);
1088 defsubr (&Sdirectory_files
);
1089 defsubr (&Sdirectory_files_and_attributes
);
1090 defsubr (&Sfile_name_completion
);
1091 defsubr (&Sfile_name_all_completions
);
1092 defsubr (&Sfile_attributes
);
1093 defsubr (&Sfile_attributes_lessp
);
1095 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1096 doc
: /* Completion ignores file names ending in any string in this list.
1097 It does not ignore them if all possible completions end in one of
1098 these strings or when displaying a list of completions.
1099 It ignores directory names if they match any string in this list which
1100 ends in a slash. */);
1101 Vcompletion_ignored_extensions
= Qnil
;