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 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>
38 /* The d_nameln member of a struct dirent includes the '\0' character
39 on some systems, but not on others. What's worse, you can't tell
40 at compile-time which one it will be, since it really depends on
41 the sort of system providing the filesystem you're reading from,
42 not the system you are running on. Paul Eggert
43 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
44 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
45 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
47 Since applying strlen to the name always works, we'll just do that. */
48 #define NAMLEN(p) strlen (p->d_name)
50 #ifdef SYSV_SYSTEM_DIR
53 #define DIRENTRY struct dirent
55 #else /* not SYSV_SYSTEM_DIR */
66 #define DIRENTRY struct direct
68 extern DIR *opendir ();
69 extern struct direct
*readdir ();
71 #endif /* not MSDOS */
72 #endif /* not SYSV_SYSTEM_DIR */
74 /* Some versions of Cygwin don't have d_ino in `struct dirent'. */
75 #if defined(MSDOS) || defined(__CYGWIN__)
76 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
78 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
85 #include "character.h"
89 #include "blockinput.h"
91 /* Returns a search buffer, with a fastmap allocated and ready to go. */
92 extern struct re_pattern_buffer
*compile_pattern ();
94 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
95 extern void filemodestring
P_ ((struct stat
*, char *));
97 /* if system does not have symbolic links, it does not have lstat.
98 In that case, use ordinary stat instead. */
104 extern int completion_ignore_case
;
105 extern Lisp_Object Qcompletion_ignore_case
;
106 extern Lisp_Object Vcompletion_regexp_list
;
107 extern Lisp_Object Vw32_get_true_file_attributes
;
109 Lisp_Object Vcompletion_ignored_extensions
;
110 Lisp_Object Qdirectory_files
;
111 Lisp_Object Qdirectory_files_and_attributes
;
112 Lisp_Object Qfile_name_completion
;
113 Lisp_Object Qfile_name_all_completions
;
114 Lisp_Object Qfile_attributes
;
115 Lisp_Object Qfile_attributes_lessp
;
117 static int scmp
P_ ((unsigned char *, unsigned char *, int));
121 directory_files_internal_w32_unwind (Lisp_Object arg
)
123 Vw32_get_true_file_attributes
= arg
;
129 directory_files_internal_unwind (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 (directory
, full
, match
, nosort
, attrs
, id_format
)
146 Lisp_Object directory
, full
, match
, nosort
;
148 Lisp_Object id_format
;
151 int directory_nbytes
;
152 Lisp_Object list
, dirfilename
, encoded_directory
;
153 struct re_pattern_buffer
*bufp
= NULL
;
155 int count
= SPECPDL_INDEX ();
156 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
159 Lisp_Object w32_save
= Qnil
;
162 /* Because of file name handlers, these functions might call
163 Ffuncall, and cause a GC. */
164 list
= encoded_directory
= dirfilename
= Qnil
;
165 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
166 dirfilename
= Fdirectory_file_name (directory
);
170 CHECK_STRING (match
);
172 /* MATCH might be a flawed regular expression. Rather than
173 catching and signaling our own errors, we just call
174 compile_pattern to do the work for us. */
175 /* Pass 1 for the MULTIBYTE arg
176 because we do make multibyte strings if the contents warrant. */
178 /* Windows users want case-insensitive wildcards. */
179 bufp
= compile_pattern (match
, 0,
180 buffer_defaults
.case_canon_table
, 0, 1);
181 # else /* !WINDOWSNT */
182 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
183 # endif /* !WINDOWSNT */
186 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
187 run_pre_post_conversion_on_str which calls Lisp directly and
189 if (STRING_MULTIBYTE (dirfilename
))
190 dirfilename
= ENCODE_FILE (dirfilename
);
191 encoded_directory
= (STRING_MULTIBYTE (directory
)
192 ? ENCODE_FILE (directory
) : directory
);
194 /* Now *bufp is the compiled form of MATCH; don't call anything
195 which might compile a new regexp until we're done with the loop! */
198 d
= opendir (SDATA (dirfilename
));
201 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
203 /* Unfortunately, we can now invoke expand-file-name and
204 file-attributes on filenames, both of which can throw, so we must
205 do a proper unwind-protect. */
206 record_unwind_protect (directory_files_internal_unwind
,
207 make_save_value (d
, 0));
212 extern Lisp_Object Qlocal
;
213 extern int is_slow_fs (const char *);
215 /* Do this only once to avoid doing it (in w32.c:stat) for each
216 file in the directory, when we call Ffile_attributes below. */
217 record_unwind_protect (directory_files_internal_w32_unwind
,
218 Vw32_get_true_file_attributes
);
219 w32_save
= Vw32_get_true_file_attributes
;
220 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
222 char *dirnm
= SDATA (dirfilename
);
223 char *fn
= alloca (SBYTES (dirfilename
) + 1);
225 strncpy (fn
, SDATA (dirfilename
), SBYTES (dirfilename
));
226 fn
[SBYTES (dirfilename
)] = '\0';
227 /* w32.c:stat will notice these bindings and avoid calling
228 GetDriveType for each file. */
230 Vw32_get_true_file_attributes
= Qnil
;
232 Vw32_get_true_file_attributes
= Qt
;
237 directory_nbytes
= SBYTES (directory
);
238 re_match_object
= Qt
;
240 /* Decide whether we need to add a directory separator. */
241 if (directory_nbytes
== 0
242 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
245 /* Loop reading blocks until EOF or error. */
264 if (DIRENTRY_NONEMPTY (dp
))
268 Lisp_Object name
, finalname
;
269 struct gcpro gcpro1
, gcpro2
;
272 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
273 GCPRO2 (finalname
, name
);
275 /* Note: DECODE_FILE can GC; it should protect its argument,
277 name
= DECODE_FILE (name
);
280 /* Now that we have unwind_protect in place, we might as well
281 allow matching to be interrupted. */
286 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
295 Lisp_Object fullname
;
296 int nbytes
= len
+ directory_nbytes
+ needsep
;
299 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
300 bcopy (SDATA (directory
), SDATA (fullname
),
304 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
307 SDATA (fullname
) + directory_nbytes
+ needsep
,
310 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
312 /* Some bug somewhere. */
316 STRING_SET_CHARS (fullname
, nchars
);
317 if (nchars
== nbytes
)
318 STRING_SET_UNIBYTE (fullname
);
320 finalname
= fullname
;
327 /* Construct an expanded filename for the directory entry.
328 Use the decoded names for input to Ffile_attributes. */
329 Lisp_Object decoded_fullname
, fileattrs
;
330 struct gcpro gcpro1
, gcpro2
;
332 decoded_fullname
= fileattrs
= Qnil
;
333 GCPRO2 (decoded_fullname
, fileattrs
);
335 /* Both Fexpand_file_name and Ffile_attributes can GC. */
336 decoded_fullname
= Fexpand_file_name (name
, directory
);
337 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
339 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
343 list
= Fcons (finalname
, list
);
355 Vw32_get_true_file_attributes
= w32_save
;
358 /* Discard the unwind protect. */
359 specpdl_ptr
= specpdl
+ count
;
362 list
= Fsort (Fnreverse (list
),
363 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
365 RETURN_UNGCPRO (list
);
369 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
370 doc
: /* Return a list of names of files in DIRECTORY.
371 There are three 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 Otherwise, the list returned is sorted with `stringp-lessp'.
377 NOSORT is useful if you plan to sort the result yourself. */)
378 (directory
, full
, match
, nosort
)
379 Lisp_Object directory
, full
, match
, nosort
;
382 directory
= Fexpand_file_name (directory
, Qnil
);
384 /* If the file name has special constructs in it,
385 call the corresponding file handler. */
386 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
388 return call5 (handler
, Qdirectory_files
, directory
,
389 full
, match
, nosort
);
391 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
394 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
395 Sdirectory_files_and_attributes
, 1, 5, 0,
396 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
397 There are four optional arguments:
398 If FULL is non-nil, return absolute file names. Otherwise return names
399 that are relative to the specified directory.
400 If MATCH is non-nil, mention only file names that match the regexp MATCH.
401 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
402 NOSORT is useful if you plan to sort the result yourself.
403 ID-FORMAT specifies the preferred format of attributes uid and gid, see
404 `file-attributes' for further documentation.
405 On MS-Windows, performance depends on `w32-get-true-file-attributes',
407 (directory
, full
, match
, nosort
, id_format
)
408 Lisp_Object directory
, full
, match
, nosort
, id_format
;
411 directory
= Fexpand_file_name (directory
, Qnil
);
413 /* If the file name has special constructs in it,
414 call the corresponding file handler. */
415 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
417 return call6 (handler
, Qdirectory_files_and_attributes
,
418 directory
, full
, match
, nosort
, id_format
);
420 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
424 Lisp_Object
file_name_completion ();
426 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
428 doc
: /* Complete file name FILE in directory DIRECTORY.
429 Returns the longest string
430 common to all file names in DIRECTORY that start with FILE.
431 If there is only one and FILE matches it exactly, returns t.
432 Returns nil if DIRECTORY contains no name starting with FILE.
434 If PREDICATE is non-nil, call PREDICATE with each possible
435 completion (in absolute form) and ignore it if PREDICATE returns nil.
437 This function ignores some of the possible completions as
438 determined by the variable `completion-ignored-extensions', which see. */)
439 (file
, directory
, predicate
)
440 Lisp_Object file
, directory
, predicate
;
444 /* If the directory name has special constructs in it,
445 call the corresponding file handler. */
446 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
448 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
450 /* If the file name has special constructs in it,
451 call the corresponding file handler. */
452 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
454 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
456 return file_name_completion (file
, directory
, 0, 0, predicate
);
459 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
460 Sfile_name_all_completions
, 2, 2, 0,
461 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
462 These are all file names in directory DIRECTORY which begin with FILE. */)
464 Lisp_Object file
, directory
;
468 /* If the directory name has special constructs in it,
469 call the corresponding file handler. */
470 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
472 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
474 /* If the file name has special constructs in it,
475 call the corresponding file handler. */
476 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
478 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
480 return file_name_completion (file
, directory
, 1, 0, Qnil
);
483 static int file_name_completion_stat ();
484 Lisp_Object Qdefault_directory
;
487 file_name_completion (file
, dirname
, all_flag
, ver_flag
, predicate
)
488 Lisp_Object file
, dirname
;
489 int all_flag
, ver_flag
;
490 Lisp_Object predicate
;
493 int bestmatchsize
= 0;
495 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
496 If ALL_FLAG is 0, BESTMATCH is either nil
497 or the best match so far, not decoded. */
498 Lisp_Object bestmatch
, tem
, elt
, name
;
499 Lisp_Object encoded_file
;
500 Lisp_Object encoded_dir
;
503 /* If includeall is zero, exclude files in completion-ignored-extensions as
504 well as "." and "..". Until shown otherwise, assume we can't exclude
507 int count
= SPECPDL_INDEX ();
508 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
514 #ifdef FILE_SYSTEM_CASE
515 file
= FILE_SYSTEM_CASE (file
);
518 encoded_file
= encoded_dir
= Qnil
;
519 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
520 dirname
= Fexpand_file_name (dirname
, Qnil
);
521 specbind (Qdefault_directory
, dirname
);
523 /* Do completion on the encoded file name
524 because the other names in the directory are (we presume)
525 encoded likewise. We decode the completed string at the end. */
526 /* Actually, this is not quite true any more: we do most of the completion
527 work with decoded file names, but we still do some filtering based
528 on the encoded file name. */
529 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
531 encoded_dir
= ENCODE_FILE (dirname
);
534 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
537 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
539 record_unwind_protect (directory_files_internal_unwind
,
540 make_save_value (d
, 0));
542 /* Loop reading blocks */
543 /* (att3b compiler bug requires do a null comparison this way) */
567 if (! DIRENTRY_NONEMPTY (dp
)
568 || len
< SCHARS (encoded_file
)
569 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
570 SCHARS (encoded_file
)))
573 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
576 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
578 /* If all_flag is set, always include all.
579 It would not actually be helpful to the user to ignore any possible
580 completions when making a list of them. */
585 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
586 /* If this entry matches the current bestmatch, the only
587 thing it can do is increase matchcount, so don't bother
588 investigating it any further. */
589 if (!completion_ignore_case
590 /* The return result depends on whether it's the sole match. */
592 && !includeall
/* This match may allow includeall to 0. */
593 && len
>= bestmatchsize
594 && 0 > scmp (dp
->d_name
, SDATA (bestmatch
), bestmatchsize
))
600 #ifndef TRIVIAL_DIRECTORY_ENTRY
601 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
603 /* "." and ".." are never interesting as completions, and are
604 actually in the way in a directory with only one file. */
605 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
607 else if (len
> SCHARS (encoded_file
))
608 /* Ignore directories if they match an element of
609 completion-ignored-extensions which ends in a slash. */
610 for (tem
= Vcompletion_ignored_extensions
;
611 CONSP (tem
); tem
= XCDR (tem
))
619 /* Need to encode ELT, since scmp compares unibyte
621 elt
= ENCODE_FILE (elt
);
622 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
626 if (p1
[elt_len
] != '/')
628 skip
= len
- elt_len
;
632 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
639 /* Compare extensions-to-be-ignored against end of this file name */
640 /* if name is not an exact match against specified string */
641 if (len
> SCHARS (encoded_file
))
642 /* and exit this for loop if a match is found */
643 for (tem
= Vcompletion_ignored_extensions
;
644 CONSP (tem
); tem
= XCDR (tem
))
647 if (!STRINGP (elt
)) continue;
648 /* Need to encode ELT, since scmp compares unibyte
650 elt
= ENCODE_FILE (elt
);
651 skip
= len
- SCHARS (elt
);
652 if (skip
< 0) continue;
654 if (0 <= scmp (dp
->d_name
+ skip
,
662 /* If an ignored-extensions match was found,
663 don't process this name as a completion. */
667 if (!includeall
&& canexclude
)
668 /* We're not including all files and this file can be excluded. */
671 if (includeall
&& !canexclude
)
672 { /* If we have one non-excludable file, we want to exclude the
675 /* Throw away any previous excludable match found. */
681 /* FIXME: If we move this `decode' earlier we can eliminate
682 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
683 name
= make_unibyte_string (dp
->d_name
, len
);
684 name
= DECODE_FILE (name
);
689 XSETFASTINT (zero
, 0);
691 /* Ignore this element if it fails to match all the regexps. */
692 if (completion_ignore_case
)
694 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
695 regexps
= XCDR (regexps
))
696 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
701 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
702 regexps
= XCDR (regexps
))
703 if (fast_string_match (XCAR (regexps
), name
) < 0)
711 /* This is a possible completion */
713 /* This completion is a directory; make it end with '/'. */
714 name
= Ffile_name_as_directory (name
);
716 /* Test the predicate, if any. */
717 if (!NILP (predicate
))
723 val
= call1 (predicate
, name
);
730 /* Suitably record this match. */
735 bestmatch
= Fcons (name
, bestmatch
);
736 else if (NILP (bestmatch
))
739 bestmatchsize
= SCHARS (name
);
743 Lisp_Object zero
= make_number (0);
744 /* FIXME: This is a copy of the code in Ftry_completion. */
745 int compare
= min (bestmatchsize
, SCHARS (name
));
747 = Fcompare_strings (bestmatch
, zero
,
748 make_number (compare
),
750 make_number (compare
),
751 completion_ignore_case
? Qt
: Qnil
);
753 = (EQ (tem
, Qt
) ? compare
754 : XINT (tem
) < 0 ? - XINT (tem
) - 1
757 if (completion_ignore_case
)
759 /* If this is an exact match except for case,
760 use it as the best match rather than one that is not
761 an exact match. This way, we get the case pattern
762 of the actual match. */
763 /* This tests that the current file is an exact match
764 but BESTMATCH is not (it is too long). */
765 if ((matchsize
== SCHARS (name
)
766 && matchsize
+ !!directoryp
< SCHARS (bestmatch
))
768 /* If there is no exact match ignoring case,
769 prefer a match that does not change the case
771 /* If there is more than one exact match aside from
772 case, and one of them is exact including case,
774 /* This == checks that, of current file and BESTMATCH,
775 either both or neither are exact. */
776 (((matchsize
== SCHARS (name
))
778 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
779 && (tem
= Fcompare_strings (name
, zero
,
780 make_number (SCHARS (file
)),
785 && (tem
= Fcompare_strings (bestmatch
, zero
,
786 make_number (SCHARS (file
)),
793 bestmatchsize
= matchsize
;
795 /* If the best completion so far is reduced to the string
796 we're trying to complete, then we already know there's no
797 other completion, so there's no point looking any further. */
798 if (matchsize
<= SCHARS (file
)
799 && !includeall
/* A future match may allow includeall to 0. */
800 /* If completion-ignore-case is non-nil, don't
801 short-circuit because we want to find the best
802 possible match *including* case differences. */
803 && (!completion_ignore_case
|| matchsize
== 0)
804 /* The return value depends on whether it's the sole match. */
812 /* This closes the directory. */
813 bestmatch
= unbind_to (count
, bestmatch
);
815 if (all_flag
|| NILP (bestmatch
))
817 /* Return t if the supplied string is an exact match (counting case);
818 it does not require any change to be made. */
819 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
821 bestmatch
= Fsubstring (bestmatch
, make_number (0),
822 make_number (bestmatchsize
));
826 /* Compare exactly LEN chars of strings at S1 and S2,
827 ignoring case if appropriate.
828 Return -1 if strings match,
829 else number of chars that match at the beginning. */
833 register unsigned char *s1
, *s2
;
836 register int l
= len
;
838 if (completion_ignore_case
)
840 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
845 while (l
&& *s1
++ == *s2
++)
855 file_name_completion_stat (dirname
, dp
, st_addr
)
858 struct stat
*st_addr
;
860 int len
= NAMLEN (dp
);
861 int pos
= SCHARS (dirname
);
863 char *fullname
= (char *) alloca (len
+ pos
+ 2);
867 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
868 but aren't required here. Avoid computing the following fields:
869 st_inode, st_size and st_nlink for directories, and the execute bits
870 in st_mode for non-directory files with non-standard extensions. */
872 unsigned short save_djstat_flags
= _djstat_flags
;
874 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
875 #endif /* __DJGPP__ > 1 */
878 bcopy (SDATA (dirname
), fullname
, pos
);
879 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
880 fullname
[pos
++] = DIRECTORY_SEP
;
882 bcopy (dp
->d_name
, fullname
+ pos
, len
);
883 fullname
[pos
+ len
] = 0;
886 /* We want to return success if a link points to a nonexistent file,
887 but we want to return the status for what the link points to,
888 in case it is a directory. */
889 value
= lstat (fullname
, st_addr
);
890 stat (fullname
, st_addr
);
893 value
= stat (fullname
, st_addr
);
896 _djstat_flags
= save_djstat_flags
;
897 #endif /* __DJGPP__ > 1 */
907 return Fcons (make_number (time
>> 16),
908 Fcons (make_number (time
& 0177777), Qnil
));
912 stat_uname (struct stat
*st
)
917 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
927 stat_gname (struct stat
*st
)
932 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
941 /* Make an integer or float number for UID and GID, while being
942 careful not to produce negative numbers due to signed integer
945 make_uid (struct stat
*st
)
947 EMACS_INT uid
= st
->st_uid
;
949 if (sizeof (st
->st_uid
) > sizeof (uid
) || uid
< 0 || FIXNUM_OVERFLOW_P (uid
))
950 return make_float ((double)st
->st_uid
);
951 return make_number (uid
);
955 make_gid (struct stat
*st
)
957 EMACS_INT gid
= st
->st_gid
;
959 if (sizeof (st
->st_gid
) > sizeof (gid
) || gid
< 0 || FIXNUM_OVERFLOW_P (gid
))
960 return make_float ((double)st
->st_gid
);
961 return make_number (gid
);
964 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
965 doc
: /* Return a list of attributes of file FILENAME.
966 Value is nil if specified file cannot be opened.
968 ID-FORMAT specifies the preferred format of attributes uid and gid (see
969 below) - valid values are 'string and 'integer. The latter is the default,
970 but we plan to change that, so you should specify a non-nil value for
971 ID-FORMAT if you use the returned uid or gid.
973 Elements of the attribute list are:
974 0. t for directory, string (name linked to) for symbolic link, or nil.
975 1. Number of links to file.
976 2. File uid as a string or a number. If a string value cannot be
977 looked up, a numeric value, either an integer or a float, is returned.
978 3. File gid, likewise.
979 4. Last access time, as a list of two integers.
980 First integer has high-order 16 bits of time, second has low 16 bits.
981 (See a note below about FAT-based filesystems.)
982 5. Last modification time, likewise.
983 6. Last status change time, likewise.
985 This is a floating point number if the size is too large for an integer.
986 8. File modes, as a string of ten letters or dashes as in ls -l.
987 9. t if file's gid would change if file were deleted and recreated.
988 10. inode number. If inode number is larger than the Emacs integer,
989 but still fits into a 32-bit number, this is a cons cell containing two
990 integers: first the high part, then the low 16 bits. If the inode number
991 is wider than 32 bits, this is a cons cell containing three integers:
992 first the high 24 bits, then middle 24 bits, and finally the low 16 bits.
993 11. Device number. If it is larger than the Emacs integer, this is
994 a cons cell, similar to the inode number.
996 On MS-Windows, performance depends on `w32-get-true-file-attributes',
999 On some FAT-based filesystems, only the date of last access is recorded,
1000 so last access time will always be midnight of that day. */)
1001 (filename
, id_format
)
1002 Lisp_Object filename
, id_format
;
1004 Lisp_Object values
[12];
1005 Lisp_Object encoded
;
1007 #if defined (BSD4_2) || defined (BSD4_3)
1008 Lisp_Object dirname
;
1012 Lisp_Object handler
;
1013 struct gcpro gcpro1
;
1014 EMACS_INT ino
, uid
, gid
;
1015 char *uname
= NULL
, *gname
= NULL
;
1017 filename
= Fexpand_file_name (filename
, Qnil
);
1019 /* If the file name has special constructs in it,
1020 call the corresponding file handler. */
1021 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
1022 if (!NILP (handler
))
1023 { /* Only pass the extra arg if it is used to help backward compatibility
1024 with old file handlers which do not implement the new arg. --Stef */
1025 if (NILP (id_format
))
1026 return call2 (handler
, Qfile_attributes
, filename
);
1028 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
1032 encoded
= ENCODE_FILE (filename
);
1035 if (lstat (SDATA (encoded
), &s
) < 0)
1038 switch (s
.st_mode
& S_IFMT
)
1041 values
[0] = Qnil
; break;
1043 values
[0] = Qt
; break;
1046 values
[0] = Ffile_symlink_p (filename
); break;
1049 values
[1] = make_number (s
.st_nlink
);
1051 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
1054 uname
= stat_uname (&s
);
1055 gname
= stat_gname (&s
);
1059 values
[2] = DECODE_SYSTEM (build_string (uname
));
1061 values
[2] = make_uid (&s
);
1063 values
[3] = DECODE_SYSTEM (build_string (gname
));
1065 values
[3] = make_gid (&s
);
1067 values
[4] = make_time (s
.st_atime
);
1068 values
[5] = make_time (s
.st_mtime
);
1069 values
[6] = make_time (s
.st_ctime
);
1070 values
[7] = make_number (s
.st_size
);
1071 /* If the size is out of range for an integer, return a float. */
1072 if (XINT (values
[7]) != s
.st_size
)
1073 values
[7] = make_float ((double)s
.st_size
);
1074 /* If the size is negative, and its type is long, convert it back to
1076 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
1077 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
1079 filemodestring (&s
, modes
);
1080 values
[8] = make_string (modes
, 10);
1081 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
1082 dirname
= Ffile_name_directory (filename
);
1083 if (! NILP (dirname
))
1084 encoded
= ENCODE_FILE (dirname
);
1085 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
1086 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
1087 else /* if we can't tell, assume worst */
1089 #else /* file gid will be egid */
1090 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1091 #endif /* BSD4_2 (or BSD4_3) */
1092 /* Shut up GCC warnings in FIXNUM_OVERFLOW_P below. */
1093 if (sizeof (s
.st_ino
) > sizeof (ino
))
1094 ino
= (EMACS_INT
)(s
.st_ino
& 0xffffffff);
1097 if (!FIXNUM_OVERFLOW_P (ino
)
1098 && (sizeof (s
.st_ino
) <= sizeof (ino
) || (s
.st_ino
& ~INTMASK
) == 0))
1099 /* Keep the most common cases as integers. */
1100 values
[10] = make_number (ino
);
1101 else if (sizeof (s
.st_ino
) <= sizeof (ino
)
1102 || ((s
.st_ino
>> 16) & ~INTMASK
) == 0)
1103 /* To allow inode numbers larger than VALBITS, separate the bottom
1105 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1106 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1109 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1110 high parts and a 16-bit bottom part.
1111 The code on the next line avoids a compiler warning on
1112 systems where st_ino is 32 bit wide. (bug#766). */
1113 EMACS_INT high_ino
= s
.st_ino
>> 31 >> 1;
1114 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1116 values
[10] = Fcons (make_number (high_ino
>> 8),
1117 Fcons (make_number (((high_ino
& 0xff) << 16)
1119 make_number (low_ino
& 0xffff)));
1122 /* Likewise for device, but don't let it become negative. We used
1123 to use FIXNUM_OVERFLOW_P here, but that won't catch large
1124 positive numbers such as 0xFFEEDDCC. */
1125 if ((EMACS_INT
)s
.st_dev
< 0
1126 || (EMACS_INT
)s
.st_dev
> MOST_POSITIVE_FIXNUM
)
1127 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1128 make_number (s
.st_dev
& 0xffff));
1130 values
[11] = make_number (s
.st_dev
);
1132 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1135 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1136 doc
: /* Return t if first arg file attributes list is less than second.
1137 Comparison is in lexicographic order and case is significant. */)
1141 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1147 Qdirectory_files
= intern ("directory-files");
1148 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1149 Qfile_name_completion
= intern ("file-name-completion");
1150 Qfile_name_all_completions
= intern ("file-name-all-completions");
1151 Qfile_attributes
= intern ("file-attributes");
1152 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1153 Qdefault_directory
= intern ("default-directory");
1155 staticpro (&Qdirectory_files
);
1156 staticpro (&Qdirectory_files_and_attributes
);
1157 staticpro (&Qfile_name_completion
);
1158 staticpro (&Qfile_name_all_completions
);
1159 staticpro (&Qfile_attributes
);
1160 staticpro (&Qfile_attributes_lessp
);
1161 staticpro (&Qdefault_directory
);
1163 defsubr (&Sdirectory_files
);
1164 defsubr (&Sdirectory_files_and_attributes
);
1165 defsubr (&Sfile_name_completion
);
1166 defsubr (&Sfile_name_all_completions
);
1167 defsubr (&Sfile_attributes
);
1168 defsubr (&Sfile_attributes_lessp
);
1170 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1171 doc
: /* Completion ignores file names ending in any string in this list.
1172 It does not ignore them if all possible completions end in one of
1173 these strings or when displaying a list of completions.
1174 It ignores directory names if they match any string in this list which
1175 ends in a slash. */);
1176 Vcompletion_ignored_extensions
= Qnil
;
1179 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1180 (do not change this comment) */