1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001, 2004
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
;
120 extern Lisp_Object Fmsdos_downcase_filename
P_ ((Lisp_Object
));
123 Lisp_Object Vcompletion_ignored_extensions
;
124 Lisp_Object Qcompletion_ignore_case
;
125 Lisp_Object Qdirectory_files
;
126 Lisp_Object Qdirectory_files_and_attributes
;
127 Lisp_Object Qfile_name_completion
;
128 Lisp_Object Qfile_name_all_completions
;
129 Lisp_Object Qfile_attributes
;
130 Lisp_Object Qfile_attributes_lessp
;
132 static int scmp
P_ ((unsigned char *, unsigned char *, int));
136 directory_files_internal_unwind (dh
)
139 DIR *d
= (DIR *) ((XINT (XCAR (dh
)) << 16) + XINT (XCDR (dh
)));
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
;
165 /* Because of file name handlers, these functions might call
166 Ffuncall, and cause a GC. */
167 list
= encoded_directory
= dirfilename
= Qnil
;
168 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
169 dirfilename
= Fdirectory_file_name (directory
);
173 CHECK_STRING (match
);
175 /* MATCH might be a flawed regular expression. Rather than
176 catching and signaling our own errors, we just call
177 compile_pattern to do the work for us. */
178 /* Pass 1 for the MULTIBYTE arg
179 because we do make multibyte strings if the contents warrant. */
181 bufp
= compile_pattern (match
, 0,
182 buffer_defaults
.downcase_table
, 0, 1);
184 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
188 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
189 run_pre_post_conversion_on_str which calls Lisp directly and
191 dirfilename
= ENCODE_FILE (dirfilename
);
192 encoded_directory
= ENCODE_FILE (directory
);
194 /* Now *bufp is the compiled form of MATCH; don't call anything
195 which might compile a new regexp until we're done with the loop! */
197 /* Do this opendir after anything which might signal an error; if
198 an error is signaled while the directory stream is open, we
199 have to make sure it gets closed, and setting up an
200 unwind_protect to do so would be a pain. */
203 d
= opendir (SDATA (dirfilename
));
205 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
207 /* Unfortunately, we can now invoke expand-file-name and
208 file-attributes on filenames, both of which can throw, so we must
209 do a proper unwind-protect. */
210 record_unwind_protect (directory_files_internal_unwind
,
211 Fcons (make_number (((unsigned long) d
) >> 16),
212 make_number (((unsigned long) d
) & 0xffff)));
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. */
231 if (dp
== NULL
&& errno
== EAGAIN
)
238 if (DIRENTRY_NONEMPTY (dp
))
242 Lisp_Object name
, finalname
;
243 struct gcpro gcpro1
, gcpro2
;
246 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
247 GCPRO2 (finalname
, name
);
249 /* Note: ENCODE_FILE can GC; it should protect its argument,
251 name
= DECODE_FILE (name
);
254 /* Now that we have unwind_protect in place, we might as well
255 allow matching to be interrupted. */
260 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
269 Lisp_Object fullname
;
270 int nbytes
= len
+ directory_nbytes
+ needsep
;
273 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
274 bcopy (SDATA (directory
), SDATA (fullname
),
278 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
281 SDATA (fullname
) + directory_nbytes
+ needsep
,
284 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
286 /* Some bug somewhere. */
290 STRING_SET_CHARS (fullname
, nchars
);
291 if (nchars
== nbytes
)
292 STRING_SET_UNIBYTE (fullname
);
294 finalname
= fullname
;
301 /* Construct an expanded filename for the directory entry.
302 Use the decoded names for input to Ffile_attributes. */
303 Lisp_Object decoded_fullname
, fileattrs
;
304 struct gcpro gcpro1
, gcpro2
;
306 decoded_fullname
= fileattrs
= Qnil
;
307 GCPRO2 (decoded_fullname
, fileattrs
);
309 /* Both Fexpand_file_name and Ffile_attributes can GC. */
310 decoded_fullname
= Fexpand_file_name (name
, directory
);
311 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
313 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
317 list
= Fcons (finalname
, list
);
326 retry_p
|= errno
== EINTR
;
331 /* Discard the unwind protect. */
332 specpdl_ptr
= specpdl
+ count
;
341 list
= Fsort (Fnreverse (list
),
342 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
344 RETURN_UNGCPRO (list
);
348 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
349 doc
: /* Return a list of names of files in DIRECTORY.
350 There are three optional arguments:
351 If FULL is non-nil, return absolute file names. Otherwise return names
352 that are relative to the specified directory.
353 If MATCH is non-nil, mention only file names that match the regexp MATCH.
354 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
355 NOSORT is useful if you plan to sort the result yourself. */)
356 (directory
, full
, match
, nosort
)
357 Lisp_Object directory
, full
, match
, nosort
;
360 directory
= Fexpand_file_name (directory
, Qnil
);
362 /* If the file name has special constructs in it,
363 call the corresponding file handler. */
364 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
366 return call5 (handler
, Qdirectory_files
, directory
,
367 full
, match
, nosort
);
369 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
372 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
373 Sdirectory_files_and_attributes
, 1, 5, 0,
374 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
375 There are four optional arguments:
376 If FULL is non-nil, return absolute file names. Otherwise return names
377 that are relative to the specified directory.
378 If MATCH is non-nil, mention only file names that match the regexp MATCH.
379 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
380 NOSORT is useful if you plan to sort the result yourself.
381 ID-FORMAT specifies the preferred format of attributes uid and gid, see
382 `file-attributes' for further documentation. */)
383 (directory
, full
, match
, nosort
, id_format
)
384 Lisp_Object directory
, full
, match
, nosort
, id_format
;
387 directory
= Fexpand_file_name (directory
, Qnil
);
389 /* If the file name has special constructs in it,
390 call the corresponding file handler. */
391 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
393 return call6 (handler
, Qdirectory_files_and_attributes
,
394 directory
, full
, match
, nosort
, id_format
);
396 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
400 Lisp_Object
file_name_completion ();
402 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
404 doc
: /* Complete file name FILE in directory DIRECTORY.
405 Returns the longest string
406 common to all file names in DIRECTORY that start with FILE.
407 If there is only one and FILE matches it exactly, returns t.
408 Returns nil if DIR contains no name starting with FILE.
410 This function ignores some of the possible completions as
411 determined by the variable `completion-ignored-extensions', which see. */)
413 Lisp_Object file
, directory
;
417 /* If the directory name has special constructs in it,
418 call the corresponding file handler. */
419 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
421 return call3 (handler
, Qfile_name_completion
, file
, directory
);
423 /* If the file name has special constructs in it,
424 call the corresponding file handler. */
425 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
427 return call3 (handler
, Qfile_name_completion
, file
, directory
);
429 return file_name_completion (file
, directory
, 0, 0);
432 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
433 Sfile_name_all_completions
, 2, 2, 0,
434 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
435 These are all file names in directory DIRECTORY which begin with FILE. */)
437 Lisp_Object file
, directory
;
441 /* If the directory name has special constructs in it,
442 call the corresponding file handler. */
443 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
445 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
447 /* If the file name has special constructs in it,
448 call the corresponding file handler. */
449 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
451 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
453 return file_name_completion (file
, directory
, 1, 0);
456 static int file_name_completion_stat ();
459 file_name_completion (file
, dirname
, all_flag
, ver_flag
)
460 Lisp_Object file
, dirname
;
461 int all_flag
, ver_flag
;
464 int bestmatchsize
= 0, skip
;
465 register int compare
, matchsize
;
466 unsigned char *p1
, *p2
;
468 Lisp_Object bestmatch
, tem
, elt
, name
;
469 Lisp_Object encoded_file
;
470 Lisp_Object encoded_dir
;
474 int count
= SPECPDL_INDEX ();
475 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
480 extern DIRENTRY
* readdirver ();
482 DIRENTRY
*((* readfunc
) ());
484 /* Filename completion on VMS ignores case, since VMS filesys does. */
485 specbind (Qcompletion_ignore_case
, Qt
);
489 readfunc
= readdirver
;
490 file
= Fupcase (file
);
495 #ifdef FILE_SYSTEM_CASE
496 file
= FILE_SYSTEM_CASE (file
);
499 encoded_file
= encoded_dir
= Qnil
;
500 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
501 dirname
= Fexpand_file_name (dirname
, Qnil
);
503 /* Do completion on the encoded file name
504 because the other names in the directory are (we presume)
505 encoded likewise. We decode the completed string at the end. */
506 encoded_file
= ENCODE_FILE (file
);
508 encoded_dir
= ENCODE_FILE (dirname
);
510 /* With passcount = 0, ignore files that end in an ignored extension.
511 If nothing found then try again with passcount = 1, don't ignore them.
512 If looking for all completions, start with passcount = 1,
513 so always take even the ignored ones.
515 ** It would not actually be helpful to the user to ignore any possible
516 completions when making a list of them.** */
518 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
520 int inner_count
= SPECPDL_INDEX ();
522 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
524 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
526 record_unwind_protect (directory_files_internal_unwind
,
527 Fcons (make_number (((unsigned long) d
) >> 16),
528 make_number (((unsigned long) d
) & 0xffff)));
530 /* Loop reading blocks */
531 /* (att3b compiler bug requires do a null comparison this way) */
538 dp
= (*readfunc
) (d
);
547 if (! DIRENTRY_NONEMPTY (dp
)
548 || len
< SCHARS (encoded_file
)
549 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
550 SCHARS (encoded_file
)))
553 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
556 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
560 #ifndef TRIVIAL_DIRECTORY_ENTRY
561 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
563 /* "." and ".." are never interesting as completions, but are
564 actually in the way in a directory contains only one file. */
565 if (!passcount
&& TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
567 if (!passcount
&& len
> SCHARS (encoded_file
))
568 /* Ignore directories if they match an element of
569 completion-ignored-extensions which ends in a slash. */
570 for (tem
= Vcompletion_ignored_extensions
;
571 CONSP (tem
); tem
= XCDR (tem
))
578 /* Need to encode ELT, since scmp compares unibyte
580 elt
= ENCODE_FILE (elt
);
581 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
585 if (p1
[elt_len
] != '/')
587 skip
= len
- elt_len
;
591 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
598 /* Compare extensions-to-be-ignored against end of this file name */
599 /* if name is not an exact match against specified string */
600 if (!passcount
&& len
> SCHARS (encoded_file
))
601 /* and exit this for loop if a match is found */
602 for (tem
= Vcompletion_ignored_extensions
;
603 CONSP (tem
); tem
= XCDR (tem
))
606 if (!STRINGP (elt
)) continue;
607 /* Need to encode ELT, since scmp compares unibyte
609 elt
= ENCODE_FILE (elt
);
610 skip
= len
- SCHARS (elt
);
611 if (skip
< 0) continue;
613 if (0 <= scmp (dp
->d_name
+ skip
,
621 /* If an ignored-extensions match was found,
622 don't process this name as a completion. */
623 if (!passcount
&& CONSP (tem
))
630 XSETFASTINT (zero
, 0);
632 /* Ignore this element if it fails to match all the regexps. */
633 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
634 regexps
= XCDR (regexps
))
636 tem
= Fstring_match (XCAR (regexps
),
637 make_string (dp
->d_name
, len
), zero
);
645 /* Update computation of how much all possible completions match */
649 if (all_flag
|| NILP (bestmatch
))
651 /* This is a possible completion */
654 /* This completion is a directory; make it end with '/' */
655 name
= Ffile_name_as_directory (make_string (dp
->d_name
, len
));
658 name
= make_string (dp
->d_name
, len
);
661 name
= DECODE_FILE (name
);
662 bestmatch
= Fcons (name
, bestmatch
);
667 bestmatchsize
= SCHARS (name
);
672 compare
= min (bestmatchsize
, len
);
673 p1
= SDATA (bestmatch
);
674 p2
= (unsigned char *) dp
->d_name
;
675 matchsize
= scmp(p1
, p2
, compare
);
678 if (completion_ignore_case
)
680 /* If this is an exact match except for case,
681 use it as the best match rather than one that is not
682 an exact match. This way, we get the case pattern
683 of the actual match. */
684 /* This tests that the current file is an exact match
685 but BESTMATCH is not (it is too long). */
686 if ((matchsize
== len
687 && matchsize
+ !!directoryp
688 < SCHARS (bestmatch
))
690 /* If there is no exact match ignoring case,
691 prefer a match that does not change the case
693 /* If there is more than one exact match aside from
694 case, and one of them is exact including case,
696 /* This == checks that, of current file and BESTMATCH,
697 either both or neither are exact. */
700 (matchsize
+ !!directoryp
701 == SCHARS (bestmatch
)))
702 && !bcmp (p2
, SDATA (encoded_file
), SCHARS (encoded_file
))
703 && bcmp (p1
, SDATA (encoded_file
), SCHARS (encoded_file
))))
705 bestmatch
= make_string (dp
->d_name
, len
);
707 bestmatch
= Ffile_name_as_directory (bestmatch
);
711 /* If this dirname all matches, see if implicit following
714 && compare
== matchsize
715 && bestmatchsize
> matchsize
716 && IS_ANY_SEP (p1
[matchsize
]))
718 bestmatchsize
= matchsize
;
721 /* This closes the directory. */
722 bestmatch
= unbind_to (inner_count
, bestmatch
);
726 bestmatch
= unbind_to (count
, bestmatch
);
728 if (all_flag
|| NILP (bestmatch
))
730 if (STRINGP (bestmatch
))
731 bestmatch
= DECODE_FILE (bestmatch
);
734 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
736 bestmatch
= Fsubstring (bestmatch
, make_number (0),
737 make_number (bestmatchsize
));
738 /* Now that we got the right initial segment of BESTMATCH,
739 decode it from the coding system in use. */
740 bestmatch
= DECODE_FILE (bestmatch
);
744 /* Compare exactly LEN chars of strings at S1 and S2,
745 ignoring case if appropriate.
746 Return -1 if strings match,
747 else number of chars that match at the beginning. */
751 register unsigned char *s1
, *s2
;
754 register int l
= len
;
756 if (completion_ignore_case
)
758 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
763 while (l
&& *s1
++ == *s2
++)
773 file_name_completion_stat (dirname
, dp
, st_addr
)
776 struct stat
*st_addr
;
778 int len
= NAMLEN (dp
);
779 int pos
= SCHARS (dirname
);
781 char *fullname
= (char *) alloca (len
+ pos
+ 2);
785 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
786 but aren't required here. Avoid computing the following fields:
787 st_inode, st_size and st_nlink for directories, and the execute bits
788 in st_mode for non-directory files with non-standard extensions. */
790 unsigned short save_djstat_flags
= _djstat_flags
;
792 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
793 #endif /* __DJGPP__ > 1 */
796 bcopy (SDATA (dirname
), fullname
, pos
);
798 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
799 fullname
[pos
++] = DIRECTORY_SEP
;
802 bcopy (dp
->d_name
, fullname
+ pos
, len
);
803 fullname
[pos
+ len
] = 0;
806 /* We want to return success if a link points to a nonexistent file,
807 but we want to return the status for what the link points to,
808 in case it is a directory. */
809 value
= lstat (fullname
, st_addr
);
810 stat (fullname
, st_addr
);
813 value
= stat (fullname
, st_addr
);
816 _djstat_flags
= save_djstat_flags
;
817 #endif /* __DJGPP__ > 1 */
825 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
826 Sfile_name_all_versions
, 2, 2, 0,
827 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
829 Lisp_Object file
, directory
;
831 return file_name_completion (file
, directory
, 1, 1);
834 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
835 doc
: /* Return the maximum number of versions allowed for FILE.
836 Returns nil if the file cannot be opened or if there is no version limit. */)
838 Lisp_Object filename
;
843 struct XABFHC xabfhc
;
846 filename
= Fexpand_file_name (filename
, Qnil
);
848 xabfhc
= cc$rms_xabfhc
;
849 fab
.fab$l_fna
= SDATA (filename
);
850 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
851 fab
.fab$l_xab
= (char *) &xabfhc
;
852 status
= sys$
open (&fab
, 0, 0);
853 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
855 sys$
close (&fab
, 0, 0);
856 if (xabfhc
.xab$w_verlimit
== 32767)
857 return Qnil
; /* No version limit */
859 return make_number (xabfhc
.xab$w_verlimit
);
868 return Fcons (make_number (time
>> 16),
869 Fcons (make_number (time
& 0177777), Qnil
));
872 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
873 doc
: /* Return a list of attributes of file FILENAME.
874 Value is nil if specified file cannot be opened.
876 ID-FORMAT specifies the preferred format of attributes uid and gid (see
877 below) - valid values are 'string and 'integer. The latter is the default,
878 but we plan to change that, so you should specify a non-nil value for
879 ID-FORMAT if you use the returned uid or gid.
881 Elements of the attribute list are:
882 0. t for directory, string (name linked to) for symbolic link, or nil.
883 1. Number of links to file.
884 2. File uid as a string or an integer. If a string value cannot be
885 looked up, the integer value is returned.
886 3. File gid, likewise.
887 4. Last access time, as a list of two integers.
888 First integer has high-order 16 bits of time, second has low 16 bits.
889 5. Last modification time, likewise.
890 6. Last status change time, likewise.
892 This is a floating point number if the size is too large for an integer.
893 8. File modes, as a string of ten letters or dashes as in ls -l.
894 9. t iff file's gid would change if file were deleted and recreated.
895 10. inode number. If inode number is larger than the Emacs integer,
896 this is a cons cell containing two integers: first the high part,
897 then the low 16 bits.
898 11. Device number. If it is larger than the Emacs integer, this is
899 a cons cell, similar to the inode number. */)
900 (filename
, id_format
)
901 Lisp_Object filename
, id_format
;
903 Lisp_Object values
[12];
908 #if defined (BSD4_2) || defined (BSD4_3)
915 filename
= Fexpand_file_name (filename
, Qnil
);
917 /* If the file name has special constructs in it,
918 call the corresponding file handler. */
919 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
921 { /* Only pass the extra arg if it is used to help backward compatibility
922 with old file handlers which do not implement the new arg. --Stef */
923 if (NILP (id_format
))
924 return call2 (handler
, Qfile_attributes
, filename
);
926 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
929 encoded
= ENCODE_FILE (filename
);
931 if (lstat (SDATA (encoded
), &s
) < 0)
934 switch (s
.st_mode
& S_IFMT
)
937 values
[0] = Qnil
; break;
939 values
[0] = Qt
; break;
942 values
[0] = Ffile_symlink_p (filename
); break;
945 values
[1] = make_number (s
.st_nlink
);
946 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
948 values
[2] = make_number (s
.st_uid
);
949 values
[3] = make_number (s
.st_gid
);
953 pw
= (struct passwd
*) getpwuid (s
.st_uid
);
954 values
[2] = (pw
? build_string (pw
->pw_name
) : make_number (s
.st_uid
));
955 gr
= (struct group
*) getgrgid (s
.st_gid
);
956 values
[3] = (gr
? build_string (gr
->gr_name
) : make_number (s
.st_gid
));
958 values
[4] = make_time (s
.st_atime
);
959 values
[5] = make_time (s
.st_mtime
);
960 values
[6] = make_time (s
.st_ctime
);
961 values
[7] = make_number (s
.st_size
);
962 /* If the size is out of range for an integer, return a float. */
963 if (XINT (values
[7]) != s
.st_size
)
964 values
[7] = make_float ((double)s
.st_size
);
965 /* If the size is negative, and its type is long, convert it back to
967 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
968 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
970 filemodestring (&s
, modes
);
971 values
[8] = make_string (modes
, 10);
972 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
973 dirname
= Ffile_name_directory (filename
);
974 if (! NILP (dirname
))
975 encoded
= ENCODE_FILE (dirname
);
976 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
977 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
978 else /* if we can't tell, assume worst */
980 #else /* file gid will be egid */
981 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
982 #endif /* BSD4_2 (or BSD4_3) */
983 if (FIXNUM_OVERFLOW_P (s
.st_ino
))
984 /* To allow inode numbers larger than VALBITS, separate the bottom
986 values
[10] = Fcons (make_number (s
.st_ino
>> 16),
987 make_number (s
.st_ino
& 0xffff));
989 /* But keep the most common cases as integers. */
990 values
[10] = make_number (s
.st_ino
);
992 /* Likewise for device. */
993 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
994 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
995 make_number (s
.st_dev
& 0xffff));
997 values
[11] = make_number (s
.st_dev
);
999 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1002 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1003 doc
: /* Return t if first arg file attributes list is less than second.
1004 Comparison is in lexicographic order and case is significant. */)
1008 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1014 Qdirectory_files
= intern ("directory-files");
1015 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1016 Qfile_name_completion
= intern ("file-name-completion");
1017 Qfile_name_all_completions
= intern ("file-name-all-completions");
1018 Qfile_attributes
= intern ("file-attributes");
1019 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1021 staticpro (&Qdirectory_files
);
1022 staticpro (&Qdirectory_files_and_attributes
);
1023 staticpro (&Qfile_name_completion
);
1024 staticpro (&Qfile_name_all_completions
);
1025 staticpro (&Qfile_attributes
);
1026 staticpro (&Qfile_attributes_lessp
);
1028 defsubr (&Sdirectory_files
);
1029 defsubr (&Sdirectory_files_and_attributes
);
1030 defsubr (&Sfile_name_completion
);
1032 defsubr (&Sfile_name_all_versions
);
1033 defsubr (&Sfile_version_limit
);
1035 defsubr (&Sfile_name_all_completions
);
1036 defsubr (&Sfile_attributes
);
1037 defsubr (&Sfile_attributes_lessp
);
1040 Qcompletion_ignore_case
= intern ("completion-ignore-case");
1041 staticpro (&Qcompletion_ignore_case
);
1044 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1045 doc
: /* *Completion ignores filenames ending in any string in this list.
1046 Directories are ignored if they match any string in this list which
1048 This variable does not affect lists of possible completions,
1049 but does affect the commands that actually do completions. */);
1050 Vcompletion_ignored_extensions
= Qnil
;
1053 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1054 (do not change this comment) */