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"
104 /* Returns a search buffer, with a fastmap allocated and ready to go. */
105 extern struct re_pattern_buffer
*compile_pattern ();
107 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
108 extern void filemodestring
P_ ((struct stat
*, char *));
110 /* if system does not have symbolic links, it does not have lstat.
111 In that case, use ordinary stat instead. */
117 extern int completion_ignore_case
;
118 extern Lisp_Object Vcompletion_regexp_list
;
120 Lisp_Object Vcompletion_ignored_extensions
;
121 Lisp_Object Qcompletion_ignore_case
;
122 Lisp_Object Qdirectory_files
;
123 Lisp_Object Qdirectory_files_and_attributes
;
124 Lisp_Object Qfile_name_completion
;
125 Lisp_Object Qfile_name_all_completions
;
126 Lisp_Object Qfile_attributes
;
127 Lisp_Object Qfile_attributes_lessp
;
129 static int scmp
P_ ((unsigned char *, unsigned char *, int));
133 directory_files_internal_unwind (dh
)
136 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
141 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
142 When ATTRS is zero, return a list of directory filenames; when
143 non-zero, return a list of directory filenames and their attributes.
144 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
147 directory_files_internal (directory
, full
, match
, nosort
, attrs
, id_format
)
148 Lisp_Object directory
, full
, match
, nosort
;
150 Lisp_Object id_format
;
153 int directory_nbytes
;
154 Lisp_Object list
, dirfilename
, encoded_directory
;
155 struct re_pattern_buffer
*bufp
= NULL
;
157 int count
= SPECPDL_INDEX ();
158 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 d
= opendir (SDATA (dirfilename
));
195 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
197 /* Unfortunately, we can now invoke expand-file-name and
198 file-attributes on filenames, both of which can throw, so we must
199 do a proper unwind-protect. */
200 record_unwind_protect (directory_files_internal_unwind
,
201 make_save_value (d
, 0));
203 directory_nbytes
= SBYTES (directory
);
204 re_match_object
= Qt
;
206 /* Decide whether we need to add a directory separator. */
208 if (directory_nbytes
== 0
209 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
213 /* Loop reading blocks until EOF or error. */
232 if (DIRENTRY_NONEMPTY (dp
))
236 Lisp_Object name
, finalname
;
237 struct gcpro gcpro1
, gcpro2
;
240 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
241 GCPRO2 (finalname
, name
);
243 /* Note: ENCODE_FILE can GC; it should protect its argument,
245 name
= DECODE_FILE (name
);
248 /* Now that we have unwind_protect in place, we might as well
249 allow matching to be interrupted. */
254 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
263 Lisp_Object fullname
;
264 int nbytes
= len
+ directory_nbytes
+ needsep
;
267 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
268 bcopy (SDATA (directory
), SDATA (fullname
),
272 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
275 SDATA (fullname
) + directory_nbytes
+ needsep
,
278 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
280 /* Some bug somewhere. */
284 STRING_SET_CHARS (fullname
, nchars
);
285 if (nchars
== nbytes
)
286 STRING_SET_UNIBYTE (fullname
);
288 finalname
= fullname
;
295 /* Construct an expanded filename for the directory entry.
296 Use the decoded names for input to Ffile_attributes. */
297 Lisp_Object decoded_fullname
, fileattrs
;
298 struct gcpro gcpro1
, gcpro2
;
300 decoded_fullname
= fileattrs
= Qnil
;
301 GCPRO2 (decoded_fullname
, fileattrs
);
303 /* Both Fexpand_file_name and Ffile_attributes can GC. */
304 decoded_fullname
= Fexpand_file_name (name
, directory
);
305 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
307 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
311 list
= Fcons (finalname
, list
);
320 /* Discard the unwind protect. */
321 specpdl_ptr
= specpdl
+ count
;
324 list
= Fsort (Fnreverse (list
),
325 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
327 RETURN_UNGCPRO (list
);
331 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
332 doc
: /* Return a list of names of files in DIRECTORY.
333 There are three optional arguments:
334 If FULL is non-nil, return absolute file names. Otherwise return names
335 that are relative to the specified directory.
336 If MATCH is non-nil, mention only file names that match the regexp MATCH.
337 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
338 NOSORT is useful if you plan to sort the result yourself. */)
339 (directory
, full
, match
, nosort
)
340 Lisp_Object directory
, full
, match
, nosort
;
343 directory
= Fexpand_file_name (directory
, Qnil
);
345 /* If the file name has special constructs in it,
346 call the corresponding file handler. */
347 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
349 return call5 (handler
, Qdirectory_files
, directory
,
350 full
, match
, nosort
);
352 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
355 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
356 Sdirectory_files_and_attributes
, 1, 5, 0,
357 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
358 There are four optional arguments:
359 If FULL is non-nil, return absolute file names. Otherwise return names
360 that are relative to the specified directory.
361 If MATCH is non-nil, mention only file names that match the regexp MATCH.
362 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
363 NOSORT is useful if you plan to sort the result yourself.
364 ID-FORMAT specifies the preferred format of attributes uid and gid, see
365 `file-attributes' for further documentation. */)
366 (directory
, full
, match
, nosort
, id_format
)
367 Lisp_Object directory
, full
, match
, nosort
, id_format
;
370 directory
= Fexpand_file_name (directory
, Qnil
);
372 /* If the file name has special constructs in it,
373 call the corresponding file handler. */
374 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
376 return call6 (handler
, Qdirectory_files_and_attributes
,
377 directory
, full
, match
, nosort
, id_format
);
379 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
383 Lisp_Object
file_name_completion ();
385 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
387 doc
: /* Complete file name FILE in directory DIRECTORY.
388 Returns the longest string
389 common to all file names in DIRECTORY that start with FILE.
390 If there is only one and FILE matches it exactly, returns t.
391 Returns nil if DIRECTORY contains no name starting with FILE.
393 This function ignores some of the possible completions as
394 determined by the variable `completion-ignored-extensions', which see. */)
396 Lisp_Object file
, directory
;
400 /* If the directory name has special constructs in it,
401 call the corresponding file handler. */
402 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
404 return call3 (handler
, Qfile_name_completion
, file
, directory
);
406 /* If the file name has special constructs in it,
407 call the corresponding file handler. */
408 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
410 return call3 (handler
, Qfile_name_completion
, file
, directory
);
412 return file_name_completion (file
, directory
, 0, 0);
415 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
416 Sfile_name_all_completions
, 2, 2, 0,
417 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
418 These are all file names in directory DIRECTORY which begin with FILE. */)
420 Lisp_Object file
, directory
;
424 /* If the directory name has special constructs in it,
425 call the corresponding file handler. */
426 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
428 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
430 /* If the file name has special constructs in it,
431 call the corresponding file handler. */
432 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
434 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
436 return file_name_completion (file
, directory
, 1, 0);
439 static int file_name_completion_stat ();
442 file_name_completion (file
, dirname
, all_flag
, ver_flag
)
443 Lisp_Object file
, dirname
;
444 int all_flag
, ver_flag
;
447 int bestmatchsize
= 0, skip
;
448 register int compare
, matchsize
;
449 unsigned char *p1
, *p2
;
451 Lisp_Object bestmatch
, tem
, elt
, name
;
452 Lisp_Object encoded_file
;
453 Lisp_Object encoded_dir
;
457 int count
= SPECPDL_INDEX ();
458 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
463 extern DIRENTRY
* readdirver ();
465 DIRENTRY
*((* readfunc
) ());
467 /* Filename completion on VMS ignores case, since VMS filesys does. */
468 specbind (Qcompletion_ignore_case
, Qt
);
472 readfunc
= readdirver
;
473 file
= Fupcase (file
);
478 #ifdef FILE_SYSTEM_CASE
479 file
= FILE_SYSTEM_CASE (file
);
482 encoded_file
= encoded_dir
= Qnil
;
483 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
484 dirname
= Fexpand_file_name (dirname
, Qnil
);
486 /* Do completion on the encoded file name
487 because the other names in the directory are (we presume)
488 encoded likewise. We decode the completed string at the end. */
489 encoded_file
= ENCODE_FILE (file
);
491 encoded_dir
= ENCODE_FILE (dirname
);
493 /* With passcount = 0, ignore files that end in an ignored extension.
494 If nothing found then try again with passcount = 1, don't ignore them.
495 If looking for all completions, start with passcount = 1,
496 so always take even the ignored ones.
498 ** It would not actually be helpful to the user to ignore any possible
499 completions when making a list of them.** */
501 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
503 int inner_count
= SPECPDL_INDEX ();
505 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
507 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
509 record_unwind_protect (directory_files_internal_unwind
,
510 make_save_value (d
, 0));
512 /* Loop reading blocks */
513 /* (att3b compiler bug requires do a null comparison this way) */
520 dp
= (*readfunc
) (d
);
540 if (! DIRENTRY_NONEMPTY (dp
)
541 || len
< SCHARS (encoded_file
)
542 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
543 SCHARS (encoded_file
)))
546 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
549 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
553 #ifndef TRIVIAL_DIRECTORY_ENTRY
554 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
556 /* "." and ".." are never interesting as completions, but are
557 actually in the way in a directory contains only one file. */
558 if (!passcount
&& TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
560 if (!passcount
&& len
> SCHARS (encoded_file
))
561 /* Ignore directories if they match an element of
562 completion-ignored-extensions which ends in a slash. */
563 for (tem
= Vcompletion_ignored_extensions
;
564 CONSP (tem
); tem
= XCDR (tem
))
571 /* Need to encode ELT, since scmp compares unibyte
573 elt
= ENCODE_FILE (elt
);
574 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
578 if (p1
[elt_len
] != '/')
580 skip
= len
- elt_len
;
584 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
591 /* Compare extensions-to-be-ignored against end of this file name */
592 /* if name is not an exact match against specified string */
593 if (!passcount
&& len
> SCHARS (encoded_file
))
594 /* and exit this for loop if a match is found */
595 for (tem
= Vcompletion_ignored_extensions
;
596 CONSP (tem
); tem
= XCDR (tem
))
599 if (!STRINGP (elt
)) continue;
600 /* Need to encode ELT, since scmp compares unibyte
602 elt
= ENCODE_FILE (elt
);
603 skip
= len
- SCHARS (elt
);
604 if (skip
< 0) continue;
606 if (0 <= scmp (dp
->d_name
+ skip
,
614 /* If an ignored-extensions match was found,
615 don't process this name as a completion. */
616 if (!passcount
&& CONSP (tem
))
623 XSETFASTINT (zero
, 0);
625 /* Ignore this element if it fails to match all the regexps. */
626 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
627 regexps
= XCDR (regexps
))
629 tem
= Fstring_match (XCAR (regexps
),
630 make_string (dp
->d_name
, len
), zero
);
638 /* Update computation of how much all possible completions match */
642 if (all_flag
|| NILP (bestmatch
))
644 /* This is a possible completion */
647 /* This completion is a directory; make it end with '/' */
648 name
= Ffile_name_as_directory (make_string (dp
->d_name
, len
));
651 name
= make_string (dp
->d_name
, len
);
654 name
= DECODE_FILE (name
);
655 bestmatch
= Fcons (name
, bestmatch
);
660 bestmatchsize
= SCHARS (name
);
665 compare
= min (bestmatchsize
, len
);
666 p1
= SDATA (bestmatch
);
667 p2
= (unsigned char *) dp
->d_name
;
668 matchsize
= scmp(p1
, p2
, compare
);
671 if (completion_ignore_case
)
673 /* If this is an exact match except for case,
674 use it as the best match rather than one that is not
675 an exact match. This way, we get the case pattern
676 of the actual match. */
677 /* This tests that the current file is an exact match
678 but BESTMATCH is not (it is too long). */
679 if ((matchsize
== len
680 && matchsize
+ !!directoryp
681 < SCHARS (bestmatch
))
683 /* If there is no exact match ignoring case,
684 prefer a match that does not change the case
686 /* If there is more than one exact match aside from
687 case, and one of them is exact including case,
689 /* This == checks that, of current file and BESTMATCH,
690 either both or neither are exact. */
693 (matchsize
+ !!directoryp
694 == SCHARS (bestmatch
)))
695 && !bcmp (p2
, SDATA (encoded_file
), SCHARS (encoded_file
))
696 && bcmp (p1
, SDATA (encoded_file
), SCHARS (encoded_file
))))
698 bestmatch
= make_string (dp
->d_name
, len
);
700 bestmatch
= Ffile_name_as_directory (bestmatch
);
704 /* If this dirname all matches, see if implicit following
707 && compare
== matchsize
708 && bestmatchsize
> matchsize
709 && IS_ANY_SEP (p1
[matchsize
]))
711 bestmatchsize
= matchsize
;
714 /* This closes the directory. */
715 bestmatch
= unbind_to (inner_count
, bestmatch
);
719 bestmatch
= unbind_to (count
, bestmatch
);
721 if (all_flag
|| NILP (bestmatch
))
723 if (STRINGP (bestmatch
))
724 bestmatch
= DECODE_FILE (bestmatch
);
727 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
729 bestmatch
= Fsubstring (bestmatch
, make_number (0),
730 make_number (bestmatchsize
));
731 /* Now that we got the right initial segment of BESTMATCH,
732 decode it from the coding system in use. */
733 bestmatch
= DECODE_FILE (bestmatch
);
737 /* Compare exactly LEN chars of strings at S1 and S2,
738 ignoring case if appropriate.
739 Return -1 if strings match,
740 else number of chars that match at the beginning. */
744 register unsigned char *s1
, *s2
;
747 register int l
= len
;
749 if (completion_ignore_case
)
751 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
756 while (l
&& *s1
++ == *s2
++)
766 file_name_completion_stat (dirname
, dp
, st_addr
)
769 struct stat
*st_addr
;
771 int len
= NAMLEN (dp
);
772 int pos
= SCHARS (dirname
);
774 char *fullname
= (char *) alloca (len
+ pos
+ 2);
778 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
779 but aren't required here. Avoid computing the following fields:
780 st_inode, st_size and st_nlink for directories, and the execute bits
781 in st_mode for non-directory files with non-standard extensions. */
783 unsigned short save_djstat_flags
= _djstat_flags
;
785 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
786 #endif /* __DJGPP__ > 1 */
789 bcopy (SDATA (dirname
), fullname
, pos
);
791 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
792 fullname
[pos
++] = DIRECTORY_SEP
;
795 bcopy (dp
->d_name
, fullname
+ pos
, len
);
796 fullname
[pos
+ len
] = 0;
799 /* We want to return success if a link points to a nonexistent file,
800 but we want to return the status for what the link points to,
801 in case it is a directory. */
802 value
= lstat (fullname
, st_addr
);
803 stat (fullname
, st_addr
);
806 value
= stat (fullname
, st_addr
);
809 _djstat_flags
= save_djstat_flags
;
810 #endif /* __DJGPP__ > 1 */
818 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
819 Sfile_name_all_versions
, 2, 2, 0,
820 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
822 Lisp_Object file
, directory
;
824 return file_name_completion (file
, directory
, 1, 1);
827 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
828 doc
: /* Return the maximum number of versions allowed for FILE.
829 Returns nil if the file cannot be opened or if there is no version limit. */)
831 Lisp_Object filename
;
836 struct XABFHC xabfhc
;
839 filename
= Fexpand_file_name (filename
, Qnil
);
841 xabfhc
= cc$rms_xabfhc
;
842 fab
.fab$l_fna
= SDATA (filename
);
843 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
844 fab
.fab$l_xab
= (char *) &xabfhc
;
845 status
= sys$
open (&fab
, 0, 0);
846 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
848 sys$
close (&fab
, 0, 0);
849 if (xabfhc
.xab$w_verlimit
== 32767)
850 return Qnil
; /* No version limit */
852 return make_number (xabfhc
.xab$w_verlimit
);
861 return Fcons (make_number (time
>> 16),
862 Fcons (make_number (time
& 0177777), Qnil
));
865 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
866 doc
: /* Return a list of attributes of file FILENAME.
867 Value is nil if specified file cannot be opened.
869 ID-FORMAT specifies the preferred format of attributes uid and gid (see
870 below) - valid values are 'string and 'integer. The latter is the default,
871 but we plan to change that, so you should specify a non-nil value for
872 ID-FORMAT if you use the returned uid or gid.
874 Elements of the attribute list are:
875 0. t for directory, string (name linked to) for symbolic link, or nil.
876 1. Number of links to file.
877 2. File uid as a string or an integer. If a string value cannot be
878 looked up, the integer value is returned.
879 3. File gid, likewise.
880 4. Last access time, as a list of two integers.
881 First integer has high-order 16 bits of time, second has low 16 bits.
882 5. Last modification time, likewise.
883 6. Last status change time, likewise.
885 This is a floating point number if the size is too large for an integer.
886 8. File modes, as a string of ten letters or dashes as in ls -l.
887 9. t iff file's gid would change if file were deleted and recreated.
888 10. inode number. If inode number is larger than the Emacs integer,
889 this is a cons cell containing two integers: first the high part,
890 then the low 16 bits.
891 11. Device number. If it is larger than the Emacs integer, this is
892 a cons cell, similar to the inode number. */)
893 (filename
, id_format
)
894 Lisp_Object filename
, id_format
;
896 Lisp_Object values
[12];
901 #if defined (BSD4_2) || defined (BSD4_3)
909 filename
= Fexpand_file_name (filename
, Qnil
);
911 /* If the file name has special constructs in it,
912 call the corresponding file handler. */
913 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
915 { /* Only pass the extra arg if it is used to help backward compatibility
916 with old file handlers which do not implement the new arg. --Stef */
917 if (NILP (id_format
))
918 return call2 (handler
, Qfile_attributes
, filename
);
920 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
924 encoded
= ENCODE_FILE (filename
);
927 if (lstat (SDATA (encoded
), &s
) < 0)
930 switch (s
.st_mode
& S_IFMT
)
933 values
[0] = Qnil
; break;
935 values
[0] = Qt
; break;
938 values
[0] = Ffile_symlink_p (filename
); break;
941 values
[1] = make_number (s
.st_nlink
);
942 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
944 values
[2] = make_number (s
.st_uid
);
945 values
[3] = make_number (s
.st_gid
);
949 pw
= (struct passwd
*) getpwuid (s
.st_uid
);
950 values
[2] = (pw
? build_string (pw
->pw_name
) : make_number (s
.st_uid
));
951 gr
= (struct group
*) getgrgid (s
.st_gid
);
952 values
[3] = (gr
? build_string (gr
->gr_name
) : make_number (s
.st_gid
));
954 values
[4] = make_time (s
.st_atime
);
955 values
[5] = make_time (s
.st_mtime
);
956 values
[6] = make_time (s
.st_ctime
);
957 values
[7] = make_number (s
.st_size
);
958 /* If the size is out of range for an integer, return a float. */
959 if (XINT (values
[7]) != s
.st_size
)
960 values
[7] = make_float ((double)s
.st_size
);
961 /* If the size is negative, and its type is long, convert it back to
963 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
964 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
966 filemodestring (&s
, modes
);
967 values
[8] = make_string (modes
, 10);
968 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
969 dirname
= Ffile_name_directory (filename
);
970 if (! NILP (dirname
))
971 encoded
= ENCODE_FILE (dirname
);
972 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
973 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
974 else /* if we can't tell, assume worst */
976 #else /* file gid will be egid */
977 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
978 #endif /* BSD4_2 (or BSD4_3) */
979 if (FIXNUM_OVERFLOW_P (s
.st_ino
))
980 /* To allow inode numbers larger than VALBITS, separate the bottom
982 values
[10] = Fcons (make_number (s
.st_ino
>> 16),
983 make_number (s
.st_ino
& 0xffff));
985 /* But keep the most common cases as integers. */
986 values
[10] = make_number (s
.st_ino
);
988 /* Likewise for device. */
989 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
990 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
991 make_number (s
.st_dev
& 0xffff));
993 values
[11] = make_number (s
.st_dev
);
995 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
998 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
999 doc
: /* Return t if first arg file attributes list is less than second.
1000 Comparison is in lexicographic order and case is significant. */)
1004 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1010 Qdirectory_files
= intern ("directory-files");
1011 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1012 Qfile_name_completion
= intern ("file-name-completion");
1013 Qfile_name_all_completions
= intern ("file-name-all-completions");
1014 Qfile_attributes
= intern ("file-attributes");
1015 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1017 staticpro (&Qdirectory_files
);
1018 staticpro (&Qdirectory_files_and_attributes
);
1019 staticpro (&Qfile_name_completion
);
1020 staticpro (&Qfile_name_all_completions
);
1021 staticpro (&Qfile_attributes
);
1022 staticpro (&Qfile_attributes_lessp
);
1024 defsubr (&Sdirectory_files
);
1025 defsubr (&Sdirectory_files_and_attributes
);
1026 defsubr (&Sfile_name_completion
);
1028 defsubr (&Sfile_name_all_versions
);
1029 defsubr (&Sfile_version_limit
);
1031 defsubr (&Sfile_name_all_completions
);
1032 defsubr (&Sfile_attributes
);
1033 defsubr (&Sfile_attributes_lessp
);
1036 Qcompletion_ignore_case
= intern ("completion-ignore-case");
1037 staticpro (&Qcompletion_ignore_case
);
1040 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1041 doc
: /* Completion ignores file names ending in any string in this list.
1042 It does not ignore them if all possible completions end in one of
1043 these strings or when displaying a list of completions.
1044 It ignores directory names if they match any string in this list which
1045 ends in a slash. */);
1046 Vcompletion_ignored_extensions
= Qnil
;
1049 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1050 (do not change this comment) */