1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001
3 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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
26 #include <sys/types.h>
49 /* The d_nameln member of a struct dirent includes the '\0' character
50 on some systems, but not on others. What's worse, you can't tell
51 at compile-time which one it will be, since it really depends on
52 the sort of system providing the filesystem you're reading from,
53 not the system you are running on. Paul Eggert
54 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
55 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
56 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
58 Since applying strlen to the name always works, we'll just do that. */
59 #define NAMLEN(p) strlen (p->d_name)
61 #ifdef SYSV_SYSTEM_DIR
64 #define DIRENTRY struct dirent
66 #else /* not SYSV_SYSTEM_DIR */
68 #ifdef NONSYSTEM_DIR_LIBRARY
70 #else /* not NONSYSTEM_DIR_LIBRARY */
76 #endif /* not NONSYSTEM_DIR_LIBRARY */
81 #define DIRENTRY struct direct
83 extern DIR *opendir ();
84 extern struct direct
*readdir ();
86 #endif /* not MSDOS */
87 #endif /* not SYSV_SYSTEM_DIR */
90 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
92 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
102 /* Returns a search buffer, with a fastmap allocated and ready to go. */
103 extern struct re_pattern_buffer
*compile_pattern ();
105 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
106 extern void filemodestring
P_ ((struct stat
*, char *));
108 /* if system does not have symbolic links, it does not have lstat.
109 In that case, use ordinary stat instead. */
115 extern int completion_ignore_case
;
116 extern Lisp_Object Vcompletion_regexp_list
;
117 extern Lisp_Object Vfile_name_coding_system
, Vdefault_file_name_coding_system
;
119 Lisp_Object Vcompletion_ignored_extensions
;
120 Lisp_Object Qcompletion_ignore_case
;
121 Lisp_Object Qdirectory_files
;
122 Lisp_Object Qdirectory_files_and_attributes
;
123 Lisp_Object Qfile_name_completion
;
124 Lisp_Object Qfile_name_all_completions
;
125 Lisp_Object Qfile_attributes
;
126 Lisp_Object Qfile_attributes_lessp
;
128 static int scmp
P_ ((unsigned char *, unsigned char *, int));
132 directory_files_internal_unwind (dh
)
135 DIR *d
= (DIR *) ((XINT (XCAR (dh
)) << 16) + XINT (XCDR (dh
)));
140 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
141 When ATTRS is zero, return a list of directory filenames; when
142 non-zero, return a list of directory filenames and their attributes.
143 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
146 directory_files_internal (directory
, full
, match
, nosort
, attrs
, id_format
)
147 Lisp_Object directory
, full
, match
, nosort
;
149 Lisp_Object id_format
;
152 int directory_nbytes
;
153 Lisp_Object list
, dirfilename
, encoded_directory
;
154 struct re_pattern_buffer
*bufp
= NULL
;
156 int count
= SPECPDL_INDEX ();
157 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
161 /* Because of file name handlers, these functions might call
162 Ffuncall, and cause a GC. */
163 list
= encoded_directory
= dirfilename
= Qnil
;
164 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
165 dirfilename
= Fdirectory_file_name (directory
);
169 CHECK_STRING (match
);
171 /* MATCH might be a flawed regular expression. Rather than
172 catching and signaling our own errors, we just call
173 compile_pattern to do the work for us. */
174 /* Pass 1 for the MULTIBYTE arg
175 because we do make multibyte strings if the contents warrant. */
177 bufp
= compile_pattern (match
, 0,
178 buffer_defaults
.downcase_table
, 0, 1);
180 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
184 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
185 run_pre_post_conversion_on_str which calls Lisp directly and
187 dirfilename
= ENCODE_FILE (dirfilename
);
188 encoded_directory
= ENCODE_FILE (directory
);
190 /* Now *bufp is the compiled form of MATCH; don't call anything
191 which might compile a new regexp until we're done with the loop! */
193 /* Do this opendir after anything which might signal an error; if
194 an error is signaled while the directory stream is open, we
195 have to make sure it gets closed, and setting up an
196 unwind_protect to do so would be a pain. */
199 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 Fcons (make_number (((unsigned long) d
) >> 16),
208 make_number (((unsigned long) d
) & 0xffff)));
210 directory_nbytes
= SBYTES (directory
);
211 re_match_object
= Qt
;
213 /* Decide whether we need to add a directory separator. */
215 if (directory_nbytes
== 0
216 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
220 /* Loop reading blocks until EOF or error. */
227 if (dp
== NULL
&& errno
== EAGAIN
)
234 if (DIRENTRY_NONEMPTY (dp
))
238 Lisp_Object name
, finalname
;
239 struct gcpro gcpro1
, gcpro2
;
242 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
243 GCPRO2 (finalname
, name
);
245 /* Note: ENCODE_FILE can GC; it should protect its argument,
247 name
= DECODE_FILE (name
);
250 /* Now that we have unwind_protect in place, we might as well
251 allow matching to be interrupted. */
256 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
265 Lisp_Object fullname
;
266 int nbytes
= len
+ directory_nbytes
+ needsep
;
269 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
270 bcopy (SDATA (directory
), SDATA (fullname
),
274 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
277 SDATA (fullname
) + directory_nbytes
+ needsep
,
280 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
282 /* Some bug somewhere. */
286 STRING_SET_CHARS (fullname
, nchars
);
287 if (nchars
== nbytes
)
288 STRING_SET_UNIBYTE (fullname
);
290 finalname
= fullname
;
297 /* Construct an expanded filename for the directory entry.
298 Use the decoded names for input to Ffile_attributes. */
299 Lisp_Object decoded_fullname
, fileattrs
;
300 struct gcpro gcpro1
, gcpro2
;
302 decoded_fullname
= fileattrs
= Qnil
;
303 GCPRO2 (decoded_fullname
, fileattrs
);
305 /* Both Fexpand_file_name and Ffile_attributes can GC. */
306 decoded_fullname
= Fexpand_file_name (name
, directory
);
307 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
309 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
313 list
= Fcons (finalname
, list
);
322 retry_p
|= errno
== EINTR
;
327 /* Discard the unwind protect. */
328 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
);
366 args
[1] = Qdirectory_files
;
371 return Ffuncall (6, args
);
374 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
377 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
378 Sdirectory_files_and_attributes
, 1, 5, 0,
379 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
380 There are four optional arguments:
381 If FULL is non-nil, return absolute file names. Otherwise return names
382 that are relative to the specified directory.
383 If MATCH is non-nil, mention only file names that match the regexp MATCH.
384 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
385 NOSORT is useful if you plan to sort the result yourself.
386 ID-FORMAT specifies the preferred format of attributes uid and gid, see
387 `file-attributes' for further documentation. */)
388 (directory
, full
, match
, nosort
, id_format
)
389 Lisp_Object directory
, full
, match
, nosort
, id_format
;
392 directory
= Fexpand_file_name (directory
, Qnil
);
394 /* If the file name has special constructs in it,
395 call the corresponding file handler. */
396 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
402 args
[1] = Qdirectory_files_and_attributes
;
408 return Ffuncall (7, args
);
411 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
415 Lisp_Object
file_name_completion ();
417 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
419 doc
: /* Complete file name FILE in directory DIRECTORY.
420 Returns the longest string
421 common to all file names in DIRECTORY that start with FILE.
422 If there is only one and FILE matches it exactly, returns t.
423 Returns nil if DIR contains no name starting with FILE.
425 This function ignores some of the possible completions as
426 determined by the variable `completion-ignored-extensions', which see. */)
428 Lisp_Object file
, directory
;
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 call3 (handler
, Qfile_name_completion
, file
, directory
);
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 call3 (handler
, Qfile_name_completion
, file
, directory
);
444 return file_name_completion (file
, directory
, 0, 0);
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. */)
452 Lisp_Object file
, directory
;
456 /* If the directory name has special constructs in it,
457 call the corresponding file handler. */
458 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
460 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
462 /* If the file name has special constructs in it,
463 call the corresponding file handler. */
464 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
466 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
468 return file_name_completion (file
, directory
, 1, 0);
471 static int file_name_completion_stat ();
474 file_name_completion (file
, dirname
, all_flag
, ver_flag
)
475 Lisp_Object file
, dirname
;
476 int all_flag
, ver_flag
;
479 int bestmatchsize
= 0, skip
;
480 register int compare
, matchsize
;
481 unsigned char *p1
, *p2
;
483 Lisp_Object bestmatch
, tem
, elt
, name
;
484 Lisp_Object encoded_file
;
485 Lisp_Object encoded_dir
;
489 int count
= SPECPDL_INDEX ();
490 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
495 extern DIRENTRY
* readdirver ();
497 DIRENTRY
*((* readfunc
) ());
499 /* Filename completion on VMS ignores case, since VMS filesys does. */
500 specbind (Qcompletion_ignore_case
, Qt
);
504 readfunc
= readdirver
;
505 file
= Fupcase (file
);
510 #ifdef FILE_SYSTEM_CASE
511 file
= FILE_SYSTEM_CASE (file
);
514 encoded_file
= encoded_dir
= Qnil
;
515 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
516 dirname
= Fexpand_file_name (dirname
, Qnil
);
518 /* Do completion on the encoded file name
519 because the other names in the directory are (we presume)
520 encoded likewise. We decode the completed string at the end. */
521 encoded_file
= ENCODE_FILE (file
);
523 encoded_dir
= ENCODE_FILE (dirname
);
525 /* With passcount = 0, ignore files that end in an ignored extension.
526 If nothing found then try again with passcount = 1, don't ignore them.
527 If looking for all completions, start with passcount = 1,
528 so always take even the ignored ones.
530 ** It would not actually be helpful to the user to ignore any possible
531 completions when making a list of them.** */
533 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
535 int inner_count
= SPECPDL_INDEX ();
537 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
539 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
541 record_unwind_protect (directory_files_internal_unwind
,
542 Fcons (make_number (((unsigned long) d
) >> 16),
543 make_number (((unsigned long) d
) & 0xffff)));
545 /* Loop reading blocks */
546 /* (att3b compiler bug requires do a null comparison this way) */
553 dp
= (*readfunc
) (d
);
562 if (! DIRENTRY_NONEMPTY (dp
)
563 || len
< SCHARS (encoded_file
)
564 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
565 SCHARS (encoded_file
)))
568 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
571 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
575 #ifndef TRIVIAL_DIRECTORY_ENTRY
576 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
578 /* "." and ".." are never interesting as completions, but are
579 actually in the way in a directory contains only one file. */
580 if (!passcount
&& TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
582 if (!passcount
&& len
> SCHARS (encoded_file
))
583 /* Ignore directories if they match an element of
584 completion-ignored-extensions which ends in a slash. */
585 for (tem
= Vcompletion_ignored_extensions
;
586 CONSP (tem
); tem
= XCDR (tem
))
593 /* Need to encode ELT, since scmp compares unibyte
595 elt
= ENCODE_FILE (elt
);
596 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
600 if (p1
[elt_len
] != '/')
602 skip
= len
- elt_len
;
606 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
613 /* Compare extensions-to-be-ignored against end of this file name */
614 /* if name is not an exact match against specified string */
615 if (!passcount
&& len
> SCHARS (encoded_file
))
616 /* and exit this for loop if a match is found */
617 for (tem
= Vcompletion_ignored_extensions
;
618 CONSP (tem
); tem
= XCDR (tem
))
621 if (!STRINGP (elt
)) continue;
622 /* Need to encode ELT, since scmp compares unibyte
624 elt
= ENCODE_FILE (elt
);
625 skip
= len
- SCHARS (elt
);
626 if (skip
< 0) continue;
628 if (0 <= scmp (dp
->d_name
+ skip
,
636 /* If an ignored-extensions match was found,
637 don't process this name as a completion. */
638 if (!passcount
&& CONSP (tem
))
645 XSETFASTINT (zero
, 0);
647 /* Ignore this element if it fails to match all the regexps. */
648 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
649 regexps
= XCDR (regexps
))
651 tem
= Fstring_match (XCAR (regexps
),
652 make_string (dp
->d_name
, len
), zero
);
660 /* Update computation of how much all possible completions match */
664 if (all_flag
|| NILP (bestmatch
))
666 /* This is a possible completion */
669 /* This completion is a directory; make it end with '/' */
670 name
= Ffile_name_as_directory (make_string (dp
->d_name
, len
));
673 name
= make_string (dp
->d_name
, len
);
676 name
= DECODE_FILE (name
);
677 bestmatch
= Fcons (name
, bestmatch
);
682 bestmatchsize
= SCHARS (name
);
687 compare
= min (bestmatchsize
, len
);
688 p1
= SDATA (bestmatch
);
689 p2
= (unsigned char *) dp
->d_name
;
690 matchsize
= scmp(p1
, p2
, compare
);
693 if (completion_ignore_case
)
695 /* If this is an exact match except for case,
696 use it as the best match rather than one that is not
697 an exact match. This way, we get the case pattern
698 of the actual match. */
699 /* This tests that the current file is an exact match
700 but BESTMATCH is not (it is too long). */
701 if ((matchsize
== len
702 && matchsize
+ !!directoryp
703 < SCHARS (bestmatch
))
705 /* If there is no exact match ignoring case,
706 prefer a match that does not change the case
708 /* If there is more than one exact match aside from
709 case, and one of them is exact including case,
711 /* This == checks that, of current file and BESTMATCH,
712 either both or neither are exact. */
715 (matchsize
+ !!directoryp
716 == SCHARS (bestmatch
)))
717 && !bcmp (p2
, SDATA (encoded_file
), SCHARS (encoded_file
))
718 && bcmp (p1
, SDATA (encoded_file
), SCHARS (encoded_file
))))
720 bestmatch
= make_string (dp
->d_name
, len
);
722 bestmatch
= Ffile_name_as_directory (bestmatch
);
726 /* If this dirname all matches, see if implicit following
729 && compare
== matchsize
730 && bestmatchsize
> matchsize
731 && IS_ANY_SEP (p1
[matchsize
]))
733 bestmatchsize
= matchsize
;
736 /* This closes the directory. */
737 bestmatch
= unbind_to (inner_count
, bestmatch
);
741 bestmatch
= unbind_to (count
, bestmatch
);
743 if (all_flag
|| NILP (bestmatch
))
745 if (STRINGP (bestmatch
))
746 bestmatch
= DECODE_FILE (bestmatch
);
749 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
751 bestmatch
= Fsubstring (bestmatch
, make_number (0),
752 make_number (bestmatchsize
));
753 /* Now that we got the right initial segment of BESTMATCH,
754 decode it from the coding system in use. */
755 bestmatch
= DECODE_FILE (bestmatch
);
759 /* Compare exactly LEN chars of strings at S1 and S2,
760 ignoring case if appropriate.
761 Return -1 if strings match,
762 else number of chars that match at the beginning. */
766 register unsigned char *s1
, *s2
;
769 register int l
= len
;
771 if (completion_ignore_case
)
773 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
778 while (l
&& *s1
++ == *s2
++)
788 file_name_completion_stat (dirname
, dp
, st_addr
)
791 struct stat
*st_addr
;
793 int len
= NAMLEN (dp
);
794 int pos
= SCHARS (dirname
);
796 char *fullname
= (char *) alloca (len
+ pos
+ 2);
800 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
801 but aren't required here. Avoid computing the following fields:
802 st_inode, st_size and st_nlink for directories, and the execute bits
803 in st_mode for non-directory files with non-standard extensions. */
805 unsigned short save_djstat_flags
= _djstat_flags
;
807 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
808 #endif /* __DJGPP__ > 1 */
811 bcopy (SDATA (dirname
), fullname
, pos
);
813 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
814 fullname
[pos
++] = DIRECTORY_SEP
;
817 bcopy (dp
->d_name
, fullname
+ pos
, len
);
818 fullname
[pos
+ len
] = 0;
821 /* We want to return success if a link points to a nonexistent file,
822 but we want to return the status for what the link points to,
823 in case it is a directory. */
824 value
= lstat (fullname
, st_addr
);
825 stat (fullname
, st_addr
);
828 value
= stat (fullname
, st_addr
);
831 _djstat_flags
= save_djstat_flags
;
832 #endif /* __DJGPP__ > 1 */
840 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
841 Sfile_name_all_versions
, 2, 2, 0,
842 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
844 Lisp_Object file
, directory
;
846 return file_name_completion (file
, directory
, 1, 1);
849 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
850 doc
: /* Return the maximum number of versions allowed for FILE.
851 Returns nil if the file cannot be opened or if there is no version limit. */)
853 Lisp_Object filename
;
858 struct XABFHC xabfhc
;
861 filename
= Fexpand_file_name (filename
, Qnil
);
863 xabfhc
= cc$rms_xabfhc
;
864 fab
.fab$l_fna
= SDATA (filename
);
865 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
866 fab
.fab$l_xab
= (char *) &xabfhc
;
867 status
= sys$
open (&fab
, 0, 0);
868 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
870 sys$
close (&fab
, 0, 0);
871 if (xabfhc
.xab$w_verlimit
== 32767)
872 return Qnil
; /* No version limit */
874 return make_number (xabfhc
.xab$w_verlimit
);
883 return Fcons (make_number (time
>> 16),
884 Fcons (make_number (time
& 0177777), Qnil
));
887 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
888 doc
: /* Return a list of attributes of file FILENAME.
889 Value is nil if specified file cannot be opened.
891 ID-FORMAT specifies the preferred format of attributes uid and gid (see
892 below) - valid values are 'string and 'integer. The latter is the default,
893 but we plan to change that, so you should specify a non-nil value for
894 ID-FORMAT if you use the returned uid or gid.
896 Elements of the attribute list are:
897 0. t for directory, string (name linked to) for symbolic link, or nil.
898 1. Number of links to file.
899 2. File uid as a string or an integer. If a string value cannot be
900 looked up, the integer value is returned.
901 3. File gid, likewise.
902 4. Last access time, as a list of two integers.
903 First integer has high-order 16 bits of time, second has low 16 bits.
904 5. Last modification time, likewise.
905 6. Last status change time, likewise.
907 This is a floating point number if the size is too large for an integer.
908 8. File modes, as a string of ten letters or dashes as in ls -l.
909 9. t iff file's gid would change if file were deleted and recreated.
910 10. inode number. If inode number is larger than the Emacs integer,
911 this is a cons cell containing two integers: first the high part,
912 then the low 16 bits.
913 11. Device number. If it is larger than the Emacs integer, this is
914 a cons cell, similar to the inode number. */)
915 (filename
, id_format
)
916 Lisp_Object filename
, id_format
;
918 Lisp_Object values
[12];
923 #if defined (BSD4_2) || defined (BSD4_3)
930 filename
= Fexpand_file_name (filename
, Qnil
);
932 /* If the file name has special constructs in it,
933 call the corresponding file handler. */
934 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
936 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
938 encoded
= ENCODE_FILE (filename
);
940 if (lstat (SDATA (encoded
), &s
) < 0)
943 switch (s
.st_mode
& S_IFMT
)
946 values
[0] = Qnil
; break;
948 values
[0] = Qt
; break;
951 values
[0] = Ffile_symlink_p (filename
); break;
954 values
[1] = make_number (s
.st_nlink
);
955 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
957 values
[2] = make_number (s
.st_uid
);
958 values
[3] = make_number (s
.st_gid
);
962 pw
= (struct passwd
*) getpwuid (s
.st_uid
);
963 values
[2] = (pw
? build_string (pw
->pw_name
) : s
.st_uid
);
964 gr
= (struct group
*) getgrgid (s
.st_gid
);
965 values
[3] = (gr
? build_string (gr
->gr_name
) : s
.st_gid
);
967 values
[4] = make_time (s
.st_atime
);
968 values
[5] = make_time (s
.st_mtime
);
969 values
[6] = make_time (s
.st_ctime
);
970 values
[7] = make_number (s
.st_size
);
971 /* If the size is out of range for an integer, return a float. */
972 if (XINT (values
[7]) != s
.st_size
)
973 values
[7] = make_float ((double)s
.st_size
);
974 /* If the size is negative, and its type is long, convert it back to
976 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
977 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
979 filemodestring (&s
, modes
);
980 values
[8] = make_string (modes
, 10);
981 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
982 dirname
= Ffile_name_directory (filename
);
983 if (! NILP (dirname
))
984 encoded
= ENCODE_FILE (dirname
);
985 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
986 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
987 else /* if we can't tell, assume worst */
989 #else /* file gid will be egid */
990 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
991 #endif /* BSD4_2 (or BSD4_3) */
992 if (FIXNUM_OVERFLOW_P (s
.st_ino
))
993 /* To allow inode numbers larger than VALBITS, separate the bottom
995 values
[10] = Fcons (make_number (s
.st_ino
>> 16),
996 make_number (s
.st_ino
& 0xffff));
998 /* But keep the most common cases as integers. */
999 values
[10] = make_number (s
.st_ino
);
1001 /* Likewise for device. */
1002 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1003 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1004 make_number (s
.st_dev
& 0xffff));
1006 values
[11] = make_number (s
.st_dev
);
1008 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1011 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1012 doc
: /* Return t if first arg file attributes list is less than second.
1013 Comparison is in lexicographic order and case is significant. */)
1017 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1023 Qdirectory_files
= intern ("directory-files");
1024 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1025 Qfile_name_completion
= intern ("file-name-completion");
1026 Qfile_name_all_completions
= intern ("file-name-all-completions");
1027 Qfile_attributes
= intern ("file-attributes");
1028 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1030 staticpro (&Qdirectory_files
);
1031 staticpro (&Qdirectory_files_and_attributes
);
1032 staticpro (&Qfile_name_completion
);
1033 staticpro (&Qfile_name_all_completions
);
1034 staticpro (&Qfile_attributes
);
1035 staticpro (&Qfile_attributes_lessp
);
1037 defsubr (&Sdirectory_files
);
1038 defsubr (&Sdirectory_files_and_attributes
);
1039 defsubr (&Sfile_name_completion
);
1041 defsubr (&Sfile_name_all_versions
);
1042 defsubr (&Sfile_version_limit
);
1044 defsubr (&Sfile_name_all_completions
);
1045 defsubr (&Sfile_attributes
);
1046 defsubr (&Sfile_attributes_lessp
);
1049 Qcompletion_ignore_case
= intern ("completion-ignore-case");
1050 staticpro (&Qcompletion_ignore_case
);
1053 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1054 doc
: /* *Completion ignores filenames ending in any string in this list.
1055 Directories are ignored if they match any string in this list which
1057 This variable does not affect lists of possible completions,
1058 but does affect the commands that actually do completions. */);
1059 Vcompletion_ignored_extensions
= Qnil
;
1062 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1063 (do not change this comment) */