1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008 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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
24 #include <sys/types.h>
46 /* The d_nameln member of a struct dirent includes the '\0' character
47 on some systems, but not on others. What's worse, you can't tell
48 at compile-time which one it will be, since it really depends on
49 the sort of system providing the filesystem you're reading from,
50 not the system you are running on. Paul Eggert
51 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
52 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
53 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
55 Since applying strlen to the name always works, we'll just do that. */
56 #define NAMLEN(p) strlen (p->d_name)
58 #ifdef SYSV_SYSTEM_DIR
61 #define DIRENTRY struct dirent
63 #else /* not SYSV_SYSTEM_DIR */
65 #ifdef NONSYSTEM_DIR_LIBRARY
67 #else /* not NONSYSTEM_DIR_LIBRARY */
73 #endif /* not NONSYSTEM_DIR_LIBRARY */
78 #define DIRENTRY struct direct
80 extern DIR *opendir ();
81 extern struct direct
*readdir ();
83 #endif /* not MSDOS */
84 #endif /* not SYSV_SYSTEM_DIR */
86 /* Some versions of Cygwin don't have d_ino in `struct dirent'. */
87 #if defined(MSDOS) || defined(__CYGWIN__)
88 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
90 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
97 #include "character.h"
101 #include "blockinput.h"
103 /* Returns a search buffer, with a fastmap allocated and ready to go. */
104 extern struct re_pattern_buffer
*compile_pattern ();
106 /* From filemode.c. Can't go in Lisp.h because of `stat'. */
107 extern void filemodestring
P_ ((struct stat
*, char *));
109 /* if system does not have symbolic links, it does not have lstat.
110 In that case, use ordinary stat instead. */
116 extern int completion_ignore_case
;
117 extern Lisp_Object Qcompletion_ignore_case
;
118 extern Lisp_Object Vcompletion_regexp_list
;
120 Lisp_Object Vcompletion_ignored_extensions
;
121 Lisp_Object Qdirectory_files
;
122 Lisp_Object Qdirectory_files_and_attributes
;
123 Lisp_Object Qfile_name_completion
;
124 Lisp_Object Qfile_name_all_completions
;
125 Lisp_Object Qfile_attributes
;
126 Lisp_Object Qfile_attributes_lessp
;
128 static int scmp
P_ ((unsigned char *, unsigned char *, int));
132 directory_files_internal_unwind (dh
)
135 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
142 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
143 When ATTRS is zero, return a list of directory filenames; when
144 non-zero, return a list of directory filenames and their attributes.
145 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
148 directory_files_internal (directory
, full
, match
, nosort
, attrs
, id_format
)
149 Lisp_Object directory
, full
, match
, nosort
;
151 Lisp_Object id_format
;
154 int directory_nbytes
;
155 Lisp_Object list
, dirfilename
, encoded_directory
;
156 struct re_pattern_buffer
*bufp
= NULL
;
158 int count
= SPECPDL_INDEX ();
159 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
162 /* Because of file name handlers, these functions might call
163 Ffuncall, and cause a GC. */
164 list
= encoded_directory
= dirfilename
= Qnil
;
165 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
166 dirfilename
= Fdirectory_file_name (directory
);
170 CHECK_STRING (match
);
172 /* MATCH might be a flawed regular expression. Rather than
173 catching and signaling our own errors, we just call
174 compile_pattern to do the work for us. */
175 /* Pass 1 for the MULTIBYTE arg
176 because we do make multibyte strings if the contents warrant. */
178 bufp
= compile_pattern (match
, 0,
179 buffer_defaults
.downcase_table
, 0, 1);
182 /* Windows users want case-insensitive wildcards. */
183 bufp
= compile_pattern (match
, 0,
184 buffer_defaults
.case_canon_table
, 0, 1);
185 # else /* !WINDOWSNT */
186 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
187 # endif /* !WINDOWSNT */
191 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
192 run_pre_post_conversion_on_str which calls Lisp directly and
194 if (STRING_MULTIBYTE (dirfilename
))
195 dirfilename
= ENCODE_FILE (dirfilename
);
196 encoded_directory
= (STRING_MULTIBYTE (directory
)
197 ? ENCODE_FILE (directory
) : 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: DECODE_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 On MS-Windows, performance depends on `w32-get-true-file-attributes',
381 (directory
, full
, match
, nosort
, id_format
)
382 Lisp_Object directory
, full
, match
, nosort
, id_format
;
385 directory
= Fexpand_file_name (directory
, Qnil
);
387 /* If the file name has special constructs in it,
388 call the corresponding file handler. */
389 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
391 return call6 (handler
, Qdirectory_files_and_attributes
,
392 directory
, full
, match
, nosort
, id_format
);
394 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
398 Lisp_Object
file_name_completion ();
400 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
402 doc
: /* Complete file name FILE in directory DIRECTORY.
403 Returns the longest string
404 common to all file names in DIRECTORY that start with FILE.
405 If there is only one and FILE matches it exactly, returns t.
406 Returns nil if DIRECTORY contains no name starting with FILE.
408 If PREDICATE is non-nil, call PREDICATE with each possible
409 completion (in absolute form) and ignore it if PREDICATE returns nil.
411 This function ignores some of the possible completions as
412 determined by the variable `completion-ignored-extensions', which see. */)
413 (file
, directory
, predicate
)
414 Lisp_Object file
, directory
, predicate
;
418 /* If the directory name has special constructs in it,
419 call the corresponding file handler. */
420 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
422 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
424 /* If the file name has special constructs in it,
425 call the corresponding file handler. */
426 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
428 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
430 return file_name_completion (file
, directory
, 0, 0, predicate
);
433 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
434 Sfile_name_all_completions
, 2, 2, 0,
435 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
436 These are all file names in directory DIRECTORY which begin with FILE. */)
438 Lisp_Object file
, directory
;
442 /* If the directory name has special constructs in it,
443 call the corresponding file handler. */
444 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
446 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
448 /* If the file name has special constructs in it,
449 call the corresponding file handler. */
450 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
452 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
454 return file_name_completion (file
, directory
, 1, 0, Qnil
);
457 static int file_name_completion_stat ();
458 Lisp_Object Qdefault_directory
;
461 file_name_completion (file
, dirname
, all_flag
, ver_flag
, predicate
)
462 Lisp_Object file
, dirname
;
463 int all_flag
, ver_flag
;
464 Lisp_Object predicate
;
467 int bestmatchsize
= 0;
469 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
470 If ALL_FLAG is 0, BESTMATCH is either nil
471 or the best match so far, not decoded. */
472 Lisp_Object bestmatch
, tem
, elt
, name
;
473 Lisp_Object encoded_file
;
474 Lisp_Object encoded_dir
;
477 /* If includeall is zero, exclude files in completion-ignored-extensions as
478 well as "." and "..". Until shown otherwise, assume we can't exclude
481 int count
= SPECPDL_INDEX ();
482 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
487 extern DIRENTRY
* readdirver ();
489 DIRENTRY
*((* readfunc
) ());
491 /* Filename completion on VMS ignores case, since VMS filesys does. */
492 specbind (Qcompletion_ignore_case
, Qt
);
496 readfunc
= readdirver
;
497 file
= Fupcase (file
);
502 #ifdef FILE_SYSTEM_CASE
503 file
= FILE_SYSTEM_CASE (file
);
506 encoded_file
= encoded_dir
= Qnil
;
507 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
508 dirname
= Fexpand_file_name (dirname
, Qnil
);
509 specbind (Qdefault_directory
, dirname
);
511 /* Do completion on the encoded file name
512 because the other names in the directory are (we presume)
513 encoded likewise. We decode the completed string at the end. */
514 /* Actually, this is not quite true any more: we do most of the completion
515 work with decoded file names, but we still do some filtering based
516 on the encoded file name. */
517 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
519 encoded_dir
= ENCODE_FILE (dirname
);
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) */
539 dp
= (*readfunc
) (d
);
559 if (! DIRENTRY_NONEMPTY (dp
)
560 || len
< SCHARS (encoded_file
)
561 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
562 SCHARS (encoded_file
)))
565 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
568 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
570 /* If all_flag is set, always include all.
571 It would not actually be helpful to the user to ignore any possible
572 completions when making a list of them. */
578 #ifndef TRIVIAL_DIRECTORY_ENTRY
579 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
581 /* "." and ".." are never interesting as completions, and are
582 actually in the way in a directory with only one file. */
583 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
585 else if (len
> SCHARS (encoded_file
))
586 /* Ignore directories if they match an element of
587 completion-ignored-extensions which ends in a slash. */
588 for (tem
= Vcompletion_ignored_extensions
;
589 CONSP (tem
); tem
= XCDR (tem
))
597 /* Need to encode ELT, since scmp compares unibyte
599 elt
= ENCODE_FILE (elt
);
600 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
604 if (p1
[elt_len
] != '/')
606 skip
= len
- elt_len
;
610 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
617 /* Compare extensions-to-be-ignored against end of this file name */
618 /* if name is not an exact match against specified string */
619 if (len
> SCHARS (encoded_file
))
620 /* and exit this for loop if a match is found */
621 for (tem
= Vcompletion_ignored_extensions
;
622 CONSP (tem
); tem
= XCDR (tem
))
625 if (!STRINGP (elt
)) continue;
626 /* Need to encode ELT, since scmp compares unibyte
628 elt
= ENCODE_FILE (elt
);
629 skip
= len
- SCHARS (elt
);
630 if (skip
< 0) continue;
632 if (0 <= scmp (dp
->d_name
+ skip
,
640 /* If an ignored-extensions match was found,
641 don't process this name as a completion. */
645 if (!includeall
&& canexclude
)
646 /* We're not including all files and this file can be excluded. */
649 if (includeall
&& !canexclude
)
650 { /* If we have one non-excludable file, we want to exclude the
653 /* Throw away any previous excludable match found. */
659 /* FIXME: If we move this `decode' earlier we can eliminate
660 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
661 name
= make_unibyte_string (dp
->d_name
, len
);
662 name
= DECODE_FILE (name
);
667 XSETFASTINT (zero
, 0);
669 /* Ignore this element if it fails to match all the regexps. */
670 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
671 regexps
= XCDR (regexps
))
672 if (fast_string_match (XCAR (regexps
), name
) < 0)
678 /* This is a possible completion */
680 /* This completion is a directory; make it end with '/'. */
681 name
= Ffile_name_as_directory (name
);
683 /* Test the predicate, if any. */
684 if (!NILP (predicate
))
690 val
= call1 (predicate
, name
);
697 /* Suitably record this match. */
702 bestmatch
= Fcons (name
, bestmatch
);
703 else if (NILP (bestmatch
))
706 bestmatchsize
= SCHARS (name
);
710 Lisp_Object zero
= make_number (0);
711 /* FIXME: This is a copy of the code in Ftry_completion. */
712 int compare
= min (bestmatchsize
, SCHARS (name
));
714 = Fcompare_strings (bestmatch
, zero
,
715 make_number (compare
),
717 make_number (compare
),
718 completion_ignore_case
? Qt
: Qnil
);
720 = (EQ (tem
, Qt
) ? compare
721 : XINT (tem
) < 0 ? - XINT (tem
) - 1
724 if (completion_ignore_case
)
726 /* If this is an exact match except for case,
727 use it as the best match rather than one that is not
728 an exact match. This way, we get the case pattern
729 of the actual match. */
730 /* This tests that the current file is an exact match
731 but BESTMATCH is not (it is too long). */
732 if ((matchsize
== SCHARS (name
)
733 && matchsize
+ !!directoryp
734 < SCHARS (bestmatch
))
736 /* If there is no exact match ignoring case,
737 prefer a match that does not change the case
739 /* If there is more than one exact match aside from
740 case, and one of them is exact including case,
742 /* This == checks that, of current file and BESTMATCH,
743 either both or neither are exact. */
744 (((matchsize
== SCHARS (name
))
746 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
747 && (tem
= Fcompare_strings (name
, zero
,
748 make_number (SCHARS (file
)),
753 && (tem
= Fcompare_strings (bestmatch
, zero
,
754 make_number (SCHARS (file
)),
761 bestmatchsize
= matchsize
;
766 /* This closes the directory. */
767 bestmatch
= unbind_to (count
, bestmatch
);
769 if (all_flag
|| NILP (bestmatch
))
771 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
773 bestmatch
= Fsubstring (bestmatch
, make_number (0),
774 make_number (bestmatchsize
));
778 /* Compare exactly LEN chars of strings at S1 and S2,
779 ignoring case if appropriate.
780 Return -1 if strings match,
781 else number of chars that match at the beginning. */
785 register unsigned char *s1
, *s2
;
788 register int l
= len
;
790 if (completion_ignore_case
)
792 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
797 while (l
&& *s1
++ == *s2
++)
807 file_name_completion_stat (dirname
, dp
, st_addr
)
810 struct stat
*st_addr
;
812 int len
= NAMLEN (dp
);
813 int pos
= SCHARS (dirname
);
815 char *fullname
= (char *) alloca (len
+ pos
+ 2);
819 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
820 but aren't required here. Avoid computing the following fields:
821 st_inode, st_size and st_nlink for directories, and the execute bits
822 in st_mode for non-directory files with non-standard extensions. */
824 unsigned short save_djstat_flags
= _djstat_flags
;
826 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
827 #endif /* __DJGPP__ > 1 */
830 bcopy (SDATA (dirname
), fullname
, pos
);
832 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
833 fullname
[pos
++] = DIRECTORY_SEP
;
836 bcopy (dp
->d_name
, fullname
+ pos
, len
);
837 fullname
[pos
+ len
] = 0;
840 /* We want to return success if a link points to a nonexistent file,
841 but we want to return the status for what the link points to,
842 in case it is a directory. */
843 value
= lstat (fullname
, st_addr
);
844 stat (fullname
, st_addr
);
847 value
= stat (fullname
, st_addr
);
850 _djstat_flags
= save_djstat_flags
;
851 #endif /* __DJGPP__ > 1 */
859 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
860 Sfile_name_all_versions
, 2, 2, 0,
861 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
863 Lisp_Object file
, directory
;
865 return file_name_completion (file
, directory
, 1, 1, Qnil
);
868 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
869 doc
: /* Return the maximum number of versions allowed for FILE.
870 Returns nil if the file cannot be opened or if there is no version limit. */)
872 Lisp_Object filename
;
877 struct XABFHC xabfhc
;
880 filename
= Fexpand_file_name (filename
, Qnil
);
882 xabfhc
= cc$rms_xabfhc
;
883 fab
.fab$l_fna
= SDATA (filename
);
884 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
885 fab
.fab$l_xab
= (char *) &xabfhc
;
886 status
= sys$
open (&fab
, 0, 0);
887 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
889 sys$
close (&fab
, 0, 0);
890 if (xabfhc
.xab$w_verlimit
== 32767)
891 return Qnil
; /* No version limit */
893 return make_number (xabfhc
.xab$w_verlimit
);
902 return Fcons (make_number (time
>> 16),
903 Fcons (make_number (time
& 0177777), Qnil
));
907 stat_uname (struct stat
*st
)
912 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
922 stat_gname (struct stat
*st
)
927 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
936 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
937 doc
: /* Return a list of attributes of file FILENAME.
938 Value is nil if specified file cannot be opened.
940 ID-FORMAT specifies the preferred format of attributes uid and gid (see
941 below) - valid values are 'string and 'integer. The latter is the default,
942 but we plan to change that, so you should specify a non-nil value for
943 ID-FORMAT if you use the returned uid or gid.
945 Elements of the attribute list are:
946 0. t for directory, string (name linked to) for symbolic link, or nil.
947 1. Number of links to file.
948 2. File uid as a string or an integer. If a string value cannot be
949 looked up, the integer value is returned.
950 3. File gid, likewise.
951 4. Last access time, as a list of two integers.
952 First integer has high-order 16 bits of time, second has low 16 bits.
953 5. Last modification time, likewise.
954 6. Last status change time, likewise.
956 This is a floating point number if the size is too large for an integer.
957 8. File modes, as a string of ten letters or dashes as in ls -l.
958 9. t if file's gid would change if file were deleted and recreated.
959 10. inode number. If inode number is larger than the Emacs integer,
960 but still fits into a 32-bit number, this is a cons cell containing two
961 integers: first the high part, then the low 16 bits. If the inode number
962 is wider than 32 bits, this is a cons cell containing three integers:
963 first the high 24 bits, then middle 24 bits, and finally the low 16 bits.
964 11. Device number. If it is larger than the Emacs integer, this is
965 a cons cell, similar to the inode number.
967 On MS-Windows, performance depends on `w32-get-true-file-attributes',
969 (filename
, id_format
)
970 Lisp_Object filename
, id_format
;
972 Lisp_Object values
[12];
975 #if defined (BSD4_2) || defined (BSD4_3)
982 EMACS_INT ino
, uid
, gid
;
985 filename
= Fexpand_file_name (filename
, Qnil
);
987 /* If the file name has special constructs in it,
988 call the corresponding file handler. */
989 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
991 { /* Only pass the extra arg if it is used to help backward compatibility
992 with old file handlers which do not implement the new arg. --Stef */
993 if (NILP (id_format
))
994 return call2 (handler
, Qfile_attributes
, filename
);
996 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
1000 encoded
= ENCODE_FILE (filename
);
1003 if (lstat (SDATA (encoded
), &s
) < 0)
1006 switch (s
.st_mode
& S_IFMT
)
1009 values
[0] = Qnil
; break;
1011 values
[0] = Qt
; break;
1014 values
[0] = Ffile_symlink_p (filename
); break;
1017 values
[1] = make_number (s
.st_nlink
);
1020 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
1022 values
[2] = make_fixnum_or_float (uid
);
1023 values
[3] = make_fixnum_or_float (gid
);
1028 uname
= stat_uname (&s
);
1029 values
[2] = (uname
? build_string (uname
)
1030 : make_fixnum_or_float (uid
));
1031 gname
= stat_gname (&s
);
1032 values
[3] = (gname
? build_string (gname
)
1033 : make_fixnum_or_float (gid
));
1036 values
[4] = make_time (s
.st_atime
);
1037 values
[5] = make_time (s
.st_mtime
);
1038 values
[6] = make_time (s
.st_ctime
);
1039 values
[7] = make_number (s
.st_size
);
1040 /* If the size is out of range for an integer, return a float. */
1041 if (XINT (values
[7]) != s
.st_size
)
1042 values
[7] = make_float ((double)s
.st_size
);
1043 /* If the size is negative, and its type is long, convert it back to
1045 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
1046 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
1048 filemodestring (&s
, modes
);
1049 values
[8] = make_string (modes
, 10);
1050 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
1051 dirname
= Ffile_name_directory (filename
);
1052 if (! NILP (dirname
))
1053 encoded
= ENCODE_FILE (dirname
);
1054 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
1055 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
1056 else /* if we can't tell, assume worst */
1058 #else /* file gid will be egid */
1059 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1060 #endif /* BSD4_2 (or BSD4_3) */
1061 /* Shut up GCC warnings in FIXNUM_OVERFLOW_P below. */
1062 if (sizeof (s
.st_ino
) > sizeof (ino
))
1063 ino
= (EMACS_INT
)(s
.st_ino
& 0xffffffff);
1066 if (!FIXNUM_OVERFLOW_P (ino
)
1067 && (sizeof (s
.st_ino
) <= sizeof (ino
) || (s
.st_ino
& ~INTMASK
) == 0))
1068 /* Keep the most common cases as integers. */
1069 values
[10] = make_number (ino
);
1070 else if (sizeof (s
.st_ino
) <= sizeof (ino
)
1071 || ((s
.st_ino
>> 16) & ~INTMASK
) == 0)
1072 /* To allow inode numbers larger than VALBITS, separate the bottom
1074 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1075 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1078 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1079 high parts and a 16-bit bottom part. */
1080 EMACS_INT high_ino
= s
.st_ino
>> 32;
1081 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1083 values
[10] = Fcons (make_number (high_ino
>> 8),
1084 Fcons (make_number (((high_ino
& 0xff) << 16)
1086 make_number (low_ino
& 0xffff)));
1089 /* Likewise for device, but don't let it become negative. We used
1090 to use FIXNUM_OVERFLOW_P here, but that won't catch large
1091 positive numbers such as 0xFFEEDDCC. */
1092 if ((EMACS_INT
)s
.st_dev
< 0
1093 || (EMACS_INT
)s
.st_dev
> MOST_POSITIVE_FIXNUM
)
1094 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1095 make_number (s
.st_dev
& 0xffff));
1097 values
[11] = make_number (s
.st_dev
);
1099 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1102 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1103 doc
: /* Return t if first arg file attributes list is less than second.
1104 Comparison is in lexicographic order and case is significant. */)
1108 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1114 Qdirectory_files
= intern ("directory-files");
1115 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1116 Qfile_name_completion
= intern ("file-name-completion");
1117 Qfile_name_all_completions
= intern ("file-name-all-completions");
1118 Qfile_attributes
= intern ("file-attributes");
1119 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1120 Qdefault_directory
= intern ("default-directory");
1122 staticpro (&Qdirectory_files
);
1123 staticpro (&Qdirectory_files_and_attributes
);
1124 staticpro (&Qfile_name_completion
);
1125 staticpro (&Qfile_name_all_completions
);
1126 staticpro (&Qfile_attributes
);
1127 staticpro (&Qfile_attributes_lessp
);
1128 staticpro (&Qdefault_directory
);
1130 defsubr (&Sdirectory_files
);
1131 defsubr (&Sdirectory_files_and_attributes
);
1132 defsubr (&Sfile_name_completion
);
1134 defsubr (&Sfile_name_all_versions
);
1135 defsubr (&Sfile_version_limit
);
1137 defsubr (&Sfile_name_all_completions
);
1138 defsubr (&Sfile_attributes
);
1139 defsubr (&Sfile_attributes_lessp
);
1141 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1142 doc
: /* Completion ignores file names ending in any string in this list.
1143 It does not ignore them if all possible completions end in one of
1144 these strings or when displaying a list of completions.
1145 It ignores directory names if they match any string in this list which
1146 ends in a slash. */);
1147 Vcompletion_ignored_extensions
= Qnil
;
1150 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1151 (do not change this comment) */