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)
102 #include "blockinput.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
;
143 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
144 When ATTRS is zero, return a list of directory filenames; when
145 non-zero, return a list of directory filenames and their attributes.
146 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
149 directory_files_internal (directory
, full
, match
, nosort
, attrs
, id_format
)
150 Lisp_Object directory
, full
, match
, nosort
;
152 Lisp_Object id_format
;
155 int directory_nbytes
;
156 Lisp_Object list
, dirfilename
, encoded_directory
;
157 struct re_pattern_buffer
*bufp
= NULL
;
159 int count
= SPECPDL_INDEX ();
160 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
163 /* Because of file name handlers, these functions might call
164 Ffuncall, and cause a GC. */
165 list
= encoded_directory
= dirfilename
= Qnil
;
166 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
167 dirfilename
= Fdirectory_file_name (directory
);
171 CHECK_STRING (match
);
173 /* MATCH might be a flawed regular expression. Rather than
174 catching and signaling our own errors, we just call
175 compile_pattern to do the work for us. */
176 /* Pass 1 for the MULTIBYTE arg
177 because we do make multibyte strings if the contents warrant. */
179 bufp
= compile_pattern (match
, 0,
180 buffer_defaults
.downcase_table
, 0, 1);
183 /* Windows users want case-insensitive wildcards. */
184 bufp
= compile_pattern (match
, 0,
185 buffer_defaults
.case_canon_table
, 0, 1);
186 # else /* !WINDOWSNT */
187 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
188 # endif /* !WINDOWSNT */
192 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
193 run_pre_post_conversion_on_str which calls Lisp directly and
195 dirfilename
= ENCODE_FILE (dirfilename
);
196 encoded_directory
= ENCODE_FILE (directory
);
198 /* Now *bufp is the compiled form of MATCH; don't call anything
199 which might compile a new regexp until we're done with the loop! */
202 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 make_save_value (d
, 0));
213 directory_nbytes
= SBYTES (directory
);
214 re_match_object
= Qt
;
216 /* Decide whether we need to add a directory separator. */
218 if (directory_nbytes
== 0
219 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
223 /* Loop reading blocks until EOF or error. */
242 if (DIRENTRY_NONEMPTY (dp
))
246 Lisp_Object name
, finalname
;
247 struct gcpro gcpro1
, gcpro2
;
250 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
251 GCPRO2 (finalname
, name
);
253 /* Note: ENCODE_FILE can GC; it should protect its argument,
255 name
= DECODE_FILE (name
);
258 /* Now that we have unwind_protect in place, we might as well
259 allow matching to be interrupted. */
264 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
273 Lisp_Object fullname
;
274 int nbytes
= len
+ directory_nbytes
+ needsep
;
277 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
278 bcopy (SDATA (directory
), SDATA (fullname
),
282 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
285 SDATA (fullname
) + directory_nbytes
+ needsep
,
288 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
290 /* Some bug somewhere. */
294 STRING_SET_CHARS (fullname
, nchars
);
295 if (nchars
== nbytes
)
296 STRING_SET_UNIBYTE (fullname
);
298 finalname
= fullname
;
305 /* Construct an expanded filename for the directory entry.
306 Use the decoded names for input to Ffile_attributes. */
307 Lisp_Object decoded_fullname
, fileattrs
;
308 struct gcpro gcpro1
, gcpro2
;
310 decoded_fullname
= fileattrs
= Qnil
;
311 GCPRO2 (decoded_fullname
, fileattrs
);
313 /* Both Fexpand_file_name and Ffile_attributes can GC. */
314 decoded_fullname
= Fexpand_file_name (name
, directory
);
315 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
317 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
321 list
= Fcons (finalname
, list
);
332 /* Discard the unwind protect. */
333 specpdl_ptr
= specpdl
+ count
;
336 list
= Fsort (Fnreverse (list
),
337 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
339 RETURN_UNGCPRO (list
);
343 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
344 doc
: /* Return a list of names of files in DIRECTORY.
345 There are three optional arguments:
346 If FULL is non-nil, return absolute file names. Otherwise return names
347 that are relative to the specified directory.
348 If MATCH is non-nil, mention only file names that match the regexp MATCH.
349 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
350 NOSORT is useful if you plan to sort the result yourself. */)
351 (directory
, full
, match
, nosort
)
352 Lisp_Object directory
, full
, match
, nosort
;
355 directory
= Fexpand_file_name (directory
, Qnil
);
357 /* If the file name has special constructs in it,
358 call the corresponding file handler. */
359 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
361 return call5 (handler
, Qdirectory_files
, directory
,
362 full
, match
, nosort
);
364 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
367 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
368 Sdirectory_files_and_attributes
, 1, 5, 0,
369 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
370 There are four optional arguments:
371 If FULL is non-nil, return absolute file names. Otherwise return names
372 that are relative to the specified directory.
373 If MATCH is non-nil, mention only file names that match the regexp MATCH.
374 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
375 NOSORT is useful if you plan to sort the result yourself.
376 ID-FORMAT specifies the preferred format of attributes uid and gid, see
377 `file-attributes' for further documentation. */)
378 (directory
, full
, match
, nosort
, id_format
)
379 Lisp_Object directory
, full
, match
, nosort
, id_format
;
382 directory
= Fexpand_file_name (directory
, Qnil
);
384 /* If the file name has special constructs in it,
385 call the corresponding file handler. */
386 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
388 return call6 (handler
, Qdirectory_files_and_attributes
,
389 directory
, full
, match
, nosort
, id_format
);
391 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
395 Lisp_Object
file_name_completion ();
397 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
399 doc
: /* Complete file name FILE in directory DIRECTORY.
400 Returns the longest string
401 common to all file names in DIRECTORY that start with FILE.
402 If there is only one and FILE matches it exactly, returns t.
403 Returns nil if DIRECTORY contains no name starting with FILE.
405 This function ignores some of the possible completions as
406 determined by the variable `completion-ignored-extensions', which see. */)
407 (file
, directory
, predicate
)
408 Lisp_Object file
, directory
, predicate
;
412 /* If the directory name has special constructs in it,
413 call the corresponding file handler. */
414 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
416 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
418 /* If the file name has special constructs in it,
419 call the corresponding file handler. */
420 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
422 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
424 return file_name_completion (file
, directory
, 0, 0, predicate
);
427 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
428 Sfile_name_all_completions
, 2, 2, 0,
429 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
430 These are all file names in directory DIRECTORY which begin with FILE. */)
432 Lisp_Object file
, directory
;
436 /* If the directory name has special constructs in it,
437 call the corresponding file handler. */
438 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
440 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
442 /* If the file name has special constructs in it,
443 call the corresponding file handler. */
444 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
446 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
448 return file_name_completion (file
, directory
, 1, 0, Qnil
);
451 static int file_name_completion_stat ();
454 file_name_completion (file
, dirname
, all_flag
, ver_flag
, predicate
)
455 Lisp_Object file
, dirname
;
456 int all_flag
, ver_flag
;
457 Lisp_Object predicate
;
460 int bestmatchsize
= 0, skip
;
461 register int compare
, matchsize
;
462 unsigned char *p1
, *p2
;
464 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
465 If ALL_FLAG is 0, BESTMATCH is either nil
466 or the best match so far, not decoded. */
467 Lisp_Object bestmatch
, tem
, elt
, name
;
468 Lisp_Object encoded_file
;
469 Lisp_Object encoded_dir
;
473 int count
= SPECPDL_INDEX ();
474 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
479 extern DIRENTRY
* readdirver ();
481 DIRENTRY
*((* readfunc
) ());
483 /* Filename completion on VMS ignores case, since VMS filesys does. */
484 specbind (Qcompletion_ignore_case
, Qt
);
488 readfunc
= readdirver
;
489 file
= Fupcase (file
);
494 #ifdef FILE_SYSTEM_CASE
495 file
= FILE_SYSTEM_CASE (file
);
498 encoded_file
= encoded_dir
= Qnil
;
499 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
500 dirname
= Fexpand_file_name (dirname
, Qnil
);
502 /* Do completion on the encoded file name
503 because the other names in the directory are (we presume)
504 encoded likewise. We decode the completed string at the end. */
505 encoded_file
= ENCODE_FILE (file
);
507 encoded_dir
= ENCODE_FILE (dirname
);
509 /* With passcount = 0, ignore files that end in an ignored extension.
510 If nothing found then try again with passcount = 1, don't ignore them.
511 If looking for all completions, start with passcount = 1,
512 so always take even the ignored ones.
514 ** It would not actually be helpful to the user to ignore any possible
515 completions when making a list of them.** */
517 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
519 int inner_count
= SPECPDL_INDEX ();
522 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
525 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
527 record_unwind_protect (directory_files_internal_unwind
,
528 make_save_value (d
, 0));
530 /* Loop reading blocks */
531 /* (att3b compiler bug requires do a null comparison this way) */
538 dp
= (*readfunc
) (d
);
558 if (! DIRENTRY_NONEMPTY (dp
)
559 || len
< SCHARS (encoded_file
)
560 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
561 SCHARS (encoded_file
)))
564 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
567 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
571 #ifndef TRIVIAL_DIRECTORY_ENTRY
572 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
574 /* "." and ".." are never interesting as completions, and are
575 actually in the way in a directory with only one file. */
576 if (!passcount
&& TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
578 if (!passcount
&& len
> SCHARS (encoded_file
))
579 /* Ignore directories if they match an element of
580 completion-ignored-extensions which ends in a slash. */
581 for (tem
= Vcompletion_ignored_extensions
;
582 CONSP (tem
); tem
= XCDR (tem
))
589 /* Need to encode ELT, since scmp compares unibyte
591 elt
= ENCODE_FILE (elt
);
592 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
596 if (p1
[elt_len
] != '/')
598 skip
= len
- elt_len
;
602 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
609 /* Compare extensions-to-be-ignored against end of this file name */
610 /* if name is not an exact match against specified string */
611 if (!passcount
&& len
> SCHARS (encoded_file
))
612 /* and exit this for loop if a match is found */
613 for (tem
= Vcompletion_ignored_extensions
;
614 CONSP (tem
); tem
= XCDR (tem
))
617 if (!STRINGP (elt
)) continue;
618 /* Need to encode ELT, since scmp compares unibyte
620 elt
= ENCODE_FILE (elt
);
621 skip
= len
- SCHARS (elt
);
622 if (skip
< 0) continue;
624 if (0 <= scmp (dp
->d_name
+ skip
,
632 /* If an ignored-extensions match was found,
633 don't process this name as a completion. */
634 if (!passcount
&& CONSP (tem
))
641 XSETFASTINT (zero
, 0);
643 /* Ignore this element if it fails to match all the regexps. */
644 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
645 regexps
= XCDR (regexps
))
647 tem
= Fstring_match (XCAR (regexps
),
648 make_string (dp
->d_name
, len
), zero
);
656 /* This is a possible completion */
659 /* This completion is a directory; make it end with '/' */
660 name
= Ffile_name_as_directory (make_string (dp
->d_name
, len
));
663 name
= make_string (dp
->d_name
, len
);
665 /* Test the predicate, if any. */
667 if (!NILP (predicate
))
670 decoded
= Fexpand_file_name (DECODE_FILE (name
), dirname
);
671 if (NILP (call1 (predicate
, decoded
)))
675 /* Suitably record this match. */
681 name
= DECODE_FILE (name
);
682 bestmatch
= Fcons (name
, bestmatch
);
684 else if (NILP (bestmatch
))
687 bestmatchsize
= SCHARS (name
);
691 compare
= min (bestmatchsize
, len
);
692 p1
= SDATA (bestmatch
);
693 p2
= (unsigned char *) dp
->d_name
;
694 matchsize
= scmp(p1
, p2
, compare
);
697 if (completion_ignore_case
)
699 /* If this is an exact match except for case,
700 use it as the best match rather than one that is not
701 an exact match. This way, we get the case pattern
702 of the actual match. */
703 /* This tests that the current file is an exact match
704 but BESTMATCH is not (it is too long). */
705 if ((matchsize
== len
706 && matchsize
+ !!directoryp
707 < SCHARS (bestmatch
))
709 /* If there is no exact match ignoring case,
710 prefer a match that does not change the case
712 /* If there is more than one exact match aside from
713 case, and one of them is exact including case,
715 /* This == checks that, of current file and BESTMATCH,
716 either both or neither are exact. */
719 (matchsize
+ !!directoryp
720 == SCHARS (bestmatch
)))
721 && !bcmp (p2
, SDATA (encoded_file
), SCHARS (encoded_file
))
722 && bcmp (p1
, SDATA (encoded_file
), SCHARS (encoded_file
))))
726 /* If this dirname all matches, see if implicit following
729 && compare
== matchsize
730 && bestmatchsize
> matchsize
731 && IS_ANY_SEP (p1
[matchsize
]))
733 bestmatchsize
= matchsize
;
736 /* This closes the directory. */
737 bestmatch
= unbind_to (inner_count
, bestmatch
);
741 bestmatch
= unbind_to (count
, bestmatch
);
743 if (all_flag
|| NILP (bestmatch
))
745 if (STRINGP (bestmatch
))
746 bestmatch
= DECODE_FILE (bestmatch
);
749 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
751 bestmatch
= Fsubstring (bestmatch
, make_number (0),
752 make_number (bestmatchsize
));
753 /* Now that we got the right initial segment of BESTMATCH,
754 decode it from the coding system in use. */
755 bestmatch
= DECODE_FILE (bestmatch
);
759 /* Compare exactly LEN chars of strings at S1 and S2,
760 ignoring case if appropriate.
761 Return -1 if strings match,
762 else number of chars that match at the beginning. */
766 register unsigned char *s1
, *s2
;
769 register int l
= len
;
771 if (completion_ignore_case
)
773 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
778 while (l
&& *s1
++ == *s2
++)
788 file_name_completion_stat (dirname
, dp
, st_addr
)
791 struct stat
*st_addr
;
793 int len
= NAMLEN (dp
);
794 int pos
= SCHARS (dirname
);
796 char *fullname
= (char *) alloca (len
+ pos
+ 2);
800 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
801 but aren't required here. Avoid computing the following fields:
802 st_inode, st_size and st_nlink for directories, and the execute bits
803 in st_mode for non-directory files with non-standard extensions. */
805 unsigned short save_djstat_flags
= _djstat_flags
;
807 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
808 #endif /* __DJGPP__ > 1 */
811 bcopy (SDATA (dirname
), fullname
, pos
);
813 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
814 fullname
[pos
++] = DIRECTORY_SEP
;
817 bcopy (dp
->d_name
, fullname
+ pos
, len
);
818 fullname
[pos
+ len
] = 0;
821 /* We want to return success if a link points to a nonexistent file,
822 but we want to return the status for what the link points to,
823 in case it is a directory. */
824 value
= lstat (fullname
, st_addr
);
825 stat (fullname
, st_addr
);
828 value
= stat (fullname
, st_addr
);
831 _djstat_flags
= save_djstat_flags
;
832 #endif /* __DJGPP__ > 1 */
840 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
841 Sfile_name_all_versions
, 2, 2, 0,
842 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
844 Lisp_Object file
, directory
;
846 return file_name_completion (file
, directory
, 1, 1, Qnil
);
849 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
850 doc
: /* Return the maximum number of versions allowed for FILE.
851 Returns nil if the file cannot be opened or if there is no version limit. */)
853 Lisp_Object filename
;
858 struct XABFHC xabfhc
;
861 filename
= Fexpand_file_name (filename
, Qnil
);
863 xabfhc
= cc$rms_xabfhc
;
864 fab
.fab$l_fna
= SDATA (filename
);
865 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
866 fab
.fab$l_xab
= (char *) &xabfhc
;
867 status
= sys$
open (&fab
, 0, 0);
868 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
870 sys$
close (&fab
, 0, 0);
871 if (xabfhc
.xab$w_verlimit
== 32767)
872 return Qnil
; /* No version limit */
874 return make_number (xabfhc
.xab$w_verlimit
);
883 return Fcons (make_number (time
>> 16),
884 Fcons (make_number (time
& 0177777), Qnil
));
887 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
888 doc
: /* Return a list of attributes of file FILENAME.
889 Value is nil if specified file cannot be opened.
891 ID-FORMAT specifies the preferred format of attributes uid and gid (see
892 below) - valid values are 'string and 'integer. The latter is the default,
893 but we plan to change that, so you should specify a non-nil value for
894 ID-FORMAT if you use the returned uid or gid.
896 Elements of the attribute list are:
897 0. t for directory, string (name linked to) for symbolic link, or nil.
898 1. Number of links to file.
899 2. File uid as a string or an integer. If a string value cannot be
900 looked up, the integer value is returned.
901 3. File gid, likewise.
902 4. Last access time, as a list of two integers.
903 First integer has high-order 16 bits of time, second has low 16 bits.
904 5. Last modification time, likewise.
905 6. Last status change time, likewise.
907 This is a floating point number if the size is too large for an integer.
908 8. File modes, as a string of ten letters or dashes as in ls -l.
909 9. t iff file's gid would change if file were deleted and recreated.
910 10. inode number. If inode number is larger than the Emacs integer,
911 this is a cons cell containing two integers: first the high part,
912 then the low 16 bits.
913 11. Device number. If it is larger than the Emacs integer, this is
914 a cons cell, similar to the inode number. */)
915 (filename
, id_format
)
916 Lisp_Object filename
, id_format
;
918 Lisp_Object values
[12];
923 #if defined (BSD4_2) || defined (BSD4_3)
931 filename
= Fexpand_file_name (filename
, Qnil
);
933 /* If the file name has special constructs in it,
934 call the corresponding file handler. */
935 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
937 { /* Only pass the extra arg if it is used to help backward compatibility
938 with old file handlers which do not implement the new arg. --Stef */
939 if (NILP (id_format
))
940 return call2 (handler
, Qfile_attributes
, filename
);
942 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
946 encoded
= ENCODE_FILE (filename
);
949 if (lstat (SDATA (encoded
), &s
) < 0)
952 switch (s
.st_mode
& S_IFMT
)
955 values
[0] = Qnil
; break;
957 values
[0] = Qt
; break;
960 values
[0] = Ffile_symlink_p (filename
); break;
963 values
[1] = make_number (s
.st_nlink
);
964 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
966 values
[2] = make_number (s
.st_uid
);
967 values
[3] = make_number (s
.st_gid
);
972 pw
= (struct passwd
*) getpwuid (s
.st_uid
);
973 values
[2] = (pw
? build_string (pw
->pw_name
) : make_number (s
.st_uid
));
974 gr
= (struct group
*) getgrgid (s
.st_gid
);
975 values
[3] = (gr
? build_string (gr
->gr_name
) : make_number (s
.st_gid
));
978 values
[4] = make_time (s
.st_atime
);
979 values
[5] = make_time (s
.st_mtime
);
980 values
[6] = make_time (s
.st_ctime
);
981 values
[7] = make_number (s
.st_size
);
982 /* If the size is out of range for an integer, return a float. */
983 if (XINT (values
[7]) != s
.st_size
)
984 values
[7] = make_float ((double)s
.st_size
);
985 /* If the size is negative, and its type is long, convert it back to
987 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
988 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
990 filemodestring (&s
, modes
);
991 values
[8] = make_string (modes
, 10);
992 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
993 dirname
= Ffile_name_directory (filename
);
994 if (! NILP (dirname
))
995 encoded
= ENCODE_FILE (dirname
);
996 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
997 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
998 else /* if we can't tell, assume worst */
1000 #else /* file gid will be egid */
1001 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1002 #endif /* BSD4_2 (or BSD4_3) */
1003 if (FIXNUM_OVERFLOW_P (s
.st_ino
))
1004 /* To allow inode numbers larger than VALBITS, separate the bottom
1006 values
[10] = Fcons (make_number (s
.st_ino
>> 16),
1007 make_number (s
.st_ino
& 0xffff));
1009 /* But keep the most common cases as integers. */
1010 values
[10] = make_number (s
.st_ino
);
1012 /* Likewise for device. */
1013 if (FIXNUM_OVERFLOW_P (s
.st_dev
))
1014 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1015 make_number (s
.st_dev
& 0xffff));
1017 values
[11] = make_number (s
.st_dev
);
1019 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1022 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1023 doc
: /* Return t if first arg file attributes list is less than second.
1024 Comparison is in lexicographic order and case is significant. */)
1028 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1034 Qdirectory_files
= intern ("directory-files");
1035 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1036 Qfile_name_completion
= intern ("file-name-completion");
1037 Qfile_name_all_completions
= intern ("file-name-all-completions");
1038 Qfile_attributes
= intern ("file-attributes");
1039 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1041 staticpro (&Qdirectory_files
);
1042 staticpro (&Qdirectory_files_and_attributes
);
1043 staticpro (&Qfile_name_completion
);
1044 staticpro (&Qfile_name_all_completions
);
1045 staticpro (&Qfile_attributes
);
1046 staticpro (&Qfile_attributes_lessp
);
1048 defsubr (&Sdirectory_files
);
1049 defsubr (&Sdirectory_files_and_attributes
);
1050 defsubr (&Sfile_name_completion
);
1052 defsubr (&Sfile_name_all_versions
);
1053 defsubr (&Sfile_version_limit
);
1055 defsubr (&Sfile_name_all_completions
);
1056 defsubr (&Sfile_attributes
);
1057 defsubr (&Sfile_attributes_lessp
);
1060 Qcompletion_ignore_case
= intern ("completion-ignore-case");
1061 staticpro (&Qcompletion_ignore_case
);
1064 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1065 doc
: /* Completion ignores file names ending in any string in this list.
1066 It does not ignore them if all possible completions end in one of
1067 these strings or when displaying a list of completions.
1068 It ignores directory names if they match any string in this list which
1069 ends in a slash. */);
1070 Vcompletion_ignored_extensions
= Qnil
;
1073 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1074 (do not change this comment) */