1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006 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 2, or (at your option)
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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
26 #include <sys/types.h>
48 /* The d_nameln member of a struct dirent includes the '\0' character
49 on some systems, but not on others. What's worse, you can't tell
50 at compile-time which one it will be, since it really depends on
51 the sort of system providing the filesystem you're reading from,
52 not the system you are running on. Paul Eggert
53 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
54 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
55 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
57 Since applying strlen to the name always works, we'll just do that. */
58 #define NAMLEN(p) strlen (p->d_name)
60 #ifdef SYSV_SYSTEM_DIR
63 #define DIRENTRY struct dirent
65 #else /* not SYSV_SYSTEM_DIR */
67 #ifdef NONSYSTEM_DIR_LIBRARY
69 #else /* not NONSYSTEM_DIR_LIBRARY */
75 #endif /* not NONSYSTEM_DIR_LIBRARY */
80 #define DIRENTRY struct direct
82 extern DIR *opendir ();
83 extern struct direct
*readdir ();
85 #endif /* not MSDOS */
86 #endif /* not SYSV_SYSTEM_DIR */
88 /* Some versions of Cygwin don't have d_ino in `struct dirent'. */
89 #if defined(MSDOS) || defined(__CYGWIN__)
90 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
92 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
99 #include "character.h"
103 #include "blockinput.h"
105 /* Returns a search buffer, with a fastmap allocated and ready to go. */
106 extern struct re_pattern_buffer
*compile_pattern ();
108 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
109 extern void filemodestring
P_ ((struct stat
*, char *));
111 /* if system does not have symbolic links, it does not have lstat.
112 In that case, use ordinary stat instead. */
118 extern int completion_ignore_case
;
119 extern Lisp_Object Vcompletion_regexp_list
;
121 Lisp_Object Vcompletion_ignored_extensions
;
122 Lisp_Object Qcompletion_ignore_case
;
123 Lisp_Object Qdirectory_files
;
124 Lisp_Object Qdirectory_files_and_attributes
;
125 Lisp_Object Qfile_name_completion
;
126 Lisp_Object Qfile_name_all_completions
;
127 Lisp_Object Qfile_attributes
;
128 Lisp_Object Qfile_attributes_lessp
;
130 static int scmp
P_ ((unsigned char *, unsigned char *, int));
134 directory_files_internal_unwind (dh
)
137 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
144 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
145 When ATTRS is zero, return a list of directory filenames; when
146 non-zero, return a list of directory filenames and their attributes.
147 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
150 directory_files_internal (directory
, full
, match
, nosort
, attrs
, id_format
)
151 Lisp_Object directory
, full
, match
, nosort
;
153 Lisp_Object id_format
;
156 int directory_nbytes
;
157 Lisp_Object list
, dirfilename
, encoded_directory
;
158 struct re_pattern_buffer
*bufp
= NULL
;
160 int count
= SPECPDL_INDEX ();
161 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
164 /* Because of file name handlers, these functions might call
165 Ffuncall, and cause a GC. */
166 list
= encoded_directory
= dirfilename
= Qnil
;
167 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
168 dirfilename
= Fdirectory_file_name (directory
);
172 CHECK_STRING (match
);
174 /* MATCH might be a flawed regular expression. Rather than
175 catching and signaling our own errors, we just call
176 compile_pattern to do the work for us. */
177 /* Pass 1 for the MULTIBYTE arg
178 because we do make multibyte strings if the contents warrant. */
180 bufp
= compile_pattern (match
, 0,
181 buffer_defaults
.downcase_table
, 0, 1);
184 /* Windows users want case-insensitive wildcards. */
185 bufp
= compile_pattern (match
, 0,
186 buffer_defaults
.case_canon_table
, 0, 1);
187 # else /* !WINDOWSNT */
188 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
189 # endif /* !WINDOWSNT */
193 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
194 run_pre_post_conversion_on_str which calls Lisp directly and
196 dirfilename
= ENCODE_FILE (dirfilename
);
197 encoded_directory
= ENCODE_FILE (directory
);
199 /* Now *bufp is the compiled form of MATCH; don't call anything
200 which might compile a new regexp until we're done with the loop! */
203 d
= opendir (SDATA (dirfilename
));
206 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
208 /* Unfortunately, we can now invoke expand-file-name and
209 file-attributes on filenames, both of which can throw, so we must
210 do a proper unwind-protect. */
211 record_unwind_protect (directory_files_internal_unwind
,
212 make_save_value (d
, 0));
214 directory_nbytes
= SBYTES (directory
);
215 re_match_object
= Qt
;
217 /* Decide whether we need to add a directory separator. */
219 if (directory_nbytes
== 0
220 || !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: ENCODE_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 bcopy (SDATA (directory
), SDATA (fullname
),
283 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
286 SDATA (fullname
) + directory_nbytes
+ needsep
,
289 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
291 /* Some bug somewhere. */
295 STRING_SET_CHARS (fullname
, nchars
);
296 if (nchars
== nbytes
)
297 STRING_SET_UNIBYTE (fullname
);
299 finalname
= fullname
;
306 /* Construct an expanded filename for the directory entry.
307 Use the decoded names for input to Ffile_attributes. */
308 Lisp_Object decoded_fullname
, fileattrs
;
309 struct gcpro gcpro1
, gcpro2
;
311 decoded_fullname
= fileattrs
= Qnil
;
312 GCPRO2 (decoded_fullname
, fileattrs
);
314 /* Both Fexpand_file_name and Ffile_attributes can GC. */
315 decoded_fullname
= Fexpand_file_name (name
, directory
);
316 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
318 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
322 list
= Fcons (finalname
, list
);
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 NOSORT is useful if you plan to sort the result yourself. */)
352 (directory
, full
, match
, nosort
)
353 Lisp_Object directory
, full
, match
, 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 (directory
, full
, match
, nosort
, id_format
)
380 Lisp_Object directory
, full
, match
, nosort
, id_format
;
383 directory
= Fexpand_file_name (directory
, Qnil
);
385 /* If the file name has special constructs in it,
386 call the corresponding file handler. */
387 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
389 return call6 (handler
, Qdirectory_files_and_attributes
,
390 directory
, full
, match
, nosort
, id_format
);
392 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
396 Lisp_Object
file_name_completion ();
398 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
400 doc
: /* Complete file name FILE in directory DIRECTORY.
401 Returns the longest string
402 common to all file names in DIRECTORY that start with FILE.
403 If there is only one and FILE matches it exactly, returns t.
404 Returns nil if DIRECTORY contains no name starting with FILE.
406 This function ignores some of the possible completions as
407 determined by the variable `completion-ignored-extensions', which see. */)
409 Lisp_Object file
, directory
;
413 /* If the directory name has special constructs in it,
414 call the corresponding file handler. */
415 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
417 return call3 (handler
, Qfile_name_completion
, file
, directory
);
419 /* If the file name has special constructs in it,
420 call the corresponding file handler. */
421 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
423 return call3 (handler
, Qfile_name_completion
, file
, directory
);
425 return file_name_completion (file
, directory
, 0, 0);
428 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
429 Sfile_name_all_completions
, 2, 2, 0,
430 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
431 These are all file names in directory DIRECTORY which begin with FILE. */)
433 Lisp_Object file
, directory
;
437 /* If the directory name has special constructs in it,
438 call the corresponding file handler. */
439 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
441 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
443 /* If the file name has special constructs in it,
444 call the corresponding file handler. */
445 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
447 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
449 return file_name_completion (file
, directory
, 1, 0);
452 static int file_name_completion_stat ();
455 file_name_completion (file
, dirname
, all_flag
, ver_flag
)
456 Lisp_Object file
, dirname
;
457 int all_flag
, ver_flag
;
460 int bestmatchsize
= 0, skip
;
461 register int compare
, matchsize
;
462 unsigned char *p1
, *p2
;
464 Lisp_Object bestmatch
, tem
, elt
, name
;
465 Lisp_Object encoded_file
;
466 Lisp_Object encoded_dir
;
470 int count
= SPECPDL_INDEX ();
471 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
476 extern DIRENTRY
* readdirver ();
478 DIRENTRY
*((* readfunc
) ());
480 /* Filename completion on VMS ignores case, since VMS filesys does. */
481 specbind (Qcompletion_ignore_case
, Qt
);
485 readfunc
= readdirver
;
486 file
= Fupcase (file
);
491 #ifdef FILE_SYSTEM_CASE
492 file
= FILE_SYSTEM_CASE (file
);
495 encoded_file
= encoded_dir
= Qnil
;
496 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
497 dirname
= Fexpand_file_name (dirname
, Qnil
);
499 /* Do completion on the encoded file name
500 because the other names in the directory are (we presume)
501 encoded likewise. We decode the completed string at the end. */
502 encoded_file
= ENCODE_FILE (file
);
504 encoded_dir
= ENCODE_FILE (dirname
);
506 /* With passcount = 0, ignore files that end in an ignored extension.
507 If nothing found then try again with passcount = 1, don't ignore them.
508 If looking for all completions, start with passcount = 1,
509 so always take even the ignored ones.
511 ** It would not actually be helpful to the user to ignore any possible
512 completions when making a list of them.** */
514 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
516 int inner_count
= SPECPDL_INDEX ();
519 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
522 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
524 record_unwind_protect (directory_files_internal_unwind
,
525 make_save_value (d
, 0));
527 /* Loop reading blocks */
528 /* (att3b compiler bug requires do a null comparison this way) */
535 dp
= (*readfunc
) (d
);
555 if (! DIRENTRY_NONEMPTY (dp
)
556 || len
< SCHARS (encoded_file
)
557 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
558 SCHARS (encoded_file
)))
561 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
564 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
568 #ifndef TRIVIAL_DIRECTORY_ENTRY
569 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
571 /* "." and ".." are never interesting as completions, but are
572 actually in the way in a directory contains only one file. */
573 if (!passcount
&& TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
575 if (!passcount
&& 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
))
586 /* Need to encode ELT, since scmp compares unibyte
588 elt
= ENCODE_FILE (elt
);
589 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
593 if (p1
[elt_len
] != '/')
595 skip
= len
- elt_len
;
599 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
606 /* Compare extensions-to-be-ignored against end of this file name */
607 /* if name is not an exact match against specified string */
608 if (!passcount
&& len
> SCHARS (encoded_file
))
609 /* and exit this for loop if a match is found */
610 for (tem
= Vcompletion_ignored_extensions
;
611 CONSP (tem
); tem
= XCDR (tem
))
614 if (!STRINGP (elt
)) continue;
615 /* Need to encode ELT, since scmp compares unibyte
617 elt
= ENCODE_FILE (elt
);
618 skip
= len
- SCHARS (elt
);
619 if (skip
< 0) continue;
621 if (0 <= scmp (dp
->d_name
+ skip
,
629 /* If an ignored-extensions match was found,
630 don't process this name as a completion. */
631 if (!passcount
&& CONSP (tem
))
638 XSETFASTINT (zero
, 0);
640 /* Ignore this element if it fails to match all the regexps. */
641 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
642 regexps
= XCDR (regexps
))
644 tem
= Fstring_match (XCAR (regexps
),
645 make_string (dp
->d_name
, len
), zero
);
653 /* Update computation of how much all possible completions match */
657 if (all_flag
|| NILP (bestmatch
))
659 /* This is a possible completion */
662 /* This completion is a directory; make it end with '/' */
663 name
= Ffile_name_as_directory (make_string (dp
->d_name
, len
));
666 name
= make_string (dp
->d_name
, len
);
669 name
= DECODE_FILE (name
);
670 bestmatch
= Fcons (name
, bestmatch
);
675 bestmatchsize
= SCHARS (name
);
680 compare
= min (bestmatchsize
, len
);
681 p1
= SDATA (bestmatch
);
682 p2
= (unsigned char *) dp
->d_name
;
683 matchsize
= scmp(p1
, p2
, compare
);
686 if (completion_ignore_case
)
688 /* If this is an exact match except for case,
689 use it as the best match rather than one that is not
690 an exact match. This way, we get the case pattern
691 of the actual match. */
692 /* This tests that the current file is an exact match
693 but BESTMATCH is not (it is too long). */
694 if ((matchsize
== len
695 && matchsize
+ !!directoryp
696 < SCHARS (bestmatch
))
698 /* If there is no exact match ignoring case,
699 prefer a match that does not change the case
701 /* If there is more than one exact match aside from
702 case, and one of them is exact including case,
704 /* This == checks that, of current file and BESTMATCH,
705 either both or neither are exact. */
708 (matchsize
+ !!directoryp
709 == SCHARS (bestmatch
)))
710 && !bcmp (p2
, SDATA (encoded_file
), SCHARS (encoded_file
))
711 && bcmp (p1
, SDATA (encoded_file
), SCHARS (encoded_file
))))
713 bestmatch
= make_string (dp
->d_name
, len
);
715 bestmatch
= Ffile_name_as_directory (bestmatch
);
719 /* If this dirname all matches, see if implicit following
722 && compare
== matchsize
723 && bestmatchsize
> matchsize
724 && IS_ANY_SEP (p1
[matchsize
]))
726 bestmatchsize
= matchsize
;
729 /* This closes the directory. */
730 bestmatch
= unbind_to (inner_count
, bestmatch
);
734 bestmatch
= unbind_to (count
, bestmatch
);
736 if (all_flag
|| NILP (bestmatch
))
738 if (STRINGP (bestmatch
))
739 bestmatch
= DECODE_FILE (bestmatch
);
742 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
744 bestmatch
= Fsubstring (bestmatch
, make_number (0),
745 make_number (bestmatchsize
));
746 /* Now that we got the right initial segment of BESTMATCH,
747 decode it from the coding system in use. */
748 bestmatch
= DECODE_FILE (bestmatch
);
752 /* Compare exactly LEN chars of strings at S1 and S2,
753 ignoring case if appropriate.
754 Return -1 if strings match,
755 else number of chars that match at the beginning. */
759 register unsigned char *s1
, *s2
;
762 register int l
= len
;
764 if (completion_ignore_case
)
766 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
771 while (l
&& *s1
++ == *s2
++)
781 file_name_completion_stat (dirname
, dp
, st_addr
)
784 struct stat
*st_addr
;
786 int len
= NAMLEN (dp
);
787 int pos
= SCHARS (dirname
);
789 char *fullname
= (char *) alloca (len
+ pos
+ 2);
793 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
794 but aren't required here. Avoid computing the following fields:
795 st_inode, st_size and st_nlink for directories, and the execute bits
796 in st_mode for non-directory files with non-standard extensions. */
798 unsigned short save_djstat_flags
= _djstat_flags
;
800 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
801 #endif /* __DJGPP__ > 1 */
804 bcopy (SDATA (dirname
), fullname
, pos
);
806 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
807 fullname
[pos
++] = DIRECTORY_SEP
;
810 bcopy (dp
->d_name
, fullname
+ pos
, len
);
811 fullname
[pos
+ len
] = 0;
814 /* We want to return success if a link points to a nonexistent file,
815 but we want to return the status for what the link points to,
816 in case it is a directory. */
817 value
= lstat (fullname
, st_addr
);
818 stat (fullname
, st_addr
);
821 value
= stat (fullname
, st_addr
);
824 _djstat_flags
= save_djstat_flags
;
825 #endif /* __DJGPP__ > 1 */
833 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
834 Sfile_name_all_versions
, 2, 2, 0,
835 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
837 Lisp_Object file
, directory
;
839 return file_name_completion (file
, directory
, 1, 1);
842 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
843 doc
: /* Return the maximum number of versions allowed for FILE.
844 Returns nil if the file cannot be opened or if there is no version limit. */)
846 Lisp_Object filename
;
851 struct XABFHC xabfhc
;
854 filename
= Fexpand_file_name (filename
, Qnil
);
856 xabfhc
= cc$rms_xabfhc
;
857 fab
.fab$l_fna
= SDATA (filename
);
858 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
859 fab
.fab$l_xab
= (char *) &xabfhc
;
860 status
= sys$
open (&fab
, 0, 0);
861 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
863 sys$
close (&fab
, 0, 0);
864 if (xabfhc
.xab$w_verlimit
== 32767)
865 return Qnil
; /* No version limit */
867 return make_number (xabfhc
.xab$w_verlimit
);
876 return Fcons (make_number (time
>> 16),
877 Fcons (make_number (time
& 0177777), Qnil
));
880 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
881 doc
: /* Return a list of attributes of file FILENAME.
882 Value is nil if specified file cannot be opened.
884 ID-FORMAT specifies the preferred format of attributes uid and gid (see
885 below) - valid values are 'string and 'integer. The latter is the default,
886 but we plan to change that, so you should specify a non-nil value for
887 ID-FORMAT if you use the returned uid or gid.
889 Elements of the attribute list are:
890 0. t for directory, string (name linked to) for symbolic link, or nil.
891 1. Number of links to file.
892 2. File uid as a string or an integer. If a string value cannot be
893 looked up, the integer value is returned.
894 3. File gid, likewise.
895 4. Last access time, as a list of two integers.
896 First integer has high-order 16 bits of time, second has low 16 bits.
897 5. Last modification time, likewise.
898 6. Last status change time, likewise.
900 This is a floating point number if the size is too large for an integer.
901 8. File modes, as a string of ten letters or dashes as in ls -l.
902 9. t iff file's gid would change if file were deleted and recreated.
903 10. inode number. If inode number is larger than the Emacs integer,
904 this is a cons cell containing two integers: first the high part,
905 then the low 16 bits.
906 11. Device number. If it is larger than the Emacs integer, this is
907 a cons cell, similar to the inode number. */)
908 (filename
, id_format
)
909 Lisp_Object filename
, id_format
;
911 Lisp_Object values
[12];
916 #if defined (BSD4_2) || defined (BSD4_3)
924 filename
= Fexpand_file_name (filename
, Qnil
);
926 /* If the file name has special constructs in it,
927 call the corresponding file handler. */
928 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
930 { /* Only pass the extra arg if it is used to help backward compatibility
931 with old file handlers which do not implement the new arg. --Stef */
932 if (NILP (id_format
))
933 return call2 (handler
, Qfile_attributes
, filename
);
935 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
939 encoded
= ENCODE_FILE (filename
);
942 if (lstat (SDATA (encoded
), &s
) < 0)
945 switch (s
.st_mode
& S_IFMT
)
948 values
[0] = Qnil
; break;
950 values
[0] = Qt
; break;
953 values
[0] = Ffile_symlink_p (filename
); break;
956 values
[1] = make_number (s
.st_nlink
);
957 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
959 values
[2] = make_number (s
.st_uid
);
960 values
[3] = make_number (s
.st_gid
);
965 pw
= (struct passwd
*) getpwuid (s
.st_uid
);
966 values
[2] = (pw
? build_string (pw
->pw_name
) : make_number (s
.st_uid
));
967 gr
= (struct group
*) getgrgid (s
.st_gid
);
968 values
[3] = (gr
? build_string (gr
->gr_name
) : make_number (s
.st_gid
));
971 values
[4] = make_time (s
.st_atime
);
972 values
[5] = make_time (s
.st_mtime
);
973 values
[6] = make_time (s
.st_ctime
);
974 values
[7] = make_number (s
.st_size
);
975 /* If the size is out of range for an integer, return a float. */
976 if (XINT (values
[7]) != s
.st_size
)
977 values
[7] = make_float ((double)s
.st_size
);
978 /* If the size is negative, and its type is long, convert it back to
980 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
981 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
983 filemodestring (&s
, modes
);
984 values
[8] = make_string (modes
, 10);
985 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
986 dirname
= Ffile_name_directory (filename
);
987 if (! NILP (dirname
))
988 encoded
= ENCODE_FILE (dirname
);
989 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
990 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
991 else /* if we can't tell, assume worst */
993 #else /* file gid will be egid */
994 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
995 #endif /* BSD4_2 (or BSD4_3) */
996 if (FIXNUM_OVERFLOW_P (s
.st_ino
))
997 /* To allow inode numbers larger than VALBITS, separate the bottom
999 values
[10] = Fcons (make_number (s
.st_ino
>> 16),
1000 make_number (s
.st_ino
& 0xffff));
1002 /* But keep the most common cases as integers. */
1003 values
[10] = make_number (s
.st_ino
);
1005 /* Likewise for device. */
1006 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1007 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1008 make_number (s
.st_dev
& 0xffff));
1010 values
[11] = make_number (s
.st_dev
);
1012 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1015 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1016 doc
: /* Return t if first arg file attributes list is less than second.
1017 Comparison is in lexicographic order and case is significant. */)
1021 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1027 Qdirectory_files
= intern ("directory-files");
1028 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1029 Qfile_name_completion
= intern ("file-name-completion");
1030 Qfile_name_all_completions
= intern ("file-name-all-completions");
1031 Qfile_attributes
= intern ("file-attributes");
1032 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1034 staticpro (&Qdirectory_files
);
1035 staticpro (&Qdirectory_files_and_attributes
);
1036 staticpro (&Qfile_name_completion
);
1037 staticpro (&Qfile_name_all_completions
);
1038 staticpro (&Qfile_attributes
);
1039 staticpro (&Qfile_attributes_lessp
);
1041 defsubr (&Sdirectory_files
);
1042 defsubr (&Sdirectory_files_and_attributes
);
1043 defsubr (&Sfile_name_completion
);
1045 defsubr (&Sfile_name_all_versions
);
1046 defsubr (&Sfile_version_limit
);
1048 defsubr (&Sfile_name_all_completions
);
1049 defsubr (&Sfile_attributes
);
1050 defsubr (&Sfile_attributes_lessp
);
1053 Qcompletion_ignore_case
= intern ("completion-ignore-case");
1054 staticpro (&Qcompletion_ignore_case
);
1057 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1058 doc
: /* Completion ignores file names ending in any string in this list.
1059 It does not ignore them if all possible completions end in one of
1060 these strings or when displaying a list of completions.
1061 It ignores directory names if they match any string in this list which
1062 ends in a slash. */);
1063 Vcompletion_ignored_extensions
= Qnil
;
1066 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1067 (do not change this comment) */