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, 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 Qcompletion_ignore_case
;
120 extern Lisp_Object Vcompletion_regexp_list
;
122 Lisp_Object Vcompletion_ignored_extensions
;
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 if (STRING_MULTIBYTE (dirfilename
))
197 dirfilename
= ENCODE_FILE (dirfilename
);
198 encoded_directory
= (STRING_MULTIBYTE (directory
)
199 ? ENCODE_FILE (directory
) : directory
);
201 /* Now *bufp is the compiled form of MATCH; don't call anything
202 which might compile a new regexp until we're done with the loop! */
205 d
= opendir (SDATA (dirfilename
));
208 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
210 /* Unfortunately, we can now invoke expand-file-name and
211 file-attributes on filenames, both of which can throw, so we must
212 do a proper unwind-protect. */
213 record_unwind_protect (directory_files_internal_unwind
,
214 make_save_value (d
, 0));
216 directory_nbytes
= SBYTES (directory
);
217 re_match_object
= Qt
;
219 /* Decide whether we need to add a directory separator. */
221 if (directory_nbytes
== 0
222 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
226 /* Loop reading blocks until EOF or error. */
245 if (DIRENTRY_NONEMPTY (dp
))
249 Lisp_Object name
, finalname
;
250 struct gcpro gcpro1
, gcpro2
;
253 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
254 GCPRO2 (finalname
, name
);
256 /* Note: DECODE_FILE can GC; it should protect its argument,
258 name
= DECODE_FILE (name
);
261 /* Now that we have unwind_protect in place, we might as well
262 allow matching to be interrupted. */
267 || (0 <= re_search (bufp
, SDATA (name
), len
, 0, len
, 0)))
276 Lisp_Object fullname
;
277 int nbytes
= len
+ directory_nbytes
+ needsep
;
280 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
281 bcopy (SDATA (directory
), SDATA (fullname
),
285 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
288 SDATA (fullname
) + directory_nbytes
+ needsep
,
291 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
293 /* Some bug somewhere. */
297 STRING_SET_CHARS (fullname
, nchars
);
298 if (nchars
== nbytes
)
299 STRING_SET_UNIBYTE (fullname
);
301 finalname
= fullname
;
308 /* Construct an expanded filename for the directory entry.
309 Use the decoded names for input to Ffile_attributes. */
310 Lisp_Object decoded_fullname
, fileattrs
;
311 struct gcpro gcpro1
, gcpro2
;
313 decoded_fullname
= fileattrs
= Qnil
;
314 GCPRO2 (decoded_fullname
, fileattrs
);
316 /* Both Fexpand_file_name and Ffile_attributes can GC. */
317 decoded_fullname
= Fexpand_file_name (name
, directory
);
318 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
320 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
324 list
= Fcons (finalname
, list
);
335 /* Discard the unwind protect. */
336 specpdl_ptr
= specpdl
+ count
;
339 list
= Fsort (Fnreverse (list
),
340 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
342 RETURN_UNGCPRO (list
);
346 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
347 doc
: /* Return a list of names of files in DIRECTORY.
348 There are three optional arguments:
349 If FULL is non-nil, return absolute file names. Otherwise return names
350 that are relative to the specified directory.
351 If MATCH is non-nil, mention only file names that match the regexp MATCH.
352 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
353 NOSORT is useful if you plan to sort the result yourself. */)
354 (directory
, full
, match
, nosort
)
355 Lisp_Object directory
, full
, match
, nosort
;
358 directory
= Fexpand_file_name (directory
, Qnil
);
360 /* If the file name has special constructs in it,
361 call the corresponding file handler. */
362 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
364 return call5 (handler
, Qdirectory_files
, directory
,
365 full
, match
, nosort
);
367 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
370 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
371 Sdirectory_files_and_attributes
, 1, 5, 0,
372 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
373 There are four optional arguments:
374 If FULL is non-nil, return absolute file names. Otherwise return names
375 that are relative to the specified directory.
376 If MATCH is non-nil, mention only file names that match the regexp MATCH.
377 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
378 NOSORT is useful if you plan to sort the result yourself.
379 ID-FORMAT specifies the preferred format of attributes uid and gid, see
380 `file-attributes' for further documentation. */)
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 ();
460 file_name_completion (file
, dirname
, all_flag
, ver_flag
, predicate
)
461 Lisp_Object file
, dirname
;
462 int all_flag
, ver_flag
;
463 Lisp_Object predicate
;
466 int bestmatchsize
= 0, skip
;
467 register int compare
, matchsize
;
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
;
478 int count
= SPECPDL_INDEX ();
479 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
484 extern DIRENTRY
* readdirver ();
486 DIRENTRY
*((* readfunc
) ());
488 /* Filename completion on VMS ignores case, since VMS filesys does. */
489 specbind (Qcompletion_ignore_case
, Qt
);
493 readfunc
= readdirver
;
494 file
= Fupcase (file
);
499 #ifdef FILE_SYSTEM_CASE
500 file
= FILE_SYSTEM_CASE (file
);
503 encoded_file
= encoded_dir
= Qnil
;
504 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
505 dirname
= Fexpand_file_name (dirname
, Qnil
);
507 /* Do completion on the encoded file name
508 because the other names in the directory are (we presume)
509 encoded likewise. We decode the completed string at the end. */
510 /* Actually, this is not quite true any more: we do most of the completion
511 work with decoded file names, but we still do some filtering based
512 on the encoded file name. */
513 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
515 encoded_dir
= ENCODE_FILE (dirname
);
517 /* With passcount = 0, ignore files that end in an ignored extension.
518 If nothing found then try again with passcount = 1, don't ignore them.
519 If looking for all completions, start with passcount = 1,
520 so always take even the ignored ones.
522 ** It would not actually be helpful to the user to ignore any possible
523 completions when making a list of them.** */
525 for (passcount
= !!all_flag
; NILP (bestmatch
) && passcount
< 2; passcount
++)
527 int inner_count
= SPECPDL_INDEX ();
530 d
= opendir (SDATA (Fdirectory_file_name (encoded_dir
)));
533 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
535 record_unwind_protect (directory_files_internal_unwind
,
536 make_save_value (d
, 0));
538 /* Loop reading blocks */
539 /* (att3b compiler bug requires do a null comparison this way) */
546 dp
= (*readfunc
) (d
);
566 if (! DIRENTRY_NONEMPTY (dp
)
567 || len
< SCHARS (encoded_file
)
568 || 0 <= scmp (dp
->d_name
, SDATA (encoded_file
),
569 SCHARS (encoded_file
)))
572 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
575 directoryp
= ((st
.st_mode
& S_IFMT
) == S_IFDIR
);
579 #ifndef TRIVIAL_DIRECTORY_ENTRY
580 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
582 /* "." and ".." are never interesting as completions, and are
583 actually in the way in a directory with only one file. */
584 if (!passcount
&& TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
586 if (!passcount
&& len
> SCHARS (encoded_file
))
587 /* Ignore directories if they match an element of
588 completion-ignored-extensions which ends in a slash. */
589 for (tem
= Vcompletion_ignored_extensions
;
590 CONSP (tem
); tem
= XCDR (tem
))
598 /* Need to encode ELT, since scmp compares unibyte
600 elt
= ENCODE_FILE (elt
);
601 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
605 if (p1
[elt_len
] != '/')
607 skip
= len
- elt_len
;
611 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
618 /* Compare extensions-to-be-ignored against end of this file name */
619 /* if name is not an exact match against specified string */
620 if (!passcount
&& len
> SCHARS (encoded_file
))
621 /* and exit this for loop if a match is found */
622 for (tem
= Vcompletion_ignored_extensions
;
623 CONSP (tem
); tem
= XCDR (tem
))
626 if (!STRINGP (elt
)) continue;
627 /* Need to encode ELT, since scmp compares unibyte
629 elt
= ENCODE_FILE (elt
);
630 skip
= len
- SCHARS (elt
);
631 if (skip
< 0) continue;
633 if (0 <= scmp (dp
->d_name
+ skip
,
641 /* If an ignored-extensions match was found,
642 don't process this name as a completion. */
643 if (!passcount
&& CONSP (tem
))
646 /* FIXME: If we move this `decode' earlier we can eliminate
647 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
648 name
= make_unibyte_string (dp
->d_name
, len
);
649 name
= DECODE_FILE (name
);
655 XSETFASTINT (zero
, 0);
657 /* Ignore this element if it fails to match all the regexps. */
658 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
659 regexps
= XCDR (regexps
))
660 if (fast_string_match (XCAR (regexps
), name
) < 0)
666 /* This is a possible completion */
669 /* This completion is a directory; make it end with '/' */
670 name
= Ffile_name_as_directory (name
);
673 /* Test the predicate, if any. */
675 if (!NILP (predicate
))
682 decoded
= Fexpand_file_name (name
, dirname
);
683 val
= call1 (predicate
, decoded
);
690 /* Suitably record this match. */
695 bestmatch
= Fcons (name
, bestmatch
);
696 else if (NILP (bestmatch
))
699 bestmatchsize
= SCHARS (name
);
703 Lisp_Object zero
= make_number (0);
704 /* FIXME: This is a copy of the code in Ftry_completion. */
705 compare
= min (bestmatchsize
, SCHARS (name
));
706 tem
= Fcompare_strings (bestmatch
, zero
,
707 make_number (compare
),
709 make_number (compare
),
710 completion_ignore_case
? Qt
: Qnil
);
713 else if (XINT (tem
) < 0)
714 matchsize
= - XINT (tem
) - 1;
716 matchsize
= XINT (tem
) - 1;
718 if (completion_ignore_case
)
720 /* If this is an exact match except for case,
721 use it as the best match rather than one that is not
722 an exact match. This way, we get the case pattern
723 of the actual match. */
724 /* This tests that the current file is an exact match
725 but BESTMATCH is not (it is too long). */
726 if ((matchsize
== SCHARS (name
)
727 && matchsize
+ !!directoryp
728 < SCHARS (bestmatch
))
730 /* If there is no exact match ignoring case,
731 prefer a match that does not change the case
733 /* If there is more than one exact match aside from
734 case, and one of them is exact including case,
736 /* This == checks that, of current file and BESTMATCH,
737 either both or neither are exact. */
738 (((matchsize
== SCHARS (name
))
740 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
741 && (tem
= Fcompare_strings (name
, zero
,
742 make_number (SCHARS (file
)),
747 && (tem
= Fcompare_strings (bestmatch
, zero
,
748 make_number (SCHARS (file
)),
755 bestmatchsize
= matchsize
;
758 /* This closes the directory. */
759 bestmatch
= unbind_to (inner_count
, bestmatch
);
763 bestmatch
= unbind_to (count
, bestmatch
);
765 if (all_flag
|| NILP (bestmatch
))
767 if (matchcount
== 1 && bestmatchsize
== SCHARS (file
))
769 bestmatch
= Fsubstring (bestmatch
, make_number (0),
770 make_number (bestmatchsize
));
774 /* Compare exactly LEN chars of strings at S1 and S2,
775 ignoring case if appropriate.
776 Return -1 if strings match,
777 else number of chars that match at the beginning. */
781 register unsigned char *s1
, *s2
;
784 register int l
= len
;
786 if (completion_ignore_case
)
788 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
793 while (l
&& *s1
++ == *s2
++)
803 file_name_completion_stat (dirname
, dp
, st_addr
)
806 struct stat
*st_addr
;
808 int len
= NAMLEN (dp
);
809 int pos
= SCHARS (dirname
);
811 char *fullname
= (char *) alloca (len
+ pos
+ 2);
815 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
816 but aren't required here. Avoid computing the following fields:
817 st_inode, st_size and st_nlink for directories, and the execute bits
818 in st_mode for non-directory files with non-standard extensions. */
820 unsigned short save_djstat_flags
= _djstat_flags
;
822 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
823 #endif /* __DJGPP__ > 1 */
826 bcopy (SDATA (dirname
), fullname
, pos
);
828 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
829 fullname
[pos
++] = DIRECTORY_SEP
;
832 bcopy (dp
->d_name
, fullname
+ pos
, len
);
833 fullname
[pos
+ len
] = 0;
836 /* We want to return success if a link points to a nonexistent file,
837 but we want to return the status for what the link points to,
838 in case it is a directory. */
839 value
= lstat (fullname
, st_addr
);
840 stat (fullname
, st_addr
);
843 value
= stat (fullname
, st_addr
);
846 _djstat_flags
= save_djstat_flags
;
847 #endif /* __DJGPP__ > 1 */
855 DEFUN ("file-name-all-versions", Ffile_name_all_versions
,
856 Sfile_name_all_versions
, 2, 2, 0,
857 doc
: /* Return a list of all versions of file name FILE in directory DIRECTORY. */)
859 Lisp_Object file
, directory
;
861 return file_name_completion (file
, directory
, 1, 1, Qnil
);
864 DEFUN ("file-version-limit", Ffile_version_limit
, Sfile_version_limit
, 1, 1, 0,
865 doc
: /* Return the maximum number of versions allowed for FILE.
866 Returns nil if the file cannot be opened or if there is no version limit. */)
868 Lisp_Object filename
;
873 struct XABFHC xabfhc
;
876 filename
= Fexpand_file_name (filename
, Qnil
);
878 xabfhc
= cc$rms_xabfhc
;
879 fab
.fab$l_fna
= SDATA (filename
);
880 fab
.fab$b_fns
= strlen (fab
.fab$l_fna
);
881 fab
.fab$l_xab
= (char *) &xabfhc
;
882 status
= sys$
open (&fab
, 0, 0);
883 if (status
!= RMS$_NORMAL
) /* Probably non-existent file */
885 sys$
close (&fab
, 0, 0);
886 if (xabfhc
.xab$w_verlimit
== 32767)
887 return Qnil
; /* No version limit */
889 return make_number (xabfhc
.xab$w_verlimit
);
898 return Fcons (make_number (time
>> 16),
899 Fcons (make_number (time
& 0177777), Qnil
));
903 stat_uname (struct stat
*st
)
908 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
918 stat_gname (struct stat
*st
)
923 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
932 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
933 doc
: /* Return a list of attributes of file FILENAME.
934 Value is nil if specified file cannot be opened.
936 ID-FORMAT specifies the preferred format of attributes uid and gid (see
937 below) - valid values are 'string and 'integer. The latter is the default,
938 but we plan to change that, so you should specify a non-nil value for
939 ID-FORMAT if you use the returned uid or gid.
941 Elements of the attribute list are:
942 0. t for directory, string (name linked to) for symbolic link, or nil.
943 1. Number of links to file.
944 2. File uid as a string or an integer. If a string value cannot be
945 looked up, the integer value is returned.
946 3. File gid, likewise.
947 4. Last access time, as a list of two integers.
948 First integer has high-order 16 bits of time, second has low 16 bits.
949 5. Last modification time, likewise.
950 6. Last status change time, likewise.
952 This is a floating point number if the size is too large for an integer.
953 8. File modes, as a string of ten letters or dashes as in ls -l.
954 9. t if file's gid would change if file were deleted and recreated.
955 10. inode number. If inode number is larger than the Emacs integer,
956 but still fits into a 32-bit number, this is a cons cell containing two
957 integers: first the high part, then the low 16 bits. If the inode number
958 is wider than 32 bits, this is a cons cell containing three integers:
959 first the high 24 bits, then middle 24 bits, and finally the low 16 bits.
960 11. Device number. If it is larger than the Emacs integer, this is
961 a cons cell, similar to the inode number. */)
962 (filename
, id_format
)
963 Lisp_Object filename
, id_format
;
965 Lisp_Object values
[12];
968 #if defined (BSD4_2) || defined (BSD4_3)
978 filename
= Fexpand_file_name (filename
, Qnil
);
980 /* If the file name has special constructs in it,
981 call the corresponding file handler. */
982 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
984 { /* Only pass the extra arg if it is used to help backward compatibility
985 with old file handlers which do not implement the new arg. --Stef */
986 if (NILP (id_format
))
987 return call2 (handler
, Qfile_attributes
, filename
);
989 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
993 encoded
= ENCODE_FILE (filename
);
996 if (lstat (SDATA (encoded
), &s
) < 0)
999 switch (s
.st_mode
& S_IFMT
)
1002 values
[0] = Qnil
; break;
1004 values
[0] = Qt
; break;
1007 values
[0] = Ffile_symlink_p (filename
); break;
1010 values
[1] = make_number (s
.st_nlink
);
1011 if (NILP (id_format
) || EQ (id_format
, Qinteger
))
1013 values
[2] = make_fixnum_or_float (s
.st_uid
);
1014 values
[3] = make_fixnum_or_float (s
.st_gid
);
1019 uname
= stat_uname (&s
);
1020 values
[2] = (uname
? build_string (uname
)
1021 : make_fixnum_or_float (s
.st_uid
));
1022 gname
= stat_gname (&s
);
1023 values
[3] = (gname
? build_string (gname
)
1024 : make_fixnum_or_float (s
.st_gid
));
1027 values
[4] = make_time (s
.st_atime
);
1028 values
[5] = make_time (s
.st_mtime
);
1029 values
[6] = make_time (s
.st_ctime
);
1030 values
[7] = make_number (s
.st_size
);
1031 /* If the size is out of range for an integer, return a float. */
1032 if (XINT (values
[7]) != s
.st_size
)
1033 values
[7] = make_float ((double)s
.st_size
);
1034 /* If the size is negative, and its type is long, convert it back to
1036 if (s
.st_size
< 0 && sizeof (s
.st_size
) == sizeof (long))
1037 values
[7] = make_float ((double) ((unsigned long) s
.st_size
));
1039 filemodestring (&s
, modes
);
1040 values
[8] = make_string (modes
, 10);
1041 #if defined (BSD4_2) || defined (BSD4_3) /* file gid will be dir gid */
1042 dirname
= Ffile_name_directory (filename
);
1043 if (! NILP (dirname
))
1044 encoded
= ENCODE_FILE (dirname
);
1045 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
1046 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
1047 else /* if we can't tell, assume worst */
1049 #else /* file gid will be egid */
1050 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1051 #endif /* BSD4_2 (or BSD4_3) */
1052 /* Shut up GCC warnings in FIXNUM_OVERFLOW_P below. */
1053 if (sizeof (s
.st_ino
) > sizeof (ino
))
1054 ino
= (EMACS_INT
)(s
.st_ino
& 0xffffffff);
1057 if (!FIXNUM_OVERFLOW_P (ino
)
1058 && (sizeof (s
.st_ino
) <= sizeof (ino
) || (s
.st_ino
& ~INTMASK
) == 0))
1059 /* Keep the most common cases as integers. */
1060 values
[10] = make_number (ino
);
1061 else if (sizeof (s
.st_ino
) <= sizeof (ino
)
1062 || ((s
.st_ino
>> 16) & ~INTMASK
) == 0)
1063 /* To allow inode numbers larger than VALBITS, separate the bottom
1065 values
[10] = Fcons (make_number ((EMACS_INT
)(s
.st_ino
>> 16)),
1066 make_number ((EMACS_INT
)(s
.st_ino
& 0xffff)));
1069 /* To allow inode numbers beyond 32 bits, separate into 2 24-bit
1070 high parts and a 16-bit bottom part. */
1071 EMACS_INT high_ino
= s
.st_ino
>> 32;
1072 EMACS_INT low_ino
= s
.st_ino
& 0xffffffff;
1074 values
[10] = Fcons (make_number (high_ino
>> 8),
1075 Fcons (make_number (((high_ino
& 0xff) << 16)
1077 make_number (low_ino
& 0xffff)));
1080 /* Likewise for device, but don't let it become negative. We used
1081 to use FIXNUM_OVERFLOW_P here, but that won't catch large
1082 positive numbers such as 0xFFEEDDCC. */
1083 if ((EMACS_INT
)s
.st_dev
< 0
1084 || (EMACS_INT
)s
.st_dev
> MOST_POSITIVE_FIXNUM
)
1085 values
[11] = Fcons (make_number (s
.st_dev
>> 16),
1086 make_number (s
.st_dev
& 0xffff));
1088 values
[11] = make_number (s
.st_dev
);
1090 return Flist (sizeof(values
) / sizeof(values
[0]), values
);
1093 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1094 doc
: /* Return t if first arg file attributes list is less than second.
1095 Comparison is in lexicographic order and case is significant. */)
1099 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1105 Qdirectory_files
= intern ("directory-files");
1106 Qdirectory_files_and_attributes
= intern ("directory-files-and-attributes");
1107 Qfile_name_completion
= intern ("file-name-completion");
1108 Qfile_name_all_completions
= intern ("file-name-all-completions");
1109 Qfile_attributes
= intern ("file-attributes");
1110 Qfile_attributes_lessp
= intern ("file-attributes-lessp");
1112 staticpro (&Qdirectory_files
);
1113 staticpro (&Qdirectory_files_and_attributes
);
1114 staticpro (&Qfile_name_completion
);
1115 staticpro (&Qfile_name_all_completions
);
1116 staticpro (&Qfile_attributes
);
1117 staticpro (&Qfile_attributes_lessp
);
1119 defsubr (&Sdirectory_files
);
1120 defsubr (&Sdirectory_files_and_attributes
);
1121 defsubr (&Sfile_name_completion
);
1123 defsubr (&Sfile_name_all_versions
);
1124 defsubr (&Sfile_version_limit
);
1126 defsubr (&Sfile_name_all_completions
);
1127 defsubr (&Sfile_attributes
);
1128 defsubr (&Sfile_attributes_lessp
);
1130 DEFVAR_LISP ("completion-ignored-extensions", &Vcompletion_ignored_extensions
,
1131 doc
: /* Completion ignores file names ending in any string in this list.
1132 It does not ignore them if all possible completions end in one of
1133 these strings or when displaying a list of completions.
1134 It ignores directory names if they match any string in this list which
1135 ends in a slash. */);
1136 Vcompletion_ignored_extensions
= Qnil
;
1139 /* arch-tag: 1ac8deca-4d8f-4d41-ade9-089154d98c03
1140 (do not change this comment) */