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)
103 /* Returns a search buffer, with a fastmap allocated and ready to go. */
104 extern struct re_pattern_buffer
*compile_pattern ();
106 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
107 extern void filemodestring
P_ ((struct stat
*, char *));
109 /* if system does not have symbolic links, it does not have lstat.
110 In that case, use ordinary stat instead. */
116 extern int completion_ignore_case
;
117 extern Lisp_Object Vcompletion_regexp_list
;
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 *) XSAVE_VALUE (dh
)->pointer
;
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
;
160 /* Because of file name handlers, these functions might call
161 Ffuncall, and cause a GC. */
162 list
= encoded_directory
= dirfilename
= Qnil
;
163 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
164 dirfilename
= Fdirectory_file_name (directory
);
168 CHECK_STRING (match
);
170 /* MATCH might be a flawed regular expression. Rather than
171 catching and signaling our own errors, we just call
172 compile_pattern to do the work for us. */
173 /* Pass 1 for the MULTIBYTE arg
174 because we do make multibyte strings if the contents warrant. */
176 bufp
= compile_pattern (match
, 0,
177 buffer_defaults
.downcase_table
, 0, 1);
179 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
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 dirfilename
= ENCODE_FILE (dirfilename
);
187 encoded_directory
= ENCODE_FILE (directory
);
189 /* Now *bufp is the compiled form of MATCH; don't call anything
190 which might compile a new regexp until we're done with the loop! */
192 d
= opendir (SDATA (dirfilename
));
194 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
196 /* Unfortunately, we can now invoke expand-file-name and
197 file-attributes on filenames, both of which can throw, so we must
198 do a proper unwind-protect. */
199 record_unwind_protect (directory_files_internal_unwind
,
200 make_save_value (d
, 0));
202 directory_nbytes
= SBYTES (directory
);
203 re_match_object
= Qt
;
205 /* Decide whether we need to add a directory separator. */
207 if (directory_nbytes
== 0
208 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
212 /* Loop reading blocks until EOF or error. */
231 if (DIRENTRY_NONEMPTY (dp
))
235 Lisp_Object name
, finalname
;
236 struct gcpro gcpro1
, gcpro2
;
239 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
240 GCPRO2 (finalname
, name
);
242 /* Note: ENCODE_FILE can GC; it should protect its argument,
244 name
= DECODE_FILE (name
);
247 /* Now that we have unwind_protect in place, we might as well
248 allow matching to be interrupted. */
253 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
262 Lisp_Object fullname
;
263 int nbytes
= len
+ directory_nbytes
+ needsep
;
266 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
267 bcopy (SDATA (directory
), SDATA (fullname
),
271 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
274 SDATA (fullname
) + directory_nbytes
+ needsep
,
277 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
279 /* Some bug somewhere. */
283 STRING_SET_CHARS (fullname
, nchars
);
284 if (nchars
== nbytes
)
285 STRING_SET_UNIBYTE (fullname
);
287 finalname
= fullname
;
294 /* Construct an expanded filename for the directory entry.
295 Use the decoded names for input to Ffile_attributes. */
296 Lisp_Object decoded_fullname
, fileattrs
;
297 struct gcpro gcpro1
, gcpro2
;
299 decoded_fullname
= fileattrs
= Qnil
;
300 GCPRO2 (decoded_fullname
, fileattrs
);
302 /* Both Fexpand_file_name and Ffile_attributes can GC. */
303 decoded_fullname
= Fexpand_file_name (name
, directory
);
304 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
306 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
310 list
= Fcons (finalname
, list
);
319 /* Discard the unwind protect. */
320 specpdl_ptr
= specpdl
+ count
;
323 list
= Fsort (Fnreverse (list
),
324 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
326 RETURN_UNGCPRO (list
);
330 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
331 doc
: /* Return a list of names of files in DIRECTORY.
332 There are three optional arguments:
333 If FULL is non-nil, return absolute file names. Otherwise return names
334 that are relative to the specified directory.
335 If MATCH is non-nil, mention only file names that match the regexp MATCH.
336 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
337 NOSORT is useful if you plan to sort the result yourself. */)
338 (directory
, full
, match
, nosort
)
339 Lisp_Object directory
, full
, match
, nosort
;
342 directory
= Fexpand_file_name (directory
, Qnil
);
344 /* If the file name has special constructs in it,
345 call the corresponding file handler. */
346 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
348 return call5 (handler
, Qdirectory_files
, directory
,
349 full
, match
, nosort
);
351 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
354 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
355 Sdirectory_files_and_attributes
, 1, 5, 0,
356 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
357 There are four optional arguments:
358 If FULL is non-nil, return absolute file names. Otherwise return names
359 that are relative to the specified directory.
360 If MATCH is non-nil, mention only file names that match the regexp MATCH.
361 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
362 NOSORT is useful if you plan to sort the result yourself.
363 ID-FORMAT specifies the preferred format of attributes uid and gid, see
364 `file-attributes' for further documentation. */)
365 (directory
, full
, match
, nosort
, id_format
)
366 Lisp_Object directory
, full
, match
, nosort
, id_format
;
369 directory
= Fexpand_file_name (directory
, Qnil
);
371 /* If the file name has special constructs in it,
372 call the corresponding file handler. */
373 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
375 return call6 (handler
, Qdirectory_files_and_attributes
,
376 directory
, full
, match
, nosort
, id_format
);
378 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
382 Lisp_Object
file_name_completion ();
384 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
386 doc
: /* Complete file name FILE in directory DIRECTORY.
387 Returns the longest string
388 common to all file names in DIRECTORY that start with FILE.
389 If there is only one and FILE matches it exactly, returns t.
390 Returns nil if DIRECTORY contains no name starting with FILE.
392 This function ignores some of the possible completions as
393 determined by the variable `completion-ignored-extensions', which see. */)
395 Lisp_Object file
, directory
;
399 /* If the directory name has special constructs in it,
400 call the corresponding file handler. */
401 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
403 return call3 (handler
, Qfile_name_completion
, file
, directory
);
405 /* If the file name has special constructs in it,
406 call the corresponding file handler. */
407 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
409 return call3 (handler
, Qfile_name_completion
, file
, directory
);
411 return file_name_completion (file
, directory
, 0, 0);
414 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
415 Sfile_name_all_completions
, 2, 2, 0,
416 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
417 These are all file names in directory DIRECTORY which begin with FILE. */)
419 Lisp_Object file
, directory
;
423 /* If the directory name has special constructs in it,
424 call the corresponding file handler. */
425 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
427 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
429 /* If the file name has special constructs in it,
430 call the corresponding file handler. */
431 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
433 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
435 return file_name_completion (file
, directory
, 1, 0);
438 static int file_name_completion_stat ();
441 file_name_completion (file
, dirname
, all_flag
, ver_flag
)
442 Lisp_Object file
, dirname
;
443 int all_flag
, ver_flag
;
446 int bestmatchsize
= 0, skip
;
447 register int compare
, matchsize
;
448 unsigned char *p1
, *p2
;
450 Lisp_Object bestmatch
, tem
, elt
, name
;
451 Lisp_Object encoded_file
;
452 Lisp_Object encoded_dir
;
456 int count
= SPECPDL_INDEX ();
457 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
462 extern DIRENTRY
* readdirver ();
464 DIRENTRY
*((* readfunc
) ());
466 /* Filename completion on VMS ignores case, since VMS filesys does. */
467 specbind (Qcompletion_ignore_case
, Qt
);
471 readfunc
= readdirver
;
472 file
= Fupcase (file
);
477 #ifdef FILE_SYSTEM_CASE
478 file
= FILE_SYSTEM_CASE (file
);
481 encoded_file
= encoded_dir
= Qnil
;
482 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
483 dirname
= Fexpand_file_name (dirname
, Qnil
);
485 /* Do completion on the encoded file name
486 because the other names in the directory are (we presume)
487 encoded likewise. We decode the completed string at the end. */
488 encoded_file
= ENCODE_FILE (file
);
490 encoded_dir
= ENCODE_FILE (dirname
);
492 /* With passcount = 0, ignore files that end in an ignored extension.
493 If nothing found then try again with passcount = 1, don't ignore them.
494 If looking for all completions, start with passcount = 1,
495 so always take even the ignored ones.
497 ** It would not actually be helpful to the user to ignore any possible
498 completions when making a list of them.** */
500 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
502 int inner_count
= SPECPDL_INDEX ();
504 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
506 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
508 record_unwind_protect (directory_files_internal_unwind
,
509 make_save_value (d
, 0));
511 /* Loop reading blocks */
512 /* (att3b compiler bug requires do a null comparison this way) */
519 dp
= (*readfunc
) (d
);
539 if (! DIRENTRY_NONEMPTY (dp
)
540 || len
< SCHARS (encoded_file
)
541 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
542 SCHARS (encoded_file
)))
545 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
548 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
552 #ifndef TRIVIAL_DIRECTORY_ENTRY
553 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
555 /* "." and ".." are never interesting as completions, but are
556 actually in the way in a directory contains only one file. */
557 if (!passcount
&& TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
559 if (!passcount
&& len
> SCHARS (encoded_file
))
560 /* Ignore directories if they match an element of
561 completion-ignored-extensions which ends in a slash. */
562 for (tem
= Vcompletion_ignored_extensions
;
563 CONSP (tem
); tem
= XCDR (tem
))
570 /* Need to encode ELT, since scmp compares unibyte
572 elt
= ENCODE_FILE (elt
);
573 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
577 if (p1
[elt_len
] != '/')
579 skip
= len
- elt_len
;
583 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
590 /* Compare extensions-to-be-ignored against end of this file name */
591 /* if name is not an exact match against specified string */
592 if (!passcount
&& len
> SCHARS (encoded_file
))
593 /* and exit this for loop if a match is found */
594 for (tem
= Vcompletion_ignored_extensions
;
595 CONSP (tem
); tem
= XCDR (tem
))
598 if (!STRINGP (elt
)) continue;
599 /* Need to encode ELT, since scmp compares unibyte
601 elt
= ENCODE_FILE (elt
);
602 skip
= len
- SCHARS (elt
);
603 if (skip
< 0) continue;
605 if (0 <= scmp (dp
->d_name
+ skip
,
613 /* If an ignored-extensions match was found,
614 don't process this name as a completion. */
615 if (!passcount
&& CONSP (tem
))
622 XSETFASTINT (zero
, 0);
624 /* Ignore this element if it fails to match all the regexps. */
625 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
626 regexps
= XCDR (regexps
))
628 tem
= Fstring_match (XCAR (regexps
),
629 make_string (dp
->d_name
, len
), zero
);
637 /* Update computation of how much all possible completions match */
641 if (all_flag
|| NILP (bestmatch
))
643 /* This is a possible completion */
646 /* This completion is a directory; make it end with '/' */
647 name
= Ffile_name_as_directory (make_string (dp
->d_name
, len
));
650 name
= make_string (dp
->d_name
, len
);
653 name
= DECODE_FILE (name
);
654 bestmatch
= Fcons (name
, bestmatch
);
659 bestmatchsize
= SCHARS (name
);
664 compare
= min (bestmatchsize
, len
);
665 p1
= SDATA (bestmatch
);
666 p2
= (unsigned char *) dp
->d_name
;
667 matchsize
= scmp(p1
, p2
, compare
);
670 if (completion_ignore_case
)
672 /* If this is an exact match except for case,
673 use it as the best match rather than one that is not
674 an exact match. This way, we get the case pattern
675 of the actual match. */
676 /* This tests that the current file is an exact match
677 but BESTMATCH is not (it is too long). */
678 if ((matchsize
== len
679 && matchsize
+ !!directoryp
680 < SCHARS (bestmatch
))
682 /* If there is no exact match ignoring case,
683 prefer a match that does not change the case
685 /* If there is more than one exact match aside from
686 case, and one of them is exact including case,
688 /* This == checks that, of current file and BESTMATCH,
689 either both or neither are exact. */
692 (matchsize
+ !!directoryp
693 == SCHARS (bestmatch
)))
694 && !bcmp (p2
, SDATA (encoded_file
), SCHARS (encoded_file
))
695 && bcmp (p1
, SDATA (encoded_file
), SCHARS (encoded_file
))))
697 bestmatch
= make_string (dp
->d_name
, len
);
699 bestmatch
= Ffile_name_as_directory (bestmatch
);
703 /* If this dirname all matches, see if implicit following
706 && compare
== matchsize
707 && bestmatchsize
> matchsize
708 && IS_ANY_SEP (p1
[matchsize
]))
710 bestmatchsize
= matchsize
;
713 /* This closes the directory. */
714 bestmatch
= unbind_to (inner_count
, bestmatch
);
718 bestmatch
= unbind_to (count
, bestmatch
);
720 if (all_flag
|| NILP (bestmatch
))
722 if (STRINGP (bestmatch
))
723 bestmatch
= DECODE_FILE (bestmatch
);
726 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
728 bestmatch
= Fsubstring (bestmatch
, make_number (0),
729 make_number (bestmatchsize
));
730 /* Now that we got the right initial segment of BESTMATCH,
731 decode it from the coding system in use. */
732 bestmatch
= DECODE_FILE (bestmatch
);
736 /* Compare exactly LEN chars of strings at S1 and S2,
737 ignoring case if appropriate.
738 Return -1 if strings match,
739 else number of chars that match at the beginning. */
743 register unsigned char *s1
, *s2
;
746 register int l
= len
;
748 if (completion_ignore_case
)
750 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
755 while (l
&& *s1
++ == *s2
++)
765 file_name_completion_stat (dirname
, dp
, st_addr
)
768 struct stat
*st_addr
;
770 int len
= NAMLEN (dp
);
771 int pos
= SCHARS (dirname
);
773 char *fullname
= (char *) alloca (len
+ pos
+ 2);
777 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
778 but aren't required here. Avoid computing the following fields:
779 st_inode, st_size and st_nlink for directories, and the execute bits
780 in st_mode for non-directory files with non-standard extensions. */
782 unsigned short save_djstat_flags
= _djstat_flags
;
784 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
785 #endif /* __DJGPP__ > 1 */
788 bcopy (SDATA (dirname
), fullname
, pos
);
790 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
791 fullname
[pos
++] = DIRECTORY_SEP
;
794 bcopy (dp
->d_name
, fullname
+ pos
, len
);
795 fullname
[pos
+ len
] = 0;
798 /* We want to return success if a link points to a nonexistent file,
799 but we want to return the status for what the link points to,
800 in case it is a directory. */
801 value
= lstat (fullname
, st_addr
);
802 stat (fullname
, st_addr
);
805 value
= stat (fullname
, st_addr
);
808 _djstat_flags
= save_djstat_flags
;
809 #endif /* __DJGPP__ > 1 */
817 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
818 Sfile_name_all_versions
, 2, 2, 0,
819 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
821 Lisp_Object file
, directory
;
823 return file_name_completion (file
, directory
, 1, 1);
826 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
827 doc
: /* Return the maximum number of versions allowed for FILE.
828 Returns nil if the file cannot be opened or if there is no version limit. */)
830 Lisp_Object filename
;
835 struct XABFHC xabfhc
;
838 filename
= Fexpand_file_name (filename
, Qnil
);
840 xabfhc
= cc$rms_xabfhc
;
841 fab
.fab$l_fna
= SDATA (filename
);
842 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
843 fab
.fab$l_xab
= (char *) &xabfhc
;
844 status
= sys$
open (&fab
, 0, 0);
845 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
847 sys$
close (&fab
, 0, 0);
848 if (xabfhc
.xab$w_verlimit
== 32767)
849 return Qnil
; /* No version limit */
851 return make_number (xabfhc
.xab$w_verlimit
);
860 return Fcons (make_number (time
>> 16),
861 Fcons (make_number (time
& 0177777), Qnil
));
864 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
865 doc
: /* Return a list of attributes of file FILENAME.
866 Value is nil if specified file cannot be opened.
868 ID-FORMAT specifies the preferred format of attributes uid and gid (see
869 below) - valid values are 'string and 'integer. The latter is the default,
870 but we plan to change that, so you should specify a non-nil value for
871 ID-FORMAT if you use the returned uid or gid.
873 Elements of the attribute list are:
874 0. t for directory, string (name linked to) for symbolic link, or nil.
875 1. Number of links to file.
876 2. File uid as a string or an integer. If a string value cannot be
877 looked up, the integer value is returned.
878 3. File gid, likewise.
879 4. Last access time, as a list of two integers.
880 First integer has high-order 16 bits of time, second has low 16 bits.
881 5. Last modification time, likewise.
882 6. Last status change time, likewise.
884 This is a floating point number if the size is too large for an integer.
885 8. File modes, as a string of ten letters or dashes as in ls -l.
886 9. t iff file's gid would change if file were deleted and recreated.
887 10. inode number. If inode number is larger than the Emacs integer,
888 this is a cons cell containing two integers: first the high part,
889 then the low 16 bits.
890 11. Device number. If it is larger than the Emacs integer, this is
891 a cons cell, similar to the inode number. */)
892 (filename
, id_format
)
893 Lisp_Object filename
, id_format
;
895 Lisp_Object values
[12];
900 #if defined (BSD4_2) || defined (BSD4_3)
908 filename
= Fexpand_file_name (filename
, Qnil
);
910 /* If the file name has special constructs in it,
911 call the corresponding file handler. */
912 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
914 { /* Only pass the extra arg if it is used to help backward compatibility
915 with old file handlers which do not implement the new arg. --Stef */
916 if (NILP (id_format
))
917 return call2 (handler
, Qfile_attributes
, filename
);
919 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
923 encoded
= ENCODE_FILE (filename
);
926 if (lstat (SDATA (encoded
), &s
) < 0)
929 switch (s
.st_mode
& S_IFMT
)
932 values
[0] = Qnil
; break;
934 values
[0] = Qt
; break;
937 values
[0] = Ffile_symlink_p (filename
); break;
940 values
[1] = make_number (s
.st_nlink
);
941 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
943 values
[2] = make_number (s
.st_uid
);
944 values
[3] = make_number (s
.st_gid
);
948 pw
= (struct passwd
*) getpwuid (s
.st_uid
);
949 values
[2] = (pw
? build_string (pw
->pw_name
) : make_number (s
.st_uid
));
950 gr
= (struct group
*) getgrgid (s
.st_gid
);
951 values
[3] = (gr
? build_string (gr
->gr_name
) : make_number (s
.st_gid
));
953 values
[4] = make_time (s
.st_atime
);
954 values
[5] = make_time (s
.st_mtime
);
955 values
[6] = make_time (s
.st_ctime
);
956 values
[7] = make_number (s
.st_size
);
957 /* If the size is out of range for an integer, return a float. */
958 if (XINT (values
[7]) != s
.st_size
)
959 values
[7] = make_float ((double)s
.st_size
);
960 /* If the size is negative, and its type is long, convert it back to
962 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
963 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
965 filemodestring (&s
, modes
);
966 values
[8] = make_string (modes
, 10);
967 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
968 dirname
= Ffile_name_directory (filename
);
969 if (! NILP (dirname
))
970 encoded
= ENCODE_FILE (dirname
);
971 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
972 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
973 else /* if we can't tell, assume worst */
975 #else /* file gid will be egid */
976 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
977 #endif /* BSD4_2 (or BSD4_3) */
978 if (FIXNUM_OVERFLOW_P (s
.st_ino
))
979 /* To allow inode numbers larger than VALBITS, separate the bottom
981 values
[10] = Fcons (make_number (s
.st_ino
>> 16),
982 make_number (s
.st_ino
& 0xffff));
984 /* But keep the most common cases as integers. */
985 values
[10] = make_number (s
.st_ino
);
987 /* Likewise for device. */
988 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
989 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
990 make_number (s
.st_dev
& 0xffff));
992 values
[11] = make_number (s
.st_dev
);
994 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
997 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
998 doc
: /* Return t if first arg file attributes list is less than second.
999 Comparison is in lexicographic order and case is significant. */)
1003 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1009 Qdirectory_files
= intern ("directory-files");
1010 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1011 Qfile_name_completion
= intern ("file-name-completion");
1012 Qfile_name_all_completions
= intern ("file-name-all-completions");
1013 Qfile_attributes
= intern ("file-attributes");
1014 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1016 staticpro (&Qdirectory_files
);
1017 staticpro (&Qdirectory_files_and_attributes
);
1018 staticpro (&Qfile_name_completion
);
1019 staticpro (&Qfile_name_all_completions
);
1020 staticpro (&Qfile_attributes
);
1021 staticpro (&Qfile_attributes_lessp
);
1023 defsubr (&Sdirectory_files
);
1024 defsubr (&Sdirectory_files_and_attributes
);
1025 defsubr (&Sfile_name_completion
);
1027 defsubr (&Sfile_name_all_versions
);
1028 defsubr (&Sfile_version_limit
);
1030 defsubr (&Sfile_name_all_completions
);
1031 defsubr (&Sfile_attributes
);
1032 defsubr (&Sfile_attributes_lessp
);
1035 Qcompletion_ignore_case
= intern ("completion-ignore-case");
1036 staticpro (&Qcompletion_ignore_case
);
1039 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1040 doc
: /* Completion ignores file names ending in any string in this list.
1041 It does not ignore them if all possible completions end in one of
1042 these strings or when displaying a list of completions.
1043 It ignores directory names if they match any string in this list which
1044 ends in a slash. */);
1045 Vcompletion_ignored_extensions
= Qnil
;
1048 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1049 (do not change this comment) */