1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
26 #include <sys/types.h>
48 /* The d_nameln member of a struct dirent includes the '\0' character
49 on some systems, but not on others. What's worse, you can't tell
50 at compile-time which one it will be, since it really depends on
51 the sort of system providing the filesystem you're reading from,
52 not the system you are running on. Paul Eggert
53 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
54 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
55 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
57 Since applying strlen to the name always works, we'll just do that. */
58 #define NAMLEN(p) strlen (p->d_name)
60 #ifdef SYSV_SYSTEM_DIR
63 #define DIRENTRY struct dirent
65 #else /* not SYSV_SYSTEM_DIR */
67 #ifdef NONSYSTEM_DIR_LIBRARY
69 #else /* not NONSYSTEM_DIR_LIBRARY */
75 #endif /* not NONSYSTEM_DIR_LIBRARY */
80 #define DIRENTRY struct direct
82 extern DIR *opendir ();
83 extern struct direct
*readdir ();
85 #endif /* not MSDOS */
86 #endif /* not SYSV_SYSTEM_DIR */
88 /* Some versions of Cygwin don't have d_ino in `struct dirent'. */
89 #if defined(MSDOS) || defined(__CYGWIN__)
90 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
92 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
99 #include "character.h"
103 #include "blockinput.h"
105 /* Returns a search buffer, with a fastmap allocated and ready to go. */
106 extern struct re_pattern_buffer
*compile_pattern ();
108 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
109 extern void filemodestring
P_ ((struct stat
*, char *));
111 /* if system does not have symbolic links, it does not have lstat.
112 In that case, use ordinary stat instead. */
118 extern int completion_ignore_case
;
119 extern Lisp_Object Vcompletion_regexp_list
;
121 Lisp_Object Vcompletion_ignored_extensions
;
122 Lisp_Object Qcompletion_ignore_case
;
123 Lisp_Object Qdirectory_files
;
124 Lisp_Object Qdirectory_files_and_attributes
;
125 Lisp_Object Qfile_name_completion
;
126 Lisp_Object Qfile_name_all_completions
;
127 Lisp_Object Qfile_attributes
;
128 Lisp_Object Qfile_attributes_lessp
;
130 static int scmp
P_ ((unsigned char *, unsigned char *, int));
134 directory_files_internal_unwind (dh
)
137 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
144 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
145 When ATTRS is zero, return a list of directory filenames; when
146 non-zero, return a list of directory filenames and their attributes.
147 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
150 directory_files_internal (directory
, full
, match
, nosort
, attrs
, id_format
)
151 Lisp_Object directory
, full
, match
, nosort
;
153 Lisp_Object id_format
;
156 int directory_nbytes
;
157 Lisp_Object list
, dirfilename
, encoded_directory
;
158 struct re_pattern_buffer
*bufp
= NULL
;
160 int count
= SPECPDL_INDEX ();
161 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
164 /* Because of file name handlers, these functions might call
165 Ffuncall, and cause a GC. */
166 list
= encoded_directory
= dirfilename
= Qnil
;
167 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
168 dirfilename
= Fdirectory_file_name (directory
);
172 CHECK_STRING (match
);
174 /* MATCH might be a flawed regular expression. Rather than
175 catching and signaling our own errors, we just call
176 compile_pattern to do the work for us. */
177 /* Pass 1 for the MULTIBYTE arg
178 because we do make multibyte strings if the contents warrant. */
180 bufp
= compile_pattern (match
, 0,
181 buffer_defaults
.downcase_table
, 0, 1);
184 /* Windows users want case-insensitive wildcards. */
185 bufp
= compile_pattern (match
, 0,
186 buffer_defaults
.case_canon_table
, 0, 1);
187 # else /* !WINDOWSNT */
188 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
189 # endif /* !WINDOWSNT */
193 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
194 run_pre_post_conversion_on_str which calls Lisp directly and
196 dirfilename
= ENCODE_FILE (dirfilename
);
197 encoded_directory
= ENCODE_FILE (directory
);
199 /* Now *bufp is the compiled form of MATCH; don't call anything
200 which might compile a new regexp until we're done with the loop! */
203 d
= opendir (SDATA (dirfilename
));
206 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
208 /* Unfortunately, we can now invoke expand-file-name and
209 file-attributes on filenames, both of which can throw, so we must
210 do a proper unwind-protect. */
211 record_unwind_protect (directory_files_internal_unwind
,
212 make_save_value (d
, 0));
214 directory_nbytes
= SBYTES (directory
);
215 re_match_object
= Qt
;
217 /* Decide whether we need to add a directory separator. */
219 if (directory_nbytes
== 0
220 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
224 /* Loop reading blocks until EOF or error. */
243 if (DIRENTRY_NONEMPTY (dp
))
247 Lisp_Object name
, finalname
;
248 struct gcpro gcpro1
, gcpro2
;
251 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
252 GCPRO2 (finalname
, name
);
254 /* Note: ENCODE_FILE can GC; it should protect its argument,
256 name
= DECODE_FILE (name
);
259 /* Now that we have unwind_protect in place, we might as well
260 allow matching to be interrupted. */
265 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
274 Lisp_Object fullname
;
275 int nbytes
= len
+ directory_nbytes
+ needsep
;
278 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
279 bcopy (SDATA (directory
), SDATA (fullname
),
283 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
286 SDATA (fullname
) + directory_nbytes
+ needsep
,
289 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
291 /* Some bug somewhere. */
295 STRING_SET_CHARS (fullname
, nchars
);
296 if (nchars
== nbytes
)
297 STRING_SET_UNIBYTE (fullname
);
299 finalname
= fullname
;
306 /* Construct an expanded filename for the directory entry.
307 Use the decoded names for input to Ffile_attributes. */
308 Lisp_Object decoded_fullname
, fileattrs
;
309 struct gcpro gcpro1
, gcpro2
;
311 decoded_fullname
= fileattrs
= Qnil
;
312 GCPRO2 (decoded_fullname
, fileattrs
);
314 /* Both Fexpand_file_name and Ffile_attributes can GC. */
315 decoded_fullname
= Fexpand_file_name (name
, directory
);
316 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
318 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
322 list
= Fcons (finalname
, list
);
333 /* Discard the unwind protect. */
334 specpdl_ptr
= specpdl
+ count
;
337 list
= Fsort (Fnreverse (list
),
338 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
340 RETURN_UNGCPRO (list
);
344 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
345 doc
: /* Return a list of names of files in DIRECTORY.
346 There are three optional arguments:
347 If FULL is non-nil, return absolute file names. Otherwise return names
348 that are relative to the specified directory.
349 If MATCH is non-nil, mention only file names that match the regexp MATCH.
350 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
351 NOSORT is useful if you plan to sort the result yourself. */)
352 (directory
, full
, match
, nosort
)
353 Lisp_Object directory
, full
, match
, nosort
;
356 directory
= Fexpand_file_name (directory
, Qnil
);
358 /* If the file name has special constructs in it,
359 call the corresponding file handler. */
360 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
362 return call5 (handler
, Qdirectory_files
, directory
,
363 full
, match
, nosort
);
365 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
368 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
369 Sdirectory_files_and_attributes
, 1, 5, 0,
370 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
371 There are four optional arguments:
372 If FULL is non-nil, return absolute file names. Otherwise return names
373 that are relative to the specified directory.
374 If MATCH is non-nil, mention only file names that match the regexp MATCH.
375 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
376 NOSORT is useful if you plan to sort the result yourself.
377 ID-FORMAT specifies the preferred format of attributes uid and gid, see
378 `file-attributes' for further documentation. */)
379 (directory
, full
, match
, nosort
, id_format
)
380 Lisp_Object directory
, full
, match
, nosort
, id_format
;
383 directory
= Fexpand_file_name (directory
, Qnil
);
385 /* If the file name has special constructs in it,
386 call the corresponding file handler. */
387 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
389 return call6 (handler
, Qdirectory_files_and_attributes
,
390 directory
, full
, match
, nosort
, id_format
);
392 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
396 Lisp_Object
file_name_completion ();
398 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
400 doc
: /* Complete file name FILE in directory DIRECTORY.
401 Returns the longest string
402 common to all file names in DIRECTORY that start with FILE.
403 If there is only one and FILE matches it exactly, returns t.
404 Returns nil if DIRECTORY contains no name starting with FILE.
406 If PREDICATE is non-nil, call PREDICATE with each possible
407 completion (in absolute form) and ignore it if PREDICATE returns nil.
409 This function ignores some of the possible completions as
410 determined by the variable `completion-ignored-extensions', which see. */)
411 (file
, directory
, predicate
)
412 Lisp_Object file
, directory
, predicate
;
416 /* If the directory name has special constructs in it,
417 call the corresponding file handler. */
418 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
420 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
422 /* If the file name has special constructs in it,
423 call the corresponding file handler. */
424 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
426 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
428 return file_name_completion (file
, directory
, 0, 0, predicate
);
431 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
432 Sfile_name_all_completions
, 2, 2, 0,
433 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
434 These are all file names in directory DIRECTORY which begin with FILE. */)
436 Lisp_Object file
, directory
;
440 /* If the directory name has special constructs in it,
441 call the corresponding file handler. */
442 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
444 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
446 /* If the file name has special constructs in it,
447 call the corresponding file handler. */
448 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
450 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
452 return file_name_completion (file
, directory
, 1, 0, Qnil
);
455 static int file_name_completion_stat ();
458 file_name_completion (file
, dirname
, all_flag
, ver_flag
, predicate
)
459 Lisp_Object file
, dirname
;
460 int all_flag
, ver_flag
;
461 Lisp_Object predicate
;
464 int bestmatchsize
= 0, skip
;
465 register int compare
, matchsize
;
466 unsigned char *p1
, *p2
;
468 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
469 If ALL_FLAG is 0, BESTMATCH is either nil
470 or the best match so far, not decoded. */
471 Lisp_Object bestmatch
, tem
, elt
, name
;
472 Lisp_Object encoded_file
;
473 Lisp_Object encoded_dir
;
477 int count
= SPECPDL_INDEX ();
478 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
483 extern DIRENTRY
* readdirver ();
485 DIRENTRY
*((* readfunc
) ());
487 /* Filename completion on VMS ignores case, since VMS filesys does. */
488 specbind (Qcompletion_ignore_case
, Qt
);
492 readfunc
= readdirver
;
493 file
= Fupcase (file
);
498 #ifdef FILE_SYSTEM_CASE
499 file
= FILE_SYSTEM_CASE (file
);
502 encoded_file
= encoded_dir
= Qnil
;
503 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
504 dirname
= Fexpand_file_name (dirname
, Qnil
);
506 /* Do completion on the encoded file name
507 because the other names in the directory are (we presume)
508 encoded likewise. We decode the completed string at the end. */
509 encoded_file
= ENCODE_FILE (file
);
511 encoded_dir
= ENCODE_FILE (dirname
);
513 /* With passcount = 0, ignore files that end in an ignored extension.
514 If nothing found then try again with passcount = 1, don't ignore them.
515 If looking for all completions, start with passcount = 1,
516 so always take even the ignored ones.
518 ** It would not actually be helpful to the user to ignore any possible
519 completions when making a list of them.** */
521 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
523 int inner_count
= SPECPDL_INDEX ();
526 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
529 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
531 record_unwind_protect (directory_files_internal_unwind
,
532 make_save_value (d
, 0));
534 /* Loop reading blocks */
535 /* (att3b compiler bug requires do a null comparison this way) */
542 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, and are
579 actually in the way in a directory with 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 /* This is a possible completion */
663 /* This completion is a directory; make it end with '/' */
664 name
= Ffile_name_as_directory (make_string (dp
->d_name
, len
));
667 name
= make_string (dp
->d_name
, len
);
669 /* Test the predicate, if any. */
671 if (!NILP (predicate
))
674 decoded
= Fexpand_file_name (DECODE_FILE (name
), dirname
);
675 if (NILP (call1 (predicate
, decoded
)))
679 /* Suitably record this match. */
685 name
= DECODE_FILE (name
);
686 bestmatch
= Fcons (name
, bestmatch
);
688 else if (NILP (bestmatch
))
691 bestmatchsize
= SCHARS (name
);
695 compare
= min (bestmatchsize
, len
);
696 p1
= SDATA (bestmatch
);
697 p2
= (unsigned char *) dp
->d_name
;
698 matchsize
= scmp(p1
, p2
, compare
);
701 if (completion_ignore_case
)
703 /* If this is an exact match except for case,
704 use it as the best match rather than one that is not
705 an exact match. This way, we get the case pattern
706 of the actual match. */
707 /* This tests that the current file is an exact match
708 but BESTMATCH is not (it is too long). */
709 if ((matchsize
== len
710 && matchsize
+ !!directoryp
711 < SCHARS (bestmatch
))
713 /* If there is no exact match ignoring case,
714 prefer a match that does not change the case
716 /* If there is more than one exact match aside from
717 case, and one of them is exact including case,
719 /* This == checks that, of current file and BESTMATCH,
720 either both or neither are exact. */
723 (matchsize
+ !!directoryp
724 == SCHARS (bestmatch
)))
725 && !bcmp (p2
, SDATA (encoded_file
), SCHARS (encoded_file
))
726 && bcmp (p1
, SDATA (encoded_file
), SCHARS (encoded_file
))))
730 /* If this dirname all matches, see if implicit following
733 && compare
== matchsize
734 && bestmatchsize
> matchsize
735 && IS_ANY_SEP (p1
[matchsize
]))
737 bestmatchsize
= matchsize
;
740 /* This closes the directory. */
741 bestmatch
= unbind_to (inner_count
, bestmatch
);
745 bestmatch
= unbind_to (count
, bestmatch
);
747 if (all_flag
|| NILP (bestmatch
))
749 if (STRINGP (bestmatch
))
750 bestmatch
= DECODE_FILE (bestmatch
);
753 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
755 bestmatch
= Fsubstring (bestmatch
, make_number (0),
756 make_number (bestmatchsize
));
757 /* Now that we got the right initial segment of BESTMATCH,
758 decode it from the coding system in use. */
759 bestmatch
= DECODE_FILE (bestmatch
);
763 /* Compare exactly LEN chars of strings at S1 and S2,
764 ignoring case if appropriate.
765 Return -1 if strings match,
766 else number of chars that match at the beginning. */
770 register unsigned char *s1
, *s2
;
773 register int l
= len
;
775 if (completion_ignore_case
)
777 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
782 while (l
&& *s1
++ == *s2
++)
792 file_name_completion_stat (dirname
, dp
, st_addr
)
795 struct stat
*st_addr
;
797 int len
= NAMLEN (dp
);
798 int pos
= SCHARS (dirname
);
800 char *fullname
= (char *) alloca (len
+ pos
+ 2);
804 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
805 but aren't required here. Avoid computing the following fields:
806 st_inode, st_size and st_nlink for directories, and the execute bits
807 in st_mode for non-directory files with non-standard extensions. */
809 unsigned short save_djstat_flags
= _djstat_flags
;
811 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
812 #endif /* __DJGPP__ > 1 */
815 bcopy (SDATA (dirname
), fullname
, pos
);
817 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
818 fullname
[pos
++] = DIRECTORY_SEP
;
821 bcopy (dp
->d_name
, fullname
+ pos
, len
);
822 fullname
[pos
+ len
] = 0;
825 /* We want to return success if a link points to a nonexistent file,
826 but we want to return the status for what the link points to,
827 in case it is a directory. */
828 value
= lstat (fullname
, st_addr
);
829 stat (fullname
, st_addr
);
832 value
= stat (fullname
, st_addr
);
835 _djstat_flags
= save_djstat_flags
;
836 #endif /* __DJGPP__ > 1 */
844 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
845 Sfile_name_all_versions
, 2, 2, 0,
846 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
848 Lisp_Object file
, directory
;
850 return file_name_completion (file
, directory
, 1, 1, Qnil
);
853 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
854 doc
: /* Return the maximum number of versions allowed for FILE.
855 Returns nil if the file cannot be opened or if there is no version limit. */)
857 Lisp_Object filename
;
862 struct XABFHC xabfhc
;
865 filename
= Fexpand_file_name (filename
, Qnil
);
867 xabfhc
= cc$rms_xabfhc
;
868 fab
.fab$l_fna
= SDATA (filename
);
869 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
870 fab
.fab$l_xab
= (char *) &xabfhc
;
871 status
= sys$
open (&fab
, 0, 0);
872 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
874 sys$
close (&fab
, 0, 0);
875 if (xabfhc
.xab$w_verlimit
== 32767)
876 return Qnil
; /* No version limit */
878 return make_number (xabfhc
.xab$w_verlimit
);
887 return Fcons (make_number (time
>> 16),
888 Fcons (make_number (time
& 0177777), Qnil
));
891 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
892 doc
: /* Return a list of attributes of file FILENAME.
893 Value is nil if specified file cannot be opened.
895 ID-FORMAT specifies the preferred format of attributes uid and gid (see
896 below) - valid values are 'string and 'integer. The latter is the default,
897 but we plan to change that, so you should specify a non-nil value for
898 ID-FORMAT if you use the returned uid or gid.
900 Elements of the attribute list are:
901 0. t for directory, string (name linked to) for symbolic link, or nil.
902 1. Number of links to file.
903 2. File uid as a string or an integer. If a string value cannot be
904 looked up, the integer value is returned.
905 3. File gid, likewise.
906 4. Last access time, as a list of two integers.
907 First integer has high-order 16 bits of time, second has low 16 bits.
908 5. Last modification time, likewise.
909 6. Last status change time, likewise.
911 This is a floating point number if the size is too large for an integer.
912 8. File modes, as a string of ten letters or dashes as in ls -l.
913 9. t iff file's gid would change if file were deleted and recreated.
914 10. inode number. If inode number is larger than the Emacs integer,
915 this is a cons cell containing two integers: first the high part,
916 then the low 16 bits.
917 11. Device number. If it is larger than the Emacs integer, this is
918 a cons cell, similar to the inode number. */)
919 (filename
, id_format
)
920 Lisp_Object filename
, id_format
;
922 Lisp_Object values
[12];
927 #if defined (BSD4_2) || defined (BSD4_3)
935 filename
= Fexpand_file_name (filename
, Qnil
);
937 /* If the file name has special constructs in it,
938 call the corresponding file handler. */
939 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
941 { /* Only pass the extra arg if it is used to help backward compatibility
942 with old file handlers which do not implement the new arg. --Stef */
943 if (NILP (id_format
))
944 return call2 (handler
, Qfile_attributes
, filename
);
946 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
950 encoded
= ENCODE_FILE (filename
);
953 if (lstat (SDATA (encoded
), &s
) < 0)
956 switch (s
.st_mode
& S_IFMT
)
959 values
[0] = Qnil
; break;
961 values
[0] = Qt
; break;
964 values
[0] = Ffile_symlink_p (filename
); break;
967 values
[1] = make_number (s
.st_nlink
);
968 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
970 values
[2] = make_number (s
.st_uid
);
971 values
[3] = make_number (s
.st_gid
);
976 pw
= (struct passwd
*) getpwuid (s
.st_uid
);
977 values
[2] = (pw
? build_string (pw
->pw_name
) : make_number (s
.st_uid
));
978 gr
= (struct group
*) getgrgid (s
.st_gid
);
979 values
[3] = (gr
? build_string (gr
->gr_name
) : make_number (s
.st_gid
));
982 values
[4] = make_time (s
.st_atime
);
983 values
[5] = make_time (s
.st_mtime
);
984 values
[6] = make_time (s
.st_ctime
);
985 values
[7] = make_number (s
.st_size
);
986 /* If the size is out of range for an integer, return a float. */
987 if (XINT (values
[7]) != s
.st_size
)
988 values
[7] = make_float ((double)s
.st_size
);
989 /* If the size is negative, and its type is long, convert it back to
991 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
992 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
994 filemodestring (&s
, modes
);
995 values
[8] = make_string (modes
, 10);
996 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
997 dirname
= Ffile_name_directory (filename
);
998 if (! NILP (dirname
))
999 encoded
= ENCODE_FILE (dirname
);
1000 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
1001 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
1002 else /* if we can't tell, assume worst */
1004 #else /* file gid will be egid */
1005 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1006 #endif /* BSD4_2 (or BSD4_3) */
1007 if (FIXNUM_OVERFLOW_P (s
.st_ino
))
1008 /* To allow inode numbers larger than VALBITS, separate the bottom
1010 values
[10] = Fcons (make_number (s
.st_ino
>> 16),
1011 make_number (s
.st_ino
& 0xffff));
1013 /* But keep the most common cases as integers. */
1014 values
[10] = make_number (s
.st_ino
);
1016 /* Likewise for device. */
1017 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1018 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1019 make_number (s
.st_dev
& 0xffff));
1021 values
[11] = make_number (s
.st_dev
);
1023 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1026 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1027 doc
: /* Return t if first arg file attributes list is less than second.
1028 Comparison is in lexicographic order and case is significant. */)
1032 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1038 Qdirectory_files
= intern ("directory-files");
1039 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1040 Qfile_name_completion
= intern ("file-name-completion");
1041 Qfile_name_all_completions
= intern ("file-name-all-completions");
1042 Qfile_attributes
= intern ("file-attributes");
1043 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1045 staticpro (&Qdirectory_files
);
1046 staticpro (&Qdirectory_files_and_attributes
);
1047 staticpro (&Qfile_name_completion
);
1048 staticpro (&Qfile_name_all_completions
);
1049 staticpro (&Qfile_attributes
);
1050 staticpro (&Qfile_attributes_lessp
);
1052 defsubr (&Sdirectory_files
);
1053 defsubr (&Sdirectory_files_and_attributes
);
1054 defsubr (&Sfile_name_completion
);
1056 defsubr (&Sfile_name_all_versions
);
1057 defsubr (&Sfile_version_limit
);
1059 defsubr (&Sfile_name_all_completions
);
1060 defsubr (&Sfile_attributes
);
1061 defsubr (&Sfile_attributes_lessp
);
1064 Qcompletion_ignore_case
= intern ("completion-ignore-case");
1065 staticpro (&Qcompletion_ignore_case
);
1068 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1069 doc
: /* Completion ignores file names ending in any string in this list.
1070 It does not ignore them if all possible completions end in one of
1071 these strings or when displaying a list of completions.
1072 It ignores directory names if they match any string in this list which
1073 ends in a slash. */);
1074 Vcompletion_ignored_extensions
= Qnil
;
1077 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1078 (do not change this comment) */