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 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>
39 /* The d_nameln member of a struct dirent includes the '\0' character
40 on some systems, but not on others. What's worse, you can't tell
41 at compile-time which one it will be, since it really depends on
42 the sort of system providing the filesystem you're reading from,
43 not the system you are running on. Paul Eggert
44 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
45 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
46 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
48 Since applying strlen to the name always works, we'll just do that. */
49 #define NAMLEN(p) strlen (p->d_name)
51 #ifdef SYSV_SYSTEM_DIR
54 #define DIRENTRY struct dirent
56 #else /* not SYSV_SYSTEM_DIR */
67 #define DIRENTRY struct direct
69 extern DIR *opendir (char *);
70 extern struct direct
*readdir (DIR *);
72 #endif /* not MSDOS */
73 #endif /* not SYSV_SYSTEM_DIR */
75 /* Some versions of Cygwin don't have d_ino in `struct dirent'. */
76 #if defined(MSDOS) || defined(__CYGWIN__)
77 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
79 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
86 #include "character.h"
90 #include "blockinput.h"
92 /* Returns a search buffer, with a fastmap allocated and ready to go. */
93 extern struct re_pattern_buffer
*compile_pattern (Lisp_Object
, struct re_registers
*, Lisp_Object
, int, int);
95 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
96 extern void filemodestring (struct stat
*, char *);
98 /* if system does not have symbolic links, it does not have lstat.
99 In that case, use ordinary stat instead. */
105 extern int completion_ignore_case
;
106 extern Lisp_Object Qcompletion_ignore_case
;
107 extern Lisp_Object Vcompletion_regexp_list
;
108 extern Lisp_Object Vw32_get_true_file_attributes
;
110 Lisp_Object Vcompletion_ignored_extensions
;
111 Lisp_Object Qdirectory_files
;
112 Lisp_Object Qdirectory_files_and_attributes
;
113 Lisp_Object Qfile_name_completion
;
114 Lisp_Object Qfile_name_all_completions
;
115 Lisp_Object Qfile_attributes
;
116 Lisp_Object Qfile_attributes_lessp
;
118 static int scmp (unsigned char *, unsigned char *, int);
122 directory_files_internal_w32_unwind (Lisp_Object arg
)
124 Vw32_get_true_file_attributes
= arg
;
130 directory_files_internal_unwind (Lisp_Object dh
)
132 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
139 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
140 When ATTRS is zero, return a list of directory filenames; when
141 non-zero, return a list of directory filenames and their attributes.
142 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
145 directory_files_internal (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, int attrs
, Lisp_Object id_format
)
148 int directory_nbytes
;
149 Lisp_Object list
, dirfilename
, encoded_directory
;
150 struct re_pattern_buffer
*bufp
= NULL
;
152 int count
= SPECPDL_INDEX ();
153 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
156 Lisp_Object w32_save
= Qnil
;
159 /* Because of file name handlers, these functions might call
160 Ffuncall, and cause a GC. */
161 list
= encoded_directory
= dirfilename
= Qnil
;
162 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
163 dirfilename
= Fdirectory_file_name (directory
);
167 CHECK_STRING (match
);
169 /* MATCH might be a flawed regular expression. Rather than
170 catching and signaling our own errors, we just call
171 compile_pattern to do the work for us. */
172 /* Pass 1 for the MULTIBYTE arg
173 because we do make multibyte strings if the contents warrant. */
175 /* Windows users want case-insensitive wildcards. */
176 bufp
= compile_pattern (match
, 0,
177 buffer_defaults
.case_canon_table
, 0, 1);
178 # else /* !WINDOWSNT */
179 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
180 # endif /* !WINDOWSNT */
183 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
184 run_pre_post_conversion_on_str which calls Lisp directly and
186 if (STRING_MULTIBYTE (dirfilename
))
187 dirfilename
= ENCODE_FILE (dirfilename
);
188 encoded_directory
= (STRING_MULTIBYTE (directory
)
189 ? ENCODE_FILE (directory
) : directory
);
191 /* Now *bufp is the compiled form of MATCH; don't call anything
192 which might compile a new regexp until we're done with the loop! */
195 d
= opendir (SDATA (dirfilename
));
198 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
200 /* Unfortunately, we can now invoke expand-file-name and
201 file-attributes on filenames, both of which can throw, so we must
202 do a proper unwind-protect. */
203 record_unwind_protect (directory_files_internal_unwind
,
204 make_save_value (d
, 0));
209 extern Lisp_Object Qlocal
;
210 extern int is_slow_fs (const char *);
212 /* Do this only once to avoid doing it (in w32.c:stat) for each
213 file in the directory, when we call Ffile_attributes below. */
214 record_unwind_protect (directory_files_internal_w32_unwind
,
215 Vw32_get_true_file_attributes
);
216 w32_save
= Vw32_get_true_file_attributes
;
217 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
219 /* w32.c:stat will notice these bindings and avoid calling
220 GetDriveType for each file. */
221 if (is_slow_fs (SDATA (dirfilename
)))
222 Vw32_get_true_file_attributes
= Qnil
;
224 Vw32_get_true_file_attributes
= Qt
;
229 directory_nbytes
= SBYTES (directory
);
230 re_match_object
= Qt
;
232 /* Decide whether we need to add a directory separator. */
233 if (directory_nbytes
== 0
234 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
237 /* Loop reading blocks until EOF or error. */
256 if (DIRENTRY_NONEMPTY (dp
))
260 Lisp_Object name
, finalname
;
261 struct gcpro gcpro1
, gcpro2
;
264 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
265 GCPRO2 (finalname
, name
);
267 /* Note: DECODE_FILE can GC; it should protect its argument,
269 name
= DECODE_FILE (name
);
272 /* Now that we have unwind_protect in place, we might as well
273 allow matching to be interrupted. */
278 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
287 Lisp_Object fullname
;
288 int nbytes
= len
+ directory_nbytes
+ needsep
;
291 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
292 memcpy (SDATA (fullname
), SDATA (directory
),
296 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
298 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
301 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
303 /* Some bug somewhere. */
307 STRING_SET_CHARS (fullname
, nchars
);
308 if (nchars
== nbytes
)
309 STRING_SET_UNIBYTE (fullname
);
311 finalname
= fullname
;
318 /* Construct an expanded filename for the directory entry.
319 Use the decoded names for input to Ffile_attributes. */
320 Lisp_Object decoded_fullname
, fileattrs
;
321 struct gcpro gcpro1
, gcpro2
;
323 decoded_fullname
= fileattrs
= Qnil
;
324 GCPRO2 (decoded_fullname
, fileattrs
);
326 /* Both Fexpand_file_name and Ffile_attributes can GC. */
327 decoded_fullname
= Fexpand_file_name (name
, directory
);
328 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
330 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
334 list
= Fcons (finalname
, list
);
346 Vw32_get_true_file_attributes
= w32_save
;
349 /* Discard the unwind protect. */
350 specpdl_ptr
= specpdl
+ count
;
353 list
= Fsort (Fnreverse (list
),
354 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
356 RETURN_UNGCPRO (list
);
360 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
361 doc
: /* Return a list of names of files in DIRECTORY.
362 There are three optional arguments:
363 If FULL is non-nil, return absolute file names. Otherwise return names
364 that are relative to the specified directory.
365 If MATCH is non-nil, mention only file names that match the regexp MATCH.
366 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
367 Otherwise, the list returned is sorted with `string-lessp'.
368 NOSORT is useful if you plan to sort the result yourself. */)
369 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
372 directory
= Fexpand_file_name (directory
, Qnil
);
374 /* If the file name has special constructs in it,
375 call the corresponding file handler. */
376 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
378 return call5 (handler
, Qdirectory_files
, directory
,
379 full
, match
, nosort
);
381 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
384 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
385 Sdirectory_files_and_attributes
, 1, 5, 0,
386 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
387 There are four optional arguments:
388 If FULL is non-nil, return absolute file names. Otherwise return names
389 that are relative to the specified directory.
390 If MATCH is non-nil, mention only file names that match the regexp MATCH.
391 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
392 NOSORT is useful if you plan to sort the result yourself.
393 ID-FORMAT specifies the preferred format of attributes uid and gid, see
394 `file-attributes' for further documentation.
395 On MS-Windows, performance depends on `w32-get-true-file-attributes',
397 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
400 directory
= Fexpand_file_name (directory
, Qnil
);
402 /* If the file name has special constructs in it,
403 call the corresponding file handler. */
404 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
406 return call6 (handler
, Qdirectory_files_and_attributes
,
407 directory
, full
, match
, nosort
, id_format
);
409 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
413 Lisp_Object
file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
);
415 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
417 doc
: /* Complete file name FILE in directory DIRECTORY.
418 Returns the longest string
419 common to all file names in DIRECTORY that start with FILE.
420 If there is only one and FILE matches it exactly, returns t.
421 Returns nil if DIRECTORY contains no name starting with FILE.
423 If PREDICATE is non-nil, call PREDICATE with each possible
424 completion (in absolute form) and ignore it if PREDICATE returns nil.
426 This function ignores some of the possible completions as
427 determined by the variable `completion-ignored-extensions', which see. */)
428 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
432 /* If the directory name has special constructs in it,
433 call the corresponding file handler. */
434 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
436 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
438 /* If the file name has special constructs in it,
439 call the corresponding file handler. */
440 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
442 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
444 return file_name_completion (file
, directory
, 0, 0, predicate
);
447 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
448 Sfile_name_all_completions
, 2, 2, 0,
449 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
450 These are all file names in directory DIRECTORY which begin with FILE. */)
451 (Lisp_Object file
, Lisp_Object directory
)
455 /* If the directory name has special constructs in it,
456 call the corresponding file handler. */
457 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
459 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
461 /* If the file name has special constructs in it,
462 call the corresponding file handler. */
463 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
465 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
467 return file_name_completion (file
, directory
, 1, 0, Qnil
);
470 static int file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
);
471 Lisp_Object Qdefault_directory
;
474 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
)
477 int bestmatchsize
= 0;
479 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
480 If ALL_FLAG is 0, BESTMATCH is either nil
481 or the best match so far, not decoded. */
482 Lisp_Object bestmatch
, tem
, elt
, name
;
483 Lisp_Object encoded_file
;
484 Lisp_Object encoded_dir
;
487 /* If includeall is zero, exclude files in completion-ignored-extensions as
488 well as "." and "..". Until shown otherwise, assume we can't exclude
491 int count
= SPECPDL_INDEX ();
492 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
498 #ifdef FILE_SYSTEM_CASE
499 file
= FILE_SYSTEM_CASE (file
);
502 encoded_file
= encoded_dir
= Qnil
;
503 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
504 dirname
= Fexpand_file_name (dirname
, Qnil
);
505 specbind (Qdefault_directory
, dirname
);
507 /* Do completion on the encoded file name
508 because the other names in the directory are (we presume)
509 encoded likewise. We decode the completed string at the end. */
510 /* Actually, this is not quite true any more: we do most of the completion
511 work with decoded file names, but we still do some filtering based
512 on the encoded file name. */
513 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
515 encoded_dir
= ENCODE_FILE (dirname
);
518 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
521 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
523 record_unwind_protect (directory_files_internal_unwind
,
524 make_save_value (d
, 0));
526 /* Loop reading blocks */
527 /* (att3b compiler bug requires do a null comparison this way) */
551 if (! DIRENTRY_NONEMPTY (dp
)
552 || len
< SCHARS (encoded_file
)
553 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
554 SCHARS (encoded_file
)))
557 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
560 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
562 /* If all_flag is set, always include all.
563 It would not actually be helpful to the user to ignore any possible
564 completions when making a list of them. */
569 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
570 /* If this entry matches the current bestmatch, the only
571 thing it can do is increase matchcount, so don't bother
572 investigating it any further. */
573 if (!completion_ignore_case
574 /* The return result depends on whether it's the sole match. */
576 && !includeall
/* This match may allow includeall to 0. */
577 && len
>= bestmatchsize
578 && 0 > scmp (dp
->d_name
, SDATA (bestmatch
), bestmatchsize
))
584 #ifndef TRIVIAL_DIRECTORY_ENTRY
585 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
587 /* "." and ".." are never interesting as completions, and are
588 actually in the way in a directory with only one file. */
589 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
591 else if (len
> SCHARS (encoded_file
))
592 /* Ignore directories if they match an element of
593 completion-ignored-extensions which ends in a slash. */
594 for (tem
= Vcompletion_ignored_extensions
;
595 CONSP (tem
); tem
= XCDR (tem
))
603 /* Need to encode ELT, since scmp compares unibyte
605 elt
= ENCODE_FILE (elt
);
606 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
610 if (p1
[elt_len
] != '/')
612 skip
= len
- elt_len
;
616 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
623 /* Compare extensions-to-be-ignored against end of this file name */
624 /* if name is not an exact match against specified string */
625 if (len
> SCHARS (encoded_file
))
626 /* and exit this for loop if a match is found */
627 for (tem
= Vcompletion_ignored_extensions
;
628 CONSP (tem
); tem
= XCDR (tem
))
631 if (!STRINGP (elt
)) continue;
632 /* Need to encode ELT, since scmp compares unibyte
634 elt
= ENCODE_FILE (elt
);
635 skip
= len
- SCHARS (elt
);
636 if (skip
< 0) continue;
638 if (0 <= scmp (dp
->d_name
+ skip
,
646 /* If an ignored-extensions match was found,
647 don't process this name as a completion. */
651 if (!includeall
&& canexclude
)
652 /* We're not including all files and this file can be excluded. */
655 if (includeall
&& !canexclude
)
656 { /* If we have one non-excludable file, we want to exclude the
659 /* Throw away any previous excludable match found. */
665 /* FIXME: If we move this `decode' earlier we can eliminate
666 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
667 name
= make_unibyte_string (dp
->d_name
, len
);
668 name
= DECODE_FILE (name
);
673 XSETFASTINT (zero
, 0);
675 /* Ignore this element if it fails to match all the regexps. */
676 if (completion_ignore_case
)
678 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
679 regexps
= XCDR (regexps
))
680 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
685 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
686 regexps
= XCDR (regexps
))
687 if (fast_string_match (XCAR (regexps
), name
) < 0)
695 /* This is a possible completion */
697 /* This completion is a directory; make it end with '/'. */
698 name
= Ffile_name_as_directory (name
);
700 /* Test the predicate, if any. */
701 if (!NILP (predicate
))
707 val
= call1 (predicate
, name
);
714 /* Suitably record this match. */
719 bestmatch
= Fcons (name
, bestmatch
);
720 else if (NILP (bestmatch
))
723 bestmatchsize
= SCHARS (name
);
727 Lisp_Object zero
= make_number (0);
728 /* FIXME: This is a copy of the code in Ftry_completion. */
729 int compare
= min (bestmatchsize
, SCHARS (name
));
731 = Fcompare_strings (bestmatch
, zero
,
732 make_number (compare
),
734 make_number (compare
),
735 completion_ignore_case
? Qt
: Qnil
);
737 = (EQ (tem
, Qt
) ? compare
738 : XINT (tem
) < 0 ? - XINT (tem
) - 1
741 if (completion_ignore_case
)
743 /* If this is an exact match except for case,
744 use it as the best match rather than one that is not
745 an exact match. This way, we get the case pattern
746 of the actual match. */
747 /* This tests that the current file is an exact match
748 but BESTMATCH is not (it is too long). */
749 if ((matchsize
== SCHARS (name
)
750 && matchsize
+ !!directoryp
< SCHARS (bestmatch
))
752 /* If there is no exact match ignoring case,
753 prefer a match that does not change the case
755 /* If there is more than one exact match aside from
756 case, and one of them is exact including case,
758 /* This == checks that, of current file and BESTMATCH,
759 either both or neither are exact. */
760 (((matchsize
== SCHARS (name
))
762 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
763 && (tem
= Fcompare_strings (name
, zero
,
764 make_number (SCHARS (file
)),
769 && (tem
= Fcompare_strings (bestmatch
, zero
,
770 make_number (SCHARS (file
)),
777 bestmatchsize
= matchsize
;
779 /* If the best completion so far is reduced to the string
780 we're trying to complete, then we already know there's no
781 other completion, so there's no point looking any further. */
782 if (matchsize
<= SCHARS (file
)
783 && !includeall
/* A future match may allow includeall to 0. */
784 /* If completion-ignore-case is non-nil, don't
785 short-circuit because we want to find the best
786 possible match *including* case differences. */
787 && (!completion_ignore_case
|| matchsize
== 0)
788 /* The return value depends on whether it's the sole match. */
796 /* This closes the directory. */
797 bestmatch
= unbind_to (count
, bestmatch
);
799 if (all_flag
|| NILP (bestmatch
))
801 /* Return t if the supplied string is an exact match (counting case);
802 it does not require any change to be made. */
803 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
805 bestmatch
= Fsubstring (bestmatch
, make_number (0),
806 make_number (bestmatchsize
));
810 /* Compare exactly LEN chars of strings at S1 and S2,
811 ignoring case if appropriate.
812 Return -1 if strings match,
813 else number of chars that match at the beginning. */
816 scmp (register unsigned char *s1
, register unsigned char *s2
, int len
)
818 register int l
= len
;
820 if (completion_ignore_case
)
822 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
827 while (l
&& *s1
++ == *s2
++)
837 file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
)
839 int len
= NAMLEN (dp
);
840 int pos
= SCHARS (dirname
);
842 char *fullname
= (char *) alloca (len
+ pos
+ 2);
845 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
846 but aren't required here. Avoid computing the following fields:
847 st_inode, st_size and st_nlink for directories, and the execute bits
848 in st_mode for non-directory files with non-standard extensions. */
850 unsigned short save_djstat_flags
= _djstat_flags
;
852 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
855 memcpy (fullname
, SDATA (dirname
), pos
);
856 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
857 fullname
[pos
++] = DIRECTORY_SEP
;
859 memcpy (fullname
+ pos
, dp
->d_name
, len
);
860 fullname
[pos
+ len
] = 0;
863 /* We want to return success if a link points to a nonexistent file,
864 but we want to return the status for what the link points to,
865 in case it is a directory. */
866 value
= lstat (fullname
, st_addr
);
867 stat (fullname
, st_addr
);
870 value
= stat (fullname
, st_addr
);
872 _djstat_flags
= save_djstat_flags
;
879 make_time (time_t time
)
881 return Fcons (make_number (time
>> 16),
882 Fcons (make_number (time
& 0177777), Qnil
));
886 stat_uname (struct stat
*st
)
891 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
901 stat_gname (struct stat
*st
)
906 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
915 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
916 doc
: /* Return a list of attributes of file FILENAME.
917 Value is nil if specified file cannot be opened.
919 ID-FORMAT specifies the preferred format of attributes uid and gid (see
920 below) - valid values are 'string and 'integer. The latter is the
921 default, but we plan to change that, so you should specify a non-nil value
922 for ID-FORMAT if you use the returned uid or gid.
924 Elements of the attribute list are:
925 0. t for directory, string (name linked to) for symbolic link, or nil.
926 1. Number of links to file.
927 2. File uid as a string or a number. If a string value cannot be
928 looked up, a numeric value, either an integer or a float, is returned.
929 3. File gid, likewise.
930 4. Last access time, as a list of two integers.
931 First integer has high-order 16 bits of time, second has low 16 bits.
932 (See a note below about access time on FAT-based filesystems.)
933 5. Last modification time, likewise. This is the time of the last
934 change to the file's contents.
935 6. Last status change time, likewise. This is the time of last change
936 to the file's attributes: owner and group, access mode bits, etc.
938 This is a floating point number if the size is too large for an integer.
939 8. File modes, as a string of ten letters or dashes as in ls -l.
940 9. t if file's gid would change if file were deleted and recreated.
941 10. inode number. If inode number is larger than what Emacs integer
942 can hold, but still fits into a 32-bit number, this is a cons cell
943 containing two integers: first the high part, then the low 16 bits.
944 If the inode number is wider than 32 bits, this is of the form
945 (HIGH MIDDLE . LOW): first the high 24 bits, then middle 24 bits,
946 and finally the low 16 bits.
947 11. Filesystem device number. If it is larger than what the Emacs
948 integer can hold, this is a cons cell, similar to the inode number.
950 On most filesystems, the combination of the inode and the device
951 number uniquely identifies the file.
953 On MS-Windows, performance depends on `w32-get-true-file-attributes',
956 On some FAT-based filesystems, only the date of last access is recorded,
957 so last access time will always be midnight of that day. */)
958 (Lisp_Object filename
, Lisp_Object id_format
)
960 Lisp_Object values
[12];
970 char *uname
= NULL
, *gname
= NULL
;
972 filename
= Fexpand_file_name (filename
, Qnil
);
974 /* If the file name has special constructs in it,
975 call the corresponding file handler. */
976 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
978 { /* Only pass the extra arg if it is used to help backward compatibility
979 with old file handlers which do not implement the new arg. --Stef */
980 if (NILP (id_format
))
981 return call2 (handler
, Qfile_attributes
, filename
);
983 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
987 encoded
= ENCODE_FILE (filename
);
990 if (lstat (SDATA (encoded
), &s
) < 0)
993 switch (s
.st_mode
& S_IFMT
)
996 values
[0] = Qnil
; break;
998 values
[0] = Qt
; break;
1001 values
[0] = Ffile_symlink_p (filename
); break;
1004 values
[1] = make_number (s
.st_nlink
);
1006 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
1009 uname
= stat_uname (&s
);
1010 gname
= stat_gname (&s
);
1014 values
[2] = DECODE_SYSTEM (build_string (uname
));
1016 values
[2] = make_fixnum_or_float (s
.st_uid
);
1018 values
[3] = DECODE_SYSTEM (build_string (gname
));
1020 values
[3] = make_fixnum_or_float (s
.st_gid
);
1022 values
[4] = make_time (s
.st_atime
);
1023 values
[5] = make_time (s
.st_mtime
);
1024 values
[6] = make_time (s
.st_ctime
);
1025 values
[7] = make_fixnum_or_float (s
.st_size
);
1026 /* If the size is negative, and its type is long, convert it back to
1028 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
1029 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
1031 filemodestring (&s
, modes
);
1032 values
[8] = make_string (modes
, 10);
1033 #ifdef BSD4_2 /* file gid will be dir gid */
1034 dirname
= Ffile_name_directory (filename
);
1035 if (! NILP (dirname
))
1036 encoded
= ENCODE_FILE (dirname
);
1037 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
1038 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
1039 else /* if we can't tell, assume worst */
1041 #else /* file gid will be egid */
1042 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1043 #endif /* not BSD4_2 */
1044 if (!FIXNUM_OVERFLOW_P (s
.st_ino
))
1045 /* Keep the most common cases as integers. */
1046 values
[10] = make_number (s
.st_ino
);
1047 else if (!FIXNUM_OVERFLOW_P (s
.st_ino
>> 16))
1048 /* To allow inode numbers larger than VALBITS, separate the bottom
1050 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1051 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1054 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1055 high parts and a 16-bit bottom part.
1056 The code on the next line avoids a compiler warning on
1057 systems where st_ino is 32 bit wide. (bug#766). */
1058 EMACS_INT high_ino
= s
.st_ino
>> 31 >> 1;
1059 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1061 values
[10] = Fcons (make_number (high_ino
>> 8),
1062 Fcons (make_number (((high_ino
& 0xff) << 16)
1064 make_number (low_ino
& 0xffff)));
1067 /* Likewise for device. */
1068 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1069 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1070 make_number (s
.st_dev
& 0xffff));
1072 values
[11] = make_number (s
.st_dev
);
1074 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1077 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1078 doc
: /* Return t if first arg file attributes list is less than second.
1079 Comparison is in lexicographic order and case is significant. */)
1080 (Lisp_Object f1
, Lisp_Object f2
)
1082 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1086 syms_of_dired (void)
1088 Qdirectory_files
= intern_c_string ("directory-files");
1089 Qdirectory_files_and_attributes
= intern_c_string ("directory-files-and-attributes");
1090 Qfile_name_completion
= intern_c_string ("file-name-completion");
1091 Qfile_name_all_completions
= intern_c_string ("file-name-all-completions");
1092 Qfile_attributes
= intern_c_string ("file-attributes");
1093 Qfile_attributes_lessp
= intern_c_string ("file-attributes-lessp");
1094 Qdefault_directory
= intern_c_string ("default-directory");
1096 staticpro (&Qdirectory_files
);
1097 staticpro (&Qdirectory_files_and_attributes
);
1098 staticpro (&Qfile_name_completion
);
1099 staticpro (&Qfile_name_all_completions
);
1100 staticpro (&Qfile_attributes
);
1101 staticpro (&Qfile_attributes_lessp
);
1102 staticpro (&Qdefault_directory
);
1104 defsubr (&Sdirectory_files
);
1105 defsubr (&Sdirectory_files_and_attributes
);
1106 defsubr (&Sfile_name_completion
);
1107 defsubr (&Sfile_name_all_completions
);
1108 defsubr (&Sfile_attributes
);
1109 defsubr (&Sfile_attributes_lessp
);
1111 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1112 doc
: /* Completion ignores file names ending in any string in this list.
1113 It does not ignore them if all possible completions end in one of
1114 these strings or when displaying a list of completions.
1115 It ignores directory names if they match any string in this list which
1116 ends in a slash. */);
1117 Vcompletion_ignored_extensions
= Qnil
;
1120 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1121 (do not change this comment) */