1 /* Lisp functions for making directory listings.
2 Copyright (C) 1985-1986, 1993-1994, 1999-2012 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/types.h>
35 /* The d_nameln member of a struct dirent includes the '\0' character
36 on some systems, but not on others. What's worse, you can't tell
37 at compile-time which one it will be, since it really depends on
38 the sort of system providing the filesystem you're reading from,
39 not the system you are running on. Paul Eggert
40 <eggert@bi.twinsun.com> says this occurs when Emacs is running on a
41 SunOS 4.1.2 host, reading a directory that is remote-mounted from a
42 Solaris 2.1 host and is in a native Solaris 2.1 filesystem.
44 Since applying strlen to the name always works, we'll just do that. */
45 #define NAMLEN(p) strlen (p->d_name)
50 #define DIRENTRY struct dirent
52 #else /* not HAVE_DIRENT_H */
57 #define DIRENTRY struct direct
59 extern DIR *opendir (char *);
60 extern struct direct
*readdir (DIR *);
62 #endif /* HAVE_DIRENT_H */
65 #include <stat-time.h>
68 #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0)
70 #define DIRENTRY_NONEMPTY(p) ((p)->d_ino)
75 #include "character.h"
81 #include "blockinput.h"
83 static Lisp_Object Qdirectory_files
;
84 static Lisp_Object Qdirectory_files_and_attributes
;
85 static Lisp_Object Qfile_name_completion
;
86 static Lisp_Object Qfile_name_all_completions
;
87 static Lisp_Object Qfile_attributes
;
88 static Lisp_Object Qfile_attributes_lessp
;
90 static ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
94 directory_files_internal_w32_unwind (Lisp_Object arg
)
96 Vw32_get_true_file_attributes
= arg
;
102 directory_files_internal_unwind (Lisp_Object dh
)
104 DIR *d
= (DIR *) XSAVE_VALUE (dh
)->pointer
;
111 /* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
112 When ATTRS is zero, return a list of directory filenames; when
113 non-zero, return a list of directory filenames and their attributes.
114 In the latter case, ID_FORMAT is passed to Ffile_attributes. */
117 directory_files_internal (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, int attrs
, Lisp_Object id_format
)
120 ptrdiff_t directory_nbytes
;
121 Lisp_Object list
, dirfilename
, encoded_directory
;
122 struct re_pattern_buffer
*bufp
= NULL
;
124 ptrdiff_t count
= SPECPDL_INDEX ();
125 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
128 Lisp_Object w32_save
= Qnil
;
131 /* Because of file name handlers, these functions might call
132 Ffuncall, and cause a GC. */
133 list
= encoded_directory
= dirfilename
= Qnil
;
134 GCPRO5 (match
, directory
, list
, dirfilename
, encoded_directory
);
135 dirfilename
= Fdirectory_file_name (directory
);
139 CHECK_STRING (match
);
141 /* MATCH might be a flawed regular expression. Rather than
142 catching and signaling our own errors, we just call
143 compile_pattern to do the work for us. */
144 /* Pass 1 for the MULTIBYTE arg
145 because we do make multibyte strings if the contents warrant. */
147 /* Windows users want case-insensitive wildcards. */
148 bufp
= compile_pattern (match
, 0,
149 BVAR (&buffer_defaults
, case_canon_table
), 0, 1);
150 # else /* !WINDOWSNT */
151 bufp
= compile_pattern (match
, 0, Qnil
, 0, 1);
152 # endif /* !WINDOWSNT */
155 /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
156 run_pre_post_conversion_on_str which calls Lisp directly and
158 if (STRING_MULTIBYTE (dirfilename
))
159 dirfilename
= ENCODE_FILE (dirfilename
);
160 encoded_directory
= (STRING_MULTIBYTE (directory
)
161 ? ENCODE_FILE (directory
) : directory
);
163 /* Now *bufp is the compiled form of MATCH; don't call anything
164 which might compile a new regexp until we're done with the loop! */
167 d
= opendir (SSDATA (dirfilename
));
170 report_file_error ("Opening directory", Fcons (directory
, Qnil
));
172 /* Unfortunately, we can now invoke expand-file-name and
173 file-attributes on filenames, both of which can throw, so we must
174 do a proper unwind-protect. */
175 record_unwind_protect (directory_files_internal_unwind
,
176 make_save_value (d
, 0));
181 extern int is_slow_fs (const char *);
183 /* Do this only once to avoid doing it (in w32.c:stat) for each
184 file in the directory, when we call Ffile_attributes below. */
185 record_unwind_protect (directory_files_internal_w32_unwind
,
186 Vw32_get_true_file_attributes
);
187 w32_save
= Vw32_get_true_file_attributes
;
188 if (EQ (Vw32_get_true_file_attributes
, Qlocal
))
190 /* w32.c:stat will notice these bindings and avoid calling
191 GetDriveType for each file. */
192 if (is_slow_fs (SDATA (dirfilename
)))
193 Vw32_get_true_file_attributes
= Qnil
;
195 Vw32_get_true_file_attributes
= Qt
;
200 directory_nbytes
= SBYTES (directory
);
201 re_match_object
= Qt
;
203 /* Decide whether we need to add a directory separator. */
204 if (directory_nbytes
== 0
205 || !IS_ANY_SEP (SREF (directory
, directory_nbytes
- 1)))
208 /* Loop reading blocks until EOF or error. */
227 if (DIRENTRY_NONEMPTY (dp
))
231 Lisp_Object name
, finalname
;
232 struct gcpro gcpro1
, gcpro2
;
235 name
= finalname
= make_unibyte_string (dp
->d_name
, len
);
236 GCPRO2 (finalname
, name
);
238 /* Note: DECODE_FILE can GC; it should protect its argument,
240 name
= DECODE_FILE (name
);
243 /* Now that we have unwind_protect in place, we might as well
244 allow matching to be interrupted. */
249 || (0 <= re_search (bufp
, SSDATA (name
), len
, 0, len
, 0)))
258 Lisp_Object fullname
;
259 ptrdiff_t nbytes
= len
+ directory_nbytes
+ needsep
;
262 fullname
= make_uninit_multibyte_string (nbytes
, nbytes
);
263 memcpy (SDATA (fullname
), SDATA (directory
),
267 SSET (fullname
, directory_nbytes
, DIRECTORY_SEP
);
269 memcpy (SDATA (fullname
) + directory_nbytes
+ needsep
,
272 nchars
= chars_in_text (SDATA (fullname
), nbytes
);
274 /* Some bug somewhere. */
278 STRING_SET_CHARS (fullname
, nchars
);
279 if (nchars
== nbytes
)
280 STRING_SET_UNIBYTE (fullname
);
282 finalname
= fullname
;
289 /* Construct an expanded filename for the directory entry.
290 Use the decoded names for input to Ffile_attributes. */
291 Lisp_Object decoded_fullname
, fileattrs
;
292 struct gcpro gcpro1
, gcpro2
;
294 decoded_fullname
= fileattrs
= Qnil
;
295 GCPRO2 (decoded_fullname
, fileattrs
);
297 /* Both Fexpand_file_name and Ffile_attributes can GC. */
298 decoded_fullname
= Fexpand_file_name (name
, directory
);
299 fileattrs
= Ffile_attributes (decoded_fullname
, id_format
);
301 list
= Fcons (Fcons (finalname
, fileattrs
), list
);
305 list
= Fcons (finalname
, list
);
317 Vw32_get_true_file_attributes
= w32_save
;
320 /* Discard the unwind protect. */
321 specpdl_ptr
= specpdl
+ count
;
324 list
= Fsort (Fnreverse (list
),
325 attrs
? Qfile_attributes_lessp
: Qstring_lessp
);
327 RETURN_UNGCPRO (list
);
331 DEFUN ("directory-files", Fdirectory_files
, Sdirectory_files
, 1, 4, 0,
332 doc
: /* Return a list of names of files in DIRECTORY.
333 There are three optional arguments:
334 If FULL is non-nil, return absolute file names. Otherwise return names
335 that are relative to the specified directory.
336 If MATCH is non-nil, mention only file names that match the regexp MATCH.
337 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
338 Otherwise, the list returned is sorted with `string-lessp'.
339 NOSORT is useful if you plan to sort the result yourself. */)
340 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
)
343 directory
= Fexpand_file_name (directory
, Qnil
);
345 /* If the file name has special constructs in it,
346 call the corresponding file handler. */
347 handler
= Ffind_file_name_handler (directory
, Qdirectory_files
);
349 return call5 (handler
, Qdirectory_files
, directory
,
350 full
, match
, nosort
);
352 return directory_files_internal (directory
, full
, match
, nosort
, 0, Qnil
);
355 DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes
,
356 Sdirectory_files_and_attributes
, 1, 5, 0,
357 doc
: /* Return a list of names of files and their attributes in DIRECTORY.
358 There are four optional arguments:
359 If FULL is non-nil, return absolute file names. Otherwise return names
360 that are relative to the specified directory.
361 If MATCH is non-nil, mention only file names that match the regexp MATCH.
362 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
363 NOSORT is useful if you plan to sort the result yourself.
364 ID-FORMAT specifies the preferred format of attributes uid and gid, see
365 `file-attributes' for further documentation.
366 On MS-Windows, performance depends on `w32-get-true-file-attributes',
368 (Lisp_Object directory
, Lisp_Object full
, Lisp_Object match
, Lisp_Object nosort
, Lisp_Object id_format
)
371 directory
= Fexpand_file_name (directory
, Qnil
);
373 /* If the file name has special constructs in it,
374 call the corresponding file handler. */
375 handler
= Ffind_file_name_handler (directory
, Qdirectory_files_and_attributes
);
377 return call6 (handler
, Qdirectory_files_and_attributes
,
378 directory
, full
, match
, nosort
, id_format
);
380 return directory_files_internal (directory
, full
, match
, nosort
, 1, id_format
);
384 static Lisp_Object file_name_completion
385 (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
,
386 Lisp_Object predicate
);
388 DEFUN ("file-name-completion", Ffile_name_completion
, Sfile_name_completion
,
390 doc
: /* Complete file name FILE in directory DIRECTORY.
391 Returns the longest string
392 common to all file names in DIRECTORY that start with FILE.
393 If there is only one and FILE matches it exactly, returns t.
394 Returns nil if DIRECTORY contains no name starting with FILE.
396 If PREDICATE is non-nil, call PREDICATE with each possible
397 completion (in absolute form) and ignore it if PREDICATE returns nil.
399 This function ignores some of the possible completions as
400 determined by the variable `completion-ignored-extensions', which see. */)
401 (Lisp_Object file
, Lisp_Object directory
, Lisp_Object predicate
)
404 directory
= Fexpand_file_name (directory
, Qnil
);
406 /* If the directory name has special constructs in it,
407 call the corresponding file handler. */
408 handler
= Ffind_file_name_handler (directory
, Qfile_name_completion
);
410 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
412 /* If the file name has special constructs in it,
413 call the corresponding file handler. */
414 handler
= Ffind_file_name_handler (file
, Qfile_name_completion
);
416 return call4 (handler
, Qfile_name_completion
, file
, directory
, predicate
);
418 return file_name_completion (file
, directory
, 0, 0, predicate
);
421 DEFUN ("file-name-all-completions", Ffile_name_all_completions
,
422 Sfile_name_all_completions
, 2, 2, 0,
423 doc
: /* Return a list of all completions of file name FILE in directory DIRECTORY.
424 These are all file names in directory DIRECTORY which begin with FILE. */)
425 (Lisp_Object file
, Lisp_Object directory
)
428 directory
= Fexpand_file_name (directory
, Qnil
);
430 /* If the directory name has special constructs in it,
431 call the corresponding file handler. */
432 handler
= Ffind_file_name_handler (directory
, Qfile_name_all_completions
);
434 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
436 /* If the file name has special constructs in it,
437 call the corresponding file handler. */
438 handler
= Ffind_file_name_handler (file
, Qfile_name_all_completions
);
440 return call3 (handler
, Qfile_name_all_completions
, file
, directory
);
442 return file_name_completion (file
, directory
, 1, 0, Qnil
);
445 static int file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
);
446 static Lisp_Object Qdefault_directory
;
449 file_name_completion (Lisp_Object file
, Lisp_Object dirname
, int all_flag
, int ver_flag
, Lisp_Object predicate
)
452 ptrdiff_t bestmatchsize
= 0;
454 /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
455 If ALL_FLAG is 0, BESTMATCH is either nil
456 or the best match so far, not decoded. */
457 Lisp_Object bestmatch
, tem
, elt
, name
;
458 Lisp_Object encoded_file
;
459 Lisp_Object encoded_dir
;
462 /* If includeall is zero, exclude files in completion-ignored-extensions as
463 well as "." and "..". Until shown otherwise, assume we can't exclude
466 ptrdiff_t count
= SPECPDL_INDEX ();
467 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
474 encoded_file
= encoded_dir
= Qnil
;
475 GCPRO5 (file
, dirname
, bestmatch
, encoded_file
, encoded_dir
);
476 specbind (Qdefault_directory
, dirname
);
478 /* Do completion on the encoded file name
479 because the other names in the directory are (we presume)
480 encoded likewise. We decode the completed string at the end. */
481 /* Actually, this is not quite true any more: we do most of the completion
482 work with decoded file names, but we still do some filtering based
483 on the encoded file name. */
484 encoded_file
= STRING_MULTIBYTE (file
) ? ENCODE_FILE (file
) : file
;
486 encoded_dir
= ENCODE_FILE (dirname
);
489 d
= opendir (SSDATA (Fdirectory_file_name (encoded_dir
)));
492 report_file_error ("Opening directory", Fcons (dirname
, Qnil
));
494 record_unwind_protect (directory_files_internal_unwind
,
495 make_save_value (d
, 0));
497 /* Loop reading blocks */
498 /* (att3b compiler bug requires do a null comparison this way) */
522 if (! DIRENTRY_NONEMPTY (dp
)
523 || len
< SCHARS (encoded_file
)
524 || 0 <= scmp (dp
->d_name
, SSDATA (encoded_file
),
525 SCHARS (encoded_file
)))
528 if (file_name_completion_stat (encoded_dir
, dp
, &st
) < 0)
531 directoryp
= S_ISDIR (st
.st_mode
);
533 /* If all_flag is set, always include all.
534 It would not actually be helpful to the user to ignore any possible
535 completions when making a list of them. */
540 #if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
541 /* If this entry matches the current bestmatch, the only
542 thing it can do is increase matchcount, so don't bother
543 investigating it any further. */
544 if (!completion_ignore_case
545 /* The return result depends on whether it's the sole match. */
547 && !includeall
/* This match may allow includeall to 0. */
548 && len
>= bestmatchsize
549 && 0 > scmp (dp
->d_name
, SSDATA (bestmatch
), bestmatchsize
))
555 #ifndef TRIVIAL_DIRECTORY_ENTRY
556 #define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
558 /* "." and ".." are never interesting as completions, and are
559 actually in the way in a directory with only one file. */
560 if (TRIVIAL_DIRECTORY_ENTRY (dp
->d_name
))
562 else if (len
> SCHARS (encoded_file
))
563 /* Ignore directories if they match an element of
564 completion-ignored-extensions which ends in a slash. */
565 for (tem
= Vcompletion_ignored_extensions
;
566 CONSP (tem
); tem
= XCDR (tem
))
574 /* Need to encode ELT, since scmp compares unibyte
576 elt
= ENCODE_FILE (elt
);
577 elt_len
= SCHARS (elt
) - 1; /* -1 for trailing / */
581 if (p1
[elt_len
] != '/')
583 skip
= len
- elt_len
;
587 if (0 <= scmp (dp
->d_name
+ skip
, p1
, elt_len
))
594 /* Compare extensions-to-be-ignored against end of this file name */
595 /* if name is not an exact match against specified string */
596 if (len
> SCHARS (encoded_file
))
597 /* and exit this for loop if a match is found */
598 for (tem
= Vcompletion_ignored_extensions
;
599 CONSP (tem
); tem
= XCDR (tem
))
602 if (!STRINGP (elt
)) continue;
603 /* Need to encode ELT, since scmp compares unibyte
605 elt
= ENCODE_FILE (elt
);
606 skip
= len
- SCHARS (elt
);
607 if (skip
< 0) continue;
609 if (0 <= scmp (dp
->d_name
+ skip
,
617 /* If an ignored-extensions match was found,
618 don't process this name as a completion. */
622 if (!includeall
&& canexclude
)
623 /* We're not including all files and this file can be excluded. */
626 if (includeall
&& !canexclude
)
627 { /* If we have one non-excludable file, we want to exclude the
630 /* Throw away any previous excludable match found. */
636 /* FIXME: If we move this `decode' earlier we can eliminate
637 the repeated ENCODE_FILE on Vcompletion_ignored_extensions. */
638 name
= make_unibyte_string (dp
->d_name
, len
);
639 name
= DECODE_FILE (name
);
644 /* Ignore this element if it fails to match all the regexps. */
645 if (completion_ignore_case
)
647 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
648 regexps
= XCDR (regexps
))
649 if (fast_string_match_ignore_case (XCAR (regexps
), name
) < 0)
654 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
655 regexps
= XCDR (regexps
))
656 if (fast_string_match (XCAR (regexps
), name
) < 0)
664 /* This is a possible completion */
666 /* This completion is a directory; make it end with '/'. */
667 name
= Ffile_name_as_directory (name
);
669 /* Test the predicate, if any. */
670 if (!NILP (predicate
))
676 val
= call1 (predicate
, name
);
683 /* Suitably record this match. */
685 matchcount
+= matchcount
<= 1;
688 bestmatch
= Fcons (name
, bestmatch
);
689 else if (NILP (bestmatch
))
692 bestmatchsize
= SCHARS (name
);
696 Lisp_Object zero
= make_number (0);
697 /* FIXME: This is a copy of the code in Ftry_completion. */
698 ptrdiff_t compare
= min (bestmatchsize
, SCHARS (name
));
700 = Fcompare_strings (bestmatch
, zero
,
701 make_number (compare
),
703 make_number (compare
),
704 completion_ignore_case
? Qt
: Qnil
);
706 = (EQ (cmp
, Qt
) ? compare
707 : XINT (cmp
) < 0 ? - XINT (cmp
) - 1
710 if (completion_ignore_case
)
712 /* If this is an exact match except for case,
713 use it as the best match rather than one that is not
714 an exact match. This way, we get the case pattern
715 of the actual match. */
716 /* This tests that the current file is an exact match
717 but BESTMATCH is not (it is too long). */
718 if ((matchsize
== SCHARS (name
)
719 && matchsize
+ !!directoryp
< SCHARS (bestmatch
))
721 /* If there is no exact match ignoring case,
722 prefer a match that does not change the case
724 /* If there is more than one exact match aside from
725 case, and one of them is exact including case,
727 /* This == checks that, of current file and BESTMATCH,
728 either both or neither are exact. */
729 (((matchsize
== SCHARS (name
))
731 (matchsize
+ !!directoryp
== SCHARS (bestmatch
)))
732 && (cmp
= Fcompare_strings (name
, zero
,
733 make_number (SCHARS (file
)),
738 && (cmp
= Fcompare_strings (bestmatch
, zero
,
739 make_number (SCHARS (file
)),
746 bestmatchsize
= matchsize
;
748 /* If the best completion so far is reduced to the string
749 we're trying to complete, then we already know there's no
750 other completion, so there's no point looking any further. */
751 if (matchsize
<= SCHARS (file
)
752 && !includeall
/* A future match may allow includeall to 0. */
753 /* If completion-ignore-case is non-nil, don't
754 short-circuit because we want to find the best
755 possible match *including* case differences. */
756 && (!completion_ignore_case
|| matchsize
== 0)
757 /* The return value depends on whether it's the sole match. */
765 /* This closes the directory. */
766 bestmatch
= unbind_to (count
, bestmatch
);
768 if (all_flag
|| NILP (bestmatch
))
770 /* Return t if the supplied string is an exact match (counting case);
771 it does not require any change to be made. */
772 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, file
)))
774 bestmatch
= Fsubstring (bestmatch
, make_number (0),
775 make_number (bestmatchsize
));
779 /* Compare exactly LEN chars of strings at S1 and S2,
780 ignoring case if appropriate.
781 Return -1 if strings match,
782 else number of chars that match at the beginning. */
785 scmp (const char *s1
, const char *s2
, ptrdiff_t len
)
787 register ptrdiff_t l
= len
;
789 if (completion_ignore_case
)
792 && (downcase ((unsigned char) *s1
++)
793 == downcase ((unsigned char) *s2
++)))
798 while (l
&& *s1
++ == *s2
++)
808 file_name_completion_stat (Lisp_Object dirname
, DIRENTRY
*dp
, struct stat
*st_addr
)
810 ptrdiff_t len
= NAMLEN (dp
);
811 ptrdiff_t pos
= SCHARS (dirname
);
815 SAFE_ALLOCA (fullname
, char *, len
+ pos
+ 2);
818 /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
819 but aren't required here. Avoid computing the following fields:
820 st_inode, st_size and st_nlink for directories, and the execute bits
821 in st_mode for non-directory files with non-standard extensions. */
823 unsigned short save_djstat_flags
= _djstat_flags
;
825 _djstat_flags
= _STAT_INODE
| _STAT_EXEC_MAGIC
| _STAT_DIRSIZE
;
828 memcpy (fullname
, SDATA (dirname
), pos
);
829 if (!IS_DIRECTORY_SEP (fullname
[pos
- 1]))
830 fullname
[pos
++] = DIRECTORY_SEP
;
832 memcpy (fullname
+ pos
, dp
->d_name
, len
);
833 fullname
[pos
+ len
] = 0;
835 /* We want to return success if a link points to a nonexistent file,
836 but we want to return the status for what the link points to,
837 in case it is a directory. */
838 value
= lstat (fullname
, st_addr
);
839 if (value
== 0 && S_ISLNK (st_addr
->st_mode
))
840 stat (fullname
, st_addr
);
842 _djstat_flags
= save_djstat_flags
;
849 stat_uname (struct stat
*st
)
854 struct passwd
*pw
= (struct passwd
*) getpwuid (st
->st_uid
);
864 stat_gname (struct stat
*st
)
869 struct group
*gr
= (struct group
*) getgrgid (st
->st_gid
);
878 DEFUN ("file-attributes", Ffile_attributes
, Sfile_attributes
, 1, 2, 0,
879 doc
: /* Return a list of attributes of file FILENAME.
880 Value is nil if specified file cannot be opened.
882 ID-FORMAT specifies the preferred format of attributes uid and gid (see
883 below) - valid values are 'string and 'integer. The latter is the
884 default, but we plan to change that, so you should specify a non-nil value
885 for ID-FORMAT if you use the returned uid or gid.
887 Elements of the attribute list are:
888 0. t for directory, string (name linked to) for symbolic link, or nil.
889 1. Number of links to file.
890 2. File uid as a string or a number. If a string value cannot be
891 looked up, a numeric value, either an integer or a float, is returned.
892 3. File gid, likewise.
893 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
894 same style as (current-time).
895 (See a note below about access time on FAT-based filesystems.)
896 5. Last modification time, likewise. This is the time of the last
897 change to the file's contents.
898 6. Last status change time, likewise. This is the time of last change
899 to the file's attributes: owner and group, access mode bits, etc.
901 This is a floating point number if the size is too large for an integer.
902 8. File modes, as a string of ten letters or dashes as in ls -l.
903 9. t if file's gid would change if file were deleted and recreated.
904 10. inode number. If it is larger than what an Emacs integer can hold,
905 this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
906 If even HIGH is too large for an Emacs integer, this is instead of the form
907 (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
908 and finally the low 16 bits.
909 11. Filesystem device number. If it is larger than what the Emacs
910 integer can hold, this is a cons cell, similar to the inode number.
912 On most filesystems, the combination of the inode and the device
913 number uniquely identifies the file.
915 On MS-Windows, performance depends on `w32-get-true-file-attributes',
918 On some FAT-based filesystems, only the date of last access is recorded,
919 so last access time will always be midnight of that day. */)
920 (Lisp_Object filename
, Lisp_Object id_format
)
922 Lisp_Object values
[12];
930 /* An array to hold the mode string generated by filemodestring,
931 including its terminating space and null byte. */
932 char modes
[sizeof "-rwxr-xr-x "];
936 char *uname
= NULL
, *gname
= NULL
;
938 filename
= Fexpand_file_name (filename
, Qnil
);
940 /* If the file name has special constructs in it,
941 call the corresponding file handler. */
942 handler
= Ffind_file_name_handler (filename
, Qfile_attributes
);
944 { /* Only pass the extra arg if it is used to help backward compatibility
945 with old file handlers which do not implement the new arg. --Stef */
946 if (NILP (id_format
))
947 return call2 (handler
, Qfile_attributes
, filename
);
949 return call3 (handler
, Qfile_attributes
, filename
, id_format
);
953 encoded
= ENCODE_FILE (filename
);
956 if (lstat (SSDATA (encoded
), &s
) < 0)
959 values
[0] = (S_ISLNK (s
.st_mode
) ? Ffile_symlink_p (filename
)
960 : S_ISDIR (s
.st_mode
) ? Qt
: Qnil
);
961 values
[1] = make_number (s
.st_nlink
);
963 if (!(NILP (id_format
) || EQ (id_format
, Qinteger
)))
966 uname
= stat_uname (&s
);
967 gname
= stat_gname (&s
);
971 values
[2] = DECODE_SYSTEM (build_string (uname
));
973 values
[2] = make_fixnum_or_float (s
.st_uid
);
975 values
[3] = DECODE_SYSTEM (build_string (gname
));
977 values
[3] = make_fixnum_or_float (s
.st_gid
);
979 values
[4] = make_lisp_time (get_stat_atime (&s
));
980 values
[5] = make_lisp_time (get_stat_mtime (&s
));
981 values
[6] = make_lisp_time (get_stat_ctime (&s
));
983 /* If the file size is a 4-byte type, assume that files of sizes in
984 the 2-4 GiB range wrap around to negative values, as this is a
985 common bug on older 32-bit platforms. */
986 if (sizeof (s
.st_size
) == 4)
987 values
[7] = make_fixnum_or_float (s
.st_size
& 0xffffffffu
);
989 values
[7] = make_fixnum_or_float (s
.st_size
);
991 filemodestring (&s
, modes
);
992 values
[8] = make_string (modes
, 10);
993 #ifdef BSD4_2 /* file gid will be dir gid */
994 dirname
= Ffile_name_directory (filename
);
995 if (! NILP (dirname
))
996 encoded
= ENCODE_FILE (dirname
);
997 if (! NILP (dirname
) && stat (SDATA (encoded
), &sdir
) == 0)
998 values
[9] = (sdir
.st_gid
!= s
.st_gid
) ? Qt
: Qnil
;
999 else /* if we can't tell, assume worst */
1001 #else /* file gid will be egid */
1002 values
[9] = (s
.st_gid
!= getegid ()) ? Qt
: Qnil
;
1003 #endif /* not BSD4_2 */
1004 values
[10] = INTEGER_TO_CONS (s
.st_ino
);
1005 values
[11] = INTEGER_TO_CONS (s
.st_dev
);
1007 return Flist (sizeof (values
) / sizeof (values
[0]), values
);
1010 DEFUN ("file-attributes-lessp", Ffile_attributes_lessp
, Sfile_attributes_lessp
, 2, 2, 0,
1011 doc
: /* Return t if first arg file attributes list is less than second.
1012 Comparison is in lexicographic order and case is significant. */)
1013 (Lisp_Object f1
, Lisp_Object f2
)
1015 return Fstring_lessp (Fcar (f1
), Fcar (f2
));
1019 DEFUN ("system-users", Fsystem_users
, Ssystem_users
, 0, 0, 0,
1020 doc
: /* Return a list of user names currently registered in the system.
1021 If we don't know how to determine that on this platform, just
1022 return a list with one element, taken from `user-real-login-name'. */)
1025 Lisp_Object users
= Qnil
;
1026 #if defined HAVE_GETPWENT && defined HAVE_ENDPWENT
1029 while ((pw
= getpwent ()))
1030 users
= Fcons (DECODE_SYSTEM (build_string (pw
->pw_name
)), users
);
1034 if (EQ (users
, Qnil
))
1035 /* At least current user is always known. */
1036 users
= Fcons (Vuser_real_login_name
, Qnil
);
1040 DEFUN ("system-groups", Fsystem_groups
, Ssystem_groups
, 0, 0, 0,
1041 doc
: /* Return a list of user group names currently registered in the system.
1042 The value may be nil if not supported on this platform. */)
1045 Lisp_Object groups
= Qnil
;
1046 #if defined HAVE_GETGRENT && defined HAVE_ENDGRENT
1049 while ((gr
= getgrent ()))
1050 groups
= Fcons (DECODE_SYSTEM (build_string (gr
->gr_name
)), groups
);
1058 syms_of_dired (void)
1060 DEFSYM (Qdirectory_files
, "directory-files");
1061 DEFSYM (Qdirectory_files_and_attributes
, "directory-files-and-attributes");
1062 DEFSYM (Qfile_name_completion
, "file-name-completion");
1063 DEFSYM (Qfile_name_all_completions
, "file-name-all-completions");
1064 DEFSYM (Qfile_attributes
, "file-attributes");
1065 DEFSYM (Qfile_attributes_lessp
, "file-attributes-lessp");
1066 DEFSYM (Qdefault_directory
, "default-directory");
1068 defsubr (&Sdirectory_files
);
1069 defsubr (&Sdirectory_files_and_attributes
);
1070 defsubr (&Sfile_name_completion
);
1071 defsubr (&Sfile_name_all_completions
);
1072 defsubr (&Sfile_attributes
);
1073 defsubr (&Sfile_attributes_lessp
);
1074 defsubr (&Ssystem_users
);
1075 defsubr (&Ssystem_groups
);
1077 DEFVAR_LISP ("completion-ignored-extensions", Vcompletion_ignored_extensions
,
1078 doc
: /* Completion ignores file names ending in any string in this list.
1079 It does not ignore them if all possible completions end in one of
1080 these strings or when displaying a list of completions.
1081 It ignores directory names if they match any string in this list which
1082 ends in a slash. */);
1083 Vcompletion_ignored_extensions
= Qnil
;